Permutation Two Array Hackerrank Solution

 There are two -element arrays of integers,  and . Permute them into some  and  such that the relation  holds for all  where .

There will be  queries consisting of , , and . For each query, return YES if some permutation ,  satisfying the relation exists. Otherwise, return NO.

Example

A valid  is  and :  and . Return YES.

Function Description

Complete the twoArrays function in the editor below. It should return a string, either YES or NO.

twoArrays has the following parameter(s):

• int k: an integer
• int A[n]: an array of integers
• int B[n]: an array of integers

Returns
- string: either YES or NO

Input Format

The first line contains an integer , the number of queries.

The next  sets of  lines are as follows:

• The first line contains two space-separated integers  and , the size of both arrays  and , and the relation variable.
• The second line contains  space-separated integers .
• The third line contains  space-separated integers .

Constraints

Sample Input

STDIN       Function
-----       --------
2           q = 2
3 10        A[] and B[] size n = 3, k = 10
2 1 3       A = [2, 1, 3]
7 8 9       B = [7, 8, 9]
4 5         A[] and B[] size n = 4, k = 5
1 2 2 1     A = [1, 2, 2, 1]
3 3 3 4     B = [3, 3, 3, 4]

Sample Output

YES
NO

Explanation

There are two queries:

1. Permute these into  and  so that the following statements are true:

2. , , and . To permute  and  into a valid  and , there must be at least three numbers in  that are greater than .

Solutions ;-

import java.io.*;

import java.math.*;

import java.security.*;

import java.text.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.function.*;

import java.util.regex.*;

import java.util.stream.*;

import static java.util.stream.Collectors.joining;

import static java.util.stream.Collectors.toList;

class Result {

    /*

     * Complete the 'twoArrays' function below.

     *

     * The function is expected to return a STRING.

     * The function accepts following parameters:

     *  1. INTEGER k

     *  2. INTEGER_ARRAY A

     *  3. INTEGER_ARRAY B

     */

    public static String twoArrays(int k, List<Integer> A, List<Integer> B) {

    // Write your code here

 int n=A.size();

    int m=B.size();

    Collections.sort(A);

    Collections.sort(B,Collections.reverseOrder());

   

   

   

    for(int i=0;i<n;i++)

    {

        if(A.get(i)+B.get(i) < k)

        {

            return "NO";

        }

    }

return "YES";

    }

}

public class Solution {

    public static void main(String[] args) throws IOException {

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int q = Integer.parseInt(bufferedReader.readLine().trim());

        IntStream.range(0, q).forEach(qItr -> {

            try {

                String[] firstMultipleInput = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");

                int n = Integer.parseInt(firstMultipleInput[0]);

                int k = Integer.parseInt(firstMultipleInput[1]);

                List<Integer> A = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))

                    .map(Integer::parseInt)

                    .collect(toList());

                List<Integer> B = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))

                    .map(Integer::parseInt)

                    .collect(toList());

                String result = Result.twoArrays(k, A, B);

                bufferedWriter.write(result);

                bufferedWriter.newLine();

            } catch (IOException ex) {

                throw new RuntimeException(ex);

            }

        });

        bufferedReader.close();

        bufferedWriter.close();

    }

}