 GeeksforGeeks App
Open App Browser
Continue

# Count pairs in an array whose absolute difference is divisible by K

Given an array arr[] and a positive integer K. The task is to count the total number of pairs in the array whose absolute difference is divisible by K.

Examples:

Input: arr[] = {1, 2, 3, 4}, K = 2
Output:
Explanation:
Total 2 pairs exists in the array with absolute difference divisible by 2.
The pairs are: (1, 3), (2, 4).

Input: arr[] = {3, 3, 3}, K = 3
Output:
Explanation:
Total 3 pairs exists in this array with absolute difference divisible by 3.
The pairs are: (3, 3), (3, 3), (3, 3).

Naive Approach: The idea is to check for each pair of the array one by one and count the total number pairs whose absolute difference is divisible by K.

## C++

 `#include ``using` `namespace` `std;` `// function to count pairs in an array``// whose absolute difference is``// divisible by k``void` `countPairs(``int` `arr[], ``int` `n, ``int` `k)``{` `    ``// initialize count as zero.``    ``int` `i, j, cnt = 0;` `    ``// loop to count the valid pair``    ``for` `(i = 0; i < n - 1; i++) {``        ``for` `(j = i + 1; j < n; j++) {``            ``if` `(``abs``(arr[i] - arr[j]) % k == 0)``                ``cnt += 1;``        ``}``    ``}``    ``cout << cnt << endl;``}` `// Driver code``int` `main()``{``    ``// input array``    ``int` `arr[] = {3, 3, 3};``    ``int` `k = 3;` `    ``// calculate the size of array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// function to count the valid pair``    ``countPairs(arr, n, k);``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `class` `GFG``{` `// function to count pairs in an array``// whose absolute difference is``// divisible by k``static` `void` `countPairs(``int` `arr[], ``int` `n, ``int` `k)``{` `    ``// initialize count as zero.``    ``int` `i, j, cnt = ``0``;` `    ``// loop to count the valid pair``    ``for` `(i = ``0``; i < n - ``1``; i++)``    ``{``        ``for` `(j = i + ``1``; j < n; j++)``        ``{``            ``if` `((arr[i] - arr[j] + k) % k == ``0``)``                ``cnt += ``1``;``        ``}``    ``}``    ``System.out.print(cnt +``"\n"``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// input array``    ``int` `arr[] = {``3``, ``3``, ``3``};``    ``int` `k = ``3``;` `    ``// calculate the size of array``    ``int` `n = arr.length;` `    ``// function to count the valid pair``    ``countPairs(arr, n, k);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 Code implementation of the above approach` `# function to count pairs in an array``# whose absolute difference is``# divisible by k``def` `countPairs(arr, n, k) :` `    ``# initialize count as zero.``    ``cnt ``=` `0``;` `    ``# loop to count the valid pair``    ``for` `i ``in` `range``(n ``-` `1``) :``        ``for` `j ``in` `range``(i ``+` `1``, n) :``            ``if` `((arr[i] ``-` `arr[j] ``+` `k) ``%` `k ``=``=` `0``) :``                ``cnt ``+``=` `1``;``    ` `    ``print``(cnt) ;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``# input array``    ``arr ``=` `[``3``, ``3``, ``3``];``    ``k ``=` `3``;` `    ``# calculate the size of array``    ``n ``=` `len``(arr);` `    ``# function to count the valid pair``    ``countPairs(arr, n, k);``    ` `# This code is contributed by AnkitRai01`

## C#

 `using` `System;` `class` `GFG``{` `// function to count pairs in an array``// whose absolute difference is``// divisible by k``static` `void` `countPairs(``int` `[]arr, ``int` `n, ``int` `k)``{` `    ``// initialize count as zero.``    ``int` `i, j, cnt = 0;` `    ``// loop to count the valid pair``    ``for` `(i = 0; i < n - 1; i++)``    ``{``        ``for` `(j = i + 1; j < n; j++)``        ``{``            ``if` `((arr[i] - arr[j] + k) % k == 0)``                ``cnt += 1;``        ``}``    ``}``    ``Console.Write(cnt +``"\n"``);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``// input array``    ``int` `[]arr = {3, 3, 3};``    ``int` `k = 3;` `    ``// calculate the size of array``    ``int` `n = arr.Length;` `    ``// function to count the valid pair``    ``countPairs(arr, n, k);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`3`

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

Efficient Approach:

Algorithm:

• Convert each elements (A[i]) of the array to ((A[i]+K)%K)
• Use hashing technique to store the number of times (A[i]%K) occurs in the array
• Now, if an element H[i] occurs x times in the array then add x*(x-1)/2 (choosing any 2 elements out of x elements ) in the count pair where 1<=i<=n .This is because value of each elements of the array lies between 0 to K-1 so the absolute difference is divisible only if value of both the elements of a pair are equal

Below is the implementation of the above approach:

## C++

 `// Write CPP code here``#include ``using` `namespace` `std;` `// function to Count pairs in an array whose``// absolute difference is divisible by k``void` `countPair(``int` `arr[], ``int` `n, ``int` `k)``{` `    ``// initialize the count``    ``int` `cnt = 0;` `    ``// making every element of arr in``    ``// range 0 to k - 1``    ``for` `(``int` `i = 0; i < n; i++) {``        ``arr[i] = (arr[i] + k) % k;``    ``}` `    ``// create an array hash[]``    ``int` `hash[k] = { 0 };` `    ``// store to count of element of arr``    ``// in hash[]``    ``for` `(``int` `i = 0; i < n; i++) {``        ``hash[arr[i]]++;``    ``}` `    ``// count the pair whose absolute``    ``// difference is divisible by k``    ``for` `(``int` `i = 0; i < k; i++) {``        ``cnt += (hash[i] * (hash[i] - 1)) / 2;``    ``}` `    ``// print the value of count``    ``cout << cnt << endl;``}` `// Driver Code``int` `main()``{``    ``// input array``    ``int` `arr[] = {1, 2, 3, 4};``    ``int` `k = 2;` `    ``// calculate the size of array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``countPair(arr, n, k);``    ``return` `0;``}`

## Java

 `// JAVA Implementation of above approach``import` `java.util.*;` `class` `GFG``{` `// function to Count pairs in an array whose``// absolute difference is divisible by k``static` `void` `countPair(``int` `arr[], ``int` `n, ``int` `k)``{` `    ``// initialize the count``    ``int` `cnt = ``0``;` `    ``// making every element of arr in``    ``// range 0 to k - 1``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``arr[i] = (arr[i] + k) % k;``    ``}` `    ``// create an array hash[]``    ``int` `hash[] = ``new` `int``[k];` `    ``// store to count of element of arr``    ``// in hash[]``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``hash[arr[i]]++;``    ``}` `    ``// count the pair whose absolute``    ``// difference is divisible by k``    ``for` `(``int` `i = ``0``; i < k; i++)``    ``{``        ``cnt += (hash[i] * (hash[i] - ``1``)) / ``2``;``    ``}` `    ``// print the value of count``    ``System.out.print(cnt +``"\n"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// input array``    ``int` `arr[] = {``1``, ``2``, ``3``, ``4``};``    ``int` `k = ``2``;` `    ``// calculate the size of array``    ``int` `n = arr.length;``    ``countPair(arr, n, k);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 Implementation of above approach` `# function to Count pairs in an array whose``# absolute difference is divisible by k``def` `countPair(arr, n, k):` `    ``# initialize the count``    ``cnt ``=` `0``;` `    ``# making every element of arr in``    ``# range 0 to k - 1``    ``for` `i ``in` `range``(n):``        ``arr[i] ``=` `(arr[i] ``+` `k) ``%` `k;` `    ``# create an array hash``    ``hash` `=` `[``0``]``*``k;` `    ``# store to count of element of arr``    ``# in hash``    ``for` `i ``in` `range``(n):``        ``hash``[arr[i]] ``+``=` `1``;` `    ``# count the pair whose absolute``    ``# difference is divisible by k``    ``for` `i ``in` `range``(k):``        ``cnt ``+``=` `(``hash``[i] ``*` `(``hash``[i] ``-` `1``)) ``/` `2``;` `    ``# print value of count``    ``print``(``int``(cnt));` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# input array``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``];``    ``k ``=` `2``;` `    ``# calculate the size of array``    ``n ``=` `len``(arr);``    ``countPair(arr, n, k);` `# This code is contributed by 29AjayKumar`

## C#

 `// C# Implementation of above approach``using` `System;` `class` `GFG``{` `// function to Count pairs in an array whose``// absolute difference is divisible by k``static` `void` `countPair(``int` `[]arr, ``int` `n, ``int` `k)``{` `    ``// initialize the count``    ``int` `cnt = 0;` `    ``// making every element of arr in``    ``// range 0 to k - 1``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``arr[i] = (arr[i] + k) % k;``    ``}` `    ``// create an array hash[]``    ``int` `[]hash = ``new` `int``[k];` `    ``// store to count of element of arr``    ``// in hash[]``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``hash[arr[i]]++;``    ``}` `    ``// count the pair whose absolute``    ``// difference is divisible by k``    ``for` `(``int` `i = 0; i < k; i++)``    ``{``        ``cnt += (hash[i] * (hash[i] - 1)) / 2;``    ``}` `    ``// print the value of count``    ``Console.Write(cnt +``"\n"``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``// input array``    ``int` `[]arr = {1, 2, 3, 4};``    ``int` `k = 2;` `    ``// calculate the size of array``    ``int` `n = arr.Length;``    ``countPair(arr, n, k);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`2`

Time Complexity: O(n+k)
Auxiliary Space: O(k)

Using unordered map approach:

Suppose we have two numbers x1 and x2 and we want (x1 -x2) to be divisible by k

and we know that if both numbers are divisible by k then if we subtract them they will also be divisible by k

for example K=2   (4-2) is divisible by 2 because ( 4 is divisible by 2 )  and ( 2 is also divisible by 2 ).

so what x%k give us ?? it give us if we add x%k or subtract x%k from that number it will became divisible by k

for example: k=5 and x=2   (5%2) = 1  if we add 1 to 5 it will became 6 which is divisible by 2 and if we subtract 1 from 5 it will became 4 which is also divisible by 2. so what we will do we will check and can i get arr[i]%k from any previous number so that i will add arr[i]%k to my current number  and subtract arr[i]%k to my previous number to make both the numbers divisible by k .

for example:  [5,7]    K=2

5%2 = 1 // subtract one to make it divisible by K

7%2 =1 // needs one to make it divisible by K

or vice versa we will take one from 5 to make it divisible by K

Implementation of the approach:

## C++

 `// Write CPP code here``#include ``using` `namespace` `std;` `// function to Count pairs in an array whose``// absolute difference is divisible by k``void` `countPair(``int` `arr[], ``int` `n, ``int` `k)``{``//initialize the map to store pairs``    ``unordered_map<``int``, ``int``> map;` `    ``int` `res = 0;` `    ``for` `(``int` `i = 0; i < n; ++i) {``// check for remainder is present in the map or not.``        ``if` `(map.find(arr[i] % k) != map.end()) {` `            ``res += map[arr[i] % k];``        ``}` `        ``map[arr[i] % k]++;``    ``}``//print the answer``    ``cout << res;``}` `// Driver Code``int` `main()``{``    ``// input array``    ``int` `arr[] = { 1, 2, 3, 4 };``    ``int` `k = 2;` `    ``// calculate the size of array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``countPair(arr, n, k);``    ``return` `0;``}``//This code is contributed by Prateek Kumar Singh`

## Java

 `// java implimentation``import` `java.util.*;` `class` `Main {``    ``static` `void` `countPair(``int``[] arr, ``int` `n, ``int` `k)``    ``{``        ``// initialize the map to store pairs``        ``Map map = ``new` `HashMap<>();``        ``int` `res = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; ++i) {``            ``// check for remainder is present in the map or``            ``// not.``            ``if` `(map.containsKey(arr[i] % k)) {``                ``res += map.get(arr[i] % k);``            ``}` `            ``map.put(arr[i] % k,``                    ``map.getOrDefault(arr[i] % k, ``0``) + ``1``);``        ``}``        ``// print the answer``        ``System.out.println(res);``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// input array``        ``int``[] arr = { ``1``, ``2``, ``3``, ``4` `};``        ``int` `k = ``2``;``        ``// calculate the size of array``        ``int` `n = arr.length;``        ``countPair(arr, n, k);``    ``}``}`

## Python3

 `# function to count pairs in an array whose absolute difference is divisible by k``def` `countPair(arr, n, k):``  ` `    ``# initialize the dictionary to store pairs``    ``dict` `=` `{}``    ``res ``=` `0` `    ``for` `i ``in` `range``(n):``      ` `        ``# check if remainder is present in the dictionary or not.``        ``if` `arr[i] ``%` `k ``in` `dict``:``            ``res ``+``=` `dict``[arr[i] ``%` `k]` `        ``dict``[arr[i] ``%` `k] ``=` `dict``.get(arr[i] ``%` `k, ``0``) ``+` `1` `    ``# print the answer``    ``print``(res)` `# driver code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# input array``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``]``    ``k ``=` `2` `    ``# calculate the size of array``    ``n ``=` `len``(arr)``    ``countPair(arr, n, k)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{``    ``// function to Count pairs in an array whose``    ``// absolute difference is divisible by k``    ``static` `void` `countPair(``int``[] arr, ``int` `n, ``int` `k)``    ``{``        ``// initialize the dictionary to store pairs``        ``Dictionary<``int``, ``int``> map = ``new` `Dictionary<``int``, ``int``>();` `        ``int` `res = 0;` `        ``for` `(``int` `i = 0; i < n; ++i)``        ``{``            ``// check for remainder is present in the dictionary or not.``            ``if` `(map.ContainsKey(arr[i] % k))``            ``{``                ``res += map[arr[i] % k];``            ``}` `            ``if` `(map.ContainsKey(arr[i] % k))``            ``{``                ``map[arr[i] % k]++;``            ``}``            ``else``            ``{``                ``map.Add(arr[i] % k, 1);``            ``}``        ``}` `        ``// print the answer``        ``Console.WriteLine(res);``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``// input array``        ``int``[] arr = { 1, 2, 3, 4 };``        ``int` `k = 2;` `        ``// calculate the size of array``        ``int` `n = arr.Length;``        ``countPair(arr, n, k);``    ``}``}`

## Javascript

 `// function to count pairs in an array whose absolute difference is divisible by k``function` `countPair(arr, n, k) {` `  ``// initialize the object to store pairs``  ``let dict = {};``  ``let res = 0;` `  ``for` `(let i = 0; i < n; i++) {` `    ``// check if remainder is present in the object or not.``    ``if` `(arr[i] % k ``in` `dict) {``      ``res += dict[arr[i] % k];``    ``}` `    ``dict[arr[i] % k] = (dict[arr[i] % k] || 0) + 1;``  ``}` `  ``// print the answer``  ``console.log(res);``}` `// driver code``let arr = [1, 2, 3, 4];``let k = 2;` `// calculate the size of array``let n = arr.length;``countPair(arr, n, k);`

Output

`2`

Time Complexity: O(n)
Auxiliary Space: O(k)

This approach is contributed by Prateek Kumar Singh (pkrsingh025).

My Personal Notes arrow_drop_up