Skip to content
Related Articles

Related Articles

Count pairs in an array whose absolute difference is divisible by K
  • Difficulty Level : Medium
  • Last Updated : 21 Apr, 2021

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)
{
 
    // 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
Javascript



<script>
 
// Function to count pairs in an array
// whose absolute difference is
// divisible by k
function countPairs(arr, n, k)
{
     
    // Initilize 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) 
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
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)
{
 
    // 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: 
2
 
Time Complexity: O(n+k) 
Auxiliary Space: O(k)
 
My Personal Notes
arrow_drop_up
Previous
Huffman Coding using Priority Queue
Next

Adaptive Huffman Coding And Decoding
Recommended Articles
Page :
Length of longest subsequence having absolute difference of all pairs divisible by K
14, Oct 20
Count pairs in array whose sum is divisible by 4
08, Dec 17
Count pairs in array whose sum is divisible by K
11, Mar 19
Count maximum elements of an array whose absolute difference does not exceed K
12, Mar 19
Count the number of pairs (i, j) such that either arr[i] is divisible by arr[j] or arr[j] is divisible by arr[i]
01, Apr 19
Count of subarrays of size K having at least one pair with absolute difference divisible by K-1
30, Jun 20
Count of all pairs in an Array with minimum absolute difference
10, Jul 20
Count pairs in an array such that the absolute difference between them is ≥ K
12, Jul 19
Count Non-Repeating array elements after inserting absolute difference between all possible pairs
17, Jan 21
Count all disjoint pairs having absolute difference at least K from a given array
25, Oct 20
Count of elements whose absolute difference with the sum of all the other elements is greater than k
15, Apr 19
Check if an array can be divided into pairs whose sum is divisible by k
02, Nov 15
Find K elements whose absolute difference with median of array is maximum
20, Jun 20
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Remaining array element after repeated removal of the smallest element from pairs with absolute difference of 2 or 0
09, Feb 21
Make all array elements equal by repeated subtraction of absolute difference of pairs from their maximum
16, Sep 20
Minimum value of maximum absolute difference of all adjacent pairs in an Array
07, Apr 20
Calculate absolute difference between minimum and maximum sum of pairs in an array
10, Mar 21
Minimize remaining array element by removing pairs and replacing them by their absolute difference
04, Dec 20
Maximum distance between two elements whose absolute difference is K
15, Aug 20
Count elements in first Array with absolute difference greater than K with an element in second Array
05, May 20
Count ways to construct array with even product from given array such that absolute difference of same indexed elements is at most 1
04, Jan 21
Sum of absolute difference of all pairs raised to power K
20, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rrlinus
@rrlinus
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox