Added tasks 392, 393, 395, 397.

Author: ThanhNIT

README.md

@@ -282,6 +282,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0392 |[Is Subsequence](src/main/kotlin/g0301_0400/s0392_is_subsequence/Solution.kt)| Easy | String, Dynamic_Programming, Two_Pointers | 156 | 87.74
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 307 | 38.36
 | 0072 |[Edit Distance](src.save/main/kotlin/g0001_0100/s0072_edit_distance/Solution.kt)| Hard | Top_100_Liked_Questions, String, Dynamic_Programming | 320 | 63.53
 
@@ -638,6 +639,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0205 |[Isomorphic Strings](src.save/main/kotlin/g0201_0300/s0205_isomorphic_strings/Solution.kt)| Easy | String, Hash_Table | 278 | 79.96
+| 0392 |[Is Subsequence](src/main/kotlin/g0301_0400/s0392_is_subsequence/Solution.kt)| Easy | String, Dynamic_Programming, Two_Pointers | 156 | 87.74
 
 #### Day 3 Linked List
 
@@ -916,6 +918,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0392 |[Is Subsequence](src/main/kotlin/g0301_0400/s0392_is_subsequence/Solution.kt)| Easy | String, Dynamic_Programming, Two_Pointers | 156 | 87.74
 | 0125 |[Valid Palindrome](src.save/main/kotlin/g0101_0200/s0125_valid_palindrome/Solution.kt)| Easy | Top_Interview_Questions, String, Two_Pointers | 353 | 52.06
 | 0026 |[Remove Duplicates from Sorted Array](src.save/main/kotlin/g0001_0100/s0026_remove_duplicates_from_sorted_array/Solution.kt)| Easy | Top_Interview_Questions, Array, Two_Pointers | 361 | 77.19
 | 0042 |[Trapping Rain Water](src.save/main/kotlin/g0001_0100/s0042_trapping_rain_water/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Two_Pointers, Stack, Monotonic_Stack | 196 | 100.00
@@ -1615,7 +1618,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 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
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
+| 0397 |[Integer Replacement](src/main/kotlin/g0301_0400/s0397_integer_replacement/Solution.kt)| Medium | Dynamic_Programming, Greedy, Bit_Manipulation, Memoization | 145 | 87.50
+| 0395 |[Longest Substring with At Least K Repeating Characters](src/main/kotlin/g0301_0400/s0395_longest_substring_with_at_least_k_repeating_characters/Solution.kt)| Medium | Top_Interview_Questions, String, Hash_Table, Sliding_Window, Divide_and_Conquer | 274 | 66.67
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
+| 0393 |[UTF-8 Validation](src/main/kotlin/g0301_0400/s0393_utf_8_validation/Solution.kt)| Medium | Array, Bit_Manipulation | 219 | 100.00
+| 0392 |[Is Subsequence](src/main/kotlin/g0301_0400/s0392_is_subsequence/Solution.kt)| Easy | String, Dynamic_Programming, Two_Pointers, Dynamic_Programming_I_Day_19, Level_1_Day_2_String, Udemy_Two_Pointers | 156 | 87.74
 | 0391 |[Perfect Rectangle](src/main/kotlin/g0301_0400/s0391_perfect_rectangle/Solution.kt)| Hard | Array, Line_Sweep | 897 | 100.00
 | 0390 |[Elimination Game](src/main/kotlin/g0301_0400/s0390_elimination_game/Solution.kt)| Medium | Math, Recursion | 319 | 55.56
 | 0389 |[Find the Difference](src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt)| Easy | String, Hash_Table, Sorting, Bit_Manipulation, Programming_Skills_I_Day_8_String, Udemy_Bit_Manipulation | 256 | 64.81

src/main/kotlin/g0301_0400/s0392_is_subsequence/Solution.kt

@@ -0,0 +1,17 @@
+package g0301_0400.s0392_is_subsequence
+
+// #Easy #String #Dynamic_Programming #Two_Pointers #Dynamic_Programming_I_Day_19
+// #Level_1_Day_2_String #Udemy_Two_Pointers
+// #2022_11_25_Time_156_ms_(87.74%)_Space_33.9_MB_(90.11%)
+
+class Solution {
+    fun isSubsequence(s: String, t: String): Boolean {
+        var i = 0
+        var j = 0
+        while (i < s.length && j < t.length) {
+            if (s[i] == t[j]) i++
+            j++
+        }
+        return i == s.length
+    }
+}

src/main/kotlin/g0301_0400/s0392_is_subsequence/readme.md

@@ -0,0 +1,27 @@
+392\. Is Subsequence
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if_ `s` _is a **subsequence** of_ `t`_, or_ `false` _otherwise_.
+
+A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of <code>"<ins>a</ins>b<ins>c</ins>d<ins>e</ins>"</code> while `"aec"` is not).
+
+**Example 1:**
+
+**Input:** s = "abc", t = "ahbgdc"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "axc", t = "ahbgdc"
+
+**Output:** false
+
+**Constraints:**
+
+*   `0 <= s.length <= 100`
+*   <code>0 <= t.length <= 10<sup>4</sup></code>
+*   `s` and `t` consist only of lowercase English letters.
+
+**Follow up:** Suppose there are lots of incoming `s`, say <code>s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub></code> where <code>k >= 10<sup>9</sup></code>, and you want to check one by one to see if `t` has its subsequence. In this scenario, how would you change your code?

src/main/kotlin/g0301_0400/s0393_utf_8_validation/Solution.kt

@@ -0,0 +1,29 @@
+package g0301_0400.s0393_utf_8_validation
+
+// #Medium #Array #Bit_Manipulation #2022_11_28_Time_219_ms_(100.00%)_Space_37_MB_(88.89%)
+
+class Solution {
+    fun validUtf8(data: IntArray): Boolean {
+        var count = 0
+        for (d in data) {
+            if (count == 0) {
+                if (d shr 5 == 6) {
+                    count = 1
+                } else if (d shr 4 == 14) {
+                    count = 2
+                } else if (d shr 3 == 30) {
+                    count = 3
+                } else if (d shr 7 == 1) {
+                    return false
+                }
+            } else {
+                if (d shr 6 != 2) {
+                    return false
+                } else {
+                    count--
+                }
+            }
+        }
+        return count == 0
+    }
+}

src/main/kotlin/g0301_0400/s0393_utf_8_validation/readme.md

@@ -0,0 +1,39 @@
+393\. UTF-8 Validation
+
+Medium
+
+Given an integer array `data` representing the data, return whether it is a valid **UTF-8** encoding (i.e. it translates to a sequence of valid UTF-8 encoded characters).
+
+A character in **UTF8** can be from **1 to 4 bytes** long, subjected to the following rules:
+
+1.  For a **1-byte** character, the first bit is a `0`, followed by its Unicode code.
+2.  For an **n-bytes** character, the first `n` bits are all one's, the `n + 1` bit is `0`, followed by `n - 1` bytes with the most significant `2` bits being `10`.
+
+This is how the UTF-8 encoding would work:
+
+Number of Bytes | UTF-8 Octet Sequence | (binary) --------------------+----------------------------------------- 1 | 0xxxxxxx 2 | 110xxxxx 10xxxxxx 3 | 1110xxxx 10xxxxxx 10xxxxxx 4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+`x` denotes a bit in the binary form of a byte that may be either `0` or `1`.
+
+**Note:** The input is an array of integers. Only the **least significant 8 bits** of each integer is used to store the data. This means each integer represents only 1 byte of data.
+
+**Example 1:**
+
+**Input:** data = [197,130,1]
+
+**Output:** true
+
+**Explanation:** data represents the octet sequence: 11000101 10000010 00000001. It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
+
+**Example 2:**
+
+**Input:** data = [235,140,4]
+
+**Output:** false
+
+**Explanation:** data represented the octet sequence: 11101011 10001100 00000100. The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character. The next byte is a continuation byte which starts with 10 and that's correct. But the second continuation byte does not start with 10, so it is invalid.
+
+**Constraints:**
+
+*   <code>1 <= data.length <= 2 * 10<sup>4</sup></code>
+*   `0 <= data[i] <= 255`

src/main/kotlin/g0301_0400/s0395_longest_substring_with_at_least_k_repeating_characters/Solution.kt

