计算数组中具有至少一位公共数字的对

给定一个N个数字的数组。找出对i和j的对数，以使i i和A _j具有至少一位数字共同(例如(11，19)具有1位数字共同但(36，48)没有数字共同)

例子：

Input: A[] = { 10, 12, 24 } 
Output: 2 
Explanation: Two valid pairs are (10, 12) and (12, 24) which have atleast one digit common 

方法1(强力)解决此问题的一种简单方法是仅运行两个嵌套循环并考虑所有可能的对。我们可以通过提取第一个数字的每个数字并尝试在提取的第二个数字的数字中查找两个数字是否至少有一个公共数字。我们只需将它们转换为字符串，任务就会变得容易得多。

下面是上述方法的实现：

C++

// CPP Program to count pairs in an array
// with some common digit
#include 
 
using namespace std;
 
// Returns true if the pair is valid,
// otherwise false
bool checkValidPair(int num1, int num2)
{
    // converting integers to strings
    string s1 = to_string(num1);
    string s2 = to_string(num2);
 
    // Iterate over the strings and check
    // if a character in first string is also
    // present in second string, return true
    for (int i = 0; i < s1.size(); i++)
        for (int j = 0; j < s2.size(); j++)
            if (s1[i] == s2[j])
                return true;
 
    // No common digit found
    return false;
}
 
// Returns the number of valid pairs
int countPairs(int arr[], int n)
{
    int numberOfPairs = 0;
 
    // Iterate over all possible pairs
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (checkValidPair(arr[i], arr[j]))
                numberOfPairs++;
 
    return numberOfPairs;
}
 
// Driver Code to test above functions
int main()
{
    int arr[] = { 10, 12, 24 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << countPairs(arr, n) << endl;
    return 0;
}

Java

// Java Program to count
// pairs in an array
// with some common digit
import java.io.*;
 
class GFG
{
     
    // Returns true if the pair
    // is valid, otherwise false
    static boolean checkValidPair(int num1,
                                  int num2)
    {
        // converting integers
        // to strings
        String s1 = Integer.toString(num1);
        String s2 = Integer.toString(num2);
     
        // Iterate over the strings
        // and check if a character
        // in first string is also
        // present in second string,
        // return true
        for (int i = 0; i < s1.length(); i++)
            for (int j = 0; j < s2.length(); j++)
                if (s1.charAt(i) == s2.charAt(j))
                    return true;
     
        // No common
        // digit found
        return false;
    }
     
    // Returns the number
    // of valid pairs
    static int countPairs(int []arr, int n)
    {
        int numberOfPairs = 0;
     
        // Iterate over all
        // possible pairs
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j < n; j++)
                if (checkValidPair(arr[i], arr[j]))
                    numberOfPairs++;
     
        return numberOfPairs;
    }
     
    // Driver Code
    public static void main(String args[])
    {
        int []arr = new int[]{ 10, 12, 24 };
        int n = arr.length;
        System.out.print(countPairs(arr, n));
    }
}
 
// This code is contributed
// by manish shaw.

Python3

# Python3 Program to count pairs in
# an array with some common digit
 
# Returns true if the pair is
# valid, otherwise false
def checkValidPair(num1, num2) :
     
    # converting integers to strings
    s1 = str(num1)
    s2 = str(num2)
 
    # Iterate over the strings and check if
    # a character in first string is also
    # present in second string, return true
    for i in range(len(s1)) :
        for j in range(len(s2)) :
            if (s1[i] == s2[j]) :
                return True;
 
    # No common digit found
    return False;
 
# Returns the number of valid pairs
def countPairs(arr, n) :
     
    numberOfPairs = 0
 
    # Iterate over all possible pairs
    for i in range(n) :
        for j in range(i + 1, n) :
            if (checkValidPair(arr[i], arr[j])) :
                numberOfPairs += 1
 
    return numberOfPairs
 
# Driver Code
if __name__ == "__main__" :
    arr = [ 10, 12, 24 ]
    n = len(arr)
    print(countPairs(arr, n))
 
# This code is contributed by Ryuga

C#

// C# Program to count pairs in an array
// with some common digit
using System;
 
class GFG {
     
    // Returns true if the pair is valid,
    // otherwise false
    static bool checkValidPair(int num1, int num2)
    {
        // converting integers to strings
        string s1 = num1.ToString();
        string s2 = num2.ToString();
     
        // Iterate over the strings and check
        // if a character in first string is also
        // present in second string, return true
        for (int i = 0; i < s1.Length; i++)
            for (int j = 0; j < s2.Length; j++)
                if (s1[i] == s2[j])
                    return true;
     
        // No common digit found
        return false;
    }
     
    // Returns the number of valid pairs
    static int countPairs(int []arr, int n)
    {
        int numberOfPairs = 0;
     
        // Iterate over all possible pairs
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j < n; j++)
                if (checkValidPair(arr[i], arr[j]))
                    numberOfPairs++;
     
        return numberOfPairs;
    }
     
    // Driver Code to test above functions
    static void Main()
    {
        int []arr = new int[]{ 10, 12, 24 };
        int n = arr.Length;
        Console.WriteLine(countPairs(arr, n));
    }
}
 
// This code is contributed by manish shaw.

输出

2

时间复杂度： O(N ² )其中N是数组的大小。

方法2(位掩码)：解决此问题的有效方法是为特定数字中存在的每个数字创建位掩码。因此，如果掩码中包含1111111111，则对于每个数字中出现的每个数字。

Digits -  0  1  2  3  4  5  6  7  8  9
          |  |  |  |  |  |  |  |  |  |
Mask   -  1  1  1  1  1  1  1  1  1  1 

Here 1 denotes that the corresponding ith digit is set. 
For e.g. 1235 can be represented as
Digits -         0  1  2  3  4  5  6  7  8  9
                 |  |  |  |  |  |  |  |  |  |
Mask for 1235 -  0  1  1  1  0  1  0  0  0  0

现在，我们只需要提取数字的每个数字并设置相应的位(1 <<^第i^个数字)，然后将整个数字存储为掩码即可。仔细的分析表明，掩码的最大值为十进制的1023(其中包含从0到9的所有数字)。由于同一组数字可以存在多个数字，因此我们需要维护一个频率数组来存储掩码值的计数。

Let the frequencies of two masks i and j be freq_i and freq_j respectively, 
If(i AND j) return true, means i_th and j_th mask contains atleast one common set bit which in turn implies that the numbers from which these masks have been built also contain a common digit 
then, 
increment the answer 
ans += freq_i * freq_j [ if i != j ] 
ans += (freq_i * (freq_i – 1)) / 2 [ if j == i ]  

以下是此有效方法的实现：

C++

// CPP Program to count pairs in an array with
// some common digit
#include 
using namespace std;
 
// This function calculates the mask frequencies
// for every present in the array
void calculateMaskFrequencies(int arr[], int n,
                 unordered_map& freq)
{
    // Iterate over the array
    for (int i = 0; i < n; i++) {
 
        int num = arr[i];
 
        // Creating an empty mask
        int mask = 0;
 
        // Extracting every digit of the number
        // and updating corresponding bit in the
        // mask
        while (num > 0) {
            mask = mask | (1 << (num % 10));
            num /= 10;
        }
 
        // Update the frequency array
        freq[mask]++;
    }
}
 
// Function return the number of valid pairs
int countPairs(int arr[], int n)
{
    // Store the mask frequencies
    unordered_map freq;
 
    calculateMaskFrequencies(arr, n, freq);
 
    long long int numberOfPairs = 0;
 
    // Considering every possible pair of masks
    // and calculate pairs according to their
    // frequencies
    for (int i = 0; i < 1024; i++) {
        numberOfPairs += (freq[i] * (freq[i] - 1)) / 2;
        for (int j = i + 1; j < 1024; j++) {
 
            // if it contains a common digit
            if (i & j)
                numberOfPairs += (freq[i] * freq[j]);
        }
    }
    return numberOfPairs;
}
 
// Driver Code to test above functions
int main()
{
    int arr[] = { 10, 12, 24 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << countPairs(arr, n) << endl;
    return 0;
}

Java

// Java Program to count pairs in an array with
// some common digit
import java.io.*;
import java.util.*;
class GFG
{
 
  // Store the mask frequencies
  public static Map freq = new HashMap();
 
  // This function calculates the mask frequencies
  // for every present in the array
  public static void calculateMaskFrequencies(int[] arr,int n)
  {
 
    // Iterate over the array
    for(int i = 0; i < n; i++)
    {
      int num = arr[i];
 
      // Creating an empty mask
      int mask = 0;
 
      // Extracting every digit of the number
      // and updating corresponding bit in the
      // mask
      while(num > 0)
      {
        mask = mask | (1 << (num % 10));
        num /= 10;
      }
 
      // Update the frequency array
      if(freq.containsKey(mask))
      {
        freq.put(new Integer(mask), freq.get(mask) + 1);
      }
      else
      {
        freq.put(new Integer(mask), 1);
      }
    }
  }
 
  // Function return the number of valid pairs
  public static int countPairs(int[] arr, int n)
  {
    calculateMaskFrequencies(arr, n);
    int numberOfPairs = 0;
 
    // Considering every possible pair of masks
    // and calculate pairs according to their
    // frequencies
    for(int i = 0; i < 1024; i++)
    {
      int x = 0;
      if(freq.containsKey(i))
      {
        x = freq.get(i);
 
      }
      numberOfPairs += ((x) * (x - 1)) / 2;
      for(int j = i + 1; j < 1024; j++)
      {
        int y = 0;
 
        // if it contains a common digit
        if((i & j) != 0)
        {
          if(freq.containsKey(j))
          {
            y = freq.get(j);
          }
          numberOfPairs += x * y;
        }
      }
    }
    return numberOfPairs;
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int[] arr = {10, 12, 24};
    int n = arr.length;       
    System.out.println(countPairs(arr, n));
  }
}
 
// This code is contributed by avanitrachhadiya2155

Python3

# Python3 Program to count pairs in an array
# with some common digit
 
# This function calculates the mask frequencies
# for every present in the array
def calculateMaskFrequencies(arr, n, freq):
     
    # Iterate over the array
    for i in range(n):
 
        num = arr[i]
 
        # Creating an empty mask
        mask = 0
 
        # Extracting every digit of the number
        # and updating corresponding bit in the
        # mask
        while (num > 0):
            mask = mask | (1 << (num % 10))
            num //= 10
         
        # Update the frequency array
        freq[mask] = freq.get(mask, 0) + 1
     
# Function return the number of valid pairs
def countPairs(arr, n):
     
    # Store the mask frequencies
    freq = dict()
 
    calculateMaskFrequencies(arr, n, freq)
 
    numberOfPairs = 0
 
    # Considering every possible pair of masks
    # and calculate pairs according to their
    # frequencies
    for i in range(1024):
 
        x = 0
 
        if i in freq.keys():
            x = freq[i]
 
        numberOfPairs += (x * (x - 1)) // 2
 
        for j in range(i + 1, 1024):
 
            y = 0
 
            if j in freq.keys():
                y = freq[j]
                 
            # if it contains a common digit
            if (i & j):
                numberOfPairs += (x * y)
         
    return numberOfPairs
 
# Driver Code
arr = [10, 12, 24]
n = len(arr)
print(countPairs(arr, n))
 
# This code is contributed by mohit kumar

C＃

// C# Program to count pairs in an array with
// some common digit
using System;
using System.Collections.Generic;
 
public class GFG
{
   
    // Store the mask frequencies
    static Dictionary freq =  new Dictionary();
     
    // This function calculates the mask frequencies
    // for every present in the array
    public static void calculateMaskFrequencies(int[] arr,int n)
    {
       
        // Iterate over the array
        for(int i = 0; i < n; i++)
        {
            int num = arr[i];
  
            // Creating an empty mask
            int mask = 0;
  
            // Extracting every digit of the number
            // and updating corresponding bit in the
            // mask
            while(num > 0)
            {
                mask = mask | (1 << (num % 10));
                num /= 10;
            }
  
            // Update the frequency array
            if(freq.ContainsKey(mask))
            {
                freq[mask]++;
            }
            else
            {
                freq.Add(mask, 1);
            }
        }
         
    }
    public static int countPairs(int[] arr, int n)
    {
        calculateMaskFrequencies(arr, n);
        int numberOfPairs = 0;
  
        // Considering every possible pair of masks
        // and calculate pairs according to their
        // frequencies
        for(int i = 0; i < 1024; i++)
        {
            int x = 0;
            if(freq.ContainsKey(i))
            {
                x = freq[i];
  
            }
            numberOfPairs += ((x) * (x - 1)) / 2;
            for(int j = i + 1; j < 1024; j++)
            {
                int y = 0;
  
                // if it contains a common digit
                if((i & j) != 0)
                {  
                    if(freq.ContainsKey(j))
                    {
                        y = freq[j];
                    }
                    numberOfPairs += x * y;
                }
            }
        }
        return numberOfPairs;
         
    }
   
    // Driver Code
    static public void Main ()
    {
        int[] arr = {10, 12, 24};
        int n = arr.Length;       
        Console.WriteLine(countPairs(arr, n));
    }
}
 
// This code is contributed by rag2127

输出

2

时间复杂度： O(N + 1024 * 1024)，其中N是数组的大小。