feat(seo): translate 32 zh-only docs to en

补齐 32 个只有中文版的 mdx 对应的 .en.md/.en.mdx，解决 /en/ URL 时
fumadocs fallbackLanguage='zh' 兜底渲染中文内容 + 中文 description
导致 URL/description 语言不一致的 SEO 隐患。

由 translator agent (claude-sonnet-4-6) 分两批并行翻译，保留代码块、
数学公式、URL、组件名 / 非文本属性原样；frontmatter 加 lang=en /
translatedFrom=zh / translatedAt / translatorAgent 4 个字段，docId
继承原文不变。

翻译范围：
- 9 个分区 index.mdx（career/community/learn/projects 等）
- 23 个 leetcode 题解 + 社区长文（PTE、UNSW 福利、Burnout、PPO 等）

翻译后中英对照对数从 97 → 129，zh-only 从 32 → 0。

Author: github-actions[bot]

content/docs/career/index.en.mdx

@@ -0,0 +1,19 @@
+---
+title: Career
+description: "Involution Hell tech docs — Career section. A one-stop resource hub for the entire CS/AI job search journey: LeetCode grinding strategies, behavioral interview (BQ) and online assessment (OA) tips, plus highlights from community events like Coffee Chat and Mock Interview."
+date: "2026-04-18"
+docId: crr0001index2026041800000001
+lang: en
+translatedFrom: zh
+translatedAt: 2026-05-11T00:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+import { SectionIndex } from "@/app/components/docs/SectionIndex";
+
+One-stop content for the job search journey:
+
+- **Interview Prep**: LeetCode grinding, BQ, OA, and Video Interview techniques
+- **Events**: Recaps of community events — Coffee Chat, Mock Interview, Career Journey, and more
+
+<SectionIndex root="career" />

content/docs/career/interview-prep/leetcode/2131. 连接两字母单词得到的最长回文串.en.md

