力扣题解-简单难度
不定时更新
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,就直接报错
