【每日一题见微知著】273周赛题-明天更新今天的周赛题

⭐️寒假新坑——代码之狐的每日做题笔记

2122. 还原原数组-Hard-273周赛题4

Alice 有一个下标从 0 开始的数组 arr ，由 n 个正整数组成。她会选择一个任意的 正整数 k 并按下述方式创建两个下标从 0 开始的新整数数组 lower 和 higher ：

1. 对每个满足 0 <= i < n 的下标 i ，lower[i] = arr[i] - k
2. 对每个满足 0 <= i < n 的下标 i ，higher[i] = arr[i] + k

不幸地是，Alice 丢失了全部三个数组。但是，她记住了在数组 lower 和 higher 中出现的整数，但不知道每个整数属于哪个数组。请你帮助 Alice 还原原数组。

给你一个由 2n 个整数组成的整数数组 nums ，其中 恰好 n 个整数出现在 lower ，剩下的出现在 higher ，还原并返回 原数组 arr 。如果出现答案不唯一的情况，返回 任一 有效数组。

**注意：**生成的测试用例保证存在 至少一个 有效数组 arr 。

class Solution {
    public int[] recoverArray(int[] nums) {
        Arrays.sort(nums);
        Map<Integer,Integer> map=new HashMap<>();
        int n=nums.length;
        for(int i=0;i<n;i++){
            map.put(nums[i],map.getOrDefault(nums[i],i));
        }
        int f=nums[0];
        for(int i=1;i<=(n+1)/2;i++){
            int k=nums[i]-f;
            if(k%2!=0||k==0){
                continue;
            }
            else{
                k/=2;
            }

            int[] index=new int[n];
            int[] ans=new int[n/2];
            int curAns=0;
            ans[curAns++]=(f+nums[i])/2;
            index[0]=-1;
            index[i]=1;
            boolean curIndex=true;
            for(int q=1;q<n;q++){
                if(index[q]==0){
                    index[q]=-1;
                    int next=map.getOrDefault(nums[q]+2*k,n);
                    boolean midIndex=false;
                    while(next<n&&index[next]!=0){
                        next++;
                    }
                    if(next>=n||nums[next]!=nums[q]+2*k){
                        curIndex=false;
                        break;
                    }
                    else{
                        ans[curAns++]=(nums[q]+nums[next])/2;
                        index[next]=1;
                    }
                }
            }
            if(curIndex){
                return ans;
            }
        }
        return new int[]{0};
    }
}

2121. 相同元素的间隔之和-Mid-273周赛题3

给你一个下标从 0 开始、由 n 个整数组成的数组 arr 。

arr 中两个元素的 间隔 定义为它们下标之间的 绝对差 。更正式地，arr[i] 和 arr[j] 之间的间隔是 |i - j| 。

返回一个长度为 n 的数组 intervals ，其中 intervals[i] 是 arr[i] 和 arr 中每个相同元素（与 arr[i] 的值相同）的 间隔之和 。

注意：|x| 是 x 的绝对值。

class Solution {
    public long[] getDistances(int[] arr) {
        int n=arr.length;
        Map<Integer,List<Integer>> map=new HashMap<>();
        for(int i=0;i<n;i++){
            int mid=arr[i];
            List<Integer> cur=map.get(mid);
            if(cur==null){
                cur=new ArrayList<Integer>();
            }
            cur.add(i);
            map.put(mid,cur);
        }
        
        long[] ans=new long[n];
        for(Map.Entry<Integer,List<Integer>> e:map.entrySet()){
            List<Integer> cur=e.getValue();
            int l=cur.size();
            long sum=0;
            int[] d=new int[l-1];
            for(int i=1;i<l;i++){
                sum+=(cur.get(i)-cur.get(0));
                d[i-1]=(cur.get(i)-cur.get(i-1));
            }
            ans[cur.get(0)]=sum;
            
            for(int i=1;i<l;i++){
                sum=sum-(l-i)*(d[i-1])+(i)*(d[i-1]);
                ans[cur.get(i)]=sum;
            }
        }
        return ans;
    }
}

2120. 执行所有后缀指令-Mid–273周赛题2

现有一个 n x n 大小的网格，左上角单元格坐标 (0, 0) ，右下角单元格坐标 (n - 1, n - 1) 。给你整数 n 和一个整数数组 startPos ，其中 startPos = [startrow, startcol] 表示机器人最开始在坐标为 (startrow, startcol) 的单元格上。

另给你一个长度为 m 、下标从 0 开始的字符串 s ，其中 s[i] 是对机器人的第 i 条指令：'L'（向左移动），'R'（向右移动），'U'（向上移动）和 'D'（向下移动）。

机器人可以从 s 中的任一第 i 条指令开始执行。它将会逐条执行指令直到 s 的末尾，但在满足下述条件之一时，机器人将会停止：

• 下一条指令将会导致机器人移动到网格外。
• 没有指令可以执行。

返回一个长度为 m 的数组 answer ，其中 answer[i] 是机器人从第 i 条指令 开始 ，可以执行的 指令数目 。

class Solution {
    public int[] executeInstructions(int n, int[] startPos, String s) {
        int x=startPos[0];
        int y=startPos[1];
        int[][] d=new int[s.length()][2];
        for(int i=0;i<s.length();i++){
            int dx=0;
            int dy=0;
            switch(s.charAt(i)){
                case 'L':dy=-1;break;
                case 'R':dy=1;break;
                case 'U':dx=-1;break;
                case 'D':dx=1;break;
            }
            d[i][0]=dx;
            d[i][1]=dy;
        }
        
        for(int i=0;i<s.length();i++){
            int curx=x;
            int cury=y;
            int sum=0;
            for(int k=i;k<s.length();k++){
                curx+=d[k][0];
                cury+=d[k][1];
                if(curx>=0&&curx<n&&cury>=0&&cury<n){
                    sum++;
                }
                else{
                    break;
                }
            }
            d[i][0]=sum;
        }
        int[] ans=new int[s.length()];
        for(int i=0;i<s.length();i++){
            ans[i]=d[i][0];
        }
        return ans;
    }
}

2119. 反转两次的数字-273周赛题1

反转 一个整数意味着倒置它的所有位。

• 例如，反转 2021 得到 1202 。反转 12300 得到 321 ，不保留前导零 。

给你一个整数 num ，反转 num 得到 reversed1 ，接着反转 reversed1 得到 reversed2 。如果 reversed2 等于 num ，返回 true ；否则，返回 false 。

class Solution {
    public boolean isSameAfterReversals(int num) {
        if(num==0){
            return true;
        }
        else if(num%10==0){
            return false;
        }
        return true;
    }
}

结尾

题目来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems

⭐️关注作者，带你刷题，从简单的算法题了解最常用的算法技能（寒假每日一题）
⭐️关注作者刷题——简单到进阶，让你不知不觉成为无情的刷题机器，有问题请私信