Reverse Bits - Practice Coding Problems

Reverse Bits - Problem

Reverse Bits is a fascinating bit manipulation challenge that tests your understanding of binary representation and bitwise operations.

Given a 32-bit unsigned integer, your task is to reverse the order of its bits. Think of it like reading a binary number backwards - the leftmost bit becomes the rightmost, and vice versa.

Example:

Input: 43261596 (00000010100101000001111010011100 in binary)
Output: 964176192 (00111001011110000010100101000000 in binary)

The key insight is that you need to process each individual bit and place it in the corresponding reverse position. This problem is excellent practice for understanding bit shifting, masking, and the relationship between decimal and binary representations.

Input & Output

example_1.py — Basic Case

$ Input: n = 43261596

› Output: 964176192

💡 Note: The binary representation of 43261596 is 00000010100101000001111010011100. When reversed, it becomes 00111001011110000010100101000000, which equals 964176192 in decimal.

example_2.py — All Zeros

$ Input: n = 0

› Output: 0

💡 Note: All bits are 0, so reversing gives the same result: 0.

example_3.py — Maximum Value

$ Input: n = 4294967295

› Output: 4294967295

💡 Note: This is 2^32 - 1, which has all bits set to 1. Reversing all 1s still gives all 1s, so the result is the same.

Visualization

Tap to expand

Understanding the Visualization

Setup

Start with input number and empty result

Extract

Take the rightmost bit from input

Transfer

Add it to the leftmost position of result

Shift

Move both numbers to process next bit

Repeat

Continue until all 32 bits are processed

Key Takeaway

🎯 Key Insight: Each bit position i maps to position (31-i) in the reversed result. The shifting approach elegantly builds this mapping by transferring one bit at a time from input to result.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always processes exactly 32 bits regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra variables

✓ Linear Space

Constraints

The input must be a 32-bit unsigned integer
0 ≤ n ≤ 2³² - 1
You must treat the integer as an unsigned value
Follow up: If this function is called many times, how would you optimize it?

Asked in

🍎 Apple 45 ⊞ Microsoft 38 a Amazon 32 G Google 28

The optimal approach uses bit shifting to efficiently reverse the bits. By shifting the result left and the input right in each iteration, we can transfer bits from the least significant position of input to the most significant positions of the result. This creates a natural reversal pattern with O(1) time complexity and elegant bit manipulation operations.

Common Approaches

Approach	Time	Space	Notes
✓ Bit-by-Bit Reversal	O(1)	O(1)	Extract each bit individually and build the reversed result
Bit Shifting Optimization	O(1)	O(1)	Build result by shifting bits from input to output efficiently

Bit-by-Bit Reversal — Algorithm Steps

Initialize result as 0
For each of the 32 bit positions (0 to 31)
Check if the current bit is set in the input number
If set, set the corresponding reversed bit position in result
Return the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with result = 0, process bit position 0

Check Bit

Check if bit at current position is set in input

Set Reversed

If set, set the corresponding reversed position in result

Continue

Move to next bit position and repeat

Code -

solution.c — C

#include <stdio.h>
#include <stdint.h>

uint32_t reverseBits(uint32_t n) {
    uint32_t result = 0;
    for (int i = 0; i < 32; i++) {
        // Check if bit at position i is set
        if (n & (1 << i)) {
            // Set bit at reversed position (31-i)
            result |= (1 << (31 - i));
        }
    }
    return result;
}

int main() {
    uint32_t n;
    scanf("%u", &n);
    printf("%u\n", reverseBits(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always processes exactly 32 bits regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra variables

✓ Linear Space

Constraints

The input must be a 32-bit unsigned integer
0 ≤ n ≤ 2³² - 1
You must treat the integer as an unsigned value
Follow up: If this function is called many times, how would you optimize it?

68.5K Views

Medium Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit-by-Bit Reversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler