Count of pairs of Array elements which are divisible by K when concatenated
Given an array arr[] and an integer K, the task is to count the pair of indices (i, j) such that i !=j and concatenation of a[i] and a[j] is divisible by K.
Example:
Input: arr[] = [4, 5, 2], K = 2
Output: 4
Explanation:
All possible concatenations are {45, 42, 54, 52, 24, 25}.
Out of these, the numbers divisible by 2 are {42, 52, 24, 54}.
Therefore, the count is 4.Input: arr[] =[45, 1, 10, 12, 11, 7], K = 11
Output: 7
Naive Approach:
The simplest approach to solve the problem is as follows:
- Iterate over the array using nested loops with variables i and j.
- Concatenate arr[i] and arr[j], for every i != j, by the equation:
Concatenation of arr[i] and arr[j] = (arr[i] * 10lenj) + arr[j], where lenj is the number of digits in arr[j]
- Check the divisibility of the concatenated number by K.
Concatenated Number is divisible by k if and only if the sum of (arr[j] % k) and ((arr[i] * 10lenj) % k) is 0 mod k.
- For all such pairs of (arr[i], arr[j]), increase count.
- Print the final value of count.
Time complexity: O(N2*len(maxm), where maxm denotes the maximum element in the array and len(maxm) denotes the count of digits of maxm.
Auxiliary Space: O(1)
Efficient Approach:
To optimize the above approach follow the steps below:
- To apply the above formula, maintain a Map for each length from 1 to 10.
- Store {len[a[i]], a[i] % k } in the map.
- To count the pairs, for each j in [1, 10], increase the count by the frequency of (k – ((arr[i] * 10^j) % k)) stored in the Map as {j, k – ((arr[i] * 10^j) % k)} mapping.
- If the pair (arr[i], arr[i]) is counted, decrease the count by 1.
- After complete traversal of the array, print the final count.
Below is the implementation of the above approach:
C++
// C++ Program to count pairs // of array elements which are // divisible by K when concatenated #include <bits/stdc++.h> using namespace std; map< int , int > rem[11]; // Function to calculate and return the // count of pairs int countPairs(vector< int > a, int n, int k) { vector< int > len(n); // Compute power of 10 modulo k vector< int > p(11); p[0] = 1; for ( int i = 1; i <= 10; i++) { p[i] = (p[i - 1] * 10) % k; } for ( int i = 0; i < n; i++) { int x = a[i]; // Calculate length of a[i] while (x > 0) { len[i]++; x /= 10; } // Increase count of remainder rem[len[i]][a[i] % k]++; } int ans = 0; for ( int i = 0; i < n; i++) { for ( int j = 1; j <= 10; j++) { // Calculate (a[i]* 10^lenj) % k int r = (a[i] * p[j]) % k; // Calculate (k - (a[i]* 10^lenj)% k) % k int xr = (k - r) % k; // Increase answer by count ans += rem[j][xr]; // If a pair (a[i], a[i]) is counted if (len[i] == j && (r + a[i] % k) % k == 0) ans--; } } // Return the count of pairs return ans; } // Driver Code int main() { vector< int > a = { 4, 5, 2 }; int n = a.size(), k = 2; cout << countPairs(a, n, k); } |
Java
// Java program to count pairs // of array elements which are // divisible by K when concatenated import java.util.*; import java.lang.*; class GFG{ static int [][] rem = new int [ 11 ][ 11 ]; // Function to calculate and return the // count of pairs static int countPairs( int [] a, int n, int k) { int [] len = new int [n]; // Compute power of 10 modulo k int [] p = new int [ 11 ]; p[ 0 ] = 1 ; for ( int i = 1 ; i <= 10 ; i++) { p[i] = (p[i - 1 ] * 10 ) % k; } for ( int i = 0 ; i < n; i++) { int x = a[i]; // Calculate length of a[i] while (x > 0 ) { len[i]++; x /= 10 ; } // Increase count of remainder rem[len[i]][a[i] % k]++; } int ans = 0 ; for ( int i = 0 ; i < n; i++) { for ( int j = 1 ; j <= 10 ; j++) { // Calculate (a[i]* 10^lenj) % k int r = (a[i] * p[j]) % k; // Calculate (k - (a[i]* 10^lenj)% k) % k int xr = (k - r) % k; // Increase answer by count ans += rem[j][xr]; // If a pair (a[i], a[i]) is counted if (len[i] == j && (r + a[i] % k) % k == 0 ) ans--; } } // Return the count of pairs return ans; } // Driver code public static void main (String[] args) { int [] a = { 4 , 5 , 2 }; int n = a.length, k = 2 ; System.out.println(countPairs(a, n, k)); } } // This code is contributed by offbeat |
Python3
# Python3 program to count pairs # of array elements which are # divisible by K when concatenated rem = [ [ 0 for x in range ( 11 ) ] for y in range ( 11 ) ] # Function to calculate and return the # count of pairs def countPairs(a, n, k): l = [ 0 ] * n # Compute power of 10 modulo k p = [ 0 ] * ( 11 ) p[ 0 ] = 1 for i in range ( 1 , 11 ): p[i] = (p[i - 1 ] * 10 ) % k for i in range (n): x = a[i] # Calculate length of a[i] while (x > 0 ): l[i] + = 1 x / / = 10 # Increase count of remainder rem[l[i]][a[i] % k] + = 1 ans = 0 for i in range (n): for j in range ( 1 , 11 ): # Calculate (a[i]* 10^lenj) % k r = (a[i] * p[j]) % k # Calculate (k - (a[i]* 10^lenj)% k) % k xr = (k - r) % k # Increase answer by count ans + = rem[j][xr] # If a pair (a[i], a[i]) is counted if (l[i] = = j and (r + a[i] % k) % k = = 0 ): ans - = 1 # Return the count of pairs return ans # Driver Code a = [ 4 , 5 , 2 ] n = len (a) k = 2 print (countPairs(a, n, k)) # This code is contributed by chitranayal |
C#
// C# program to count pairs // of array elements which are // divisible by K when concatenated using System; class GFG{ static int [,]rem = new int [11, 11]; // Function to calculate and // return the count of pairs static int countPairs( int [] a, int n, int k) { int [] len = new int [n]; // Compute power of 10 modulo k int [] p = new int [11]; p[0] = 1; for ( int i = 1; i <= 10; i++) { p[i] = (p[i - 1] * 10) % k; } for ( int i = 0; i < n; i++) { int x = a[i]; // Calculate length of a[i] while (x > 0) { len[i]++; x /= 10; } // Increase count of remainder rem[len[i], a[i] % k]++; } int ans = 0; for ( int i = 0; i < n; i++) { for ( int j = 1; j <= 10; j++) { // Calculate (a[i]* 10^lenj) % k int r = (a[i] * p[j]) % k; // Calculate (k - (a[i]* 10^lenj)% k) % k int xr = (k - r) % k; // Increase answer by count ans += rem[j, xr]; // If a pair (a[i], a[i]) is counted if (len[i] == j && (r + a[i] % k) % k == 0) ans--; } } // Return the count of pairs return ans; } // Driver code public static void Main( string [] args) { int [] a = {4, 5, 2}; int n = a.Length, k = 2; Console.Write(countPairs(a, n, k)); } } // This code is contributed by rutvik_56 |
Javascript
<script> // JavaScript program to count pairs // of array elements which are // divisible by K when concatenated let rem = new Array(11); // Loop to create 2D array using 1D array for ( var i = 0; i < rem.length; i++) { rem[i] = new Array(2); } for ( var i = 0; i < rem.length; i++) { for ( var j = 0; j < rem.length; j++) { rem[i][j] = 0; } } // Function to calculate and return the // count of pairs function countPairs(a, n, k) { let len = Array.from({length: n}, (_, i) => 0); // Compute power of 10 modulo k let p = Array.from({length: 11}, (_, i) => 0); p[0] = 1; for (let i = 1; i <= 10; i++) { p[i] = (p[i - 1] * 10) % k; } for (let i = 0; i < n; i++) { let x = a[i]; // Calculate length of a[i] while (x > 0) { len[i]++; x = Math.floor(x / 10); } // Increase count of remainder rem[len[i]][a[i] % k]++; } let ans = 0; for (let i = 0; i < n; i++) { for (let j = 1; j <= 10; j++) { // Calculate (a[i]* 10^lenj) % k let r = (a[i] * p[j]) % k; // Calculate (k - (a[i]* 10^lenj)% k) % k let xr = (k - r) % k; // Increase answer by count ans += rem[j][xr]; // If a pair (a[i], a[i]) is counted if (len[i] == j && (r + a[i] % k) % k == 0) ans--; } } // Return the count of pairs return ans; } // Driver Code let a = [ 4, 5, 2 ]; let n = a.length, k = 2; document.write(countPairs(a, n, k)); </script> |
4
Time Complexity: O(N * len(maxm))
Auxiliary Space: O(N)