Added tasks 2251-2300

Author: javadev

src/main/kotlin/g2201_2300/s2251_number_of_flowers_in_full_bloom/Solution.kt

@@ -0,0 +1,47 @@
+package g2201_2300.s2251_number_of_flowers_in_full_bloom
+
+// #Hard #Array #Hash_Table #Sorting #Binary_Search #Prefix_Sum #Ordered_Set
+// #2023_06_28_Time_973_ms_(100.00%)_Space_88.6_MB_(100.00%)
+
+import java.util.Arrays
+import java.util.PriorityQueue
+
+class Solution {
+    fun fullBloomFlowers(flowers: Array<IntArray>, persons: IntArray): IntArray {
+        Arrays.sort(flowers, { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) })
+        val ans = IntArray(persons.size)
+        val pq = PriorityQueue({ a: Pair, b: Pair -> a.j.compareTo(b.j) })
+        var j = 0
+        val t = Array(persons.size) { IntArray(2) }
+        for (i in persons.indices) {
+            t[i][0] = persons[i]
+            t[i][1] = i
+        }
+        Arrays.sort(t, { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) })
+        for (ints in t) {
+            while (pq.isNotEmpty()) {
+                if (pq.peek().j < ints[0]) {
+                    pq.poll()
+                } else {
+                    break
+                }
+            }
+            while (j < flowers.size) {
+                if (flowers[j][0] <= ints[0] && flowers[j][1] >= ints[0]) {
+                    pq.add(Pair(flowers[j][0], flowers[j][1]))
+                    j++
+                    continue
+                }
+                if (flowers[j][1] < ints[0]) {
+                    j++
+                    continue
+                }
+                break
+            }
+            ans[ints[1]] = pq.size
+        }
+        return ans
+    }
+
+    private class Pair(var i: Int, var j: Int)
+}

src/main/kotlin/g2201_2300/s2251_number_of_flowers_in_full_bloom/readme.md

@@ -0,0 +1,35 @@
+2251\. Number of Flowers in Full Bloom
+
+Hard
+
+You are given a **0-indexed** 2D integer array `flowers`, where <code>flowers[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> means the <code>i<sup>th</sup></code> flower will be in **full bloom** from <code>start<sub>i</sub></code> to <code>end<sub>i</sub></code> (**inclusive**). You are also given a **0-indexed** integer array `persons` of size `n`, where `persons[i]` is the time that the <code>i<sup>th</sup></code> person will arrive to see the flowers.
+
+Return _an integer array_ `answer` _of size_ `n`_, where_ `answer[i]` _is the **number** of flowers that are in full bloom when the_ <code>i<sup>th</sup></code> _person arrives._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/03/02/ex1new.jpg)
+
+**Input:** flowers = [[1,6],[3,7],[9,12],[4,13]], persons = [2,3,7,11]
+
+**Output:** [1,2,2,2]
+
+**Explanation:** The figure above shows the times when the flowers are in full bloom and when the people arrive. For each person, we return the number of flowers in full bloom during their arrival.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/03/02/ex2new.jpg)
+
+**Input:** flowers = [[1,10],[3,3]], persons = [3,3,2]
+
+**Output:** [2,2,1]
+
+**Explanation:** The figure above shows the times when the flowers are in full bloom and when the people arrive. For each person, we return the number of flowers in full bloom during their arrival.
+
+**Constraints:**
+
+*   <code>1 <= flowers.length <= 5 * 10<sup>4</sup></code>
+*   `flowers[i].length == 2`
+*   <code>1 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>9</sup></code>
+*   <code>1 <= persons.length <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= persons[i] <= 10<sup>9</sup></code>

src/main/kotlin/g2201_2300/s2255_count_prefixes_of_a_given_string/Solution.kt

@@ -0,0 +1,15 @@
+package g2201_2300.s2255_count_prefixes_of_a_given_string
+
+// #Easy #Array #String #2023_06_28_Time_162_ms_(100.00%)_Space_37.5_MB_(66.67%)
+
+class Solution {
+    fun countPrefixes(words: Array<String>, s: String): Int {
+        var count = 0
+        for (str in words) {
+            if (s.indexOf(str) == 0) {
+                ++count
+            }
+        }
+        return count
+    }
+}

src/main/kotlin/g2201_2300/s2255_count_prefixes_of_a_given_string/readme.md

