Added tasks 441, 442, 443, 445.

Author: ThanhNIT

README.md

@@ -355,6 +355,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0002 |[Add Two Numbers](src.save/main/kotlin/g0001_0100/s0002_add_two_numbers/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Math, Linked_List, Recursion | 417 | 50.44
+| 0445 |[Add Two Numbers II](src/main/kotlin/g0401_0500/s0445_add_two_numbers_ii/Solution.kt)| Medium | Math, Stack, Linked_List | 240 | 82.61
 
 #### Day 16
 
@@ -809,6 +810,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0075 |[Sort Colors](src.save/main/kotlin/g0001_0100/s0075_sort_colors/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 198 | 85.66
 | 0066 |[Plus One](src.save/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt)| Easy | Top_Interview_Questions, Array, Math | 303 | 35.18
 | 0238 |[Product of Array Except Self](src.save/main/kotlin/g0201_0300/s0238_product_of_array_except_self/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Prefix_Sum | 669 | 48.96
+| 0442 |[Find All Duplicates in an Array](src/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table | 480 | 73.81
 | 0041 |[First Missing Positive](src.save/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
 | 0239 |[Sliding Window Maximum](src.save/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
 
@@ -850,6 +852,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0114 |[Flatten Binary Tree to Linked List](src.save/main/kotlin/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Linked_List | 191 | 93.10
+| 0445 |[Add Two Numbers II](src/main/kotlin/g0401_0500/s0445_add_two_numbers_ii/Solution.kt)| Medium | Math, Stack, Linked_List | 240 | 82.61
 | 0328 |[Odd Even Linked List](src.save/main/kotlin/g0301_0400/s0328_odd_even_linked_list/Solution.kt)| Medium | Top_Interview_Questions, Linked_List | 216 | 86.96
 | 0061 |[Rotate List](src.save/main/kotlin/g0001_0100/s0061_rotate_list/Solution.kt)| Medium | Two_Pointers, Linked_List | 193 | 92.16
 | 0024 |[Swap Nodes in Pairs](src.save/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/Solution.kt)| Medium | Top_100_Liked_Questions, Linked_List, Recursion | 149 | 99.39
@@ -1469,6 +1472,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0441 |[Arranging Coins](src/main/kotlin/g0401_0500/s0441_arranging_coins/Solution.kt)| Easy | Math, Binary_Search | 150 | 84.21
 
 #### Day 7
 
@@ -1630,6 +1634,10 @@ 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
+| 0445 |[Add Two Numbers II](src/main/kotlin/g0401_0500/s0445_add_two_numbers_ii/Solution.kt)| Medium | Math, Stack, Linked_List, Programming_Skills_II_Day_15, Udemy_Linked_List | 240 | 82.61
+| 0443 |[String Compression](src/main/kotlin/g0401_0500/s0443_string_compression/Solution.kt)| Medium | String, Two_Pointers | 198 | 92.68
+| 0442 |[Find All Duplicates in an Array](src/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Udemy_Arrays | 480 | 73.81
+| 0441 |[Arranging Coins](src/main/kotlin/g0401_0500/s0441_arranging_coins/Solution.kt)| Easy | Math, Binary_Search, Binary_Search_I_Day_6 | 150 | 84.21
 | 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

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

@@ -0,0 +1,15 @@
+package g0401_0500.s0441_arranging_coins
+
+// #Easy #Math #Binary_Search #Binary_Search_I_Day_6
+// #2022_12_23_Time_150_ms_(84.21%)_Space_33.4_MB_(100.00%)
+
+class Solution {
+    fun arrangeCoins(n: Int): Int {
+        var i = 1
+        var x = n
+        while (x > 0) {
+            x -= ++i
+        }
+        return i - 1
+    }
+}

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

@@ -0,0 +1,31 @@
+441\. Arranging Coins
+
+Easy
+
+You have `n` coins and you want to build a staircase with these coins. The staircase consists of `k` rows where the <code>i<sup>th</sup></code> row has exactly `i` coins. The last row of the staircase **may be** incomplete.
+
+Given the integer `n`, return _the number of **complete rows** of the staircase you will build_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/arrangecoins1-grid.jpg)
+
+**Input:** n = 5
+
+**Output:** 2
+
+**Explanation:** Because the 3<sup>rd</sup> row is incomplete, we return 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/arrangecoins2-grid.jpg)
+
+**Input:** n = 8
+
+**Output:** 3
+
+**Explanation:** Because the 4<sup>th</sup> row is incomplete, we return 3.
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,18 @@
+package g0401_0500.s0442_find_all_duplicates_in_an_array
+
+// #Medium #Array #Hash_Table #Udemy_Arrays #2022_12_23_Time_480_ms_(73.81%)_Space_45.6_MB_(100.00%)
+
+class Solution {
+    fun findDuplicates(nums: IntArray): List<Int> {
+        val setToCheck: MutableSet<Int> = mutableSetOf()
+        val duplicates: MutableList<Int> = mutableListOf()
+
+        nums.forEach { element ->
+            if (!setToCheck.add(element)) {
+                duplicates.add(element)
+            }
+        }
+
+        return duplicates
+    }
+}

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

@@ -0,0 +1,32 @@
+442\. Find All Duplicates in an Array
+
+Medium
+
+Given an integer array `nums` of length `n` where all the integers of `nums` are in the range `[1, n]` and each integer appears **once** or **twice**, return _an array of all the integers that appears **twice**_.
+
+You must write an algorithm that runs in `O(n) `time and uses only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,7,8,2,3,1]
+
+**Output:** [2,3]
+
+**Example 2:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** [1]
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** []
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= nums[i] <= n`
+*   Each element in `nums` appears **once** or **twice**.

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

@@ -0,0 +1,38 @@
+package g0401_0500.s0443_string_compression
+
+// #Medium #String #Two_Pointers #2022_12_23_Time_198_ms_(92.68%)_Space_35.4_MB_(95.12%)
+
+class Solution {
+    /* This is breaking the rules, it's not in-place. */
+    fun compress(chars: CharArray): Int {
+        if (chars.size == 0) {
+            return 0
+        }
+        val sb = StringBuilder()
+        var count = 1
+        var prev = chars[0]
+        for (i in 1 until chars.size) {
+            if (chars[i] == prev) {
+                count++
+            } else {
+                if (count > 1) {
+                    sb.append(prev)
+                    sb.append(count)
+                } else if (count == 1) {
+                    sb.append(prev)
+                }
+                prev = chars[i]
+                count = 1
+            }
+        }
+        sb.append(prev)
+        if (count > 1) {
+            sb.append(count)
+        }
+        var i = 0
+        for (c in sb.toString().toCharArray()) {
+            chars[i++] = c
+        }
+        return sb.length
+    }
+}

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

@@ -0,0 +1,45 @@
+443\. String Compression
+
+Medium
+
+Given an array of characters `chars`, compress it using the following algorithm:
+
+Begin with an empty string `s`. For each group of **consecutive repeating characters** in `chars`:
+
+*   If the group's length is `1`, append the character to `s`.
+*   Otherwise, append the character followed by the group's length.
+
+The compressed string `s` **should not be returned separately**, but instead, be stored **in the input character array `chars`**. Note that group lengths that are `10` or longer will be split into multiple characters in `chars`.
+
+After you are done **modifying the input array,** return _the new length of the array_.
+
+You must write an algorithm that uses only constant extra space.
+
+**Example 1:**
+
+**Input:** chars = ["a","a","b","b","c","c","c"]
+
+**Output:** Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]
+
+**Explanation:** The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3".
+
+**Example 2:**
+
+**Input:** chars = ["a"]
+
+**Output:** Return 1, and the first character of the input array should be: ["a"]
+
+**Explanation:** The only group is "a", which remains uncompressed since it's a single character.
+
+**Example 3:**
+
+**Input:** chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
+
+**Output:** Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].
+
+**Explanation:** The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12".
+
+**Constraints:**
+
+*   `1 <= chars.length <= 2000`
+*   `chars[i]` is a lowercase English letter, uppercase English letter, digit, or symbol.

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

@@ -0,0 +1,74 @@
+package g0401_0500.s0445_add_two_numbers_ii
+
+// #Medium #Math #Stack #Linked_List #Programming_Skills_II_Day_15 #Udemy_Linked_List
+// #2022_12_23_Time_240_ms_(82.61%)_Space_42.6_MB_(73.91%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private fun reverse(head: ListNode?): ListNode? {
+        if (head == null || head.next == null) {
+            return head
+        }
+        var prev: ListNode? = null
+        var curr: ListNode = head
+        var next = head.next
+        while (next != null) {
+            curr.next = prev
+            prev = curr
+            curr = next
+            next = next.next
+        }
+        curr.next = prev
+        return curr
+    }
+
+    fun addTwoNumbers(l1: ListNode?, l2: ListNode?): ListNode? {
+        var l1 = l1
+        var l2 = l2
+        l1 = reverse(l1)
+        l2 = reverse(l2)
+        var res: ListNode? = ListNode()
+        val head = res
+        var carry = 0
+        while (l1 != null || l2 != null) {
+            var val1: Int
+            var val2: Int
+            if (l1 == null) {
+                val1 = 0
+            } else {
+                val1 = l1.`val`
+                l1 = l1.next
+            }
+            if (l2 == null) {
+                val2 = 0
+            } else {
+                val2 = l2.`val`
+                l2 = l2.next
+            }
+            var data = val1 + val2 + carry
+            if (data > 9) {
+                carry = data / 10
+                data = data % 10
+            } else {
+                carry = 0
+            }
+            res!!.next = ListNode(data)
+            res = res.next
+        }
+        if (carry != 0) {
+            res!!.next = ListNode(carry)
+        }
+        return reverse(head!!.next)
+    }
+}

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

@@ -0,0 +1,35 @@
+445\. Add Two Numbers II
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/sumii-linked-list.jpg)
+
+**Input:** l1 = [7,2,4,3], l2 = [5,6,4]
+
+**Output:** [7,8,0,7]
+
+**Example 2:**
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [8,0,7]
+
+**Example 3:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.
+
+**Follow up:** Could you solve it without reversing the input lists?

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

@@ -0,0 +1,17 @@
+package g0401_0500.s0441_arranging_coins
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findKthNumber() {
+        assertThat(Solution().arrangeCoins(5), equalTo(2))
+    }
+
+    @Test
+    fun arrangeCoins2() {
+        assertThat(Solution().arrangeCoins(8), equalTo(3))
+    }
+}