Added tasks 216, 217, 218, 219.

Author: ThanhNIT

README.md

@@ -419,6 +419,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting | 719 | 73.49
 
 #### Day 12 Class and Object
 
@@ -942,6 +943,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0121 |[Best Time to Buy and Sell Stock](src/main/kotlin/g0101_0200/s0121_best_time_to_buy_and_sell_stock/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming | 609 | 94.06
 | 0283 |[Move Zeroes](src/main/kotlin/g0201_0300/s0283_move_zeroes/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Two_Pointers | 516 | 79.07
 | 0001 |[Two Sum](src/main/kotlin/g0001_0100/s0001_two_sum/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 234 | 92.75
+| 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting | 719 | 73.49
 | 0058 |[Length of Last Word](src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt)| Easy | String | 243 | 63.33
 | 0122 |[Best Time to Buy and Sell Stock II](src/main/kotlin/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/Solution.kt)| Medium | Top_Interview_Questions, Array, Dynamic_Programming, Greedy | 370 | 16.98
 | 0080 |[Remove Duplicates from Sorted Array II](src/main/kotlin/g0001_0100/s0080_remove_duplicates_from_sorted_array_ii/Solution.kt)| Medium | Array, Two_Pointers | 357 | 44.78
@@ -1059,6 +1061,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 |-|-|-|-|-|-
 | 0022 |[Generate Parentheses](src/main/kotlin/g0001_0100/s0022_generate_parentheses/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming, Backtracking | 210 | 78.51
 | 0039 |[Combination Sum](src/main/kotlin/g0001_0100/s0039_combination_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Backtracking | 317 | 86.85
+| 0216 |[Combination Sum III](src/main/kotlin/g0201_0300/s0216_combination_sum_iii/Solution.kt)| Medium | Array, Backtracking | 175 | 90.91
 | 0078 |[Subsets](src/main/kotlin/g0001_0100/s0078_subsets/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Backtracking | 353 | 30.14
 | 0017 |[Letter Combinations of a Phone Number](src/main/kotlin/g0001_0100/s0017_letter_combinations_of_a_phone_number/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Backtracking | 262 | 73.59
 | 0046 |[Permutations](src/main/kotlin/g0001_0100/s0046_permutations/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Backtracking | 186 | 100.00
@@ -1084,6 +1087,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting | 719 | 73.49
 | 0053 |[Maximum Subarray](src/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
 
 #### Day 2 Array
@@ -1578,6 +1582,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0230 |[Kth Smallest Element in a BST](src/main/kotlin/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_II_Day_17_Tree, Level_2_Day_9_Binary_Search_Tree | 393 | 33.33
 | 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
+| 0219 |[Contains Duplicate II](src/main/kotlin/g0201_0300/s0219_contains_duplicate_ii/Solution.kt)| Easy | Array, Hash_Table, Sliding_Window | 813 | 80.46
+| 0218 |[The Skyline Problem](src/main/kotlin/g0201_0300/s0218_the_skyline_problem/Solution.kt)| Hard | Top_Interview_Questions, Array, Heap_Priority_Queue, Ordered_Set, Divide_and_Conquer, Segment_Tree, Binary_Indexed_Tree, Line_Sweep | 365 | 93.14
+| 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting, Data_Structure_I_Day_1_Array, Programming_Skills_I_Day_11_Containers_and_Libraries, Udemy_Arrays | 719 | 73.49
+| 0216 |[Combination Sum III](src/main/kotlin/g0201_0300/s0216_combination_sum_iii/Solution.kt)| Medium | Array, Backtracking, Udemy_Backtracking/Recursion | 175 | 90.91
 | 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
 | 0214 |[Shortest Palindrome](src/main/kotlin/g0201_0300/s0214_shortest_palindrome/Solution.kt)| Hard | String, Hash_Function, String_Matching, Rolling_Hash | 278 | 100.00
 | 0213 |[House Robber II](src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Algorithm_II_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_3, Udemy_Dynamic_Programming | 257 | 59.62

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

@@ -0,0 +1,30 @@
+package g0201_0300.s0216_combination_sum_iii
+
+// #Medium #Array #Backtracking #Udemy_Backtracking/Recursion
+// #2022_10_25_Time_175_ms_(90.91%)_Space_34.4_MB_(72.73%)
+
+class Solution {
+    fun combinationSum3(k: Int, n: Int): List<List<Int>> {
+        val a = MutableList(0) { MutableList(0) { 0 } }
+        comb(a, k, n, 1, MutableList<Int>(0) { 0 })
+        return a
+    }
+
+    fun comb(a: MutableList<MutableList<Int>>, k: Int, n: Int, index: Int, tmp: MutableList<Int>) {
+        if (n < 0) {
+            return
+        }
+        if (tmp.size > k) {
+            return
+        }
+        if (n == 0 && tmp.size == k) {
+            a.add(tmp.map { it -> it }.toMutableList())
+            return
+        }
+        for (i in index until 10) {
+            tmp.add(i)
+            comb(a, k, n - i, i + 1, tmp)
+            tmp.removeAt(tmp.size - 1)
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+216\. Combination Sum III
+
+Medium
+
+Find all valid combinations of `k` numbers that sum up to `n` such that the following conditions are true:
+
+*   Only numbers `1` through `9` are used.
+*   Each number is used **at most once**.
+
+Return _a list of all possible valid combinations_. The list must not contain the same combination twice, and the combinations may be returned in any order.
+
+**Example 1:**
+
+**Input:** k = 3, n = 7
+
+**Output:** [[1,2,4]]
+
+**Explanation:** 1 + 2 + 4 = 7 There are no other valid combinations.
+
+**Example 2:**
+
+**Input:** k = 3, n = 9
+
+**Output:** [[1,2,6],[1,3,5],[2,3,4]]
+
+**Explanation:** 
+
+1 + 2 + 6 = 9 
+
+1 + 3 + 5 = 9 
+
+2 + 3 + 4 = 9 
+
+There are no other valid combinations.
+
+**Example 3:**
+
+**Input:** k = 4, n = 1
+
+**Output:** []
+
+**Explanation:** There are no valid combinations. Using 4 different numbers in the range [1,9], the smallest sum we can get is 1+2+3+4 = 10 and since 10 > 1, there are no valid combination.
+
+**Constraints:**
+
+*   `2 <= k <= 9`
+*   `1 <= n <= 60`

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

@@ -0,0 +1,18 @@
+package g0201_0300.s0217_contains_duplicate
+
+// #Easy #Top_Interview_Questions #Array #Hash_Table #Sorting #Data_Structure_I_Day_1_Array
+// #Programming_Skills_I_Day_11_Containers_and_Libraries #Udemy_Arrays
+// #2022_10_25_Time_719_ms_(73.49%)_Space_71.6_MB_(55.82%)
+
+class Solution {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val set: MutableSet<Int> = HashSet()
+        for (n in nums) {
+            if (set.contains(n)) {
+                return true
+            }
+            set.add(n)
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,28 @@
+217\. Contains Duplicate
+
+Easy
+
+Given an integer array `nums`, return `true` if any value appears **at least twice** in the array, and return `false` if every element is distinct.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1]
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** nums = [1,1,1,3,3,4,3,2,4,2]
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,64 @@
+package g0201_0300.s0218_the_skyline_problem
+
+// #Hard #Top_Interview_Questions #Array #Heap_Priority_Queue #Ordered_Set #Divide_and_Conquer
+// #Segment_Tree #Binary_Indexed_Tree #Line_Sweep
+// #2022_10_25_Time_365_ms_(93.14%)_Space_45.7_MB_(93.71%)
+
+import java.util.TreeMap
+
+class Solution {
+    fun getSkyline(blds: Array<IntArray>): List<List<Int>> {
+        val ans = ArrayList<List<Int>>()
+        if (blds.isEmpty()) {
+            return ans
+        }
+        val totalBuildings = blds.size
+        val buildings = Array<Building?>(totalBuildings * 2) { null }
+        var idx = 0
+        for (building in blds) {
+            buildings[idx] = Building(building[0], building[2], true)
+            buildings[idx + 1] = Building(building[1], building[2], false)
+            idx += 2
+        }
+        buildings.sort()
+        val skyline = TreeMap<Int, Int>()
+        skyline[0] = 1
+        var prevMaxHeight = 0
+        for (building in buildings) {
+            if (building == null) {
+                continue
+            }
+            val height = building.height
+            if (building.isStart) {
+                skyline[height] = 1 + (skyline[height] ?: 0)
+            } else {
+                skyline[height] = (skyline[height] ?: 1) - 1
+                if (skyline[height] == 0) skyline.remove(height)
+            }
+            val xCoor = building.xCoor
+            val curMaxHeight = skyline.lastKey()
+            if (prevMaxHeight != curMaxHeight) {
+                ans.add(arrayListOf(xCoor, curMaxHeight))
+                prevMaxHeight = curMaxHeight
+            }
+        }
+        return ans
+    }
+
+    private class Building(val xCoor: Int, val height: Int, val isStart: Boolean) : Comparable<Building> {
+        override fun compareTo(other: Building): Int {
+            return COMPARATOR.compare(this, other)
+        }
+
+        private companion object {
+            private val COMPARATOR = Comparator<Building> { a, b ->
+                when {
+                    a.xCoor != b.xCoor -> a.xCoor.compareTo(b.xCoor)
+                    a.isStart && b.isStart -> b.height.compareTo(a.height)
+                    !(a.isStart || b.isStart) -> a.height.compareTo(b.height)
+                    else -> if (a.isStart) -1 else 1
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+218\. The Skyline Problem
+
+Hard
+
+A city's **skyline** is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return _the **skyline** formed by these buildings collectively_.
+
+The geometric information of each building is given in the array `buildings` where <code>buildings[i] = [left<sub>i</sub>, right<sub>i</sub>, height<sub>i</sub>]</code>:
+
+*   <code>left<sub>i</sub></code> is the x coordinate of the left edge of the <code>i<sup>th</sup></code> building.
+*   <code>right<sub>i</sub></code> is the x coordinate of the right edge of the <code>i<sup>th</sup></code> building.
+*   <code>height<sub>i</sub></code> is the height of the <code>i<sup>th</sup></code> building.
+
+You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height `0`.
+
+The **skyline** should be represented as a list of "key points" **sorted by their x-coordinate** in the form <code>[[x<sub>1</sub>,y<sub>1</sub>],[x<sub>2</sub>,y<sub>2</sub>],...]</code>. Each key point is the left endpoint of some horizontal segment in the skyline except the last point in the list, which always has a y-coordinate `0` and is used to mark the skyline's termination where the rightmost building ends. Any ground between the leftmost and rightmost buildings should be part of the skyline's contour.
+
+**Note:** There must be no consecutive horizontal lines of equal height in the output skyline. For instance, `[...,[2 3],[4 5],[7 5],[11 5],[12 7],...]` is not acceptable; the three lines of height 5 should be merged into one in the final output as such: `[...,[2 3],[4 5],[12 7],...]`
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/01/merged.jpg)
+
+**Input:** buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
+
+**Output:** [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
+
+**Explanation:** Figure A shows the buildings of the input. Figure B shows the skyline formed by those buildings. The red points in figure B represent the key points in the output list.
+
+**Example 2:**
+
+**Input:** buildings = [[0,2,3],[2,5,3]]
+
+**Output:** [[0,3],[5,0]]
+
+**Constraints:**
+
+*   <code>1 <= buildings.length <= 10<sup>4</sup></code>
+*   <code>0 <= left<sub>i</sub> < right<sub>i</sub> <= 2<sup>31</sup> - 1</code>
+*   <code>1 <= height<sub>i</sub> <= 2<sup>31</sup> - 1</code>
+*   `buildings` is sorted by <code>left<sub>i</sub></code> in non-decreasing order.

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

@@ -0,0 +1,17 @@
+package g0201_0300.s0219_contains_duplicate_ii
+
+// #Easy #Array #Hash_Table #Sliding_Window #2022_10_25_Time_813_ms_(80.46%)_Space_71.1_MB_(81.22%)
+
+class Solution {
+    fun containsNearbyDuplicate(nums: IntArray, k: Int): Boolean {
+        val map: MutableMap<Int, Int> = HashMap()
+        val len = nums.size
+        for (i in 0 until len) {
+            val index = map.put(nums[i], i)
+            if (index != null && Math.abs(index - i) <= k) {
+                return true
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,29 @@
+219\. Contains Duplicate II
+
+Easy
+
+Given an integer array `nums` and an integer `k`, return `true` if there are two **distinct indices** `i` and `j` in the array such that `nums[i] == nums[j]` and `abs(i - j) <= k`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1], k = 3
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** nums = [1,0,1,1], k = 1
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** nums = [1,2,3,1,2,3], k = 2
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>0 <= k <= 10<sup>5</sup></code>

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

@@ -0,0 +1,24 @@
+package g0201_0300.s0216_combination_sum_iii
+
+import com_github_leetcode.ArrayUtils
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun combinationSum3() {
+        assertThat(
+            Solution().combinationSum3(3, 7),
+            equalTo(ArrayUtils.getLists(arrayOf(intArrayOf(1, 2, 4))))
+        )
+    }
+
+    @Test
+    fun combinationSum32() {
+        assertThat(
+            Solution().combinationSum3(3, 9),
+            equalTo(ArrayUtils.getLists(arrayOf(intArrayOf(1, 2, 6), intArrayOf(1, 3, 5), intArrayOf(2, 3, 4))))
+        )
+    }
+}

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

@@ -0,0 +1,25 @@
+package g0201_0300.s0217_contains_duplicate
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun containsDuplicate() {
+        assertThat(Solution().containsDuplicate(intArrayOf(1, 2, 3, 1)), equalTo(true))
+    }
+
+    @Test
+    fun containsDuplicate2() {
+        assertThat(Solution().containsDuplicate(intArrayOf(1, 2, 3, 4)), equalTo(false))
+    }
+
+    @Test
+    fun containsDuplicate3() {
+        assertThat(
+            Solution().containsDuplicate(intArrayOf(1, 1, 1, 3, 3, 4, 3, 2, 4, 2)),
+            equalTo(true)
+        )
+    }
+}