Reverse Bits of a Number in DSA Python - Build from Scratch

Reverse Bits of a Number

📖 Scenario: Imagine you are working with a simple digital device that stores numbers in binary form. Sometimes, you need to reverse the order of bits in a number to decode a message or fix data alignment.

🎯 Goal: You will write a program that takes a number and reverses its bits. For example, if the number is 13 (binary 1101), reversing the bits gives 11 (binary 1011).

📋 What You'll Learn

Create a variable to hold the input number.

Create a variable to hold the number of bits to reverse.

Write a loop to reverse the bits of the number.

Print the reversed number.

💡 Why This Matters

🌍 Real World

Reversing bits is useful in low-level programming, data encoding, and communication protocols where bit order matters.

💼 Career

Understanding bitwise operations and bit manipulation is important for roles in embedded systems, firmware development, and performance optimization.

1

Create the input number

Create a variable called num and set it to 13.

DSA Python

# Create a variable called num and set it to 13
# Your code here

Hint

Use num = 13 to store the number.

2

Set the number of bits to reverse

Create a variable called bit_size and set it to 4 because we want to reverse 4 bits.

DSA Python

num = 13
# Create a variable called bit_size and set it to 4
# Your code here

Hint

Use bit_size = 4 to specify how many bits to reverse.

3

Reverse the bits of the number

Create a variable called reversed_num and set it to 0. Then use a for loop with variable i from 0 to bit_size - 1. Inside the loop, shift reversed_num left by 1, add the least significant bit of num, and then shift num right by 1.

DSA Python

num = 13
bit_size = 4
# Reverse the bits of num using a for loop
# Your code here

Hint

Use bitwise operators: & to get the last bit, << to shift left, and >> to shift right.

4

Print the reversed number

Print the value of reversed_num.

DSA Python

num = 13
bit_size = 4
reversed_num = 0
for i in range(bit_size):
    reversed_num = (reversed_num > 1
# Print the reversed number
# Your code here

Hint

Use print(reversed_num) to show the result.

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