Reverse Integer

Problem Statement

In this task, a signed 32-bit integer x is provided, and the objective is to return the number with its digits reversed. This task, however, comes with specific challenges that hinge upon data format and overflow issues. Reversing the digits of x may sometimes result in a number that exceeds the boundaries of a 32-bit signed integer range, which is [-2^31, 2^31 - 1]. If the reversed integer exceeds this range, the function should return 0 instead of the out-of-range integer. Moreover, this problem must be solved under the constraint that the environment only supports 32-bit integers, effectively prohibiting the use of 64-bit integers to easily tackle overflow scenarios.

Examples

Example 1

Input:

x = 123

Output:

321

Example 2

Input:

x = -123

Output:

-321

Example 3

Input:

x = 120

Output:

21

Constraints

• -231 <= x <= 231 - 1

Approach and Intuition

Reversing the digits of a number seems straightforward but requires careful handling of the integer overflow and the presence of negative numbers. Here's a strategy to achieve the reversal without inadvertently causing overflow:

1. Handle the input number as per its sign (positive or negative).
   • If the number is negative, process it as a positive number temporarily and reintroduce the sign at the end.
2. Extract each digit from the number and construct the reversed number:
   • Initialize a result variable to 0.
   • Utilize a loop to pop the last digit of the current number and push it to the next position in result:
     • Multiply result by 10 (shifting digits left).
     • Add the extracted last digit of the number.
3. Check for overflow during each iteration:
   • Before appending a digit, check if result is about to exceed or meet the overflow criterion. This can be done by comparing result against a pre-determined safe limit (2^31 / 10 for positive numbers and (-2^31 - digit) / 10 for negative numbers after adjusting for the current digit).
   • If an overflow is detected, return 0 immediately.
4. Return the correctly signed reversed number:
   • If the original number was negative, multiply the result by -1.

By using the above method, we ensure that the solution adheres to the 32-bit environment constraints and correctly handles all the given examples and potential edge cases like overcoming the challenge posed when x is 0 or when reversing results in a number like 120 becoming 21, dismissing the insignificant zero.

Solutions

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