Distinct Prime Factors of Product of Array

Distinct Prime Factors of Product of Array - Problem

Given an array of positive integers nums, imagine multiplying all the numbers together to get one giant product. Your task is to find how many distinct prime factors this product would have, without actually computing the massive product!

For example, if you have [2, 4, 3, 7, 10, 6], the product would be 2 × 4 × 3 × 7 × 10 × 6 = 40,320. The prime factorization reveals distinct prime factors: 2, 3, 5, 7 - so the answer is 4.

Key Points:

A prime number is only divisible by 1 and itself (like 2, 3, 5, 7, 11...)
We want distinct primes - count each prime only once regardless of how many times it appears
We don't need to calculate the actual product - that would cause overflow!

Input & Output

example_1.py — Basic Example

$ Input: nums = [2, 4, 3, 7, 10, 6]

› Output: 4

💡 Note: The prime factors are: 2 from multiple numbers, 3 from (3,6), 5 from (10), and 7 from (7). Total distinct primes: 4.

example_2.py — Simple Case

$ Input: nums = [2, 4, 8, 16]

› Output: 1

💡 Note: All numbers are powers of 2. The only distinct prime factor is 2.

example_3.py — All Primes

$ Input: nums = [2, 3, 5, 7, 11]

› Output: 5

💡 Note: Each number is already prime, so we have 5 distinct prime factors: 2, 3, 5, 7, and 11.

Visualization

Tap to expand

Understanding the Visualization

Process Each Number

Factor each array element individually: 2→{2}, 4→{2}, 3→{3}

Collect Unique Primes

Add each prime factor to our set, ignoring duplicates

Count Results

Return the size of our distinct prime factors set

Key Takeaway

🎯 Key Insight: Instead of computing the massive product, factor each number individually and collect unique primes - this avoids overflow and is much more efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n × √M)

For each of n numbers, factorization takes O(√M) where M is the maximum value

✓ Linear Growth

Space Complexity

O(P)

O(P) space where P is the number of distinct prime factors across all numbers

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
2 ≤ nums[i] ≤ 1000
All integers in nums are positive

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses prime factorization on each number individually, collecting all distinct prime factors in a hash set. This approach avoids integer overflow while maintaining O(n × √M) time complexity, where M is the maximum array value.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Prime Factorization (Optimal)	O(n × √M)	O(P)	Factor each number individually and collect all distinct primes in one pass
Brute Force (Compute Product Then Factor)	O(n + √P)	O(log P)	Calculate the actual product, then find its prime factors

One-Pass Prime Factorization (Optimal) — Algorithm Steps

Initialize an empty set to store distinct prime factors
For each number in the array, find its prime factors
Add each prime factor to the set (duplicates automatically ignored)
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Factor First Number

2 → {2}

Factor Second Number

4 = 2² → add 2 to set → {2}

Factor Third Number

3 → add 3 to set → {2, 3}

Continue Process

7 → {2,3,7}, 10=2×5 → {2,3,5,7}, 6=2×3 → {2,3,5,7}

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int factors[1000];
    int count;
} PrimeSet;

bool contains(PrimeSet* set, int factor) {
    for (int i = 0; i < set->count; i++) {
        if (set->factors[i] == factor) return true;
    }
    return false;
}

void add(PrimeSet* set, int factor) {
    if (!contains(set, factor)) {
        set->factors[set->count++] = factor;
    }
}

void getPrimeFactors(int n, PrimeSet* result) {
    int d = 2;
    while (d * d <= n) {
        while (n % d == 0) {
            add(result, d);
            n /= d;
        }
        d++;
    }
    if (n > 1) {
        add(result, n);
    }
}

int distinctPrimeFactors(int* nums, int n) {
    PrimeSet primeFactors = {0};
    
    for (int i = 0; i < n; i++) {
        getPrimeFactors(nums[i], &primeFactors);
    }
    
    return primeFactors.count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", distinctPrimeFactors(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × √M)

For each of n numbers, factorization takes O(√M) where M is the maximum value

✓ Linear Growth

Space Complexity

O(P)

O(P) space where P is the number of distinct prime factors across all numbers

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
2 ≤ nums[i] ≤ 1000
All integers in nums are positive

18.5K Views

Medium Frequency

~15 min Avg. Time

687 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Prime Factorization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler