Swap Adjacent Nibble Pairs in a 32-Bit Unsigned Integer
Company: Arista Networks
Role: Software Engineer
Category: Coding & Algorithms
Difficulty: medium
Interview Round: Technical Screen
A nibble is a group of 4 bits, which is one hexadecimal digit. Given a 32-bit unsigned integer, swap every even-position nibble with the odd-position nibble next to it, and return the result. For example, the hexadecimal value `0x12345678` becomes `0x21436587`.
The report did not state the integer's width; this version fixes it at 32 bits.
### Function Signature
```python
def swap_nibbles(x: int) -> int:
```
### Rules
- Nibble positions count from the least significant end: position 0 is bits 0 to 3, position 1 is bits 4 to 7, and so on up to position 7, which is bits 28 to 31.
- Swap position 0 with position 1, 2 with 3, 4 with 5, and 6 with 7.
- `x` is treated as exactly 32 bits, so leading zero nibbles take part in the swap: `0x1` becomes `0x10`.
- Return the result as a non-negative integer in the same 32-bit range. Inputs and outputs are plain integers; the hexadecimal forms below are only for reading.
### Constraints
- `0 <= x <= 2^32 - 1`, that is, `0 <= x <= 4294967295`
- Inputs and outputs can exceed the 32-bit signed maximum `2^31 - 1`, so in a fixed-width language use an unsigned 32-bit or a 64-bit type.
### Examples
**Example 1**
```text
Input: x = 305419896 (0x12345678)
Output: 558065031 (0x21436587)
```
The pairs `12`, `34`, `56` and `78` each swap their two digits.
**Example 2**
```text
Input: x = 171 (0x000000AB)
Output: 186 (0x000000BA)
```
Nibble 0 holds `B` and nibble 1 holds `A`; they trade places. The zero nibbles above them swap with each other and stay zero.
**Example 3**
```text
Input: x = 4026531841 (0xF0000001)
Output: 251658256 (0x0F000010)
```
Nibbles 7 and 6 (`F` and `0`) swap, and nibbles 1 and 0 (`0` and `1`) swap.
Overview: A bit manipulation problem: given a 32-bit unsigned integer, swap each even-position nibble, one hexadecimal digit of 4 bits, with the adjacent odd-position nibble and return the result. It tests masks, shifts and handling values above the signed 32-bit range.
Read the full Arista Networks Software Engineer interview experience this question came from
A nibble is a group of 4 bits, which is one hexadecimal digit. You are given an unsigned 32-bit integer `x`. Swap every even-position nibble with the odd-position nibble next to it, and return the resulting integer.
**Rules**
- Nibble positions count from the least significant end: position 0 is bits 0 to 3, position 1 is bits 4 to 7, and so on up to position 7, which is bits 28 to 31.
- Swap position 0 with position 1, position 2 with position 3, position 4 with position 5, and position 6 with position 7.
- `x` is treated as exactly 32 bits, so leading zero nibbles take part in the swap: `0x1` becomes `0x10`.
- Return the result as a non-negative integer in the same 32-bit range. Inputs and outputs are plain integers; the hexadecimal forms below are only for reading.
**Example 1**
```text
Input: x = 305419896 (0x12345678)
Output: 558065031 (0x21436587)
```
The pairs `12`, `34`, `56` and `78` each swap their two digits.
**Example 2**
```text
Input: x = 4026531841 (0xF0000001)
Output: 251658256 (0x0F000010)
```
Nibbles 7 and 6 (`F` and `0`) swap, and nibbles 1 and 0 (`0` and `1`) swap.
**Constraints**
- `0 <= x <= 2^32 - 1`, that is, `0 <= x <= 4294967295`
- Inputs and outputs can exceed the 32-bit signed maximum `2^31 - 1` (2147483647), so Java uses `long` and C++ uses `long long`. Every value stays below 2^53, so a JavaScript number holds it exactly.
Constraints
- 0 <= x <= 2^32 - 1, that is, 0 <= x <= 4294967295
- x is treated as exactly 32 bits (8 nibbles), so leading zero nibbles take part in the swap
- Inputs and outputs can exceed 2^31 - 1 = 2147483647: Java uses long and C++ uses long long; all values stay below 2^53
Examples
Input: (0,)
Expected Output: 0
Explanation: Minimum value: all eight nibbles are zero, so swapping changes nothing.
Input: (1,)
Expected Output: 16
Explanation: 0x00000001 becomes 0x00000010: the leading-zero nibble 1 swaps in with nibble 0.
Hints
- Number the eight nibbles 0 to 7 from the least significant end; each even position trades places with the odd position directly above it.
- Leading zero nibbles still count: picture x as always having exactly eight hexadecimal digits.
- The result can be as large as 4294967295, so make sure your return type and intermediate values cannot overflow or turn negative.