1.在python里,可以并列if,可以不写else
2.接17号的找不同
字典强制转为列表,是保留键还是值,列表可以强制转为字典吗
是可以的,操作如下:
1.字典强制转换为列表,只保留键:
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict)
print(my_list) #输出['a', 'b', 'c']
2.字典的值,强制转换为列表:
my_list = list(my_dict.values())
print(my_list) #输出[1, 2, 3]
3.也可以都:
my_list = list(my_dict.items())
print(my_list) #输出[('a', 1), ('b', 2), ('c', 3)]
4.列表转为字典:
my_list = ['a', 1, 'b', 2, 'c', 3]
my_dict = dict(zip(my_list[::2], my_list[1::2])) #从0到底,以2为隔断,从1到底,以2为隔断
print(my_dict) #输出{'a': 1, 'b': 2, 'c': 3}
3.zip的用法
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped)) # [(1, 'a'), (2, 'b'), (3, 'c')]
zipped = [(1, 'a'), (2, 'b'), (3, 'c')]
list1, list2 = zip(*zipped)
print(list1) #(1, 2, 3)
print(list2) #('a', 'b', 'c')
有点难理解,主要是形式感觉有点乱,之后有更多例子了再继续。
4.找不同
给定两个字符串 s 和 t ,它们只包含小写字母。
字符串 t 由字符串 s 随机重排,然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。
示例 1:
输入:s = “abcd”, t = “abcde”
输出:“e”
解释:‘e’ 是那个被添加的字母。
class Solution:
def findTheDifference(self, s: str, t: str) -> str:
s=sorted(s)+[' ']
t=sorted(t)
for c1,c2 in zip(s,t):
if c1!=c2:
return c2
sorted会按顺序排列,然后给s补一个空格,用zip打包,对比
class Solution:
def findTheDifference(self,s:str,t:str)->str:
diff= Counter(t)-Counter(s)
diff_list=list(diff)
return diff_list[0]
5.找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ,请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标(下标从 0 开始)。如果 needle 不是 haystack 的一部分,则返回 -1 。
示例 1:
输入:haystack = “sadbutsad”, needle = “sad”
输出:0
解释:“sad” 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ,所以返回 0 。
示例 2:
输入:haystack = “leetcode”, needle = “leeto”
输出:-1
解释:“leeto” 没有在 “leetcode” 中出现,所以返回 -1 。
第一种:库函数:
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
return haystack.find(needle)
第二种:带有判断的库函数:
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
return haystack.index(needle) if needle in haystack else -1
#也就是说
def strStr(self, haystack:str,needle:str)->int:
if needle in haystack:
return haystack.index(needle)
else
return -1
都能这样写了,那python也太自由了吧
6.重复的子字符串
已解答
简单
相关标签
相关企业
给定一个非空的字符串 s ,检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。
示例 2:
输入: s = “aba”
输出: false
class Solution:
def repeatSubstringPattern(self,s:str)->bool:
n=len(s)
for i in range (1,n//2+1):
if n%i==0:
if all(s[j]==s[j-i]for j in range(i,n)):
return True
return False
这个题有好几种写法,第二种方法很巧但是学不到什么东西,第三种方法是KMP算法,不是现在的我能去理解的东西,没必要。
PS1这个all很好,再看,相当于and的嵌套,KMP算法可以之后有机会了看
PS2all是所有都正确才正确,any是只要有一个正确那就正确
7.移动零,双指针
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
请注意 ,必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
n = len(nums)
left = right = 0
while right < n:
if nums[right] != 0:
nums[left], nums[right] = nums[right], nums[left]
left += 1
right += 1
代码逻辑:
1.上来如果是0,left不动,right向右走,找第一个非0数
2.上来如果是非0,left和right相等,交换,然后继续向右走
3.右遇到0直接跳过,right+1,左等着,右遇到非0数,进入交换,并给left+1
4.右到顶,说明已经没有非0数了,停。
8.罗马数字
class Solution:
def romanToInt(self, s: str) -> int:
hashtable={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
res=0
n=len(s)
i=0
while i<n:
if i<n-1 and hashtable[s[i]]<hashtable[s[i+1]]: #注意这里,先判断,不让超出
res+=hashtable[s[i+1]]-hashtable[s[i]]
i+=2
else:
res+=hashtable[s[i]]
i+=1
return res
这是一个非常好的哈希表的例子,而且用的也非常的好,没啥好说的。
9.交替存放(zip)
提示
给你两个字符串 word1 和 word2 。请你从 word1 开始,通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长,就将多出来的字母追加到合并后字符串的末尾。
返回 合并后的字符串
示例 1:
输入:word1 = “abc”, word2 = “pqr”
输出:“apbqcr”
解释:字符串合并情况如下所示:
word1: a b c
word2: p q r
合并后: a p b q c r
示例 2:
输入:word1 = “ab”, word2 = “pqrs”
输出:“apbqrs”
解释:注意,word2 比 word1 长,“rs” 需要追加到合并后字符串的末尾。
word1: a b
word2: p q r s
合并后: a p b q r s
class Solution:
def mergeAlternately(self, word1: str, word2: str) -> str:
ans = []
for x, y in zip_longest(word1, word2, fillvalue=''): #注意这里的fillvalue=''
ans.append(x)
ans.append(y)
return ''.join(ans)
这个题的逻辑是这样的,假设:
word1 = “abc”
word2 = “pq”
执行 zip_longest(“abc”, “pq”, fillvalue=‘’) 后会得到以下元组序列:
(‘a’, ‘p’)
(‘b’, ‘q’)
(‘c’, ‘’)
然后他是分别append的,也就是说,ap出来的时候就已经分别append进去了,bq是下一次循环进去的,最后用join把字符列表改成字符串
10.map函数的用法
先说背景,这个题是想从[1,2,3]先转实数,然后再转实数列表输出成[1,2,4],其中有几步非常的关键:
1.nums = ‘’.join(map(str, digits)) 给digits中的每个数先变成字符,然后再变串,后期通过强制转int就可以计算了
2.list(map(int, str(nums))) 给nums是实数,str(nums)变成数字字符串,map给每位都变成int,此时输出的话其实是124,然后list就变成了[1,2,4]
那我当时就想了,我直接list(124)行不行,实际是不行的,所以上面这种麻烦的步骤是必须要的。或者这样
nums = 124
ans = [int(digit) for digit in str(nums)]
print(ans) # 输出: [1, 2, 4]
11.二叉树的深度计算
class TreeNode:
def __init__(self,val=0,left=None,right=None):
self.val=val
self.left=left
self.right=right
class Solution:
def maxDepth(self,root:TreeNode)->int:
if not root:
return 0
left_depth=self.maxDepth(root.left)
right_depth=self.maxDepth(root.right)
return max(left_depth,right_depth)+1
代码逻辑:现在就假设只有两层,root=[1,2,3]那么带入第一次,self.maxDepth(root.left)带进去东西了,所以之后可以return 1,但是进去了以后,下一次迭代已经是空了,所以返回0,然后出来回到了第二层前面提到的return 1,然后再回到最开始的return 1+1
最小深度的代码如下:
class Solution:
def minDepth(self, root: TreeNode) -> int:
if not root:
return 0
# 计算左子树和右子树的最小深度
left_depth = self.minDepth(root.left)
right_depth = self.minDepth(root.right)
# 如果其中一个子树为空,则返回不为空的子树的深度+1
if not root.left or not root.right:
return left_depth + right_depth + 1
# 否则,返回左右子树中较小的深度,并加一
return min(left_depth, right_depth) + 1
这个代码多了一个if not root.left or not root.right: return left_depth + right_depth + 1,就改成最小深度了