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

Reverse Bits of a Number

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

🎯 Goal: You will write a program to reverse the bits of an 8-bit number. For example, if the number is 13 (binary 00001101), reversing the bits will give 176 (binary 10110000).

📋 What You'll Learn

Create an 8-bit unsigned integer variable called num with the value 13

Create an 8-bit unsigned integer variable called reversed_num and initialize it to 0

Use a for loop with variable i from 0 to 7 to reverse the bits of num

Print the value of reversed_num after reversing the bits

💡 Why This Matters

🌍 Real World

Bit reversal is used in digital signal processing and communication systems to reorder data bits for correct interpretation.

💼 Career

Understanding bitwise operations and bit manipulation is important for embedded systems programming, low-level device drivers, and performance optimization.

1

Create the initial number

Create an 8-bit unsigned integer variable called num and set it to 13.

DSA C

#include 

int main() {
    // Create an 8-bit unsigned integer variable called num and set it to 13
    // Your code here

    return 0;
}

Hint

Use unsigned char for an 8-bit number and assign 13 to num.

2

Create the reversed number variable

Create an 8-bit unsigned integer variable called reversed_num and initialize it to 0.

DSA C

#include 

int main() {
    unsigned char num = 13;
    // Create an 8-bit unsigned integer variable called reversed_num and set it to 0
    // Your code here

    return 0;
}

Hint

Use unsigned char reversed_num = 0; to start with zero reversed bits.

3

Reverse the bits using a loop

Use a for loop with variable i from 0 to 7 to reverse the bits of num and store the result in reversed_num. Inside the loop, shift reversed_num left by 1, then add the least significant bit of num. Then shift num right by 1.

DSA C

#include 

int main() {
    unsigned char num = 13;
    unsigned char reversed_num = 0;

    // Use a for loop with i from 0 to 7 to reverse bits
    // Your code here

    return 0;
}

Hint

Shift reversed_num left by 1, add the last bit of num, then shift num right by 1 in each loop.

4

Print the reversed number

Print the value of reversed_num using printf with format specifier %u.

DSA C

#include 

int main() {
    unsigned char num = 13;
    unsigned char reversed_num = 0;

    for (int i = 0; i >= 1;
    }

    // Print the reversed_num
    // Your code here

    return 0;
}

Hint

Use printf("%u\n", reversed_num); to print the reversed number.

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. Changing all 0s to 1s and 1s to 0s

C. Flipping the order of bits from left to right

D. Adding 1 to the number

Solution

1. Step 1: Understand bit order

   Bits are arranged from left (most significant) to right (least significant).

2. Step 2: Reverse means flip order

   Reversing bits means the leftmost bit becomes rightmost, second leftmost becomes second rightmost, and so on.

3. Final Answer:

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

4. Quick Check:

   Reverse bits = flip order [OK]

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

Common Mistakes:

• Confusing reversing bits with bitwise NOT
• Thinking reversing bits adds or subtracts from number
• Mixing bit shifting with reversing bits

2. Which of the following C code snippets correctly reverses the bits of an 8-bit unsigned integer n?

easy

A. unsigned char reverseBits(unsigned char n) { return n << 1; }

B. unsigned char reverseBits(unsigned char n) { unsigned char rev = 0; for(int i=0; i<8; i++) { rev |= (n & 1) << i; n >>= 1; } return rev; }

C. unsigned char reverseBits(unsigned char n) { return ~n; }

D. unsigned char reverseBits(unsigned char n) { unsigned char rev = 0; for(int i=0; i<8; i++) { rev <<= 1; rev |= (n & 1); n >>= 1; } return rev; }

Solution

1. Step 1: Analyze the correct loop logic

   The loop shifts rev left by 1, ORs with (n & 1), then shifts n right by 1. This reverses bits correctly.

2. Step 2: Check distractor options

   rev |= (n & 1) << i; n >>= 1; copies bits in same order. return ~n; is bitwise NOT, not reverse. return n << 1; shifts bits left, not reverse.

3. Final Answer:

   rev <<= 1; rev |= (n & 1); n >>= 1; -> Option D

4. Quick Check:

   Shift rev left + add bit from n = reverse bits [OK]

Hint: Shift rev left, add n's LSB, shift n right each step [OK]

Common Mistakes:

• Using bitwise NOT (~) instead of reversing bits
• Not shifting rev before adding new bit
• Shifting bits incorrectly causing wrong order

3. What is the output of the following C code snippet?

unsigned char reverseBits(unsigned char n) {
    unsigned char rev = 0;
    for(int i = 0; i < 8; i++) {
        rev <<= 1;
        rev |= (n & 1);
        n >>= 1;
    }
    return rev;
}

int main() {
    unsigned char x = 13; // binary 00001101
    unsigned char y = reverseBits(x);
    printf("%u", y);
    return 0;
}

medium

A. 11

B. 176

C. 101

D. 13

Solution

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

   13 in 8-bit binary is 00001101. Reversing bits gives 10110000.

2. Step 2: Convert reversed binary to decimal

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

3. Final Answer:

   176 -> Option B

4. Quick Check:

   Reverse 00001101 = 10110000 = 176 [OK]

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

Common Mistakes:

• Confusing reversed bits with original number
• Calculating decimal incorrectly from binary
• Ignoring leading zeros in binary

4. Identify the error in the following C function that attempts to reverse bits of a 4-bit number:

unsigned char reverseBits4(unsigned char n) {
    unsigned char rev = 0;
    for(int i = 0; i < 4; i++) {
        rev |= (n & 1) << i;
        n >>= 1;
    }
    return rev;
}

medium

A. It does not shift rev left before adding bits, so bits are not reversed

B. It shifts n left instead of right

C. It uses 8-bit loop instead of 4-bit

D. It returns rev without masking bits

Solution

1. Step 1: Analyze bit addition logic

   The code adds bits to rev using rev |= (n & 1) << i, which places bits in original order, not reversed.

2. Step 2: Understand correct reversing method

   To reverse bits, rev should be shifted left before adding new bit, not ORed at position i.

3. Final Answer:

   It does not shift rev left before adding bits, so bits are not reversed -> Option A

4. Quick Check:

   Shift rev left before adding bit to reverse [OK]

Hint: Shift rev left before OR to reverse bits correctly [OK]

Common Mistakes:

• Adding bits at same positions without shifting rev
• Confusing left and right shifts on n
• Looping wrong number of times

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

hard

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

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

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

D. Shift bits left by 8 and compare with original

Solution

1. Step 1: Compute reversed bits

   Reverse bits using a loop to obtain the reversed number rev.

2. Step 2: Check if reversed is palindrome

   The reversed number is a palindrome if it reads the same forwards and backwards, i.e., rev == original (since reverse(rev) == original always holds for a correct reverse).

3. Final Answer:

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

4. Quick Check:

   rev == original means rev is palindrome [OK]

Hint: rev == original checks if reversed bits form a palindrome [OK]

Common Mistakes:

• Thinking double reverse checks palindrome (it only verifies the reverse function)
• Trying to check palindrome without computing reversed bits
• Confusing bit reversal with simple shifts