Added tasks 1561, 1562, 1563, 1566, 1567.

Author: ThanhNIT

src/main/java/g1501_1600/s1561_maximum_number_of_coins_you_can_get/Solution.java

@@ -0,0 +1,21 @@
+package g1501_1600.s1561_maximum_number_of_coins_you_can_get;
+
+// #Medium #Array #Math #Sorting #Greedy #Game_Theory
+// #2022_04_11_Time_34_ms_(69.29%)_Space_77_MB_(21.83%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public int maxCoins(int[] piles) {
+ Arrays.sort(piles);
+ int j = 0;
+ int coins = 0;
+ for (int i = piles.length - 2; i > 0; i -= 2) {
+ coins += piles[i];
+ if (++j == piles.length / 3) {
+ return coins;
+ }
+ }
+ return coins;
+ }
+}

src/main/java/g1501_1600/s1561_maximum_number_of_coins_you_can_get/readme.md

@@ -0,0 +1,45 @@
+1561\. Maximum Number of Coins You Can Get
+
+Medium
+
+There are `3n` piles of coins of varying size, you and your friends will take piles of coins as follows:
+
+* In each step, you will choose **any** `3` piles of coins (not necessarily consecutive).
+* Of your choice, Alice will pick the pile with the maximum number of coins.
+* You will pick the next pile with the maximum number of coins.
+* Your friend Bob will pick the last pile.
+* Repeat until there are no more piles of coins.
+
+Given an array of integers `piles` where `piles[i]` is the number of coins in the <code>i<sup>th</sup></code> pile.
+
+Return the maximum number of coins that you can have.
+
+**Example 1:**
+
+**Input:** piles = [2,4,1,2,7,8]
+
+**Output:** 9
+
+**Explanation:** Choose the triplet (2, 7, 8), Alice Pick the pile with 8 coins, you the pile with **7** coins and Bob the last one.
+
+Choose the triplet (1, 2, 4), Alice Pick the pile with 4 coins, you the pile with **2** coins and Bob the last one. The maximum number of coins which you can have are: 7 + 2 = 9.
+
+On the other hand if we choose this arrangement (1, **2**, 8), (2, **4**, 7) you only get 2 + 4 = 6 coins which is not optimal.
+
+**Example 2:**
+
+**Input:** piles = [2,4,5]
+
+**Output:** 4
+
+**Example 3:**
+
+**Input:** piles = [9,8,7,6,5,1,2,3,4]
+
+**Output:** 18
+
+**Constraints:**
+
+* <code>3 <= piles.length <= 10<sup>5</sup></code>
+* `piles.length % 3 == 0`
+* <code>1 <= piles[i] <= 10<sup>4</sup></code>

src/main/java/g1501_1600/s1562_find_latest_group_of_size_m/Solution.java

@@ -0,0 +1,29 @@
+package g1501_1600.s1562_find_latest_group_of_size_m;
+
+// #Medium #Array #Binary_Search #Simulation #2022_04_11_Time_8_ms_(90.00%)_Space_84.2_MB_(53.00%)
+
+public class Solution {
+ public int findLatestStep(int[] arr, int m) {
+ int[] lengthAtIndex = new int[arr.length + 2];
+ int[] countOfLength = new int[arr.length + 1];
+ int res = -1;
+ int step = 1;
+ for (int i : arr) {
+ int leftLength = lengthAtIndex[i - 1];
+ int rightLength = lengthAtIndex[i + 1];
+ int newLength = leftLength + rightLength + 1;
+ lengthAtIndex[i] = newLength;
+ lengthAtIndex[i - leftLength] = newLength;
+ lengthAtIndex[i + rightLength] = newLength;
+ countOfLength[newLength] += 1;
+ countOfLength[leftLength] -= 1;
+ countOfLength[rightLength] -= 1;
+ if (countOfLength[m] > 0) {
+ res = step;
+ }
+ step++;
+ }
+
+ return res;
+ }
+}

src/main/java/g1501_1600/s1562_find_latest_group_of_size_m/readme.md

@@ -0,0 +1,58 @@
+1562\. Find Latest Group of Size M
+
+Medium
+
+Given an array `arr` that represents a permutation of numbers from `1` to `n`.
+
+You have a binary string of size `n` that initially has all its bits set to zero. At each step `i` (assuming both the binary string and `arr` are 1-indexed) from `1` to `n`, the bit at position `arr[i]` is set to `1`.
+
+You are also given an integer `m`. Find the latest step at which there exists a group of ones of length `m`. A group of ones is a contiguous substring of `1`'s such that it cannot be extended in either direction.
+
+Return _the latest step at which there exists a group of ones of length **exactly**_ `m`. _If no such group exists, return_ `-1`.
+
+**Example 1:**
+
+**Input:** arr = [3,5,1,2,4], m = 1
+
+**Output:** 4
+
+**Explanation:** 
+
+Step 1: "00100", groups: ["1"] 
+
+Step 2: "00101", groups: ["1", "1"] 
+
+Step 3: "10101", groups: ["1", "1", "1"] 
+
+Step 4: "11101", groups: ["111", "1"] 
+
+Step 5: "11111", groups: ["11111"] 
+
+The latest step at which there exists a group of size 1 is step 4.
+
+**Example 2:**
+
+**Input:** arr = [3,1,5,4,2], m = 2
+
+**Output:** -1
+
+**Explanation:** 
+
+Step 1: "00100", groups: ["1"] 
+
+Step 2: "10100", groups: ["1", "1"] 
+
+Step 3: "10101", groups: ["1", "1", "1"] 
+
+Step 4: "10111", groups: ["1", "111"] 
+
+Step 5: "11111", groups: ["11111"]
+
+No group of size 2 exists during any step.
+
+**Constraints:**
+
+* `n == arr.length`
+* <code>1 <= m <= n <= 10<sup>5</sup></code>
+* `1 <= arr[i] <= n`
+* All integers in `arr` are **distinct**.

src/main/java/g1501_1600/s1563_stone_game_v/Solution.java

@@ -0,0 +1,40 @@
+package g1501_1600.s1563_stone_game_v;
+
+// #Hard #Array #Dynamic_Programming #Math #Game_Theory
+// #2022_04_11_Time_36_ms_(95.56%)_Space_54.3_MB_(17.78%)
+
+public class Solution {
+ public int stoneGameV(int[] stoneValue) {
+ int n = stoneValue.length;
+ int[] ps = new int[n];
+ ps[0] = stoneValue[0];
+ for (int i = 1; i < n; i++) {
+ ps[i] = ps[i - 1] + stoneValue[i];
+ }
+ return gameDP(ps, 0, n - 1, new Integer[n][n]);
+ }
+
+ private int gameDP(int[] ps, int i, int j, Integer[][] dp) {
+ if (i == j) {
+ return 0;
+ }
+ if (dp[i][j] != null) {
+ return dp[i][j];
+ }
+ int max = 0;
+ for (int k = i + 1; k <= j; k++) {
+ int l = ps[k - 1] - (i == 0 ? 0 : ps[i - 1]);
+ int r = ps[j] - ps[k - 1];
+ if (2 * Math.min(l, r) < max) {
+ continue;
+ }
+ if (l <= r) {
+ max = Math.max(max, l + gameDP(ps, i, k - 1, dp));
+ }
+ if (l >= r) {
+ max = Math.max(max, r + gameDP(ps, k, j, dp));
+ }
+ }
+ return dp[i][j] = max;
+ }
+}

src/main/java/g1501_1600/s1563_stone_game_v/readme.md

@@ -0,0 +1,38 @@
+1563\. Stone Game V
+
+Hard
+
+There are several stones **arranged in a row**, and each stone has an associated value which is an integer given in the array `stoneValue`.
+
+In each round of the game, Alice divides the row into **two non-empty rows** (i.e. left row and right row), then Bob calculates the value of each row which is the sum of the values of all the stones in this row. Bob throws away the row which has the maximum value, and Alice's score increases by the value of the remaining row. If the value of the two rows are equal, Bob lets Alice decide which row will be thrown away. The next round starts with the remaining row.
+
+The game ends when there is only **one stone remaining**. Alice's is initially **zero**.
+
+Return _the maximum score that Alice can obtain_.
+
+**Example 1:**
+
+**Input:** stoneValue = [6,2,3,4,5,5]
+
+**Output:** 18
+
+**Explanation:** In the first round, Alice divides the row to [6,2,3], [4,5,5]. The left row has the value 11 and the right row has value 14. Bob throws away the right row and Alice's score is now 11. In the second round Alice divides the row to [6], [2,3]. This time Bob throws away the left row and Alice's score becomes 16 (11 + 5).
+
+ The last round Alice has only one choice to divide the row which is [2], [3]. Bob throws away the right row and Alice's score is now 18 (16 + 2). The game ends because only one stone is remaining in the row.
+
+**Example 2:**
+
+**Input:** stoneValue = [7,7,7,7,7,7,7]
+
+**Output:** 28
+
+**Example 3:**
+
+**Input:** stoneValue = [4]
+
+**Output:** 0
+
+**Constraints:**
+
+* `1 <= stoneValue.length <= 500`
+* <code>1 <= stoneValue[i] <= 10<sup>6</sup></code>

src/main/java/g1501_1600/s1566_detect_pattern_of_length_m_repeated_k_or_more_times/Solution.java

