LeetCode #7 Reverse Integer Solution & Explanation

(updated on 2023.08.21 – added c++ solution)

LeetCode Problem

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 – 1], then return 0.

Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

LeetCode #7 Examples and Constraints

Solution

Because the limit of the problem, we can’t use long number to calculate the number.

With C#, the first idea is to use Int32.TryParse, which can easily check if bigger or smaller than Int32.

And let us try of that.

C# Solution

Solution1 (use string to reverse and Int32.TryParse to check the result)

public class Solution {
    public int Reverse(int x) {
        bool neg = false;      //check if negative number
        if(x<0)
        {
            neg = true;
            x = x*-1;
        }
        
        //Convert to string than reverse by Array
        string y = x.ToString();
        char[] arr = y.ToCharArray();
        Array.Reverse(arr);
        y = new string(arr);
        
        int res = 0;
        if(Int32.TryParse(y,out res))
        {
            res *= neg ? -1 : 1;
        }
        return res;
    }
}

Solution2 (the solution is too superfluous and complex)

public class Solution {
    public int Reverse(int x) {
        bool neg = false;      //check if negative number
        if(x<0)
        {
            neg = true;
            x = x*-1;
        }
        
      
        string y = x.ToString();
        char[] arr = y.ToCharArray();
        Array.Reverse(arr);
        y = new string(arr);
        

        //calculate and check
        int res = 0;
        for(int i =0; i<y.Length;i++)
        {
            int tmp = (int)(Convert.ToInt32(y[i].ToString()) *Math.Pow(10,y.Length-i-1));         
            if(tmp == Int32.MinValue || tmp == Int32.MaxValue) 
            {
                return 0;
            }
            
            if(neg)
            {
                tmp *= -1;
            }

            if(tmp > Int32.MaxValue-res && !neg)
            {
                return 0;
            }
            else if( Int32.MinValue-res >tmp &&neg)
            {
                return 0;
            }
            res += tmp;
        }
        return res;
    }
}

⭐Solution 3

public class Solution {
    public int Reverse(int x) {
        int res = 0;
        while(x !=0)
        {
            int tmp = x%10;
            res = res*10+tmp;
            x = (x-tmp)/10;
            
            if(res%10!=tmp) //exceed int range
            {
                return 0;
            }
        }
        
        return res;
    }
}

【res%10!=tmp】 is to check if the res number exceed the Int32 range, than return 0

Java Solution

Solution1

class Solution {
    public int reverse(int x) {

       boolean neg = false;      //check if negative number
        if(x<0)
        {
            neg = true;
            x = x*-1;
        }
        
        //Convert to string than reverse by Array
        String y = Integer.toString(x);
        
        StringBuilder sb=new StringBuilder(y);  
        y = sb.reverse().toString();  
        
        try {
            x = Integer.parseInt(y);
        } catch (NumberFormatException e) {
            return 0;
        }
        
        if(neg)
        {
            x*=-1;
        }
        return x;
    }
}

Use try catch to pretend C# ‘s Int32.TryParse function

Runtime : 3ms

Solution2

class Solution {
    public int reverse(int x) {

        int res = 0;
        while(x !=0)
        {
            int tmp = x%10;
            res = res*10+tmp;
            x = (x-tmp)/10;
            
            if(res%10!=tmp) //exceed int range
            {
                return 0;
            }
        }
        
        return res;
    }
}

⭐Runtime : 2ms

Python3 Solution

Solution1

class Solution:
    def reverse(self, x: int) -> int:
        x = str(x)
        if x[0] == '-':
         a = int('-' + x[-1:0:-1])
         if a >= -2147483648 and a<= 2147483647:
            return a
         else:
            return 0
        else:
            a = int(x[::-1])
        if a >= -2147483648 and a<= 2147483647:
           return a
        else:
           return 0

JavaScript Solution

Solution1

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var res = 0;
    while(x !=0)
    {
        var tmp = x%10;
        res = res*10+tmp;
        x = (x-tmp)/10;

        if (res < -2147483648 || res > 2147483647)
        {
            return 0;
        }
    }

    return res;
};

C++ Solution

class Solution {
public:
    int reverse(int x) {
        int res = 0;
        while (x != 0) {
            int tmp = x % 10;
            
            if (res > INT_MAX / 10 || (res == INT_MAX / 10 && tmp > 7)) {
                return 0;
            }
            if (res < INT_MIN / 10 || (res == INT_MIN / 10 && tmp < -8)) {
                return 0;
            }
            
            res = res * 10 + tmp;
            x = (x - tmp) / 10;
        }
        
        return res;
    }
};

And why we need to check 7 and -8, that is because we need to check if the number will be overflow of integer range .

INT_MIN = -231 = -2,147,483,648

INT_MAX = 231-1 = 2,147,483,647


Conclusion

This is an interesting problem, like C#, you can use Library TryParse to get the answer easily.

But I thought the best way to finish this problem is the solution3.

"the reverse side also has a reverse side"
                                                                                    Japanese proverb                   

Cover Photo – Photo by 愚木混株 cdd20 on Unsplash

The problem link : Reverse Integer – LeetCode

Some Technology Article

Related Post

2 Comments

  1. well in c++, this question is a bug and cant be solved. i used ur trick

    if(res%10!=tmp) //exceed int range
    {
    return 0;
    }
    but i still dont get it.
    if u dont get what im saying im on leet code question 7. How to reverse a string.
    Plz provide a c++ solution also.

Leave a Reply

Your email address will not be published. Required fields are marked *