From 9d01a958d791223894675da3f18eee212029e16d Mon Sep 17 00:00:00 2001
From: acbin <44314231+acbin@users.noreply.github.com>
Date: Sun, 7 Jan 2024 07:37:37 +0800
Subject: [PATCH 1/5] feat: add biweekly contest 121 (#2188)
* https://leetcode.cn/circle/discuss/pMSs2M/
* https://leetcode.cn/contest/biweekly-contest-121/
---
.../README.md | 82 +++++++++++++
.../README_EN.md | 72 ++++++++++++
.../README.md | 93 +++++++++++++++
.../README_EN.md | 83 +++++++++++++
.../README.md | 111 ++++++++++++++++++
.../README_EN.md | 101 ++++++++++++++++
.../README.md | 97 +++++++++++++++
.../README_EN.md | 87 ++++++++++++++
solution/CONTEST_README.md | 7 ++
solution/CONTEST_README_EN.md | 7 ++
solution/README.md | 4 +
solution/README_EN.md | 4 +
solution/summary.md | 6 +
solution/summary_en.md | 6 +
14 files changed, 760 insertions(+)
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
create mode 100644 solution/10000-10099/10034.Count the Number of Powerful Integers/README.md
create mode 100644 solution/10000-10099/10034.Count the Number of Powerful Integers/README_EN.md
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
new file mode 100644
index 0000000000000..bb4fbf59fc392
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
@@ -0,0 +1,82 @@
+# [10031. 大于等于顺序前缀和的最小缺失整数](https://leetcode.cn/problems/smallest-missing-integer-greater-than-sequential-prefix-sum)
+
+[English Version](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README_EN.md)
+
+## 题目描述
+
+
+
+给你一个下标从 0 开始的整数数组 nums 。
+
+如果一个前缀 nums[0..i] 满足对于 1 <= j <= i 的所有元素都有 nums[j] = nums[j - 1] + 1 ，那么我们称这个前缀是一个 顺序前缀 。特殊情况是，只包含 nums[0] 的前缀也是一个 顺序前缀 。
+
+请你返回 nums 中没有出现过的 最小 整数 x ，满足 x 大于等于 最长 顺序前缀的和。
+
+
+
+示例 1：
+
+
+输入：nums = [1,2,3,2,5]
+输出：6
+解释：nums 的最长顺序前缀是 [1,2,3] ，和为 6 ，6 不在数组中，所以 6 是大于等于最长顺序前缀和的最小整数。
+
+
+示例 2：
+
+
+输入：nums = [3,4,5,1,12,14,13]
+输出：15
+解释：nums 的最长顺序前缀是 [3,4,5] ，和为 12 ，12、13 和 14 都在数组中，但 15 不在，所以 15 是大于等于最长顺序前缀和的最小整数。
+
+
+
+
+提示：
+
+
+ 1 <= nums.length <= 501 <= nums[i] <= 50
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
new file mode 100644
index 0000000000000..a1edd49e3820e
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
@@ -0,0 +1,72 @@
+# [10031. Smallest Missing Integer Greater Than Sequential Prefix Sum](https://leetcode.com/problems/smallest-missing-integer-greater-than-sequential-prefix-sum)
+
+[中文文档](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README.md)
+
+## Description
+
+You are given a 0-indexed array of integers nums.
+
+A prefix nums[0..i] is sequential if, for all 1 <= j <= i, nums[j] = nums[j - 1] + 1. In particular, the prefix consisting only of nums[0] is sequential.
+
+Return the smallest integer x missing from nums such that x is greater than or equal to the sum of the longest sequential prefix.
+
+
+Example 1:
+
+
+Input: nums = [1,2,3,2,5]
+Output: 6
+Explanation: The longest sequential prefix of nums is [1,2,3] with a sum of 6. 6 is not in the array, therefore 6 is the smallest missing integer greater than or equal to the sum of the longest sequential prefix.
+
+
+Example 2:
+
+
+Input: nums = [3,4,5,1,12,14,13]
+Output: 15
+Explanation: The longest sequential prefix of nums is [3,4,5] with a sum of 12. 12, 13, and 14 belong to the array while 15 does not. Therefore 15 is the smallest missing integer greater than or equal to the sum of the longest sequential prefix.
+
+
+
+Constraints:
+
+
+ 1 <= nums.length <= 501 <= nums[i] <= 50
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
new file mode 100644
index 0000000000000..5d2aec6532e0b
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
@@ -0,0 +1,93 @@
+# [10032. 使数组异或和等于 K 的最少操作次数](https://leetcode.cn/problems/minimum-number-of-operations-to-make-array-xor-equal-to-k)
+
+[English Version](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README_EN.md)
+
+## 题目描述
+
+
+
+给你一个下标从 0 开始的整数数组 nums 和一个正整数 k 。
+
+你可以对数组执行以下操作 任意次 ：
+
+
+ - 选择数组里的 任意 一个元素，并将它的 二进制 表示 翻转 一个数位，翻转数位表示将
0 变成 1 或者将 1 变成 0 。
+
+
+你的目标是让数组里 所有 元素的按位异或和得到 k ，请你返回达成这一目标的 最少 操作次数。
+
+注意，你也可以将一个数的前导 0 翻转。比方说，数字 (101)2 翻转第四个数位，得到 (1101)2 。
+
+
+
+示例 1：
+
+
+输入：nums = [2,1,3,4], k = 1
+输出：2
+解释：我们可以执行以下操作：
+- 选择下标为 2 的元素，也就是 3 == (011)2 ，我们翻转第一个数位得到 (010)2 == 2 。数组变为 [2,1,2,4] 。
+- 选择下标为 0 的元素，也就是 2 == (010)2 ，我们翻转第三个数位得到 (110)2 == 6 。数组变为 [6,1,2,4] 。
+最终数组的所有元素异或和为 (6 XOR 1 XOR 2 XOR 4) == 1 == k 。
+无法用少于 2 次操作得到异或和等于 k 。
+
+
+示例 2：
+
+
+输入：nums = [2,0,2,0], k = 0
+输出：0
+解释：数组所有元素的异或和为 (2 XOR 0 XOR 2 XOR 0) == 0 == k 。所以不需要进行任何操作。
+
+
+
+
+提示：
+
+
+ 1 <= nums.length <= 1050 <= nums[i] <= 1060 <= k <= 106
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
new file mode 100644
index 0000000000000..cc60b43f70e3a
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
@@ -0,0 +1,83 @@
+# [10032. Minimum Number of Operations to Make Array XOR Equal to K](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-xor-equal-to-k)
+
+[中文文档](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README.md)
+
+## Description
+
+You are given a 0-indexed integer array nums and a positive integer k.
+
+You can apply the following operation on the array any number of times:
+
+
+ - Choose any element of the array and flip a bit in its binary representation. Flipping a bit means changing a
0 to 1 or vice versa.
+
+
+Return the minimum number of operations required to make the bitwise XOR of all elements of the final array equal to k.
+
+Note that you can flip leading zero bits in the binary representation of elements. For example, for the number (101)2 you can flip the fourth bit and obtain (1101)2.
+
+
+Example 1:
+
+
+Input: nums = [2,1,3,4], k = 1
+Output: 2
+Explanation: We can do the following operations:
+- Choose element 2 which is 3 == (011)2, we flip the first bit and we obtain (010)2 == 2. nums becomes [2,1,2,4].
+- Choose element 0 which is 2 == (010)2, we flip the third bit and we obtain (110)2 = 6. nums becomes [6,1,2,4].
+The XOR of elements of the final array is (6 XOR 1 XOR 2 XOR 4) == 1 == k.
+It can be shown that we cannot make the XOR equal to k in less than 2 operations.
+
+
+Example 2:
+
+
+Input: nums = [2,0,2,0], k = 0
+Output: 0
+Explanation: The XOR of elements of the array is (2 XOR 0 XOR 2 XOR 0) == 0 == k. So no operation is needed.
+
+
+
+Constraints:
+
+
+ 1 <= nums.length <= 1050 <= nums[i] <= 1060 <= k <= 106
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
new file mode 100644
index 0000000000000..09ca5b0e33469
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
@@ -0,0 +1,111 @@
+# [10033. 使 X 和 Y 相等的最少操作次数](https://leetcode.cn/problems/minimum-number-of-operations-to-make-x-and-y-equal)
+
+[English Version](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README_EN.md)
+
+## 题目描述
+
+
+
+给你两个正整数 x 和 y 。
+
+一次操作中，你可以执行以下四种操作之一：
+
+
+ - 如果
x 是 11 的倍数，将 x 除以 11 。
+ - 如果
x 是 5 的倍数，将 x 除以 5 。
+ - 将
x 减 1 。
+ - 将
x 加 1 。
+
+
+请你返回让 x 和 y 相等的 最少 操作次数。
+
+
+
+示例 1：
+
+
+输入：x = 26, y = 1
+输出：3
+解释：我们可以通过以下操作将 26 变为 1 ：
+1. 将 x 减 1
+2. 将 x 除以 5
+3. 将 x 除以 5
+将 26 变为 1 最少需要 3 次操作。
+
+
+示例 2：
+
+
+输入：x = 54, y = 2
+输出：4
+解释：我们可以通过以下操作将 54 变为 2 ：
+1. 将 x 加 1
+2. 将 x 除以 11
+3. 将 x 除以 5
+4. 将 x 加 1
+将 54 变为 2 最少需要 4 次操作。
+
+
+示例 3：
+
+
+输入：x = 25, y = 30
+输出：5
+解释：我们可以通过以下操作将 25 变为 30 ：
+1. 将 x 加 1
+2. 将 x 加 1
+3. 将 x 加 1
+4. 将 x 加 1
+5. 将 x 加 1
+将 25 变为 30 最少需要 5 次操作。
+
+
+
+
+提示：
+
+
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
new file mode 100644
index 0000000000000..7377bf7787b80
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
@@ -0,0 +1,101 @@
+# [10033. Minimum Number of Operations to Make X and Y Equal](https://leetcode.com/problems/minimum-number-of-operations-to-make-x-and-y-equal)
+
+[中文文档](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README.md)
+
+## Description
+
+You are given two positive integers x and y.
+
+In one operation, you can do one of the four following operations:
+
+
+ - Divide
x by 11 if x is a multiple of 11.
+ - Divide
x by 5 if x is a multiple of 5.
+ - Decrement
x by 1.
+ - Increment
x by 1.
+
+
+Return the minimum number of operations required to make x and y equal.
+
+
+Example 1:
+
+
+Input: x = 26, y = 1
+Output: 3
+Explanation: We can make 26 equal to 1 by applying the following operations:
+1. Decrement x by 1
+2. Divide x by 5
+3. Divide x by 5
+It can be shown that 3 is the minimum number of operations required to make 26 equal to 1.
+
+
+Example 2:
+
+
+Input: x = 54, y = 2
+Output: 4
+Explanation: We can make 54 equal to 2 by applying the following operations:
+1. Increment x by 1
+2. Divide x by 11
+3. Divide x by 5
+4. Increment x by 1
+It can be shown that 4 is the minimum number of operations required to make 54 equal to 2.
+
+
+Example 3:
+
+
+Input: x = 25, y = 30
+Output: 5
+Explanation: We can make 25 equal to 30 by applying the following operations:
+1. Increment x by 1
+2. Increment x by 1
+3. Increment x by 1
+4. Increment x by 1
+5. Increment x by 1
+It can be shown that 5 is the minimum number of operations required to make 25 equal to 30.
+
+
+
+Constraints:
+
+
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10034.Count the Number of Powerful Integers/README.md b/solution/10000-10099/10034.Count the Number of Powerful Integers/README.md
new file mode 100644
index 0000000000000..dc1aeeff8a12d
--- /dev/null
+++ b/solution/10000-10099/10034.Count the Number of Powerful Integers/README.md
@@ -0,0 +1,97 @@
+# [10034. 统计强大整数的数目](https://leetcode.cn/problems/count-the-number-of-powerful-integers)
+
+[English Version](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README_EN.md)
+
+## 题目描述
+
+
+
+给你三个整数 start ，finish 和 limit 。同时给你一个下标从 0 开始的字符串 s ，表示一个 正 整数。
+
+如果一个 正 整数 x 末尾部分是 s （换句话说，s 是 x 的 后缀），且 x 中的每个数位至多是 limit ，那么我们称 x 是 强大的 。
+
+请你返回区间 [start..finish] 内强大整数的 总数目 。
+
+如果一个字符串 x 是 y 中某个下标开始（包括 0 ），到下标为 y.length - 1 结束的子字符串，那么我们称 x 是 y 的一个后缀。比方说，25 是 5125 的一个后缀，但不是 512 的后缀。
+
+
+
+示例 1：
+
+
+输入：start = 1, finish = 6000, limit = 4, s = "124"
+输出：5
+解释：区间 [1..6000] 内的强大数字为 124 ，1124 ，2124 ，3124 和 4124 。这些整数的各个数位都 <= 4 且 "124" 是它们的后缀。注意 5124 不是强大整数，因为第一个数位 5 大于 4 。
+这个区间内总共只有这 5 个强大整数。
+
+
+示例 2：
+
+
+输入：start = 15, finish = 215, limit = 6, s = "10"
+输出：2
+解释：区间 [15..215] 内的强大整数为 110 和 210 。这些整数的各个数位都 <= 6 且 "10" 是它们的后缀。
+这个区间总共只有这 2 个强大整数。
+
+
+示例 3：
+
+
+输入：start = 1000, finish = 2000, limit = 4, s = "3000"
+输出：0
+解释：区间 [1000..2000] 内的整数都小于 3000 ，所以 "3000" 不可能是这个区间内任何整数的后缀。
+
+
+
+
+提示：
+
+
+ 1 <= start <= finish <= 10151 <= limit <= 91 <= s.length <= floor(log10(finish)) + 1s 数位中每个数字都小于等于 limit 。s 不包含任何前导 0 。
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10034.Count the Number of Powerful Integers/README_EN.md b/solution/10000-10099/10034.Count the Number of Powerful Integers/README_EN.md
new file mode 100644
index 0000000000000..7a8451f39efe0
--- /dev/null
+++ b/solution/10000-10099/10034.Count the Number of Powerful Integers/README_EN.md
@@ -0,0 +1,87 @@
+# [10034. Count the Number of Powerful Integers](https://leetcode.com/problems/count-the-number-of-powerful-integers)
+
+[中文文档](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README.md)
+
+## Description
+
+You are given three integers start, finish, and limit. You are also given a 0-indexed string s representing a positive integer.
+
+A positive integer x is called powerful if it ends with s (in other words, s is a suffix of x) and each digit in x is at most limit.
+
+Return the total number of powerful integers in the range [start..finish].
+
+A string x is a suffix of a string y if and only if x is a substring of y that starts from some index (including 0) in y and extends to the index y.length - 1. For example, 25 is a suffix of 5125 whereas 512 is not.
+
+
+Example 1:
+
+
+Input: start = 1, finish = 6000, limit = 4, s = "124"
+Output: 5
+Explanation: The powerful integers in the range [1..6000] are 124, 1124, 2124, 3124, and, 4124. All these integers have each digit <= 4, and "124" as a suffix. Note that 5124 is not a powerful integer because the first digit is 5 which is greater than 4.
+It can be shown that there are only 5 powerful integers in this range.
+
+
+Example 2:
+
+
+Input: start = 15, finish = 215, limit = 6, s = "10"
+Output: 2
+Explanation: The powerful integers in the range [15..215] are 110 and 210. All these integers have each digit <= 6, and "10" as a suffix.
+It can be shown that there are only 2 powerful integers in this range.
+
+
+Example 3:
+
+
+Input: start = 1000, finish = 2000, limit = 4, s = "3000"
+Output: 0
+Explanation: All integers in the range [1000..2000] are smaller than 3000, hence "3000" cannot be a suffix of any integer in this range.
+
+
+
+Constraints:
+
+
+ 1 <= start <= finish <= 10151 <= limit <= 91 <= s.length <= floor(log10(finish)) + 1s only consists of numeric digits which are at most limit.s does not have leading zeros.
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/CONTEST_README.md b/solution/CONTEST_README.md
index aca013d3b07de..2db1f3ed66f28 100644
--- a/solution/CONTEST_README.md
+++ b/solution/CONTEST_README.md
@@ -22,6 +22,13 @@
## 往期竞赛
+#### 第 121 场双周赛(2024-01-06 22:30, 90 分钟) 参赛人数 2218
+
+- [10031. 大于等于顺序前缀和的最小缺失整数](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README.md)
+- [10032. 使数组异或和等于 K 的最少操作次数](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README.md)
+- [10033. 使 X 和 Y 相等的最少操作次数](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README.md)
+- [10034. 统计强大整数的数目](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README.md)
+
#### 第 378 场周赛(2023-12-31 10:30, 90 分钟) 参赛人数 2747
- [2980. 检查按位或是否存在尾随零](/solution/2900-2999/2980.Check%20if%20Bitwise%20OR%20Has%20Trailing%20Zeros/README.md)
diff --git a/solution/CONTEST_README_EN.md b/solution/CONTEST_README_EN.md
index b52182a8992a5..73e2ce765ce2f 100644
--- a/solution/CONTEST_README_EN.md
+++ b/solution/CONTEST_README_EN.md
@@ -25,6 +25,13 @@ Get your rating changes right after the completion of LeetCode contests, https:/
## Past Contests
+#### Biweekly Contest 121
+
+- [10031. Smallest Missing Integer Greater Than Sequential Prefix Sum](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README_EN.md)
+- [10032. Minimum Number of Operations to Make Array XOR Equal to K](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README_EN.md)
+- [10033. Minimum Number of Operations to Make X and Y Equal](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README_EN.md)
+- [10034. Count the Number of Powerful Integers](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README_EN.md)
+
#### Weekly Contest 378
- [2980. Check if Bitwise OR Has Trailing Zeros](/solution/2900-2999/2980.Check%20if%20Bitwise%20OR%20Has%20Trailing%20Zeros/README_EN.md)
diff --git a/solution/README.md b/solution/README.md
index ba104a4c232a2..406559bf185f7 100644
--- a/solution/README.md
+++ b/solution/README.md
@@ -1014,6 +1014,10 @@
| 1001 | [网格照明](/solution/1000-1099/1001.Grid%20Illumination/README.md) | `数组`,`哈希表` | 困难 | 第 125 场周赛 |
| 1002 | [查找共用字符](/solution/1000-1099/1002.Find%20Common%20Characters/README.md) | `数组`,`哈希表`,`字符串` | 简单 | 第 126 场周赛 |
| 1003 | [检查替换后的词是否有效](/solution/1000-1099/1003.Check%20If%20Word%20Is%20Valid%20After%20Substitutions/README.md) | `栈`,`字符串` | 中等 | 第 126 场周赛 |
+| 10031 | [大于等于顺序前缀和的最小缺失整数](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README.md) | | 简单 | 第 121 场双周赛 |
+| 10032 | [使数组异或和等于 K 的最少操作次数](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README.md) | | 中等 | 第 121 场双周赛 |
+| 10033 | [使 X 和 Y 相等的最少操作次数](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README.md) | | 中等 | 第 121 场双周赛 |
+| 10034 | [统计强大整数的数目](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README.md) | | 困难 | 第 121 场双周赛 |
| 1004 | [最大连续1的个数 III](/solution/1000-1099/1004.Max%20Consecutive%20Ones%20III/README.md) | `数组`,`二分查找`,`前缀和`,`滑动窗口` | 中等 | 第 126 场周赛 |
| 1005 | [K 次取反后最大化的数组和](/solution/1000-1099/1005.Maximize%20Sum%20Of%20Array%20After%20K%20Negations/README.md) | `贪心`,`数组`,`排序` | 简单 | 第 127 场周赛 |
| 1006 | [笨阶乘](/solution/1000-1099/1006.Clumsy%20Factorial/README.md) | `栈`,`数学`,`模拟` | 中等 | 第 127 场周赛 |
diff --git a/solution/README_EN.md b/solution/README_EN.md
index 446286e79191e..9277b30a025e8 100644
--- a/solution/README_EN.md
+++ b/solution/README_EN.md
@@ -1012,6 +1012,10 @@ Press Control + F(or Command + F on
| 1001 | [Grid Illumination](/solution/1000-1099/1001.Grid%20Illumination/README_EN.md) | `Array`,`Hash Table` | Hard | Weekly Contest 125 |
| 1002 | [Find Common Characters](/solution/1000-1099/1002.Find%20Common%20Characters/README_EN.md) | `Array`,`Hash Table`,`String` | Easy | Weekly Contest 126 |
| 1003 | [Check If Word Is Valid After Substitutions](/solution/1000-1099/1003.Check%20If%20Word%20Is%20Valid%20After%20Substitutions/README_EN.md) | `Stack`,`String` | Medium | Weekly Contest 126 |
+| 10031 | [Smallest Missing Integer Greater Than Sequential Prefix Sum](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README_EN.md) | | Easy | Biweekly Contest 121 |
+| 10032 | [Minimum Number of Operations to Make Array XOR Equal to K](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README_EN.md) | | Medium | Biweekly Contest 121 |
+| 10033 | [Minimum Number of Operations to Make X and Y Equal](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README_EN.md) | | Medium | Biweekly Contest 121 |
+| 10034 | [Count the Number of Powerful Integers](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README_EN.md) | | Hard | Biweekly Contest 121 |
| 1004 | [Max Consecutive Ones III](/solution/1000-1099/1004.Max%20Consecutive%20Ones%20III/README_EN.md) | `Array`,`Binary Search`,`Prefix Sum`,`Sliding Window` | Medium | Weekly Contest 126 |
| 1005 | [Maximize Sum Of Array After K Negations](/solution/1000-1099/1005.Maximize%20Sum%20Of%20Array%20After%20K%20Negations/README_EN.md) | `Greedy`,`Array`,`Sorting` | Easy | Weekly Contest 127 |
| 1006 | [Clumsy Factorial](/solution/1000-1099/1006.Clumsy%20Factorial/README_EN.md) | `Stack`,`Math`,`Simulation` | Medium | Weekly Contest 127 |
diff --git a/solution/summary.md b/solution/summary.md
index 39ee62e053b44..24748a8f8e242 100644
--- a/solution/summary.md
+++ b/solution/summary.md
@@ -1120,6 +1120,12 @@
- [1098.小众书籍](/solution/1000-1099/1098.Unpopular%20Books/README.md)
- [1099.小于 K 的两数之和](/solution/1000-1099/1099.Two%20Sum%20Less%20Than%20K/README.md)
+- 10000-10099
+ - [10031检查替换后的词是否有效](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README.md)
+ - [10032检查替换后的词是否有效](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README.md)
+ - [10033检查替换后的词是否有效](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README.md)
+ - [10034检查替换后的词是否有效](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README.md)
+
- 1100-1199
- [1100.长度为 K 的无重复字符子串](/solution/1100-1199/1100.Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters/README.md)
- [1101.彼此熟识的最早时间](/solution/1100-1199/1101.The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends/README.md)
diff --git a/solution/summary_en.md b/solution/summary_en.md
index cdfd81174d895..bbd2e3f04acf3 100644
--- a/solution/summary_en.md
+++ b/solution/summary_en.md
@@ -1120,6 +1120,12 @@
- [1098.Unpopular Books](/solution/1000-1099/1098.Unpopular%20Books/README_EN.md)
- [1099.Two Sum Less Than K](/solution/1000-1099/1099.Two%20Sum%20Less%20Than%20K/README_EN.md)
+- 10000-10099
+ - [10031.Smallest Missing Integer Greater Than Sequential Prefix Sum](/solution/10000-10099/10031.Smallest%20Missing%20Integer%20Greater%20Than%20Sequential%20Prefix%20Sum/README_EN.md)
+ - [10032.Minimum Number of Operations to Make Array XOR Equal to K](/solution/10000-10099/10032.Minimum%20Number%20of%20Operations%20to%20Make%20Array%20XOR%20Equal%20to%20K/README_EN.md)
+ - [10033.Minimum Number of Operations to Make X and Y Equal](/solution/10000-10099/10033.Minimum%20Number%20of%20Operations%20to%20Make%20X%20and%20Y%20Equal/README_EN.md)
+ - [10034.Count the Number of Powerful Integers](/solution/10000-10099/10034.Count%20the%20Number%20of%20Powerful%20Integers/README_EN.md)
+
- 1100-1199
- [1100.Find K-Length Substrings With No Repeated Characters](/solution/1100-1199/1100.Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters/README_EN.md)
- [1101.The Earliest Moment When Everyone Become Friends](/solution/1100-1199/1101.The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends/README_EN.md)
From 07290a113add5177f26247c089a664b4bee0dcce Mon Sep 17 00:00:00 2001
From: Libin YANG
Date: Sun, 7 Jan 2024 12:50:08 +0800
Subject: [PATCH 2/5] feat: add solutions to lc problems: No.10031+ (#2189)
---
solution/0300-0399/0383.Ransom Note/README.md | 2 +-
.../0300-0399/0383.Ransom Note/README_EN.md | 2 +-
.../0300-0399/0383.Ransom Note/Solution.ts | 2 +-
.../README.md | 84 +++++++++++++-
.../README_EN.md | 84 +++++++++++++-
.../Solution.cpp | 18 +++
.../Solution.go | 15 +++
.../Solution.java | 17 +++
.../Solution.py | 11 ++
.../Solution.ts | 16 +++
.../README.md | 64 ++++++++++-
.../README_EN.md | 64 ++++++++++-
.../Solution.cpp | 14 +++
.../Solution.go | 10 ++
.../Solution.java | 13 +++
.../Solution.py | 9 ++
.../Solution.ts | 11 ++
.../README.md | 105 +++++++++++++++++-
.../README_EN.md | 105 +++++++++++++++++-
.../Solution.cpp | 20 ++++
.../Solution.go | 19 ++++
.../Solution.java | 26 +++++
.../Solution.py | 14 +++
.../Solution.ts | 19 ++++
24 files changed, 723 insertions(+), 21 deletions(-)
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.cpp
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.go
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.java
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.py
create mode 100644 solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.ts
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.cpp
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.go
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.java
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.py
create mode 100644 solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.ts
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.cpp
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.go
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.java
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.py
create mode 100644 solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.ts
diff --git a/solution/0300-0399/0383.Ransom Note/README.md b/solution/0300-0399/0383.Ransom Note/README.md
index 5c720a3b45638..44cabea0cfd21 100644
--- a/solution/0300-0399/0383.Ransom Note/README.md
+++ b/solution/0300-0399/0383.Ransom Note/README.md
@@ -136,7 +136,7 @@ func canConstruct(ransomNote string, magazine string) bool {
```ts
function canConstruct(ransomNote: string, magazine: string): boolean {
- const cnt = new Array(26).fill(0);
+ const cnt: number[] = Array(26).fill(0);
for (const c of magazine) {
++cnt[c.charCodeAt(0) - 97];
}
diff --git a/solution/0300-0399/0383.Ransom Note/README_EN.md b/solution/0300-0399/0383.Ransom Note/README_EN.md
index 2c792b73cd809..e3a3698e4ef77 100644
--- a/solution/0300-0399/0383.Ransom Note/README_EN.md
+++ b/solution/0300-0399/0383.Ransom Note/README_EN.md
@@ -113,7 +113,7 @@ func canConstruct(ransomNote string, magazine string) bool {
```ts
function canConstruct(ransomNote: string, magazine: string): boolean {
- const cnt = new Array(26).fill(0);
+ const cnt: number[] = Array(26).fill(0);
for (const c of magazine) {
++cnt[c.charCodeAt(0) - 97];
}
diff --git a/solution/0300-0399/0383.Ransom Note/Solution.ts b/solution/0300-0399/0383.Ransom Note/Solution.ts
index 66a65595b63e0..7fe6ae0705da8 100644
--- a/solution/0300-0399/0383.Ransom Note/Solution.ts
+++ b/solution/0300-0399/0383.Ransom Note/Solution.ts
@@ -1,5 +1,5 @@
function canConstruct(ransomNote: string, magazine: string): boolean {
- const cnt = new Array(26).fill(0);
+ const cnt: number[] = Array(26).fill(0);
for (const c of magazine) {
++cnt[c.charCodeAt(0) - 97];
}
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
index bb4fbf59fc392..c626bbeccbab7 100644
--- a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README.md
@@ -50,7 +50,17 @@
```python
-
+class Solution:
+ def missingInteger(self, nums: List[int]) -> int:
+ s, n = nums[0], len(nums)
+ j = 1
+ while j < len(nums) and nums[j] == nums[j - 1] + 1:
+ s += nums[j]
+ j += 1
+ vis = set(nums)
+ for x in count(s):
+ if x not in vis:
+ return x
```
### **Java**
@@ -58,19 +68,87 @@
```java
-
+class Solution {
+ public int missingInteger(int[] nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.length && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ boolean[] vis = new boolean[51];
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int missingInteger(vector& nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.size() && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ bool vis[51]{};
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= 51 || !vis[x]) {
+ return x;
+ }
+ }
+ }
+};
```
### **Go**
```go
+func missingInteger(nums []int) int {
+ s, j := nums[0], 1
+ for j < len(nums) && nums[j] == nums[j-1]+1 {
+ s, j = s+nums[j], j+1
+ }
+ vis := [51]bool{}
+ for _, x := range nums {
+ vis[x] = true
+ }
+ for x := s; ; x++ {
+ if x >= len(vis) || !vis[x] {
+ return x
+ }
+ }
+}
+```
+### **TypeScript**
+
+```ts
+function missingInteger(nums: number[]): number {
+ let [s, j] = [nums[0], 1];
+ const n = nums.length;
+ while (j < n && nums[j] === nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ const vis: boolean[] = Array(51).fill(false);
+ for (const x of nums) {
+ vis[x] = true;
+ }
+ for (let x = s; ; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+}
```
### **...**
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
index a1edd49e3820e..9667644b4f00a 100644
--- a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/README_EN.md
@@ -42,25 +42,103 @@
### **Python3**
```python
-
+class Solution:
+ def missingInteger(self, nums: List[int]) -> int:
+ s, n = nums[0], len(nums)
+ j = 1
+ while j < len(nums) and nums[j] == nums[j - 1] + 1:
+ s += nums[j]
+ j += 1
+ vis = set(nums)
+ for x in count(s):
+ if x not in vis:
+ return x
```
### **Java**
```java
-
+class Solution {
+ public int missingInteger(int[] nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.length && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ boolean[] vis = new boolean[51];
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int missingInteger(vector& nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.size() && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ bool vis[51]{};
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= 51 || !vis[x]) {
+ return x;
+ }
+ }
+ }
+};
```
### **Go**
```go
+func missingInteger(nums []int) int {
+ s, j := nums[0], 1
+ for j < len(nums) && nums[j] == nums[j-1]+1 {
+ s, j = s+nums[j], j+1
+ }
+ vis := [51]bool{}
+ for _, x := range nums {
+ vis[x] = true
+ }
+ for x := s; ; x++ {
+ if x >= len(vis) || !vis[x] {
+ return x
+ }
+ }
+}
+```
+### **TypeScript**
+
+```ts
+function missingInteger(nums: number[]): number {
+ let [s, j] = [nums[0], 1];
+ const n = nums.length;
+ while (j < n && nums[j] === nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ const vis: boolean[] = Array(51).fill(false);
+ for (const x of nums) {
+ vis[x] = true;
+ }
+ for (let x = s; ; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+}
```
### **...**
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.cpp b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.cpp
new file mode 100644
index 0000000000000..6081ba54c6b44
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+ int missingInteger(vector& nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.size() && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ bool vis[51]{};
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= 51 || !vis[x]) {
+ return x;
+ }
+ }
+ }
+};
\ No newline at end of file
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.go b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.go
new file mode 100644
index 0000000000000..26f4a6d360c78
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.go
@@ -0,0 +1,15 @@
+func missingInteger(nums []int) int {
+ s, j := nums[0], 1
+ for j < len(nums) && nums[j] == nums[j-1]+1 {
+ s, j = s+nums[j], j+1
+ }
+ vis := [51]bool{}
+ for _, x := range nums {
+ vis[x] = true
+ }
+ for x := s; ; x++ {
+ if x >= len(vis) || !vis[x] {
+ return x
+ }
+ }
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.java b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.java
new file mode 100644
index 0000000000000..14710bee62193
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.java
@@ -0,0 +1,17 @@
+class Solution {
+ public int missingInteger(int[] nums) {
+ int s = nums[0], j = 1;
+ while (j < nums.length && nums[j] == nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ boolean[] vis = new boolean[51];
+ for (int x : nums) {
+ vis[x] = true;
+ }
+ for (int x = s;; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.py b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.py
new file mode 100644
index 0000000000000..70bc58d87facf
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.py
@@ -0,0 +1,11 @@
+class Solution:
+ def missingInteger(self, nums: List[int]) -> int:
+ s, n = nums[0], len(nums)
+ j = 1
+ while j < len(nums) and nums[j] == nums[j - 1] + 1:
+ s += nums[j]
+ j += 1
+ vis = set(nums)
+ for x in count(s):
+ if x not in vis:
+ return x
diff --git a/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.ts b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.ts
new file mode 100644
index 0000000000000..97932f3652710
--- /dev/null
+++ b/solution/10000-10099/10031.Smallest Missing Integer Greater Than Sequential Prefix Sum/Solution.ts
@@ -0,0 +1,16 @@
+function missingInteger(nums: number[]): number {
+ let [s, j] = [nums[0], 1];
+ const n = nums.length;
+ while (j < n && nums[j] === nums[j - 1] + 1) {
+ s += nums[j++];
+ }
+ const vis: boolean[] = Array(51).fill(false);
+ for (const x of nums) {
+ vis[x] = true;
+ }
+ for (let x = s; ; ++x) {
+ if (x >= vis.length || !vis[x]) {
+ return x;
+ }
+ }
+}
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
index 5d2aec6532e0b..9630bdd603fe3 100644
--- a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README.md
@@ -61,7 +61,15 @@
```python
-
+class Solution:
+ def minOperations(self, nums: List[int], k: int) -> int:
+ ans = 0
+ for i in range(20):
+ v = 0
+ for x in nums:
+ v ^= x >> i & 1
+ ans += (k >> i & 1) != v
+ return ans
```
### **Java**
@@ -69,19 +77,69 @@
```java
-
+class Solution {
+ public int minOperations(int[] nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int minOperations(vector& nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+};
```
### **Go**
```go
+func minOperations(nums []int, k int) (ans int) {
+ for i := 0; i < 20; i++ {
+ v := 0
+ for _, x := range nums {
+ v ^= x >> i & 1
+ }
+ ans += k>>i&1 ^ v
+ }
+ return
+}
+```
+### **TypeScript**
+
+```ts
+function minOperations(nums: number[], k: number): number {
+ let ans = 0;
+ for (let i = 0; i < 20; ++i) {
+ let v = 0;
+ for (const x of nums) {
+ v ^= (x >> i) & 1;
+ }
+ ans += ((k >> i) & 1) ^ v;
+ }
+ return ans;
+}
```
### **...**
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
index cc60b43f70e3a..1d44e8a3661ef 100644
--- a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/README_EN.md
@@ -53,25 +53,83 @@ It can be shown that we cannot make the XOR equal to k in less than 2 operations
### **Python3**
```python
-
+class Solution:
+ def minOperations(self, nums: List[int], k: int) -> int:
+ ans = 0
+ for i in range(20):
+ v = 0
+ for x in nums:
+ v ^= x >> i & 1
+ ans += (k >> i & 1) != v
+ return ans
```
### **Java**
```java
-
+class Solution {
+ public int minOperations(int[] nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int minOperations(vector& nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+};
```
### **Go**
```go
+func minOperations(nums []int, k int) (ans int) {
+ for i := 0; i < 20; i++ {
+ v := 0
+ for _, x := range nums {
+ v ^= x >> i & 1
+ }
+ ans += k>>i&1 ^ v
+ }
+ return
+}
+```
+### **TypeScript**
+
+```ts
+function minOperations(nums: number[], k: number): number {
+ let ans = 0;
+ for (let i = 0; i < 20; ++i) {
+ let v = 0;
+ for (const x of nums) {
+ v ^= (x >> i) & 1;
+ }
+ ans += ((k >> i) & 1) ^ v;
+ }
+ return ans;
+}
```
### **...**
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.cpp b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.cpp
new file mode 100644
index 0000000000000..7717cfa06fc7d
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+ int minOperations(vector& nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+};
\ No newline at end of file
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.go b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.go
new file mode 100644
index 0000000000000..a8c6b5278ac66
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.go
@@ -0,0 +1,10 @@
+func minOperations(nums []int, k int) (ans int) {
+ for i := 0; i < 20; i++ {
+ v := 0
+ for _, x := range nums {
+ v ^= x >> i & 1
+ }
+ ans += k>>i&1 ^ v
+ }
+ return
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.java b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.java
new file mode 100644
index 0000000000000..5c13d4f76094b
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.java
@@ -0,0 +1,13 @@
+class Solution {
+ public int minOperations(int[] nums, int k) {
+ int ans = 0;
+ for (int i = 0; i < 20; ++i) {
+ int v = 0;
+ for (int x : nums) {
+ v ^= (x >> i & 1);
+ }
+ ans += k >> i & 1 ^ v;
+ }
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.py b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.py
new file mode 100644
index 0000000000000..92fdc83805505
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.py
@@ -0,0 +1,9 @@
+class Solution:
+ def minOperations(self, nums: List[int], k: int) -> int:
+ ans = 0
+ for i in range(20):
+ v = 0
+ for x in nums:
+ v ^= x >> i & 1
+ ans += (k >> i & 1) != v
+ return ans
diff --git a/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.ts b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.ts
new file mode 100644
index 0000000000000..142deff264ddb
--- /dev/null
+++ b/solution/10000-10099/10032.Minimum Number of Operations to Make Array XOR Equal to K/Solution.ts
@@ -0,0 +1,11 @@
+function minOperations(nums: number[], k: number): number {
+ let ans = 0;
+ for (let i = 0; i < 20; ++i) {
+ let v = 0;
+ for (const x of nums) {
+ v ^= (x >> i) & 1;
+ }
+ ans += ((k >> i) & 1) ^ v;
+ }
+ return ans;
+}
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
index 09ca5b0e33469..ed84d0115a5e6 100644
--- a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README.md
@@ -79,7 +79,20 @@
```python
-
+class Solution:
+ def minimumOperationsToMakeEqual(self, x: int, y: int) -> int:
+ @cache
+ def dfs(x: int) -> int:
+ if y >= x:
+ return y - x
+ ans = x - y
+ ans = min(ans, x % 5 + 1 + dfs(x // 5))
+ ans = min(ans, 5 - x % 5 + 1 + dfs(x // 5 + 1))
+ ans = min(ans, x % 11 + 1 + dfs(x // 11))
+ ans = min(ans, 11 - x % 11 + 1 + dfs(x // 11 + 1))
+ return ans
+
+ return dfs(x)
```
### **Java**
@@ -87,19 +100,105 @@
```java
-
+class Solution {
+ private Map f = new HashMap<>();
+ private int y;
+
+ public int minimumOperationsToMakeEqual(int x, int y) {
+ this.y = y;
+ return dfs(x);
+ }
+
+ private int dfs(int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.containsKey(x)) {
+ return f.get(x);
+ }
+ int ans = x - y;
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ ans = Math.min(ans, Math.min(a, Math.min(b, Math.min(c, d))));
+ f.put(x, ans);
+ return ans;
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int minimumOperationsToMakeEqual(int x, int y) {
+ unordered_map f;
+ function dfs = [&](int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.count(x)) {
+ return f[x];
+ }
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ return f[x] = min({x - y, a, b, c, d});
+ };
+ return dfs(x);
+ }
+};
```
### **Go**
```go
+func minimumOperationsToMakeEqual(x int, y int) int {
+ f := map[int]int{}
+ var dfs func(int) int
+ dfs = func(x int) int {
+ if y >= x {
+ return y - x
+ }
+ if v, ok := f[x]; ok {
+ return v
+ }
+ a := x%5 + 1 + dfs(x/5)
+ b := 5 - x%5 + 1 + dfs(x/5+1)
+ c := x%11 + 1 + dfs(x/11)
+ d := 11 - x%11 + 1 + dfs(x/11+1)
+ f[x] = min(x-y, a, b, c, d)
+ return f[x]
+ }
+ return dfs(x)
+}
+```
+### **TypeScript**
+
+```ts
+function minimumOperationsToMakeEqual(x: number, y: number): number {
+ const f: Map = new Map();
+ const dfs = (x: number): number => {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.has(x)) {
+ return f.get(x)!;
+ }
+ const a = (x % 5) + 1 + dfs((x / 5) | 0);
+ const b = 5 - (x % 5) + 1 + dfs(((x / 5) | 0) + 1);
+ const c = (x % 11) + 1 + dfs((x / 11) | 0);
+ const d = 11 - (x % 11) + 1 + dfs(((x / 11) | 0) + 1);
+ const ans = Math.min(x - y, a, b, c, d);
+ f.set(x, ans);
+ return ans;
+ };
+ return dfs(x);
+}
```
### **...**
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
index 7377bf7787b80..e88607cad372f 100644
--- a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/README_EN.md
@@ -71,25 +71,124 @@ It can be shown that 5 is the minimum number of operations required to make 25 e
### **Python3**
```python
-
+class Solution:
+ def minimumOperationsToMakeEqual(self, x: int, y: int) -> int:
+ @cache
+ def dfs(x: int) -> int:
+ if y >= x:
+ return y - x
+ ans = x - y
+ ans = min(ans, x % 5 + 1 + dfs(x // 5))
+ ans = min(ans, 5 - x % 5 + 1 + dfs(x // 5 + 1))
+ ans = min(ans, x % 11 + 1 + dfs(x // 11))
+ ans = min(ans, 11 - x % 11 + 1 + dfs(x // 11 + 1))
+ return ans
+
+ return dfs(x)
```
### **Java**
```java
-
+class Solution {
+ private Map f = new HashMap<>();
+ private int y;
+
+ public int minimumOperationsToMakeEqual(int x, int y) {
+ this.y = y;
+ return dfs(x);
+ }
+
+ private int dfs(int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.containsKey(x)) {
+ return f.get(x);
+ }
+ int ans = x - y;
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ ans = Math.min(ans, Math.min(a, Math.min(b, Math.min(c, d))));
+ f.put(x, ans);
+ return ans;
+ }
+}
```
### **C++**
```cpp
-
+class Solution {
+public:
+ int minimumOperationsToMakeEqual(int x, int y) {
+ unordered_map f;
+ function dfs = [&](int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.count(x)) {
+ return f[x];
+ }
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ return f[x] = min({x - y, a, b, c, d});
+ };
+ return dfs(x);
+ }
+};
```
### **Go**
```go
+func minimumOperationsToMakeEqual(x int, y int) int {
+ f := map[int]int{}
+ var dfs func(int) int
+ dfs = func(x int) int {
+ if y >= x {
+ return y - x
+ }
+ if v, ok := f[x]; ok {
+ return v
+ }
+ a := x%5 + 1 + dfs(x/5)
+ b := 5 - x%5 + 1 + dfs(x/5+1)
+ c := x%11 + 1 + dfs(x/11)
+ d := 11 - x%11 + 1 + dfs(x/11+1)
+ f[x] = min(x-y, a, b, c, d)
+ return f[x]
+ }
+ return dfs(x)
+}
+```
+### **TypeScript**
+
+```ts
+function minimumOperationsToMakeEqual(x: number, y: number): number {
+ const f: Map = new Map();
+ const dfs = (x: number): number => {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.has(x)) {
+ return f.get(x)!;
+ }
+ const a = (x % 5) + 1 + dfs((x / 5) | 0);
+ const b = 5 - (x % 5) + 1 + dfs(((x / 5) | 0) + 1);
+ const c = (x % 11) + 1 + dfs((x / 11) | 0);
+ const d = 11 - (x % 11) + 1 + dfs(((x / 11) | 0) + 1);
+ const ans = Math.min(x - y, a, b, c, d);
+ f.set(x, ans);
+ return ans;
+ };
+ return dfs(x);
+}
```
### **...**
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.cpp b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.cpp
new file mode 100644
index 0000000000000..5f739d9aa3f3f
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+ int minimumOperationsToMakeEqual(int x, int y) {
+ unordered_map f;
+ function dfs = [&](int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.count(x)) {
+ return f[x];
+ }
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ return f[x] = min({x - y, a, b, c, d});
+ };
+ return dfs(x);
+ }
+};
\ No newline at end of file
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.go b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.go
new file mode 100644
index 0000000000000..f06dea6c22c6f
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.go
@@ -0,0 +1,19 @@
+func minimumOperationsToMakeEqual(x int, y int) int {
+ f := map[int]int{}
+ var dfs func(int) int
+ dfs = func(x int) int {
+ if y >= x {
+ return y - x
+ }
+ if v, ok := f[x]; ok {
+ return v
+ }
+ a := x%5 + 1 + dfs(x/5)
+ b := 5 - x%5 + 1 + dfs(x/5+1)
+ c := x%11 + 1 + dfs(x/11)
+ d := 11 - x%11 + 1 + dfs(x/11+1)
+ f[x] = min(x-y, a, b, c, d)
+ return f[x]
+ }
+ return dfs(x)
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.java b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.java
new file mode 100644
index 0000000000000..8faf975eabce1
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.java
@@ -0,0 +1,26 @@
+class Solution {
+ private Map f = new HashMap<>();
+ private int y;
+
+ public int minimumOperationsToMakeEqual(int x, int y) {
+ this.y = y;
+ return dfs(x);
+ }
+
+ private int dfs(int x) {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.containsKey(x)) {
+ return f.get(x);
+ }
+ int ans = x - y;
+ int a = x % 5 + 1 + dfs(x / 5);
+ int b = 5 - x % 5 + 1 + dfs(x / 5 + 1);
+ int c = x % 11 + 1 + dfs(x / 11);
+ int d = 11 - x % 11 + 1 + dfs(x / 11 + 1);
+ ans = Math.min(ans, Math.min(a, Math.min(b, Math.min(c, d))));
+ f.put(x, ans);
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.py b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.py
new file mode 100644
index 0000000000000..bcfbce832d4ef
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.py
@@ -0,0 +1,14 @@
+class Solution:
+ def minimumOperationsToMakeEqual(self, x: int, y: int) -> int:
+ @cache
+ def dfs(x: int) -> int:
+ if y >= x:
+ return y - x
+ ans = x - y
+ ans = min(ans, x % 5 + 1 + dfs(x // 5))
+ ans = min(ans, 5 - x % 5 + 1 + dfs(x // 5 + 1))
+ ans = min(ans, x % 11 + 1 + dfs(x // 11))
+ ans = min(ans, 11 - x % 11 + 1 + dfs(x // 11 + 1))
+ return ans
+
+ return dfs(x)
diff --git a/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.ts b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.ts
new file mode 100644
index 0000000000000..27a3b8492f4cd
--- /dev/null
+++ b/solution/10000-10099/10033.Minimum Number of Operations to Make X and Y Equal/Solution.ts
@@ -0,0 +1,19 @@
+function minimumOperationsToMakeEqual(x: number, y: number): number {
+ const f: Map = new Map();
+ const dfs = (x: number): number => {
+ if (y >= x) {
+ return y - x;
+ }
+ if (f.has(x)) {
+ return f.get(x)!;
+ }
+ const a = (x % 5) + 1 + dfs((x / 5) | 0);
+ const b = 5 - (x % 5) + 1 + dfs(((x / 5) | 0) + 1);
+ const c = (x % 11) + 1 + dfs((x / 11) | 0);
+ const d = 11 - (x % 11) + 1 + dfs(((x / 11) | 0) + 1);
+ const ans = Math.min(x - y, a, b, c, d);
+ f.set(x, ans);
+ return ans;
+ };
+ return dfs(x);
+}
From a4b8b4ea37f2b73e92bae4ad005d65c3c269d7f8 Mon Sep 17 00:00:00 2001
From: acbin <44314231+acbin@users.noreply.github.com>
Date: Sun, 7 Jan 2024 16:31:23 +0800
Subject: [PATCH 3/5] feat: add weekly contest 379 (#2191)
---
.../README.md | 86 ++++++++++++
.../README_EN.md | 76 +++++++++++
.../README.md | 100 ++++++++++++++
.../README_EN.md | 90 +++++++++++++
.../images/ex1.png | Bin 0 -> 2059661 bytes
.../images/ex2.png | Bin 0 -> 2051228 bytes
.../README.md | 94 ++++++++++++++
.../README_EN.md | 85 ++++++++++++
.../README.md | 122 ++++++++++++++++++
.../README_EN.md | 113 ++++++++++++++++
solution/CONTEST_README.md | 7 +
solution/CONTEST_README_EN.md | 7 +
solution/README.md | 4 +
solution/README_EN.md | 4 +
solution/summary.md | 4 +
solution/summary_en.md | 4 +
16 files changed, 796 insertions(+)
create mode 100644 solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README.md
create mode 100644 solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README_EN.md
create mode 100644 solution/10000-10099/10036.Minimum Moves to Capture The Queen/README.md
create mode 100644 solution/10000-10099/10036.Minimum Moves to Capture The Queen/README_EN.md
create mode 100644 solution/10000-10099/10036.Minimum Moves to Capture The Queen/images/ex1.png
create mode 100644 solution/10000-10099/10036.Minimum Moves to Capture The Queen/images/ex2.png
create mode 100644 solution/10000-10099/10037.Maximum Size of a Set After Removals/README.md
create mode 100644 solution/10000-10099/10037.Maximum Size of a Set After Removals/README_EN.md
create mode 100644 solution/10000-10099/10038.Maximize the Number of Partitions After Operations/README.md
create mode 100644 solution/10000-10099/10038.Maximize the Number of Partitions After Operations/README_EN.md
diff --git a/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README.md b/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README.md
new file mode 100644
index 0000000000000..572f31398e032
--- /dev/null
+++ b/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README.md
@@ -0,0 +1,86 @@
+# [10035. 对角线最长的矩形的面积](https://leetcode.cn/problems/maximum-area-of-longest-diagonal-rectangle)
+
+[English Version](/solution/10000-10099/10035.Maximum%20Area%20of%20Longest%20Diagonal%20Rectangle/README_EN.md)
+
+## 题目描述
+
+
+
+给你一个下标从 0 开始的二维整数数组 dimensions。
+
+对于所有下标 i（0 <= i < dimensions.length），dimensions[i][0] 表示矩形 i 的长度，而 dimensions[i][1] 表示矩形 i 的宽度。
+
+返回对角线最 长 的矩形的 面积 。如果存在多个对角线长度相同的矩形，返回面积最 大 的矩形的面积。
+
+
+
+示例 1：
+
+
+输入：dimensions = [[9,3],[8,6]]
+输出：48
+解释：
+下标 = 0，长度 = 9，宽度 = 3。对角线长度 = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487。
+下标 = 1，长度 = 8，宽度 = 6。对角线长度 = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10。
+因此，下标为 1 的矩形对角线更长，所以返回面积 = 8 * 6 = 48。
+
+
+示例 2：
+
+
+输入：dimensions = [[3,4],[4,3]]
+输出：12
+解释：两个矩形的对角线长度相同，为 5，所以最大面积 = 12。
+
+
+
+
+提示：
+
+
+ 1 <= dimensions.length <= 100dimensions[i].length == 21 <= dimensions[i][0], dimensions[i][1] <= 100
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README_EN.md b/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README_EN.md
new file mode 100644
index 0000000000000..344d43c6d78f2
--- /dev/null
+++ b/solution/10000-10099/10035.Maximum Area of Longest Diagonal Rectangle/README_EN.md
@@ -0,0 +1,76 @@
+# [10035. Maximum Area of Longest Diagonal Rectangle](https://leetcode.com/problems/maximum-area-of-longest-diagonal-rectangle)
+
+[中文文档](/solution/10000-10099/10035.Maximum%20Area%20of%20Longest%20Diagonal%20Rectangle/README.md)
+
+## Description
+
+You are given a 2D 0-indexed integer array dimensions.
+
+For all indices i, 0 <= i < dimensions.length, dimensions[i][0] represents the length and dimensions[i][1] represents the width of the rectangle i.
+
+Return the area of the rectangle having the longest diagonal. If there are multiple rectangles with the longest diagonal, return the area of the rectangle having the maximum area.
+
+
+Example 1:
+
+
+Input: dimensions = [[9,3],[8,6]]
+Output: 48
+Explanation:
+For index = 0, length = 9 and width = 3. Diagonal length = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487.
+For index = 1, length = 8 and width = 6. Diagonal length = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10.
+So, the rectangle at index 1 has a greater diagonal length therefore we return area = 8 * 6 = 48.
+
+
+Example 2:
+
+
+Input: dimensions = [[3,4],[4,3]]
+Output: 12
+Explanation: Length of diagonal is the same for both which is 5, so maximum area = 12.
+
+
+
+Constraints:
+
+
+ 1 <= dimensions.length <= 100dimensions[i].length == 21 <= dimensions[i][0], dimensions[i][1] <= 100
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README.md b/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README.md
new file mode 100644
index 0000000000000..dbabbdf85d957
--- /dev/null
+++ b/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README.md
@@ -0,0 +1,100 @@
+# [10036. 捕获黑皇后需要的最少移动次数](https://leetcode.cn/problems/minimum-moves-to-capture-the-queen)
+
+[English Version](/solution/10000-10099/10036.Minimum%20Moves%20to%20Capture%20The%20Queen/README_EN.md)
+
+## 题目描述
+
+
+
+现有一个下标从 0 开始的 8 x 8 棋盘，上面有 3 枚棋子。
+
+给你 6 个整数 a 、b 、c 、d 、e 和 f ，其中：
+
+
+ (a, b) 表示白色车的位置。(c, d) 表示白色象的位置。(e, f) 表示黑皇后的位置。
+
+假定你只能移动白色棋子，返回捕获黑皇后所需的最少移动次数。
+
+请注意：
+
+
+ - 车可以向垂直或水平方向移动任意数量的格子，但不能跳过其他棋子。
+ - 象可以沿对角线方向移动任意数量的格子，但不能跳过其他棋子。
+ - 如果车或象能移向皇后所在的格子，则认为它们可以捕获皇后。
+ - 皇后不能移动。
+
+
+
+
+示例 1：
+
+
+输入：a = 1, b = 1, c = 8, d = 8, e = 2, f = 3
+输出：2
+解释：将白色车先移动到 (1, 3) ，然后移动到 (2, 3) 来捕获黑皇后，共需移动 2 次。
+由于起始时没有任何棋子正在攻击黑皇后，要想捕获黑皇后，移动次数不可能少于 2 次。
+
+
+示例 2：
+
+
+输入：a = 5, b = 3, c = 3, d = 4, e = 5, f = 2
+输出：1
+解释：可以通过以下任一方式移动 1 次捕获黑皇后：
+- 将白色车移动到 (5, 2) 。
+- 将白色象移动到 (5, 2) 。
+
+
+
+
+提示：
+
+
+ 1 <= a, b, c, d, e, f <= 8- 两枚棋子不会同时出现在同一个格子上。
+
+
+## 解法
+
+
+
+
+
+### **Python3**
+
+
+
+```python
+
+```
+
+### **Java**
+
+
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README_EN.md b/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README_EN.md
new file mode 100644
index 0000000000000..8340757c22f7f
--- /dev/null
+++ b/solution/10000-10099/10036.Minimum Moves to Capture The Queen/README_EN.md
@@ -0,0 +1,90 @@
+# [10036. Minimum Moves to Capture The Queen](https://leetcode.com/problems/minimum-moves-to-capture-the-queen)
+
+[中文文档](/solution/10000-10099/10036.Minimum%20Moves%20to%20Capture%20The%20Queen/README.md)
+
+## Description
+
+There is a 1-indexed 8 x 8 chessboard containing 3 pieces.
+
+You are given 6 integers a, b, c, d, e, and f where:
+
+
+ (a, b) denotes the position of the white rook.(c, d) denotes the position of the white bishop.(e, f) denotes the position of the black queen.
+
+Given that you can only move the white pieces, return the minimum number of moves required to capture the black queen.
+
+Note that:
+
+
+ - Rooks can move any number of squares either vertically or horizontally, but cannot jump over other pieces.
+ - Bishops can move any number of squares diagonally, but cannot jump over other pieces.
+ - A rook or a bishop can capture the queen if it is located in a square that they can move to.
+ - The queen does not move.
+
+
+
+Example 1:
+
+
+Input: a = 1, b = 1, c = 8, d = 8, e = 2, f = 3
+Output: 2
+Explanation: We can capture the black queen in two moves by moving the white rook to (1, 3) then to (2, 3).
+It is impossible to capture the black queen in less than two moves since it is not being attacked by any of the pieces at the beginning.
+
+
+Example 2:
+
+
+Input: a = 5, b = 3, c = 3, d = 4, e = 5, f = 2
+Output: 1
+Explanation: We can capture the black queen in a single move by doing one of the following:
+- Move the white rook to (5, 2).
+- Move the white bishop to (5, 2).
+
+
+
+Constraints:
+
+
+ 1 <= a, b, c, d, e, f <= 8- No two pieces are on the same square.
+
+
+## Solutions
+
+
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+
diff --git a/solution/10000-10099/10036.Minimum Moves to Capture The Queen/images/ex1.png b/solution/10000-10099/10036.Minimum Moves to Capture The Queen/images/ex1.png
new file mode 100644
index 0000000000000000000000000000000000000000..7621069b3105d8120fca92e17d1c04c22979e6ba
GIT binary patch
literal 2059661
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