代码随想录day6---LeetCode 242.有效的字母异位词 & 349. 两个数组的交集&202. 快乐数 &1. 两数之和

1. LeetCode 242.有效的字母异位词

• 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
• 示例 1:
  输入: s = "anagram", t = "nagaram"
  输出: true
• 示例 2:
  输入: s = "rat", t = "car"
  输出: false
• 分析：准备暴力破解，在实现的时候想到可以使用java中string的replace，把取到的字符去除，来检查去除后的s和t的长度是否相等。应该是算投机取巧，没有联系到哈希表上，代码如下：

点击查看代码

public class Solution {

    public boolean isAnagram(String s, String t) {

        if(s.length()!=t.length()){
            return false;
        }
        boolean flag=true;
        while (s.length()>0){
            String tmp=s.charAt(0)+"";
            s=s.replaceAll(tmp,"");
            t=t.replaceAll(tmp,"");
            if(s.length()!=t.length()){
                flag=false;
                break;
            }
        }
        return flag;
             
    }
}

• 查看视频后，使用哈希表方法，代码如下：

点击查看代码

public class Solution {

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

2. LeetCode 349. 两个数组的交集

• 给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一的。我们可以 不考虑输出结果的顺序
• 示例 1：
  输入：nums1 = [1,2,2,1], nums2 = [2,2]
  输出：[2]
• 示例 2：
  输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
  输出：[9,4]
  解释：[4,9] 也是可通过的
• 分析:使用set

点击查看代码

import java.util.HashSet;
import java.util.Set;

public class Solution {

    public int[] intersection(int[] nums1, int[] nums2) {

        Set<Integer> set=new HashSet<Integer>();
        Set<Integer> resSet = new HashSet<Integer>();
        for(int num:nums1){
            set.add(num);
        }
        for (int num:nums2){
            if(set.contains(num)){
                resSet.add(num);
            }
        }
        Integer[] tmp=resSet.toArray(new Integer[resSet.size()]);
        int[] result=new int[tmp.length];
        for(int i=0;i<tmp.length;i++){
            result[i]=tmp[i];
        }
        return result;
    }
}

3. LeetCode 202. 快乐数

• 编写一个算法来判断一个数 n 是不是快乐数。
  「快乐数」 定义为：
  对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
  然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
  如果这个过程 结果为 1，那么这个数就是快乐数。
  如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

• 本来以自己的方法实现的，但还没完全理解到题意，没有用哈希表实现，代码如下：

点击查看代码

public class Solution {

    public boolean isHappy(int n) {

        int tmpResult=0;
        String tmpn=n+"";
        while (tmpResult!=1) {
            if((tmpResult!=0)&&(tmpResult<=4)){
                return false;
            }
            tmpResult=0;
            for (int i = 0; i < tmpn.length(); i++) {
                int tmp = Integer.parseInt(tmpn.charAt(i) + "");
                tmpResult += tmp * tmp;
            }
            tmpn=tmpResult+"";
        }
        return true;
    }
}

• 查看文章实现：

点击查看代码

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        while (n != 1 && !record.contains(n)) {
            record.add(n);
            n = getNextNumber(n);
        }
        return n == 1;
    }

    private int getNextNumber(int n) {
        int res = 0;
        while (n > 0) {
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

4. LeetCode 1. 两数之和

• 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
  你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
• 示例 1：
  输入：nums = [2,7,11,15], target = 9
  输出：[0,1]
  解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
• 示例 2：
  输入：nums = [3,2,4], target = 6
  输出：[1,2]
• 示例 3：
  输入：nums = [3,3], target = 6
  输出：[0,1]
• 代码如下

点击查看代码

import java.util.HashMap;
import java.util.Map;

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

        Map<Integer, Integer> map=new HashMap<Integer, Integer>();
        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 null;
    }
}