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 <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) 
{ 
  
    // 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[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) 
{ 
  
    // 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:

Time Complexity: O(N²)
Space Complexity:O(1)

Efficient Approach:

Algorithm:

Convert each elements (A[i]) of the array to ((A[i]+K)%K)

Use hashing teching technique to store the number of times (A[i]%K) occurs in the array

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 <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) 
{ 
  
    // 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[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) 
{ 
  
    // 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:

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

My Personal Notes

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

C++

Java

Python3

C#

CPP

Java

Python3

C#

Recommended Posts: