day6|242,349，202，1

day6 202自己不会做

242.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

本题有点像之前做过的水果篮的低配版，我自己的方法是，遍历两个字符串，map<Character,Integer>里存的就是每个字符出现的次数。

class Solution {
        public boolean isAnagram(String s, String t) {
            Map<Character, Integer> count1 = isCount(s);
            Map<Character, Integer> count2 = isCount(t);
            return count1.equals(count2);
        }

        public Map<Character,Integer> isCount(String s){
            Map<Character,Integer> map = new HashMap<>();
            for (int i = 0; i < s.length(); i++) {
                map.put(s.charAt(i),map.getOrDefault(s.charAt(i),0)+1);
            }
            return map;
        }
}

随想录提出的方法更巧妙，因为题中都是小写字母，所以可以构建一个长度为26的数组，每个数组的元素就代表是a到z出现的次数，这样S那里加得的，在t那里再减去，看最后的数组是不是每个都尉0.实现起来比较简单。

class Solution {
        public boolean isAnagram(String s, String t) {
            int[] arr = new int[26];
            for(int i = 0; i<s.length(); i++){
                arr[s.charAt(i) - 'a']++;
            }

            for(int i = 0; i<t.length(); i++){
                arr[t.charAt(i) - 'a']--;
            }
            for(int i = 0;i< arr.length;i++){
                if(arr[i] != 0){
                    return false;
                }
            }
            return true;
        }
}

349.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

依旧可以用上面那道题的解法，设定两个数组分别记录nums1和nums2的数的出现情况，如果这个数出现了，那么arr[nums[i]] = 1,若两个数组在同一索引均为1，则认为是重复的数。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
            int[] arr1 = new int[1001];
            int[] arr2 = new int[1001];
            for(int i = 0;i<nums1.length;i++){
                arr1[nums1[i]] = 1;
            }
            for(int i = 0;i<nums2.length;i++){
                arr2[nums2[i]] = 1;
                }
            ArrayList<Integer> list = new ArrayList();
            for(int i = 0;i<arr1.length;i++){
                if(arr1[i] == 1 && arr2[i] == 1){
                    list.add(i);
                }
            }
            int[] newArr = new int[list.size()];
            for (int i = 0; i < newArr.length; i++) {
                newArr[i] = list.get(i);
            }
            return newArr;
        
    }
}

如果用hashset的方法，那么设定一个set1先记录nums1的数的出现情况，再设定一个set2，如果nums2里的数在set1里出现过，则认为这个数是交集数，set2进行add操作，返回数组。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        return resSet.stream().mapToInt(x -> x).toArray();
    }
}

202.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

这道题的关键在于，无限循环必然存在重复出现的数，所以只要判断一个数，它如果重复出现了，那么它就不是快乐数了。

class Solution {
    public boolean isHappy(int n) {
      HashSet<Integer> set = new HashSet<>();
            while(!set.contains(n)){
                set.add(n);
                n = resultGe(n);
            }
            if(n == 1){
                return true;
            }
            return false;

        }

    private static int resultGe(int n) {
            int result = 0;
            while(n != 0){
                int ge = n%10;
                n = n/10;
                result = ge*ge + result;
            }
            return result;
    }
}

1.两数之和力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

这个题我自己用的是最常规的方法，就是遍历数组，很明显时间复杂度等于 O(n2)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0;i<nums.length;i++){
            for(int j = i+1;j<nums.length;j++){
                if(nums[i] + nums[j] == target){
                    return new int[] {i,j};
                }
            }
        }
        return new int[] {0};
    }
}

如果用hash表法，那么可以从这个方向考虑：

class Solution {
    public int[] twoSum(int[] nums, int target) {
            Map<Integer,Integer> map = new HashMap<>();
            int[] res = new int[2];
            for(int i = 0; i< nums.length;i++){
                int a = nums[i];
                int b = target - a;
                if(map.containsKey(b)){
                    res[0] = i;
                    res[1] = map.get(b);
                }
                map.put(a,i);
            }
            return res;
    }
}