s-0-1_city = 0 poly = 1 tmp = snum res = []-CSDN博客

本文链接：https://blog.csdn.net/Missduo/article/details/123624987

class Solution:
    def reverse(self, x: int) -> int:
        flag = False
        if x > 0:
            flag = True
            num = x
        else:
            num = (-1)*x
        str_x = str(num)[::-1]
        cnt = 0
        for i in str_x:
            cnt = cnt *10 + int(i)
        if flag:
            if cnt > 2**31-1:
                return 0
            else:
                return cnt
        else:
            if cnt > 2**31:return 0
            else:return (-1)*(cnt)

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        return str(x) == str(x)[::-1]

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        sz, ret = zip(*strs), ""
        print(sz)
        for c in sz:
            if len(set(c)) > 1: 
                break
            ret += c[0]
        return ret

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        l = []
        dic_ = {']':'[','}':'{',')':'('}
        for i in s:
            if i in dic_:
                if l == []:return False
                else:
                    if dic_[i] == l[-1]:
                        l.pop()
                    else:
                        return False
            else:
                l.append(i)
        if l == []:
            return True
        else:
            return False

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if nums == []:return 0
        res,tmp = 1,nums[0]
        for i in range(1,len(nums)):
            if tmp!=nums[i]:
                nums[res] = nums[i]
                res+=1
                tmp = nums[i]
        return res

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        cnt = 0
        for index in range(len(nums)):
            if nums[index] != val:
                nums[cnt] = nums[index]
                cnt += 1
        nums = nums[:cnt]
        return cnt

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if len(haystack) < len(needle):return -1
        if len(haystack) == len(needle):
            if haystack == needle:
                return 0
            else:
                return -1
        for i in range(len(haystack)-len(needle)+1):
            if needle == haystack[i:i+len(needle)]:
                return i
        return -1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = (l + r) // 2
            if nums[mid] == target:
                return mid
            if nums[0] <= nums[mid]:
                if nums[0] <= target < nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            else:
                if nums[mid] < target <= nums[len(nums) - 1]:
                    l = mid + 1
                else:
                    r = mid - 1
        return -1

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        length = len(nums)
        start = 0
        end = length
        if length == 0:
            return False
        while start < end:
            mid = (end+start)//2
            if nums[mid]>target:
                end = mid
            elif nums[mid]<target:
                start=mid+1
            else:
                return mid
        return start

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        l = len(nums) 
        i = 0 
        sum = 0 
        MaxSum = nums[0] 
        while i < l: 
            sum += nums[i] 
            if sum > MaxSum: 
                MaxSum = sum 
            if sum < 0: 
                sum = 0 
            i += 1 
        return MaxSum

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        #计算字符串的长度
        n = len(s)
        #计算最后单词的长度，初值为0
        nums = 0
        #从右向左遍历字符串
        for i in range(n-1,-1,-1):
            #当遍历到的值不为空格时，单词长度+1
            if s[i] != " ":
                nums += 1
            #当遍历到空格时，判断nums是否为0
            else:
                #nums不为0，说明已经遍历完了最后一个单词
                if nums != 0:
                    return nums
                #为0说明还没有遍历到字母
                else:
                    pass
        #如果没有单词返回初值
        return nums

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(len(digits)-1,-1,-1):
            if digits[i] != 9:
                digits[i] += 1
                break
            else:
                digits[i] = 0
        if digits[0] == 0:
            digits.insert(0, 1);
        return digits;

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        num1, num2 = a, b
        res = ''
        i1, i2, carry = len(num1) - 1, len(num2) - 1, 0
        while i1 >= 0 or i2 >= 0:
            x = ord(num1[i1]) - ord('0') if i1 >= 0 else 0
            y = ord(num2[i2]) - ord('0') if i2 >= 0 else 0

            sum = x + y + carry
            res += str(sum % 2)
            carry = sum // 2

            i1, i2 = i1 - 1, i2 - 1
        if carry != 0: res += str(carry)
        return res[::-1]


class Solution:
    def mySqrt(self, x: int) -> int:
        if x == 0:
            return 0

        l = 1
        r = x

        while l <= x:
            middle = (l + r) // 2
            s = middle**2

            if s <= x < (middle + 1)**2:
                return middle
            if s < x:
                l = middle
            if s > x:
                r = middle

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1 or n == 2:
            return n
        a = 1
        b = 2
        for i in range(3,n+1):
            a,b = b,a+b
        return b

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if not head:
            return head
        root = head
        while head.next:
            if head.val == head.next.val:
                head.next = head.next.next
            else:
                head = head.next
        return root

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        #用两个指针 从后往前走
        cnt = m+n-1 #表示总的指针
        while m > 0 and n > 0:
            if nums1[m-1] >= nums2[n-1]:
                nums1[cnt] = nums1[m-1]
                m -= 1
                cnt -= 1
            else:
                nums1[cnt] = nums2[n-1]
                n -= 1
                cnt -= 1
        if m == 0:
            nums1[:cnt+1] = nums2[:cnt+1]

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        def dfs(root,res):
            if not root:return 
            dfs(root.left,res)
            res.append(root.val)
            dfs(root.right,res)
        res = []
        dfs(root,res)
        return res

100

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if (p and not q) or (not p and q):
            return False
        elif not p and not q:
            return True
        else:
            if p.val != q.val:
                return False
            else:
                return self.isSameTree(p.right,q.right) and self.isSameTree(p.left,q.left)