代码随想录算法训练营第六天|242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

242.有效的字母异位词

题目链接;242.有效的字母异位词
思路；定义一个数组record用来上记录字符串s里字符出现的次数。把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。
代码如下：

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in s:
            # ord()返回字符的Unicode码
            record[ord(i) - ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -= 1
        for i in range(26):
            if record[i] != 0:
                # record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return False
        return True

• 时间复杂度: O(n)
• 空间复杂度: O(1)

学习时长
20分钟

349. 两个数组的交集

题目链接;349. 两个数组的交集

使用数组

思路：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序因为题目都限制了数值的大小，可以用数组来做哈希的题目。
代码如下：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        count1 = [0] * 1001
        count2 = [0] * 1001
        result = []
        for i in range(len(nums1)):
            count1[nums1[i]] += 1
        for j in range(len(nums2)):
            count2[nums1[j]] += 1
        for k in range(1001):
            if count1[k] * count2[k] > 0:
                result.append(k)
        return result

使用集合

代码如下：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

使用字典和集合

思路：创建一个字典table、一个字典res，将nums1中的元素作为字典table的key（nums1中的元素可能有重复的，map中的key不能重复，如果重复，会把相同key的value覆盖，但因为题目要求输出结果是惟一的，所以不影响输出结果），然后遍历nums2，判断table中是否有与nums2中的元素相同的key， 如果字典里存在与nums2中的元素相同的key，则说明该数是nums1与nums2交集中的数，将该数加入集合，并将table中的键值对删除，最后将list（res）返回
代码如下：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        table = {}
        # 将nums1中的元素作为字典的key
        for num in nums1:
            table[num] = table.get(num, 0) + 1  # dict.get(k)返回字典里键值为k的值（value）

        res = set()
        for num in nums2:
            if num in table:  # 如果字典里存在与nums2中的元素相同的key，则说明该数是nums1与nums2交集中的数
                res.add(num)
                del table[num]
        return list(res)

学习时长
1个小时

202. 快乐数

题目链接:202题. 快乐数
代码如下：

class Solution:
    def isHappy(self, n: int) -> bool:
        record = set()
        while True:
            n = self.get_sum(n)
            if n == 1:
                return True
            if n in record:
                return False
            else:
                record.add(n)
    def get_sum(self, n: int) -> int:
        new_sum = 0
        while n :
            n, r = divmod(n, 10) #divmod函数是Python的内置函数，它可以返回一个包含商和余数的元组。
            new_sum += r**2
        return new_sum

学习时长
20分钟

1. 两数之和

题目链接:1. 两数之和

使用字典

代码如下：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        for index,value in enumerate(nums): #enumerate()是python的内置函数,利用它可以同时获得索引和值
            if target-value in record:
                return [record[target-value],index]
            else:
                record[value] = index
        return []

使用集合

代码如下：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = set()
        for index, value in enumerate(nums):  # enumerate()是python的内置函数,利用它可以同时获得索引和值
            if target - value in seen:
                return [nums.index(target - value), index]
            else:
                seen.add(value)
        return []

暴力算法

 class Solution:
        def twoSum(self, nums: List[int], target: int) -> List[int]:
            for i in range(len(nums)):
                for j in range(i+1,len(nums)):
                    if nums[i] + nums[j] == target:
                        return [i,j]
           

学习时长
30分钟