Ugly Number

                                            
class Solution {
public:
    bool isUgly(int n) {
        if(n <= 0) return false;
        
        while(n % 2 == 0) {
            n /= 2;
        }
        
        while(n % 3 == 0) {
            n /= 3;
        }
        
        while(n % 5 == 0) {
            n /= 5;
        }
        
        return n == 1;
    }
};

                                            
class Solution {
    public boolean isUgly(int n) {
        if(n <= 0) {
            return false;
        }
        
        while(n % 2 == 0) {
            n /= 2;
        }
        
        while(n % 3 == 0) {
            n /= 3;
        }
        
        while(n % 5 == 0) {
            n /= 5;
        }
        
        return n == 1;
    }
}

                                            
class Solution(object):
    def isUgly(self, n):
        """
        :type n: int
        :rtype: bool
        """
        if n <= 0:
            return False
        while n % 2 == 0:
            n /= 2
        while n % 3 == 0:
            n /= 3
        while n % 5 == 0:
            n /= 5
        return n == 1

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

                                            
public class Solution {
    public bool IsUgly(int n) {
        if (n <= 0) {
            return false;
        }
        
        while (n % 2 == 0) {
            n /= 2;
        }
        
        while (n % 3 == 0) {
            n /= 3;
        }
        
        while (n % 5 == 0) {
            n /= 5;
        }
        
        return n == 1;
    }
}

                                            
/**
 * @param {number} n
 * @return {boolean}
 */
const isUgly = (n) => {
    if (n <= 0) {
        return false;
    }
    
    while (n % 2 === 0) {
        n /= 2;
    }
    
    while (n % 3 === 0) {
        n /= 3;
    }
    
    while (n % 5 === 0) {
        n /= 5;
    }
    
    return n === 1;
};

                                            
function isUgly(n: number): boolean {
    if (n <= 0) {
        return false;
    }
    
    while (n % 2 === 0) {
        n /= 2;
    }

    while (n % 3 === 0) {
        n /= 3;
    }

    while (n % 5 === 0) {
        n /= 5;
    }

    return n === 1;
};

                                            
class Solution {
    /**
     * @param Integer $n
     * @return Boolean
     */
    function isUgly($n) {
        if ($n <= 0) {
            return false;
        }
        
        while ($n % 2 == 0) {
            $n /= 2;
        }
        while ($n % 3 == 0) {
            $n /= 3;
        }
        while ($n % 5 == 0) {
            $n /= 5;
        }
        
        return $n == 1;
    }
}

                                            
class Solution {
    func isUgly(_ n: Int) -> Bool {
        if n <= 0 {
            return false
        }
        
        var num = n
        
        while num % 2 == 0 {
            num /= 2
        }
        
        while num % 3 == 0 {
            num /= 3
        }
        
        while num % 5 == 0 {
            num /= 5
        }
        
        return num == 1
    }
}

                                            
class Solution {
    fun isUgly(n: Int): Boolean {
        if (n <= 0) return false
        var num = n
        while (num % 2 == 0) num /= 2
        while (num % 3 == 0) num /= 3
        while (num % 5 == 0) num /= 5
        return num == 1
    }
}

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

                                            
func isUgly(n int) bool {
    if n <= 0 {
        return false
    }
    
    for n%2 == 0 {
        n /= 2
    }
    
    for n%3 == 0 {
        n /= 3
    }
    
    for n%5 == 0 {
        n /= 5
    }
    
    return n == 1
}

                                            
# @param {Integer} n
# @return {Boolean}
def is_ugly(n)
    return false if n <= 0
    while n % 2 == 0
        n /= 2
    end
    while n % 3 == 0
        n /= 3
    end
    while n % 5 == 0
        n /= 5
    end
    n == 1
end

                                            
object Solution {
    def isUgly(n: Int): Boolean = {
        if (n <= 0) {
            return false
        }
        
        var num = n
        
        while (num % 2 == 0) {
            num /= 2
        }
        
        while (num % 3 == 0) {
            num /= 3
        }
        
        while (num % 5 == 0) {
            num /= 5
        }
        
        num == 1
    }
}

                                            
impl Solution {
    pub fn is_ugly(n: i32) -> bool {
        if n <= 0 {
            return false;
        }
        let mut num = n;
        while num % 2 == 0 {
            num /= 2;
        }
        while num % 3 == 0 {
            num /= 3;
        }
        while num % 5 == 0 {
            num /= 5;
        }
        num == 1
    }
}

                                            
(define/contract (is-ugly n)
  (-> exact-integer? boolean?)
  (cond
    ((<= n 0) #f)
    ((= n 1) #t)
    ((= (modulo n 2) 0) (is-ugly (/ n 2)))
    ((= (modulo n 3) 0) (is-ugly (/ n 3)))
    ((= (modulo n 5) 0) (is-ugly (/ n 5)))
    (else #f)
    )
  )

                                            
is_ugly(N) ->
    case N of
        0 -> false;
        _ when N rem 2 == 0 -> is_ugly(N div 2);
        _ when N rem 3 == 0 -> is_ugly(N div 3);
        _ when N rem 5 == 0 -> is_ugly(N div 5);
        1 -> true;
        _ -> false
    end.

                                            
defmodule Solution do
  @spec is_ugly(n :: integer) :: boolean
  def is_ugly(n) do
    cond do
      n <= 0 -> false
      rem(n, 2) == 0 -> is_ugly(div(n, 2))
      rem(n, 3) == 0 -> is_ugly(div(n, 3))
      rem(n, 5) == 0 -> is_ugly(div(n, 5))
      n == 1 -> true
      true -> false
    end
  end
end

To solve this coding challenge, we need to determine if a given positive integer \( n \) is an "ugly number." An ugly number is defined as a positive integer whose prime factors are limited to 2, 3, and 5. Therefore, any number that has only these prime factors (or is 1) will be considered ugly.

Explanation:

Understanding the Problem : First, we need to reduce any integer \( n \) by its prime factors (2, 3, and 5) iteratively. If after completely dividing \( n \) by these factors the result is 1, then \( n \) is an ugly number.
Special Case Handling : Any integer less than or equal to 0 cannot be an ugly number because an ugly number is defined as a positive integer. Hence, we can immediately return
False

for such cases.
Iterative Division :

Continuously divide \( n \) by 2 as long as \( n \) is divisible by 2.
Repeat the same process for 3 and 5.
Finally, check if the resultant \( n \) is 1. If it is, then \( n \) consists only of the prime factors 2, 3, and 5. Otherwise, it has other prime factors, and we should return
False

.

Detailed Steps in Pseudocode:

Initialization and Edge Case Check :

If \( n \) is less than or equal to 0, return
False

.

Divide by Prime Factors :

While \( n \) is divisible by 2, divide \( n \) by 2.
While \( n \) is divisible by 3, divide \( n \) by 3.
While \( n \) is divisible by 5, divide \( n \) by 5.

Final Check :

After all divisions, if \( n \) is equal to 1, return
True

(it is an ugly number).
Otherwise, return
False

(it is not an ugly number).

Pseudocode:

                                            
// Function to check if the number is ugly
function isUglyNumber(n):
    // Step 1: Handle edge case
    if n <= 0:
        return False

    // Step 2: Process all prime factors 2, 3, and 5
    while n % 2 == 0:
        n = n / 2

    while n % 3 == 0:
        n = n / 3

    while n % 5 == 0:
        n = n / 5

    // Step 3: Final check
    if n == 1:
        return True
    else:
        return False

Clarification and Additional Details:

The problem constraints specify that \( n \) can be an integer from \( -2^{31} \) to \( 2^{31} - 1 \). Since the problem specifies an "ugly number" as a positive integer, the function immediately returns
False

if \( n \) is non-positive, aligning with the given constraints.
By continuously dividing \( n \) by 2, 3, and 5, we systematically remove these prime factors. If no other factors remain (i.e., \( n \) becomes 1), we confirm \( n \) could only be made up of these primes, validating its "ugliness".

This approach ensures we cover all cases mentioned in the problem's examples and any additional edge cases resulting from the constraints.