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.
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 ( 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; } |
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> |
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:
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> |
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:
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 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
// 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); } } |
Python3
# 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) |
C#
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); } } |
Javascript
// 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).
Please Login to comment...