# Count of pairs of Array elements which are divisible by K when concatenated

• Difficulty Level : Hard
• Last Updated : 01 Sep, 2021

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:
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:

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 ``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

 ``
Output
`4`

Time Complexity: O(N * len(maxm))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up