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
Last Updated :
25 Oct, 2023
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++
#include <bits/stdc++.h>
using namespace std;
string check( int a[], int b[], int Na,
int Nb, int k, int m)
{
if (Na < k || Nb < m)
return "No" ;
sort(a, a + Na);
sort(b, b + Nb);
if (a[k - 1] < b[Nb - m]) {
return "Yes" ;
}
return "No" ;
}
int main()
{
int arr1[] = { 1, 2, 3 };
int arr2[] = { 3, 4, 5 };
int N = sizeof (arr1) / sizeof (arr1[0]);
int M = sizeof (arr2) / sizeof (arr2[0]);
int X = 2, Y = 1;
cout << check(arr1, arr2, N, M, X, Y);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static String check( int [] a, int [] b,
int Na, int Nb,
int k, int m)
{
if (Na < k || Nb < m)
return "No" ;
Arrays.sort(a);
Arrays.sort(b);
if (a[k - 1 ] < b[Nb - m])
{
return "Yes" ;
}
return "No" ;
}
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 ;
System.out.println(check(
arr1, arr2, N, M, X, Y));
}
}
|
Python3
def check( a, b, Na, Nb, k, m):
if (Na < k or Nb < m):
return "No"
a.sort()
a.sort()
if (a[k - 1 ] < b[Nb - m]):
return "Yes"
return "No"
arr1 = [ 1 , 2 , 3 ]
arr2 = [ 3 , 4 , 5 ]
N = len (arr1)
M = len (arr2)
X = 2
Y = 1
print (check(arr1, arr2, N, M, X, Y))
|
C#
using System;
class GFG{
static string check( int [] a, int [] b,
int Na, int Nb,
int k, int m)
{
if (Na < k || Nb < m)
return "No" ;
Array.Sort(a);
Array.Sort(b);
if (a[k - 1] < b[Nb - m])
{
return "Yes" ;
}
return "No" ;
}
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;
Console.WriteLine(check(
arr1, arr2, N, M, X, Y));
}
}
|
Javascript
<script>
function check(a, b , Na , Nb , k , m)
{
if (Na < k || Nb < m)
return "No" ;
a.sort();
b.sort();
if (a[k - 1] < b[Nb - m]) {
return "Yes" ;
}
return "No" ;
}
var arr1 = [ 1, 2, 3 ];
var arr2 = [ 3, 4, 5 ];
var N = arr1.length;
var M = arr2.length;
var X = 2, Y = 1;
document.write(check(arr1, arr2, N, M, X, Y));
</script>
|
Time Complexity: O(N*log N+M*log M)
Auxiliary Space O(1)
New Approach: The idea to solve this problem is to use the Binary Search algorithm. Follow the steps below to solve the problem:
- Sort both arrays in ascending order.
- For each element in arr1[], find the largest element in arr2[] that is smaller than that element using binary search.
- If the index of the largest element in arr2[] is greater than or equal to M – Y, then it is possible to choose X elements from arr1[] and Y elements from arr2[] such that the maximum element among X is less than the minimum element among Y.
- Otherwise, continue to the next element in arr1[].
- If none of the elements in arr1[] satisfy the above condition, then it is not possible to choose any such combinations.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <algorithm>
using namespace std;
bool check( int a[], int b[], int n, int m, int x, int y)
{
sort(a, a + n);
sort(b, b + m);
for ( int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
if (j < 0) {
j = -(j + 1);
}
if (j <= m - y && a[i + x - 1] < b[j + y - 1]) {
return true ;
}
}
return false ;
}
int main()
{
int arr1[] = {1, 2, 3};
int arr2[] = {3, 4, 5};
int n = sizeof (arr1) / sizeof (arr1[0]);
int m = sizeof (arr2) / sizeof (arr2[0]);
int x = 2, y = 1;
if (check(arr1, arr2, n, m, x, y)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
|
Java
import java.util.*;
class GFG {
static boolean check( int [] a, int [] b, int n, int m,
int x, int y)
{
Arrays.sort(a);
Arrays.sort(b);
for ( int i = 0 ; i < n; i++) {
int j = Arrays.binarySearch(b, a[i]);
if (j < 0 ) {
j = -(j + 1 );
}
if (j <= m - y && a[i + x - 1 ] < b[j + y - 1 ]) {
return true ;
}
}
return false ;
}
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 ;
if (check(arr1, arr2, n, m, x, y)) {
System.out.println( "Yes" );
}
else {
System.out.println( "No" );
}
}
}
|
Python
import bisect
def check(a, b, n, m, x, y):
a.sort()
b.sort()
for i in range (n):
j = bisect.bisect_left(b, a[i])
if j < 0 :
j = - (j + 1 )
if j < = m - y and a[i + x - 1 ] < b[j + y - 1 ]:
return True
return False
arr1 = [ 1 , 2 , 3 ]
arr2 = [ 3 , 4 , 5 ]
n = len (arr1)
m = len (arr2)
x = 2
y = 1
if check(arr1, arr2, n, m, x, y):
print ( "Yes" )
else :
print ( "No" )
|
C#
using System;
class GFG {
static bool check( int [] a, int [] b, int n, int m, int x,
int y)
{
Array.Sort(a);
Array.Sort(b);
for ( int i = 0; i < n; i++) {
int j = Array.BinarySearch(b, a[i]);
if (j < 0) {
j = -(j + 1);
}
if (j <= m - y && a[i + x - 1] < b[j + y - 1]) {
return true ;
}
}
return false ;
}
public static 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;
if (check(arr1, arr2, n, m, x, y)) {
Console.WriteLine( "Yes" );
}
else {
Console.WriteLine( "No" );
}
}
}
|
Javascript
function check(a, b, x, y) {
a.sort((x, y) => x - y);
b.sort((x, y) => x - y);
for (let i = 0; i < a.length; i++) {
let j = b.findIndex(el => el >= a[i]);
if (j < 0) {
j = b.length + j;
}
if (j <= b.length - y && a[i + x - 1] < b[j + y - 1]) {
return true ;
}
}
return false ;
}
let arr1 = [1, 2, 3];
let arr2 = [3, 4, 5];
let x = 2, y = 1;
if (check(arr1, arr2, x, y)) {
console.log( "Yes" );
} else {
console.log( "No" );
}
|
“Note: In this approach, the idea is to use the binary search algorithm to find the largest element in arr2[] that is smaller than each element in arr1[]. We then check if the index of this element is greater than or equal to M-Y and if the maximum element among X is less than the minimum element among Y.“
Time Complexity:
The time complexity of the given solution is O(n log m) where n and m are the lengths of the two arrays. This is because the code involves sorting both the arrays and then performing a binary search on array b for each element of array a, which takes O(log m) time for each iteration. Therefore, the overall time complexity is O(n log m).
Auxiliary Space:
The given solution requires O(1) auxiliary space as it only uses a few variables to store the array lengths, indices, and loop variables. The space required for sorting the arrays is also O(1) as the sorting is performed in place. Therefore, the overall space complexity is O(1).
Share your thoughts in the comments
Please Login to comment...