【代码随想录—day_06】

242.有效的字母异位词 ：用数组作为哈希表来解决哈希问题

第一想法：用Couter，两次遍历，防止出现子串的情况，代码如下

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        c_s = Counter(s)
        c_t = Counter(t)
        flag_1,flag_2 = 1,1
        for k,v in c_s.items():
            if c_t[k] != v:
                flag_1 = 0
        for k,v in c_t.items():
            if c_s[k] != v:
                flag_2 = 0
        # print(c_s,c_t)
        if flag_1 and flag_2:
            return True
        else:
            return False

法二：先判断两个字符串的长度，再对分别使用计数器对比求解，这样只需一次遍历

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        flag  = True
        temp_s =  Counter(s)
        temp_t = Counter(t)
        if len(s) != len(t):
            return False
        for k,v in temp_s.items():
            if v != temp_t[k]:
                flag = False
                break
            continue
        return flag

除了使用Couter计数器，还可以使用字典defaultdict学习链接：代码随想录—python法二

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        d_1 = defaultdict(int)
        d_2 = defaultdict(int)

        for _ in s:
            d_1[_] += 1
        for _ in t:
            d_2[_] += 1
        return d_1 == d_2

最妙的想法，具体思路如下：

1.定义一个大小为26的数组，初始化为0（因为字符a到字符z的ASCII也是26个连续的数值）用来记录字符串里字符出现的次数
2.遍历 字符串s，将 s[i] - ‘a’ 所在的元素做+1 操作，求出一个相对数值
3.再遍历字符串t，对t中出现的字符映射哈希表索引上的数值再做-1的操作
4.如果record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。否则，return true

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        hash_map = [0] * 26
        for _ in s:
            hash_map[ord(_) - ord('a')] += 1
        for _ in t:
            hash_map[ord(_) - ord('a')] -= 1
        for i in range(26):
            if hash_map[i] != 0:
                return False 
        return True

349. 两个数组的交集：通过set作为哈希表来解决哈希问题

第一想法：

记录nums2数组每个元素出现的次数，如果nums1中的元素在nums2中，泽江结果添加到nums1中

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = []
        n2 = defaultdict(int)
        for i in nums2:
            n2[i] += 1
        for i in nums1:
            if i in n2:
                ans.append(i)
                n2[i] -= 1
                if n2[i] == 0:
                    del n2[i]
        return list(set(ans))

法二：利用集合去重，一行代码

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

第202题. 快乐数

思路：对于每一次得到的快乐数，如果在之前出现过，就会陷入循环，无法得到1（不是快乐数），否则的话该数是快乐数
分成两部分：一个函数计算平方和，一个循环判断n，记录每次平方和得到的结果

class Solution:
    def isHappy(self, n: int) -> bool:
        def compute(x):
            ret = 0
            while x >= 10:
                temp = x % 10
                ret += temp ** 2
                x = x // 10
            ret += x ** 2
            return ret 
        hash_map = []
        while n != 1:
            ans = compute(n)
            # print(ans,hash_map)
            if ans not in hash_map:
                hash_map.append(ans)
                n = ans
            else:
                return False 
        return True

1. 两数之和

学习思路总结：

用一个字典来记录{‘值’：‘索引下标’}，一次遍历，判断每个元素的target-val是否在字典中，如果在字典中，则返回两数索引

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        records = dict()

        # 用枚举更方便，就不需要通过索引再去取当前位置的值
        for idx, val in enumerate(nums):
            if target - val not in records:
                records[val] = idx
            else:
                return [records[target-val],idx]  # 如果存在就返回字典记录索引和当前索引