Added tasks 2301-2312

Author: ThanhNIT

src/main/kotlin/g2301_2400/s2301_match_substring_after_replacement/Solution.kt

@@ -0,0 +1,45 @@
+package g2301_2400.s2301_match_substring_after_replacement
+
+// #Hard #Array #String #Hash_Table #String_Matching
+// #2023_06_29_Time_343_ms_(100.00%)_Space_44.5_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private lateinit var c1: CharArray
+    private lateinit var c2: CharArray
+    private lateinit var al: Array<MutableSet<Char>?>
+    fun matchReplacement(s: String, sub: String, mappings: Array<CharArray>): Boolean {
+        c1 = s.toCharArray()
+        c2 = sub.toCharArray()
+        al = arrayOfNulls(75)
+        for (i in 0..74) {
+            val temp: MutableSet<Char> = HashSet()
+            al[i] = temp
+        }
+        for (mapping in mappings) {
+            al[mapping[0].code - '0'.code]!!.add(mapping[1])
+        }
+        return ans(c1.size, c2.size) == 1
+    }
+
+    private fun ans(m: Int, n: Int): Int {
+        var m = m
+        var n = n
+        if (m == 0) {
+            return 0
+        }
+        if (ans(m - 1, n) == 1) {
+            return 1
+        }
+        if (m >= n && (c1[m - 1] == c2[n - 1] || al[c2[n - 1].code - '0'.code]!!.contains(c1[m - 1]))) {
+            while (n >= 1 && (c1[m - 1] == c2[n - 1] || al[c2[n - 1].code - '0'.code]!!.contains(c1[m - 1]))) {
+                n--
+                m--
+            }
+            if (n == 0) {
+                return 1
+            }
+        }
+        return 0
+    }
+}

src/main/kotlin/g2301_2400/s2301_match_substring_after_replacement/readme.md

@@ -0,0 +1,48 @@
+2301\. Match Substring After Replacement
+
+Hard
+
+You are given two strings `s` and `sub`. You are also given a 2D character array `mappings` where <code>mappings[i] = [old<sub>i</sub>, new<sub>i</sub>]</code> indicates that you may **replace** any number of <code>old<sub>i</sub></code> characters of `sub` with <code>new<sub>i</sub></code>. Each character in `sub` **cannot** be replaced more than once.
+
+Return `true` _if it is possible to make_ `sub` _a substring of_ `s` _by replacing zero or more characters according to_ `mappings`. Otherwise, return `false`.
+
+A **substring** is a contiguous non-empty sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "fool3e7bar", sub = "leet", mappings = [["e","3"],["t","7"],["t","8"]]
+
+**Output:** true
+
+**Explanation:** Replace the first 'e' in sub with '3' and 't' in sub with '7'.
+
+Now sub = "l3e7" is a substring of s, so we return true.
+
+**Example 2:**
+
+**Input:** s = "fooleetbar", sub = "f00l", mappings = [["o","0"]]
+
+**Output:** false
+
+**Explanation:** The string "f00l" is not a substring of s and no replacements can be made.
+
+Note that we cannot replace '0' with 'o'. 
+
+**Example 3:**
+
+**Input:** s = "Fool33tbaR", sub = "leetd", mappings = [["e","3"],["t","7"],["t","8"],["d","b"],["p","b"]]
+
+**Output:** true
+
+**Explanation:** Replace the first and second 'e' in sub with '3' and 'd' in sub with 'b'.
+
+Now sub = "l33tb" is a substring of s, so we return true. 
+
+**Constraints:**
+
+*   `1 <= sub.length <= s.length <= 5000`
+*   `0 <= mappings.length <= 1000`
+*   `mappings[i].length == 2`
+*   <code>old<sub>i</sub> != new<sub>i</sub></code>
+*   `s` and `sub` consist of uppercase and lowercase English letters and digits.
+*   <code>old<sub>i</sub></code> and <code>new<sub>i</sub></code> are either uppercase or lowercase English letters or digits.

src/main/kotlin/g2301_2400/s2302_count_subarrays_with_score_less_than_k/Solution.kt

@@ -0,0 +1,21 @@
+package g2301_2400.s2302_count_subarrays_with_score_less_than_k
+
+// #Hard #Array #Binary_Search #Prefix_Sum #Sliding_Window
+// #2023_06_29_Time_556_ms_(100.00%)_Space_55.3_MB_(100.00%)
+
+class Solution {
+    fun countSubarrays(nums: IntArray, k: Long): Long {
+        var sum: Long = 0
+        var count: Long = 0
+        var i = 0
+        var j = 0
+        while (i < nums.size) {
+            sum += nums[i].toLong()
+            while (sum * (i - j + 1) >= k) {
+                sum -= nums[j++].toLong()
+            }
+            count += (i++ - j + 1).toLong()
+        }
+        return count
+    }
+}

src/main/kotlin/g2301_2400/s2302_count_subarrays_with_score_less_than_k/readme.md

@@ -0,0 +1,55 @@
+2302\. Count Subarrays With Score Less Than K
+
+Hard
+
+The **score** of an array is defined as the **product** of its sum and its length.
+
+*   For example, the score of `[1, 2, 3, 4, 5]` is `(1 + 2 + 3 + 4 + 5) * 5 = 75`.
+
+Given a positive integer array `nums` and an integer `k`, return _the **number of non-empty subarrays** of_ `nums` _whose score is **strictly less** than_ `k`.
+
+A **subarray** is a contiguous sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [2,1,4,3,5], k = 10
+
+**Output:** 6
+
+**Explanation:**
+
+The 6 subarrays having scores less than 10 are:
+
+- [2] with score 2 \* 1 = 2.
+
+- [1] with score 1 \* 1 = 1.
+
+- [4] with score 4 \* 1 = 4.
+
+- [3] with score 3 \* 1 = 3.
+
+- [5] with score 5 \* 1 = 5.
+
+- [2,1] with score (2 + 1) \* 2 = 6.
+
+Note that subarrays such as [1,4] and [4,3,5] are not considered because their scores are 10 and 36 respectively, while we need scores strictly less than 10.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1], k = 5
+
+**Output:** 5
+
+**Explanation:**
+
+Every subarray except [1,1,1] has a score less than 5.
+
+[1,1,1] has a score (1 + 1 + 1) \* 3 = 9, which is greater than 5.
+
+Thus, there are 5 subarrays having scores less than 5. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= k <= 10<sup>15</sup></code>

src/main/kotlin/g2301_2400/s2303_calculate_amount_paid_in_taxes/Solution.kt

@@ -0,0 +1,21 @@
+package g2301_2400.s2303_calculate_amount_paid_in_taxes
+
+// #Easy #Array #Simulation #2023_06_29_Time_213_ms_(100.00%)_Space_40.4_MB_(100.00%)
+
+class Solution {
+    fun calculateTax(brackets: Array<IntArray>, income: Int): Double {
+        // you can remove this line
+        if (income == 0) {
+            return 0.0
+        }
+        var sum = 0.0
+        var prev = 0.0
+        for (bracket in brackets) {
+            val salary = bracket[0].coerceAtMost(income).toDouble()
+            val tax = bracket[1].toDouble()
+            sum += (salary - prev) * tax
+            prev = salary
+        }
+        return sum / 100
+    }
+}

src/main/kotlin/g2301_2400/s2303_calculate_amount_paid_in_taxes/readme.md

@@ -0,0 +1,60 @@
+2303\. Calculate Amount Paid in Taxes
+
+Easy
+
+You are given a **0-indexed** 2D integer array `brackets` where <code>brackets[i] = [upper<sub>i</sub>, percent<sub>i</sub>]</code> means that the <code>i<sup>th</sup></code> tax bracket has an upper bound of <code>upper<sub>i</sub></code> and is taxed at a rate of <code>percent<sub>i</sub></code>. The brackets are **sorted** by upper bound (i.e. <code>upper<sub>i-1</sub> < upper<sub>i</sub></code> for `0 < i < brackets.length`).
+
+Tax is calculated as follows:
+
+*   The first <code>upper<sub>0</sub></code> dollars earned are taxed at a rate of <code>percent<sub>0</sub></code>.
+*   The next <code>upper<sub>1</sub> - upper<sub>0</sub></code> dollars earned are taxed at a rate of <code>percent<sub>1</sub></code>.
+*   The next <code>upper<sub>2</sub> - upper<sub>1</sub></code> dollars earned are taxed at a rate of <code>percent<sub>2</sub></code>.
+*   And so on.
+
+You are given an integer `income` representing the amount of money you earned. Return _the amount of money that you have to pay in taxes._ Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+**Input:** brackets = [[3,50],[7,10],[12,25]], income = 10
+
+**Output:** 2.65000
+
+**Explanation:**
+
+The first 3 dollars you earn are taxed at 50%. You have to pay $3 \* 50% = $1.50 dollars in taxes.
+
+The next 7 - 3 = 4 dollars you earn are taxed at 10%. You have to pay $4 \* 10% = $0.40 dollars in taxes.
+
+The final 10 - 7 = 3 dollars you earn are taxed at 25%. You have to pay $3 \* 25% = $0.75 dollars in taxes. You have to pay a total of $1.50 + $0.40 + $0.75 = $2.65 dollars in taxes. 
+
+**Example 2:**
+
+**Input:** brackets = [[1,0],[4,25],[5,50]], income = 2
+
+**Output:** 0.25000
+
+**Explanation:**
+
+The first dollar you earn is taxed at 0%. You have to pay $1 \* 0% = $0 dollars in taxes.
+
+The second dollar you earn is taxed at 25%. You have to pay $1 \* 25% = $0.25 dollars in taxes.
+
+You have to pay a total of $0 + $0.25 = $0.25 dollars in taxes. 
+
+**Example 3:**
+
+**Input:** brackets = [[2,50]], income = 0
+
+**Output:** 0.00000
+
+**Explanation:** You have no income to tax, so you have to pay a total of $0 dollars in taxes. 
+
+**Constraints:**
+
+*   `1 <= brackets.length <= 100`
+*   <code>1 <= upper<sub>i</sub> <= 1000</code>
+*   <code>0 <= percent<sub>i</sub> <= 100</code>
+*   `0 <= income <= 1000`
+*   <code>upper<sub>i</sub></code> is sorted in ascending order.
+*   All the values of <code>upper<sub>i</sub></code> are **unique**.
+*   The upper bound of the last tax bracket is greater than or equal to `income`.

