Added tasks 434, 435, 436, 440.

Author: ThanhNIT

README.md

@@ -1077,6 +1077,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0240 |[Search a 2D Matrix II](src.save/main/kotlin/g0201_0300/s0240_search_a_2d_matrix_ii/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search, Matrix, Divide_and_Conquer | 460 | 66.08
+| 0435 |[Non-overlapping Intervals](src/main/kotlin/g0401_0500/s0435_non_overlapping_intervals/Solution.kt)| Medium | Array, Dynamic_Programming, Sorting, Greedy | 1040 | 85.07
 
 #### Day 5 Array
 
@@ -1566,6 +1567,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0436 |[Find Right Interval](src/main/kotlin/g0401_0500/s0436_find_right_interval/Solution.kt)| Medium | Array, Sorting, Binary_Search | 333 | 100.00
 
 #### Day 12
 
@@ -1628,8 +1630,12 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
 | 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, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
+| 0440 |[K-th Smallest in Lexicographical Order](src/main/kotlin/g0401_0500/s0440_k_th_smallest_in_lexicographical_order/Solution.kt)| Hard | Trie | 149 | 100.00
 | 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, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
+| 0436 |[Find Right Interval](src/main/kotlin/g0401_0500/s0436_find_right_interval/Solution.kt)| Medium | Array, Sorting, Binary_Search, Binary_Search_II_Day_11 | 333 | 100.00
+| 0435 |[Non-overlapping Intervals](src/main/kotlin/g0401_0500/s0435_non_overlapping_intervals/Solution.kt)| Medium | Array, Dynamic_Programming, Sorting, Greedy, Data_Structure_II_Day_4_Array | 1040 | 85.07
+| 0434 |[Number of Segments in a String](src/main/kotlin/g0401_0500/s0434_number_of_segments_in_a_string/Solution.kt)| Easy | String | 167 | 80.00
 | 0433 |[Minimum Genetic Mutation](src/main/kotlin/g0401_0500/s0433_minimum_genetic_mutation/Solution.kt)| Medium | String, Hash_Table, Breadth_First_Search, Graph_Theory_I_Day_12_Breadth_First_Search | 204 | 82.08
 | 0432 |[All O\`one Data Structure](src/main/kotlin/g0401_0500/s0432_all_oone_data_structure/AllOne.kt)| Hard | Hash_Table, Design, Linked_List, Doubly_Linked_List | 1200 | 100.00
 | 0430 |[Flatten a Multilevel Doubly Linked List](src/main/kotlin/g0401_0500/s0430_flatten_a_multilevel_doubly_linked_list/Solution.kt)| Medium | Depth_First_Search, Linked_List, Doubly_Linked_List | 194 | 97.44

src/main/kotlin/g0401_0500/s0434_number_of_segments_in_a_string/Solution.kt

@@ -0,0 +1,21 @@
+package g0401_0500.s0434_number_of_segments_in_a_string
+
+// #Easy #String #2022_12_22_Time_167_ms_(80.00%)_Space_35.4_MB_(46.67%)
+
+class Solution {
+    fun countSegments(s: String): Int {
+        var s = s
+        s = s.trim { it <= ' ' }
+        if (s.length == 0) {
+            return 0
+        }
+        val splitted = s.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        var result = 0
+        for (value in splitted) {
+            if (value.length > 0) {
+                result++
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g0401_0500/s0434_number_of_segments_in_a_string/readme.md

@@ -0,0 +1,27 @@
+434\. Number of Segments in a String
+
+Easy
+
+Given a string `s`, return _the number of segments in the string_.
+
+A **segment** is defined to be a contiguous sequence of **non-space characters**.
+
+**Example 1:**
+
+**Input:** s = "Hello, my name is John"
+
+**Output:** 5
+
+**Explanation:** The five segments are ["Hello,", "my", "name", "is", "John"]
+
+**Example 2:**
+
+**Input:** s = "Hello"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `0 <= s.length <= 300`
+*   `s` consists of lowercase and uppercase English letters, digits, or one of the following characters `"!@#$%^&*()_+-=',.:"`.
+*   The only space character in `s` is `' '`.

src/main/kotlin/g0401_0500/s0435_non_overlapping_intervals/Solution.kt

@@ -0,0 +1,26 @@
+package g0401_0500.s0435_non_overlapping_intervals
+
+// #Medium #Array #Dynamic_Programming #Sorting #Greedy #Data_Structure_II_Day_4_Array
+// #2022_12_22_Time_1040_ms_(85.07%)_Space_117.9_MB_(82.09%)
+
+import java.util.Arrays
+
+class Solution {
+    fun eraseOverlapIntervals(intervals: Array<IntArray>): Int {
+        Arrays.sort(intervals) { a: IntArray, b: IntArray ->
+            if (a[0] != b[0]
+            ) a[0] - b[0] else a[1] - b[1]
+        }
+        var erasures = 0
+        var end = intervals[0][1]
+        for (i in 1 until intervals.size) {
+            end = if (intervals[i][0] < end) {
+                erasures++
+                Math.min(end, intervals[i][1])
+            } else {
+                intervals[i][1]
+            }
+        }
+        return erasures
+    }
+}

src/main/kotlin/g0401_0500/s0435_non_overlapping_intervals/readme.md

@@ -0,0 +1,35 @@
+435\. Non-overlapping Intervals
+
+Medium
+
+Given an array of intervals `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, return _the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping_.
+
+**Example 1:**
+
+**Input:** intervals = [[1,2],[2,3],[3,4],[1,3]]
+
+**Output:** 1
+
+**Explanation:** [1,3] can be removed and the rest of the intervals are non-overlapping.
+
+**Example 2:**
+
+**Input:** intervals = [[1,2],[1,2],[1,2]]
+
+**Output:** 2
+
+**Explanation:** You need to remove two [1,2] to make the rest of the intervals non-overlapping.
+
+**Example 3:**
+
+**Input:** intervals = [[1,2],[2,3]]
+
+**Output:** 0
+
+**Explanation:** You don't need to remove any of the intervals since they're already non-overlapping.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>5</sup></code>
+*   `intervals[i].length == 2`
+*   <code>-5 * 10<sup>4</sup> <= start<sub>i</sub> < end<sub>i</sub> <= 5 * 10<sup>4</sup></code>

src/main/kotlin/g0401_0500/s0436_find_right_interval/Solution.kt

@@ -0,0 +1,38 @@
+package g0401_0500.s0436_find_right_interval
+
+// #Medium #Array #Sorting #Binary_Search #Binary_Search_II_Day_11
+// #2022_12_22_Time_333_ms_(100.00%)_Space_49.7_MB_(90.00%)
+
+import java.util.function.Function
+
+class Solution {
+    private fun findminmax(num: Array<IntArray>): IntArray {
+        var min = num[0][0]
+        var max = num[0][0]
+        for (i in 1 until num.size) {
+            min = Math.min(min, num[i][0])
+            max = Math.max(max, num[i][0])
+        }
+        return intArrayOf(min, max)
+    }
+
+    fun findRightInterval(intervals: Array<IntArray>): IntArray {
+        if (intervals.size <= 1) {
+            return intArrayOf(-1)
+        }
+        val n = intervals.size
+        val result = IntArray(n)
+        val map: MutableMap<Int, Int?> = HashMap()
+        for (i in 0 until n) {
+            map[intervals[i][0]] = i
+        }
+        val minmax = findminmax(intervals)
+        for (i in minmax[1] - 1 downTo minmax[0] + 1) {
+            map.computeIfAbsent(i, Function { k: Int -> map[k + 1] })
+        }
+        for (i in 0 until n) {
+            result[i] = map.getOrDefault(intervals[i][1], -1)!!
+        }
+        return result
+    }
+}

src/main/kotlin/g0401_0500/s0436_find_right_interval/readme.md

@@ -0,0 +1,44 @@
+436\. Find Right Interval
+
+Medium
+
+You are given an array of `intervals`, where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> and each <code>start<sub>i</sub></code> is **unique**.
+
+The **right interval** for an interval `i` is an interval `j` such that <code>start<sub>j</sub> >= end<sub>i</sub></code> and <code>start<sub>j</sub></code> is **minimized**. Note that `i` may equal `j`.
+
+Return _an array of **right interval** indices for each interval `i`_. If no **right interval** exists for interval `i`, then put `-1` at index `i`.
+
+**Example 1:**
+
+**Input:** intervals = [[1,2]]
+
+**Output:** [-1]
+
+**Explanation:** There is only one interval in the collection, so it outputs -1.
+
+**Example 2:**
+
+**Input:** intervals = [[3,4],[2,3],[1,2]]
+
+**Output:** [-1,0,1]
+
+**Explanation:** There is no right interval for [3,4]. 
+
+The right interval for [2,3] is [3,4] since start<sub>0</sub> = 3 is the smallest start that is >= end<sub>1</sub> = 3. 
+
+The right interval for [1,2] is [2,3] since start<sub>1</sub> = 2 is the smallest start that is >= end<sub>2</sub> = 2.
+
+**Example 3:**
+
+**Input:** intervals = [[1,4],[2,3],[3,4]]
+
+**Output:** [-1,2,-1]
+
+**Explanation:** There is no right interval for [1,4] and [3,4]. The right interval for [2,3] is [3,4] since start<sub>2</sub> = 3 is the smallest start that is >= end<sub>1</sub> = 3.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 2 * 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>-10<sup>6</sup> <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>6</sup></code>
+*   The start point of each interval is **unique**.

src/main/kotlin/g0401_0500/s0440_k_th_smallest_in_lexicographical_order/Solution.kt

@@ -0,0 +1,35 @@
+package g0401_0500.s0440_k_th_smallest_in_lexicographical_order
+
+// #Hard #Trie #2022_12_22_Time_149_ms_(100.00%)_Space_32.5_MB_(100.00%)
+
+class Solution {
+    fun findKthNumber(n: Int, k: Int): Int {
+        var k = k
+        var curr = 1
+        k = k - 1
+        while (k > 0) {
+            val steps = calSteps(n, curr.toLong(), curr + 1L)
+            if (steps <= k) {
+                curr += 1
+                k -= steps
+            } else {
+                curr *= 10
+                k -= 1
+            }
+        }
+        return curr
+    }
+
+    // use long in case of overflow
+    private fun calSteps(n: Int, n1: Long, n2: Long): Int {
+        var n1 = n1
+        var n2 = n2
+        var steps: Long = 0
+        while (n1 <= n) {
+            steps += Math.min(n + 1L, n2) - n1
+            n1 *= 10
+            n2 *= 10
+        }
+        return steps.toInt()
+    }
+}

src/main/kotlin/g0401_0500/s0440_k_th_smallest_in_lexicographical_order/readme.md

@@ -0,0 +1,23 @@
+440\. K-th Smallest in Lexicographical Order
+
+Hard
+
+Given two integers `n` and `k`, return _the_ <code>k<sup>th</sup></code> _lexicographically smallest integer in the range_ `[1, n]`.
+
+**Example 1:**
+
+**Input:** n = 13, k = 2
+
+**Output:** 10
+
+**Explanation:** The lexicographical order is [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9], so the second smallest number is 10.
+
+**Example 2:**
+
+**Input:** n = 1, k = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= k <= n <= 10<sup>9</sup></code>

src/test/kotlin/g0401_0500/s0434_number_of_segments_in_a_string/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0401_0500.s0434_number_of_segments_in_a_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun countSegments() {
+        assertThat(Solution().countSegments("Hello, my name is John"), equalTo(5))
+    }
+
+    @Test
+    fun countSegments2() {
+        assertThat(Solution().countSegments("Hello"), equalTo(1))
+    }
+}