Checking if a number is some power of the other JavaScript

In this problem statement, our objective is to check if a given input number is some power of another number using JavaScript functionalities.

Logic for the Problem

To determine if a number a is a power of another number b, we can use logarithms. If a = b^n for some integer n, then log_b(a) = n should be an integer.

Since JavaScript's Math.log() returns the natural logarithm, we use the change of base formula: log_b(a) = ln(a) / ln(b). If this result is an integer, then a is a power of b.

Algorithm

Step 1 ? Declare a function called powerOfOther with two parameters a and b.

Step 2 ? Calculate the logarithm of a with base b using the formula Math.log(a) / Math.log(b).

Step 3 ? Check if the result is an integer using Number.isInteger().

Step 4 ? Return true if it's an integer, false otherwise.

Example Implementation

function powerOfOther(a, b) {
   // Handle edge cases
   if (a <= 0 || b <= 0 || b === 1) {
      return false;
   }
   
   // Calculate the logarithm of a with base b
   const result = Math.log(a) / Math.log(b);
   
   // Check if the result is an integer
   return Number.isInteger(result);
}

// Example usage
console.log(powerOfOther(8, 2));    // 8 = 2^3
console.log(powerOfOther(27, 3));   // 27 = 3^3
console.log(powerOfOther(16, 4));   // 16 = 4^2
console.log(powerOfOther(10, 2));   // 10 is not a power of 2
console.log(powerOfOther(1, 5));    // 1 = 5^0

true
true
true
false
true

Alternative Approach Using Loop

For integer bases, you can also use a loop-based approach:

function powerOfOtherLoop(a, b) {
   if (a <= 0 || b <= 0 || b === 1) {
      return false;
   }
   
   if (a === 1) {
      return true; // 1 is b^0 for any base b
   }
   
   let power = 1;
   while (power < a) {
      power *= b;
   }
   
   return power === a;
}

// Test the loop approach
console.log(powerOfOtherLoop(32, 2));   // 32 = 2^5
console.log(powerOfOtherLoop(125, 5));  // 125 = 5^3
console.log(powerOfOtherLoop(30, 3));   // 30 is not a power of 3

true
true
false

Comparison of Approaches

Edge Cases to Consider

Both implementations handle important edge cases:

• Negative numbers return false
• Base of 1 returns false (would cause infinite loop)
• The number 1 returns true (since 1 = b^0 for any base)

Conclusion

The logarithmic approach provides an efficient O(1) solution for checking if a number is a power of another. For integer operations requiring exact precision, the loop-based method is more reliable despite being slightly slower.