Question

我正在尝试解决leetcode.com中涉及signed 32bit integers的锻炼问题。

任务是：

返回带符号的32位整数的倒数，如果溢出32位有符号整数的范围则返回0。

32位寄存器可以存储32个不同的值。整数范围可以以32位存储的值取决于整数使用的表示。有两个最常见的表示，范围是0到4,294,967,295（2 ^ 32 - 1）表示为（无符号）二进制数，和-2,147,483,648（-2 ^ 31）到 2,147,483,647（2 ^ 31 - 1）表示为两个补码。

所以，如果我理解的是正确的，我应该在0 to (2^31)-1和(-2^31) to 0之间进行测试，否则返回0。

这是我的代码：

def reverse_int(nums):
    a = str(nums)

    if 0 < nums <= (1 << 31)-1:
        return int(a[::-1])

    elif (-1 << 31) <= nums < 0:
        return -(int(a[:-len(a):-1]))
    else:
        return 0

这是我的问题：当我在网站上测试我的代码：

nums = 1534236469 # Fail
nums = 1463847412 # Success
nums = 9000000    # Success

为什么我的当前代码会因1534236469而失败？ 1534236469范围内32 bit signed integers不是{{1}}？我错过了什么？

Answer 1

如评论中所述，您必须首先撤消，然后检查。然而，这是一种不同的检查方式。

要检查您是否可以使用适当的面具&结果。

因此，在您的情况下，限制为−2,147,483,648和2,147,483,647它们的十六进制值为-0x80000000和0x7fffffff

在解释器中试试这个。

>>> 0x7fffffff
2147483647
>>> 2147483647 & 0x7fffffff   #within limit
2147483647

超出限制的值，您可以看到显示其他一些值。

>>> 2147483648 & 0x7fffffff     #Exceeds limit
0
>>> 98989898989898 & 0x7fffffff  #Exceeds limit
1640235338

但是当价值在限度内时。该值作为输出给出。

>>> 1 & 0x7fffffff               #within limit
1
>>> 780 & 0x7fffffff
780

负值

 >>> -0x80000000     #Limit
-2147483648
>>> -2147483648 & -0x80000000
-2147483648

当值在范围内时。限制作为输出。

>>> -2147483647 & -0x80000000
-2147483648
>>> -2 & -0x80000000          #within limit
-2147483648
>>> -2323 & -0x80000000
-2147483648

但是，如果值超出范围，您可以看到显示其他值。

>>> -2147483649 & -0x80000000
-4294967296
>>> -999999999999 & -0x80000000
-1000727379968

你可以很好地利用这一点，以获得你想要的东西！

这是一个完成你想要的程序。

def reverse(x):
    str_x = str(x)
    if x<0:
        str_x = '-'+str_x[::-1][:-1]
        x = int(str_x)
    else:
        str_x = str_x[::-1]
        x = int(str_x)
    neg_limit= -0x80000000
    pos_limit= 0x7fffffff

    if(x<0):
        val=x&neg_limit
        if(val==neg_limit):
            return x
        else:
            return 0
    elif(x==0):
        return x
    else:
        val = x&pos_limit
        if(val==x):
            return x
        else:
            return 0

value = int(input("Enter value: "))
print(reverse(value))

下面的部分只是反转了负值和正值。

if x<0:
    str_x = '-'+str_x[::-1][:-1]
    x = int(str_x)
    print(x)
else:
    str_x = str_x[::-1]
    x = int(str_x)
    print(x)

设置限制neg_limit= -0x80000000和pos_limit= 0x7fffffff并根据解释的逻辑检查它们。

Answer 2

解决方案已经存在，我正在发布此信息，因为这可能对像我这样的新手很有帮助。我使用了 void 的解决方案（如上）来完成它。起初，我没有执行反向方法就进行了测试，它显示了原始问题中提到的问题。然后我在将正负情况下的数字都反转后进行了测试，并且它起作用了。

def reverse(self, x: int) -> int:
        neg_limit =-0x80000000 # hex(-2**31-1),see details in accepted answer above
        pos_limit = 0x7fffffff #hex(2**31-1)
        if x >0:
            reverse_num = int(str(x)[::-1])
            if reverse_num & pos_limit==reverse_num: #conditions explained above
                return reverse_num
            else:
                return 0

        elif x <0:
            reverse_num = -int(str(abs(x))[::-1])
            if reverse_num&neg_limit == neg_limit:
                return reverse_num
            else:
                    return 0
        else:
            return 0

Answer 3

简单而纯粹的数学-

def reverse(self, x: int) -> int:
        r = 2 ** 31
        maxLimit = r - 1
        minLimit = r * -1
        rev = None
        negative = False

        if x < 0:
            negative = True
            x = x * -1

        while True:
            mod = x % 10
            x = (x - mod) / 10

            if not rev:
                rev = mod
            else:
                rev = (rev * 10) + mod

            if x <= 0:
                break

        if negative:
            rev = rev * -1

        returnValue = int(rev)
        if returnValue < minLimit or returnValue > maxLimit:
            return 0 #Return whatever you want. if overflows
        return int(rev)

Answer 4

发生这种情况是因为nums = 1534236469在32位带符号整数的范围内，但相反的是9646324351不在32位带符号整数的范围内。

class Solution:
def reverse(self, x: int) -> int:
    if x in range((-1 << 31),(1 << 31)-1):
        r=0
        c=False
        if(x<0):
            c=True
            x*=-1

        while(x!=0):
            r=10*r+x%10
            x=x//10
        if(c):
            r*=-1
        if r in range((-1 << 31),(1 << 31)-1):
            return r
        else:
            return 0
    else:
        return 0

Answer 5

不使用任何其他变量作为限制来检查结果溢出的另一种方法是：

def reverse(x):
    num = str(abs(x))

    if x < 0:
        result = -1 * int(num[::-1])
    else:
        result = int(num[::-1])

    if result not in range((-1 << 31), (1 << 31) - 1):
        return 0

    return result

Answer 6

基于@Keshari解决方案的简单，数学和Python方式

def reverse(x):
    is_neg = x < 0
    imax = (1 << 31) - 1
    imin = (-1 << 31)
    r = 0
    x = abs(x)
    while x:
        x, m = divmod(x, 10)
        if (r > imax / 10) or (r == imax / 10 and m > 7):
            return 0
        if (r < imin / 10) or (r == imin / 10 and m < -8):
            return 0
        r = (r * 10) + m
    return r * -1 if is_neg else r

Answer 7

反转有符号整数，但如果超出给定的 int32 限制（低于 2^31 或高于 2^31 -1，则返回 0。

[将其嵌入解决方案类是问题站点要求的一部分。]

我是 Python 新手，所以请批评指正——事实上，这是我的第一个 Python 函数和第一个“类”。

执行以下操作似乎简单明了：

class Solution:
    def reverse(self, x: int) -> int:
        s = str(abs(x))[::-1]
        sign = -1 if x < 0 else 1
        rx = int(s) * sign
        return 0 if rx < -2**31 or rx > 2**31 - 1 else rx

折叠临时值 s、rx 和/或 sign 也很容易，但不使则不太清楚。

说真的，我很感激批评，因为这实际上是我的第一个 Python；多年来一直想学习它。

反转32位整数

7 个答案: