MediumMath

Reverse Integer

1 approach, code in every language

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 see the solution

You get 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

After the pattern

Now solve one you haven't seen.

Legacy Register Flip is our own problem on the technique behind Reverse Integer: a new statement, so there's no answer to remember. Write it in your browser and run it against graded tests.

Practise it with tests All practice problems

1,194 problems · 15,062 graded tests · free