leetcode简单题_1), d(1), a(1), alp(1), 0]); l2 = link([th(2), d(2-CSDN博客

本文链接：https://blog.csdn.net/Uchiha_tw/article/details/101055334

整数反转

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

回文数

    def isPalindrome(self, x: int) -> bool:
        if str(x)[0] == '-':
            return False
        else:
            if x == int(str(x)[::-1]):
                return True
            else:
                return False

罗马数字转整数

    def romanToInt(self, s: str) -> int:
        q={'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
        a=[]
        b=0
        for i in s:
            a.append(q[i])
        for i in range(len(a)):
            if i < len(a)-1 and a[i] < a[i+1]:
                b = b - a[i]
            else:
                b = b + a[i]
        return b

最长公共前缀

    def longestCommonPrefix(self, strs: List[str]) -> str:
        if len(set(strs)) > 1:
            b = 0
            while 1:
                a = []
                for i in strs:
                    a.append(i[:b])
                if len(set(a)) == 1 and b < len(max([i for i in strs])):
                    b += 1
                else:
                    return a[0][:b - 1]
        else:
            if len(strs):
                return  strs[0]
            else:
                return ''

有效的括号

  def isValid(self, s: str) -> bool:
      stack = []
      lookup = {
          "(": ")",
          "[": "]",
          "{": "}"
      }
      for alp in s:
          if alp in lookup:
              stack.append(alp)
              continue
          if stack and lookup[stack[-1]] == alp:
              stack.pop()
          else:
              return False
      return True if not stack else False

合并两个有序链表

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1: return l2
        if not l2: return l1
        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2

删除排序数组中的重复项

  def removeDuplicates(self, nums: List[int]) -> int:
      q = []
      for j in nums:
          if j in q:
              continue
          else:
              q.append(j)
      for i, j in enumerate(q):
          nums[i] = j
      return len(q)

移除元素

    def removeElement(self, nums: List[int], val: int) -> int:
        #if len(nums)>2:
        while 1:
            if val in nums:
                nums.remove(val)
            else:
                break
        #else:
            #if nums[0] == val:
                #return 0
        return len(nums)

实现 strStr()

    def strStr(self, haystack: str, needle: str) -> int:
        if haystack == '' and needle == '':
            return 0
        elif needle == '':
            return 0
        else:
            if needle in haystack:
                return haystack.index(needle)
            else:
                return -1

搜索插入位置

    def searchInsert(self, nums: List[int], target: int) -> int:
        if target in nums:
            return nums.index(target)
        else:
            a=0
            while 1:
                if nums[a] > target:
                    return a
                elif a < len(nums)-1 :
                    a += 1
                else:
                    return len(nums)

最大子序和

    def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1, len(nums)):
            nums[i] = max(nums[i-1]+nums[i], nums[i])
        return max(nums)

最后一个单词的长度

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        s = s.lstrip()
        if len(s) == 0:
            return 0
        return len(s.split()[-1])

加一

    def plusOne(self, digits: List[int]) -> List[int]:
        lenght = len(digits)
        new = digits[lenght-1] + 1
        i = 1
        while True:
            if new == 10 :
                digits[lenght-i] = 0
                i += 1
                if i <= lenght:
                    new = digits[lenght-i] + 1
                else:
                    digits.insert(0,1)
                    break
            else:
                digits[lenght - i] = new
                break
        return digits

二进制求和

    def addBinary(self, a: str, b: str) -> str:
        a, b = int(a, 2), int(b, 2)
        ans = bin(a + b)
        ans = str(ans)
        ans = ans[2:]
        return ans

x 的平方根

class Solution:
    def mySqrt(self, x: int) -> int:
        a = math.sqrt(x)
        return int(a//1)

爬楼梯

    a = {}
    def inner(self,x):
        print(a)
        if x in a.keys():
            return a[x]
        a[x] = fun(self,x)
        return fun(self,x)
    return inner

class Solution:
    @warpe
    def climbStairs(self, x: int) -> int:
        if x <= 2:
            return x
        return self.climbStairs(x-1) + self.climbStairs(x-2)

删除排序链表中的重复元素

    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head is None or head.next is None:
            return head
        child = self.deleteDuplicates(head.next)
        if child and head.val == child.val:
            head.next = child.next
            child.next = None
        return head

合并两个有序数组

    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        for i, j in enumerate(nums2):
            nums1[i+m] = j
        nums1.sort()
        return nums1