[组队学习]查找1------打卡
一、查找表
根据基本的数据结构
- 第一类： 查找有无–set
元素’a’是否存在，通常用set：集合
set只存储键，而不需要对应其相应的值。
set中的键不允许重复 - 第二类： 查找对应关系(键值对应)–dict
元素’a’出现了几次：dict–>字典
dict中的键不允许重复 - 第三类： 改变映射关系–map
通过将原有序列的关系映射统一表示为其他
题-349.两个数组的交集
给定两个数组，编写一个函数来计算它们的交集。
示例1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解题思路：由于本题的交集没有重复元素，所以可以将两个数组都通过set去重处理，然后遍历nums1中的元素，判断是否在nums2中，如果在，那么存进结果set中。
class Solution:def set_intersection(self, set1, set2):return [x for x in set1 if x in set2] def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:set1 = set(nums1)set2 = set(nums2) if len(set1) < len(set2):return self.set_intersection(set1, set2)else:return self.set_intersection(set2, set1)
题-350.数组的交集II
给定两个数组，编写一个函数来计算它们的交集。
示例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 intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:from collections import Counterif len(nums1) > len(nums2):return self.intersect(nums2,nums1)nums1_dict = Counter(nums1)relust = list()print(nums1_dict)for n in nums2:if nums1_dict[n] > 0:relust.append(n)nums1_dict[n] -= 1return relust
题-242.有效字母的异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词
示例1：
输入: s = “anagram”, t = “nagaram”
输出: true
示例2：
输入: s = “rat”, t = “car”
输出: false
解题分析：异位词就是指：两个字符串含有的字符种类和数量相同
因此，可以通过将两个字符串映射为“字符”–“数量”的字典，然后比较字典是否完全相同
class Solution:def isAnagram(self, s: str, t: str) -> bool:from collections import Counterreturn Counter(s) == Counter(t)
题-202.快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
12+92=821^2 + 9^2 = 8212+92=82
82+22=688^2 + 2^2 = 6882+22=68
62+82=1006^2 + 8^2 = 10062+82=100
12+02+02=11^2 + 0^2 + 0^2 = 112+02+02=1
解题分析：
这道题目思路很明显，当n不等于1时就循环，每次循环时，将其最后一位到第一位的数依次平方求和，比较求和是否为1。
难点在于，什么时候跳出循环？
例如：116的快乐数循环，当执行到58时，循环执行完一圈之后又回到了58.
所以，我们可以利用set不可重复的性质，把每次执行的结果放到set中，如果set中存在了那么就结束循环返回False。
还有一点，循环过程中的数，会不会越来越大，知道趋近于无穷呢？
答案是：不会！
| 位数 | 最大值 | 下一步的值 |
|---|---|---|
| 1 | 9 | 81 |
| 2 | 99 | 162 |
| 3 | 999 | 243 |
| 4 | 9999 | 324 |
| 13 | 9999999999999 | 1053 |
对于 3 位数的数字，它不可能大于 243。这意味着它要么被困在 243 以下的循环内，要么跌到 1。4 位或 4位以上的数字在每一步都会丢失一位，直到降到 3 位为止。所以我们知道，最坏的情况下，算法可能会在 243以下的所有数字上循环，然后回到它已经到过的一个循环或者回到 1。但它不会无限期地进行下去。
class Solution:def isHappy(self, n: int) -> bool:res = set()while n != 1:sumN = 0#对每个数的循环求结果while n > 0:temp = n % 10sumN += temp**2n = n // 10if sumN in res:return Falseelse: res.add(sumN)n = sumN return True
题-290.单词规律
输入: pattern = “abba”, str = “dog cat cat dog”
输出: true
示例2：
输入:pattern = “abba”, str = “dog cat cat fish”
输出: false
示例3：
输入: pattern = “aaaa”, str = “dog cat cat dog”
输出: false
示例4：
输入: pattern = “abba”, str = “dog dog dog dog”
输出: false
解题分析：
利用字典 ，pattern 的每个字母作为 key ，str 的每个单词作为 value 。第一次遇到的 key 就加入到 字典中，第二次遇到同一个 key，那就判断它的value 和当前单词是否一致。
例如：
pattern = "abba", str = "dog cat cat dog"a b b a
dog cat cat dog^i
第一次遇到 a, 加入到 字典dict
dict= {a:dog}a b b a
dog cat cat dog^i
第一次遇到 b, 加入到 dict
dict= {a: dog, b: cat}a b b a
dog cat cat dog^i
dict= {a: dog, b: cat}
第二次遇到 b, 判断 dict中 b 的 value 和当前的单词是否符合
符合的话继续判断, 不符合就返回 falsea b b a
dog cat cat dog^i
dict= {a: dog, b: cat}
第二次遇到 a, 判断 HashMap 中 a 的 value 和当前的单词是否符合
符合的话继续判断, 不符合就返回 false
遍历结束，返回 true
但是有一个问题是：没有考虑到顺序
例如：
pattern = “abba”
str = “dog dog dog dog”
解决方法：可以在新添加key的时候，判断这个key对应的value是否已经存在了，如果存在则不符合
class Solution:def wordPattern(self, pattern: str, str: str) -> bool:s = str.split(' ')if len(s)!= len(pattern):return Falsedic = {}#enumerate() --是将数组映射为 ‘下标’-‘元素’的字典for i,x in enumerate(s):if pattern[i] not in dic:if x in dic.values():return Falsedic[pattern[i]] = xelse:if x != dic[pattern[i]]:return Falsereturn True
第二种方法：
可以通过一个第三方来进行比较，对于pattern和str来说，每个字母或者单词第一次出现的位置(下标)是固定的，那么分别将 pattern和str映射为‘字母(单词)’-‘首次下标’的字典，比较映射后的字典是否相同。
这种解题方法和题-205.同构字符串相同
例如：
pattern = "abba", str = "dog cat cat dog"对于 abba
a -> 1
b -> 2
b -> 2
a -> 1
最终的得到的字符串就是 1221对于 dog cat cat dog
dog -> 1
cat -> 2
cat -> 2
dog -> 1
最终的得到的字符串就是 1221 最终两个字符串都映射到了 1221, 所以 str 符合 pattern
这样就既考虑了元素也考虑了顺序
class Solution:def wordPattern(self, pattern: str, str: str) -> bool:str = str.split()# str.index() 函数返回 要查询子串在str中的 开始索引值，如果不存在抛出Value异常。用法的str.find()相同return list(map(pattern.index,pattern)) == list(map(str.index,str))
二、对撞指针
审题思路：
1）数组是否是有序的？
2）数组从0开始还是从1开始？
3）对于无解的情况怎么处理？
4）对于多个解怎么处理？
…
题-1.两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解题分析：
1）最容易想到的是通过暴力法遍历数组求和判断，时间复杂度为O(n2)O(n^2)O(n2)
class Solution:def twoSum(self, nums: List[int], target: int) -> List[int]:len_nums = len(nums)for i in range(len_nums):for j in range(i+1,len_nums):if nums[i] + nums[j] == target:return [i,j]
2）排序+指针对撞(O(n)+O(nlogn)=O(n))
对原来的数组进行一次排序，排序后就可以用O(n)的指针对撞进行解决，但是，返回的是数字的索引，如果只是对数组的值进行排序，那么数组原来表示的索引的信息就会丢失，所以在排序前要进行些处理。
而且如果只是使用dict保存为‘元素’-‘下标’，就会造成相同元素被限制的情况。
所以可以通过拷贝一份原数组，对于两个相同元素的索引问题，使用一个bool型变量辅助将两个索引都找到，总的时间复杂度为O(n)+O(nlogn)=O(nlogn)O(n)+O(nlogn) = O(nlogn)O(n)+O(nlogn)=O(nlogn)
本题应该是必有正确的结果
class Solution:def twoSum(self, nums: List[int], target: int) -> List[int]:record = dict()nums_copy = nums.copy()sameFlag = True;nums.sort()l,r = 0,len(nums)-1while l < r:if nums[l] + nums[r] == target:breakelif nums[l] + nums[r] < target:l += 1else:r -= 1res = []for i in range(len(nums)):if nums_copy[i] == nums[l] and sameFlag:res.append(i)sameFlag = Falseelif nums_copy[i] == nums[r]:res.append(i)return res
可以通过 enumerate() 函数直接实现 ‘元素’-‘下标’的映射，进而不需要通过复制一份来解决重复元素问题。
def twoSum(nums, target):dict={}for ind,num in enumerate(nums):dict[num] = indfor i,num in enumerate(nums):j = dict.get(target - num)if j is not None and i!=j:return [i,j]
题-15.三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
解题分析：
开始想的是使用两层循环，以此遍历frist，second，third下标，判断是否符合条件。
但是有个问题是存在重复的元素，例如对示例的运行会产生如下结果：
[
[-1, 0, 1],
[0,1,-1] #重复结果
[-1, -1, 2]
]
然后，通过排序+双指针对撞的思路求解：
- 对数组进行排序。
- 遍历排序后数组：
1)若 nums[i]>0nums[i]>0nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 000，直接返回结果。
2)对于重复元素：跳过，避免出现重复解
3)令左指针$ L=i+1$，右指针 R=n−1R=n-1R=n−1，当 L<RL<RL<R 时，执行循环：- 当 nums[i]+nums[L]+nums[R]==0nums[i]+nums[L]+nums[R]==0nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,RL,RL,R移到下一位置，寻找新的解
- 若和大于 000，说明$ nums[R]$ 太大，R 左移
- 若和小于 000，说明 nums[L]nums[L]nums[L]太小，L 右移
class Solution:def threeSum(self, nums: List[int]) -> List[List[int]]:n=len(nums)res=[]if(not nums or n<3):return []nums.sort()res=[]for i in range(n-2):if(nums[i]>0): #排序之后，如果第一个数大于0了，那么往后就不存在结果了return resif(i>0 and nums[i]==nums[i-1]): #第二个数要跳过第一个数的重复值continueL=i+1R=n-1while(L<R): if(nums[i]+nums[L]+nums[R]==0): res.append([nums[i],nums[L],nums[R]])#在找到一个结果后， 以后遍历的数要跳过对应的重复值while(L<R and nums[L]==nums[L+1]):L=L+1while(L<R and nums[R]==nums[R-1]):R=R-1L=L+1R=R-1elif(nums[i]+nums[L]+nums[R]>0):R=R-1else:L=L+1return res
题-18.四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
解题分析：
本题是在三数之和的基础上，又增加的一个数字，解题思路和三数之和一样，首先排序。接着从[0,len−1]遍历i[0,len-1]遍历i[0,len−1]遍历i，跳过iii的重复元素，再在[i+1,len−1]中遍历j[i+1,len-1]中遍历j[i+1,len−1]中遍历j，得到i，ji，ji，j后，再选择首尾的L和RL和RL和R，通过对撞指针的思路，四数和大的话R−−R--R−−，小的话L++L++L++,相等的话纳入结果list，最后返回。
套用3Sum得代码，在其前加一层循环，对边界情况进行改动即可:
原来3个是到len-2,现在外层循环是到len-3;
在中间层得迭代中，当第二个遍历得值在第一个遍历得值之后且后项大于前项时，认定为重复；
加些边界条件判断：当len小于4时，直接返回。
class Solution:def fourSum(self, nums: List[int], target: int) -> List[List[int]]:n=len(nums)res=[]if(not nums or n<4):return []nums.sort()res=[]for i in range(n-3):if(i>0 and nums[i]==nums[i-1]): #第二个数要跳过第一个数的重复值continuefor j in range(i+1,n-2):if (j>i+1 and nums[j]==nums[j-1]):continueL=j+1R=n-1while(L<R): if(nums[i]+nums[j]+nums[L]+nums[R]==target): res.append([nums[i],nums[j],nums[L],nums[R]])#在找到一个结果后， 以后遍历的数要跳过对应的重复值while(L<R and nums[L]==nums[L+1]):L=L+1while(L<R and nums[R]==nums[R-1]):R=R-1L=L+1R=R-1elif(nums[i]+nums[j]+nums[L]+nums[R]>target):R=R-1else:L=L+1return res
题-16.最接近的三数之和
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
解题分析：
本题与三数之和的区别在于，不需要找出每一个符合的三元组，只需要返回一个结果即可。
那么在原三数之和的基础上，另外设置一个存储最接近结果的中间变量，当最接近的结果与target相等时，直接返回。如果遍历中存在三元组的和与target更接近，那么更新最接近的结果。最终返回最接近的结果。
class Solution:def threeSumClosest(self, nums: List[int], target: int) -> int:nums.sort()n=len(nums)close= abs(nums[0]+nums[1]+nums[2]-target)res = nums[0]+nums[1]+nums[2]for i in range(n-2):if(i>0 and nums[i]==nums[i-1]): #第二个数要跳过第一个数的重复值continueL=i+1R=n-1while(L<R):s = nums[i]+nums[L]+nums[R] if(s==target): return s#如果不相等，那么更新最接近的值if abs(s-target) < close:close = abs(s-target)res = sif(s>target):R=R-1else:L=L+1return res
题-454.四数之和II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得$ A[i] + B[j] + C[k] + D[l] = 0$。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 −228到228−1之间，最终结果不会超过231−1-2^{28} 到 2^{28} - 1 之间，最终结果不会超过 2^{31} - 1−228到228−1之间，最终结果不会超过231−1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:2
解释:
两个元组如下:
- (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
- (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
解题分析：
首先可以考虑把A数组中的元素都放入查找表，然后遍历后三个数组，判断target减去后三个数组每个元素值后 是否在查找表中存在，存在的话，把结果值加1。那么查找表的数据结构选择用set还是dict？考虑到数组中可能存在重复的元素，而重复的元素属于不同的情况，因此用dict存储，最后的结果值加上dict相应key的value。这样后面的遍历为三重循环，时间复杂度为:O(n)+O(n3)=O(n3)O(n)+O(n^3) = O(n^3)O(n)+O(n3)=O(n3)
那么dict中存两个数组之和，如AB。然后计算两个数组之和，如CD。时间复杂度为：O(n2)+O(n2)O(n^2)+O(n^2)O(n2)+O(n2),得到O(n2)O(n^2)O(n2)。
class Solution:def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:from collections import Counterdic = Counter()for i in range(len(A)):for j in range(len(B)):dic[A[i]+B[j]] += 1res = 0for i in range(len(C)):for j in range(len(D)):find_num = 0 - C[i] - D[j]if dic.get(find_num) != None:res += dic[find_num]return res
题-49.字母异位词分组
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例:
输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]
说明：
所有输入均为小写字母。
不考虑答案输出的顺序。
解题分析：
题目的意思，对异位词的进行分组，同异位词的分为一组，那么考虑对这一组内什么是相同的，且这个相同的也能作为不同组的判断条件。
不同组的判断条件，就可以用数据结构dict中的key来代表，那么什么相同的适合当作key呢？
这时回顾下下LeetCode 242，当时是因为异位字符串中包含的字符串的字母个数都是相同的，故把字母当作key来进行判断是否为异位词。
但是对于本题，把每个字符串的字母dict，再当作字符串数组的dict的key，显然不太合适，那么对于异位词，还有什么是相同的？
显然，如果将字符串统一排序，异位词排序后的字符串，显然都是相同的。那么就可以把其当作key，把遍历的数组中的异位词当作value，对字典进行赋值，进而遍历字典的value，得到结果list。
需要注意的细节是，字符串和list之间的转换：
- 默认构造字典需为list的字典；
- 排序使用sorted()函数，而不用list.sort()方法，因为其不返回值；
- 通过’’.join(list)，将list转换为字符串；
- 通过str.split(’,’)将字符串整个转换为list中的一项；
class Solution:def groupAnagrams(self, strs: List[str]) -> List[List[str]]:temp_dict={}for temp_str in strs:sort_str = self.HashMapFunc(temp_str)if sort_str in temp_dict:temp_dict[sort_str].append(temp_str)else:temp_dict[sort_str]=[temp_str]return list(temp_dict.values())def HashMapFunc(self, temp_str):return ''.join(sorted(list(temp_str)))
题-447.回旋镖的数量
给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。
找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。
示例:
输入:
[[0,0],[1,0],[2,0]]
输出:
2
解释:
两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
解题分析：
参考题解：
- 原始思路
题目的要求是：使得i,j两点的距离等于i,k两点的距离，那么相当于是比较三个点之间距离的，那么开始的思路就是三层遍历，i从0到leni从0到leni从0到len，j从i+1到len，k从j+1到lenj从i+1到len，k从j+1到lenj从i+1到len，k从j+1到len，然后比较三个点的距离，相等则结果数加一。
显然这样的时间复杂度为O(n3)O(n^3)O(n3)，对于这道题目，能否用查找表的思路进行解决优化？ - 查找表
之前的查找表问题，大多是通过构建一个查找表，而避免了在查找中再内层嵌套循环，从而降低了时间复杂度。那么可以考虑在这道题中，可以通过查找表进行代替哪两层循环。
当i,j两点距离等于i,k时，用查找表的思路，等价于：对距离key(i,j或i,k的距离)，其值value(个数)为2。
那么就可以做一个查找表，用来查找相同距离key的个数value是多少。遍历每一个节点i，扫描得到其他点到节点i的距离，在查找表中，对应的键就是距离的值，对应的值就是距离值得个数。
在拿到对于元素i的距离查找表后，接下来就是排列选择问题了：
- 如果当距离为x的值有2个时，那么选择j,k的可能情况有：第一次选择有2种，第二次选择有1种，为2*1；
- 如果当距离为x的值有3个时，那么选择j,k的可能的情况有：第一次选择有3种，第二次选择有2种，为3*2;
- 那么当距离为x的值有n个时，选择j,k的可能情况有：第一次选择有n种，第二次选择有n-1种。
距离 - 对于距离值的求算，按照欧式距离的方法进行求算的话，容易产生浮点数，可以将根号去掉，用差的平方和来进行比较距离。
class Solution:def numberOfBoomerangs(self, points: List[List[int]]) -> int:res = 0from collections import Counterfor i in points:record = Counter()for j in points:if i != j:record[self.dis(i,j)] += 1for k,v in record.items():res += v*(v-1)return resdef dis(self,point1,point2):return (point1[0]-point2[0]) ** 2 + (point1[1]-point2[1]) ** 2
[组队学习]查找1------打卡相关推荐
- leetcode组队学习——查找（一）
文章目录 方法:考虑的基本数据结构 例题 202. 快乐数 205. 同构字符串 242. 有效的字母异位词 290. 单词规律 349. 两个数组的交集 350. 两个数组的交集 II 451. 根 ...
- leetcode组队学习——查找（二）
文章目录 1.两数之和 15. 三数之和 16. 最接近的三数之和 18. 四数之和 454. 四数相加 II 49. 字母异位词分组 447. 回旋镖的数量 149. 直线上最多的点数 1.两数之和 ...
- 微信群，组队学习打卡
组队学习打卡.一年时间太长,我怕不能每天坚持学习,希望可以和有梦想的你每天来组队打卡学习以此培养出来一个好习惯!!! 为了保证群的质量,有以下群规需要遵守: 为了防止偷偷潜水,每人进群前必须交5元违约 ...
- Datewhale数据分析组队学习第一次打卡
**复习:**这门课程得主要目的是通过真实的数据,以实战的方式了解数据分析的流程和熟悉数据分析python的基本操作.知道了课程的目的之后,我们接下来我们要正式的开始数据分析的实战教学,完成kaggl ...
- 【组队学习】【第30期】青少年编程（Scratch 三级）
小朋友们大家好,我是本次组队学习的领航员-马燕鹏,欢迎大家参加<青少年编程(Scratch 三级)>航海活动. 今天的开营有两大环节: 1.「活动介绍」介绍我们这个活动的整体设计框架. 2 ...
- 组队学习：学习者参考手册
学习者参考手册 作为希望参与组队学习活动的学习者,一定想了解有关本次活动的各种环节.我就通过这份手册来给大家介绍一下. 本手册一共分为四个部分,分别是活动角色划分,活动流程介绍.打卡环节介绍.角色职责 ...
- 第8期Datawhale组队学习计划
第8期Datawhale组队学习计划马上就要开始啦 这次共组织15个组队学习,涵盖了AI领域从理论知识到动手实践的内容 按照下面给出的最完备学习路线分类,难度系数分为低.中.高三档,可以按照需要参加 ...
- 转发：Datawhale第七期组队学习计划
编者注:Datawhale是一个公益组织,也是AiUnion的四个成员之一,所有学习计划是免费的. 第7期Datawhale组队学习计划 马上就要开始啦 这次共组织15个组队学习 涵盖了AI领域从理论 ...
- Datawhale 暑期组队学习计划
Datawhale暑期组队学习计划 马上就要开始啦 这次共组织15个组队学习 涵盖了AI领域从理论知识到动手实践的内容 按照下面给出的最完备学习路线分类 难度系数分为低.中.高三档 可以按照需要参加 ...
最新文章
- python爬虫实验报告_python爬虫实验
- LVGL-v8.1 demo win32 VS2017工程
- linux C 列出目录中的文件列表 包含文件的相关信息
- 浓缩版java8新特性
- idea页面简单介绍
- 值计算公式_板式换热器选型，K值是关键点！
- Flume篇---Flume安装配置与相关使用
- 地推主管需要跑业务吗
- PMP考试参加培训一定能过吗？
- 通过duet软件实现ipad作为mac的副屏并修改分辨率
- VR/AR 技术学习园地
- RGB颜色对照表（全）
- 关于Java的位移运算
- CAN矩阵（入门篇）（史上最全）
- ISO26262第二版发布
- SpringBoot整合腾讯云COS对象存储实现文件上传
- 小波去噪处理音频\MFCC对比
- 目前计算机科学领域的前沿,计算机科学前沿热点及发展趋势
- 计算机专业系统文献,计算机系统参考文献
- matlab 不提示warning,matlab 打开后就显示的warning,要怎么解决