checking integer overflow in python

Question

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        negative = False
        if(x < 0):
            x = x * -1
            negative = True
        else:
            x = x
        sum = 0
        dig = 1
        strX = str(x)
        lst = list(strX)
        for i in lst:
            sum += int(i) * dig
            dig *= 10

        if(abs(sum) > 2 ** 32):
            return 0
        elif(negative == True):
            return sum * -1
        else:
            return sum

This is a leetcode problem that asks us to reverse an integer. I know it's a dirty code but it still works but it does not return 0 when the reversed integer overflows. I tried to check that on the line

        if(abs(sum) > 2 ** 32):
            return 0

but one of the test cases gives me:

Input: 1563847412

Output: 2147483651

Expected: 0

First, I am not sure why this overflows, and I am not sure how to fix this.

Thanks!

The largest 32-bit signed integer is (1 << 31) - 1, which is 2147483647. — Tim Peters
– Tim Peters, Commented Aug 6, 2017 at 4:58
Assuming you're checking for signed integers, you need abs(sum) > 2 ** 31 - 1 (or, even better, abs(sum) > (1 << 31) - 1) — cs95
– cs95, Commented Aug 6, 2017 at 5:03
This code is a lot more complicated than it needs to be. For instance, you can reverse a string in a single step, you don't need a for loop to do it. BTW, it's not a good idea to use sum as a variable name because that shadows the built-in sum function. It won't hurt anything here, though. — PM 2Ring
– PM 2Ring, Commented Aug 6, 2017 at 6:09

OLIVER.KOO · Accepted Answer · 2017-08-06 05:17:14Z

36

change if(abs(sum) > 2 ** 32): to if(abs(sum) > (2 ** 31 - 1)): or abs(sum) > (1 << 31) - 1): The largest 32 bit signed interger is actually not 2^32 but (2 ^ (31)) -1). because we need one bit reserve as the sign bit.

Read about it here of why The number 2,147,483,647 (or hexadecimal 7FFF,FFFF) is the maximum positive value for a 32-bit signed binary integer

edited Aug 6, 2017 at 5:17

answered Aug 6, 2017 at 5:05

OLIVER.KOO

6,1133 gold badges38 silver badges71 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

Hariom Singh Over a year ago

I think down voter should provide justification why?

OLIVER.KOO Over a year ago

seems like someone upvoted my answer. But I still wish whoever downvoted it can give an explanation.

Dukakus17 Over a year ago

Yeah who downvoted? I selected your answer. Thanks for the explanation!

SAKURA Over a year ago

@OLIVER.KOO I understand reserving 1 bit as the sign bit, so it's not to the power of 32 but rather 31. But can you explain why is it "minus 1"? Why is it not (2**31)? Thanks!

ryh Over a year ago

I think the smallest 32-bit signed integer is - 2 ** 31

|

varun · Accepted Answer · 2017-10-12 10:42:06Z

3

I guess some thing light weight like below could perhaps achieve the same logic, For someone else looking , the main overflow check after reversed 32 bit int is

if(abs(n) > (2 ** 31 - 1)):
                    return 0

Full code below

def reverse(self, x):

            neg = False
            if x < 0:
                neg = True
                x = x * -1

            s = str(x)[::-1]
            n = int(s)
            if neg:
                n = n*-1
            if(abs(n) > (2 ** 31 - 1)):
                return 0
            return n

edited Oct 12, 2017 at 10:42

answered Oct 12, 2017 at 8:58

varun

4,65036 silver badges28 bronze badges

1 Comment

varun Over a year ago

@ErikvonAsmuth ok fixed

Md. Rezwanul Haque · Accepted Answer · 2017-08-06 05:18:06Z

1

The largest 32-bit signed integer is (1 << 31) - 1 which is (2**31)-1 but not (2**32).

Try This way :

class Solution(object):
  def reverse(self, x):
    """
    :type x: int
    :rtype: int
    """
    negative = False
    if (x < 0):
      x = x * -1
      negative = True
    else:
      x = x
    sum = 0
    dig = 1
    strX = str(x)
    lst = list(strX)
    for i in lst:
      sum += int(i) * dig
      dig *= 10

    if (abs(sum) > ((1 << 31) - 1)): #use (1 << 31) - 1) instead of 2 ** 32
      return 0
    elif (negative == True):
      return sum * -1
    else:
      return sum

if __name__ == '__main__':
    x = 1563847412
    sol = Solution().reverse(x)
    print(sol)

Output :

edited Aug 6, 2017 at 5:18

answered Aug 6, 2017 at 5:10

Md. Rezwanul Haque

2,9487 gold badges35 silver badges49 bronze badges

Comments

Nikhil G · Accepted Answer · 2020-11-16 19:57:09Z

1

class Solution:
    def reverse(self, x: int) -> int:

        split = [i for i in str(x)]
        split = split[::-1]
        final = ''

        
        if split[-1]=='-':
            final += '-'
            
            for i in split[0:-1]:
                print(i)
                final+=i
        else:
            
            for i in split[0:]:
                final+=i
                
        final = int(final)
        
        if(abs(final) > (2 ** 31 - 1)):
                return 0
                
        return(final)

answered Nov 16, 2020 at 19:57

Nikhil G

5694 silver badges10 bronze badges

Comments

Shubhra Deshpande · Accepted Answer · 2019-09-16 15:50:29Z

0

you can simply use:

if sum >= pow(2,31)-1:
     return 0

answered Sep 16, 2019 at 15:50

Shubhra Deshpande

1072 silver badges12 bronze badges

Comments

Juri Noga · Accepted Answer · 2020-01-29 12:11:05Z

0

if sum > ((1 << 31) - 1):
    return 0
else:
    if negative == True:
      sum = -sum
      return sum

edited Jan 29, 2020 at 12:11

Juri Noga

4,4017 gold badges42 silver badges54 bronze badges

answered Jan 29, 2020 at 11:51

ayesha kaleem

772 silver badges7 bronze badges

Collectives™ on Stack Overflow

checking integer overflow in python

6 Answers 6

6 Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

6 Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related