Added tasks 2656-2660

Author: ThanhNIT

src/main/kotlin/g2601_2700/s2656_maximum_sum_with_exactly_k_elements/Solution.kt

@@ -0,0 +1,9 @@
+package g2601_2700.s2656_maximum_sum_with_exactly_k_elements
+
+// #Easy #Array #Greedy #2023_07_21_Time_241_ms_(93.94%)_Space_40.5_MB_(63.64%)
+
+class Solution {
+    fun maximizeSum(nums: IntArray, k: Int): Int {
+        return k * nums.max() + k * (k - 1) / 2
+    }
+}

src/main/kotlin/g2601_2700/s2656_maximum_sum_with_exactly_k_elements/readme.md

@@ -0,0 +1,50 @@
+2656\. Maximum Sum With Exactly K Elements
+
+Easy
+
+You are given a **0-indexed** integer array `nums` and an integer `k`. Your task is to perform the following operation **exactly** `k` times in order to maximize your score:
+
+1.  Select an element `m` from `nums`.
+2.  Remove the selected element `m` from the array.
+3.  Add a new element with a value of `m + 1` to the array.
+4.  Increase your score by `m`.
+
+Return _the maximum score you can achieve after performing the operation exactly_ `k` _times._
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5], k = 3
+
+**Output:** 18
+
+**Explanation:** We need to choose exactly 3 elements from nums to maximize the sum. 
+
+For the first iteration, we choose 5. Then sum is 5 and nums = [1,2,3,4,6] 
+
+For the second iteration, we choose 6. Then sum is 5 + 6 and nums = [1,2,3,4,7]
+
+For the third iteration, we choose 7. Then sum is 5 + 6 + 7 = 18 and nums = [1,2,3,4,8] 
+
+So, we will return 18. It can be proven, that 18 is the maximum answer that we can achieve.
+
+**Example 2:**
+
+**Input:** nums = [5,5,5], k = 2
+
+**Output:** 11
+
+**Explanation:** We need to choose exactly 2 elements from nums to maximize the sum. 
+
+For the first iteration, we choose 5. Then sum is 5 and nums = [5,5,6] 
+
+For the second iteration, we choose 6. Then sum is 5 + 6 = 11 and nums = [5,5,7] 
+
+So, we will return 11. 
+
+It can be proven, that 11 is the maximum answer that we can achieve.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+*   `1 <= k <= 100`

src/main/kotlin/g2601_2700/s2657_find_the_prefix_common_array_of_two_arrays/Solution.kt

