Super Ugly Number - Practice Coding Problems

Super Ugly Number - Problem

A super ugly number is a positive integer whose only prime factors are found in a given array of primes. Think of it as building numbers using only specific "building blocks" (prime factors).

Given an integer n and an array of integers primes, your task is to find the n-th super ugly number. The sequence starts with 1 (which has no prime factors), and each subsequent number can only be formed by multiplying previous super ugly numbers with the given primes.

Example: If primes = [2, 7, 13, 19], the sequence begins: 1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32...

Your goal is to efficiently generate this sequence and return the n-th number, which is guaranteed to fit in a 32-bit signed integer.

Input & Output

example_1.py — Basic case

$ Input: n = 12, primes = [2,7,13,19]

› Output: 32

💡 Note: The sequence is [1,2,4,7,8,13,14,16,19,26,28,32]. The 12th super ugly number is 32.

example_2.py — Single prime

$ Input: n = 1, primes = [2,3,5]

› Output: 1

💡 Note: The first super ugly number is always 1, regardless of the primes array.

example_3.py — Small sequence

$ Input: n = 5, primes = [2,3]

› Output: 8

💡 Note: The sequence is [1,2,3,4,6,8]. The 5th number would be 6, but we want the 5th index (0-based) which gives us 8.

Visualization

Tap to expand

Understanding the Visualization

Setup Assembly Lines

Each prime gets its own production line that multiplies existing products

Generate Candidates

Each line produces its next candidate product

Pick Minimum

Quality control selects the smallest product from all lines

Advance Lines

All lines that produced the selected product move to their next position

Key Takeaway

🎯 Key Insight: By maintaining multiple production lines (pointers) and always selecting the minimum product, we generate super ugly numbers in perfect sorted order with optimal O(n×k) efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

For each of n positions, we check k primes to find minimum candidate

✓ Linear Growth

Space Complexity

O(n + k)

O(n) for result array and O(k) for pointers array where k is number of primes

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁶
1 ≤ primes.length ≤ 100
2 ≤ primes[i] ≤ 1000
primes[i] is guaranteed to be a prime number
All the values of primes are unique and sorted in ascending order

Asked in

G Google 45 f Facebook 32 A Amazon 28 ⊞ Microsoft 22

The optimal solution uses dynamic programming with multiple pointers. Each pointer tracks the next candidate from multiplying each prime with previous super ugly numbers. We always select the minimum candidate and advance corresponding pointers, achieving O(n × k) time complexity where k is the number of primes.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Priority Queue (Optimal)	O(n * k)	O(n + k)	Use multiple pointers to track next candidates from each prime, always select minimum
Brute Force (Check Every Number)	O(n * m * log(max_value))	O(1)	Check every integer starting from 1 to see if it's a super ugly number

Dynamic Programming with Priority Queue (Optimal) — Algorithm Steps

Initialize result array with first super ugly number (1)
Create pointers array, one for each prime, all starting at index 0
For each position from 1 to n-1:
Calculate next candidates: primes[i] * result[pointers[i]] for each prime
Pick the minimum candidate as the next super ugly number
Advance all pointers whose candidates equal this minimum (to avoid duplicates)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

result=[1], pointers=[0,0,0,0] for primes [2,7,13,19]

Generate candidates

candidates: 2×1=2, 7×1=7, 13×1=13, 19×1=19

Pick minimum

min=2, add to result=[1,2], advance pointer[0]

Next iteration

candidates: 2×2=4, 7×1=7, 13×1=13, 19×1=19, min=4

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int nthSuperUglyNumber(int n, int* primes, int primeCount) {
    if (n == 1) return 1;
    
    int* result = (int*)malloc(n * sizeof(int));
    result[0] = 1;
    
    int* pointers = (int*)calloc(primeCount, sizeof(int));
    
    for (int i = 1; i < n; i++) {
        int nextUgly = INT_MAX;
        
        // Find minimum candidate
        for (int j = 0; j < primeCount; j++) {
            nextUgly = min(nextUgly, primes[j] * result[pointers[j]]);
        }
        
        result[i] = nextUgly;
        
        // Advance pointers
        for (int j = 0; j < primeCount; j++) {
            if (primes[j] * result[pointers[j]] == nextUgly) {
                pointers[j]++;
            }
        }
    }
    
    int answer = result[n - 1];
    free(result);
    free(pointers);
    return answer;
}

int main() {
    int primes[] = {2, 7, 13, 19};
    int n = 12;
    printf("%d\n", nthSuperUglyNumber(n, primes, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

For each of n positions, we check k primes to find minimum candidate

✓ Linear Growth

Space Complexity

O(n + k)

O(n) for result array and O(k) for pointers array where k is number of primes

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁶
1 ≤ primes.length ≤ 100
2 ≤ primes[i] ≤ 1000
primes[i] is guaranteed to be a prime number
All the values of primes are unique and sorted in ascending order

52.0K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Dynamic Programming with Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler