Reverse Integer

Problem in Plain English

Reverse the decimal digits of a signed 32-bit integer x while keeping its sign. If the mirrored digits fall outside the signed 32-bit range, return 0.

Problem Statement

Given a signed 32-bit integer x, return x with its digits reversed. A negative sign stays in front, so -123 becomes -321, and trailing zeros vanish because 120 becomes 21.

If the reversed digits fall outside the signed 32-bit range from $-2^{31}$ to $2^{31}-1$ , return 0. The environment does not allow storing 64-bit integers, so the overflow must be detected before it happens.

Constraints

$-2^{31} \le x \le 2^{31}-1$
A reversal outside the signed 32-bit range returns 0.
No 64-bit storage may be used for the intermediate result.

Examples

Example 1

Input: x = 123
Output: 321

The digits 123 mirrored give 321, which fits in the 32-bit range.

Example 2

Input: x = -123
Output: -321

The sign stays in front while the digits 123 mirror to 321.

Example 3

Input: x = 120
Output: 21

Mirroring gives 021, and the leading zero drops to leave 21.

Example 4

Input: x = 0
Output: 0

Zero has no nonzero digit to move, so its reversed numeric value remains zero.

Example 5

Input: x = 1534236469
Output: 0

Its decimal reversal would be 9646324351, larger than 2147483647. Return zero rather than constructing that value in the solution.

Example 6

Input: x = -1463847412
Output: -2147483641

The reversed negative digits still fit above the lower bound -2147483648, so retain the sign and return -2147483641.

Intuition

Think of the input as a stack of decimal digits: taking the last digit of 123 yields 3, then 2, then 1, and appending them gives 321. A negative input must keep its sign while its digits change places. The difficult part is detecting overflow before an accumulator grows; comparing a textual candidate to the bound or guarding each arithmetic append avoids ever storing an out-of-range result.

Approaches

String Reverse

Solution Details

Reveal String Reverse: intuition, complexity, and code

Intuition

Reverse the digit characters, remove leading zeros, and compare their length and lexicographic order with the signed limit before parsing. Text can represent a rejected candidate without constructing an oversized integer. Keep the sign separate without negating x, which also handles the minimum signed integer.

Step-by-Step Logic

Record whether x is negative and convert x to text. Remove only a leading minus sign; on Example 1, the digit text is 123.
Reverse the digit characters to 321. Strip any leading zeros while retaining one digit for zero; for 120 this gives 21.
Choose the allowed magnitude as text: 2147483647 for positive inputs or 2147483648 for negative inputs. Example 1 uses 2147483647.
Reject a candidate with more digits than the limit, or equal length and lexicographically larger digits. The three-digit 321 is shorter, so it is safe.
Attach the minus sign if needed, parse the already-checked signed text, and return 321 for Example 1.

Why It Works

Removing the sign and reversing the remaining characters moves each decimal digit to its mirror position. Leading zeros do not contribute to numeric value, so stripping them preserves that reversal. For canonical nonnegative decimal strings, fewer digits means smaller magnitude; at equal length, lexicographic order equals numeric order. Comparing to the sign-specific bound therefore accepts exactly the representable signed results. Only an accepted signed string is parsed, so no intermediate integer exceeds the 32-bit range.

Dry Run

String Reverse: variable states at each step
Stage	digits / candidate	negative	limit	Decision
Convert 123	123	false	not chosen	no minus sign to remove
Reverse	321	false	not chosen	mirror all three characters
Strip leading zeros	321	false	not chosen	none present
Choose bound	321	false	2147483647	positive signed maximum
Compare lengths	3 vs 10	false	2147483647	candidate is safe
Parse signed text	321	false	2147483647	return 321

Complexity Analysis

Time Complexity

O(d)

Space Complexity

O(d)

Let d be the decimal digit count, taking d = 1 for zero. Text conversion, reversal, normalization, comparison and parsing each scan at most d characters. Strings/builders and the JavaScript character array allocate O(d) auxiliary storage. Signed 32-bit input has at most ten digits, so both bounds are constant under the fixed contract; d avoids the undefined log(0) and log of negative x.

Code

Solution.java

1class Solution {2    public int reverse(int x) {3        boolean negative = x < 0;4        String digits = Integer.toString(x);5        // Remove the sign as text: negating Integer.MIN_VALUE would overflow.6        if (negative) digits = digits.substring(1);7        String reversed = new StringBuilder(digits).reverse().toString();8        int first = 0;9        while (first < reversed.length() - 1 && reversed.charAt(first) == '0') first++;10        reversed = reversed.substring(first);11        String limit = negative ? "2147483648" : "2147483647";12        // Equal-width decimal strings can be range-checked before numeric parsing.13        if (reversed.length() > limit.length()14                || (reversed.length() == limit.length() && reversed.compareTo(limit) > 0)) {15            return 0;16        }17        return Integer.parseInt(negative ? "-" + reversed : reversed);18    }19}

Hints

Hint 1

Peel digits off the right end with x % 10 and drop them with truncating division by 10.

Hint 2

Grow the answer from the left with res = res * 10 + digit, mirroring the digit order.

Hint 3

Before the multiply-and-add step, compare res against 214748364 so the overflow is caught while every value still fits.

Edge Cases

Input 0 returns 0; trailing zeros vanish naturally, so 120 becomes 21 and -120 becomes -21.
1534236469 and -1534236469 reverse outside the range and return 0.
-2147483648 cannot be safely negated in signed 32-bit arithmetic. Keep signed digits or remove its minus sign as text; its reversal is rejected.
1463847412 and -1463847412 return 2147483641 and -2147483641, close to the positive and negative limits.
A negative one-digit input such as -7 reverses to itself; -10 returns -1.

Common Mistakes and Interview Tips

Checking overflow after res * 10 + digit, when the damage is already done.
Using x % 10 on negatives in Python, where the remainder stays non-negative and breaks the digit stream.
Special-casing trailing zeros instead of letting the peel-and-push math drop them into 21.
Using the same final digit limit for both signs ignores the asymmetric range: the positive bound ends in 7, the negative magnitude ends in 8.
Parsing a mirrored string before checking its range violates the intermediate-storage constraint even if a later check returns zero.
Interview tip: explain the quotient-and-final-digit guard first, then show how negative division differs between Python and Java/JavaScript.

Key Takeaway

Peel-and-push with % 10 and truncating division rebuilds any integer digit by digit, and bounds must be tested before the accumulator grows.