Added tasks 920, 921, 922, 923

Author: ThanhNIT

README.md

@@ -1730,6 +1730,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
+| 0923 |[3Sum With Multiplicity](src/main/kotlin/g0901_1000/s0923_3sum_with_multiplicity/Solution.kt)| Medium | Array, Hash_Table, Sorting, Two_Pointers, Counting | 190 | 100.00
+| 0922 |[Sort Array By Parity II](src/main/kotlin/g0901_1000/s0922_sort_array_by_parity_ii/Solution.kt)| Easy | Array, Sorting, Two_Pointers | 257 | 87.50
+| 0921 |[Minimum Add to Make Parentheses Valid](src/main/kotlin/g0901_1000/s0921_minimum_add_to_make_parentheses_valid/Solution.kt)| Medium | String, Greedy, Stack | 131 | 92.59
+| 0920 |[Number of Music Playlists](src/main/kotlin/g0901_1000/s0920_number_of_music_playlists/Solution.kt)| Hard | Dynamic_Programming, Math, Combinatorics | 136 | 100.00
 | 0919 |[Complete Binary Tree Inserter](src/main/kotlin/g0901_1000/s0919_complete_binary_tree_inserter/CBTInserter.kt)| Medium | Breadth_First_Search, Tree, Binary_Tree, Design | 225 | 100.00
 | 0918 |[Maximum Sum Circular Subarray](src/main/kotlin/g0901_1000/s0918_maximum_sum_circular_subarray/Solution.kt)| Medium | Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue, Dynamic_Programming_I_Day_5 | 339 | 86.96
 | 0917 |[Reverse Only Letters](src/main/kotlin/g0901_1000/s0917_reverse_only_letters/Solution.kt)| Easy | String, Two_Pointers | 126 | 100.00

src/main/kotlin/g0901_1000/s0920_number_of_music_playlists/Solution.kt

@@ -0,0 +1,36 @@
+package g0901_1000.s0920_number_of_music_playlists
+
+// #Hard #Dynamic_Programming #Math #Combinatorics
+// #2023_04_17_Time_136_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+class Solution {
+    fun numMusicPlaylists(n: Int, l: Int, k: Int): Int {
+        val dp = Array(l) { LongArray(n + 1) }
+        for (i in 0 until l) {
+            dp[i].fill(-1)
+        }
+        return helper(0, l, 0, n, k, dp).toInt()
+    }
+
+    private fun helper(songNumber: Int, l: Int, usedSong: Int, n: Int, k: Int, dp: Array<LongArray>): Long {
+        if (songNumber == l) {
+            return if (usedSong == n) 1 else 0
+        }
+        if (dp[songNumber][usedSong] != -1L) {
+            return dp[songNumber][usedSong]
+        }
+        val ans: Long = if (songNumber < k) {
+            (n - usedSong) * helper(songNumber + 1, l, usedSong + 1, n, k, dp)
+        } else if (usedSong == n) {
+            (usedSong - k) * helper(songNumber + 1, l, usedSong, n, k, dp)
+        } else {
+            (
+                (n - usedSong) * helper(songNumber + 1, l, usedSong + 1, n, k, dp) +
+                    (usedSong - k) * helper(songNumber + 1, l, usedSong, n, k, dp)
+                )
+        }
+        val mod = 1e9.toInt() + 7
+        dp[songNumber][usedSong] = ans % mod
+        return ans % mod
+    }
+}

src/main/kotlin/g0901_1000/s0920_number_of_music_playlists/readme.md

