Question

问题陈述：给定一个32位带符号整数，该整数为反向数字。

示例1：

输入：123 输出：321 示例2：

输入：-123 输出：-321

我的解决方案：

class Solution7{
public int reverse(int x) {
    if(x>Integer.MAX_VALUE || x<Integer.MIN_VALUE) {
        return 0;
    }


    StringBuilder S_rev = new StringBuilder();
    String S_r_v=S_rev.append(Math.abs(x)).reverse().toString();//.toString() String builder to String

   double reverse_no=Double.parseDouble(S_r_v);

    if (x < 0) {
        return -(int)reverse_no;
    }
    return (int)reverse_no;

}

}

对于大多数测试用例，我的解决方案都可以。但是它无法通过一个测试用例，并且出现错误

Error：第10行：java.lang.NumberFormatException：对于输入字符串：“ 8463847412-”

如果有人知道错误的类型，请进行讨论。

谢谢。

Answer 1

通过将数字转换为String并反转符号将结束于值的末尾。这会使该号码无效。

您不必转换为String或double。您可以使用模块运算符%提取数字：

public int reverse(int x) {
  long result = 0;
  while (x != 0) {
    result *= 10;
    result += x % 10;
    x /= 10;
  }
  if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
    throw new IllegalArgumentException(); // overflow
  }
  return result;
}

Answer 2

似乎您正在尝试传递Integer.MIN_VALUE

传入最小整数值时，Math.abs似乎返回负数，如此处所述

https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#abs-int-

 Note that if the argument is equal to the value of Integer.MIN_VALUE, the most negative representable int value, the result is that same value, which is negative.

如果x是Integer.MIN_VALUE，则可以检查x<=Integer.MIN_VALUE并返回0，也可以处理Integer.MIN_VALUE的特殊情况

 if(x== Integer.MIN_VALUE)
      return -8463847412;

Answer 3

如果您一定要使用StringBuilder来实现它，则为：

  public static void main(String[] args) {
    ReverseNum reverseNum = new ReverseNum();
    System.out.println(reverseNum.reverse(-123));
    System.out.println(reverseNum.reverse(123));
    System.out.println(reverseNum.reverse(0));
  }

  public int reverse(int x) {
    int res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Integer.valueOf(builder.reverse().toString());
  }

输出：

-321
321
0

P.S。如果要避免整数溢出，则可以使用long代替int，如下所示：

  public long reverse(int x) {
    long res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Long.valueOf(builder.reverse().toString());
  }

Answer 4

public class ReverseString {
  public static void main(String args[]) {
    ReverseString rs = new ReverseString();
    System.out.println(rs.reverse(-84638));
    System.out.println(rs.reverse(5464867));
  }

  public long reverse(int number) {

    boolean isNegative = number < 0;

    StringBuilder reverseBuilder = new StringBuilder();
    String reversedString = reverseBuilder.append(Math.abs(number)).reverse().toString();
    long reversedStringValue = Long.parseLong(reversedString);

    if(isNegative) {
      return reversedStringValue * -1;
    } else {
      return reversedStringValue;
    }
  }
}

此代码提供您在需求中提到的输出。并且它还支持整数溢出。您的要求是转换int值。可以采用更高格式的转换值，因为转换后的值可能不在int范围内。我将反向方法的返回类型更改为long。

我在您的代码中发现了一些问题。

public int reverse(int x) {
if(x>Integer.MAX_VALUE || x<Integer.MIN_VALUE) {
    return 0;
}

在代码段的上方，不是要检查该值是否在int范围内，因为它已作为字符串接收在参数中。在执行代码行之前，它应该引发错误，因为它无法将较大的值拟合到int变量。

最后，您使用的int数不在int范围内。（-8463847412）

Answer 5

那呢？

public class ReverseNumber {
    public static void main(String[] args) {
        System.out.println(reverse(123456));
        System.out.println(reverse(0));
        System.out.println(reverse(-987654));
    }

    private static int reverse(int i) {
        final int signum;
        if(i < 0) {
            signum = -1;
        } else {
            signum = +1;
        }

        int reversedNumber = 0;
        int current = Math.abs(i);

        while(0 < current) {
            final int cipher = current % 10;

            reversedNumber = Math.addExact(Math.multiplyExact(reversedNumber, 10), cipher);
            current = current / 10;
        }

        return signum * reversedNumber;
    }
}

输出：

654321
0
-456789

此解决方案避免使用字符串，并且可以处理负数。如果发生整数溢出，则会引发算术异常。

使用Java中的字符串构建器反转数字

5 个答案: