Added tasks 2028, 2029, 2030, 2032, 2033.

Author: ThanhNIT

src/main/java/g2001_2100/s2028_find_missing_observations/Solution.java

@@ -0,0 +1,27 @@
+package g2001_2100.s2028_find_missing_observations;
+
+// #Medium #Array #Math #Simulation #2022_05_25_Time_10_ms_(31.40%)_Space_165.4_MB_(26.74%)
+
+public class Solution {
+ public int[] missingRolls(int[] rolls, int mean, int n) {
+ int m = rolls.length;
+ int msum = 0;
+ int[] res = new int[n];
+ for (int roll : rolls) {
+ msum += roll;
+ }
+ int totalmn = mean * (m + n) - msum;
+ if (totalmn < n || totalmn > n * 6) {
+ return new int[0];
+ }
+ int j = 0;
+ while (totalmn > 0) {
+ int dice = Math.min(6, totalmn - n + 1);
+ res[j] = dice;
+ totalmn = totalmn - dice;
+ n--;
+ j++;
+ }
+ return res;
+ }
+}

src/main/java/g2001_2100/s2028_find_missing_observations/readme.md

@@ -0,0 +1,43 @@
+2028\. Find Missing Observations
+
+Medium
+
+You have observations of `n + m` **6-sided** dice rolls with each face numbered from `1` to `6`. `n` of the observations went missing, and you only have the observations of `m` rolls. Fortunately, you have also calculated the **average value** of the `n + m` rolls.
+
+You are given an integer array `rolls` of length `m` where `rolls[i]` is the value of the <code>i<sup>th</sup></code> observation. You are also given the two integers `mean` and `n`.
+
+Return _an array of length_ `n` _containing the missing observations such that the **average value** of the_ `n + m` _rolls is **exactly**_ `mean`. If there are multiple valid answers, return _any of them_. If no such array exists, return _an empty array_.
+
+The **average value** of a set of `k` numbers is the sum of the numbers divided by `k`.
+
+Note that `mean` is an integer, so the sum of the `n + m` rolls should be divisible by `n + m`.
+
+**Example 1:**
+
+**Input:** rolls = [3,2,4,3], mean = 4, n = 2
+
+**Output:** [6,6]
+
+**Explanation:** The mean of all n + m rolls is (3 + 2 + 4 + 3 + 6 + 6) / 6 = 4.
+
+**Example 2:**
+
+**Input:** rolls = [1,5,6], mean = 3, n = 4
+
+**Output:** [2,3,2,2]
+
+**Explanation:** The mean of all n + m rolls is (1 + 5 + 6 + 2 + 3 + 2 + 2) / 7 = 3.
+
+**Example 3:**
+
+**Input:** rolls = [1,2,3,4], mean = 6, n = 4
+
+**Output:** []
+
+**Explanation:** It is impossible for the mean to be 6 no matter what the 4 missing rolls are.
+
+**Constraints:**
+
+* `m == rolls.length`
+* <code>1 <= n, m <= 10<sup>5</sup></code>
+* `1 <= rolls[i], mean <= 6`

src/main/java/g2001_2100/s2029_stone_game_ix/Solution.java

@@ -0,0 +1,85 @@
+package g2001_2100.s2029_stone_game_ix;
+
+// #Medium #Array #Math #Greedy #Counting #Game_Theory
+// #2022_05_25_Time_31_ms_(10.87%)_Space_114.5_MB_(65.22%)
+
+public class Solution {
+ private int[] stones;
+
+ public boolean stoneGameIX(int[] stones) {
+ this.stones = stones;
+ int[] freq = new int[3];
+ for (int i : stones) {
+ if (i % 3 == 0) {
+ freq[0]++;
+ } else if (i % 3 == 1) {
+ freq[1]++;
+ } else {
+ freq[2]++;
+ }
+ }
+ boolean b1 = false;
+ boolean b2 = false;
+ int[] a = freq.clone();
+ int[] b = freq.clone();
+ if (a[1] > 0) {
+ a[1]--;
+ b1 = fun(a, 1);
+ }
+ if (b[2] > 0) {
+ b[2]--;
+ b2 = fun(b, 2);
+ }
+ return b1 || b2;
+ }
+
+ private boolean fun(int[] freq, int sum) {
+ int n = stones.length;
+ int i = 1;
+ while (i < n) {
+ if (i % 2 == 0) {
+ if (sum % 3 == 1) {
+ if (freq[0] > 0) {
+ freq[0]--;
+ } else if (freq[1] > 0) {
+ freq[1]--;
+ sum += 1;
+ } else {
+ return false;
+ }
+ } else if (sum % 3 == 2) {
+ if (freq[0] > 0) {
+ freq[0]--;
+ } else if (freq[2] > 0) {
+ freq[2]--;
+ sum += 2;
+ } else {
+ return false;
+ }
+ }
+ } else {
+ if (sum % 3 == 2) {
+ if (freq[0] > 0) {
+ freq[0]--;
+ } else if (freq[2] > 0) {
+ freq[2]--;
+ sum += 2;
+ } else {
+ return true;
+ }
+ } else if (sum % 3 == 1) {
+ if (freq[0] > 0) {
+ freq[0]--;
+ } else if (freq[1] > 0) {
+ freq[1]--;
+ sum += 1;
+ } else {
+ return true;
+ }
+ }
+ }
+ i++;
+ }
+ return false;
+ }
+}

