Added tasks 826, 827, 828, 829

Author: ThanhNIT

README.md

@@ -1299,6 +1299,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0826 |[Most Profit Assigning Work](src/main/kotlin/g0801_0900/s0826_most_profit_assigning_work/Solution.kt)| Medium | Array, Sorting, Greedy, Binary_Search, Two_Pointers | 366 | 100.00
 | 0436 |[Find Right Interval](src.save/main/kotlin/g0401_0500/s0436_find_right_interval/Solution.kt)| Medium | Array, Sorting, Binary_Search | 333 | 100.00
 
 #### Day 12
@@ -1712,6 +1713,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
+| 0829 |[Consecutive Numbers Sum](src/main/kotlin/g0801_0900/s0829_consecutive_numbers_sum/Solution.kt)| Hard | Math, Enumeration | 151 | 100.00
+| 0828 |[Count Unique Characters of All Substrings of a Given String](src/main/kotlin/g0801_0900/s0828_count_unique_characters_of_all_substrings_of_a_given_string/Solution.kt)| Hard | String, Hash_Table, Dynamic_Programming | 216 | 100.00
+| 0827 |[Making A Large Island](src/main/kotlin/g0801_0900/s0827_making_a_large_island/Solution.kt)| Hard | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 985 | 100.00
+| 0826 |[Most Profit Assigning Work](src/main/kotlin/g0801_0900/s0826_most_profit_assigning_work/Solution.kt)| Medium | Array, Sorting, Greedy, Binary_Search, Two_Pointers, Binary_Search_II_Day_11 | 366 | 100.00
 | 0825 |[Friends Of Appropriate Ages](src/main/kotlin/g0801_0900/s0825_friends_of_appropriate_ages/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers | 278 | 100.00
 | 0824 |[Goat Latin](src/main/kotlin/g0801_0900/s0824_goat_latin/Solution.kt)| Easy | String | 146 | 100.00
 | 0823 |[Binary Trees With Factors](src/main/kotlin/g0801_0900/s0823_binary_trees_with_factors/Solution.kt)| Medium | Array, Hash_Table, Dynamic_Programming | 298 | 100.00

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

@@ -0,0 +1,22 @@
+package g0801_0900.s0826_most_profit_assigning_work
+
+// #Medium #Array #Sorting #Greedy #Binary_Search #Two_Pointers #Binary_Search_II_Day_11
+// #2023_03_25_Time_366_ms_(100.00%)_Space_42.9_MB_(83.33%)
+
+class Solution {
+    fun maxProfitAssignment(difficulty: IntArray, profit: IntArray, worker: IntArray): Int {
+        val n = 100000
+        val maxProfit = IntArray(n)
+        for (i in difficulty.indices) {
+            maxProfit[difficulty[i]] = maxProfit[difficulty[i]].coerceAtLeast(profit[i])
+        }
+        for (i in 1 until n) {
+            maxProfit[i] = maxProfit[i].coerceAtLeast(maxProfit[i - 1])
+        }
+        var sum = 0
+        for (efficiency in worker) {
+            sum += maxProfit[efficiency]
+        }
+        return sum
+    }
+}

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

@@ -0,0 +1,36 @@
+826\. Most Profit Assigning Work
+
+Medium
+
+You have `n` jobs and `m` workers. You are given three arrays: `difficulty`, `profit`, and `worker` where:
+
+*   `difficulty[i]` and `profit[i]` are the difficulty and the profit of the <code>i<sup>th</sup></code> job, and
+*   `worker[j]` is the ability of <code>j<sup>th</sup></code> worker (i.e., the <code>j<sup>th</sup></code> worker can only complete a job with difficulty at most `worker[j]`).
+
+Every worker can be assigned **at most one job**, but one job can be **completed multiple times**.
+
+*   For example, if three workers attempt the same job that pays `$1`, then the total profit will be `$3`. If a worker cannot complete any job, their profit is `$0`.
+
+Return the maximum profit we can achieve after assigning the workers to the jobs.
+
+**Example 1:**
+
+**Input:** difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
+
+**Output:** 100
+
+**Explanation:** Workers are assigned jobs of difficulty [4,4,6,6] and they get a profit of [20,20,30,30] separately.
+
+**Example 2:**
+
+**Input:** difficulty = [85,47,57], profit = [24,66,99], worker = [40,25,25]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == difficulty.length`
+*   `n == profit.length`
+*   `m == worker.length`
+*   <code>1 <= n, m <= 10<sup>4</sup></code>
+*   <code>1 <= difficulty[i], profit[i], worker[i] <= 10<sup>5</sup></code>

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

@@ -0,0 +1,90 @@
+package g0801_0900.s0827_making_a_large_island
+
+// #Hard #Array #Depth_First_Search #Breadth_First_Search #Matrix #Union_Find
+// #2023_03_25_Time_985_ms_(100.00%)_Space_92.1_MB_(33.33%)
+
+class Solution {
+    private lateinit var p: IntArray
+    private lateinit var s: IntArray
+
+    private fun makeSet(x: Int, y: Int, rl: Int) {
+        val a = x * rl + y
+        p[a] = a
+        s[a] = 1
+    }
+
+    private fun comb(x1: Int, y1: Int, x2: Int, y2: Int, rl: Int) {
+        var a = find(x1 * rl + y1)
+        var b = find(x2 * rl + y2)
+        if (a == b) {
+            return
+        }
+        if (s[a] < s[b]) {
+            val t = a
+            a = b
+            b = t
+        }
+        p[b] = a
+        s[a] += s[b]
+    }
+
+    private fun find(a: Int): Int {
+        if (p[a] == a) {
+            return a
+        }
+        p[a] = find(p[a])
+        return p[a]
+    }
+
+    fun largestIsland(grid: Array<IntArray>): Int {
+        val rl = grid.size
+        val cl = grid[0].size
+        p = IntArray(rl * cl)
+        s = IntArray(rl * cl)
+        for (i in 0 until rl) {
+            for (j in 0 until cl) {
+                if (grid[i][j] == 0) {
+                    continue
+                }
+                makeSet(i, j, rl)
+                if (i > 0 && grid[i - 1][j] == 1) {
+                    comb(i, j, i - 1, j, rl)
+                }
+                if (j > 0 && grid[i][j - 1] == 1) {
+                    comb(i, j, i, j - 1, rl)
+                }
+            }
+        }
+        var m = 0
+        var t: Int
+        val sz: HashMap<Int, Int> = HashMap()
+        for (i in 0 until rl) {
+            for (j in 0 until cl) {
+                if (grid[i][j] == 0) {
+                    // find root, check if same and combine size
+                    t = 1
+                    if (i > 0 && grid[i - 1][j] == 1) {
+                        sz[find((i - 1) * rl + j)] = s[find((i - 1) * rl + j)]
+                    }
+                    if (j > 0 && grid[i][j - 1] == 1) {
+                        sz[find(i * rl + j - 1)] = s[find(i * rl + j - 1)]
+                    }
+                    if (i < rl - 1 && grid[i + 1][j] == 1) {
+                        sz[find((i + 1) * rl + j)] = s[find((i + 1) * rl + j)]
+                    }
+                    if (j < cl - 1 && grid[i][j + 1] == 1) {
+                        sz[find(i * rl + j + 1)] = s[find(i * rl + j + 1)]
+                    }
+                    for (`val` in sz.values) {
+                        t += `val`
+                    }
+                    m = m.coerceAtLeast(t)
+                    sz.clear()
+                } else {
+                    m = m.coerceAtLeast(s[i * rl + j])
+                }
+            }
+        }
+        return m
+    }
+}

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

@@ -0,0 +1,40 @@
+827\. Making A Large Island
+
+Hard
+
+You are given an `n x n` binary matrix `grid`. You are allowed to change **at most one** `0` to be `1`.
+
+Return _the size of the largest **island** in_ `grid` _after applying this operation_.
+
+An **island** is a 4-directionally connected group of `1`s.
+
+**Example 1:**
+
+**Input:** grid = [[1,0],[0,1]]
+
+**Output:** 3
+
+**Explanation:** Change one 0 to 1 and connect two 1s, then we get an island with area = 3.
+
+**Example 2:**
+
+**Input:** grid = [[1,1],[1,0]]
+
+**Output:** 4
+
+**Explanation:** Change the 0 to 1 and make the island bigger, only one island with area = 4.
+
+**Example 3:**
+
+**Input:** grid = [[1,1],[1,1]]
+
+**Output:** 4
+
+**Explanation:** Can't change any 0 to 1, only one island with area = 4.
+
+**Constraints:**
+
+*   `n == grid.length`
+*   `n == grid[i].length`
+*   `1 <= n <= 500`
+*   `grid[i][j]` is either `0` or `1`.

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

@@ -0,0 +1,49 @@
+package g0801_0900.s0828_count_unique_characters_of_all_substrings_of_a_given_string
+
+// #Hard #String #Hash_Table #Dynamic_Programming
+// #2023_03_25_Time_216_ms_(100.00%)_Space_37.1_MB_(50.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun uniqueLetterString(s: String): Int {
+        // Store last index of a character.
+        val lastCharIdx = IntArray(26)
+        // Store last to last index of a character.
+        // Eg. For ABA - lastCharIdx = 2, prevLastCharIdx = 0.
+        val prevLastCharIdx = IntArray(26)
+        Arrays.fill(lastCharIdx, -1)
+        Arrays.fill(prevLastCharIdx, -1)
+        val len = s.length
+        val dp = IntArray(len)
+        var account = 1
+        dp[0] = 1
+        lastCharIdx[s[0].code - 'A'.code] = 0
+        prevLastCharIdx[s[0].code - 'A'.code] = 0
+        for (i in 1 until len) {
+            val ch = s[i]
+            val chIdx = ch.code - 'A'.code
+            val lastSeenIdx = lastCharIdx[chIdx]
+            val prevLastIdx = prevLastCharIdx[chIdx]
+            dp[i] = dp[i - 1] + 1
+            if (lastSeenIdx == -1) {
+                dp[i] += i
+            } else {
+                // Add count for curr index from index of last char appearance.
+                dp[i] += i - lastSeenIdx - 1
+                if (prevLastIdx == lastSeenIdx) {
+                    // if last char idx is the only appearance of the char from left so far,
+                    // substrings that overlap [0, lastSeenIdx] will need count to be discounted, as
+                    // current char will cause duplication.
+                    dp[i] -= lastSeenIdx + 1
+                } else {
+                    dp[i] -= lastSeenIdx - prevLastIdx
+                }
+            }
+            prevLastCharIdx[chIdx] = lastSeenIdx
+            lastCharIdx[chIdx] = i
+            account += dp[i]
+        }
+        return account
+    }
+}

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

@@ -0,0 +1,42 @@
+828\. Count Unique Characters of All Substrings of a Given String
+
+Hard
+
+Let's define a function `countUniqueChars(s)` that returns the number of unique characters on `s`.
+
+*   For example, calling `countUniqueChars(s)` if `s = "LEETCODE"` then `"L"`, `"T"`, `"C"`, `"O"`, `"D"` are the unique characters since they appear only once in `s`, therefore `countUniqueChars(s) = 5`.
+
+Given a string `s`, return the sum of `countUniqueChars(t)` where `t` is a substring of `s`. The test cases are generated such that the answer fits in a 32-bit integer.
+
+Notice that some substrings can be repeated so in this case you have to count the repeated ones too.
+
+**Example 1:**
+
+**Input:** s = "ABC"
+
+**Output:** 10
+
+**Explanation:** All possible substrings are: "A","B","C","AB","BC" and "ABC".
+
+Every substring is composed with only unique letters. 
+
+Sum of lengths of all substring is 1 + 1 + 1 + 2 + 2 + 3 = 10
+
+**Example 2:**
+
+**Input:** s = "ABA"
+
+**Output:** 8
+
+**Explanation:** The same as example 1, except `countUniqueChars`("ABA") = 1.
+
+**Example 3:**
+
+**Input:** s = "LEETCODE"
+
+**Output:** 92
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of uppercase English letters only.

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

@@ -0,0 +1,25 @@
+package g0801_0900.s0829_consecutive_numbers_sum
+
+// #Hard #Math #Enumeration #2023_03_25_Time_151_ms_(100.00%)_Space_33.6_MB_(100.00%)
+
+class Solution {
+    fun consecutiveNumbersSum(n: Int): Int {
+        var ans = 0
+        var i = 1
+        while (i * i <= n) {
+            if (n % i > 0) {
+                i++
+                continue
+            }
+            val j = n / i
+            if (i % 2 == 1) {
+                ans++
+            }
+            if (j != i && j % 2 == 1) {
+                ans++
+            }
+            i++
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,33 @@
+829\. Consecutive Numbers Sum
+
+Hard
+
+Given an integer `n`, return _the number of ways you can write_ `n` _as the sum of consecutive positive integers._
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** 2
+
+**Explanation:** 5 = 2 + 3
+
+**Example 2:**
+
+**Input:** n = 9
+
+**Output:** 3
+
+**Explanation:** 9 = 4 + 5 = 2 + 3 + 4
+
+**Example 3:**
+
+**Input:** n = 15
+
+**Output:** 4
+
+**Explanation:** 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>

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

@@ -0,0 +1,29 @@
+package g0801_0900.s0826_most_profit_assigning_work
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxProfitAssignment() {
+        assertThat(
+            Solution()
+                .maxProfitAssignment(
+                    intArrayOf(2, 4, 6, 8, 10),
+                    intArrayOf(10, 20, 30, 40, 50),
+                    intArrayOf(4, 5, 6, 7)
+                ),
+            equalTo(100)
+        )
+    }
+
+    @Test
+    fun maxProfitAssignment2() {
+        assertThat(
+            Solution()
+                .maxProfitAssignment(intArrayOf(85, 47, 57), intArrayOf(24, 66, 99), intArrayOf(40, 25, 25)),
+            equalTo(0)
+        )
+    }
+}