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++
#include <bits/stdc++.h>
using namespace std;
map<int, int> rem[11];
int countPairs(vector<int> a, int n, int k)
{
vector<int> len(n);
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];
while (x > 0) {
len[i]++;
x /= 10;
}
rem[len[i]][a[i] % k]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10; j++) {
int r = (a[i] * p[j]) % k;
int xr = (k - r) % k;
ans += rem[j][xr];
if (len[i] == j
&& (r + a[i] % k) % k == 0)
ans--;
}
}
return ans;
}
int main()
{
vector<int> a = { 4, 5, 2 };
int n = a.size(), k = 2;
cout << countPairs(a, n, k);
}
|
Java
import java.util.*;
import java.lang.*;
class GFG{
static int[][] rem = new int[11][11];
static int countPairs(int[] a, int n, int k)
{
int[] len = new int[n];
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];
while (x > 0)
{
len[i]++;
x /= 10;
}
rem[len[i]][a[i] % k]++;
}
int ans = 0;
for(int i = 0; i < n; i++)
{
for(int j = 1; j <= 10; j++)
{
int r = (a[i] * p[j]) % k;
int xr = (k - r) % k;
ans += rem[j][xr];
if (len[i] == j &&
(r + a[i] % k) % k == 0)
ans--;
}
}
return ans;
}
public static void main (String[] args)
{
int[] a = { 4, 5, 2 };
int n = a.length, k = 2;
System.out.println(countPairs(a, n, k));
}
}
|
Python3
rem = [ [ 0 for x in range(11) ]
for y in range(11) ]
def countPairs(a, n, k):
l = [0] * n
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]
while (x > 0):
l[i] += 1
x //= 10
rem[l[i]][a[i] % k] += 1
ans = 0
for i in range(n):
for j in range(1, 11):
r = (a[i] * p[j]) % k
xr = (k - r) % k
ans += rem[j][xr]
if (l[i] == j and
(r + a[i] % k) % k == 0):
ans -= 1
return ans
a = [ 4, 5, 2 ]
n = len(a)
k = 2
print(countPairs(a, n, k))
|
C#
using System;
class GFG{
static int [,]rem = new int[11, 11];
static int countPairs(int[] a,
int n, int k)
{
int[] len = new int[n];
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];
while (x > 0)
{
len[i]++;
x /= 10;
}
rem[len[i], a[i] % k]++;
}
int ans = 0;
for(int i = 0; i < n; i++)
{
for(int j = 1; j <= 10; j++)
{
int r = (a[i] * p[j]) % k;
int xr = (k - r) % k;
ans += rem[j, xr];
if (len[i] == j &&
(r + a[i] % k) % k == 0)
ans--;
}
}
return ans;
}
public static void Main(string[] args)
{
int[] a = {4, 5, 2};
int n = a.Length, k = 2;
Console.Write(countPairs(a, n, k));
}
}
|
Javascript
<script>
let rem = new Array(11);
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 countPairs(a, n, k)
{
let len = Array.from({length: n}, (_, i) => 0);
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];
while (x > 0)
{
len[i]++;
x = Math.floor(x / 10);
}
rem[len[i]][a[i] % k]++;
}
let ans = 0;
for(let i = 0; i < n; i++)
{
for(let j = 1; j <= 10; j++)
{
let r = (a[i] * p[j]) % k;
let xr = (k - r) % k;
ans += rem[j][xr];
if (len[i] == j &&
(r + a[i] % k) % k == 0)
ans--;
}
}
return ans;
}
let a = [ 4, 5, 2 ];
let n = a.length, k = 2;
document.write(countPairs(a, n, k));
</script>
|
Time Complexity: O(N * len(maxm))
Auxiliary Space: O(N)