@@ -0,0 +1,41 @@
+2255\. Count Prefixes of a Given String
+
+Easy
+
+You are given a string array `words` and a string `s`, where `words[i]` and `s` comprise only of **lowercase English letters**.
+
+Return _the **number of strings** in_ `words` _that are a **prefix** of_ `s`.
+
+A **prefix** of a string is a substring that occurs at the beginning of the string. A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** words = ["a","b","c","ab","bc","abc"], s = "abc"
+
+**Output:** 3
+
+**Explanation:**
+
+The strings in words which are a prefix of s = "abc" are:
+
+"a", "ab", and "abc".
+
+Thus the number of strings in words which are a prefix of s is 3.
+
+**Example 2:**
+
+**Input:** words = ["a","a"], s = "aa"
+
+**Output:** 2
+
+**Explanation:**
+
+Both of the strings are a prefix of s.
+
+Note that the same string can occur multiple times in words, and it should be counted each time.
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length, s.length <= 10`
+*   `words[i]` and `s` consist of lowercase English letters **only**.

src/main/kotlin/g2201_2300/s2256_minimum_average_difference/Solution.kt

@@ -0,0 +1,28 @@
+package g2201_2300.s2256_minimum_average_difference
+
+// #Medium #Array #Prefix_Sum #2023_06_28_Time_527_ms_(100.00%)_Space_52.1_MB_(100.00%)
+
+class Solution {
+    fun minimumAverageDifference(nums: IntArray): Int {
+        var numsSum: Long = 0
+        for (num in nums) {
+            numsSum += num.toLong()
+        }
+        var minAverageDiff = Long.MAX_VALUE
+        var sumFromFront: Long = 0
+        var index = 0
+        for (i in nums.indices) {
+            sumFromFront += nums[i].toLong()
+            val numbersRight = if (i == nums.size - 1) 1 else nums.size - i - 1
+            val averageDiff = Math.abs(sumFromFront / (i + 1) - (numsSum - sumFromFront) / numbersRight)
+            if (minAverageDiff > averageDiff) {
+                minAverageDiff = averageDiff
+                index = i
+            }
+            if (averageDiff == 0L) {
+                break
+            }
+        }
+        return index
+    }
+}

src/main/kotlin/g2201_2300/s2256_minimum_average_difference/readme.md

@@ -0,0 +1,54 @@
+2256\. Minimum Average Difference
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of length `n`.
+
+The **average difference** of the index `i` is the **absolute** **difference** between the average of the **first** `i + 1` elements of `nums` and the average of the **last** `n - i - 1` elements. Both averages should be **rounded down** to the nearest integer.
+
+Return _the index with the **minimum average difference**_. If there are multiple such indices, return the **smallest** one.
+
+**Note:**
+
+*   The **absolute difference** of two numbers is the absolute value of their difference.
+*   The **average** of `n` elements is the **sum** of the `n` elements divided (**integer division**) by `n`.
+*   The average of `0` elements is considered to be `0`.
+
+**Example 1:**
+
+**Input:** nums = [2,5,3,9,5,3]
+
+**Output:** 3
+
+**Explanation:** 
+
+- The average difference of index 0 is: |2 / 1 - (5 + 3 + 9 + 5 + 3) / 5| = |2 / 1 - 25 / 5| = |2 - 5| = 3. 
+
+- The average difference of index 1 is: |(2 + 5) / 2 - (3 + 9 + 5 + 3) / 4| = |7 / 2 - 20 / 4| = |3 - 5| = 2. 
+ 
+- The average difference of index 2 is: |(2 + 5 + 3) / 3 - (9 + 5 + 3) / 3| = |10 / 3 - 17 / 3| = |3 - 5| = 2. 
+ 
+- The average difference of index 3 is: |(2 + 5 + 3 + 9) / 4 - (5 + 3) / 2| = |19 / 4 - 8 / 2| = |4 - 4| = 0. 
+ 
+- The average difference of index 4 is: |(2 + 5 + 3 + 9 + 5) / 5 - 3 / 1| = |24 / 5 - 3 / 1| = |4 - 3| = 1. 
+ 
+- The average difference of index 5 is: |(2 + 5 + 3 + 9 + 5 + 3) / 6 - 0| = |27 / 6 - 0| = |4 - 0| = 4. 
+ 
+The average difference of index 3 is the minimum average difference so return 3. 
+
+**Example 2:**
+
+**Input:** nums = [0]
+
+**Output:** 0
+
+**Explanation:** 
+
+The only index is 0 so return 0. 
+
+The average difference of index 0 is: |0 / 1 - 0| = |0 - 0| = 0. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g2201_2300/s2257_count_unguarded_cells_in_the_grid/Solution.kt

@@ -0,0 +1,91 @@
+package g2201_2300.s2257_count_unguarded_cells_in_the_grid
+
+// #Medium #Array #Matrix #Simulation #2023_06_28_Time_901_ms_(100.00%)_Space_76.1_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun countUnguarded(m: Int, n: Int, guards: Array<IntArray>, walls: Array<IntArray>): Int {
+        val matrix = Array(m) { CharArray(n) }
+        var result = 0
+        for (i in guards.indices) {
+            val guardRow = guards[i][0]
+            val guardCol = guards[i][1]
+            matrix[guardRow][guardCol] = 'G'
+        }
+        for (i in walls.indices) {
+            val wallRow = walls[i][0]
+            val wallCol = walls[i][1]
+            matrix[wallRow][wallCol] = 'W'
+        }
+        for (i in guards.indices) {
+            var currentRow = guards[i][0]
+            var currentCol = guards[i][1] - 1
+            extracted(matrix, currentRow, currentCol)
+            currentRow = guards[i][0]
+            currentCol = guards[i][1] + 1
+            extracted(n, matrix, currentRow, currentCol)
+            currentRow = guards[i][0] - 1
+            currentCol = guards[i][1]
+            extracted1(matrix, currentRow, currentCol)
+            currentRow = guards[i][0] + 1
+            currentCol = guards[i][1]
+            extracted1(m, matrix, currentRow, currentCol)
+        }
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                if (matrix[i][j] != 'R' && matrix[i][j] != 'G' && matrix[i][j] != 'W') {
+                    result++
+                }
+            }
+        }
+        return result
+    }
+
+    private fun extracted1(m: Int, matrix: Array<CharArray>, currentRow: Int, currentCol: Int) {
+        var currentRow = currentRow
+        while (currentRow <= m - 1) {
+            if (matrix[currentRow][currentCol] != 'W' && matrix[currentRow][currentCol] != 'G') {
+                matrix[currentRow][currentCol] = 'R'
+            } else {
+                break
+            }
+            currentRow++
+        }
+    }
+
+    private fun extracted1(matrix: Array<CharArray>, currentRow: Int, currentCol: Int) {
+        var currentRow = currentRow
+        while (currentRow >= 0) {
+            if (matrix[currentRow][currentCol] != 'W' && matrix[currentRow][currentCol] != 'G') {
+                matrix[currentRow][currentCol] = 'R'
+            } else {
+                break
+            }
+            currentRow--
+        }
+    }
+
+    private fun extracted(n: Int, matrix: Array<CharArray>, currentRow: Int, currentCol: Int) {
+        var currentCol = currentCol
+        while (currentCol <= n - 1) {
+            if (matrix[currentRow][currentCol] != 'W' && matrix[currentRow][currentCol] != 'G') {
+                matrix[currentRow][currentCol] = 'R'
+            } else {
+                break
+            }
+            currentCol++
+        }
+    }
+
+    private fun extracted(matrix: Array<CharArray>, currentRow: Int, currentCol: Int) {
+        var currentCol = currentCol
+        while (currentCol >= 0) {
+            if (matrix[currentRow][currentCol] != 'W' && matrix[currentRow][currentCol] != 'G') {
+                matrix[currentRow][currentCol] = 'R'
+            } else {
+                break
+            }
+            currentCol--
+        }
+    }
+}

src/main/kotlin/g2201_2300/s2257_count_unguarded_cells_in_the_grid/readme.md

@@ -0,0 +1,40 @@
+2257\. Count Unguarded Cells in the Grid
+
+Medium
+
+You are given two integers `m` and `n` representing a **0-indexed** `m x n` grid. You are also given two 2D integer arrays `guards` and `walls` where <code>guards[i] = [row<sub>i</sub>, col<sub>i</sub>]</code> and <code>walls[j] = [row<sub>j</sub>, col<sub>j</sub>]</code> represent the positions of the <code>i<sup>th</sup></code> guard and <code>j<sup>th</sup></code> wall respectively.
+
+A guard can see **every** cell in the four cardinal directions (north, east, south, or west) starting from their position unless **obstructed** by a wall or another guard. A cell is **guarded** if there is **at least** one guard that can see it.
+
+Return _the number of unoccupied cells that are **not** **guarded**._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/03/10/example1drawio2.png)
+
+**Input:** m = 4, n = 6, guards = [[0,0],[1,1],[2,3]], walls = [[0,1],[2,2],[1,4]]
+
+**Output:** 7
+
+**Explanation:** The guarded and unguarded cells are shown in red and green respectively in the above diagram. There are a total of 7 unguarded cells, so we return 7.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/03/10/example2drawio.png)
+
+**Input:** m = 3, n = 3, guards = [[1,1]], walls = [[0,1],[1,0],[2,1],[1,2]]
+
+**Output:** 4
+
+**Explanation:** The unguarded cells are shown in green in the above diagram. There are a total of 4 unguarded cells, so we return 4.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>2 <= m * n <= 10<sup>5</sup></code>
+*   <code>1 <= guards.length, walls.length <= 5 * 10<sup>4</sup></code>
+*   `2 <= guards.length + walls.length <= m * n`
+*   `guards[i].length == walls[j].length == 2`
+*   <code>0 <= row<sub>i</sub>, row<sub>j</sub> < m</code>
+*   <code>0 <= col<sub>i</sub>, col<sub>j</sub> < n</code>
+*   All the positions in `guards` and `walls` are **unique**.