LeetCode7 整数反转 C++, Java, Python

LeetCode7 整数反转

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer/

博主Github：https://github.com/GDUT-Rp/LeetCode

题目

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 $[-2^{31},2^{31}-1]$。请根据这个假设，如果反转后整数溢出那么就返回 0。

思路

判断奇数偶数，变成字符串，反转一下，再变回来整数，变回奇偶，再判断一下是否溢出。

Python

# -*- coding: utf-8 -*-
# https://leetcode-cn.com/problems/reverse-integer/
import sys


def create_sample():
    return [123, -123, 120, 21, 1534236469, -2147483648]


class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        flag = 1
        if x < 0:
            flag = -1
            x = str(x)[1:]
        else:
            x = str(x)
        x = x[::-1]
        ans = int(x) * flag
        if ans > (2 << 30) - 1 or ans < (-2 << 30):
            return 0
        else:
            return ans


if __name__ == '__main__':
    solution = Solution()
    for elem in create_sample():
        print(solution.reverse(elem))
    print(sys.maxsize)
    print((-2 << 30))
    print(pow(-2, 31))

Java

package com.leetcode.rp;

class SolutionOfLeetCode7 {
    public int reverse(int x) {
        int flag = 1;
        String string;
        if (x < 0){
            flag = -1;
            string = x + "";
            string = string.substring(1, string.length());
        }
        else{
            string = x + "";
        }
        String newstring = new String();
        int length = string.length();
        for (int i = length - 1; i > -1; i--) {
            newstring += string.charAt(i);
        }
        try {
            x = Integer.parseInt(newstring);
        } catch (NumberFormatException e) {
            return 0;
        }
        return x * flag;
    }
    public int easy(int x){
        int ans = 0;
        int yu = 0;
        while (x != 0){
            yu = x % 10;
            x = x / 10;
            if (ans > Integer.MAX_VALUE / 10 || ans < Integer.MIN_VALUE / 10)
                return 0;
            ans = ans * 10 + yu;
        }
        return ans;
    }
}
public class LeetCode7 {
    public static void main(String[] args) {
        SolutionOfLeetCode7 solutionOfLeetCode7 = new SolutionOfLeetCode7();
        int[] x = {123, -123, 120, 21, 1534236469, -2147483648};
        for (int i:x) {
            int ans = solutionOfLeetCode7.reverse(i);
            System.out.println(ans);
            System.out.println(solutionOfLeetCode7.easy(i));
        }
    }
}

C++

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