diff --git a/solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README.md b/solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README.md
index c61b7107f3d89..b8aece0189f8d 100644
--- a/solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README.md
+++ b/solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README.md
@@ -15,21 +15,21 @@
你所设计的解决方案必须只使用常量级的额外空间。
-示例 1：
+示例 1：
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
-示例 2：
+示例 2：
输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
-示例 3：
+示例 3：
输入：numbers = [-1,0], target = -1
diff --git a/solution/0100-0199/0195.Tenth Line/README_EN.md b/solution/0100-0199/0195.Tenth Line/README_EN.md
index 67c2637df5b2f..f8e0d5ad36d86 100644
--- a/solution/0100-0199/0195.Tenth Line/README_EN.md
+++ b/solution/0100-0199/0195.Tenth Line/README_EN.md
@@ -11,26 +11,41 @@
Assume that file.txt has the following content:
+
Line 1
+
Line 2
+
Line 3
+
Line 4
+
Line 5
+
Line 6
+
Line 7
+
Line 8
+
Line 9
+
Line 10
+
Your script should output the tenth line, which is:
+
Line 10
+
Note:
+
1. If the file contains less than 10 lines, what should you output?
+
2. There's at least three different solutions. Try to explore all possibilities.
## Solutions
diff --git a/solution/0200-0299/0255.Verify Preorder Sequence in Binary Search Tree/README.md b/solution/0200-0299/0255.Verify Preorder Sequence in Binary Search Tree/README.md
index 31fa53370a286..574f40d424b6b 100644
--- a/solution/0200-0299/0255.Verify Preorder Sequence in Binary Search Tree/README.md
+++ b/solution/0200-0299/0255.Verify Preorder Sequence in Binary Search Tree/README.md
@@ -1,4 +1,4 @@
-# [255. 验证前序遍历序列二叉搜索树](https://leetcode.cn/problems/verify-preorder-sequence-in-binary-search-tree)
+# [255. 验证二叉搜索树的前序遍历序列](https://leetcode.cn/problems/verify-preorder-sequence-in-binary-search-tree)
[English Version](/solution/0200-0299/0255.Verify%20Preorder%20Sequence%20in%20Binary%20Search%20Tree/README_EN.md)
diff --git a/solution/0200-0299/0266.Palindrome Permutation/README.md b/solution/0200-0299/0266.Palindrome Permutation/README.md
index a4be9414ffc0e..2cd1047e8c82b 100644
--- a/solution/0200-0299/0266.Palindrome Permutation/README.md
+++ b/solution/0200-0299/0266.Palindrome Permutation/README.md
@@ -6,22 +6,39 @@
-给定一个字符串，判断该字符串中是否可以通过重新排列组合，形成一个回文字符串。
+给你一个字符串 s ，如果该字符串的某个排列是 回文 ，则返回 true ；否则，返回 false 。
-示例 1：
+
-输入: "code"
-输出: false
+示例 1：
-示例 2：
+
+输入：s = "code"
+输出：false
+
-输入: "aab"
-输出: true
+示例 2：
-示例 3：
+
+输入：s = "aab"
+输出：true
+
-输入: "carerac"
-输出: true
+示例 3：
+
+
+输入：s = "carerac"
+输出：true
+
+
+
+
+提示：
+
+
+ 1 <= s.length <= 5000s 仅由小写英文字母组成
## 解法
diff --git a/solution/0200-0299/0297.Serialize and Deserialize Binary Tree/README.md b/solution/0200-0299/0297.Serialize and Deserialize Binary Tree/README.md
index bb24d7cc21854..1d7c6e6edff8a 100644
--- a/solution/0200-0299/0297.Serialize and Deserialize Binary Tree/README.md
+++ b/solution/0200-0299/0297.Serialize and Deserialize Binary Tree/README.md
@@ -10,9 +10,9 @@
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
-提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
+提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
-
+
示例 1：
@@ -42,13 +42,13 @@
输出：[1,2]
-
+
提示：
- 树中结点数在范围
[0, 104] 内
- -1000 <= Node.val <= 1000-1000 <= Node.val <= 1000
## 解法
diff --git a/solution/0300-0399/0339.Nested List Weight Sum/README.md b/solution/0300-0399/0339.Nested List Weight Sum/README.md
index 6416d947d0c0d..890f0c3933e56 100644
--- a/solution/0300-0399/0339.Nested List Weight Sum/README.md
+++ b/solution/0300-0399/0339.Nested List Weight Sum/README.md
@@ -1,4 +1,4 @@
-# [339. 嵌套列表权重和](https://leetcode.cn/problems/nested-list-weight-sum)
+# [339. 嵌套列表加权和](https://leetcode.cn/problems/nested-list-weight-sum)
[English Version](/solution/0300-0399/0339.Nested%20List%20Weight%20Sum/README_EN.md)
diff --git a/solution/0300-0399/0364.Nested List Weight Sum II/README.md b/solution/0300-0399/0364.Nested List Weight Sum II/README.md
index 446b65f968359..d8254cd44f570 100644
--- a/solution/0300-0399/0364.Nested List Weight Sum II/README.md
+++ b/solution/0300-0399/0364.Nested List Weight Sum II/README.md
@@ -1,4 +1,4 @@
-# [364. 加权嵌套序列和 II](https://leetcode.cn/problems/nested-list-weight-sum-ii)
+# [364. 嵌套列表加权和 II](https://leetcode.cn/problems/nested-list-weight-sum-ii)
[English Version](/solution/0300-0399/0364.Nested%20List%20Weight%20Sum%20II/README_EN.md)
diff --git a/solution/0300-0399/0373.Find K Pairs with Smallest Sums/README.md b/solution/0300-0399/0373.Find K Pairs with Smallest Sums/README.md
index 98334b98008cc..47eb14f333a29 100644
--- a/solution/0300-0399/0373.Find K Pairs with Smallest Sums/README.md
+++ b/solution/0300-0399/0373.Find K Pairs with Smallest Sums/README.md
@@ -47,8 +47,9 @@
1 <= nums1.length, nums2.length <= 105-109 <= nums1[i], nums2[i] <= 109nums1 和 nums2 均为升序排列1 <= k <= 104nums1 和 nums2 均为 升序排列1 <= k <= 104k <= nums1.length * nums2.length
## 解法
diff --git a/solution/0400-0499/0491.Non-decreasing Subsequences/README.md b/solution/0400-0499/0491.Non-decreasing Subsequences/README.md
index c41682165bd1b..b339eaeac2122 100644
--- a/solution/0400-0499/0491.Non-decreasing Subsequences/README.md
+++ b/solution/0400-0499/0491.Non-decreasing Subsequences/README.md
@@ -1,4 +1,4 @@
-# [491. 递增子序列](https://leetcode.cn/problems/non-decreasing-subsequences)
+# [491. 非递减子序列](https://leetcode.cn/problems/non-decreasing-subsequences)
[English Version](/solution/0400-0499/0491.Non-decreasing%20Subsequences/README_EN.md)
diff --git a/solution/0500-0599/0573.Squirrel Simulation/README.md b/solution/0500-0599/0573.Squirrel Simulation/README.md
index 44c194cbcee8e..59eebfb752179 100644
--- a/solution/0500-0599/0573.Squirrel Simulation/README.md
+++ b/solution/0500-0599/0573.Squirrel Simulation/README.md
@@ -6,30 +6,50 @@
-现在有一棵树，一只松鼠和一些坚果。位置由二维网格的单元格表示。你的目标是找到松鼠收集所有坚果的最小路程，且坚果是一颗接一颗地被放在树下。松鼠一次最多只能携带一颗坚果，松鼠可以向上，向下，向左和向右四个方向移动到相邻的单元格。移动次数表示路程。
-
-输入 1:
-
-输入:
-高度 : 5
-宽度 : 7
-树的位置 : [2,2]
-松鼠 : [4,4]
-坚果 : [[3,0], [2,5]]
-输出: 12
-解释:
-
+给你两个整数 height 和 width ，代表一个大小为 height x width 的花园。你还得到了以下信息：
+
+
+ - 一个数组
tree ，其中 tree = [treer, treec] 是花园中树的位置，
+ - 一个数组
squirrel ，其中 squirrel = [squirrelr, squirrelc] 是花园中松鼠的位置，
+ - 一个数组
nuts ，其中 nuts[i] = [nutir, nutic] 是花园中第 ith 个坚果的位置。
+
+
+松鼠一次最多只能携带一个坚果，并且能够向上、下、左、右四个方向移动到相邻的单元格。
+
+返回松鼠收集所有坚果并逐一放在树下的 最小距离 。
+
+距离 是指移动的次数。
+
+
+
+示例 1：
+
+
+输入：height = 5, width = 7, tree = [2,2], squirrel = [4,4], nuts = [[3,0], [2,5]]
+输出：12
+解释：为实现最小的距离，松鼠应该先摘 [2, 5] 位置的坚果。
+
+
+示例 2：
+
+
+输入：height = 1, width = 3, tree = [0,1], squirrel = [0,0], nuts = [[0,2]]
+输出：3
-注意:
+
+
+提示：
-
- - 所有给定的位置不会重叠。
- - 松鼠一次最多只能携带一颗坚果。
- - 给定的坚果位置没有顺序。
- - 高度和宽度是正整数。 3 <= 高度 * 宽度 <= 10,000。
- - 给定的网格至少包含一颗坚果，唯一的一棵树和一只松鼠。
-
+
+ 1 <= height, width <= 100tree.length == 2squirrel.length == 21 <= nuts.length <= 5000nuts[i].length == 20 <= treer, squirrelr, nutir <= height0 <= treec, squirrelc, nutic <= width
## 解法
diff --git a/solution/0500-0599/0573.Squirrel Simulation/images/squirrel_simulation.png b/solution/0500-0599/0573.Squirrel Simulation/images/squirrel_simulation.png
deleted file mode 100644
index efad1490e7553..0000000000000
Binary files a/solution/0500-0599/0573.Squirrel Simulation/images/squirrel_simulation.png and /dev/null differ
diff --git a/solution/0600-0699/0616.Add Bold Tag in String/README.md b/solution/0600-0699/0616.Add Bold Tag in String/README.md
index bae0776facdf7..2255c677ab0f3 100644
--- a/solution/0600-0699/0616.Add Bold Tag in String/README.md
+++ b/solution/0600-0699/0616.Add Bold Tag in String/README.md
@@ -31,8 +31,8 @@
示例 2：
-输入：s = "aaabbcc", words = ["aaa","aab","bc"]
-输出："<b>aaabbc</b>c"
+输入：s = "aaabbb", words = ["aa","b"]
+输出："<b>aaabbb</b>"
解释：
"aa"作为子字符串出现了两次: "aaabbb" 和 "aaabbb"。
"b"作为子字符串出现了三次: "aaabbb"、"aaabbb" 和 "aaabbb"。
diff --git a/solution/0600-0699/0650.2 Keys Keyboard/README.md b/solution/0600-0699/0650.2 Keys Keyboard/README.md
index 8a14cc8d1e92b..5e2b256f53e46 100644
--- a/solution/0600-0699/0650.2 Keys Keyboard/README.md
+++ b/solution/0600-0699/0650.2 Keys Keyboard/README.md
@@ -1,4 +1,4 @@
-# [650. 只有两个键的键盘](https://leetcode.cn/problems/2-keys-keyboard)
+# [650. 两个键的键盘](https://leetcode.cn/problems/2-keys-keyboard)
[English Version](/solution/0600-0699/0650.2%20Keys%20Keyboard/README_EN.md)
diff --git a/solution/0600-0699/0651.4 Keys Keyboard/README.md b/solution/0600-0699/0651.4 Keys Keyboard/README.md
index d7c06594101b1..58e4994dad05f 100644
--- a/solution/0600-0699/0651.4 Keys Keyboard/README.md
+++ b/solution/0600-0699/0651.4 Keys Keyboard/README.md
@@ -1,4 +1,4 @@
-# [651. 4 键键盘](https://leetcode.cn/problems/4-keys-keyboard)
+# [651. 四个键的键盘](https://leetcode.cn/problems/4-keys-keyboard)
[English Version](/solution/0600-0699/0651.4%20Keys%20Keyboard/README_EN.md)
diff --git a/solution/0800-0899/0819.Most Common Word/README.md b/solution/0800-0899/0819.Most Common Word/README.md
index 2b69ee38258f3..07e8be75b9bc0 100644
--- a/solution/0800-0899/0819.Most Common Word/README.md
+++ b/solution/0800-0899/0819.Most Common Word/README.md
@@ -6,25 +6,30 @@
-给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。
+给你一个字符串 paragraph 和一个表示禁用词的字符串数组 banned ，返回出现频率最高的非禁用词。题目数据 保证 至少存在一个非禁用词，且答案 唯一 。
-题目保证至少有一个词不在禁用列表中，而且答案唯一。
-
-禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。
+paragraph 中的单词 不区分大小写 ，答案应以 小写 形式返回。
-示例：
-
-输入:
-paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
-banned = ["hit"]
-输出: "ball"
-解释:
-"hit" 出现了3次，但它是一个禁用的单词。
-"ball" 出现了2次 (同时没有其他单词出现2次)，所以它是段落里出现次数最多的，且不在禁用列表中的单词。
-注意，所有这些单词在段落里不区分大小写，标点符号需要忽略（即使是紧挨着单词也忽略， 比如 "ball,"），
-"hit"不是最终的答案，虽然它出现次数更多，但它在禁用单词列表中。
+示例 1：
+
+
+输入：paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.", banned = ["hit"]
+输出："ball"
+解释：
+"hit" 出现了 3 次，但它是禁用词。
+"ball" 出现了两次（没有其他单词出现这么多次），因此它是段落中出现频率最高的非禁用词。
+请注意，段落中的单词不区分大小写，
+标点符号会被忽略（即使它们紧挨着单词，如 "ball,"），
+并且尽管 "hit" 出现的次数更多，但它不能作为答案，因为它是禁用词。
+
+
+示例 2：
+
+
+输入：paragraph = "a.", banned = []
+输出："a"
@@ -32,13 +37,11 @@ banned = ["hit"]
提示：
- 1 <= 段落长度 <= 10000 <= 禁用单词个数 <= 1001 <= 禁用单词长度 <= 10- 答案是唯一的, 且都是小写字母 (即使在
paragraph 里是大写的，即使是一些特定的名词，答案都是小写的。)
- paragraph 只包含字母、空格和下列标点符号!?',;.- 不存在没有连字符或者带有连字符的单词。
- - 单词里只包含字母，不会出现省略号或者其他标点符号。
+ 1 <= paragraph.length <= 1000paragraph 由英文字母、空格 ' '、和以下符号组成："!?',;."0 <= banned.length <= 1001 <= banned[i].length <= 10banned[i] 仅由小写英文字母组成
## 解法
diff --git a/solution/0800-0899/0864.Shortest Path to Get All Keys/README.md b/solution/0800-0899/0864.Shortest Path to Get All Keys/README.md
index f171ed61405ee..347c8b244c67a 100644
--- a/solution/0800-0899/0864.Shortest Path to Get All Keys/README.md
+++ b/solution/0800-0899/0864.Shortest Path to Get All Keys/README.md
@@ -29,7 +29,7 @@
-输入：grid = ["@.a.#","###.#","b.A.B"]
+输入：grid = ["@.a..","###.#","b.A.B"]
输出：8
解释：目标是获得所有钥匙，而不是打开所有锁。
diff --git a/solution/0900-0999/0930.Binary Subarrays With Sum/README_EN.md b/solution/0900-0999/0930.Binary Subarrays With Sum/README_EN.md
index 96b012c6a9dad..dfc9157dd9bb6 100644
--- a/solution/0900-0999/0930.Binary Subarrays With Sum/README_EN.md
+++ b/solution/0900-0999/0930.Binary Subarrays With Sum/README_EN.md
@@ -9,32 +9,45 @@
A subarray is a contiguous part of the array.
+
Example 1:
+
Input: nums = [1,0,1,0,1], goal = 2
+
Output: 4
+
Explanation: The 4 subarrays are bolded and underlined below:
+
[1,0,1,0,1]
+
[1,0,1,0,1]
+
[1,0,1,0,1]
+
[1,0,1,0,1]
+
Example 2:
+
Input: nums = [0,0,0,0,0], goal = 0
+
Output: 15
+
+
Constraints:
- 1 <= nums.length <= 3 * 104nums[i] is either 0 or 1.0 <= goal <= nums.length1 <= nums.length <= 3 * 104nums[i] is either 0 or 1.0 <= goal <= nums.length
## Solutions
diff --git a/solution/1100-1199/1108.Defanging an IP Address/README_EN.md b/solution/1100-1199/1108.Defanging an IP Address/README_EN.md
index e52608592d259..49151237d4df0 100644
--- a/solution/1100-1199/1108.Defanging an IP Address/README_EN.md
+++ b/solution/1100-1199/1108.Defanging an IP Address/README_EN.md
@@ -9,18 +9,27 @@
A defanged IP address replaces every period "." with "[.]".
+
Example 1:
+
Input: address = "1.1.1.1"
+
Output: "1[.]1[.]1[.]1"
+
Example 2:
+
Input: address = "255.100.50.0"
+
Output: "255[.]100[.]50[.]0"
+
+
+
Constraints:
- - The given
address is a valid IPv4 address.
+ - The given
address is a valid IPv4 address.
## Solutions
diff --git a/solution/2300-2399/2330.Valid Palindrome IV/README.md b/solution/2300-2399/2330.Valid Palindrome IV/README.md
index de80fee4bbf06..d192bcdf4feff 100644
--- a/solution/2300-2399/2330.Valid Palindrome IV/README.md
+++ b/solution/2300-2399/2330.Valid Palindrome IV/README.md
@@ -1,4 +1,4 @@
-# [2330. 有效的回文 IV](https://leetcode.cn/problems/valid-palindrome-iv)
+# [2330. 验证回文串 IV](https://leetcode.cn/problems/valid-palindrome-iv)
[English Version](/solution/2300-2399/2330.Valid%20Palindrome%20IV/README_EN.md)
diff --git a/solution/2400-2499/2429.Minimize XOR/README.md b/solution/2400-2499/2429.Minimize XOR/README.md
index 82ae4f5ee0a45..71944535d49a6 100644
--- a/solution/2400-2499/2429.Minimize XOR/README.md
+++ b/solution/2400-2499/2429.Minimize XOR/README.md
@@ -1,4 +1,4 @@
-# [2429. 最小 XOR](https://leetcode.cn/problems/minimize-xor)
+# [2429. 最小异或](https://leetcode.cn/problems/minimize-xor)
[English Version](/solution/2400-2499/2429.Minimize%20XOR/README_EN.md)
@@ -6,7 +6,7 @@
-给你两个正整数 num1 和 num2 ，找出满足下述条件的整数 x ：
+给你两个正整数 num1 和 num2 ，找出满足下述条件的正整数 x ：
x 的置位数和 num2 相同，且示例 1：
-
输入：num1 = 3, num2 = 5
+
+输入：num1 = 3, num2 = 5
输出：3
解释：
num1 和 num2 的二进制表示分别是 0011 和 0101 。
@@ -32,7 +33,8 @@ num1 和 num2 的二进制表示分别是 0011 和 0101 。
示例 2：
-输入：num1 = 1, num2 = 12
+
+输入：num1 = 1, num2 = 12
输出：3
解释：
num1 和 num2 的二进制表示分别是 0001 和 1100 。
diff --git a/solution/2500-2599/2523.Closest Prime Numbers in Range/README.md b/solution/2500-2599/2523.Closest Prime Numbers in Range/README.md
index 204cb253e9588..5988dbcc9863d 100644
--- a/solution/2500-2599/2523.Closest Prime Numbers in Range/README.md
+++ b/solution/2500-2599/2523.Closest Prime Numbers in Range/README.md
@@ -16,7 +16,7 @@
请你返回正整数数组 ans = [nums1, nums2] 。如果有多个整数对满足上述条件，请你返回 nums1 最小的质数对。如果不存在符合题意的质数对，请你返回 [-1, -1] 。
-如果一个整数大于 1 ，且只能被 1 和它自己整除，那么它是一个质数。
+如果一个整数大于 1 ，且只能被 1 和它自己整除，那么它是一个 质数。
diff --git a/solution/2500-2599/2523.Closest Prime Numbers in Range/README_EN.md b/solution/2500-2599/2523.Closest Prime Numbers in Range/README_EN.md
index adace92138e6f..05ca6218bce26 100644
--- a/solution/2500-2599/2523.Closest Prime Numbers in Range/README_EN.md
+++ b/solution/2500-2599/2523.Closest Prime Numbers in Range/README_EN.md
@@ -7,12 +7,12 @@
Given two positive integers left and right, find the two integers num1 and num2 such that:
- left <= nums1 < nums2 <= right .nums1 and nums2 are both prime numbers.nums2 - nums1 is the minimum amongst all other pairs satisfying the above conditions.left <= num1 < num2 <= right .num1 and num2 are both prime numbers.num2 - num1 is the minimum amongst all other pairs satisfying the above conditions.
-Return the positive integer array ans = [nums1, nums2]. If there are multiple pairs satisfying these conditions, return the one with the minimum nums1 value or [-1, -1] if such numbers do not exist.
+Return the positive integer array ans = [num1, num2]. If there are multiple pairs satisfying these conditions, return the one with the minimum num1 value or [-1, -1] if such numbers do not exist.
A number greater than 1 is called prime if it is only divisible by 1 and itself.
diff --git a/solution/2500-2599/2527.Find Xor-Beauty of Array/README.md b/solution/2500-2599/2527.Find Xor-Beauty of Array/README.md
index 7db0d75f7a956..6481c2dc75d08 100644
--- a/solution/2500-2599/2527.Find Xor-Beauty of Array/README.md
+++ b/solution/2500-2599/2527.Find Xor-Beauty of Array/README.md
@@ -1,4 +1,4 @@
-# [2527. 查询数组 Xor 美丽值](https://leetcode.cn/problems/find-xor-beauty-of-array)
+# [2527. 查询数组异或美丽值](https://leetcode.cn/problems/find-xor-beauty-of-array)
[English Version](/solution/2500-2599/2527.Find%20Xor-Beauty%20of%20Array/README_EN.md)
@@ -10,9 +10,9 @@
三个下标 i ，j 和 k 的 有效值 定义为 ((nums[i] | nums[j]) & nums[k]) 。
-一个数组的 xor 美丽值 是数组中所有满足 0 <= i, j, k < n 的三元组 (i, j, k) 的 有效值 的异或结果。
+一个数组的 异或美丽值 是数组中所有满足 0 <= i, j, k < n 的三元组 (i, j, k) 的 有效值 的异或结果。
-请你返回 nums 的 xor 美丽值。
+请你返回 nums 的异或美丽值。
注意：
@@ -38,14 +38,14 @@
- (1,0,1) 有效值为 ((4 | 1) & 4) = 4
- (1,1,0) 有效值为 ((4 | 4) & 1) = 0
- (1,1,1) 有效值为 ((4 | 4) & 4) = 4
-数组的 xor 美丽值为所有有效值的按位异或 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5 。
+数组的异或美丽值为所有有效值的按位异或 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5 。
示例 2：
输入：nums = [15,45,20,2,34,35,5,44,32,30]
输出：34
-解释：数组的 xor 美丽值为 34 。
+解释：数组的异或美丽值为 34 。
diff --git a/solution/2500-2599/2531.Make Number of Distinct Characters Equal/README.md b/solution/2500-2599/2531.Make Number of Distinct Characters Equal/README.md
index 68f54d43ae470..26102995a9cb9 100644
--- a/solution/2500-2599/2531.Make Number of Distinct Characters Equal/README.md
+++ b/solution/2500-2599/2531.Make Number of Distinct Characters Equal/README.md
@@ -1,4 +1,4 @@
-# [2531. 使字符串总不同字符的数目相等](https://leetcode.cn/problems/make-number-of-distinct-characters-equal)
+# [2531. 使字符串中不同字符的数目相等](https://leetcode.cn/problems/make-number-of-distinct-characters-equal)
[English Version](/solution/2500-2599/2531.Make%20Number%20of%20Distinct%20Characters%20Equal/README_EN.md)
diff --git a/solution/2500-2599/2533.Number of Good Binary Strings/README.md b/solution/2500-2599/2533.Number of Good Binary Strings/README.md
index ddfb225148699..a4ad99276793e 100644
--- a/solution/2500-2599/2533.Number of Good Binary Strings/README.md
+++ b/solution/2500-2599/2533.Number of Good Binary Strings/README.md
@@ -24,7 +24,7 @@
-请返回好二进制字符串的个数。答案可能很大，请返回对 109 + 7 取余后的结果。
+请返回 好 二进制字符串的个数。答案可能很大，请返回对 109 + 7 取余 后的结果。
注意：0 可以被认为是所有数字的倍数。
diff --git a/solution/2500-2599/2566.Maximum Difference by Remapping a Digit/README_EN.md b/solution/2500-2599/2566.Maximum Difference by Remapping a Digit/README_EN.md
index 1af5c408fb5e9..7f78038ba0097 100644
--- a/solution/2500-2599/2566.Maximum Difference by Remapping a Digit/README_EN.md
+++ b/solution/2500-2599/2566.Maximum Difference by Remapping a Digit/README_EN.md
@@ -4,18 +4,17 @@
## Description
-You are given an integer num. You know that Danny Mittal will sneakily remap one of the 10 possible digits (0 to 9) to another digit.
+You are given an integer num. You know that Bob will sneakily remap one of the 10 possible digits (0 to 9) to another digit.
-Return the difference between the maximum and minimum values Danny can make by remapping exactly one digit in num.
+Return the difference between the maximum and minimum values Bob can make by remapping exactly one digit in num.
Notes:
- - When Danny remaps a digit d1 to another digit d2, Danny replaces all occurrences of
d1 in num with d2.
- - Danny can remap a digit to itself, in which case
num does not change.
- - Danny can remap different digits for obtaining minimum and maximum values respectively.
+ - When Bob remaps a digit d1 to another digit d2, Bob replaces all occurrences of
d1 in num with d2.
+ - Bob can remap a digit to itself, in which case
num does not change.
+ - Bob can remap different digits for obtaining minimum and maximum values respectively.
- The resulting number after remapping can contain leading zeroes.
- - We mentioned "Danny Mittal" to congratulate him on being in the top 10 in Weekly Contest 326.
@@ -25,8 +24,8 @@
Input: num = 11891
Output: 99009
Explanation:
-To achieve the maximum value, Danny can remap the digit 1 to the digit 9 to yield 99899.
-To achieve the minimum value, Danny can remap the digit 1 to the digit 0, yielding 890.
+To achieve the maximum value, Bob can remap the digit 1 to the digit 9 to yield 99899.
+To achieve the minimum value, Bob can remap the digit 1 to the digit 0, yielding 890.
The difference between these two numbers is 99009.
diff --git a/solution/2600-2699/2626.Array Reduce Transformation/README.md b/solution/2600-2699/2626.Array Reduce Transformation/README.md
index 1bc4186f8fa1a..dc76479562162 100644
--- a/solution/2600-2699/2626.Array Reduce Transformation/README.md
+++ b/solution/2600-2699/2626.Array Reduce Transformation/README.md
@@ -6,11 +6,11 @@
-请你编写一个函数，它的参数为一个整数数组 nums 、一个计算函数 fn 和初始值init 。返回一个数组 归约后 的值。
+给定一个整数数组 nums、一个 reducer 函数 fn 和一个初始值 init，返回通过依次对数组的每个元素执行 fn 函数得到的最终结果。
-你可以定义一个数组 归约后 的值，然后应用以下操作： val = fn(init, nums[0]) ， val = fn(val, nums[1]) ， val = fn(val, nums[2]) ，... 直到数组中的每个元素都被处理完毕。返回 val 的最终值。
+通过以下操作实现这个结果：val = fn(init, nums[0])，val = fn(val, nums[1])，val = fn(val, nums[2])，... 直到处理数组中的每个元素。然后返回 val 的最终值。
-如果数组的长度为 0，它应该返回 init 的值。
+如果数组的长度为 0，则函数应返回 init。
请你在不使用内置数组方法的 Array.reduce 前提下解决这个问题。
diff --git a/solution/2600-2699/2626.Array Reduce Transformation/README_EN.md b/solution/2600-2699/2626.Array Reduce Transformation/README_EN.md
index ad4c13d1b888a..77935e60d2006 100644
--- a/solution/2600-2699/2626.Array Reduce Transformation/README_EN.md
+++ b/solution/2600-2699/2626.Array Reduce Transformation/README_EN.md
@@ -4,11 +4,11 @@
## Description
-Given an integer array nums, a reducer function fn, and an initial value init, return a reduced array.
+Given an integer array nums, a reducer function fn, and an initial value init, return the final result obtained by executing the fn function on each element of the array, sequentially, passing in the return value from the calculation on the preceding element.
-A reduced array is created by applying the following operation: val = fn(init, nums[0]), val = fn(val, nums[1]), val = fn(val, nums[2]), ... until every element in the array has been processed. The final value of val is returned.
+This result is achieved through the following operations: val = fn(init, nums[0]), val = fn(val, nums[1]), val = fn(val, nums[2]), ... until every element in the array has been processed. The ultimate value of val is then returned.
-If the length of the array is 0, it should return init.
+If the length of the array is 0, the function should return init.
Please solve it without using the built-in Array.reduce method.
@@ -40,10 +40,10 @@ init = 100
Output: 130
Explanation:
initially, the value is init=100.
-(100) + nums[0]^2 = 101
-(101) + nums[1]^2 = 105
-(105) + nums[2]^2 = 114
-(114) + nums[3]^2 = 130
+(100) + nums[0] * nums[0] = 101
+(101) + nums[1] * nums[1] = 105
+(105) + nums[2] * nums[2] = 114
+(114) + nums[3] * nums[3] = 130
The final answer is 130.
diff --git a/solution/2700-2799/2700.Differences Between Two Objects/README.md b/solution/2700-2799/2700.Differences Between Two Objects/README.md
index 56d77df13ca04..40b925442834f 100644
--- a/solution/2700-2799/2700.Differences Between Two Objects/README.md
+++ b/solution/2700-2799/2700.Differences Between Two Objects/README.md
@@ -8,7 +8,9 @@
请你编写一个函数，它接收两个深度嵌套的对象或数组 obj1 和 obj2 ，并返回一个新对象表示它们之间差异。
-该函数应该比较这两个对象的属性，并识别任何变化。返回的对象应仅包含从 obj1 到 obj2 的值不同的键。对于每个变化的键，值应表示为一个数组 [obj1 value, obj2 value] 。不存在于一个对象中但存在于另一个对象中的键不应包含在返回的对象中。在比较两个数组时，数组的索引被视为它们的键。最终结果应是一个深度嵌套的对象，其中每个叶子的值都是一个差异数组。
+该函数应该比较这两个对象的属性，并识别任何变化。返回的对象应仅包含从 obj1 到 obj2 的值不同的键。
+
+对于每个变化的键，值应表示为一个数组 [obj1 value, obj2 value] 。不存在于一个对象中但存在于另一个对象中的键不应包含在返回的对象中。在比较两个数组时，数组的索引被视为它们的键。最终结果应是一个深度嵌套的对象，其中每个叶子的值都是一个差异数组。
你可以假设这两个对象都是 JSON.parse 的输出结果。
diff --git a/solution/2700-2799/2715.Timeout Cancellation/README.md b/solution/2700-2799/2715.Timeout Cancellation/README.md
index 963be0b2d3f1d..a97e6eb2dcfd8 100644
--- a/solution/2700-2799/2715.Timeout Cancellation/README.md
+++ b/solution/2700-2799/2715.Timeout Cancellation/README.md
@@ -6,43 +6,56 @@
-现给定一个函数 fn ，一个参数数组 args 和一个以毫秒为单位的超时时间 t ，返回一个取消函数 cancelFn 。
+给定一个函数 fn ，一个参数数组 args 和一个以毫秒为单位的超时时间 t ，返回一个取消函数 cancelFn 。
-在经过 t 毫秒的延迟后，应该调用 fn 函数，并将 args 作为参数传递。除非 在 t 毫秒的延迟过程中，在 cancelT 毫秒时调用了 cancelFn。并且在这种情况下，fn 函数不应该被调用。
+在 cancelTimeMs 的延迟后，返回的取消函数 cancelFn 将被调用。
+
+
+setTimeout(cancelFn, cancelTimeMs)
+
+
+最初，函数 fn 的执行应该延迟 t 毫秒。
+
+如果在 t 毫秒的延迟之前调用了函数 cancelFn，它应该取消 fn 的延迟执行。否则，如果在指定的延迟 t 内没有调用 cancelFn，则应执行 fn，并使用提供的 args 作为参数。
+
+
示例 1:
-输入：fn = (x) => x * 5, args = [2], t = 20, cancelT = 50
+输入：fn = (x) => x * 5, args = [2], t = 20
输出：[{"time": 20, "returned": 10}]
解释：
-const cancel = cancellable((x) => x * 5, [2], 20); // fn(2) 在 t=20ms 时被调用
-setTimeout(cancel, 50);
+const cancelTimeMs = 50;
+const cancelFn = cancellable((x) => x * 5, [2], 20);
+setTimeout(cancelFn, cancelTimeMs);
-取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在20毫秒时执行之后。
+取消操作被安排在延迟了 cancelTimeMs（50毫秒）后进行，这发生在 fn(2) 在20毫秒时执行之后。
示例 2：
-输入：fn = (x) => x**2, args = [2], t = 100, cancelT = 50
+输入：fn = (x) => x**2, args = [2], t = 100
输出：[]
解释：
-const cancel = cancellable((x) => x**2, [2], 100); // fn(2) 没被调用
-setTimeout(cancel, 50);
+const cancelTimeMs = 50;
+const cancelFn = cancellable((x) => x**2, [2], 100);
+setTimeout(cancelFn, cancelTimeMs);
-取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在100毫秒时执行之前，导致 fn(2) 从未被调用。
+取消操作被安排在延迟了 cancelTimeMs（50毫秒）后进行，这发生在 fn(2) 在100毫秒时执行之前，导致 fn(2) 从未被调用。
示例 3：
-输入：fn = (x1, x2) => x1 * x2, args = [2,4], t = 30, cancelTime = 100
+输入：fn = (x1, x2) => x1 * x2, args = [2,4], t = 30
输出：[{"time": 30, "returned": 8}]
解释：
-const cancel = cancellable((x1, x2) => x1 * x2, [2,4], 30); // fn(2,4) 在 t=30ms 时被调用
-setTimeout(cancel, 100);
+const cancelTimeMs = 100;
+const cancelFn = cancellable((x1, x2) => x1 * x2, [2,4], 30);
+setTimeout(cancelFn, cancelTimeMs);
-取消操作被安排在延迟了 cancelT（100毫秒）后进行，这发生在 fn(2,4) 在30毫秒时执行之后。
+取消操作被安排在延迟了 cancelTimeMs（100毫秒）后进行，这发生在 fn(2,4) 在30毫秒时执行之后。
@@ -54,7 +67,7 @@ setTimeout(cancel, 100);
args 是一个有效的 JSON 数组
1 <= args.length <= 10
20 <= t <= 1000
- 10 <= cancelT <= 1000
+ 10 <= cancelTimeMs <= 1000
## 解法
diff --git a/solution/2700-2799/2724.Sort By/README.md b/solution/2700-2799/2724.Sort By/README.md
index 07e88e3afa981..487d83b877877 100644
--- a/solution/2700-2799/2724.Sort By/README.md
+++ b/solution/2700-2799/2724.Sort By/README.md
@@ -41,8 +41,8 @@
提示：
- arr 是一个有效的 JSON 数组fn 是一个函数，返回一个数字arr 是一个有效的 JSON 数组fn 是一个函数，返回一个数字1 <= arr.length <= 5 * 105
diff --git a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README.md b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README.md
index d9b19b0cc3617..016c9f77a0d29 100644
--- a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README.md
+++ b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README.md
@@ -154,6 +154,62 @@ func smallestString(s string) string {
}
```
+### **Rust**
+
+```rust
+impl Solution {
+ pub fn smallest_string(s: String) -> String {
+ let mut cs: Vec = s.chars().collect();
+ let n = cs.len();
+ let mut i = 0;
+
+ while i < n && cs[i] == 'a' {
+ i += 1;
+ }
+
+ if i == n {
+ cs[n - 1] = 'z';
+ return cs.into_iter().collect();
+ }
+
+ let mut j = i;
+ while j < n && cs[j] != 'a' {
+ cs[j] = ((cs[j] as u8) - 1) as char;
+ j += 1;
+ }
+
+ cs.into_iter().collect()
+ }
+}
+```
+
+### **TypeScript**
+
+```ts
+function smallestString(s: string): string {
+ const cs: string[] = s.split('');
+ const n: number = cs.length;
+ let i: number = 0;
+ while (i < n && cs[i] === 'a') {
+ i++;
+ }
+
+ if (i === n) {
+ cs[n - 1] = 'z';
+ return cs.join('');
+ }
+
+ let j: number = i;
+ while (j < n && cs[j] !== 'a') {
+ const c: number = cs[j].charCodeAt(0);
+ cs[j] = String.fromCharCode(c - 1);
+ j++;
+ }
+
+ return cs.join('');
+}
+```
+
### **...**
```
diff --git a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README_EN.md b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README_EN.md
index a3e94a3fe9f29..46c77f94ef876 100644
--- a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README_EN.md
+++ b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/README_EN.md
@@ -143,6 +143,62 @@ func smallestString(s string) string {
}
```
+### **Rust**
+
+```rust
+impl Solution {
+ pub fn smallest_string(s: String) -> String {
+ let mut cs: Vec = s.chars().collect();
+ let n = cs.len();
+ let mut i = 0;
+
+ while i < n && cs[i] == 'a' {
+ i += 1;
+ }
+
+ if i == n {
+ cs[n - 1] = 'z';
+ return cs.into_iter().collect();
+ }
+
+ let mut j = i;
+ while j < n && cs[j] != 'a' {
+ cs[j] = ((cs[j] as u8) - 1) as char;
+ j += 1;
+ }
+
+ cs.into_iter().collect()
+ }
+}
+```
+
+### **TypeScript**
+
+```ts
+function smallestString(s: string): string {
+ const cs: string[] = s.split('');
+ const n: number = cs.length;
+ let i: number = 0;
+ while (i < n && cs[i] === 'a') {
+ i++;
+ }
+
+ if (i === n) {
+ cs[n - 1] = 'z';
+ return cs.join('');
+ }
+
+ let j: number = i;
+ while (j < n && cs[j] !== 'a') {
+ const c: number = cs[j].charCodeAt(0);
+ cs[j] = String.fromCharCode(c - 1);
+ j++;
+ }
+
+ return cs.join('');
+}
+```
+
### **...**
```
diff --git a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.rs b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.rs
new file mode 100644
index 0000000000000..7b79415befa2d
--- /dev/null
+++ b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.rs
@@ -0,0 +1,24 @@
+impl Solution {
+ pub fn smallest_string(s: String) -> String {
+ let mut cs: Vec = s.chars().collect();
+ let n = cs.len();
+ let mut i = 0;
+
+ while i < n && cs[i] == 'a' {
+ i += 1;
+ }
+
+ if i == n {
+ cs[n - 1] = 'z';
+ return cs.into_iter().collect();
+ }
+
+ let mut j = i;
+ while j < n && cs[j] != 'a' {
+ cs[j] = ((cs[j] as u8) - 1) as char;
+ j += 1;
+ }
+
+ cs.into_iter().collect()
+ }
+}
diff --git a/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.ts b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.ts
new file mode 100644
index 0000000000000..7839f0c185c07
--- /dev/null
+++ b/solution/2700-2799/2734.Lexicographically Smallest String After Substring Operation/Solution.ts
@@ -0,0 +1,22 @@
+function smallestString(s: string): string {
+ const cs: string[] = s.split('');
+ const n: number = cs.length;
+ let i: number = 0;
+ while (i < n && cs[i] === 'a') {
+ i++;
+ }
+
+ if (i === n) {
+ cs[n - 1] = 'z';
+ return cs.join('');
+ }
+
+ let j: number = i;
+ while (j < n && cs[j] !== 'a') {
+ const c: number = cs[j].charCodeAt(0);
+ cs[j] = String.fromCharCode(c - 1);
+ j++;
+ }
+
+ return cs.join('');
+}
diff --git a/solution/2700-2799/2735.Collecting Chocolates/README.md b/solution/2700-2799/2735.Collecting Chocolates/README.md
index 2123b1e7f218d..c5f2c8d8be6f0 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/README.md
+++ b/solution/2700-2799/2735.Collecting Chocolates/README.md
@@ -53,13 +53,13 @@
**方法一：枚举**
-我们考虑枚举操作的次数，定义 $f[i][j]$ 表示类型为 $i$ 的巧克力进行了 $j$ 次操作后的最小成本。
+我们考虑枚举操作的次数，定义 $f[i][j]$ 表示第 $i$ 个巧克力进行了 $j$ 次操作后的最小成本。
-对于类型为 $i$ 的巧克力：
+对于第 $i$ 个巧克力：
- 如果 $j = 0$，即没有进行操作，那么 $f[i][j] = nums[i]$；
-- 如果 $0 \lt j \leq n-1$，那么它的最小成本就是下标范围为 $[i,.. (i + j) \bmod n]$ 的巧克力的最小成本，即 $f[i][j] = \min\{nums[i], nums[i + 1], \cdots, nums[(i + j) \bmod n]\}$，或者可以写成 $f[i][j] = \min\{f[i][j - 1], nums[(i + j) \bmod n]\}$。
-- 如果 $j \ge n$，由于当 $j = n - 1$ 时，已经覆盖了所有巧克力的最小成本，如果 $j$ 继续增大，那么最小成本不会再变化，但是操作次数的增加却会导致最终的成本增加，因此，我们不需要考虑 $j \ge n$ 的情况。
+- 如果 $0 \lt j \leq n-1$，那么它的最小成本就是下标范围为 $[i,.. (i - j + n) \bmod n]$ 的最小成本，即 $f[i][j] = \min\{nums[i], nums[i - 1], \cdots, nums[(i - j + n) \bmod n]\}$，或者可以写成 $f[i][j] = \min\{f[i][j - 1], nums[(i - j + n) \bmod n]\}$。
+- 如果 $j \ge n$，由于当 $j = n - 1$ 时，已经覆盖了所有最小成本，如果 $j$ 继续增大，那么最小成本不会再变化，但是操作次数的增加却会导致最终的成本增加，因此，我们不需要考虑 $j \ge n$ 的情况。
综上，我们可以得到状态转移方程：
@@ -67,7 +67,7 @@ $$
f[i][j] =
\begin{cases}
nums[i] ,& j = 0 \\
-\min(f[i][j - 1], nums[(i + j) \bmod n]) ,& 0 \lt j \leq n - 1
+\min(f[i][j - 1], nums[(i - j + n) \bmod n]) ,& 0 \lt j \leq n - 1
\end{cases}
$$
@@ -89,7 +89,7 @@ class Solution:
for i, v in enumerate(nums):
f[i][0] = v
for j in range(1, n):
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n])
+ f[i][j] = min(f[i][j - 1], nums[(i - j) % n])
return min(sum(f[i][j] for i in range(n)) + x * j for j in range(n))
```
@@ -105,7 +105,7 @@ class Solution {
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long ans = 1L << 60;
@@ -132,7 +132,7 @@ public:
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long long ans = 1LL << 60;
@@ -158,7 +158,7 @@ func minCost(nums []int, x int) int64 {
f[i] = make([]int, n)
f[i][0] = v
for j := 1; j < n; j++ {
- f[i][j] = min(f[i][j-1], nums[(i+j)%n])
+ f[i][j] = min(f[i][j-1], nums[(i-j+n)%n])
}
}
ans := 1 << 60
@@ -182,7 +182,7 @@ function minCost(nums: number[], x: number): number {
for (let i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (let j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
let ans = Infinity;
@@ -207,7 +207,7 @@ impl Solution {
for i in 0..n {
f[i][0] = nums[i];
for j in 1..n {
- f[i][j] = f[i][j - 1].min(nums[(i + j) % n]);
+ f[i][j] = f[i][j - 1].min(nums[(i - j + n) % n]);
}
}
let mut ans = i64::MAX;
diff --git a/solution/2700-2799/2735.Collecting Chocolates/README_EN.md b/solution/2700-2799/2735.Collecting Chocolates/README_EN.md
index 4af1950e952aa..253e9d61db832 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/README_EN.md
+++ b/solution/2700-2799/2735.Collecting Chocolates/README_EN.md
@@ -47,13 +47,13 @@ Thus, the total cost will become (1 + 5 + 1 + 5 + 1) = 13. We can prove that thi
**Solution 1: Enumeration**
-We consider enumerating the number of operations, and define $f[i][j]$ as the minimum cost after performing $j$ operations on the chocolate of type $i$.
+We consider enumerating the number of operations, and define $f[i][j]$ as the minimum cost after the $i$-th chocolate has undergone $j$ operations.
-For the chocolate of type $i$:
+For the $i$-th chocolate:
-- If $j = 0$, i.e., no operation is performed, then $f[i][j] = nums[i]$;
-- If $0 \lt j \leq n-1$, then its minimum cost is the minimum cost of the chocolates with indices in the range $[i,.. (i + j) \bmod n]$, i.e., $f[i][j] = \min\{nums[i], nums[i + 1], \cdots, nums[(i + j) \bmod n]\}$, or it can be written as $f[i][j] = \min\{f[i][j - 1], nums[(i + j) \bmod n]\}$.
-- If $j \ge n$, since when $j = n - 1$, the minimum cost of all covered chocolates has been obtained. If $j$ continues to increase, the minimum cost will not change, but the increase in the number of operations will lead to an increase in the final cost. Therefore, we do not need to consider the case where $j \ge n$.
+- If $j = 0$, i.e., no operation is performed, then $f[i][j] = nums[i]$.
+- If $0 < j \leq n-1$, its minimum cost is the minimum cost within the index range $[i,.. (i - j + n) \bmod n]$, i.e., $f[i][j] = \min\{nums[i], nums[i - 1], \cdots, nums[(i - j + n) \bmod n]\}$, or it can be written as $f[i][j] = \min\{f[i][j - 1], nums[(i - j + n) \bmod n]\}$.
+- If $j \ge n$, since when $j = n - 1$, all minimum costs have been covered, if $j$ continues to increase, the minimum cost will not change, but the increase in the number of operations will lead to an increase in the final cost, so we do not need to consider the case where $j \ge n$.
In summary, we can get the state transition equation:
@@ -61,7 +61,7 @@ $$
f[i][j] =
\begin{cases}
nums[i] ,& j = 0 \\
-\min(f[i][j - 1], nums[(i + j) \bmod n]) ,& 0 \lt j \leq n - 1
+\min(f[i][j - 1], nums[(i - j + n) \bmod n]) ,& 0 \lt j \leq n - 1
\end{cases}
$$
@@ -81,7 +81,7 @@ class Solution:
for i, v in enumerate(nums):
f[i][0] = v
for j in range(1, n):
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n])
+ f[i][j] = min(f[i][j - 1], nums[(i - j) % n])
return min(sum(f[i][j] for i in range(n)) + x * j for j in range(n))
```
@@ -95,7 +95,7 @@ class Solution {
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long ans = 1L << 60;
@@ -122,7 +122,7 @@ public:
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long long ans = 1LL << 60;
@@ -148,7 +148,7 @@ func minCost(nums []int, x int) int64 {
f[i] = make([]int, n)
f[i][0] = v
for j := 1; j < n; j++ {
- f[i][j] = min(f[i][j-1], nums[(i+j)%n])
+ f[i][j] = min(f[i][j-1], nums[(i-j+n)%n])
}
}
ans := 1 << 60
@@ -172,7 +172,7 @@ function minCost(nums: number[], x: number): number {
for (let i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (let j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
let ans = Infinity;
@@ -197,7 +197,7 @@ impl Solution {
for i in 0..n {
f[i][0] = nums[i];
for j in 1..n {
- f[i][j] = f[i][j - 1].min(nums[(i + j) % n]);
+ f[i][j] = f[i][j - 1].min(nums[(i - j + n) % n]);
}
}
let mut ans = i64::MAX;
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.cpp b/solution/2700-2799/2735.Collecting Chocolates/Solution.cpp
index 971687a6e1dbb..196f50602e492 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.cpp
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.cpp
@@ -6,7 +6,7 @@ class Solution {
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long long ans = 1LL << 60;
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.go b/solution/2700-2799/2735.Collecting Chocolates/Solution.go
index a62e16a70a1c7..4ddca35d29d6e 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.go
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.go
@@ -5,7 +5,7 @@ func minCost(nums []int, x int) int64 {
f[i] = make([]int, n)
f[i][0] = v
for j := 1; j < n; j++ {
- f[i][j] = min(f[i][j-1], nums[(i+j)%n])
+ f[i][j] = min(f[i][j-1], nums[(i-j+n)%n])
}
}
ans := 1 << 60
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.java b/solution/2700-2799/2735.Collecting Chocolates/Solution.java
index 0e1c75f244ce0..6e4afa4a1c552 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.java
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.java
@@ -5,7 +5,7 @@ public long minCost(int[] nums, int x) {
for (int i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (int j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
long ans = 1L << 60;
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.py b/solution/2700-2799/2735.Collecting Chocolates/Solution.py
index 48ebe53a46246..c5b0c2ebf778b 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.py
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.py
@@ -5,5 +5,5 @@ def minCost(self, nums: List[int], x: int) -> int:
for i, v in enumerate(nums):
f[i][0] = v
for j in range(1, n):
- f[i][j] = min(f[i][j - 1], nums[(i + j) % n])
+ f[i][j] = min(f[i][j - 1], nums[(i - j) % n])
return min(sum(f[i][j] for i in range(n)) + x * j for j in range(n))
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.rs b/solution/2700-2799/2735.Collecting Chocolates/Solution.rs
index 037aec5fa0484..b510f19c2d2fb 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.rs
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.rs
@@ -5,7 +5,7 @@ impl Solution {
for i in 0..n {
f[i][0] = nums[i];
for j in 1..n {
- f[i][j] = f[i][j - 1].min(nums[(i + j) % n]);
+ f[i][j] = f[i][j - 1].min(nums[(i - j + n) % n]);
}
}
let mut ans = i64::MAX;
diff --git a/solution/2700-2799/2735.Collecting Chocolates/Solution.ts b/solution/2700-2799/2735.Collecting Chocolates/Solution.ts
index bc513852c19db..f10898508d691 100644
--- a/solution/2700-2799/2735.Collecting Chocolates/Solution.ts
+++ b/solution/2700-2799/2735.Collecting Chocolates/Solution.ts
@@ -4,7 +4,7 @@ function minCost(nums: number[], x: number): number {
for (let i = 0; i < n; ++i) {
f[i][0] = nums[i];
for (let j = 1; j < n; ++j) {
- f[i][j] = Math.min(f[i][j - 1], nums[(i + j) % n]);
+ f[i][j] = Math.min(f[i][j - 1], nums[(i - j + n) % n]);
}
}
let ans = Infinity;
diff --git a/solution/2700-2799/2754.Bind Function to Context/README.md b/solution/2700-2799/2754.Bind Function to Context/README.md
index 13caf1bc3e012..a3d86d2477caf 100644
--- a/solution/2700-2799/2754.Bind Function to Context/README.md
+++ b/solution/2700-2799/2754.Bind Function to Context/README.md
@@ -72,7 +72,7 @@ boundFunc(); // "My name is Kathy"
提示：
- obj 是一个非空对象obj 是一个非空对象0 <= inputs.length <= 100
diff --git a/solution/2700-2799/2756.Query Batching/README.md b/solution/2700-2799/2756.Query Batching/README.md
index f818ad8a63f0d..f94e10e1bda59 100644
--- a/solution/2700-2799/2756.Query Batching/README.md
+++ b/solution/2700-2799/2756.Query Batching/README.md
@@ -123,7 +123,7 @@ calls = [
0 <= t <= 1000
0 <= calls.length <= 10
1 <= key.length <= 100
- 所有的键值都是唯一的
+ 所有的键值都是唯一的
## 解法
diff --git a/solution/2700-2799/2759.Convert JSON String to Object/README.md b/solution/2700-2799/2759.Convert JSON String to Object/README.md
index 6bcec137a1fd1..54d97592c3e25 100644
--- a/solution/2700-2799/2759.Convert JSON String to Object/README.md
+++ b/solution/2700-2799/2759.Convert JSON String to Object/README.md
@@ -6,7 +6,7 @@
-给定一个字符串 str ，返回 JSON 解析后的 parsedStr 。你可以假设 str 是一个有效的 JSON 字符串，因此它只包含字符串、数字、数组、对象、布尔值和 null。str 不会包含不可见字符和转义字符。JSON 中的字符串值只包含字母数字字符。
+给定一个字符串 str ，返回 JSON 解析后的 parsedStr 。你可以假设 str 是一个有效的 JSON 字符串，因此它只包含字符串、数字、数组、对象、布尔值和 null。str 不会包含不可见字符和转义字符。
请在不使用内置的 JSON.parse 方法的情况下解决此问题。
diff --git a/solution/2700-2799/2759.Convert JSON String to Object/README_EN.md b/solution/2700-2799/2759.Convert JSON String to Object/README_EN.md
index 23adcd72b80e3..22426011cc0b4 100644
--- a/solution/2700-2799/2759.Convert JSON String to Object/README_EN.md
+++ b/solution/2700-2799/2759.Convert JSON String to Object/README_EN.md
@@ -4,7 +4,7 @@
## Description
-Given a string str, return parsed JSON parsedStr. You may assume the str is a valid JSON string hence it only includes strings, numbers, arrays, objects, booleans, and null. str will not include invisible characters and escape characters. String values within the JSON will only contain alphanumeric characters.
+Given a string str, return parsed JSON parsedStr. You may assume the str is a valid JSON string hence it only includes strings, numbers, arrays, objects, booleans, and null. str will not include invisible characters and escape characters.
Please solve it without using the built-in JSON.parse method.
diff --git a/solution/2700-2799/2774.Array Upper Bound/README.md b/solution/2700-2799/2774.Array Upper Bound/README.md
index 219f36a9dd757..b88ef281bff47 100644
--- a/solution/2700-2799/2774.Array Upper Bound/README.md
+++ b/solution/2700-2799/2774.Array Upper Bound/README.md
@@ -10,8 +10,6 @@
-
-
示例 1：
@@ -45,6 +43,10 @@
nums 按升序排序。
+
+
+进阶：你能编写一个时间复杂度为 O(log n) 的算法吗？
+
## 解法
diff --git a/solution/2700-2799/2776.Convert Callback Based Function to Promise Based Function/README.md b/solution/2700-2799/2776.Convert Callback Based Function to Promise Based Function/README.md
index 46ca9f3cee02d..22ec0e94f0b42 100644
--- a/solution/2700-2799/2776.Convert Callback Based Function to Promise Based Function/README.md
+++ b/solution/2700-2799/2776.Convert Callback Based Function to Promise Based Function/README.md
@@ -8,7 +8,9 @@
编写一个函数，接受另一个函数 fn ，并将基于回调函数的函数转换为基于 Promise 的函数。
-promisify 函数接受一个函数 fn ，fn 将回调函数作为其第一个参数，并且还可以接受其他额外的参数。promisfy 返回一个新函数，新函数会返回一个 Promise 对象。当回调函数被成功调用时，新函数返回的 Promise 对象应该使用原始函数的结果进行解析；当回调函数被调用出现错误时，返回的 Promise 对象应该被拒绝并携带错误信息。最终返回的基于 Promise 的函数应该接受额外的参数作为输入。
+promisify 函数接受一个函数 fn ，fn 将回调函数作为其第一个参数，并且还可以接受其他额外的参数。
+
+promisfy 返回一个新函数，新函数会返回一个 Promise 对象。当回调函数被成功调用时，新函数返回的 Promise 对象应该使用原始函数的结果进行解析；当回调函数被调用出现错误时，返回的 Promise 对象应该被拒绝并携带错误信息。最终返回的基于 Promise 的函数应该接受额外的参数作为输入。
以下是一个可以传递给 promisify 的函数示例：
diff --git a/solution/2700-2799/2796.Repeat String/README.md b/solution/2700-2799/2796.Repeat String/README.md
index abe7d9e2da69e..337996a4bdbc2 100644
--- a/solution/2700-2799/2796.Repeat String/README.md
+++ b/solution/2700-2799/2796.Repeat String/README.md
@@ -41,8 +41,7 @@
提示：
- 1 <= str.length <= 10001 <= times <= 10001 <= str.length, times <= 105
## 解法
diff --git a/solution/2900-2999/2921.Maximum Profitable Triplets With Increasing Prices II/README.md b/solution/2900-2999/2921.Maximum Profitable Triplets With Increasing Prices II/README.md
index c06b254dc0cc2..cc6dec52b4e0d 100644
--- a/solution/2900-2999/2921.Maximum Profitable Triplets With Increasing Prices II/README.md
+++ b/solution/2900-2999/2921.Maximum Profitable Triplets With Increasing Prices II/README.md
@@ -1,4 +1,4 @@
-# [2921. 具有递增价格的最大利润三元组 II](https://leetcode.cn/problems/maximum-profitable-triplets-with-increasing-prices-ii)
+# [2921. 价格递增的最大利润三元组 II](https://leetcode.cn/problems/maximum-profitable-triplets-with-increasing-prices-ii)
[English Version](/solution/2900-2999/2921.Maximum%20Profitable%20Triplets%20With%20Increasing%20Prices%20II/README_EN.md)
diff --git a/solution/2900-2999/2964.Number of Divisible Triplet Sums/README.md b/solution/2900-2999/2964.Number of Divisible Triplet Sums/README.md
index 7fd9ecb5ab347..1482102fecd2f 100644
--- a/solution/2900-2999/2964.Number of Divisible Triplet Sums/README.md
+++ b/solution/2900-2999/2964.Number of Divisible Triplet Sums/README.md
@@ -1,4 +1,4 @@
-# [2964. Number of Divisible Triplet Sums](https://leetcode.cn/problems/number-of-divisible-triplet-sums)
+# [2964. 可被整除的三元组数量](https://leetcode.cn/problems/number-of-divisible-triplet-sums)
[English Version](/solution/2900-2999/2964.Number%20of%20Divisible%20Triplet%20Sums/README_EN.md)
@@ -6,36 +6,37 @@
-Given a 0-indexed integer array nums and an integer d, return the number of triplets (i, j, k) such that i < j < k and (nums[i] + nums[j] + nums[k]) % d == 0.
+给定一个 下标从 0 开始 的整数数组 nums 和一个整数 d，请返回满足 i < j < k 且 (nums[i] + nums[j] + nums[k]) % d == 0 的三元组 (i, j, k) 的数量。
-Example 1:
+
+示例 1:
-Input: nums = [3,3,4,7,8], d = 5
-Output: 3
-Explanation: The triplets which are divisible by 5 are: (0, 1, 2), (0, 2, 4), (1, 2, 4).
-It can be shown that no other triplet is divisible by 5. Hence, the answer is 3.
+输入：nums = [3,3,4,7,8], d = 5
+输出：3
+解释：可以被5整除的三元组有：(0, 1, 2),(0, 2, 4),(1, 2, 4)。其他没有其他能被5整除的三元组。因此，答案是3。
-Example 2:
+示例 2：
-Input: nums = [3,3,3,3], d = 3
-Output: 4
-Explanation: Any triplet chosen here has a sum of 9, which is divisible by 3. Hence, the answer is the total number of triplets which is 4.
+输入：nums = [3,3,3,3], d = 3
+输出：4
+解释：这里选择的任何三元组的和都是9，可以被3整除。因此，答案是所有三元组的总数，即4。
-Example 3:
+示例 3:
-Input: nums = [3,3,3,3], d = 6
-Output: 0
-Explanation: Any triplet chosen here has a sum of 9, which is not divisible by 6. Hence, the answer is 0.
+输入：nums = [3,3,3,3], d = 6
+输出：0
+解释：这里选择的任何三元组的和都是9，不能被6整除。因此，答案是0。
-Constraints:
+
+提示：
1 <= nums.length <= 1000You are at a fruit market with different types of exotic fruits on display.
+你在一个水果超市里，货架上摆满了玲琅满目的奇珍异果。
-You are given a 1-indexed array prices, where prices[i] denotes the number of coins needed to purchase the ith fruit.
+给你一个 下标从 1 开始 的数组 prices，其中 prices[i] 表示你购买第 i 个水果所需的硬币数量。
-The fruit market has the following offer:
+水果市场有以下优惠活动：
- - If you purchase the
ith fruit at prices[i] coins, you can get the next i fruits for free.
+ - 如果你用
prices[i] 个硬币购买第 i 个水果， 那么接下来的 i 个水果你都可以免费获得。
-Note that even if you can take fruit j for free, you can still purchase it for prices[j] coins to receive a new offer.
+请注意 即使你 可以 免费获得第 j 个水果，你仍然可以用 prices[j] 个硬币来购买它，以获取新的优惠。
-Return the minimum number of coins needed to acquire all the fruits.
+返回 获得所有水果所需的 最小 硬币数量。
-Example 1:
+
+示例 1：
-Input: prices = [3,1,2]
-Output: 4
-Explanation: You can acquire the fruits as follows:
-- Purchase the 1st fruit with 3 coins, and you are allowed to take the 2nd fruit for free.
-- Purchase the 2nd fruit with 1 coin, and you are allowed to take the 3rd fruit for free.
-- Take the 3rd fruit for free.
-Note that even though you were allowed to take the 2nd fruit for free, you purchased it because it is more optimal.
-It can be proven that 4 is the minimum number of coins needed to acquire all the fruits.
+输入：prices = [3,1,2]
+输出：4
+解释：你可以按以下方式获取水果：
+- 用3个硬币购买第1个水果，并且可以免费获得第2个水果。
+- 用1个硬币购买第2个水果，并且可以免费获得第3个水果。
+- 免费获得第三个水果。
+请注意，即使你可以免费获得第2个水果，你还是购买了它，因为这是更优的选择。
+可以证明4是获取所有水果所需的最小硬币数量。
-Example 2:
+示例 2：
-Input: prices = [1,10,1,1]
-Output: 2
-Explanation: You can acquire the fruits as follows:
-- Purchase the 1st fruit with 1 coin, and you are allowed to take the 2nd fruit for free.
-- Take the 2nd fruit for free.
-- Purchase the 3rd fruit for 1 coin, and you are allowed to take the 4th fruit for free.
-- Take the 4th fruit for free.
-It can be proven that 2 is the minimum number of coins needed to acquire all the fruits.
+输入：prices = [1,10,1,1]
+输出：2
+解释：你可以按以下方式获取水果：
+- 用1个硬币购买第1个水果，并且可以免费获得第2个水果。
+- 免费获得第2个水果。
+- 用1个硬币购买第3个水果，并且可以免费获得第4个水果。
+- 免费获得第4个水果。
+可以证明2是获取所有水果所需的最小硬币数量。
-Constraints:
+
+提示：
1 <= prices.length <= 105