Leetcode笔记 python_容易篇

Leetcode刷题笔记（容易篇）

12.16日

1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]在这里插入代码片
        """
       	"""1
        暴力解法：直接遍历
        """
        # for i in range(len(nums) - 1): 
        #     for j in range(i+1, len(nums)):
        #         if nums[i] + nums[j] == target:
        #             return [i, j]
       	"""2
       通过使用enumerate()将列表可以获取下标和值
       使用字典模拟哈希查表法
       
        """
        dict_sum = {}
        for i, num in enumerate(nums):
            temp = target - num
            if temp in dict_sum:
                return [dict_sum[temp],i]
            dict_sum[num] = i

58. 最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指由字母组成，但不包含任何空格的字符串。
示例:
输入: “Hello World”
输出: 5

class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        '''1
        使用str.strip()  将首尾指定的字符去掉，
        然后使用str.split('') 以空格分割，
        取最后一个单词的长度
        '''
        # return len(s.rstrip().split(" ")[-1])

        '''2
        首先从后面遍历找出最后一位不为空格的index
        然后继续遍历，直到碰到' '
        '''
        count = 0 
        n = len(s)-1
        while n>=0 and s[n] == ' ':
            n -= 1
        while n>=0 and s[n] != ' ':
            count += 1
            n -= 1
        return count

12.17日

7. 整数反转
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """

        if x<0:
            y = -1*int(str(-x)[::-1])
        else:
            y = int(str(x)[::-1])
        if y > 2147483648 or y < -2147483648 :
            y = 0 
        return y

class Solution(object):
    def myAtoi(self, str):
        """
        :type str: str
        :rtype: int
        """

        # 去掉两边的空格
        s = str.strip()
        # 全空格，无效
        if not s:
            return 0
        # 单个非数字字符，无效
        if len(s) == 1 and not s[0].isnumeric():
            return 0
        # 以数字、+、-以外的字符开头，无效
        if not s[0].isnumeric() and s[0] != '-' and s[0] != '+':
            return 0
        # 提取加减号
        # 加减号提取后仍然以非数字开头，无效
        neg = False
        if s[0] == '-':
            neg = True
            s = s[1:]
            if not s[0].isnumeric():
                return 0
        elif s[0] == '+':
            s = s[1:]
            if not s[0].isnumeric():
                return 0
        # 从左往右提取连续的数字
        numbers = ''
        i = 0
        while i < len(s) and s[i].isnumeric():
            numbers += s[i]
            i += 1 
        # 加上正负号并处理溢出（真是傻逼用python还要处理溢出）
        value = int(numbers)
        if neg:
            if value > 2147483648:
                return -2147483648
            else:
                return 0 - value
        else:
            if value > 2147483647:
                return 2147483647
            else:
                return value

12.18日

13 罗马数字转整数

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """

        d = {'I':1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
        sum = 0
        for i in range(len(s)-1, -1, -1):
            if(i < len(s)-1) and (d[s[i]] < d[s[i+1]]):
                sum -= d[s[i]]
            else:
                sum += d[s[i]]
        return sum

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if len(strs)==0:
            return ""
        minlen = min([len(x) for x in strs])
        end = 0 
        while end <minlen:
            for i in range(1,len(strs)):
                if strs[i][end] != strs[i-1][end]:
                    return strs[i][:end]
            end += 1
        return strs[0][:end]

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        temp = [None]
        dic = {')':'(',']':'[','}':'{'}
    
        for t in s:
            if t in dic and dic[t] == temp[len(temp)-1]:
                temp.pop() 
            else:
                temp.append(t)
        return len(temp) == 1

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        思路：由于必须要原地删除，就不考虑用其他数据结构储存。然后可以想到，用指针变量来辅助存储。
        双指针思想：相当于从原地，得到了一个与原数据结构有关联新数据结构。
        题目特征和需要注意的地方：
        1.输入空列表
        如果不加上前提条件，会出现空列表错误
        2.给出的是有序列表（？）
        无序列表无法用此种方法解题
        """
        
        if len(nums)==0:
            return 0
        i=0
        for j in range(1,len(nums)) :
            if nums[i] != nums[j]:
                i +=1
                nums[i]= nums[j]
        return i+1

12.19日

题目描述

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """

        length = 0
        i = 0 
        while i < len(nums):
            if nums[i] != val :
                nums[length] = nums[i]
                length +=1
                i +=1
            else:
                i +=1
        return length 
                

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        right = len(nums)-1
        left = 0
        middle = 0
        while left <= right:
            middle = (left + right) //2
            if nums[middle] == target:
                return middle
            if nums[middle] > target:
                right = middle-1
            if nums[middle] < target:
                left = middle+1
        return left

12.20日

题目描述

在这里插入代码片

12.21日

题目描述

在这里插入代码片

12.22日

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        cur_sum=0
        res=nums[0]
        n=len(nums)
        for i in range(n):
            if(cur_sum>0):
                cur_sum+=nums[i]
            else:
                cur_sum=nums[i]
            res=max(res,cur_sum)    
        return res

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        number = 0
        for i in range(len(digits)):
            number = number*10 + digits[i]
        number += 1 
        number_str = str(number)
        return [int(i) for i in number_str]

class Solution(object):
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        a = int(a,2)
        b = int(b,2)
        add = bin(a+b )
        return add[2:]

#参考代码 1：所有的数都放在一起考虑，为了照顾到 00 把左边界设置为 00，为了照顾到 11 把右边界设置为 x // 2 + 1。

PythonJava
class Solution:
    def mySqrt(self, x: int) -> int:
        # 为了照顾到 0 把左边界设置为 0
        left = 0
        # 为了照顾到 1 把右边界设置为 x // 2 + 1
        right = x // 2 + 1
        while left < right:
            # 注意：这里一定取右中位数，如果取左中位数，代码可能会进入死循环
            # mid = left + (right - left + 1) // 2
            mid = (left + right + 1) >> 1
            square = mid * mid

            if square > x:
                right = mid - 1
            else:
                left = mid
        # 因为一定存在，因此无需后处理
        return left

首先考虑第一步的走法：第一步可以走1级台阶，也可以走2级台阶。那么，设S(n)表示走n级台阶的走法数量，如果第一步走1级台阶，剩下的台阶数为n-1，也就是说这种情况下的走法是相当于S(n-1)；同理，如果第一步走2级台阶，剩下的台阶数为n-2，这样的走法相当于
S(n-2)；于是，得出递推公式：
S(n) = S(n-1) + S(n-2);
S(1) =1
S(2) = 2

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        result = [0]*(n+1)
        if n <= 2 :
            return n
        result[1] = 1
        result[2] = 2
        for i in range(3,n+1):
            result[i] = result[i-1] +result[i-2]
        return result[n]

持续更新…