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

• 前言
  状态：全部可以 AC。看了解析之后，242、202 可再优化。

• 更新

24.05.23 初始记录

初步题解

242 有效的字母异位词

题目链接：(https://leetcode.cn/problems/valid-anagram/description/)

public class LE242 {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        String s = scanner.nextLine();  
        String t = scanner.nextLine();  
        System.out.println(isAnagram(s, t));  
    }  
  
    /**  
     * 思路：  
     * 1.用map接收每个字符出现的次数  
     * 2.比较次数是否相同  
     */  
    public static boolean isAnagram(String s, String t) {  
        char[] charsS = s.toCharArray();  
        char[] charsT = t.toCharArray();  
  
        HashMap<String, Integer> numMapS = getNumMap(charsS);  
        HashMap<String, Integer> numMapT = getNumMap(charsT);  
  
        if (numMapS.size() != numMapT.size()) {  
            return false;  
        }  
        for (String key : numMapS.keySet()) {  
            if (!numMapS.get(key).equals(numMapT.get(key))) {  
                return false;  
            }  
        }  
        return true;  
    }  
  
    /**  
     * 获取每个字符的数量  
     * @param charsS 字符串  
     * @return 每个字符的数量  
     */  
    private static HashMap<String, Integer> getNumMap(char[] charsS) {  
        HashMap<String, Integer> map = new HashMap<>();  
        for (char c : charsS) {  
            if (map.containsKey(String.valueOf(c))) {  
                map.put(String.valueOf(c) , map.get(String.valueOf(c)) + 1);  
            } else {  
                map.put(String.valueOf(c), 1);  
            }  
        }  
        return map;  
    }  
}

349 两个数组的交集

题目链接：(https://leetcode.cn/problems/intersection-of-two-arrays/description/)

public class LE349 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] nums1 = Arrays.stream(scanner.nextLine().split(",")).filter(Objects::nonNull).mapToInt(Integer::parseInt).toArray();
        int[] nums2 = Arrays.stream(scanner.nextLine().split(",")).filter(Objects::nonNull).mapToInt(Integer::parseInt).toArray();
        int[] intersection = intersection(nums1, nums2);
    }

    public static int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> intersection = new HashSet<>();
        for (int i : nums1) {
            set.add(i);
        }
        for (int i : nums2) {
            if (set.contains(i)) {
                intersection.add(i);
            }
        }

        return intersection.stream().filter(Objects::nonNull).mapToInt(i -> i).toArray();
    }
}

202 快乐数

题目链接：(https://leetcode.cn/problems/happy-number/description/)

public class LE202 {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        String s = scanner.nextLine();  
        System.out.println(isHappy(Integer.parseInt(s)));  
    }  
  
    /**  
     * 思路：放到set中，重复或者为1，跳出循环  
     * @param n 数  
     * @return 是否是快乐数  
     */  
    public static boolean isHappy(int n) {  
        HashSet<Integer> set = new HashSet<>();  
        String num = n + "";  
        set.add(n);  
        while (true) {  
            int sum = 0;  
            for (int i = 0; i < num.length(); i++) {  
                sum += Math.pow(Integer.parseInt(num.charAt(i) + ""), 2);  
            }  
  
            if (sum == 1) {  
                return true;  
            }  
  
            if (set.contains(sum)) {  
                return false;  
            }  
            num = sum + "";  
            set.add(sum);  
        }  
    }  
}

1 两数之和

题目链接：(https://leetcode.cn/problems/two-sum/)

public class LE1 {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int[] nums = Arrays.stream(scanner.nextLine().split(",")).filter(Objects::nonNull).mapToInt(Integer::parseInt).toArray();  
        int target = Integer.parseInt(scanner.next());  
        twoSum(nums, target);  
    }  
  
    /**  
     * 暴力解法肯定是循环两遍  
     * 但是这题放在哈希表专题里，就应该哈希表也能解决  
     * 用值为key，下标为value放入map  
     */    
     public static int[] twoSum(int[] nums, int target) {  
        HashMap<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};  
            }  
            map.put(nums[i], i);  
        }  
  
        return null;  
    }  
}

看讲解

242 有效的字母异位词

题目链接/文章讲解/视频讲解：(https://programmercarl.com/0242.有效的字母异位词.html)

/**  
 * 优化：  
 * 改为定义数组去接收数值（其实和map是一样的思想，但是这样代码量更少）  
 * 改为第二次遍历，在原数组上直接--（空间用得更少了）  
 */  
public static boolean isAnagram1(String s, String t) {  
    int[] record = new int[26];  
  
    for (int i = 0; i < s.length(); i++) {  
        record[s.charAt(i) - 'a']++;  
    }  
  
    for (int i = 0; i < t.length(); i++) {  
        record[t.charAt(i) - 'a']--;  
    }  
  
    for (int count : record) {  
        if (count != 0) {  
            return false;  
        }  
    }  
    return true;  
}

349 两个数组的交集

题目链接/文章讲解/视频讲解：(https://programmercarl.com/0349.两个数组的交集.html)

202 快乐数

题目链接/文章讲解：(https://programmercarl.com/0202.快乐数.html)

// 可以再优化，一个数各个位数平方求和
while (n > 0) {  
    int temp = n % 10;  
    sum += temp * temp;  
    n = n / 10;  
}

1 两数之和

题目链接/文章讲解/视频讲解：(https://programmercarl.com/0001.两数之和.html)