Count Ways to Make Array With Product - Practice Coding Problems

Count Ways to Make Array With Product - Problem

Array Math Dynamic Programming Combinatorics Number Theory Hard

Imagine you're a mathematician tasked with finding all possible ways to arrange positive integers in an array such that their product equals a specific target value.

You are given a 2D integer array queries, where each queries[i] = [ni, ki] represents a challenge:

ni: The size of the array you need to create
ki: The target product that all elements must multiply to

For each query, you need to count how many different ways you can place positive integers into an array of size ni such that the product of all integers equals ki.

Example: If n=2 and k=6, valid arrays include [1,6], [2,3], [3,2], [6,1] - that's 4 different ways!

Since the answer can be extremely large, return each result modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case

$ Input: queries = [[2,6],[3,4],[4,1]]

› Output: [4,2,1]

💡 Note: For [2,6]: Arrays like [1,6], [2,3], [3,2], [6,1] give product 6. For [3,4]: Arrays like [1,1,4], [1,2,2] give product 4. For [4,1]: Only [1,1,1,1] gives product 1.

example_2.py — Edge case with 1

$ Input: queries = [[1,1],[2,1]]

› Output: [1,1]

💡 Note: When k=1, there's exactly one way: fill all positions with 1. For [1,1]: [1]. For [2,1]: [1,1].

example_3.py — Larger numbers

$ Input: queries = [[3,12],[2,8]]

› Output: [18,10]

💡 Note: For [3,12]: 12 = 2² × 3¹, using stars and bars gives C(4,2) × C(3,1) = 6 × 3 = 18 ways. For [2,8]: 8 = 2³, gives C(4,3) = 4 ways for first query type.

Visualization

Tap to expand

Understanding the Visualization

Prime Factorization

Break k = 12 into 2² × 3¹

Distribute Exponent 2

Place two '2' coins into 3 boxes: C(4,2) = 6 ways

Distribute Exponent 1

Place one '3' coin into 3 boxes: C(3,1) = 3 ways

Multiply Results

Total ways = 6 × 3 = 18

Key Takeaway

🎯 Key Insight: Transform the array product problem into a combinatorial distribution problem using prime factorization and the stars-and-bars formula.

Time & Space Complexity

Time Complexity

⏱️

O(max_k * log(log(max_k)) + Q * d(k))

Sieve for preprocessing + Q queries × number of distinct prime factors

⚡ Linearithmic

Space Complexity

O(max_k)

Space for storing prime factorizations and precomputed factorials

✓ Linear Space

Constraints

1 ≤ queries.length ≤ 10⁴
1 ≤ ni, ki ≤ 10⁴
All positive integers must be ≥ 1
Answer should be returned modulo 10⁹ + 7

Asked in

G Google 42 f Meta 28 a Amazon 35 ⊞ Microsoft 19

The optimal solution uses prime factorization combined with combinatorics. First, factorize each k into prime factors with exponents. Then, for each prime factor with exponent e, use the stars and bars formula C(n+e-1, e) to count ways to distribute the exponent across n array positions. The final answer is the product of results for all prime factors, computed modulo 10⁹ + 7.

Common Approaches

Approach	Time	Space	Notes
✓ Prime Factorization + Combinatorics (Optimal)	O(max_k * log(log(max_k)) + Q * d(k))	O(max_k)	Use prime factorization and stars-and-bars combinatorial formula
Brute Force (Generate All Combinations)	O(k^n)	O(n)	Generate all possible arrays and count those with target product

Prime Factorization + Combinatorics (Optimal) — Algorithm Steps

Precompute prime factorization for all numbers up to max k
For each query, get prime factors of k with their exponents
For each prime factor with exponent e, calculate C(n+e-1, e) using stars and bars
Multiply results for all prime factors
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Prime Factorization

Break k into prime factors with exponents

Stars and Bars

For each prime factor, distribute its exponent across n positions

Combinatorial Formula

Use C(n+e-1,e) for each prime factor exponent e

Code -

solution.c — C

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

const int MOD = 1000000007;
const int MAX_K = 10000;

typedef struct {
    int prime;
    int count;
} PrimeFactor;

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

long long modInverse(long long a) {
    return modPow(a, MOD - 2, MOD);
}

int* waysToFillArray(int** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    // Precompute factorials
    long long* fact = (long long*)malloc((MAX_K + 15) * sizeof(long long));
    fact[0] = 1;
    for (int i = 1; i < MAX_K + 15; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }
    
    long long* invFact = (long long*)malloc((MAX_K + 15) * sizeof(long long));
    invFact[MAX_K + 14] = modInverse(fact[MAX_K + 14]);
    for (int i = MAX_K + 13; i >= 0; i--) {
        invFact[i] = (invFact[i+1] * (i+1)) % MOD;
    }
    
    // Sieve for smallest prime factor
    int* spf = (int*)malloc((MAX_K + 1) * sizeof(int));
    for (int i = 0; i <= MAX_K; i++) spf[i] = i;
    for (int i = 2; i * i <= MAX_K; i++) {
        if (spf[i] == i) {
            for (int j = i * i; j <= MAX_K; j += i) {
                if (spf[j] == j) spf[j] = i;
            }
        }
    }
    
    for (int i = 0; i < queriesSize; i++) {
        int n = queries[i][0], k = queries[i][1];
        if (k == 1) {
            result[i] = 1;
            continue;
        }
        
        // Get prime factors
        PrimeFactor factors[100];
        int factorCount = 0;
        int temp = k;
        
        while (temp > 1) {
            int p = spf[temp];
            int idx = -1;
            for (int j = 0; j < factorCount; j++) {
                if (factors[j].prime == p) {
                    idx = j;
                    break;
                }
            }
            if (idx == -1) {
                factors[factorCount].prime = p;
                factors[factorCount].count = 1;
                factorCount++;
            } else {
                factors[idx].count++;
            }
            temp /= p;
        }
        
        long long ways = 1;
        for (int j = 0; j < factorCount; j++) {
            int exp = factors[j].count;
            // nCr(n + exp - 1, exp)
            if (exp >= 0 && exp <= n + exp - 1) {
                long long comb = (fact[n + exp - 1] * invFact[exp] % MOD) * invFact[n - 1] % MOD;
                ways = (ways * comb) % MOD;
            }
        }
        
        result[i] = ways;
    }
    
    free(fact);
    free(invFact);
    free(spf);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max_k * log(log(max_k)) + Q * d(k))

Sieve for preprocessing + Q queries × number of distinct prime factors

⚡ Linearithmic

Space Complexity

O(max_k)

Space for storing prime factorizations and precomputed factorials

✓ Linear Space

Constraints

1 ≤ queries.length ≤ 10⁴
1 ≤ ni, ki ≤ 10⁴
All positive integers must be ≥ 1
Answer should be returned modulo 10⁹ + 7

28.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Prime Factorization + Combinatorics (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler