Added tasks 1021, 1022, 1023, 1024

Author: ThanhNIT

README.md

@@ -1750,6 +1750,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 1024 |[Video Stitching](src/main/kotlin/g1001_1100/s1024_video_stitching/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 141 | 100.00
+| 1023 |[Camelcase Matching](src/main/kotlin/g1001_1100/s1023_camelcase_matching/Solution.kt)| Medium | String, Two_Pointers, Trie, String_Matching | 149 | 60.00
+| 1022 |[Remove Outermost Parentheses](src/main/kotlin/g1001_1100/s1022_sum_of_root_to_leaf_binary_numbers/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 158 | 88.89
+| 1021 |[Remove Outermost Parentheses](src/main/kotlin/g1001_1100/s1021_remove_outermost_parentheses/Solution.kt)| Easy | String, Stack | 156 | 60.00
 | 1020 |[Number of Enclaves](src/main/kotlin/g1001_1100/s1020_number_of_enclaves/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Graph_Theory_I_Day_3_Matrix_Related_Problems | 369 | 76.26
 | 1019 |[Next Greater Node In Linked List](src/main/kotlin/g1001_1100/s1019_next_greater_node_in_linked_list/Solution.kt)| Medium | Array, Stack, Linked_List, Monotonic_Stack | 472 | 75.00
 | 1018 |[Binary Prefix Divisible By 5](src/main/kotlin/g1001_1100/s1018_binary_prefix_divisible_by_5/Solution.kt)| Easy | Array | 297 | 100.00

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

@@ -0,0 +1,29 @@
+package g1001_1100.s1021_remove_outermost_parentheses
+
+// #Easy #String #Stack #2023_05_22_Time_156_ms_(60.00%)_Space_37.3_MB_(40.00%)
+
+class Solution {
+    fun removeOuterParentheses(s: String): String {
+        val primitives: MutableList<String> = ArrayList()
+        var i = 1
+        while (i < s.length) {
+            val initialI = i - 1
+            var left = 1
+            while (i < s.length && left > 0) {
+                if (s[i] == '(') {
+                    left++
+                } else {
+                    left--
+                }
+                i++
+            }
+            primitives.add(s.substring(initialI, i))
+            i++
+        }
+        val sb = StringBuilder()
+        for (primitive in primitives) {
+            sb.append(primitive, 1, primitive.length - 1)
+        }
+        return sb.toString()
+    }
+}

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

@@ -0,0 +1,43 @@
+1021\. Remove Outermost Parentheses
+
+Easy
+
+A valid parentheses string is either empty `""`, `"(" + A + ")"`, or `A + B`, where `A` and `B` are valid parentheses strings, and `+` represents string concatenation.
+
+*   For example, `""`, `"()"`, `"(())()"`, and `"(()(()))"` are all valid parentheses strings.
+
+A valid parentheses string `s` is primitive if it is nonempty, and there does not exist a way to split it into `s = A + B`, with `A` and `B` nonempty valid parentheses strings.
+
+Given a valid parentheses string `s`, consider its primitive decomposition: <code>s = P<sub>1</sub> + P<sub>2</sub> + ... + P<sub>k</sub></code>, where <code>P<sub>i</sub></code> are primitive valid parentheses strings.
+
+Return `s` _after removing the outermost parentheses of every primitive string in the primitive decomposition of_ `s`.
+
+**Example 1:**
+
+**Input:** s = "(()())(())"
+
+**Output:** "()()()"
+
+**Explanation:** The input string is "(()())(())", with primitive decomposition "(()())" + "(())". After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
+
+**Example 2:**
+
+**Input:** s = "(()())(())(()(()))"
+
+**Output:** "()()()()(())"
+
+**Explanation:** The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))". After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
+
+**Example 3:**
+
+**Input:** s = "()()"
+
+**Output:** ""
+
+**Explanation:** The input string is "()()", with primitive decomposition "()" + "()". After removing outer parentheses of each part, this is "" + "" = "".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s[i]` is either `'('` or `')'`.
+*   `s` is a valid parentheses string.

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

@@ -0,0 +1,47 @@
+package g1001_1100.s1022_sum_of_root_to_leaf_binary_numbers
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree
+// #2023_05_22_Time_158_ms_(88.89%)_Space_36.3_MB_(11.11%)
+
+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 sumRootToLeaf(root: TreeNode?): Int {
+        val paths: MutableList<List<Int>> = ArrayList()
+        dfs(root, paths, ArrayList())
+        var sum = 0
+        for (list in paths) {
+            var num = 0
+            for (i in list) {
+                num = (num shl 1) + i
+            }
+            sum += num
+        }
+        return sum
+    }
+
+    private fun dfs(root: TreeNode?, paths: MutableList<List<Int>>, path: MutableList<Int>) {
+        path.add(root!!.`val`)
+        if (root.left != null) {
+            dfs(root.left!!, paths, path)
+            path.removeAt(path.size - 1)
+        }
+        if (root.right != null) {
+            dfs(root.right!!, paths, path)
+            path.removeAt(path.size - 1)
+        }
+        if (root.left == null && root.right == null) {
+            paths.add(ArrayList(path))
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+1021\. Remove Outermost Parentheses
+
+Easy
+
+A valid parentheses string is either empty `""`, `"(" + A + ")"`, or `A + B`, where `A` and `B` are valid parentheses strings, and `+` represents string concatenation.
+
+*   For example, `""`, `"()"`, `"(())()"`, and `"(()(()))"` are all valid parentheses strings.
+
+A valid parentheses string `s` is primitive if it is nonempty, and there does not exist a way to split it into `s = A + B`, with `A` and `B` nonempty valid parentheses strings.
+
+Given a valid parentheses string `s`, consider its primitive decomposition: <code>s = P<sub>1</sub> + P<sub>2</sub> + ... + P<sub>k</sub></code>, where <code>P<sub>i</sub></code> are primitive valid parentheses strings.
+
+Return `s` _after removing the outermost parentheses of every primitive string in the primitive decomposition of_ `s`.
+
+**Example 1:**
+
+**Input:** s = "(()())(())"
+
+**Output:** "()()()"
+
+**Explanation:** The input string is "(()())(())", with primitive decomposition "(()())" + "(())". After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
+
+**Example 2:**
+
+**Input:** s = "(()())(())(()(()))"
+
+**Output:** "()()()()(())"
+
+**Explanation:** The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))". After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
+
+**Example 3:**
+
+**Input:** s = "()()"
+
+**Output:** ""
+
+**Explanation:** The input string is "()()", with primitive decomposition "()" + "()". After removing outer parentheses of each part, this is "" + "" = "".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s[i]` is either `'('` or `')'`.
+*   `s` is a valid parentheses string.

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

@@ -0,0 +1,40 @@
+package g1001_1100.s1023_camelcase_matching
+
+// #Medium #String #Two_Pointers #Trie #String_Matching
+// #2023_05_22_Time_149_ms_(60.00%)_Space_35.1_MB_(40.00%)
+
+import java.util.LinkedList
+
+class Solution {
+    fun camelMatch(queries: Array<String>, pattern: String): List<Boolean> {
+        val ret: MutableList<Boolean> = LinkedList()
+        for (query in queries) {
+            ret.add(check(query, pattern))
+        }
+        return ret
+    }
+
+    private fun check(query: String, pattern: String): Boolean {
+        val patternLen = pattern.length
+        var patternPos = 0
+        var uppercaseCount = 0
+        for (element in query) {
+            val c = element
+            if (Character.isUpperCase(c)) {
+                if (patternPos < patternLen && c != pattern[patternPos]) {
+                    return false
+                }
+                uppercaseCount++
+                if (uppercaseCount > patternLen) {
+                    return false
+                }
+                patternPos++
+            } else {
+                if (patternPos < patternLen && c == pattern[patternPos]) {
+                    patternPos++
+                }
+            }
+        }
+        return patternPos == patternLen
+    }
+}

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

@@ -0,0 +1,37 @@
+1023\. Camelcase Matching
+
+Medium
+
+Given an array of strings `queries` and a string `pattern`, return a boolean array `answer` where `answer[i]` is `true` if `queries[i]` matches `pattern`, and `false` otherwise.
+
+A query word `queries[i]` matches `pattern` if you can insert lowercase English letters pattern so that it equals the query. You may insert each character at any position and you may not insert any characters.
+
+**Example 1:**
+
+**Input:** queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FB"
+
+**Output:** [true,false,true,true,false]
+
+**Explanation:** "FooBar" can be generated like this "F" + "oo" + "B" + "ar". "FootBall" can be generated like this "F" + "oot" + "B" + "all". "FrameBuffer" can be generated like this "F" + "rame" + "B" + "uffer".
+
+**Example 2:**
+
+**Input:** queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBa"
+
+**Output:** [true,false,true,false,false]
+
+**Explanation:** "FooBar" can be generated like this "Fo" + "o" + "Ba" + "r". "FootBall" can be generated like this "Fo" + "ot" + "Ba" + "ll".
+
+**Example 3:**
+
+**Input:** queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBaT"
+
+**Output:** [false,true,false,false,false]
+
+**Explanation:** "FooBarTest" can be generated like this "Fo" + "o" + "Ba" + "r" + "T" + "est".
+
+**Constraints:**
+
+*   `1 <= pattern.length, queries.length <= 100`
+*   `1 <= queries[i].length <= 100`
+*   `queries[i]` and `pattern` consist of English letters.

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

@@ -0,0 +1,31 @@
+package g1001_1100.s1024_video_stitching
+
+// #Medium #Array #Dynamic_Programming #Greedy
+// #2023_05_22_Time_141_ms_(100.00%)_Space_34.8_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun videoStitching(clips: Array<IntArray>, time: Int): Int {
+        Arrays.sort(clips) { a: IntArray, b: IntArray ->
+            if (a[0] == b[0]
+            ) a[1] - b[1] else a[0] - b[0]
+        }
+        var count = 0
+        var covered = 0
+        var i = 0
+        var start = 0
+        while (start < time) {
+            while (i < clips.size && clips[i][0] <= start) {
+                covered = covered.coerceAtLeast(clips[i][1])
+                i++
+            }
+            if (start == covered) {
+                return -1
+            }
+            count++
+            start = covered
+        }
+        return count
+    }
+}

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

