Added tasks 643, 645, 646, 648

Author: ThanhNIT

README.md

@@ -1673,7 +1673,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0648 |[Replace Words](src/main/kotlin/g0601_0700/s0648_replace_words/Solution.kt)| Medium | Array, String, Hash_Table, Trie | 392 | 100.00
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0646 |[Maximum Length of Pair Chain](src/main/kotlin/g0601_0700/s0646_maximum_length_of_pair_chain/Solution.kt)| Medium | Array, Dynamic_Programming, Sorting, Greedy | 249 | 100.00
+| 0645 |[Set Mismatch](src/main/kotlin/g0601_0700/s0645_set_mismatch/Solution.kt)| Easy | Array, Hash_Table, Sorting, Bit_Manipulation | 246 | 88.46
+| 0643 |[Maximum Average Subarray I](src/main/kotlin/g0601_0700/s0643_maximum_average_subarray_i/Solution.kt)| Easy | Array, Sliding_Window | 494 | 98.65
 | 0641 |[Design Circular Deque](src/main/kotlin/g0601_0700/s0641_design_circular_deque/MyCircularDeque.kt)| Medium | Array, Design, Linked_List, Queue | 232 | 100.00
 | 0640 |[Solve the Equation](src/main/kotlin/g0601_0700/s0640_solve_the_equation/Solution.kt)| Medium | String, Math, Simulation | 170 | 66.67
 | 0639 |[Decode Ways II](src/main/kotlin/g0601_0700/s0639_decode_ways_ii/Solution.kt)| Hard | String, Dynamic_Programming | 259 | 100.00

src/main/kotlin/g0601_0700/s0643_maximum_average_subarray_i/Solution.kt

@@ -0,0 +1,21 @@
+package g0601_0700.s0643_maximum_average_subarray_i
+
+// #Easy #Array #Sliding_Window #2023_02_11_Time_494_ms_(98.65%)_Space_45.8_MB_(95.95%)
+
+class Solution {
+    fun findMaxAverage(nums: IntArray, k: Int): Double {
+        var windowSum = 0.0
+        var windowStart = 0
+        var max = Int.MIN_VALUE.toDouble()
+        for (windowEnd in nums.indices) {
+            windowSum += nums[windowEnd].toDouble()
+            if (windowEnd >= k - 1) {
+                val candidate = windowSum / k
+                max = Math.max(candidate, max)
+                windowSum -= nums[windowStart].toDouble()
+                windowStart++
+            }
+        }
+        return max
+    }
+}

src/main/kotlin/g0601_0700/s0643_maximum_average_subarray_i/readme.md

@@ -0,0 +1,27 @@
+643\. Maximum Average Subarray I
+
+Easy
+
+You are given an integer array `nums` consisting of `n` elements, and an integer `k`.
+
+Find a contiguous subarray whose **length is equal to** `k` that has the maximum average value and return _this value_. Any answer with a calculation error less than <code>10<sup>-5</sup></code> will be accepted.
+
+**Example 1:**
+
+**Input:** nums = [1,12,-5,-6,50,3], k = 4
+
+**Output:** 12.75000
+
+**Explanation:** Maximum average is (12 - 5 - 6 + 50) / 4 = 51 / 4 = 12.75
+
+**Example 2:**
+
+**Input:** nums = [5], k = 1
+
+**Output:** 5.00000
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= k <= n <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>

src/main/kotlin/g0601_0700/s0645_set_mismatch/Solution.kt

@@ -0,0 +1,29 @@
+package g0601_0700.s0645_set_mismatch
+
+// #Easy #Array #Hash_Table #Sorting #Bit_Manipulation
+// #2023_02_11_Time_246_ms_(88.46%)_Space_38.1_MB_(80.77%)
+
+class Solution {
+    fun findErrorNums(nums: IntArray): IntArray {
+        val ans = IntArray(2)
+        var i = 0
+        while (i < nums.size) {
+            val correct = nums[i] - 1
+            if (nums[i] != nums[correct]) {
+                val temp = nums[i]
+                nums[i] = nums[correct]
+                nums[correct] = temp
+            } else {
+                i++
+            }
+        }
+        for (a in nums.indices) {
+            if (nums[a] != a + 1) {
+                ans[0] = nums[a]
+                ans[1] = a + 1
+                break
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g0601_0700/s0645_set_mismatch/readme.md

@@ -0,0 +1,26 @@
+645\. Set Mismatch
+
+Easy
+
+You have a set of integers `s`, which originally contains all the numbers from `1` to `n`. Unfortunately, due to some error, one of the numbers in `s` got duplicated to another number in the set, which results in **repetition of one** number and **loss of another** number.
+
+You are given an integer array `nums` representing the data status of this set after the error.
+
+Find the number that occurs twice and the number that is missing and return _them in the form of an array_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,4]
+
+**Output:** [2,3]
+
+**Example 2:**
+
+**Input:** nums = [1,1]
+
+**Output:** [1,2]
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>

src/main/kotlin/g0601_0700/s0646_maximum_length_of_pair_chain/Solution.kt

@@ -0,0 +1,26 @@
+package g0601_0700.s0646_maximum_length_of_pair_chain
+
+// #Medium #Array #Dynamic_Programming #Sorting #Greedy
+// #2023_02_11_Time_249_ms_(100.00%)_Space_38.2_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun findLongestChain(pairs: Array<IntArray>): Int {
+        if (pairs.size == 1) {
+            return 1
+        }
+        Arrays.sort(pairs) { a: IntArray, b: IntArray ->
+            a[1] - b[1]
+        }
+        var min = pairs[0][1]
+        var max = 1
+        for (i in 1 until pairs.size) {
+            if (pairs[i][0] > min) {
+                max++
+                min = pairs[i][1]
+            }
+        }
+        return max
+    }
+}

src/main/kotlin/g0601_0700/s0646_maximum_length_of_pair_chain/readme.md

@@ -0,0 +1,33 @@
+646\. Maximum Length of Pair Chain
+
+Medium
+
+You are given an array of `n` pairs `pairs` where <code>pairs[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> and <code>left<sub>i</sub> < right<sub>i</sub></code>.
+
+A pair `p2 = [c, d]` **follows** a pair `p1 = [a, b]` if `b < c`. A **chain** of pairs can be formed in this fashion.
+
+Return _the length longest chain which can be formed_.
+
+You do not need to use up all the given intervals. You can select pairs in any order.
+
+**Example 1:**
+
+**Input:** pairs = [[1,2],[2,3],[3,4]]
+
+**Output:** 2
+
+**Explanation:** The longest chain is [1,2] -> [3,4].
+
+**Example 2:**
+
+**Input:** pairs = [[1,2],[7,8],[4,5]]
+
+**Output:** 3
+
+**Explanation:** The longest chain is [1,2] -> [4,5] -> [7,8].
+
+**Constraints:**
+
+*   `n == pairs.length`
+*   `1 <= n <= 1000`
+*   <code>-1000 <= left<sub>i</sub> < right<sub>i</sub> <= 1000</code>

src/main/kotlin/g0601_0700/s0648_replace_words/Solution.kt

@@ -0,0 +1,66 @@
+package g0601_0700.s0648_replace_words
+
+// #Medium #Array #String #Hash_Table #Trie #2023_02_11_Time_392_ms_(100.00%)_Space_62.4_MB_(25.00%)
+
+import java.util.function.Consumer
+
+class Solution {
+    fun replaceWords(dictionary: List<String>, sentence: String): String {
+        val trie = Trie()
+        dictionary.forEach(Consumer { word: String -> trie.insert(word) })
+        val allWords = sentence.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        for (i in allWords.indices) {
+            allWords[i] = trie.getRootForWord(allWords[i])
+        }
+        return java.lang.String.join(" ", *allWords)
+    }
+
+    internal class Node {
+        var links = arrayOfNulls<Node>(26)
+        var isWordCompleted = false
+
+        fun containsKey(ch: Char): Boolean {
+            return links[ch.code - 'a'.code] != null
+        }
+
+        fun put(ch: Char, node: Node?) {
+            links[ch.code - 'a'.code] = node
+        }
+
+        operator fun get(ch: Char): Node? {
+            return links[ch.code - 'a'.code]
+        }
+    }
+
+    internal class Trie {
+        var root: Node = Node()
+
+        fun insert(word: String) {
+            var node: Node? = root
+            for (i in word.indices) {
+                if (!node!!.containsKey(word[i])) {
+                    node.put(word[i], Node())
+                }
+                node = node[word[i]]
+            }
+            node!!.isWordCompleted = true
+        }
+
+        fun getRootForWord(word: String): String {
+            var node: Node? = root
+            val rootWord = StringBuilder()
+            for (i in word.indices) {
+                if (node!!.containsKey(word[i])) {
+                    rootWord.append(word[i])
+                    node = node[word[i]]
+                    if (node!!.isWordCompleted) {
+                        return rootWord.toString()
+                    }
+                } else {
+                    return word
+                }
+            }
+            return word
+        }
+    }
+}

src/main/kotlin/g0601_0700/s0648_replace_words/readme.md

@@ -0,0 +1,33 @@
+648\. Replace Words
+
+Medium
+
+In English, we have a concept called **root**, which can be followed by some other word to form another longer word - let's call this word **successor**. For example, when the **root** `"an"` is followed by the **successor** word `"other"`, we can form a new word `"another"`.
+
+Given a `dictionary` consisting of many **roots** and a `sentence` consisting of words separated by spaces, replace all the **successors** in the sentence with the **root** forming it. If a **successor** can be replaced by more than one **root**, replace it with the **root** that has **the shortest length**.
+
+Return _the `sentence`_ after the replacement.
+
+**Example 1:**
+
+**Input:** dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"
+
+**Output:** "the cat was rat by the bat"
+
+**Example 2:**
+
+**Input:** dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
+
+**Output:** "a a b c"
+
+**Constraints:**
+
+*   `1 <= dictionary.length <= 1000`
+*   `1 <= dictionary[i].length <= 100`
+*   `dictionary[i]` consists of only lower-case letters.
+*   <code>1 <= sentence.length <= 10<sup>6</sup></code>
+*   `sentence` consists of only lower-case letters and spaces.
+*   The number of words in `sentence` is in the range `[1, 1000]`
+*   The length of each word in `sentence` is in the range `[1, 1000]`
+*   Every two consecutive words in `sentence` will be separated by exactly one space.
+*   `sentence` does not have leading or trailing spaces.

src/test/kotlin/g0601_0700/s0643_maximum_average_subarray_i/SolutionTest.kt

@@ -0,0 +1,20 @@
+package g0601_0700.s0643_maximum_average_subarray_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findMaxAverage() {
+        assertThat(
+            Solution().findMaxAverage(intArrayOf(1, 12, -5, -6, 50, 3), 4),
+            equalTo(12.75000)
+        )
+    }
+
+    @Test
+    fun findMaxAverage2() {
+        assertThat(Solution().findMaxAverage(intArrayOf(5), 1), equalTo(5.00000))
+    }
+}