Related Articles

# Check if X and Y elements can be selected from two arrays respectively such that the maximum in X is less than the minimum in Y

• Difficulty Level : Expert
• Last Updated : 16 Apr, 2021

Given two arrays arr1[] and arr2[] consisting of N and M integers respectively, and two integers X and Y, the task is to check if it is possible to choose X elements from arr1[] and Y elements from arr2[] such that the largest among these X elements is less than the minimum element among these Y elements. If it is possible, then print “Yes”. Otherwise, print “No”.

Examples:

Input: arr1[] = {1, 1, 1, 1, 1}, arr2[] = {2, 2}, X = 3, Y = 1
Output: Yes
Explanation: Every possible selection satisfies the above condition as every element of arr1[] is less than minimum element in the arr2[].

Input: arr1[] = {1, 2, 3}, arr2[] = {3, 4, 5}, X = 2, Y = 1
Output: Yes
Explanation: One possible selection is take elements at indices 0 and 1 from arr1[] and indices 0 from arr2[], i.e {1, 2} and {3}.

Approach: The idea is to sort both the arrays in ascending order and then, choose the first X elements from arr1[] and the last Y elements from arr2[]. Follow the steps below to solve the problem:

• Sort both the arrays in ascending order.
• If X is greater than N or Y is greater than M, then print “No” as it is not possible to choose any such combinations.
• Otherwise, if the value of arr1[X – 1] is less than arr2[M – Y], then print “Yes”.
• Otherwise, print “No”. If none of the above conditions are satisfied.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to check if it is possible to``// choose X and Y elements from a[] and``// b[] such that maximum element among``// X element is less than minimum``// element among Y elements``string check(``int` `a[], ``int` `b[], ``int` `Na,``             ``int` `Nb, ``int` `k, ``int` `m)``{``    ``// Check if there are atleast X``    ``// elements in arr1[] and atleast``    ``// Y elements in arr2[]``    ``if` `(Na < k || Nb < m)``        ``return` `"No"``;` `    ``// Sort arrays in ascending order``    ``sort(a, a + Na);``    ``sort(b, b + Nb);` `    ``// Check if (X - 1)-th element in arr1[]``    ``// is less than from M-Yth element``    ``// in arr2[]``    ``if` `(a[k - 1] < b[Nb - m]) {``        ``return` `"Yes"``;``    ``}` `    ``// Return false``    ``return` `"No"``;``}` `// Driver Code``int` `main()``{``    ``int` `arr1[] = { 1, 2, 3 };``    ``int` `arr2[] = { 3, 4, 5 };``    ``int` `N = ``sizeof``(arr1) / ``sizeof``(arr1);``    ``int` `M = ``sizeof``(arr2) / ``sizeof``(arr2);` `    ``int` `X = 2, Y = 1;` `    ``// Function Call``    ``cout << check(arr1, arr2, N, M, X, Y);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to check if it is possible to``// choose X and Y elements from a[] and``// b[] such that maximum element among``// X element is less than minimum``// element among Y elements``static` `String check(``int``[] a, ``int``[] b,``                    ``int` `Na, ``int` `Nb,``                    ``int` `k, ``int` `m)``{``    ` `    ``// Check if there are atleast X``    ``// elements in arr1[] and atleast``    ``// Y elements in arr2[]``    ``if` `(Na < k || Nb < m)``        ``return` `"No"``;` `    ``// Sort arrays in ascending order``    ``Arrays.sort(a);``    ``Arrays.sort(b);` `    ``// Check if (X - 1)-th element in arr1[]``    ``// is less than from M-Yth element``    ``// in arr2[]``    ``if` `(a[k - ``1``] < b[Nb - m])``    ``{``        ``return` `"Yes"``;``    ``}` `    ``// Return false``    ``return` `"No"``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr1 = { ``1``, ``2``, ``3` `};``    ``int``[] arr2 = { ``3``, ``4``, ``5` `};``    ``int` `N = arr1.length;``    ``int` `M = arr2.length;` `    ``int` `X = ``2``, Y = ``1``;` `    ``// Function Call``    ``System.out.println(check(``        ``arr1, arr2, N, M, X, Y));``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python3 program for the above approach` `# Function to check if it is possible to``# choose X and Y elements from a[] and``# b[] such that maximum element among``# X element is less than minimum``# element among Y elements``def` `check( a, b, Na, Nb, k, m):``  ` `  ``# Check if there are atleast X``  ``# elements in arr1[] and atleast``  ``# Y elements in arr2[]``  ``if` `(Na < k ``or` `Nb < m):``    ``return` `"No"` `  ``# Sort arrays in ascending order``  ``a.sort()``  ``a.sort()` `  ``# Check if (X - 1)-th element in arr1[]``  ``# is less than from M-Yth element``  ``# in arr2[]``  ``if` `(a[k ``-` `1``] < b[Nb ``-` `m]):``    ``return` `"Yes"` `  ``# Return false``  ``return` `"No"` `# Driver Code``arr1 ``=` `[ ``1``, ``2``, ``3` `]``arr2 ``=` `[ ``3``, ``4``, ``5` `]``N ``=` `len``(arr1)``M ``=` `len``(arr2)``X ``=` `2``Y ``=` `1` `# Function Call``print``(check(arr1, arr2, N, M, X, Y))` `# This code is contributed by rohitsongh07052.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to check if it is possible to``// choose X and Y elements from a[] and``// b[] such that maximum element among``// X element is less than minimum``// element among Y elements``static` `string` `check(``int``[] a, ``int``[] b,``                    ``int` `Na, ``int` `Nb,``                    ``int` `k, ``int` `m)``{``    ` `    ``// Check if there are atleast X``    ``// elements in arr1[] and atleast``    ``// Y elements in arr2[]``    ``if` `(Na < k || Nb < m)``        ``return` `"No"``;` `    ``// Sort arrays in ascending order``    ``Array.Sort(a);``    ``Array.Sort(b);` `    ``// Check if (X - 1)-th element in arr1[]``    ``// is less than from M-Yth element``    ``// in arr2[]``    ``if` `(a[k - 1] < b[Nb - m])``    ``{``        ``return` `"Yes"``;``    ``}` `    ``// Return false``    ``return` `"No"``;``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int``[] arr1 = { 1, 2, 3 };``    ``int``[] arr2 = { 3, 4, 5 };``    ``int` `N = arr1.Length;``    ``int` `M = arr2.Length;` `    ``int` `X = 2, Y = 1;` `    ``// Function Call``    ``Console.WriteLine(check(``        ``arr1, arr2, N, M, X, Y));``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O(N*log N)
Auxiliary Space O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up