精华内容
下载资源
问答
  • leetcode整数反转

    2020-01-27 09:57:59
    leetcode 整数反转 int reverse(int x) { long sum = 0; while(x) { sum=sum*10+x%10; x/=10; } if(sum>2147483647||sum<-2147483648) return 0; return sum; }...

    leetcode 整数反转

    题目要求

    int reverse(int x)
    {
        long sum = 0;
        while(x)
        {
            sum=sum*10+x%10;
            x/=10;
        }
        if(sum>2147483647||sum<-2147483648)
            return 0;
        return sum;
    }
    
    展开全文
  • Leetcode 整数反转

    千次阅读 2020-12-19 15:01:35
    整数反转 题目描述: 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 注意: 假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转...

    整数反转

    题目描述:

    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
    注意:
    
    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231,  231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。
    
    

    题目链接

    class Solution:
        def reverse(self, x: int) -> int:
            flag = 0 # 符号位默认为正数
            if(x<0):
                flag = 1
                x = -x
            number = str(x)
            number = number[::-1] # 反转
            if(flag):
                number = '-'+number;
            # 在Python内部对整数的处理分为普通整数和长整数,普通整数长度为机器位长,通常都是32位,超过这个范围的整数就自动作为长整数处理,而长整数的范围几乎完全没限制,故可以作为判断是溢出的标准
            if(int(number)>2**31-1 or int(number) < -2**31):
                return 0
            else:
                return int(number)
            
    

    这里的题目思路非常容易,只需做到反转即可,主要是判断是否溢出。

    展开全文
  • leetcode 整数反转

    2020-09-16 08:19:35
    leetcode 第七题整数反转 题目描述 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 注意: 假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个...

    leetcode 第七题整数反转

    题目描述

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

    注意:

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

    输入: 123
    输出: 321

    输入: -123
    输出: -321

    输入: 120
    输出: 21

    方法

    首先我们看到整数反转,能联想到类似将数字压入堆栈,然后根据堆栈的特点先进后出,因此我们设置了一个变量pop,每次将给定的整数对10取余,即可得出当前的这个数字最后一位。然后我们使用了一个变量rev对其自乘10再加上pop,也即rev=rev*10 + pop,这是关键的反转数学式子,不难想到,但是笔者做题之前并未认真思考,直接上手写,所以式子很是繁杂。
    其次,我们需要注意一个关键点,防止整数溢出。所以需要在上面的数学式子前进行溢出的判断,这是测试的关键点,由此即可得出答案,正负号我们在这个式子中会自动保留,无需我们另外考虑。

    class Solution {
        public int reverse(int x) {
            int rev = 0;
            while(x != 0) {
                int pop = x % 10;
                x /= 10;
                if(rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE/10 && pop > 7)) {
                    return 0;
                }
                if(rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE/10 && pop < -8)) {
                    return 0;
                }
                //need /10 because we need to judge, if rev *10 + pop greater than MAX or MIN ,it               //will overflow 
                rev = rev*10 + pop; // may occur overflow
            }
            return rev;
        }
    }
    
    展开全文
  • LeetCode 整数反转

    2020-01-11 09:58:17
    整数反转 题目 给出一个 32 位的有符号整数,将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 假设环境只能存储 32 位的有符号...

    整数反转


    题目


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

    示例 1:

    输入: 123
    输出: 321
    

    示例 2:

    输入: -123
    输出: -321
    

    示例 3:

    输入: 120
    输出: 21
    

    假设环境只能存储 32 位的有符号整数,则其数值范围为 [ − 2 31 , 2 31 − 1 -2^{31},2^{31}-1 2312311]。若在反转后溢出,则返回 0。

    解题思路


    • 本题需要考虑溢出的问题,可考虑数学计算处理,或者转换字符串进行处理。
    • 本篇考虑数学计算的方法处理溢出问题,字符串转换效率相对较低。
    • 循环拆开 x 的每一位数字,计算时判断是否溢出。
    • 溢出条件,一是大于最大的边界值,二是小于最小的边界值。设当前值为 cur,下一位拆分的值为 pop
    • 数值为正,溢出条件 cur * 10 + pop > max_value
      • cur > max_value_div_10 时,还需加上 pop 则判断溢出
      • cur == max_value_div_10 时,pop > 7 则判断为溢出,2^32 - 1 最后一位为 7
    • 数值为负,溢出条件 cur * 10 + pop < min_value
      • cur < min_value_div_10 时,还需加上 pop 判断溢出
      • cur == min_value_div_10 时,pop < -8 则判断为溢出,-2^32 最后一位为 -8
    • 注意,python 正、负值取余,取模不同于 java,要加以区分

    代码实现


    class Solution:
        def reverse(self, x: int) -> int:
            '''反转整数
    
            Args:
                int: 传入待反转的整数
    
            Returns:
                返回反转后的整数
            '''
            # 存储返回值
            cur = 0
    
            # 边界值除以 10,用于后续判断是否溢出
            max_value_div_10 = (1<<31) // 10
            min_value_div_10 = -(-((1<<31)-1) // -10)
            
    
            while x != 0:
                # Python 正、负值取模,取余有区别,需分开判断
                if x > 0:
                    pop = x % 10
                    x //= 10
                else:
                    pop = x % -10
                    x = -(x // -10)
                # 若 cur > max_value_div_10 时,还需加上 pop 则判断溢出
            	# 若 cur == max_value_div_10 时,pop > 7 则判断为溢出,2^32 - 1 最后一位为 7
                if (cur > (max_value_div_10)) or ((cur == (max_value_div_10)) and (pop > 7)):
                    return 0
                # 若 cur < min_value_div_10 时,还需加上 pop 判断溢出
    	        # 若 cur == min_value_div_10 时,pop < -8 则判断为溢出,-2^32 最后一位为 -8
                if (cur < (min_value_div_10)) or ((cur == (min_value_div_10)) and (pop < -8)):
                    return 0
                cur = cur * 10 + pop
    
            return cur
    

    实现效果


    lettcode_reverse_result.jpg

    leetcode_reverse_result2.png


    以上为本篇的主要内容。


    欢迎关注『书所集录』公众号
    展开全文
  • Leetcode整数反转

    2020-09-02 11:09:46
    题目 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 ...整数反转部分比较简单。主要需要注意的是题中对边界条件的要求,需要判断

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,342
精华内容 4,536
关键字:

leetcode整数反转