Added tasks 850, 851, 852, 853

Author: ThanhNIT

README.md

@@ -1,6 +1,6 @@
 # LeetCode-in-Kotlin
 
-[![Maven Central](https://img.shields.io/maven-central/v/com.github.javadev/leetcode-in-kotlin?style=flat-square)](https://central.sonatype.com/artifact/com.github.javadev/leetcode-in-kotlin/1.10)
+[![Maven Central](https://img.shields.io/maven-central/v/com.github.javadev/leetcode-in-kotlin?style=flat-square)](https://central.sonatype.com/artifact/com.github.javadev/leetcode-in-kotlin/1.11)
 [![MIT License](http://img.shields.io/badge/license-MIT-green.svg) ](https://github.com/javadev/leetcode-in-kotlin/blob/main/LICENSE)
 [![Java CI with Maven](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/maven.yml/badge.svg)](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/maven.yml)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=javadev_LeetCode-in-Kotlin&metric=sqale_rating)](https://sonarcloud.io/summary/overall?id=javadev_LeetCode-in-Kotlin)
@@ -1176,6 +1176,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0035 |[Search Insert Position](src/main/kotlin/g0001_0100/s0035_search_insert_position/Solution.kt)| Easy | Top_100_Liked_Questions, Array, Binary_Search | 267 | 50.32
+| 0852 |[Peak Index in a Mountain Array](src/main/kotlin/g0801_0900/s0852_peak_index_in_a_mountain_array/Solution.kt)| Easy | Array, Binary_Search | 433 | 94.29
 
 #### Day 3
 
@@ -1718,6 +1719,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
+| 0853 |[Car Fleet](src/main/kotlin/g0801_0900/s0853_car_fleet/Solution.kt)| Medium | Array, Sorting, Stack, Monotonic_Stack | 757 | 85.29
+| 0852 |[Peak Index in a Mountain Array](src/main/kotlin/g0801_0900/s0852_peak_index_in_a_mountain_array/Solution.kt)| Easy | Array, Binary_Search, Binary_Search_I_Day_2 | 433 | 94.29
+| 0851 |[Loud and Rich](src/main/kotlin/g0801_0900/s0851_loud_and_rich/Solution.kt)| Medium | Array, Depth_First_Search, Graph, Topological_Sort | 347 | 100.00
+| 0850 |[Rectangle Area II](src/main/kotlin/g0801_0900/s0850_rectangle_area_ii/Solution.kt)| Hard | Array, Ordered_Set, Segment_Tree, Line_Sweep | 171 | 100.00
 | 0849 |[Maximize Distance to Closest Person](src/main/kotlin/g0801_0900/s0849_maximize_distance_to_closest_person/Solution.kt)| Medium | Array | 196 | 88.46
 | 0848 |[Shifting Letters](src/main/kotlin/g0801_0900/s0848_shifting_letters/Solution.kt)| Medium | Array, String | 537 | 93.75
 | 0847 |[Shortest Path Visiting All Nodes](src/main/kotlin/g0801_0900/s0847_shortest_path_visiting_all_nodes/Solution.kt)| Hard | Dynamic_Programming, Breadth_First_Search, Bit_Manipulation, Graph, Bitmask, Graph_Theory_I_Day_10_Standard_Traversal | 164 | 100.00

src/main/kotlin/g0801_0900/s0850_rectangle_area_ii/Solution.kt

@@ -0,0 +1,61 @@
+package g0801_0900.s0850_rectangle_area_ii
+
+// #Hard #Array #Ordered_Set #Segment_Tree #Line_Sweep
+// #2023_03_30_Time_171_ms_(100.00%)_Space_35.7_MB_(100.00%)
+
+class Solution {
+    fun rectangleArea(rectangles: Array<IntArray>): Int {
+        val memo: MutableList<IntArray> = ArrayList()
+        for (rectangle in rectangles) {
+            helper(0, rectangle, memo)
+        }
+        var res: Long = 0
+        val mod = (1e9 + 7).toInt()
+        for (m in memo) {
+            res = (res + (m[2] - m[0]).toLong() * (m[3] - m[1]).toLong()) % mod
+        }
+        return res.toInt()
+    }
+
+    private fun helper(id: Int, rectangle: IntArray, memo: MutableList<IntArray>) {
+        if (id >= memo.size) {
+            memo.add(rectangle)
+            return
+        }
+        val cur = memo[id]
+        if (rectangle[2] <= cur[0] || rectangle[0] >= cur[2] || rectangle[1] >= cur[3] || rectangle[3] <= cur[1]) {
+            helper(id + 1, rectangle, memo)
+            return
+        }
+        if (rectangle[0] < cur[0]) {
+            helper(id + 1, intArrayOf(rectangle[0], rectangle[1], cur[0], rectangle[3]), memo)
+        }
+        if (rectangle[2] > cur[2]) {
+            helper(id + 1, intArrayOf(cur[2], rectangle[1], rectangle[2], rectangle[3]), memo)
+        }
+        if (rectangle[1] < cur[1]) {
+            helper(
+                id + 1,
+                intArrayOf(
+                    rectangle[0].coerceAtLeast(cur[0]),
+                    rectangle[1],
+                    rectangle[2].coerceAtMost(cur[2]),
+                    cur[1]
+                ),
+                memo
+            )
+        }
+        if (rectangle[3] > cur[3]) {
+            helper(
+                id + 1,
+                intArrayOf(
+                    rectangle[0].coerceAtLeast(cur[0]),
+                    cur[3],
+                    rectangle[2].coerceAtMost(cur[2]),
+                    rectangle[3]
+                ),
+                memo
+            )
+        }
+    }
+}

src/main/kotlin/g0801_0900/s0850_rectangle_area_ii/readme.md

@@ -0,0 +1,39 @@
+850\. Rectangle Area II
+
+Hard
+
+You are given a 2D array of axis-aligned `rectangles`. Each <code>rectangle[i] = [x<sub>i1</sub>, y<sub>i1</sub>, x<sub>i2</sub>, y<sub>i2</sub>]</code> denotes the <code>i<sup>th</sup></code> rectangle where <code>(x<sub>i1</sub>, y<sub>i1</sub>)</code> are the coordinates of the **bottom-left corner**, and <code>(x<sub>i2</sub>, y<sub>i2</sub>)</code> are the coordinates of the **top-right corner**.
+
+Calculate the **total area** covered by all `rectangles` in the plane. Any area covered by two or more rectangles should only be counted **once**.
+
+Return _the **total area**_. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/06/06/rectangle_area_ii_pic.png)
+
+**Input:** rectangles = [[0,0,2,2],[1,0,2,3],[1,0,3,1]]
+
+**Output:** 6
+
+**Explanation:** A total area of 6 is covered by all three rectangles, as illustrated in the picture. 
+
+From (1,1) to (2,2), the green and red rectangles overlap. 
+
+From (1,0) to (2,3), all three rectangles overlap.
+
+**Example 2:**
+
+**Input:** rectangles = [[0,0,1000000000,1000000000]]
+
+**Output:** 49
+
+**Explanation:** The answer is 10<sup>18</sup> modulo (10<sup>9</sup> + 7), which is 49.
+
+**Constraints:**
+
+*   `1 <= rectangles.length <= 200`
+*   `rectanges[i].length == 4`
+*   <code>0 <= x<sub>i1</sub>, y<sub>i1</sub>, x<sub>i2</sub>, y<sub>i2</sub> <= 10<sup>9</sup></code>
+*   <code>x<sub>i1 <=</sub> x<sub>i2</sub></code>
+*   <code>y<sub>i1 <=</sub> y<sub>i2</sub></code>

src/main/kotlin/g0801_0900/s0851_loud_and_rich/Solution.kt

@@ -0,0 +1,26 @@
+package g0801_0900.s0851_loud_and_rich
+
+// #Medium #Array #Depth_First_Search #Graph #Topological_Sort
+// #2023_03_30_Time_347_ms_(100.00%)_Space_54.4_MB_(80.00%)
+
+class Solution {
+    fun loudAndRich(richer: Array<IntArray>, quiet: IntArray): IntArray {
+        val result = IntArray(quiet.size)
+        for (i in quiet.indices) {
+            result[i] = i
+        }
+        for (k in quiet.indices) {
+            var changed = false
+            for (r in richer) {
+                if (quiet[result[r[0]]] < quiet[result[r[1]]]) {
+                    result[r[1]] = result[r[0]]
+                    changed = true
+                }
+            }
+            if (!changed) {
+                break
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g0801_0900/s0851_loud_and_rich/readme.md

@@ -0,0 +1,47 @@
+851\. Loud and Rich
+
+Medium
+
+There is a group of `n` people labeled from `0` to `n - 1` where each person has a different amount of money and a different level of quietness.
+
+You are given an array `richer` where <code>richer[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that <code>a<sub>i</sub></code> has more money than <code>b<sub>i</sub></code> and an integer array `quiet` where `quiet[i]` is the quietness of the <code>i<sup>th</sup></code> person. All the given data in richer are **logically correct** (i.e., the data will not lead you to a situation where `x` is richer than `y` and `y` is richer than `x` at the same time).
+
+Return _an integer array_ `answer` _where_ `answer[x] = y` _if_ `y` _is the least quiet person (that is, the person_ `y` _with the smallest value of_ `quiet[y]`_) among all people who definitely have equal to or more money than the person_ `x`.
+
+**Example 1:**
+
+**Input:** richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
+
+**Output:** [5,5,2,5,4,5,6,7]
+
+**Explanation:**
+
+answer[0] = 5.
+
+Person 5 has more money than 3, which has more money than 1, which has more money than 0.
+
+The only person who is quieter (has lower quiet[x]) is person 7, but it is not clear if they have more money than person 0.
+
+answer[7] = 7.
+
+Among all people that definitely have equal to or more money than person 7 (which could be persons 3, 4, 5, 6, or 7), the person who is the quietest (has lower quiet[x]) is person 7.
+
+The other answers can be filled out with similar reasoning.
+
+**Example 2:**
+
+**Input:** richer = [], quiet = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   `n == quiet.length`
+*   `1 <= n <= 500`
+*   `0 <= quiet[i] < n`
+*   All the values of `quiet` are **unique**.
+*   `0 <= richer.length <= n * (n - 1) / 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   All the pairs of `richer` are **unique**.
+*   The observations in `richer` are all logically consistent.

src/main/kotlin/g0801_0900/s0852_peak_index_in_a_mountain_array/Solution.kt

@@ -0,0 +1,15 @@
+package g0801_0900.s0852_peak_index_in_a_mountain_array
+
+// #Easy #Array #Binary_Search #Binary_Search_I_Day_2
+// #2023_03_30_Time_433_ms_(94.29%)_Space_49.4_MB_(100.00%)
+
+class Solution {
+    fun peakIndexInMountainArray(arr: IntArray): Int {
+        for (i in 1 until arr.size - 1) {
+            if (arr[i] > arr[i + 1]) {
+                return i
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g0801_0900/s0852_peak_index_in_a_mountain_array/readme.md

@@ -0,0 +1,38 @@
+852\. Peak Index in a Mountain Array
+
+Medium
+
+An array `arr` a **mountain** if the following properties hold:
+
+*   `arr.length >= 3`
+*   There exists some `i` with `0 < i < arr.length - 1` such that:
+    *   `arr[0] < arr[1] < ... < arr[i - 1] < arr[i]`
+    *   `arr[i] > arr[i + 1] > ... > arr[arr.length - 1]`
+
+Given a mountain array `arr`, return the index `i` such that `arr[0] < arr[1] < ... < arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]`.
+
+You must solve it in `O(log(arr.length))` time complexity.
+
+**Example 1:**
+
+**Input:** arr = [0,1,0]
+
+**Output:** 1
+
+**Example 2:**
+
+**Input:** arr = [0,2,1,0]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** arr = [0,10,5,2]
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>3 <= arr.length <= 10<sup>5</sup></code>
+*   <code>0 <= arr[i] <= 10<sup>6</sup></code>
+*   `arr` is **guaranteed** to be a mountain array.

src/main/kotlin/g0801_0900/s0853_car_fleet/Solution.kt

@@ -0,0 +1,35 @@
+package g0801_0900.s0853_car_fleet
+
+// #Medium #Array #Sorting #Stack #Monotonic_Stack
+// #2023_03_30_Time_757_ms_(85.29%)_Space_50.7_MB_(100.00%)
+
+class Solution {
+    private class Car {
+        var position = 0
+        var speed = 0
+    }
+
+    fun carFleet(target: Int, position: IntArray, speed: IntArray): Int {
+        val cars: MutableList<Car> = ArrayList()
+        for (i in position.indices) {
+            val c = Car()
+            c.position = position[i]
+            c.speed = speed[i]
+            cars.add(c)
+        }
+        cars.sortBy { it.position }
+        var numFleets = 1
+        var lastTime = (
+            (target - cars[cars.size - 1].position).toFloat() /
+                cars[cars.size - 1].speed
+            )
+        for (i in cars.size - 2 downTo 0) {
+            val timeToTarget = (target - cars[i].position).toFloat() / cars[i].speed
+            if (timeToTarget > lastTime) {
+                numFleets++
+                lastTime = timeToTarget
+            }
+        }
+        return numFleets
+    }
+}

src/main/kotlin/g0801_0900/s0853_car_fleet/readme.md

@@ -0,0 +1,56 @@
+853\. Car Fleet
+
+Medium
+
+There are `n` cars going to the same destination along a one-lane road. The destination is `target` miles away.
+
+You are given two integer array `position` and `speed`, both of length `n`, where `position[i]` is the position of the <code>i<sup>th</sup></code> car and `speed[i]` is the speed of the <code>i<sup>th</sup></code> car (in miles per hour).
+
+A car can never pass another car ahead of it, but it can catch up to it and drive bumper to bumper **at the same speed**. The faster car will **slow down** to match the slower car's speed. The distance between these two cars is ignored (i.e., they are assumed to have the same position).
+
+A **car fleet** is some non-empty set of cars driving at the same position and same speed. Note that a single car is also a car fleet.
+
+If a car catches up to a car fleet right at the destination point, it will still be considered as one car fleet.
+
+Return _the **number of car fleets** that will arrive at the destination_.
+
+**Example 1:**
+
+**Input:** target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]
+
+**Output:** 3
+
+**Explanation:**
+
+The cars starting at 10 (speed 2) and 8 (speed 4) become a fleet, meeting each other at 12.
+
+The car starting at 0 does not catch up to any other car, so it is a fleet by itself.
+
+The cars starting at 5 (speed 1) and 3 (speed 3) become a fleet, meeting each other at 6. The fleet moves at speed 1 until it reaches target.
+
+Note that no other cars meet these fleets before the destination, so the answer is 3.
+
+**Example 2:**
+
+**Input:** target = 10, position = [3], speed = [3]
+
+**Output:** 1
+
+**Explanation:** There is only one car, hence there is only one fleet.
+
+**Example 3:**
+
+**Input:** target = 100, position = [0,2,4], speed = [4,2,1]
+
+**Output:** 1
+
+**Explanation:** The cars starting at 0 (speed 4) and 2 (speed 2) become a fleet, meeting each other at 4. The fleet moves at speed 2. Then, the fleet (speed 2) and the car starting at 4 (speed 1) become one fleet, meeting each other at 6. The fleet moves at speed 1 until it reaches target.
+
+**Constraints:**
+
+*   `n == position.length == speed.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 < target <= 10<sup>6</sup></code>
+*   `0 <= position[i] < target`
+*   All the values of `position` are **unique**.
+*   <code>0 < speed[i] <= 10<sup>6</sup></code>

src/test/kotlin/g0801_0900/s0850_rectangle_area_ii/SolutionTest.kt

@@ -0,0 +1,24 @@
+package g0801_0900.s0850_rectangle_area_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun rectangleArea() {
+        assertThat(
+            Solution()
+                .rectangleArea(arrayOf(intArrayOf(0, 0, 2, 2), intArrayOf(1, 0, 2, 3), intArrayOf(1, 0, 3, 1))),
+            equalTo(6)
+        )
+    }
+
+    @Test
+    fun rectangleArea2() {
+        assertThat(
+            Solution().rectangleArea(arrayOf(intArrayOf(0, 0, 1000000000, 1000000000))),
+            equalTo(49)
+        )
+    }
+}