力扣简单题刷题笔记（python实现）

class Solution:

    def romanToInt(self, s: str) -> int:

        dict_key = ['I','V','X','L','C','D','M']

        dict_value = [1,5,10,50,100,500,1000]

        dict_roman = dict(zip(dict_key,dict_value))#做个字典存值

        sum = 0

        i = 0

        while i < len(s)-1:

            if dict_roman[s[i+1]] <= dict_roman[s[i]]:#如果不是特殊情况

                sum = dict_roman[s[i]] + sum#加上当前的值

                i = i + 1#指针往前走1

            else:

                sum = dict_roman[s[i+1]] - dict_roman[s[i]] + sum#计算特殊情况的值

                i = i + 2#指针往前走2

        if i<len(s):#如果指针没走到最后一个数

            sum = dict_roman[s[-1]] + sum

        return sum

 

class Solution:

    def twoSum(self, nums: List[int], target: int) -> List[int]:

        for i in range(len(nums)):

            if target-nums[i] in nums and nums.index(target-nums[i]) != i:

                #如果目标值减去当前值得到的值也在数组里，而且和当前值下标不同，就找到了这两个数

                return [i,nums.index(target-nums[i])]

 

class Solution:

    def isPalindrome(self, x: int) -> bool:

        x = list(map(str,str(x))) #将整数转化为list

        x1 = x[::-1] #倒置list

        if x1 == x :

            return True

        else:

            return False

 

class Solution:

    def longestCommonPrefix(self, strs: List[str]) -> str:    

        str = ""

        for i in zip(*strs):#使用zip(*list)函数，取出迭代对象中的可迭代对象的同一位置的元素组成元祖。

            if len(set(i))==1:#给元组去重，若去重后长度为1，则是公共部分

                str += i[0]

            else:

                return str

        return str

class Solution:

    def isValid(self, s: str) -> bool:

        #利用栈的先入后出原理，当字符串中的字符和字典中的key值相同入栈，如果栈顶的元素在字典中对应的value和字符串当前指针不符，就退出。因为栈的pop操作，栈空报错，因此提前给栈输入一个值。

        dict_kuohao = {'(': ')', '{': '}', '[': ']','?':'?'}

        stack = ['?']

        for i in s:

            if i in dict_kuohao:

                stack.append(i)

            elif dict_kuohao[stack.pop()] != i:

                return False

        return len(stack) == 1#如果最后的栈只剩？，则括号匹配，否则就一定不匹配

 

class Solution:

    def removeDuplicates(self, nums: List[int]) -> int:

        i = 0

        j = 1

        length = len(nums)

        while j <= length - 1 and i < j:

            if nums[i] == nums[j]:

                nums.pop(i)

                i = j - 1 #为了保证i只向后移一个

                j = i + 1 #为了保证j只向后移一个

                length -= 1

            else:

                j += 1

                i += 1

        return len(nums)

 

class Solution:

    def removeElement(self, nums: List[int], val: int) -> int:

        length = len(nums)

        i = 0

        while i <= length-1:

            if nums[i] == val:

                nums.remove(val)

                length -=1 #移除元素后，指针位置保持不变

            else:

                i += 1

        return len(nums)

 

 

class Solution:

    def searchInsert(self, nums: List[int], target: int) -> int:

        #题目的要求是使用二分法（时间复杂度为 O(log n)）查找一个大于等于目标值的下标

        left = 0

        right = len(nums) - 1

        #进行特殊判断，如果target比全部数都大

        if nums[right] < target:

            return len(nums)

        while left < right:#如果填等于，就要死循环了

            mid = int(left + (right - left) / 2)

            if nums[mid] < target:

                left = mid + 1

            else:

                right = mid 

        return left