Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

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

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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[0]);
 
    // 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




<script>
 
// Function to count pairs in an array
// whose absolute difference is
// divisible by k
function countPairs(arr, n, k)
{
     
    // Initialize count as zero.
    var 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;
        }
    }
    document.write(cnt + "\n");
}
 
// Driver code
 
// Input array
var arr = [ 3, 3, 3 ];
var k = 3;
 
// Calculate the size of array
var n = arr.length;
 
// Function to count the valid pair
countPairs(arr, n, k);
 
// This code is contributed by umadevi9616
 
</script>

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 <bits/stdc++.h>
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[0]);
    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




<script>
 
// Javascript Implementation of above approach
 
// function to Count pairs in an array whose
// absolute difference is divisible by k
function countPair(arr, n, k)
{
    // let initialize the count
    let cnt = 0;
  
    // making every element of arr in
    // range 0 to k - 1
    for (let i = 0; i < n; i++)
    {
        arr[i] = (arr[i] + k) % k;
    }
  
    // create an array hash[]
    let hash =  Array.from({length: k}, (_, i) => 0);
  
    // store to count of element of arr
    // in hash[]
    for (let i = 0; i < n; i++)
    {
        hash[arr[i]]++;
    }
  
    // count the pair whose absolute
    // difference is divisible by k
    for (let i = 0; i < k; i++)
    {
        cnt += (hash[i] * (hash[i] - 1)) / 2;
    }
  
    // print the value of count
    document.write(cnt +"<br/>");
}
       
// Driver code
     
      // input array
    let arr = [1, 2, 3, 4];
    let k = 2;
  
    // calculate the size of array
    let n = arr.length;
    countPair(arr, n, k);
                                                                                      
</script>

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 <bits/stdc++.h>
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[0]);
    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<Integer, Integer> 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
Last Updated : 17 Mar, 2023
Like Article
Save Article
Similar Reads
Related Tutorials