263. Ugly Number

Problem Description

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

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

Example 1:

Input: n = 6
Output: true
Explanation: 6 = 2 × 3

Example 2:

Input: n = 1
Output: true
Explanation: 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.

Example 3:

Input: n = 14
Output: false
Explanation: 14 is not ugly since it includes the prime factor 7.

Constraints:

• -2³¹ <= n <= 2³¹ - 1

Python Solution

class Solution:
    def isUgly(self, n: int) -> bool:
        # Handle non-positive numbers
        if n <= 0:
            return False
            
        # Divide by 2, 3, and 5 as many times as possible
        for prime in [2, 3, 5]:
            while n % prime == 0:
                n //= prime
                
        # If n is 1, it means all prime factors were 2, 3, or 5
        return n == 1

Java Solution

class Solution {
    public boolean isUgly(int n) {
        // Handle non-positive numbers
        if (n <= 0) {
            return false;
        }
        
        // Divide by 2, 3, and 5 as many times as possible
        int[] primes = {2, 3, 5};
        for (int prime : primes) {
            while (n % prime == 0) {
                n /= prime;
            }
        }
        
        // If n is 1, it means all prime factors were 2, 3, or 5
        return n == 1;
    }
}

C++ Solution

class Solution {
public:
    bool isUgly(int n) {
        // Handle non-positive numbers
        if (n <= 0) {
            return false;
        }
        
        // Divide by 2, 3, and 5 as many times as possible
        vector primes = {2, 3, 5};
        for (int prime : primes) {
            while (n % prime == 0) {
                n /= prime;
            }
        }
        
        // If n is 1, it means all prime factors were 2, 3, or 5
        return n == 1;
    }
};

JavaScript Solution

/**
 * @param {number} n
 * @return {boolean}
 */
var isUgly = function(n) {
    // Handle non-positive numbers
    if (n <= 0) {
        return false;
    }
    
    // Divide by 2, 3, and 5 as many times as possible
    const primes = [2, 3, 5];
    for (const prime of primes) {
        while (n % prime === 0) {
            n /= prime;
        }
    }
    
    // If n is 1, it means all prime factors were 2, 3, or 5
    return n === 1;
};

C# Solution

public class Solution {
    public bool IsUgly(int n) {
        // Handle non-positive numbers
        if (n <= 0) {
            return false;
        }
        
        // Divide by 2, 3, and 5 as many times as possible
        int[] primes = {2, 3, 5};
        foreach (int prime in primes) {
            while (n % prime == 0) {
                n /= prime;
            }
        }
        
        // If n is 1, it means all prime factors were 2, 3, or 5
        return n == 1;
    }
}