代码随想录算法训练营第6天| LeetCode 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

1.

242.有效的字母异位词

class Solution {
    public boolean isAnagram(String s, String t) {
        // // 如果两个字符串的长度不等 它们不能是字符异位词

        // if(s.length() != t.length()){
        //     return false;
        // }

        // // 初始化一个大小为26的数组来存储每个字符出现的次数
        // int[] counter = new int[26];

        // // 遍历每个字符串
        // for (int i = 0; i < s.length(); i++){
        //     // 对于字符串s中的字符 将对应的计数增加
        //     counter[s.charAt(i) - 'a']++;
        //     counter[t.charAt(i) - 'a']--;
        // }

        // // 检查计数器数组 如果有非零元素 说明两个字符串不是字母异位词
        // for(int count : counter){
        //     if(count != 0){
        //         return false;
        //     }
        // }

        // // 如果计数器数组的所有元素都是0 说明两个字符串是字母异位词
        // return true;

        if(s.length() != t.length()){
            return false;
        }

        int[] counter = new int[26];

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

        for(int j = 0 ;j < t.length(); j++){
            counter[t.charAt(j) - 'a']--;
        }

        for(int i = 0; i<26;i++){
            if(counter[i] != 0){
                return false;
            }
        }

        return true;
    }
}

1. 它首先检查两个字符串的长度是否相等。如果不是，它立即返回false，因为词必须具有相同数量的字符。

2. 它创建一个包含 26 个槽的计数器数组counter，每个槽对应英文字母表中的一个字母。

3. 第一个循环遍历字符串中的每个字符s并递增计数器数组中的相应槽。

4. 第二个循环遍历字符串中的每个字符t并递减计数器数组中的相应槽。

5. 最后的循环遍历计数器数组中的每个槽。s如果任何槽不为零，则意味着和的字符计数t与该字符不匹配，并且立即返回false。

6. 如果它遍历整个数组而没有找到非零槽，则返回true，表示s和t是异位词。

7. 最后的循环。它应该迭代计数器数组的 26 个槽（对于 26 个字母表）而不是字符串的长度s

2.

 349. 两个数组的交集 

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 创建一个集合用来存储nums1的唯一元素
        Set<Integer> set1 = new HashSet<Integer>();
        // 创建一个集合用来存储交集元素
        Set<Integer> set2 = new HashSet<Integer>();

        // 遍历nums1
        for(int i = 0; i< nums1.length; i++){
            set1.add(nums1[i]);
        }

        // 遍历nums2
        for(int i = 0; i< nums2.length; i++){
            if(set1.contains(nums2[i])){
                set2.add(nums2[i]);
            }
        }

        // 将set 转换为数组
        int[] result = new int[set2.size()];
        int i = 0;  

        for (Integer num : set2) {
            result[i++] = num;
        }

       return result;
    }
}

3.

202. 快乐数

class Solution {
    public boolean isHappy(int n) {
        // 创建一个 HashSet 来存储已经见过的数值
        Set<Integer> seen = new HashSet<>();
        // 这个循环会一直进行，直到 n 变为1或者发现一个无限循环（n的值开始重复）
        while (n != 1) {
            int current = n;
            int sum = 0;
            // 计算数字 n 的每一位的平方和
            while (current != 0) {
                sum += (current % 10) * (current % 10);  // 加上当前位上数字的平方
                current /= 10;  // 去掉最后一位
            }
            // 如果已经看到了这个 sum，那就意味着开始了一个无限循环，因此返回 false
            if (seen.contains(sum)) {
                return false;
            }
            // 否则，添加 sum 到 seen 集合中，并且将 n 设置为刚才计算的 sum
            seen.add(sum);
            n = sum;
        }
        // 如果跳出了循环，那就意味着 n 变成了1，因此返回 true
        return true;
    }
}

4.

1. 两数之和 

class Solution {
    public int[] twoSum(int[] nums, int target) {



        Map<Integer,Integer> map = new HashMap<>();
        
        for(int i = 0; i< nums.length; i++){
            if(map.containsKey(target- nums[i])){
                return new int[]{map.get(target - nums[i]), i};
            } else {
                map.put(nums[i],i);
            }
        }

        return new int[]{0};


    }
}