一枚菜鸟的leetcode刷题笔记 -Day 2

最新推荐文章于 2024-11-14 13:48:50 发布

Joyeeee.

最新推荐文章于 2024-11-14 13:48:50 发布

阅读量251

点赞数

分类专栏： leetcode 文章标签： python 数据结构字符串

本文链接：https://blog.csdn.net/Joye_BNU/article/details/112548625

版权

leetcode 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

7 - 整数反转

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

class Solution:
    def reverse(self, x: int) -> int:
        flag = False    #判断符号，如果是负数设置为True
        if x < 0 :
            flag = True
            x = -x
        q = []  #用列表存储输入数字的各个位数的数字
        while x > 0:    #终止循环的条件是x=0
            q.append(int(x%10))     #利用取余操作获取最后的一位数
            x = int(x//10)      #利用取整操作排除最后一位数
        ans = 0
        while q:
            ans = ans*10 + q.pop(0)
        if flag:
            if ans > 2**31:
                return 0
            else:
                return -ans
        else:
            if ans > 2**31 - 1:
                return 0
            else:
                return ans

利用取余和取整获取各个位数并添加到队列q，再依次出队并组合成最终结果。

class Solution:
    def reverse(self, x: int) -> int:
        flag = False    #用于判断x的正负以便后面分类讨论
        if x < 0:
            flag = True
            x = -x
        reNum = 0
        while x > 0:
            reNum = reNum*10 + x%10
            x = x//10
        if flag:
            if reNum > 2**31:
                return 0
            else:
                return -reNum
        else:
            if reNum > 2**31-1:
                return 0
            else:
                return reNum

借鉴了 9 - 回文数的思路，直接定义一个逆序数，可以通过x求出来，最后别忘了判断范围。

9 - 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        q = []
        while x > 0:
            q.append(x%10)
            x = x//10
        while len(q) > 1:
            if q.pop(0) != q.pop(-1):
                return False
        return True

用一个列表维护整数x的所有数字。
依次出队列表左右两端的数字并比较，若不同，则直接返回False，直到列表里只剩下一个或零个元素。
注意若x为负数，那么一定是False

class Solution:
    def isPalindrome(self,x:int)->bool:
        s = str(x)
        l = len(s)
        h = l//2
        return s[:h] == s[-1:-h-1:-1]

这是官方答案，非常简洁，直接转成字符串，厉害。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        reNum = 0
        y = x
        while x > 0:
            reNum = reNum*10 + x%10
            x = x//10
        return y == reNum

这个是看了答案之后有的思路，可以直接求逆序数，例如345的逆序数就是543，求逆序数的步骤其实还是利用取余和取整操作，其实就是不断的给x对10取余的结果乘10

8 - 字符串转换整数 (atoi)

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：

如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0 。

注意：本题中的空白字符只包括空格字符 ’ '。假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [ $2^{31}$ , $2^{31} − 1$ ]。如果数值超过这个范围，请返回 $2^{31} − 1$ 或 $2^{31}$ 。

class Solution:
    def myAtoi(self, s: str) -> int:
        num = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
        sign = ['+', '-']
        target = '0'
        #遍历整个字符串
        for j in range(len(s)):
            if (s[j] not in num) and (s[j] not in sign) and (s[j] != ' '):
                return 0
            elif s[j] in sign:
                if j < len(s)-1 and s[j+1] in num:                   
                    target = s[j]
                    i = j+1
                    while s[i] in num:
                        target += s[i]
                        i += 1
                        if i >= len(s):
                            break
                    break
                else:   #这里如果不写这个else语句，会导致循环继续，对于'+-12'这样的事例就会输出错误的结果
                    return 0
            elif s[j] in num:
                target = ''
                i = j
                while s[i] in num:
                    target += s[i]
                    i += 1
                    if i >= len(s):
                        break
                break
            else:
                pass
        #判断输出数的取值范围
        if int(target) < -2**31:
            return -2**31
        elif int(target) > 2**31 - 1:
            return 2**31 - 1
        else:
            return int(target)

题不难，坑挺多，注意避免各种条件的坑吧。

INT_MAX = 2**31 - 1
INT_MIN = 2**31

class fsm:
    def __init__(self):
        self.state = 'start'
        self.sign = True   #用True和False表示符号
        self.ans = 0
        self.table = {'start':['start', 'sign', 'num', 'end'],
                      'sign':['end', 'end', 'num', 'end'],
                      'num':['end', 'end', 'num', 'end'],
                      'end':['end', 'end', 'end', 'end']
                      }
    
    def get_state(self, s):
        if s.isspace():
            return 0
        elif s == '+' or s == '-':
            return 1
        elif s.isdigit():
            return 2
        else:
            return 3
    
    def solve(self, ss):
        self.state = self.table[self.state][self.get_state(ss)]
        if self.state == 'sign' and ss == '-':
            self.sign = False
        if self.state == 'num':
            self.ans = self.ans*10 + int(ss)
            self.ans = min(INT_MAX, self.ans) if self.sign else min(INT_MIN, self.ans)

class Solution:
    def myAtoi(self, str: str) -> int:
        atoi = fsm()
        for c in str:
            atoi.solve(c)
        if atoi.sign:
            return atoi.ans
        else:
            return -atoi.ans