目录
题解二:用字典collections.defaultdict(int) 动态存储
242.有效的字母异位词
题目描述:
给定两个字符串 s
和 t
,编写一个函数来判断 t
是否是 s
的字母异位词。
注意:若 s
和 t
中每个字符出现的次数都相同,则称 s
和 t
互为字母异位词。
提示:
1 <= s.length, t.length <= 5 * 104
s
和t
仅包含小写字母
题解一:用列表[0] * 26 静态存储
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
s_cnt = [0] * 26
c_cnt = [0] * 26
for _, e in enumerate(t):
c_cnt[ord(e) - ord('a')] += 1
for _, a in enumerate(s):
s_cnt[ord(a) - ord('a')] += 1
return True if c_cnt == s_cnt else False
题解二:用字典collections.defaultdict(int) 动态存储
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
t_dict = collections.defaultdict(int)
l = 0
for i, e in enumerate(t):
t_dict[e] += 1
l += 1
for j, a in enumerate(s):
if t_dict[a] > 0:
t_dict[a] -= 1
l -= 1
elif t_dict[a] == 0:
return False
return True if l == 0 else False
349 两个数组的交集
题目描述:
给定两个数组 nums1
和 nums2
,返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
题解一:动态字典
时空效率低!
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
nums1_dict = collections.defaultdict(int)
ans = []
for i, e in enumerate(nums1):
e = str(e)
nums1_dict[e] += 1
for _, a in enumerate(nums2):
# a = str(a)
if nums1_dict[str(a)] > 0:
ans.append(a)
nums1_dict[str(a)] = 0
return ans
题解二:简单粗暴
时空效率差不多
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
res = []
for i, e in enumerate(nums1):
if e in nums2:
res.append(e)
return list(set(res))
题解三:排序加双指针(来自leetcode官方)
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
nums1.sort()
nums2.sort()
length1, length2 = len(nums1), len(nums2)
intersection = list()
index1 = index2 = 0
while index1 < length1 and index2 < length2:
num1 = nums1[index1]
num2 = nums2[index2]
if num1 == num2:
# 保证加入元素的唯一性
if not intersection or num1 != intersection[-1]:
intersection.append(num1)
index1 += 1
index2 += 1
elif num1 < num2:
index1 += 1
else:
index2 += 1
return intersection
202 快乐数
题目描述:
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为:对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和,然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。如果 可以变为 1,那么这个数就是快乐数。
如果 n 是快乐数就返回 True ;不是,则返回 False 。
示例:
输入:19
输出:true
解释:
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
题解一:快慢指针
注意非快乐数会进入一个固定的循环
class Solution:
def isHappy(self, n: int) -> bool:
slow, fast = n, n
#下面这个写法有问题,因为一开始输入的是slow == fast
# while fast != slow:
# slow = self.square_sum(slow)
# fast = self.square_sum(fast)
# fast = self.square_sum(fast)
while True:
slow = self.square_sum(slow)
fast = self.square_sum(self.square_sum(fast))
if slow == fast:
break
return fast == 1
def square_sum(self, num):
sum = 0
while num > 0:
sum += (num % 10) ** 2
num = num // 10
return sum
题解二:列表存储
class Solution:
def isHappy(self, n: int) -> bool:
l = []
while n not in l:
# 顺序反了,注意细节!!!
# n = self.square_sum(n)
# l.append(n)
l.append(n)
n = self.square_sum(n)
if n == 1:
break
return n == 1
def square_sum(self, num):
sum = 0
while num > 0:
sum += (num % 10) ** 2
num = num // 10
return sum
1 两数之和
题目描述:
给定一个整数数组 nums
和一个整数目标值 target
,请你在该数组中找出 和为目标值 target
的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
题解一:双指针(也就是暴力解法)
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
l = len(nums)
slow, fast = 0, 0
while slow < l and fast < l:
fast += 1
if nums[slow] + nums[fast] == target:
return [slow, fast]
if fast == l-1:
fast = slow + 1
slow += 1
题解二:哈希表(字典存储每个数字对应下标)
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
pos_dict = {}
for i, e in enumerate(nums):
if target - e in pos_dict.keys():
return [pos_dict[target - e], i]
pos_dict[e] = i
15 三数之和(为零)
题目描述:
给你一个整数数组 nums
,判断是否存在三元组 [nums[i], nums[j], nums[k]]
满足 i != j
、i != k
且 j != k
,同时还满足 nums[i] + nums[j] + nums[k] == 0
。请
你返回所有和为 0
且不重复的三元组。
注意:答案中不可以包含重复的三元组。
题解:排序加双指针
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
ans = []
# nums = nums.sort()
nums.sort()
if not nums:
return ans
l = len(nums)
# 不对,因为内部不一定会执行i++,死循环
# i = 0
# while i < l - 2:
for i in range(l - 2):
if i > 0 and nums[i] == nums[i - 1]: # Skip duplicates
continue
left, right = i + 1, l - 1
while left < right:
total = nums[i] + nums[left] + nums[right]
if total < 0:
left += 1
elif total > 0:
right -= 1
else:
ans.append([nums[i], nums[left], nums[right]])
#不对,若有好几个重复的呢?
# left = left + 2 if nums[left + 1] == nums[left] else left + 1
# right = right - 2 if nums[right - 1] == nums[right] else right - 1
while left < right and nums[left] == nums[left + 1]: # Skip duplicates
left += 1
while left < right and nums[right] == nums[right - 1]: # Skip duplicates
right -= 1
left += 1
right -= 1
return ans