@@ -0,0 +1,97 @@
+---
+title: "2131. Longest Palindrome by Concatenating Two Letter Words"
+description: "LeetCode 2131. Longest Palindrome by Concatenating Two Letter Words — solution using a hash map to count word occurrences, pairing words with their reverses to form palindrome pairs, and checking for any self-palindrome word that can serve as the center. Great for interview prep on hash tables and palindrome problems."
+date: "2025/5/25-2:33"
+tags:
+  - - Python
+  - - Answer
+abbrlink: 9fa195e5
+docId: ksw2vic4alf1tdnnueay81g8
+lang: en
+translatedFrom: zh
+translatedAt: 2026-05-11T00:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# QUESTION
+
+[2131. Longest Palindrome by Concatenating Two Letter Words](https://leetcode.cn/problems/longest-palindrome-by-concatenating-two-letter-words/description/?envType=daily-question&envId=2025-05-25)
+
+# My Think
+
+The idea comes from the brilliant Ling-nc.
+
+We build a hash map to count the occurrences of each word.
+
+For each word, we check whether its reverse exists in the hash map.
+If it does, they can form a palindrome pair — we update the result and decrease the corresponding count.
+If the reverse does not exist, we increment the count for the current word.
+Finally, we check if there's any palindromic word that can be used as the center of the palindrome.
+
+Example:
+
+1. Input: ["lc", "cl", "gg", "gg"]
+
+2. "lc" has no pair → stored in the map: { "lc": 1 }
+
+3. "cl" finds "lc" exists → use "lc" + "cl" as a pair → res += 4 → map updated to { "lc": 0 }
+
+4. "gg" has no pair → stored in the map: { "lc": 0, "gg": 1 }
+
+5. Second "gg" finds "gg" exists → use "gg" + "gg" as a pair → res += 4 → map becomes { "lc": 0, "gg": 0 }
+
+   Then we check whether the hash map contains any palindromic word (i.e., a word with two identical characters) that can be used as the center of the final palindrome string.
+   If such a word exists, we can add 2 more to the result.
+
+6. Finding a center word (can only pick one symmetric word)
+   ⚠️ In this example, all "gg" words have been paired, so none is left → no center word is added.
+
+# Code
+
+```python
+from collections import defaultdict
+from typing import List
+class Solution:
+    def longestPalindrome(self, words: List[str]) -> int:
+        count = defaultdict(int)
+        res = 0
+        for word in words:
+            if count[word[::-1]] > 0:
+                count[word[::-1]] -= 1
+                res += 4
+            else:
+                count[word] += 1
+        for key, value in count.items():
+            if key[0] == key[1] and value > 0:
+                res += 2
+                break
+        return res
+```
+
+```typescript
+function longestPalindrome(words: string[]): number {
+  const count: Map<string, number> = new Map();
+  let res = 0;
+
+  for (const word of words) {
+    const reversed = word.split("").reverse().join("");
+    const reversedCount = count.get(reversed) ?? 0;
+
+    if (reversedCount > 0) {
+      count.set(reversed, reversedCount - 1);
+      res += 2 * word.length;
+    } else {
+      count.set(word, (count.get(word) ?? 0) + 1);
+    }
+  }
+
+  for (const [word, freq] of count.entries()) {
+    if (word === word.split("").reverse().join("") && freq > 0) {
+      res += word.length;
+      break; // 只能选一个居中的回文串
+    }
+  }
+
+  return res;
+}
+```

content/docs/career/interview-prep/leetcode/2241-design-an-atm-machine.en.md

@@ -0,0 +1,97 @@
+---
+title: "2241. Design an ATM Machine"
+description: "LeetCode 2241. Design an ATM Machine — solution using a greedy algorithm to simulate ATM deposit and withdrawal logic. The core technique is iterating denominations in reverse (500→20) with a hash map tracking banknote counts, always using the largest denomination first. Suitable for CS/AI job seekers preparing for system design interviews or practicing medium-difficulty simulation problems."
+date: "2025-01-06"
+tags:
+  - - Python
+  - - Answer
+abbrlink: a21411f
+docId: lzrh7ftq3kegsyx8gimonrfu
+lang: en
+translatedFrom: zh
+translatedAt: 2026-05-11T00:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# Problem
+
+[2241. Design an ATM Machine](https://leetcode.cn/problems/design-an-atm-machine/description/?envType=daily-question&envId=2025-01-05)
+
+There is an ATM machine that stores banknotes of 5 denominations: $20, $50, $100, $200, and $500. Initially the ATM is empty. Users can deposit or withdraw money.
+
+When withdrawing, the machine prioritizes using banknotes of larger denominations.
+
+For example, if you want to withdraw $300 and there are 2 $50 banknotes, 1 $100 banknote, and 1 $200 banknote, the machine will use the $100 and $200 banknotes.
+
+However, if you try to withdraw $600 and there are 3 $200 banknotes and 1 $500 banknote, the request will be rejected — the machine first tries to use the $500 banknote, then cannot make up the remaining $100. Note that switching to $200 banknotes instead of the $500 is not allowed.
+
+Implement the ATM class:
+
+- `ATM()` initializes the ATM object.
+- `void deposit(int[] banknotesCount)` deposits new banknotes in the order $20, $50, $100, $200, $500.
+- `int[] withdraw(int amount)` returns an array of length 5 representing the number of banknotes of each denomination handed to the user (in the order $20, $50, $100, $200, $500), and updates the ATM's remaining banknotes. Returns `[-1]` if the withdrawal is impossible (no banknotes are dispensed in that case).
+
+# Approach
+
+The goal of this problem is to simulate an ATM — dispense exactly as much as requested, no more and no less. I use a greedy strategy, because the statement "if there are 3 `$200` banknotes and 1 `$500` banknote, the withdrawal request will be rejected" tells us we can skip the knapsack problem entirely and apply simple greedy logic.
+
+Since there are only five denominations — `20`, `50`, `100`, `200`, `500` — we store them in a list and iterate as needed. We then create a `defaultdict()` to maintain a hash map of banknote counts for each denomination.
+
+`deposit()` builds a reverse-order dictionary. Since we need to traverse from the largest to the smallest denomination, a reverse dictionary is very convenient here.
+
+Assuming the initial `amount` is `600`, the first denomination encountered is `500`, which fits the problem's logic perfectly.
+
+In the `withdraw()` function, I create a deep copy of the dictionary as a temporary store. This way, when we need to return `[-1]`, the original banknote counts remain unchanged — avoiding the need for backtracking.
+
+Sylvia and I used two different traversal approaches: she iterated over the denomination list, while I iterated directly over the dictionary (effectively over its keys).
+
+1. If the current amount (`600`) is greater than or equal to the current denomination (`500`), try to deduct. If all banknotes of that denomination are used up, move to the next denomination.
+2. If not fully used up, deduct as much as possible from `amount` and continue to the next denomination.
+3. If `amount` still has a remainder at the end, return `[-1]`; otherwise, calculate the total number of banknotes consumed — that is the answer.
+
+# Code
+
+```python
+import copy
+from typing import List
+
+from collections import defaultdict
+
+
+class ATM:
+
+    def __init__(self):
+        self.sd = defaultdict(int)
+        self.amount = ['20', '50', '100', '200', '500']
+
+    def deposit(self, banknotesCount: List[int]) -> None:
+        for i in range(len(banknotesCount) - 1, -1, -1):
+            self.sd[self.amount[i]] += banknotesCount[i]
+
+
+
+    def withdraw(self, amount: int) -> List[int]:
+        tempSd = copy.deepcopy(self.sd)
+        # key = 面值, value = 张数
+        for key, value in tempSd.items():
+            if amount >= int(key) and value > 0:
+                # 需要多少张钞票
+                howManyPiece = amount // int(key)
+                if howManyPiece >= value:
+                    # 全部取出来
+                    tempSd[key] = 0
+                    amount -= value * int(key)
+                else:
+                    # 取出这么多钞票
+                    tempSd[key] -= howManyPiece
+                    amount -= int(key) * howManyPiece
+        else:
+            if amount > 0:
+                return [-1]
+            else:
+                ans = []
+                for i in self.sd.keys():
+                    ans.append(self.sd[i] - tempSd[i])
+                self.sd = copy.deepcopy(tempSd)
+                return ans[::-1]
+```

content/docs/career/interview-prep/leetcode/2241. Design an ATM Machine.en.md

@@ -0,0 +1,101 @@
+---
+title: "2241. Design an ATM Machine"
+description: "LeetCode 2241. Design an ATM Machine — simulating bank ATM deposit and withdrawal logic with a focus on implementing a greedy withdrawal strategy: always use the largest denomination first (500, 200, 100, 50, 20), and handle cases where the balance is insufficient or cannot be evenly dispensed. Suitable for algorithm learners preparing for system design interviews or practicing object-oriented simulation problems."
+date: "2025-01-06"
+tags:
+  - - Python
+  - - Answer
+abbrlink: a21411f
+docId: lzrh7ftq3kegsyx8gimonrfu
+lang: en
+translatedFrom: zh
+translatedAt: 2026-05-11T00:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# QUESTION
+
+[2241. Design an ATM Machine](https://leetcode.cn/problems/design-an-atm-machine/description/?envType=daily-question&envId=2025-01-05)
+
+There is an ATM machine that stores banknotes of 5 denominations: 20, 50, 100, 200, and 500 dollars. Initially the ATM is empty. The user can use the machine to deposit or withdraw any amount of money.
+
+When withdrawing, the machine prioritizes using banknotes of larger values.
+
+For example, if you want to withdraw $300 and there are 2 $50 banknotes, 1 $100 banknote, and 1 $200 banknote, then the machine will use the $100 and $200 banknotes.
+However, if you try to withdraw $600 and there are 3 $200 banknotes and 1 $500 banknote, then the withdraw request will be rejected because the machine will first try to use the $500 banknote and then be unable to use banknotes to complete the remaining $100. Note that the machine is not allowed to use the $200 banknotes instead of the $500 banknote.
+
+Implement the ATM class:
+
+ATM() Initializes the ATM object.
+void deposit(int[] banknotesCount) Deposits new banknotes in the order $20, $50, $100, $200, and $500.
+int[] withdraw(int amount) Returns an array of length 5 of the number of banknotes that will be handed to the user in the order $20, $50, $100, $200, and $500, and update the number of banknotes in the ATM after withdrawing. Returns [-1] if it is not possible (do not withdraw any banknotes in this case).
+
+# My Think
+
+The purpose of this question is to simulate an ATM machine, which returns the amount of money you withdraw, no more and no less. I am greedy, because the second sentence "There are 3 `$200` bills and 1 `$500` bill in the machine, so the withdrawal request will be rejected"
+This shows that we can skip thinking about the knapsack problem in complex dynamic programming and directly consider simple greed.
+
+Because the denominations of the deposited money are only `20`, `50`, `100`, `200`, `500`, we can store them in the list in advance and wait for traversal.
+
+Then we create a `defaultdict()` to create a hash table for each denomination in the ATM machine.
+
+`deposit()` creates a reverse traversal dictionary. Because we need to traverse the dictionary from large denominations to small denominations, the reverse dictionary is very convenient at this time.
+
+Assuming the initial `amount` is `600`, the first denomination traversed is `500`, It fits the logic of the question very well.
+
+For the `withdraw()` function, I created a temporary dictionary deep copy storage so that the initial array will not be changed when `[-1]` is returned. Otherwise, it will be troublesome to backtrack.
+
+Here, Sylvia and I used two different traversal methods. She traversed the list of denominations, while I traversed the dictionary directly (actually traversed the key directly).
+
+1. If the current denomination (`600`) is greater than the current denomination (`500`), then try to deduct it. If the bank money is withdrawn directly, then look at the next denomination.
+
+2. If it is not withdrawn, then `amount` deducts the deductible share and then continues to look at the next denomination.
+
+3. If there is still `amount` left at the end, return `[-1]`, otherwise calculate how many bills have been consumed in total, which is the answer.
+
+# Code
+
+```python
+import copy
+from typing import List
+
+from collections import defaultdict
+
+
+class ATM:
+
+    def __init__(self):
+        self.sd = defaultdict(int)
+        self.amount = ['20', '50', '100', '200', '500']
+
+    def deposit(self, banknotesCount: List[int]) -> None:
+        for i in range(len(banknotesCount) - 1, -1, -1):
+            self.sd[self.amount[i]] += banknotesCount[i]
+
+
+
+    def withdraw(self, amount: int) -> List[int]:
+        tempSd = copy.deepcopy(self.sd)
+        # key = 面值, value = 张数
+        for key, value in tempSd.items():
+            if amount >= int(key) and value > 0:
+                # 需要多少张钞票
+                howManyPiece = amount // int(key)
+                if howManyPiece >= value:
+                    # 全部取出来
+                    tempSd[key] = 0
+                    amount -= value * int(key)
+                else:
+                    # 取出这么多钞票
+                    tempSd[key] -= howManyPiece
+                    amount -= int(key) * howManyPiece
+        else:
+            if amount > 0:
+                return [-1]
+            else:
+                ans = []
+                for i in self.sd.keys():
+                    ans.append(self.sd[i] - tempSd[i])
+                self.sd = copy.deepcopy(tempSd)
+                return ans[::-1]
+```

content/docs/career/interview-prep/leetcode/2270-number-of-ways-to-split-array.en.md

@@ -0,0 +1,45 @@
+---
+title: "2270. Number of Ways to Split Array"
+description: "LeetCode 2270. Number of Ways to Split Array — solution using prefix sums and a single traversal to count valid split points. The core technique is maintaining left and right subarray sums and comparing whether the left side is greater than or equal to the right. Suitable for job seekers and beginners practicing array interval sum problems."
+date: "2025/1/14-9:31"
+tags:
+  - - Python
+  - - Answer
+abbrlink: c25bb550
+docId: a6inw303oslb7i5tcqj5xxx4
+lang: en
+translatedFrom: zh
+translatedAt: 2026-05-11T00:00:00Z
+translatorAgent: claude-sonnet-4-6
+---
+
+# Problem
+
+[2270. Number of Ways to Split Array](https://leetcode.cn/problems/number-of-ways-to-split-array/description/)
+
+# Approach
+
+`2 <= nums.length <= 10^5`, so we can directly take the first element. The initial state has the pointer at index 0, about to move to index 1. A single `for` loop is all we need.
+
+The second method is the key one — taken from the editorial.
+
+# Code
+
+```python
+class Solution:
+    def waysToSplitArray(self, nums: List[int]) -> int:
+        temp_sum = nums[0]
+        total_sum = sum(nums) - temp_sum
+        ans = 0
+        for i in range(1, len(nums)):
+            if temp_sum >= total_sum:
+                ans += 1
+            temp_sum += nums[i]
+            total_sum -= nums[i]
+        return ans
+```
+
+```python
+t = (sum(nums) + 1) // 2
+return sum(s >= t for s in accumulate(nums[:-1]))
+```