src/main/java/g2001_2100/s2029_stone_game_ix/readme.md

@@ -0,0 +1,58 @@
+2029\. Stone Game IX
+
+Medium
+
+Alice and Bob continue their games with stones. There is a row of n stones, and each stone has an associated value. You are given an integer array `stones`, where `stones[i]` is the **value** of the <code>i<sup>th</sup></code> stone.
+
+Alice and Bob take turns, with **Alice** starting first. On each turn, the player may remove any stone from `stones`. The player who removes a stone **loses** if the **sum** of the values of **all removed stones** is divisible by `3`. Bob will win automatically if there are no remaining stones (even if it is Alice's turn).
+
+Assuming both players play **optimally**, return `true` _if Alice wins and_ `false` _if Bob wins_.
+
+**Example 1:**
+
+**Input:** stones = [2,1]
+
+**Output:** true
+
+**Explanation:** The game will be played as follows: 
+
+- Turn 1: Alice can remove either stone. 
+
+- Turn 2: Bob removes the remaining stone. 
+ 
+The sum of the removed stones is 1 + 2 = 3 and is divisible by 3. Therefore, Bob loses and Alice wins the game.
+
+**Example 2:**
+
+**Input:** stones = [2]
+
+**Output:** false
+
+**Explanation:** Alice will remove the only stone, and the sum of the values on the removed stones is 2. 
+
+Since all the stones are removed and the sum of values is not divisible by 3, Bob wins the game.
+
+**Example 3:**
+
+**Input:** stones = [5,1,2,4,3]
+
+**Output:** false
+
+**Explanation:** Bob will always win. One possible way for Bob to win is shown below: 
+
+- Turn 1: Alice can remove the second stone with value 1. Sum of removed stones = 1. 
+
+- Turn 2: Bob removes the fifth stone with value 3. Sum of removed stones = 1 + 3 = 4. 
+
+- Turn 3: Alices removes the fourth stone with value 4. Sum of removed stones = 1 + 3 + 4 = 8. 
+
+- Turn 4: Bob removes the third stone with value 2. Sum of removed stones = 1 + 3 + 4 + 2 = 10. 
+
+- Turn 5: Alice removes the first stone with value 5. Sum of removed stones = 1 + 3 + 4 + 2 + 5 = 15.
+ 
+Alice loses the game because the sum of the removed stones (15) is divisible by 3. Bob wins the game.
+
+**Constraints:**
+
+* <code>1 <= stones.length <= 10<sup>5</sup></code>
+* <code>1 <= stones[i] <= 10<sup>4</sup></code>

src/main/java/g2001_2100/s2030_smallest_k_length_subsequence_with_occurrences_of_a_letter/Solution.java

@@ -0,0 +1,28 @@
+package g2001_2100.s2030_smallest_k_length_subsequence_with_occurrences_of_a_letter;
+
+// #Hard #String #Greedy #Stack #Monotonic_Stack
+// #2022_05_25_Time_131_ms_(64.46%)_Space_72.3_MB_(46.99%)
+
+public class Solution {
+ public String smallestSubsequence(String s, int k, char letter, int repetition) {
+ int count = 0;
+ for (char c : s.toCharArray()) {
+ count += c == letter ? 1 : 0;
+ }
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < s.length(); count -= s.charAt(i++) == letter ? 1 : 0) {
+ while (sb.length() + s.length() > i + k
+ && sb.length() > 0
+ && s.charAt(i) < sb.charAt(sb.length() - 1)
+ && (sb.charAt(sb.length() - 1) != letter || count != repetition)) {
+ repetition += sb.charAt(sb.length() - 1) == letter ? 1 : 0;
+ sb.setLength(sb.length() - 1);
+ }
+ if (k - sb.length() > Math.max(0, s.charAt(i) == letter ? 0 : repetition)) {
+ sb.append(s.charAt(i));
+ repetition -= s.charAt(i) == letter ? 1 : 0;
+ }
+ }
+ return sb.toString();
+ }
+}

src/main/java/g2001_2100/s2030_smallest_k_length_subsequence_with_occurrences_of_a_letter/readme.md

@@ -0,0 +1,53 @@
+2030\. Smallest K-Length Subsequence With Occurrences of a Letter
+
+Hard
+
+You are given a string `s`, an integer `k`, a letter `letter`, and an integer `repetition`.
+
+Return _the **lexicographically smallest** subsequence of_ `s` _of length_ `k` _that has the letter_ `letter` _appear **at least**_ `repetition` _times_. The test cases are generated so that the `letter` appears in `s` **at least** `repetition` times.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.
+
+A string `a` is **lexicographically smaller** than a string `b` if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`.
+
+**Example 1:**
+
+**Input:** s = "leet", k = 3, letter = "e", repetition = 1
+
+**Output:** "eet"
+
+**Explanation:** There are four subsequences of length 3 that have the letter 'e' appear at least 1 time: 
+
+- "lee" (from "**lee**t") 
+
+- "let" (from "**le**e**t**") 
+
+- "let" (from "**l**e**et**") 
+
+- "eet" (from "l**eet**") 
+ 
+The lexicographically smallest subsequence among them is "eet".
+
+**Example 2:**
+
+![example-2](https://assets.leetcode.com/uploads/2021/09/13/smallest-k-length-subsequence.png)
+
+**Input:** s = "leetcode", k = 4, letter = "e", repetition = 2
+
+**Output:** "ecde"
+
+**Explanation:** "ecde" is the lexicographically smallest subsequence of length 4 that has the letter "e" appear at least 2 times.
+
+**Example 3:**
+
+**Input:** s = "bb", k = 2, letter = "b", repetition = 2
+
+**Output:** "bb"
+
+**Explanation:** "bb" is the only subsequence of length 2 that has the letter "b" appear at least 2 times.
+
+**Constraints:**
+
+* <code>1 <= repetition <= k <= s.length <= 5 * 10<sup>4</sup></code>
+* `s` consists of lowercase English letters.
+* `letter` is a lowercase English letter, and appears in `s` at least `repetition` times.

src/main/java/g2001_2100/s2032_two_out_of_three/Solution.java

@@ -0,0 +1,44 @@
+package g2001_2100.s2032_two_out_of_three;
+
+// #Easy #Array #Hash_Table #2022_05_25_Time_9_ms_(45.56%)_Space_47.4_MB_(38.52%)
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+ public List<Integer> twoOutOfThree(int[] nums1, int[] nums2, int[] nums3) {
+ Set<Integer> ans = new HashSet<>();
+ Set<Integer> set1 = new HashSet<>();
+ for (int i : nums1) {
+ set1.add(i);
+ }
+ Set<Integer> set2 = new HashSet<>();
+ for (int i : nums2) {
+ set2.add(i);
+ }
+ Set<Integer> set3 = new HashSet<>();
+ for (int i : nums3) {
+ set3.add(i);
+ }
+ for (int j : nums1) {
+ if (set2.contains(j) || set3.contains(j)) {
+ ans.add(j);
+ }
+ }
+ for (int j : nums2) {
+ if (set1.contains(j) || set3.contains(j)) {
+ ans.add(j);
+ }
+ }
+ for (int j : nums3) {
+ if (set1.contains(j) || set2.contains(j)) {
+ ans.add(j);
+ }
+ }
+ List<Integer> result = new ArrayList<>();
+ result.addAll(ans);
+ return result;
+ }
+}

src/main/java/g2001_2100/s2032_two_out_of_three/readme.md

@@ -0,0 +1,44 @@
+2032\. Two Out of Three
+
+Easy
+
+Given three integer arrays `nums1`, `nums2`, and `nums3`, return _a **distinct** array containing all the values that are present in **at least two** out of the three arrays. You may return the values in **any** order_.
+
+**Example 1:**
+
+**Input:** nums1 = [1,1,3,2], nums2 = [2,3], nums3 = [3]
+
+**Output:** [3,2]
+
+**Explanation:** The values that are present in at least two arrays are: 
+
+- 3, in all three arrays. 
+
+- 2, in nums1 and nums2.
+
+**Example 2:**
+
+**Input:** nums1 = [3,1], nums2 = [2,3], nums3 = [1,2]
+
+**Output:** [2,3,1]
+
+**Explanation:** The values that are present in at least two arrays are: 
+
+- 2, in nums2 and nums3.
+
+- 3, in nums1 and nums2. 
+
+- 1, in nums1 and nums3.
+
+**Example 3:**
+
+**Input:** nums1 = [1,2,2], nums2 = [4,3,3], nums3 = [5]
+
+**Output:** []
+
+**Explanation:** No value is present in at least two arrays.
+
+**Constraints:**
+
+* `1 <= nums1.length, nums2.length, nums3.length <= 100`
+* `1 <= nums1[i], nums2[j], nums3[k] <= 100`