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).

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

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:

Time Complexity: O(N²)
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# 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:

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)

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

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

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

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

Explore