Open in App
Not now

# Find whether a given number is a power of 4 or not

• Difficulty Level : Medium
• Last Updated : 31 Mar, 2023

Given an integer n, find whether it is a power of 4 or not.

Example :

```Input : 16
Output : 16 is a power of 4

Input : 20
Output : 20 is not a power of 4```

## We strongly recommend that you click here and practice it, before moving on to the solution.

Method 1: Using the in-built log method: Take log of given number to the base 4, and then raise 4 to this result. If the output is equal to n, then given number is a power of 4, else not.

## C++

 `// C++ program to find whether a given ` `// number is a power of 4 or not` `#include`   `using` `namespace` `std;`   `class` `GFG` `{` `    `  `/* Function to check if x is power of 4*/` `public` `: ``bool` `isPowerOfFour(``int` `n)` `{` `    ``if``(n == ``pow``(4, (``int``)(``log``(n)/``log``(4))) && n != 0)` `        ``return` `true``;` `    ``return` `false``;` `}` `};`   `/*Driver code*/` `int` `main()` `{` `    ``GFG g;` `    ``int` `test_no = 64;` `    ``if``(g.isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"``;` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``;` `}`   `// This code is contributed by devendra123world`

## Java

 `// Java program to find whether a given number is a power of` `// 4 or not`   `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to check if x is a power of 4` `    ``public` `boolean` `isPowerOfFour(``int` `n)` `    ``{` `        ``if` `(n != ``0` `&& n == (``int``)Math.pow(``4``, (Math.log(n) / Math.log(``4``)))) {` `            ``return` `true``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``GFG g = ``new` `GFG();` `        ``int` `test_no = ``64``;` `        ``if` `(g.isPowerOfFour(test_no)) {` `            ``System.out.print(test_no + ``" is a power of 4 "``);` `        ``}` `        ``else` `{` `            ``System.out.print(test_no` `                             ``+ ``" is not a power of 4"``);` `        ``}` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## C#

 `// C# program to find whether a given number is a power of 4` `// or not.`   `using` `System;`   `public` `class` `GFG {`   `    ``// Function to check if x is power of 4` `    ``public` `bool` `isPowerOfFour(``int` `n)` `    ``{` `        ``if` `(n != 0 && n == Math.Pow(4, (Math.Log(n) / Math.Log(4)))) {` `            ``return` `true``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``GFG g = ``new` `GFG();` `        ``int` `test_no = 64;` `        ``if` `(g.isPowerOfFour(test_no)) {` `            ``Console.Write(test_no + ``" is a power of 4"``);` `        ``}` `        ``else` `{` `            ``Console.Write(test_no + ``" is not a power of 4"``);` `        ``}` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21)`

## Python3

 `# Python program to find whether a given number is a power of 4 or not.`   `import` `math`     `# Function to check if x is power of 4` `def` `isPowerOfFour(n):` `    ``if` `(n !``=` `0` `and` `n ``=``=` `pow``(``4``, (math.log(n)``/``math.log(``4``)))):` `        ``return` `True` `    ``return` `False`     `test_no ``=` `64` `if``(isPowerOfFour(test_no)):` `    ``print``(test_no, ``' is a power of 4'``)` `else``:` `    ``print``(test_no, ``' is not a power of 4'``)`     `# This code is contributed by lokesh (lokeshmvs21).`

## Javascript

 ``

Output

`64 is a power of 4`

Time Complexity: O(log(log2(n))*log2(n))
Auxiliary Space: O(1)

Method 2: Another solution is to keep dividing the number by 4, i.e, do n = n/4 iteratively. In any iteration, if n%4 becomes non-zero and n is not 1 then n is not a power of 4, otherwise, n is a power of 4.

## C++

 `// C++ program to find whether a given ` `// number is a power of 4 or not` `#include`   `using` `namespace` `std;` `#define bool int`   `class` `GFG` `{` `    `  `/* Function to check if x is power of 4*/` `public` `: ``bool` `isPowerOfFour(``int` `n)` `{` `    ``if``(n == 0)` `        ``return` `0;` `    ``while``(n != 1)` `    ``{ ` `        ``if``(n % 4 != 0)` `            ``return` `0;` `        ``n = n / 4; ` `    ``}` `    ``return` `1;` `}` `};`   `/*Driver code*/` `int` `main()` `{` `    ``GFG g;` `    ``int` `test_no = 64;` `    ``if``(g.isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"``;` `    ``else` `        ``cout << test_no << ``"is not a power of 4"``;` `    ``getchar``();` `}`   `// This code is contributed by SoM15242`

## C

 `#include` `#define bool int`   `/* Function to check if x is power of 4*/` `bool` `isPowerOfFour(``int` `n)` `{` `  ``if``(n == 0)` `    ``return` `0;` `  ``while``(n != 1)` `  ``{    ` `   ``if``(n % 4 != 0)` `      ``return` `0;` `    ``n = n / 4;      ` `  ``}` `  ``return` `1;` `} `   `/*Driver program to test above function*/` `int` `main()` `{` `  ``int` `test_no = 64;` `  ``if``(isPowerOfFour(test_no))` `    ``printf``(``"%d is a power of 4"``, test_no);` `  ``else` `    ``printf``(``"%d is not a power of 4"``, test_no);` `  ``getchar``();` `}`

## Java

 `// Java code to check if given` `// number is power of 4 or not`   `class` `GFG {`   `    ``// Function to check if ` `    ``// x is power of 4` `    ``static` `int` `isPowerOfFour(``int` `n)` `    ``{` `        ``if``(n == ``0``)` `        ``return` `0``;` `        ``while``(n != ``1``)` `        ``{ ` `            ``if``(n % ``4` `!= ``0``)` `            ``return` `0``;` `            ``n = n / ``4``;     ` `        ``}` `        ``return` `1``;` `    ``} `   `    ``// Driver program ` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `test_no = ``64``;` `        ``if``(isPowerOfFour(test_no) == ``1``)` `         ``System.out.println(test_no + ` `                           ``" is a power of 4"``);` `        ``else` `         ``System.out.println(test_no + ` `                           ``"is not a power of 4"``);` `    ``}` `}`   `// This code is contributed` `// by  prerna saini`

## Python3

 `# Python3 program to check if given` `# number is power of 4 or not `   `# Function to check if x is power of 4` `def` `isPowerOfFour(n):` `    ``if` `(n ``=``=` `0``):` `        ``return` `False` `    ``while` `(n !``=` `1``):` `            ``if` `(n ``%` `4` `!``=` `0``):` `                ``return` `False` `            ``n ``=` `n ``/``/` `4` `            `  `    ``return` `True`   `# Driver code` `test_no ``=` `64` `if``(isPowerOfFour(``64``)):` `    ``print``(test_no, ``'is a power of 4'``)` `else``:` `    ``print``(test_no, ``'is not a power of 4'``)`   `# This code is contributed by Danish Raza`

## C#

 `// C# code to check if given` `// number is power of 4 or not` `using` `System;`   `class` `GFG {` `    `  `    ``// Function to check if` `    ``// x is power of 4` `    ``static` `int` `isPowerOfFour(``int` `n)` `    ``{` `        ``if` `(n == 0)` `            ``return` `0;` `        ``while` `(n != 1) {` `            ``if` `(n % 4 != 0)` `                ``return` `0;` `            ``n = n / 4;` `        ``}` `        ``return` `1;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `test_no = 64;` `        ``if` `(isPowerOfFour(test_no) == 1)` `            ``Console.Write(test_no + ` `                    ``" is a power of 4"``);` `        ``else` `            ``Console.Write(test_no + ` `                ``" is not a power of 4"``);` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 3: A number n is a power of 4 if the following conditions are met.
a) There is only one bit set in the binary representation of n (or n is a power of 2)
b) The count of zero bits before the (only) set bit is even.
For example 16 (10000) is the power of 4 because there is only one bit set and count of 0s before the set bit is 4 which is even.
Thanks to Geek4u for suggesting the approach and providing the code.

## C++

 `// C++ program to check ` `// if given number is ` `// power of 4 or not ` `#include`   `using` `namespace` `std;`   `bool` `isPowerOfFour(unsigned ``int` `n)` `{` `    ``int` `count = 0;`   `    ``/*Check if there is only one bit set in n*/` `    ``if` `( n && !(n&(n-1)) )` `    ``{` `        ``/* count 0 bits before set bit */` `        ``while``(n > 1)` `        ``{` `            ``n >>= 1;` `            ``count += 1;` `        ``} `   `        ``/*If count is even then ` `        ``return true else false*/` `        ``return` `(count%2 == 0)? 1 :0;` `    ``}`   `    ``/* If there are more than 1 bit set` `    ``then n is not a power of 4*/` `    ``return` `0;` `} `   `/*Driver code*/` `int` `main()` `{` `    ``int` `test_no = 64;` `    ``if``(isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"` `;` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``;` `}`   `// This code is contributed by Shivi_Aggarwal`

## C

 `#include` `#define bool int`   `bool` `isPowerOfFour(unsigned ``int` `n)` `{` `  ``int` `count = 0;`   `  ``/*Check if there is only one bit set in n*/` `  ``if` `( n && !(n&(n-1)) )` `  ``{` `     ``/* count 0 bits before set bit */` `     ``while``(n > 1)` `     ``{` `       ``n  >>= 1;` `       ``count += 1;` `     ``}      `   `    ``/*If count is even then return true else false*/` `    ``return` `(count%2 == 0)? 1 :0;` `  ``}`   `  ``/* If there are more than 1 bit set` `    ``then n is not a power of 4*/` `  ``return` `0;` `}    `   `/*Driver program to test above function*/` `int` `main()` `{` `   ``int` `test_no = 64;` `   ``if``(isPowerOfFour(test_no))` `     ``printf``(``"%d is a power of 4"``, test_no);` `   ``else` `     ``printf``(``"%d is not a power of 4"``, test_no);` `   ``getchar``();` `}`

## Java

 `// Java program to check ` `// if given number is ` `// power of 4 or not ` `import` `java.io.*;` `class` `GFG ` `{` `    ``static` `int` `isPowerOfFour(``int` `n)` `    ``{` `        ``int` `count = ``0``;` `        `  `        ``/*Check if there is ` `        ``only one bit set in n*/` `        ``int` `x = n & (n - ``1``);` `        `  `        ``if` `( n > ``0` `&& x == ``0``)` `        ``{` `            ``/* count 0 bits ` `            ``before set bit */` `            ``while``(n > ``1``)` `            ``{` `                ``n >>= ``1``;` `                ``count += ``1``;` `            ``} ` `        `  `            ``/*If count is even ` `            ``then return true` `            ``else false*/` `            ``return` `(count % ``2` `== ``0``) ? ``1` `: ``0``;` `        ``}` `        `  `            ``/* If there are more than ` `            ``1 bit set then n is not a` `            ``power of 4*/` `        ``return` `0``;` `    ``} `   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `test_no = ``64``;` `        `  `        ``if``(isPowerOfFour(test_no)>``0``)` `            ``System.out.println(test_no +` `                               ``" is a power of 4"``);` `        ``else` `            ``System.out.println(test_no +` `                               ``" is not a power of 4"``);` `    ``}` `}`   `// This code is contributed by mits`

## Python3

 `# Python3 program to check if given` `# number is power of 4 or not `   `# Function to check if x is power of 4` `def` `isPowerOfFour(n):` `    `  `    ``count ``=` `0` `    `  `    ``# Check if there is only one ` `    ``# bit set in n` `    ``if` `(n ``and` `(``not``(n & (n ``-` `1``)))):` `        `  `        ``# count 0 bits before set bit ` `        ``while``(n > ``1``):` `            ``n >>``=` `1` `            ``count ``+``=` `1` `        `  `        ``# If count is even then return` `        ``# true else false` `        ``if``(count ``%` `2` `=``=` `0``):` `            ``return` `True` `        ``else``:` `            ``return` `False`   `# Driver code` `test_no ``=` `64` `if``(isPowerOfFour(``64``)):` `    ``print``(test_no, ``'is a power of 4'``)` `else``:` `    ``print``(test_no, ``'is not a power of 4'``)`   `# This code is contributed by Danish Raza`

## C#

 `// C# program to check if given` `// number is power of 4 or not ` `using` `System;`   `class` `GFG {` `    `  `    ``static` `int` `isPowerOfFour(``int` `n)` `    ``{` `        ``int` `count = 0;` `        `  `        ``/*Check if there is only one bit` `        ``set in n*/` `        ``int` `x = n & (n-1);` `        `  `        ``if` `( n > 0 && x == 0)` `        ``{` `            ``/* count 0 bits before set bit */` `            ``while``(n > 1)` `            ``{` `                ``n >>= 1;` `                ``count += 1;` `            ``} ` `        `  `            ``/*If count is even then return ` `            ``true else false*/` `            ``return` `(count % 2 == 0) ? 1 : 0;` `        ``}` `        `  `            ``/* If there are more than 1 bit set` `            ``then n is not a power of 4*/` `        ``return` `0;` `    ``} `   `    ``/*Driver program to test above function*/` `    ``static` `void` `Main()` `    ``{` `        ``int` `test_no = 64;` `        `  `        ``if``(isPowerOfFour(test_no)>0)` `            ``Console.WriteLine(``"{0} is a power of 4"``,` `                                          ``test_no);` `        ``else` `            ``Console.WriteLine(``"{0} is not a power of 4"``,` `                                             ``test_no);` `    ``}` `}`   `// This Code is Contributed by mits`

## PHP

 ` 1)` `    ``{` `    ``\$n` `>>= 1;` `    ``\$count` `+= 1;` `    ``}     `   `    ``/*If count is even then return true else false*/` `    ``return` `(``\$count``%2 == 0)? 1 :0;` `}`   `/* If there are more than 1 bit set` `    ``then n is not a power of 4*/` `return` `0;` `} `   `/*Driver program to test above function*/`   `    ``\$test_no` `= 64;` `    `  `if``(isPowerOfFour(``\$test_no``))`   `    ``echo` `\$test_no``, ``" is a power of 4"``;`   `else`   `    ``echo` `\$test_no``, ``" not is a power of 4"``;` `    `    `#This Code is Contributed by Ajit` `?>`

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 4: A number n is a power of 4 if the following conditions are met.
a) There is only one bit set in the binary representation of n (or n is a power of 2)
b) The bits don’t AND(&) any part of the pattern 0xAAAAAAAA
For example: 16 (10000) is power of 4 because there is only one bit set and 0x10 & 0xAAAAAAAA is zero.
Thanks to Sarthak Sahu for suggesting the approach.

## C++

 `// C++ program to check ` `// if given number is ` `// power of 4 or not ` `#include`   `using` `namespace` `std;`   `bool` `isPowerOfFour(unsigned ``int` `n)` `{` `    ``return` `n !=0 && ((n&(n-1)) == 0) && !(n & 0xAAAAAAAA);` `} `   `/*Driver code*/` `int` `main()` `{` `    ``int` `test_no = 64;` `    ``if``(isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"` `;` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``;` `}`

## C

 `// C program to check ` `// if given number is ` `// power of 4 or not ` `#include` `#define bool int`   `bool` `isPowerOfFour(unsigned ``int` `n)` `{` `  ``return` `n != 0 && ((n&(n-1)) == 0) && !(n & 0xAAAAAAAA);` `}    `   `/*Driver program to test above function*/` `int` `main() {` `   ``int` `test_no = 64;` `   ``if``(isPowerOfFour(test_no))` `     ``printf``(``"%d is a power of 4"``, test_no);` `   ``else` `     ``printf``(``"%d is not a power of 4"``, test_no);` `   ``getchar``();` `}`

## Java

 `// Java program to check ` `// if given number is ` `// power of 4 or not ` `import` `java.io.*;` `class` `GFG {` `    ``static` `boolean` `isPowerOfFour(``int` `n) {` `        ``return` `n != ``0` `&& ((n&(n-``1``)) == ``0``) && (n & ``0xAAAAAAAA``) == ``0``;` `    ``} `   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `test_no = ``64``;` `        `  `        ``if``(isPowerOfFour(test_no))` `            ``System.out.println(test_no +` `                               ``" is a power of 4"``);` `        ``else` `            ``System.out.println(test_no +` `                               ``" is not a power of 4"``);` `    ``}` `}`

## Python3

 `# Python3 program to check ` `# if given number is ` `# power of 4 or not ` `def` `isPowerOfFour(n):` `    ``return` `(n !``=` `0` `and` `          ``((n & (n ``-` `1``)) ``=``=` `0``) ``and` `            ``not``(n & ``0xAAAAAAAA``));`   `# Driver code` `test_no ``=` `64``;` `if``(isPowerOfFour(test_no)):` `    ``print``(test_no ,``"is a power of 4"``);` `else``:` `    ``print``(test_no , ``"is not a power of 4"``);`   `# This code contributed by Rajput-Ji`

## C#

 `// C# program to check ` `// if given number is ` `// power of 4 or not ` `using` `System;`   `class` `GFG` `{` `    ``static` `bool` `isPowerOfFour(``int` `n)` `    ``{` `        ``return` `n != 0 && ((n&(n-1)) == 0) &&` `                        ``(n & 0xAAAAAAAA) == 0;` `    ``} `   `    ``// Driver Code` `    ``static` `void` `Main()` `    ``{` `        ``int` `test_no = 64;` `        `  `        ``if``(isPowerOfFour(test_no))` `            ``Console.WriteLine(``"{0} is a power of 4"``,` `                                        ``test_no);` `        ``else` `            ``Console.WriteLine(``"{0} is not a power of 4"``,` `                                            ``test_no);` `    ``}` `}`   `// This code is contributed by mohit kumar 29`

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 5: A number will be a power of 4 if the floor(log4(num))=ceil(log4(num) because log4 of a number that is a power of 4 will always be an integer.

Below is the implementation of the above approach.

## C++

 `// C++ program to check  ` `// if given number is  ` `// power of 4 or not  ` `#include ` `  `  `using` `namespace` `std; `   `float` `logn(``int` `n, ``int` `r)` `{` `    ``return` `log``(n) / ``log``(r);` `}`   `bool` `isPowerOfFour(``int` `n) ` `{` `    ``//0 is not considered as a power` `    ``//of 4 ` `    ``if``(n == 0)` `        ``return` `false``;` `    ``return` `floor``(logn(n,4))==``ceil``(logn(n,4)); ` `}  ` `  `  `/*Driver code*/` `int` `main() ` `{ ` `    ``int` `test_no = 64; ` `    ``if``(isPowerOfFour(test_no)) ` `        ``cout << test_no << ``" is a power of 4"` `; ` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``; ` `    ``return` `0;` `}`

## Java

 `// Java program to check ` `// if given number is ` `// power of 4 or not ` `import` `java.util.*;` `class` `GFG{`   `static` `double` `logn(``int` `n, ` `                   ``int` `r) ` `{` `  ``return` `Math.log(n) / ` `         ``Math.log(r);` `}`   `static` `boolean` `isPowerOfFour(``int` `n) ` `{` `  ``// 0 is not considered ` `  ``// as a power of 4` `  ``if` `(n == ``0``)` `    ``return` `false``;` `  ``return` `Math.floor(logn(n, ``4``)) == ` `         ``Math.ceil(logn(n, ``4``));` `}`   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{` `  ``int` `test_no = ``64``;` `  ``if` `(isPowerOfFour(test_no))` `    ``System.out.print(test_no + ` `                     ``" is a power of 4"``);` `  ``else` `    ``System.out.print(test_no + ` `                     ``" is not a power of 4"``);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to check` `# if given number is` `# power of 4 or not` `import` `math`   `def` `logn(n, r):` `    ``return` `math.log(n) ``/` `math.log(r)`   `def` `isPowerOfFour(n):` `    `  `    ``# 0 is not considered` `    ``# as a power of 4` `    ``if` `(n ``=``=` `0``):` `        ``return` `False` `        `  `    ``return` `(math.floor(logn(n, ``4``)) ``=``=` `             ``math.ceil(logn(n, ``4``)))`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``test_no ``=` `64` `    `  `    ``if` `(isPowerOfFour(test_no)):` `        ``print``(test_no, ``" is a power of 4"``)` `    ``else``:` `        ``print``(test_no, ``" is not a power of 4"``)`   `# This code is contributed by Amit Katiyar`

## C#

 `// C# program to check ` `// if given number is ` `// power of 4 or not ` `using` `System;` `class` `GFG{`   `static` `double` `logn(``int` `n, ` `                   ``int` `r) ` `{` `  ``return` `Math.Log(n) / ` `         ``Math.Log(r);` `}`   `static` `bool` `isPowerOfFour(``int` `n) ` `{` `  ``// 0 is not considered ` `  ``// as a power of 4` `  ``if` `(n == 0)` `    ``return` `false``;` `  ``return` `Math.Floor(logn(n, 4)) == ` `         ``Math.Ceiling(logn(n, 4));` `}`   `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{` `  ``int` `test_no = 64;` `  ``if` `(isPowerOfFour(test_no))` `    ``Console.Write(test_no + ` `                  ``" is a power of 4"``);` `  ``else` `    ``Console.Write(test_no + ` `                  ``" is not a power of 4"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 6: Using Log and without using ceil (Oneliner)

We can easily calculate without using ceil by checking the log of number base 4 to the power of 4 is equal to that number

## C++

 `// C++ program to check` `// if given number is` `// power of 4 or not` `#include ` `using` `namespace` `std;`   `int` `isPowerOfFour(``int` `n)` `{` `    ``return` `(n > 0 and ``pow``(4, ``int``(log2(n) / ` `                                 ``log2(4))) == n);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `test_no = 64;`   `    ``if` `(isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"``;` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``;` `        `  `    ``return` `0;` `}`   `// This code is contributed by ukasp`

## Java

 `// Java program to check` `// if given number is` `import` `java.io.*;`   `class` `GFG{` `    `  `static` `boolean` `isPowerOfFour(``int` `n)` `{` `    ``return` `(n > ``0` `&& Math.pow(` `        ``4``, (``int``)((Math.log(n) / ` `                  ``Math.log(``2``)) / ` `                 ``(Math.log(``4``) / ` `                  ``Math.log(``2``)))) == n);` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `test_no = ``64``;` `    `  `    ``if` `(isPowerOfFour(test_no))` `        ``System.out.println(test_no +` `         ``" is a power of 4"``);` `    ``else` `        ``System.out.println(test_no + ` `         ``" is not a power of 4"``);` `}` `}`   `// This code is contributed by rag2127`

## Python3

 `# Python3 program to check` `# if given number is` `# power of 4 or not` `import` `math`     `def` `isPowerOfFour(n):` `    ``return` `(n > ``0` `and` `4``*``*``int``(math.log(n, ``4``)) ``=``=` `n)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``test_no ``=` `64`   `    ``if` `(isPowerOfFour(test_no)):` `        ``print``(test_no, ``" is a power of 4"``)` `    ``else``:` `        ``print``(test_no, ``" is not a power of 4"``)`   `# This code is contributed by vikkycirus`

## C#

 `// C# program to check` `// if given number is` `using` `System;` `class` `GFG` `{` `    `  `static` `Boolean isPowerOfFour(``int` `n)` `{` `    ``return` `(n > 0 && Math.Pow(` `        ``4, (``int``)((Math.Log(n) / ` `                  ``Math.Log(2)) / ` `                 ``(Math.Log(4) / ` `                  ``Math.Log(2)))) == n);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `    ``int` `test_no = 64;` `    `  `    ``if` `(isPowerOfFour(test_no))` `        ``Console.WriteLine(test_no +` `         ``" is a power of 4"``);` `    ``else` `        ``Console.WriteLine(test_no + ` `         ``" is not a power of 4"``);` `}` `}`   `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 7: A number ‘n’ is a power of 4 if,

a) It is a perfect square
b) It is a power of two

Below is the implementation of the above idea.

## C++

 `// C++ program to check if given number is power of 4 or not` `#include ` `using` `namespace` `std;`   `// Function to check perfect square` `bool` `isPerfectSquare(``int` `n)` `{` `    ``int` `x = ``sqrt``(n);` `    ``return` `(x * x == n);` `}`   `bool` `isPowerOfFour(``int` `n)` `{` `    ``// If n <= 0, it is not the power of four` `    ``if` `(n <= 0)` `        ``return` `false``;` `    ``// Check whether 'n' is a perfect square or not` `    ``if` `(!isPerfectSquare(n))` `        ``return` `false``;`   `    ``// If 'n' is the perfect square Check for the second` `    ``// condition i.e. 'n' must be power of two` `    ``return` `!(n & (n - 1));` `}`   `/*Driver code*/` `int` `main()` `{` `    ``int` `test_no = 64;` `    ``if` `(isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4"``;` `    ``else` `        ``cout << test_no << ``" is not a power of 4"``;` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to check if given number is power of 4 or not` `#include ` `#include ` `#include `   `// Function to check perfect square` `bool` `isPerfectSquare(``int` `n)` `{` `    ``int` `x = ``sqrt``(n);` `    ``return` `(x * x == n);` `}`   `bool` `isPowerOfFour(``int` `n)` `{` `    ``// If n <= 0, it is not the power of four` `    ``if` `(n <= 0)` `        ``return` `false``;` `    ``// Check whether 'n' is a perfect square or not` `    ``if` `(!isPerfectSquare(n))` `        ``return` `false``;`   `    ``// If 'n' is the perfect square Check for the second` `    ``// condition i.e. 'n' must be power of two` `    ``return` `!(n & (n - 1));` `}`   `/*Driver code*/` `int` `main()` `{` `    ``int` `test_no = 64;` `    ``if` `(isPowerOfFour(test_no))` `        ``printf``(``"%d is a power of 4"``, test_no);` `    ``else` `        ``printf``(``"%d is not a power of 4"``, test_no);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to check ` `// if given number is ` `// power of 4 or not ` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to check perfect square` `    ``static` `boolean` `isPerfectSquare(``int` `n) {` `        ``int` `x = (``int``) Math.sqrt(n);`   `        ``return` `(x * x == n);` `    ``}`   `    ``static` `boolean` `isPowerOfFour(``int` `n)` `    ``{` `      `  `        ``// If n <= 0, it is not the power of four` `        ``if` `(n <= ``0``)` `            ``return` `false``;`   `        ``// Check whether 'n' is a perfect square or not` `        ``if` `(!isPerfectSquare(n))` `            ``return` `false``;`   `        ``// If 'n' is the perfect square` `        ``// Check for the second condition i.e. 'n' must be power of two` `        ``return` `(n & (n - ``1``)) != ``1` `? ``true` `: ``false``;` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `test_no = ``64``;` `        ``if` `(isPowerOfFour(test_no))` `            ``System.out.print(test_no + ``" is a power of 4"``);` `        ``else` `            ``System.out.print(test_no + ``" is not a power of 4"``);` `    ``}` `}`   `// This code is contributed by gauravrajput1 `

## Python3

 `# Python program to check ` `# if given number is ` `# power of 4 or not ` `# Function to check perfect square ` `# import the math module ` `import` `math `   `def` `isPerfectSquare(n):` `    ``x ``=` `math.sqrt(n)` `    ``return` `(x``*``x ``=``=` `n)`     `def` `isPowerOfFour(n):` `    `  `      ``# If n <= 0, it is not the power of four` `      ``if``(n <``=` `0``):` `         ``return` `False` `  `  `      ``# Check whether 'n' is a perfect square or not` `      ``if``(isPerfectSquare(n)):` `         ``return` `False`     `    `  `      ``# If 'n' is the perfect square` `      ``# Check for the second condition i.e. 'n' must be power of two` `      ``return` `(n & (n ``-` `1``))` ` `  `# Driver code` `test_no ``=` `64` `if``(isPowerOfFour(test_no)):` `        ``print``(test_no ,``" is a power of 4"``)` `else``:` `        ``print``(test_no ,``" is not a power of 4"``)`   `# This code is contributed by shivanisinghss2110`

## C#

 `// C# program to check ` `// if given number is ` `// power of 4 or not ` `using` `System;`   `public` `class` `GFG {`   `    ``// Function to check perfect square` `    ``static` `bool` `isPerfectSquare(``int` `n) {` `        ``int` `x = (``int``) Math.Sqrt(n);`   `        ``return` `(x * x == n);` `    ``}`   `    ``static` `bool` `isPowerOfFour(``int` `n)` `    ``{` `      `  `        ``// If n <= 0, it is not the power of four` `        ``if` `(n <= 0)` `            ``return` `false``;`   `        ``// Check whether 'n' is a perfect square or not` `        ``if` `(!isPerfectSquare(n))` `            ``return` `false``;`   `        ``// If 'n' is the perfect square` `        ``// Check for the second condition i.e. 'n' must be power of two` `        ``return` `(n & (n - 1)) != 1 ? ``true` `: ``false``;` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args) {` `        ``int` `test_no = 64;` `        ``if` `(isPowerOfFour(test_no))` `            ``Console.Write(test_no + ``" is a power of 4"``);` `        ``else` `            ``Console.Write(test_no + ``" is not a power of 4"``);` `    ``}` `}`   `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

`64 is a power of 4`

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

Method 8: Using a similar concept of “Power of 2”:

A number can be considered a power of 4 when:

1. * The number is a power of 2 for example : 4, 16, 64 … all are powers of 2 as well . The O(1) bit manipulation technique using n&(n-1)==0 can be used, but wait every power of 4 is a power of 2. Will the reverse apply?
2. *Obviously not, 8,32,128 … aren’t power of 4, so we need one more check here. If you clearly notice all powers of 4 when divided by 3 gives 1 as the remainder.

Below is the code implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `// C++ code to check if given` `// number is power of 4 or not`   `// Function to check if` `// x is power of 4` `bool` `isPowerOfFour(``int` `n)` `{` `  ``return` `((n > 0) && ((n & n - 1) == 0) && (n % 3 == 1));` `}`   `// Driver program` `int` `main()` `{` `  ``int` `test_no = 64;` `  ``if` `(isPowerOfFour(test_no) == ``true``)` `    ``cout << (test_no) << ``" is a power of 4"``;` `  ``else` `    ``cout << (test_no) << ``" is not a power of 4"``;` `}`   `// This code is contributed by garg28harsh.`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `// Java code to check if given` `// number is power of 4 or not`   `class` `GFG {`   `    ``// Function to check if` `    ``// x is power of 4` `    ``static` `boolean` `isPowerOfFour(``int` `n)` `    ``{` `        ``return` `((n>``0``) && ((n & n-``1``) == ``0``) && (n%``3` `== ``1``));` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `test_no = ``64``;` `        ``if``(isPowerOfFour(test_no) == ``true``)` `        ``System.out.println(test_no +` `                        ``" is a power of 4"``);` `        ``else` `        ``System.out.println(test_no +` `                        ``" is not a power of 4"``);` `    ``}` `}`   `// This code is contributed` `// Aravind Ravi`

## Python3

 `# Python code to check if given` `# number is power of 4 or not`   `# Function to check if` `# x is power of 4`   `def` `isPowerOfFour(n):` `    `  `    ``return` `((n > ``0``) ``and` `((n & n ``-` `1``) ``=``=` `0``) ``and` `(n ``%` `3` `=``=` `1``))`   `# Driver code` `test_no ``=` `64` `if``(isPowerOfFour(test_no)):` `        ``print``(test_no,``"is a power of 4"``)` `else``:` `        ``print``(test_no,``"is not a power of 4"``)` `        `  `# This code is contributed by Pushpesh Raj.`

## C#

 `using` `System;`   `// C# code to check if given` `// number is power of 4 or not` `class` `GFG ` `{`   `  ``// Function to check if` `  ``// x is power of 4` `  ``static` `bool` `isPowerOfFour(``int` `n)` `  ``{` `    ``return` `((n > 0) && ((n & n - 1) == 0)` `            ``&& (n % 3 == 1));` `  ``}` `  ``static` `void` `Main()` `  ``{` `    ``int` `test_no = 64;` `    ``if` `(isPowerOfFour(test_no) == ``true``)` `      ``Console.Write(test_no + ``" is a power of 4"``);` `    ``else` `      ``Console.Write(test_no + ``" is not a power of 4"``);` `  ``}` `}`   `// This code is contributed by garg28harsh.`

## Javascript

 `// JavaScript code to check if given` `// number is power of 4 or not`   `function` `isPowerOfFour(n){` `    ``return` `((n>0) && ((n & n-1) == 0) && (n%3 == 1));` `}`   `let test_no = 64` `if``(isPowerOfFour(test_no)==``true``){` `    ``console.log(test_no + ``" is a power of 4"``);` `}` `else``{` `    ``console.log(test_no + ``" is not a power of 4"``);` `}`   `// This code is contributed lokeshmvs21.`

Output

`64 is a power of 4`

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

Method 9: Alternative approach: Using built-in methods (one-liner)

Any number that is a power of 4 has the following properties:

1. It is a power of 2 (that is, only its leftmost bit is set)
2. It has an even number of unset bits.

Most languages have in-built methods to count the number of leading and trailing unset bits, such as __builtin_clz in C++,  numberOfLeadingZeros() in Java, and bit_length() in Python3. If a number is a power of 2, then it shall only have one set bit. Therefore, if the number of trailing zeros is even, then it is a power of 4.

The approach is shown below:

## C++

 `// C++ program to check if given number is power of 4 or not` `#include ` `using` `namespace` `std;`   `bool` `isPowerOfFour(``int` `n)` `{` `    ``return` `!(n & (n - 1)) && ((32 - __builtin_clz(n)) % 2);` `}`   `/*Driver code*/` `int` `main()` `{` `    ``int` `test_no = 64;` `    ``if` `(isPowerOfFour(test_no))` `        ``cout << test_no << ``" is a power of 4\n"``;`   `    ``else` `        ``cout << test_no << ``" is not a power of 4\n"``;`   `    ``return` `0;` `}`   `// This code is contributed by phasing17`

## Java

 `// Java program to check if given number is power of 4 or not` `import` `java.util.*;`   `public` `class` `GFG` `{` `  ``static` `boolean` `isPowerOfFour(``int` `n)` `  ``{` `    ``return` `((n & (n - ``1``)) == ``0``) && ((``32` `-  Integer.numberOfLeadingZeros(n)) % ``2` `!= ``0``);` `  ``}`   `  ``/*Driver code*/` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `test_no = ``64``;` `    ``if` `(isPowerOfFour(test_no))` `      ``System.out.println(test_no + ``" is a power of 4\n"``);`   `    ``else` `      ``System.out.println(test_no + ``" is not a power of 4\n"``);`   `  ``}` `}`   `// This code is contributed by phasing17`

## Python3

 `# Python code for the above approach` `import` `math`   `def` `isPowerOfFour(n):` `    ``return` `((n & (n``-``1``)) ``=``=` `0``) ``and` `((``32` `+` `1` `-` `(math.floor(math.log(n)``/``math.log(``2``)))) ``%` `2` `=``=` `1``)`   `test_no ``=` `64` `if``(isPowerOfFour(test_no)):` `    ``print``(test_no, ``"is a power of 4"``)` `else``:` `    ``print``(test_no, ``"is not a power of 4"``)`   `# This code is contributed by lokeshmvs21.`

## C#

 `// C# program to check if given number is power of 4 or not` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{` `  ``static` `bool` `isPowerOfFour(``int` `n)` `  ``{` `    ``return` `((n & (n - 1)) == 0) && ((32 + 1 - (Math.Floor(Math.Log(n) / Math.Log(2)))) % 2 == 1);` `  ``}`   `  ``/*Driver code*/` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int` `test_no = 64;` `    ``if` `(isPowerOfFour(test_no))` `      ``Console.WriteLine(test_no + ``" is a power of 4\n"``);`   `    ``else` `      ``Console.WriteLine(test_no + ``" is not a power of 4\n"``);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JS program to check if given number is power of 4 or not`   `function` `isPowerOfFour(n)` `{` `    ``return` `!(n & (n - 1)) && (32 + 1 - (Math.floor(Math.log(n) / Math.log(2)))) % 2;` `}`   `/*Driver code*/` `let test_no = 64;` `if` `(isPowerOfFour(test_no))` `    ``console.log(test_no + ``" is a power of 4"``);` `else` `    ``console.log(test_no + ``" is not a power of 4"``);`     `// This code is contributed by phasing17`

Output

`64 is a power of 4`

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

### Method 10: Using math module and is_integer

1. This function takes an integer n as input and returns True if it is a power of 4 and False otherwise.

2. The math.log function is used to calculate the logarithm base 4 of n.

3. The is_integer method is used to check if the result is an integer.

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `bool` `is_power_of_4_log(``int` `n) {` `    ``if` `(n <= 0) {` `        ``return` `false``;` `    ``}` `    ``return` `fmod``(``log``(n) / ``log``(4), 1) == 0;` `}`   `int` `main() {` `    ``cout << is_power_of_4_log(16) << endl;` `    ``cout << is_power_of_4_log(36) << endl;` `    ``cout << is_power_of_4_log(20) << endl;` `    ``return` `0;` `}`

## Python3

 `import` `math`   `def` `is_power_of_4_log(n):` `    ``if` `n <``=` `0``:` `        ``return` `False` `    ``return` `math.log(n, ``4``).is_integer()` `print``(is_power_of_4_log(``16``))` `print``(is_power_of_4_log(``36``)) ` `print``(is_power_of_4_log(``20``))`

## C#

 `using` `System;`   `class` `Program ` `{`   `  ``// This function checks if a number is a power of 4` `  ``// using logarithms.` `  ``static` `bool` `IsPowerOf4Log(``int` `n)` `  ``{`   `    ``// If n is less than or equal to 0, it cannot be a` `    ``// power of 4.` `    ``if` `(n <= 0) {` `      ``return` `false``;` `    ``}` `    ``// Check if the logarithm of n to base 4 is an` `    ``// integer.` `    ``return` `Math.IEEERemainder(Math.Log(n) / Math.Log(4),` `                              ``1)` `      ``== 0;` `  ``}`   `  ``static` `void` `Main(``string``[] args)` `  ``{`   `    ``Console.WriteLine(IsPowerOf4Log(16));` `    ``Console.WriteLine(IsPowerOf4Log(36));` `    ``Console.WriteLine(IsPowerOf4Log(20));` `  ``}` `}`

## Javascript

 `function` `is_power_of_4_log(n) {` `    ``if` `(n <= 0) {` `        ``return` `false``;` `    ``}` `    ``return` `Number.isInteger(Math.log(n) / Math.log(4));` `}`   `console.log(is_power_of_4_log(16)==1?``"True"``:``"False"``);` `console.log(is_power_of_4_log(36)==1?``"True"``:``"False"``);` `console.log(is_power_of_4_log(20)==1?``"True"``:``"False"``);`

## Java

 `public` `class` `Main {` `    ``public` `static` `void` `main(String[] args) {` `        ``System.out.println(isPowerOf4Log(``16``)); ``// true` `        ``System.out.println(isPowerOf4Log(``36``)); ``// false` `        ``System.out.println(isPowerOf4Log(``20``)); ``// false` `    ``}`   `    ``public` `static` `boolean` `isPowerOf4Log(``int` `n) {` `        ``if` `(n <= ``0``) {` `            ``return` `false``;` `        ``}` `        ``return` `(Math.log(n) / Math.log(``4``)) % ``1` `== ``0``;` `    ``}` `}`

Output

```True
False
False```

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

Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem

My Personal Notes arrow_drop_up
Related Articles