feat: update lc problems

Author: yanglbme

solution/2600-2699/2674.Split a Circular Linked List/README.md

@@ -1,41 +1,43 @@
-# [2674. Split a Circular Linked List](https://leetcode.cn/problems/split-a-circular-linked-list)
+# [2674. 拆分循环链表](https://leetcode.cn/problems/split-a-circular-linked-list)
 
 [English Version](/solution/2600-2699/2674.Split%20a%20Circular%20Linked%20List/README_EN.md)
 
 ## 题目描述
 
 <!-- 这里写题目描述 -->
 
-<p>Given a <strong>circular linked list</strong> <code>list</code> of positive integers, your task is to split it into 2 <strong>circular linked lists</strong> so that the first one contains the <strong>first half</strong> of the nodes in <code>list</code> (exactly <code>ceil(list.length / 2)</code> nodes) in the same order they appeared in <code>list</code>, and the second one contains <strong>the rest</strong> of the nodes in <code>list</code> in the same order they appeared in <code>list</code>.</p>
+<p>现给定一个由正整数组成的 <strong>循环链表</strong> <code>list</code> ，你的任务是将其拆分为 2 个 <strong>循环链表</strong> ，使得第一个链表包含 <code>list</code> <strong>前半部分&nbsp;</strong>的节点（即 <code>ceil(list.length / 2)</code> 个节点），顺序与 list 中的顺序相同，而第二个链表包含 <code>list</code> 中 <strong>剩余</strong> 的节点，顺序也与 <code>list</code> 中的顺序相同。</p>
 
-<p>Return <em>an array answer of length 2 in which the first element is a <strong>circular linked list</strong> representing the <strong>first half</strong> and the second element is a <strong>circular linked list</strong> representing the <strong>second half</strong>.</em></p>
+<p>返回一个长度为 2 的数组，其中第一个元素是表示 <strong>前半部分</strong> 链表的<strong> 循环链表</strong> ，第二个元素是表示 <strong>后半部分</strong> 链表的 <strong>循环链表</strong> 。</p>
 
-<div>A <strong>circular linked list</strong> is a normal linked list with the only difference being that the last node&#39;s next node, is the first node.</div>
+<p><strong>循环链表</strong> 是一个普通的链表，唯一的区别是最后一个节点的下一个节点是头节点。</p>
 
 <p>&nbsp;</p>
-<p><strong class="example">Example 1:</strong></p>
+
+<p><strong class="example">示例 1：</strong></p>
 
 <pre>
-<strong>Input:</strong> nums = [1,5,7]
-<strong>Output:</strong> [[1,5],[7]]
-<strong>Explanation:</strong> The initial list has 3 nodes so the first half would be the first 2 elements since ceil(3 / 2) = 2 and the rest which is 1 node is in the second half.
+<b>输入：</b>nums = [1,5,7]
+<b>输出：</b>[[1,5],[7]]
+<b>解释：</b>初始链表有3个节点，因此前半部分是前两个元素，剩下的 1 个节点在后半部分。
 </pre>
 
-<p><strong class="example">Example 2:</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>Input:</strong> nums = [2,6,1,5]
-<strong>Output:</strong> [[2,6],[1,5]]
-<strong>Explanation:</strong> The initial list has 4 nodes so the first half would be the first 2 elements since ceil(4 / 2) = 2 and the rest which is 2 nodes are in the second half.
+<b>输入：</b>nums = [2,6,1,5]
+<b>输出：</b>[[2,6],[1,5]]
+<b>解释：</b>初始链表有4个节点，因此前半部分是前两个元素，剩下的 2 个节点在后半部分。
 </pre>
 
 <p>&nbsp;</p>
-<p><strong>Constraints:</strong></p>
+
+<p><strong>提示：</strong></p>
 
 <ul>
-	<li>The number of nodes in <code>list</code>&nbsp;is in the range <code>[2, 10<sup>5</sup>]</code></li>
+	<li><code>list</code> 中的节点数范围为 <code>[2, 105]</code></li>
 	<li><code>0 &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
-	<li><font face="monospace"><code>LastNode.next = FirstNode</code></font> where <code>LastNode</code> is the last node of the list and <code>FirstNode</code> is the first one</li>
+	<li><code>LastNode.next = FirstNode</code> ，其中 <code>LastNode</code> 是链表的最后一个节点，<code>FirstNode</code> 是第一个节点。</li>
 </ul>
 
 ## 解法

solution/2600-2699/2675.Array of Objects to Matrix/README.md

@@ -1,131 +1,133 @@
-# [2675. Array of Objects to Matrix](https://leetcode.cn/problems/array-of-objects-to-matrix)
+# [2675. 将对象数组转换为矩阵](https://leetcode.cn/problems/array-of-objects-to-matrix)
 
 [English Version](/solution/2600-2699/2675.Array%20of%20Objects%20to%20Matrix/README_EN.md)
 
 ## 题目描述
 
 <!-- 这里写题目描述 -->
 
-<p>Write a function that converts an array of objects&nbsp;<code>arr</code> into a matrix <code>m</code>.</p>
+<p>编写一个函数，将对象数组&nbsp;<code>arr</code>&nbsp;转换为矩阵&nbsp;<code>m</code>&nbsp;。</p>
 
-<p><code>arr</code>&nbsp;is an array of objects or arrays. Each item in the array can be deeply nested with child arrays and child objects. It can also contain numbers, strings, booleans, and&nbsp;null values.</p>
+<p><code>arr</code>&nbsp;是一个由对象组成的数组或一个数组。数组中的每个项都可以包含深层嵌套的子数组和子对象。它还可以包含数字、字符串、布尔值和空值。</p>
 
-<p>The first row <code>m</code>&nbsp;should be the column names. If there is no nesting, the column names are the unique keys within the objects. If there is nesting, the column names&nbsp;are the respective paths in the object separated by <code>&quot;.&quot;</code>.</p>
+<p>矩阵&nbsp;<code>m</code>&nbsp;的第一行应该是列名。如果没有嵌套，列名是对象中的唯一键。如果存在嵌套，列名是对象中相应路径，以点号&nbsp;<code>"."</code>&nbsp;分隔。</p>
 
-<p>Each of the remaining rows corresponds to an object in&nbsp;<code>arr</code>. Each value in the matrix corresponds to a value in an object. If a given object doesn&#39;t contain a value for a given column, the cell should contain an empty string&nbsp;<code>&quot;&quot;</code>.</p>
+<p>剩余的每一行对应&nbsp;<code>arr</code>&nbsp;中的一个对象。矩阵中的每个值对应对象中的一个值。如果给定对象在给定列中没有值，则应该包含空字符串 <code>""</code> 。</p>
 
-<p>The colums in the matrix should be in <strong>lexographically ascending</strong> order.</p>
+<p>矩阵中的列应按 <strong>字典升序</strong> 排列。</p>
 
 <p>&nbsp;</p>
-<p><strong class="example">Example 1:</strong></p>
+
+<p><strong class="example">示例 1：</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<b>输入：</b>
 arr = [
-&nbsp; {&quot;b&quot;: 1, &quot;a&quot;: 2},
-&nbsp; {&quot;b&quot;: 3, &quot;a&quot;: 4}
+&nbsp; {"b": 1, "a": 2},
+&nbsp; {"b": 3, "a": 4}
 ]
-<strong>Output:</strong> 
+<b>输出：</b>
 [
-&nbsp; [&quot;a&quot;, &quot;b&quot;],
+&nbsp; ["a", "b"],
 &nbsp; [2, 1],
 &nbsp; [4, 3]
 ]
 
-<strong>Explanation:</strong>
-There are two unique column names in the two objects: &quot;a&quot; and &quot;b&quot;.
-&quot;a&quot; corresponds with [2, 4].
-&quot;b&quot; coresponds with [1, 3].
+<strong>解释：</strong>
+两个对象中有两个唯一的列名："a"和"b"。 
+"a"对应[2, 4]。 
+"b"对应[1, 3]。
 </pre>
 
-<p><strong class="example">Example 2:</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<b>输入：</b>
 arr = [
-&nbsp; {&quot;a&quot;: 1, &quot;b&quot;: 2},
-&nbsp; {&quot;c&quot;: 3, &quot;d&quot;: 4},
+&nbsp; {"a": 1, "b": 2},
+&nbsp; {"c": 3, "d": 4},
 &nbsp; {}
 ]
-<strong>Output:</strong> 
+<b>输出：</b>
 [
-&nbsp; [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;],
-&nbsp; [1, 2, &quot;&quot;, &quot;&quot;],
-&nbsp; [&quot;&quot;, &quot;&quot;, 3, 4],
-&nbsp; [&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;]
+&nbsp; ["a", "b", "c", "d"],
+&nbsp; [1, 2, "", ""],
+&nbsp; ["", "", 3, 4],
+&nbsp; ["", "", "", ""]
 ]
 
