Reverse Bits of a Number in DSA Python - Time & Space Complexity

Time Complexity: Reverse Bits of a Number

O(1)

Understanding Time Complexity

We want to understand how the time to reverse bits in a number changes as the number size changes.

Specifically, how many steps does it take to flip all bits from right to left?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

def reverse_bits(n: int) -> int:
    result = 0
    for i in range(32):
        bit = (n >> i) & 1
        result |= bit << (31 - i)
    return result

This code reverses the bits of a 32-bit integer by checking each bit and placing it in the reversed position.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A loop running 32 times to process each bit.
• How many times: Exactly 32 times, once for each bit in the integer.

How Execution Grows With Input

Since the loop runs a fixed 32 times regardless of the input number, the operations stay the same.

Input Size (n)	Approx. Operations
10 (small number)	32 steps
100 (larger number)	32 steps
1000 (even larger)	32 steps

Pattern observation: The number of steps does not grow with input size; it stays constant.

Final Time Complexity

Time Complexity: O(1)

This means the time to reverse bits is constant and does not increase as the input number grows.

Common Mistake

[X] Wrong: "The time to reverse bits depends on the value of the number or its size."

[OK] Correct: The code always processes a fixed number of bits (32), so time does not change with the number's value.

Interview Connect

Understanding fixed-time operations like bit manipulation shows you can reason about low-level efficiency, a valuable skill in many coding challenges.

Self-Check

What if we changed the code to reverse bits of a 64-bit number? How would the time complexity change?

Practice

1. What does reversing the bits of a number mean in simple terms?

easy

A. Multiplying the number by 2

B. Changing all 0 bits to 1 bits

C. Flipping the order of all bits from left to right

D. Adding 1 to the number

Solution

1. Step 1: Understand bits as binary digits

   Bits are the 0s and 1s that make up a number in binary form.

2. Step 2: Define reversing bits

   Reversing bits means reading the bits from right to left instead of left to right, flipping their order.

3. Final Answer:

   Flipping the order of all bits from left to right -> Option C

4. Quick Check:

   Reverse bits = flip order [OK]

Hint: Think of bits as beads on a string flipped end to end [OK]

Common Mistakes:

• Confusing reversing bits with flipping bits (0 to 1)
• Thinking reversing bits means adding or multiplying
• Assuming reversing bits changes the number's value directly

2. Which of the following Python code snippets correctly reverses the bits of an 8-bit number n?

easy

A. reversed_num = 0
for i in range(8):
reversed_num |= ((n >> i) & 1) << (7 - i)

B. reversed_num = 0
for i in range(8):
reversed_num |= ((n << i) & 1) << i

C. reversed_num = n << 8

D. reversed_num = n >> 8

Solution

1. Step 1: Analyze bit extraction and placement

   reversed_num = 0 for i in range(8): reversed_num |= ((n >> i) & 1) << (7 - i) extracts each bit from right to left and places it reversed from left to right.

2. Step 2: Check other options for correctness

   reversed_num = 0 for i in range(8): reversed_num |= ((n << i) & 1) << i shifts bits incorrectly; C and D just shift without reversing bits.

3. Final Answer:

   Option A code correctly reverses bits -> Option A

4. Quick Check:

   Shift right, mask, shift left reversed position [OK]

Hint: Use bit shifts and masks to pick and place bits reversed [OK]

Common Mistakes:

• Using left shift instead of right shift to extract bits
• Not shifting bits to reversed positions
• Confusing bitwise OR with addition

3. What is the output of the following Python code?

def reverse_bits(n):
    result = 0
    for i in range(4):
        result |= ((n >> i) & 1) << (3 - i)
    return result

print(reverse_bits(13))  # 13 in binary is 1101

medium

A. 13

B. 7

C. 14

D. 11

Solution

1. Step 1: Convert 13 to 4-bit binary and reverse bits

   13 in 4 bits is 1101. Reversing bits: 1011.

2. Step 2: Convert reversed bits back to decimal

   1011 in binary is 8+0+2+1 = 11.

3. Final Answer:

   11 -> Option D

4. Quick Check:

   1101 reversed = 1011 = 11 [OK]

Hint: Reverse bits visually, then convert back to decimal [OK]

Common Mistakes:

• Not reversing bits correctly (reading left to right)
• Confusing binary to decimal conversion
• Using wrong bit length for reversal

4. Find the error in this code that attempts to reverse bits of a 3-bit number n:

def reverse_bits(n):
    result = 0
    for i in range(3):
        bit = (n >> i) & 1
        result |= bit << i
    return result

medium

A. It uses wrong bitwise AND operator

B. It shifts bits to the same position instead of reversed position

C. It does not initialize result to zero

D. It uses range(3) instead of range(4)

Solution

1. Step 1: Check bit shifting logic

   The code shifts extracted bits back to the same position i, not reversed (2 - i).

2. Step 2: Identify correct reversed position

   For 3 bits, reversed position should be (2 - i) to flip bits order.

3. Final Answer:

   It shifts bits to the same position instead of reversed position -> Option B

4. Quick Check:

   Shift bits to reversed index, not original [OK]

Hint: Shift bits to (bit_length - 1 - i) for reversal [OK]

Common Mistakes:

• Shifting bits back to original position
• Forgetting to reverse bit positions
• Incorrect loop range for bit length

5. You want to reverse the bits of a 5-bit number n and then add it to the original number. Which Python code correctly does this?

hard

A. def reverse_bits(n):
result = 0
for i in range(5):
result |= ((n >> i) & 1) << (4 - i)
return result

print(n + reverse_bits(n))

B. def reverse_bits(n):
result = 0
for i in range(5):
result |= ((n << i) & 1) << i
return result

print(n - reverse_bits(n))

C. def reverse_bits(n):
return n << 5

print(n + reverse_bits(n))

D. def reverse_bits(n):
return n >> 5

print(n + reverse_bits(n))

Solution

1. Step 1: Verify bit reversal logic for 5 bits

   def reverse_bits(n): result = 0 for i in range(5): result |= ((n >> i) & 1) << (4 - i) return result print(n + reverse_bits(n)) correctly reverses bits by shifting each bit from position i to (4 - i).

2. Step 2: Check addition of reversed bits to original

   def reverse_bits(n): result = 0 for i in range(5): result |= ((n >> i) & 1) << (4 - i) return result print(n + reverse_bits(n)) prints sum of n and reversed bits, matching the problem requirement.

3. Final Answer:

   Option A code correctly reverses bits and adds to original -> Option A

4. Quick Check:

   Reverse bits with correct shifts, then add [OK]

Hint: Reverse bits by shifting to (bit_length - 1 - i), then add [OK]

Common Mistakes:

• Using left shift instead of right shift for extraction
• Subtracting instead of adding reversed bits
• Incorrect bit length or shift positions