代码随想录算法训练营第六天

242. 有效的字母异位词

题目链接：有效的字母异位词

内置函数

之前做的时候非常的粗暴直接拿了python的内置函数来写的，就非常的懒。

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        #return sorted(s) == sorted(t)
        return Counter(s) == Counter(t)

哈希

重新考虑哈希法。
我自己的想法是给两个字符串做一个计数的哈希，其实就是自己把内置函数Counter(s)写了一遍，可能办法不是很好，但效果还可以。

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t):
            return False
        d1 = {}
        d2 = {}
        for i in s:
            if i not in d1:
                d1[i] = 1
            else:
                d1[i] += 1
        for i in t:
            if i not in d2:
                d2[i] = 1
            else:
                d2[i] += 1
        return d1 == d2

注意，这里可以用defaultdict(int)来创建哈希，就不用和我的代码一样先判断有没有这个元素了，因为defaultdict如果没有这个key也会创建一个然后赋值为0

349. 两个数组的交集

题目链接：两个数组的交集

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        l = []
        for i in range(len(nums1)):
            if (nums1[i] in nums2) and (nums1[i] not in l):
                l.append(nums1[i])
        return l

Set()

可以直接用个set，set可以的到一个去重之后的列表。
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
添加元素用set.add()如果元素已经存在，则不报错，也不会添加,不会将字符串拆分成多个元素，去别update。
使用set.update添加一些元组列表，字典等，但不能是字符串，否则会拆分。
set.remove和set.discard都是移除函数但是discard如果没有不会报错。
set.pop() 在list里默认删除最后一个，在set里随机删除一个。

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

202. 快乐数

题目链接：快乐数
题目解析：快乐数
这道题的重点其实是可能会无限循环，意思是求和的过程中，有一些sum会重复出现，当开始重复时，那么就开始无限循环了，这一点真的很难想到。

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        def happy_sum(n):
            n = str(n)
            sum = 0
            for i in n:
                sum += int(i)**2
            return sum
        
        l = []
        while 1:
            n = happy_sum(n)
            if n == 1:
                return True
            elif n in l:
                return False
            l.append(n)

1. 两数之和

暴力解法

题目链接：两数之和
以前就写过一个暴力解，能跑通但比较慢。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        d = len(nums)-1
        for i in range(d):
            for j in range((i+1),(d+1)):
                s = nums[i]+nums[j]
                if s == target:
                    return [i,j]

哈希

这道题，哈希表是用来存放我们遍历过得元素的。
例子：[2,7,3,6], target=9
hash = {}
首先走到2，去哈希表里找一找我们有没有走过7=9-2，没有；
那么把2存进哈希表里，然后去下一个7；
走到7，去哈希表里找一找有没有2=9-7，有，停下return
这里的重点是表里的元素不重复，并不会出现哈希冲突，所以key是元素，value是索引。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        h = {}
        for i in range(len(nums)):
            if target - nums[i] in h:
                return [h[target - nums[i]],i]
            h[nums[i]] = i
        return []