Replaced Intuition behind the Solution with Intuition.

gazeldx · gazeldx · commit 5ae74b3bf39c · 2025-01-19T13:48:08.000+08:00
diff --git a/en/1-1000/160-intersection-of-two-linked-lists.md b/en/1-1000/160-intersection-of-two-linked-lists.md
@@ -39,7 +39,7 @@ Difficulty: **Easy**
 
 **Follow up**: Could you write a solution that runs in `O(m + n)` time and use only `O(1)` memory?
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. First calculate the number of nodes in the two linked lists A and B. The number of nodes in linked list A is `node_count_a`, and the number of nodes in linked list B is `node_count_b`.
diff --git a/en/1-1000/18-4sum.md b/en/1-1000/18-4sum.md
@@ -29,7 +29,7 @@ Difficulty: **Medium**
 - `-10**9 <= nums[i] <= 10**9`
 - `-10**9 <= target <= 10**9`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. The idea of this question is the same as [15. 3Sum](15-3sum.md), please click the link to view.
diff --git a/en/1-1000/19-remove-nth-node-from-end-of-list.md b/en/1-1000/19-remove-nth-node-from-end-of-list.md
@@ -35,7 +35,7 @@ Given the `head` of a linked list, remove the `n-th` node from the end of the li
   Maintain two pointers and update one with a delay of n steps.
 </details>
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Deleting the `N-th` to last node in a linked list is equivalent to deleting the `node_count - N`-th node in the linked list.
diff --git a/en/1-1000/202-happy-number.md b/en/1-1000/202-happy-number.md
@@ -38,7 +38,7 @@ Difficulty: **Easy**
 ### [Constraints]
 - `1 <= n <= 2**31 - 1`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. It is more convenient to call `isHappy(n)` recursively. You only need to generate a new `n` as a parameter each time.
diff --git a/en/1-1000/203-remove-linked-list-elements.md b/en/1-1000/203-remove-linked-list-elements.md
@@ -29,7 +29,7 @@ Given the `head` of a linked list and an integer `val`, remove all the nodes of
 - `1 <= Node.val <= 50`
 - `0 <= val <= 50`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Assume that the node to be deleted in the linked list is `d`, and the previous node of `d` is `p`, so `p.next` is `d`.
diff --git a/en/1-1000/206-reverse-linked-list.md b/en/1-1000/206-reverse-linked-list.md
@@ -30,7 +30,7 @@ Given the `head` of a singly linked list, reverse the list, and return _the reve
 - The number of nodes in the list is the range `[0, 5000]`.
 - `-5000 <= Node.val <= 5000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. To solve this problem, we only need to define **two** variables: `current` and `previous`.
diff --git a/en/1-1000/209-minimum-size-subarray-sum.md b/en/1-1000/209-minimum-size-subarray-sum.md
@@ -33,7 +33,7 @@ Difficulty: **Medium**
 - `1 <= nums.length <= 100000`
 - `1 <= nums[i] <= 10000`
 
-## Intuition behind the Solution
+## Intuition
 For **subarray** problems, you can consider using **Sliding Window Technique**, which is similar to the **Fast and Slow Pointers Technique**.
 
 ## Steps
diff --git a/en/1-1000/232-implement-queue-using-stacks.md b/en/1-1000/232-implement-queue-using-stacks.md
@@ -48,7 +48,7 @@ myQueue.empty(); // return false
 
 **Follow-up**: Can you implement the queue such that each operation is amortized `O(1)` time complexity? In other words, performing `n` operations will take overall `O(n)` time even if one of those operations may take longer.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 
diff --git a/en/1-1000/24-swap-nodes-in-pairs.md b/en/1-1000/24-swap-nodes-in-pairs.md
@@ -33,7 +33,7 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 - The number of nodes in the list is in the range `[0, 100]`.
 - `0 <= Node.val <= 100`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Before solving this problem, it is recommended to solve the simple problem [206. Reverse Linked List](206-reverse-linked-list.md) first.
diff --git a/en/1-1000/242-valid-anagram.md b/en/1-1000/242-valid-anagram.md
@@ -25,7 +25,7 @@ Difficulty: **Easy**
 - `1 <= s.length, t.length <= 5 * 10000`
 - `s` and `t` consist of lowercase English letters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. If the lengths of the two strings are different, return `false` directly.
diff --git a/en/1-1000/27-remove-element.md b/en/1-1000/27-remove-element.md
@@ -46,7 +46,7 @@ It does not matter what you leave beyond the returned k (hence they are undersco
   Yet another direction of thought is to consider the elements to be removed as non-existent. In a single pass, if we keep copying the visible elements in-place, that should also solve this problem for us.
 </details>
 
-## Intuition behind the Solution
+## Intuition
 The goal is to remove the elements in the array that are equal to `val`, and the order of the remaining elements is not important.
 
 ### Solution 1 (easier to think of)
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
@@ -32,7 +32,7 @@ The first occurrence is at index 0, so we return 0.
 - `1 <= haystack.length, needle.length <= 10000`
 - `haystack` and `needle` consist of only lowercase English characters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Traverse the string once, and if the `needle.length` characters after the current position are equal to `needle`, return the current `index`.
diff --git a/en/1-1000/303-range-sum-query-immutable.md b/en/1-1000/303-range-sum-query-immutable.md
@@ -37,7 +37,7 @@ numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
 - `0 <= left <= right < nums.length`
 - At most `10000` calls will be made to `sumRange`.
 
-## Intuition behind the Solution
+## Intuition
 ### Solution 2
 Directly returning the sum of the array elements can pass the tests, but if the test case is more stringent, it will fail.
 So we still need to learn a more efficient solution.
diff --git a/en/1-1000/344-reverse-string.md b/en/1-1000/344-reverse-string.md
@@ -31,7 +31,7 @@ Difficulty: **Easy**
   The entire logic for reversing a string is based on using the opposite directional two-pointer approach!
 </details>
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. This problem can be solved in one line of code using the built-in `sort()` method of the programming language. If this question is asked in an interview, the questioner should be testing how to do it without the built-in method.
diff --git a/en/1-1000/349-intersection-of-two-arrays.md b/en/1-1000/349-intersection-of-two-arrays.md
@@ -24,7 +24,7 @@ Difficulty: **Easy**
 - `1 <= nums1.length, nums2.length <= 1000`
 - `0 <= nums1[i], nums2[i] <= 1000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Convert one of the arrays to a `set`. The elements are unique in a `set`.
diff --git a/en/1-1000/383-ransom-note.md b/en/1-1000/383-ransom-note.md
@@ -30,7 +30,7 @@ Difficulty: **Easy**
 - `1 <= ransomNote.length, magazine.length <= 100000`
 - `ransomNote` and `magazine` consist of lowercase English letters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. This question is equivalent to asking whether `magazine` can contain all the characters in `ransomNote`.
diff --git a/en/1-1000/454-4sum-ii.md b/en/1-1000/454-4sum-ii.md
@@ -37,7 +37,7 @@ The two tuples are:
 - `1 <= n <= 200`
 - `-2**28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2**28`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Because the final requirement is to take one number from each group of numbers, the four groups of numbers can be split into **two groups of two**.
diff --git a/en/1-1000/459-repeated-substring-pattern.md b/en/1-1000/459-repeated-substring-pattern.md
@@ -20,7 +20,7 @@ Given a string `s`, check if it can be constructed by taking a substring of it a
 - `1 <= s.length <= 10000`
 - `s` consists of lowercase English letters.
 
-## Intuition behind the Solution
+## Intuition
 The key to solving this problem is to see clearly that if `s` can be obtained by repeating the substring, then the starting letter of the substring must be `s[0]`.
 Once you understand this, the scope of substring investigation is greatly narrowed.
 
diff --git a/en/1-1000/541-reverse-string-ii.md b/en/1-1000/541-reverse-string-ii.md
@@ -26,7 +26,7 @@ Difficulty: **Easy**
 - `s` consists of only lowercase English letters.
 - `1 <= k <= 10000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. The question does not require `reverse in place`, so using a new string `result` as the return value is easier to operate.
diff --git a/en/1-1000/59-spiral-matrix-ii.md b/en/1-1000/59-spiral-matrix-ii.md
@@ -20,7 +20,7 @@ Output: [[1]]
 ### Constraints
 - `1 <= n <= 20`
 
-## Intuition behind the Solution
+## Intuition
 * The difficulty of this question lies in the control of the two-dimensional array index.
 
 * You only need to use a `get_increment(i, j)` function to specifically control the index of the next two-dimensional array.
diff --git a/en/1-1000/707-design-linked-list.md b/en/1-1000/707-design-linked-list.md
@@ -49,7 +49,7 @@ myLinkedList.get(1);              // return 3
 - Please do not use the built-in LinkedList library.
 - At most `2000` calls will be made to `get`, `addAtHead`, `addAtTail`, `addAtIndex` and `deleteAtIndex`.
 
-## Intuition behind the Solution
+## Intuition
 Before solving this problem, it is recommended to solve the simple problem [19. Remove Nth Node From End of List](19-remove-nth-node-from-end-of-list.md) first.
 
 This question can comprehensively test the candidate's mastery of linked lists. The following points need to be paid attention to:
diff --git a/en/1-1000/977-squares-of-a-sorted-array.md b/en/1-1000/977-squares-of-a-sorted-array.md
@@ -25,7 +25,7 @@ Output: [4,9,9,49,121]
 
 **Follow up**: Squaring each element and sorting the new array is very trivial, could you find an `O(n)` solution using a different approach?
 
-## Intuition behind the Solution
+## Intuition
 ### Solution 1: using `sort()`
 * Square each number in the array.
 * Sort the new array.
diff --git a/zh/1-1000/160-intersection-of-two-linked-lists.md b/zh/1-1000/160-intersection-of-two-linked-lists.md
@@ -39,7 +39,7 @@ Difficulty: **Easy**
 
 **Follow up**: Could you write a solution that runs in `O(m + n)` time and use only `O(1)` memory?
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. First calculate the number of nodes in the two linked lists A and B. The number of nodes in linked list A is `node_count_a`, and the number of nodes in linked list B is `node_count_b`.
diff --git a/zh/1-1000/18-4sum.md b/zh/1-1000/18-4sum.md
@@ -29,7 +29,7 @@ Difficulty: **Medium**
 - `-10**9 <= nums[i] <= 10**9`
 - `-10**9 <= target <= 10**9`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. The idea of this question is the same as [15. 3Sum](15-3sum.md), please click the link to view.
diff --git a/zh/1-1000/19-remove-nth-node-from-end-of-list.md b/zh/1-1000/19-remove-nth-node-from-end-of-list.md
@@ -35,7 +35,7 @@ Given the `head` of a linked list, remove the `n-th` node from the end of the li
   Maintain two pointers and update one with a delay of n steps.
 </details>
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Deleting the `N-th` to last node in a linked list is equivalent to deleting the `node_count - N`-th node in the linked list.
diff --git a/zh/1-1000/202-happy-number.md b/zh/1-1000/202-happy-number.md
@@ -38,7 +38,7 @@ Difficulty: **Easy**
 ### [Constraints]
 - `1 <= n <= 2**31 - 1`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. It is more convenient to call `isHappy(n)` recursively. You only need to generate a new `n` as a parameter each time.
diff --git a/zh/1-1000/203-remove-linked-list-elements.md b/zh/1-1000/203-remove-linked-list-elements.md
@@ -29,7 +29,7 @@ Given the `head` of a linked list and an integer `val`, remove all the nodes of
 - `1 <= Node.val <= 50`
 - `0 <= val <= 50`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Assume that the node to be deleted in the linked list is `d`, and the previous node of `d` is `p`, so `p.next` is `d`.
diff --git a/zh/1-1000/206-reverse-linked-list.md b/zh/1-1000/206-reverse-linked-list.md
@@ -30,7 +30,7 @@ Given the `head` of a singly linked list, reverse the list, and return _the reve
 - The number of nodes in the list is the range `[0, 5000]`.
 - `-5000 <= Node.val <= 5000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. To solve this problem, we only need to define **two** variables: `current` and `previous`.
diff --git a/zh/1-1000/209-minimum-size-subarray-sum.md b/zh/1-1000/209-minimum-size-subarray-sum.md
@@ -33,7 +33,7 @@ Difficulty: **Medium**
 - `1 <= nums.length <= 100000`
 - `1 <= nums[i] <= 10000`
 
-## Intuition behind the Solution
+## Intuition
 For **subarray** problems, you can consider using **Sliding Window Technique**, which is similar to the **Fast and Slow Pointers Technique**.
 
 ## Steps
diff --git a/zh/1-1000/232-implement-queue-using-stacks.md b/zh/1-1000/232-implement-queue-using-stacks.md
@@ -48,7 +48,7 @@ myQueue.empty(); // return false
 
 **Follow-up**: Can you implement the queue such that each operation is amortized `O(1)` time complexity? In other words, performing `n` operations will take overall `O(n)` time even if one of those operations may take longer.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 
diff --git a/zh/1-1000/24-swap-nodes-in-pairs.md b/zh/1-1000/24-swap-nodes-in-pairs.md
@@ -33,7 +33,7 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 - The number of nodes in the list is in the range `[0, 100]`.
 - `0 <= Node.val <= 100`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Before solving this problem, it is recommended to solve the simple problem [206. Reverse Linked List](206-reverse-linked-list.md) first.
diff --git a/zh/1-1000/242-valid-anagram.md b/zh/1-1000/242-valid-anagram.md
@@ -25,7 +25,7 @@ Difficulty: **Easy**
 - `1 <= s.length, t.length <= 5 * 10000`
 - `s` and `t` consist of lowercase English letters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. If the lengths of the two strings are different, return `false` directly.
diff --git a/zh/1-1000/27-remove-element.md b/zh/1-1000/27-remove-element.md
@@ -46,7 +46,7 @@ It does not matter what you leave beyond the returned k (hence they are undersco
   Yet another direction of thought is to consider the elements to be removed as non-existent. In a single pass, if we keep copying the visible elements in-place, that should also solve this problem for us.
 </details>
 
-## Intuition behind the Solution
+## Intuition
 The goal is to remove the elements in the array that are equal to `val`, and the order of the remaining elements is not important.
 
 ### Solution 1 (easier to think of)
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
@@ -32,7 +32,7 @@ The first occurrence is at index 0, so we return 0.
 - `1 <= haystack.length, needle.length <= 10000`
 - `haystack` and `needle` consist of only lowercase English characters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 Traverse the string once, and if the `needle.length` characters after the current position are equal to `needle`, return the current `index`.
diff --git a/zh/1-1000/303-range-sum-query-immutable.md b/zh/1-1000/303-range-sum-query-immutable.md
@@ -37,7 +37,7 @@ numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
 - `0 <= left <= right < nums.length`
 - At most `10000` calls will be made to `sumRange`.
 
-## Intuition behind the Solution
+## Intuition
 ### Solution 2
 Directly returning the sum of the array elements can pass the tests, but if the test case is more stringent, it will fail.
 So we still need to learn a more efficient solution.
diff --git a/zh/1-1000/344-reverse-string.md b/zh/1-1000/344-reverse-string.md
@@ -31,7 +31,7 @@ Difficulty: **Easy**
   The entire logic for reversing a string is based on using the opposite directional two-pointer approach!
 </details>
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. This problem can be solved in one line of code using the built-in `sort()` method of the programming language. If this question is asked in an interview, the questioner should be testing how to do it without the built-in method.
diff --git a/zh/1-1000/349-intersection-of-two-arrays.md b/zh/1-1000/349-intersection-of-two-arrays.md
@@ -24,7 +24,7 @@ Difficulty: **Easy**
 - `1 <= nums1.length, nums2.length <= 1000`
 - `0 <= nums1[i], nums2[i] <= 1000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Convert one of the arrays to a `set`. The elements are unique in a `set`.
diff --git a/zh/1-1000/383-ransom-note.md b/zh/1-1000/383-ransom-note.md
@@ -30,7 +30,7 @@ Difficulty: **Easy**
 - `1 <= ransomNote.length, magazine.length <= 100000`
 - `ransomNote` and `magazine` consist of lowercase English letters.
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. This question is equivalent to asking whether `magazine` can contain all the characters in `ransomNote`.
diff --git a/zh/1-1000/454-4sum-ii.md b/zh/1-1000/454-4sum-ii.md
@@ -37,7 +37,7 @@ The two tuples are:
 - `1 <= n <= 200`
 - `-2**28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2**28`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. Because the final requirement is to take one number from each group of numbers, the four groups of numbers can be split into **two groups of two**.
diff --git a/zh/1-1000/541-reverse-string-ii.md b/zh/1-1000/541-reverse-string-ii.md
@@ -26,7 +26,7 @@ Difficulty: **Easy**
 - `s` consists of only lowercase English letters.
 - `1 <= k <= 10000`
 
-## Intuition behind the Solution
+## Intuition
 [中文题解](#中文题解)
 
 1. The question does not require `reverse in place`, so using a new string `result` as the return value is easier to operate.
diff --git a/zh/1-1000/59-spiral-matrix-ii.md b/zh/1-1000/59-spiral-matrix-ii.md
@@ -20,7 +20,7 @@ Output: [[1]]
 ### Constraints
 - `1 <= n <= 20`
 
-## Intuition behind the Solution
+## Intuition
 * The difficulty of this question lies in the control of the two-dimensional array index.
 
 * You only need to use a `get_increment(i, j)` function to specifically control the index of the next two-dimensional array.
diff --git a/zh/1-1000/707-design-linked-list.md b/zh/1-1000/707-design-linked-list.md
@@ -49,7 +49,7 @@ myLinkedList.get(1);              // return 3
 - Please do not use the built-in LinkedList library.
 - At most `2000` calls will be made to `get`, `addAtHead`, `addAtTail`, `addAtIndex` and `deleteAtIndex`.
 
-## Intuition behind the Solution
+## Intuition
 Before solving this problem, it is recommended to solve the simple problem [19. Remove Nth Node From End of List](19-remove-nth-node-from-end-of-list.md) first.
 
 This question can comprehensively test the candidate's mastery of linked lists. The following points need to be paid attention to:
diff --git a/zh/1-1000/977-squares-of-a-sorted-array.md b/zh/1-1000/977-squares-of-a-sorted-array.md
@@ -25,7 +25,7 @@ Output: [4,9,9,49,121]
 
 **Follow up**: Squaring each element and sorting the new array is very trivial, could you find an `O(n)` solution using a different approach?
 
-## Intuition behind the Solution
+## Intuition
 ### Solution 1: using `sort()`
 * Square each number in the array.
 * Sort the new array.