-<strong>Explanation:</strong>
-There are 4 unique column names: &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;.
-The first object has values associated with &quot;a&quot; and &quot;b&quot;.
-The second object has values associated with &quot;c&quot; and &quot;d&quot;.
-The third object has no keys, so it is just a row of empty strings.
+<strong>解释：</strong>
+有四个唯一的列名："a"、"b"、"c"、"d"。 
+ 第一个对象具有与"a"和"b"关联的值。 
+第二个对象具有与"c"和"d"关联的值。 
+第三个对象没有键，因此只是一行空字符串。
 </pre>
 
-<p><strong class="example">Example 3:</strong></p>
+<p><strong class="example">示例 3：</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<b>输入：</b>
 arr = [
-&nbsp; {&quot;a&quot;: {&quot;b&quot;: 1, &quot;c&quot;: 2}},
-&nbsp; {&quot;a&quot;: {&quot;b&quot;: 3, &quot;d&quot;: 4}}
+&nbsp; {"a": {"b": 1, "c": 2}},
+&nbsp; {"a": {"b": 3, "d": 4}}
 ]
-<strong>Output:</strong> 
+<b>输出：</b>
 [
-&nbsp; [&quot;a.b&quot;, &quot;a.c&quot;, &quot;a.d&quot;],
-&nbsp; [1, 2, &quot;&quot;],
-&nbsp; [3, &quot;&quot;, 4]
+&nbsp; ["a.b", "a.c", "a.d"],
+&nbsp; [1, 2, ""],
+&nbsp; [3, "", 4]
 ]
 
-<strong>Explanation:</strong>
-In this example, the objects are nested. The keys represent the full path to each value separated by periods.
-There are three paths: &quot;a.b&quot;, &quot;a.c&quot;, &quot;a.d&quot;.
+<b>解释：</b>
+在这个例子中，对象是嵌套的。键表示每个值的完整路径，路径之间用句点分隔。 
+有三个路径："a.b"、"a.c"、"a.d"。
 </pre>
 
-<p><strong class="example">Example 4:</strong></p>
+<p><strong class="example">示例 4：</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<b>输入：</b>
 arr = [
-&nbsp; [{&quot;a&quot;: null}],
-&nbsp; [{&quot;b&quot;: true}],
-&nbsp; [{&quot;c&quot;: &quot;x&quot;}]
+&nbsp; [{"a": null}],
+&nbsp; [{"b": true}],
+&nbsp; [{"c": "x"}]
 ]
-<strong>Output:</strong> 
+<strong>输出：</strong> 
 [
-&nbsp; [&quot;0.a&quot;, &quot;0.b&quot;, &quot;0.c&quot;],
-&nbsp; [null, &quot;&quot;, &quot;&quot;],
-&nbsp; [&quot;&quot;, true, &quot;&quot;],
-&nbsp; [&quot;&quot;, &quot;&quot;, &quot;x&quot;]
+&nbsp; ["0.a", "0.b", "0.c"],
+&nbsp; [null, "", ""],
+&nbsp; ["", true, ""],
+&nbsp; ["", "", "x"]
 ]
 
-<strong>Explanation:</strong>
-Arrays are also considered objects with their keys being their indices.
-Each array has one element so the keys are &quot;0.a&quot;, &quot;0.b&quot;, and &quot;0.c&quot;.
+<strong>解释：</strong>
+数组也被视为具有索引为键的对象。 
+每个数组只有一个元素，所以键是"0.a"、"0.b"和"0.c"。
 </pre>
 
-<p><strong class="example">Example 5:</strong></p>
+<p><strong class="example">示例 5：</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<b>输入：</b>
 arr = [
   {},
 &nbsp; {},
 &nbsp; {},
 ]
-<strong>Output:</strong> 
+<b>输出：</b>
 [
 &nbsp; [],
 &nbsp; [],
 &nbsp; [],
 &nbsp; []
 ]
 
-<strong>Explanation:</strong>
-There are no keys so every row is an empty array.</pre>
+<strong>解释：</strong>
+没有键，所以每一行都是一个空数组。</pre>
 
 <p>&nbsp;</p>
-<p><strong>Constraints:</strong></p>
+
+<p><strong>提示：</strong></p>
 
 <ul>
 	<li><code>1 &lt;= arr.length &lt;= 1000</code></li>

solution/2600-2699/2676.Throttle/README.md

@@ -1,52 +1,54 @@
-# [2676. Throttle](https://leetcode.cn/problems/throttle)
+# [2676. 节流](https://leetcode.cn/problems/throttle)
 
-[English Version](/solution/2600-2699/2676.Throttle/README_EN.md)
+[English Version](/solution/2600-2699/2676.节流/README_EN.md)
 
 ## 题目描述
 
 <!-- 这里写题目描述 -->
 
-<p>Given a function <code>fn</code> and&nbsp;a time in milliseconds <code>t</code>, return&nbsp;a <strong>throttled</strong> version of that function.</p>
+<p>现给定一个函数 <code>fn</code> 和一个以毫秒为单位的时间 <code>t</code> ，请你返回该函数的 <strong>节流</strong> 版本。</p>
 
-<p>A <strong>throttled</strong> function is first called without delay and then, for a time interval of <code>t</code> milliseconds, can&#39;t be executed but should store the latest function arguments provided to call <code>fn</code> with them after the end of the delay.</p>
+<p><strong>节流</strong> 函数首先立即被调用，然后在 <code>t</code> 毫秒的时间间隔内不能再次执行，但应该存储最新的函数参数，以便在延迟结束后使用这些参数调用 <code>fn</code> 。</p>
 
-<p>For instance, <code>t = 50ms</code>, and the function was called at <code>30ms</code>, <code>40ms</code>, and <code>60ms</code>. The first function call would block calling functions for the following <code>t</code> milliseconds. The second function call would save arguments, and the third call arguments should overwrite currently stored arguments from the second call because the second and third calls are called before <code>80ms</code>. Once the delay has passed, the throttled function should be called with the latest arguments provided during the delay period, and it should also create another delay period of <code>80ms + t</code>.</p>
+<p>例如，<code>t = 50ms</code> ，并且函数在 <code>30ms</code> 、 <code>40ms</code> 和 <code>60ms</code> 时被调用。第一次函数调用会在接下来的 <code>t</code> 毫秒内阻止调用函数。第二次函数调用会保存参数，而第三次调用的参数应该覆盖当前保存的第二次调用的参数，因为第二次和第三次调用发生在 <code>80ms</code> 之前。一旦延迟时间过去，节流函数应该使用延迟期间提供的最新参数进行调用，并且还应创建另一个延迟期间，时长为 <code>80ms + t</code> 。</p>
 
-<p><img alt="Throttle Diagram" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2600-2699/2676.Throttle/images/screen-shot-2023-04-08-at-120313-pm.png" style="width: 1156px; height: 372px;" />The above diagram&nbsp;shows how throttle&nbsp;will transform&nbsp;events. Each rectangle represents 100ms and the throttle&nbsp;time is 400ms. Each color represents a different set of inputs.</p>
+<p><img alt="Throttle Diagram" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2600-2699/2676.Throttle/images/screen-shot-2023-04-08-at-120313-pm.png" style="width: 1156px; height: 372px;" />上面的图示展示了节流如何转换事件。每个矩形代表100毫秒，节流时间为400毫秒。每种颜色代表不同的输入集合。</p>
 
 <p>&nbsp;</p>
-<p><strong class="example">Example 1:</strong></p>
+
+<p><strong class="example">示例 1：</strong></p>
 
 <pre>
-<strong>Input:</strong> t = 100, calls = [{&quot;t&quot;:20,&quot;inputs&quot;:[1]}]
-<strong>Output:</strong> [{&quot;t&quot;:20,&quot;inputs&quot;:[1]}]
-<strong>Explanation:</strong> The 1st call is always called without delay
+<b>输入：</b>t = 100, calls = [{"t":20,"inputs":[1]}]
+<b>输出：</b>[{"t":20,"inputs":[1]}]
+<b>解释：</b>第一次调用总是立即执行，没有延迟。
 </pre>
 
-<p><strong class="example">Example 2:</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>Input:</strong> t = 50, calls = [{&quot;t&quot;:50,&quot;inputs&quot;:[1]},{&quot;t&quot;:75,&quot;inputs&quot;:[2]}]
-<strong>Output:</strong> [{&quot;t&quot;:50,&quot;inputs&quot;:[1]},{&quot;t&quot;:100,&quot;inputs&quot;:[2]}]
-<strong>Explanation:</strong> 
-The 1st is called a function with arguments (1) without delay.
-The 2nd is called at 75ms, within the delay period because 50ms + 50ms = 100ms, so the next call can be reached at 100ms. Therefore, we save arguments from the 2nd call to use them at the callback of the 1st call.
+<b>输入：</b>t = 50, calls = [{"t":50,"inputs":[1]},{"t":75,"inputs":[2]}]
+<b>输出：</b>[{"t":50,"inputs":[1]},{"t":100,"inputs":[2]}]
+<b>解释：</b>
+第一次调用立即执行带有参数 (1) 的函数。 
+第二次调用发生在 75毫秒 时，在延迟期间内，因为 50毫秒 + 50毫秒 = 100毫秒，所以下一次调用可以在 100毫秒 时执行。因此，我们保存第二次调用的参数，以便在第一次调用的回调函数中使用。
 </pre>
 
