Ugly Number II

Ugly Number II - Problem

An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5.

Given an integer n, return the n-th ugly number.

For example, the first 10 ugly numbers are: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12. Note that 1 is typically treated as an ugly number.

Input & Output

Example 1 — Finding 10th Ugly Number

$ 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 — First Ugly Number

$ Input: n = 1

› Output: 1

💡 Note: 1 is conventionally treated as the first ugly number.

Example 3 — Edge Case with Small n

$ Input: n = 6

› Output: 6

💡 Note: The first 6 ugly numbers are: 1, 2, 3, 4, 5, 6. The 6th is 6 (which is 2 × 3).

Constraints

1 ≤ n ≤ 1690

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15 f Facebook 12

The key insight is to generate ugly numbers in ascending order rather than checking every number. The optimal DP approach uses three pointers to efficiently produce the sequence by always choosing the minimum next candidate. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(n * m) Space: O(1)

For each number starting from 1, check if it's ugly by repeatedly dividing by 2, 3, and 5. Count ugly numbers until we reach the nth one.

Dynamic Programming (Three Pointers)

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

Maintain an array of ugly numbers and three pointers for multiples of 2, 3, and 5. At each step, choose the minimum of the three candidates and advance the corresponding pointer(s).

Priority Queue (Min Heap)

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

Start with 1 in a min heap. For each extracted number, add its multiples (×2, ×3, ×5) back to the heap. Use a set to avoid duplicates. Extract n times to get the nth ugly number.

Brute Force — Algorithm Steps

Start from number 1
For each number, check if it's ugly by dividing by 2, 3, 5
Count ugly numbers until we reach the nth one

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Numbers

Test each number starting from 1

Count Ugly

Count valid ugly numbers

Find nth

Return when we reach the nth ugly number

Code -

solution.c — C

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

bool isUgly(int num) {
    if (num <= 0) return false;
    while (num % 2 == 0) num /= 2;
    while (num % 3 == 0) num /= 3;
    while (num % 5 == 0) num /= 5;
    return num == 1;
}

int solution(int n) {
    int count = 0;
    int num = 1;
    while (count < n) {
        if (isUgly(num)) {
            count++;
            if (count == n) return num;
        }
        num++;
    }
    return -1; // This should never be reached
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

For each of n ugly numbers, we might check m numbers in between, and each check takes log(num) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

185.0K Views

Medium Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler