Added tasks 81, 82, 83, 85.

Author: ThanhNIT

README.md

@@ -69,6 +69,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0082 |[Remove Duplicates from Sorted List II](src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/Solution.kt)| Medium | Two_Pointers, Linked_List | 241 | 91.04
 | 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 1059 | 55.28
 
 #### Day 4 Two Pointers
@@ -312,6 +313,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0081 |[Search in Rotated Sorted Array II](src/main/kotlin/g0001_0100/s0081_search_in_rotated_sorted_array_ii/Solution.kt)| Medium | Array, Binary_Search | 352 | 42.31
 
 #### Day 13
 
@@ -1206,6 +1208,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0206 |[Reverse Linked List](src/main/kotlin/g0201_0300/s0206_reverse_linked_list/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Linked_List, Recursion | 309 | 15.90
+| 0083 |[Remove Duplicates from Sorted List](src/main/kotlin/g0001_0100/s0083_remove_duplicates_from_sorted_list/Solution.kt)| Easy | Linked_List | 274 | 77.82
 
 #### Day 9 Stack Queue
 
@@ -1316,6 +1319,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0160 |[Intersection of Two Linked Lists](src/main/kotlin/g0101_0200/s0160_intersection_of_two_linked_lists/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Two_Pointers, Linked_List | 262 | 83.50
+| 0082 |[Remove Duplicates from Sorted List II](src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/Solution.kt)| Medium | Two_Pointers, Linked_List | 241 | 91.04
 
 #### Day 12 Linked List
 
@@ -1525,7 +1529,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree, Udemy_Tree_Stack_Queue | 330 | 41.38
 | 0096 |[Unique Binary Search Trees](src/main/kotlin/g0001_0100/s0096_unique_binary_search_trees/Solution.kt)| Medium | Top_100_Liked_Questions, Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Dynamic_Programming_I_Day_11 | 237 | 26.76
 | 0094 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0094_binary_tree_inorder_traversal/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Data_Structure_I_Day_10_Tree, Udemy_Tree_Stack_Queue | 283 | 17.97
+| 0085 |[Maximal Rectangle](src/main/kotlin/g0001_0100/s0085_maximal_rectangle/Solution.kt)| Hard | Array, Dynamic_Programming, Matrix, Stack, Monotonic_Stack | 463 | 55.17
 | 0084 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0084_largest_rectangle_in_histogram/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Stack, Monotonic_Stack | 525 | 100.00
+| 0083 |[Remove Duplicates from Sorted List](src/main/kotlin/g0001_0100/s0083_remove_duplicates_from_sorted_list/Solution.kt)| Easy | Linked_List, Data_Structure_I_Day_8_Linked_List | 274 | 77.82
+| 0082 |[Remove Duplicates from Sorted List II](src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/Solution.kt)| Medium | Two_Pointers, Linked_List, Data_Structure_II_Day_11_Linked_List, Algorithm_II_Day_3_Two_Pointers | 241 | 91.04
+| 0081 |[Search in Rotated Sorted Array II](src/main/kotlin/g0001_0100/s0081_search_in_rotated_sorted_array_ii/Solution.kt)| Medium | Array, Binary_Search, Binary_Search_II_Day_12 | 352 | 42.31
 | 0080 |[Remove Duplicates from Sorted Array II](src/main/kotlin/g0001_0100/s0080_remove_duplicates_from_sorted_array_ii/Solution.kt)| Medium | Array, Two_Pointers, Udemy_Arrays | 357 | 44.78
 | 0079 |[Word Search](src/main/kotlin/g0001_0100/s0079_word_search/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Matrix, Backtracking, Algorithm_II_Day_11_Recursion_Backtracking | 463 | 68.49
 | 0078 |[Subsets](src/main/kotlin/g0001_0100/s0078_subsets/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Backtracking, Algorithm_II_Day_9_Recursion_Backtracking, Udemy_Backtracking/Recursion | 353 | 30.14
@@ -1535,7 +1543,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0074 |[Search a 2D Matrix](src/main/kotlin/g0001_0100/s0074_search_a_2d_matrix/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Binary_Search, Matrix, Data_Structure_I_Day_5_Array, Algorithm_II_Day_1_Binary_Search, Binary_Search_I_Day_8, Level_2_Day_8_Binary_Search, Udemy_2D_Arrays/Matrix | 290 | 40.17
 | 0073 |[Set Matrix Zeroes](src/main/kotlin/g0001_0100/s0073_set_matrix_zeroes/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Matrix, Udemy_2D_Arrays/Matrix | 255 | 100.00
 | 0072 |[Edit Distance](src/main/kotlin/g0001_0100/s0072_edit_distance/Solution.kt)| Hard | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_18_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 320 | 63.53
-| 0071 |[Simplify Path](src/main/kotlin/g0001_0100/s0071_simplify_path/Solution.kt)| |||
+| 0071 |[Simplify Path](src/main/kotlin/g0001_0100/s0071_simplify_path/Solution.kt)| Medium | String, Stack | 318 | 64.44
 | 0070 |[Climbing Stairs](src/main/kotlin/g0001_0100/s0070_climbing_stairs/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Memoization, Algorithm_I_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_2, Level_1_Day_10_Dynamic_Programming, Udemy_Dynamic_Programming | 127 | 97.06
 | 0069 |[Sqrt(x)](src/main/kotlin/g0001_0100/s0069_sqrtx/Solution.kt)| Easy | Top_Interview_Questions, Math, Binary_Search, Binary_Search_I_Day_4 | 153 | 95.75
 | 0068 |[Text Justification](src/main/kotlin/g0001_0100/s0068_text_justification/Solution.kt)| Hard | Array, String, Simulation | 269 | 50.00

src/main/kotlin/g0001_0100/s0081_search_in_rotated_sorted_array_ii/Solution.kt

@@ -0,0 +1,23 @@
+package g0001_0100.s0081_search_in_rotated_sorted_array_ii
+
+// #Medium #Array #Binary_Search #Binary_Search_II_Day_12
+// #2022_09_25_Time_352_ms_(42.31%)_Space_37.5_MB_(88.46%)
+
+class Solution {
+    fun search(nums: IntArray, target: Int): Boolean {
+        return binary(nums, 0, nums.size - 1, target)
+    }
+
+    private fun binary(a: IntArray, i: Int, j: Int, t: Int): Boolean {
+        if (i > j) {
+            return false
+        }
+        val mid = (i + j) / 2
+        if (a[mid] == t) {
+            return true
+        }
+        val c1 = binary(a, i, mid - 1, t)
+        val c2 = binary(a, mid + 1, j, t)
+        return c1 || c2
+    }
+}

src/main/kotlin/g0001_0100/s0081_search_in_rotated_sorted_array_ii/readme.md

@@ -0,0 +1,32 @@
+81\. Search in Rotated Sorted Array II
+
+Medium
+
+There is an integer array `nums` sorted in non-decreasing order (not necessarily with **distinct** values).
+
+Before being passed to your function, `nums` is **rotated** at an unknown pivot index `k` (`0 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,4,4,5,6,6,7]` might be rotated at pivot index `5` and become `[4,5,6,6,7,0,1,2,4,4]`.
+
+Given the array `nums` **after** the rotation and an integer `target`, return `true` _if_ `target` _is in_ `nums`_, or_ `false` _if it is not in_ `nums`_._
+
+You must decrease the overall operation steps as much as possible.
+
+**Example 1:**
+
+**Input:** nums = [2,5,6,0,0,1,2], target = 0
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** nums = [2,5,6,0,0,1,2], target = 3
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` is guaranteed to be rotated at some pivot.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
+
+**Follow up:** This problem is similar to [Search in Rotated Sorted Array](/problems/search-in-rotated-sorted-array/description/), but `nums` may contain **duplicates**. Would this affect the runtime complexity? How and why?

src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/Solution.kt

@@ -0,0 +1,45 @@
+package g0001_0100.s0082_remove_duplicates_from_sorted_list_ii
+
+// #Medium #Two_Pointers #Linked_List #Data_Structure_II_Day_11_Linked_List
+// #Algorithm_II_Day_3_Two_Pointers #2022_09_25_Time_241_ms_(91.04%)_Space_39.6_MB_(16.42%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun deleteDuplicates(head: ListNode?): ListNode? {
+        if (head == null || head.next == null) {
+            return head
+        }
+        val dummy = ListNode(0)
+        var prev: ListNode? = dummy
+        prev!!.next = head
+        var curr = head.next
+        while (curr != null) {
+            var flagFoundDuplicate = false
+            while (curr != null && prev!!.next!!.`val` == curr.`val`) {
+                flagFoundDuplicate = true
+                curr = curr.next
+            }
+            if (flagFoundDuplicate) {
+                prev!!.next = curr
+                if (curr != null) {
+                    curr = curr.next
+                }
+            } else {
+                prev = prev!!.next
+                prev!!.next = curr
+                curr = curr!!.next
+            }
+        }
+        return dummy.next
+    }
+}

src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/readme.md

@@ -0,0 +1,27 @@
+82\. Remove Duplicates from Sorted List II
+
+Medium
+
+Given the `head` of a sorted linked list, _delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list_. Return _the linked list **sorted** as well_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg)
+
+**Input:** head = [1,2,3,3,4,4,5]
+
+**Output:** [1,2,5]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg)
+
+**Input:** head = [1,1,1,2,3]
+
+**Output:** [2,3]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 300]`.
+*   `-100 <= Node.val <= 100`
+*   The list is guaranteed to be **sorted** in ascending order.

src/main/kotlin/g0001_0100/s0083_remove_duplicates_from_sorted_list/Solution.kt

@@ -0,0 +1,34 @@
+package g0001_0100.s0083_remove_duplicates_from_sorted_list
+
+// #Easy #Linked_List #Data_Structure_I_Day_8_Linked_List
+// #2022_09_25_Time_274_ms_(77.82%)_Space_37.9_MB_(53.23%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun deleteDuplicates(head: ListNode?): ListNode? {
+        if (head == null) {
+            return null
+        }
+        var current: ListNode = head
+        var next = current.next
+        while (null != next) {
+            if (current.`val` == next.`val`) {
+                current.next = next.next
+            } else {
+                current = next
+            }
+            next = current.next
+        }
+        return head
+    }
+}

src/main/kotlin/g0001_0100/s0083_remove_duplicates_from_sorted_list/readme.md

@@ -0,0 +1,27 @@
+83\. Remove Duplicates from Sorted List
+
+Easy
+
+Given the `head` of a sorted linked list, _delete all duplicates such that each element appears only once_. Return _the linked list **sorted** as well_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/list1.jpg)
+
+**Input:** head = [1,1,2]
+
+**Output:** [1,2]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/list2.jpg)
+
+**Input:** head = [1,1,2,3,3]
+
+**Output:** [1,2,3]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 300]`.
+*   `-100 <= Node.val <= 100`
+*   The list is guaranteed to be **sorted** in ascending order.

src/main/kotlin/g0001_0100/s0085_maximal_rectangle/Solution.kt

@@ -0,0 +1,88 @@
+package g0001_0100.s0085_maximal_rectangle
+
+// #Hard #Array #Dynamic_Programming #Matrix #Stack #Monotonic_Stack
+// #2022_09_25_Time_463_ms_(55.17%)_Space_58.5_MB_(62.07%)
+
+class Solution {
+    fun maximalRectangle(matrix: Array<CharArray>): Int {
+        /*
+         * idea: using [LC84 Largest Rectangle in Histogram]. For each row of the matrix, construct
+         * the histogram based on the current row and the previous histogram (up to the previous
+         * row), then compute the largest rectangle area using LC84.
+         */
+        val m = matrix.size
+        var n = 0
+        if (m == 0 || matrix[0].size.also { n = it } == 0) {
+            return 0
+        }
+        var i: Int
+        var j: Int
+        var res = 0
+        val heights = IntArray(n)
+        i = 0
+        while (i < m) {
+            j = 0
+            while (j < n) {
+                if (matrix[i][j] == '0') {
+                    heights[j] = 0
+                } else {
+                    heights[j] += 1
+                }
+                j++
+            }
+            res = Math.max(res, largestRectangleArea(heights))
+            i++
+        }
+        return res
+    }
+
+    private fun largestRectangleArea(heights: IntArray): Int {
+        /*
+         * idea: scan and store if a[i-1]<=a[i] (increasing), then as long as a[i]<a[i-1], then we
+         * can compute the largest rectangle area with base a[j], for j<=i-1, and a[j]>a[i], which
+         * is a[j]*(i-j). And meanwhile, all these bars (a[j]'s) are already done, and thus are
+         * throwable (using pop() with a stack).
+         *
+         * <p>We can use an array nLeftGeq[] of size n to simulate a stack. nLeftGeq[i] = the number
+         * of elements to the left of [i] having value greater than or equal to a[i] (including a[i]
+         * itself). It is also the index difference between [i] and the next index on the top of the
+         * stack.
+         */
+        val n = heights.size
+        if (n == 0) {
+            return 0
+        }
+        val nLeftGeq = IntArray(n)
+        // the number of elements to the left
+        // of [i] with value >= heights[i]
+        nLeftGeq[0] = 1
+        // preIdx=the index of stack.peek(), res=max area so far
+        var preIdx = 0
+        var res = 0
+        for (i in 1 until n) {
+            nLeftGeq[i] = 1
+            // notice that preIdx = i - 1 = peek()
+            while (preIdx >= 0 && heights[i] < heights[preIdx]) {
+                res = Math.max(res, heights[preIdx] * (nLeftGeq[preIdx] + i - preIdx - 1))
+                // pop()
+                nLeftGeq[i] += nLeftGeq[preIdx]
+                // peek() current top
+                preIdx = preIdx - nLeftGeq[preIdx]
+            }
+            if (preIdx >= 0 && heights[i] == heights[preIdx]) {
+                // pop()
+                nLeftGeq[i] += nLeftGeq[preIdx]
+            }
+            // otherwise nothing to do
+            preIdx = i
+        }
+        // compute the rest largest rectangle areas with (indices of) bases
+        // on stack
+        while (preIdx >= 0 && 0 < heights[preIdx]) {
+            res = Math.max(res, heights[preIdx] * (nLeftGeq[preIdx] + n - preIdx - 1))
+            // peek() current top
+            preIdx = preIdx - nLeftGeq[preIdx]
+        }
+        return res
+    }
+}

src/main/kotlin/g0001_0100/s0085_maximal_rectangle/readme.md

@@ -0,0 +1,34 @@
+85\. Maximal Rectangle
+
+Hard
+
+Given a `rows x cols` binary `matrix` filled with `0`'s and `1`'s, find the largest rectangle containing only `1`'s and return _its area_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/maximal.jpg)
+
+**Input:** matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+
+**Output:** 6
+
+**Explanation:** The maximal rectangle is shown in the above picture.
+
+**Example 2:**
+
+**Input:** matrix = [["0"]]
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** matrix = [["1"]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `rows == matrix.length`
+*   `cols == matrix[i].length`
+*   `1 <= row, cols <= 200`
+*   `matrix[i][j]` is `'0'` or `'1'`.

src/test/kotlin/g0001_0100/s0081_search_in_rotated_sorted_array_ii/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0001_0100.s0081_search_in_rotated_sorted_array_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun search() {
+        assertThat(Solution().search(intArrayOf(2, 5, 6, 0, 0, 1, 2), 0), equalTo(true))
+    }
+
+    @Test
+    fun search2() {
+        assertThat(Solution().search(intArrayOf(2, 5, 6, 0, 0, 1, 2), 3), equalTo(false))
+    }
+}