Pairs whose concatenation contain all digits

Last Updated : 16 Dec, 2022

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.
import java.io.*;
public 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)

Comment

Explore