@@ -0,0 +1,49 @@
+1024\. Video Stitching
+
+Medium
+
+You are given a series of video clips from a sporting event that lasted `time` seconds. These video clips can be overlapping with each other and have varying lengths.
+
+Each video clip is described by an array `clips` where <code>clips[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> indicates that the ith clip started at <code>start<sub>i</sub></code> and ended at <code>end<sub>i</sub></code>.
+
+We can cut these clips into segments freely.
+
+*   For example, a clip `[0, 7]` can be cut into segments `[0, 1] + [1, 3] + [3, 7]`.
+
+Return _the minimum number of clips needed so that we can cut the clips into segments that cover the entire sporting event_ `[0, time]`. If the task is impossible, return `-1`.
+
+**Example 1:**
+
+**Input:** clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], time = 10
+
+**Output:** 3
+
+**Explanation:** We take the clips [0,2], [8,10], [1,9]; a total of 3 clips. 
+
+Then, we can reconstruct the sporting event as follows:
+
+We cut [1,9] into segments [1,2] + [2,8] + [8,9]. 
+
+Now we have segments [0,2] + [2,8] + [8,10] which cover the sporting event [0, 10].
+
+**Example 2:**
+
+**Input:** clips = [[0,1],[1,2]], time = 5
+
+**Output:** -1
+
+**Explanation:** We cannot cover [0,5] with only [0,1] and [1,2].
+
+**Example 3:**
+
+**Input:** clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], time = 9
+
+**Output:** 3
+
+**Explanation:** We can take clips [0,4], [4,7], and [6,9].
+
+**Constraints:**
+
+*   `1 <= clips.length <= 100`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 100</code>
+*   `1 <= time <= 100`

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

@@ -0,0 +1,25 @@
+package g1001_1100.s1021_remove_outermost_parentheses
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun removeOuterParentheses() {
+        assertThat(Solution().removeOuterParentheses("(()())(())"), equalTo("()()()"))
+    }
+
+    @Test
+    fun removeOuterParentheses2() {
+        assertThat(
+            Solution().removeOuterParentheses("(()())(())(()(()))"),
+            equalTo("()()()()(())")
+        )
+    }
+
+    @Test
+    fun removeOuterParentheses3() {
+        assertThat(Solution().removeOuterParentheses("()()"), equalTo(""))
+    }
+}