Ugly Number III - Practice Coding Problems

Ugly Number III - Problem

An ugly number is a positive integer that is divisible by at least one of three given numbers: a, b, or c.

Given four integers n, a, b, and c, your task is to find the n-th ugly number in the sequence of all ugly numbers sorted in ascending order.

Example: If a = 2, b = 3, c = 5, then the ugly numbers are: 2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20...

The challenge is to find this efficiently for large values of n (up to 2 × 10⁹), making a brute force approach impractical.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, a = 2, b = 3, c = 5

› Output: 4

💡 Note: The ugly numbers are 2, 3, 4, 5, 6, 8, 9, 10, 12... The 3rd ugly number is 4.

example_2.py — Larger Input

$ Input: n = 4, a = 2, b = 3, c = 4

› Output: 6

💡 Note: Since 4 = 2×2, numbers divisible by 4 are also divisible by 2. The ugly numbers are 2, 3, 4, 6, 8, 9... The 4th ugly number is 6.

example_3.py — Edge Case

$ Input: n = 1000000000, a = 2, b = 217983653, c = 336916467

› Output: 1999999984

💡 Note: This demonstrates why we need an efficient algorithm - brute force would be impossible for such large n.

Visualization

Tap to expand

Understanding the Visualization

Binary Search Setup

Search space is from 1 to n × min(a,b,c) since the n-th ugly number can't exceed this

Counting Function

For any value x, count ugly numbers ≤ x using inclusion-exclusion principle

Include Individual Sets

Add ⌊x/a⌋ + ⌊x/b⌋ + ⌊x/c⌋ to count multiples of each

Exclude Intersections

Subtract ⌊x/lcm(a,b)⌋ + ⌊x/lcm(a,c)⌋ + ⌊x/lcm(b,c)⌋ to avoid double counting

Include Triple Intersection

Add back ⌊x/lcm(a,b,c)⌋ for numbers divisible by all three

Key Takeaway

🎯 Key Insight: Instead of generating ugly numbers sequentially (slow), we binary search on the answer and use inclusion-exclusion principle to count ugly numbers ≤ any value in constant time, achieving O(log n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n × result)

We potentially check every number up to the n-th ugly number, which could be very large

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track count and current number

✓ Linear Space

Constraints

1 ≤ n ≤ 2 × 10⁹
2 ≤ a, b, c ≤ 10⁹
Important: The result will fit in a 32-bit signed integer

Asked in

G Google 45 ⊞ Microsoft 35 a Amazon 30 f Meta 25

The optimal solution uses binary search on the answer combined with the inclusion-exclusion principle. Instead of generating ugly numbers sequentially, we binary search for the n-th ugly number and use a mathematical formula to count how many ugly numbers exist up to any given value in O(1) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n × result)	O(1)	Check each number starting from 1 until we find the n-th ugly number
Binary Search + Inclusion-Exclusion (Optimal)	O(log(n * min(a,b,c)))	O(1)	Binary search on the answer using inclusion-exclusion principle to count ugly numbers

Brute Force (Check Every Number) — Algorithm Steps

Initialize counter = 0 and current number = 1
For each number, check if it's divisible by a, b, or c
If divisible, increment counter
If counter equals n, return current number
Otherwise, increment current number and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from 1

Begin checking from number 1

Check Divisibility

Test if current number is divisible by a, b, or c

Count if Ugly

If divisible, increment our count of ugly numbers found

Continue or Return

If count equals n, return current number; otherwise continue

Code -

solution.c — C

#include <stdio.h>

int nthUglyNumber(int n, int a, int b, int c) {
    int count = 0;
    int num = 1;
    
    while (1) {
        if (num % a == 0 || num % b == 0 || num % c == 0) {
            count++;
            if (count == n) {
                return num;
            }
        }
        num++;
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × result)

We potentially check every number up to the n-th ugly number, which could be very large

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track count and current number

✓ Linear Space

Constraints

1 ≤ n ≤ 2 × 10⁹
2 ≤ a, b, c ≤ 10⁹
Important: The result will fit in a 32-bit signed integer

34.5K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler