 GeeksforGeeks App
Open App Browser
Continue

# 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

My Personal Notes arrow_drop_up