目录
2032. 至少在两个数组中出现的值
2037. 使每位学生都有座位的最少移动次数
2042. 检查句子中的数字是否递增
2097. 合法重新排列数对
2180. 统计各位数字之和为偶数的整数个数
2185. 统计包含给定前缀的字符串
2283. 判断一个数的数字计数是否等于数位的值
2287. 重排字符形成目标字符串
2293. 极大极小游戏
2299. 强密码检验器 II
2303. 计算应缴税款总额
2309. 兼具大小写的最好英文字母
2326. 螺旋矩阵 IV
2351. 第一个出现两次的字母
2425. 所有数对的异或和
2032. 至少在两个数组中出现的值
给你三个整数数组 nums1、nums2 和 nums3 ，请你构造并返回一个 元素各不相同的 数组，且由 至少 在 两个 数组中出现的所有值组成。数组中的元素可以按 任意 顺序排列。
示例 1：
输入：nums1 = [1,1,3,2], nums2 = [2,3], nums3 = [3]
输出：[3,2]
解释：至少在两个数组中出现的所有值为：
- 3 ，在全部三个数组中都出现过。
- 2 ，在数组 nums1 和 nums2 中出现过。
示例 2：
输入：nums1 = [3,1], nums2 = [2,3], nums3 = [1,2]
输出：[2,3,1]
解释：至少在两个数组中出现的所有值为：
- 2 ，在数组 nums2 和 nums3 中出现过。
- 3 ，在数组 nums1 和 nums2 中出现过。
- 1 ，在数组 nums1 和 nums3 中出现过。
示例 3：
输入：nums1 = [1,2,2], nums2 = [4,3,3], nums3 = [5]
输出：[]
解释：不存在至少在两个数组中出现的值。
提示：
1 <= nums1.length, nums2.length, nums3.length <= 100
1 <= nums1[i], nums2[j], nums3[k] <= 100
class Solution {
public:
vector<int> twoOutOfThree(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3) {
auto v1 = GetSameData(nums1, nums2);
auto v2 = GetSameData(nums1, nums3);
auto v3 = GetSameData(nums2, nums3);
v1 = GetInAnyData(v1, v2);
return GetInAnyData(v1, v3);
}
};2037. 使每位学生都有座位的最少移动次数
一个房间里有 n 个座位和 n 名学生，房间用一个数轴表示。给你一个长度为 n 的数组 seats ，其中 seats[i] 是第 i 个座位的位置。同时给你一个长度为 n 的数组 students ，其中 students[j] 是第 j 位学生的位置。
你可以执行以下操作任意次：
增加或者减少第 i 位学生的位置，每次变化量为 1 （也就是将第 i 位学生从位置 x 移动到 x + 1 或者 x - 1）
请你返回使所有学生都有座位坐的 最少移动次数 ，并确保没有两位学生的座位相同。
请注意，初始时有可能有多个座位或者多位学生在 同一 位置。
示例 1：
输入：seats = [3,1,5], students = [2,7,4]
输出：4
解释：学生移动方式如下：
- 第一位学生从位置 2 移动到位置 1 ，移动 1 次。
- 第二位学生从位置 7 移动到位置 5 ，移动 2 次。
- 第三位学生从位置 4 移动到位置 3 ，移动 1 次。
总共 1 + 2 + 1 = 4 次移动。
示例 2：
输入：seats = [4,1,5,9], students = [1,3,2,6]
输出：7
解释：学生移动方式如下：
- 第一位学生不移动。
- 第二位学生从位置 3 移动到位置 4 ，移动 1 次。
- 第三位学生从位置 2 移动到位置 5 ，移动 3 次。
- 第四位学生从位置 6 移动到位置 9 ，移动 3 次。
总共 0 + 1 + 3 + 3 = 7 次移动。
示例 3：
输入：seats = [2,2,6,6], students = [1,3,2,6]
输出：4
解释：学生移动方式如下：
- 第一位学生从位置 1 移动到位置 2 ，移动 1 次。
- 第二位学生从位置 3 移动到位置 6 ，移动 3 次。
- 第三位学生不移动。
- 第四位学生不移动。
总共 1 + 3 + 0 + 0 = 4 次移动。
提示：
n == seats.length == students.length
1 <= n <= 100
1 <= seats[i], students[j] <= 100
class Solution {
public:
int minMovesToSeat(vector<int>& v1, vector<int>& v2) {
sort(v1.begin(),v1.end());
sort(v2.begin(),v2.end());
int ans=0;
for(int i=0;i<v1.size();i++)ans+=abs(v1[i]-v2[i]);
return ans;
}
};2042. 检查句子中的数字是否递增
力扣水题：字符串
2097. 合法重新排列数对
欧拉回路、链路
2180. 统计各位数字之和为偶数的整数个数
水题
2185. 统计包含给定前缀的字符串
水题
2283. 判断一个数的数字计数是否等于数位的值
水题
2287. 重排字符形成目标字符串
水题
2293. 极大极小游戏
给你一个下标从 0 开始的整数数组 nums ，其长度是 2 的幂。
对 nums 执行下述算法：
设 n 等于 nums 的长度，如果 n == 1 ，终止 算法过程。否则，创建 一个新的整数数组 newNums ，新数组长度为 n / 2 ，下标从 0 开始。
对于满足 0 <= i < n / 2 的每个 偶数 下标 i ，将 newNums[i] 赋值 为 min(nums[2 * i], nums[2 * i + 1]) 。
对于满足 0 <= i < n / 2 的每个 奇数 下标 i ，将 newNums[i] 赋值 为 max(nums[2 * i], nums[2 * i + 1]) 。
用 newNums 替换 nums 。
从步骤 1 开始 重复 整个过程。
执行算法后，返回 nums 中剩下的那个数字。
示例 1：
输入：nums = [1,3,5,2,4,8,2,2]
输出：1
解释：重复执行算法会得到下述数组。
第一轮：nums = [1,5,4,2]
第二轮：nums = [1,4]
第三轮：nums = [1]
1 是最后剩下的那个数字，返回 1 。
示例 2：
输入：nums = [3]
输出：3
解释：3 就是最后剩下的数字，返回 3 。
提示：
1 <= nums.length <= 1024
1 <= nums[i] <= 109
nums.length 是 2 的幂
class Solution {
public:
int minMaxGame(vector<int>& nums) {
if (nums.size() == 1)return nums[0];
for (int i = 0; i < nums.size() / 2; i++) {
nums[i] = (i % 2) ? max(nums[i * 2], nums[i * 2 + 1]) : min(nums[i * 2], nums[i * 2 + 1]);
}
nums.resize(nums.size() / 2);
return minMaxGame(nums);
}
};2299. 强密码检验器 II
水题
2303. 计算应缴税款总额
水题
2309. 兼具大小写的最好英文字母
水题
2326. 螺旋矩阵 IV
给你两个整数：m 和 n ，表示矩阵的维数。
另给你一个整数链表的头节点 head 。
请你生成一个大小为 m x n 的螺旋矩阵，矩阵包含链表中的所有整数。链表中的整数从矩阵 左上角 开始、顺时针 按 螺旋 顺序填充。如果还存在剩余的空格，则用 -1 填充。
返回生成的矩阵。
示例 1：
输入：m = 3, n = 5, head = [3,0,2,6,8,1,7,9,4,2,5,5,0] 输出：[[3,0,2,6,8],[5,0,-1,-1,1],[5,2,4,9,7]] 解释：上图展示了链表中的整数在矩阵中是如何排布的。 注意，矩阵中剩下的空格用 -1 填充。
示例 2：
输入：m = 1, n = 4, head = [0,1,2] 输出：[[0,1,2,-1]] 解释：上图展示了链表中的整数在矩阵中是如何从左到右排布的。 注意，矩阵中剩下的空格用 -1 填充。
提示：
1 <= m, n <= 1051 <= m * n <= 105- 链表中节点数目在范围
[1, m * n]内 0 <= Node.val <= 1000
int dx[] = { 0,1,0,-1 };
int dy[] = { 1,0,-1,0 };
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>> matrix) {
vector<int>ans;
if (matrix.empty())return ans;
int k = 0, len = matrix.size() * matrix[0].size();
int x = 0, y = 0;
while (len--)
{
if (x < 0 || x >= matrix.size() || y < 0 || y >= matrix[0].size() || matrix[x][y] == -1234567)
{
x -= dx[k], y -= dy[k];
k++, k %= 4;
x += dx[k], y += dy[k];
}
ans.push_back(matrix[x][y]);
matrix[x][y] = -1234567;
x += dx[k], y += dy[k];
}
return ans;
}
vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
vector<vector<int>> matrix(m);
for (int i = 0; i < m; i++)for (int j = 0; j < n; j++)matrix[i].push_back(i * n + j);
vector<int> v = spiralOrder(matrix);
for (int i = 0; i < m * n; i++) {
if (head)matrix[v[i] / n][v[i] % n] = head->val, head = head->next;
else matrix[v[i] / n][v[i] % n] = -1;
}
return matrix;
}
};2351. 第一个出现两次的字母
给你一个由小写英文字母组成的字符串 s ，请你找出并返回第一个出现 两次 的字母。
注意：
如果 a 的 第二次 出现比 b 的 第二次 出现在字符串中的位置更靠前，则认为字母 a 在字母 b 之前出现两次。
s 包含至少一个出现两次的字母。
示例 1：
输入：s = "abccbaacz"
输出："c"
解释：
字母 'a' 在下标 0 、5 和 6 处出现。
字母 'b' 在下标 1 和 4 处出现。
字母 'c' 在下标 2 、3 和 7 处出现。
字母 'z' 在下标 8 处出现。
字母 'c' 是第一个出现两次的字母，因为在所有字母中，'c' 第二次出现的下标是最小的。
示例 2：
输入：s = "abcdd"
输出："d"
解释：
只有字母 'd' 出现两次，所以返回 'd' 。
提示：
2 <= s.length <= 100
s 由小写英文字母组成
s 包含至少一个重复字母
class Solution {
public:
char repeatedCharacter(string s) {
map<char,int>m;
for(auto c:s){
if(m[c]++)return c;
}
return '0';
}
};2425. 所有数对的异或和
位运算
