Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if a given array can be divided into pairs with even sum

  • Difficulty Level : Hard
  • Last Updated : 13 Sep, 2021

Given an array arr[] consisting of N integers, the task is to check if it is possible to divide the entire array into pairs such that the sum of each pair is even. If it is possible, print “Yes”. Otherwise, print “No”.

Examples:

Input: arr[] = {3, 2, 1, 4, 7, 5, }
Output: Yes
Explanation:
The given array can be divided into pairs: {1, 3}, {2, 4}, {5, 7}.

Input: arr[] = {1, 2, 3, 4, 5, 6}
Output: No
Explanation:
No possible pair distribution exists such that each pair sum is even.

Naive Approach: The simplest approach to solve the problem is to traverse the given array and for each element, find an element having the same parity which has not been picked yet and mark both the elements picked to avoid repetitions. If for any element, no suitable element is found, print “No”. Otherwise, if the entire array could be partitioned into desired pairs, print “Yes”. 



Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: The idea is to observe the fact that if the count of even and odd numbers present in the given array are both even, only then, the given array can be divided into pairs having even sum by odd numbers together and even numbers together. Follow the steps below to solve the problem:

  1. Find the total number of odd and even elements present in the given array and store it in two variables, countEven and countOdd respectively.
  2. Check if both countEven and countOdd are even or not. If found to be true, print “Yes”.
  3. Otherwise, print “No”.

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 we can split
// array into pairs of even sum or not
bool canPairs(int arr[], int n)
{
    // If the length is odd then it
    // is not possible to make pairs
    if (n % 2 == 1)
        return false;
 
    // Initialize count of odd & even
    int odd_count = 0, even_count = 0;
 
    // Iterate through the array
    for (int i = 0; i < n; i++)
    {
        // Count even element
        if (arr[i] % 2 == 0)
            even_count++;
        else
            odd_count++;
    }
 
    // If count of even elements
    // and odd elements are even
    if (even_count % 2 == 0 && odd_count % 2 == 0)
    {
        return true;
    }
 
    return false;
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 2, 1, 4, 7, 5 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    if (canPairs(arr, N)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
 
class GFG {
 
    // Function to check if we can split
    // array into pairs of even sum or not
    static boolean canPairs(int[] arr, int n)
    {
        // If the length is odd then it
        // is not possible to make pairs
        if (n % 2 == 1)
            return false;
 
        // Initialize count of odd & even
        int odd_count = 0, even_count = 0;
 
        // Iterate through the array
        for (int i = 0; i < n; i++)
        {
            // Count even element
            if (arr[i] % 2 == 0)
                even_count++;
            else
                odd_count++;
        }
 
        // If count of even elements
        // and odd elements are even
        if (even_count % 2 == 0 && odd_count % 2 == 0)
        {
            return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 3, 2, 1, 4, 7, 5 };
        int N = arr.length;
 
        // Function call
        if (canPairs(arr, N))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by akhilsaini
Python3



# Python3 program for the above approach
 
# Function to check if we can split
# array into pairs of even sum or not
 
 
def canPairs(arr, n):
 
    # If the length is odd then it
    # is not possible to make pairs
    if (n % 2 == 1):
        return False
 
    # Initialize count of odd & even
    odd_count = 0
    even_count = 0
 
    # Iterate through the array
    for i in range(0, n):
 
        # Count even element
        if (arr[i] % 2 == 0):
            even_count = even_count + 1
        else:
            odd_count = odd_count + 1
 
    # If count of even elements
    # and odd elements are even
    if ((even_count % 2 == 0) and
            (odd_count % 2 == 0)):
        return True
 
    return False
 
 
# Driver Code
if __name__ == '__main__':
 
    arr = [3, 2, 1, 4, 7, 5]
    N = len(arr)
 
    # Function call
    if (canPairs(arr, N)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by akhilsaini
C#



// C# program for the above approach
using System;
 
class GFG {
 
    // Function to check if we can split
    // array into pairs of even sum or not
    static bool canPairs(int[] arr, int n)
    {
 
        // If the length is odd then it
        // is not possible to make pairs
        if (n % 2 == 1)
            return false;
 
        // Initialize count of odd & even
        int odd_count = 0, even_count = 0;
 
        // Iterate through the array
        for (int i = 0; i < n; i++)
        {
            // Count even element
            if (arr[i] % 2 == 0)
                even_count++;
            else
                odd_count++;
        }
 
        // If count of even elements
        // and odd elements are even
        if (even_count % 2 == 0 && odd_count % 2 == 0)
        {
            return true;
        }
        return false;
    }
 
    // Driver Code
    public static void Main()
    {
        int[] arr = { 3, 2, 1, 4, 7, 5 };
        int N = arr.Length;
 
        // Function call
        if (canPairs(arr, N))
            Console.Write("Yes");
        else
            Console.Write("No");
    }
}
 
// This code is contributed by akhilsaini
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to check if we can split
// array into pairs of even sum or not
function canPairs(arr, n)
{
     
    // If the length is odd then it
    // is not possible to make pairs
    if (n % 2 == 1)
        return false;
 
    // Initialize count of odd & even
    let odd_count = 0, even_count = 0;
 
    // Iterate through the array
    for(let i = 0; i < n; i++)
    {
         
        // Count even element
        if (arr[i] % 2 == 0)
            even_count++;
        else
            odd_count++;
    }
 
    // If count of even elements
    // and odd elements are even
    if (even_count % 2 == 0 &&
         odd_count % 2 == 0)
    {
        return true;
    }
    return false;
}
 
// Driver Code
let arr = [ 3, 2, 1, 4, 7, 5 ];
let N = arr.length;
 
// Function call
if (canPairs(arr, N))
    document.write("Yes");
else
    document.write("No");
     
// This code is contributed by target_2  
 
</script>
Output
Yes
Time Complexity: O(N)
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Print the last character of lexicographically smallest non-palindromic permutation of a string
Next

Maximum possible sum of non-adjacent array elements not exceeding K
Recommended Articles
Page :
Check if an array can be divided into pairs whose sum is divisible by k
02, Nov 15
Difference between ceil of array sum divided by K and sum of ceil of array elements divided by K
03, May 21
Absolute difference between floor of Array sum divided by X and floor sum of every Array element when divided by X
15, Jun 21
Check if an array of 1s and 2s can be divided into 2 parts with equal sum
14, Feb 19
Check if a sorted array can be divided in pairs whose sum is k
02, Nov 15
Check if given Array can be divided into subsequences of K increasing consecutive integers
29, Sep 21
Check if N can be divided into K consecutive elements with a sum equal to N
31, Jul 20
Number of K's such that the given array can be divided into two sets satisfying the given conditions
29, Oct 19
Check if array can be divided into two sub-arrays such that their absolute difference is K
29, Jan 19
Find if array can be divided into two subarrays of equal sum
04, Aug 16
Find the sums for which an array can be divided into sub-arrays of equal sum
31, Dec 18
Check whether N items can be divided into K groups of unique size
03, Jan 22
First N natural can be divided into two sets with given difference and co-prime sums
18, Apr 18
Minimize the sum of the squares of the sum of elements of each group the array is divided into
11, Feb 19
Minimum Cuts can be made in the Chessboard such that it is not divided into 2 parts
16, Nov 18
Number of ways N can be divided into four parts to construct a rectangle
21, Oct 19
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Check if an array of pairs can be sorted by swapping pairs with different first elements
29, Apr 21
Check if N numbers with Even Sum can be selected from a given Array
19, Aug 20
Find all the possible numbers in a range that can be evenly divided by its digits
26, Apr 20
Check if ceil of number divided by power of two exist in sorted array
15, Jul 20
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Generate Array whose sum of all K-size subarrays divided by N leaves remainder X
29, Jun 20
Maximize array sum by X increments when each element is divided by 10
03, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ArifShaikh
@ArifShaikh
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!