Added tasks 871-891

README.md

@@ -108,6 +108,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list)| Easy | Two_Pointers, Linked_List | 136 | 76.52
 | 0142 |[Linked List Cycle II](src/main/kotlin/g0101_0200/s0142_linked_list_cycle_ii)| Medium | Top_100_Liked_Questions, Hash_Table, Two_Pointers, Linked_List | 192 | 63.39
 
 #### Day 5 Greedy
@@ -435,6 +436,7 @@
 | 0328 |[Odd Even Linked List](src/main/kotlin/g0301_0400/s0328_odd_even_linked_list)| Medium | Top_Interview_Questions, Linked_List | 216 | 86.96
 | 0061 |[Rotate List](src/main/kotlin/g0001_0100/s0061_rotate_list)| Medium | Two_Pointers, Linked_List | 193 | 92.16
 | 0024 |[Swap Nodes in Pairs](src/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs)| Medium | Top_100_Liked_Questions, Linked_List, Recursion | 149 | 99.39
+| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list)| Easy | Two_Pointers, Linked_List | 136 | 76.52
 | 0142 |[Linked List Cycle II](src/main/kotlin/g0101_0200/s0142_linked_list_cycle_ii)| Medium | Top_100_Liked_Questions, Hash_Table, Two_Pointers, Linked_List | 192 | 63.39
 | 0141 |[Linked List Cycle](src/main/kotlin/g0101_0200/s0141_linked_list_cycle)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Two_Pointers, Linked_List | 223 | 91.85
 | 0206 |[Reverse Linked List](src/main/kotlin/g0201_0300/s0206_reverse_linked_list)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Linked_List, Recursion | 279 | 45.78
@@ -824,6 +826,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list)| Easy | Two_Pointers, Linked_List | 136 | 76.52
 | 0019 |[Remove Nth Node From End of List](src/main/kotlin/g0001_0100/s0019_remove_nth_node_from_end_of_list)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Two_Pointers, Linked_List | 180 | 91.58
 
 #### Day 6 Sliding Window
@@ -1146,6 +1149,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0875 |[Koko Eating Bananas](src/main/kotlin/g0801_0900/s0875_koko_eating_bananas)| Medium | Array, Binary_Search | 267 | 93.85
 
 #### Day 5
 
@@ -1444,6 +1448,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list)| Easy | Two_Pointers, Linked_List | 136 | 76.52
 | 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
 | 0404 |[Sum of Left Leaves](src/main/kotlin/g0401_0500/s0404_sum_of_left_leaves)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 173 | 86.05
 
@@ -1679,6 +1684,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0886 |[Possible Bipartition](src/main/kotlin/g0801_0900/s0886_possible_bipartition)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 397 | 100.00
 | 0785 |[Is Graph Bipartite?](src/main/kotlin/g0701_0800/s0785_is_graph_bipartite)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 215 | 82.35
 
 ## Algorithms
@@ -1687,6 +1693,27 @@
 |------|----------------|-------------|-------------|----------|--------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence)| 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)| 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
