242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例

输入: s = “anagram”, t = “nagaram”
输出: true

思路
1. 首先初始化一个长度为26的列表result，元素值为0；
2. 遍历s字符串，在对应位置上+1
3. 遍历t字符串，在对应位置上-1
4. 遍历result，若遇到非0元素，返回False，否则，返回True
代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.10
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/valid-anagram/

class Solution:
    """
    1. 首先初始化一个长度为26的列表result，元素值为0；
    2. 遍历s字符串，在对应位置上+1
    3. 遍历t字符串，在对应位置上-1
    4. 遍历result，若遇到非0元素，返回False，否则，返回True
    """

    def init_list(self, length=26):
        result = []
        for i in range(length):
            result.append(0)
        return result

    def isAnagram(self, s: str, t: str) -> bool:
        # 1. 首先初始化一个长度为26的列表result，元素值为0；
        result = self.init_list(length=26)
        # 2. 遍历s字符串，在对应位置上+1
        for ele in s:
            result[ord(ele) - ord('a')] += 1
        # 3. 遍历t字符串，在对应位置上-1
        for ele in t:
            result[ord(ele) - ord('a')] -= 1
        # 4. 遍历result，若遇到非0元素，返回False，否则，返回True
        for ele in result:
            if ele != 0:
                return False
        return True


if __name__ == '__main__':
    s = "anagram"
    t = "nagaram"
    solution = Solution()
    print(solution.isAnagram(s, t))

349.两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

思路

1. 使用set进行去重

代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.10
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/intersection-of-two-arrays/
from typing import List


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


if __name__ == '__main__':
    pass

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

思路
快乐数若不能变为1，则会出现无限循环，因此只要该元素出现了第二次，则返回False，否则最终返回True
1. 计算数字n每个位置的平方和
2. 将平方和加入到set集合中；若为1，则返回True；若出现重复，则返回False；继续循环
代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.10
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/happy-number/
class Solution:
    """
    快乐数若不能变为1，则会出现无限循环，因此只要该元素出现了第二次，则返回False，否则最终返回True
    1. 计算数字n每个位置的平方和
    2. 将平方和加入到set集合中；若为1，则返回True；若出现重复，则返回False；继续循环
    """

    def ele_square_sum(self, n: int) -> int:
        res = 0
        while n // 10 or n % 10:
            res += (n % 10) ** 2
            n = n // 10
        return res

    def isHappy(self, n: int) -> bool:
        res = set()
        while 1:
            n = self.ele_square_sum(n)
            if n == 1:
                return True
            if n in res:
                return False
            res.add(n)


if __name__ == '__main__':
    n = 19
    s = Solution()
    print(s.isHappy(n))

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

示例1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

思路
定义一个字典dict，{ele：index}格式，遍历数组，对每个ele，判断target-ele是否在字典中出现，若没有出现，则将ele和下标加入到字典里。题干描述会存在一个有效答案
代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.10
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/two-sum/
from typing import List


class Solution:
    """
    定义一个字典dict，{ele：index}格式，遍历数组，对每个ele，判断target-ele是否在字典中出现，若没有出现，则将ele和下标加入到字典里。
    并且会存在一个有效答案
    """
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dict = {}
        for i,ele in enumerate(nums):
            if target - ele not in dict:
                dict[ele] = i
            else:
                return [i,dict[target - ele]]


if __name__ == '__main__':
    pass