242. 有效的字母异位词

如果长度不同则肯定为false

声明长度为26的数组，如果s中出现则对应位置+1，t中出现则-1，最后遍历数组，如果都是0则返回true，否则false

 1 class Solution {
 2 public:
 3     bool isAnagram(string s, string t) {
 4         if(s.size() != t.size())    return  false;
 5         int arr[26];
 6         for(int i = 0; i < s.size(); i++){
 7             char sc = s[i];
 8             char tc = t[i];
 9             arr[sc-'a']++;
10             arr[tc-'a']--;
11         }
12         for(int i = 0; i < 26; i++){
13             if(arr[i] != 0) return false;
14         }
15         return true;
16     }
17 };

349. 两个数组的交集

声明一个set，用于去重，然后遍历nums2，如果nums1中存在nums2里的数字，则加入到set中

 1 class Solution {
 2 public:
 3     vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
 4         unordered_set<int> set;
 5         unordered_set<int> tmp(nums1.begin(),nums1.end());
 6         for(int i = 0; i < nums2.size(); i++){
 7             if(tmp.find(nums2[i]) != tmp.end()){
 8                 set.insert(nums2[i]);
 9             }
10         }
11         return vector<int>(set.begin(),set.end());
12     }
13 };

202. 快乐数

声明一个set，开始循环计算，如果结果为1则跳出循环，返回true。每次的结果对比set，如果set中存在则说明循环计算，则返回false

 1 class Solution {
 2 public:
 3     bool isHappy(int n) {
 4         unordered_set<int> set;
 5         set.insert(n);
 6         while(1){
 7             int sum = 0;
 8             while(n){
 9                 int tmp = n%10;
10                 sum+=tmp*tmp;
11                 n/=10;
12             }
13             if(sum == 1)    break;
14             if(set.find(sum)!=set.end()){
15                 return false;
16             }else{
17                 set.insert(sum);
18             }
19             n = sum;
20         }
21         return true;
22     }
23 };

1. 两数之和

声明一个map，key为需要的目标数，value为当前索引，遍历数组，如果map中的key存在当前数字，则返回value和当前索引，否则map中insert(index,target-nums[i])

 1 class Solution {
 2 public:
 3     vector<int> twoSum(vector<int>& nums, int target) {
 4         unordered_map<int, int> map;
 5         for(int i = 0; i < nums.size(); i++){
 6             if(map.find(nums[i]) != map.end()){
 7                 return {map[nums[i]],i};
 8             }
 9             map.insert(pair<int,int>(target-nums[i],i));
10         }
11         return {};
12     }
13 };