第六天| 242.有效的字母异位词 ,349. 两个数组的交集 , 202. 快乐数,1. 两数之和

今天是hash table专题,主要涉及到三种数据结构: array, set和dictionary. 每当涉及到查找操作时,大概率就要用到hash table了.

242.有效的字母异位词

这道题涉及到比较问题,那最好的办法就是做处理比较

Way1:

直接通过dictionary Counter来计算每个字符在两个不同的字符串的数量,然后进行对比即可

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        dics=Counter(s)
        dict=Counter(t)
        return dics==dict

Way2:

不借助inner function, 在做完dictionary的定义之后分别遍历string 进行计算也可以

349. 两个数组的交集

这道题要去除重复项,所以选择用set是最好的

Way1:

首先分别对两个array生成set,然后遍历其中一个set,并判断数值是否在另一个set里面

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        n1=set(nums1)
        n2=set(nums2)
        res=[]
        for n in n1:
            if n in n2:
                res.append(n)
        return res

202. 快乐数

这道题需要察觉出为什么涉及到hash table. 重点在于sum的重复查找. 那很显然需要把每一次生成的值放到一个array里面即可

Way1:

直接用数字的%和**来剥离出每一位并且算出一个sum,之后把这个sum加到定义的array里面,并且判断知否之前出现过.同时看一下这个sum是不是1即可

class Solution:
    def isHappy(self, n: int) -> bool:
        def happy(x):
            tmp=0
            while x>=1:
                tmp+=(x%10)**2
                x//=10
            return tmp
        judge=[n]
        while n!=1:
            n=happy(n)
            if n in judge:
                return False
            judge.append(n)
        return True

Way2:

整体思路上没有太大变化,只是在计算值的方面可以利用一个string,但是涉及到类型转化,所以并不是一个很好的办法

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        check=[]
        def cal(num):
            tmp=0
            s=str(num)
            for ch in s:
                tmp=tmp+(int(ch))**2
            return tmp
        result=n
        while result:
            result=cal(result)
            if result in check:
                return False
            if result == 1:
                return True
            check.append(result)

1. 两数之和

这道题算是一道远古题了,详细分析了hash table之后我发现其实用dictionary或者array 都可以

Way1:

遍历数组,直接判断target-val是不是在这个数组内,同时这个值的index还不能是当前的index,后面这个判断条件是个很隐晦的需要探查出的点

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        result=[]
        for i in range(len(nums)):
            if target-nums[i] in nums and nums.index(target-nums[i])!=i:
                result.append(i)
                result.append(nums.index(target-nums[i]))
                return result

Way2:

选择用dic来记录值和index 之前的关系,并且判断target-val的值是否在dic里面.这种办法不用考虑index的判断,算是一种tradeoff

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