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.
#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 ( abs (arr[i] - arr[j]) % 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;
} |
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 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 |
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 |
<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> |
3
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach:
Algorithm:
- Convert each elements (A[i]) of the array to ((A[i]+K)%K)
- Use hashing technique to store the number of times (A[i]%K) occurs in the array
- Now, if an element H[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
Below is the implementation of the above approach:
// 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 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 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# 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 |
<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> |
2
Time Complexity: O(n+k)
Auxiliary Space: O(k)
Using unordered map approach:
Suppose we have two numbers x1 and x2 and we want (x1 -x2) to be divisible by k
and we know that if both numbers are divisible by k then if we subtract them they will also be divisible by k
for example K=2 (4-2) is divisible by 2 because ( 4 is divisible by 2 ) and ( 2 is also divisible by 2 ).
so what x%k give us ?? it give us if we add x%k or subtract x%k from that number it will became divisible by k
for example: k=5 and x=2 (5%2) = 1 if we add 1 to 5 it will became 6 which is divisible by 2 and if we subtract 1 from 5 it will became 4 which is also divisible by 2. so what we will do we will check and can i get arr[i]%k from any previous number so that i will add arr[i]%k to my current number and subtract arr[i]%k to my previous number to make both the numbers divisible by k .
for example: [5,7] K=2
5%2 = 1 // subtract one to make it divisible by K
7%2 =1 // needs one to make it divisible by K
or vice versa we will take one from 5 to make it divisible by K
Implementation of the approach:
// 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 map to store pairs unordered_map< int , int > map;
int res = 0;
for ( int i = 0; i < n; ++i) {
// check for remainder is present in the map or not. if (map.find(arr[i] % k) != map.end()) {
res += map[arr[i] % k];
}
map[arr[i] % k]++;
}
//print the answer cout << res;
} // 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;
} //This code is contributed by Prateek Kumar Singh |
// java implimentation import java.util.*;
class Main {
static void countPair( int [] arr, int n, int k)
{
// initialize the map to store pairs
Map<Integer, Integer> map = new HashMap<>();
int res = 0 ;
for ( int i = 0 ; i < n; ++i) {
// check for remainder is present in the map or
// not.
if (map.containsKey(arr[i] % k)) {
res += map.get(arr[i] % k);
}
map.put(arr[i] % k,
map.getOrDefault(arr[i] % k, 0 ) + 1 );
}
// print the answer
System.out.println(res);
}
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);
}
} |
# function to count pairs in an array whose absolute difference is divisible by k def countPair(arr, n, k):
# initialize the dictionary to store pairs
dict = {}
res = 0
for i in range (n):
# check if remainder is present in the dictionary or not.
if arr[i] % k in dict :
res + = dict [arr[i] % k]
dict [arr[i] % k] = dict .get(arr[i] % k, 0 ) + 1
# print the answer
print (res)
# 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)
|
using System;
using System.Collections.Generic;
public 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 dictionary to store pairs
Dictionary< int , int > map = new Dictionary< int , int >();
int res = 0;
for ( int i = 0; i < n; ++i)
{
// check for remainder is present in the dictionary or not.
if (map.ContainsKey(arr[i] % k))
{
res += map[arr[i] % k];
}
if (map.ContainsKey(arr[i] % k))
{
map[arr[i] % k]++;
}
else
{
map.Add(arr[i] % k, 1);
}
}
// print the answer
Console.WriteLine(res);
}
// Driver Code
static void Main()
{
// input array
int [] arr = { 1, 2, 3, 4 };
int k = 2;
// calculate the size of array
int n = arr.Length;
countPair(arr, n, k);
}
} |
// function to count pairs in an array whose absolute difference is divisible by k function countPair(arr, n, k) {
// initialize the object to store pairs
let dict = {};
let res = 0;
for (let i = 0; i < n; i++) {
// check if remainder is present in the object or not.
if (arr[i] % k in dict) {
res += dict[arr[i] % k];
}
dict[arr[i] % k] = (dict[arr[i] % k] || 0) + 1;
}
// print the answer
console.log(res);
} // driver code let arr = [1, 2, 3, 4]; let k = 2; // calculate the size of array let n = arr.length; countPair(arr, n, k); |
2
Time Complexity: O(n)
Auxiliary Space: O(k)
This approach is contributed by Prateek Kumar Singh (pkrsingh025).