Added tasks 50, 52, 57, 58.

Author: ThanhNIT

README.md

@@ -574,6 +574,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack | 936 | 80.54
+| 0058 |[Length of Last Word](src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt)| Easy | String | 243 | 63.33
 
 #### Day 7
 
@@ -976,6 +977,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0057 |[Insert Interval](src/main/kotlin/g0001_0100/s0057_insert_interval/Solution.kt)| Medium | Array | 257 | 99.52
 | 0056 |[Merge Intervals](src/main/kotlin/g0001_0100/s0056_merge_intervals/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting | 323 | 99.68
 
 #### Day 18 Stack
@@ -1004,6 +1006,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0136 |[Single Number](src/main/kotlin/g0101_0200/s0136_single_number/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation | 344 | 83.63
 | 0007 |[Reverse Integer](src/main/kotlin/g0001_0100/s0007_reverse_integer/Solution.kt)| Medium | Top_Interview_Questions, Math | 230 | 57.36
 | 0009 |[Palindrome Number](src/main/kotlin/g0001_0100/s0009_palindrome_number/Solution.kt)| Easy | Math | 208 | 94.88
+| 0050 |[Pow(x, n)](src/main/kotlin/g0001_0100/s0050_powx_n/Solution.kt)| Medium | Top_Interview_Questions, Math, Recursion | 307 | 17.33
 
 #### Udemy Strings
 
@@ -1030,6 +1033,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 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
+| 0058 |[Length of Last Word](src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt)| Easy | String | 243 | 63.33
 | 0189 |[Rotate Array](src/main/kotlin/g0101_0200/s0189_rotate_array/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Math, Two_Pointers | 483 | 86.95
 | 0055 |[Jump Game](src/main/kotlin/g0001_0100/s0055_jump_game/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy | 670 | 66.67
 | 0075 |[Sort Colors](src/main/kotlin/g0001_0100/s0075_sort_colors/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 198 | 85.66
@@ -1522,11 +1526,15 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0070 |[Climbing Stairs](src/main/kotlin/g0001_0100/s0070_climbing_stairs/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Memoization, Algorithm_I_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_2, Level_1_Day_10_Dynamic_Programming, Udemy_Dynamic_Programming | 127 | 97.06
 | 0064 |[Minimum Path Sum](src/main/kotlin/g0001_0100/s0064_minimum_path_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16, Udemy_Dynamic_Programming | 222 | 95.70
 | 0062 |[Unique Paths](src/main/kotlin/g0001_0100/s0062_unique_paths/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Combinatorics, Algorithm_II_Day_13_Dynamic_Programming, Dynamic_Programming_I_Day_15, Level_1_Day_11_Dynamic_Programming | 209 | 49.18
+| 0058 |[Length of Last Word](src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt)| Easy | String, Programming_Skills_II_Day_6, Udemy_Arrays | 243 | 63.33
+| 0057 |[Insert Interval](src/main/kotlin/g0001_0100/s0057_insert_interval/Solution.kt)| Medium | Array, Level_2_Day_17_Interval | 257 | 99.52
 | 0056 |[Merge Intervals](src/main/kotlin/g0001_0100/s0056_merge_intervals/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Data_Structure_II_Day_2_Array, Level_2_Day_17_Interval, Udemy_2D_Arrays/Matrix | 323 | 99.68
 | 0055 |[Jump Game](src/main/kotlin/g0001_0100/s0055_jump_game/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy, Algorithm_II_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_4, Udemy_Arrays | 670 | 66.67
 | 0054 |[Spiral Matrix](src/main/kotlin/g0001_0100/s0054_spiral_matrix/Solution.kt)| Medium | Top_Interview_Questions, Array, Matrix, Simulation, Programming_Skills_II_Day_8, Level_2_Day_1_Implementation/Simulation, Udemy_2D_Arrays/Matrix | 224 | 62.50
 | 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, Data_Structure_I_Day_1_Array, Dynamic_Programming_I_Day_5, Udemy_Famous_Algorithm | 662 | 82.48
+| 0052 |[N-Queens II](src/main/kotlin/g0001_0100/s0052_n_queens_ii/Solution.kt)| Hard | Backtracking | 231 | 80.00
 | 0051 |[N-Queens](src/main/kotlin/g0001_0100/s0051_n_queens/Solution.kt)| Hard | Top_100_Liked_Questions, Array, Backtracking | 243 | 95.10
+| 0050 |[Pow(x, n)](src/main/kotlin/g0001_0100/s0050_powx_n/Solution.kt)| Medium | Top_Interview_Questions, Math, Recursion, Udemy_Integers | 307 | 17.33
 | 0049 |[Group Anagrams](src/main/kotlin/g0001_0100/s0049_group_anagrams/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, String, Hash_Table, Sorting, Data_Structure_II_Day_8_String, Programming_Skills_II_Day_11, Udemy_Strings | 506 | 86.55
 | 0048 |[Rotate Image](src/main/kotlin/g0001_0100/s0048_rotate_image/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Math, Matrix, Data_Structure_II_Day_3_Array, Programming_Skills_II_Day_7, Udemy_2D_Arrays/Matrix | 287 | 46.50
 | 0047 |[Permutations II](src/main/kotlin/g0001_0100/s0047_permutations_ii/Solution.kt)| Medium | Array, Backtracking, Algorithm_II_Day_10_Recursion_Backtracking | 406 | 76.36

src/main/kotlin/g0001_0100/s0050_powx_n/Solution.kt

@@ -0,0 +1,27 @@
+package g0001_0100.s0050_powx_n
+
+// #Medium #Top_Interview_Questions #Math #Recursion #Udemy_Integers
+// #2022_09_21_Time_307_ms_(17.33%)_Space_35.2_MB_(54.67%)
+
+class Solution {
+    fun myPow(x: Double, n: Int): Double {
+        var x = x
+        var nn = n.toLong()
+        var res = 1.0
+        if (n < 0) {
+            nn *= -1
+        }
+        while (nn > 0) {
+            if (nn % 2 == 1L) {
+                nn--
+                res *= x
+            } else {
+                x *= x
+                nn /= 2
+            }
+        }
+        return if (n < 0) {
+            1.0 / res
+        } else res
+    }
+}

src/main/kotlin/g0001_0100/s0050_powx_n/readme.md

@@ -0,0 +1,32 @@
+50\. Pow(x, n)
+
+Medium
+
+Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., <code>x<sup>n</sup></code>).
+
+**Example 1:**
+
+**Input:** x = 2.00000, n = 10
+
+**Output:** 1024.00000
+
+**Example 2:**
+
+**Input:** x = 2.10000, n = 3
+
+**Output:** 9.26100
+
+**Example 3:**
+
+**Input:** x = 2.00000, n = -2
+
+**Output:** 0.25000
+
+**Explanation:** 2<sup>\-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
+
+**Constraints:**
+
+*   `-100.0 < x < 100.0`
+*   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code>
+*   `n` is an integer.
+*   <code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code>

src/main/kotlin/g0001_0100/s0052_n_queens_ii/Solution.kt

@@ -0,0 +1,41 @@
+package g0001_0100.s0052_n_queens_ii
+
+// #Hard #Backtracking #2022_09_21_Time_231_ms_(80.00%)_Space_33.7_MB_(94.29%)
+
+class Solution {
+    fun totalNQueens(n: Int): Int {
+        val row = BooleanArray(n)
+        val col = BooleanArray(n)
+        val diagonal = BooleanArray(n + n - 1)
+        val antiDiagonal = BooleanArray(n + n - 1)
+        return totalNQueens(n, 0, row, col, diagonal, antiDiagonal)
+    }
+
+    private fun totalNQueens(
+        n: Int,
+        r: Int,
+        row: BooleanArray,
+        col: BooleanArray,
+        diagonal: BooleanArray,
+        antiDiagonal: BooleanArray
+    ): Int {
+        if (r == n) {
+            return 1
+        }
+        var count = 0
+        for (c in 0 until n) {
+            if (!row[r] && !col[c] && !diagonal[r + c] && !antiDiagonal[r - c + n - 1]) {
+                antiDiagonal[r - c + n - 1] = true
+                diagonal[r + c] = antiDiagonal[r - c + n - 1]
+                col[c] = diagonal[r + c]
+                row[r] = col[c]
+                count += totalNQueens(n, r + 1, row, col, diagonal, antiDiagonal)
+                antiDiagonal[r - c + n - 1] = false
+                diagonal[r + c] = antiDiagonal[r - c + n - 1]
+                col[c] = diagonal[r + c]
+                row[r] = col[c]
+            }
+        }
+        return count
+    }
+}

src/main/kotlin/g0001_0100/s0052_n_queens_ii/readme.md

@@ -0,0 +1,27 @@
+52\. N-Queens II
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _the number of distinct solutions to the **n-queens puzzle**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Explanation:** There are two distinct solutions to the 4-queens puzzle as shown.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= n <= 9`

src/main/kotlin/g0001_0100/s0057_insert_interval/Solution.kt

@@ -0,0 +1,33 @@
+package g0001_0100.s0057_insert_interval
+
+// #Medium #Array #Level_2_Day_17_Interval #2022_09_21_Time_257_ms_(99.52%)_Space_37.1_MB_(99.52%)
+
+import java.util.Arrays
+
+class Solution {
+    fun insert(intervals: Array<IntArray>, newInterval: IntArray): Array<IntArray> {
+        val n = intervals.size
+        var l = 0
+        var r = n - 1
+        while (l < n && newInterval[0] > intervals[l][1]) {
+            l++
+        }
+        while (r >= 0 && newInterval[1] < intervals[r][0]) {
+            r--
+        }
+        val res = Array(l + n - r) { IntArray(2) }
+        for (i in 0 until l) {
+            res[i] = Arrays.copyOf(intervals[i], intervals[i].size)
+        }
+        res[l][0] = Math.min(newInterval[0], if (l == n) newInterval[0] else intervals[l][0])
+        res[l][1] = Math.max(newInterval[1], if (r == -1) newInterval[1] else intervals[r][1])
+        var i = l + 1
+        var j = r + 1
+        while (j < n) {
+            res[i] = intervals[j]
+            i++
+            j++
+        }
+        return res
+    }
+}

src/main/kotlin/g0001_0100/s0057_insert_interval/readme.md

@@ -0,0 +1,32 @@
+57\. Insert Interval
+
+Medium
+
+You are given an array of non-overlapping intervals `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> represent the start and the end of the <code>i<sup>th</sup></code> interval and `intervals` is sorted in ascending order by <code>start<sub>i</sub></code>. You are also given an interval `newInterval = [start, end]` that represents the start and end of another interval.
+
+Insert `newInterval` into `intervals` such that `intervals` is still sorted in ascending order by <code>start<sub>i</sub></code> and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).
+
+Return `intervals` _after the insertion_.
+
+**Example 1:**
+
+**Input:** intervals = [[1,3],[6,9]], newInterval = [2,5]
+
+**Output:** [[1,5],[6,9]]
+
+**Example 2:**
+
+**Input:** intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+
+**Output:** [[1,2],[3,10],[12,16]]
+
+**Explanation:** Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
+
+**Constraints:**
+
+*   <code>0 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>5</sup></code>
+*   `intervals` is sorted by <code>start<sub>i</sub></code> in **ascending** order.
+*   `newInterval.length == 2`
+*   <code>0 <= start <= end <= 10<sup>5</sup></code>

src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt

@@ -0,0 +1,19 @@
+package g0001_0100.s0058_length_of_last_word
+
+// #Easy #String #Programming_Skills_II_Day_6 #Udemy_Arrays
+// #2022_09_21_Time_243_ms_(63.33%)_Space_35.7_MB_(73.11%)
+
+class Solution {
+    fun lengthOfLastWord(str: String): Int {
+        var len = 0
+        for (i in str.length - 1 downTo 0) {
+            val ch = str[i]
+            if (ch == ' ' && len > 0) {
+                break
+            } else if (ch != ' ') {
+                len++
+            }
+        }
+        return len
+    }
+}

src/main/kotlin/g0001_0100/s0058_length_of_last_word/readme.md

@@ -0,0 +1,37 @@
+58\. Length of Last Word
+
+Easy
+
+Given a string `s` consisting of words and spaces, return _the length of the **last** word in the string._
+
+A **word** is a maximal substring consisting of non-space characters only.
+
+**Example 1:**
+
+**Input:** s = "Hello World"
+
+**Output:** 5
+
+**Explanation:** The last word is "World" with length 5.
+
+**Example 2:**
+
+**Input:** s = " fly me to the moon "
+
+**Output:** 4
+
+**Explanation:** The last word is "moon" with length 4.
+
+**Example 3:**
+
+**Input:** s = "luffy is still joyboy"
+
+**Output:** 6
+
+**Explanation:** The last word is "joyboy" with length 6.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of only English letters and spaces `' '`.
+*   There will be at least one word in `s`.

src/test/kotlin/g0001_0100/s0050_powx_n/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0050_powx_n
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun myPow() {
+        assertThat(Solution().myPow(2.00000, 10), equalTo(1024.00000))
+    }
+
+    @Test
+    fun myPow2() {
+        assertThat(Solution().myPow(2.10000, 3), equalTo(9.261000000000001))
+    }
+
+    @Test
+    fun myPow3() {
+        assertThat(Solution().myPow(2.00000, -2), equalTo(0.25000))
+    }
+}