Reverse Bits of a Number in DSA C - Execution Trace

Concept Flow - Reverse Bits of a Number

Start with number n

↓

Initialize result = 0

↓

Loop 8 times

↓

Shift result left by 1

↓

Extract last bit of n

↓

Add extracted bit to result

↓

Shift n right by 1

↓

Repeat loop

↓

Return result with bits reversed

Start with the number, then for each of the 8 bits, shift the result left, add the last bit of the number, and shift the number right. Repeat until all bits are reversed.

Execution Sample

DSA C

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

This code reverses the bits of an 8-bit unsigned integer by shifting and masking bits.

Execution Table

Step	Operation	n (binary)	Extracted Bit	result (binary)	Visual State
1	Initialize result=0	00000000000000000000000000001010	-	00000000000000000000000000000000	result=0, n=10 (binary 1010)
2	Shift result left by 1	00000000000000000000000000001010	-	00000000000000000000000000000000	result=0
3	Extract last bit of n (n & 1)	00000000000000000000000000001010	0	00000000000000000000000000000000	bit=0
4	Add extracted bit to result	00000000000000000000000000001010	0	00000000000000000000000000000000	result=0
5	Shift n right by 1	00000000000000000000000000000101	-	00000000000000000000000000000000	n=5
6	Shift result left by 1	00000000000000000000000000000101	-	00000000000000000000000000000000	result=0
7	Extract last bit of n (n & 1)	00000000000000000000000000000101	1	00000000000000000000000000000000	bit=1
8	Add extracted bit to result	00000000000000000000000000000101	1	00000000000000000000000000000001	result=1
9	Shift n right by 1	00000000000000000000000000000010	-	00000000000000000000000000000001	n=2
10	Shift result left by 1	00000000000000000000000000000010	-	00000000000000000000000000000010	result=2
11	Extract last bit of n (n & 1)	00000000000000000000000000000010	0	00000000000000000000000000000010	bit=0
12	Add extracted bit to result	00000000000000000000000000000010	0	00000000000000000000000000000010	result=2
13	Shift n right by 1	00000000000000000000000000000001	-	00000000000000000000000000000010	n=1
14	Shift result left by 1	00000000000000000000000000000001	-	00000000000000000000000000000100	result=4
15	Extract last bit of n (n & 1)	00000000000000000000000000000001	1	00000000000000000000000000000100	bit=1
16	Add extracted bit to result	00000000000000000000000000000001	1	00000000000000000000000000000101	result=5
17	Shift n right by 1	00000000000000000000000000000000	-	00000000000000000000000000000101	n=0
18	Shift result left by 1	00000000000000000000000000000000	-	00000000000000000000000000001010	result=10
19	Extract last bit of n (n & 1)	00000000000000000000000000000000	0	00000000000000000000000000001010	bit=0
20	Add extracted bit to result	00000000000000000000000000000000	0	00000000000000000000000000001010	result=10
21	Shift n right by 1	00000000000000000000000000000000	-	00000000000000000000000000001010	n=0
22	Shift result left by 1	00000000000000000000000000000000	-	00000000000000000000000000010100	result=20
23	Extract last bit of n (n & 1)	00000000000000000000000000000000	0	00000000000000000000000000010100	bit=0
24	Add extracted bit to result	00000000000000000000000000000000	0	00000000000000000000000000010100	result=20
25	Shift n right by 1	00000000000000000000000000000000	-	00000000000000000000000000010100	n=0
26	Shift result left by 1	00000000000000000000000000000000	-	00000000000000000000000000101000	result=40
27	Extract last bit of n (n & 1)	00000000000000000000000000000000	0	00000000000000000000000000101000	bit=0
28	Add extracted bit to result	00000000000000000000000000000000	0	00000000000000000000000000101000	result=40
29	Shift n right by 1	00000000000000000000000000000000	-	00000000000000000000000000101000	n=0
30	Shift result left by 1	00000000000000000000000000000000	-	00000000000000000000000001010000	result=80
31	Extract last bit of n (n & 1)	00000000000000000000000000000000	0	00000000000000000000000001010000	bit=0
32	Add extracted bit to result	00000000000000000000000000000000	0	00000000000000000000000001010000	result=80
33	Shift n right by 1	00000000000000000000000000000000	-	00000000000000000000000001010000	n=0
34	Loop ends after 8 iterations	-	-	00000000000000000000000001010000	Final reversed bits result=80

💡 Loop ends after 8 iterations, all bits processed

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
n	00000000000000000000000000001010 (10)	00000000000000000000000000000101 (5)	00000000000000000000000000000010 (2)	00000000000000000000000000000001 (1)	00000000000000000000000000000000 (0)	00000000000000000000000000000000 (0)
result	00000000000000000000000000000000 (0)	00000000000000000000000000000000 (0)	00000000000000000000000000000001 (1)	00000000000000000000000000000010 (2)	00000000000000000000000000000101 (5)	00000000000000000000000001010000 (80)
Extracted Bit	-	0	1	0	1	0

Key Moments - 3 Insights

Why do we shift the result left before adding the extracted bit?

Shifting result left makes room for the new bit on the right. This is shown in execution_table rows 2 and 6 where result is shifted before adding the bit in rows 4 and 8.

Why do we extract the last bit of n using (n & 1)?

The expression (n & 1) isolates the least significant bit of n. This is the bit we add to result each iteration, as seen in execution_table rows 3, 7, 11, and 15.

What happens when n becomes zero before 8 iterations?

Even if n becomes zero early (row 17), the loop continues shifting result and adding zeros to complete 8 bits, ensuring all bits are reversed.

Visual Quiz - 3 Questions

Look at the execution_table at step 8, what is the value of result in binary?

A 00000000000000000000000000000001

B 00000000000000000000000000000010

C 00000000000000000000000000000000

D 00000000000000000000000000000101

💡 Hint

Check the 'result (binary)' column at step 8 in the execution_table.

At which step does n first become zero according to the execution_table?

A Step 14

B Step 17

C Step 20

D Step 33

💡 Hint

Look at the 'n (binary)' column to find when it changes to all zeros.

If we did not shift result left before adding the extracted bit, how would the result change at step 8?

A Result would be 0

B Result would be 2

C Result would be 1

D Result would be 5

💡 Hint

Without shifting left, adding bit 1 would set result to 1 directly, check step 8 in execution_table.

Concept Snapshot

Reverse Bits of a Number:
- Initialize result = 0
- Loop 8 times:
  - Shift result left by 1
  - Add last bit of n (n & 1) to result
  - Shift n right by 1
- Return result with bits reversed

Full Transcript

This concept reverses the bits of an 8-bit unsigned integer. We start with the input number n and a result initialized to zero. For each of the 8 bits, we shift the result left by one to make space, then add the least significant bit of n to result. Next, we shift n right by one to process the next bit. This repeats 8 times to reverse all bits. The execution table shows each step with the binary states of n and result, and the extracted bit. Key moments clarify why shifting and masking are needed. The visual quiz tests understanding of intermediate states and effects of operations.