Skip to content
Related Articles

Related Articles

Improve Article

Pairs whose concatenation contain all digits

  • Difficulty Level : Hard
  • Last Updated : 11 May, 2021
Geek Week

Given an array of n numbers. The task is to find the number of pairs that can be taken from the given which on concatenation will contain all the digits from 0 to 9.
Examples: 

Input : num[][] = { “129300455”, “5559948277”, “012334556”, “56789”, “123456879” } 
Output : 5 
{“129300455”, “56789”}, { “129300455”, “123456879”}, {“5559948277”, “012334556”}, 
{“012334556”, “56789”}, {“012334556”, “123456879”} are the pair which contain all the digits from 0 to 9 on concatenation.

Note: The number of the digit in each of the numbers can be 10^6.

The idea is to represent each number as the mask of 10 bits such that if it contains digit i at least once then ith bit will be set in the mask. 
For example, 
let n = 4556120 then 0th, 1st, 2nd, 4th, 5th, 6th bits will be set in the mask. 
Thus, mask = (0001110111)2 = (119)10 
Now, for every mask m from 0 to 2^10 – 1, we will store the count of the number of numbers having the mask of their number equals to m
So, we will make an array, say cnt[], where cnt[i] stores the count of the number of numbers whose mask is equal to i. Pseudocode for this: 
 

for (i = 0; i < (1 << 10); i++)
  cnt[i] = 0;

for (i = 1; i <= n; i++)
{
  string x = p[i];
  int mask  = 0;
  for (j = 0; j < x.size(); j++)  
    mask |= (1 << (x[j] - '0';);
  
  
  cnt[mask]++;
}

A pair of numbers will have all the digit from 0 to 9 if every bit from 0 to 9 is set in the bitwise OR of maskof both the number, i.e if it’s equal to (1111111111)2</sub) = (1023)10
 



Now, we will iterate over all pairs of masks whose bitwise OR is equal to 1023 and add a number of ways.
Below is the implementation of this approach: 
 

C++




// C++ Program to find number of pairs whose
// concatenation contains all digits from 0 to 9.
#include <bits/stdc++.h>
using namespace std;
#define N 20
 
// Function to return number of pairs whose
// concatenation contain all digits from 0 to 9
int countPair(char str[N][N], int n)
{
    int cnt[1 << 10] = { 0 };
 
    // making the mask for each of the number.
    for (int i = 0; i < n; i++) {
 
        int mask = 0;
        for (int j = 0; str[i][j] != '\0'; ++j)
            mask |= (1 << (str[i][j] - '0'));       
        cnt[mask]++;
    }
    
    // for each of the possible pair which can
    // make OR value equal to 1023
    int ans = 0;
    for (int m1 = 0; m1 <= 1023; m1++)
        for (int m2 = 0; m2 <= 1023; m2++)
            if ((m1 | m2) == 1023) {
 
                // finding the count of pair
                // from the given numbers.
                ans += ((m1 == m2) ?
                       (cnt[m1] * (cnt[m1] - 1)) :
                       (cnt[m1] * cnt[m2]));
            }
 
    return ans / 2;
}
 
// Driven Program
int main()
{
    int n = 5;
    char str[][N] = { "129300455", "5559948277",
               "012334556", "56789", "123456879" };
    cout << countPair(str, n) << endl;
    return 0;
}

Java




// Java Program to find number of pairs whose
// concatenation contains all digits from 0 to 9.
class GFG
{
    static final int N = 20;
 
    // Function to return number of pairs whose
    // concatenation contain all digits from 0 to 9
    static int countPair(char str[][], int n)
    {
        int[] cnt = new int[1 << 10];
 
        // making the mask for each of the number.
        for (int i = 0; i < n; i++)
        {
            int mask = 0;
            for (int j = 0; j < str[i].length; ++j)
                mask |= (1 << (str[i][j] - '0'));
            cnt[mask]++;
        }
 
        // for each of the possible pair which can
        // make OR value equal to 1023
        int ans = 0;
        for (int m1 = 0; m1 <= 1023; m1++)
            for (int m2 = 0; m2 <= 1023; m2++)
                if ((m1 | m2) == 1023)
                {
 
                    // finding the count of pair
                    // from the given numbers.
                    ans += ((m1 == m2) ? (cnt[m1] * (cnt[m1] - 1)) :
                                          (cnt[m1] * cnt[m2]));
                }
        return ans / 2;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 5;
        char str[][] = { "129300455".toCharArray(),
                         "5559948277".toCharArray(),
                         "012334556".toCharArray(),
                         "56789".toCharArray(),
                         "123456879".toCharArray() };
        System.out.print(countPair(str, n) + "\n");
    }
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python3 Program to find
# number of pairs whose
# concatenation contains
# all digits from 0 to 9.
N = 20
 
# Function to return number
# of pairs whose concatenation
# contain all digits from 0 to 9
def countPair(st, n):
 
    cnt = [0] * (1 << 10)
 
    # Making the mask for
    # each of the number.
    for i in range (n):
        mask = 0
        for j in range (len(st[i])):
            mask |= (1 << (ord(st[i][j]) - ord('0')))      
        cnt[mask] += 1
     
    # for each of the possible
    # pair which can make OR
    # value equal to 1023
    ans = 0
    for m1 in range(1024):
        for m2 in range (1024):
            if ((m1 | m2) == 1023):
 
                # Finding the count of pair
                # from the given numbers.
                if (m1 == m2):
                      ans += (cnt[m1] * (cnt[m1] - 1))
                else:
                      ans += (cnt[m1] * cnt[m2])
            
    return ans // 2
 
# Driven Program
if __name__ == "__main__":
 
    n = 5
    st = ["129300455", "5559948277",
          "012334556", "56789", "123456879"]
    print(countPair(st, n))
     
# This code is contributed by Chitranayal

C#




// C# Program to find number of pairs whose
// concatenation contains all digits from 0 to 9.
using System;
 
class GFG
{
    static readonly int N = 20;
 
    // Function to return number of pairs whose
    // concatenation contain all digits from 0 to 9
    static int countPair(String []str, int n)
    {
        int[] cnt = new int[1 << 10];
 
        // making the mask for each of the number.
        for (int i = 0; i < n; i++)
        {
            int mask = 0;
            for (int j = 0; j < str[i].Length; ++j)
                mask |= (1 << (str[i][j] - '0'));
            cnt[mask]++;
        }
 
        // for each of the possible pair which can
        // make OR value equal to 1023
        int ans = 0;
        for (int m1 = 0; m1 <= 1023; m1++)
            for (int m2 = 0; m2 <= 1023; m2++)
                if ((m1 | m2) == 1023)
                {
 
                    // finding the count of pair
                    // from the given numbers.
                    ans += ((m1 == m2) ? (cnt[m1] * (cnt[m1] - 1)) :
                                         (cnt[m1] * cnt[m2]));
                }
        return ans / 2;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 5;
        String []str = {"129300455",
                        "5559948277",
                        "012334556",
                        "56789",
                        "123456879" };
        Console.Write(countPair(str, n) + "\n");
    }
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
// Javascript Program to find number of pairs whose
// concatenation contains all digits from 0 to 9.
     
    let N = 20;
     
    // Function to return number of pairs whose
    // concatenation contain all digits from 0 to 9
    function countPair(str,n)
    {
        let cnt = new Array(1 << 10);
        for(let i=0;i<cnt.length;i++)
        {
            cnt[i]=0;
        }
  
        // making the mask for each of the number.
        for (let i = 0; i < n; i++)
        {
            let mask = 0;
            for (let j = 0; j < str[i].length; ++j)
                mask |= (1 << (str[i][j] - '0'));
            cnt[mask]++;
        }
  
        // for each of the possible pair which can
        // make OR value equal to 1023
        let ans = 0;
        for (let m1 = 0; m1 <= 1023; m1++)
            for (let m2 = 0; m2 <= 1023; m2++)
                if ((m1 | m2) == 1023)
                {
  
                    // finding the count of pair
                    // from the given numbers.
                    ans += ((m1 == m2) ? (cnt[m1] * (cnt[m1] - 1)) :
                                          (cnt[m1] * cnt[m2]));
                }
        return Math.floor(ans / 2);
    }
     
    // Driver Code
    let n = 5;
    let st = ["129300455", "5559948277",
          "012334556", "56789", "123456879"];
    document.write(countPair(st, n))    
     
    // This code is contributed by avanitrachhadiya2155
</script>
Output
5

Complexity : O(n + 2^10 * 2^10)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :