Given an array A[] of integers whose length is N, (where N is even) the task is to check if A[] can be grouped into N/2 pairs having equal sum.
Examples:
Input: N = 6, A[] = {4, 5, 3, 1, 2, 6}
Output: True
Explanation: Consider the pairs {1, 6}, {5, 2} and {4, 3}.
All 3 of them are having sum = 7.
Hence, the given array can be divided into N/2 i.e. 3 pairs having equal sum.Input : N = 8, A[] = {1, 1, 1, 1, 1, 1, 2, 3}
Output: False
Approach: The idea to solve the problem is by using two pointer approach following the below observation.
If there exist N/2 pairs having equal sum, then the sum of each pair must be equal to min + max, where min is the minimum element of the array and max is the maximum element of the array.
Follow the steps mentioned below to solve the problem based on the above observation:
- Sort the given array.
- Initialize a variable (say target) equal to the sum of the first and the last element of the sorted array.
- Initialize two pointers pointing at the first and the last element.
- Increment and decrement the pointers simultaneously and check if the sum of elements at the pointers is equal to target.
- If so, continue iteration.
- Else return false.
- After the iteration is complete return true.
Below is the implementation of the above approach.
// C++ code for the above approach. #include <bits/stdc++.h> using namespace std;
// Function to check if it is possible // to divide the given array into // N/2 pairs having equal sum bool isPossible( int N, int A[])
{ // Sorting the given array
sort(A, A + N);
// Initializing target as the sum of
// minimum and maximum element
int target = A[0] + A[N - 1];
// Initializing two pointers
int i = 0, j = N - 1;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (A[i] + A[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
} // Driver Code int main()
{ int N = 6;
int A[] = { 4, 5, 3, 1, 2, 6 };
// Function call
bool answer = isPossible(N, A);
if (answer)
cout << "True" ;
else
cout << "False" ;
return 0;
} |
// JAVA code for the above approach. import java.util.*;
class GFG
{ // Function to check if it is possible
// to divide the given array into
// N/2 pairs having equal sum
public static boolean isPossible( int N, int A[])
{
// Sorting the given array
Arrays.sort(A);
// Initializing target as the sum of
// minimum and maximum element
int target = A[ 0 ] + A[N - 1 ];
// Initializing two pointers
int i = 0 , j = N - 1 ;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (A[i] + A[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
}
// Driver Code
public static void main(String[] args)
{
int N = 6 ;
int A[] = { 4 , 5 , 3 , 1 , 2 , 6 };
// Function call
boolean answer = isPossible(N, A);
if (answer)
System.out.print( "True" );
else
System.out.print( "False" );
}
} // This code is contributed by Taranpreet |
# Python3 code for the above approach. # Function to check if it is possible # to divide the given array into # N/2 pairs having equal sum def isPossible(N, A):
# Sorting the given array
A.sort()
# Initializing target as the sum of
# minimum and maximum element
target = A[ 0 ] + A[N - 1 ]
# Initializing two pointers
i = 0
j = N - 1
while (i < j):
# If sum of elements at i and j
# is equal to target then,
# increment and decrement i and j
# respectively
if (A[i] + A[j] = = target):
i + = 1
j - = 1
# Else return false
else :
return False
# After whole array is traversed,
# which means N/2 pairs have sum
# equal to target, hence return true
return True
# Driver Code N = 6
A = [ 4 , 5 , 3 , 1 , 2 , 6 ]
# Function call answer = isPossible(N, A)
if (answer):
print ( "True" )
else :
print ( "False" )
# This code is contributed by shinjanpatra |
// C# code for the above approach. using System;
public class GFG{
// Function to check if it is possible
// to divide the given array into
// N/2 pairs having equal sum
static bool isPossible( int N, int [] A){
// Sorting the given array
Array.Sort(A);
// Initializing target as the sum of
// minimum and maximum element
int target = A[0] + A[N - 1];
// Initializing two pointers
int i = 0, j = N - 1;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (A[i] + A[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
}
// Driver Code
static public void Main (){
int N = 6;
int [] A = { 4, 5, 3, 1, 2, 6 };
// Function call
bool answer = isPossible(N, A);
if (answer == true )
Console.Write( "True" );
else
Console.Write( "False" );
}
} // This code is contributed by hrithikgarg03188. |
<script> // JavaScript code for the above approach.
// Function to check if it is possible
// to divide the given array into
// N/2 pairs having equal sum
const isPossible = (N, A) => {
// Sorting the given array
A.sort();
// Initializing target as the sum of
// minimum and maximum element
let target = A[0] + A[N - 1];
// Initializing two pointers
let i = 0, j = N - 1;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (A[i] + A[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
}
// Driver Code
let N = 6;
let A = [4, 5, 3, 1, 2, 6];
// Function call
answer = isPossible(N, A);
if (answer)
document.write( "True" );
else
document.write( "False" );
// This code is contributed by rakeshsahni </script> |
True
Time Complexity: O(N * logN), as we are using inbuilt sort function which will cost O (N*logN).
Auxiliary Space: O(1), as we are not using any extra space.
Approach 2: Using Vectors:
The code above is using a vector approach to solve a specific problem, which is to check if it is possible to divide an array into N/2 pairs having equal sum. The algorithm uses sorting and two pointers to traverse the array and check if there are N/2 pairs that add up to a specific value (target).
Vectors provide iterators that allow you to traverse the elements of the vector in a range-based for loop, making the code more readable and easier to understand.
#include <bits/stdc++.h> using namespace std;
// Function to check if it is possible // to divide the given array into // N/2 pairs having equal sum bool isPossible(vector< int >& nums)
{ // Sorting the given array
sort(nums.begin(), nums.end());
// Initializing target as the sum of
// minimum and maximum element
int target = nums[0] + nums[nums.size() - 1];
// Initializing two pointers
int i = 0, j = nums.size() - 1;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (nums[i] + nums[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
} // Driver Code int main()
{ vector< int > nums = {4, 5, 3, 1, 2, 6};
// Function call
bool answer = isPossible(nums);
if (answer)
cout << "True" ;
else
cout << "False" ;
return 0;
} |
import java.util.*;
public class Main {
// Function to check if it is possible
// to divide the given array into
// N/2 pairs having equal sum
public static boolean isPossible(ArrayList<Integer> nums) {
// Sorting the given array
Collections.sort(nums);
// Initializing target as the sum of
// minimum and maximum element
int target = nums.get( 0 ) + nums.get(nums.size() - 1 );
// Initializing two pointers
int i = 0 , j = nums.size() - 1 ;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (nums.get(i) + nums.get(j) == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
}
// Driver Code
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<>(Arrays.asList( 4 , 5 , 3 , 1 , 2 , 6 ));
// Function call
boolean answer = isPossible(nums);
if (answer)
System.out.println( "True" );
else
System.out.println( "False" );
}
} |
from typing import List
def is_possible(nums: List [ int ]) - > bool :
# Sorting the given array
nums.sort()
# Initializing target as the sum of
# minimum and maximum element
target = nums[ 0 ] + nums[ - 1 ]
# Initializing two pointers
i, j = 0 , len (nums) - 1
while i < j:
# If sum of elements at i and j
# is equal to target then,
# increment and decrement i and j
# respectively
if nums[i] + nums[j] = = target:
i + = 1
j - = 1
# Else return false
else :
return False
# After whole array is traversed,
# which means N/2 pairs have sum
# equal to target, hence return true
return True
# Driver code if __name__ = = '__main__' :
nums = [ 4 , 5 , 3 , 1 , 2 , 6 ]
# Function call
answer = is_possible(nums)
if answer:
print ( "True" )
else :
print ( "False" )
|
using System;
using System.Collections.Generic;
using System.Linq;
class Program {
// Function to check if it is possible
// to divide the given array into
// N/2 pairs having equal sum
static bool IsPossible(List< int > nums) {
// Sorting the given array
nums.Sort();
// Initializing target as the sum of
// minimum and maximum element
int target = nums[0] + nums[nums.Count - 1];
// Initializing two pointers
int i = 0, j = nums.Count - 1;
while (i < j) {
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (nums[i] + nums[j] == target) {
i++;
j--;
}
// Else return false
else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
}
// Driver Code
static void Main() {
List< int > nums = new List< int > {4, 5, 3, 1, 2, 6};
// Function call
bool answer = IsPossible(nums);
if (answer)
Console.WriteLine( "True" );
else
Console.WriteLine( "False" );
}
} // This code is contributed by Prajwal Kandekar |
// JavaScript Code function isPossible(nums){
// Sorting the given array
nums.sort();
// Initializing target as the sum of
// minimum and maximum element
let target = nums[0] + nums[nums.length - 1];
// Initializing two pointers
let i = 0, j = nums.length - 1;
while (i < j){
// If sum of elements at i and j
// is equal to target then,
// increment and decrement i and j
// respectively
if (nums[i] + nums[j] === target){
i += 1;
j -= 1;
// Else return false
} else {
return false ;
}
}
// After whole array is traversed,
// which means N/2 pairs have sum
// equal to target, hence return true
return true ;
} // Driver code let nums = [4, 5, 3, 1, 2, 6]; // Function call let answer = isPossible(nums); if (answer){
console.log( "True" );
} else {
console.log( "False" );
} |
True
Time Complexity: O(N * logN), as we are using inbuilt sort function which will cost O (N*logN).
Auxiliary Space: O(N)