feat(docs): i18n Leetcode 目录翻译完成 (42 篇)

translator-leetcode 产出。Leetcode 题解目录特殊处理：
- 原文件名含方括号/中文/空格/_translated 后缀，命名风格混乱
- 翻译版统一改为 kebab-case 英文 slug：
  [146]LRU 缓存_translated.md → 146-lru-cache.en.md
  [121]买卖股票的最佳时期_translated.md → 121-best-time-to-buy-and-sell-stock.en.md

双向翻译：
- zh→en: 35 篇（绝大多数原文是中文题解）
- en→zh: 7 篇（2241 ATM / 2270 Split Array / 3138 Anagram /
  46 全排列 / 9021 TUT / 93 IP / Counting Stars / 等英文原文）

代码块（Python/C++/Java）原样保留，仅译注释。LaTeX 公式保留。
frontmatter 继承原文 docId，带 translatedFrom 标记。
跳过：1 个 <Cards> 索引页。

Author: longsizhuo

app/docs/CommunityShare/Leetcode/1004-max-consecutive-ones-iii.en.md

@@ -0,0 +1,74 @@
+---
+title: "1004. Max Consecutive Ones III"
+date: "2022.12.07-01:15"
+tags:
+  - - Python
+  - - solved
+    - answer
+abbrlink: ed19b576
+docId: ytg2bds2dnhzw37nrb3vassy
+lang: en
+translatedFrom: zh
+translatedAt: 2026-04-15T12:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+Today's daily problem was too hard, so I picked one myself. The approach is hash table + sliding window, though it feels like only sliding window was really used.
+
+```python
+
+class Solution:
+    def longestOnes(self, nums: List[int], k: int) -> int:
+        k_mean = k
+        # Used to record how many arrays there are now
+        flag = 0
+        # Used to record the maximum land number
+        max_flag = 0
+        for start in range(len(nums)):
+            tail = start
+            while k >= 0 and tail <= len(nums) - 1:
+                if nums[tail] == 1:
+                    tail += 1
+                    flag += 1
+                elif nums[tail] == 0 and k > 0:
+                    tail += 1
+                    k -= 1
+                    flag += 1
+                elif nums[tail] == 0 and k == 0:
+                    k = k_mean
+                    max_flag = max(max_flag, flag)
+                    flag = 0
+                    break
+                if tail == len(nums):
+                    max_flag = max(max_flag, flag)
+                    flag = 0
+                    break
+        return max_flag
+```
+
+This was my initial approach. Although it uses two pointers, it lacks flexibility — feels very stiff.
+
+The following is from [@Lincoln](/u/lincoln), recorded here purely as a personal note, not presented as my own answer.
+
+```
+class Solution:
+    def longestOnes(self, nums: List[int], k: int) -> int:
+        """
+        Idea: 1. k=0 can be understood as finding the longest substring without duplicates
+             2. If (current window size - number of 1s in window) <= k: expand the window (right+1)
+                If (current window size - number of 1s in window) > k: slide the window right (left+1)
+        Method: Hash table + Sliding window
+        """
+        n = len(nums)
+        o_res = 0
+        left = right = 0
+        while right < n:
+            if nums[right]== 1: o_res += 1
+            if right-left+1- o_res > k:
+                if nums[left]== 1: o_res -= 1
+                left += 1
+            right += 1
+        return right - left
+```
+
+Lincoln's thinking is very clear — worth remembering.

app/docs/CommunityShare/Leetcode/121-best-time-to-buy-and-sell-stock.en.md

@@ -0,0 +1,39 @@
+---
+title: "121. Best Time to Buy and Sell Stock"
+date: "2024.01.01 0:00"
+tags:
+  - Python
+  - answer
+  - Array
+  - Dynamic planning
+abbrlink: 3a21fe32
+docId: w9ffo1wycpbz50051cb7lyo5
+lang: en
+translatedFrom: zh
+translatedAt: 2026-04-15T12:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# Problem
+
+[121. Best Time to Buy and Sell Stock](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/)
+
+# Approach
+
+Dynamic programming — find the minimum problem.
+
+Recurrence: the maximum profit on day `i` = max(maximum profit on day `i-1`, price on day `i` − minimum price before day `i`)
+
+# Code
+
+```python
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        # Recurrence: max profit on day i = max(max profit on day i-1, price on day i - min price before day i-1)
+        dp = [0] * len(prices)
+        min_price = prices[0]
+        for i in range(1, len(prices)):
+            dp[i] = max(dp[i - 1], prices[i] - min_price)
+            min_price = min(min_price, prices[i])
+        return dp[-1]
+```

