Codestin Search App

Ugly Number II - Problem

An ugly number is a fascinating mathematical concept - it's a positive integer whose only prime factors are 2, 3, and 5. In other words, ugly numbers can only be formed by multiplying powers of 2, 3, and 5 together!

The sequence starts as: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12...

Notice how 7 is missing (it's prime), 11 is missing (also prime), and 14 is missing (contains factor 7).

Your task: Given an integer n, return the nth ugly number in this sequence.

Goal: Efficiently generate the sequence of ugly numbers and find the nth one.

Input & Output

example_1.py — Basic Case

$ Input: n = 10

› Output: 12

💡 Note: The first 10 ugly numbers are [1, 2, 3, 4, 5, 6, 8, 9, 10, 12]. The 10th ugly number is 12.

example_2.py — Small Case

$ Input: n = 1

› Output: 1

💡 Note: The first ugly number is 1, which by definition has no prime factors and is considered ugly.

example_3.py — Medium Case

$ Input: n = 15

› Output: 24

💡 Note: The sequence continues: [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24]. The 15th ugly number is 24 = 2³ × 3.

Visualization

Tap to expand

Understanding the Visualization

Factory Setup

Three machines start processing the first ugly number (1)

Generate Candidates

Machine-2 produces 2, Machine-3 produces 3, Machine-5 produces 5

Pick Minimum

Choose smallest output (2) as next ugly number

Advance Production

Machine-2 moves to next input, continues generating sequence

Key Takeaway

🎯 Key Insight: Every ugly number (except 1) comes from multiplying a smaller ugly number by 2, 3, or 5. Using three pointers eliminates redundant calculations and generates the sequence efficiently in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We generate exactly n ugly numbers, each in constant time

✓ Linear Growth

Space Complexity

O(n)

We store all n ugly numbers in an array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1690
The answer is guaranteed to fit in a 32-bit signed integer
All ugly numbers must be positive integers

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 35 f Meta 28 Apple 22

The optimal solution uses dynamic programming with three pointers. The key insight is that every ugly number (except 1) is formed by multiplying a smaller ugly number by 2, 3, or 5. We maintain three pointers tracking multiplication candidates and always pick the minimum to ensure ascending order. This achieves O(n) time complexity and generates exactly n ugly numbers without checking any non-ugly numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Three Pointers (Optimal)	O(n)	O(n)	Use three pointers to generate ugly numbers in order by multiplying previous ugly numbers by 2, 3, and 5
Brute Force (Check Every Number)	O(n * log(max_ugly))	O(1)	Check each number sequentially to see if it's ugly until we find the nth one

Dynamic Programming with Three Pointers (Optimal) — Algorithm Steps

Initialize array with first ugly number: ugly[0] = 1
Use three pointers i2=0, i3=0, i5=0 for factors 2, 3, 5
Calculate next candidates: ugly[i2]*2, ugly[i3]*3, ugly[i5]*5
Pick the minimum as next ugly number
Advance corresponding pointer(s) to avoid duplicates
Repeat until we have n ugly numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with ugly[0] = 1, three pointers at 0

Calculate candidates

next2 = ugly[i2]*2, next3 = ugly[i3]*3, next5 = ugly[i5]*5

Pick minimum

Choose min(next2, next3, next5) as next ugly number

Advance pointers

Move pointer(s) that produced the minimum

Code -

solution.c — C

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

int min(int a, int b, int c) {
    if (a <= b && a <= c) return a;
    if (b <= c) return b;
    return c;
}

int nthUglyNumber(int n) {
    int* ugly = (int*)malloc(n * sizeof(int));
    ugly[0] = 1;
    
    int i2 = 0, i3 = 0, i5 = 0;
    int next2 = 2, next3 = 3, next5 = 5;
    
    for (int i = 1; i < n; i++) {
        ugly[i] = min(next2, next3, next5);
        
        if (ugly[i] == next2) {
            i2++;
            next2 = ugly[i2] * 2;
        }
        
        if (ugly[i] == next3) {
            i3++;
            next3 = ugly[i3] * 3;
        }
        
        if (ugly[i] == next5) {
            i5++;
            next5 = ugly[i5] * 5;
        }
    }
    
    int result = ugly[n - 1];
    free(ugly);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", nthUglyNumber(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We generate exactly n ugly numbers, each in constant time

✓ Linear Growth

Space Complexity

O(n)

We store all n ugly numbers in an array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1690
The answer is guaranteed to fit in a 32-bit signed integer
All ugly numbers must be positive integers

142.5K Views

High Frequency

~18 min Avg. Time

3.2K 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 Three Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler