Added tasks 842, 843, 844, 845

Author: ThanhNIT

README.md

@@ -295,6 +295,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0844 |[Backspace String Compare](src/main/kotlin/g0801_0900/s0844_backspace_string_compare/Solution.kt)| Easy | String, Two_Pointers, Stack, Simulation | 126 | 98.31
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion | 224 | 64.86
 
 #### Day 15 Heap
@@ -1036,6 +1037,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0844 |[Backspace String Compare](src/main/kotlin/g0801_0900/s0844_backspace_string_compare/Solution.kt)| Easy | String, Two_Pointers, Stack, Simulation | 126 | 98.31
 | 0011 |[Container With Most Water](src/main/kotlin/g0001_0100/s0011_container_with_most_water/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Greedy, Two_Pointers | 474 | 89.18
 
 #### Day 5 Sliding Window
@@ -1715,6 +1717,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
 | 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
+| 0845 |[Longest Mountain in Array](src/main/kotlin/g0801_0900/s0845_longest_mountain_in_array/Solution.kt)| Medium | Array, Dynamic_Programming, Two_Pointers, Enumeration | 222 | 100.00
+| 0844 |[Backspace String Compare](src/main/kotlin/g0801_0900/s0844_backspace_string_compare/Solution.kt)| Easy | String, Two_Pointers, Stack, Simulation, Algorithm_II_Day_4_Two_Pointers, Level_1_Day_14_Stack | 126 | 98.31
+| 0843 |[Guess the Word](src/main/kotlin/g0801_0900/s0843_guess_the_word/Solution.kt)| Hard | Array, String, Math, Game_Theory, Interactive | 75 | 100.00
+| 0842 |[Split Array into Fibonacci Sequence](src/main/kotlin/g0801_0900/s0842_split_array_into_fibonacci_sequence/Solution.kt)| Medium | String, Backtracking | 142 | 100.00
 | 0841 |[Keys and Rooms](src/main/kotlin/g0801_0900/s0841_keys_and_rooms/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Data_Structure_II_Day_19_Graph, Graph_Theory_I_Day_7_Standard_Traversal | 189 | 69.23
 | 0840 |[Magic Squares In Grid](src/main/kotlin/g0801_0900/s0840_magic_squares_in_grid/Solution.kt)| Medium | Array, Math, Matrix | 149 | 100.00
 | 0839 |[Similar String Groups](src/main/kotlin/g0801_0900/s0839_similar_string_groups/Solution.kt)| Hard | Array, String, Depth_First_Search, Breadth_First_Search, Union_Find | 205 | 100.00

src/main/kotlin/g0801_0900/s0842_split_array_into_fibonacci_sequence/Solution.kt

@@ -0,0 +1,38 @@
+package g0801_0900.s0842_split_array_into_fibonacci_sequence
+
+// #Medium #String #Backtracking #2023_03_29_Time_142_ms_(100.00%)_Space_35_MB_(100.00%)
+
+class Solution {
+    fun splitIntoFibonacci(num: String): List<Int> {
+        val res: MutableList<Int> = ArrayList()
+        solve(num, res, 0)
+        return res
+    }
+
+    private fun solve(s: String, res: MutableList<Int>, idx: Int): Boolean {
+        if (idx == s.length && res.size >= 3) {
+            return true
+        }
+        for (i in idx until s.length) {
+            if (s[idx] == '0' && i > idx) {
+                return false
+            }
+            val num = s.substring(idx, i + 1).toLong()
+            if (num > Int.MAX_VALUE) {
+                return false
+            }
+            val size = res.size
+            if (size >= 2 && num > res[size - 1] + res[size - 2]) {
+                return false
+            }
+            if (size <= 1 || num == (res[size - 1] + res[size - 2]).toLong()) {
+                res.add(num.toInt())
+                if (solve(s, res, i + 1)) {
+                    return true
+                }
+                res.removeAt(res.size - 1)
+            }
+        }
+        return false
+    }
+}

src/main/kotlin/g0801_0900/s0842_split_array_into_fibonacci_sequence/readme.md

@@ -0,0 +1,44 @@
+842\. Split Array into Fibonacci Sequence
+
+Medium
+
+You are given a string of digits `num`, such as `"123456579"`. We can split it into a Fibonacci-like sequence `[123, 456, 579]`.
+
+Formally, a **Fibonacci-like** sequence is a list `f` of non-negative integers such that:
+
+*   <code>0 <= f[i] < 2<sup>31</sup></code>, (that is, each integer fits in a **32-bit** signed integer type),
+*   `f.length >= 3`, and
+*   `f[i] + f[i + 1] == f[i + 2]` for all `0 <= i < f.length - 2`.
+
+Note that when splitting the string into pieces, each piece must not have extra leading zeroes, except if the piece is the number `0` itself.
+
+Return any Fibonacci-like sequence split from `num`, or return `[]` if it cannot be done.
+
+**Example 1:**
+
+**Input:** num = "1101111"
+
+**Output:** [11,0,11,11]
+
+**Explanation:** The output [110, 1, 111] would also be accepted.
+
+**Example 2:**
+
+**Input:** num = "112358130"
+
+**Output:** []
+
+**Explanation:** The task is impossible.
+
+**Example 3:**
+
+**Input:** num = "0123"
+
+**Output:** []
+
+**Explanation:** Leading zeroes are not allowed, so "01", "2", "3" is not valid.
+
+**Constraints:**
+
+*   `1 <= num.length <= 200`
+*   `num` contains only digits.

src/main/kotlin/g0801_0900/s0843_guess_the_word/Solution.kt

@@ -0,0 +1,59 @@
+package g0801_0900.s0843_guess_the_word
+
+// #Hard #Array #String #Math #Game_Theory #Interactive
+// #2023_03_29_Time_75_ms_(100.00%)_Space_31.5_MB_(100.00%)
+
+import java.util.Collections
+
+/*
+ * // This is the Master's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface Master {
+ *     fun guess(word: String): Int {}
+ * }
+ */
+class Solution {
+    interface Master {
+        fun guess(word: String): Int
+    }
+
+    private var next = 0
+
+    fun findSecretWord(wordlist: Array<String>, master: Master) {
+        val list = listOf(*wordlist)
+        Collections.shuffle(list)
+        val test = BooleanArray(wordlist.size)
+        while (true) {
+            val num = master.guess(list[next])
+            if (num == 6) {
+                break
+            }
+            updateList(list, test, num)
+        }
+    }
+
+    private fun updateList(list: List<String?>, test: BooleanArray, num: Int) {
+        val index = next
+        for (i in index + 1 until test.size) {
+            if (test[i]) {
+                continue
+            }
+            val samePart = getSame(list[index], list[i])
+            if (samePart != num) {
+                test[i] = true
+            } else if (next == index) {
+                next = i
+            }
+        }
+    }
+
+    private fun getSame(word1: String?, word2: String?): Int {
+        var ret = 0
+        for (i in 0..5) {
+            if (word1!![i] == word2!![i]) {
+                ret++
+            }
+        }
+        return ret
+    }
+}

src/main/kotlin/g0801_0900/s0843_guess_the_word/readme.md

@@ -0,0 +1,43 @@
+843\. Guess the Word
+
+Hard
+
+This is an **_interactive problem_**.
+
+You are given an array of **unique** strings `wordlist` where `wordlist[i]` is `6` letters long, and one word in this list is chosen as `secret`.
+
+You may call `Master.guess(word)` to guess a word. The guessed word should have type `string` and must be from the original list with `6` lowercase letters.
+
+This function returns an `integer` type, representing the number of exact matches (value and position) of your guess to the `secret` word. Also, if your guess is not in the given wordlist, it will return `-1` instead.
+
+For each test case, you have exactly `10` guesses to guess the word. At the end of any number of calls, if you have made `10` or fewer calls to `Master.guess` and at least one of these guesses was `secret`, then you pass the test case.
+
+**Example 1:**
+
+**Input:** secret = "acckzz", wordlist = ["acckzz","ccbazz","eiowzz","abcczz"], numguesses = 10
+
+**Output:** You guessed the secret word correctly.
+
+**Explanation:**
+
+    master.guess("aaaaaa") returns -1, because "aaaaaa" is not in wordlist.
+    master.guess("acckzz") returns 6, because "acckzz" is secret and has all 6 matches.
+    master.guess("ccbazz") returns 3, because "ccbazz" has 3 matches.
+    master.guess("eiowzz") returns 2, because "eiowzz" has 2 matches.
+    master.guess("abcczz") returns 4, because "abcczz" has 4 matches.
+    We made 5 calls to master.guess and one of them was the secret, so we pass the test case. 
+
+**Example 2:**
+
+**Input:** secret = "hamada", wordlist = ["hamada","khaled"], numguesses = 10
+
+**Output:** You guessed the secret word correctly.
+
+**Constraints:**
+
+*   `1 <= wordlist.length <= 100`
+*   `wordlist[i].length == 6`
+*   `wordlist[i]` consist of lowercase English letters.
+*   All the strings of `wordlist` are **unique**.
+*   `secret` exists in `wordlist`.
+*   `numguesses == 10`

src/main/kotlin/g0801_0900/s0844_backspace_string_compare/Solution.kt

@@ -0,0 +1,28 @@
+package g0801_0900.s0844_backspace_string_compare
+
+// #Easy #String #Two_Pointers #Stack #Simulation #Algorithm_II_Day_4_Two_Pointers
+// #Level_1_Day_14_Stack #2023_03_29_Time_126_ms_(98.31%)_Space_33.5_MB_(93.22%)
+
+class Solution {
+    fun backspaceCompare(s: String, t: String): Boolean {
+        return cmprStr(s) == cmprStr(t)
+    }
+
+    private fun cmprStr(str: String): String {
+        val res = StringBuilder()
+        var count = 0
+        for (i in str.length - 1 downTo 0) {
+            val currChar = str[i]
+            if (currChar == '#') {
+                count++
+            } else {
+                if (count > 0) {
+                    count--
+                } else {
+                    res.append(currChar)
+                }
+            }
+        }
+        return res.toString()
+    }
+}

src/main/kotlin/g0801_0900/s0844_backspace_string_compare/readme.md

@@ -0,0 +1,38 @@
+844\. Backspace String Compare
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if they are equal when both are typed into empty text editors_. `'#'` means a backspace character.
+
+Note that after backspacing an empty text, the text will continue empty.
+
+**Example 1:**
+
+**Input:** s = "ab#c", t = "ad#c"
+
+**Output:** true
+
+**Explanation:** Both s and t become "ac".
+
+**Example 2:**
+
+**Input:** s = "ab##", t = "c#d#"
+
+**Output:** true
+
+**Explanation:** Both s and t become "".
+
+**Example 3:**
+
+**Input:** s = "a#c", t = "b"
+
+**Output:** false
+
+**Explanation:** s becomes "c" while t becomes "b".
+
+**Constraints:**
+
+*   `1 <= s.length, t.length <= 200`
+*   `s` and `t` only contain lowercase letters and `'#'` characters.
+
+**Follow up:** Can you solve it in `O(n)` time and `O(1)` space?

src/main/kotlin/g0801_0900/s0845_longest_mountain_in_array/Solution.kt

@@ -0,0 +1,30 @@
+package g0801_0900.s0845_longest_mountain_in_array
+
+// #Medium #Array #Dynamic_Programming #Two_Pointers #Enumeration
+// #2023_03_29_Time_222_ms_(100.00%)_Space_38.4_MB_(16.67%)
+
+class Solution {
+    fun longestMountain(arr: IntArray): Int {
+        var s = 0
+        var i = 1
+        while (i < arr.size - 1) {
+            if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) {
+                var j = i
+                var tem = 1
+                while (j > 0 && arr[j] > arr[j - 1]) {
+                    j--
+                    tem++
+                }
+                j = i
+                while (j < arr.size - 1 && arr[j] > arr[j + 1]) {
+                    j++
+                    tem++
+                }
+                s = s.coerceAtLeast(tem)
+                i = j
+            }
+            i++
+        }
+        return s
+    }
+}

src/main/kotlin/g0801_0900/s0845_longest_mountain_in_array/readme.md

@@ -0,0 +1,38 @@
+845\. Longest Mountain in Array
+
+Medium
+
+You may recall that an array `arr` is a **mountain array** if and only if:
+
+*   `arr.length >= 3`
+*   There exists some index `i` (**0-indexed**) with `0 < i < arr.length - 1` such that:
+    *   `arr[0] < arr[1] < ... < arr[i - 1] < arr[i]`
+    *   `arr[i] > arr[i + 1] > ... > arr[arr.length - 1]`
+
+Given an integer array `arr`, return _the length of the longest subarray, which is a mountain_. Return `0` if there is no mountain subarray.
+
+**Example 1:**
+
+**Input:** arr = [2,1,4,7,3,2,5]
+
+**Output:** 5
+
+**Explanation:** The largest mountain is [1,4,7,3,2] which has length 5.
+
+**Example 2:**
+
+**Input:** arr = [2,2,2]
+
+**Output:** 0
+
+**Explanation:** There is no mountain.
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   <code>0 <= arr[i] <= 10<sup>4</sup></code>
+
+**Follow up:**
+
+*   Can you solve it using only one pass?
+*   Can you solve it in `O(1)` space?

src/test/kotlin/g0801_0900/s0842_split_array_into_fibonacci_sequence/SolutionTest.kt

@@ -0,0 +1,27 @@
+package g0801_0900.s0842_split_array_into_fibonacci_sequence
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun splitIntoFibonacci() {
+        assertThat(
+            Solution().splitIntoFibonacci("1101111"),
+            equalTo(listOf(11, 0, 11, 11))
+        )
+    }
+
+    @Test
+    fun splitIntoFibonacci2() {
+        assertThat(
+            Solution().splitIntoFibonacci("112358130"), equalTo(emptyList())
+        )
+    }
+
+    @Test
+    fun splitIntoFibonacci3() {
+        assertThat(Solution().splitIntoFibonacci("0123"), equalTo(emptyList()))
+    }
+}