Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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 <stdio.h>
#include <string.h>
 
// 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 <bits/stdc++.h>
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




<?php
/* PHP 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)
{
    $len_str = strlen($str);
 
    // 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 && $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 <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
 
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




<?php
// PHP program to find
// whether a number
// is power of 2 or not
 
// Function to check whether a
// number is power of 2 or not
function ispowerof2 ( $num )
{
    if (($num & ($num - 1 )) == 0)
        return 1;
    return 0;
}
 
// Driver Code
$num = 549755813888;
echo ispowerof2($num);
 
// This code is contributed
// by mits
?>


Javascript




<script>
 
// Javascript program to find
// whether a number
// is power of 2 or not
 
// Function to check whether a
// number is power of 2 or not
function ispowerof2(num)
{
    if ((num & (num - 1)) == 0)
        return 1;
         
    return 0;
}
 
// Driver code
var num = 549755813888;
 
document.write(ispowerof2(num));
 
// This code is contributed by Princi Singh
 
</script>


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 <iostream>
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




<script>
var x = 128;
 
// condition to check if given
// number is power of 2 or not
    if (x and (not(x & (x - 1))))
    {
      document.write("Yes");
    }
  else
  {
     document.write("No");
  }
   
  // This code is contributed by ksrikanth0498
  </script>


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 <iostream>
#include <math.h>
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)

Reference: https://www.boost.org/doc/libs/1_61_0/libs/multiprecision/doc/html/index.html

 



Last Updated : 08 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads