Added tasks 148-1143

Author: javadev

README.md

@@ -39,11 +39,9 @@ var longestConsecutive = function(nums) {
     if (nums.length === 0) {
         return 0
     }
-
-    nums.sort((a, b) => a - b) // Sort the array in ascending order
+    nums.sort((a, b) => a - b)
     let max = Number.MIN_SAFE_INTEGER
     let thsMax = 1
-
     for (let i = 0; i < nums.length - 1; i++) {
         if (nums[i + 1] === nums[i] + 1) {
             thsMax += 1
@@ -52,11 +50,9 @@ var longestConsecutive = function(nums) {
         if (nums[i + 1] === nums[i]) {
             continue
         }
-        // Start of a new sequence
         max = Math.max(max, thsMax)
-        thsMax = 1
+        thsMax = 1 // NOSONAR
     }
-
     return Math.max(max, thsMax)
 };
 

src/main/js/g0101_0200/s0128_longest_consecutive_sequence/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript/fork)
+
+## 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)?
+
+## 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 sortList = function(head) {
+    let arr = []
+    let current = head
+    while (current) {
+        arr.push(current)
+        current = current.next
+    }
+
+    arr = arr.sort((a, b) => {
+        if (a.val > b.val) {
+            return 1
+        } else {
+            return -1
+        }
+    })
+
+    const result = arr.reduce((acc, curr) => {
+        acc.next = curr
+        return acc.next
+    }, arr[0])
+
+    if (!result) {
+        return null
+    }
+    result.next = null
+    return arr[0]
+};
+
+export { sortList }
+```

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

@@ -0,0 +1,68 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript/fork)
+
+## 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_.
+
+The test cases are generated so 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.
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+    let overAllMaxProd = Number.MIN_SAFE_INTEGER
+    let n = nums.length
+    let start = 1
+    let end = 1
+
+    for (let i = 0; i < n; i++) {
+        // Reset `start` and `end` to 1 if they become 0
+        if (start === 0) {
+            start = 1
+        }
+        if (end === 0) {
+            end = 1
+        }
+
+        start *= nums[i]
+        end *= nums[n - i - 1]
+
+        overAllMaxProd = Math.max(overAllMaxProd, Math.max(start, end))
+    }
+
+    return overAllMaxProd
+};
+
+export { maxProduct }
+```

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

@@ -0,0 +1,85 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript/fork)
+
+## 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.
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    function findMinUtil(nums, l, r) {
+        if (l === r) {
+            return nums[l]
+        }
+        let mid = Math.floor((l + r) / 2)
+
+        if (mid === l && nums[mid] < nums[r]) {
+            return nums[l]
+        }
+        if (mid - 1 >= 0 && nums[mid - 1] > nums[mid]) {
+            return nums[mid]
+        }
+        if (nums[mid] < nums[l]) {
+            return findMinUtil(nums, l, mid - 1)
+        } else if (nums[mid] > nums[r]) {
+            return findMinUtil(nums, mid + 1, r)
+        }
+        return findMinUtil(nums, l, mid - 1)
+    }
+
+    let l = 0
+    let r = nums.length - 1
+    return findMinUtil(nums, l, r)
+};
+
+export { findMin }
+```

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

@@ -0,0 +1,101 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-JavaScript/LeetCode-in-JavaScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-JavaScript/LeetCode-in-JavaScript/fork)
+
+## 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`.
+
+## Solution
+
+```javascript
+var MinStack = function () {
+    this.stack = []
+    this.minStack = []
+};
+
+/**
+ * @param {number} val
+ * @return {void}
+ */
+MinStack.prototype.push = function (val) {
+    this.stack.push(val)
+
+
+    if (this.minStack.length == 0) {
+        this.minStack.push(val)
+    } else {
+        let min = Math.min(val, this.minStack[this.minStack.length - 1]);
+        this.minStack.push(min)
+    }
+
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function () {
+    this.stack.pop()
+    this.minStack.pop()
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function () {
+    return this.stack[this.stack.length - 1]
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function () {
+    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 }
+```