# HackerRank Permuting Two Arrays problem solution

In this HackerRank Permuting Two Arrays problem solution there are two n element arrays of integers A and B. we need to permute them into some A' and B' such that the relation A'[i] + B'[i] >= k holds for all I where 0 <= I < n. and there are q queries consisting of A, B, and k. for each query return YES if some permutation A'.B' satisfying the relation exists. otherwise, return NO.

## Problem solution in Python.

```#!/usr/bin/env python3

def rl(T=str):
return list(map(T,input().split()))

T, = rl(int)
for _ in range((T)):
N,K = rl(int)
A = rl(int)
B = rl(int)
A.sort()
B.sort(reverse=True)
bad = len([a+b for a,b in zip(A,B) if a+b<K ])>0

```

{"mode":"full","isActive":false}

## Problem solution in Java.

```import java.util.*;

public class Solution {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
int k = in.nextInt();
int[] a = new int[n];
int[] b = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
for (int i = 0; i < n; i++) {
b[i] = in.nextInt();
}
Arrays.sort(a);
Arrays.sort(b);
solve(a, b, k);
}
}

private static void solve(int[] a, int[] b, int k) {
for(int i=0, j=a.length-1; i<a.length; i++, j--){
if(a[i]+b[j] < k) {
System.out.println("NO");
return;
}
}
System.out.println("YES");
}
}```

{"mode":"full","isActive":false}

## Problem solution in C++.

```#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
using namespace std;

int compare1(const void * a, const void * b)
{
return ( *(int*)b - *(int*)a );
}

int compare2(const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}

int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */

long t;
long n, k;
long a[1000], b[1000];

cin>>t;

for(int i=0; i < t; i++)
{
cin>>n>>k;

for(int j=0; j<n; j++)
{
cin>>a[j];
}

qsort (a, n, sizeof(long), compare1);

for(int j=0; j<n; j++)
cin>>b[j];

qsort (b, n, sizeof(long), compare2);

bool flag=true;

for(int i=0; i<n; i++)
if(a[i]+b[i]<k)
{
flag = false;
break;
}

if(flag)
cout<<"YES\n";
else
cout<<"NO\n";
}

return 0;
}
```

{"mode":"full","isActive":false}

## Problem solution in C.

```#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}

int main() {

/* Enter your code here. Read input from STDIN. Print output to STDOUT */
int T;
int dummy;
dummy=scanf("%d",&T);

int N;
int K;

int i;
for(i=0; i<T; i++)
{
dummy=scanf("%d",&N);
int A[N];
int B[N];

dummy=scanf("%d",&K);

int j;
for(j=0; j<N; j++)
{
dummy=scanf("%d",A+j);
}
for(j=0; j<N; j++)
{
dummy=scanf("%d",B+j);
}

/* input fetched */

//sorting arrays...
qsort (A, N, sizeof(int), compare);
qsort (B, N, sizeof(int), compare);

int k;
int isPossible = 1;

for (k=0; k<N; k++)
{
if ((isPossible == 1) && (A[k]+B[N-1-k] < K))
isPossible = 0;
}

if (isPossible == 1)
printf("YES\n");
else
printf("NO\n");

}
return 0;
}
```

{"mode":"full","isActive":false}