周赛笔记10/16/2022

6204. 与对应负数同时存在的最大正整数

给你一个 不包含 任何零的整数数组 nums ，找出自身与对应的负数都在数组中存在的最大正整数 k 
输入：nums = [-1,2,-3,3]
输出：3
解释：3 是数组中唯一一个满足题目要求的 k 。

一个HashSet+一遍遍历，秒解

class Solution {
    public int findMaxK(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        int res = Integer.MIN_VALUE;
        for(int n:nums){
            if(set.contains(-n)) res = Math.max(res,Math.abs(n));
            set.add(n);
        }
        return res==Integer.MIN_VALUE?-1:res;
    }
}

6205. 反转之后不同整数的数目

给你一个由正整数组成的数组nums 。
你必须取出数组中的每个整数，反转其中每个数位，并将反转后得到的数字添加到数组的末尾。这一操作只针对 nums 中原有的整数执行。
返回结果数组中不同整数的数目。
输入：nums = [1,13,10,12,31]
输出：6
解释：反转每个数字后，结果数组是 [1,13,10,12,31,1,31,1,21,13] 。
反转后得到的数字添加到数组的末尾并按斜体加粗表示。注意对于整数 10 ，反转之后会变成 01 ，即 1 。
数组中不同整数的数目为 6（数字 1、10、12、13、21 和 31）

同样一个HashSet+一遍遍历，秒解

class Solution {
    public int countDistinctIntegers(int[] nums) {
        HashSet<Integer> set = new HashSet();
        for(int num : nums){
            if(num==1) {
                set.add(num);
                continue;
            }
            set.add(num);
            int n =0;
            while(num!=0){
                n=n*10+num%10;
                num/=10;
            }
            set.add(n);
        }
        return set.size();
    }
}

6219. 反转之后的数字和

输入：num = 443
输出：true
解释：172 + 271 = 443 ，所以返回 true 。

我以为我的方法很笨，但是发现大家都是同样的解法…

class Solution {
    public boolean sumOfNumberAndReverse(int num) {
        if(num==0) return true;
        for(int i=1;i<=num;i++){
            if((i+reverseNum(i))==num) return true;
        }
        return false;
    }
    int reverseNum(int num){
        int n =0;
        while(num!=0){
            n=n*10+num%10;
            num/=10;
        }
        return n;
    }
}

6207. 统计定界子数组的数目

给你一个整数数组 nums 和两个整数 minK 以及 maxK 。
nums 的定界子数组是满足下述条件的一个子数组：
子数组中的最小值等于 minK
子数组中的最大值等于 maxK
返回定界子数组的数目。
子数组是数组中的一个连续部分
输入：nums = [1,3,5,2,7,5], minK = 1, maxK = 5
输出：2
解释：定界子数组是 [1,3,5] 和 [1,3,5,2] 。

发呆一小时，没写出来…

看了好几个解析，写了一个自己的解法，然后有一些自己的理解

class Solution {
 public long countSubarrays(int[] nums, int minK, int maxK) {
        int n = nums.length;
        long res = 0;
        int left = 0, minIndex = -1, maxIndex = -1;
        for (int i = 0; i < n; i++) {
            //定位出现最大最小值的索引
            if (nums[i] == minK) minIndex = i;
            if (nums[i] == maxK) maxIndex = i;
            //刚进来的数影响了最大值或最小值
            if (nums[i] < minK || nums[i] > maxK) {
                //将left定位到刚好不出现越界值的位置
                left = i + 1;
                minIndex = maxIndex = -1;
                //当窗口内同时包含最大值和最小值时，更新结果
            } else if (minIndex != -1 && maxIndex != -1) {
                int min = Math.min(minIndex, maxIndex);
                res += min - left + 1;
            }
        }
        return res;
    }
}