@@ -0,0 +1,38 @@
+920\. Number of Music Playlists
+
+Hard
+
+Your music player contains `n` different songs. You want to listen to `goal` songs (not necessarily different) during your trip. To avoid boredom, you will create a playlist so that:
+
+*   Every song is played **at least once**.
+*   A song can only be played again only if `k` other songs have been played.
+
+Given `n`, `goal`, and `k`, return _the number of possible playlists that you can create_. Since the answer can be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 3, goal = 3, k = 1
+
+**Output:** 6
+
+**Explanation:** There are 6 possible playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], and [3, 2, 1].
+
+**Example 2:**
+
+**Input:** n = 2, goal = 3, k = 0
+
+**Output:** 6
+
+**Explanation:** There are 6 possible playlists: [1, 1, 2], [1, 2, 1], [2, 1, 1], [2, 2, 1], [2, 1, 2], and [1, 2, 2].
+
+**Example 3:**
+
+**Input:** n = 2, goal = 3, k = 1
+
+**Output:** 2
+
+**Explanation:** There are 2 possible playlists: [1, 2, 1] and [2, 1, 2].
+
+**Constraints:**
+
+*   `0 <= k < n <= goal <= 100`

src/main/kotlin/g0901_1000/s0921_minimum_add_to_make_parentheses_valid/Solution.kt

@@ -0,0 +1,24 @@
+package g0901_1000.s0921_minimum_add_to_make_parentheses_valid
+
+// #Medium #String #Greedy #Stack #2023_04_17_Time_131_ms_(92.59%)_Space_34.3_MB_(14.81%)
+
+import java.util.Deque
+import java.util.LinkedList
+
+class Solution {
+    fun minAddToMakeValid(s: String): Int {
+        val stack: Deque<Char> = LinkedList()
+        for (c in s.toCharArray()) {
+            if (c == ')') {
+                if (!stack.isEmpty() && stack.peek() == '(') {
+                    stack.pop()
+                } else {
+                    stack.push(c)
+                }
+            } else {
+                stack.push(c)
+            }
+        }
+        return stack.size
+    }
+}

src/main/kotlin/g0901_1000/s0921_minimum_add_to_make_parentheses_valid/readme.md

