Why Check if Number is Power of Two in DSA Python?

The Big Idea

Discover a tiny trick that turns a long, boring check into a blink-of-an-eye answer!

The Scenario

Imagine you have a big list of numbers and you want to find out which ones are powers of two, like 1, 2, 4, 8, 16, and so on. Doing this by hand means dividing each number by 2 again and again to see if you end up with 1.

The Problem

This manual way is slow and boring. You might make mistakes counting divisions or forget to check some numbers. It takes a lot of time if the list is big, and it's easy to get confused.

The Solution

Using a simple trick with bits (the tiny 0s and 1s inside computers), we can quickly check if a number is a power of two. This method is fast, clean, and never makes mistakes, even with very big numbers.

Before vs After

✗ Before

def is_power_of_two(number):
    if number < 1:
        return False
    while number % 2 == 0:
        number = number // 2
    return number == 1

✓ After

def is_power_of_two(number):
    return number > 0 and (number & (number - 1)) == 0

What It Enables

This lets us instantly know if a number is a power of two, making programs faster and simpler.

Real Life Example

In computer graphics, textures often need to be powers of two in size for better performance. Quickly checking this helps games run smoothly.

Key Takeaways

Manual division is slow and error-prone.

Bitwise check is fast and reliable.

Useful in many computer tasks like graphics and memory management.

Practice

1. Which of the following numbers is a power of two?

easy

A. 16

B. 18

C. 20

D. 22

Solution

1. Step 1: Understand powers of two

   Powers of two are numbers like 1, 2, 4, 8, 16, 32, etc., where each is 2 raised to an integer.

2. Step 2: Check each option

   16 = 2^4, so it is a power of two. Others like 18, 20, 22 are not powers of two.

3. Final Answer:

   16 -> Option A

4. Quick Check:

   16 = 2^4 [OK]

Hint: Only numbers with one '1' bit in binary are powers of two [OK]

Common Mistakes:

• Confusing even numbers with powers of two
• Thinking any multiple of 2 is a power of two

2. Which of the following Python expressions correctly checks if n is a power of two?

easy

A. n | (n - 1) == 0

B. n & (n - 1) == 0

C. n ^ (n - 1) == 0

D. n + (n - 1) == 0

Solution

1. Step 1: Understand bitwise AND check

   For powers of two, binary form has only one '1'. n & (n-1) clears the lowest set bit. If result is 0, n is power of two.

2. Step 2: Analyze options

   n & (n - 1) == 0 uses correct bitwise AND check. Others use OR, XOR, or addition which do not correctly check power of two.

3. Final Answer:

   n & (n - 1) == 0 -> Option B

4. Quick Check:

   Bitwise AND check is standard for power of two [OK]

Hint: Use n & (n-1) == 0 to check power of two [OK]

Common Mistakes:

• Using OR or XOR instead of AND
• Forgetting to check n > 0 before this test

3. What is the output of the following code?

def is_power_of_two(n):
    return n > 0 and (n & (n - 1)) == 0

print(is_power_of_two(32))
print(is_power_of_two(45))

medium

A. False\nFalse

B. False\nTrue

C. True\nFalse

D. True\nTrue

Solution

1. Step 1: Check 32

   32 is 2^5, so n > 0 and n & (n-1) == 0 is True.

2. Step 2: Check 45

   45 is not a power of two, so n & (n-1) != 0, returns False.

3. Final Answer:

   True\nFalse -> Option C

4. Quick Check:

   32 power of two = True, 45 not = False [OK]

Hint: Check output for known powers of two and non-powers [OK]

Common Mistakes:

• Ignoring n > 0 condition
• Assuming all even numbers are powers of two

4. Find the error in this code snippet that checks if a number is a power of two:

def check_power(n):
    if n & (n - 1) == 0:
        return True
    else:
        return False

print(check_power(0))

medium

A. Missing check for n > 0 before bitwise operation

B. No error, code works fine

C. Should use OR instead of AND

D. Return values should be strings 'True' or 'False'

Solution

1. Step 1: Analyze bitwise check

   n & (n-1) == 0 works only if n > 0. For n=0, it returns True incorrectly.

2. Step 2: Identify missing condition

   Code lacks n > 0 check, so 0 incorrectly returns True.

3. Final Answer:

   Missing check for n > 0 before bitwise operation -> Option A

4. Quick Check:

   Always check n > 0 before bitwise test [OK]

Hint: Always check n > 0 before bitwise power of two test [OK]

Common Mistakes:

• Not handling zero or negative inputs
• Using wrong bitwise operators

5. You want to filter a list to keep only numbers that are powers of two. Which code snippet correctly does this?

nums = [0, 1, 2, 3, 4, 5, 8, 16, 18]

A) result = [x for x in nums if x & (x - 1) == 0]
B) result = [x for x in nums if x > 0 and x & (x - 1) == 0]
C) result = [x for x in nums if x | (x - 1) == 0]
D) result = [x for x in nums if x > 0 or x & (x - 1) == 0]

hard

A. result = [x for x in nums if x & (x - 1) == 0]

B. result = [x for x in nums if x > 0 or x & (x - 1) == 0]

C. result = [x for x in nums if x | (x - 1) == 0]

D. result = [x for x in nums if x > 0 and x & (x - 1) == 0]

Solution

1. Step 1: Understand filtering condition

   We must check x > 0 to avoid zero or negative numbers passing the test.

2. Step 2: Analyze each option

   result = [x for x in nums if x > 0 and x & (x - 1) == 0] correctly uses x > 0 and bitwise check. result = [x for x in nums if x & (x - 1) == 0] misses x > 0, so 0 passes incorrectly. Options C and D use wrong operators or logic.

3. Final Answer:

   result = [x for x in nums if x > 0 and x & (x - 1) == 0] -> Option D

4. Quick Check:

   Filter with x > 0 and bitwise AND check [OK]

Hint: Filter with x > 0 and x & (x-1) == 0 for powers of two [OK]

Common Mistakes:

• Not filtering out zero
• Using OR instead of AND in condition
• Using bitwise OR instead of AND