docs: 更新多个题解文件以匹配 leetcoder.net 的格式

gazeldx · gazeldx · commit 58dda9d6cbf4 · 2025-03-24T14:10:42.000+08:00
diff --git a/en/1-1000/202-happy-number.md b/en/1-1000/202-happy-number.md
@@ -1,4 +1,6 @@
-# 202. Happy Number - Best Practices of LeetCode Solutions
+Original link: [leetcoder.net - Fucking Good LeetCode Solutions](https://leetcoder.net/en/leetcode/202-happy-number)
+
+# 202. Happy Number - Fucking Good LeetCode Solutions
 LeetCode link: [202. Happy Number](https://leetcode.com/problems/happy-number), difficulty: **Easy**.
 
 ## LeetCode description of "202. Happy Number"
diff --git a/en/1-1000/28-find-the-index-of-the-first-occurrence-in-a-string.md b/en/1-1000/28-find-the-index-of-the-first-occurrence-in-a-string.md
@@ -1,4 +1,6 @@
-# 28. Find the Index of the First Occurrence in a String - Best Practices of LeetCode Solutions
+Original link: [leetcoder.net - Fucking Good LeetCode Solutions](https://leetcoder.net/en/leetcode/28-find-the-index-of-the-first-occurrence-in-a-string)
+
+# 28. Find the Index of the First Occurrence in a String - Fucking Good LeetCode Solutions
 LeetCode link: [28. Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string), difficulty: **Easy**.
 
 ## LeetCode description of "28. Find the Index of the First Occurrence in a String"
@@ -100,7 +102,27 @@ var strStr = function (haystack, needle) {
 # Welcome to create a PR to complete the code of this language, thanks!
 ```
 
-## C, Kotlin, Swift, Rust or other languages
+## C
+```c
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Kotlin
+```kotlin
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Swift
+```swift
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Rust
+```rust
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Other languages
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
diff --git a/en/1-1000/349-intersection-of-two-arrays.md b/en/1-1000/349-intersection-of-two-arrays.md
@@ -1,4 +1,6 @@
-# 349. Intersection of Two Arrays - Best Practices of LeetCode Solutions
+Original link: [leetcoder.net - Fucking Good LeetCode Solutions](https://leetcoder.net/en/leetcode/349-intersection-of-two-arrays)
+
+# 349. Intersection of Two Arrays - Fucking Good LeetCode Solutions
 LeetCode link: [349. Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays), difficulty: **Easy**.
 
 ## LeetCode description of "349. Intersection of Two Arrays"
@@ -26,9 +28,31 @@ Each element in the result must be **unique** and you may return the result in *
 2. When traversing the other array, if an element is found to already exist in the `set`, it means that the element belongs to the intersection, and the element should be added to the `results`.
 3. The `results` is also of `set` type because duplicate removal is required.
 
+## Steps
+
+1. Convert one of the arrays to a `set`. The elements are unique in a `set`.
+
+	```javascript
+	let num1Set = new Set(nums1)
+	```
+
+2. When traversing the other array, if an element is found to already exist in the `set`, it means that the element belongs to the intersection, and the element should be added to the `results`.
+
+	```javascript
+	let results = new Set()
+	
+	for (const num of nums2) {
+	  if (num1Set.has(num)) {
+	    results.add(num)
+	  }
+	}
+	
+	return Array.from(results)
+	```
+
 ## Complexity
-* Time: `O(N)`.
-* Space: `O(N)`.
+* Time: `O(n)`.
+* Space: `O(n)`.
 
 ## Java
 ```java
diff --git a/en/1-1000/383-ransom-note.md b/en/1-1000/383-ransom-note.md
@@ -1,4 +1,5 @@
-# 383. Ransom Note - Best Practices of LeetCode Solutions
+# 383. Ransom Note - Fucking Good LeetCode Solutions
+
 LeetCode link: [383. Ransom Note](https://leetcode.com/problems/ransom-note),
 [383. 赎金信](https://leetcode.cn/problems/ransom-note)
 
@@ -256,3 +257,104 @@ for (character in ransomNote) {
 
 return true
 ```
+
+## 复杂度
+* 时间：`O(n)`。
+* 空间：`O(n)`。
+
+## Java
+```java
+class Solution {
+    public boolean canConstruct(String ransomNote, String magazine) {
+        var charToCount = new HashMap<Character, Integer>();
+
+        for (var character : magazine.toCharArray()) {
+            charToCount.put(character, charToCount.getOrDefault(character, 0) + 1);
+        }
+
+        for (var character : ransomNote.toCharArray()) {
+            charToCount.put(character, charToCount.getOrDefault(character, 0) - 1);
+
+            if (charToCount.get(character) < 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+```
+
+## Python
+```python
+# from collections import defaultdict
+
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        char_to_count = defaultdict(int)
+
+        for char in magazine:
+            char_to_count[char] += 1
+
+        for char in ransomNote:
+            char_to_count[char] -= 1
+
+            if char_to_count[char] < 0:
+                return False
+
+        return True
+```
+
+## JavaScript
+```javascript
+var canConstruct = function (ransomNote, magazine) {
+  const charToCount = new Map()
+
+  for (const character of magazine) {
+    charToCount.set(character, (charToCount.get(character) || 0) + 1)
+  }
+
+  for (const character of ransomNote) {
+    charToCount.set(character, (charToCount.get(character) || 0) - 1)
+
+    if (charToCount.get(character) < 0) {
+      return false
+    }
+  }
+
+  return true
+};
+```
+
+## C#
+```c#
+public class Solution
+{
+    public bool CanConstruct(string ransomNote, string magazine)
+    {
+        var charToCount = new Dictionary<char, int>();
+
+        foreach (char character in magazine)
+            charToCount[character] = charToCount.GetValueOrDefault(character, 0) + 1;
+
+        foreach (char character in ransomNote)
+        {
+            charToCount[character] = charToCount.GetValueOrDefault(character, 0) - 1;
+
+            if (charToCount[character] < 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+```
+
+## Other languages
+```java
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+原文链接：[leetcoder.net - Fucking Good LeetCode Solutions](https://leetcoder.net/en/leetcode/383-ransom-note)
diff --git a/en/1-1000/454-4sum-ii.md b/en/1-1000/454-4sum-ii.md
@@ -1,5 +1,7 @@
-# 454. 4Sum II - Best Practices of LeetCode Solutions
-LeetCode link: [454. 4Sum II](https://leetcode.com/problems/problem), difficulty: **Medium**.
+原文链接：[leetcoder.net - Fucking Good LeetCode Solutions](https://leetcoder.net/en/leetcode/454-4sum-ii)
+
+# 454. 4Sum II - Fucking Good LeetCode Solutions
+LeetCode link: [454. 4Sum II](https://leetcode.com/problems/4sum-ii), difficulty: **Medium**.
 
 ## LeetCode description of "454. 4Sum II"
 Given four integer arrays `nums1`, `nums2`, `nums3`, and `nums4` all of length `n`, return the number of tuples `(i, j, k, l)` such that:
diff --git a/zh/1-1000/202-happy-number.md b/zh/1-1000/202-happy-number.md
@@ -1,15 +1,18 @@
+原文链接：[leetcoder.net - 力扣题解最佳实践](https://leetcoder.net/zh/leetcode/202-happy-number)
+
 # 202. 快乐数 - 力扣题解最佳实践
 力扣链接：[202. 快乐数](https://leetcode.cn/problems/happy-number) ，难度：**简单**。
 
-## 力扣“202. 快乐数”问题描述
+## 力扣"202. 快乐数"问题描述
 编写一个算法来判断一个数 `n` 是不是快乐数。
 
-「**快乐数**」 定义为：
+「快乐数」定义为：
 
 - 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
-- 然后重复这个过程直到这个数变为 `1`，也可能是 **无限循环** 但始终变不到 `1`。
-- 如果这个过程 **结果为** `1`，那么这个数就是快乐数。
-- 如果 `n` 是 *快乐数* 就返回 `true` ；不是，则返回 `false` 。
+- 然后重复这个过程直到这个数变为 1，也可能是 **无限循环** 但始终变不到 1。
+- 如果 **可以变为** 1，那么这个数就是快乐数。
+
+如果 `n` 是快乐数就返回 `true` ；不是，则返回 `false` 。
 
 ### [示例 1]
 **输入**: `n = 19`
@@ -18,10 +21,10 @@
 
 **解释**:
 ```
-1**2 + 9**2 = 82
-8**2 + 2**2 = 68
-6**2 + 8**2 = 100
-1**2 + 0**2 + 0**2 = 1
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
 ```
 
 ### [示例 2]
@@ -30,15 +33,15 @@
 **输出**: `false`
 
 ### [约束]
-- `1 <= n <= 2**31 - 1`
+- `1 <= n <= 2^31 - 1`
 
 ## 思路
-1. 递归调用`isHappy(n)`比较方便，每次只需要生成新的`n`作为参数。
-2. 如果`n`已经出现过了，说明进入了循环，`return false`。可以用`Set`保存已经出现过的`n`。
+1. 递归调用 `isHappy(n)` 更方便。每次只需要生成新的 `n` 作为参数。
+2. 如果 `n` 已经出现过，说明进入了循环，`return false`。可以用 `Set` 保存出现过的 `n`。
 
 ## 步骤
 
-1. 生成新的`n`作为`isHappy()`的参数。
+1. 生成新的 `n` 作为 `isHappy(n)` 的参数。
 
 	```javascript
 	let sum = 0
@@ -52,10 +55,10 @@
 	return isHappy(sum)
 	```
 
-2. 如果`n`已经出现过了，说明进入了循环，`return false`。可以用`Set`保存已经出现过的`n`。
+2. 如果 `n` 已经出现过，说明进入了循环，`return false`。可以用 `Set` 保存出现过的 `n`。
 
 	```javascript
-	var isHappy = function (n, appearedNums) {
+	var isHappy = function (n, appearedNums) { // 0
 	  appearedNums ||= new Set() // 1
 	  let sum = 0
 	
@@ -78,8 +81,8 @@
 	```
 
 ## 复杂度
-* 时间：`O(log N)`。
-* 空间：`O(log N)`。
+* 时间: `O(log N)`.
+* 空间: `O(log N)`.
 
 ## Java
 ```java
diff --git a/zh/1-1000/28-find-the-index-of-the-first-occurrence-in-a-string.md b/zh/1-1000/28-find-the-index-of-the-first-occurrence-in-a-string.md
@@ -1,7 +1,9 @@
+原文链接：[leetcoder.net - 力扣题解最佳实践](https://leetcoder.net/zh/leetcode/28-find-the-index-of-the-first-occurrence-in-a-string)
+
 # 28. 找出字符串中第一个匹配项的下标 - 力扣题解最佳实践
 力扣链接：[28. 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) ，难度：**简单**。
 
-## 力扣“28. 找出字符串中第一个匹配项的下标”问题描述
+## 力扣"28. 找出字符串中第一个匹配项的下标"问题描述
 给你两个字符串 `haystack` 和 `needle` ，请你在 `haystack` 字符串中找出 `needle` 字符串的第一个匹配项的下标（下标从 `0` 开始）。如果 `needle` 不是 `haystack` 的一部分，则返回 `-1` 。
 
 ### [示例 1]
diff --git a/zh/1-1000/383-ransom-note.md b/zh/1-1000/383-ransom-note.md
@@ -2,9 +2,9 @@
 
 # 383. 赎金信 - 力扣题解最佳实践
 
-力扣链接：[383. 赎金信](https://leetcode.cn/problems/ransom-note), 难度：**简单**。
+力扣链接：[383. 赎金信](https://leetcode.cn/problems/ransom-note) ，难度：**简单**。
 
-## 力扣“383. 赎金信”问题描述
+## 力扣"383. 赎金信"问题描述
 
 给你两个字符串：`ransomNote` 和 `magazine` ，判断 `ransomNote` 能不能由 `magazine` 里面的字符构成。
 
@@ -29,15 +29,14 @@
 **输出**: `true`
 ### [约束]
 
-- `1 <= ransomNote.length, magazine.length <= 10^5`
+- `1 <= ransomNote.length, magazine.length <= 100000`
 - `ransomNote` 和 `magazine` 由小写英文字母组成
 
 ## 思路
 
 1. 本题等同于求`magazine`是否能包含`ransomNote`中的所有字符。
-2. 先对`magazine`进行统计，得出每个字符对应的字数，结果存储在`Map`中。每一次都是一个加一的操作。
-3. 下一步做什么？
-    <details><summary>点击查看答案</summary><p>遍历`ransomNote`，对当前字符对应的数量进行减一操作（反向操作）。如果某个字符的数量小于0，则返回`false`。</p></details>
+2. 先对`magazine`进行字符和字数统计，结果存储在`Map`中。
+3. 然后，遍历`ransomNote`，并对`Map`中的数据进行反向操作。如果某个字符的字数小于0，则返回`false`。
 
 ## 步骤
 
@@ -73,8 +72,8 @@
 
 ## 复杂度
 
-- 时间复杂度: `O(N)`.
-- 空间复杂度: `O(N)`.
+- 时间复杂度: `O(n)`.
+- 空间复杂度: `O(n)`.
 
 ## Java
 
@@ -170,8 +169,50 @@ public class Solution
 }
 ```
 
+## C++
+
+```cpp
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Go
+
+```go
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Ruby
+
+```ruby
+# Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## C
+
+```c
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Kotlin
+
+```kotlin
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Swift
+
+```swift
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
+## Rust
+
+```rust
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
 ## Other languages
 
-```java
+```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
diff --git a/zh/1-1000/454-4sum-ii.md b/zh/1-1000/454-4sum-ii.md
