代码随想录跟练第五天——LeetCode 242.有效的字母异位词，349. 两个数组的交集、第202题. 快乐数、1. 两数之和

242.有效的字母异位词

力扣题目链接(opens new window)

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

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in s:
            #并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[ord(i) - ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -= 1
        for i in range(26):
            if record[i] != 0:
                #record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return False
        return True

思路：

• 哈希表可以用来快速解决在数据结构中判断元素是不是存在 
• 本题思路在于将26个字母映射为数字0-26，定义一个数组用来存储s中各个字母出现的次数，然后用同样的方法来将t中字母出现的次数从存储了s字母次数的数组中减掉，for循环判断存储的数组中每个元素是否为0，如果为0说明s和t中字母出现的次数相等。

知识点：

• ord(i) - ord("a"): 计算字符 i 与字符 'a' 之间的偏移量。这个值会是一个从 0 到 25 的整数，分别对应 a 到 z。
• ord是 Python 内置的函数。它用于返回一个字符对应的 Unicode 码点（即 ASCII 码或 Unicode 编码）。换句话说，ord 函数接收一个字符作为参数，并返回该字符在 Unicode 标准中的整数表示。
• 'a' 对应的 Unicode 码点是 97。
• 'A' 对应的 Unicode 码点是 65。
• '1' 对应的 Unicode 码点是 49。
• 与 ord 函数相对的另一个内置函数是 chr，它用于将整数转换为对应的字符。

print(chr(97))  # 输出: 'a'
print(chr(65))  # 输出: 'A'
print(chr(49))  # 输出: '1'

349. 两个数组的交集

力扣题目链接(opens new window)

题意：给定两个数组，编写一个函数来计算它们的交集。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # return list(set(nums1) & set(nums2))
        count1 = [0]*1001
        count2 = [0]*1001
        result = []
        for i in range(len(nums1)):
            count1[nums1[i]] = 1
        for i in range(len(nums2)):
            count2[nums2[i]] = 1 
        for i in range(len(count2)):
            if count1[i] * count2[i] > 0:
                result.append(i)
        return result

思路：

• 如果用C++解，这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

  注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序

        关于set，C++ 给提供了如下三种可用的数据结构：

•  std::set
• std::multiset
• std::unordered_set

        std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用 unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

• 用python可以用字典，数组，集合，三种数据结构都可以：数组：主体思路为定义两个数组所有元素初始化为0，再定义一个数组存储交集，把两个列表中元素统计到数组中，比如列表：nums1 = [1,2,2,1], nums2 = [2,2]，在数组中统计为count1[1] = 1，count1[2] = 1，注意统计的是出现的元素，如果列表中没有重复的元素个数为3，那么count1中长度为3，（不统计重复元素）判断交集时判断两个数组中元素值相乘是否为0；字典和集合：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
    # 使用哈希表存储一个数组中的所有元素
        table = {}
        for num in nums1:
            table[num] = table.get(num, 0) + 1
        
        # 使用集合存储结果
        res = set()
        for num in nums2:
            if num in table:
                res.add(num)
                del table[num]
        
        return list(res)

集合 ：直接用&符号

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

知识点：

• 字典定义：

   table = {}

  集合定义用set（），数组定义用[]

• 增加元素： 数组添加元素result.append(i)；集合添加元素用 res.add(num)

 

第202题. 快乐数

力扣题目链接(opens new window)

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

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

class Solution:
    def isHappy(self, n: int) -> bool:
        seen = []
        while n not in seen:
            seen.append(n)
            n_new = 0
            n_str = str(n)
            for i in n_str:
                n_new += int(i)**2
            if n_new == 1:  # 这个if应该在for循环的外面如果在里面n_new有可能是单独数平方
                return True
            else:
                n = n_new
        return False
            # n = sum(int(i) ** 2 for i in str(n))

思路： 

• python做如何取n的每一位数做平方，可以先把n转化为str类型，然后取每一位，把每一位转化为int做平方，求和直接用sum函数，判断n是不是在之前的存储的求和数组中出现过，如果出现过说明有循环，如果没有将求和结果添加到存储的求和数组中。循环可以设置如果n不等于1就一直循环。

知识点：

• python可以实现将每一步集合在一起用函数嵌套起来：

class Solution:
    def isHappy(self, n: int) -> bool:
        seen = []
        while n != 1:
            n = sum(int(i) ** 2 for i in str(n))
            if n in seen:
                return False
            seen.append(n)
        return True

1. 两数之和

力扣题目链接(opens new window)

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = []
        for i ,num in enumerate(nums):
            com = target - num
            if com in seen:
                return [nums.index(com), i]
            seen.append(num)

思路：

• 需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。需要一个集合来存放遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，是否出现在这个集合。

• 初始化了一个空的字典 hashtable，用来存储 nums 中的元素值及其对应的索引。enumerate(nums) 同时遍历 nums 的索引和对应的元素值。对于每个元素，i 是索引，num 是元素的值。

• 假设当前遍历的元素 num 是组成目标和 target 的其中一个数，那么目标和的另一个数就是 target - num。
• 代码首先检查 target - num 是否已经存在于哈希表 hashtable 中（即在之前的遍历中是否已经看过这个数）。如果存在，说明已经找到了两个数，它们的和为 target，此时返回它们的索引。
• 通过 return [hashtable[target - num], i]，返回的是两个数在数组中的索引，其中 hashtable[target - num] 是之前存储的数的索引，i 是当前遍历到的数的索引。

知识点：

• enumerate（）

fruits = ['apple', 'banana', 'cherry']
for i, fruit in enumerate(fruits):
    print(i, fruit)

输出：

0 apple
1 banana
2 cherry

本题的enumerate中key是nums中的元素，value是元素下标

• 列表中的下标索引可以用index（）：nums.index(com)