+| 0891 |[Sum of Subsequence Widths](src/main/kotlin/g0801_0900/s0891_sum_of_subsequence_widths)| Hard | Array, Math, Sorting | 481 | 100.00
+| 0890 |[Find and Replace Pattern](src/main/kotlin/g0801_0900/s0890_find_and_replace_pattern)| Medium | Array, String, Hash_Table | 150 | 100.00
+| 0889 |[Construct Binary Tree from Preorder and Postorder Traversal](src/main/kotlin/g0801_0900/s0889_construct_binary_tree_from_preorder_and_postorder_traversal)| Medium | Array, Hash_Table, Tree, Binary_Tree, Divide_and_Conquer | 168 | 100.00
+| 0888 |[Fair Candy Swap](src/main/kotlin/g0801_0900/s0888_fair_candy_swap)| Easy | Array, Hash_Table, Sorting, Binary_Search | 318 | 100.00
+| 0887 |[Super Egg Drop](src/main/kotlin/g0801_0900/s0887_super_egg_drop)| Hard | Dynamic_Programming, Math, Binary_Search | 119 | 100.00
+| 0886 |[Possible Bipartition](src/main/kotlin/g0801_0900/s0886_possible_bipartition)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Graph_Theory_I_Day_14_Graph_Theory | 397 | 100.00
+| 0885 |[Spiral Matrix III](src/main/kotlin/g0801_0900/s0885_spiral_matrix_iii)| Medium | Array, Matrix, Simulation | 265 | 100.00
+| 0884 |[Uncommon Words from Two Sentences](src/main/kotlin/g0801_0900/s0884_uncommon_words_from_two_sentences)| Easy | String, Hash_Table | 171 | 100.00
+| 0883 |[Projection Area of 3D Shapes](src/main/kotlin/g0801_0900/s0883_projection_area_of_3d_shapes)| Easy | Array, Math, Matrix, Geometry | 173 | 100.00
+| 0882 |[Reachable Nodes In Subdivided Graph](src/main/kotlin/g0801_0900/s0882_reachable_nodes_in_subdivided_graph)| Hard | Heap_Priority_Queue, Graph, Shortest_Path | 434 | 100.00
+| 0881 |[Boats to Save People](src/main/kotlin/g0801_0900/s0881_boats_to_save_people)| Medium | Array, Sorting, Greedy, Two_Pointers | 370 | 96.07
+| 0880 |[Decoded String at Index](src/main/kotlin/g0801_0900/s0880_decoded_string_at_index)| Medium | String, Stack | 134 | 100.00
+| 0879 |[Profitable Schemes](src/main/kotlin/g0801_0900/s0879_profitable_schemes)| Hard | Array, Dynamic_Programming | 198 | 75.00
+| 0878 |[Nth Magical Number](src/main/kotlin/g0801_0900/s0878_nth_magical_number)| Hard | Math, Binary_Search | 124 | 100.00
+| 0877 |[Stone Game](src/main/kotlin/g0801_0900/s0877_stone_game)| Medium | Array, Dynamic_Programming, Math, Game_Theory | 136 | 88.24
+| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list)| Easy | Two_Pointers, Linked_List, Algorithm_I_Day_5_Two_Pointers, Programming_Skills_I_Day_10_Linked_List_and_Tree, Level_1_Day_4_Linked_List, Udemy_Linked_List | 136 | 76.52
+| 0875 |[Koko Eating Bananas](src/main/kotlin/g0801_0900/s0875_koko_eating_bananas)| Medium | Array, Binary_Search, Binary_Search_II_Day_4 | 267 | 93.85
+| 0874 |[Walking Robot Simulation](src/main/kotlin/g0801_0900/s0874_walking_robot_simulation)| Medium | Array, Simulation | 274 | 100.00
+| 0873 |[Length of Longest Fibonacci Subsequence](src/main/kotlin/g0801_0900/s0873_length_of_longest_fibonacci_subsequence)| Medium | Array, Hash_Table, Dynamic_Programming | 341 | 90.00
+| 0872 |[Leaf-Similar Trees](src/main/kotlin/g0801_0900/s0872_leaf_similar_trees)| Easy | Depth_First_Search, Tree, Binary_Tree | 140 | 100.00
+| 0871 |[Minimum Number of Refueling Stops](src/main/kotlin/g0801_0900/s0871_minimum_number_of_refueling_stops)| Hard | Array, Dynamic_Programming, Greedy, Heap_Priority_Queue | 203 | 92.86
 | 0870 |[Advantage Shuffle](src/main/kotlin/g0801_0900/s0870_advantage_shuffle)| Medium | Array, Sorting, Greedy | 698 | 100.00
 | 0869 |[Reordered Power of 2](src/main/kotlin/g0801_0900/s0869_reordered_power_of_2)| Medium | Math, Sorting, Counting, Enumeration | 145 | 87.50
 | 0868 |[Binary Gap](src/main/kotlin/g0801_0900/s0868_binary_gap)| Easy | Bit_Manipulation | 142 | 100.00

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

