反转int限制内的整数值

Question

我想反转一个整数。我尝试了下面的代码，当数字太大，以至于它的反向值大于int极限时(例如1534236469(，就会出现问题，所以在这种情况下，它会返回一些垃圾整数。

如何使用Integer.MIN_VALUE和Integer.MAX_VALUE检查反转的数字是否在限制范围内？

注意：必须仅使用int变量类型。

int num = 1534236469;
int reverseInt = 0;
int multiplier = 1;
if ( num < 0 ) {
multiplier *= -1;
}
while ( num != 0 ) {
//get the last digit
int digit = num % 10;
//multiply the reverseInt by 10 and then add the last digit
reverseInt = (reverseInt * multiplier) + digit;
multiplier = 10;
num /= 10;
}
//how to fix this.
if (reverseInt < Integer.MIN_VALUE || reverseInt > Integer.MAX_VALUE ) {
System.out.println("Invalid number");
} else {
System.out.println("Reversed integer is " + reverseInt);
}

Answer 1

您只需要在添加下一个数字之前进行检查，这样您就可以简单地将检查移动到实际计算中。如果您当前的反向正数大于Integer.MAX_VALUE/10，则无法添加其他数字。负数也是如此。

我做的唯一一件事就是把你代码的这一部分上移：

if (reverseInt < Integer.MIN_VALUE || reverseInt > Integer.MAX_VALUE ) {
System.out.println("Invalid number");
} else {

然后我添加了/10和return语句，因为程序必须在出现溢出时结束：

public class StackOverflowTest {
public static void main(String[] args) {
int num = -1534236469;
int reverseInt = 0;
int multiplier = 1;
if ( num < 0 ) {
multiplier *= -1;
}
while ( num != 0 ) {
// if this next step will push is into overflow, then stop:
if (reverseInt < Integer.MIN_VALUE/10 || reverseInt > Integer.MAX_VALUE/10) {
System.out.println("Invalid number");
return;
} else {
//get the last digit
int digit = num % 10;
// multiply the reverseInt by 10 and then add the last digit
reverseInt = (reverseInt * multiplier) + digit;
}
multiplier = 10;
num /= 10;
}
System.out.println("Reversed integer is " + reverseInt);
}
}

---

或者，您可以将其视为字符串，然后简单地反转字符串(同时摆弄符号(：

public class StackOverflowTest {
public static void main(String[] args) {
reverse(1534236469);
System.out.println();
reverse(-153423646);
}
public static void reverse(int num) { 
System.out.println("int = " + num);
int number = num < 0 ? -num : num;           // remove the sign
String reverse = new StringBuilder(String.valueOf(number)).reverse().toString();
System.out.println("reverse String: " + reverse);
try {
int reversed = Integer.parseInt(reverse);
reversed = num < 0 ? -reversed : reversed;  // get back the sign
System.out.println("Reversed integer is " + reversed);
} catch (NumberFormatException ex) {
System.out.println("Invalid number");
}
}
}

打印：

int = 1534236469
reverse String: 9646324351
Invalid number
int = -153423646
reverse String: 646324351
Reversed integer is -646324351

Answer 2

在Java 8+中，更改为：

reverseInt = Math.addExact(Math.multiplyExact(reverseInt, multiplier), digit);

如果结果溢出，代码现在将抛出ArithmeticException。

Answer 3

每当超过Integer.MAX_VALUE的值时，它都从Integer.MIN_VALUE开始，即Integer.MAX_VALUE + 1计算为Integer.MIN_VALUE。您可以使用此功能来获得您正在寻找的解决方案。

在从1到10的循环中简单地乘以reverseInt，如果该值变为负值，则意味着下一个值(reverseInt * multiplier(将超过Integer.MAX_VALUE。此外，您需要将循环中的reverseInt * multiplier添加到从0到9的值中，如果该值变为负值，则意味着下一个值(reverseInt * multiplier + digit(将超过Integer.MAX_VALUE。

public class Main {
public static void main(String[] args) throws InterruptedException {
int num = 1534236469;
boolean valid = true;
int reverseInt = 0;
int multiplier = 1;
if (num < 0) {
multiplier *= -1;
}
while (num != 0) {
// get the last digit
int digit = num % 10;
for (int i = 1; i <= multiplier; i++) {
for (int j = 0; j <= 9; j++) {
if (reverseInt * i < 0 || (reverseInt * i + j) < 0) {
System.out.println("Invalid number");
valid = false;
break;
}
}
if (!valid) {
break;
}
}
if (!valid) {
break;
}
// multiply the reverseInt by 10 and then add the last digit
reverseInt = reverseInt * multiplier + digit;
multiplier = 10;
num /= 10;
}
if (valid) {
System.out.println("Reversed integer is " + reverseInt);
}
}
}

输出：

Invalid number