Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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: 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>
Output
4
Time Complexity: O(N * len(maxm)) 
Auxiliary Space: O(N)

My Personal Notes
arrow_drop_up
Next

Number of pairs in an array having sum equal to product
Recommended Articles
Page :
Maximum Pairs of Bracket Sequences which can be concatenated to form a Regular Bracket Sequence
07, Jul 21
Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
28, May 19
Count of pairs in a given range with sum of their product and sum equal to their concatenated number
14, Jun 20
Count the number of pairs (i, j) such that either arr[i] is divisible by arr[j] or arr[j] is divisible by arr[i]
01, Apr 19
Count of strings to be concatenated with a character having frequency greater than sum of others
18, Nov 21
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Find the K-th minimum element from an array concatenated M times
06, Mar 19
Count the number of elements in an array which are divisible by k
15, Nov 18
Find permutation of n which is divisible by 3 but not divisible by 6
13, Nov 18
Nth character in Concatenated Decimal String
27, Dec 16
Reorder the given string to form a K-concatenated string
09, Jul 18
Maximum number of times a given string needs to be concatenated to form a substring of another string
14, Dec 20
Concatenated string with uncommon characters of two strings
02, Sep 17
Print the final string when minimum value strings get concatenated in every operation
25, Apr 19
Count of elements on the left which are divisible by current element
15, Oct 19
Count of elements on the left which are divisible by current element | Set 2
30, Jun 20
Maximize the number of sum pairs which are divisible by K
09, Mar 19
Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K
19, Apr 21
Find numbers in between [L, R] which are divisible by all Array elements
26, Dec 21
Count of elements not divisible by any other elements of Array
20, Jun 20
Count of elements in given Array divisible by all elements in their prefix
11, Jan 22
Count all prefixes of the given binary array which are divisible by x
03, Apr 19
Count divisible pairs in an array
30, Apr 18
Count number of pairs in array having sum divisible by K | SET 2
14, Aug 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rohitpal210
@rohitpal210
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!