Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 24 Feb, 2022

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



// 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: 
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 :
Count pairs in an array whose absolute difference is divisible by K | Using Map
10, Nov 21
Minimize sum of absolute difference between all pairs of array elements by decrementing and incrementing pairs by 1
30, Jul 21
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 K
11, Mar 19
Count pairs in Array whose product is divisible by K
08, Mar 22
Count pairs in array whose sum is divisible by 4
08, Dec 17
Count of pairs in Array whose product is divisible by K
15, Mar 22
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 pairs in an array such that the absolute difference between them is ≥ K
12, Jul 19
Count of all pairs in an Array with minimum absolute difference
10, Jul 20
Count all disjoint pairs having absolute difference at least K from a given array
25, Oct 20
Count Non-Repeating array elements after inserting absolute difference between all possible pairs
17, Jan 21
Count pairs from an array with absolute difference not less than the minimum element in the pair
29, Jul 21
Count of subarrays of size K having at least one pair with absolute difference divisible by K-1
30, Jun 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
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Find K elements whose absolute difference with median of array is maximum
20, Jun 20
Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices
07, Jul 21
Maximize Array sum by subtracting absolute of odd and adding absolute of even elements
24, Mar 22
Minimum value of maximum absolute difference of all adjacent pairs in an Array
07, Apr 20
Make all array elements equal by repeated subtraction of absolute difference of pairs from their maximum
16, Sep 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

Start Your Coding Journey Now!