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

Find if a given number, num is power of 2 or not. More specifically, find if 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 :

• 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 : 3
Output : 0
2^0 = 1 where as k >= 1

Input : 128
Output : 1
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 last digit itself is not divisible by 2, we return 0. Otherwise we follow 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; ` ` `  `        ``// 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, j = 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; ` `} `

## 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 ` `?> ` ` `  `?> `

Output:

```0
0
1
```

Time Complexity : O(N^2) where N is number of digits in 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 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 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

 ` `

Output :

```1
```

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.