Skip to content
Related Articles

Related Articles

Count pairs in an array whose absolute difference is divisible by K
  • Difficulty Level : Medium
  • Last Updated : 27 Feb, 2020

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++

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


Java

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


Python3

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


C#

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

CPP

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


Java

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


Python3

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


C#

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :