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

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next