Super Ugly Number

Super Ugly Number - Problem

A super ugly number is a positive integer whose prime factors are all contained in the given array primes.

Given an integer n and an array of integers primes, return the n^th super ugly number.

The n^th super ugly number is guaranteed to fit in a 32-bit signed integer.

Input & Output

Example 1 — 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 — Small Input

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

› Output: 1

💡 Note: 1 is the first super ugly number for any prime array.

Example 3 — Single Prime

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

› Output: 81

💡 Note: With only prime 3, the sequence is [1,3,9,27,81]. The 5th number is 81 = 3⁴.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28 M Microsoft 22

The key insight is that super ugly numbers can be generated by multiplying existing super ugly numbers with given primes. The optimal approach uses dynamic programming with multiple pointers, maintaining a pointer for each prime to track which existing number to multiply next. This generates numbers in sorted order efficiently. Time: O(n×k), Space: O(n).

Common Approaches

✓ Brute Force Check

⏱️ Time: O(n × k × log(max_number)) Space: O(1)

For each number starting from 1, check if all its prime factors are in the given primes array. Keep counting until we find the nth super ugly number.

Dynamic Programming with Pointers

⏱️ Time: O(n × k) Space: O(n)

Maintain pointers for each prime to track which existing super ugly number to multiply next. At each step, find the minimum product and advance corresponding pointers.

Priority Queue (Heap) Approach

⏱️ Time: O(n × k × log(n × k)) Space: O(n × k)

Start with 1 in a min-heap. For each step, pop the minimum, add it to result, and push all its multiples with given primes back to heap. Use a set to avoid duplicates.

Brute Force Check — Algorithm Steps

Start from number 1
For each number, check if it's super ugly by factorization
Count valid numbers until we reach n

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Number

Test if current number is super ugly

Factorize

Divide by all allowed primes

Count Valid

If remainder is 1, it's super ugly

Code -

solution.c — C

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

int isSuperUgly(int num, int* primes, int primesSize) {
    for (int i = 0; i < primesSize; i++) {
        while (num % primes[i] == 0) {
            num /= primes[i];
        }
    }
    return num == 1;
}

int solution(int n, int* primes, int primesSize) {
    int count = 0;
    int num = 1;
    while (count < n) {
        if (isSuperUgly(num, primes, primesSize)) {
            count++;
            if (count == n) {
                return num;
            }
        }
        num++;
    }
    return num - 1;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    scanf(" %s", line);
    
    int primes[100];
    int primesSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        primes[primesSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(n, primes, primesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k × log(max_number))

For each of n numbers, we do factorization which takes O(k × log(num)) where k is number of primes

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for counting and checking

✓ Linear Space

89.4K Views

Medium Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler