Added tasks 678, 679, 680, 682

Author: ThanhNIT

README.md

@@ -1676,6 +1676,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
+| 0682 |[Baseball Game](src/main/kotlin/g0601_0700/s0682_baseball_game/Solution.kt)| Easy | Array, Stack, Simulation | 159 | 100.00
+| 0680 |[Valid Palindrome II](src/main/kotlin/g0601_0700/s0680_valid_palindrome_ii/Solution.kt)| Easy | String, Greedy, Two_Pointers | 296 | 79.17
+| 0679 |[24 Game](src/main/kotlin/g0601_0700/s0679_24_game/Solution.kt)| Hard | Array, Math, Backtracking | 175 | 100.00
+| 0678 |[Valid Parenthesis String](src/main/kotlin/g0601_0700/s0678_valid_parenthesis_string/Solution.kt)| Medium | String, Dynamic_Programming, Greedy, Stack | 133 | 100.00
 | 0677 |[Map Sum Pairs](src/main/kotlin/g0601_0700/s0677_map_sum_pairs/MapSum.kt)| Medium | String, Hash_Table, Design, Trie | 197 | 80.00
 | 0676 |[Implement Magic Dictionary](src/main/kotlin/g0601_0700/s0676_implement_magic_dictionary/MagicDictionary.kt)| Medium | String, Hash_Table, Design, Trie | 256 | 100.00
 | 0675 |[Cut Off Trees for Golf Event](src/main/kotlin/g0601_0700/s0675_cut_off_trees_for_golf_event/Solution.kt)| Hard | Array, Breadth_First_Search, Matrix, Heap_Priority_Queue | 777 | 100.00

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

@@ -0,0 +1,20 @@
+package g0601_0700.s0678_valid_parenthesis_string
+
+// #Medium #String #Dynamic_Programming #Greedy #Stack
+// #2023_02_16_Time_133_ms_(100.00%)_Space_33.8_MB_(46.15%)
+
+class Solution {
+    fun checkValidString(s: String): Boolean {
+        var lo = 0
+        var hi = 0
+        for (i in s.indices) {
+            lo += if (s[i] == '(') 1 else -1
+            hi += if (s[i] != ')') 1 else -1
+            if (hi < 0) {
+                break
+            }
+            lo = 0.coerceAtLeast(lo)
+        }
+        return lo == 0
+    }
+}

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

@@ -0,0 +1,35 @@
+678\. Valid Parenthesis String
+
+Medium
+
+Given a string `s` containing only three types of characters: `'('`, `')'` and `'*'`, return `true` _if_ `s` _is **valid**_.
+
+The following rules define a **valid** string:
+
+*   Any left parenthesis `'('` must have a corresponding right parenthesis `')'`.
+*   Any right parenthesis `')'` must have a corresponding left parenthesis `'('`.
+*   Left parenthesis `'('` must go before the corresponding right parenthesis `')'`.
+*   `'*'` could be treated as a single right parenthesis `')'` or a single left parenthesis `'('` or an empty string `""`.
+
+**Example 1:**
+
+**Input:** s = "()"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "(\*)"
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** s = "(\*))"
+
+**Output:** true
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s[i]` is `'('`, `')'` or `'*'`.

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

@@ -0,0 +1,61 @@
+package g0601_0700.s0679_24_game
+
+// #Hard #Array #Math #Backtracking #2023_02_16_Time_175_ms_(100.00%)_Space_34.7_MB_(100.00%)
+
+import java.util.Arrays
+import kotlin.math.abs
+
+class Solution {
+    private fun backtrack(list: DoubleArray, n: Int): Boolean {
+        if (n == 1) {
+            return abs(list[0] - 24) < EPS
+        }
+        for (i in 0 until n) {
+            for (j in i + 1 until n) {
+                val a = list[i]
+                val b = list[j]
+                list[j] = list[n - 1]
+                list[i] = a + b
+                if (backtrack(list, n - 1)) {
+                    return true
+                }
+                list[i] = a - b
+                if (backtrack(list, n - 1)) {
+                    return true
+                }
+                list[i] = b - a
+                if (backtrack(list, n - 1)) {
+                    return true
+                }
+                list[i] = a * b
+                if (backtrack(list, n - 1)) {
+                    return true
+                }
+                if (Math.abs(b) > EPS) {
+                    list[i] = a / b
+                    if (backtrack(list, n - 1)) {
+                        return true
+                    }
+                }
+                if (Math.abs(a) > EPS) {
+                    list[i] = b / a
+                    if (backtrack(list, n - 1)) {
+                        return true
+                    }
+                }
+                list[i] = a
+                list[j] = b
+            }
+        }
+        return false
+    }
+
+    fun judgePoint24(nums: IntArray?): Boolean {
+        val a = Arrays.stream(nums).asDoubleStream().toArray()
+        return backtrack(a, a.size)
+    }
+
+    companion object {
+        private const val EPS = 1e-6
+    }
+}

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

@@ -0,0 +1,35 @@
+679\. 24 Game
+
+Hard
+
+You are given an integer array `cards` of length `4`. You have four cards, each containing a number in the range `[1, 9]`. You should arrange the numbers on these cards in a mathematical expression using the operators `['+', '-', '*', '/']` and the parentheses `'('` and `')'` to get the value 24.
+
+You are restricted with the following rules:
+
+*   The division operator `'/'` represents real division, not integer division.
+    *   For example, `4 / (1 - 2 / 3) = 4 / (1 / 3) = 12`.
+*   Every operation done is between two numbers. In particular, we cannot use `'-'` as a unary operator.
+    *   For example, if `cards = [1, 1, 1, 1]`, the expression `"-1 - 1 - 1 - 1"` is **not allowed**.
+*   You cannot concatenate numbers together
+    *   For example, if `cards = [1, 2, 1, 2]`, the expression `"12 + 12"` is not valid.
+
+Return `true` if you can get such expression that evaluates to `24`, and `false` otherwise.
+
+**Example 1:**
+
+**Input:** cards = [4,1,8,7]
+
+**Output:** true
+
+**Explanation:** (8-4) \* (7-1) = 24
+
+**Example 2:**
+
+**Input:** cards = [1,2,1,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   `cards.length == 4`
+*   `1 <= cards[i] <= 9`

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

@@ -0,0 +1,31 @@
+package g0601_0700.s0680_valid_palindrome_ii
+
+// #Easy #String #Greedy #Two_Pointers #2023_02_16_Time_296_ms_(79.17%)_Space_36.7_MB_(75.00%)
+
+class Solution {
+    fun validPalindrome(s: String): Boolean {
+        var l = 0
+        var r = s.length - 1
+        while (l < r) {
+            if (s[l] != s[r]) {
+                return isPalindrome(s.substring(l + 1, r + 1)) || isPalindrome(s.substring(l, r))
+            }
+            l++
+            r--
+        }
+        return true
+    }
+
+    private fun isPalindrome(s: String): Boolean {
+        var l = 0
+        var r = s.length - 1
+        while (l < r) {
+            if (s[l] != s[r]) {
+                return false
+            }
+            l++
+            r--
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,30 @@
+680\. Valid Palindrome II
+
+Easy
+
+Given a string `s`, return `true` _if the_ `s` _can be palindrome after deleting **at most one** character from it_.
+
+**Example 1:**
+
+**Input:** s = "aba"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "abca"
+
+**Output:** true
+
+**Explanation:** You could delete the character 'c'.
+
+**Example 3:**
+
+**Input:** s = "abc"
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

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

@@ -0,0 +1,22 @@
+package g0601_0700.s0682_baseball_game
+
+// #Easy #Array #Stack #Simulation #2023_02_16_Time_159_ms_(100.00%)_Space_35.7_MB_(62.50%)
+
+class Solution {
+    fun calPoints(ops: Array<String>): Int {
+        val resultList: MutableList<Int> = ArrayList(ops.size)
+        for (op in ops) {
+            val size = resultList.size
+            if ("C" == op) {
+                resultList.removeAt(size - 1)
+            } else if ("D" == op) {
+                resultList.add(resultList[size - 1] * 2)
+            } else if ("+" == op) {
+                resultList.add(resultList[size - 1] + resultList[size - 2])
+            } else {
+                resultList.add(op.toInt())
+            }
+        }
+        return resultList.stream().reduce(0) { a: Int, b: Int -> Integer.sum(a, b) }
+    }
+}

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

@@ -0,0 +1,60 @@
+682\. Baseball Game
+
+Easy
+
+You are keeping score for a baseball game with strange rules. The game consists of several rounds, where the scores of past rounds may affect future rounds' scores.
+
+At the beginning of the game, you start with an empty record. You are given a list of strings `ops`, where `ops[i]` is the <code>i<sup>th</sup></code> operation you must apply to the record and is one of the following:
+
+1.  An integer `x` - Record a new score of `x`.
+2.  `"+"` - Record a new score that is the sum of the previous two scores. It is guaranteed there will always be two previous scores.
+3.  `"D"` - Record a new score that is double the previous score. It is guaranteed there will always be a previous score.
+4.  `"C"` - Invalidate the previous score, removing it from the record. It is guaranteed there will always be a previous score.
+
+Return _the sum of all the scores on the record_.
+
+**Example 1:**
+
+**Input:** ops = ["5","2","C","D","+"]
+
+**Output:** 30
+
+**Explanation:**
+
+    "5" - Add 5 to the record, record is now [5]. 
+    "2" - Add 2 to the record, record is now [5, 2]. 
+    "C" - Invalidate and remove the previous score, record is now [5]. 
+    "D" - Add 2 \* 5 = 10 to the record, record is now [5, 10]. 
+    "+" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15]. 
+    The total sum is 5 + 10 + 15 = 30.
+
+**Example 2:**
+
+**Input:** ops = ["5","-2","4","C","D","9","+","+"]
+
+**Output:** 27
+
+**Explanation:**
+
+    "5" - Add 5 to the record, record is now [5]. 
+    "-2" - Add -2 to the record, record is now [5, -2]. 
+    "4" - Add 4 to the record, record is now [5, -2, 4]. 
+    "C" - Invalidate and remove the previous score, record is now [5, -2]. 
+    "D" - Add 2 \* -2 = -4 to the record, record is now [5, -2, -4]. 
+    "9" - Add 9 to the record, record is now [5, -2, -4, 9]. 
+    "+" - Add -4 + 9 = 5 to the record, record is now [5, -2, -4, 9, 5]. 
+    "+" - Add 9 + 5 = 14 to the record, record is now [5, -2, -4, 9, 5, 14]. 
+    The total sum is 5 + -2 + -4 + 9 + 5 + 14 = 27.
+
+**Example 3:**
+
+**Input:** ops = ["1"]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= ops.length <= 1000`
+*   `ops[i]` is `"C"`, `"D"`, `"+"`, or a string representing an integer in the range <code>[-3 * 10<sup>4</sup>, 3 * 10<sup>4</sup>]</code>.
+*   For operation `"+"`, there will always be at least two previous scores on the record.
+*   For operations `"C"` and `"D"`, there will always be at least one previous score on the record.

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

@@ -0,0 +1,22 @@
+package g0601_0700.s0678_valid_parenthesis_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun checkValidString() {
+        assertThat(Solution().checkValidString("()"), equalTo(true))
+    }
+
+    @Test
+    fun checkValidString2() {
+        assertThat(Solution().checkValidString("(*)"), equalTo(true))
+    }
+
+    @Test
+    fun checkValidString3() {
+        assertThat(Solution().checkValidString("(*))"), equalTo(true))
+    }
+}