Added tasks 2763-2768

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2763_sum_of_imbalance_numbers_of_all_subarrays/Solution.kt

@@ -0,0 +1,27 @@
+package g2701_2800.s2763_sum_of_imbalance_numbers_of_all_subarrays
+
+// #Hard #Array #Hash_Table #Ordered_Set #2023_08_11_Time_417_ms_(95.24%)_Space_40.2_MB_(95.24%)
+
+class Solution {
+    fun sumImbalanceNumbers(nums: IntArray): Int {
+        val n = nums.size
+        var ans = 0
+        for (i in 0 until n) {
+            val s: MutableSet<Int> = HashSet()
+            var curr = 0
+            for (j in i until n) {
+                val x = nums[j]
+                if (s.contains(x)) {
+                    // do nothing
+                } else if (s.contains(x - 1) && s.contains(x + 1)) {
+                    curr--
+                } else if (!s.contains(x - 1) && !s.contains(x + 1) && s.isNotEmpty()) {
+                    curr++
+                }
+                s.add(x)
+                ans += curr
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g2701_2800/s2763_sum_of_imbalance_numbers_of_all_subarrays/readme.md

@@ -0,0 +1,49 @@
+2763\. Sum of Imbalance Numbers of All Subarrays
+
+Hard
+
+The **imbalance number** of a **0-indexed** integer array `arr` of length `n` is defined as the number of indices in `sarr = sorted(arr)` such that:
+
+*   `0 <= i < n - 1`, and
+*   `sarr[i+1] - sarr[i] > 1`
+
+Here, `sorted(arr)` is the function that returns the sorted version of `arr`.
+
+Given a **0-indexed** integer array `nums`, return _the **sum of imbalance numbers** of all its **subarrays**_.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,4]
+
+**Output:** 3
+
+**Explanation:** There are 3 subarrays with non-zero imbalance numbers: 
+- Subarray [3, 1] with an imbalance number of 1. 
+- Subarray [3, 1, 4] with an imbalance number of 1. 
+- Subarray [1, 4] with an imbalance number of 1. 
+
+The imbalance number of all other subarrays is 0. Hence, the sum of imbalance numbers of all the subarrays of nums is 3.
+
+**Example 2:**
+
+**Input:** nums = [1,3,3,3,5]
+
+**Output:** 8
+
+**Explanation:** There are 7 subarrays with non-zero imbalance numbers: 
+- Subarray [1, 3] with an imbalance number of 1. 
+- Subarray [1, 3, 3] with an imbalance number of 1. 
+- Subarray [1, 3, 3, 3] with an imbalance number of 1. 
+- Subarray [1, 3, 3, 3, 5] with an imbalance number of 2. 
+- Subarray [3, 3, 3, 5] with an imbalance number of 1. 
+- Subarray [3, 3, 5] with an imbalance number of 1. 
+- Subarray [3, 5] with an imbalance number of 1. 
+
+The imbalance number of all other subarrays is 0. Hence, the sum of imbalance numbers of all the subarrays of nums is 8.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i] <= nums.length`

src/main/kotlin/g2701_2800/s2765_longest_alternating_subarray/Solution.kt

@@ -0,0 +1,30 @@
+package g2701_2800.s2765_longest_alternating_subarray
+
+// #Easy #Array #Enumeration #2023_08_11_Time_191_ms_(97.92%)_Space_42.2_MB_(41.67%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun alternatingSubarray(nums: IntArray): Int {
+        var result = -1
+        var prious = 0
+        var sum = 1
+        for (i in 1..nums.lastIndex) {
+            val s = nums[i] - nums[i - 1]
+            if (abs(s) != 1) {
+                sum = 1
+                continue
+            }
+            if (s == prious) {
+                sum = 2
+            }
+            if (s != prious) {
+                if (s != if (sum % 2 == 0) -1 else 1) continue
+                sum++
+                prious = s
+            }
+            result = maxOf(result, sum)
+        }
+        return result
+    }
+}

src/main/kotlin/g2701_2800/s2765_longest_alternating_subarray/readme.md

@@ -0,0 +1,34 @@
+2765\. Longest Alternating Subarray
+
+Easy
+
+You are given a **0-indexed** integer array `nums`. A subarray `s` of length `m` is called **alternating** if:
+
+*   `m` is greater than `1`.
+*   <code>s<sub>1</sub> = s<sub>0</sub> + 1</code>.
+*   The **0-indexed** subarray `s` looks like <code>[s<sub>0</sub>, s<sub>1</sub>, s<sub>0</sub>, s<sub>1</sub>,...,s<sub>(m-1) % 2</sub>]</code>. In other words, <code>s<sub>1</sub> - s<sub>0</sub> = 1</code>, <code>s<sub>2</sub> - s<sub>1</sub> = -1</code>, <code>s<sub>3</sub> - s<sub>2</sub> = 1</code>, <code>s<sub>4</sub> - s<sub>3</sub> = -1</code>, and so on up to <code>s[m - 1] - s[m - 2] = (-1)<sup>m</sup></code>.
+
+Return _the maximum length of all **alternating** subarrays present in_ `nums` _or_ `-1` _if no such subarray exists__._
+
+A subarray is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,4,3,4]
+
+**Output:** 4
+
+**Explanation:** The alternating subarrays are [3,4], [3,4,3], and [3,4,3,4]. The longest of these is [3,4,3,4], which is of length 4. 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6]
+
+**Output:** 2
+
+**Explanation:** [4,5] and [5,6] are the only two alternating subarrays. They are both of length 2. 
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>

src/main/kotlin/g2701_2800/s2766_relocate_marbles/Solution.kt

@@ -0,0 +1,18 @@
+package g2701_2800.s2766_relocate_marbles
+
+// #Medium #Array #Hash_Table #Sorting #Simulation
+// #2023_08_11_Time_1038_ms_(100.00%)_Space_79.8_MB_(51.61%)
+
+class Solution {
+    fun relocateMarbles(nums: IntArray, moveFrom: IntArray, moveTo: IntArray): List<Int> {
+        val s = HashSet<Int>()
+        nums.forEach { s.add(it) }
+        for (i in moveTo.indices) {
+            if (s.contains(moveFrom[i])) {
+                s.remove(moveFrom[i])
+                s.add(moveTo[i])
+            }
+        }
+        return s.toList().sorted()
+    }
+}

src/main/kotlin/g2701_2800/s2766_relocate_marbles/readme.md

@@ -0,0 +1,52 @@
+2766\. Relocate Marbles
+
+Medium
+
+You are given a **0-indexed** integer array `nums` representing the initial positions of some marbles. You are also given two **0-indexed** integer arrays `moveFrom` and `moveTo` of **equal** length.
+
+Throughout `moveFrom.length` steps, you will change the positions of the marbles. On the <code>i<sup>th</sup></code> step, you will move **all** marbles at position `moveFrom[i]` to position `moveTo[i]`.
+
+After completing all the steps, return _the sorted list of **occupied** positions_.
+
+**Notes:**
+
+*   We call a position **occupied** if there is at least one marble in that position.
+*   There may be multiple marbles in a single position.
+
+**Example 1:**
+
+**Input:** nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]
+
+**Output:** [5,6,8,9]
+
+**Explanation:** Initially, the marbles are at positions 1,6,7,8. 
+
+At the i = 0th step, we move the marbles at position 1 to position 2. Then, positions 2,6,7,8 are occupied. 
+
+At the i = 1st step, we move the marbles at position 7 to position 9. Then, positions 2,6,8,9 are occupied. 
+
+At the i = 2nd step, we move the marbles at position 2 to position 5. Then, positions 5,6,8,9 are occupied. 
+
+At the end, the final positions containing at least one marbles are [5,6,8,9].
+
+**Example 2:**
+
+**Input:** nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2]
+
+**Output:** [2]
+
+**Explanation:** Initially, the marbles are at positions [1,1,3,3]. 
+
+At the i = 0th step, we move all the marbles at position 1 to position 2. Then, the marbles are at positions [2,2,3,3]. 
+
+At the i = 1st step, we move all the marbles at position 3 to position 2. Then, the marbles are at positions [2,2,2,2]. 
+
+Since 2 is the only occupied position, we return [2].
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= moveFrom.length <= 10<sup>5</sup></code>
+*   `moveFrom.length == moveTo.length`
+*   <code>1 <= nums[i], moveFrom[i], moveTo[i] <= 10<sup>9</sup></code>
+*   The test cases are generated such that there is at least a marble in `moveFrom[i]` at the moment we want to apply the <code>i<sup>th</sup></code> move.

src/main/kotlin/g2701_2800/s2767_partition_string_into_minimum_beautiful_substrings/Solution.kt

@@ -0,0 +1,35 @@
+package g2701_2800.s2767_partition_string_into_minimum_beautiful_substrings
+
+// #Medium #String #Hash_Table #Dynamic_Programming #Backtracking
+// #2023_08_11_Time_162_ms_(96.00%)_Space_36.2_MB_(80.00%)
+
+class Solution {
+    fun minimumBeautifulSubstrings(s: String): Int {
+        val set: MutableSet<String> = HashSet()
+        set.add("1")
+        set.add("101")
+        set.add("11001")
+        set.add("1111101")
+        set.add("1001110001")
+        set.add("110000110101")
+        set.add("11110100001001")
+        val result = minimumBeautifulSubstringsHelper(s, 0, set, 0)
+        return if (result == Int.MAX_VALUE) {
+            -1
+        } else result
+    }
+
+    private fun minimumBeautifulSubstringsHelper(s: String, index: Int, set: Set<String>, count: Int): Int {
+        if (index >= s.length) {
+            return count
+        }
+        var minResult = Int.MAX_VALUE
+        for (i in index..s.length) {
+            if (set.contains(s.substring(index, i))) {
+                val result = minimumBeautifulSubstringsHelper(s, i, set, count + 1)
+                minResult = minResult.coerceAtMost(result)
+            }
+        }
+        return minResult
+    }
+}

src/main/kotlin/g2701_2800/s2767_partition_string_into_minimum_beautiful_substrings/readme.md

@@ -0,0 +1,50 @@
+2767\. Partition String Into Minimum Beautiful Substrings
+
+Medium
+
+Given a binary string `s`, partition the string into one or more **substrings** such that each substring is **beautiful**.
+
+A string is **beautiful** if:
+
+*   It doesn't contain leading zeros.
+*   It's the **binary** representation of a number that is a power of `5`.
+
+Return _the **minimum** number of substrings in such partition._ If it is impossible to partition the string `s` into beautiful substrings, return `-1`.
+
+A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** s = "1011"
+
+**Output:** 2
+
+**Explanation:** We can paritition the given string into ["101", "1"]. 
+- The string "101" does not contain leading zeros and is the binary representation of integer 5<sup>1</sup> = 5. 
+- The string "1" does not contain leading zeros and is the binary representation of integer 5<sup>0</sup> = 1. 
+
+It can be shown that 2 is the minimum number of beautiful substrings that s can be partitioned into.
+
+**Example 2:**
+
+**Input:** s = "111"
+
+**Output:** 3
+
+**Explanation:** We can paritition the given string into ["1", "1", "1"]. 
+- The string "1" does not contain leading zeros and is the binary representation of integer 5<sup>0</sup> = 1. 
+
+It can be shown that 3 is the minimum number of beautiful substrings that s can be partitioned into.
+
+**Example 3:**
+
+**Input:** s = "0"
+
+**Output:** -1
+
+**Explanation:** We can not partition the given string into beautiful substrings.
+
+**Constraints:**
+
+*   `1 <= s.length <= 15`
+*   `s[i]` is either `'0'` or `'1'`.

src/main/kotlin/g2701_2800/s2768_number_of_black_blocks/Solution.kt

@@ -0,0 +1,28 @@
+package g2701_2800.s2768_number_of_black_blocks
+
+// #Medium #Array #Hash_Table #Enumeration #2023_08_11_Time_719_ms_(100.00%)_Space_55.3_MB_(100.00%)
+
+class Solution {
+    fun countBlackBlocks(m: Int, n: Int, coordinates: Array<IntArray>): LongArray {
+        val ans = LongArray(5)
+        val count: MutableMap<Int, Int> = HashMap()
+        for (coordinate in coordinates) {
+            val x = coordinate[0]
+            val y = coordinate[1]
+            for (i in x until x + 2) {
+                for (j in y until y + 2) {
+                    if (i - 1 >= 0 && i < m && j - 1 >= 0 && j < n) {
+                        count.merge(
+                            i * n + j, 1
+                        ) { a: Int?, b: Int? -> Integer.sum(a!!, b!!) }
+                    }
+                }
+            }
+        }
+        for (freq in count.values) {
+            ++ans[freq]
+        }
+        ans[0] = (m - 1L) * (n - 1) - ans.sum()
+        return ans
+    }
+}

src/main/kotlin/g2701_2800/s2768_number_of_black_blocks/readme.md

@@ -0,0 +1,49 @@
+2768\. Number of Black Blocks
+
+Medium
+
+You are given two integers `m` and `n` representing the dimensions of a **0-indexed** `m x n` grid.
+
+You are also given a **0-indexed** 2D integer matrix `coordinates`, where `coordinates[i] = [x, y]` indicates that the cell with coordinates `[x, y]` is colored **black**. All cells in the grid that do not appear in `coordinates` are **white**.
+
+A block is defined as a `2 x 2` submatrix of the grid. More formally, a block with cell `[x, y]` as its top-left corner where `0 <= x < m - 1` and `0 <= y < n - 1` contains the coordinates `[x, y]`, `[x + 1, y]`, `[x, y + 1]`, and `[x + 1, y + 1]`.
+
+Return _a **0-indexed** integer array_ `arr` _of size_ `5` _such that_ `arr[i]` _is the number of blocks that contains exactly_ `i` _**black** cells_.
+
+**Example 1:**
+
+**Input:** m = 3, n = 3, coordinates = [[0,0]]
+
+**Output:** [3,1,0,0,0]
+
+**Explanation:** The grid looks like this: ![](https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-44656-am.png) 
+
+There is only 1 block with one black cell, and it is the block starting with cell [0,0].
+
+The other 3 blocks start with cells [0,1], [1,0] and [1,1]. They all have zero black cells.
+
+Thus, we return [3,1,0,0,0].
+
+**Example 2:**
+
+**Input:** m = 3, n = 3, coordinates = [[0,0],[1,1],[0,2]]
+
+**Output:** [0,2,2,0,0]
+
+**Explanation:** The grid looks like this: ![](https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-45018-am.png) 
+
+There are 2 blocks with two black cells (the ones starting with cell coordinates [0,0] and [0,1]). 
+
+The other 2 blocks have starting cell coordinates of [1,0] and [1,1]. They both have 1 black cell. 
+
+Therefore, we return [0,2,2,0,0].
+
+**Constraints:**
+
+*   <code>2 <= m <= 10<sup>5</sup></code>
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= coordinates.length <= 10<sup>4</sup></code>
+*   `coordinates[i].length == 2`
+*   `0 <= coordinates[i][0] < m`
+*   `0 <= coordinates[i][1] < n`
+*   It is guaranteed that `coordinates` contains pairwise distinct coordinates.