Reverse Bits - Practice Coding Problems

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

Understanding the Visualization

Input

32-bit integer representation

Process

Reverse the order of all 32 bits

Output

Reversed bit pattern as integer

Key Takeaway

🎯 Key Insight: Use bit manipulation to efficiently extract and reposition each bit without string conversions

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

Approach	Time	Space	Notes
✓ Convert to Binary String	O(1)	O(1)	Convert number to 32-bit binary string, reverse it, convert back
Bit-by-Bit Processing	O(1)	O(1)	Extract each bit from right and build result from left using bit shifting

Convert to Binary String — Algorithm Steps

Convert integer to 32-bit binary string
Reverse the binary string
Convert reversed string back to integer

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Binary

Convert integer to 32-bit binary string

Reverse String

Reverse the binary string

Convert Back

Parse reversed string to get result

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int solution(int n) {
    char binary[33];
    char reversed[33];
    unsigned int num = (unsigned int)n;
    
    // Convert to 32-bit binary string
    for (int i = 0; i < 32; i++) {
        binary[31-i] = ((num >> i) & 1) ? '1' : '0';
    }
    binary[32] = '\0';
    
    // Reverse the binary string
    for (int i = 0; i < 32; i++) {
        reversed[i] = binary[31-i];
    }
    reversed[32] = '\0';
    
    // Convert back to integer
    unsigned int result = 0;
    for (int i = 0; i < 32; i++) {
        if (reversed[i] == '1') {
            result |= (1U << (31 - i));
        }
    }
    
    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)

Always processes exactly 32 bits regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only stores fixed-size binary string (32 characters)

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Convert to Binary String — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler