第一题: 2206. 将数组划分成相等数对

LeetCode: 2206. 将数组划分成相等数对

描述:
给你一个整数数组 nums ，它包含 2 * n 个整数。

你需要将 nums 划分成 n 个数对，满足：

• 每个元素 只属于一个 数对。
• 同一数对中的元素 相等 。

如果可以将 nums 划分成 n 个数对，请你返回 true ，否则返回 false 。

解题思路:

1. 由题可知, 数组中的元素都是成对出现,
2. 如果出现的元素个数有单个的肯定是错误的.
3. 这里使用哈希表, 遍历数组, 如果当前元素不存在, 就直接加入哈希表中, 如果当前元素存在, 就删除该元素.
4. 这样的解决办法, 就让每次有2个就可以删除. 删除的是成对的.
5. 如果最后哈希表不为空, 就表示false

代码实现:

class Solution {
    public boolean divideArray(int[] nums) {
       Set<Integer> set = new HashSet<>();
       for(int num : nums) {
           if(!set.add(num)){
               set.remove(num);
           }
       }
       return set.isEmpty();
    }
}
1
2
3
4
5
6
7
8
9
10
11

第二题: 2215. 找出两数组的不同

LeetCode: 2215. 找出两数组的不同

描述:
给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，请你返回一个长度为 2 的列表 answer ，其中：

• answer[0] 是 nums1 中所有 不 存在于 nums2 中的 不同 整数组成的列表。
• answer[1] 是 nums2 中所有 不 存在于 nums1 中的 不同 整数组成的列表。

注意：列表中的整数可以按 任意 顺序返回。

解题思路:

1. 建立两个哈希表, 将数组nums1, 添加到一个哈希表中 set1. 将数组 nums2, 添加到另一个哈希表中set2
2. 再次遍历哈希表 set1, 查看哈希表1中的元素是否存在哈希表2中, 如果哈希表2中不存在哈希表1中的元素, 表示这个就是多余的元素, 就放入结果集中.
3. 再次遍历哈希表 set2, 查看哈希表2中的元素是否存在哈希表1中, 如果哈希表1中不存在哈希表2中的元素, 表示这个就是多余的元素, 也放入结果集中,

代码实现:

class Solution {
    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        for(int num : nums1) set1.add(num);
        for(int num : nums2) set2.add(num);
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        for(int num : set1) {
            if(!set2.contains(num)){
                list1.add(num);
            }
        }
        for(int num : set2) {
            if(!set1.contains(num)){
                list2.add(num);
            }
        }
        res.add(new ArrayList<>(list1));
        res.add(new ArrayList<>(list2));
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第三题: 2225. 找出输掉零场或一场比赛的玩家

LeetCode: 2225. 找出输掉零场或一场比赛的玩家

描述:
给你一个整数数组 matches 其中 matches[i] = [winneri, loseri] 表示在一场比赛中 winneri 击败了 loseri 。

返回一个长度为 2 的列表 answer ：

• answer[0] 是所有 没有 输掉任何比赛的玩家列表。
• answer[1] 是所有恰好输掉 一场 比赛的玩家列表。

两个列表中的值都应该按 递增 顺序返回。

注意：

• 只考虑那些参与 至少一场 比赛的玩家。
• 生成的测试用例保证 不存在 两场比赛结果 相同 。

解题思路:

1. 这里使用哈希表解题
2. 遍历数组, 如果是为 matches[i][0] 下标的元素直接添加, value值设置为0. 如果是为 matches[i][1] 下标的元素对 value值进行+1操作,
3. 如果 key 对应的 value 值为0, 则是一把没输添加到结果集中, 如果 key 对应的 value 值为1, 则是只输一把的玩家, 添加到结果集中.
4. 注意要按递增顺序返回. 进行排序.

代码实现:

class Solution {
    public List<List<Integer>> findWinners(int[][] matches) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < matches.length; i++) {
            if(!map.containsKey(matches[i][0]))map.put(matches[i][0],0);
            map.put(matches[i][1],map.getOrDefault(matches[i][1],0)+1);
        }
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        for(int key : map.keySet()) {
            if(map.get(key) == 0) {
                list1.add(key);
            }else if(map.get(key) == 1){
                list2.add(key);
            }
        }
        Collections.sort(list1);
        Collections.sort(list2);
        res.add(new ArrayList<>(list1));
        res.add(new ArrayList<>(list2));
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第四题: 2273. 移除字母异位词后的结果数组

LeetCode: 2273. 移除字母异位词后的结果数组

描述:
给你一个下标从 0 开始的字符串 words ，其中 words[i] 由小写英文字符组成。

在一步操作中，需要选出任一下标 i ，从 words 中 删除 words[i] 。其中下标 i 需要同时满足下述两个条件：

• 0 < i < words.length
• words[i - 1] 和 words[i] 是 字母异位词 。

只要可以选出满足条件的下标，就一直执行这个操作。

在执行所有操作后，返回 words 。可以证明，按任意顺序为每步操作选择下标都会得到相同的结果。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。例如，"dacb" 是 "abdc" 的一个字母异位词。

解题思路:

1. 对字符串数组中的每个字符进行重排
2. 再去两两进行比较/
3. 如果一致就只添加一次
4. 如果不一致就直接添加

代码实现:

class Solution {
    public List<String> removeAnagrams(String[] words) {
        List<String> res = new ArrayList<>();
        String pre = "";
        for(String word : words) {
            char[] ch = word.toCharArray();
            Arrays.sort(ch);
            String newWord = new String(ch);
            if(!pre.equals(newWord)) {
                res.add(word);
                pre = newWord;
            }
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第五题: 2283. 判断一个数的数字计数是否等于数位的值

LeetCode: 2283. 判断一个数的数字计数是否等于数位的值

描述:
给你一个下标从 0 开始长度为 n 的字符串 num ，它只包含数字。

如果对于 每个 0 <= i < n 的下标 i ，都满足数位 i 在 num 中出现了 num[i]次，那么请你返回 true ，否则返回 false 。

解题思路:

1. 遍历字符串 num, 对每个字符进行记录, 记录对应数字出现的次数.
2. 再次遍历, 比较对应i下标出现的次数, 和字符串当前表示的次数是否一致, 不一致直接返回false
3. 如果遍历结束, 就返回true

代码实现:

class Solution {
    public boolean digitCount(String num) {
        int[] arr = new int[10];
        for(char ch : num.toCharArray()) {
            arr[ch-'0']++;
        }
        for(int i = 0; i < num.length();i++){
            if(arr[i] != num.charAt(i)-'0'){
                return false;
            }
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第六题: 2295. 替换数组中的元素

LeetCode: 2295. 替换数组中的元素

描述:
给你一个下标从 0 开始的数组 nums ，它包含 n 个 互不相同 的正整数。请你对这个数组执行 m 个操作，在第 i 个操作中，你需要将数字 operations[i][0] 替换成 operations[i][1] 。

题目保证在第 i 个操作中：

• operations[i][0] 在 nums 中存在。
• operations[i][1] 在 nums 中不存在。

请你返回执行完所有操作后的数组。

解题思路:

1. 用哈希表解题
2. 遍历数组 nums, 将每个元素, 和下标记录在哈希表中.
3. 再遍历 operations , 如果当前 operations[i][0] 的下标存在哈希表中, 获取到下标, 然后进行数组元素的替换成 operations[i][1], 再将更新的元素和下标放入哈希表中.
4. 遍历结束. 数组已经修改完毕

代码实现:

class Solution {
    public int[] arrayChange(int[] nums, int[][] operations) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }
        for(int i = 0; i < operations.length; i++) {
            if(map.containsKey(operations[i][0])) {
                int index = map.get(operations[i][0]);
                nums[index] = operations[i][1];
                map.put(nums[index],index);
            }
        }
        return nums;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16