@@ -49,7 +49,7 @@ The diagram on the right represents the answer.
 ```kotlin
 import com_github_leetcode.TreeNode
 
-/**
+/*
  * Example:
  * var ti = TreeNode(5)
  * var v = ti.`val`

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

@@ -44,7 +44,7 @@ Return _the number of connected components in_ `nums` _where two values are conn
 ```kotlin
 import com_github_leetcode.ListNode
 
-/**
+/*
  * Example:
  * var li = ListNode(5)
  * var v = li.`val`
@@ -53,7 +53,6 @@ import com_github_leetcode.ListNode
  *     var next: ListNode? = null
  * }
  */
-
 @Suppress("NAME_SHADOWING")
 class Solution {
     fun numComponents(head: ListNode?, nums: IntArray): Int {

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

@@ -0,0 +1,90 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 871\. Minimum Number of Refueling Stops
+
+Hard
+
+A car travels from a starting position to a destination which is `target` miles east of the starting position.
+
+There are gas stations along the way. The gas stations are represented as an array `stations` where <code>stations[i] = [position<sub>i</sub>, fuel<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> gas station is <code>position<sub>i</sub></code> miles east of the starting position and has <code>fuel<sub>i</sub></code> liters of gas.
+
+The car starts with an infinite tank of gas, which initially has `startFuel` liters of fuel in it. It uses one liter of gas per one mile that it drives. When the car reaches a gas station, it may stop and refuel, transferring all the gas from the station into the car.
+
+Return _the minimum number of refueling stops the car must make in order to reach its destination_. If it cannot reach the destination, return `-1`.
+
+Note that if the car reaches a gas station with `0` fuel left, the car can still refuel there. If the car reaches the destination with `0` fuel left, it is still considered to have arrived.
+
+**Example 1:**
+
+**Input:** target = 1, startFuel = 1, stations = []
+
+**Output:** 0
+
+**Explanation:** We can reach the target without refueling.
+
+**Example 2:**
+
+**Input:** target = 100, startFuel = 1, stations = \[\[10,100]]
+
+**Output:** -1
+
+**Explanation:** We can not reach the target (or even the first gas station).
+
+**Example 3:**
+
+**Input:** target = 100, startFuel = 10, stations = \[\[10,60],[20,30],[30,30],[60,40]]
+
+**Output:** 2
+
+**Explanation:** We start with 10 liters of fuel. We drive to position 10, expending 10 liters of fuel.
+
+We refuel from 0 liters to 60 liters of gas.
+
+Then, we drive from position 10 to position 60 (expending 50 liters of fuel),
+
+and refuel from 10 liters to 50 liters of gas. We then drive to and reach the target.
+
+We made 2 refueling stops along the way, so we return 2.
+
+**Constraints:**
+
+*   <code>1 <= target, startFuel <= 10<sup>9</sup></code>
+*   `0 <= stations.length <= 500`
+*   <code>0 <= position<sub>i</sub> <= position<sub>i+1</sub> < target</code>
+*   <code>1 <= fuel<sub>i</sub> < 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+import java.util.PriorityQueue
+
+class Solution {
+    fun minRefuelStops(target: Int, startFuel: Int, stations: Array<IntArray>?): Int {
+        if (startFuel >= target) {
+            return 0
+        } else if (stations.isNullOrEmpty()) {
+            return -1
+        }
+        val pq = PriorityQueue { a: IntArray, b: IntArray ->
+            b[1] - a[1]
+        }
+        var start = 0
+        val end = stations.size
+        var currentFuel = startFuel
+        var stops = 0
+        while (currentFuel < target) {
+            while (start < end && currentFuel >= stations[start][0]) {
+                pq.add(stations[start++])
+            }
+            if (pq.isEmpty()) {
+                return -1
+            }
+            val current = pq.poll()
+            currentFuel += current[1]
+            stops++
+        }
+        return stops
+    }
+}
+```

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

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 872\. Leaf-Similar Trees
+
+Easy
+
+Consider all the leaves of a binary tree, from left to right order, the values of those leaves form a **leaf value sequence**_._
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/16/tree.png)
+
+For example, in the given tree above, the leaf value sequence is `(6, 7, 4, 9, 8)`.
+
+Two binary trees are considered _leaf-similar_ if their leaf value sequence is the same.
+
+Return `true` if and only if the two given trees with head nodes `root1` and `root2` are leaf-similar.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/03/leaf-similar-1.jpg)
+
+**Input:** root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/03/leaf-similar-2.jpg)
+
+**Input:** root1 = [1,2,3], root2 = [1,3,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   The number of nodes in each tree will be in the range `[1, 200]`.
+*   Both of the given trees will have values in the range `[0, 200]`.
+
+## Solution
+
+```kotlin
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun leafSimilar(root1: TreeNode?, root2: TreeNode?): Boolean {
+        val list1: MutableList<Int> = ArrayList()
+        val list2: MutableList<Int> = ArrayList()
+        preOrder(root1, list1)
+        preOrder(root2, list2)
+        // compare the lists
+        if (list1.size != list2.size) {
+            return false
+        }
+        for (i in list1.indices) {
+            if (list1[i] != list2[i]) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun preOrder(root: TreeNode?, list: MutableList<Int>) {
+        if (root != null) {
+            if (root.left == null && root.right == null) {
+                list.add(root.`val`)
+            }
+            preOrder(root.left, list)
+            preOrder(root.right, list)
+        }
+    }
+}
+```

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

@@ -0,0 +1,69 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 873\. Length of Longest Fibonacci Subsequence
+
+Medium
+
+A sequence <code>x<sub>1</sub>, x<sub>2</sub>, ..., x<sub>n</sub></code> is _Fibonacci-like_ if:
+
+*   `n >= 3`
+*   <code>x<sub>i</sub> + x<sub>i+1</sub> == x<sub>i+2</sub></code> for all `i + 2 <= n`
+
+Given a **strictly increasing** array `arr` of positive integers forming a sequence, return _the **length** of the longest Fibonacci-like subsequence of_ `arr`. If one does not exist, return `0`.
+
+A **subsequence** is derived from another sequence `arr` by deleting any number of elements (including none) from `arr`, without changing the order of the remaining elements. For example, `[3, 5, 8]` is a subsequence of `[3, 4, 5, 6, 7, 8]`.
+
+**Example 1:**
+
+**Input:** arr = [1,2,3,4,5,6,7,8]
+
+**Output:** 5
+
+**Explanation:** The longest subsequence that is fibonacci-like: [1,2,3,5,8].
+
+**Example 2:**
+
+**Input:** arr = [1,3,7,11,12,14,18]
+
+**Output:** 3
+
+**Explanation:**: The longest subsequence that is fibonacci-like: [1,11,12], [3,11,14] or [7,11,18].
+
+**Constraints:**
+
+*   `3 <= arr.length <= 1000`
+*   <code>1 <= arr[i] < arr[i + 1] <= 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun lenLongestFibSubseq(arr: IntArray?): Int {
+        if (arr == null || arr.size < 3) {
+            return 0
+        }
+        val len = arr.size
+        val dp = Array(len) { IntArray(len) }
+        var ans = 0
+        for (i in 2 until len) {
+            var left = 0
+            var right = i - 1
+            while (left < right) {
+                if (arr[left] + arr[right] < arr[i]) {
+                    left++
+                } else if (arr[left] + arr[right] > arr[i]) {
+                    right--
+                } else {
+                    // dp[right][i] = Math.max(dp[right][i], dp[left][right] + 1);
+                    dp[right][i] = dp[left][right] + 1
+                    ans = Math.max(ans, dp[right][i])
+                    left++
+                    right--
+                }
+            }
+        }
+        return if (ans > 0) ans + 2 else 0
+    }
+}
+```