Added tasks 936, 937, 938, 939

Author: ThanhNIT

README.md

@@ -492,6 +492,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | 0103 |[Binary Tree Zigzag Level Order Traversal](src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.kt)| Medium | Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 316 | 34.25
 | 0108 |[Convert Sorted Array to Binary Search Tree](src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.kt)| Easy | Top_Interview_Questions, Array, Tree, Binary_Tree, Binary_Search_Tree, Divide_and_Conquer | 334 | 35.39
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree | 307 | 43.93
+| 0938 |[Range Sum of BST](src/main/kotlin/g0901_1000/s0938_range_sum_of_bst/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 356 | 55.36
 | 0100 |[Same Tree](src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 208 | 72.24
 | 0226 |[Invert Binary Tree](src/main/kotlin/g0201_0300/s0226_invert_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 233 | 54.90
 | 0111 |[Minimum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0111_minimum_depth_of_binary_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 525 | 90.51
@@ -1732,6 +1733,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 0939 |[Minimum Area Rectangle](src/main/kotlin/g0901_1000/s0939_minimum_area_rectangle/Solution.kt)| Medium | Array, Hash_Table, Math, Sorting, Geometry | 461 | 100.00
+| 0938 |[Range Sum of BST](src/main/kotlin/g0901_1000/s0938_range_sum_of_bst/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Udemy_Tree_Stack_Queue | 356 | 55.36
+| 0937 |[Reorder Data in Log Files](src/main/kotlin/g0901_1000/s0937_reorder_data_in_log_files/Solution.kt)| Easy | Array, String, Sorting | 205 | 81.82
+| 0936 |[Stamping The Sequence](src/main/kotlin/g0901_1000/s0936_stamping_the_sequence/Solution.kt)| Hard | String, Greedy, Stack, Queue | 196 | 100.00
 | 0935 |[Knight Dialer](src/main/kotlin/g0901_1000/s0935_knight_dialer/Solution.kt)| Medium | Dynamic_Programming | 160 | 100.00
 | 0934 |[Shortest Bridge](src/main/kotlin/g0901_1000/s0934_shortest_bridge/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Graph_Theory_I_Day_6_Matrix_Related_Problems | 301 | 80.95
 | 0933 |[Number of Recent Calls](src/main/kotlin/g0901_1000/s0933_number_of_recent_calls/RecentCounter.kt)| Easy | Design, Queue, Data_Stream | 476 | 82.50

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

@@ -0,0 +1,56 @@
+package g0901_1000.s0936_stamping_the_sequence
+
+// #Hard #String #Greedy #Stack #Queue #2023_04_28_Time_196_ms_(100.00%)_Space_40.3_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun movesToStamp(stamp: String, target: String): IntArray {
+        val moves: MutableList<Int> = ArrayList()
+        val s = stamp.toCharArray()
+        val t = target.toCharArray()
+        var stars = 0
+        val visited = BooleanArray(target.length)
+        while (stars < target.length) {
+            var doneReplace = false
+            for (i in 0..target.length - stamp.length) {
+                if (!visited[i] && canReplace(t, i, s)) {
+                    stars = doReplace(t, i, s, stars)
+                    doneReplace = true
+                    visited[i] = true
+                    moves.add(i)
+                    if (stars == t.size) {
+                        break
+                    }
+                }
+            }
+            if (!doneReplace) {
+                return IntArray(0)
+            }
+        }
+        val result = IntArray(moves.size)
+        for (i in moves.indices) {
+            result[i] = moves[moves.size - i - 1]
+        }
+        return result
+    }
+
+    private fun canReplace(t: CharArray, i: Int, s: CharArray): Boolean {
+        for (j in s.indices) {
+            if (t[i + j] != '*' && t[i + j] != s[j]) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun doReplace(t: CharArray, i: Int, s: CharArray, stars: Int): Int {
+        var stars = stars
+        for (j in s.indices) {
+            if (t[i + j] != '*') {
+                t[i + j] = '*'
+                stars++
+            }
+        }
+        return stars
+    }
+}

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

@@ -0,0 +1,52 @@
+936\. Stamping The Sequence
+
+Hard
+
+You are given two strings `stamp` and `target`. Initially, there is a string `s` of length `target.length` with all `s[i] == '?'`.
+
+In one turn, you can place `stamp` over `s` and replace every letter in the `s` with the corresponding letter from `stamp`.
+
+*   For example, if `stamp = "abc"` and `target = "abcba"`, then `s` is `"?????"` initially. In one turn you can:
+
+    *   place `stamp` at index `0` of `s` to obtain `"abc??"`,
+    *   place `stamp` at index `1` of `s` to obtain `"?abc?"`, or
+    *   place `stamp` at index `2` of `s` to obtain `"??abc"`.
+
+    Note that `stamp` must be fully contained in the boundaries of `s` in order to stamp (i.e., you cannot place `stamp` at index `3` of `s`).
+
+We want to convert `s` to `target` using **at most** `10 * target.length` turns.
+
+Return _an array of the index of the left-most letter being stamped at each turn_. If we cannot obtain `target` from `s` within `10 * target.length` turns, return an empty array.
+
+**Example 1:**
+
+**Input:** stamp = "abc", target = "ababc"
+
+**Output:** [0,2]
+
+**Explanation:** Initially s = "?????". 
+
+- Place stamp at index 0 to get "abc??". 
+
+- Place stamp at index 2 to get "ababc".
+
+[1,0,2] would also be accepted as an answer, as well as some other answers.
+
+**Example 2:**
+
+**Input:** stamp = "abca", target = "aabcaca"
+
+**Output:** [3,0,1]
+
+**Explanation:** Initially s = "???????".
+
+- Place stamp at index 3 to get "???abca". 
+
+- Place stamp at index 0 to get "abcabca". 
+
+- Place stamp at index 1 to get "aabcaca".
+
+**Constraints:**
+
+*   `1 <= stamp.length <= target.length <= 1000`
+*   `stamp` and `target` consist of lowercase English letters.

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

@@ -0,0 +1,37 @@
+package g0901_1000.s0937_reorder_data_in_log_files
+
+// #Easy #Array #String #Sorting #2023_04_28_Time_205_ms_(81.82%)_Space_44_MB_(9.09%)
+
+import java.util.Collections
+
+class Solution {
+    fun reorderLogFiles(logs: Array<String>): Array<String?> {
+        val digi: MutableList<String> = ArrayList()
+        val word: MutableList<String> = ArrayList()
+        for (s in logs) {
+            if (Character.isDigit(s[s.length - 1])) digi.add(s) else word.add(s)
+        }
+        Collections.sort(
+            word,
+            Comparator { s1, s2 ->
+                val firstSpacePosition = s1.indexOf(" ")
+                val firstWord = s1.substring(firstSpacePosition, s1.length)
+                val secondSpacePosition = s2.indexOf(" ")
+                val secondWord = s2.substring(secondSpacePosition, s2.length)
+                if (firstWord.compareTo(secondWord) == 0) {
+                    val firstSpacePosition1 = s1.indexOf(" ")
+                    val firstWord1 = s1.substring(0, firstSpacePosition1)
+                    val secondSpacePosition1 = s2.indexOf(" ")
+                    val secondWord1 = s2.substring(0, secondSpacePosition1)
+                    return@Comparator firstWord1.compareTo(secondWord1)
+                }
+                firstWord.compareTo(secondWord)
+            }
+        )
+        val result = arrayOfNulls<String>(digi.size + word.size)
+        var `in` = 0
+        for (s in word) result[`in`++] = s
+        for (s in digi) result[`in`++] = s
+        return result
+    }
+}

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

@@ -0,0 +1,43 @@
+937\. Reorder Data in Log Files
+
+Medium
+
+You are given an array of `logs`. Each log is a space-delimited string of words, where the first word is the **identifier**.
+
+There are two types of logs:
+
+*   **Letter-logs**: All words (except the identifier) consist of lowercase English letters.
+*   **Digit-logs**: All words (except the identifier) consist of digits.
+
+Reorder these logs so that:
+
+1.  The **letter-logs** come before all **digit-logs**.
+2.  The **letter-logs** are sorted lexicographically by their contents. If their contents are the same, then sort them lexicographically by their identifiers.
+3.  The **digit-logs** maintain their relative ordering.
+
+Return _the final order of the logs_.
+
+**Example 1:**
+
+**Input:** logs = ["dig1 8 1 5 1","let1 art can","dig2 3 6","let2 own kit dig","let3 art zero"]
+
+**Output:** ["let1 art can","let3 art zero","let2 own kit dig","dig1 8 1 5 1","dig2 3 6"]
+
+**Explanation:** 
+
+The letter-log contents are all different, so their ordering is "art can", "art zero", "own kit dig". 
+
+The digit-logs have a relative order of "dig1 8 1 5 1", "dig2 3 6".
+
+**Example 2:**
+
+**Input:** logs = ["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
+
+**Output:** ["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]
+
+**Constraints:**
+
+*   `1 <= logs.length <= 100`
+*   `3 <= logs[i].length <= 100`
+*   All the tokens of `logs[i]` are separated by a **single** space.
+*   `logs[i]` is guaranteed to have an identifier and at least one word after the identifier.

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

@@ -0,0 +1,35 @@
+package g0901_1000.s0938_range_sum_of_bst
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree #Udemy_Tree_Stack_Queue
+// #2023_04_29_Time_356_ms_(55.36%)_Space_83.3_MB_(5.36%)
+
+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
+ * }
+ */
+internal class Solution {
+    fun rangeSumBST(root: TreeNode?, low: Int, high: Int): Int {
+        var ans = 0
+        if (root == null) return 0
+        if (root.`val` in low..high) {
+            ans += root.`val`
+        }
+        if (root.`val` in low..high) {
+            ans += rangeSumBST(root.left, low, high)
+            ans += rangeSumBST(root.right, low, high)
+        } else if (root.`val` >= low && root.`val` >= high) {
+            ans += rangeSumBST(root.left, low, high)
+        } else {
+            ans += rangeSumBST(root.right, low, high)
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,32 @@
+938\. Range Sum of BST
+
+Easy
+
+Given the `root` node of a binary search tree and two integers `low` and `high`, return _the sum of values of all nodes with a value in the **inclusive** range_ `[low, high]`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/bst1.jpg)
+
+**Input:** root = [10,5,15,3,7,null,18], low = 7, high = 15
+
+**Output:** 32
+
+**Explanation:** Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/bst2.jpg)
+
+**Input:** root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+
+**Output:** 23
+
+**Explanation:** Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 2 * 10<sup>4</sup>]</code>.
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   <code>1 <= low <= high <= 10<sup>5</sup></code>
+*   All `Node.val` are **unique**.

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

@@ -0,0 +1,43 @@
+package g0901_1000.s0939_minimum_area_rectangle
+
+// #Medium #Array #Hash_Table #Math #Sorting #Geometry
+// #2023_04_29_Time_461_ms_(100.00%)_Space_74.8_MB_(20.00%)
+
+import java.util.Arrays
+import kotlin.math.abs
+
+class Solution {
+    fun minAreaRect(points: Array<IntArray>): Int {
+        if (points.size < 4) {
+            return 0
+        }
+        val map: MutableMap<Int, MutableSet<Int>> = HashMap()
+        for (p in points) {
+            map.putIfAbsent(p[0], HashSet())
+            map[p[0]]!!.add(p[1])
+        }
+        Arrays.sort(
+            points
+        ) { a: IntArray, b: IntArray ->
+            if (a[0] == b[0]) Integer.compare(
+                a[1],
+                b[1]
+            ) else Integer.compare(a[0], b[0])
+        }
+        var min = Int.MAX_VALUE
+        for (i in 0 until points.size - 2) {
+            for (j in i + 1 until points.size - 1) {
+                val p1 = points[i]
+                val p2 = points[j]
+                val area = abs((p1[0] - p2[0]) * (p1[1] - p2[1]))
+                if (area >= min || area == 0) {
+                    continue
+                }
+                if (map[p1[0]]!!.contains(p2[1]) && map[p2[0]]!!.contains(p1[1])) {
+                    min = area
+                }
+            }
+        }
+        return if (min == Int.MAX_VALUE) 0 else min
+    }
+}

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

@@ -0,0 +1,30 @@
+939\. Minimum Area Rectangle
+
+Medium
+
+You are given an array of points in the **X-Y** plane `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>.
+
+Return _the minimum area of a rectangle formed from these points, with sides parallel to the X and Y axes_. If there is not any such rectangle, return `0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/08/03/rec1.JPG)
+
+**Input:** points = [[1,1],[1,3],[3,1],[3,3],[2,2]]
+
+**Output:** 4
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/08/03/rec2.JPG)
+
+**Input:** points = [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
+
+**Output:** 2
+
+**Constraints:**
+
+*   `1 <= points.length <= 500`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 4 * 10<sup>4</sup></code>
+*   All the given points are **unique**.

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

@@ -0,0 +1,28 @@
+package g0901_1000.s0936_stamping_the_sequence
+
+import com_github_leetcode.CommonUtils
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun movesToStamp() {
+        assertThat(
+            CommonUtils().compareArray(
+                Solution().movesToStamp("abc", "ababc"), intArrayOf(0, 2)
+            ),
+            equalTo(true)
+        )
+    }
+
+    @Test
+    fun movesToStamp2() {
+        assertThat(
+            CommonUtils().compareArray(
+                Solution().movesToStamp("abca", "aabcaca"), intArrayOf(3, 0, 1)
+            ),
+            equalTo(true)
+        )
+    }
+}