# 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: 2
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: 3
Explanation:
Total 3 pairs exists in this array with absolute difference divisible by 3.
The pairs are: (3, 3), (3, 3), (3, 3).

## Recommended: Please solve it on {IDE} first, before moving on to the solution.

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) ` `{ ` ` `  `    ``// initilize 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; ` `        ``} ` `    ``} ` `    ``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) ` `{ ` ` `  `    ``// initilize 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 implementaton of the above approach ` ` `  `# function to count pairs in an array  ` `# whose absolute difference is  ` `# divisible by k  ` `def` `countPairs(arr, n, k) : ` ` `  `    ``# initilize 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) ` `{ ` ` `  `    ``// initilize 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 `

Output:

```3
```

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

Efficient Approach:

Algorithm:

1. Convert each elements `(A[i])` of the array to `((A[i]+K)%K) `
2. Use hashing teching technique to store the number of times `(A[i]%K)` occurs in the array
3. Now, if an element A[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

## CPP

 `// 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) ` `{ ` ` `  `    ``// intialize 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) ` `{ ` ` `  `    ``// intialize 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): ` ` `  `    ``# intialize 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``; ` ` `  `    ``# prthe 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) ` `{ ` ` `  `    ``// intialize 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 `

Output:

```2
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Coder and Django developer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

6

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.