7. Reverse Integer

This problem is popular in MAANG (Meta, Microsoft, Amazon, Google, etc.) coding interviews because it tests more than basic digit manipulation. It checks whether you can work with numbers directly, extract digits using math operations, and handle edge cases and overflow safely while building the answer.

Problem statement

You are given a signed 32-bit integer, x. Your task is to return x with its digits reversed.

• If reversing x causes the resultant value to go beyond the signed 32-bit integer range, [-2³¹, 2³¹ – 1], return 0.
• Assume the environment does not support storing 64-bit integers, so you must handle overflow carefully.

Constraints:

• -2³¹ <= x <= 2³¹ – 1

Examples

Key observations

We need to reverse the digits of an integer (for example, 7462 → 2647). However, there are two extra rules we must follow: If the number is negative, the reversed result should remain negative. If the reversed number goes outside the 32-bit signed integer range, we must return 0.

One shortcut is to convert the number to a string and reverse it, but that avoids the real integer logic and does not help with practicing overflow-safe arithmetic. Instead, we reverse the number the same way you would do it by hand:

• We repeatedly take the last digit of the number.
• We append that digit to the end of a new number that we are building as the reversed result.

Optimized approach: Reverse digits safely without strings

We use a digit-by-digit approach because it mirrors how reversal works in basic arithmetic and lets us control overflow without relying on string tricks.

Handling the sign:
We first determine whether the input is negative or positive. We store that sign and then work with the absolute value, so digit operations stay straightforward.

Building the reversed number:
We start the reversed result at zero and process the number one digit at a time. In each step, we take the last digit from the remaining number, remove it from the remaining number, and then add it to the end of the result. The last digit is taken using modulo 10, and the remaining number is shortened using integer division by 10. To attach the digit, we shift the current result one place left (multiply by 10) and then add the digit. This is why reversing 7462 builds up as 2, then 26, then 264, and finally 2647.

Preventing overflow:
After adding each digit, we check whether the number we are building has gone beyond the 32-bit signed integer limit. If it has, we return 0 right away.

Returning the result:
Once the remaining number becomes zero, all digits have been processed. We then apply the saved sign to the reversed result and return it. This keeps negative numbers negative and naturally drops any trailing zeros from the original number after reversal.

Step-by-step algorithm

1. Set limit = 2**31 - 1 to represent the maximum allowed 32-bit signed integer value. Next, initialize the reversed number as result = 0.
2. Find the sign of x:
   1. If x is negative, set sign = -1.
   2. Otherwise, set sign = 1.
3. Convert x to a positive number for easier digit handling by setting num = abs(x).
4. While num still has digits, i.e., it is not zero:
   1. Use num, digit = divmod(num, 10) to get the last digit in digit, and shorten num.
   2. Update result = result * 10 + digit to add that digit to the end of the reversed number.
   3. If result > limit, return 0 because it is too large for 32-bit range.
5. When num changes to 0, return the signed result using sign * result.

This solution is perfectly fine in Python because Python integers don’t overflow. But in fixed-width integer languages, building the reversed number by doing “result × 10 + digit” can overflow during the operation before you get a chance to compare against the 32-bit limit. So in those languages, you must check whether the next step would exceed the 32-bit signed range before multiplying and adding, and immediately return 0 if it would.

The slides below help to visualize the solution steps in a better way.

1 / 7

Python code for the optimized solution

Here is the Python implementation of the optimized solution we discussed above.

def reverse(x):
    # 32-bit signed integer upper bound
    limit = 2**31 - 1
    
    # This will store the reversed number
    result = 0

    # Keep the sign, and work with a positive number
    sign = -1 if x < 0 else 1
    num = abs(x)

    # Build the reversed number digit by digit
    while num:
        # Split off the last digit
        num, digit = divmod(num, 10)

        # Append digit to the reversed result
        result = result * 10 + digit

        # If we exceed 32-bit signed range, return 0
        if result > limit:
            return 0

    # Re-apply sign and return
    return sign * result


# Driver code
def main():
    test_cases = [
        7462,            # expected 2647
        -5809,           # expected -9085
        30040,           # expected 4003
        0,               # expected 0
        1534236469,      # expected 0 (overflow when reversed)
    ]

    for idx, x in enumerate(test_cases, 1):
        answer = reverse(x)
        print(f"{idx}.\tx = {x}")
        print(f"\tReversed x: {answer}")
        print("-" * 75)


if __name__ == "__main__":
    main()

Time complexity

The time complexity of this solution is O(log10​(∣x∣)) because each loop iteration removes one digit by doing num //= 10, and the number of times you can divide by 10 before reaching 0 is the number of digits, which is about log10​(∣x∣)+1.

Space complexity

The space complexity of this solution is constant, O(1), as it uses only a few fixed variables.

Common mistakes to avoid

Here are the common mistakes to keep in mind for the Reverse Integer problem:

• Integer overflow: The most common mistake is failing to check if the number exceeds the 32-bit signed integer range ([-2³¹, 2³¹ – 1]). Always check for potential overflow before multiplying the current result by 10.
• The “Last Digit” trick: Use the mathematical approach (pop = x % 10; rev = rev * 10 + pop) instead of converting the integer to a string. String conversion is slower and often seen as a “cheat” in technical interviews.
• Handling trailing zeros: Numbers like 120 should reverse to 21. If you use the mathematical approach, the leading zero is handled automatically, but if you use strings, you must manually strip them.