Added tasks 810, 811, 812, 813

Author: ThanhNIT

README.md

@@ -1711,6 +1711,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
+| 0813 |[Largest Sum of Averages](src/main/kotlin/g0801_0900/s0813_largest_sum_of_averages/Solution.kt)| Medium | Array, Dynamic_Programming | 160 | 100.00
+| 0812 |[Largest Triangle Area](src/main/kotlin/g0801_0900/s0812_largest_triangle_area/Solution.kt)| Easy | Array, Math, Geometry | 156 | 71.43
+| 0811 |[Subdomain Visit Count](src/main/kotlin/g0801_0900/s0811_subdomain_visit_count/Solution.kt)| Medium | Array, String, Hash_Table, Counting | 220 | 100.00
+| 0810 |[Chalkboard XOR Game](src/main/kotlin/g0801_0900/s0810_chalkboard_xor_game/Solution.kt)| Hard | Array, Math, Bit_Manipulation, Game_Theory, Brainteaser | 172 | 100.00
 | 0809 |[Expressive Words](src/main/kotlin/g0801_0900/s0809_expressive_words/Solution.kt)| Medium | Array, String, Two_Pointers | 158 | 100.00
 | 0808 |[Soup Servings](src/main/kotlin/g0801_0900/s0808_soup_servings/Solution.kt)| Medium | Dynamic_Programming, Math, Probability_and_Statistics | 112 | 100.00
 | 0807 |[Max Increase to Keep City Skyline](src/main/kotlin/g0801_0900/s0807_max_increase_to_keep_city_skyline/Solution.kt)| Medium | Array, Greedy, Matrix | 158 | 100.00

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

@@ -0,0 +1,14 @@
+package g0801_0900.s0810_chalkboard_xor_game
+
+// #Hard #Array #Math #Bit_Manipulation #Game_Theory #Brainteaser
+// #2023_03_17_Time_172_ms_(100.00%)_Space_37_MB_(33.33%)
+
+class Solution {
+    fun xorGame(nums: IntArray): Boolean {
+        var xor = 0
+        for (i in nums) {
+            xor = xor xor i
+        }
+        return xor == 0 || nums.size and 1 == 0
+    }
+}

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

@@ -0,0 +1,50 @@
+810\. Chalkboard XOR Game
+
+Hard
+
+You are given an array of integers `nums` represents the numbers written on a chalkboard.
+
+Alice and Bob take turns erasing exactly one number from the chalkboard, with Alice starting first. If erasing a number causes the bitwise XOR of all the elements of the chalkboard to become `0`, then that player loses. The bitwise XOR of one element is that element itself, and the bitwise XOR of no elements is `0`.
+
+Also, if any player starts their turn with the bitwise XOR of all the elements of the chalkboard equal to `0`, then that player wins.
+
+Return `true` _if and only if Alice wins the game, assuming both players play optimally_.
+
+**Example 1:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** false
+
+**Explanation:**
+
+Alice has two choices: erase 1 or erase 2.
+
+If she erases 1, the nums array becomes [1, 2].
+
+The bitwise XOR of all the elements of the chalkboard is 1 XOR 2 = 3.
+
+Now Bob can remove any element he wants, because Alice will be the one to erase the last element and she will lose.
+
+If Alice erases 2 first, now nums become [1, 1].
+
+The bitwise XOR of all the elements of the chalkboard is 1 XOR 1 = 0.
+
+Alice will lose.
+
+**Example 2:**
+
+**Input:** nums = [0,1]
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** true
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>0 <= nums[i] < 2<sup>16</sup></code>

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

@@ -0,0 +1,46 @@
+package g0801_0900.s0811_subdomain_visit_count
+
+// #Medium #Array #String #Hash_Table #Counting
+// #2023_03_17_Time_220_ms_(100.00%)_Space_36.6_MB_(100.00%)
+
+class Solution {
+    fun subdomainVisits(d: Array<String>): List<String> {
+        val fmap: MutableMap<String, Int> = HashMap()
+        for (s in d) {
+            var rep = 0
+            var i: Int = 0
+            while (i < s.length) {
+                val c = s[i]
+                rep = if (c in '0'..'9') {
+                    rep * 10 + (c.code - '0'.code)
+                } else {
+                    break
+                }
+                i++
+            }
+            val str = s.substring(i + 1)
+            seperate(rep, str, fmap)
+        }
+        val res: MutableList<String> = ArrayList()
+        for (entry in fmap.entries.iterator()) {
+            var comp = ""
+            comp += entry.value
+            comp += " "
+            comp += entry.key
+            res.add(comp)
+        }
+        return res
+    }
+
+    private fun seperate(rep: Int, s: String, fmap: MutableMap<String, Int>) {
+        var i = s.length - 1
+        while (i >= 0) {
+            while (i >= 0 && s[i] != '.') {
+                i--
+            }
+            val toHash: String = s.substring(i + 1)
+            fmap[toHash] = fmap.getOrDefault(toHash, 0) + rep
+            i--
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+811\. Subdomain Visit Count
+
+Medium
+
+A website domain `"discuss.leetcode.com"` consists of various subdomains. At the top level, we have `"com"`, at the next level, we have `"leetcode.com"` and at the lowest level, `"discuss.leetcode.com"`. When we visit a domain like `"discuss.leetcode.com"`, we will also visit the parent domains `"leetcode.com"` and `"com"` implicitly.
+
+A **count-paired domain** is a domain that has one of the two formats `"rep d1.d2.d3"` or `"rep d1.d2"` where `rep` is the number of visits to the domain and `d1.d2.d3` is the domain itself.
+
+*   For example, `"9001 discuss.leetcode.com"` is a **count-paired domain** that indicates that `discuss.leetcode.com` was visited `9001` times.
+
+Given an array of **count-paired domains** `cpdomains`, return _an array of the **count-paired domains** of each subdomain in the input_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** cpdomains = ["9001 discuss.leetcode.com"]
+
+**Output:** ["9001 leetcode.com","9001 discuss.leetcode.com","9001 com"]
+
+**Explanation:** We only have one website domain: "discuss.leetcode.com". As discussed above, the subdomain "leetcode.com" and "com" will also be visited. So they will all be visited 9001 times.
+
+**Example 2:**
+
+**Input:** cpdomains = ["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]
+
+**Output:** ["901 mail.com","50 yahoo.com","900 google.mail.com","5 wiki.org","5 org","1 intel.mail.com","951 com"]
+
+**Explanation:** We will visit "google.mail.com" 900 times, "yahoo.com" 50 times, "intel.mail.com" once and "wiki.org" 5 times. For the subdomains, we will visit "mail.com" 900 + 1 = 901 times, "com" 900 + 50 + 1 = 951 times, and "org" 5 times.
+
+**Constraints:**
+
+*   `1 <= cpdomain.length <= 100`
+*   `1 <= cpdomain[i].length <= 100`
+*   `cpdomain[i]` follows either the <code>"rep<sub>i</sub> d1<sub>i</sub>.d2<sub>i</sub>.d3<sub>i</sub>"</code> format or the <code>"rep<sub>i</sub> d1<sub>i</sub>.d2<sub>i</sub>"</code> format.
+*   <code>rep<sub>i</sub></code> is an integer in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>d1<sub>i</sub></code>, <code>d2<sub>i</sub></code>, and <code>d3<sub>i</sub></code> consist of lowercase English letters.

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

@@ -0,0 +1,33 @@
+package g0801_0900.s0812_largest_triangle_area
+
+// #Easy #Array #Math #Geometry #2023_03_17_Time_156_ms_(71.43%)_Space_34.3_MB_(57.14%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun largestTriangleArea(points: Array<IntArray>): Double {
+        val n = points.size
+        var max = 0.0
+        for (i in 0 until n) {
+            for (j in i + 1 until n) {
+                for (k in j + 1 until n) {
+                    var area: Double
+                    val a = points[i]
+                    val b = points[j]
+                    val c = points[k]
+                    area = abs(area(a, b) + area(b, c) + area(c, a))
+                    if (area > max) {
+                        max = area
+                    }
+                }
+            }
+        }
+        return max
+    }
+
+    private fun area(a: IntArray, b: IntArray): Double {
+        val l = b[0] - a[0]
+        val h = (a[1] + b[1] + 200) / 2.0
+        return l * h
+    }
+}

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

@@ -0,0 +1,27 @@
+812\. Largest Triangle Area
+
+Easy
+
+Given an array of points on the **X-Y** plane `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>, return _the area of the largest triangle that can be formed by any three different points_. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/04/1027.png)
+
+**Input:** points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
+
+**Output:** 2.00000
+
+**Explanation:** The five points are shown in the above figure. The red triangle is the largest.
+
+**Example 2:**
+
+**Input:** points = [[1,0],[0,0],[0,1]]
+
+**Output:** 0.50000
+
+**Constraints:**
+
+*   `3 <= points.length <= 50`
+*   <code>-50 <= x<sub>i</sub>, y<sub>i</sub> <= 50</code>
+*   All the given points are **unique**.

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

@@ -0,0 +1,27 @@
+package g0801_0900.s0813_largest_sum_of_averages
+
+// #Medium #Array #Dynamic_Programming #2023_03_17_Time_160_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+class Solution {
+    fun largestSumOfAverages(nums: IntArray, k: Int): Double {
+        return helper(nums, k, 0, Array(k + 1) { arrayOfNulls(nums.size) })
+    }
+
+    private fun helper(nums: IntArray, k: Int, idx: Int, memo: Array<Array<Double?>>): Double {
+        if (memo[k][idx] != null) {
+            return memo[k][idx]!!
+        }
+        var maxAvg = 0.0
+        var sum = 0.0
+        for (i in idx..nums.size - k) {
+            sum += nums[i].toDouble()
+            if (k - 1 > 0) {
+                maxAvg = maxAvg.coerceAtLeast(sum / (i - idx + 1) + helper(nums, k - 1, i + 1, memo))
+            } else if (i == nums.size - 1) {
+                maxAvg = maxAvg.coerceAtLeast(sum / (i - idx + 1))
+            }
+        }
+        memo[k][idx] = maxAvg
+        return maxAvg
+    }
+}

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

@@ -0,0 +1,35 @@
+813\. Largest Sum of Averages
+
+Medium
+
+You are given an integer array `nums` and an integer `k`. You can partition the array into **at most** `k` non-empty adjacent subarrays. The **score** of a partition is the sum of the averages of each subarray.
+
+Note that the partition must use every integer in `nums`, and that the score is not necessarily an integer.
+
+Return _the maximum **score** you can achieve of all the possible partitions_. Answers within <code>10<sup>-6</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+**Input:** nums = [9,1,2,3,9], k = 3
+
+**Output:** 20.00000
+
+**Explanation:**
+
+The best choice is to partition nums into [9], [1, 2, 3], [9]. The answer is 9 + (1 + 2 + 3) / 3 + 9 = 20.
+
+We could have also partitioned nums into [9, 1], [2], [3, 9], for example.
+
+That partition would lead to a score of 5 + 2 + 6 = 13, which is worse.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4,5,6,7], k = 4
+
+**Output:** 20.50000
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>
+*   `1 <= k <= nums.length`

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

@@ -0,0 +1,22 @@
+package g0801_0900.s0810_chalkboard_xor_game
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun xorGame() {
+        assertThat(Solution().xorGame(intArrayOf(1, 1, 2)), equalTo(false))
+    }
+
+    @Test
+    fun xorGame2() {
+        assertThat(Solution().xorGame(intArrayOf(0, 1)), equalTo(true))
+    }
+
+    @Test
+    fun xorGame3() {
+        assertThat(Solution().xorGame(intArrayOf(1, 2, 3)), equalTo(true))
+    }
+}