1. The two operations that read digits

Every whole number $x \ge 0$ splits into its last digit and the rest:

$x = 10 \cdot q + d \qquad d = x \bmod 10 \qquad q = \lfloor x / 10 \rfloor$

Here $x \bmod 10$ is the remainder after dividing by 10, which is the last digit. $\lfloor x / 10 \rfloor$ is the quotient rounded down, which is $x$ with its last digit removed. In Python they are x % 10 and x // 10. For $x = 123$, the last digit is $d = 3$ and the rest is $q = 12$.

The reverse step is the opposite: appending a digit $d$ to the right of a number $r$ gives $10 \cdot r + d$. So the code reads digits from the right end of x and appends them to the right end of res. This builds the digits in reverse order.

2. One round of the loop

Each round moves one digit from x to res:

The loop runs while x > 0, so it runs once per digit of x.

3. The 32-bit bound, checked before it is crossed

The result must fit in a signed 32-bit integer, which holds values from $-2^{31} = -2147483648$ to $2^{31} - 1 = 2147483647$. The problem also says to act as if no larger integer type exists. So the code may never compute a value above INT_MAX and check it afterwards. It must decide before the multiplication whether res * 10 + digit would be too large.

Write $\text{INT\_MAX} = 2147483647 = 10 \cdot 214748364 + 7$. Then $10 \cdot r + d > \text{INT\_MAX}$ in exactly two cases:

If $r < 214748364$, then $10 \cdot r + d \le 2147483630 + 9$, which fits. If $r = 214748364$ and $d \le 7$, the new value is at most $2147483647$, which also fits. So the test is exact. INT_MAX // 10 is $214748364$, and the 7 is INT_MAX % 10.

4. Why the code takes the absolute value first

Python's % and // round toward minus infinity. So for a negative number, -123 % 10 is 7, not -3, and -123 // 10 is -13, not -12. The digit rule of part 1 would read wrong digits. The code avoids this: it saves sign, reverses abs(x), and multiplies by sign at the end.

The check in part 3 compares against INT_MAX only, even for negative inputs. This is safe for every 32-bit input. res can reach $214748364$ only after 9 digits. The 10th and last digit is then the first digit of x. A 32-bit value has at most 10 digits, and a 10-digit one starts with 1 or 2. So that last digit is never greater than 7. The last line, return res if INT_MIN <= res <= INT_MAX else 0, is a second check of the same bound.

An example where the bound decides: x = 1463847412 reverses to $2147483641$. Before the last round, res is $214748364$ and the digit is 1. Since $1 \le 7$, the value fits and the code returns $2147483641$. For x = 1534236469, the reversal would be $9646324351$. Before the last round res is $964632435$, which is greater than $214748364$. So the code returns 0 without ever computing the large value.

5. Example 1 by hand

x = 123, so sign = 1.

x is now 0, so the loop stops. The code returns $321 \cdot 1 = 321$, the expected output.

6. Example 2 by hand

x = -123. The code sets sign = -1 and x = 123. The three rounds are the same as in Example 1, so res ends as 321. The code returns $321 \cdot (-1) = -321$, the expected output.

7. From the math to the code

The loop runs once per digit, and a 32-bit value has at most 10 digits. So the code takes $O(\log |x|)$ time, which is at most 10 rounds, and $O(1)$ space.