Skip to content

Count pairs in array whose sum is divisible by K

Check If Array Pair Sums Divisible by k

Last Updated : 19 Nov, 2024

Try it on GfG Practice

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

Examples:

Input: arr[] = [9, 7, 5, 3], k = 6
Output: True
We can divide the 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 the array into (92, 48), (75, 65) and (45, 35). The sum of all these pairs are multiples of 10.

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

Naive Approach – O(n^2) Time and O(n) Space

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

C++

#include <iostream> #include <vector> using namespace std;  bool canPairs(vector<int>& arr, int k) {        int n = arr.size();        if (n % 2 == 1)         return false;      int count = 0;      vector<int> vis(n, -1);      for (int i = 0; i < n; i++) {         for (int j = i + 1; j < n; j++) {                        // If pair is divisible increment the                // count and mark elements as visited             if ((arr[i] + arr[j]) % k == 0 &&                  vis[i] == -1 && vis[j] == -1) {                                   count++;                 vis[i] = 1;                 vis[j] = 1;             }         }     }      return (count == n / 2); }  // Driver code int main() {     vector<int> arr = {92, 75, 65, 48, 45, 35};     int k = 10;     cout << (canPairs(arr, k) ? "True" : "False");     return 0; }

Java

import java.util.*;  public class GfG {     public static boolean canPairs(int[] arr, int k) {         int n = arr.length;          if (n % 2 == 1)             return false;                int count = 0;          boolean[] vis = new boolean[n];          for (int i = 0; i < n; i++) {             for (int j = i + 1; j < n; j++) {                                // If pair is divisible increment the                 // count and mark elements as visited                 if ((arr[i] + arr[j]) % k == 0 &&                      !vis[i] && !vis[j]) {                                        count++;                     vis[i] = true;                     vis[j] = true;                 }             }         }          return (count == n / 2);     }      public static void main(String[] args) {         int[] arr = {92, 75, 65, 48, 45, 35};         int k = 10;         System.out.println(canPairs(arr, k) ? "True" : "False");     } }

Python

def can_pairs(arr, k):     n = len(arr)          if n % 2 == 1:         return False      count = 0      vis = [-1] * n      for i in range(n):         for j in range(i + 1, n):                        # If pair is divisible increment the             # count and mark elements as visited             if (arr[i] + arr[j]) % k == 0 and vis[i] == -1 and vis[j] == -1:                 count += 1                 vis[i] = 1                 vis[j] = 1      return count == n // 2  # Driver code arr = [92, 75, 65, 48, 45, 35] k = 10 print("True" if can_pairs(arr, k) else "False")

C#

// Include necessary namespaces using System; using System.Collections.Generic;  class Program {     static bool CanPairs(List<int> arr, int k) {         int n = arr.Count;                if (n % 2 == 1)             return false;          int count = 0;          bool[] vis = new bool[n];          for (int i = 0; i < n; i++) {             for (int j = i + 1; j < n; j++) {                                // If pair is divisible increment                 // the count and mark elements as visited                 if ((arr[i] + arr[j]) % k == 0 &&                      !vis[i] && !vis[j]) {                                        count++;                     vis[i] = true;                     vis[j] = true;                 }             }         }          return (count == n / 2);     }      // Driver code     static void Main() {         List<int> arr = new List<int> { 92, 75, 65, 48, 45, 35 };         int k = 10;         Console.WriteLine(CanPairs(arr, k) ? "True" : "False");     } }

JavaScript

// Function to check if pairs can be formed function canPairs(arr, k) {     let n = arr.length;      if (n % 2 === 1)         return false;      let count = 0;      let vis = new Array(n).fill(-1);      for (let i = 0; i < n; i++) {         for (let j = i + 1; j < n; j++) {                      // If pair is divisible increment the              // count and mark elements as visited             if ((arr[i] + arr[j]) % k === 0 &&                  vis[i] === -1 && vis[j] === -1) {                 count++;                 vis[i] = 1;                 vis[j] = 1;             }         }     }      return (count === n / 2); }  // Driver code let arr = [92, 75, 65, 48, 45, 35]; let k = 10; console.log(canPairs(arr, k) ? "True" : "False");

Output

True

Expected Approach – Using Hash Map – O(n) Time and O(n) Space

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 remainders (use (arr[i] % k) + k)%k for handling the case of negative integers as well).
freq[((arr[i] % k) + k) % 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.
d) Else, number of occurrences of current the remainder must be equal to a number of occurrences of “k – current remainder”.

C++

#include <bits/stdc++.h> using namespace std;  // Returns true if arr can be divided into pairs // with sum divisible by k. bool canPairs(vector<int>& arr, int k) {     int n = arr.size();          // An odd length array cannot be divided     // into pairs     if (n % 2 != 0)         return false;      // Create a frequency map to count occurrences     // of all remainders when divided by k.     unordered_map<int, int> freq;      // Count occurrences of all remainders     for (int x : arr)         freq[((x % k) + k) % k]++;      // Traverse the array and check pairs     for (int x : arr) {         int rem = ((x % k) + k) % k;          // If remainder divides k into two halves         if (2 * rem == k) {             if (freq[rem] % 2 != 0)                 return false;         }                // If remainder is 0, there must be an even count         else if (rem == 0) {             if (freq[rem] % 2 != 0)                 return false;         }                // Else occurrences of remainder and          // k - remainder must match         else if (freq[rem] != freq[k - rem])             return false;     }     return true; }  // Driver code int main() {     vector<int> arr = {92, 75, 65, 48, 45, 35};     int k = 10;     canPairs(arr, k) ? cout << "True" : cout << "False";     return 0; }

Java

// JAVA program to check if arr[0..n-1] can be divided // in pairs such that every pair is divisible by k. 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) + k) % 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) + k) % 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 code     public static void main(String[] args)     {         int arr[] = { 92, 75, 65, 48, 45, 35 };         int k = 10;          // Function call         boolean ans = canPairs(arr, k);         if (ans)             System.out.println("True");         else             System.out.println("False");     } }  // This code is contributed by Rishabh Mahrsee

Python

from collections import defaultdict  def can_pairs(arr, k):     n = len(arr)          # An odd length array cannot be divided into pairs     if n % 2 != 0:         return False      # Create a frequency map to count occurrences     # of all remainders when divided by k     freq = defaultdict(int)          for x in arr:         freq[(x % k + k) % k] += 1      # Traverse the array and check pairs     for x in arr:         rem = (x % k + k) % k          # If remainder divides k into two halves         if 2 * rem == k:             if freq[rem] % 2 != 0:                 return False          # If remainder is 0, there must be an even count         elif rem == 0:             if freq[rem] % 2 != 0:                 return False          # Else occurrences of remainder and         # k - remainder must match         elif freq[rem] != freq[k - rem]:             return False      return True   # Driver code arr = [92, 75, 65, 48, 45, 35] k = 10 print("True" if can_pairs(arr, k) else "False")

C#

// C# program to check if arr[0..n-1] // can be divided in pairs such that // every pair is divisible by k. using System.Collections.Generic; using System;  class GFG {      // Returns true if arr[0..n-1] can be     // divided into pairs with sum     // divisible by k.     static bool 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.         Dictionary<Double, int> hm             = new Dictionary<Double, int>();          // Count occurrences of all remainders         for (int i = 0; i < ar.Length; i++) {             int rem = ((ar[i] % k) + k) % k;             if (!hm.ContainsKey(rem)) {                 hm[rem] = 0;             }             hm[rem]++;         }          // 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) + k) % 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[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[rem] % 2 == 1)                     return false;             }              // Else number of occurrences of remainder             // must be equal to number of occurrences of             // k - remainder             else {                 if (hm[k - rem] != hm[rem])                     return false;             }         }         return true;     }      // Driver code     public static void Main()     {         int[] arr = { 92, 75, 65, 48, 45, 35 };         int k = 10;          bool ans = canPairs(arr, k);         if (ans)             Console.WriteLine("True");         else             Console.WriteLine("False");     } }

JavaScript

function canPairs(arr, k) {     const n = arr.length;      // An odd length array cannot be divided into pairs     if (n % 2 !== 0) return false;      // Create a frequency map to count occurrences     // of all remainders when divided by k     const freq = new Map();      for (let x of arr) {         const rem = ((x % k) + k) % k;         freq.set(rem, (freq.get(rem) || 0) + 1);     }      // Traverse the array and check pairs     for (let x of arr) {         const rem = ((x % k) + k) % k;          // If remainder divides k into two halves         if (2 * rem === k) {             if ((freq.get(rem) || 0) % 2 !== 0) return false;         }                  // If remainder is 0, there must be an even count         else if (rem === 0) {             if ((freq.get(rem) || 0) % 2 !== 0) return false;         }                  // Else occurrences of remainder and k - remainder must match         else if ((freq.get(rem) || 0) !== (freq.get(k - rem) || 0)) {             return false;         }     }     return true; }  // Driver code const arr = [92, 75, 65, 48, 45, 35]; const k = 10; console.log(canPairs(arr, k) ? "True" : "False");

Output

True

Efficient Approach for Small K – O(n) Time and O(k) Space

In this approach we focus on the fact that if sum of two numbers mod K gives the output 0,then it is true for all instances that the individual number mod K would sum up to the K.
We make an array of size K and there we increase the frequency and reduces it, if found a match and in the end if array has no element greater than 0 then it returns true else return false.

C++

#include <bits/stdc++.h> using namespace std;  bool canPairs(vector<int> arr, int k) {        if (arr.size() % 2 != 0)         return false;      vector<int> freq(k);      for (int x : arr) {         int rem = x % k;                  // If the complement of the current          // remainder exists in freq, decrement its count         if (freq[(k - rem) % k] != 0)             freq[(k - rem) % k]--;                // Otherwise, increment the count of t         // he current remainder         else             freq[rem]++;     }      // Check if all elements in the frequency     // array are 0     for (int count : freq) {         if (count != 0)             return false;     }      return true; }  int main() {     vector<int> arr = {92, 75, 65, 48, 45, 35};     int k = 10;     cout << (canPairs(arr, k) ? "True" : "False");     return 0; }

Java

import java.util.*;  public class Main {     public static boolean canPairs(int[] arr, int k) {         if (arr.length % 2 != 0)             return false;          // Create a frequency array of size k         int[] freq = new int[k];          for (int x : arr) {             int rem = x % k;                          // If the complement of the current              // remainder exists in freq, decrement             // its count             if (freq[(k - rem) % k] != 0)                 freq[(k - rem) % k]--;                          // Otherwise, increment the count of              // the current remainder             else                 freq[rem]++;         }          // Check if all elements in the frequency          // array are 0         for (int count : freq) {             if (count != 0)                 return false;         }          return true;     }      public static void main(String[] args) {         int[] arr = {92, 75, 65, 48, 45, 35};         int k = 10;         System.out.println(canPairs(arr, k) ? "True" : "False");     } }

Python

def can_pairs(arr, k):     if len(arr) % 2 != 0:         return False      freq = [0] * k      for x in arr:         rem = x % k                  # If the complement of the current          # remainder exists in freq, decrement its count         if freq[(k - rem) % k] != 0:             freq[(k - rem) % k] -= 1                  # Otherwise, increment the count of the current remainder         else:             freq[rem] += 1      # Check if all elements in the frequency array are 0     for count in freq:         if count != 0:             return False      return True  arr = [92, 75, 65, 48, 45, 35] k = 10 print("True" if can_pairs(arr, k) else "False")

C#

using System; using System.Linq;  class Program {     static bool CanPairs(int[] arr, int k) {         if (arr.Length % 2 != 0)             return false;          // Create a frequency array of size k         int[] freq = new int[k];          foreach (int x in arr) {             int rem = x % k;                          // If the complement of the current              // remainder exists in freq, decrement             // its count             if (freq[(k - rem) % k] != 0)                 freq[(k - rem) % k]--;                          // Otherwise, increment the count of              // the current remainder             else                 freq[rem]++;         }          // Check if all elements in the frequency array are 0         foreach (int count in freq) {             if (count != 0)                 return false;         }          return true;     }      static void Main() {         int[] arr = {92, 75, 65, 48, 45, 35};         int k = 10;         Console.WriteLine(CanPairs(arr, k) ? "True" : "False");     } }

JavaScript

function canPairs(arr, k) {     if (arr.length % 2 !== 0)         return false;      let freq = new Array(k).fill(0);      for (let x of arr) {         let rem = x % k;                  // If the complement of the current          // remainder exists in freq, decrement          // its count         if (freq[(k - rem) % k] !== 0)             freq[(k - rem) % k]--;                  // Otherwise, increment the count of          // the current remainder         else             freq[rem]++;     }      // Check if all elements in the      // frequency array are 0     for (let count of freq) {         if (count !== 0)             return false;     }      return true; }  let arr = [92, 75, 65, 48, 45, 35]; let k = 10; console.log(canPairs(arr, k) ? "True" : "False");

Output

True

Count pairs in array whose sum is divisible by K

A

Aarti_Rathi and Priyanka

Improve

Article Tags :

Practice Tags :

Similar Reads

Count pairs in array whose sum is divisible by K

Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose sum is divisible by K. Note: This question is a generalized version of this Examples: Input : A[] = {2, 2, 1, 7, 5, 3}, K = 4 Output : 5 Explanation : There are five pairs possible whose sum

Count pairs in array whose sum is divisible by 4

Given a array if 'n' positive integers. Count number of pairs of integers in the array that have the sum divisible by 4. Examples : Input: {2, 2, 1, 7, 5}Output: 3Explanation:Only three pairs are possible whose sumis divisible by '4' i.e., (2, 2), (1, 7) and (7, 5)Input: {2, 2, 3, 5, 6}Output: 4Reco

Count sub-arrays whose product is divisible by k

Given an integer K and an array arr[], the task is to count all the sub-arrays whose product is divisible by K.Examples: Input: arr[] = {6, 2, 8}, K = 4 Output: 4 Required sub-arrays are {6, 2}, {6, 2, 8}, {2, 8}and {8}.Input: arr[] = {9, 1, 14}, K = 6 Output: 1 Naive approach: Run nested loops and

Count pairs in Array whose product is divisible by K

Given a array vec and an integer K, count the number of pairs (i, j) such that vec[i]*vec[j] is divisible by K where i<j. Examples: Input: vec = {1, 2, 3, 4, 5, 6}, K = 4Output: 6Explanation: The pairs of indices (0, 3), (1, 3), (2, 3), (3, 4), (3, 5) and (1, 5) satisfy the condition as their pro

Count divisible pairs in an array

Given an array, count pairs in the array such that one element of the pair divides the other. Examples: Input : arr[] = {1, 2, 3} Output : 2 The two pairs are (1, 2) and (1, 3) Input : arr[] = {2, 3, 5, 7} Output: 0 Naive Approach: The brute force approach can be implemented by iterating through eve

Check if any valid sequence is divisible by M

Given an array of N integers, using '+' and '-' between the elements check if there is a way to form a sequence of numbers that evaluate to a number divisible by M Examples: Input: arr = {1, 2, 3, 4, 6} M = 4Output: True Explanation:There is a valid sequence i.e., (1 - 2+ 3 + 4 + 6), which evaluates

Count of pairs in Array whose product is divisible by K

Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose product is divisible by K. Examples : Input: A[] = [1, 2, 3, 4, 5], K = 2Output: 7Explanation: The 7 pairs of indices whose corresponding products are divisible by 2 are(0, 1), (0, 3), (1, 2)

Check if a sorted array can be divided in pairs whose sum is k

Given a sorted 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 k.Expected time complexity O(n) and extra space O(1). This problem is a variation of below problem, but has a different interesting solution that r

Count number of pairs in array having sum divisible by K | SET 2

Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose sum is divisible by K.Examples: Input : A[] = {2, 2, 1, 7, 5, 3}, K = 4 Output : 5 There are five pairs possible whose sum Is divisible by '4' i.e., (2, 2), (1, 7), (7, 5), (1, 3) and (5, 3)I

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

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: YesExplanation:The given arr