Added tasks 2138, 2139, 2140, 2141.

Author: ThanhNIT

src/main/java/g2101_2200/s2138_divide_a_string_into_groups_of_size_k/Solution.java

@@ -0,0 +1,36 @@
+package g2101_2200.s2138_divide_a_string_into_groups_of_size_k;
+
+// #Easy #String #Simulation #2022_06_05_Time_2_ms_(70.97%)_Space_42.6_MB_(65.21%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+ public String[] divideString(String s, int k, char fill) {
+ String[] ans = new String[(s.length() % k != 0) ? (s.length() / k) + 1 : s.length() / k];
+ int t = k;
+ List<String> str = new ArrayList<>();
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < s.length(); i++) {
+ if (t > 0) {
+ sb.append(s.charAt(i));
+ t--;
+ } else {
+ t = k;
+ str.add(sb.toString());
+ sb.setLength(0);
+ i--;
+ }
+ }
+ if (t > 0) {
+ while (t-- > 0) {
+ sb.append(fill);
+ }
+ }
+ str.add(sb.toString());
+ for (int i = 0; i < str.size(); i++) {
+ ans[i] = str.get(i);
+ }
+ return ans;
+ }
+}

src/main/java/g2101_2200/s2138_divide_a_string_into_groups_of_size_k/readme.md

@@ -0,0 +1,51 @@
+2138\. Divide a String Into Groups of Size k
+
+Easy
+
+A string `s` can be partitioned into groups of size `k` using the following procedure:
+
+* The first group consists of the first `k` characters of the string, the second group consists of the next `k` characters of the string, and so on. Each character can be a part of **exactly one** group.
+* For the last group, if the string **does not** have `k` characters remaining, a character `fill` is used to complete the group.
+
+Note that the partition is done so that after removing the `fill` character from the last group (if it exists) and concatenating all the groups in order, the resultant string should be `s`.
+
+Given the string `s`, the size of each group `k` and the character `fill`, return _a string array denoting the **composition of every group**_ `s` _has been divided into, using the above procedure_.
+
+**Example 1:**
+
+**Input:** s = "abcdefghi", k = 3, fill = "x"
+
+**Output:** ["abc","def","ghi"]
+
+**Explanation:** 
+
+The first 3 characters "abc" form the first group. 
+
+The next 3 characters "def" form the second group. 
+
+The last 3 characters "ghi" form the third group. 
+
+Since all groups can be completely filled by characters from the string, we do not need to use fill. 
+
+Thus, the groups formed are "abc", "def", and "ghi".
+
+**Example 2:**
+
+**Input:** s = "abcdefghij", k = 3, fill = "x"
+
+**Output:** ["abc","def","ghi","jxx"]
+
+**Explanation:** 
+
+Similar to the previous example, we are forming the first three groups "abc", "def", and "ghi". 
+
+For the last group, we can only use the character 'j' from the string. 
+
+To complete this group, we add 'x' twice. Thus, the 4 groups formed are "abc", "def", "ghi", and "jxx".
+
+**Constraints:**
+
+* `1 <= s.length <= 100`
+* `s` consists of lowercase English letters only.
+* `1 <= k <= 100`
+* `fill` is a lowercase English letter.

src/main/java/g2101_2200/s2139_minimum_moves_to_reach_target_score/Solution.java

@@ -0,0 +1,26 @@
+package g2101_2200.s2139_minimum_moves_to_reach_target_score;
+
+// #Medium #Math #Greedy #2022_06_05_Time_1_ms_(37.95%)_Space_40.8_MB_(55.49%)
+
+public class Solution {
+ public int minMoves(int target, int maxDoubles) {
+ int count = 0;
+ while (target > 1) {
+ if (maxDoubles > 0 && target % 2 == 0) {
+ maxDoubles--;
+ target = target / 2;
+
+ } else {
+ if (maxDoubles == 0) {
+ count = count + target - 1;
+ return count;
+ } else {
+ target = target - 1;
+ }
+ }
+
+ count++;
+ }
+ return count;
+ }
+}

src/main/java/g2101_2200/s2139_minimum_moves_to_reach_target_score/readme.md

@@ -0,0 +1,61 @@
+2139\. Minimum Moves to Reach Target Score
+
+Medium
+
+You are playing a game with integers. You start with the integer `1` and you want to reach the integer `target`.
+
+In one move, you can either:
+
+* **Increment** the current integer by one (i.e., `x = x + 1`).
+* **Double** the current integer (i.e., `x = 2 * x`).
+
+You can use the **increment** operation **any** number of times, however, you can only use the **double** operation **at most** `maxDoubles` times.
+
+Given the two integers `target` and `maxDoubles`, return _the minimum number of moves needed to reach_ `target` _starting with_ `1`.
+
+**Example 1:**
+
+**Input:** target = 5, maxDoubles = 0
+
+**Output:** 4
+
+**Explanation:** Keep incrementing by 1 until you reach target.
+
+**Example 2:**
+
+**Input:** target = 19, maxDoubles = 2
+
+**Output:** 7
+
+**Explanation:** Initially, x = 1 
+
+Increment 3 times so x = 4 
+
+Double once so x = 8 
+
+Increment once so x = 9 
+
+Double again so x = 18 
+
+Increment once so x = 19
+
+**Example 3:**
+
+**Input:** target = 10, maxDoubles = 4
+
+**Output:** 4
+
+**Explanation:** Initially, x = 1 
+
+Increment once so x = 2 
+
+Double once so x = 4 
+
+Increment once so x = 5 
+
+Double again so x = 10
+
+**Constraints:**
+
+* <code>1 <= target <= 10<sup>9</sup></code>
+* `0 <= maxDoubles <= 100`

src/main/java/g2101_2200/s2140_solving_questions_with_brainpower/Solution.java

@@ -0,0 +1,19 @@
+package g2101_2200.s2140_solving_questions_with_brainpower;
+
+// #Medium #Array #Dynamic_Programming #2022_06_05_Time_5_ms_(98.77%)_Space_92.6_MB_(94.67%)
+
+public class Solution {
+ public long mostPoints(int[][] questions) {
+ int n = questions.length;
+ long[] memo = new long[n];
+ memo[n - 1] = questions[n - 1][0];
+ for (int i = n - 2; i >= 0; i--) {
+ if (i + questions[i][1] + 1 < n) {
+ memo[i] = Math.max(memo[i + 1], questions[i][0] + memo[i + questions[i][1] + 1]);
+ } else {
+ memo[i] = Math.max(memo[i + 1], questions[i][0]);
+ }
+ }
+ return memo[0];
+ }
+}

src/main/java/g2101_2200/s2140_solving_questions_with_brainpower/readme.md

@@ -0,0 +1,53 @@
+2140\. Solving Questions With Brainpower
+
+Medium
+
+You are given a **0-indexed** 2D integer array `questions` where <code>questions[i] = [points<sub>i</sub>, brainpower<sub>i</sub>]</code>.
+
+The array describes the questions of an exam, where you have to process the questions **in order** (i.e., starting from question `0`) and make a decision whether to **solve** or **skip** each question. Solving question `i` will **earn** you <code>points<sub>i</sub></code> points but you will be **unable** to solve each of the next <code>brainpower<sub>i</sub></code> questions. If you skip question `i`, you get to make the decision on the next question.
+
+* For example, given `questions = [[3, 2], [4, 3], [4, 4], [2, 5]]`:
+ * If question `0` is solved, you will earn `3` points but you will be unable to solve questions `1` and `2`.
+ * If instead, question `0` is skipped and question `1` is solved, you will earn `4` points but you will be unable to solve questions `2` and `3`.
+
+Return _the **maximum** points you can earn for the exam_.
+
+**Example 1:**
+
+**Input:** questions = [[3,2],[4,3],[4,4],[2,5]]
+
+**Output:** 5
+
+**Explanation:** The maximum points can be earned by solving questions 0 and 3. 
+
+- Solve question 0: Earn 3 points, will be unable to solve the next 2 questions 
+
+- Unable to solve questions 1 and 2 
+
+- Solve question 3: Earn 2 points 
+ 
+Total points earned: 3 + 2 = 5. There is no other way to earn 5 or more points.
+
+**Example 2:**
+
+**Input:** questions = [[1,1],[2,2],[3,3],[4,4],[5,5]]
+
+**Output:** 7
+
+**Explanation:** The maximum points can be earned by solving questions 1 and 4. 
+
+- Skip question 0 
+
+- Solve question 1: Earn 2 points, will be unable to solve the next 2 questions 
+
+- Unable to solve questions 2 and 3 
+
+- Solve question 4: Earn 5 points 
+ 
+Total points earned: 2 + 5 = 7. There is no other way to earn 7 or more points.
+
+**Constraints:**
+
+* <code>1 <= questions.length <= 10<sup>5</sup></code>
+* `questions[i].length == 2`
+* <code>1 <= points<sub>i</sub>, brainpower<sub>i</sub> <= 10<sup>5</sup></code>

src/main/java/g2101_2200/s2141_maximum_running_time_of_n_computers/Solution.java

