Added tasks 1025, 1026, 1027, 1028

Author: ThanhNIT

README.md

@@ -1750,6 +1750,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 1028 |[Recover a Tree From Preorder Traversal](src/main/kotlin/g1001_1100/s1028_recover_a_tree_from_preorder_traversal/Solution.kt)| Hard | String, Depth_First_Search, Tree, Binary_Tree | 246 | 100.00
+| 1027 |[Longest Arithmetic Subsequence](src/main/kotlin/g1001_1100/s1027_longest_arithmetic_subsequence/Solution.kt)| Medium | Array, Hash_Table, Dynamic_Programming, Binary_Search | 330 | 100.00
+| 1026 |[Maximum Difference Between Node and Ancestor](src/main/kotlin/g1001_1100/s1026_maximum_difference_between_node_and_ancestor/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 155 | 77.78
+| 1025 |[Divisor Game](src/main/kotlin/g1001_1100/s1025_divisor_game/Solution.kt)| Easy | Dynamic_Programming, Math, Game_Theory, Brainteaser | 114 | 93.33
 | 1024 |[Video Stitching](src/main/kotlin/g1001_1100/s1024_video_stitching/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 141 | 100.00
 | 1023 |[Camelcase Matching](src/main/kotlin/g1001_1100/s1023_camelcase_matching/Solution.kt)| Medium | String, Two_Pointers, Trie, String_Matching | 149 | 60.00
 | 1022 |[Sum of Root To Leaf Binary Numbers](src/main/kotlin/g1001_1100/s1022_sum_of_root_to_leaf_binary_numbers/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 158 | 88.89

src/main/kotlin/g1001_1100/s1025_divisor_game/Solution.kt

@@ -0,0 +1,10 @@
+package g1001_1100.s1025_divisor_game
+
+// #Easy #Dynamic_Programming #Math #Game_Theory #Brainteaser
+// #2023_05_23_Time_114_ms_(93.33%)_Space_34.2_MB_(13.33%)
+
+class Solution {
+    fun divisorGame(n: Int): Boolean {
+        return n % 2 == 0
+    }
+}

src/main/kotlin/g1001_1100/s1025_divisor_game/readme.md

@@ -0,0 +1,34 @@
+1025\. Divisor Game
+
+Easy
+
+Alice and Bob take turns playing a game, with Alice starting first.
+
+Initially, there is a number `n` on the chalkboard. On each player's turn, that player makes a move consisting of:
+
+*   Choosing any `x` with `0 < x < n` and `n % x == 0`.
+*   Replacing the number `n` on the chalkboard with `n - x`.
+
+Also, if a player cannot make a move, they lose the game.
+
+Return `true` _if and only if Alice wins the game, assuming both players play optimally_.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** true
+
+**Explanation:** Alice chooses 1, and Bob has no more moves.
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** false
+
+**Explanation:** Alice chooses 1, Bob chooses 1, and Alice has no more moves.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/kotlin/g1001_1100/s1026_maximum_difference_between_node_and_ancestor/Solution.kt

@@ -0,0 +1,41 @@
+package g1001_1100.s1026_maximum_difference_between_node_and_ancestor
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree
+// #2023_05_23_Time_155_ms_(77.78%)_Space_36.6_MB_(48.15%)
+
+import com_github_leetcode.TreeNode
+import kotlin.math.abs
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var max = 0
+    fun maxAncestorDiff(root: TreeNode?): Int {
+        traverse(root, -1, -1)
+        return max
+    }
+
+    private fun traverse(root: TreeNode?, maxAncestor: Int, minAncestor: Int) {
+        if (root == null) {
+            return
+        }
+        if (maxAncestor == -1) {
+            traverse(root.left, root.`val`, root.`val`)
+            traverse(root.right, root.`val`, root.`val`)
+        }
+        if (maxAncestor != -1) {
+            max = max.coerceAtLeast(abs(maxAncestor - root.`val`))
+            max = max.coerceAtLeast(abs(minAncestor - root.`val`))
+            traverse(root.left, root.`val`.coerceAtLeast(maxAncestor), root.`val`.coerceAtMost(minAncestor))
+            traverse(root.right, root.`val`.coerceAtLeast(maxAncestor), root.`val`.coerceAtMost(minAncestor))
+        }
+    }
+}

src/main/kotlin/g1001_1100/s1026_maximum_difference_between_node_and_ancestor/readme.md

@@ -0,0 +1,40 @@
+1026\. Maximum Difference Between Node and Ancestor
+
+Medium
+
+Given the `root` of a binary tree, find the maximum value `v` for which there exist **different** nodes `a` and `b` where `v = |a.val - b.val|` and `a` is an ancestor of `b`.
+
+A node `a` is an ancestor of `b` if either: any child of `a` is equal to `b` or any child of `a` is an ancestor of `b`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg)
+
+**Input:** root = [8,3,10,1,6,null,14,null,null,4,7,13]
+
+**Output:** 7
+
+**Explanation:** We have various ancestor-node differences, some of which are given below : 
+
+|8 - 3| = 5 
+
+|3 - 7| = 4 
+
+|8 - 1| = 7 
+
+|10 - 13| = 3 
+
+Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg)
+
+**Input:** root = [1,null,2,null,0,3]
+
+**Output:** 3
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[2, 5000]`.
+*   <code>0 <= Node.val <= 10<sup>5</sup></code>

src/main/kotlin/g1001_1100/s1027_longest_arithmetic_subsequence/Solution.kt

@@ -0,0 +1,51 @@
+package g1001_1100.s1027_longest_arithmetic_subsequence
+
+// #Medium #Array #Hash_Table #Dynamic_Programming #Binary_Search
+// #2023_05_23_Time_330_ms_(100.00%)_Space_101.4_MB_(16.67%)
+
+import java.util.Arrays
+
+class Solution {
+    fun longestArithSeqLength(nums: IntArray): Int {
+        val max = maxElement(nums)
+        val min = minElement(nums)
+        val diff = max - min
+        val n = nums.size
+        val dp = Array(n) { IntArray(2 * diff + 2) }
+        for (d in dp) {
+            Arrays.fill(d, 1)
+        }
+        var ans = 0
+        for (i in 0 until n) {
+            for (j in i - 1 downTo 0) {
+                val difference = nums[i] - nums[j] + diff
+                val temp = dp[j][difference]
+                dp[i][difference] = Math.max(dp[i][difference], temp + 1)
+                if (ans < dp[i][difference]) {
+                    ans = dp[i][difference]
+                }
+            }
+        }
+        return ans
+    }
+
+    private fun maxElement(arr: IntArray): Int {
+        var max = Int.MIN_VALUE
+        for (e in arr) {
+            if (max < e) {
+                max = e
+            }
+        }
+        return max
+    }
+
+    private fun minElement(arr: IntArray): Int {
+        var min = Int.MAX_VALUE
+        for (e in arr) {
+            if (min > e) {
+                min = e
+            }
+        }
+        return min
+    }
+}

src/main/kotlin/g1001_1100/s1027_longest_arithmetic_subsequence/readme.md

@@ -0,0 +1,33 @@
+1027\. Longest Arithmetic Subsequence
+
+Medium
+
+Given an array `nums` of integers, return _the length of the longest arithmetic subsequence in_ `nums`.
+
+**Note** that:
+
+*   A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+*   A sequence `seq` is arithmetic if `seq[i + 1] - seq[i]` are all the same value (for `0 <= i < seq.length - 1`).
+
+**Example 1:**
+
+**Input:** nums = [3,6,9,12]
+
+**Output:** 4 **Explanation: ** The whole array is an arithmetic sequence with steps of length = 3.
+
+**Example 2:**
+
+**Input:** nums = [9,4,7,2,10]
+
+**Output:** 3 **Explanation: ** The longest arithmetic subsequence is [4,7,10].
+
+**Example 3:**
+
+**Input:** nums = [20,1,15,3,10,5,8]
+
+**Output:** 4 **Explanation: ** The longest arithmetic subsequence is [20,15,10,5].
+
+**Constraints:**
+
+*   `2 <= nums.length <= 1000`
+*   `0 <= nums[i] <= 500`

src/main/kotlin/g1001_1100/s1028_recover_a_tree_from_preorder_traversal/Solution.kt

@@ -0,0 +1,49 @@
+package g1001_1100.s1028_recover_a_tree_from_preorder_traversal
+
+// #Hard #String #Depth_First_Search #Tree #Binary_Tree
+// #2023_05_23_Time_246_ms_(100.00%)_Space_49.3_MB_(100.00%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var ptr = 0
+    fun recoverFromPreorder(traversal: String): TreeNode? {
+        return find(traversal, 0)
+    }
+
+    private fun find(traversal: String, level: Int): TreeNode? {
+        if (ptr == traversal.length) {
+            return null
+        }
+        var i = ptr
+        var count = 0
+        while (traversal[i] == '-') {
+            count++
+            i++
+        }
+        return if (count == level) {
+            val start = i
+            while (i < traversal.length && traversal[i] != '-') {
+                i++
+            }
+            val `val` = traversal.substring(start, i).toInt()
+            ptr = i
+            val root = TreeNode(`val`)
+            root.left = find(traversal, level + 1)
+            root.right = find(traversal, level + 1)
+            root
+        } else {
+            null
+        }
+    }
+}

src/main/kotlin/g1001_1100/s1028_recover_a_tree_from_preorder_traversal/readme.md

@@ -0,0 +1,40 @@
+1028\. Recover a Tree From Preorder Traversal
+
+Hard
+
+We run a preorder depth-first search (DFS) on the `root` of a binary tree.
+
+At each node in this traversal, we output `D` dashes (where `D` is the depth of this node), then we output the value of this node. If the depth of a node is `D`, the depth of its immediate child is `D + 1`. The depth of the `root` node is `0`.
+
+If a node has only one child, that child is guaranteed to be **the left child**.
+
+Given the output `traversal` of this traversal, recover the tree and return _its_ `root`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/04/08/recover-a-tree-from-preorder-traversal.png)
+
+**Input:** traversal = "1-2--3--4-5--6--7"
+
+**Output:** [1,2,5,3,4,6,7]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/04/11/screen-shot-2019-04-10-at-114101-pm.png)
+
+**Input:** traversal = "1-2--3---4-5--6---7"
+
+**Output:** [1,2,5,3,null,6,null,4,null,7]
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2019/04/11/screen-shot-2019-04-10-at-114955-pm.png)
+
+**Input:** traversal = "1-401--349---90--88"
+
+**Output:** [1,401,null,349,88,90]
+
+**Constraints:**
+
+*   The number of nodes in the original tree is in the range `[1, 1000]`.
+*   <code>1 <= Node.val <= 10<sup>9</sup></code>

src/test/kotlin/g1001_1100/s1025_divisor_game/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g1001_1100.s1025_divisor_game
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun divisorGame() {
+        assertThat(Solution().divisorGame(2), equalTo(true))
+    }
+
+    @Test
+    fun divisorGame2() {
+        assertThat(Solution().divisorGame(3), equalTo(false))
+    }
+}