java反向整数leetcode如何处理溢出

Question

问题是： 整数的倒数

示例1:x=123，返回321

示例2:x=-123，返回-321

您是否注意到反向整数可能会溢出？假设输入是32位整数，则100000003溢出的相反值。你应该如何处理这些案件

抛出异常？很好，但是如果抛出异常不是一个选项呢？然后必须重新设计函数（即，添加一个额外的参数）

我搜索的网站的解决方案是：

public class Solution {

     public static int reverse(int x) {
            int ret = 0;
            boolean zero = false;
            while (!zero) {
                ret = ret * 10 + (x % 10);
                x /= 10;      
                if(x == 0){
                    zero = true;
                }
            }
            return ret;   
        }

    public static void main(String[] args) {
        int s = 1000000003;
        System.out.println(reverse(s));
    }

}

但是，当s = 1000000003时，控制台将打印-1294967295，而不是3000000001。因此，如果我们不能使用异常，这个解决方案仍然不能解决溢出问题。有人帮忙吗？（虽然有一个提示：添加一个额外的参数，但我仍然不知道应该添加什么参数）

Answer 1

除了int之外，不需要任何数据类型。 只要确保当有一个操作增加一个数字时，反转该操作应该会给出上一个数字。否则，就会出现溢出

public int reverse(int x) {
    int y = 0;

    while(x != 0) {
        int yy = y*10 + x%10;

        if ((yy - x%10)/10 != y) return 0;
        else y = yy;

        x = x/10;   
    }
    return y;
}

Answer 2

您可以使用java中的字符串尝试此代码

class Solution {
    public int reverse(int x) {
        int n = Math.abs(x);
        String num = Integer.toString(n);
        StringBuilder sb = new StringBuilder(num);
        sb.reverse();
        String sb1;
    
        sb1 = sb.toString();
        
        int foo;
        try {
            foo = Integer.parseInt(sb1);
        }
        catch (NumberFormatException e){
            foo = 0;
        }
        if(x < 0){
            foo *= -1;
        }
        
        return foo;
    }
}

Answer 3

以上大多数答案都有一个小问题，那就是int变量可能会溢出。您可以尝试这样做：x=-2147483648作为参数。 有一个简单的方法来解决这个问题。将x转换为long，并检查结果是否>；=整数最大值，否则返回0。 该解决方案通过了https://leetcode.com/problems/reverse-integer/上的所有测试用例

这是一个java版本

public int reverse(int x) {
        long k = x;
        boolean isNegtive = false;        
        if(k < 0){
            k = 0 - k;
            isNegtive = true;
        }

        long result = 0;
        while(k != 0){
            result *= 10;
            result += k % 10;
            k /= 10;
        }

        if(result > Integer.MAX_VALUE) return 0;
        return isNegtive  ? 0 - ((int)result) : (int)result;
    }

C版本

    public int Reverse(int x)
    {
        long value = 0;
        bool negative = x < 0;
        long y = x;
        y = Math.Abs(y);

        while (y > 0)
        {
            value *= 10;
            value += y % 10;
            y /= 10;
        }

        if(value > int.MaxValue)
        {
            return int.MaxValue;
        }

        int ret = (int)value;

        if (negative)
        {
            return 0 - ret;
        }
        else
        {
            return ret;
        }
    }

Python版本

def reverse(self, x):                
    isNegative = x < 0
    ret = 0
    x = abs(x)
    while x > 0:
        ret *= 10
        ret += x % 10
        x /= 10
    if ret > 1<<31:
        return 0

    if isNegative:
        return 0 - ret
    else:
        return ret

Answer 4

此java代码处理溢出情况：

public int reverse(int x) {

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

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

Answer 5

我解决这个问题的方法是将输入的整数转换成c字符串，这样一切都会很简单

class Solution {
public:
  int reverse(int x) {
    char str[11];
    bool isNegative = false;
    int i;
    int ret = 0;

    if ( x < 0 ) {
        isNegative = true;
        x = -x;
    }

    i = 0;
    while ( x != 0 ) {
        str[i++] = x % 10 + '0';
        x = x / 10;
    }
    str[i] = '\0';

    if ( (isNegative && strlen(str) == 10 && strcmp(str, "2147483648") > 0) || (!isNegative && strlen(str) == 10 && strcmp(str, "2147483647") > 0) ) {
        cout << "Out of range!" << endl;
        throw new exception();
    }

    i = 0;
    int strLen = (int)strlen(str);
    while ( str[i] != '\0' ) {
        ret += ((str[i] - '0') * pow(10.0, strLen - 1 - i));
        i++;
    }

    return (isNegative ? -ret : ret);
}

}

Answer 6

这是一个老问题，但无论如何让我也试一下！我刚刚在leetcode上解决了这个问题。通过这个检查，您在两个方向上都不会遇到溢出/下溢，我认为代码比列出的所有代码都要简洁。它通过了所有测试用例

public int reverse(int x) {
    int y = 0;
    while(x != 0) {
        if(y > Integer.MAX_VALUE/10 || y < Integer.MIN_VALUE/10) return 0;
        y *= 10;
        y += x % 10;
        x /= 10;
    }
    return y;
}