Reverse Bits of a Number in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reversing bits for a small number

What is the output of reversing the bits of the 8-bit number 13 (00001101) using a 8-bit reverse function?

DSA Go

func reverseBits8(n uint8) uint8 {
    var result uint8 = 0
    for i := 0; i < 8; i++ {
        result <<= 1
        result |= n & 1
        n >>= 1
    }
    return result
}

fmt.Println(reverseBits8(13))

A 104

B 91

C 212

D 176

💡 Hint

Think about how bits shift left and right during reversal.

Reversing bits of 00001101 results in 10110000 which is 176 in decimal.

❓ Predict Output

intermediate

Output of reversing bits for a 16-bit number

What is the output of reversing the bits of the 16-bit number 4660 (0001001000110100) using a 16-bit reverse function?

DSA Go

func reverseBits16(n uint16) uint16 {
    var result uint16 = 0
    for i := 0; i < 16; i++ {
        result <<= 1
        result |= n & 1
        n >>= 1
    }
    return result
}

fmt.Println(reverseBits16(4660))

A 13328

B 13312

C 13330

D 13344

💡 Hint

Reverse the bits carefully and convert back to decimal.

Reversing bits of 0001001000110100 results in 0011001000010000 which is 13328 decimal.

🔧 Debug

advanced

Identify the error in this bit reversal code

What error does this Go code produce when reversing bits of a 32-bit unsigned integer?

DSA Go

func reverseBits32(n uint32) uint32 {
    var result uint32 = 0
    for i := 0; i < 32; i++ {
        result <<= 1
        result |= n & 1
        n >>= 1
    }
    return result
}

fmt.Println(reverseBits32(43261596))

A Compilation error due to invalid syntax

B Infinite loop

C Incorrect output due to extra iteration

D Index out of range error

💡 Hint

Check the loop boundary condition carefully.

The loop runs 33 times (i <= 32) instead of 32, causing an extra shift and wrong output.

🧠 Conceptual

advanced

Why use bitwise operations for reversing bits?

Which reason best explains why bitwise operations are preferred for reversing bits of a number?

A They automatically convert numbers to strings for easy reversal.

B They allow direct manipulation of individual bits efficiently.

C They use more memory but are easier to read.

D They avoid the need for loops by using recursion.

💡 Hint

Think about how computers store and handle bits.

Bitwise operations work directly on bits, making reversal fast and memory efficient.

❓ Predict Output

expert

Output of reversing bits for a 32-bit number with leading zeros

What is the output of reversing the bits of the 32-bit number 1 (only the least significant bit set) using a 32-bit reverse function?

DSA Go

func reverseBits32(n uint32) uint32 {
    var result uint32 = 0
    for i := 0; i < 32; i++ {
        result <<= 1
        result |= n & 1
        n >>= 1
    }
    return result
}

fmt.Println(reverseBits32(1))

A 2147483648

B 1

C 4294967295

D 0

💡 Hint

Consider where the single 1 bit moves after reversal.

Reversing bits of 000...0001 results in 100...0000 which is 2147483648 decimal.

Practice

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

easy

A. Shifting bits to the left by one position

B. Flipping the order of bits from left to right

C. Adding 1 to the number

D. Changing all 0s to 1s and 1s to 0s

Solution

1. Step 1: Understand bit representation

   Numbers are stored as bits (0s and 1s) in a sequence from left (most significant) to right (least significant).

2. Step 2: Define reversing bits

   Reversing bits means taking the bit sequence and flipping it so the first bit becomes last, second becomes second last, and so on.

3. Final Answer:

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

4. Quick Check:

   Reverse bits = flip order [OK]

Hint: Reverse bits means flip their order, not flip values [OK]

Common Mistakes:

• Confusing reversing bits with bitwise NOT (flip 0s and 1s)
• Thinking reversing bits means adding or subtracting
• Mixing reversing bits with shifting bits

2. Which Go code snippet correctly reverses bits of a 8-bit unsigned integer n?

easy

A. var rev uint8 = 0
for i := 0; i < 8; i++ {
rev = rev >> 1
rev |= n & 1
n <<= 1
}

B. var rev uint8 = 0
for i := 0; i < 8; i++ {
rev |= (n & 1) << i
n >>= 1
}

C. var rev uint8 = 0
for i := 0; i < 8; i++ {
rev += n & 1
n <<= 1
}

D. var rev uint8 = 0
for i := 0; i < 8; i++ {
rev <<= 1
rev |= n & 1
n >>= 1
}

Solution

1. Step 1: Analyze bit reversal logic

   We shift rev left to make space, add the least significant bit of n, then shift n right to process next bit.

2. Step 2: Check code correctness

   var rev uint8 = 0 for i := 0; i < 8; i++ { rev <<= 1 rev |= n & 1 n >>= 1 } correctly shifts rev left, ORs with n's last bit, then shifts n right. Others either shift wrong direction or add bits incorrectly.

3. Final Answer:

   The code in A correctly reverses bits -> Option D

4. Quick Check:

   Shift rev left + add n's LSB + shift n right = correct [OK]

Hint: Shift rev left, add n's last bit, shift n right each loop [OK]

Common Mistakes:

• Shifting rev right instead of left
• Shifting n left instead of right
• Adding bits without shifting rev

3. What is the output of this Go code snippet?

func reverseBits(n uint8) uint8 {
  var rev uint8 = 0
  for i := 0; i < 8; i++ {
    rev <<= 1
    rev |= n & 1
    n >>= 1
  }
  return rev
}

fmt.Println(reverseBits(13))

Note: 13 in binary is 00001101.

medium

A. 176

B. 11

C. 101

D. 208

Solution

1. Step 1: Convert 13 to binary and reverse bits

   13 in 8 bits: 00001101. Reversing bits: 10110000.

2. Step 2: Convert reversed bits back to decimal

   10110000 binary = 128 + 32 + 16 = 176 decimal.

3. Final Answer:

   176 -> Option A

4. Quick Check:

   Reverse(00001101) = 10110000 = 176 [OK]

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

Common Mistakes:

• Confusing bit order and reversing incorrectly
• Calculating decimal from wrong binary
• Ignoring leading zeros in 8-bit representation

4. Find the error in this Go function that tries to reverse bits of a 4-bit number:

func reverse4Bits(n uint8) uint8 {
  var rev uint8 = 0
  for i := 0; i < 4; i++ {
    rev |= (n & 1) << i
    n >>= 1
  }
  return rev
}

medium

A. The shift operator should be >> instead of <<

B. The loop should run 8 times for 4-bit numbers

C. The bits are not reversed; they are copied in the same order

D. Variable rev should be int, not uint8

Solution

1. Step 1: Understand the code logic

   The code shifts bits of n right, then sets rev bits by shifting left by i, which copies bits in same order.

2. Step 2: Identify why bits are not reversed

   Reversing bits requires shifting rev left each time and adding n's last bit, not shifting by i.

3. Final Answer:

   The bits are not reversed; they are copied in the same order -> Option C

4. Quick Check:

   Shifting rev by i copies bits, not reverses [OK]

Hint: Shift rev left each loop to reverse bits, not shift by i [OK]

Common Mistakes:

• Confusing bit copying with reversing
• Wrong loop count for bit size
• Incorrect variable types for bits

5. You want to reverse bits of a 16-bit unsigned integer and then check if the reversed number is a palindrome in binary (reads same forwards and backwards). Which approach is correct?

hard

A. Reverse bits using a loop, then compare reversed number with original

B. Reverse bits using a loop, then reverse again and compare with original

C. Check if original number equals reversed number without reversing bits

D. Shift bits left and right alternately without reversing

Solution

1. Step 1: Reverse bits of the number

   Use a loop to reverse all 16 bits to get reversed number.

2. Step 2: Check if reversed number is a palindrome

   To verify if reversed reads the same forwards and backwards, compute reverse(reversed) and check if it equals reversed. Since reverse(reversed) = original, this is equivalent to comparing reversed with original.

3. Final Answer:

   Reverse bits using a loop, then compare reversed number with original -> Option A

4. Quick Check:

   reversed == original iff reversed is palindrome [OK]

Hint: Reverse once, then compare reversed with original [OK]

Common Mistakes:

• Double reversing and comparing to original (always true, doesn't check palindrome)
• Trying to check equality without computing the reverse
• Using shifting without proper bit reversal