# Check whether N is Kth power of an integer

• Difficulty Level : Easy
• Last Updated : 09 Jun, 2022

Given two numbers N and K. The task is to check whether N is Kth power to any integer i.e., whether N can be expressed as XK, where X is an integer.

Examples:

Input: N = 81, K = 4
Output: True
Explanation: 81 can be expressed as 34

Input: N = 26, K = 2
Output: False
Explanation: 26 can not be expressed as power of 2 to any number

Input: N = 512, K = 3
Output: True
Explanation: 512 can be expressed 83

Naive Approach: To solve this problem we can traverse from 1 to N and check whether the number N is Kth power to the current number.

Time Complexity: O(N)
Auxiliary Space: O(1)

Efficient Approach: The efficient approach to solve the above problem is based on the following idea:

Say the number N is Kth power of some integer X. So,
N = XK
or X = N1/K. Now if X is an integer then the solution exists.

So we need to find if the floor of Kth root of N is the actual Kth root or not

Follow the steps mentioned below to implement the idea:

• Check if K is 0 or not. If K is 0 and N = 1 then its possible that N is Kth power of any number.
• Store the reciprocal of K (say x) and then find the xth root of N.
• If both the ceil and the floor value of xth root of N is equal then it is possible that N is Kth of any number.
• If none of the above conditions is true then no such solution is possible.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to check whether n is``// kth power of an integer``bool` `check_Kth_power(``int` `n, ``int` `k)``{``    ``// Checking for special case when k=0``    ``if` `(k == 0) {``        ``if` `(n == 1) {``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}``    ``else` `{` `        ``// Calculating reciprocal of k``        ``double` `reciprocal = (``double``)(1) / (``double``)(k);` `        ``// The result for n^(1/k)``        ``double` `result = ``pow``(n, reciprocal);` `        ``// Checking condition for an integer``        ``if` `(``floor``(result) == ``ceil``(result)) {``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 81;``    ``int` `K = 4;` `    ``// Function call``    ``bool` `ans = check_Kth_power(N, K);``    ``if` `(ans)``        ``cout << ``"True"``;``    ``else``        ``cout << ``"False"``;``    ``return` `0;``}`

## C

 `// C code to implement the approach` `#include ``#include ``#include ` `// Function to check  whether n is kth power``// to an integer``bool` `check_Kth_power(``int` `n, ``int` `k)``{``    ``// Checking for special case when k=0``    ``if` `(k == 0) {``        ``if` `(n == 1) {``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}` `    ``else` `{` `        ``// Calculating reciprocal of k``        ``double` `reciprocal = (``double``)(1) / (``double``)(k);` `        ``// The result for n^(1/k)``        ``double` `result = ``pow``(n, reciprocal);` `        ``// Checking condition for an integer``        ``if` `(``floor``(result) == ``ceil``(result)) {``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `N = 81;``    ``int` `K = 4;` `    ``// Function call``    ``bool` `ans = check_Kth_power(N, K);``    ``if` `(ans == ``true``)``        ``printf``(``"True"``);``    ``else``        ``printf``(``"False"``);``    ``return` `0;``}`

## Java

 `// Java code  to implement the approach` `import` `java.io.*;``import` `java.lang.Math;` `class` `GFG {` `    ``// Function to check  whether n is kth power``    ``// to an integer``    ``public` `static` `Boolean check_Kth_power(``int` `n,``                                          ``int` `k)``    ``{``        ``// Checking for special case when k=0``        ``if` `(k == ``0``) {``            ``if` `(n == ``1``) {``                ``return` `true``;``            ``}``            ``return` `false``;``        ``}``        ``else` `{` `            ``// Calculating reciprocal of k``            ``double` `reciprocal = (``double``)(``1``) / (``double``)(k);` `            ``// The result for n^(1/k)``            ``double` `result = Math.pow(n, reciprocal);` `            ``// Checking condition for an integer``            ``if` `(Math.floor(result) == Math.ceil(result)) {``                ``return` `true``;``            ``}``            ``return` `false``;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``81``;``        ``int` `K = ``4``;` `        ``// Function call``        ``Boolean ans = check_Kth_power(N, K);``        ``if` `(ans == ``true``)``            ``System.out.println(``"True"``);``        ``else``            ``System.out.println(``"False"``);``    ``}``}`

## Python3

 `# python code to implement the approach``import` `math` `# Function to check whether n is``# kth power of an integer``def` `check_Kth_power( n, k):``  ` `  ``# Checking for special case when k=0``  ``if` `(k ``=``=` `0``):``    ``if` `(n ``=``=` `1``):``      ``return` `True``    ``return` `False``  ``else``:``    ``# Calculating reciprocal of k``    ``reciprocal ``=` `(``1``) ``/``/` `(k)``    ` `    ``# The result for n^(1/k)``    ``result ``=` `n``*``*``reciprocal``    ` `    ``# Checking condition for an integer``    ``if` `math.floor(result) ``=``=` `math.ceil(result):``      ``return` `True``        ` `    ``return` `False``    ` `# Driver Code``N ``=` `81``K ``=` `4` `# Function call``ans ``=` `check_Kth_power(N, K)``if` `(ans):``  ``print``(``"True"``)``else``:``  ``print``(``"False"``)``  ` `  ``# This code is contributed by rohitsingh07052.`

## C#

 `// C# code to implement the approach``using` `System;` `public` `class` `GFG {` `    ``// Function to check  whether n is kth power``    ``// to an integer``    ``static` `Boolean check_Kth_power(``int` `n, ``int` `k)``    ``{``        ``// Checking for special case when k=0``        ``if` `(k == 0) {``            ``if` `(n == 1) {``                ``return` `true``;``            ``}``            ``return` `false``;``        ``}``        ``else` `{` `            ``// Calculating reciprocal of k``            ``double` `reciprocal = (``double``)(1) / (``double``)(k);` `            ``// The result for n^(1/k)``            ``double` `result = Math.Pow(n, reciprocal);` `            ``// Checking condition for an integer``            ``if` `(Math.Floor(result)``                ``== Math.Ceiling(result)) {``                ``return` `true``;``            ``}``            ``return` `false``;``        ``}``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int` `N = 81;``        ``int` `K = 4;` `        ``// Function call``        ``Boolean ans = check_Kth_power(N, K);``        ``if` `(ans == ``true``)``            ``Console.WriteLine(``"True"``);``        ``else``            ``Console.WriteLine(``"False"``);``    ``}``}` `// This code is contributed by Rohit Pradhan`

## Javascript

 ``

Output

`True`

Time Complexity: O(log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up