Added tasks 1080-1093

Author: javadev

README.md

@@ -437,6 +437,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1091 |[Shortest Path in Binary Matrix](src/main/kotlin/g1001_1100/s1091_shortest_path_in_binary_matrix)| Medium | Array, Breadth_First_Search, Matrix | 305 | 98.28
 | 0130 |[Surrounded Regions](src/main/kotlin/g0101_0200/s0130_surrounded_regions)| Medium | Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 355 | 84.42
 | 0797 |[All Paths From Source to Target](src/main/kotlin/g0701_0800/s0797_all_paths_from_source_to_target)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Backtracking | 232 | 100.00
 
@@ -1130,6 +1131,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1091 |[Shortest Path in Binary Matrix](src/main/kotlin/g1001_1100/s1091_shortest_path_in_binary_matrix)| Medium | Array, Breadth_First_Search, Matrix | 305 | 98.28
 | 0542 |[01 Matrix](src/main/kotlin/g0501_0600/s0542_01_matrix)| Medium | Array, Dynamic_Programming, Breadth_First_Search, Matrix | 441 | 94.06
 
 #### Day 6 Matrix Related Problems
@@ -1259,6 +1261,7 @@
 |-|-|-|-|-|-
 | 0182 |[Duplicate Emails](src/main/kotlin/g0101_0200/s0182_duplicate_emails)| Easy | Database | 396 | 68.40
 | 1050 |[Actors and Directors Who Cooperated At Least Three Times](src/main/kotlin/g1001_1100/s1050_actors_and_directors_who_cooperated_at_least_three_times)| Easy | LeetCode_Curated_SQL_70, Database | 629 | 81.02
+| 1084 |[Sales Analysis III](src/main/kotlin/g1001_1100/s1084_sales_analysis_iii)| Easy | LeetCode_Curated_SQL_70, Database | 1881 | 79.36
 
 ### Level 1
 
@@ -1784,6 +1787,14 @@
 | 1105 |[Filling Bookcase Shelves](src/main/kotlin/g1101_1200/s1105_filling_bookcase_shelves)| Medium | Array, Dynamic_Programming | 175 | 33.33
 | 1104 |[Path In Zigzag Labelled Binary Tree](src/main/kotlin/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree)| Medium | Math, Tree, Binary_Tree | 136 | 100.00
 | 1103 |[Distribute Candies to People](src/main/kotlin/g1101_1200/s1103_distribute_candies_to_people)| Easy | Math, Simulation | 129 | 100.00
+| 1093 |[Statistics from a Large Sample](src/main/kotlin/g1001_1100/s1093_statistics_from_a_large_sample)| Medium | Math, Two_Pointers, Probability_and_Statistics | 191 | 100.00
+| 1092 |[Shortest Common Supersequence](src/main/kotlin/g1001_1100/s1092_shortest_common_supersequence)| Hard | String, Dynamic_Programming | 174 | 100.00
+| 1091 |[Shortest Path in Binary Matrix](src/main/kotlin/g1001_1100/s1091_shortest_path_in_binary_matrix)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_II_Day_8_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_5_Matrix_Related_Problems | 305 | 98.28
+| 1090 |[Largest Values From Labels](src/main/kotlin/g1001_1100/s1090_largest_values_from_labels)| Medium | Array, Hash_Table, Sorting, Greedy, Counting | 281 | 100.00
+| 1089 |[Duplicate Zeros](src/main/kotlin/g1001_1100/s1089_duplicate_zeros)| Easy | Array, Two_Pointers | 185 | 93.60
+| 1084 |[Sales Analysis III](src/main/kotlin/g1001_1100/s1084_sales_analysis_iii)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_10_Where | 1881 | 79.36
+| 1081 |[Smallest Subsequence of Distinct Characters](src/main/kotlin/g1001_1100/s1081_smallest_subsequence_of_distinct_characters)| Medium | String, Greedy, Stack, Monotonic_Stack | 146 | 100.00
+| 1080 |[Insufficient Nodes in Root to Leaf Paths](src/main/kotlin/g1001_1100/s1080_insufficient_nodes_in_root_to_leaf_paths)| Medium | Depth_First_Search, Tree, Binary_Tree | 271 | 100.00
 | 1079 |[Letter Tile Possibilities](src/main/kotlin/g1001_1100/s1079_letter_tile_possibilities)| Medium | String, Backtracking | 144 | 100.00
 | 1078 |[Occurrences After Bigram](src/main/kotlin/g1001_1100/s1078_occurrences_after_bigram)| Easy | String | 151 | 88.24
 | 1075 |[Project Employees I](src/main/kotlin/g1001_1100/s1075_project_employees_i)| Easy | Database | 1268 | 94.71