@@ -0,0 +1,26 @@
+package g1501_1600.s1566_detect_pattern_of_length_m_repeated_k_or_more_times;
+
+// #Easy #Array #Enumeration #2022_04_11_Time_1_ms_(49.25%)_Space_41.7_MB_(66.67%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public boolean containsPattern(int[] arr, int m, int k) {
+ for (int i = 0; i < arr.length - m; i++) {
+ int[] pattern = Arrays.copyOfRange(arr, i, i + m);
+ int times = 1;
+ for (int j = i + m; j < arr.length; j += m) {
+ int[] candidate = Arrays.copyOfRange(arr, j, j + m);
+ if (Arrays.equals(pattern, candidate)) {
+ times++;
+ if (times == k) {
+ return true;
+ }
+ } else {
+ break;
+ }
+ }
+ }
+ return false;
+ }
+}

src/main/java/g1501_1600/s1566_detect_pattern_of_length_m_repeated_k_or_more_times/readme.md

@@ -0,0 +1,40 @@
+1566\. Detect Pattern of Length M Repeated K or More Times
+
+Easy
+
+Given an array of positive integers `arr`, find a pattern of length `m` that is repeated `k` or more times.
+
+A **pattern** is a subarray (consecutive sub-sequence) that consists of one or more values, repeated multiple times **consecutively** without overlapping. A pattern is defined by its length and the number of repetitions.
+
+Return `true` _if there exists a pattern of length_ `m` _that is repeated_ `k` _or more times, otherwise return_ `false`.
+
+**Example 1:**
+
+**Input:** arr = [1,2,4,4,4,4], m = 1, k = 3
+
+**Output:** true
+
+**Explanation:** The pattern **(4)** of length 1 is repeated 4 consecutive times. Notice that pattern can be repeated k or more times but not less.
+
+**Example 2:**
+
+**Input:** arr = [1,2,1,2,1,1,1,3], m = 2, k = 2
+
+**Output:** true
+
+**Explanation:** The pattern **(1,2)** of length 2 is repeated 2 consecutive times. Another valid pattern **(2,1) is** also repeated 2 times.
+
+**Example 3:**
+
+**Input:** arr = [1,2,1,2,1,3], m = 2, k = 3
+
+**Output:** false
+
+**Explanation:** The pattern (1,2) is of length 2 but is repeated only 2 times. There is no pattern of length 2 that is repeated 3 or more times.
+
+**Constraints:**
+
+* `2 <= arr.length <= 100`
+* `1 <= arr[i] <= 100`
+* `1 <= m <= 100`
+* `2 <= k <= 100`

src/main/java/g1501_1600/s1567_maximum_length_of_subarray_with_positive_product/Solution.java

@@ -0,0 +1,27 @@
+package g1501_1600.s1567_maximum_length_of_subarray_with_positive_product;
+
+// #Medium #Array #Dynamic_Programming #Greedy #Dynamic_Programming_I_Day_6
+// #2022_04_11_Time_4_ms_(80.86%)_Space_77.8_MB_(65.54%)
+
+public class Solution {
+ public int getMaxLen(int[] nums) {
+ int posLen = 0;
+ int negLen = 0;
+ int res = 0;
+ for (int num : nums) {
+ if (num == 0) {
+ posLen = 0;
+ negLen = 0;
+ } else if (num > 0) {
+ posLen++;
+ negLen = negLen == 0 ? 0 : negLen + 1;
+ } else {
+ int temp = posLen;
+ posLen = negLen == 0 ? 0 : negLen + 1;
+ negLen = temp + 1;
+ }
+ res = Math.max(res, posLen);
+ }
+ return res;
+ }
+}

src/main/java/g1501_1600/s1567_maximum_length_of_subarray_with_positive_product/readme.md

@@ -0,0 +1,38 @@
+1567\. Maximum Length of Subarray With Positive Product
+
+Medium
+
+Given an array of integers `nums`, find the maximum length of a subarray where the product of all its elements is positive.
+
+A subarray of an array is a consecutive sequence of zero or more values taken out of that array.
+
+Return _the maximum length of a subarray with positive product_.
+
+**Example 1:**
+
+**Input:** nums = [1,-2,-3,4]
+
+**Output:** 4
+
+**Explanation:** The array nums already has a positive product of 24.
+
+**Example 2:**
+
+**Input:** nums = [0,1,-2,-3,-4]
+
+**Output:** 3
+
+**Explanation:** The longest subarray with positive product is [1,-2,-3] which has a product of 6. Notice that we cannot include 0 in the subarray since that'll make the product 0 which is not positive.
+
+**Example 3:**
+
+**Input:** nums = [-1,-2,-3,0,1]
+
+**Output:** 2
+
+**Explanation:** The longest subarray with positive product is [-1,-2] or [-2,-3].
+
+**Constraints:**
+
+* <code>1 <= nums.length <= 10<sup>5</sup></code>
+* <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>