Added tasks 717, 718, 719, 720

Author: ThanhNIT

README.md

@@ -1696,6 +1696,10 @@ 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
+| 0720 |[Longest Word in Dictionary](src/main/kotlin/g0701_0800/s0720_longest_word_in_dictionary/Solution.kt)| Medium | Array, String, Hash_Table, Sorting, Trie | 209 | 100.00
+| 0719 |[Find K-th Smallest Pair Distance](src/main/kotlin/g0701_0800/s0719_find_k_th_smallest_pair_distance/Solution.kt)| Hard | Array, Sorting, Binary_Search, Two_Pointers | 172 | 100.00
+| 0718 |[Maximum Length of Repeated Subarray](src/main/kotlin/g0701_0800/s0718_maximum_length_of_repeated_subarray/Solution.kt)| Medium | Array, Dynamic_Programming, Binary_Search, Sliding_Window, Hash_Function, Rolling_Hash | 270 | 91.43
+| 0717 |[1-bit and 2-bit Characters](src/main/kotlin/g0701_0800/s0717_1_bit_and_2_bit_characters/Solution.kt)| Easy | Array | 165 | 100.00
 | 0715 |[Range Module](src/main/kotlin/g0701_0800/s0715_range_module/RangeModule.kt)| Hard | Design, Ordered_Set, Segment_Tree | 638 | 58.33
 | 0714 |[Best Time to Buy and Sell Stock with Transaction Fee](src/main/kotlin/g0701_0800/s0714_best_time_to_buy_and_sell_stock_with_transaction_fee/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy, Dynamic_Programming_I_Day_8 | 417 | 90.91
 | 0713 |[Subarray Product Less Than K](src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt)| Medium | Array, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Udemy_Arrays | 336 | 92.11

src/main/kotlin/g0701_0800/s0717_1_bit_and_2_bit_characters/Solution.kt

@@ -0,0 +1,13 @@
+package g0701_0800.s0717_1_bit_and_2_bit_characters
+
+// #Easy #Array #2023_02_27_Time_165_ms_(100.00%)_Space_35.2_MB_(100.00%)
+
+class Solution {
+    fun isOneBitCharacter(arr: IntArray): Boolean {
+        var i = 0
+        while (i < arr.size - 1) {
+            i = if (arr[i] == 1) i + 2 else i + 1
+        }
+        return i == arr.size - 1
+    }
+}

src/main/kotlin/g0701_0800/s0717_1_bit_and_2_bit_characters/readme.md

@@ -0,0 +1,31 @@
+717\. 1-bit and 2-bit Characters
+
+Easy
+
+We have two special characters:
+
+*   The first character can be represented by one bit `0`.
+*   The second character can be represented by two bits (`10` or `11`).
+
+Given a binary array `bits` that ends with `0`, return `true` if the last character must be a one-bit character.
+
+**Example 1:**
+
+**Input:** bits = [1,0,0]
+
+**Output:** true
+
+**Explanation:** The only way to decode it is two-bit character and one-bit character. So the last character is one-bit character.
+
+**Example 2:**
+
+**Input:** bits = [1,1,1,0]
+
+**Output:** false
+
+**Explanation:** The only way to decode it is two-bit character and two-bit character. So the last character is not one-bit character.
+
+**Constraints:**
+
+*   `1 <= bits.length <= 1000`
+*   `bits[i]` is either `0` or `1`.

src/main/kotlin/g0701_0800/s0718_maximum_length_of_repeated_subarray/Solution.kt

@@ -0,0 +1,22 @@
+package g0701_0800.s0718_maximum_length_of_repeated_subarray
+
+// #Medium #Array #Dynamic_Programming #Binary_Search #Sliding_Window #Hash_Function #Rolling_Hash
+// #2023_02_27_Time_270_ms_(91.43%)_Space_45.6_MB_(48.57%)
+
+class Solution {
+    fun findLength(nums1: IntArray, nums2: IntArray): Int {
+        val m = nums1.size
+        val n = nums2.size
+        var max = 0
+        val dp = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                if (nums1[i - 1] == nums2[j - 1]) {
+                    dp[i][j] = 1 + dp[i - 1][j - 1]
+                    max = Math.max(max, dp[i][j])
+                }
+            }
+        }
+        return max
+    }
+}

src/main/kotlin/g0701_0800/s0718_maximum_length_of_repeated_subarray/readme.md

@@ -0,0 +1,26 @@
+718\. Maximum Length of Repeated Subarray
+
+Medium
+
+Given two integer arrays `nums1` and `nums2`, return _the maximum length of a subarray that appears in **both** arrays_.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
+
+**Output:** 3
+
+**Explanation:** The repeated subarray with maximum length is [3,2,1].
+
+**Example 2:**
+
+**Input:** nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
+
+**Output:** 5
+
+**Explanation:** The repeated subarray with maximum length is [0,0,0,0,0].
+
+**Constraints:**
+
+*   `1 <= nums1.length, nums2.length <= 1000`
+*   `0 <= nums1[i], nums2[i] <= 100`

src/main/kotlin/g0701_0800/s0719_find_k_th_smallest_pair_distance/Solution.kt

@@ -0,0 +1,35 @@
+package g0701_0800.s0719_find_k_th_smallest_pair_distance
+
+// #Hard #Array #Sorting #Binary_Search #Two_Pointers
+// #2023_02_27_Time_172_ms_(100.00%)_Space_37.2_MB_(100.00%)
+
+class Solution {
+    fun smallestDistancePair(nums: IntArray, k: Int): Int {
+        nums.sort()
+        val length = nums.size
+        val maxDiff = nums[length - 1] - nums[0]
+        var start = 0
+        var end = maxDiff
+        while (start < end) {
+            val mid = start + (end - start) / 2
+            if (isPair(nums, mid, k)) {
+                end = mid
+            } else {
+                start = mid + 1
+            }
+        }
+        return start
+    }
+
+    private fun isPair(nums: IntArray, mid: Int, k: Int): Boolean {
+        var count = 0
+        var i = 0
+        for (j in 1 until nums.size) {
+            while (nums[j] - nums[i] > mid) {
+                i++
+            }
+            count += j - i
+        }
+        return count >= k
+    }
+}

src/main/kotlin/g0701_0800/s0719_find_k_th_smallest_pair_distance/readme.md

@@ -0,0 +1,42 @@
+719\. Find K-th Smallest Pair Distance
+
+Hard
+
+The **distance of a pair** of integers `a` and `b` is defined as the absolute difference between `a` and `b`.
+
+Given an integer array `nums` and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest **distance among all the pairs**_ `nums[i]` _and_ `nums[j]` _where_ `0 <= i < j < nums.length`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,1], k = 1
+
+**Output:** 0
+
+**Explanation:** Here are all the pairs: 
+
+(1,3) -> 2 
+
+(1,1) -> 0 
+
+(3,1) -> 2 
+
+Then the 1<sup>st</sup> smallest distance pair is (1,1), and its distance is 0.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1], k = 2
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** nums = [1,6,1], k = 3
+
+**Output:** 5
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>2 <= n <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>6</sup></code>
+*   `1 <= k <= n * (n - 1) / 2`

src/main/kotlin/g0701_0800/s0720_longest_word_in_dictionary/Solution.kt

@@ -0,0 +1,45 @@
+package g0701_0800.s0720_longest_word_in_dictionary
+
+// #Medium #Array #String #Hash_Table #Sorting #Trie
+// #2023_02_27_Time_209_ms_(100.00%)_Space_37_MB_(83.33%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private val root = Node()
+    private var longestWord: String? = ""
+
+    private class Node {
+        var children: Array<Node?> = arrayOfNulls(26)
+        var str: String? = null
+
+        fun insert(curr: Node?, word: String) {
+            var curr = curr
+            for (element in word) {
+                if (curr!!.children[element.code - 'a'.code] == null) {
+                    curr.children[element.code - 'a'.code] = Node()
+                }
+                curr = curr.children[element.code - 'a'.code]
+            }
+            curr!!.str = word
+        }
+    }
+
+    fun longestWord(words: Array<String>): String? {
+        for (word in words) {
+            root.insert(root, word)
+        }
+        dfs(root)
+        return longestWord
+    }
+
+    private fun dfs(curr: Node?) {
+        for (i in 0..25) {
+            if (curr!!.children[i] != null && curr.children[i]!!.str != null) {
+                if (curr.children[i]!!.str!!.length > longestWord!!.length) {
+                    longestWord = curr.children[i]!!.str
+                }
+                dfs(curr.children[i])
+            }
+        }
+    }
+}

src/main/kotlin/g0701_0800/s0720_longest_word_in_dictionary/readme.md

@@ -0,0 +1,31 @@
+720\. Longest Word in Dictionary
+
+Medium
+
+Given an array of strings `words` representing an English Dictionary, return _the longest word in_ `words` _that can be built one character at a time by other words in_ `words`.
+
+If there is more than one possible answer, return the longest word with the smallest lexicographical order. If there is no answer, return the empty string.
+
+Note that the word should be built from left to right with each additional character being added to the end of a previous word.
+
+**Example 1:**
+
+**Input:** words = ["w","wo","wor","worl","world"]
+
+**Output:** "world"
+
+**Explanation:** The word "world" can be built one character at a time by "w", "wo", "wor", and "worl".
+
+**Example 2:**
+
+**Input:** words = ["a","banana","app","appl","ap","apply","apple"]
+
+**Output:** "apple"
+
+**Explanation:** Both "apply" and "apple" can be built from other words in the dictionary. However, "apple" is lexicographically smaller than "apply".
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 30`
+*   `words[i]` consists of lowercase English letters.

src/test/kotlin/g0701_0800/s0717_1_bit_and_2_bit_characters/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0701_0800.s0717_1_bit_and_2_bit_characters
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isOneBitCharacter() {
+        assertThat(Solution().isOneBitCharacter(intArrayOf(1, 0, 0)), equalTo(true))
+    }
+
+    @Test
+    fun isOneBitCharacter2() {
+        assertThat(Solution().isOneBitCharacter(intArrayOf(1, 1, 1, 0)), equalTo(false))
+    }
+}