@@ -0,0 +1,32 @@
+921\. Minimum Add to Make Parentheses Valid
+
+Medium
+
+A parentheses string is valid if and only if:
+
+*   It is the empty string,
+*   It can be written as `AB` (`A` concatenated with `B`), where `A` and `B` are valid strings, or
+*   It can be written as `(A)`, where `A` is a valid string.
+
+You are given a parentheses string `s`. In one move, you can insert a parenthesis at any position of the string.
+
+*   For example, if `s = "()))"`, you can insert an opening parenthesis to be <code>"(**(**)))"</code> or a closing parenthesis to be <code>"())**)**)"</code>.
+
+Return _the minimum number of moves required to make_ `s` _valid_.
+
+**Example 1:**
+
+**Input:** s = "())"
+
+**Output:** 1
+
+**Example 2:**
+
+**Input:** s = "((("
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s[i]` is either `'('` or `')'`.

src/main/kotlin/g0901_1000/s0922_sort_array_by_parity_ii/Solution.kt

@@ -0,0 +1,26 @@
+package g0901_1000.s0922_sort_array_by_parity_ii
+
+// #Easy #Array #Sorting #Two_Pointers #2023_04_17_Time_257_ms_(87.50%)_Space_39_MB_(87.50%)
+
+class Solution {
+    fun sortArrayByParityII(nums: IntArray): IntArray {
+        var i = 0
+        var j = 1
+        while (i < nums.size - 1 && j < nums.size) {
+            if (nums[i] % 2 != 0 && nums[j] % 2 == 0) {
+                val tmp = nums[i]
+                nums[i] = nums[j]
+                nums[j] = tmp
+                i += 2
+                j += 2
+            }
+            while (i < nums.size - 1 && nums[i] % 2 == 0) {
+                i += 2
+            }
+            while (j < nums.size && nums[j] % 2 != 0) {
+                j += 2
+            }
+        }
+        return nums
+    }
+}

src/main/kotlin/g0901_1000/s0922_sort_array_by_parity_ii/readme.md

@@ -0,0 +1,32 @@
+922\. Sort Array By Parity II
+
+Easy
+
+Given an array of integers `nums`, half of the integers in `nums` are **odd**, and the other half are **even**.
+
+Sort the array so that whenever `nums[i]` is odd, `i` is **odd**, and whenever `nums[i]` is even, `i` is **even**.
+
+Return _any answer array that satisfies this condition_.
+
+**Example 1:**
+
+**Input:** nums = [4,2,5,7]
+
+**Output:** [4,5,2,7]
+
+**Explanation:** [4,7,2,5], [2,5,4,7], [2,7,4,5] would also have been accepted.
+
+**Example 2:**
+
+**Input:** nums = [2,3]
+
+**Output:** [2,3]
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `nums.length` is even.
+*   Half of the integers in `nums` are even.
+*   `0 <= nums[i] <= 1000`
+
+**Follow Up:** Could you solve it in-place?

src/main/kotlin/g0901_1000/s0923_3sum_with_multiplicity/Solution.kt

@@ -0,0 +1,36 @@
+package g0901_1000.s0923_3sum_with_multiplicity
+
+// #Medium #Array #Hash_Table #Sorting #Two_Pointers #Counting
+// #2023_04_17_Time_190_ms_(100.00%)_Space_36.4_MB_(100.00%)
+
+class Solution {
+    fun threeSumMulti(arr: IntArray, target: Int): Int {
+        var answer = 0
+        val countRight = IntArray(MAX + 1)
+        for (num in arr) {
+            ++countRight[num]
+        }
+        val countLeft = IntArray(MAX + 1)
+        for (j in 0 until arr.size - 1) {
+            --countRight[arr[j]]
+            val remains = target - arr[j]
+            if (remains <= 2 * MAX) {
+                for (v in 0..remains.coerceAtMost(MAX)) {
+                    if (remains - v <= MAX) {
+                        val count = countRight[v] * countLeft[remains - v]
+                        if (count > 0) {
+                            answer = (answer + count) % MOD
+                        }
+                    }
+                }
+            }
+            ++countLeft[arr[j]]
+        }
+        return answer
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+        private const val MAX = 100
+    }
+}

src/main/kotlin/g0901_1000/s0923_3sum_with_multiplicity/readme.md

@@ -0,0 +1,41 @@
+923\. 3Sum With Multiplicity
+
+Medium
+
+Given an integer array `arr`, and an integer `target`, return the number of tuples `i, j, k` such that `i < j < k` and `arr[i] + arr[j] + arr[k] == target`.
+
+As the answer can be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** arr = [1,1,2,2,3,3,4,4,5,5], target = 8
+
+**Output:** 20
+
+**Explanation:**
+
+    Enumerating by the values (arr[i], arr[j], arr[k]): 
+    (1, 2, 5) occurs 8 times; 
+    (1, 3, 4) occurs 8 times; 
+    (2, 2, 4) occurs 2 times; 
+    (2, 3, 3) occurs 2 times.
+
+**Example 2:**
+
+**Input:** arr = [1,1,2,2,2,2], target = 5
+
+**Output:** 12
+
+**Explanation:**
+
+arr[i] = 1, arr[j] = arr[k] = 2 occurs 12 times:
+
+We choose one 1 from [1,1] in 2 ways,
+
+and two 2s from [2,2,2,2] in 6 ways.
+
+**Constraints:**
+
+*   `3 <= arr.length <= 3000`
+*   `0 <= arr[i] <= 100`
+*   `0 <= target <= 300`

src/test/kotlin/g0901_1000/s0920_number_of_music_playlists/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0901_1000.s0920_number_of_music_playlists
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun numMusicPlaylists() {
+        assertThat(Solution().numMusicPlaylists(3, 3, 1), equalTo(6))
+    }
+
+    @Test
+    fun numMusicPlaylists2() {
+        assertThat(Solution().numMusicPlaylists(2, 3, 0), equalTo(6))
+    }
+
+    @Test
+    fun numMusicPlaylists3() {
+        assertThat(Solution().numMusicPlaylists(2, 3, 1), equalTo(2))
+    }
+}