Added tasks 1049, 1050, 1051, 1052

Author: ThanhNIT

README.md

@@ -1747,6 +1747,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0182 |[Duplicate Emails](src/main/kotlin/g0101_0200/s0182_duplicate_emails/script.sql)| 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/script.sql)| Easy | LeetCode_Curated_SQL_70, Database | 629 | 81.02
 
 ## Algorithms
 
@@ -1780,6 +1781,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
+| 1052 |[Grumpy Bookstore Owner](src/main/kotlin/g1001_1100/s1052_grumpy_bookstore_owner/Solution.kt)| Medium | Array, Sliding_Window | 268 | 80.00
+| 1051 |[Height Checker](src/main/kotlin/g1001_1100/s1051_height_checker/Solution.kt)| Easy | Array, Sorting, Counting_Sort | 140 | 94.37
+| 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/script.sql)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_10_Where | 629 | 81.02
+| 1049 |[Last Stone Weight II](src/main/kotlin/g1001_1100/s1049_last_stone_weight_ii/Solution.kt)| Medium | Array, Dynamic_Programming | 150 | 100.00
 | 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

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

@@ -0,0 +1,23 @@
+package g1001_1100.s1049_last_stone_weight_ii
+
+// #Medium #Array #Dynamic_Programming #2023_05_29_Time_150_ms_(100.00%)_Space_35.5_MB_(100.00%)
+
+class Solution {
+    fun lastStoneWeightII(stones: IntArray): Int {
+        // dp[i][j] i is the index of stones, j is the current weight
+        // goal is to find max closest to half and use it to get the diff
+        // 0-1 knapsack problem
+        var sum = 0
+        for (stone in stones) {
+            sum += stone
+        }
+        val half = sum / 2
+        val dp = IntArray(half + 1)
+        for (cur in stones) {
+            for (j in half downTo cur) {
+                dp[j] = dp[j].coerceAtLeast(dp[j - cur] + cur)
+            }
+        }
+        return sum - dp[half] * 2
+    }
+}

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

@@ -0,0 +1,41 @@
+1049\. Last Stone Weight II
+
+Medium
+
+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 any two stones and smash them together. Suppose the 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 smallest possible weight of the left stone_. If there are no stones left, return `0`.
+
+**Example 1:**
+
+**Input:** stones = [2,7,4,1,8,1]
+
+**Output:** 1
+
+**Explanation:**
+
+We can combine 2 and 4 to get 2, so the array converts to [2,7,1,8,1] then, 
+
+we can combine 7 and 8 to get 1, so the array converts to [2,1,1,1] then, 
+
+we can combine 2 and 1 to get 1, so the array converts to [1,1,1] then, 
+
+we can combine 1 and 1 to get 0, so the array converts to [1], then that's the optimal value.
+
+**Example 2:**
+
+**Input:** stones = [31,26,33,21,40]
+
+**Output:** 5
+
+**Constraints:**
+
+*   `1 <= stones.length <= 30`
+*   `1 <= stones[i] <= 100`

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

@@ -0,0 +1,49 @@
+1050\. Actors and Directors Who Cooperated At Least Three Times
+
+Easy
+
+SQL Schema
+
+Table: `ActorDirector`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | actor_id    | int     |
+    | director_id | int     |
+    | timestamp   | int     |
+    +-------------+---------+
+    timestamp is the primary key column for this table. 
+
+Write a SQL query for a report that provides the pairs `(actor_id, director_id)` where the actor has cooperated with the director at least three times.
+
+Return the result table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:**
+
+    ActorDirector table:
+    +-------------+-------------+-------------+
+    | actor_id    | director_id | timestamp   |
+    +-------------+-------------+-------------+
+    | 1           | 1           | 0           |
+    | 1           | 1           | 1           |
+    | 1           | 1           | 2           |
+    | 1           | 2           | 3           |
+    | 1           | 2           | 4           |
+    | 2           | 1           | 5           |
+    | 2           | 1           | 6           |
+    +-------------+-------------+-------------+
+
+**Output:**
+
+    +-------------+-------------+
+    | actor_id    | director_id |
+    +-------------+-------------+
+    | 1           | 1           |
+    +-------------+-------------+
+
+**Explanation:** The only pair is (1, 1) where they cooperated exactly 3 times. 

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

@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+# #Easy #LeetCode_Curated_SQL_70 #Database #SQL_I_Day_10_Where
+# #2023_05_29_Time_629_ms_(81.02%)_Space_0B_(100.00%)
+SELECT actor_id, director_id
+FROM ActorDirector
+GROUP BY actor_id, director_id
+HAVING COUNT(*) > 2

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

@@ -0,0 +1,30 @@
+package g1001_1100.s1051_height_checker
+
+// #Easy #Array #Sorting #Counting_Sort #2023_05_29_Time_140_ms_(94.37%)_Space_35.3_MB_(77.46%)
+
+class Solution {
+    fun heightChecker(heights: IntArray): Int {
+        var heightDiff = 0
+        val count = IntArray(101)
+        val actualLine = IntArray(heights.size)
+        for (height in heights) {
+            count[height]++
+        }
+        var heightLength = 0
+        for (i in count.indices) {
+            if (count[i] > 0) {
+                for (j in 0 until count[i]) {
+                    actualLine[heightLength] = i
+                    heightLength++
+                }
+                count[i] = 0
+            }
+        }
+        for (i in heights.indices) {
+            if (actualLine[i] != heights[i]) {
+                heightDiff++
+            }
+        }
+        return heightDiff
+    }
+}

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

@@ -0,0 +1,56 @@
+1051\. Height Checker
+
+Easy
+
+A school is trying to take an annual photo of all the students. The students are asked to stand in a single file line in **non-decreasing order** by height. Let this ordering be represented by the integer array `expected` where `expected[i]` is the expected height of the <code>i<sup>th</sup></code> student in line.
+
+You are given an integer array `heights` representing the **current order** that the students are standing in. Each `heights[i]` is the height of the <code>i<sup>th</sup></code> student in line (**0-indexed**).
+
+Return _the **number of indices** where_ `heights[i] != expected[i]`.
+
+**Example 1:**
+
+**Input:** heights = [1,1,4,2,1,3]
+
+**Output:** 3
+
+**Explanation:**
+
+heights: [1,1,4,2,1,3]
+
+expected: [1,1,1,2,3,4]
+
+Indices 2, 4, and 5 do not match.
+
+**Example 2:**
+
+**Input:** heights = [5,1,2,3,4]
+
+**Output:** 5
+
+**Explanation:**
+
+heights: [5,1,2,3,4]
+
+expected: [1,2,3,4,5]
+
+All indices do not match.
+
+**Example 3:**
+
+**Input:** heights = [1,2,3,4,5]
+
+**Output:** 0
+
+**Explanation:**
+
+heights: [1,2,3,4,5]
+
+expected: [1,2,3,4,5]
+
+All indices match.
+
+**Constraints:**
+
+*   `1 <= heights.length <= 100`
+*   `1 <= heights[i] <= 100`

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

@@ -0,0 +1,37 @@
+package g1001_1100.s1052_grumpy_bookstore_owner
+
+// #Medium #Array #Sliding_Window #2023_05_29_Time_268_ms_(80.00%)_Space_64.6_MB_(60.00%)
+
+class Solution {
+    fun maxSatisfied(customers: IntArray, grumpy: IntArray, minutes: Int): Int {
+        // storing numbers of customers who faced grumpy owner till ith minute.
+        val grumpySum = IntArray(grumpy.size)
+        var ans = 0
+        if (grumpy[0] == 1) {
+            grumpySum[0] = customers[0]
+        } else {
+            ans += customers[0]
+        }
+        for (i in 1 until grumpy.size) {
+            if (grumpy[i] == 1) {
+                grumpySum[i] = grumpySum[i - 1] + customers[i]
+            } else {
+                grumpySum[i] = grumpySum[i - 1]
+                ans += customers[i]
+            }
+        }
+        // calculating max number of customers who faced grumpy owner in a window of size 'minutes'.
+        var max = 0
+        for (i in 0..customers.size - minutes) {
+            max = if (i == 0) {
+                max.coerceAtLeast(grumpySum[i + minutes - 1])
+            } else {
+                max.coerceAtLeast(grumpySum[i + minutes - 1] - grumpySum[i - 1])
+            }
+        }
+        // making the owner non-grumpy in that max window and adding the number of customers who do
+        // not face the grumpy customers.
+        ans += max
+        return ans
+    }
+}

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

@@ -0,0 +1,34 @@
+1052\. Grumpy Bookstore Owner
+
+Medium
+
+There is a bookstore owner that has a store open for `n` minutes. Every minute, some number of customers enter the store. You are given an integer array `customers` of length `n` where `customers[i]` is the number of the customer that enters the store at the start of the <code>i<sup>th</sup></code> minute and all those customers leave after the end of that minute.
+
+On some minutes, the bookstore owner is grumpy. You are given a binary array grumpy where `grumpy[i]` is `1` if the bookstore owner is grumpy during the <code>i<sup>th</sup></code> minute, and is `0` otherwise.
+
+When the bookstore owner is grumpy, the customers of that minute are not satisfied, otherwise, they are satisfied.
+
+The bookstore owner knows a secret technique to keep themselves not grumpy for `minutes` consecutive minutes, but can only use it once.
+
+Return _the maximum number of customers that can be satisfied throughout the day_.
+
+**Example 1:**
+
+**Input:** customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3
+
+**Output:** 16
+
+**Explanation:** The bookstore owner keeps themselves not grumpy for the last 3 minutes. The maximum number of customers that can be satisfied = 1 + 1 + 1 + 1 + 7 + 5 = 16.
+
+**Example 2:**
+
+**Input:** customers = [1], grumpy = [0], minutes = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == customers.length == grumpy.length`
+*   <code>1 <= minutes <= n <= 2 * 10<sup>4</sup></code>
+*   `0 <= customers[i] <= 1000`
+*   `grumpy[i]` is either `0` or `1`.

src/test/kotlin/g1001_1100/s1049_last_stone_weight_ii/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g1001_1100.s1049_last_stone_weight_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun lastStoneWeightII() {
+        assertThat(Solution().lastStoneWeightII(intArrayOf(2, 7, 4, 1, 8, 1)), equalTo(1))
+    }
+
+    @Test
+    fun lastStoneWeightII2() {
+        assertThat(Solution().lastStoneWeightII(intArrayOf(31, 26, 33, 21, 40)), equalTo(5))
+    }
+}