feat: solve No.237,881,2000,2441,2487

Author: BaffinLee

1901-2000/2000. Reverse Prefix of Word.md

@@ -0,0 +1,87 @@
+# 2000. Reverse Prefix of Word
+
+- Difficulty: Easy.
+- Related Topics: Two Pointers, String.
+- Similar Questions: .
+
+## Problem
+
+Given a **0-indexed** string `word` and a character `ch`, **reverse** the segment of `word` that starts at index `0` and ends at the index of the **first occurrence** of `ch` (**inclusive**). If the character `ch` does not exist in `word`, do nothing.
+
+
+	
+- For example, if `word = "abcdefd"` and `ch = "d"`, then you should **reverse** the segment that starts at `0` and ends at `3` (**inclusive**). The resulting string will be `"dcbaefd"`.
+
+
+Return **the resulting string**.
+
+ 
+Example 1:
+
+```
+Input: word = "abcdefd", ch = "d"
+Output: "dcbaefd"
+Explanation: The first occurrence of "d" is at index 3. 
+Reverse the part of word from 0 to 3 (inclusive), the resulting string is "dcbaefd".
+```
+
+Example 2:
+
+```
+Input: word = "xyxzxe", ch = "z"
+Output: "zxyxxe"
+Explanation: The first and only occurrence of "z" is at index 3.
+Reverse the part of word from 0 to 3 (inclusive), the resulting string is "zxyxxe".
+```
+
+Example 3:
+
+```
+Input: word = "abcd", ch = "z"
+Output: "abcd"
+Explanation: "z" does not exist in word.
+You should not do any reverse operation, the resulting string is "abcd".
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= word.length <= 250`
+	
+- `word` consists of lowercase English letters.
+	
+- `ch` is a lowercase English letter.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} word
+ * @param {character} ch
+ * @return {string}
+ */
+var reversePrefix = function(word, ch) {
+    var index = word.indexOf(ch);
+    if (index === -1) return word;
+    var arr = word.split('');
+    for (var i = 0; i < index / 2; i++) {
+        var tmp = arr[i];
+        arr[i] = arr[index - i];
+        arr[index - i] = tmp;
+    }
+    return arr.join('');
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

201-300/237. Delete Node in a Linked List.md

@@ -0,0 +1,106 @@
+# 237. Delete Node in a Linked List
+
+- Difficulty: Medium.
+- Related Topics: Linked List.
+- Similar Questions: Remove Linked List Elements, Remove Nodes From Linked List.
+
+## Problem
+
+There is a singly-linked list `head` and we want to delete a node `node` in it.
+
+You are given the node to be deleted `node`. You will **not be given access** to the first node of `head`.
+
+All the values of the linked list are **unique**, and it is guaranteed that the given node `node` is not the last node in the linked list.
+
+Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:
+
+
+	
+- The value of the given node should not exist in the linked list.
+	
+- The number of nodes in the linked list should decrease by one.
+	
+- All the values before `node` should be in the same order.
+	
+- All the values after `node` should be in the same order.
+
+
+**Custom testing:**
+
+
+	
+- For the input, you should provide the entire linked list `head` and the node to be given `node`. `node` should not be the last node of the list and should be an actual node in the list.
+	
+- We will build the linked list and pass the node to your function.
+	
+- The output will be the entire list after calling your function.
+
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/09/01/node1.jpg)
+
+```
+Input: head = [4,5,1,9], node = 5
+Output: [4,1,9]
+Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/09/01/node2.jpg)
+
+```
+Input: head = [4,5,1,9], node = 1
+Output: [4,5,9]
+Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+```
+
+ 
+**Constraints:**
+
+
+	
+- The number of the nodes in the given list is in the range `[2, 1000]`.
+	
+- `-1000 <= Node.val <= 1000`
+	
+- The value of each node in the list is **unique**.
+	
+- The `node` to be deleted is **in the list** and is **not a tail** node.
+
+
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} node
+ * @return {void} Do not return anything, modify node in-place instead.
+ */
+var deleteNode = function(node) {
+    while (node.next.next) {
+        node.val = node.next.val;
+        node = node.next;
+    }
+    node.val = node.next.val;
+    node.next = null;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

2401-2500/2441. Largest Positive Integer That Exists With Its Negative.md

@@ -0,0 +1,78 @@
+# 2441. Largest Positive Integer That Exists With Its Negative
+
+- Difficulty: Easy.
+- Related Topics: Array, Hash Table, Two Pointers, Sorting.
+- Similar Questions: Two Sum.
+
+## Problem
+
+Given an integer array `nums` that **does not contain** any zeros, find **the largest positive** integer `k` such that `-k` also exists in the array.
+
+Return **the positive integer **`k`. If there is no such integer, return `-1`.
+
+ 
+Example 1:
+
+```
+Input: nums = [-1,2,-3,3]
+Output: 3
+Explanation: 3 is the only valid k we can find in the array.
+```
+
+Example 2:
+
+```
+Input: nums = [-1,10,6,7,-7,1]
+Output: 7
+Explanation: Both 1 and 7 have their corresponding negative values in the array. 7 has a larger value.
+```
+
+Example 3:
+
+```
+Input: nums = [-10,8,6,7,-2,-3]
+Output: -1
+Explanation: There is no a single valid k, we return -1.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= nums.length <= 1000`
+	
+- `-1000 <= nums[i] <= 1000`
+	
+- `nums[i] != 0`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMaxK = function(nums) {
+    var map = {};
+    var max = -1;
+    for (var i = 0; i < nums.length; i++) {
+        if (map[-nums[i]]) {
+            max = Math.max(max, Math.abs(nums[i]));
+        }
+        map[nums[i]] = true;
+    }
+    return max;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

2401-2500/2487. Remove Nodes From Linked List.md

@@ -0,0 +1,85 @@
+# 2487. Remove Nodes From Linked List
+
+- Difficulty: Medium.
+- Related Topics: Linked List, Stack, Recursion, Monotonic Stack.
+- Similar Questions: Reverse Linked List, Delete Node in a Linked List, Next Greater Element I.
+
+## Problem
+
+You are given the `head` of a linked list.
+
+Remove every node which has a node with a greater value anywhere to the right side of it.
+
+Return **the **`head`** of the modified linked list.**
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2022/10/02/drawio.png)
+
+```
+Input: head = [5,2,13,3,8]
+Output: [13,8]
+Explanation: The nodes that should be removed are 5, 2 and 3.
+- Node 13 is to the right of node 5.
+- Node 13 is to the right of node 2.
+- Node 8 is to the right of node 3.
+```
+
+Example 2:
+
+```
+Input: head = [1,1,1,1]
+Output: [1,1,1,1]
+Explanation: Every node has value 1, so no nodes are removed.
+```
+
+ 
+**Constraints:**
+
+
+	
+- The number of the nodes in the given list is in the range `[1, 105]`.
+	
+- `1 <= Node.val <= 105`
+
+
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var removeNodes = function(head) {
+    var newHead = new ListNode(Number.MAX_SAFE_INTEGER, head);
+    var stack = [newHead];
+    var current = head;
+    while (current) {
+        while (current.val > stack[stack.length - 1].val) {
+            stack.pop();
+        }
+        stack[stack.length - 1].next = current;
+        stack.push(current);
+        current = current.next;
+    }
+    return newHead.next;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).