力扣题解-简单难度

不定时更新

1,两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

你可以按任意顺序返回答案。

我的解答:

时间复杂度为O(n^2)

def twoSum(self, nums: List[int], target: int) -> List[int]:
        
        dic = {i:v for i,v in enumerate(nums)}
        
        for i in dic:
            res = target-dic[i]
            for k in dic:
                if res == dic[k] and k!=i:
                    return i,k
 #解题中遇到的问题:
	1. list.index()如果列表中有相同元素,也只返回的第一个元素的索引
  2. enumerate()返回一个生成器,如果用两层循环去循环同一个生成器,那么内层循环不会从第一个元素开始
  3. 不能用列表的值做字典的key,除非你知道如何处理相同key值得覆盖问题

优质解答:

def twoSum(self, nums, target):

        hashmap = {}
        for index, num in enumerate(nums):
            another_num = target - num
            if another_num in hashmap:
                return [hashmap[another_num], index]
            hashmap[num] = index
        return None
特点:
  我的思路是用第一个数找第二个数,本答案思路是由第二个数找第一个数,一个集合中的元素内部有关系时都可以用此方法降低求解难度.

2,整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转

我的解答:

def reverse(self, x: int) -> int:
        
        _x = list(str(abs(x)))
        _x.reverse()   #这里没有必要用列表的reverse,还要拼接回来的,字符串和列表都可以用[::-1]反转
        num = int("".join(_x))
        tag = 2**31
        if x>0 and num <=tag-1:
            return num
        elif x <0 and num <=tag:
            return -num
        else:
            return 0

优质解答:

def reverse(self, x: int) -> int:
        a = str(x) if x>0 else str(-x)+'-'
        a = int(a[::-1])
        return a if a <= 2**31-1 and a >= -2**31-1 else 0

3,回文数

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

我的解答:

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

优质解答:

def isPalindrome(self, x: int) -> bool:
        return True if str(x) == str(x)[::-1] else False
  
  #解析:字符串也能比是否相等,先转成字符串反转再转int比较多此一举

4,罗马数组转数字

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

我的解答:一遍过

def romanToInt(self, s: str) -> int:
        dic = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        res = 0
        i = 0
        while i <len(s)-1:
        
            item = s[i]
            next_item = s[i+1]
            if dic[item]<dic[next_item]:
                res-=dic[item]
            else:
                res += dic[item]
            i+=1
        res += dic[s[i]]
        return res
      #思路:左边小与右边减,左边大于右边加上

5,最大公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

我的答案:

def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs or '' in strs :
            return ''
        if len(strs) == 1:
            return strs[0]

        res = []
        for i in range(len(strs[0])):
            s = strs[0][0:i+1]
            for item in strs:
                if not item.startswith(s):
                    break
            else: #代码走到这说明上面的循环是正常结束的
                res.append(s)
                continue #这个continue是用来控制外层循环的,跳过下面的代码break直接进入下次循环
            break #如果内层循环是正常结束的这个break永远都不会执行
        if res:
            return res[-1]
        return ''
      #暴力求解双循环的控制,内层循环结束整个循环结束rhe控制

优质答案:

def longestCommonPrefix(strs) :
    res = ""
    r = zip(*strs)
    print(r)
    for tmp in zip(*strs):
        tmp_set = set(tmp)
        if len(tmp_set) == 1:
            res += tmp[0]
        else:
            break
    return res

  #1.zip函数的特点,zip可以打包多个对象,循环zip对象得到元组

6,有效的括号

我的解答:超过了98.8%的python

def isValid(self, s: str) -> bool:
        dic = {'(':')','{':'}','[':']'}
        lifo = []
        for i in range(len(s)):
            if not lifo:
                lifo.append(s[i])
            else:
                try:
                    if not dic[lifo[-1]] == s[i]:
                        lifo.append(s[i])
                    else:
                        lifo.pop()
                except:
                    return False

        return False if lifo else True

能配对的话一定是一左配一右,按这个规律存入字典里
循环字符串,不匹配就加到列表里,能匹配就删除列表的最后一个元素
循环结束后列表内没有元素就返回true
如果出现右括号在前,字典内没有这个key,就直接报错