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

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 <bits/stdc++.h>
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[0]);
    int M = sizeof(arr2) / sizeof(arr2[0]);

    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

<script>
// javascript 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
    function 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 || Nb < m)
            return "No";

        // Sort arrays in ascending order
        a.sort();
        b.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
        var arr1 = [ 1, 2, 3 ];
        var arr2 = [ 3, 4, 5 ];
        var N = arr1.length;
        var M = arr2.length;

        var X = 2, Y = 1;

        // Function Call
        document.write(check(arr1, arr2, N, M, X, Y));

// This code is contributed by todaysgaurav
</script>

Output

Yes

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;

// Function to check if it is possible to
// choose X and Y elements from a[] and b[]
// such that the maximum element among X element
// is less than minimum element among Y elements
bool check(int a[], int b[], int n, int m, int x, int y)
{
    // Sort both arrays in ascending order
    sort(a, a + n);
    sort(b, b + m);

    // For each element in arr1[],
    // find the largest element in arr2[]
    // that is smaller than that element
    for (int i = 0; i < n; i++) {
        int j = lower_bound(b, b + m, a[i]) - b;

        // If binary search returns a negative
        // number, then the element is not found
        // in arr2[] and we need to convert the
        // index to its corresponding positive
        // value using the formula: -(index + 1)
        if (j < 0) {
            j = -(j + 1);
        }

        // 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
        if (j <= m - y && a[i + x - 1] < b[j + y - 1]) {
            return true;
        }
    }

    // If none of the elements in arr1[]
    // satisfy the above condition, then
    // it is not possible to choose any
    // such combinations
    return false;
}

// Driver Code
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;

    // Function Call
    if (check(arr1, arr2, n, m, x, y)) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }

    return 0;
}

Java

// Java program for the above approach
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 boolean check(int[] a, int[] b, int n, int m,
                         int x, int y)
    {

        // Sort both arrays in ascending order
        Arrays.sort(a);
        Arrays.sort(b);

        // For each element in arr1[],
        // find the largest element in arr2[]
        // that is smaller than that element
        for (int i = 0; i < n; i++) {
            int j = Arrays.binarySearch(b, a[i]);

            // If binary search returns a negative
            // number, then the element is not found
            // in arr2[] and we need to convert the
            // index to its corresponding positive
            // value using the formula: -(index + 1)
            if (j < 0) {
                j = -(j + 1);
            }

            // 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
            if (j <= m - y && a[i + x - 1] < b[j + y - 1]) {
                return true;
            }
        }

        // If none of the elements in arr1[]
        // satisfy the above condition, then
        // it is not possible to choose any
        // such combinations
        return false;
    }

    // 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
        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):
    # Sort both arrays in ascending order
    a.sort()
    b.sort()

    # For each element in a[],
    # find the largest element in b[]
    # that is smaller than that element
    for i in range(n):
        j = bisect.bisect_left(b, a[i])

        # If binary search returns a negative
        # number, then the element is not found
        # in b[] and we need to convert the
        # index to its corresponding positive
        # value using the formula: -(index + 1)
        if j < 0:
            j = -(j + 1)

        # If the index of the largest element
        # in b[] is greater than or equal
        # to M-Y, then it is possible to choose
        # X elements from a[] and Y elements
        # from b[] such that the maximum
        # element among X is less than the
        # minimum element among Y
        if j <= m - y and a[i + x - 1] < b[j + y - 1]:
            return True

    # If none of the elements in a[]
    # satisfy the above condition, then
    # it is not possible to choose any
    # such combinations
    return False


# Driver Code
arr1 = [1, 2, 3]
arr2 = [3, 4, 5]
n = len(arr1)
m = len(arr2)
x = 2
y = 1

# Function Call
if check(arr1, arr2, n, m, x, y):
    print("Yes")
else:
    print("No")

C#

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 bool check(int[] a, int[] b, int n, int m, int x,
                      int y)
    {
        // Sort both arrays in ascending order
        Array.Sort(a);
        Array.Sort(b);

        // For each element in arr1[],
        // find the largest element in arr2[]
        // that is smaller than that element
        for (int i = 0; i < n; i++) {
            int j = Array.BinarySearch(b, a[i]);

            // If binary search returns a negative
            // number, then the element is not found
            // in arr2[] and we need to convert the
            // index to its corresponding positive
            // value using the formula: -(index + 1)
            if (j < 0) {
                j = -(j + 1);
            }

            // 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
            if (j <= m - y && a[i + x - 1] < b[j + y - 1]) {
                return true;
            }
        }

        // If none of the elements in arr1[]
        // satisfy the above condition, then
        // it is not possible to choose any
        // such combinations
        return false;
    }

    // Driver Code
    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;

        // Function Call
        if (check(arr1, arr2, n, m, x, y)) {
            Console.WriteLine("Yes");
        }
        else {
            Console.WriteLine("No");
        }
    }
}

Javascript

// Function to check if it is possible to
// choose X and Y elements from a[] and b[]
// such that the maximum element among X element
// is less than minimum element among Y elements
function check(a, b, x, y) {
    // Sort both arrays in ascending order
    a.sort((x, y) => x - y);
    b.sort((x, y) => x - y);

    // For each element in a[],
    // find the largest element in b[]
    // that is smaller than that element
    for (let i = 0; i < a.length; i++) {
        let j = b.findIndex(el => el >= a[i]);

        // If the element is not found in b[],
        // findIndex returns -1, so we handle it here
        if (j < 0) {
            j = b.length + j;
        }

        // If the index of the largest element
        // in b[] is less than or equal to (M - Y),
        // then it is possible to choose
        // X elements from a[] and Y elements
        // from b[] such that the maximum
        // element among X is less than the
        // minimum element among Y
        if (j <= b.length - y && a[i + x - 1] < b[j + y - 1]) {
            return true;
        }
    }

    // If none of the elements in a[]
    // satisfy the above condition, then
    // it is not possible to choose any
    // such combinations
    return false;
}

// Driver Code
let arr1 = [1, 2, 3];
let arr2 = [3, 4, 5];
let x = 2, y = 1;

// Function Call
if (check(arr1, arr2, x, y)) {
    console.log("Yes");
} else {
    console.log("No");
}

Output

Yes

“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).