Added tasks 1045, 1046, 1047, 1048

Author: ThanhNIT

README.md

@@ -152,6 +152,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1046 |[Last Stone Weight](src/main/kotlin/g1001_1100/s1046_last_stone_weight/Solution.kt)| Easy | Array, Heap_Priority_Queue | 123 | 100.00
 | 0692 |[Top K Frequent Words](src/main/kotlin/g0601_0700/s0692_top_k_frequent_words/Solution.kt)| Medium | String, Hash_Table, Sorting, Heap_Priority_Queue, Counting, Trie, Bucket_Sort | 239 | 81.10
 
 ### Level 2
@@ -1779,6 +1780,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | 1155 |[Number of Dice Rolls With Target Sum](src/main/kotlin/g1101_1200/s1155_number_of_dice_rolls_with_target_sum/Solution.kt)| Medium | Dynamic_Programming | 158 | 80.95
 | 1154 |[Day of the Year](src/main/kotlin/g1101_1200/s1154_day_of_the_year/Solution.kt)| Easy | String, Math | 317 | 70.00
 | 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
+| 1048 |[Longest String Chain](src/main/kotlin/g1001_1100/s1048_longest_string_chain/Solution.kt)| Medium | Array, String, Hash_Table, Dynamic_Programming, Two_Pointers | 273 | 75.00
+| 1047 |[Remove All Adjacent Duplicates In String](src/main/kotlin/g1001_1100/s1047_remove_all_adjacent_duplicates_in_string/Solution.kt)| Easy | String, Stack | 228 | 94.52
+| 1046 |[Last Stone Weight](src/main/kotlin/g1001_1100/s1046_last_stone_weight/Solution.kt)| Easy | Array, Heap_Priority_Queue, Level_1_Day_15_Heap | 123 | 100.00
+| 1045 |[Customers Who Bought All Products](src/main/kotlin/g1001_1100/s1045_customers_who_bought_all_products/script.sql)| Medium | Database | 881 | 90.47
 | 1044 |[Longest Duplicate Substring](src/main/kotlin/g1001_1100/s1044_longest_duplicate_substring/Solution.kt)| Hard | String, Binary_Search, Sliding_Window, Hash_Function, Rolling_Hash, Suffix_Array | 592 | 100.00
 | 1043 |[Partition Array for Maximum Sum](src/main/kotlin/g1001_1100/s1043_partition_array_for_maximum_sum/Solution.kt)| Medium | Array, Dynamic_Programming | 194 | 71.43
 | 1042 |[Flower Planting With No Adjacent](src/main/kotlin/g1001_1100/s1042_flower_planting_with_no_adjacent/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 396 | 85.71

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

@@ -0,0 +1,66 @@
+1045\. Customers Who Bought All Products
+
+Medium
+
+SQL Schema
+
+Table: `Customer`
+
+    +-------------+---------+ 
+    | Column Name | Type    | 
+    +-------------+---------+ 
+    | customer_id | int     | 
+    | product_key | int     | 
+    +-------------+---------+ 
+
+There is no primary key for this table. It may contain duplicates. `customer_id` is not NULL`.` product\_key is a foreign key to `Product` table.
+
+Table: `Product`
+
+    +-------------+---------+ 
+    | Column Name | Type    | 
+    +-------------+---------+ 
+    | product_key | int     | 
+    +-------------+---------+ 
+
+    product_key is the primary key column for this table.
+
+Write an SQL query to report the customer ids from the `Customer` table that bought all the products in the `Product` table.
+
+Return the result table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:** Customer table: 
+
+    +-------------+-------------+ 
+    | customer_id | product_key | 
+    +-------------+-------------+ 
+    | 1           | 5           | 
+    | 2           | 6           | 
+    | 3           | 5           | 
+    | 3           | 6           | 
+    | 1           | 6           | 
+    +-------------+-------------+ 
+
+Product table: 
+
+    +-------------+ 
+    | product_key | 
+    +-------------+ 
+    | 5           | 
+    | 6           | 
+    +-------------+
+
+**Output:** 
+
+    +-------------+ 
+    | customer_id | 
+    +-------------+ 
+    | 1           | 
+    | 3           | 
+    +-------------+
+
+**Explanation:** The customers who bought all the products (5 and 6) are customers with IDs 1 and 3. 

src/main/kotlin/g1001_1100/s1045_customers_who_bought_all_products/script.sql

@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+# #Medium #Database #2023_05_28_Time_881_ms_(90.47%)_Space_0B_(100.00%)
+select customer_id
+from customer
+group by customer_id
+having count(distinct product_key)=(select count(*) from product);

src/main/kotlin/g1001_1100/s1046_last_stone_weight/Solution.kt

@@ -0,0 +1,26 @@
+package g1001_1100.s1046_last_stone_weight
+
+// #Easy #Array #Heap_Priority_Queue #Level_1_Day_15_Heap
+// #2023_05_28_Time_123_ms_(100.00%)_Space_35_MB_(39.50%)
+
+import java.util.PriorityQueue
+
+class Solution {
+    fun lastStoneWeight(stones: IntArray): Int {
+        val heap = PriorityQueue { a: Int, b: Int -> b - a }
+        for (stone in stones) {
+            heap.offer(stone)
+        }
+        while (heap.isNotEmpty()) {
+            if (heap.size >= 2) {
+                val one = heap.poll()
+                val two = heap.poll()
+                val diff = one - two
+                heap.offer(diff)
+            } else {
+                return heap.poll()
+            }
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,41 @@
+1046\. Last Stone Weight
+
+Easy
+
+You are given an array of integers `stones` where `stones[i]` is the weight of the <code>i<sup>th</sup></code> stone.
+
+We are playing a game with the stones. On each turn, we choose the **heaviest two stones** and smash them together. Suppose the heaviest two stones have weights `x` and `y` with `x <= y`. The result of this smash is:
+
+*   If `x == y`, both stones are destroyed, and
+*   If `x != y`, the stone of weight `x` is destroyed, and the stone of weight `y` has new weight `y - x`.
+
+At the end of the game, there is **at most one** stone left.
+
+Return _the weight of the last remaining stone_. If there are no stones left, return `0`.
+
+**Example 1:**
+
+**Input:** stones = [2,7,4,1,8,1]
+
+**Output:** 1
+
+**Explanation:** 
+
+We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then, 
+
+we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+
+we combine 2 and 1 to get 1 so the array converts to [1,1,1] then, 
+
+we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of the last stone.
+
+**Example 2:**
+
+**Input:** stones = [1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= stones.length <= 30`
+*   `1 <= stones[i] <= 1000`

src/main/kotlin/g1001_1100/s1047_remove_all_adjacent_duplicates_in_string/Solution.kt

@@ -0,0 +1,26 @@
+package g1001_1100.s1047_remove_all_adjacent_duplicates_in_string
+
+// #Easy #String #Stack #2023_05_28_Time_228_ms_(94.52%)_Space_50.5_MB_(54.79%)
+
+class Solution {
+    fun removeDuplicates(s: String): String {
+        if (s.length == 1) {
+            return s
+        }
+        val array = s.toCharArray()
+        val length = array.size
+        var fast = 0
+        var slow = 0
+        while (fast < length) {
+            if (slow == 0 || array[fast] != array[slow - 1]) {
+                array[slow++] = array[fast++]
+            } else {
+                if (array[fast] == array[slow - 1]) {
+                    fast++
+                }
+                slow--
+            }
+        }
+        return String(array, 0, slow)
+    }
+}

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

@@ -0,0 +1,28 @@
+1047\. Remove All Adjacent Duplicates In String
+
+Easy
+
+You are given a string `s` consisting of lowercase English letters. A **duplicate removal** consists of choosing two **adjacent** and **equal** letters and removing them.
+
+We repeatedly make **duplicate removals** on `s` until we no longer can.
+
+Return _the final string after all such duplicate removals have been made_. It can be proven that the answer is **unique**.
+
+**Example 1:**
+
+**Input:** s = "abbaca"
+
+**Output:** "ca"
+
+**Explanation:** For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move. The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+
+**Example 2:**
+
+**Input:** s = "azxxzy"
+
+**Output:** "ay"
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

src/main/kotlin/g1001_1100/s1048_longest_string_chain/Solution.kt

@@ -0,0 +1,57 @@
+package g1001_1100.s1048_longest_string_chain
+
+// #Medium #Array #String #Hash_Table #Dynamic_Programming #Two_Pointers
+// #2023_05_28_Time_273_ms_(75.00%)_Space_46.5_MB_(50.00%)
+
+class Solution {
+    fun longestStrChain(words: Array<String>): Int {
+        val lenStr = arrayOfNulls<MutableList<String>?>(20)
+        for (word in words) {
+            val len = word.length
+            if (lenStr[len] == null) {
+                lenStr[len] = ArrayList()
+            }
+            lenStr[len]!!.add(word)
+        }
+        val longest: MutableMap<String?, Int?> = HashMap()
+        var max = 0
+        for (s in words) {
+            max = findLongest(s, lenStr, longest).coerceAtLeast(max)
+        }
+        return max
+    }
+
+    private fun findLongest(
+        word: String,
+        lenStr: Array<MutableList<String>?>,
+        longest: MutableMap<String?, Int?>
+    ): Int {
+        if (longest.containsKey(word)) {
+            return longest[word]!!
+        }
+        val len = word.length
+        val words: List<String>? = lenStr[len + 1]
+        if (words == null) {
+            longest[word] = 1
+            return 1
+        }
+        var max = 0
+        var i: Int
+        var j: Int
+        for (w in words) {
+            i = 0
+            j = 0
+            while (i < len && j - i <= 1) {
+                if (word[i] == w[j++]) {
+                    ++i
+                }
+            }
+            if (j - i <= 1) {
+                max = findLongest(w, lenStr, longest).coerceAtLeast(max)
+            }
+        }
+        ++max
+        longest[word] = max
+        return max
+    }
+}

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

@@ -0,0 +1,43 @@
+1048\. Longest String Chain
+
+Medium
+
+You are given an array of `words` where each word consists of lowercase English letters.
+
+<code>word<sub>A</sub></code> is a **predecessor** of <code>word<sub>B</sub></code> if and only if we can insert **exactly one** letter anywhere in <code>word<sub>A</sub></code> **without changing the order of the other characters** to make it equal to <code>word<sub>B</sub></code>.
+
+*   For example, `"abc"` is a **predecessor** of <code>"ab<ins>a</ins>c"</code>, while `"cba"` is not a **predecessor** of `"bcad"`.
+
+A **word chain** is a sequence of words <code>[word<sub>1</sub>, word<sub>2</sub>, ..., word<sub>k</sub>]</code> with `k >= 1`, where <code>word<sub>1</sub></code> is a **predecessor** of <code>word<sub>2</sub></code>, <code>word<sub>2</sub></code> is a **predecessor** of <code>word<sub>3</sub></code>, and so on. A single word is trivially a **word chain** with `k == 1`.
+
+Return _the **length** of the **longest possible word chain** with words chosen from the given list of_ `words`.
+
+**Example 1:**
+
+**Input:** words = ["a","b","ba","bca","bda","bdca"]
+
+**Output:** 4
+
+**Explanation:**: One of the longest word chains is ["a","<ins>b</ins>a","b<ins>d</ins>a","bd<ins>c</ins>a"].
+
+**Example 2:**
+
+**Input:** words = ["xbc","pcxbcf","xb","cxbc","pcxbc"]
+
+**Output:** 5
+
+**Explanation:** All the words can be put in a word chain ["xb", "xb<ins>c</ins>", "<ins>c</ins>xbc", "<ins>p</ins>cxbc", "pcxbc<ins>f</ins>"].
+
+**Example 3:**
+
+**Input:** words = ["abcd","dbqca"]
+
+**Output:** 1
+
+**Explanation:** The trivial word chain ["abcd"] is one of the longest word chains. ["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 16`
+*   `words[i]` only consists of lowercase English letters.

src/test/kotlin/g1001_1100/s1045_customers_who_bought_all_products/MysqlTest.kt

@@ -0,0 +1,57 @@
+package g1001_1100.s1045_customers_who_bought_all_products
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.zapodot.junit.db.annotations.EmbeddedDatabase
+import org.zapodot.junit.db.annotations.EmbeddedDatabaseTest
+import org.zapodot.junit.db.common.CompatibilityMode
+import java.io.BufferedReader
+import java.io.FileNotFoundException
+import java.io.FileReader
+import java.sql.SQLException
+import java.util.stream.Collectors
+import javax.sql.DataSource
+
+@EmbeddedDatabaseTest(
+    compatibilityMode = CompatibilityMode.MySQL,
+    initialSqls = [
+        "CREATE TABLE Customer(customer_id INTEGER, product_key INTEGER); " +
+            " INSERT INTO Customer(customer_id, product_key) VALUES (1, 5); " +
+            " INSERT INTO Customer(customer_id, product_key) VALUES (2, 6); " +
+            " INSERT INTO Customer(customer_id, product_key) VALUES (3, 5); " +
+            " INSERT INTO Customer(customer_id, product_key) VALUES (3, 6); " +
+            " INSERT INTO Customer(customer_id, product_key) VALUES (1, 6); " +
+            "CREATE TABLE Product(product_key INTEGER); " +
+            " INSERT INTO Product(product_key) VALUES (5); " +
+            " INSERT INTO Product(product_key) VALUES (6); "
+    ]
+)
+internal class MysqlTest {
+    @Test
+    @Throws(SQLException::class, FileNotFoundException::class)
+    fun testScript(@EmbeddedDatabase dataSource: DataSource) {
+        dataSource.connection.use { connection ->
+            connection.createStatement().use { statement ->
+                statement.executeQuery(
+                    BufferedReader(
+                        FileReader(
+                            "src/main/kotlin/g1001_1100/" +
+                                "s1045_customers_who_bought_all_products" +
+                                "/script.sql"
+                        )
+                    )
+                        .lines()
+                        .collect(Collectors.joining("\n"))
+                        .replace("#.*?\\r?\\n".toRegex(), "")
+                ).use { resultSet ->
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(1))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(3))
+                    assertThat(resultSet.next(), equalTo(false))
+                }
+            }
+        }
+    }
+}