leetcode打卡

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

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        from collections import Counter
        nums1_dict=Counter(nums1)
        res=[]
        for num in nums2:
            if nums1_dict[num]>0:
                res.append(num)
                nums1_dict[num]-=1
        return res

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        a={}
        b={}
        for i in s:
            a[i]=s.count(i)
        for j in t:
            b[j]=t.count(j)
        if a==b:
            return True
        else:
            return False

202

class Solution:
    def isHappy(self, n: int) -> bool:
        # 初始化 visited
        visited = set()
        # 当 n != 1，并且没见过 n 时进行判断
        while n != 1 and n not in visited:
            # 把 n 放入 visited
            visited.add(n)
            # 计算下一轮的数字
            nxt = 0
            # 计算 n 的各位数字平方和
            while n != 0:
                nxt += (n % 10) ** 2
                n //= 10
            # 把下一轮的数字设定为 n
            n = nxt
        # 判断 n 的最终结果是否为 1
        return n == 1

290

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        t = str.split()
        if len(pattern) != len(t):
            return False
        dct = {}
        for i in range(len(pattern)):
            if pattern[i] not in dct:
                if t[i] in dct.values():
                    return False
                dct[pattern[i]] = t[i]
            else:
                if dct[pattern[i]] != t[i]:
                    return False
        return True

205

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        if s=="":
            return True
        dic={}
        for i in range(len(s)):
            if s[i] not in dic:
                if t[i] not in dic.values():
                    dic[s[i]] = t[i]
                else:
                    return False
            else:
                if t[i]!=dic[s[i]]:
                    print(s[i],t[i])
                    return False
        return True

class Solution:
    def frequencySort(self, s: str) -> str:
        # 大顶堆
        countFrequency = collections.defaultdict(int)
        for i in s:
            countFrequency[i] += 1
        lst = []
        heapq.heapify(lst)
        for i in countFrequency:
            for j in range(countFrequency[i]):
                heapq.heappush(lst, (-countFrequency[i], i))
        
        return ''.join([heapq.heappop(lst)[1] for _ in range(len(s))])