@@ -0,0 +1,29 @@
+package g2601_2700.s2657_find_the_prefix_common_array_of_two_arrays
+
+// #Medium #Array #Hash_Table #2023_07_21_Time_288_ms_(88.89%)_Space_39.9_MB_(100.00%)
+
+class Solution {
+    fun findThePrefixCommonArray(a: IntArray, b: IntArray): IntArray {
+        val hsA = HashSet<Int>()
+        val hsB = HashSet<Int>()
+        val addedA = HashSet<Int>()
+        val addedB = HashSet<Int>()
+        val res = IntArray(a.size)
+        for (i in a.indices) {
+            val numA = a[i]
+            val numB = b[i]
+            hsA.add(numA)
+            hsB.add(numB)
+            if (i > 0) res[i] += res[i - 1] else res[i] = 0
+            if (numA in hsB && numA !in addedB) {
+                addedA.add(numA)
+                res[i] += 1
+            }
+            if (numB in hsA && numB !in addedA) {
+                addedB.add(numB)
+                res[i] += 1
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2657_find_the_prefix_common_array_of_two_arrays/readme.md

@@ -0,0 +1,43 @@
+2657\. Find the Prefix Common Array of Two Arrays
+
+Medium
+
+You are given two **0-indexed** integer permutations `A` and `B` of length `n`.
+
+A **prefix common array** of `A` and `B` is an array `C` such that `C[i]` is equal to the count of numbers that are present at or before the index `i` in both `A` and `B`.
+
+Return _the **prefix common array** of_ `A` _and_ `B`.
+
+A sequence of `n` integers is called a **permutation** if it contains all integers from `1` to `n` exactly once.
+
+**Example 1:**
+
+**Input:** A = [1,3,2,4], B = [3,1,2,4]
+
+**Output:** [0,2,3,4]
+
+**Explanation:** At i = 0: no number is common, so C[0] = 0. 
+
+At i = 1: 1 and 3 are common in A and B, so C[1] = 2. 
+
+At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3. 
+
+At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.
+
+**Example 2:**
+
+**Input:** A = [2,3,1], B = [3,1,2]
+
+**Output:** [0,1,3]
+
+**Explanation:** At i = 0: no number is common, so C[0] = 0. 
+
+At i = 1: only 3 is common in A and B, so C[1] = 1. 
+
+At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
+
+**Constraints:**
+
+*   `1 <= A.length == B.length == n <= 50`
+*   `1 <= A[i], B[i] <= n`
+*   `It is guaranteed that A and B are both a permutation of n integers.`

src/main/kotlin/g2601_2700/s2658_maximum_number_of_fish_in_a_grid/Solution.kt

@@ -0,0 +1,41 @@
+package g2601_2700.s2658_maximum_number_of_fish_in_a_grid
+
+// #Medium #Array #Matrix #Union_Find #Depth_First_Search #Breadth_First_Search
+// #2023_07_21_Time_269_ms_(80.00%)_Space_45.4_MB_(80.00%)
+
+class Solution {
+    fun findMaxFish(grid: Array<IntArray>): Int {
+        val visited = Array(grid.size) { BooleanArray(grid[0].size) }
+        val dir = arrayOf(
+            intArrayOf(0, 1),
+            intArrayOf(0, -1),
+            intArrayOf(1, 0),
+            intArrayOf(-1, 0)
+        )
+
+        fun isValid(x: Int, y: Int) = x in (0..grid.lastIndex) && y in (0..grid[0].lastIndex) &&
+            grid[x][y] != 0 && !visited[x][y]
+
+        fun dfs(x: Int, y: Int): Int {
+            if (!isValid(x, y)) {
+                return 0
+            }
+            visited[x][y] = true
+            var total = grid[x][y]
+            for (d in dir) {
+                total += dfs(x + d[0], y + d[1])
+            }
+            return total
+        }
+
+        var res = 0
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (grid[i][j] != 0)
+                    res = maxOf(res, dfs(i, j))
+            }
+        }
+
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2658_maximum_number_of_fish_in_a_grid/readme.md

@@ -0,0 +1,44 @@
+2658\. Maximum Number of Fish in a Grid
+
+Medium
+
+You are given a **0-indexed** 2D matrix `grid` of size `m x n`, where `(r, c)` represents:
+
+*   A **land** cell if `grid[r][c] = 0`, or
+*   A **water** cell containing `grid[r][c]` fish, if `grid[r][c] > 0`.
+
+A fisher can start at any **water** cell `(r, c)` and can do the following operations any number of times:
+
+*   Catch all the fish at cell `(r, c)`, or
+*   Move to any adjacent **water** cell.
+
+Return _the **maximum** number of fish the fisher can catch if he chooses his starting cell optimally, or_ `0` if no water cell exists.
+
+An **adjacent** cell of the cell `(r, c)`, is one of the cells `(r, c + 1)`, `(r, c - 1)`, `(r + 1, c)` or `(r - 1, c)` if it exists.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/03/29/example.png)
+
+**Input:** grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
+
+**Output:** 7
+
+**Explanation:** The fisher can start at cell `(1,3)` and collect 3 fish, then move to cell `(2,3)` and collect 4 fish.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/03/29/example2.png)
+
+**Input:** grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
+
+**Output:** 1
+
+**Explanation:** The fisher can start at cells (0,0) or (3,3) and collect a single fish.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 10`
+*   `0 <= grid[i][j] <= 10`

src/main/kotlin/g2601_2700/s2659_make_array_empty/Solution.kt

@@ -0,0 +1,21 @@
+package g2601_2700.s2659_make_array_empty
+
+// #Hard #Array #Sorting #Greedy #Binary_Search #Ordered_Set #Segment_Tree #Binary_Indexed_Tree
+// #2023_07_21_Time_728_ms_(100.00%)_Space_71_MB_(100.00%)
+
+class Solution {
+    fun countOperationsToEmptyArray(nums: IntArray): Long {
+        val sortNums = Array(nums.size) { IntArray(2) }
+        for (i in nums.indices) {
+            sortNums[i][0] = nums[i]
+            sortNums[i][1] = i
+        }
+        sortNums.sortBy { it[0] }
+        var res = 0L + nums.size
+        for (i in 1..sortNums.lastIndex) {
+            if (sortNums[i - 1][1] > sortNums[i][1])
+                res += nums.size - i
+        }
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2659_make_array_empty/readme.md

@@ -0,0 +1,53 @@
+2659\. Make Array Empty
+
+Hard
+
+You are given an integer array `nums` containing **distinct** numbers, and you can perform the following operations **until the array is empty**:
+
+*   If the first element has the **smallest** value, remove it
+*   Otherwise, put the first element at the **end** of the array.
+
+Return _an integer denoting the number of operations it takes to make_ `nums` _empty._
+
+**Example 1:**
+
+**Input:** nums = [3,4,-1]
+
+**Output:** 5
+
+    Operation   Array
+    1           [4, -1, 3]
+    2           [-1, 3, 4]
+    3           [3, 4]
+    4           [4]
+    5           []
+
+**Example 2:**
+
+**Input:** nums = [1,2,4,3]
+
+**Output:** 5
+
+    Operation   Array
+    1           [2, 4, 3]
+    2           [4, 3]
+    3           [3, 4]
+    4           [4]
+    5           []
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 3
+
+    Operation   Array
+    1           [2, 3]
+    2           [3]
+    3           []
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9 </sup><= nums[i] <= 10<sup>9</sup></code>
+*   All values in `nums` are **distinct**.

src/main/kotlin/g2601_2700/s2660_determine_the_winner_of_a_bowling_game/Solution.kt

@@ -0,0 +1,27 @@
+package g2601_2700.s2660_determine_the_winner_of_a_bowling_game
+
+// #Easy #Array #Simulation #2023_07_21_Time_263_ms_(85.71%)_Space_40.3_MB_(85.71%)
+
+class Solution {
+    fun isWinner(player1: IntArray, player2: IntArray): Int {
+        var p1Score = 0
+        var p2Score = 0
+        var isTen = 0
+        for (score in player1) {
+            p1Score += if (isTen > 0) 2 * score else score
+            if (isTen > 0) isTen--
+            if (score == 10) isTen = 2
+        }
+        isTen = 0
+        for (score in player2) {
+            p2Score += if (isTen > 0) 2 * score else score
+            if (isTen > 0) isTen--
+            if (score == 10) isTen = 2
+        }
+        return when {
+            p1Score == p2Score -> 0
+            p1Score > p2Score -> 1
+            else -> 2
+        }
+    }
+}

src/main/kotlin/g2601_2700/s2660_determine_the_winner_of_a_bowling_game/readme.md

@@ -0,0 +1,62 @@
+2660\. Determine the Winner of a Bowling Game
+
+Easy
+
+You are given two **0-indexed** integer arrays `player1` and `player2`, that represent the number of pins that player 1 and player 2 hit in a bowling game, respectively.
+
+The bowling game consists of `n` turns, and the number of pins in each turn is exactly `10`.
+
+Assume a player hit <code>x<sub>i</sub></code> pins in the <code>i<sup>th</sup></code> turn. The value of the <code>i<sup>th</sup></code> turn for the player is:
+
+*   <code>2x<sub>i</sub></code> if the player hit `10` pins in any of the previous two turns.
+*   Otherwise, It is <code>x<sub>i</sub></code>.
+
+The score of the player is the sum of the values of their `n` turns.
+
+Return
+
+*   `1` _if the score of player 1 is more than the score of player 2,_
+*   `2` _if the score of player 2 is more than the score of player 1, and_
+*   `0` _in case of a draw._
+
+**Example 1:**
+
+**Input:** player1 = [4,10,7,9], player2 = [6,5,2,3]
+
+**Output:** 1
+
+**Explanation:** The score of player1 is 4 + 10 + 2*7 + 2*9 = 46. 
+
+The score of player2 is 6 + 5 + 2 + 3 = 16. 
+
+Score of player1 is more than the score of player2, so, player1 is the winner, and the answer is 1.
+
+**Example 2:**
+
+**Input:** player1 = [3,5,7,6], player2 = [8,10,10,2]
+
+**Output:** 2
+
+**Explanation:** The score of player1 is 3 + 5 + 7 + 6 = 21. 
+
+The score of player2 is 8 + 10 + 2*10 + 2*2 = 42. 
+
+Score of player2 is more than the score of player1, so, player2 is the winner, and the answer is 2.
+
+**Example 3:**
+
+**Input:** player1 = [2,3], player2 = [4,1]
+
+**Output:** 0
+
+**Explanation:** The score of player1 is 2 + 3 = 5 
+
+The score of player2 is 4 + 1 = 5 
+
+The score of player1 equals to the score of player2, so, there is a draw, and the answer is 0.
+
+**Constraints:**
+
+*   `n == player1.length == player2.length`
+*   `1 <= n <= 1000`
+*   `0 <= player1[i], player2[i] <= 10`