@@ -0,0 +1,30 @@
+package g0301_0400.s0395_longest_substring_with_at_least_k_repeating_characters
+
+// #Medium #Top_Interview_Questions #String #Hash_Table #Sliding_Window #Divide_and_Conquer
+// #2022_11_28_Time_274_ms_(66.67%)_Space_34_MB_(100.00%)
+
+class Solution {
+    fun longestSubstring(s: String, k: Int): Int {
+        return helper(s, k, 0, s.length)
+    }
+
+    private fun helper(s: String, k: Int, start: Int, end: Int): Int {
+        if (end - start < k) {
+            return 0
+        }
+        val nums = IntArray(26)
+        for (i in start until end) {
+            nums[s[i].code - 'a'.code]++
+        }
+        for (i in start until end) {
+            if (nums[s[i].code - 'a'.code] < k) {
+                var j = i + 1
+                while (j < s.length && nums[s[j].code - 'a'.code] < k) {
+                    j++
+                }
+                return Math.max(helper(s, k, start, i), helper(s, k, j, end))
+            }
+        }
+        return end - start
+    }
+}

src/main/kotlin/g0301_0400/s0395_longest_substring_with_at_least_k_repeating_characters/readme.md

@@ -0,0 +1,27 @@
+395\. Longest Substring with At Least K Repeating Characters
+
+Medium
+
+Given a string `s` and an integer `k`, return _the length of the longest substring of_ `s` _such that the frequency of each character in this substring is greater than or equal to_ `k`.
+
+**Example 1:**
+
+**Input:** s = "aaabb", k = 3
+
+**Output:** 3
+
+**Explanation:** The longest substring is "aaa", as 'a' is repeated 3 times.
+
+**Example 2:**
+
+**Input:** s = "ababbc", k = 2
+
+**Output:** 5
+
+**Explanation:** The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of only lowercase English letters.
+*   <code>1 <= k <= 10<sup>5</sup></code>

src/main/kotlin/g0301_0400/s0397_integer_replacement/Solution.kt

@@ -0,0 +1,49 @@
+package g0301_0400.s0397_integer_replacement
+
+// #Medium #Dynamic_Programming #Greedy #Bit_Manipulation #Memoization
+// #2022_11_28_Time_145_ms_(87.50%)_Space_33.1_MB_(87.50%)
+
+import java.util.LinkedList
+
+class Solution {
+    fun integerReplacement(n: Int): Int {
+        if (n == 1) return 0
+        val num = n.toLong()
+        val queue = LinkedList<Long>()
+        val seen = HashSet<Long>()
+        if (n % 2 == 0) {
+            queue.offer(num / 2)
+            seen.add(num / 2)
+        } else {
+            queue.offer(num + 1)
+            seen.add(num + 1)
+            queue.offer(num - 1)
+            seen.add(num - 1)
+        }
+        var steps = 1
+        while (queue.isNotEmpty()) {
+            val size = queue.size
+            for (sz in 0 until size) {
+                val cur = queue.poll()
+                if (cur == 1L) return steps
+                if (cur % 2 == 0L) {
+                    val next = cur / 2
+                    if (seen.add(next)) {
+                        queue.offer(next)
+                    }
+                } else {
+                    val next1 = cur + 1
+                    if (seen.add(next1)) {
+                        queue.offer(next1)
+                    }
+                    val next2 = cur - 1
+                    if (seen.add(next2)) {
+                        queue.offer(next2)
+                    }
+                }
+            }
+            ++steps
+        }
+        return steps
+    }
+}

src/main/kotlin/g0301_0400/s0397_integer_replacement/readme.md

@@ -0,0 +1,36 @@
+397\. Integer Replacement
+
+Medium
+
+Given a positive integer `n`, you can apply one of the following operations:
+
+1.  If `n` is even, replace `n` with `n / 2`.
+2.  If `n` is odd, replace `n` with either `n + 1` or `n - 1`.
+
+Return _the minimum number of operations needed for_ `n` _to become_ `1`.
+
+**Example 1:**
+
+**Input:** n = 8
+
+**Output:** 3
+
+**Explanation:** 8 -> 4 -> 2 -> 1
+
+**Example 2:**
+
+**Input:** n = 7
+
+**Output:** 4
+
+**Explanation:** 7 -> 8 -> 4 -> 2 -> 1 or 7 -> 6 -> 3 -> 2 -> 1
+
+**Example 3:**
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/test/kotlin/g0301_0400/s0392_is_subsequence/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0301_0400.s0392_is_subsequence
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isSubsequence() {
+        assertThat(Solution().isSubsequence("abc", "ahbgdc"), equalTo(true))
+    }
+
+    @Test
+    fun isSubsequence2() {
+        assertThat(Solution().isSubsequence("axc", "ahbgdc"), equalTo(false))
+    }
+}