The first question is : 2206. Divide the array into equal pairs

LeetCode: 2206. Divide the array into equal pairs

describe :
Give you an array of integers nums , It contains 2 * n It's an integer .

You need to nums Divide into n Pairs of numbers , Satisfy ：

• Every element It belongs to only one Number pair .
• Elements in the same number pair equal .

If you can nums Divide into n Pairs of numbers , Please return true , Otherwise return to false .

Their thinking :

1. From the title, we can see , The elements in the array appear in pairs ,
2. If there is a single number of elements, it must be wrong .
3. Here we use hash table , Traversal array , If the current element does not exist , Just add it directly to the hash table , If the current element exists , Just delete the element .
4. Such a solution , Let every time there is 2 You can delete . The deleted ones are in pairs .
5. If the last hash table is not empty , It means false

Code implementation :

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();
    }
}

The second question is : 2215. Find out the difference between the two arrays

LeetCode: 2215. Find out the difference between the two arrays

describe :
Give you two subscripts from 0 The starting array of integers nums1 and nums2 , Please return a length of 2 A list of answer , among ：

• answer[0] yes nums1 All in No Exist in nums2 Medium Different List of integers .
• answer[1] yes nums2 All in No Exist in nums1 Medium Different List of integers .

Be careful ： The integers in the list can be pressed arbitrarily Sequential return .

Their thinking :

1. Create two hash tables , Will array nums1, Add to a hash table set1. Will array nums2, Add to another hash table set2
2. Traverse the hash table again set1, Look at the hash table 1 Whether there is a hash table for the element in 2 in , If the hash table 2 Hash table does not exist in 1 The elements in , It means that this is a redundant element , Put it in the result set .
3. Traverse the hash table again set2, Look at the hash table 2 Whether there is a hash table for the element in 1 in , If the hash table 1 Hash table does not exist in 2 The elements in , It means that this is a redundant element , Also put into the result set ,

Code implementation :

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;
    }
}

Third question : 2225. Find the player who lost zero or one game

LeetCode: 2225. Find the player who lost zero or one game

describe :
Give you an array of integers matches among matches[i] = [winneri, loseri] In a game winneri Beat the loseri .

Returns a length of 2 A list of answer ：

• answer[0] It's all No, List of players who lost any game .
• answer[1] Is all that happens to lose a List of players in the game .

The values in both lists should be pressed Increasing Sequential return .

Be careful ：

• Only those involved At least one The players of the game .
• The generated test cases guarantee non-existent The results of two games identical .

Their thinking :

1. Here we use hash table to solve problems
2. Traversal array , If it's for matches[i][0] Subscript elements are added directly , value Value is set to 0. If it's for matches[i][1] Subscript element pairs value Value for +1 operation ,
3. If key Corresponding value The value is 0, It is a failed addition to the result set , If key Corresponding value The value is 1, It's a player who only loses one , Add to result set .
4. Be careful to return in ascending order . Sort .

Code implementation :

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;
    }
}

Fourth question : 2273. Result array after removing letter ectopic words

LeetCode: 2273. Result array after removing letter ectopic words

describe :
I'll give you a subscript from 0 Starting string words , among words[i] Composed of lowercase English characters .

In one step , Any subscript needs to be selected i , from words in Delete words[i] . Subscript i The following two conditions need to be met at the same time ：

• 0 < i < words.length
• words[i - 1] and words[i] yes Letter heterotopic word .

As long as you can choose a subscript that meets the conditions , Just keep doing this .

After performing all operations , return words . Can prove that , Selecting subscripts for each operation in any order will get the same result .

Letter heterotopic word Is a new word obtained by rearranging the letters of the source word , Letters in all source words are usually used just once . for example ,"dacb" yes "abdc" A letter heterotopic word of .

Their thinking :

1. Rearrange each character in the string array
2. Go to pairs and compare /
3. If it is consistent, add it only once
4. If it is inconsistent, add it directly

Code implementation :

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;
    }
}

Fifth question : 2283. Determine whether the number count of a number is equal to the value of the digit

LeetCode: 2283. Determine whether the number count of a number is equal to the value of the digit

describe :
I'll give you a subscript from 0 Start length is n String num , It contains only numbers .

If for Every 0 <= i < n The subscript i , All meet the digit i stay num In the num[i] Time , So please go back to true , Otherwise return to false .

Their thinking :

1. Traversal string num, Record each character , Record the number of times the corresponding number appears .
2. Traverse... Again , Comparison correspondence i Number of subscripts , Whether it is consistent with the current number of times represented by the string , Inconsistent direct return false
3. If the traversal ends , Just go back to true

Code implementation :

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;
    }
}

Sixth question : 2295. Replace elements in an array

LeetCode: 2295. Replace elements in an array

describe :
I'll give you a subscript from 0 Starting array nums , It contains n individual Different from each other The positive integer . Please execute on this array m Operations , In the i In one operation , You need to put the numbers operations[i][0] Replace with operations[i][1] .

The title is guaranteed in i In one operation ：

• operations[i][0] stay nums in .
• operations[i][1] stay nums Does not exist in the .

Please return the array after performing all operations .

Their thinking :

1. Solve problems with hash table
2. Traversal array nums, Put each element , And subscripts are recorded in the hash table .
3. Re traversal operations , If at present operations[i][0] The subscript of exists in the hash table , Get subscript , Then replace the array elements with operations[i][1], Then put the updated elements and subscripts into the hash table .
4. End of traversal . The array has been modified

Code implementation :

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;
    }
}