Reverse Bits

class Solution {
public:
    uint32_t reverseBits(uint32_t value) {
        value = (value >> 16) | (value << 16);
        value = ((value & 0xff00ff00) >> 8) | ((value & 0x00ff00ff) << 8);
        value = ((value & 0xf0f0f0f0) >> 4) | ((value & 0x0f0f0f0f) << 4);
        value = ((value & 0xcccccccc) >> 2) | ((value & 0x33333333) << 2);
        value = ((value & 0xaaaaaaaa) >> 1) | ((value & 0x55555555) << 1);
        return value;
    }
};

This article provides a concise guide to reversing the bits of a 32-bit unsigned integer in C++. The provided C++ function utilizes bitwise operations to achieve this task efficiently. Let’s break down how the code operates:

• In the first line of the function, the code swaps the higher and lower 16 bits using bit shifting and bitwise OR operation.
• Subsequent lines perform further bit-level reversals. Each operation targets increasingly smaller segments—first 8-bit chunks, then 4 bits, 2 bits, and finally 1 bit—employing bitwise masks and shifts.
• Masks such as 0xff00ff00 and 0x00ff00ff allow for selective targeting of byte segments, and similar masks are applied for smaller bit segments.
• Each step reduces the level of granularity until each individual bit is reversed in the final operation using masks 0xaaaaaaaa and 0x55555555.

The resulting function efficiently reverses the bits of the input value, returning the newly arranged 32-bit unsigned integer. This solution offers not only efficacy in terms of execution but also clarity, using a series of logical bit manipulations.

public class Solution {
    public int flipBits(int m) {
        m = (m >>> 16) | (m << 16);
        m = ((m & 0xff00ff00) >>> 8) | ((m & 0x00ff00ff) << 8);
        m = ((m & 0xf0f0f0f0) >>> 4) | ((m & 0x0f0f0f0f) << 4);
        m = ((m & 0xcccccccc) >>> 2) | ((m & 0x33333333) << 2);
        m = ((m & 0xaaaaaaaa) >>> 1) | ((m & 0x55555555) << 1);
        return m;
    }
}

The "Reverse Bits" solution provided involves a series of bitwise operations in Java to reverse the bits of an integer. Below is a concise summary of how the solution works:

1. Declare a method flipBits that receives m as an integer argument.
2. The first operation shifts the bits of m to reverse the order of bytes, treating the integer as composed of two-byte halves.
3. Subsequent lines process progressively smaller groups of bits:
   • Separates and reverses bytes using masks 0xff00ff00 and 0x00ff00ff.
   • Handles nibbles (4 bits) with masks 0xf0f0f0f0 and 0x0f0f0f0f.
   • Interchanges pairs of bits using masks 0xcccccccc and 0x33333333.
   • Finally, swaps individual bits using masks 0xaaaaaaaa and 0x55555555.
4. Each step involves a mask and shift operation:
   • Apply a bit mask to isolate groups of bits.
   • Shift isolated bits to their new reversed positions.
5. The final line returns the reversed bit integer.

This method efficiently reverses the bits of an integer using a combination of masks and shifts, ensuring the process is both clear and optimal in terms of performance.

class Solution:
    def reverse32(self, x: int) -> int:
        x = (x >> 16) | (x << 16)
        x = ((x & 0xFF00FF00) >> 8) | ((x & 0x00FF00FF) << 8)
        x = ((x & 0xF0F0F0F0) >> 4) | ((x & 0x0F0F0F0F) << 4)
        x = ((x & 0xCCCCCCCC) >> 2) | ((x & 0x33333333) << 2)
        x = ((x & 0xAAAAAAAA) >> 1) | ((x & 0x55555555) << 1)
        return x

The solution employs a bit manipulation technique to reverse the bits of a 32-bit integer in Python. To accomplish this, the provided code performs the following operations:

1. Swap the Halfwords: The code first swaps the two halves (16 bits each) of the 32-bit integer. This is achieved using:

   • x = (x >> 16) | (x << 16)

2. Swap the Bytes: It then swaps consecutive 8-bit blocks by masking and shifting bits.

   • x = ((x & 0xFF00FF00) >> 8) | ((x & 0x00FF00FF) << 8)

3. Swap the Nibbles: Each byte (now correctly positioned) is split into nibbles (4 bits) and swapped.

   • x = ((x & 0xF0F0F0F0) >> 4) | ((x & 0x0F0F0F0F) << 4)

4. Swap Pairs of Bits: Consecutive groups of two bits are swapped next.

   • x = ((x & 0xCCCCCCCC) >> 2) | ((x & 0x33333333) << 2)

5. Swap Individual Bits: Finally, each adjacent pair of bits gets swapped.

   • x = ((x & 0xAAAAAAAA) >> 1) | ((x & 0x55555555) << 1)

By the end of these operations, x holds the value of the original integer with all bits reversed, and this value is returned. This method ensures that every bit in the integer occupies the position that its mirror image would in a purely reversed binary number, thus effectively reversing the bits of the integer.