-<p><strong class="example">Example 3:</strong></p>
+<p><strong class="example">示例 3：</strong></p>
 
 <pre>
-<strong>Input:</strong> t = 70, calls = [{&quot;t&quot;:50,&quot;inputs&quot;:[1]},{&quot;t&quot;:75,&quot;inputs&quot;:[2]},{&quot;t&quot;:90,&quot;inputs&quot;:[8]},{&quot;t&quot;: 140, &quot;inputs&quot;:[5,7]},{&quot;t&quot;: 300, &quot;inputs&quot;: [9,4]}]
-<strong>Output:</strong> [{&quot;t&quot;:50,&quot;inputs&quot;:[1]},{&quot;t&quot;:120,&quot;inputs&quot;:[8]},{&quot;t&quot;:190,&quot;inputs&quot;:[5,7]},{&quot;t&quot;:300,&quot;inputs&quot;:[9,4]}]
-<strong>Explanation:</strong> 
-The 1st is called a function with arguments (1) without delay.
-The 2nd is called at 75ms within the delay period because 50ms + 70ms = 120ms, so it should only save arguments.&nbsp;
-The 3rd is also called within the delay period, and because we need just the latest function arguments, we overwrite previous ones. After the delay period, we do a callback at 120ms with saved arguments. That callback makes another delay period of 120ms + 70ms = 190ms so that the next function can be called at 190ms.
-The 4th is called at 140ms in the delay period, so it should be called as a callback at 190ms. That will create another delay period of 190ms + 70ms = 260ms.
-The 5th is called at 300ms, but it is after 260ms, so it should be called immediately and should create another delay period of 300ms + 70ms = 370ms.</pre>
+<b>输入：</b>t = 70, calls = [{"t":50,"inputs":[1]},{"t":75,"inputs":[2]},{"t":90,"inputs":[8]},{"t": 140, "inputs":[5,7]},{"t": 300, "inputs": [9,4]}]
+<b>输出：</b>[{"t":50,"inputs":[1]},{"t":120,"inputs":[8]},{"t":190,"inputs":[5,7]},{"t":300,"inputs":[9,4]}]
+<b>解释：</b>
+第一次调用立即执行带有参数 (1) 的函数。 
+第二次调用发生在 75毫秒 时，在延迟期间内，因为 50毫秒 + 70毫秒 = 120毫秒，所以它只应保存参数。 
+第三次调用也在延迟期间内，因为我们只需要最新的函数参数，所以覆盖之前的参数。延迟期过后，在 120毫秒时进行回调，并使用保存的参数进行调用。该回调会创建另一个延迟期间，时长为 120毫秒 + 70毫秒 = 190毫秒，以便下一个函数可以在 190毫秒时调用。 
+第四次调用发生在 140毫秒，在延迟期间内，因此应在190毫秒时作为回调进行调用。这将创建另一个延迟期间，时长为 190毫秒 + 70毫秒 = 260毫秒。 
+第五次调用发生在 300毫秒，但它是在 260毫秒 之后，所以应立即调用，并创建另一个延迟期间，时长为 300毫秒 + 70毫秒 = 370毫秒。</pre>
 
 <p>&nbsp;</p>
-<p><strong>Constraints:</strong></p>
+
+<p><strong>提示：</strong></p>
 
 <ul>
 	<li><code>0 &lt;= t &lt;= 1000</code></li>
@@ -68,24 +70,23 @@ The 5th is called at 300ms, but it is after 260ms, so it should be called immedi
 ```ts
 type F = (...args: any[]) => void;
 
-function throttle(fn: F, t: number): F {
-    let pre = 0;
-    let timeId = null;
-
-    return function (...args) {
-        const cur = Date.now();
-        if (cur - pre >= t) {
+const throttle = (fn: F, t: number): F => {
+    let pending = false;
+    let nextArgs;
+    const wrapper = (...args) => {
+        nextArgs = args;
+        if (!pending) {
             fn(...args);
-            pre = cur;
-        } else {
-            clearTimeout(timeId);
-            timeId = setTimeout(() => {
-                fn(...args);
-                pre += t;
-            }, t - (cur - pre));
+            pending = true;
+            nextArgs = undefined;
+            setTimeout(() => {
+                pending = false;
+                if (nextArgs) wrapper(...nextArgs);
+            }, t);
         }
     };
-}
+    return wrapper;
+};
 
 /**
  * const throttled = throttle(console.log, 100);