计算除数为质数的数组元素

给定一个由N个正整数组成的数组arr [] ，任务是查找除数为质数的数组元素的数量。

例子：

Input: arr[] = {3, 6, 4}
Output: 2
Explanation:
The count of divisors for each element are:

1. arr[0]( = 3): 3 has 2 divisors i.e., 1 and 3.
2. arr[1]( = 6): 6 has 4 divisors i.e., 1, 2, 3, and 6.
3. arr[2]( = 4): 4 has 3 divisors i.e., 1, 2, and 4.

Therefore, there are only 2 array elements, i.e. {3, 4}, whose count of divisors is a prime number.

Input: arr[] = {10, 13, 17, 25}
Output: 3

天真的方法：解决给定问题的最简单方法是找到每个数组元素的除数，并检查除数是否为质数。如果发现是真的，则增加计数。否则，请检查下一个元素。检查所有数组元素后，打印获得的计数。
时间复杂度： O(N ^(3/2) )
辅助空间： O(1)

高效方法：可以通过使用Eratosthenes筛子预先计算素数来优化上述方法。请按照以下步骤解决给定的问题：

• 初始化一个变量，例如count ，以存储除数为质数的数组元素的数量。
• 使用Eratosthenes的Sieve将所有素数存储到布尔数组中的最大元素，例如prime []。
• 现在找到元素的除数直到数组的最大元素的数目，并将它们存储在数组中，例如countDivisor [] 。
• 遍历给定的数组arr []和每个元素arr [i] ，如果countDivisor [arr [i]]的值是质数，则将计数增加1 。否则，请检查下一个元素。
• 完成上述步骤后，打印count的值作为结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to count the array elements
// whose count of divisors is prime
int primeDivisors(int arr[], int N)
{
    // Stores the maximum element
    int K = arr[0];
  
    // Find the maximum element
    for (int i = 1; i < N; i++) {
        K = max(K, arr[i]);
    }
  
    // Store if i-th element is
    // prime(0) or non-prime(1)
    int prime[K + 1] = { 0 };
  
    // Base Case
    prime[0] = 1;
    prime[1] = 1;
  
    for (int i = 2; i < K + 1; i++) {
  
        // If i is a prime number
        if (!prime[i]) {
  
            // Mark all multiples
            // of i as non-prime
            for (int j = 2 * i;
                 j < K + 1; j += i) {
  
                prime[j] = 1;
            }
        }
    }
  
    // Stores the count of divisors
    int factor[K + 1] = { 0 };
  
    // Base Case
    factor[0] = 0;
    factor[1] = 1;
  
    for (int i = 2; i < K + 1; i++) {
  
        factor[i] += 1;
  
        // Iterate to count factors
        for (int j = i; j < K + 1;
             j += i) {
  
            factor[j] += 1;
        }
    }
  
    // Stores the count of array
    // elements whose count of
    // divisors is a prime number
    int count = 0;
  
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
  
        // If count of divisors is prime
        if (prime[factor[arr[i]]] == 0)
            count++;
    }
  
    // Return the resultant count
    return count;
}
  
// Driver Code
int main()
{
    int arr[] = { 10, 13, 17, 25 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << primeDivisors(arr, N);
  
    return 0;
}

输出：

3

时间复杂度： O(M * log M)，其中M是给定数组的最大元素。
辅助空间： O(M)