src/main/kotlin/g2301_2400/s2304_minimum_path_cost_in_a_grid/Solution.kt

@@ -0,0 +1,27 @@
+package g2301_2400.s2304_minimum_path_cost_in_a_grid
+
+// #Medium #Array #Dynamic_Programming #Matrix
+// #2023_06_29_Time_1048_ms_(100.00%)_Space_71.7_MB_(100.00%)
+
+class Solution {
+    fun minPathCost(grid: Array<IntArray>, moveCost: Array<IntArray>): Int {
+        val m = grid.size
+        val n = grid[0].size
+        val dp = Array(m) { IntArray(n) }
+        System.arraycopy(grid[m - 1], 0, dp[m - 1], 0, n)
+        for (i in m - 2 downTo 0) {
+            for (j in 0 until n) {
+                var min = Int.MAX_VALUE
+                for (k in 0 until n) {
+                    min = min.coerceAtMost(grid[i][j] + moveCost[grid[i][j]][k] + dp[i + 1][k])
+                }
+                dp[i][j] = min
+            }
+        }
+        var min = Int.MAX_VALUE
+        for (s in dp[0]) {
+            min = min.coerceAtMost(s)
+        }
+        return min
+    }
+}

src/main/kotlin/g2301_2400/s2304_minimum_path_cost_in_a_grid/readme.md

@@ -0,0 +1,51 @@
+2304\. Minimum Path Cost in a Grid
+
+Medium
+
+You are given a **0-indexed** `m x n` integer matrix `grid` consisting of **distinct** integers from `0` to `m * n - 1`. You can move in this matrix from a cell to any other cell in the **next** row. That is, if you are in cell `(x, y)` such that `x < m - 1`, you can move to any of the cells `(x + 1, 0)`, `(x + 1, 1)`, ..., `(x + 1, n - 1)`. **Note** that it is not possible to move from cells in the last row.
+
+Each possible move has a cost given by a **0-indexed** 2D array `moveCost` of size `(m * n) x n`, where `moveCost[i][j]` is the cost of moving from a cell with value `i` to a cell in column `j` of the next row. The cost of moving from cells in the last row of `grid` can be ignored.
+
+The cost of a path in `grid` is the **sum** of all values of cells visited plus the **sum** of costs of all the moves made. Return _the **minimum** cost of a path that starts from any cell in the **first** row and ends at any cell in the **last** row._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/04/28/griddrawio-2.png)
+
+**Input:** grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]
+
+**Output:** 17
+
+**Explanation:** The path with the minimum possible cost is the path 5 -> 0 -> 1.
+
+- The sum of the values of cells visited is 5 + 0 + 1 = 6.
+
+- The cost of moving from 5 to 0 is 3.
+
+- The cost of moving from 0 to 1 is 8.
+
+So the total cost of the path is 6 + 3 + 8 = 17.
+
+**Example 2:**
+
+**Input:** grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]
+
+**Output:** 6
+
+**Explanation:** The path with the minimum possible cost is the path 2 -> 3.
+
+- The sum of the values of cells visited is 2 + 3 = 5.
+
+- The cost of moving from 2 to 3 is 1.
+
+So the total cost of this path is 5 + 1 = 6.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 50`
+*   `grid` consists of distinct integers from `0` to `m * n - 1`.
+*   `moveCost.length == m * n`
+*   `moveCost[i].length == n`
+*   `1 <= moveCost[i][j] <= 100`

src/main/kotlin/g2301_2400/s2305_fair_distribution_of_cookies/Solution.kt

@@ -0,0 +1,32 @@
+package g2301_2400.s2305_fair_distribution_of_cookies
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2023_06_29_Time_255_ms_(100.00%)_Space_33.7_MB_(100.00%)
+
+class Solution {
+    private var res = Int.MAX_VALUE
+    fun distributeCookies(c: IntArray, k: Int): Int {
+        val nums = IntArray(k)
+        dfs(c, nums, 0)
+        return res
+    }
+
+    private fun dfs(c: IntArray, nums: IntArray, cur: Int) {
+        if (cur == c.size) {
+            var r = 0
+            for (num in nums) {
+                r = r.coerceAtLeast(num)
+            }
+            res = res.coerceAtMost(r)
+            return
+        }
+        for (i in nums.indices) {
+            if (nums[i] + c[cur] > res) {
+                continue
+            }
+            nums[i] += c[cur]
+            dfs(c, nums, cur + 1)
+            nums[i] -= c[cur]
+        }
+    }
+}