242 有效的字母异位词(easy)

力扣地址

https://leetcode.cn/problems/valid-anagram/

题目描述

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

题目实例

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

解题思路

可以直接用map，然后再遍历map即可，但是纯字母的话，尤其纯大写，纯小写，只有大小写，一般都是用数组代替map，这样开销小，速度快。
题目已知全部都是小写字母，开辟一个26长度的数组，从头向后遍历，数组的下标表示字母，0对于a，以此类推，数组的值表示字母的个数。然后比较这两个数组即可。

代码实现

    public boolean isAnagram(String s, String t) {
        int[] sNum = new int[26];
        int[] tNum = new int[26];
        for (char ch : s.toCharArray()) {
            sNum[ch - 'a']++;
        }
        for (char ch : t.toCharArray()) {
            tNum[ch - 'a']++;
        }
        for (int i = 0; i < 26; i++) {
            if (sNum[i] != tNum[i]) {
                return false;
            }
        }
        return true;
    }

383 赎金信(easy)

力扣地址

https://leetcode.cn/problems/ransom-note/

题目描述

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

题目实例

输入：ransomNote = "a", magazine = "b"
输`出：false

解题思路

就是判断其中一个字符的字母的个数全部都大于等于另一个字符的字母的个数，至于业务意义别管了，又不是真的要去抢劫。

和242一样，用数组来代替map。可以跟上一个题一样，判断两个数组是不是其中一个的每一个字母的个数都大于等于另一个，但是这个可以只用一个数组即可。
初始状态：
将其中一个字符s按照数组进行组装。
下标是字母，数组值是个数。
过程状态：
遍历另一个字符串t，当遇到同样的就抵消掉，也就是数组的值–，如果数组的值小于0，那就说明组成不了。
结束状态：
过程状态没有返回false的话，那说明组成的了，返回true即可。

代码实现

    public boolean canConstruct(String ransomNote, String magazine) {
        int[] charArr = new int[26];
        for (int i = 0; i < magazine.length(); i++) {
            charArr[magazine.charAt(i) - 'a']++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            charArr[ransomNote.charAt(i) - 'a']--;
            if (charArr[ransomNote.charAt(i) - 'a'] < 0) {
                return false;
            }
        }
        return true;

    }

49 字母异位词分组(mid)

力扣地址

https://leetcode.cn/problems/group-anagrams/description/

题目描述

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

题目实例

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

解题思路

将每一个排序以后的是一样的划分成一组，然后返回即可。用stream的group by就行，就不需要手写了。

代码实现

    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> stringListMap = Arrays.stream(strs).collect(Collectors.groupingBy(item -> {
            char[] arr = item.toCharArray();
            Arrays.sort(arr);
            return String.valueOf(arr);
        }));
        return new ArrayList<>(stringListMap.values());
    }

438 找到字符串中所有字母异位词(mid)

力扣地址

https://leetcode.cn/problems/find-all-anagrams-in-a-string/description/

题目描述

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

题目实例

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

解题思路

依旧是两个数组表示两个字符串，下标是字母，下标对应的值是个数。
s是长串，p的短串
初始状态：
从0开始遍历到p，统计两个数组是不是一致的，一致的话，先把下标0加入
过程状态：
从p的长度位置开始遍历，下标 - p的长度的索引对应的字母个数–，下标对应的索引字符个数++，相当于一个固定的窗口，窗口左边弹出，个数–，窗口右边加入，个数++
理解成一个窗口 [x,y,z],g x,[y,z,g]这个时候就把x对应的个数–，g就要加加
结束状态：
返回统计的下标即可

代码实现

        List<Integer> res = new ArrayList<>();
        int sLen = s.length();
        int pLen = p.length();
        // 边界判断，如果s都没p长，怎么可能p是s的子串
        if (sLen < pLen) {
            return res;
        }

        int[] sMap = new int[26];
        int[] pMap = new int[26];

        for (int index = 0; index < pLen; index++) {
            sMap[s.charAt(index) - 'a']++;
            pMap[p.charAt(index) - 'a']++;
        }
        if (Arrays.equals(sMap, pMap)) {
            res.add(0);
        }
        
        for (int index = pLen; index < sLen; index++) {
            // 理解成一个窗口 [x,y,z],g  x,[y,z,g]这个时候就把x对应的个数--，g就要加加
            sMap[s.charAt(index - pLen) - 'a']--;
            sMap[s.charAt(index) - 'a']++;
            if (Arrays.equals(sMap, pMap)) {
                res.add(index - pLen + 1);
            }
        }
        return res;
    }

349 两个数组的交集(easy)

力扣地址

https://leetcode.cn/problems/intersection-of-two-arrays/description/

题目描述

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

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

题目实例

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

解题思路

解法一：实际开发建议选择朴实无华的。
用stream的fifter过滤掉包含nums2的即可
解法二：
值不会超过1000，那开个1001长的数组，把下标当这个值，下标的值当成个数即可。
开两个数组按照上面的初始化，然后遍历一遍，取两个数组值都大于0的加进结果集合即可。

代码实现

stream实现

    public int[] intersection(int[] nums1, int[] nums2) {
        // 实际这里肯定是list，用工具类判空
        if (nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0) {
            return null;
        }
         // 实际list转set
        Set<Integer> nums2Set = new HashSet<>();
        for (int item : nums2) {
            nums2Set.add(item);
        }
        Set<Integer> resSet = new HashSet<>();
        Arrays.stream(nums1).filter(nums2Set::contains).forEach(resSet::add);
        int[] res = new int[resSet.size()];
        AtomicInteger index = new AtomicInteger();
        resSet.forEach(item -> res[index.getAndIncrement()] = item);
        return res;
    }

    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0) {
            return null;
        }
        // init
        int[] nums1countArr = new int[1001];
        int[] nums2countArr = new int[1001];
        for (int item : nums1) {
            nums1countArr[item]++;
        }
        for (int item : nums2) {
            nums2countArr[item]++;
        }

        Set<Integer> resSet = new HashSet<>();
        // 过程。两个都有的加入结果集合
        for (int i = 0; i < 1001; i++) {
            if (nums1countArr[i] > 0 && nums2countArr[i] > 0) {
                resSet.add(i);
            }
        }
        // 结果
        int[] res = new int[resSet.size()];
        int index = 0;
        for (Integer item : resSet) {
            res[index++] = item;
        }
        return res;
    }

350 两个数组的交集 II(easy)

力扣地址

https://leetcode.cn/problems/intersection-of-two-arrays-ii/description/

题目描述

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

题目实例

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

解题思路

用349的思路二，这个要求统计个数最小的，那么就不能用set，用list，然后统计两个数组中小的那个，再把这个个数的数填充答案即可。

代码实现

   public int[] intersect(int[] nums1, int[] nums2) {
      if (nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0) {
          return null;
      }
      // init
      int[] nums1countArr = new int[1001];
      int[] nums2countArr = new int[1001];
      for (int item : nums1) {
          nums1countArr[item]++;
      }
      for (int item : nums2) {
          nums2countArr[item]++;
      }

      List<Integer> resList = new LinkedList<>();
      // 过程。两个都有的加入结果集合
      for (int i = 0; i < 1001; i++) {
         // 这样写就可以少一层嵌套
          if (nums1countArr[i] <= 0 || nums2countArr[i] <= 0) {
              continue;
          }
          int minSize = Math.min(nums1countArr[i], nums2countArr[i]);
          for (int index = 0; index < minSize; index++) {
              resList.add(i);
          }
      }
      // 结果
      int[] res = new int[resList.size()];
      int index = 0;
      for (Integer item : resList) {
          res[index++] = item;
      }
      return res;
  }

202 快乐数(easy)

力扣地址

https://leetcode.cn/problems/happy-number/description/

题目描述

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

「快乐数」 定义为：

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

题目实例

解题思路

定义函数f,f可以求出每个数的和。输入是n，输出是每个位置的平方和。 按照题目要求，直到n等于1才结束循环，同时数字是可能重复的，所以要加入一个set来去重。那么就可以得到终止条件

while (n != 1 && !set.contains(n)) {
    对n进行操作   
}

代码实现

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

  private int getNextNum(int n) {
      int res = 0;
      while (n != 0) {
          int lastIndexNum = n % 10;
          res += lastIndexNum * lastIndexNum;
          n /= 10;
      }
      return res;
  }

1 两数之和(easy)

力扣地址

https://leetcode.cn/problems/two-sum/

题目描述

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

题目实例

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

解题思路

定义map，key是num[i]，value是i，那么当出现map.contains(target - nums[i])的时候，就说明已经找到了。返回这两个下标即可。

代码实现

    public int[] twoSum(int[] nums, int target) {
      Map<Integer, Integer> numMap = new HashMap<>();
      for (int i = 0; i < nums.length; i++) {
          // 如果map里已经有了
          if (numMap.containsKey(target - nums[i])) {
              return new int[]{numMap.get(target - nums[i]), i};
          }
          // map没有，添加进去
          numMap.put(nums[i], i);
      }
      return new int[]{-1, -1};
  }

454四数相加II(mid)

力扣地址

https://leetcode.cn/problems/4sum-ii/description/

题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

题目实例

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

解题思路

统计个数，也不用去重，把前两个数组理解成一个数组，后两个数组理解成一个数组，然后就变成第一题的两数之和的解法。
定义一个map key是两个数组的数的和，value是这两个数的和出现的个数。此时的target就是0。

代码实现

    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
       Map<Integer, Integer> mapNum = new HashMap<>();
       // 前两个当成一个数组
       for (int i = 0; i < nums1.length; i++) {
           for (int j = 0; j < nums2.length; j++) {
               mapNum.put(nums1[i] + nums2[j], mapNum.getOrDefault(nums1[i] +nums2[j], 0) + 1);
           }
       }
       int res = 0;
       // 后两个当成一个数组
       for (int i = 0; i < nums3.length; i++) {
           for (int j = 0; j < nums4.length; j++) {
              // 然后就变成了两数之和
               if (mapNum.containsKey(0 - nums4[j] - nums3[i])) {
                   res += mapNum.get(0 - nums4[j] - nums3[i]);
               }
           }
       }
       return res;
   }

15 三数之和(mid)

力扣地址

https://leetcode.cn/problems/3sum/description/

题目描述

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

题目实例

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

解题思路

这个是需要去重的，n数之和按照模板来就好了

   public static List<List<Integer>> nSum(int[] nums, int target) {
       // 先排序
       List<List<Integer>> res = new ArrayList<>();
       // n - 2 层for循环
       for (int i = 0; i < nums.length; i++) {
           // 当前的值大于target,还大于target，减枝
           if (nums[i] > 0 && nums[i] > target) {
               return res;
           }
           // 去重
           if (i > 0 && nums[i] == nums[i - 1]) {
               continue;
           }
           for (int j = i + 1; j < nums.length; j++) {
               // 去重，剩下还有层数以此类推即可
               if (j > i + 1 && nums[j] == nums[j - 1]) {
                   continue;
               }
               // n - 2层for循环+这个核心逻辑
               int left = j + 1;
               int right = nums.length - 1; 
               while (left < right) {
                   // 这里一定是long，防止越界
                   long sum = nums[i] + nums[j] + nums[left] + nums[right];
                   if (sum > target) {
                       right--;
                   } else if (sum < target) {
                       left++;
                   } else {
                       // 记得一定是new出来的，否则值不会变
                       res.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[left], nums[right])));
                       // 去重
                       while (left < right && nums[left] == nums[left + 1]) {
                           left++;
                       }
                       // 去重
                       while (left < right && nums[right] == nums[right - 1]) {
                           right--;
                       }
                       left++;
                       right--;
                   }
               }
           }
       }
       
       return res;
   }

代码实现

这里的target相当于是0，直接省略

    public List<List<Integer>> threeSum(int[] nums) {

       List<List<Integer>> res = new ArrayList<>();
       if (nums.length == 0) {
           return res;
       }
       Arrays.sort(nums);
       // n - 2层for循环，n是3，只需要一层
       for (int i = 0; i < nums.length; i++) {
          // taget = 0，两个条件一致了，省略掉一个
           if (nums[i] > 0) {
               return res;
           }
           if (i > 0 && nums[i] == nums[i - 1]) {
               continue;
           }
           int left = i + 1;
           int right = nums.length - 1;
           while (left < right) {
               long sum = nums[i] + nums[left] + nums[right];
               if (sum > 0) {
                   right--;
               } else  if (sum < 0) {
                   left++;
               } else {
                   res.add(new ArrayList<>(Arrays.asList(nums[i], nums[left], nums[right])));
                   while (left < right && nums[left] == nums[left + 1]) {
                       left++;
                   }
                   while (left < right && nums[right] == nums[right - 1]) {
                       right--;
                   }
                   left++;
                   right--;
               }
           }


       }
       return res;
   }

18 四数之和(mid)

力扣地址

https://leetcode.cn/problems/4sum/

题目描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

题目实例

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

解题思路

同上

代码实现

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > target && nums[i] > 0) {
                return res;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i +1; j < nums.length; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    long sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        res.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[left], nums[right])));
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
        }

}