Reverse Bits

Reverse Bits - Problem

Reverse bits of a given 32-bit unsigned integer.

Note: Note that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.

In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 2 below, the input represents the signed integer -3 and the output represents the signed integer -1073741825.

Input & Output

Example 1 — Basic Case

$ Input: n = 43261596

› Output: 964176192

💡 Note: Binary of 43261596 is 00000010100101000001111010011100. Reversing gives 00111001011110000010100101000000 which is 964176192 in decimal.

Example 2 — Negative Number

$ Input: n = -3

› Output: -1073741825

💡 Note: Binary of -3 (in 32-bit) is 11111111111111111111111111111101. Reversing gives 10111111111111111111111111111111 which is -1073741825 in decimal.

Example 3 — Edge Case

$ Input: n = 1

› Output: -2147483648

💡 Note: Binary of 1 is 00000000000000000000000000000001. Reversing gives 10000000000000000000000000000000 which is -2147483648 in decimal.

Constraints

The input must be a 32-bit unsigned integer
-2³¹ ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

A Apple 15 Ab Airbnb 8

The key insight is to use bit manipulation to extract each bit from the right and build the result from the left. The optimal approach uses bit shifting operations: extract LSB with n & 1, shift result left, add bit, then shift input right. Time: O(1), Space: O(1)

Common Approaches

✓ Bit-by-Bit Processing

⏱️ Time: O(1) Space: O(1)

Process each bit individually by extracting the least significant bit from the input and placing it at the most significant position of the result. Use bit shifting to efficiently move bits without string conversions.

Convert to Binary String

⏱️ Time: O(1) Space: O(1)

Convert the integer to its 32-bit binary string representation, reverse the string, then convert back to integer. This is straightforward but involves string operations which are slower than direct bit manipulation.

Bit-by-Bit Processing — Algorithm Steps

Extract rightmost bit from input
Place extracted bit at leftmost position in result
Shift input right and result left
Repeat for all 32 bits

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Bit

Get rightmost bit using n & 1

Build Result

Shift result left and add extracted bit

Continue

Shift input right and repeat

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    unsigned int result = 0;
    // Convert to unsigned 32-bit representation
    unsigned int num = (unsigned int)n;
    
    // Process all 32 bits
    for (int i = 0; i < 32; i++) {
        // Extract the least significant bit
        unsigned int bit = num & 1;
        // Shift result left and add the extracted bit
        result = (result << 1) | bit;
        // Shift num right to process next bit
        num >>= 1;
    }
    
    // Convert back to signed 32-bit if needed
    if (result >= (1U << 31)) {
        return (int)result - (int)(1ULL << 32);
    }
    
    return (int)result;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 32 iterations regardless of input value

✓ Linear Growth

Space Complexity

O(1)

Only uses a few integer variables

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Algorithm Visualization

Pinch to zoom • Tap outside to close

Test Cases

0 passed

0 failed

3 pending

Select Compiler

Choose a programming language

Compiler list would appear here...

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit-by-Bit Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler