代码随想录算法训练营第六天 | 有效的字母异位词、两个数组的交集、 快乐数 、两数之和

242. 有效的字母异位词

代码：

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in range(len(s)):
            record[ord(s[i]) - ord("a")] += 1 #要减去a的asc码才能对应到0-25
        for i in range(len(t)):
            record[ord(t[i]) - ord("a")] -= 1#要减去a的asc码才能对应到0-25
        for i in range(len(record)):
            if record[i] != 0:
                return false False
        return true True #在python中True和False才是标识符

349. 两个数组的交集

思路：首先，确定使用set和数组的区别，当数据很大的时候，数组的下标不能很大，无法使用数组，还有当数据相差很大的时候，使用数组会浪费资源和空间，所以使用map更好，这道题因为限制了数据的大小，所以也可以使用数组

代码：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))
把nums2和nums1变成set，再取交集，最后把得到的交集变成列表输出

202. 快乐数

python解法：

Python:
class Solution:
    def isHappy(self, n: int) -> bool:
        def getSum(num):
            sum = 0
            while(num):
                sum += (num % 10) * (num % 10)#错误：把num写成了n，这里应该是已经更新过的num
                num = num // 10
            return sum
        record = set()
        while True:
            n = getSum(n)
            if (n == 1):
                return True
            else:
                if n in record:
                    return False
                else:
                    record.add(n)

c++解法：

class Solution {
public:
    int getSum(int n) {
        int sum = 0;
        while(n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> record;
        while(1) {
            n = getSum(n);#在循环里，而不是在循环外，否则就只会算第一次的结果
            if(n == 1) return true;
            else{
                if (record.find(n) != record.end()) return false;
                else record.insert(n);
            }
        }
    }
};

1. 两数之和

python：

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

C++：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int, int> map;
        for(int i = 0; i < nums.size(); i++){
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()){
                return {iter -> second, i};#iter -> second的含义见右图
            }
            else{
                map.insert(pair<int, int>(nums[i], i));
            }
        }
        return {};
    }
};