Reverse Bits of a Number in DSA Python - Execution Trace

Concept Flow - Reverse Bits of a Number

Start with number n

↓

Initialize result = 0

↓

Repeat for each bit position i from 0 to 31

↓

Extract bit at position i from n

↓

Shift result left by 1

↓

Add extracted bit to result

↓

Move to next bit

↓

After 32 bits, return result

We take each bit from the original number starting from the least significant bit, and build the reversed number by shifting and adding bits one by one.

Execution Sample

DSA Python

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

This code reverses the bits of a 32-bit unsigned integer by extracting each bit and building the reversed number.

Execution Table

Step	Operation	Bit Extracted	Result Before	Result After	Visual State (bits)
1	Extract bit 0	1	00000000000000000000000000000000	00000000000000000000000000000001	00000000000000000000000000000001
2	Extract bit 1	0	00000000000000000000000000000010	00000000000000000000000000000010	00000000000000000000000000000010
3	Extract bit 2	1	00000000000000000000000000000101	00000000000000000000000000000101	00000000000000000000000000000101
4	Extract bit 3	0	00000000000000000000000000001010	00000000000000000000000000001010	00000000000000000000000000001010
5	Extract bit 4	1	00000000000000000000000000010101	00000000000000000000000000010101	00000000000000000000000000010101
6	Extract bit 5	0	00000000000000000000000000101010	00000000000000000000000000101010	00000000000000000000000000101010
7	Extract bit 6	0	00000000000000000000000001010100	00000000000000000000000001010100	00000000000000000000000001010100
8	Extract bit 7	0	00000000000000000000000010101000	00000000000000000000000010101000	00000000000000000000000010101000
9	Extract bit 8	0	00000000000000000000000101010000	00000000000000000000000101010000	00000000000000000000000101010000
10	Extract bit 9	0	00000000000000000000001010100000	00000000000000000000001010100000	00000000000000000000001010100000
11	Extract bit 10	0	00000000000000000000010101000000	00000000000000000000010101000000	00000000000000000000010101000000
12	Extract bit 11	0	00000000000000000000101010000000	00000000000000000000101010000000	00000000000000000000101010000000
13	Extract bit 12	0	00000000000000000001010100000000	00000000000000000001010100000000	00000000000000000001010100000000
14	Extract bit 13	0	00000000000000000010101000000000	00000000000000000010101000000000	00000000000000000010101000000000
15	Extract bit 14	0	00000000000000000101010000000000	00000000000000000101010000000000	00000000000000000101010000000000
16	Extract bit 15	0	00000000000000001010100000000000	00000000000000001010100000000000	00000000000000001010100000000000
17	Extract bit 16	0	00000000000000010101000000000000	00000000000000010101000000000000	00000000000000010101000000000000
18	Extract bit 17	0	00000000000000101010000000000000	00000000000000101010000000000000	00000000000000101010000000000000
19	Extract bit 18	0	00000000000001010100000000000000	00000000000001010100000000000000	00000000000001010100000000000000
20	Extract bit 19	0	00000000000010101000000000000000	00000000000010101000000000000000	00000000000010101000000000000000
21	Extract bit 20	0	00000000000101010000000000000000	00000000000101010000000000000000	00000000000101010000000000000000
22	Extract bit 21	0	00000000001010100000000000000000	00000000001010100000000000000000	00000000001010100000000000000000
23	Extract bit 22	0	00000000010101000000000000000000	00000000010101000000000000000000	00000000010101000000000000000000
24	Extract bit 23	0	00000000101010000000000000000000	00000000101010000000000000000000	00000000101010000000000000000000
25	Extract bit 24	0	00000001010100000000000000000000	00000001010100000000000000000000	00000001010100000000000000000000
26	Extract bit 25	0	00000010101000000000000000000000	00000010101000000000000000000000	00000010101000000000000000000000
27	Extract bit 26	0	00000101010000000000000000000000	00000101010000000000000000000000	00000101010000000000000000000000
28	Extract bit 27	0	00001010100000000000000000000000	00001010100000000000000000000000	00001010100000000000000000000000
29	Extract bit 28	0	00010101000000000000000000000000	00010101000000000000000000000000	00010101000000000000000000000000
30	Extract bit 29	0	00101010000000000000000000000000	00101010000000000000000000000000	00101010000000000000000000000000
31	Extract bit 30	0	01010100000000000000000000000000	01010100000000000000000000000000	01010100000000000000000000000000
32	Extract bit 31	0	10101000000000000000000000000000	10101000000000000000000000000000	10101000000000000000000000000000

💡 All 32 bits processed, loop ends

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	After 8	After 9	After 10	After 11	After 12	After 13	After 14	After 15	After 16	After 17	After 18	After 19	After 20	After 21	After 22	After 23	After 24	After 25	After 26	After 27	After 28	After 29	After 30	After 31	After 32	Final
result	00000000000000000000000000000000	00000000000000000000000000000001	00000000000000000000000000000010	00000000000000000000000000000101	00000000000000000000000000001010	00000000000000000000000000010101	00000000000000000000000000101010	00000000000000000000000001010100	00000000000000000000000010101000	00000000000000000000000101010000	00000000000000000000001010100000	00000000000000000000010101000000	00000000000000000000101010000000	00000000000000000001010100000000	00000000000000000010101000000000	00000000000000000101010000000000	00000000000000001010100000000000	00000000000000010101000000000000	00000000000000101010000000000000	00000000000001010100000000000000	00000000000010101000000000000000	00000000000101010000000000000000	00000000001010100000000000000000	00000000010101000000000000000000	00000000101010000000000000000000	00000001010100000000000000000000	00000010101000000000000000000000	00000101010000000000000000000000	00001010100000000000000000000000	00010101000000000000000000000000	00101010000000000000000000000000	01010100000000000000000000000000	10101000000000000000000000000000	10101000000000000000000000000000

Key Moments - 3 Insights

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

Because we build the reversed number from left to right, shifting left makes space for the new bit at the rightmost position. This is shown in execution_table rows where 'Result Before' is shifted left before adding 'Bit Extracted'.

Why do we extract bits from the original number using (n >> i) & 1?

This operation moves the bit at position i to the least significant bit and masks all others, isolating that single bit. The execution_table shows 'Bit Extracted' changing each step, confirming this extraction.

Why do we loop exactly 32 times?

Because we assume a 32-bit number, and each bit must be processed to reverse the entire bit pattern. The exit_note confirms the loop ends after 32 bits.

Visual Quiz - 3 Questions

Look at the execution_table at Step 3, what is the 'Bit Extracted' value?

A 0

B 1

C 2

D None

💡 Hint

Check the 'Bit Extracted' column in row with Step 3 in execution_table.

At which step does the 'Result After' first become 00000000000000000000000000000101?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Result After' column in execution_table rows for the exact bit pattern.

If we change the loop to run only 16 times, what will happen to the 'Final' result?

A It will reverse only the lower 16 bits

B It will reverse all 32 bits

C It will produce zero

D It will cause an error

💡 Hint

Refer to the concept_flow and variable_tracker showing 32 iterations for full reversal.

Concept Snapshot

Reverse Bits of a Number:
- Loop 32 times for each bit
- Extract bit i with (n >> i) & 1
- Shift result left by 1
- Add extracted bit to result
- Return result after loop
- Reverses bit order of 32-bit integer

Full Transcript

This concept reverses the bits of a 32-bit number by extracting each bit from the original number starting from the least significant bit. For each bit, the result is shifted left to make space, then the extracted bit is added. This process repeats 32 times to cover all bits. The execution table shows each step with the bit extracted, the result before and after shifting and adding, and the visual bit pattern. The variable tracker follows the result variable's changes after each iteration. Key moments clarify why shifting is needed before adding bits, how bits are extracted, and why the loop runs 32 times. The visual quiz tests understanding of bit extraction, result changes, and effects of changing loop count.