MediumMath

Reverse Integer

1 approach, code in all languages

Given a signed 32-bit integer, produce the integer whose decimal digits are written in the opposite order. The sign of the value is preserved, and any trailing zeros of the original number simply vanish once they move to the front.

Because the computing environment can only hold signed 32-bit integers, the reversed value might not fit. If the reversal falls outside the range that a 32-bit signed integer can represent, return 0 instead.

Example 1

Input: x = 456

Output: 654

The digits 4, 5, 6 are emitted in reverse to form 654.

Example 2

Input: x = 1999999999

Output: 0

Reversing yields 9999999991, which exceeds the largest 32-bit signed integer, so the answer is 0.

Constraints

-2^31 <= x <= 2^31 - 1
The reversed value must fit in a signed 32-bit integer, otherwise return 0
Assume the environment cannot store any integer wider than 32 bits

Pop and Push Digits with Overflow Guard

Peel the last digit off the number and append it to a running result, checking before each append whether the next multiply-and-add would overflow the 32-bit range.

Loading animation…

Intuition

Taking a number modulo ten pops its final digit, and integer division by ten removes that digit from the source. Rebuilding the answer as result = result * 10 + digit pushes digits back in reverse order. The only danger is that the running result can grow past the 32-bit limit. Rather than reversing first and checking after (which would already have overflowed), we test the boundary before each step: if result is about to exceed the safe threshold, we bail out early and return 0.

Algorithm walkthrough

1Start with result set to 0; the input keeps its sign because of how truncating division and modulo behave.
2Repeatedly extract digit = x % 10 and shrink x with integer division by 10.
3Before folding the digit in, verify result will not pass the positive or negative 32-bit boundary; if it would, return 0.
4Otherwise update result = result * 10 + digit and continue until x becomes 0.
5Return the accumulated result once every digit has been consumed.

Implementation

class Solution:
    def reverse(self, x: int) -> int:
        INT_MIN, INT_MAX = -2**31, 2**31 - 1
        sign = -1 if x < 0 else 1
        x = abs(x)
        result = 0
        while x != 0:
            digit = x % 10
            x //= 10
            result = result * 10 + digit
        result *= sign
        if result < INT_MIN or result > INT_MAX:
            return 0
        return result

Time

O(log10(x))

Space

O(1)

The loop runs once per decimal digit and uses a fixed number of variables.

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in

Back to Strings

You've got the patterns

Patterns get you through the screen. Shipping gets you hired.

FDE Coach is a cohort-based program in frontend, backend, AWS, and AI where you build real products and get referred to 200+ hiring partners. The free live workshop is the fastest way to see how we teach.

Join the free workshop Explore the program

750+ engineers trained · frontend, backend, AWS & AI