Added tasks 916, 917, 918, 919

Author: ThanhNIT

README.md

@@ -1311,6 +1311,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0053 |[Maximum Subarray](src.save/main/kotlin/g0001_0100/s0053_maximum_subarray/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Divide_and_Conquer | 662 | 82.48
+| 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 | 339 | 86.96
 
 #### Day 6
 
@@ -1729,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
+| 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
+| 0916 |[Word Subsets](src/main/kotlin/g0901_1000/s0916_word_subsets/Solution.kt)| Medium | Array, String, Hash_Table | 397 | 88.89
 | 0915 |[Partition Array into Disjoint Intervals](src/main/kotlin/g0901_1000/s0915_partition_array_into_disjoint_intervals/Solution.kt)| Medium | Array | 510 | 76.92
 | 0914 |[X of a Kind in a Deck of Cards](src/main/kotlin/g0901_1000/s0914_x_of_a_kind_in_a_deck_of_cards/Solution.kt)| Easy | Array, Hash_Table, Math, Counting, Number_Theory | 238 | 70.00
 | 0913 |[Cat and Mouse](src/main/kotlin/g0901_1000/s0913_cat_and_mouse/Solution.kt)| Hard | Dynamic_Programming, Math, Graph, Memoization, Topological_Sort, Game_Theory | 211 | 100.00

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

@@ -0,0 +1,37 @@
+package g0901_1000.s0916_word_subsets
+
+// #Medium #Array #String #Hash_Table #2023_04_16_Time_397_ms_(88.89%)_Space_45_MB_(55.56%)
+
+class Solution {
+    fun wordSubsets(words1: Array<String>, words2: Array<String>): List<String> {
+        val l1: MutableList<String> = ArrayList()
+        val target = IntArray(26)
+        for (s1 in words2) {
+            val temp = IntArray(26)
+            for (ch1 in s1.toCharArray()) {
+                temp[ch1.code - 'a'.code]++
+                target[ch1.code - 'a'.code] =
+                    target[ch1.code - 'a'.code].coerceAtLeast(temp[ch1.code - 'a'.code])
+            }
+        }
+        for (s1 in words1) {
+            val count = IntArray(26)
+            for (ch1 in s1.toCharArray()) {
+                count[ch1.code - 'a'.code]++
+            }
+            if (checkIt(target, count)) {
+                l1.add(s1)
+            }
+        }
+        return l1
+    }
+
+    private fun checkIt(target: IntArray, count: IntArray): Boolean {
+        for (i in 0..25) {
+            if (count[i] < target[i]) {
+                return false
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,32 @@
+916\. Word Subsets
+
+Medium
+
+You are given two string arrays `words1` and `words2`.
+
+A string `b` is a **subset** of string `a` if every letter in `b` occurs in `a` including multiplicity.
+
+*   For example, `"wrr"` is a subset of `"warrior"` but is not a subset of `"world"`.
+
+A string `a` from `words1` is **universal** if for every string `b` in `words2`, `b` is a subset of `a`.
+
+Return an array of all the **universal** strings in `words1`. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["e","o"]
+
+**Output:** ["facebook","google","leetcode"]
+
+**Example 2:**
+
+**Input:** words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["l","e"]
+
+**Output:** ["apple","google","leetcode"]
+
+**Constraints:**
+
+*   <code>1 <= words1.length, words2.length <= 10<sup>4</sup></code>
+*   `1 <= words1[i].length, words2[i].length <= 10`
+*   `words1[i]` and `words2[i]` consist only of lowercase English letters.
+*   All the strings of `words1` are **unique**.

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

@@ -0,0 +1,26 @@
+package g0901_1000.s0917_reverse_only_letters
+
+// #Easy #String #Two_Pointers #2023_04_16_Time_126_ms_(100.00%)_Space_33.6_MB_(94.44%)
+
+class Solution {
+    fun reverseOnlyLetters(s: String): String {
+        val array = s.toCharArray()
+        var i = 0
+        var j = array.size - 1
+        while (i < j) {
+            if (Character.isLetter(array[i]) && Character.isLetter(array[j])) {
+                val temp = array[i]
+                array[i++] = array[j]
+                array[j--] = temp
+            } else if (Character.isLetter(array[i])) {
+                j--
+            } else if (Character.isLetter(array[j])) {
+                i++
+            } else {
+                i++
+                j--
+            }
+        }
+        return String(array)
+    }
+}

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

@@ -0,0 +1,34 @@
+917\. Reverse Only Letters
+
+Easy
+
+Given a string `s`, reverse the string according to the following rules:
+
+*   All the characters that are not English letters remain in the same position.
+*   All the English letters (lowercase or uppercase) should be reversed.
+
+Return `s` _after reversing it_.
+
+**Example 1:**
+
+**Input:** s = "ab-cd"
+
+**Output:** "dc-ba"
+
+**Example 2:**
+
+**Input:** s = "a-bC-dEf-ghIj"
+
+**Output:** "j-Ih-gfE-dCba"
+
+**Example 3:**
+
+**Input:** s = "Test1ng-Leet=code-Q!"
+
+**Output:** "Qedo1ct-eeLg=ntse-T!"
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists of characters with ASCII values in the range `[33, 122]`.
+*   `s` does not contain `'\"'` or `'\\'`.

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

@@ -0,0 +1,33 @@
+package g0901_1000.s0918_maximum_sum_circular_subarray
+
+// #Medium #Array #Dynamic_Programming #Divide_and_Conquer #Queue #Monotonic_Queue
+// #Dynamic_Programming_I_Day_5 #2023_04_16_Time_339_ms_(86.96%)_Space_46.4_MB_(56.52%)
+
+class Solution {
+    private fun kadane(nums: IntArray, sign: Int): Int {
+        var currSum = Int.MIN_VALUE
+        var maxSum = Int.MIN_VALUE
+        for (i in nums) {
+            currSum = sign * i + currSum.coerceAtLeast(0)
+            maxSum = maxSum.coerceAtLeast(currSum)
+        }
+        return maxSum
+    }
+
+    fun maxSubarraySumCircular(nums: IntArray): Int {
+        if (nums.size == 1) {
+            return nums[0]
+        }
+        var sumOfArray = 0
+        for (i in nums) {
+            sumOfArray += i
+        }
+        val maxSumSubarray = kadane(nums, 1)
+        val minSumSubarray = kadane(nums, -1) * -1
+        return if (sumOfArray == minSumSubarray) {
+            maxSumSubarray
+        } else {
+            maxSumSubarray.coerceAtLeast(sumOfArray - minSumSubarray)
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+918\. Maximum Sum Circular Subarray
+
+Medium
+
+Given a **circular integer array** `nums` of length `n`, return _the maximum possible sum of a non-empty **subarray** of_ `nums`.
+
+A **circular array** means the end of the array connects to the beginning of the array. Formally, the next element of `nums[i]` is `nums[(i + 1) % n]` and the previous element of `nums[i]` is `nums[(i - 1 + n) % n]`.
+
+A **subarray** may only include each element of the fixed buffer `nums` at most once. Formally, for a subarray `nums[i], nums[i + 1], ..., nums[j]`, there does not exist `i <= k1`, `k2 <= j` with `k1 % n == k2 % n`.
+
+**Example 1:**
+
+**Input:** nums = [1,-2,3,-2]
+
+**Output:** 3
+
+**Explanation:** Subarray [3] has maximum sum 3.
+
+**Example 2:**
+
+**Input:** nums = [5,-3,5]
+
+**Output:** 10
+
+**Explanation:** Subarray [5,5] has maximum sum 5 + 5 = 10.
+
+**Example 3:**
+
+**Input:** nums = [-3,-2,-3]
+
+**Output:** -2
+
+**Explanation:** Subarray [-2] has maximum sum -2.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 3 * 10<sup>4</sup></code>
+*   <code>-3 * 10<sup>4</sup> <= nums[i] <= 3 * 10<sup>4</sup></code>

src/main/kotlin/g0901_1000/s0919_complete_binary_tree_inserter/CBTInserter.kt

@@ -0,0 +1,83 @@
+package g0901_1000.s0919_complete_binary_tree_inserter
+
+// #Medium #Breadth_First_Search #Tree #Binary_Tree #Design
+// #2023_04_16_Time_225_ms_(100.00%)_Space_37_MB_(100.00%)
+
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+import java.util.Queue
+
+/*
+ * 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 CBTInserter(root: TreeNode?) {
+    private val q: Queue<TreeNode>
+    private val head: TreeNode
+
+    init {
+        q = LinkedList()
+        head = root!!
+        addToQueue()
+    }
+
+    private fun addToQueue() {
+        val hlq: Queue<TreeNode> = LinkedList()
+        hlq.add(head)
+        while (!hlq.isEmpty()) {
+            var size = hlq.size
+            while (size-- > 0) {
+                val poll: TreeNode = hlq.poll()
+                q.add(poll)
+                if (poll.left != null) {
+                    hlq.add(poll.left)
+                }
+                if (poll.right != null) {
+                    hlq.add(poll.right)
+                }
+            }
+        }
+    }
+
+    fun insert(`val`: Int): Int {
+        val nn = TreeNode(`val`)
+        deleteFullNode()
+        val peek: TreeNode = q.peek()
+        if (peek.left == null) {
+            peek.left = nn
+        } else {
+            peek.right = nn
+        }
+        q.add(nn)
+        return peek.`val`
+    }
+
+    private fun deleteFullNode() {
+        while (!q.isEmpty()) {
+            val peek: TreeNode = q.peek()
+            if (peek.left != null && peek.right != null) {
+                q.poll()
+            } else {
+                break
+            }
+        }
+    }
+
+    // get_root()
+    fun getRoot(): TreeNode {
+        return head
+    }
+}
+
+/*
+ * Your CBTInserter object will be instantiated and called as such:
+ * var obj = CBTInserter(root)
+ * var param_1 = obj.insert(`val`)
+ * var param_2 = obj.get_root()
+ */

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

@@ -0,0 +1,36 @@
+919\. Complete Binary Tree Inserter
+
+Medium
+
+A **complete binary tree** is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.
+
+Design an algorithm to insert a new node to a complete binary tree keeping it complete after the insertion.
+
+Implement the `CBTInserter` class:
+
+*   `CBTInserter(TreeNode root)` Initializes the data structure with the `root` of the complete binary tree.
+*   `int insert(int v)` Inserts a `TreeNode` into the tree with value `Node.val == val` so that the tree remains complete, and returns the value of the parent of the inserted `TreeNode`.
+*   `TreeNode get_root()` Returns the root node of the tree.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/08/03/lc-treeinsert.jpg)
+
+**Input** ["CBTInserter", "insert", "insert", "get\_root"] [[[1, 2]], [3], [4], []]
+
+**Output:** [null, 1, 2, [1, 2, 3, 4]]
+
+**Explanation:**
+
+    CBTInserter cBTInserter = new CBTInserter([1, 2]); 
+    cBTInserter.insert(3); // return 1 
+    cBTInserter.insert(4); // return 2 
+    cBTInserter.get\_root(); // return [1, 2, 3, 4]
+
+**Constraints:**
+
+*   The number of nodes in the tree will be in the range `[1, 1000]`.
+*   `0 <= Node.val <= 5000`
+*   `root` is a complete binary tree.
+*   `0 <= val <= 5000`
+*   At most <code>10<sup>4</sup></code> calls will be made to `insert` and `get_root`.

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

@@ -0,0 +1,25 @@
+package g0901_1000.s0916_word_subsets
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun wordSubsets() {
+        assertThat(
+            Solution()
+                .wordSubsets(arrayOf("amazon", "apple", "facebook", "google", "leetcode"), arrayOf("e", "o")),
+            equalTo(listOf("facebook", "google", "leetcode"))
+        )
+    }
+
+    @Test
+    fun wordSubsets2() {
+        assertThat(
+            Solution()
+                .wordSubsets(arrayOf("amazon", "apple", "facebook", "google", "leetcode"), arrayOf("l", "e")),
+            equalTo(listOf("apple", "google", "leetcode"))
+        )
+    }
+}