@@ -0,0 +1,34 @@
+package g2101_2200.s2141_maximum_running_time_of_n_computers;
+
+// #Hard #Array #Sorting #Greedy #Binary_Search
+// #2022_06_05_Time_24_ms_(70.39%)_Space_83.1_MB_(5.83%)
+
+public class Solution {
+ private boolean isPossibeToRun(int n, int[] batteries, long avgTime) {
+ long duration = 0;
+ for (long ele : batteries) {
+ duration += Math.min(ele, avgTime);
+ }
+ return avgTime * n <= duration;
+ }
+
+ public long maxRunTime(int n, int[] batteries) {
+ long startTime = 0;
+ long sum = 0;
+ long ans = 0;
+ for (long ele : batteries) {
+ sum += ele;
+ }
+ long endTime = sum;
+ while (startTime <= endTime) {
+ long avgTime = (startTime + endTime) / 2;
+ if (isPossibeToRun(n, batteries, avgTime)) {
+ ans = avgTime;
+ startTime = avgTime + 1;
+ } else {
+ endTime = avgTime - 1;
+ }
+ }
+ return ans;
+ }
+}

src/main/java/g2101_2200/s2141_maximum_running_time_of_n_computers/readme.md

@@ -0,0 +1,54 @@
+2141\. Maximum Running Time of N Computers
+
+Hard
+
+You have `n` computers. You are given the integer `n` and a **0-indexed** integer array `batteries` where the <code>i<sup>th</sup></code> battery can **run** a computer for `batteries[i]` minutes. You are interested in running **all** `n` computers **simultaneously** using the given batteries.
+
+Initially, you can insert **at most one battery** into each computer. After that and at any integer time moment, you can remove a battery from a computer and insert another battery **any number of times**. The inserted battery can be a totally new battery or a battery from another computer. You may assume that the removing and inserting processes take no time.
+
+Note that the batteries cannot be recharged.
+
+Return _the **maximum** number of minutes you can run all the_ `n` _computers simultaneously._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/01/06/example1-fit.png)
+
+**Input:** n = 2, batteries = [3,3,3]
+
+**Output:** 4
+
+**Explanation:** 
+
+Initially, insert battery 0 into the first computer and battery 1 into the second computer. 
+
+After two minutes, remove battery 1 from the second computer and insert battery 2 instead. Note that battery 1 can still run for one minute.
+
+At the end of the third minute, battery 0 is drained, and you need to remove it from the first computer and insert battery 1 instead. 
+
+By the end of the fourth minute, battery 1 is also drained, and the first computer is no longer running. 
+
+We can run the two computers simultaneously for at most 4 minutes, so we return 4.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/01/06/example2.png)
+
+**Input:** n = 2, batteries = [1,1,1,1]
+
+**Output:** 2
+
+**Explanation:** 
+
+Initially, insert battery 0 into the first computer and battery 2 into the second computer. 
+
+After one minute, battery 0 and battery 2 are drained so you need to remove them and insert battery 1 into the first computer and battery 3 into the second computer. 
+
+After another minute, battery 1 and battery 3 are also drained so the first and second computers are no longer running. 
+
+We can run the two computers simultaneously for at most 2 minutes, so we return 2.
+
+**Constraints:**
+
+* <code>1 <= n <= batteries.length <= 10<sup>5</sup></code>
+* <code>1 <= batteries[i] <= 10<sup>9</sup></code>

src/test/java/g2101_2200/s2138_divide_a_string_into_groups_of_size_k/SolutionTest.java

@@ -0,0 +1,22 @@
+package g2101_2200.s2138_divide_a_string_into_groups_of_size_k;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void divideString() {
+ assertThat(
+ new Solution().divideString("abcdefghi", 3, 'x'),
+ equalTo(new String[] {"abc", "def", "ghi"}));
+ }
+
+ @Test
+ void divideString2() {
+ assertThat(
+ new Solution().divideString("abcdefghij", 3, 'x'),
+ equalTo(new String[] {"abc", "def", "ghi", "jxx"}));
+ }
+}

src/test/java/g2101_2200/s2139_minimum_moves_to_reach_target_score/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2101_2200.s2139_minimum_moves_to_reach_target_score;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minMoves() {
+ assertThat(new Solution().minMoves(5, 0), equalTo(4));
+ }
+
+ @Test
+ void minMoves2() {
+ assertThat(new Solution().minMoves(19, 2), equalTo(7));
+ }
+
+ @Test
+ void minMoves3() {
+ assertThat(new Solution().minMoves(10, 4), equalTo(4));
+ }
+}