Added tasks 204, 205, 209, 210.

Author: ThanhNIT

README.md

@@ -124,6 +124,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0209 |[Minimum Size Subarray Sum](src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window | 315 | 96.73
 
 #### Day 2
 
@@ -652,7 +653,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
-| 0197 |[Rising Temperature](src/main/kotlin/g0101_0200/s0197_rising_temperature/script.sql)| |||
+| 0197 |[Rising Temperature](src/main/kotlin/g0101_0200/s0197_rising_temperature/script.sql)| Easy | Database | 394 | 94.15
 
 #### Day 7 Function
 
@@ -686,6 +687,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0205 |[Isomorphic Strings](src/main/kotlin/g0201_0300/s0205_isomorphic_strings/Solution.kt)| Easy | String, Hash_Table | 278 | 79.96
 
 #### Day 3 Linked List
 
@@ -837,6 +839,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0210 |[Course Schedule II](src/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 266 | 96.32
 
 #### Day 12 Dynamic Programming
 
@@ -1433,6 +1436,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window | 561 | 54.68
+| 0209 |[Minimum Size Subarray Sum](src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window | 315 | 96.73
 
 #### Day 6 Breadth First Search Depth First Search
 
@@ -1572,16 +1576,20 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 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, Data_Structure_I_Day_12_Tree, Level_2_Day_6_Tree, Udemy_Tree_Stack_Queue | 233 | 54.90
 | 0221 |[Maximal Square](src/main/kotlin/g0201_0300/s0221_maximal_square/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16 | 614 | 44.00
 | 0215 |[Kth Largest Element in an Array](src/main/kotlin/g0201_0300/s0215_kth_largest_element_in_an_array/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Heap_Priority_Queue, Divide_and_Conquer, Quickselect, Data_Structure_II_Day_20_Heap_Priority_Queue | 839 | 34.43
+| 0210 |[Course Schedule II](src/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Level_2_Day_11_Graph/BFS/DFS | 266 | 96.32
+| 0209 |[Minimum Size Subarray Sum](src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Binary_Search_II_Day_1 | 315 | 96.73
 | 0208 |[Implement Trie (Prefix Tree)](src/main/kotlin/g0201_0300/s0208_implement_trie_prefix_tree/Trie.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Design, Trie, Level_2_Day_16_Design, Udemy_Trie_and_Heap | 689 | 61.00
 | 0207 |[Course Schedule](src/main/kotlin/g0201_0300/s0207_course_schedule/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 416 | 40.10
 | 0206 |[Reverse Linked List](src/main/kotlin/g0201_0300/s0206_reverse_linked_list/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Linked_List, Recursion, Data_Structure_I_Day_8_Linked_List, Algorithm_I_Day_10_Recursion_Backtracking, Level_1_Day_3_Linked_List, Udemy_Linked_List | 279 | 45.78
+| 0205 |[Isomorphic Strings](src/main/kotlin/g0201_0300/s0205_isomorphic_strings/Solution.kt)| Easy | String, Hash_Table, Level_1_Day_2_String | 278 | 79.96
+| 0204 |[Count Primes](src/main/kotlin/g0201_0300/s0204_count_primes/Solution.kt)| Medium | Top_Interview_Questions, Array, Math, Enumeration, Number_Theory | 360 | 96.61
 | 0203 |[Remove Linked List Elements](src/main/kotlin/g0201_0300/s0203_remove_linked_list_elements/Solution.kt)| Easy | Linked_List, Recursion, Data_Structure_I_Day_7_Linked_List | 233 | 91.22
 | 0202 |[Happy Number](src/main/kotlin/g0201_0300/s0202_happy_number/Solution.kt)| Easy | Top_Interview_Questions, Hash_Table, Math, Two_Pointers, Algorithm_II_Day_21_Others, Programming_Skills_I_Day_4_Loop, Level_2_Day_1_Implementation/Simulation | 261 | 45.08
 | 0201 |[Bitwise AND of Numbers Range](src/main/kotlin/g0201_0300/s0201_bitwise_and_of_numbers_range/Solution.kt)| Medium | Bit_Manipulation, Algorithm_II_Day_19_Bit_Manipulation | 368 | 80.00
 | 0200 |[Number of Islands](src/main/kotlin/g0101_0200/s0200_number_of_islands/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_1_Matrix_Related_Problems, Level_1_Day_9_Graph/BFS/DFS, Udemy_Graph | 252 | 95.41
 | 0199 |[Binary Tree Right Side View](src/main/kotlin/g0101_0200/s0199_binary_tree_right_side_view/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_II_Day_16_Tree, Level_2_Day_15_Tree | 194 | 92.89
 | 0198 |[House Robber](src/main/kotlin/g0101_0200/s0198_house_robber/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Algorithm_I_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_3, Level_2_Day_12_Dynamic_Programming, Udemy_Dynamic_Programming | 156 | 92.24
-| 0197 |[Rising Temperature](src/main/kotlin/g0101_0200/s0197_rising_temperature/script.sql)| |||
+| 0197 |[Rising Temperature](src/main/kotlin/g0101_0200/s0197_rising_temperature/script.sql)| Easy | Database, SQL_I_Day_6_Union | 394 | 94.15
 | 0196 |[Delete Duplicate Emails](src/main/kotlin/g0101_0200/s0196_delete_duplicate_emails/script.sql)| Easy | Database, SQL_I_Day_2_Select_and_Order | 593 | 94.17
 | 0195 |[Tenth Line](src/main/kotlin/g0101_0200/s0195_tenth_line/script.sh)| Easy | Shell | 36 | 87.50
 | 0194 |[Transpose File](src/main/kotlin/g0101_0200/s0194_transpose_file/script.sh)| Medium | Shell | 477 | 28.60

src/main/kotlin/g0201_0300/s0204_count_primes/Solution.kt

@@ -0,0 +1,30 @@
+package g0201_0300.s0204_count_primes
+
+// #Medium #Top_Interview_Questions #Array #Math #Enumeration #Number_Theory
+// #2022_10_19_Time_360_ms_(96.61%)_Space_61.2_MB_(71.19%)
+
+class Solution {
+    fun countPrimes(n: Int): Int {
+        val isprime = BooleanArray(n)
+        var count = 0
+        run {
+            var i = 2
+            while (i * i <= n) {
+                if (!isprime[i]) {
+                    var j = i * 2
+                    while (j < n) {
+                        isprime[j] = true
+                        j += i
+                    }
+                }
+                i++
+            }
+        }
+        for (i in 2 until isprime.size) {
+            if (!isprime[i]) {
+                count++
+            }
+        }
+        return count
+    }
+}

src/main/kotlin/g0201_0300/s0204_count_primes/readme.md

@@ -0,0 +1,29 @@
+204\. Count Primes
+
+Medium
+
+Given an integer `n`, return _the number of prime numbers that are strictly less than_ `n`.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** 4
+
+**Explanation:** There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
+
+**Example 2:**
+
+**Input:** n = 0
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** n = 1
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>0 <= n <= 5 * 10<sup>6</sup></code>

src/main/kotlin/g0201_0300/s0205_isomorphic_strings/Solution.kt

@@ -0,0 +1,38 @@
+package g0201_0300.s0205_isomorphic_strings
+
+// #Easy #String #Hash_Table #Level_1_Day_2_String
+// #2022_10_20_Time_278_ms_(79.96%)_Space_37.7_MB_(72.52%)
+
+class Solution {
+    fun isIsomorphic(s: String, t: String): Boolean {
+        val map = IntArray(128)
+        val str = s.toCharArray()
+        val tar = t.toCharArray()
+        val n = str.size
+        for (i in 0 until n) {
+            if (map[tar[i].code] == 0) {
+                if (search(map, str[i].code, tar[i].code) != -1) {
+                    return false
+                }
+                map[tar[i].code] = str[i].code
+            } else {
+                if (map[tar[i].code] != str[i].code) {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+
+    private fun search(map: IntArray, tar: Int, skip: Int): Int {
+        for (i in 0..127) {
+            if (i == skip) {
+                continue
+            }
+            if (map[i] != 0 && map[i] == tar) {
+                return i
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g0201_0300/s0205_isomorphic_strings/readme.md

@@ -0,0 +1,33 @@
+205\. Isomorphic Strings
+
+Easy
+
+Given two strings `s` and `t`, _determine if they are isomorphic_.
+
+Two strings `s` and `t` are isomorphic if the characters in `s` can be replaced to get `t`.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.
+
+**Example 1:**
+
+**Input:** s = "egg", t = "add"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "foo", t = "bar"
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** s = "paper", t = "title"
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `t.length == s.length`
+*   `s` and `t` consist of any valid ascii character.

src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt

@@ -0,0 +1,25 @@
+package g0201_0300.s0209_minimum_size_subarray_sum
+
+// #Medium #Array #Binary_Search #Prefix_Sum #Sliding_Window #Algorithm_II_Day_5_Sliding_Window
+// #Binary_Search_II_Day_1 #2022_10_20_Time_315_ms_(96.73%)_Space_46.7_MB_(90.20%)
+
+class Solution {
+    fun minSubArrayLen(s: Int, nums: IntArray): Int {
+        var sum = 0
+        var start = 0
+        var minLength = Integer.MAX_VALUE
+        var end = 0
+        if (nums.size < 1) {
+            return 0
+        }
+        while (end < nums.size) {
+            sum += nums[end]
+            while (sum >= s) {
+                minLength = Math.min(minLength, end - start + 1)
+                sum -= nums[start++]
+            }
+            end++
+        }
+        return if (start > 0) minLength else 0
+    }
+}

src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/readme.md

@@ -0,0 +1,33 @@
+209\. Minimum Size Subarray Sum
+
+Medium
+
+Given an array of positive integers `nums` and a positive integer `target`, return the minimal length of a **contiguous subarray** <code>[nums<sub>l</sub>, nums<sub>l+1</sub>, ..., nums<sub>r-1</sub>, nums<sub>r</sub>]</code> of which the sum is greater than or equal to `target`. If there is no such subarray, return `0` instead.
+
+**Example 1:**
+
+**Input:** target = 7, nums = [2,3,1,2,4,3]
+
+**Output:** 2
+
+**Explanation:** The subarray [4,3] has the minimal length under the problem constraint.
+
+**Example 2:**
+
+**Input:** target = 4, nums = [1,4,4]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** target = 11, nums = [1,1,1,1,1,1,1,1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= target <= 10<sup>9</sup></code>
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution of which the time complexity is `O(n log(n))`.

src/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt

@@ -0,0 +1,46 @@
+package g0201_0300.s0210_course_schedule_ii
+
+// #Medium #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search #Graph
+// #Topological_Sort #Level_2_Day_11_Graph/BFS/DFS
+// #2022_10_20_Time_266_ms_(96.32%)_Space_45.9_MB_(92.65%)
+
+class Solution {
+    fun findOrder(numCourses: Int, prerequisites: Array<IntArray>): IntArray {
+        val indegrees = IntArray(numCourses) { 0 }
+        val graph = buildGraph(numCourses, prerequisites, indegrees)
+        val queue = ArrayDeque<Int>()
+        for ((idx, indegree) in indegrees.withIndex()) {
+            if (indegree == 0) {
+                queue.addLast(idx)
+            }
+        }
+        val ans = IntArray(numCourses) { 0 }
+        var idx = 0
+        while (queue.isNotEmpty()) {
+            val cur = queue.removeFirst()
+            ans[idx++] = cur
+            for (pre in graph[cur]) {
+                if (--indegrees[pre] == 0) {
+                    queue.addLast(pre)
+                }
+            }
+        }
+        if (idx < numCourses) {
+            return intArrayOf()
+        }
+        return ans
+    }
+
+    private fun buildGraph(
+        numCourses: Int,
+        prerequisites: Array<IntArray>,
+        indegrees: IntArray
+    ): List<List<Int>> {
+        val graph = List(numCourses) { mutableListOf<Int>() }
+        for ((cur, prev) in prerequisites) {
+            graph[prev].add(cur)
+            ++indegrees[cur]
+        }
+        return graph
+    }
+}

src/main/kotlin/g0201_0300/s0210_course_schedule_ii/readme.md

@@ -0,0 +1,40 @@
+210\. Course Schedule II
+
+Medium
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you **must** take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.
+
+*   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return _the ordering of courses you should take to finish all courses_. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
+
+**Example 1:**
+
+**Input:** numCourses = 2, prerequisites = [[1,0]]
+
+**Output:** [0,1]
+
+**Explanation:** There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].
+
+**Example 2:**
+
+**Input:** numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+
+**Output:** [0,2,1,3]
+
+**Explanation:** There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+
+**Example 3:**
+
+**Input:** numCourses = 1, prerequisites = []
+
+**Output:** [0]
+
+**Constraints:**
+
+*   `1 <= numCourses <= 2000`
+*   `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+*   `prerequisites[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   All the pairs <code>[a<sub>i</sub>, b<sub>i</sub>]</code> are **distinct**.

src/test/kotlin/g0201_0300/s0204_count_primes/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0201_0300.s0204_count_primes
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun countPrimes() {
+        assertThat(Solution().countPrimes(10), equalTo(4))
+    }
+
+    @Test
+    fun countPrimes2() {
+        assertThat(Solution().countPrimes(0), equalTo(0))
+    }
+
+    @Test
+    fun countPrimes3() {
+        assertThat(Solution().countPrimes(1), equalTo(0))
+    }
+}

src/test/kotlin/g0201_0300/s0205_isomorphic_strings/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0201_0300.s0205_isomorphic_strings
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isIsomorphic() {
+        assertThat(Solution().isIsomorphic("egg", "add"), equalTo(true))
+    }
+
+    @Test
+    fun isIsomorphic2() {
+        assertThat(Solution().isIsomorphic("foo", "bar"), equalTo(false))
+    }
+
+    @Test
+    fun isIsomorphic3() {
+        assertThat(Solution().isIsomorphic("paper", "title"), equalTo(true))
+    }
+}