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.

filter_none

edit
close

play_arrow

link
brightness_4
code

#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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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
chevron_right

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
filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

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.




Recommended Posts:


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 :