# Given a HUGE number check if it’s a power of two.

Last Updated : 08 Feb, 2023

Find if a given number, num is the power of 2 or not. More specifically, find if the given number can be expressed as 2^k where k >= 1. Return 1 if the number is a power of 2 else return 0
NOTE :

• A number of digits of the given number i.e (num) can be greater than 100.
• There are no leading zeros before a non-zero number. E.g 0000128 is not in input./li>

Examples:

Input :
Output : 0
Explanation: 2^0 = 1 where as k >= 1

Input : 128
Output : 1

Method 1: Using strings
The idea is to repeatedly divide the large number (represented as a string) by 2. To perform division, we traverse digits from right to left. If the last digit itself is not divisible by 2, we return 0. Otherwise, we follow the school method of division.

## C

 `/*  C program to find whether a number is power of ` `    ``2 or not */` `#include ` `#include `   `// Returns 1 when str is power of 2` `// Return 0 when str is not a power of 2` `int` `isPowerOf2(``char``* str)` `{` `    ``int` `len_str = ``strlen``(str);`   `    ``// Sum stores the intermediate dividend while` `    ``// dividing.` `    ``int` `num = 0;`   `    ``// If the input is "1" then return 0` `    ``// because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str == 1 && str[len_str - 1] == ``'1'``)` `        ``return` `0;`   `    ``// Divide the number until it gets reduced to 1` `    ``// If we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in ` `    ``// between an odd number appears at the end it means ` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(len_str != 1 || str[len_str - 1] != ``'1'``) {`   `        ``// If the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two ` `        ``// return 0.` `        ``if` `((str[len_str - 1] - ``'0'``) % 2 == 1)` `            ``return` `0;`   `          ``int` `j = 0;` `        ``// Divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``for` `(``int` `i = 0; i < len_str; i++) {` `            ``num = num * 10 + str[i] - ``'0'``;` `            `  `            ``// If num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than ` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < 2) {`   `                ``// If it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(i != 0) ` `                    ``str[j++] = ``'0'``;                `   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}`   `            ``str[j++] = (``int``)(num / 2) + ``'0'``;` `            ``num = (num) - (num / 2) * 2;` `        ``}`   `        ``str[j] = ``'\0'``;`   `        ``// After every division by 2 the ` `        ``// length of string is changed.` `        ``len_str = j;` `    ``}`   `    ``// If the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1;` `}`   `// Driver code.` `int` `main()` `{` `    ``char` `str1[] = ``"12468462246684202468024"` `                     ``"6842024662202000002"``;` `    ``char` `str2[] = ``"1"``;` `    ``char` `str3[] = ``"128"``;`   `    ``printf``(``"%d\n%d\n%d"``, isPowerOf2(str1),` `           ``isPowerOf2(str2), isPowerOf2(str3));`   `    ``return` `0;` `}`

## C++

 `//  C++ program to find whether a number is power of 2 or` `//  not` `#include ` `using` `namespace` `std;`   `// Returns 1 when str is power of 2` `// Return 0 when str is not a power of 2` `int` `isPowerOf2(string str)` `{` `    ``int` `len_str = str.size();`   `    ``// Sum stores the intermediate dividend while` `    ``// dividing.` `    ``int` `num = 0;`   `    ``// If the input is "1" then return 0` `    ``// because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str == 1 && str[len_str - 1] == ``'1'``)` `        ``return` `0;`   `    ``// Divide the number until it gets reduced to 1` `    ``// If we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in` `    ``// between an odd number appears at the end it means` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(len_str != 1 || str[len_str - 1] != ``'1'``) {`   `        ``// If the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two` `        ``// return 0.` `        ``if` `((str[len_str - 1] - ``'0'``) % 2 == 1)` `            ``return` `0;`   `        ``int` `j = 0;` `        ``// Divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``for` `(``int` `i = 0; i < len_str; i++) {` `            ``num = num * 10 + str[i] - ``'0'``;`   `            ``// If num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < 2) {`   `                ``// If it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(i != 0)` `                    ``str[j++] = ``'0'``;`   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}`   `            ``str[j++] = (``int``)(num / 2) + ``'0'``;` `            ``num = (num) - (num / 2) * 2;` `        ``}`   `        ``// After every division by 2 the` `        ``// length of string is changed.` `        ``len_str = j;` `    ``}`   `    ``// If the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1;` `}`   `// Driver code.` `int` `main()` `{` `    ``string str1 = ``"12468462246684202468024"` `                  ``"6842024662202000002"``;` `    ``string str2 = ``"1"``;` `    ``string str3 = ``"128"``;`   `    ``cout << isPowerOf2(str1) << endl` `         ``<< isPowerOf2(str2) << endl` `         ``<< isPowerOf2(str3);`   `    ``return` `0;` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Java

 `/* Java program to find whether a number  ` `    ``is power of 2 or not */` `import` `java.util.*;`   `class` `GFG` `{` `    `  `// returns 1 when str is power of 2` `// return 0 when str is not a power of 2` `static` `int` `isPowerOf2(String s)` `{` `    ``char` `[]str = s.toCharArray();` `    ``int` `len_str = s.length();`   `    ``// sum stores the intermediate dividend while` `    ``// dividing.` `    ``int` `num = ``0``;`   `    ``// if the input is "1" then return 0` `    ``// because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str == ``1` `&& str[len_str - ``1``] == ``'1'``)` `        ``return` `0``;`   `    ``// Divide the number until it gets reduced to 1` `    ``// if we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in ` `    ``// between an odd number appears at the end it means ` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(len_str != ``1` `|| str[len_str - ``1``] != ``'1'``)` `    ``{`   `        ``// if the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two ` `        ``// return 0.` `        ``if` `((str[len_str - ``1``] - ``'0'``) % ``2` `== ``1``)` `            ``return` `0``;`   `        ``// divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``int` `j = ``0``;` `        ``for` `(``int` `i = ``0``; i < len_str; i++) ` `        ``{` `            ``num = num * ``10` `+ (``int``)str[i] - (``int``)``'0'``;` `            `  `            ``// if num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than ` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < ``2``) ` `            ``{`   `                ``// if it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(i != ``0``)` `                    ``str[j++] = ``'0'``;     `   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}`   `            ``str[j++] = (``char``)((``int``)(num / ``2``) + (``int``)``'0'``);` `            ``num = (num) - (num / ``2``) * ``2``;` `        ``}`   `        ``str[j] = ``'\0'``;`   `        ``// After every division by 2 the ` `        ``// length of string is changed.` `        ``len_str = j;` `    ``}`   `    ``// if the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1``;` `}`   `// Driver code.` `public` `static` `void` `main (String[] args) ` `{` `    ``String str1 = ``"124684622466842024680246842024662202000002"``;` `    ``String str2 = ``"1"``;` `    ``String str3 = ``"128"``;`   `    ``System.out.println(isPowerOf2(str1) + ` `                ``"\n"``+isPowerOf2(str2) + ` `                ``"\n"``+isPowerOf2(str3));` `}` `}`   `// This code is contributed by mits`

## Python3

 `# Python3 program to find whether a number` `# is power of 2 or not `   `# returns 1 when str is power of 2` `# return 0 when str is not a power of 2` `def` `isPowerOf2(sttr):`   `    ``len_str ``=` `len``(sttr);` `    ``sttr``=``list``(sttr);`   `    ``# sum stores the intermediate dividend ` `    ``# while dividing.` `    ``num ``=` `0``;`   `    ``# if the input is "1" then return 0` `    ``# because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str ``=``=` `1` `and` `sttr[len_str ``-` `1``] ``=``=` `'1'``):` `        ``return` `0``;`   `    ``# Divide the number until it gets reduced to 1` `    ``# if we are successfully able to reduce the number` `    ``# to 1 it means input string is power of two if in ` `    ``# between an odd number appears at the end it means ` `    ``# string is not divisible by two hence not a power` `    ``# of 2.` `    ``while` `(len_str !``=` `1` `or` `sttr[len_str ``-` `1``] !``=` `'1'``):`   `        ``# if the last digit is odd then string is not` `        ``# divisible by 2 hence not a power of two ` `        ``# return 0.` `        ``if` `((``ord``(sttr[len_str ``-` `1``]) ``-` `ord``(``'0'``)) ``%` `2` `=``=` `1``):` `            ``return` `0``;`   `        ``# divide the whole string by 2. i is used to` `        ``# track index in current number. j is used to` `        ``# track index for next iteration.` `        ``j ``=` `0``;` `        ``for` `i ``in` `range``(len_str): ` `            ``num ``=` `num ``*` `10` `+` `(``ord``(sttr[i]) ``-` `ord``(``'0'``));` `            `  `            ``# if num < 2 then we have to take another digit` `            ``# to the right of A[i] to make it bigger than ` `            ``# A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < ``2``):`   `                ``# if it's not the first index. E.g 214` `                ``# then we have to include 0.` `                ``if` `(i !``=` `0``): ` `                    ``sttr[j] ``=` `'0'``;` `                    ``j ``+``=` `1``;`   `                ``# for eg. "124" we will not write 064` `                ``# so if it is the first index just ignore` `                ``continue``;`   `            ``sttr[j] ``=` `chr``((num ``/``/` `2``) ``+` `ord``(``'0'``));` `            ``j ``+``=` `1``;` `            ``num ``=` `(num) ``-` `(num ``/``/` `2``) ``*` `2``;`   `        ``# After every division by 2 the ` `        ``# length of string is changed.` `        ``len_str ``=` `j;`   `    ``# if the string reaches to 1 then the ` `    ``# str is a power of 2.` `    ``return` `1``;`   `# Driver code.` `str1 ``=` `"124684622466842024680246842024662202000002"``;` `str2 ``=` `"1"``;` `str3 ``=` `"128"``;`   `print``("``", isPowerOf2(str1), "``\n", ` `          ``isPowerOf2(str2), ``"\n"``, ` `          ``isPowerOf2(str3));`   `# This code is contributed by mits`

## C#

 `/* C# program to find whether a number is power of ` `    ``2 or not */` `using` `System;`   `class` `GFG` `{` `    `  `// returns 1 when str is power of 2` `// return 0 when str is not a power of 2` `static` `int` `isPowerOf2(``string` `s)` `{` `    ``char` `[]str = s.ToCharArray();` `    ``int` `len_str = str.Length;`   `    ``// sum stores the intermediate dividend while` `    ``// dividing.` `    ``int` `num = 0;`   `    ``// if the input is "1" then return 0` `    ``// because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str == 1 && str[len_str - 1] == ``'1'``)` `        ``return` `0;`   `    ``// Divide the number until it gets reduced to 1` `    ``// if we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in ` `    ``// between an odd number appears at the end it means ` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(len_str != 1 || str[len_str - 1] != ``'1'``)` `    ``{`   `        ``// if the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two ` `        ``// return 0.` `        ``if` `((str[len_str - 1] - ``'0'``) % 2 == 1)` `            ``return` `0;`   `        ``// divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``int` `j = 0;` `        ``for` `(``int` `i = 0; i < len_str; i++) ` `        ``{` `            ``num = num * 10 + (``int``)str[i] - (``int``)``'0'``;` `            `  `            ``// if num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than ` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < 2) ` `            ``{`   `                ``// if it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(i != 0)` `                    ``str[j++] = ``'0'``;         `   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}`   `            ``str[j++] = (``char``)((``int``)(num / 2) + (``int``)``'0'``);` `            ``num = (num) - (num / 2) * 2;` `        ``}`   `        ``str[j] = ``'\0'``;`   `        ``// After every division by 2 the ` `        ``// length of string is changed.` `        ``len_str = j;` `    ``}`   `    ``// if the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1;` `}`   `// Driver code.` `static` `void` `Main()` `{` `    ``string` `str1 = ``"124684622466842024680246842024662202000002"``;` `    ``string` `str2 = ``"1"``;` `    ``string` `str3 = ``"128"``;`   `    ``Console.Write(isPowerOf2(str1) + ` `                ``"\n"``+isPowerOf2(str2) + ` `                ``"\n"``+isPowerOf2(str3));` `}` `}`   `// This code is contributed by mits`

## PHP

 `= 1 and here k = 0` `    ``if` `(``\$len_str` `== 1 && ``\$str``[``\$len_str` `- 1] == ``'1'``)` `        ``return` `0;`   `    ``// Divide the number until it gets reduced to 1` `    ``// if we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in ` `    ``// between an odd number appears at the end it means ` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(``\$len_str` `!= 1 || ``\$str``[``\$len_str` `- 1] != ``'1'``)` `    ``{`   `        ``// if the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two ` `        ``// return 0.` `        ``if` `(ord(``\$str``[``\$len_str` `- 1] - ``'0'``) % 2 == 1)` `            ``return` `0;`   `        ``// divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``\$j``=0;` `        ``for` `(``\$i` `= 0; ``\$i` `< ``\$len_str``; ``\$i``++) ` `        ``{` `            ``\$num` `= ``\$num` `* 10 + (ord(``\$str``[``\$i``]) - ord(``'0'``));` `            `  `            ``// if num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than ` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(``\$num` `< 2)` `            ``{`   `                ``// if it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(``\$i` `!= 0) ` `                    ``\$str``[``\$j``++] = ``'0'``;         `   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}`   `            ``\$str``[``\$j``++] = ``chr``((int)(``\$num` `/ 2) + ord(``'0'``));` `            ``\$num` `= (``\$num``) - (int)(``\$num` `/ 2) * 2;` `        ``}`     `        ``// After every division by 2 the ` `        ``// length of string is changed.` `        ``\$len_str` `= ``\$j``;` `    ``}`   `    ``// if the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1;` `}`   `    ``// Driver code.` `    ``\$str1` `= ``"124684622466842024680246842024662202000002"``;` `    ``\$str2` `= ``"1"``;` `    ``\$str3` `= ``"128"``;`   `    ``print``(isPowerOf2(``\$str1``).``"\n"``.isPowerOf2(``\$str2``).``"\n"``.isPowerOf2(``\$str3``));`   `// This code is contributed by mits` `?>`   `?>`

## Javascript

 `//  JavaScript program to find whether a number is power of 2 or` `//  not`   `// Returns 1 when str is power of 2` `// Return 0 when str is not a power of 2` `function` `isPowerOf2(str)` `{` `    ``let len_str = str.length;`   `    ``// Sum stores the intermediate dividend while` `    ``// dividing.` `    ``let num = 0;`   `    ``// If the input is "1" then return 0` `    ``// because 2^k = 1 where k >= 1 and here k = 0` `    ``if` `(len_str == 1 && str.charAt(len_str - 1) == ``'1'``)` `        ``return` `0;`   `    ``// Divide the number until it gets reduced to 1` `    ``// If we are successfully able to reduce the number` `    ``// to 1 it means input string is power of two if in` `    ``// between an odd number appears at the end it means` `    ``// string is not divisible by two hence not a power` `    ``// of 2.` `    ``while` `(len_str != 1 || str.charAt(len_str - 1) != ``'1'``) {`   `        ``// If the last digit is odd then string is not` `        ``// divisible by 2 hence not a power of two` `        ``// return 0.` `        ``if` `( parseInt(str.charAt(len_str - 1)) % 2 == 1)` `            ``return` `0;`   `        ``let j = 0;` `        ``// Divide the whole string by 2. i is used to` `        ``// track index in current number. j is used to` `        ``// track index for next iteration.` `        ``for` `(let i = 0; i < len_str; i++) {` `            ``num = num * 10 + parseInt(str.charAt(i));`   `            ``// If num < 2 then we have to take another digit` `            ``// to the right of A[i] to make it bigger than` `            ``// A[i]. E. g. 214 / 2 --> 107` `            ``if` `(num < 2) {`   `                ``// If it's not the first index. E.g 214` `                ``// then we have to include 0.` `                ``if` `(i != 0)` `                ``{` `                    ``str = str.substring(0, j) + '0' + str.substring(j + 1);` `                    ``j++;` `                ``}`   `                ``// for eg. "124" we will not write 064` `                ``// so if it is the first index just ignore` `                ``continue``;` `            ``}` `            ``str = str.substring(0, j) + (Math.floor(num / 2)).toString() + str.substring(j + 1);` `            ``j++;` `            ``num = (num) - Math.floor(num / 2) * 2;` `        ``}`   `        ``// After every division by 2 the` `        ``// length of string is changed.` `        ``len_str = j;` `    ``}`   `    ``// If the string reaches to 1 then the str is` `    ``// a power of 2.` `    ``return` `1;` `}`   `// Driver code.` `let str1 = ``"124684622466842024680246842024662202000002"``;` `let str2 = ``"1"``;` `let str3 = ``"128"``;`   `console.log(isPowerOf2(str1));` `console.log(isPowerOf2(str2));` `console.log(isPowerOf2(str3));`   `// This code is contributed by phasing17`

Output

```0
0
1```

Time Complexity: O(N^2) where N is a number of digits in the given number.

Method 2: Using boost library
Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. For example, they are helpful for handling large numbers having a range beyond the long long, long double data type (264) in C++.

1. Take input as a boost integer.
2. Using bit manipulation check whether itâ€™s the power of 2 or not.

## C++

 `// C++ program to find whether a number` `// is power of 2 or not ` `#include ` `#include `   `using` `namespace` `std;` `using` `namespace` `boost::multiprecision;`   `// Function to check whether a` `// number is power of 2 or not` `bool` `ispowerof2 ( cpp_int num )` `{` `    ``if` `( ( num & ( num - 1 ) ) == 0 )` `        ``return` `1;` `    ``return` `0;    ` `}`   `// Driver function` `int` `main()` `{` `    ``cpp_int num = 549755813888;` `    ``cout << ispowerof2 ( num ) << endl;` `    ``return` `0;` `}  `   `// This code is contributed by  Aditya Gupta 4`

## Java

 `// Java program to find ` `// whether a number` `// is power of 2 or not ` `class` `GfG` `{`   `// Function to check whether a` `// number is power of 2 or not` `static` `long` `ispowerof2 ( ``long` `num )` `{` `    ``if` `((num & (num - ``1``)) == ``0``)` `        ``return` `1``;` `    ``return` `0``; ` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``long` `num = 549755813888L;` `    ``System.out.println(ispowerof2(num));` `}` `}`   `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python3 program to find whether a number` `# is power of 2 or not`   `# Function to check whether a` `# number is power of 2 or not` `def` `ispowerof2(num):`   `    ``if``((num & (num ``-` `1``)) ``=``=` `0``):` `        ``return` `1` `    ``return` `0`   `# Driver function` `if` `__name__``=``=``'__main__'``:` `    ``num ``=` `549755813888` `    ``print``(ispowerof2(num))` `    `  `# This code is contributed by` `# Sanjit_Prasad`

## C#

 `// C# program to find ` `// whether a number` `// is power of 2 or not ` `class` `GFG{` `// Function to check whether a` `// number is power of 2 or not` `static` `long` `ispowerof2 ( ``long` `num )` `{` `    ``if` `((num&(num-1)) == 0)` `        ``return` `1;` `    ``return` `0; ` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `long` `num = 549755813888;` `System.Console.WriteLine(ispowerof2(num));` `}` `}` `// This code is contributed` `// by mits`

## PHP

 ``

## Javascript

 ``

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

Method 3: Using logical and bitwise operators
If we subtract a power of 2 numbers by 1 then all unset bits after the only set bit become set; and the set bit becomes unset.
So, if a number n is a power of 2 then bitwise & of n and n-1 will be zero. We can say n is a power of 2 or not based on the value of n&(n-1). The expression n&(n-1) will not work when n is 0. To handle this case also, our expression will become n& (!n&(n-1))

## C++

 `// C++ code to check if HUGE number` `// is a power of two or not.` `#include ` `using` `namespace` `std;`   `int` `main()` `{` `    ``long` `int` `x = 128; ` `  `  `  ``// condition to check if given ` `// number is power of 2 or not` `    ``if` `(x and (not(x & (x - 1)))){` `      ``cout<<``"Yes"``;` `    ``}` `  ``else` `  ``{` `     ``cout<<``"No"``;` `  ``}` `    `  `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `main (String[] args) {` `      `  `      ``int` `x = ``128``;`   `        ``// condition to check if given` `        ``// number is power of 2 or not` `        ``if` `((x != ``0``) && (``0` `== (x & (x - ``1``)))) {` `            ``System.out.println(``"Yes"``);` `        ``}` `        ``else` `{` `            ``System.out.println(``"No"``);` `        ``}` `      `  `        `  `    ``}` `}`

## Python3

 `#python code to check if HUGE number` `# is a power of two or not.` `x``=``128` `# condition to check if given ` `# number is power of 2 or not` `if` `(x ``and` `(``not``(x & (x ``-` `1``)))):` `  ``print``(``"yes"``) ` `else``: ` `  ``print``(``"no"``)`

## C#

 `// C# code to check if HUGE number` `// is a power of two or not.`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `x = 128;`   `        ``// condition to check if given` `        ``// number is power of 2 or not` `        ``if` `((x != 0) && (0 == (x & (x - 1)))) {` `            ``Console.Write(``"Yes"``);` `        ``}` `        ``else` `{` `            ``Console.Write(``"No"``);` `        ``}` `    ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output

`Yes`

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

Method 4: Using log() function
The idea is to find Log n in base 2 and store it in integer as well as double variables, if the integer value is the same as the double value then the result is true, else the result is false.

## C++

 `// C++ program to find whether the given` `// number is a power of 2` `#include ` `#include ` `using` `namespace` `std;`   `bool` `isPowerOfTwo(``int` `y)` `{` `    ``// logarithm function to calculate value` `    ``int` `res1 = ``log``(y) / ``log``(2);` `  `  `    ``double` `res2 = ``log``(y) / ``log``(2);`   `    ``// The number is power of two if ` `    ``// res1 and res2 are equal` `    ``return` `(res1 == res2);` `}`   `// Driven program` `int` `main()` `{` `  `  `    ``// Function call` `    ``cout << isPowerOfTwo(128) << endl;` `  `  `    ``return` `0;` `}`

## Java

 `// Java program to find whether the given` `// number is a power of 2` `import` `java.util.*;`   `public` `class` `GFG {` `    ``static` `boolean` `isPowerOfTwo(``int` `y)` `    ``{` `        ``// logarithm function to calculate value` `        ``int` `res1 = (``int``)(Math.log(y) / Math.log(``2``));`   `        ``double` `res2 = Math.log(y) / Math.log(``2``);`   `        ``// The number is power of two if` `        ``// res1 and res2 are equal` `        ``return` `(res1 == res2);` `    ``}`   `    ``// Driven program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``if` `(isPowerOfTwo(``128``))` `            ``System.out.println(``1``);` `        ``else` `            ``System.out.println(``0``);` `    ``}` `}` `// This code is contributed by Karandeep1234`

## Python3

 `# Python program to find whether` `# the given number is a power of 2` `import` `math`   `def` `isPowerOfTwo(y):` `    ``# logarithm function to calculate value` `    ``res1 ``=` `int``(math.log(y) ``/``/` `math.log(``2``))`   `    ``res2 ``=` `math.log(y) ``/``/` `math.log(``2``)`   `    ``# The number is power of two` `    ``# if res1 and res2 are equal` `    ``return` `res1 ``=``=` `res2`   `if``(isPowerOfTwo(``128``)):` `    ``print``(``1``)` `else``:` `    ``print``(``0``)`   `# This code is contributed by lokesh`

## C#

 `// C# program to find whether the given` `// number is a power of 2` `using` `System;`   `public` `class` `GFG {`   `  ``static` `bool` `isPowerOfTwo(``int` `y)` `  ``{` `    ``// logarithm function to calculate value` `    ``int` `res1 = (``int``)(Math.Log(y) / Math.Log(2));`   `    ``double` `res2 = Math.Log(y) / Math.Log(2);`   `    ``// The number is power of two if` `    ``// res1 and res2 are equal` `    ``return` `(res1 == res2);` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``if` `(isPowerOfTwo(128))` `      ``Console.WriteLine(1);` `    ``else` `      ``Console.WriteLine(0);` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 `// javascript program to find whether the given` `// number is a power of 2` `function` `isPowerOfTwo( y)` `{`   `    ``// logarithm function to calculate value` `    ``let res1 = Math.log2(y);` `    ``res1= Math.round(res1);` `  `  `    ``let res2 = Math.log2(y);`   `    ``// The number is power of two if ` `    ``// res1 and res2 are equal` `    ``return` `(res1 == res2);` `}`   `// Driven program` `  `  `    ``// Function call` `    ``if``(isPowerOfTwo(128)==``true``)` `        ``console.log(1);` `    ``else` `        ``console.log(0);` `  `  `   ``// This code is contributed by garg28harsh.`

Output

```1
```

Time Complexity: O(log(log(N))), for using the inbuilt log() function.
Auxiliary Space: O(1)

Previous
Next