Day6|242.有效的字母异位词， 349. 两个数组的交集， 202. 快乐数 ， 1. 两数之和

242.有效的字母异位词代码随想录

用减法运算把字符映射成index，在该char对应的index处记录其总共出现的次数

细节，java里字符串对象的length（）是方法故加（），数组的length是成员变量，不用（）

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] hash = new int[26];
        for(int i = 0; i < s.length(); i++){
            int index = s.charAt(i) - 'a';
            hash[index]++;
        }
        for(int i = 0; i < t.length(); i++){
            int index1 = t.charAt(i) - 'a';
            hash[index1]--;
        }
        for(int i = 0; i < hash.length; i++){
            if(hash[i] != 0){
                return false;
            }
        }
        return true;
    }
}

 349. 两个数组的交集代码随想录

遍历nums1，存入set，遍历nums2时检测是否在set里出现过，出现过就存入resSet，

for each在完全遍历数组集合时很方便

法1 用set

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> numsSet = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        for(int num : nums1){//for(int i = 0; i < t.length; i++)
            numsSet.add(num);
        }
        for(int num : nums2){
            if(numsSet.contains(num)){//contains(Object);
                resSet.add(num);
            }
        }
        return resSet.stream().mapToInt(Integer :: intValue).toArray();//stream()
    }
}

法2用数组

用两个recordhash数组记录有没有出现，出现翻值为1，当两个recordhash同时为1时加入动态数组

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash = new int[1001];
        int[] hash2 = new int[1001];
        for(int num : nums1){
            hash[num] = 1;
        }
        for(int num : nums2){
            hash2[num] = 1;
        }
        List<Integer> resList = new ArrayList<>();
        for(int i = 0; i < 1001; i++){
            if(hash[i] == 1 && hash2[i] == 1){
                resList.add(i);
            }
        }
        return resList.stream().mapToInt(Integer :: intValue).toArray();
    }
}

 202. 快乐数 代码随想录

对于一个多位数其得快乐数不可能是无限递增

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
       while(true){
           record.add(n);
           n = getSum(n);//这两条顺序很重要，加完原始值再更新n，如果添加x后直接上判断语句则始终return fasle
           if(n == 1){
               return true;
           }else if(record.contains(n)){
               return false;
           }
       }
    }
     int getSum(int n){
         int res = 0;
            while(n != 0){
                int temp = n % 10;
                res = temp * temp + res;//这种快乐数在3位数以上后快乐计算后数值变小，不会单调增增到无要么出现循环重复数字要么跌到1
                n = n / 10;
            }
            return res;
        }
}

 1. 两数之和 代码随想录

循环时寻找target与cur的差之前有没有出现过，要用map存遍历过的数值及其对应标号。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer , Integer> map = new HashMap<>();
        int i = 0;
        int[] res = new int[2];
        for(int num : nums){//也可用i < length循环
            int s = target - num;
            if(map.containsKey(s)){
                res[0] = map.get(s);
                res[1] = i;
                return res;
            }
            map.put(num , i);
            i++;
        }
        return res;
    }
}