有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
-示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
-示例 2: 输入: s = “rat”, t = “car” 输出: false
说明: 你可以假设字符串只包含小写字母。

1
2
3
4
5
6
7
8
9
10
11
class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        hash = [0] * 26
        for i in s:
            hash[ord(i) - ord('a')] += 1
        for t_ in t:
            hash[ord(t_) - ord('a')] -= 1
        for h in hash:
            if h != 0:
                return False
        return True

这道题的思路是：用一个长度为26的数组来存储每个字母出现的次数，遍历字符串s时，对应字母的位置加1，遍历字符串t时，对应字母的位置减1。最后遍历数组，
如果数组里面的元素都为0，说明两个字符串是字母异位词，返回True，否则返回False。
讲一下我觉得比较有意思的地方就是这个下标转化的方式，通过减去a的ascll值得到一个在0-25之间的下标，对应数组的位置，这样就可以统计每个字母出现的次数。（有点像凯撒密码，也算是一种哈希函数的实现）

两个数组的交集

题意：给定两个数组，编写一个函数来计算它们的交集。
T2题目案例
说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

1
2
3
4
5
6
7
8
9
10
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        hash_set = set()
        hash_list = set()
        for i in nums1:
            hash_set.add(i)
        for i in nums2:
            if i in hash_set:
                hash_list.add(i)
        return list(hash_list)

也是用哈希表来存储数组里面的元素，然后存放在集合里面，因为集合里面要求元素是唯一的，再把数组1里集合元素和数组2里元素进行对比，如果存在就放到另一个集合里面，
最后返回集合转换为列表即可。

快乐数

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

  • 示例：
    输入：19
    输出：true
    解释：
    1^2 + 9^2 = 82
    8^2 + 2^2 = 68
    6^2 + 8^2 = 100
    1^2 + 0^2 + 0^2 = 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution:
    def isHappy(self, n: int) -> bool:
        set_=set()
        while True:
            if n == 1:
                return True
            n = self.self_sum(n)
            if n in set_:
                return False
            else :
                set_.add(n)         
    def self_sum(self,n):   
        new_n = 0
        while n :
            n1 = n % 10
            n = n // 10
            new_n += n1 ** 2 
        return new_n

这道题的思路是：用一个集合来存储每次计算得到的结果，如果结果重复出现，说明进入了循环，不是快乐数。如果结果为1，说明是快乐数。
利用哈希表来存储每次计算的结果，一旦出现重复的结果，说明进入了循环，不是快乐数。

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

  • 示例:
    给定 nums = [2, 7, 11, 15], target = 9
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]
1
2
3
4
5
6
dir={}
      for i in range(len(nums)): #遍历数组
          if target-nums[i] not in dir: #如果目标值减去当前值不在字典中
              dir[nums[i]] = i
          else :
              return [dir[target-nums[i]],i]

这道题在我的第一篇blog有，感兴趣的可以去看看，这道题是哈希表里面map的应用