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

•  242.有效的字母异位词  ：利用数组的索引来当key ，索引用字母的ASCII码来表示 ；

•  349. 两个数组的交集 ： 利用两个set，set1存储数组1的元素，set2存储交集（存储set1存在的数组2的元素）；

•  202. 快乐数 ：判断有没有出现循环，即是否出现了set中记录过的结果；

•  1. 两数之和   ：用i遍历，把nums[i]加入map,在map里找target-nums[i]。
• 日期：2024. 4. 23

 242.有效的字母异位词

242. 有效的字母异位词

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

注意：若 s 和 t 中

每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

思路：用数组当哈希表 索引为字母的ASCII码 

1. 用数组的索引当key，索引用字母的ASCII码表示；
2. 遍历数组1的字母，增加数组里对应的key；
3. 遍历数组2的字母，减少数组里对应的key；
4. 遍历数组，如果有元素不为0，说明数组1和数组2并不完全重合，不是异位词，返回false，否则返回true。

class Solution {
    public boolean isAnagram(String s, String t) {
        //用数组的索引来当key 索引用字母的ASCII码表示
        int[] res = new int[26];
        int slen = s.length(); int tlen = t.length();

        for(int i = 0; i < slen; i++){
            res[s.charAt(i) - 'a'] ++;
        }

        for(int i = 0; i < tlen; i++){
            res[t.charAt(i) - 'a']--;
        }

        for(int cnt : res){
            if(cnt != 0){//差不为0，说明次数不相同
                return false;
            }
        }

        return true;
    }
}

 349. 两个数组的交集 

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的 交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

思路：使用两个set：一个set存储nums1所有元素，一个res存储nums2中元素与set1的元素的交集

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        Set<Integer> set = new HashSet<>();
        Set<Integer> res = new HashSet<>();
        for(int c : nums1){
            set.add(c);
        }

        for(int c : nums2){
            if(set.contains(c)){
                res.add(c);
            }
        }

        return res.stream().mapToInt(x -> x).toArray();
    }
}

 202. 快乐数 

202. 快乐数

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

「快乐数」 定义为：

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

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

 思路：重点是判断是否进入了无限循环（用set来记录出现过的结果，判断结果是否已经在set里记录过了，如果记录过了说明进入了死循环，不是快乐数）

1. 写getNextNumber函数，用来将该数替换为它每个位置上的数字的平方和。先令n%10获取个位上的数，再除以10取整，直到n不大于0，返回计算结果；
2. 创建一个set用来记录出现过的结果；
3. 若n不等于1且n不存在set中，就把这个n记录到set里，并计算平方和获得新的数字n；
4. 若n==1则是快乐数，会返回true  ；
5. 若n存在set里且不为1，说明进入了无限循环 ，返回false。

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();//记录结果数字，如果出现重复说明进入无限循环，不是快乐书
        while(n != 1 && !set.contains(n)){
            set.add(n);//把这个数字加入记录中
            n = getNextNumber(n);//获得下一个数字
        }
        return n == 1;
    }
    
    //进行计算得到下一个数字
    public int getNextNumber(int n){
        int sum = 0;
        while(n > 0){
            int num = n % 10;
            sum += num * num;
            n = n / 10;
        }
        return sum;
    }
}

1. 两数之和

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

思路：哈希表map

1. 创建一个map和结果数组res； 在该map中，key是数字，值是这个数字在nums里的索引。
2. for循环遍历nums，把元素放入map里；
3. 判断map里是否存在 key 为 target-nums[i]，如果存在就说明找到了答案，把 nums[i] 和map.get ( target - nums[i] ) 存入res，并退出循环。
4. 返回res

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        //在哈希表找target-数字1  key是数字.值是索引
        if(nums == null || nums.length == 0){
            return res;
        }
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[1] = i;
                res[0] = map.get(temp);
                break;//因为题目已经说了只会对应一个答案，所以得到答案后退出循环即可。
            }
            map.put(nums[i],i);//记录到map里
        }
        return res;
    }
}