Given two arrays arr1[] and arr2[] consisting of N positive integers and an even integer K, the task is to check if the sum of the same indexed elements in the two arrays lie in the range [K/2, K] after rearranging the given arrays or not. If it is possible to obtain such an arrangement, then print “Yes”. Otherwise, print “No”.
Examples:
Input: arr1[] = {1, 4, 3, 5}, arr2[] = {0, 2, 1, 1}, K = 6
Output: Yes
Explanation: Rearranging arr1[] to {1, 4, 3, 5} and arr2[] to {2, 0, 1, 1} ensures that the sum of same indexed elements lie in the range [3, 6]. Therefore, print “Yes”.Input: arr1[] = {2, 0}, arr2[] = {3, 4}, K = 2
Output: No
Explanation: No such arrangement is possible
Naive Approach: The simplest approach to generate all possible permutations of the given arrays and check if any possible arrangements satisfy the given conditions or not. If found to be true, then print “Yes”. Otherwise, print “No”.
Time Complexity: O((N!)2)
Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach, follow the steps below to solve the problem:
- Sort the array arr1[] in increasing order.
- Sort the array arr2[] in decreasing order.
- Iterate over the array and check if the sum of elements arr1[i] and arr2[i] for all possible values of i in the range[0, N – 1] lies in the range [K/2, K] or not. If found to be true, then print “Yes”. Otherwise, print “No”.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check if there exists any // arrangements of the arrays such that // sum of element lie in the range [K/2, K] void checkArrangement( int A1[], int A2[],
int n, int k)
{ // Sort the array arr1[] in
// increasing order
sort(A1, A1 + n);
// Sort the array arr2[] in
// decreasing order
sort(A2, A2 + n, greater< int >());
int flag = 0;
// Traverse the array
for ( int i = 0; i < n; i++) {
// If condition is not satisfied
// break the loop
if ((A1[i] + A2[i] > k)
|| (A1[i] + A2[i] < k / 2)) {
flag = 1;
break ;
}
}
// Print the result
if (flag == 1)
cout << "No" ;
else
cout << "Yes" ;
} // Driver Code int main()
{ int arr1[] = { 1, 3, 4, 5 };
int arr2[] = { 2, 0, 1, 1 };
int K = 6;
int N = sizeof (arr1)
/ sizeof (arr1[0]);
checkArrangement(arr1, arr2, N, K);
return 0;
} |
// Java program for the above approach import java.io.*;
import java.util.*;
class GFG{
// Function to check if there exists any // arrangements of the arrays such that // sum of element lie in the range [K/2, K] static void checkArrangement(Integer[] A1,
Integer[] A2,
int n, int k)
{ // Sort the array arr1[] in
// increasing order
Arrays.sort(A1);
// Sort the array arr2[] in
// decreasing order
Arrays.sort(A2, Collections.reverseOrder());
int flag = 0 ;
// Traverse the array
for ( int i = 0 ; i < n; i++)
{
// If condition is not satisfied
// break the loop
if ((A1[i] + A2[i] > k) ||
(A1[i] + A2[i] < k / 2 ))
{
flag = 1 ;
break ;
}
}
// Print the result
if (flag == 1 )
System.out.println( "No" );
else
System.out.println( "Yes" );
} // Driver Code public static void main(String[] args)
{ Integer[] arr1 = { 1 , 3 , 4 , 5 };
Integer[] arr2 = { 2 , 0 , 1 , 1 };
int K = 6 ;
int N = arr1.length;
checkArrangement(arr1, arr2, N, K);
} } // This code is contributed by akhilsaini |
# Python3 program for the above approach # Function to check if there exists any # arrangements of the arrays such that # sum of element lie in the range [K/2, K] def checkArrangement(A1, A2, n, k):
# Sort the array arr1[] in
# increasing order
A1 = sorted (A1)
# Sort the array arr2[] in
# decreasing order
A2 = sorted (A2)
A2 = A2[:: - 1 ]
flag = 0
# Traverse the array
for i in range (n):
# If condition is not satisfied
# break the loop
if ((A1[i] + A2[i] > k) or
(A1[i] + A2[i] < k / / 2 )):
flag = 1
break
# Print the result
if (flag = = 1 ):
print ( "No" )
else :
print ( "Yes" )
# Driver Code if __name__ = = '__main__' :
arr1 = [ 1 , 3 , 4 , 5 ]
arr2 = [ 2 , 0 , 1 , 1 ]
K = 6
N = len (arr1)
checkArrangement(arr1, arr2, N, K)
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
using System.Collections;
class GFG{
// Function to check if there exists any // arrangements of the arrays such that // sum of element lie in the range [K/2, K] static void checkArrangement( int [] A1, int [] A2,
int n, int k)
{ // Sort the array arr1[] in
// increasing order
Array.Sort(A1);
// Sort the array arr2[] in
// decreasing order
Array.Sort(A2);
Array.Reverse(A2);
int flag = 0;
// Traverse the array
for ( int i = 0; i < n; i++)
{
// If condition is not satisfied
// break the loop
if ((A1[i] + A2[i] > k) ||
(A1[i] + A2[i] < k / 2))
{
flag = 1;
break ;
}
}
// Print the result
if (flag == 1)
Console.WriteLine( "No" );
else
Console.WriteLine( "Yes" );
} // Driver Code public static void Main()
{ int [] arr1 = { 1, 3, 4, 5 };
int [] arr2 = { 2, 0, 1, 1 };
int K = 6;
int N = arr1.Length;
checkArrangement(arr1, arr2, N, K);
} } // This code is contributed by akhilsaini |
<script> // JavaScript program for // the above approach // Function to check if there exists any // arrangements of the arrays such that // sum of element lie in the range [K/2, K] function checkArrangement( A1, A2, n, k)
{ // Sort the array arr1[] in
// increasing order
A1.sort();
// Sort the array arr2[] in
// decreasing order
A2.sort();
A2.reverse();
let flag = 0;
// Traverse the array
for (let i = 0; i < n; i++)
{
// If condition is not satisfied
// break the loop
if ((A1[i] + A2[i] > k) ||
(A1[i] + A2[i] < k / 2))
{
flag = 1;
break ;
}
}
// Print the result
if (flag == 1)
document.write( "No" );
else
document.write( "Yes" );
} // Driver Code let arr1 = [ 1, 3, 4, 5 ];
let arr2 = [ 2, 0, 1, 1 ];
let K = 6;
let N = arr1.length;
checkArrangement(arr1, arr2, N, K);
</script> |
Yes
Time Complexity: O(N*log N)
Auxiliary Space: O(1)