Reverse Integer

Reverse Integer

Reverse a 32-bit signed integer's digits — detect overflow before multiplying by 10.

Medium

Time O(log n) Space O(1)

LeetCode

May 16, 2026 3 min read

Problem#

Reverse the digits of a 32-bit signed integer. If the result overflows [-2^31, 2^31 - 1], return 0.

Examples#

123 → 321; -123 → -321.
120 → 21; 1534236469 → 0 (overflow).

Constraints#

-2^31 <= x <= 2^31 - 1.

Approach#

Repeatedly peel off x % 10 and append to rev. Before each rev = rev * 10 + d, check whether rev would exceed bounds.

Solution#

class Solution {
public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int d = x % 10;
            x /= 10;
            if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && d > 7)) return 0;
            if (rev < INT_MIN / 10 || (rev == INT_MIN / 10 && d < -8)) return 0;
            rev = rev * 10 + d;
        }
        return rev;
    }
};

import "math"

func reverse(x int) int {
    rev := 0
    for x != 0 {
        d := x % 10
        x /= 10
        if rev > math.MaxInt32/10 || (rev == math.MaxInt32/10 && d > 7) {
            return 0
        }
        if rev < math.MinInt32/10 || (rev == math.MinInt32/10 && d < -8) {
            return 0
        }
        rev = rev*10 + d
    }
    return rev
}

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

function reverse(x) {
    const INT_MAX = 2 ** 31 - 1;
    const INT_MIN = -(2 ** 31);
    const sign = x < 0 ? -1 : 1;
    x = Math.abs(x);
    let rev = 0;
    while (x !== 0) {
        const d = x % 10;
        x = Math.trunc(x / 10);
        rev = rev * 10 + d;
    }
    rev *= sign;
    if (rev < INT_MIN || rev > INT_MAX) return 0;
    return rev;
}

class Solution {
    public int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int d = x % 10;
            x /= 10;
            if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && d > 7)) return 0;
            if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && d < -8)) return 0;
            rev = rev * 10 + d;
        }
        return rev;
    }
}

function reverse(x: number): number {
    const INT_MAX = 2 ** 31 - 1;
    const INT_MIN = -(2 ** 31);
    const sign = x < 0 ? -1 : 1;
    x = Math.abs(x);
    let rev = 0;
    while (x !== 0) {
        const d = x % 10;
        x = Math.trunc(x / 10);
        rev = rev * 10 + d;
    }
    rev *= sign;
    if (rev < INT_MIN || rev > INT_MAX) return 0;
    return rev;
}

Editorial#

C++‘s % rounds toward zero, so negative inputs naturally produce negative digits, sparing us a sign branch. The overflow check must happen before the multiply: INT_MAX = 2147483647 so the last digit can be at most 7 if rev == INT_MAX / 10.

Complexity#

Time: O(log10 |x|).
Space: O(1).

Problem#

Examples#

Constraints#

Approach#

Solution#

Editorial#

Complexity#

Concept revision#

Keyboard shortcuts

Problem#

Examples#

Constraints#

Approach#

Solution#

Editorial#

Complexity#

Concept revision#

Related#