src/main/kotlin/g1001_1100/s1080_insufficient_nodes_in_root_to_leaf_paths/readme.md

@@ -0,0 +1,89 @@
+[![](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)
+
+## 1080\. Insufficient Nodes in Root to Leaf Paths
+
+Medium
+
+Given the `root` of a binary tree and an integer `limit`, delete all **insufficient nodes** in the tree simultaneously, and return _the root of the resulting binary tree_.
+
+A node is **insufficient** if every root to **leaf** path intersecting this node has a sum strictly less than `limit`.
+
+A **leaf** is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/06/05/insufficient-11.png)
+
+**Input:** root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1
+
+**Output:** [1,2,3,4,null,null,7,8,9,null,14]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/06/05/insufficient-3.png)
+
+**Input:** root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22
+
+**Output:** [5,4,8,11,null,17,4,7,null,null,null,5]
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2019/06/11/screen-shot-2019-06-11-at-83301-pm.png)
+
+**Input:** root = [1,2,-3,-5,null,4,null], limit = -1
+
+**Output:** [1,null,-3,4]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 5000]`.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= limit <= 10<sup>9</sup></code>
+
+## 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 sufficientSubset(root: TreeNode?, limit: Int): TreeNode? {
+        return if (sufficientSubset(root, limit, 0, root!!.left == null && root.right == null) < limit) null else root
+    }
+
+    fun sufficientSubset(root: TreeNode?, limit: Int, sum: Int, isLeaf: Boolean): Int {
+        if (root != null) {
+            val leftSum = sufficientSubset(
+                root.left,
+                limit,
+                sum + root.`val`,
+                root.left == null && root.right == null
+            )
+            val rightSum = sufficientSubset(
+                root.right,
+                limit,
+                sum + root.`val`,
+                root.left == null && root.right == null
+            )
+            if (leftSum < limit) {
+                root.left = null
+            }
+            if (rightSum < limit) {
+                root.right = null
+            }
+            return leftSum.coerceAtLeast(rightSum)
+        }
+        return if (isLeaf) sum else Int.MIN_VALUE
+    }
+}
+```

src/main/kotlin/g1001_1100/s1081_smallest_subsequence_of_distinct_characters/readme.md

@@ -0,0 +1,68 @@
+[![](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)
+
+## 1081\. Smallest Subsequence of Distinct Characters
+
+Medium
+
+Given a string `s`, return _the_ _lexicographically smallest_ _subsequence_ _of_ `s` _that contains all the distinct characters of_ `s` _exactly once_.
+
+**Example 1:**
+
+**Input:** s = "bcabc"
+
+**Output:** "abc"
+
+**Example 2:**
+
+**Input:** s = "cbacdcbc"
+
+**Output:** "acdb"
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consists of lowercase English letters.
+
+**Note:** This question is the same as 316: [https://leetcode.com/problems/remove-duplicate-letters/](https://leetcode.com/problems/remove-duplicate-letters/)
+
+## Solution
+
+```kotlin
+import java.util.Arrays
+import java.util.Deque
+import java.util.LinkedList
+
+class Solution {
+    fun smallestSubsequence(s: String): String {
+        val n = s.length
+        val stk: Deque<Char> = LinkedList()
+        val freq = IntArray(26)
+        val exist = BooleanArray(26)
+        Arrays.fill(exist, false)
+        for (ch in s.toCharArray()) {
+            freq[ch.code - 'a'.code]++
+        }
+        for (i in 0 until n) {
+            val ch = s[i]
+            freq[ch.code - 'a'.code]--
+            if (exist[ch.code - 'a'.code]) {
+                continue
+            }
+            while (stk.isNotEmpty() && stk.peek() > ch && freq[stk.peek().code - 'a'.code] > 0) {
+                val rem = stk.pop()
+                exist[rem.code - 'a'.code] = false
+            }
+            stk.push(ch)
+            exist[ch.code - 'a'.code] = true
+        }
+        val ans = CharArray(stk.size)
+        var index = 0
+        while (stk.isNotEmpty()) {
+            ans[index] = stk.pop()
+            index++
+        }
+        return StringBuilder(String(ans)).reverse().toString()
+    }
+}
+```

src/main/kotlin/g1001_1100/s1084_sales_analysis_iii/readme.md

@@ -0,0 +1,94 @@
+[![](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)
+
+## 1084\. Sales Analysis III
+
+Easy
+
+SQL Schema
+
+Table: `Product`
+
+    +--------------+---------+
+    | Column Name  | Type    |
+    +--------------+---------+
+    | product_id   | int     |
+    | product_name | varchar |
+    | unit_price   | int     |
+    +--------------+---------+
+    product_id is the primary key of this table.
+    Each row of this table indicates the name and the price of each product. 
+
+Table: `Sales`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | seller_id   | int     |
+    | product_id  | int     |
+    | buyer_id    | int     |
+    | sale_date   | date    |
+    | quantity    | int     |
+    | price       | int     |
+    +-------------+---------+
+    This table has no primary key, it can have repeated rows.
+    product_id is a foreign key to the Product table.
+    Each row of this table contains some information about one sale. 
+
+Write an SQL query that reports the **products** that were **only** sold in the first quarter of `2019`. That is, between `2019-01-01` and `2019-03-31` inclusive.
+
+Return the result table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:**
+
+    Product table:
+    +------------+--------------+------------+
+    | product_id | product_name | unit_price |
+    +------------+--------------+------------+
+    | 1          | S8           | 1000       |
+    | 2          | G4           | 800        |
+    | 3          | iPhone       | 1400       |
+    +------------+--------------+------------+
+    
+    Sales table:
+    +-----------+------------+----------+------------+----------+-------+
+    | seller_id | product_id | buyer_id | sale_date  | quantity | price |
+    +-----------+------------+----------+------------+----------+-------+
+    | 1         | 1          | 1        | 2019-01-21 | 2        | 2000  |
+    | 1         | 2          | 2        | 2019-02-17 | 1        | 800   |
+    | 2         | 2          | 3        | 2019-06-02 | 1        | 800   |
+    | 3         | 3          | 4        | 2019-05-13 | 2        | 2800  |
+    +-----------+------------+----------+------------+----------+-------+
+
+**Output:**
+
+    +-------------+--------------+
+    | product_id  | product_name |
+    +-------------+--------------+
+    | 1           | S8           |
+    +-------------+--------------+
+
+**Explanation:**
+
+The product with id 1 was only sold in the spring of 2019.
+
+The product with id 2 was sold in the spring of 2019 but was also sold after the spring of 2019.
+
+The product with id 3 was sold after spring 2019.
+
+We return only product 1 as it is the product that was only sold in the spring of 2019.
+
+## Solution
+
+```sql
+# Write your MySQL query statement below
+SELECT P.product_id, P.product_name
+FROM Product P
+INNER JOIN Sales S ON P.product_id = S.product_id
+GROUP BY P.product_id
+HAVING MIN(S.sale_date) >= '2019-01-01' AND MAX(S.sale_date) <= '2019-03-31';
+```

src/main/kotlin/g1001_1100/s1089_duplicate_zeros/readme.md

@@ -0,0 +1,65 @@
+[![](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)
+
+## 1089\. Duplicate Zeros
+
+Easy
+
+Given a fixed-length integer array `arr`, duplicate each occurrence of zero, shifting the remaining elements to the right.
+
+**Note** that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.
+
+**Example 1:**
+
+**Input:** arr = [1,0,2,3,0,4,5,0]
+
+**Output:** [1,0,0,2,3,0,0,4]
+
+**Explanation:** After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]
+
+**Example 2:**
+
+**Input:** arr = [1,2,3]
+
+**Output:** [1,2,3]
+
+**Explanation:** After calling your function, the input array is modified to: [1,2,3]
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   `0 <= arr[i] <= 9`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun duplicateZeros(arr: IntArray) {
+        var countZero = 0
+        for (k in arr) {
+            if (k == 0) {
+                countZero++
+            }
+        }
+        val len = arr.size + countZero
+        // We just need O(1) space if we scan from back
+        // i point to the original array, j point to the new location
+        var i = arr.size - 1
+        var j = len - 1
+        while (i < j) {
+            // copy twice when hit '0'
+            if (arr[i] == 0) {
+                if (j < arr.size) {
+                    arr[j] = arr[i]
+                }
+                j--
+            }
+            if (j < arr.size) {
+                arr[j] = arr[i]
+            }
+            i--
+            j--
+        }
+    }
+}
+```