Ugly Number III - Practice Coding Problems

Ugly Number III - Problem

An ugly number is a positive integer that is divisible by a, b, or c.

Given four integers n, a, b, and c, return the n^th ugly number.

Example: If a = 2, b = 3, c = 5, and n = 4, the ugly numbers are: 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ... The 4th ugly number is 5.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Ugly numbers divisible by 2, 3, or 5: {2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ...}. The 3rd ugly number is 4.

Example 2 — Larger Case

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

› Output: 6

💡 Note: Ugly numbers: {2, 3, 4, 6, 8, 9, 10, 12, ...}. The 4th ugly number is 6.

Example 3 — Single Divisor

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

› Output: 1999999984

💡 Note: For very large n, the binary search approach efficiently finds the billionth ugly number.

Constraints

1 ≤ n, a, b, c ≤ 10⁹
1 ≤ a * b * c ≤ 10¹⁸
It's guaranteed that the result will be in range [1, 2 * 10⁹]

Visualization

Tap to expand

Understanding the Visualization

Input

n=4, a=2, b=3, c=5 (find 4th ugly number)

Process

Count numbers divisible by 2, 3, or 5

Output

4th ugly number is 5

Key Takeaway

🎯 Key Insight: Use binary search with inclusion-exclusion to count ugly numbers efficiently without generating them

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use binary search on the answer space combined with inclusion-exclusion principle to count ugly numbers efficiently. Instead of generating ugly numbers, we count how many exist below a threshold. Best approach uses binary search with mathematical counting: Time: O(log(2×10⁹)), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Inclusion-Exclusion	O(log(2×10⁹))	O(1)	Binary search on answer space using math to count ugly numbers efficiently
Brute Force - Check Every Number	O(n × max(a,b,c))	O(1)	Check each number starting from 1 until we find n ugly numbers

Binary Search + Inclusion-Exclusion — Algorithm Steps

Binary search on possible answer range [1, 2×10⁹]
For each mid value, count ugly numbers ≤ mid using inclusion-exclusion
If count ≥ n, search left half; otherwise search right half
Return the smallest number where count equals n

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Search in range [1, 2×10⁹]

Count Function

Use inclusion-exclusion to count ugly numbers ≤ mid

Narrow Range

Adjust search range based on count

Code -

solution.c — C

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

long long gcd(long long x, long long y) {
    while (y != 0) {
        long long temp = y;
        y = x % y;
        x = temp;
    }
    return x;
}

long long lcm(long long x, long long y) {
    return x * y / gcd(x, y);
}

long long countUgly(long long num, long long a, long long b, long long c) {
    return num / a + num / b + num / c - 
           num / lcm(a, b) - num / lcm(a, c) - num / lcm(b, c) + 
           num / lcm(lcm(a, b), c);
}

int solution(int n, int a, int b, int c) {
    long long left = 1, right = 2000000000LL;
    while (left < right) {
        long long mid = (left + right) / 2;
        if (countUgly(mid, a, b, c) < n) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return (int)left;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log(2×10⁹))

Binary search has at most 31 iterations, each counting operation is O(1)

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and calculations

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Binary Search + Inclusion-Exclusion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler