Problem

You work for a financial services company that handles transactions involving 32-bit signed integer amounts. Your goal is to enhance security by implementing an additional check: reverse the digits of a given transaction amount to create a new reference code. If reversing the digits results in a value outside the valid range of transaction amounts, which lies between -2,147,483,648 and 2,147,483,647, then return a code indicating the operation is invalid. Otherwise, return the reversed amount as the reference code. Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Example 1:

Input: x = 123
Output: 321

Example 2:

Input: x = -123
Output: -321

Example 3:

Input: x = 120
Output: 21

Example 4:

Input: x = 0
Output: 0

Example 5:

Input: x = 1534236469
Output: 0 Exceeds the 32-bit signed integer range, so it’s invalid

Example 6:

Input: x = -2147483648
Output: 0 Exceeds the 32-bit signed integer range, so it’s invalid

Constraints:

-231 <= x <= 231 - 1

Java Solution

class Solution {
  public int reverse(int x) {
    long ans = 0;

    while (x != 0) {
      ans = ans * 10 + x % 10;
      x /= 10;
    }

    return (ans < Integer.MIN_VALUE || ans > Integer.MAX_VALUE) ? 0 : (int) ans;
  }
}

The algorithm initializes `res` as 0. Then, we determine the sign of the input integer and take its absolute value. We use a while loop to iterate through each digit of `x` from right to left. In each iteration, we multiply the current `res` by 10 and add the last digit of `x` to it. The last digit of `x` is obtained by `x % 10`. After adding the last digit, we remove it from `x` by doing either `x /= 10` or `x //= 10`.

After processing all the digits, we adjust res with the sign we computed earlier. Finally, we check if the reversed integer is within the 32-bit integer range. If it is, we return the result; otherwise, we return 0.

C++ Solution

class Solution {
 public:
  int reverse(int x) {
    long ans = 0;

    while (x != 0) {
      ans = ans * 10 + x % 10;
      x /= 10;
    }

    return (ans < INT_MIN || ans > INT_MAX) ? 0 : ans;
  }
};

The algorithm initializes `res` as 0. Then, we determine the sign of the input integer and take its absolute value. We use a while loop to iterate through each digit of `x` from right to left. In each iteration, we multiply the current `res` by 10 and add the last digit of `x` to it. The last digit of `x` is obtained by `x % 10`. After adding the last digit, we remove it from `x` by doing either `x /= 10` or `x //= 10`.

Python Solution

class Solution:
  def reverse(self, x: int) -> int:
    ans = 0
    sign = -1 if x < 0 else 1
    x *= sign

    while x:
      ans = ans * 10 + x % 10
      x //= 10

    return 0 if ans < -2**31 or ans > 2**31 - 1 else sign * ans

The algorithm initializes `res` as 0. Then, we determine the sign of the input integer and take its absolute value. We use a while loop to iterate through each digit of `x` from right to left. In each iteration, we multiply the current `res` by 10 and add the last digit of `x` to it. The last digit of `x` is obtained by `x % 10`. After adding the last digit, we remove it from `x` by doing either `x /= 10` or `x //= 10`.

JavaScript Solution

function reverse(x) {
    let sign = x < 0 ? -1 : 1;
    x = Math.abs(x);
    let res = 0;
    while (x !== 0) {
        res = res * 10 + x % 10;
        x = Math.floor(x / 10);
    }
    res *= sign;
    return (res < -(2 ** 31) || res > 2 ** 31 - 1) ? 0 : res;
}

The algorithm initializes `res` as 0. Then, we determine the sign of the input integer and take its absolute value. We use a while loop to iterate through each digit of `x` from right to left. In each iteration, we multiply the current `res` by 10 and add the last digit of `x` to it. The last digit of `x` is obtained by `x % 10`. After adding the last digit, we remove it from `x` by doing either `x /= 10` or `x //= 10`.

We often encounter problems related to numerical data manipulation and constraints. For example, consider a scenario in a banking system where customers can only have an account balance within a certain range. In this case, reversing the digits of an account number or any other identifier becomes relevant.

Let’s say our banking system has the following rules:

The maximum allowed account balance is $999,999 (six-digit number).
The minimum allowed account balance is -$999,999 (negative six-digit number).

A user enters a 32-bit signed integer value representing their account number. In this context, reversing the digits of the account number could be necessary for some internal processing or verification purposes within our system.

When we reverse the digits of the account number and it exceeds the valid range (-999999 to 999999), our system should handle it by returning a specific error code (e.g., -1) to indicate an invalid operation. This is similar to the requirement mentioned in the original problem statement, where reversing the integer results in a value that falls outside the [-2^31, 2^31 - 1] range.

In both cases, we are dealing with constraints related to numerical data and its manipulation (i.e., reversing digits), along with error handling when the result exceeds the allowed range. The real-world example above illustrates how such constraints can apply in practical scenarios, beyond just an abstract programming problem.

The problem is an algorithmic task that involves reversing the digits of a signed 32-bit integer while ensuring the reversed integer falls within the valid range for a 32-bit signed integer. This real-world example can be related to the financial domain, specifically in processing and manipulating numerical data.

Let’s consider a scenario where a company needs to process transaction amounts represented as signed integers. These transaction amounts are stored in a database with a limit of 32-bits for storage efficiency. The task is to develop an algorithm that reverses the digits of these transaction amounts while ensuring that the reversed value remains within the valid range.

In this context, the original problem statement translates to:

Given a financial transaction amount x represented as a signed 32-bit integer, return the amount with its digits reversed. If reversing the amount causes it to fall outside the valid range for a 32-bit signed integer ([-2,147,483,647, 2,147,483,646]), then return 0.

For instance:

Input: Transaction amount = 123 (representing $123)
Output: Reversed amount = 321 (representing $321)
Input: Transaction amount = -456 (representing -$456)
Output: Reversed amount = -654 (representing -$654)
Input: Transaction amount = 120
Output: Reversed amount = 21 (truncated to the valid range, representing $21)

In this financial context, reversing the digits of transaction amounts can be useful in various scenarios such as generating reversed invoice numbers or processing refunds. The algorithm must handle negative values and ensure that the reversed amount remains within the valid range to avoid any data loss or errors during storage or further calculations.

The constraints mentioned in the original problem statement are also applicable:

The maximum value for a 32-bit signed integer is 2,147,483,647 (231 - 1)
The minimum value for a 32-bit signed integer is -2,147,483,648 (-231)

Problem#

Java Solution#

C++ Solution#

Python Solution#

JavaScript Solution#

Problem

Java Solution

C++ Solution

Python Solution

JavaScript Solution