Update readme for tasks 23-49

Author: ThanhNIT

src/main/java/g0001_0100/s0023_merge_k_sorted_lists/readme.md

@@ -12,7 +12,7 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 
 **Output:** [1,1,2,3,4,4,5,6]
 
-**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6 
+**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted linked list: 1->1->2->3->4->4->5->6 
 
 **Example 2:**
 
@@ -29,105 +29,8 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 **Constraints:**
 
 *   `k == lists.length`
-*   `0 <= k <= 10^4`
+*   <code>0 <= k <= 10<sup>4</sup></code>
 *   `0 <= lists[i].length <= 500`
-*   `-10^4 <= lists[i][j] <= 10^4`
+*   <code>-10<sup>4</sup> <= lists[i][j] <= 10<sup>4</sup></code>
 *   `lists[i]` is sorted in **ascending order**.
-*   The sum of `lists[i].length` won't exceed `10^4`.
-
-To solve the "Merge k Sorted Lists" problem in Java with a `Solution` class, we can use a priority queue (min-heap) to efficiently merge the lists. Here are the steps:
-
-1. Define a `Solution` class.
-2. Define a method named `mergeKLists` that takes an array of linked lists `lists` as input and returns a single sorted linked list.
-3. Create a priority queue of ListNode objects. We will use this priority queue to store the heads of each linked list.
-4. Iterate through each linked list in the input array `lists` and add the head node of each list to the priority queue.
-5. Create a dummy ListNode object to serve as the head of the merged sorted linked list.
-6. Initialize a ListNode object named `current` to point to the dummy node.
-7. While the priority queue is not empty:
-   - Remove the ListNode with the smallest value from the priority queue.
-   - Add this node to the merged linked list by setting the `next` pointer of the `current` node to this node.
-   - Move the `current` pointer to the next node in the merged linked list.
-   - If the removed node has a `next` pointer, add the next node from the same list to the priority queue.
-8. Return the `next` pointer of the dummy node, which points to the head of the merged sorted linked list.
-
-Here's the implementation:
-
-```java
-import java.util.PriorityQueue;
-
-public class Solution {
-    public ListNode mergeKLists(ListNode[] lists) {
-        PriorityQueue<ListNode> minHeap = new PriorityQueue<>((a, b) -> a.val - b.val);
-        
-        // Add the heads of all lists to the priority queue
-        for (ListNode node : lists) {
-            if (node != null) {
-                minHeap.offer(node);
-            }
-        }
-        
-        // Create a dummy node to serve as the head of the merged list
-        ListNode dummy = new ListNode(0);
-        ListNode current = dummy;
-        
-        // Merge the lists
-        while (!minHeap.isEmpty()) {
-            ListNode minNode = minHeap.poll();
-            current.next = minNode;
-            current = current.next;
-            
-            if (minNode.next != null) {
-                minHeap.offer(minNode.next);
-            }
-        }
-        
-        return dummy.next;
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-
-        // Test case
-        ListNode[] lists = new ListNode[] {
-            ListNode.createList(new int[] {1, 4, 5}),
-            ListNode.createList(new int[] {1, 3, 4}),
-            ListNode.createList(new int[] {2, 6})
-        };
-        System.out.println("Merged list:");
-        ListNode.printList(solution.mergeKLists(lists));
-    }
-}
-
-class ListNode {
-    int val;
-    ListNode next;
-
-    ListNode(int val) {
-        this.val = val;
-    }
-
-    static ListNode createList(int[] arr) {
-        if (arr == null || arr.length == 0) {
-            return null;
-        }
-
-        ListNode dummy = new ListNode(0);
-        ListNode current = dummy;
-        for (int num : arr) {
-            current.next = new ListNode(num);
-            current = current.next;
-        }
-        return dummy.next;
-    }
-
-    static void printList(ListNode head) {
-        while (head != null) {
-            System.out.print(head.val + " ");
-            head = head.next;
-        }
-        System.out.println();
-    }
-}
-```
-
-This implementation provides a solution to the "Merge k Sorted Lists" problem in Java using a priority queue.
+*   The sum of `lists[i].length` will not exceed <code>10<sup>4</sup></code>.

src/main/java/g0001_0100/s0024_swap_nodes_in_pairs/readme.md

@@ -6,74 +6,33 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 
 **Example 1:**
 
-![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
-
 **Input:** head = [1,2,3,4]
 
-**Output:** [2,1,4,3] 
+**Output:** [2,1,4,3]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
 
 **Example 2:**
 
 **Input:** head = []
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** head = [1]
 
-**Output:** [1] 
+**Output:** [1]
+
+**Example 4:**
+
+**Input:** head = [1,2,3]
+
+**Output:** [2,1,3]
 
 **Constraints:**
 
 *   The number of nodes in the list is in the range `[0, 100]`.
-*   `0 <= Node.val <= 100`
-
-To solve the "Swap Nodes in Pairs" problem in Java with a `Solution` class, we can traverse the linked list while swapping pairs of nodes. Here are the steps:
-
-1. Define a `Solution` class.
-2. Define a method named `swapPairs` that takes the head of a linked list as input and returns the head of the modified list.
-3. Create a dummy ListNode object and set its `next` pointer to the head of the input list. This dummy node will serve as the new head of the modified list.
-4. Initialize three pointers: `prev`, `first`, and `second`.
-5. Iterate through the list while `first` and `second` are not null:
-   - Assign `first` to the `next` pointer of `prev`.
-   - Assign `second` to the `next` pointer of `first`.
-   - Assign the `next` pointer of `prev` to the `next` pointer of `second`.
-   - Assign the `next` pointer of `second` to `first`.
-   - Move `prev` to `first`.
-   - Move `first` to `first.next` (which is the next pair of nodes).
-6. Return the `next` pointer of the dummy node, which points to the head of the modified list.
-
-Here's the implementation:
-
-```java
-public class Solution {
-    public ListNode swapPairs(ListNode head) {
-        // Create a dummy node and point its next to the head
-        ListNode dummy = new ListNode(0);
-        dummy.next = head;
-        
-        // Initialize pointers
-        ListNode prev = dummy;
-        ListNode first, second;
-        
-        // Swap pairs of nodes
-        while (prev.next != null && prev.next.next != null) {
-            first = prev.next;
-            second = first.next;
-            
-            // Swap nodes
-            prev.next = second;
-            first.next = second.next;
-            second.next = first;
-            
-            // Move prev to the next pair of nodes
-            prev = first;
-        }
-        
-        return dummy.next;
-    }
-}
-```
-
-This implementation provides a solution to the "Swap Nodes in Pairs" problem in Java without modifying the values in the list's nodes.
+*   `0 <= Node.val <= 100`

src/main/java/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md

@@ -2,9 +2,9 @@
 
 Hard
 
-Given a linked list, reverse the nodes of a linked list _k_ at a time and return its modified list.
+Given the `head` of a linked list, reverse the nodes of the list `k` at a time, and return _the modified list_.
 
-_k_ is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of _k_ then left-out nodes, in the end, should remain as it is.
+`k` is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of `k` then left-out nodes, in the end, should remain as it is.
 
 You may not alter the values in the list's nodes, only nodes themselves may be changed.
 
@@ -24,89 +24,10 @@ You may not alter the values in the list's nodes, only nodes themselves may be c
 
 **Output:** [3,2,1,4,5] 
 
-**Example 3:**
-
-**Input:** head = [1,2,3,4,5], k = 1
-
-**Output:** [1,2,3,4,5] 
-
-**Example 4:**
-
-**Input:** head = [1], k = 1
-
-**Output:** [1] 
-
 **Constraints:**
 
-*   The number of nodes in the list is in the range `sz`.
-*   `1 <= sz <= 5000`
+*   The number of nodes in the list is `n`.
+*   `1 <= k <= n <= 5000`
 *   `0 <= Node.val <= 1000`
-*   `1 <= k <= sz`
-
-**Follow-up:** Can you solve the problem in O(1) extra memory space?
-
-To solve the "Reverse Nodes in k-Group" problem in Java with a `Solution` class, we can reverse the nodes in groups of k using a recursive approach. Here are the steps:
-
-1. Define a `Solution` class.
-2. Define a method named `reverseKGroup` that takes the head of a linked list and an integer k as input and returns the head of the modified list.
-3. Define a helper method named `reverse` that takes the head and tail of a sublist as input and reverses the sublist in place. This method returns the new head of the sublist.
-4. Create a dummy ListNode object and set its `next` pointer to the head of the input list. This dummy node will serve as the new head of the modified list.
-5. Initialize pointers `prev`, `curr`, `next`, and `tail`. Set `prev` and `tail` to the dummy node, and `curr` to the head of the input list.
-6. Iterate through the list:
-   - Move `curr` k steps forward. If it's not possible (i.e., there are less than k nodes left), break the loop.
-   - Set `next` to the `next` pointer of `curr`.
-   - Reverse the sublist from `curr` to `next` using the `reverse` method. Update `prev` and `tail` accordingly.
-   - Move `prev` and `tail` k steps forward to the last node of the reversed sublist.
-   - Move `curr` to `next`.
-7. Return the `next` pointer of the dummy node, which points to the head of the modified list.
-
-Here's the implementation:
-
-```java
-public class Solution {
-    public ListNode reverseKGroup(ListNode head, int k) {
-        // Create a dummy node and point its next to the head
-        ListNode dummy = new ListNode(0);
-        dummy.next = head;
-        
-        // Initialize pointers
-        ListNode prev = dummy, curr = head, next, tail;
-        
-        // Iterate through the list and reverse in groups of k
-        while (true) {
-            // Move curr k steps forward
-            tail = prev;
-            for (int i = 0; i < k; i++) {
-                tail = tail.next;
-                if (tail == null) return dummy.next; // Less than k nodes left
-            }
-            
-            next = tail.next; // Save the next pointer of the sublist
-            tail.next = null; // Disconnect the sublist from the rest of the list
-            
-            // Reverse the sublist and update prev and tail pointers
-            prev.next = reverse(curr, tail);
-            tail.next = next; // Connect the reversed sublist back to the rest of the list
-            
-            // Move prev, tail, and curr to the next group
-            prev = curr;
-            curr = next;
-        }
-    }
-    
-    // Helper method to reverse a sublist from head to tail
-    private ListNode reverse(ListNode head, ListNode tail) {
-        ListNode prev = null, curr = head, next;
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-            if (prev == tail) break;
-        }
-        return prev; // Return the new head of the reversed sublist
-    }
-}
-```
 
-This implementation provides a solution to the "Reverse Nodes in k-Group" problem in Java without modifying the values in the list's nodes. It recursively reverses the nodes in groups of k.
+**Follow-up:** Can you solve the problem in `O(1)` extra memory space?

src/main/java/g0001_0100/s0026_remove_duplicates_from_sorted_array/readme.md

@@ -4,25 +4,15 @@ Easy
 
 Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**.
 
-Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+Consider the number of _unique elements_ in `nums` to be `k`. After removing duplicates, return the number of unique elements `k`.
 
-Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
-
-Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+The first `k` elements of `nums` should contain the unique numbers in **sorted order**. The remaining elements beyond index `k - 1` can be ignored.
 
 **Custom Judge:**
 
 The judge will test your solution with the following code:
 
-    int[] nums = [...]; // Input array
-    int[] expectedNums = [...]; // The expected answer with correct length
-
-    int k = removeDuplicates(nums); // Calls your implementation
-
-    assert k == expectedNums.length;
-    for (int i = 0; i < k; i++) {
-        assert nums[i] == expectedNums[i];
-    } 
+int[] nums = [...]; // Input array int[] expectedNums = [...]; // The expected answer with correct length int k = removeDuplicates(nums); // Calls your implementation assert k == expectedNums.length; for (int i = 0; i < k; i++) { assert nums[i] == expectedNums[i]; } 
 
 If all assertions pass, then your solution will be **accepted**.
 
@@ -44,6 +34,6 @@ If all assertions pass, then your solution will be **accepted**.
 
 **Constraints:**
 
-*   <code>0 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
 *   `-100 <= nums[i] <= 100`
 *   `nums` is sorted in **non-decreasing** order.

src/main/java/g0001_0100/s0027_remove_element/readme.md

@@ -2,30 +2,18 @@
 
 Easy
 
-Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm). The relative order of the elements may be changed.
+Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm). The order of the elements may be changed. Then return _the number of elements in_ `nums` _which are not equal to_ `val`.
 
-Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+Consider the number of elements in `nums` which are not equal to `val` be `k`, to get accepted, you need to do the following things:
 
-Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
-
-Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+*   Change the array `nums` such that the first `k` elements of `nums` contain the elements which are not equal to `val`. The remaining elements of `nums` are not important as well as the size of `nums`.
+*   Return `k`.
 
 **Custom Judge:**
 
 The judge will test your solution with the following code:
 
-    int[] nums = [...]; // Input array
-    int val = ...; // Value to remove
-    int[] expectedNums = [...]; // The expected answer with correct length.
-                                // It is sorted with no values equaling val.
-
-    int k = removeElement(nums, val); // Calls your implementation
-
-    assert k == expectedNums.length;
-    sort(nums, 0, k); // Sort the first k elements of nums
-    for (int i = 0; i < actualLength; i++) {
-        assert nums[i] == expectedNums[i];
-    } 
+int[] nums = [...]; // Input array int val = ...; // Value to remove int[] expectedNums = [...]; // The expected answer with correct length. // It is sorted with no values equaling val. int k = removeElement(nums, val); // Calls your implementation assert k == expectedNums.length; sort(nums, 0, k); // Sort the first k elements of nums for (int i = 0; i < actualLength; i++) { assert nums[i] == expectedNums[i]; } 
 
 If all assertions pass, then your solution will be **accepted**.