Checking if a number is power of 2 or not

Question

This is my solution in Java and I need your opinion:

public class Main {

  /**
   * 
   */

  public static void main(String[] args) {

    Scanner in = new Scanner(System.in);
    int number = in.nextInt();
    in.close();

    if (isPowerOfTwo(number)) {
      System.out.println("yes");
    } else {
      System.out.printf("no");
    }
  }

  private static boolean isPowerOfTwo(int number) {

    if (number % 2 != 0) {
      return false;
    } else {

      for (int i = 0; i <= number; i++) {

        if (Math.pow(2, i) == number) return true;
      }
    }
    return false;
  }
}

Answer 1

try-with-resources

Since Java 7, you should use try-with-resources on your Scanner for safe and efficient handling of the underlying I/O resource:

public static void main(String[] args) {
    try (Scanner scanner = new Scanner(System.in)) {
        int number = scanner.nextInt();
        // other operations
    }
}

Mathematical approach

You may want to consider using a faster mathematical approach to test if the number is a positive power of two or not...

boolean result = number > 0 && ((number & (number - 1)) == 0);

\$1\$ is technically a power of two: \$2^0\$

Answer 2

There's actually a bit hack for this :

private static boolean isPowerOfTwo(int number) {

    return number > 0 && ((number & (number - 1)) == 0);

}

(ref : Bit Twiddling hacks)

This exploits the fact, that in binary notation a power of two is a 1 followed by a number of 0's, and the number just below is all 1's equal to that number of 0's :

  100000000 // number
& 011111111 // number - 1
-----------
  000000000 

Answer 3

1. It incorrectly returns false when the input is 1. \$2^0 = 1\$
2. Looping up to number is very inefficient. For example if number is two billion, it'll loop two billion times, but you'd only need about log2(number) iterations, or simply hardcode the range 0 to 30, since the input is a 32-bit integer.

3. Mixing floating point and integers is difficult to reason about. In this case it's no problem, since every 32-bit integer is exactly representable as double, but using long the code would compile and return incorrect results, since Math.pow(2,62) == Long.MAX_VALUE / 2.

   I'd use bit-shifts instead.

Answer 4

Adding to the existing answers. If you want to preserve the idea of looping through powers of two, you can multiply by two at each step

int i=1;
while(i<number && i<Integer.MAX_VALUE/2) {
  i*=2;
}
return i == number;

If you want to use binary numbers you can check that the number is positive and contains exactly one one bit

return number > 0 && Integer.bitCount(number) == 1;

Note that Integer.MIN_VALUE has a bit count of one, so you technically need the number > 0 check.

Answer 5

If you don't want to use bit manipulation, then look at the Math.log2(x) method, which is the reverse of Math.pow(2, x).

Or alternatively repeat dividing the number by 2 until you have an odd number. If that number is 1 then the original number is a power of 2.