链接：LeetCode
[Leetcode]2119. 反转两次的数字
反转 一个整数意味着倒置它的所有位。
例如，反转 2021 得到 1202 。反转 12300 得到 321 ，不保留前导零 。
给你一个整数 num ，反转 num 得到 reversed1 ，接着反转 reversed1 得到 reversed2 。如果 reversed2 等于 num ，返回 true ；否则，返回 false 。
判断个位是否为0即可。
class Solution {
public boolean isSameAfterReversals(int num) {
int lastNum = num % 10;
if(num == 0 || lastNum != 0) return true;
return false;
}
}
[Leetcode]2120. 执行所有后缀指令
现有一个 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 leng = s.length();
int[] res = new int[leng];
for(int ind=0;ind<leng;ind++) {
int cur = ind;
int[] curPos = Arrays.copyOfRange(startPos,0,2);
while(cur<leng) {
char ch = s.charAt(cur);
switch(ch) {
case 'L':
curPos[1] --;
break;
case 'R':
curPos[1] ++;
break;
case 'U':
curPos[0] --;
break;
case 'D':
curPos[0] ++;
break;
}
if(curPos[0] < 0 || curPos[0] >=n || curPos[1] < 0 || curPos[1] >=n) break;
cur ++;
}
res[ind] = cur - ind;
}
return res;
}
}
[Leetcode]2121. 相同元素的间隔之和
给你一个下标从 0 开始、由 n 个整数组成的数组 arr 。
arr 中两个元素的 间隔 定义为它们下标之间的 绝对差 。更正式地，arr[i] 和 arr[j] 之间的间隔是 |i - j| 。
返回一个长度为 n 的数组 intervals ，其中 intervals[i] 是 arr[i] 和 arr 中每个相同元素（与 arr[i] 的值相同）的 间隔之和 。
注意：|x| 是 x 的绝对值。
其实是是一个数学问题。很容易想到用字典来存储每个数字的索引列表，需要考虑的是已知第i-1个索引所代表的间隔之和，如何计算第i个索引的间隔之和时。
对比第 i−1 个元素与第 i 个元素，观察他们间隔和的变化量：
- 左边有 i 个元素的间隔变大了 p[i]-p[i-1]；
- 右边有n−i 个元素的间隔变小了 p[i]-p[i-1]。
所以间隔和的变化量为
class Solution {
public long[] getDistances(int[] arr) {
HashMap<Integer, ArrayList<Integer>> indexMap = new HashMap<>();
int n = arr.length;
for(int i=0;i<n;++i) {
ArrayList<Integer> exists = new ArrayList<>();
if(indexMap.containsKey(arr[i])) exists = indexMap.get(arr[i]);
exists.add(i);
indexMap.put(arr[i], exists);
}
long[] res = new long[n];
for (var indexes: indexMap.values()) {
int indexesLength = indexes.size();
long distanceSum = 0;
for (int i=0;i<indexesLength;++i) {
distanceSum += indexes.get(i) - indexes.get(0);
}
res[indexes.get(0)] = distanceSum;
for(int i=1;i<indexesLength;++i) {
int ind = indexes.get(i);
int dis = indexes.get(i) - indexes.get(i-1);
distanceSum += i * dis - (indexesLength-i) * dis;
res[ind] = distanceSum;
}
}
return res;
}
}
[Leetcode]2122. 还原原数组
Alice 有一个下标从 0 开始的数组 arr ，由 n 个正整数组成。她会选择一个任意的 正整数 k 并按下述方式创建两个下标从 0 开始的新整数数组 lower 和 higher ：
对每个满足 0 <= i < n 的下标 i ，lower[i] = arr[i] - k
对每个满足 0 <= i < n 的下标 i ，higher[i] = arr[i] + k
不幸地是，Alice 丢失了全部三个数组。但是，她记住了在数组 lower 和 higher 中出现的整数，但不知道每个整数属于哪个数组。请你帮助 Alice 还原原数组。
给你一个由 2n 个整数组成的整数数组 nums ，其中 恰好 n 个整数出现在 lower ，剩下的出现在 higher ，还原并返回 原数组 arr 。如果出现答案不唯一的情况，返回 任一 有效数组。
注意：生成的测试用例保证存在 至少一个 有效数组 arr 。
枚举 + 双指针.
我们首先将数组 \(\textit{arr}\) 按照升序排序。
根据题目的要求，\(\textit{arr}\) 可以拆分成两个长度为 n 的数组，并且对于元素较小的那个数组 \(\textit{lower}\) 中的每一个元素，在元素较大的那个数组 \(\textit{upper}\) 中都唯一对应着一个恰好比它大 2k 的元素。当 \(\textit{arr}\) 有序时，最小的那个元素 \(\textit{arr}[0]\) 一定是属于 \(\textit{lower}\) 的，这样一来，我们就可以枚举 \(\textit{arr}\) 中剩余的 2n-1 个元素，分别作为 \(\textit{arr}[0]\) 在 \(\textit{upper}\) 中唯一对应的元素，并判断剩余元素的合法性。
另外在遍历剩余的 2n-1 个元素时，可以用双指针。容易想到每次遍历，最小的那个元素一定是属于\(\textit{lower}\)的， 我们用left指针指向最小的那个元素，用right指针去寻找正好是最小元素+2k且未枚举到的值。如果没有找到，则退出循环，枚举下一个可能的\(\textit{arr[i]}\).
class Solution {
public int[] recoverArray(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
int[] ans = new int[n / 2];
for(int i = 1; i < n; i++){
if(nums[i] == nums[0]) continue;
int dif = nums[i] - nums[0];
if(dif % 2 != 0) continue;
Queue<Integer> q = new LinkedList();
int pointer = 0;
for(int j = 0; j < n; j++){
if(!q.isEmpty() && q.peek() == nums[j]){
q.poll();
continue;
}
if(pointer == n / 2) break;
q.offer(nums[j] + dif);
ans[pointer++] = nums[j] + dif / 2;
}
if(q.isEmpty()) break;
}
return ans;
}
}