这里写目录标题
- 一、217. 存在重复元素
- 二、219. 存在重复元素 II
- 三、242. 有效的字母异位词
- 四、268. 丢失的数字
- 五、290. 单词规律
- 六、349. 两个数组的交集
- 七、350. 两个数组的交集 II
一、217. 存在重复元素
简单
给你一个整数数组 nums 。如果任一值在数组中出现至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。
示例 1：
输入：nums = [1,2,3,1]
输出：true
示例 2：
输入：nums = [1,2,3,4]
输出：false
示例 3：
输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true
def func217(nums):
return len(set(nums))!=len(nums)
nums=[1,2,3,4]
print(func217(nums))
二、219. 存在重复元素 II
简单
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
示例 1：
输入：nums = [1,2,3,1], k = 3
输出：true
示例 2：
输入：nums = [1,0,1,1], k = 1
输出：true
示例 3：
输入：nums = [1,2,3,1,2,3], k = 2
输出：false
class Solution:
def func219(self,nums,k):
d={}
for i in range(len(nums)):
if nums[i] not in d:
d[nums[i]]=i
else:
if i - d[nums[i]]<=k:
return True
else:
d[nums[i]]=i
return False
ss=Solution()
nums=[1,0,1,1]
k = 1
print(ss.func219(nums, k))
三、242. 有效的字母异位词
简单
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false
提示:
1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母
进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
from collections import Counter
from typing import List
def tt(s,t):
a1=Counter(s)
b1=Counter(t)
if a1==b1:
return True
else:
return False
s = "anagram"
t = "nagaram"
res=tt(s,t)
print(res)
四、268. 丢失的数字
简单
给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。
示例 1：
输入：nums = [3,0,1]
输出：2
解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。
示例 2：
输入：nums = [0,1]
输出：2
解释：n = 2，因为有 2 个数字，所以所有的数字都在范围 [0,2] 内。2 是丢失的数字，因为它没有出现在 nums 中。
示例 3：
输入：nums = [9,6,4,2,3,5,7,0,1]
输出：8
解释：n = 9，因为有 9 个数字，所以所有的数字都在范围 [0,9] 内。8 是丢失的数字，因为它没有出现在 nums 中。
示例 4：
输入：nums = [0]
输出：1
解释：n = 1，因为有 1 个数字，所以所有的数字都在范围 [0,1] 内。1 是丢失的数字，因为它没有出现在 nums 中。
class Solution1:
def test1(self,nums):
res=sum(range(len(nums)+1))-sum(nums)
return res
nums =[0]
s=Solution1()
res=s.test1(nums)
print(res)
五、290. 单词规律
简单
给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。
示例1:
输入: pattern = “abba”, s = “dog cat cat dog”
输出: true
示例 2:
输入:pattern = “abba”, s = “dog cat cat fish”
输出: false
示例 3:
输入: pattern = “aaaa”, s = “dog cat cat dog”
输出: false
class Solution:
def func(self,pattern,s):
ss=s.split()
d={}
for i in range(len(pattern)):
if pattern[i] not in d:
if ss[i] in d.values():
return False
else:
d[pattern[i]]=ss[i]
else:
if d[pattern[i]]!=ss[i]:
return False
return True
r=Solution()
pattern = "aaaa"
s = "dog cat cat dog"
print(r.func(pattern, s))
六、349. 两个数组的交集
简单
给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的
class Solution:
def func349(self,nums1,nums2):
nums1.sort()
nums2.sort()
i=0
j=0
res=[]
while i<len(nums1) and j<len(nums2):
if nums1[i]<nums2[j]:
i+=1
elif nums1[i]>nums2[j]:
j+=1
else:
if nums1[i] not in res:
res.append(nums1[i])
i+=1
j+=1
return res
s=Solution()
nums1 = [4,9,5]
nums2 = [9,4,9,8,4]
print(s.func349(nums1, nums2))
七、350. 两个数组的交集 II
简单
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
示例 2:
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]
class Solution:
def func349(self,nums1,nums2):
nums1.sort()
nums2.sort()
i=0
j=0
res=[]
while i<len(nums1) and j<len(nums2):
if nums1[i]<nums2[j]:
i+=1
elif nums1[i]>nums2[j]:
j+=1
else:
res.append(nums1[i])
i+=1
j+=1
return res
s=Solution()
nums1 = [4,9,5]
nums2 = [9,4,9,8,4]
print(s.func349(nums1, nums2))
