Removed fence mark in explanations.

gazeldx · gazeldx · commit a127a62f1e55 · 2025-03-25T06:43:04.000+08:00
diff --git a/en/1-1000/1-two-sum.md b/en/1-1000/1-two-sum.md
@@ -20,9 +20,7 @@ You can return the answer in any order.
 
 **Explanation**: 
 
-```
 Because nums[0] + nums[1] == 9, we return [0, 1].
-```
 
 ### [Example 2]
 
diff --git a/en/1-1000/15-3sum.md b/en/1-1000/15-3sum.md
@@ -18,13 +18,11 @@ Notice that the solution set must not contain duplicate triplets.
 
 **Explanation**: 
 
-```
 nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
 The distinct triplets are [-1,0,1] and [-1,-1,2].
 Notice that the order of the output and the order of the triplets does not matter.
-```
 
 ### [Example 2]
 
@@ -34,9 +32,7 @@ Notice that the order of the output and the order of the triplets does not matte
 
 **Explanation**: 
 
-```
 The only possible triplet does not sum up to 0.
-```
 
 ### [Example 3]
 
diff --git a/en/1-1000/202-happy-number.md b/en/1-1000/202-happy-number.md
@@ -24,12 +24,10 @@ Return `true` if `n` is *a happy number*, and `false` if not.
 
 **Explanation**: 
 
-```
 1^2 + 9^2 = 82
 8^2 + 2^2 = 68
 6^2 + 8^2 = 100
 1^2 + 0^2 + 0^2 = 1
-```
 
 ### [Example 2]
 
diff --git a/en/1-1000/209-minimum-size-subarray-sum.md b/en/1-1000/209-minimum-size-subarray-sum.md
@@ -18,9 +18,7 @@ Given an array of positive integers `nums` and a positive integer `target`, retu
 
 **Explanation**: 
 
-```
 The subarray [4,3] has the minimal length under the problem constraint.
-```
 
 ### [Example 2]
 
diff --git a/en/1-1000/27-remove-element.md b/en/1-1000/27-remove-element.md
@@ -21,10 +21,8 @@ Consider the number of elements in `nums` which are not equal to `val` be `k`, t
 
 **Explanation**: 
 
-```
 Your function should return k = 2, with the first two elements of nums being 2.
 It does not matter what you leave beyond the returned k (hence they are underscores).
-```
 
 ### [Example 2]
 
@@ -34,11 +32,9 @@ It does not matter what you leave beyond the returned k (hence they are undersco
 
 **Explanation**: 
 
-```
 Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4.
 Note that the five elements can be returned in any order.
 It does not matter what you leave beyond the returned k (hence they are underscores).
-```
 
 ### [Constraints]
 
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
@@ -16,10 +16,8 @@ Given two strings `needle` and `haystack`, return the **index** of the first occ
 
 **Explanation**: 
 
-```
 "sad" occurs at index 0 and 6.
 The first occurrence is at index 0, so we return 0.
-```
 
 ### [Example 2]
 
@@ -29,9 +27,7 @@ The first occurrence is at index 0, so we return 0.
 
 **Explanation**: 
 
-```
 "leeto" did not occur in "leetcode", so we return -1.
-```
 
 ### [Constraints]
 
diff --git a/en/1-1000/303-range-sum-query-immutable.md b/en/1-1000/303-range-sum-query-immutable.md
@@ -23,12 +23,10 @@ Implement the `NumArray` class:
 
 **Explanation**: 
 
-```
 NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
 numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1
 numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1
 numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
-```
 
 ### [Constraints]
 
diff --git a/en/1-1000/454-4sum-ii.md b/en/1-1000/454-4sum-ii.md
@@ -19,12 +19,10 @@ Given four integer arrays `nums1`, `nums2`, `nums3`, and `nums4` all of length `
 
 **Explanation**: 
 
-```
 The two tuples are:
 
 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
-```
 
 ### [Example 2]
 
diff --git a/en/1-1000/707-design-linked-list.md b/en/1-1000/707-design-linked-list.md
@@ -30,15 +30,13 @@ Implement the `MyLinkedList` class:
 
 **Explanation**: 
 
-```
 MyLinkedList myLinkedList = new MyLinkedList();
 myLinkedList.addAtHead(1);
 myLinkedList.addAtTail(3);
 myLinkedList.addAtIndex(1, 2);    // linked list becomes 1->2->3
 myLinkedList.get(1);              // return 2
 myLinkedList.deleteAtIndex(1);    // now the linked list is 1->3
 myLinkedList.get(1);              // return 3
-```
 
 ### [Constraints]
 
diff --git a/en/1-1000/833-find-and-replace-in-string.md b/en/1-1000/833-find-and-replace-in-string.md
@@ -34,10 +34,8 @@ A **substring** is a contiguous sequence of characters in a string.
 
 **Explanation**: 
 
-```
 "a" occurs at index 0 in s, so we replace it with "eee".
 "cd" occurs at index 2 in s, so we replace it with "ffff".
-```
 
 ### [Example 2]
 
@@ -49,10 +47,8 @@ A **substring** is a contiguous sequence of characters in a string.
 
 **Explanation**: 
 
-```
 "ab" occurs at index 0 in s, so we replace it with "eee".
 "ec" does not occur at index 2 in s, so we do nothing.
-```
 
 ### [Constraints]
 
diff --git a/en/1-1000/977-squares-of-a-sorted-array.md b/en/1-1000/977-squares-of-a-sorted-array.md
@@ -18,10 +18,8 @@ Given an integer array `nums` sorted in **non-decreasing** order, return *an arr
 
 **Explanation**: 
 
-```
 After squaring, the array becomes [16,1,0,9,100].
 After sorting, it becomes [0,1,9,16,100].
-```
 
 ### [Example 2]
 
diff --git a/en/3001-4000/3478-choose-k-elements-with-maximum-sum.md b/en/3001-4000/3478-choose-k-elements-with-maximum-sum.md
@@ -23,13 +23,11 @@ Return an array `answer` of size `n`, where `answer[i]` represents the result fo
 
 **Explanation**: 
 
-```
 - For `i = 0`: Select the 2 largest values from `nums2` at indices `[1, 2, 4]` where `nums1[j] < nums1[0]`, resulting in `50 + 30 = 80`.
 - For `i = 1`: Select the 2 largest values from `nums2` at index `[2]` where `nums1[j] < nums1[1]`, resulting in `30`.
 - For `i = 2`: No indices satisfy `nums1[j] < nums1[2]`, resulting in `0`.
 - For `i = 3`: Select the 2 largest values from `nums2` at indices `[0, 1, 2, 4]` where `nums1[j] < nums1[3]`, resulting in `50 + 30 = 80`.
 - For `i = 4`: Select the 2 largest values from `nums2` at indices `[1, 2]` where `nums1[j] < nums1[4]`, resulting in `30 + 20 = 50`.
-```
 
 ### [Example 2]
 
@@ -39,9 +37,7 @@ Return an array `answer` of size `n`, where `answer[i]` represents the result fo
 
 **Explanation**: 
 
-```
 Since all elements in `nums1` are equal, no indices satisfy the condition `nums1[j] < nums1[i]` for any `i`, resulting in `0` for all positions.
-```
 
 ### [Constraints]
 
diff --git a/zh/1-1000/15-3sum.md b/zh/1-1000/15-3sum.md
@@ -19,13 +19,11 @@
 
 **解释**: 
 
-```
 nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
 注意，输出的顺序和三元组的顺序并不重要。
-```
 
 ### [示例 2]
 
diff --git a/zh/1-1000/202-happy-number.md b/zh/1-1000/202-happy-number.md
@@ -23,12 +23,10 @@
 
 **解释**: 
 
-```
 1^2 + 9^2 = 82
 8^2 + 2^2 = 68
 6^2 + 8^2 = 100
 1^2 + 0^2 + 0^2 = 1
-```
 
 ### [示例 2]
 
diff --git a/zh/1-1000/27-remove-element.md b/zh/1-1000/27-remove-element.md
@@ -21,10 +21,8 @@
 
 **解释**: 
 
-```
 你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
 你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
-```
 
 ### [示例 2]
 
@@ -34,11 +32,9 @@
 
 **解释**: 
 
-```
 你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
 注意这五个元素可以任意顺序返回。
 你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
-```
 
 ### [约束]
 
diff --git a/zh/1-1000/303-range-sum-query-immutable.md b/zh/1-1000/303-range-sum-query-immutable.md
@@ -22,12 +22,10 @@
 
 **解释**: 
 
-```
 NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
 numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1
 numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1
 numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
-```
 
 ### [约束]
 
diff --git a/zh/1-1000/454-4sum-ii.md b/zh/1-1000/454-4sum-ii.md
@@ -19,12 +19,10 @@
 
 **解释**: 
 
-```
 两个元组如下：
 
 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
-```
 
 ### [示例 2]
 
diff --git a/zh/1-1000/707-design-linked-list.md b/zh/1-1000/707-design-linked-list.md
@@ -29,15 +29,13 @@
 
 **解释**: 
 
-```
 MyLinkedList myLinkedList = new MyLinkedList();
 myLinkedList.addAtHead(1);
 myLinkedList.addAtTail(3);
 myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
 myLinkedList.get(1);              // 返回 2
 myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
 myLinkedList.get(1);              // 返回 3
-```
 
 ### [约束]
 
diff --git a/zh/1-1000/833-find-and-replace-in-string.md b/zh/1-1000/833-find-and-replace-in-string.md
@@ -34,10 +34,8 @@
 
 **解释**: 
 
-```
 "a" 从 s 中的索引 0 开始，所以它被替换为 "eee"。
 "cd" 从 s 中的索引 2 开始，所以它被替换为 "ffff"。
-```
 
 ### [示例 2]
 
@@ -49,10 +47,8 @@
 
 **解释**: 
 
-```
 "ab" 从 s 中的索引 0 开始，所以它被替换为 "eee"。
 "ec" 没有从原始的 S 中的索引 2 开始，所以它没有被替换。
-```
 
 ### [约束]
 
diff --git a/zh/1-1000/977-squares-of-a-sorted-array.md b/zh/1-1000/977-squares-of-a-sorted-array.md
@@ -18,10 +18,8 @@
 
 **解释**: 
 
-```
 平方后，数组变为 [16,1,0,9,100]
 排序后，数组变为 [0,1,9,16,100]
-```
 
 ### [示例 2]
 
diff --git a/zh/3001-4000/3478-choose-k-elements-with-maximum-sum.md b/zh/3001-4000/3478-choose-k-elements-with-maximum-sum.md
@@ -24,13 +24,11 @@
 
 **解释**: 
 
-```
 - 对于 `i = 0` ：满足 `nums1[j] < nums1[0]` 的下标为 `[1, 2, 4]` ，选出其中值最大的两个，结果为 `50 + 30 = 80` 。
 - 对于 `i = 1` ：满足 `nums1[j] < nums1[1]` 的下标为 `[2]` ，只能选择这个值，结果为 `30` 。
 - 对于 `i = 2` ：不存在满足 `nums1[j] < nums1[2]` 的下标，结果为 `0` 。
 - 对于 `i = 3` ：满足 `nums1[j] < nums1[3]` 的下标为 `[0, 1, 2, 4]` ，选出其中值最大的两个，结果为 `50 + 30 = 80` 。
 - 对于 `i = 4` ：满足 `nums1[j] < nums1[4]` 的下标为 `[1, 2]` ，选出其中值最大的两个，结果为 `30 + 20 = 50` 。
-```
 
 ### [示例 2]
 
@@ -40,9 +38,7 @@
 
 **解释**: 
 
-```
 由于 `nums1` 中的所有元素相等，不存在满足条件 `nums1[j] < nums1[i]`，所有位置的结果都是 `0` 。
-```
 
 ### [约束]
 
