Ugly Number - Practice Coding Problems

Ugly Number - Problem

Math Easy

An ugly number is a positive integer whose only prime factors are 2, 3, and 5. In other words, it can be expressed as 2ⁱ × 3^j × 5^k where i, j, and k are non-negative integers.

Given an integer n, return true if n is an ugly number, otherwise return false.

Examples:

6 = 2 × 3 → ugly number ✅
8 = 2³ → ugly number ✅
14 = 2 × 7 → not ugly (contains prime factor 7) ❌

Note: By definition, 1 is considered an ugly number since it has no prime factors.

Input & Output

example_1.py — Basic Ugly Number

$ Input: n = 6

› Output: true

💡 Note: 6 = 2 × 3, which only contains the prime factors 2 and 3. Therefore, 6 is an ugly number.

example_2.py — Single Prime Factor

$ Input: n = 8

› Output: true

💡 Note: 8 = 2³, which only contains the prime factor 2. Therefore, 8 is an ugly number.

example_3.py — Non-Ugly Number

$ Input: n = 14

› Output: false

💡 Note: 14 = 2 × 7. Since 7 is a prime factor other than 2, 3, or 5, 14 is not an ugly number.

Visualization

Tap to expand

Understanding the Visualization

Start with number n

Begin with the input number to test

Remove all 2s

Divide by 2 repeatedly while possible

Remove all 3s

Divide by 3 repeatedly while possible

Remove all 5s

Divide by 5 repeatedly while possible

Check remainder

If 1 remains, number was ugly; otherwise not ugly

Key Takeaway

🎯 Key Insight: Rather than finding all prime factors, systematically eliminate allowed factors (2, 3, 5). If 1 remains, the original number was ugly!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We divide n by 2, 3, or 5 repeatedly. In worst case, we do this log n times

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

-2³¹ ≤ n ≤ 2³¹ - 1
n must be checked for positive values only
Consider edge cases like 0, 1, and negative numbers

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 Apple 12

The optimal solution uses systematic division: repeatedly divide the number by 2, 3, and 5 until no longer possible. If the result is 1, the original number was ugly. This approach runs in O(log n) time and O(1) space, making it much more efficient than checking all prime factors.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Prime Factors)	O(√n)	O(1)	Find all prime factors and verify they're only 2, 3, or 5
Optimal Division Method	O(log n)	O(1)	Repeatedly divide by 2, 3, and 5 until no longer possible

Brute Force (Check All Prime Factors) — Algorithm Steps

Handle edge cases: if n ≤ 0, return false
If n = 1, return true (by definition)
For each number i from 2 to sqrt(n), check if i divides n
If i divides n, check if i is 2, 3, or 5
If any divisor is not 2, 3, or 5, return false
Continue until all factors are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n

Begin with the input number

Test divisibility

Check each number from 2 to √n

Verify factors

Ensure all factors are 2, 3, or 5

Return result

True if all factors are allowed, false otherwise

Code -

solution.c — C

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

bool isUgly(int n) {
    if (n <= 0) return false;
    
    if (n == 1) return true;
    
    // Check for prime factors other than 2, 3, 5
    for (int i = 2; i * i <= n; i++) {
        while (n % i == 0) {
            if (i != 2 && i != 3 && i != 5) {
                return false;
            }
            n /= i;
        }
    }
    
    // If n > 1, then it's a prime factor
    if (n > 1 && n != 2 && n != 3 && n != 5) {
        return false;
    }
    
    return true;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", isUgly(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We need to check all potential factors up to the square root of n

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for the calculation

✓ Linear Space

Constraints

-2³¹ ≤ n ≤ 2³¹ - 1
n must be checked for positive values only
Consider edge cases like 0, 1, and negative numbers

28.4K Views

Medium Frequency

~15 min Avg. Time

985 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 All Prime Factors) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler