Check if a number is a power of another number

Last Updated : 12 Mar, 2025

Given two positive numbers x and y, check if y is a power of x or not.
Examples :

Input: x = 10, y = 1
Output: True
x^0 = 1

Input: x = 10, y = 1000
Output: True
x^3 = 1

Input: x = 10, y = 1001
Output: False

[Naive Approach] Repeated Multiplication Method

This approach checks whether a number y is a power of another number x by repeatedly multiplying x until it either matches or exceeds y. It starts with an initial value of 1 and keeps multiplying it by x in a loop. If the resulting value becomes equal to y, then y is a power of x; otherwise, if it exceeds y without a match, the function returns false. This method efficiently verifies powers by iteratively computing exponential values instead of using logarithms or recursion.

C++

#include <bits/stdc++.h> using namespace std;  bool isPower(int x, long int y) {     // The only power of 1 is 1 itself     if (x == 1)         return (y == 1);      // Repeatedly compute power of x     long int pow = 1;     while (pow < y)         pow *= x;      // Check if power of x becomes y     return (pow == y); }   int main() {     cout << boolalpha;       cout << isPower(10, 1) << endl;         cout << isPower(1, 20) << endl;         cout << isPower(2, 128) << endl;        cout << isPower(2, 30) << endl;         return 0; }

#include <stdio.h>  int isPower(int x, long int y) {     // The only power of 1 is 1 itself     if (x == 1)         return (y == 1);      // Repeatedly compute power of x     long int pow = 1;     while (pow < y)         pow *= x;      // Check if power of x becomes y     return (pow == y); }  int main() {     printf("%d\n", isPower(10, 1));     printf("%d\n", isPower(1, 20));     printf("%d\n", isPower(2, 128));     printf("%d\n", isPower(2, 30));     return 0; }

Java

public class Main {     public static boolean isPower(int x, long y) {         // The only power of 1 is 1 itself         if (x == 1)             return (y == 1);          // Repeatedly compute power of x         long pow = 1;         while (pow < y)             pow *= x;          // Check if power of x becomes y         return (pow == y);     }      public static void main(String[] args) {         System.out.println(isPower(10, 1));         System.out.println(isPower(1, 20));         System.out.println(isPower(2, 128));         System.out.println(isPower(2, 30));     } }

Python

def isPower(x, y):     # The only power of 1 is 1 itself     if x == 1:         return y == 1      # Repeatedly compute power of x     pow = 1     while pow < y:         pow *= x      # Check if power of x becomes y     return pow == y  if __name__ == '__main__':     print(isPower(10, 1))     print(isPower(1, 20))     print(isPower(2, 128))     print(isPower(2, 30))

using System;  class Program {     static bool isPower(int x, long y) {         // The only power of 1 is 1 itself         if (x == 1)             return (y == 1);          // Repeatedly compute power of x         long pow = 1;         while (pow < y)             pow *= x;          // Check if power of x becomes y         return (pow == y);     }      static void Main() {         Console.WriteLine(isPower(10, 1));         Console.WriteLine(isPower(1, 20));         Console.WriteLine(isPower(2, 128));         Console.WriteLine(isPower(2, 30));     } }

JavaScript

function isPower(x, y) {     // The only power of 1 is 1 itself     if (x === 1)         return y === 1;      // Repeatedly compute power of x     let pow = 1;     while (pow < y)         pow *= x;      // Check if power of x becomes y     return pow === y; }  console.log(isPower(10, 1)); console.log(isPower(1, 20)); console.log(isPower(2, 128)); console.log(isPower(2, 30));

Output

true false true false

Time complexity: O(Log_xy)
Auxiliary space: O(1)

[Better Approach] Exponentiation and Binary Search Method

This approach efficiently checks if a number y is a power of another number x by leveraging exponential growth and binary search. It first attempts to reach or exceed y by repeatedly squaring x, which significantly reduces the number of multiplications compared to simple iteration. If the squared value matches y, the function returns true. If it overshoots y, a binary search is performed between the last two computed powers of x to find an exact match.

C++

#include <bits/stdc++.h> using namespace std;  bool isPower(int x, long int y) {     if (x == 1) return (y == 1);      long int pow = x, i = 1;      while (pow < y) {         pow *= pow;         i *= 2;     }      if (pow == y) return true;      long int low = x, high = pow;     while (low <= high) {         long int mid = low + (high - low) / 2;         long int result = powl(x, log2(mid) / log2(x));          if (result == y) return true;         if (result < y) low = mid + 1;         else high = mid - 1;     }      return false; }  int main() {     cout << boolalpha;     cout << isPower(10, 1) << endl;     cout << isPower(1, 20) << endl;     cout << isPower(2, 128) << endl;     cout << isPower(2, 30) << endl;     return 0; }

#include <stdio.h> #include <math.h>  int isPower(int x, long int y) {     if (x == 1) return (y == 1);      long int pow = x;      while (pow < y) {         pow *= x;     }      return (pow == y) ? 1 : 0; }  int main() {     printf("%s\n", isPower(10, 1) ? "true" : "false");     printf("%s\n", isPower(1, 20) ? "true" : "false");     printf("%s\n", isPower(2, 128) ? "true" : "false");     printf("%s\n", isPower(2, 30) ? "true" : "false");     return 0; }

Java

public class PowerCheck {     public static boolean isPower(int x, long y) {         if (x == 1) return (y == 1);          long pow = x;          while (pow < y) {             pow *= pow;         }          if (pow == y) return true;          long low = x, high = pow;         while (low <= high) {             long mid = low + (high - low) / 2;             long result = (long) Math.pow(x, Math.log(mid) / Math.log(x));              if (result == y) return true;             if (result < y) low = mid + 1;             else high = mid - 1;         }          return false;     }      public static void main(String[] args) {         System.out.println(isPower(10, 1));         System.out.println(isPower(1, 20));         System.out.println(isPower(2, 128));         System.out.println(isPower(2, 30));     } }

Python

import math  def isPower(x, y):     if x == 1:         return y == 1      pow = x      while pow < y:         pow *= x      if pow == y:         return True      low, high = x, pow     while low <= high:         mid = low + (high - low) // 2         result = int(x ** (math.log(mid) / math.log(x)))          if result == y:             return True         if result < y:             low = mid + 1         else:             high = mid - 1      return False  print("true" if isPower(10, 1) else "false") print("true" if isPower(1, 20) else "false") print("true" if isPower(2, 128) else "false") print("true" if isPower(2, 30) else "false")

using System;  class Program {     public static bool IsPower(int x, long y) {         if (x == 1) return (y == 1);          long pow = x;          while (pow < y) {             pow *= pow;         }          if (pow == y) return true;          long low = x, high = pow;         while (low <= high) {             long mid = low + (high - low) / 2;             long result = (long)Math.Pow(x, Math.Log(mid) / Math.Log(x));              if (result == y) return true;             if (result < y) low = mid + 1;             else high = mid - 1;         }          return false;     }      static void Main() {         Console.WriteLine(IsPower(10, 1));         Console.WriteLine(IsPower(1, 20));         Console.WriteLine(IsPower(2, 128));         Console.WriteLine(IsPower(2, 30));     } }

JavaScript

function isPower(x, y) {     if (x === 1) return (y === 1);      let pow = x;      while (pow < y) {         pow *= pow;     }      if (pow === y) return true;      let low = x, high = pow;     while (low <= high) {         let mid = Math.floor((low + high) / 2);         let result = Math.pow(x, Math.log(mid) / Math.log(x));          if (result === y) return true;         if (result < y) low = mid + 1;         else high = mid - 1;     }      return false; }  console.log(isPower(10, 1)); console.log(isPower(1, 20)); console.log(isPower(2, 128)); console.log(isPower(2, 30));

Output

false false true true

Time Complexity – O(log log y)
Auxiliary Space – O(1)

[Expected Approach] Logarithmic Method

This approach checks if y is a power of x using logarithms. By applying the logarithm change of base formula, it computes log⁡_y(x)=log⁡(y)/log⁡(x). If the result is an integer, it means that y is an exact power of x, and the function returns true. Otherwise, it returns false.

C++

#include <iostream> #include <math.h> using namespace std;  bool isPower(int x, int y) {     float res1 = log(y) / log(x);     return res1 == floor(res1); }  int main() {     cout << boolalpha;     cout << isPower(2, 128) << endl;     return 0; }

#include <stdio.h> #include <math.h> #include <stdbool.h>  bool isPower(int x, int y) {     double res1 = log(y) / log(x);     return res1 == floor(res1); }  int main() {     printf("%s\n", isPower(2, 128) ? "true" : "false");     return 0; }

Java

import java.lang.Math;  public class Main {     public static boolean isPower(int x, int y) {         double res1 = Math.log(y) / Math.log(x);         return res1 == Math.floor(res1);     }      public static void main(String[] args) {         System.out.println(isPower(2, 128));     } }

Python

import math  def isPower(x, y):     res1 = math.log(y) / math.log(x)     return res1 == math.floor(res1)  print(isPower(2, 128))

using System;  class Program {     static bool IsPower(int x, int y) {         double res1 = Math.Log(y) / Math.Log(x);         return res1 == Math.Floor(res1);     }      static void Main() {         Console.WriteLine(IsPower(2, 128));     } }

JavaScript

function isPower(x, y) {     let res1 = Math.log(y) / Math.log(x);     return res1 === Math.floor(res1); }  console.log(isPower(2, 128));

Output

true

Time complexity: O(1)
Auxiliary space: O(1)

Program to evaluate simple expressions

kartik

Improve

Article Tags :

Practice Tags :

Check if a number is a power of another number

[Naive Approach] Repeated Multiplication Method

[Better Approach] Exponentiation and Binary Search Method

[Expected Approach] Logarithmic Method

Similar Reads

Divisibility & Large Numbers

GCD and LCM

Series

Number Digits

Algebra

Number System

Prime Numbers & Primality Tests

Prime Factorization & Divisors

Modular Arithmetic