Elija elementos X de A[] y elementos Y de B[] que satisfagan la condición dada

Dadas dos arrays A[] y B[] y dos enteros X e Y , la tarea es elegir elementos X de A[] y elementos Y de B[] de modo que todos los elementos elegidos de A[] sean menores que todos los elementos elegidos de B[]
Ejemplos: 
 

Entrada: A[] = {1, 1, 1, 1, 1}, B[] = {3, 1}, X = 3, Y = 1 
Salida: Sí 
Elija {1, 1, 1} de A[] y {3} de B[].
Entrada: A[] = {5, 4}, B[] = {2, 3, 2, 2}, X = 2, Y = 1 
Salida: No 
 

Enfoque: Para satisfacer las condiciones dadas, los elementos X mínimos deben elegirse de A[] y los elementos Y máximos deben elegirse de B[] . Esto se puede hacer clasificando ambas arrays y luego eligiendo el X elemento más pequeño de A[] digamos ^xSmall y el Y elemento más grande de B[ ] digamos ^yLarge . 
Esto se debe a que si xSmall es más pequeño que yLarge , todos los elementos más pequeños definitivamente serán más pequeños que yLargey todos los elementos mayores que yLarge definitivamente serán mayores que xSmall .
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to that returns true if
// it possible to choose the elements
bool isPossible(int A[], int B[], int n,
                int m, int x, int y)
{
 
    // If elements can't be chosen
    if (x > n || y > m)
        return false;
 
    // Sort both the arrays
    sort(A, A + n);
    sort(B, B + m);
 
    // If xth smallest element of A[]
    // is smaller than the yth
    // greatest element of B[]
    if (A[x - 1] < B[m - y])
        return true;
    else
        return false;
}
 
// Driver code
int main()
{
    int A[] = { 1, 1, 1, 1, 1 };
    int B[] = { 2, 2 };
    int n = sizeof(A) / sizeof(int);
    int m = sizeof(B) / sizeof(int);
    int x = 3, y = 1;
 
    if (isPossible(A, B, n, m, x, y))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}

// Java implementation of the above approach
import java.util.*;
 
class GFG
{
     
    // Function to that returns true if
    // it possible to choose the elements
    static boolean isPossible(int A[], int B[], int n,
                              int m, int x, int y)
    {
     
        // If elements can't be chosen
        if (x > n || y > m)
            return false;
     
        // Sort both the arrays
        Arrays.sort(A);
        Arrays.sort(B);
     
        // If xth smallest element of A[]
        // is smaller than the yth
        // greatest element of B[]
        if (A[x - 1] < B[m - y])
            return true;
        else
            return false;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int A[] = { 1, 1, 1, 1, 1 };
        int B[] = { 2, 2 };
        int n = A.length;
        int m = B.length;;
        int x = 3, y = 1;
     
        if (isPossible(A, B, n, m, x, y))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the approach
 
# Function to that returns true if
# it possible to choose the elements
def isPossible(A, B, n, m, x, y) :
 
    # If elements can't be chosen
    if (x > n or y > m) :
        return False
 
    # Sort both the arrays
    A.sort()
    B.sort()
 
    # If xth smallest element of A[]
    # is smaller than the yth
    # greatest element of B[]
    if (A[x - 1] < B[m - y]) :
        return True
    else :
        return False
         
# Driver code
A = [ 1, 1, 1, 1, 1 ]
B = [ 2, 2 ]
n = len(A)
m = len(B)
x = 3
y = 1
 
if (isPossible(A, B, n, m, x, y)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by
# divyamohan123

// C# implementation of the above approach
using System;        
 
class GFG
{
     
    // Function to that returns true if
    // it possible to choose the elements
    static bool isPossible(int []A, int []B, int n,
                           int m, int x, int y)
    {
     
        // If elements can't be chosen
        if (x > n || y > m)
            return false;
     
        // Sort both the arrays
        Array.Sort(A);
        Array.Sort(B);
     
        // If xth smallest element of A[]
        // is smaller than the yth
        // greatest element of B[]
        if (A[x - 1] < B[m - y])
            return true;
        else
            return false;
    }
     
    // Driver code
    public static void Main (String[] args)
    {
        int []A = { 1, 1, 1, 1, 1 };
        int []B = { 2, 2 };
        int n = A.Length;
        int m = B.Length;;
        int x = 3, y = 1;
     
        if (isPossible(A, B, n, m, x, y))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed by Rajput-Ji

<script>
// javascript implementation of the above approach
 
 
// Function to that returns true if
// it possible to choose the elements
function isPossible(A , B , n, m , x , y)
{
 
    // If elements can't be chosen
    if (x > n || y > m)
        return false;
 
    // Sort both the arrays
    A.sort();
    B.sort();
 
    // If xth smallest element of A
    // is smaller than the yth
    // greatest element of B
    if (A[x - 1] < B[m - y])
        return true;
    else
        return false;
}
 
// Driver code
 
var A = [ 1, 1, 1, 1, 1 ];
var B = [ 2, 2 ];
var n = A.length;
var m = B.length;;
var x = 3, y = 1;
 
if (isPossible(A, B, n, m, x, y))
    document.write("Yes");
else
    document.write("No");
 
 
// This code is contributed by 29AjayKumar
 
</script>

Yes

Complejidad de tiempo: O(N*log(N))

Espacio Auxiliar: O(1)