# Pairs whose concatenation contain all digits

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

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.

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.

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];
for (j = 0; j < x.size(); j++)
mask |= (1 << (x[j] - '0';);

}```

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

 ``
Output
`5`

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

My Personal Notes arrow_drop_up