Check if an array can be divided into pairs whose sum is divisible by k

Given an array of integers and a number k, write a function that returns true if given array can be divided into pairs such that sum of every pair is divisible by k.

Examples:

Input: arr[] = {9, 7, 5, 3},
k = 6
Output: True
We can divide array into (9, 3) and
(7, 5). Sum of both of these pairs
is a multiple of 6.

Input: arr[] = {92, 75, 65, 48, 45, 35},
k = 10
Output: True
We can divide array into (92, 48), (75, 65)
and (45, 35). Sum of all these pairs is a
multiple of 10.

Input: arr[] = {91, 74, 66, 48}, k = 10
Output: False

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

A Simple Solution is to iterate through every element arr[i]. Find if there is another not yet visited element that has remainder as (k – arr[i]%k). If there is no such element, return false. If a pair is found, then mark both elements as visited.

Time complexity of this solution is O(n² and it requires O(n) extra space.

An Efficient Solution is to use Hashing.

1) If length of given array is odd, return false. 
    An odd length array cannot be divided into pairs.
2) Traverse input array and count occurrences of 
    all reminders. 
      freq[arr[i] % k]++
3) Traverse input array again. 
   a) Find the remainder of the current element.
   b) If remainder divides k into two halves, then
      there must be even occurrences of it as it 
      forms pair with itself only.
   c) If the remainder is 0, then there must be 
      even occurrences.
   c) Else, number of occurrences of current 
      the remainder must be equal to a number of 
      occurrences of "k - current remainder".

An efficient approach is to use hashing (unordered_map in C++ and HashMap in Java).

Below image is a dry run of the above approach:

Below is th eimplemntation of the above approach:

C++

// A C++ program to check if arr[0..n-1] can be divided 
// in pairs such that every pair is divisible by k. 
#include <bits/stdc++.h> 
using namespace std; 
  
// Returns true if arr[0..n-1] can be divided into pairs 
// with sum divisible by k. 
bool canPairs(int arr[], int n, int k) 
{ 
    // An odd length array cannot be divided into pairs 
    if (n & 1) 
        return false; 
  
    // Create a frequency array to count occurrences 
    // of all remainders when divided by k. 
    unordered_map<int, int> freq; 
  
    // Count occurrences of all remainders 
    for (int i = 0; i < n; i++) 
        freq[arr[i] % k]++; 
  
    // Traverse input array and use freq[] to decide 
    // if given array can be divided in pairs 
    for (int i = 0; i < n; i++) 
    { 
        // Remainder of current element 
        int rem = arr[i] % k; 
  
        // If remainder with current element divides 
        // k into two halves. 
        if  (2*rem == k) 
        { 
            // Then there must be even occurrences of 
            // such remainder 
            if (freq[rem] % 2 != 0) 
                return false; 
        } 
  
        // If remainder is 0, then there must be two  
        // elements with 0 remainder 
        else if (rem == 0) 
        { 
           if (freq[rem] & 1)            
               return false; 
        }         
  
        // Else number of occurrences of remainder 
        // must be equal to number of occurrences of 
        // k - remainder 
        else if (freq[rem] != freq[k - rem]) 
            return false; 
    } 
    return true; 
} 
  
/* Driver program to test above function */
int main() 
{ 
    int arr[] =  {92, 75, 65, 48, 45, 35}; 
    int k = 10; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    canPairs(arr, n, k)? cout << "True": cout << "False"; 
    return 0; 
} 

Java

   
import java.util.HashMap; 
  
public class Divisiblepair  
{ 
    // Returns true if arr[0..n-1] can be divided into pairs 
    // with sum divisible by k. 
    static boolean canPairs(int ar[], int k)  
    { 
        // An odd length array cannot be divided into pairs 
        if (ar.length % 2 == 1) 
            return false; 
          
        // Create a frequency array to count occurrences 
        // of all remainders when divided by k. 
        HashMap<Integer, Integer> hm = new HashMap<>(); 
          
        // Count occurrences of all remainders 
        for (int i = 0; i < ar.length; i++)  
        { 
            int rem = ar[i] % k; 
            if (!hm.containsKey(rem))  
            { 
                hm.put(rem, 0); 
            } 
            hm.put(rem, hm.get(rem) + 1); 
        } 
          
        // Traverse input array and use freq[] to decide 
        // if given array can be divided in pairs 
        for (int i = 0; i < ar.length; i++)  
        { 
             // Remainder of current element 
            int rem = ar[i] % k; 
              
            // If remainder with current element divides 
            // k into two halves. 
            if (2 * rem == k)  
            { 
                // Then there must be even occurrences of 
                // such remainder 
                if (hm.get(rem) % 2 == 1) 
                    return false; 
            }  
              
            // If remainder is 0, then there must be two  
            // elements with 0 remainder 
            else if (rem == 0)  
            { 
                // Then there must be even occurrences of 
                // such remainder 
                if (hm.get(rem) % 2 == 1) 
                    return false; 
            } 
              
            // Else number of occurrences of remainder 
            // must be equal to number of occurrences of 
            // k - remainder 
            else 
            { 
                if (hm.get(k - rem) != hm.get(rem)) 
                    return false; 
            } 
        } 
        return true; 
    } 
  
    // Driver program to test above functions 
    public static void main(String[] args)  
    { 
        int arr[] = { 92, 75, 65, 48, 45, 35 }; 
        int k = 10; 
        boolean ans = canPairs(arr, k); 
        if (ans) 
            System.out.println("True"); 
        else
            System.out.println("False"); 
  
    } 
} 
  
// This code is contributed by Rishabh Mahrsee 

Output:

True

Time complexity : O(n).

This article is contributed by Priyanka. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

Java

Recommended Posts: