计算数字乘积为复合数的数组元素

给定一个由N 个非负整数组成的数组arr[] ，任务是计算数字乘积为合数的数组元素的数量。

例子：

Input: arr[] = {13, 55, 7, 13, 11, 71, 233, 144, 89}
Output: 4
Explanation: The array elements having product of digits equal to a composite number are 55 (5 * 5 = 25), 233 (2 * 3 * 3 = 18), 144 (1 * 4 * 4 = 16), 89 ( = 8 * 9 = 72)

Input: arr[] = {34, 13, 55, 11, 8, 3, 55, 23}
Output: 3 
Explanation: The array elements having product of digits equal to a composite number are 34 ( = 3 * 4 = 12), 55 ( 5 * 5 = 25), 23 ( = 2 * 3 = 6)

处理方法：按照以下步骤解决问题：

• 使用 Eratosthenes 筛法预先计算并存储所有质数。
• 创建一个 Set 来存储所有数字乘积为合数的不同数组元素。
• 遍历给定的数组，对于每个数组元素，检查其所有数字的乘积是否为质数。如果发现为真，则将当前元素添加到 Set 中。
• 否则，继续下一个数组元素。
• 遍历后，打印集合的大小作为所需答案。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
#include 
using namespace std;
 
#define N 100005
 
// Function to generate prime numbers
// using Sieve of Eratosthenes
void SieveOfEratosthenes(bool prime[],
                         int p_size)
{
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= p_size; p++) {
        // If p is a prime
        if (prime[p]) {
 
            // Set all multiples of p as non-prime
            for (int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to calculate the product
// of digits of the given number
long long int digitProduct(int number)
{
    // Stores the product of digits
    long long int res = 1;
    while (number > 0) {
 
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
 
    // Return the product
    // of its digits
    return res;
}
 
// Function to print number of distinct
// values with digit product as composite
void DistinctCompositeDigitProduct(int arr[],
                                   int n)
{
    // Initialize set
    set output;
 
    // Initialize boolean array
    bool prime[N + 1];
    memset(prime, true, sizeof(prime));
 
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
 
    // Traverse array
    for (int i = 0; i < n; i++) {
 
        // Stores the product of digits
        // of the current array element
        long long int ans
            = digitProduct(arr[i]);
 
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1) {
            continue;
        }
 
        // If Product of digits is
        // not a prime
        if (!prime[ans]) {
            output.insert(ans);
        }
    }
 
    // Print the answer
    cout << output.size() << endl;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[]
        = { 13, 55, 7, 13, 11,
            71, 233, 233, 144, 89 };
 
    // Given size
    int n = sizeof(arr)
            / sizeof(arr[0]);
 
    // Function call
    DistinctCompositeDigitProduct(arr, n);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
   
class GFG{
   
static int N = 100005;
  
// Function to generate prime numbers
// using Sieve of Eratosthenes
static void SieveOfEratosthenes(boolean prime[],
                                int p_size)
{
     
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
  
    for(int p = 2; p * p <= p_size; p++)
    {
         
        // If p is a prime
        if (prime[p])
        {
             
            // Set all multiples of p as non-prime
            for(int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
  
// Function to calculate the product
// of digits of the given number
static int digitProduct(int number)
{
     
    // Stores the product of digits
    int res = 1;
    while (number > 0)
    {
         
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
  
    // Return the product
    // of its digits
    return res;
}
  
// Function to print number of distinct
// values with digit product as composite
static void DistinctCompositeDigitProduct(int arr[],
                                          int n)
{
     
    // Initialize set
    TreeSet output = new TreeSet();
 
    // Initialize boolean array
    boolean prime[] = new boolean[N + 1];
    Arrays.fill(prime, true);
  
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
  
    // Traverse array
    for(int i = 0; i < n; i++)
    {
         
        // Stores the product of digits
        // of the current array element
        int ans = digitProduct(arr[i]);
  
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1)
        {
            continue;
        }
  
        // If Product of digits is
        // not a prime
        if (!prime[ans])
        {
            output.add(ans);
        }
    }
  
    // Print the answer
    System.out.print(output.size());
}
   
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int arr[] = { 13, 55, 7, 13, 11,
                  71, 233, 233, 144, 89 };
  
    // Given size
    int n = arr.length;
  
    // Function call
    DistinctCompositeDigitProduct(arr, n);
}
}
 
// This code is contributed by susmitakundugoaldanga

Python3

# Python3 program for the above approach
N = 100005
from math import sqrt
 
# Function to generate prime numbers
# using Sieve of Eratosthenes
def SieveOfEratosthenes(prime, p_size):
   
    # Set 0 and 1 as non-prime
    prime[0] = False
    prime[1] = False
    for p in range(2, int(sqrt(p_size)), 1):
       
        # If p is a prime
        if (prime[p]):
           
            # Set all multiples of p as non-prime
            for i in range(p * 2, p_size + 1, p):
                prime[i] = False
 
# Function to calculate the product
# of digits of the given number
def digitProduct(number):
   
    # Stores the product of digits
    res = 1
    while(number > 0):
       
        # Extract digits and
        # add to the sum
        res *= (number % 10)
        number //= 10
 
    # Return the product
    # of its digits
    return res
 
# Function to print number of distinct
# values with digit product as composite
def DistinctCompositeDigitProduct(arr, n):
   
    # Initialize set
    output = set()
 
    # Initialize boolean array
    prime = [True for i in range(N + 1)]
 
    # Pre-compute primes
    SieveOfEratosthenes(prime, N)
 
    # Traverse array
    for i in range(n):
       
        # of the current array element
        ans = digitProduct(arr[i])
 
        # If Product of digits is
        # less than or equal to 1
        if (ans <= 1):
            continue
 
        # If Product of digits is
        # not a prime
        if (prime[ans] == False):
            output.add(ans)
 
    # Print the answer
    print(len(output))
 
# Driver Code
if __name__ == '__main__':
   
    # Given array
    arr = [13, 55, 7, 13, 11, 71, 233, 233, 144, 89]
 
    # Given size
    n = len(arr)
 
    # Function call
    DistinctCompositeDigitProduct(arr, n)
     
    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
    
static int N = 100005;
   
// Function to generate prime numbers
// using Sieve of Eratosthenes
static void SieveOfEratosthenes(bool[] prime,
                                int p_size)
{
   
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
   
    for(int p = 2; p * p <= p_size; p++)
    {
       
        // If p is a prime
        if (prime[p])
        {
              
            // Set all multiples of p as non-prime
            for(int i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
   
// Function to calculate the product
// of digits of the given number
static int digitProduct(int number)
{
      
    // Stores the product of digits
    int res = 1;
    while (number > 0)
    {
          
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number /= 10;
    }
   
    // Return the product
    // of its digits
    return res;
}
   
// Function to print number of distinct
// values with digit product as composite
static void DistinctCompositeDigitProduct(int[] arr,
                                          int n)
{
      
    // Initialize set
    SortedSet output = new SortedSet();
  
    // Initialize boolean array
    bool[] prime = new bool[N + 1];
    for(int i = 0; i < N + 1; i++)
    {
        prime[i] = true;
    }
     
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
   
    // Traverse array
    for(int i = 0; i < n; i++)
    {
          
        // Stores the product of digits
        // of the current array element
        int ans = digitProduct(arr[i]);
   
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1)
        {
            continue;
        }
   
        // If Product of digits is
        // not a prime
        if (!prime[ans])
        {
            output.Add(ans);
        }
    }
   
    // Print the answer
    Console.WriteLine(output.Count);
}
 
   
// Driver Code
public static void Main()
{
    // Given array
    int[] arr = { 13, 55, 7, 13, 11,
                  71, 233, 233, 144, 89 };
   
    // Given size
    int n = arr.Length;
   
    // Function call
    DistinctCompositeDigitProduct(arr, n);
}
}
 
// This code is contributed by sanjoy_62

Javascript

 
// javascript program for the above approach
 
var N = 100005;
 
// Function to generate prime numbers
// using Sieve of Eratosthenes
function SieveOfEratosthenes(prime, p_size)
{
    // Set 0 and 1 as non-prime
    prime[0] = false;
    prime[1] = false;
     
    var p,i;
    for (p = 2; p * p <= p_size; p++) {
        // If p is a prime
        if (prime[p]) {
 
            // Set all multiples of p as non-prime
            for (i = p * 2; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to calculate the product
// of digits of the given number
function digitProduct(number)
{
    // Stores the product of digits
    var res = 1;
    while (number > 0) {
 
        // Extract digits and
        // add to the sum
        res *= (number % 10);
        number = parseInt(number/10);
    }
 
    // Return the product
    // of its digits
    return res;
}
 
// Function to print number of distinct
// values with digit product as composite
function DistinctCompositeDigitProduct(arr, n)
{
    // Initialize set
    var output = new Set();
 
    // Initialize boolean array
    var prime = Array(N + 1).fill(true);
 
    // Pre-compute primes
    SieveOfEratosthenes(prime, N);
     
    var i;
    // Traverse array
    for (i = 0; i < n; i++) {
 
        // Stores the product of digits
        // of the current array element
        var ans = digitProduct(arr[i]);
 
        // If Product of digits is
        // less than or equal to 1
        if (ans <= 1) {
            continue;
        }
 
        // If Product of digits is
        // not a prime
        if (prime[ans]==false) {
            output.add(ans);
        }
    }
 
    // Print the answer
    document.write(output.size);
}
 
// Driver Code
    // Given array
    var arr = [13, 55, 7, 13, 11,
            71, 233, 233, 144, 89];
 
    // Given size
    var n = arr.length;
 
    // Function call
    DistinctCompositeDigitProduct(arr, n);
     

输出：

4

时间复杂度： O(N + MlogM)，其中N是给定数组的大小， M是最大数组元素。
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live