Added tasks 148-160

Author: ThanhNIT

src/main/ts/g0101_0200/s0148_sort_list/readme.md

@@ -0,0 +1,34 @@
+148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5] 
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?

src/main/ts/g0101_0200/s0148_sort_list/solution.ts

@@ -0,0 +1,36 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Sorting #Two_Pointers #Linked_List
+// #Divide_and_Conquer #Merge_Sort #Level_2_Day_4_Linked_List #Big_O_Time_O(log(N))_Space_O(log(N))
+// #2023_10_08_Time_141_ms_(97.14%)_Space_71.9_MB_(47.35%)
+
+import { ListNode } from '../../com_github_leetcode/listnode'
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function sortList(head: ListNode | null): ListNode | null {
+    if (!head) return null
+    let array = []
+    while (head) {
+        array.push([head, head.val])
+        head = head.next
+    }
+    array.sort((a, b) => {
+        return a[1] - b[1]
+    })
+    for (let iter = 0; iter < array.length; iter++) {
+        if (iter + 1 >= array.length) array[iter][0].next = null
+        else array[iter][0].next = array[iter + 1][0]
+    }
+    return array[0][0]
+}
+
+export { sortList }

src/main/ts/g0101_0200/s0152_maximum_product_subarray/readme.md

@@ -0,0 +1,31 @@
+152\. Maximum Product Subarray
+
+Medium
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return _the product_.
+
+It is **guaranteed** that the answer will fit in a **32-bit** integer.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-2,4]
+
+**Output:** 6
+
+**Explanation:** [2,3] has the largest product 6. 
+
+**Example 2:**
+
+**Input:** nums = [-2,0,-1]
+
+**Output:** 0
+
+**Explanation:** The result cannot be 2, because [-2,-1] is not a subarray. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `-10 <= nums[i] <= 10`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.

src/main/ts/g0101_0200/s0152_maximum_product_subarray/solution.ts

@@ -0,0 +1,18 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
+// #Dynamic_Programming_I_Day_6 #Level_2_Day_13_Dynamic_Programming #Udemy_Dynamic_Programming
+// #Big_O_Time_O(N)_Space_O(1) #2023_10_08_Time_53_ms_(87.50%)_Space_44.6_MB_(63.86%)
+
+function maxProduct(nums: number[]): number {
+    let cMin = 1
+    let cMax = 1
+    let max = nums[0]
+    for (const num of nums) {
+        let tempMin = cMin
+        cMin = Math.min(cMax * num, cMin * num, num)
+        cMax = Math.max(cMax * num, tempMin * num, num)
+        max = Math.max(max, cMax)
+    }
+    return max
+}
+
+export { maxProduct }

src/main/ts/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/readme.md

@@ -0,0 +1,46 @@
+153\. Find Minimum in Rotated Sorted Array
+
+Medium
+
+Suppose an array of length `n` sorted in ascending order is **rotated** between `1` and `n` times. For example, the array `nums = [0,1,2,4,5,6,7]` might become:
+
+*   `[4,5,6,7,0,1,2]` if it was rotated `4` times.
+*   `[0,1,2,4,5,6,7]` if it was rotated `7` times.
+
+Notice that **rotating** an array `[a[0], a[1], a[2], ..., a[n-1]]` 1 time results in the array `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`.
+
+Given the sorted rotated array `nums` of **unique** elements, return _the minimum element of this array_.
+
+You must write an algorithm that runs in `O(log n) time.`
+
+**Example 1:**
+
+**Input:** nums = [3,4,5,1,2]
+
+**Output:** 1
+
+**Explanation:** The original array was [1,2,3,4,5] rotated 3 times. 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2]
+
+**Output:** 0
+
+**Explanation:** The original array was [0,1,2,4,5,6,7] and it was rotated 4 times. 
+
+**Example 3:**
+
+**Input:** nums = [11,13,15,17]
+
+**Output:** 11
+
+**Explanation:** The original array was [11,13,15,17] and it was rotated 4 times. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `1 <= n <= 5000`
+*   `-5000 <= nums[i] <= 5000`
+*   All the integers of `nums` are **unique**.
+*   `nums` is sorted and rotated between `1` and `n` times.

src/main/ts/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/solution.ts

@@ -0,0 +1,9 @@
+// #Medium #Top_100_Liked_Questions #Array #Binary_Search #Algorithm_II_Day_2_Binary_Search
+// #Binary_Search_I_Day_12 #Udemy_Binary_Search #Big_O_Time_O(log_N)_Space_O(log_N)
+// #2023_10_08_Time_42_ms_(98.87%)_Space_42.9_MB_(84.75%)
+
+function findMin(nums: number[]): number {
+    return Math.min(...nums)
+}
+
+export { findMin }

src/main/ts/g0101_0200/s0155_min_stack/readme.md

@@ -0,0 +1,39 @@
+155\. Min Stack
+
+Easy
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+Implement the `MinStack` class:
+
+*   `MinStack()` initializes the stack object.
+*   `void push(int val)` pushes the element `val` onto the stack.
+*   `void pop()` removes the element on the top of the stack.
+*   `int top()` gets the top element of the stack.
+*   `int getMin()` retrieves the minimum element in the stack.
+
+**Example 1:**
+
+**Input**
+
+    ["MinStack","push","push","push","getMin","pop","top","getMin"]
+    [[],[-2],[0],[-3],[],[],[],[]]
+
+**Output:** [null,null,null,null,-3,null,0,-2]
+
+**Explanation:**
+
+    MinStack minStack = new MinStack();
+    minStack.push(-2);
+    minStack.push(0);
+    minStack.push(-3);
+    minStack.getMin(); // return -3
+    minStack.pop();
+    minStack.top(); // return 0
+    minStack.getMin(); // return -2 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   Methods `pop`, `top` and `getMin` operations will always be called on **non-empty** stacks.
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `push`, `pop`, `top`, and `getMin`.

src/main/ts/g0101_0200/s0155_min_stack/solution.ts

@@ -0,0 +1,46 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Stack #Design
+// #Data_Structure_II_Day_14_Stack_Queue #Programming_Skills_II_Day_18 #Level_2_Day_16_Design
+// #Udemy_Design #Big_O_Time_O(1)_Space_O(N) #2023_10_08_Time_84_ms_(92.72%)_Space_51.8_MB_(30.46%)
+
+class MinStack {
+    stack: number[]
+    minStack: number[]
+
+    constructor() {
+        this.stack = []
+        this.minStack = []
+    }
+
+    push(val: number): void {
+        this.stack.push(val)
+        if (this.minStack.length === 0 || this.minStack[this.minStack.length - 1] >= val) {
+            this.minStack.push(val)
+        }
+    }
+
+    pop(): void {
+        const popValue = this.stack.pop()
+        if (popValue === this.minStack[this.minStack.length - 1]) {
+            this.minStack.pop()
+        }
+    }
+
+    top(): number {
+        return this.stack[this.stack.length - 1]
+    }
+
+    getMin(): number {
+        return this.minStack[this.minStack.length - 1]
+    }
+}
+
+/*
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(val)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+
+export { MinStack }

src/main/ts/g0101_0200/s0160_intersection_of_two_linked_lists/readme.md

@@ -0,0 +1,68 @@
+160\. Intersection of Two Linked Lists
+
+Easy
+
+Given the heads of two singly linked-lists `headA` and `headB`, return _the node at which the two lists intersect_. If the two linked lists have no intersection at all, return `null`.
+
+For example, the following two linked lists begin to intersect at node `c1`:
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_statement.png)
+
+The test cases are generated such that there are no cycles anywhere in the entire linked structure.
+
+**Note** that the linked lists must **retain their original structure** after the function returns.
+
+**Custom Judge:**
+
+The inputs to the **judge** are given as follows (your program is **not** given these inputs):
+
+*   `intersectVal` - The value of the node where the intersection occurs. This is `0` if there is no intersected node.
+*   `listA` - The first linked list.
+*   `listB` - The second linked list.
+*   `skipA` - The number of nodes to skip ahead in `listA` (starting from the head) to get to the intersected node.
+*   `skipB` - The number of nodes to skip ahead in `listB` (starting from the head) to get to the intersected node.
+
+The judge will then create the linked structure based on these inputs and pass the two heads, `headA` and `headB` to your program. If you correctly return the intersected node, then your solution will be **accepted**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png)
+
+**Input:** intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+
+**Output:** Intersected at '8'
+
+**Explanation:** The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png)
+
+**Input:** intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+
+**Output:** Intersected at '2'
+
+**Explanation:** The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_3.png)
+
+**Input:** intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+
+**Output:** No intersection
+
+**Explanation:** From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values. Explanation: The two lists do not intersect, so return null. 
+
+**Constraints:**
+
+*   The number of nodes of `listA` is in the `m`.
+*   The number of nodes of `listB` is in the `n`.
+*   <code>0 <= m, n <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   `0 <= skipA <= m`
+*   `0 <= skipB <= n`
+*   `intersectVal` is `0` if `listA` and `listB` do not intersect.
+*   `intersectVal == listA[skipA] == listB[skipB]` if `listA` and `listB` intersect.
+
+**Follow up:** Could you write a solution that runs in `O(n)` time and use only `O(1)` memory?