Power Of Three

                                            
class Solution {
public:
    bool isPowerOfThree(int n) {
        return n > 0 && 1162261467 % n == 0;
    }
};

                                            
class Solution {
    public boolean isPowerOfThree(int n) {
        if (n <= 0) {
            return false;
        }
        
        return Math.log10(n) / Math.log10(3) % 1 == 0;
    }
}

                                            
class Solution(object):
    def isPowerOfThree(self, n):
        return n > 0 and 1162261467 % n == 0

                                            
bool isPowerOfThree(int n) {
    return n > 0 && 1162261467 % n == 0;
}

                                            
public class Solution {
    public bool IsPowerOfThree(int n) {
        return n > 0 && 1162261467 % n == 0;
    }
}

                                            
/**
 * @param {number} n
 * @return {boolean}
 */
var isPowerOfThree = function(n) {
    return n > 0 && 1162261467 % n === 0;
};

                                            
function isPowerOfThree(n: number): boolean {
    return n > 0 && 1162261467 % n === 0;
};

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

                                            
class Solution {
    func isPowerOfThree(_ n: Int) -> Bool {
        if n <= 0 {
            return false
        }
        
        let maxPowerOfThree = Int(pow(3.0, (log(Double(Int32.max)) / log(3.0)).rounded(.down)))
        
        return maxPowerOfThree % n == 0
    }
}

                                            
class Solution {
    fun isPowerOfThree(n: Int): Boolean {
        return n > 0 && 1162261467 % n == 0
    }
}

                                            
class Solution {
  bool isPowerOfThree(int n) {
    return n > 0 && 1162261467 % n == 0;
  }
}

                                            
func isPowerOfThree(n int) bool {
    return n > 0 && 1162261467 % n == 0
}

                                            
# @param {Integer} n
# @return {Boolean}
def is_power_of_three(n)
    n > 0 && 1162261467 % n == 0
end

                                            
object Solution {
    def isPowerOfThree(n: Int): Boolean = {
        n > 0 && 1162261467 % n == 0
    }
}

                                            
impl Solution {
    pub fn is_power_of_three(n: i32) -> bool {
        n > 0 && 1162261467 % n == 0
    }
}

                                            
(define/contract (is-power-of-three n)
  (-> exact-integer? boolean?)
  (cond
    [(<= n 0) #f]
    [(= n 1) #t]
    [(= (remainder n 3) 0) (is-power-of-three (/ n 3))]
    [else #f]
  )
)

                                            
-spec is_power_of_three(N :: integer()) -> boolean().
is_power_of_three(N) ->
    if
        N == 1 -> true;
        N > 0 andalso N rem 3 == 0 -> is_power_of_three(N div 3);
        true -> false
    end.

To solve this coding challenge, we need to determine if a given integer \( n \) is a power of three. This means we need to check if there exists an integer \( x \) such that \( 3^x = n \). Below, I will explain the methodology step-by-step and provide pseudocode to achieve the solution.

Explanation

Step-by-Step Explanation

Understanding Powers of Three : Numbers that are powers of three include 1, 3, 9, 27, etc. If\( n \) is one of these numbers, we should return
true

. Otherwise, return
false

.
Direct Calculation : One approach is to perform repeated division by 3. However, this involves using loops or recursion.
Optimized Approach Without Loops/Recursion : Mathematical properties can be useful here:

The maximum value for a signed 32-bit integer is \( 2^{31} - 1 \).
The largest power of three within this range is \( 3^{19} = 1162261467 \) (since \( 3^{20} \) slightly exceeds the limit).

Using Modulo Property : If \( n \) is a power of three, it should divide \( 1162261467 \) without leaving a remainder. This is because \( 1162261467 \) is the largest power of three in the 32-bit signed integer range.
Final Check : Combine the above observations:

If \( n \) is greater than 0 and \( 1162261467 \mod n = 0 \), then \( n \) is a power of three.
Otherwise, \( n \) is not a power of three.

Detailed Steps in Pseudocode

Declare a Function : Define a function named
isPowerOfThree

which takes an integer \( n \) as an argument.
Check for Validity : Immediately check whether \( n \) is greater than zero because powers of three are positive integers.
Modulo Operation : Use the modulo operator to check whether \( 1162261467 \mod n = 0 \).
Return Result : If both conditions are satisfied, return
true

; otherwise, return
false

.

Pseudocode

                                            
# Define the function to check power of three
function isPowerOfThree(n):
    # Check if n is greater than 0
    if n > 0:
        # Check if n divides 1162261467 without leaving a remainder
        if 1162261467 % n == 0:
            # n is a power of three
            return true
        else:
            # n is not a power of three
            return false
    else:
        # n is not greater than 0 and hence cannot be a power of three
        return false

The explanation above provides a clear methodology and detailed steps to determine if a given integer \( n \) is a power of three. The pseudocode follows the described logic, checking whether \( n \) is positive and then using the modulo operation to determine if \( n \) is a power of three. This approach avoids the use of loops or recursion and leverages mathematical properties for an optimized solution.