app/docs/CommunityShare/Leetcode/1234-replace-substring-for-balanced-string.en.md

@@ -0,0 +1,78 @@
+---
+title: "1234. Replace the Substring for Balanced String — Daily Problem"
+date: "2024.01.01 0:00"
+tags:
+  - - Python
+  - - answer
+abbrlink: 56d97dcf
+docId: p8igr19xfxnuyo2lpngnr6fg
+lang: en
+translatedFrom: zh
+translatedAt: 2026-04-15T12:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# Problem
+
+[1234. Replace the Substring for Balanced String](https://leetcode.cn/problems/replace-the-substring-for-balanced-string/description/)
+
+# Approach
+
+`all()`: returns `True` if `bool(x)` is `True` for all values `x` in the iterable. Returns `True` if the iterable is empty.
+
+Two pointers in the same direction — the elegant solution for this problem.
+
+If every character in the string appears exactly `n/4` times, then it is a "balanced string."
+
+If any character **outside** the substring to be replaced appears more than $m = \dfrac{n}{4}$ times, then no matter how you replace the substring, you cannot make that character's count equal to `m`.
+
+Conversely, if every character **outside** the substring appears at most `m` times:
+
+> Then a replacement exists that makes `s` a balanced string, where each character appears exactly `m` times.
+> For this problem, let the left and right endpoints of the substring be `left` and `right`. Enumerate `right`:
+> if every character outside the substring has count ≤ m, then the substring from `left` to `right` is a valid replacement. Its length is `right − left + 1`.
+> Update the minimum answer, then move `left` right to shrink the substring length.
+
+# Code
+
+```python
+class Solution:
+    def balancedString(self, s: str) -> int:
+        s_c = Counter(s)
+        n = len(s)
+        if all(s_c[v] <= n//4 for v in s_c):
+            return 0
+        ans, left = inf, 0
+        # enumerate right endpoint
+        for i, j in enumerate(s):
+            s_c[j] -= 1
+            while all(s_c[v] <= n // 4 for v in s_c):
+                ans = min(ans, i - left + 1)
+                s_c[s[left]] += 1
+                left += 1
+        return ans
+
+```
+
+```go
+func balancedString(s string) int {
+	cnt, m := ['X']int{}, len(s)/4
+	for _, c := range s {
+		cnt[c]++
+	}
+	if cnt['Q'] == m && cnt['W'] == m && cnt['E'] == m && cnt['R'] == m {
+		return 0
+	}
+	ans, left := len(s), 0
+	for right, c := range s {
+		cnt[c]--
+		for cnt['Q'] <= m && cnt['W'] <= m && cnt['E'] <= m && cnt['R'] <= m {
+			ans = min(ans, right-left+1)
+			cnt[s[left]]++
+			left++
+		}
+	}
+	return ans
+}
+func min(a, b int) int { if a > b { return b }; return a }
+```

app/docs/CommunityShare/Leetcode/1333-filter-restaurants-by-vegan-friendly-price-and-distance.en.md

@@ -0,0 +1,60 @@
+---
+title: "1333. Filter Restaurants by Vegan-Friendly, Price, and Distance"
+date: "2024.01.01 0:00"
+tags:
+  - Python
+  - answer
+  - Sort
+  - Array
+abbrlink: 7f1331bc
+docId: jcqhknk5z2xr3rfqn49me4j9
+lang: en
+translatedFrom: zh
+translatedAt: 2026-04-15T12:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# Problem
+
+[1333. Filter Restaurants by Vegan-Friendly, Price, and Distance](https://leetcode-cn.com/problems/filter-restaurants-by-vegan-friendly-price-and-distance/)
+
+# Approach
+
+My initial approach used `pop()`, but the time complexity was too high (~400ms). I switched to a list comprehension.
+
+A senior once told me: `pop()` runtime is fine, but when you combine it with index operations inside, it becomes very slow.
+
+**`sorted` and `lambda` usage:**
+
+`lambda` is Python's anonymous function syntax. Here, `lambda x: (x[1], x[0])` defines a function that takes an element `x` (a sublist of `restaurants`) and returns a tuple `(x[1], x[0])`.
+
+This means sorting is first based on `x[1]` (rating), then by `x[0]` (id) if `x[1]` values are equal.
+
+```python
+while ind < len(restaurants):
+     i = restaurants[ind]
+     if veganFriendly == 1 and i[2] == 0:
+         restaurants.pop(ind)
+     elif maxPrice < i[3]:
+         restaurants.pop(ind)
+     elif maxDistance < i[4]:
+         restaurants.pop(ind)
+     else:
+         ind += 1
+```
+
+# Code
+
+```python
+class Solution:
+    def filterRestaurants(self, restaurants: List[List[int]], veganFriendly: int, maxPrice: int, maxDistance: int) -> \
+            List[int]:
+        restaurants = [
+            i for i in restaurants
+            if (veganFriendly == 0 or i[2] == veganFriendly)
+               and i[3] <= maxPrice
+               and i[4] <= maxDistance
+        ]
+        restaurants = sorted(restaurants, key=lambda x: (x[1], x[0]), reverse=True)
+        return [i[0] for i in restaurants]
+```

app/docs/CommunityShare/Leetcode/142-linked-list-cycle-ii.en.md

@@ -0,0 +1,106 @@
+---
+title: "142. Linked List Cycle II"
+date: "2024.01.01 0:00"
+tags:
+  - - Python
+  - - answer
+abbrlink: e2c9cca9
+docId: ylpucy1rbbnfpe3t62u8kcfq
+lang: en
+translatedFrom: zh
+translatedAt: 2026-04-15T12:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+[142. Linked List Cycle II](https://leetcode.cn/problems/linked-list-cycle-ii/)
+
+# Approach
+
+### Problem Analysis
+
+This type of linked list problem is generally solved using the two-pointer technique — for example, finding the node at distance K from the tail, finding the cycle entrance, or finding the intersection node.
+
+### Algorithm
+
+1. **First meeting of two pointers:** Set two pointers `fast` and `slow` both pointing to `head`. `fast` moves 2 steps per round, `slow` moves 1 step per round.
+
+   a. **Case 1:** If `fast` reaches the end of the list, the list has no cycle — return `null`.
+
+   **Tip:** If there is a cycle, the two pointers will definitely meet. Each round, the gap between `fast` and `slow` decreases by 1, so `fast` will eventually catch `slow`.
+
+   b. **Case 2:** When `fast == slow`, the two pointers **meet for the first time inside the cycle**. Let's analyze the steps taken:
+
+   Suppose the list has `a + b` nodes in total, with `a` nodes from the head to the cycle entrance (not counting the entrance node), and `b` nodes in the cycle. Let `f` and `s` be the steps taken by each pointer:
+   - `fast` travels twice the steps of `slow`: `f = 2s`
+   - `fast` travels `n` extra cycles compared to `slow`: `f = s + nb`
+   - From the above: `f = 2nb`, `s = nb` — both pointers have walked an integer multiple of the cycle length.
+
+2. **Current situation analysis:**
+
+   If a pointer walks `k` steps from `head`, it reaches the cycle entrance when `k = a + nb` (after `a` steps it reaches the entrance; each additional cycle of `b` steps brings it back to the entrance).
+
+   Currently, `slow` has walked `nb` steps. So we just need `slow` to walk `a` more steps to reach the cycle entrance.
+
+   But we don't know `a`. We use a second pointer starting from `head`. When this pointer and `slow` both walk `a` steps together, they meet exactly at the cycle entrance.
+
+3. **Second meeting of two pointers:**
+   Keep `slow` in place, reset `fast` to `head`. Both move forward 1 step per round.
+
+   When `fast` has walked `a` steps: `slow` has walked `a + nb` steps. The two pointers meet and both point to the **cycle entrance**.
+
+4. Return the node pointed to by `slow`.
+
+### Complexity Analysis
+
+**Time complexity O(N):** In the second encounter, the slow pointer walks `a < a + b` steps. In the first encounter, the slow pointer walks `a + b − x < a + b` steps (where `x` is the distance from the meeting point to the entrance). The overall complexity is linear.
+
+**Space complexity O(1):** The two pointers use constant extra space.
+
+# Code
+
+```python
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        a = head
+        b = head
+        while True:
+            if not b or not b.next:
+                return None
+            a = a.next
+            b = b.next.next
+            if b == a:
+                break
+        b = head
+        while a != b:
+            a, b = a.next, b.next
+        return b
+```
+
+```cpp
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        ListNode *a = head;
+        ListNode *b = head;
+        while (true) {
+            if (!b or !b->next) {
+                return nullptr;
+            }
+            a = a->next;
+            b = b->next->next;
+            // because b moves two steps each time, a and b must meet
+            if (a == b) {
+                break;
+            }
+        }
+        // After meeting, keep a in place, reset b to head
+        b = head;
+        while(a!=b){
+            a = a->next;
+            b = b->next;
+        }
+
+        return a;
+    }
+};
+```