Added tasks 2585-2589

Author: ThanhNIT

src/main/java/g2501_2600/s2585_number_of_ways_to_earn_points/Solution.java

@@ -0,0 +1,38 @@
+package g2501_2600.s2585_number_of_ways_to_earn_points;
+
+// #Hard #Array #Dynamic_Programming #2023_08_22_Time_56_ms_(76.40%)_Space_43.9_MB_(21.91%)
+
+public class Solution {
+    private static final int MOD = 1000000007;
+    private Integer[][] memo;
+
+    private int helper(int[][] types, int target, int typeIndex) {
+        int n = types.length;
+        if (typeIndex >= n) {
+            return target == 0 ? 1 : 0;
+        }
+        if (memo[typeIndex][target] != null) {
+            return memo[typeIndex][target];
+        }
+        int ways = 0;
+        ways = (ways + helper(types, target, typeIndex + 1)) % MOD;
+        int currQuestCount = types[typeIndex][0];
+        int currQuestPoint = types[typeIndex][1];
+        int pointsEarned;
+        for (int quest = 1; quest <= currQuestCount; quest++) {
+            pointsEarned = quest * currQuestPoint;
+            if (pointsEarned > target) {
+                break;
+            }
+            ways = (ways + helper(types, target - pointsEarned, typeIndex + 1)) % MOD;
+        }
+        memo[typeIndex][target] = ways;
+        return memo[typeIndex][target];
+    }
+
+    public int waysToReachTarget(int target, int[][] types) {
+        int n = types.length;
+        memo = new Integer[n + 1][target + 1];
+        return helper(types, target, 0);
+    }
+}

src/main/java/g2501_2600/s2585_number_of_ways_to_earn_points/readme.md

@@ -0,0 +1,55 @@
+2585\. Number of Ways to Earn Points
+
+Hard
+
+There is a test that has `n` types of questions. You are given an integer `target` and a **0-indexed** 2D integer array `types` where <code>types[i] = [count<sub>i</sub>, marks<sub>i</sub>]</code> indicates that there are <code>count<sub>i</sub></code> questions of the <code>i<sup>th</sup></code> type, and each one of them is worth <code>marks<sub>i</sub></code> points.
+
+Return _the number of ways you can earn **exactly**_ `target` _points in the exam_. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Note** that questions of the same type are indistinguishable.
+
+*   For example, if there are `3` questions of the same type, then solving the <code>1<sup>st</sup></code> and <code>2<sup>nd</sup></code> questions is the same as solving the <code>1<sup>st</sup></code> and <code>3<sup>rd</sup></code> questions, or the <code>2<sup>nd</sup></code> and <code>3<sup>rd</sup></code> questions.
+
+**Example 1:**
+
+**Input:** target = 6, types = [[6,1],[3,2],[2,3]]
+
+**Output:** 7
+
+**Explanation:** You can earn 6 points in one of the seven ways: 
+
+- Solve 6 questions of the 0<sup>th</sup> type: 1 + 1 + 1 + 1 + 1 + 1 = 6 
+- Solve 4 questions of the 0<sup>th</sup> type and 1 question of the 1<sup>st</sup> type: 1 + 1 + 1 + 1 + 2 = 6 
+- Solve 2 questions of the 0<sup>th</sup> type and 2 questions of the 1<sup>st</sup> type: 1 + 1 + 2 + 2 = 6 
+- Solve 3 questions of the 0<sup>th</sup> type and 1 question of the 2<sup>nd</sup> type: 1 + 1 + 1 + 3 = 6 
+- Solve 1 question of the 0<sup>th</sup> type, 1 question of the 1<sup>st</sup> type and 1 question of the 2<sup>nd</sup> type: 1 + 2 + 3 = 6 
+- Solve 3 questions of the 1<sup>st</sup> type: 2 + 2 + 2 = 6 - Solve 2 questions of the 2<sup>nd</sup> type: 3 + 3 = 6
+
+**Example 2:**
+
+**Input:** target = 5, types = [[50,1],[50,2],[50,5]]
+
+**Output:** 4
+
+**Explanation:** You can earn 5 points in one of the four ways: 
+
+- Solve 5 questions of the 0<sup>th</sup> type: 1 + 1 + 1 + 1 + 1 = 5
+- Solve 3 questions of the 0<sup>th</sup> type and 1 question of the 1<sup>st</sup> type: 1 + 1 + 1 + 2 = 5 
+- Solve 1 questions of the 0<sup>th</sup> type and 2 questions of the 1<sup>st</sup> type: 1 + 2 + 2 = 5 
+- Solve 1 question of the 2<sup>nd</sup> type: 5
+
+**Example 3:**
+
+**Input:** target = 18, types = [[6,1],[3,2],[2,3]]
+
+**Output:** 1
+
+**Explanation:** You can only earn 18 points by answering all questions.
+
+**Constraints:**
+
+*   `1 <= target <= 1000`
+*   `n == types.length`
+*   `1 <= n <= 50`
+*   `types[i].length == 2`
+*   <code>1 <= count<sub>i</sub>, marks<sub>i</sub> <= 50</code>

src/main/java/g2501_2600/s2586_count_the_number_of_vowel_strings_in_range/Solution.java

@@ -0,0 +1,20 @@
+package g2501_2600.s2586_count_the_number_of_vowel_strings_in_range;
+
+// #Easy #Array #String #2023_08_22_Time_1_ms_(100.00%)_Space_43.1_MB_(79.90%)
+
+public class Solution {
+    public int vowelStrings(String[] words, int left, int right) {
+        int count = 0;
+        for (int i = left; i <= right; i++) {
+            if (isVowel(words[i].charAt(0)) && isVowel(words[i].charAt(words[i].length() - 1))) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private boolean isVowel(char ch) {
+        String str = "aeiou";
+        return str.indexOf(ch) != -1;
+    }
+}

src/main/java/g2501_2600/s2586_count_the_number_of_vowel_strings_in_range/readme.md

@@ -0,0 +1,48 @@
+2586\. Count the Number of Vowel Strings in Range
+
+Easy
+
+You are given a **0-indexed** array of string `words` and two integers `left` and `right`.
+
+A string is called a **vowel string** if it starts with a vowel character and ends with a vowel character where vowel characters are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`.
+
+Return _the number of vowel strings_ `words[i]` _where_ `i` _belongs to the inclusive range_ `[left, right]`.
+
+**Example 1:**
+
+**Input:** words = ["are","amy","u"], left = 0, right = 2
+
+**Output:** 2
+
+**Explanation:**
+
+- "are" is a vowel string because it starts with 'a' and ends with 'e'.
+
+- "amy" is not a vowel string because it does not end with a vowel.
+
+- "u" is a vowel string because it starts with 'u' and ends with 'u'. The number of vowel strings in the mentioned range is 2.
+
+**Example 2:**
+
+**Input:** words = ["hey","aeo","mu","ooo","artro"], left = 1, right = 4
+
+**Output:** 3
+
+**Explanation:**
+
+- "aeo" is a vowel string because it starts with 'a' and ends with 'o'.
+
+- "mu" is not a vowel string because it does not start with a vowel.
+
+- "ooo" is a vowel string because it starts with 'o' and ends with 'o'.
+
+- "artro" is a vowel string because it starts with 'a' and ends with 'o'.
+
+The number of vowel strings in the mentioned range is 3.
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 10`
+*   `words[i]` consists of only lowercase English letters.
+*   `0 <= left <= right < words.length`

src/main/java/g2501_2600/s2587_rearrange_array_to_maximize_prefix_score/Solution.java

@@ -0,0 +1,21 @@
+package g2501_2600.s2587_rearrange_array_to_maximize_prefix_score;
+
+// #Medium #Array #Sorting #Greedy #Prefix_Sum
+// #2023_08_22_Time_28_ms_(92.55%)_Space_57.7_MB_(77.66%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxScore(int[] nums) {
+        Arrays.sort(nums);
+        int count = 0;
+        long sum = 0;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            sum += nums[i];
+            if (sum > 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

src/main/java/g2501_2600/s2587_rearrange_array_to_maximize_prefix_score/readme.md

@@ -0,0 +1,36 @@
+2587\. Rearrange Array to Maximize Prefix Score
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. You can rearrange the elements of `nums` to **any order** (including the given order).
+
+Let `prefix` be the array containing the prefix sums of `nums` after rearranging it. In other words, `prefix[i]` is the sum of the elements from `0` to `i` in `nums` after rearranging it. The **score** of `nums` is the number of positive integers in the array `prefix`.
+
+Return _the maximum score you can achieve_.
+
+**Example 1:**
+
+**Input:** nums = [2,-1,0,1,-3,3,-3]
+
+**Output:** 6
+
+**Explanation:**
+
+We can rearrange the array into nums = [2,3,1,-1,-3,0,-3].
+
+prefix = [2,5,6,5,2,2,-1], so the score is 6.
+
+It can be shown that 6 is the maximum score we can obtain.
+
+**Example 2:**
+
+**Input:** nums = [-2,-3,0]
+
+**Output:** 0
+
+**Explanation:** Any rearrangement of the array will result in a score of 0.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>6</sup> <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g2501_2600/s2588_count_the_number_of_beautiful_subarrays/Solution.java

@@ -0,0 +1,21 @@
+package g2501_2600.s2588_count_the_number_of_beautiful_subarrays;
+
+// #Medium #Array #Hash_Table #Bit_Manipulation #Prefix_Sum
+// #2023_08_22_Time_38_ms_(96.52%)_Space_58_MB_(52.17%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public long beautifulSubarrays(int[] nums) {
+        long count = 0;
+        int xor = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, 1);
+        for (int num : nums) {
+            xor ^= num;
+            count += map.merge(xor, 1, Integer::sum) - 1;
+        }
+        return count;
+    }
+}

src/main/java/g2501_2600/s2588_count_the_number_of_beautiful_subarrays/readme.md

@@ -0,0 +1,43 @@
+2588\. Count the Number of Beautiful Subarrays
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. In one operation, you can:
+
+*   Choose two different indices `i` and `j` such that `0 <= i, j < nums.length`.
+*   Choose a non-negative integer `k` such that the <code>k<sup>th</sup></code> bit (**0-indexed**) in the binary representation of `nums[i]` and `nums[j]` is `1`.
+*   Subtract <code>2<sup>k</sup></code> from `nums[i]` and `nums[j]`.
+
+A subarray is **beautiful** if it is possible to make all of its elements equal to `0` after applying the above operation any number of times.
+
+Return _the number of **beautiful subarrays** in the array_ `nums`.
+
+A subarray is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [4,3,1,2,4]
+
+**Output:** 2
+
+**Explanation:** There are 2 beautiful subarrays in nums: [4,<ins>3,1,2</ins>,4] and [<ins>4,3,1,2,4</ins>]. 
+- We can make all elements in the subarray [3,1,2] equal to 0 in the following way: 
+  - Choose [<ins>3</ins>, 1, <ins>2</ins>] and k = 1. Subtract 2<sup>1</sup> from both numbers. The subarray becomes [1, 1, 0]. 
+  - Choose [<ins>1</ins>, <ins>1</ins>, 0] and k = 0. Subtract 2<sup>0</sup> from both numbers. The subarray becomes [0, 0, 0]. 
+- We can make all elements in the subarray [4,3,1,2,4] equal to 0 in the following way: 
+  - Choose [<ins>4</ins>, 3, 1, 2, <ins>4</ins>] and k = 2. Subtract 2<sup>2</sup> from both numbers. The subarray becomes [0, 3, 1, 2, 0]. 
+  - Choose [0, <ins>3</ins>, <ins>1</ins>, 2, 0] and k = 0. Subtract 2<sup>0</sup> from both numbers. The subarray becomes [0, 2, 0, 2, 0]. 
+  - Choose [0, <ins>2</ins>, 0, <ins>2</ins>, 0] and k = 1. Subtract 2<sup>1</sup> from both numbers. The subarray becomes [0, 0, 0, 0, 0].
+
+**Example 2:**
+
+**Input:** nums = [1,10,4]
+
+**Output:** 0
+
+**Explanation:** There are no beautiful subarrays in nums.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g2501_2600/s2589_minimum_time_to_complete_all_tasks/Solution.java

@@ -0,0 +1,33 @@
+package g2501_2600.s2589_minimum_time_to_complete_all_tasks;
+
+// #Hard #Array #Sorting #Greedy #Binary_Search #Stack
+// #2023_08_22_Time_19_ms_(97.26%)_Space_43.9_MB_(72.60%)
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Solution {
+    public int findMinimumTime(int[][] tasks) {
+        Arrays.sort(tasks, Comparator.comparingInt(a -> a[1]));
+        boolean[] visited = new boolean[2001];
+        int output = 0;
+        for (int[] row : tasks) {
+            int num = 0;
+            for (int i = row[0]; i <= row[1]; i++) {
+                if (visited[i]) {
+                    num++;
+                }
+            }
+            int j = row[1];
+            while (num < row[2]) {
+                if (!visited[j]) {
+                    visited[j] = true;
+                    num++;
+                    output++;
+                }
+                j--;
+            }
+        }
+        return output;
+    }
+}

src/main/java/g2501_2600/s2589_minimum_time_to_complete_all_tasks/readme.md

@@ -0,0 +1,40 @@
+2589\. Minimum Time to Complete All Tasks
+
+Hard
+
+There is a computer that can run an unlimited number of tasks **at the same time**. You are given a 2D integer array `tasks` where <code>tasks[i] = [start<sub>i</sub>, end<sub>i</sub>, duration<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> task should run for a total of <code>duration<sub>i</sub></code> seconds (not necessarily continuous) within the **inclusive** time range <code>[start<sub>i</sub>, end<sub>i</sub>]</code>.
+
+You may turn on the computer only when it needs to run a task. You can also turn it off if it is idle.
+
+Return _the minimum time during which the computer should be turned on to complete all tasks_.
+
+**Example 1:**
+
+**Input:** tasks = [[2,3,1],[4,5,1],[1,5,2]]
+
+**Output:** 2
+
+**Explanation:** 
+- The first task can be run in the inclusive time range [2, 2]. 
+- The second task can be run in the inclusive time range [5, 5]. 
+- The third task can be run in the two inclusive time ranges [2, 2] and [5, 5]. The computer will be on for a total of 2 seconds.
+
+**Example 2:**
+
+**Input:** tasks = [[1,3,2],[2,5,3],[5,6,2]]
+
+**Output:** 4
+
+**Explanation:** 
+- The first task can be run in the inclusive time range [2, 3]. 
+- The second task can be run in the inclusive time ranges [2, 3] and [5, 5]. 
+- The third task can be run in the two inclusive time range [5, 6]. 
+
+The computer will be on for a total of 4 seconds.
+
+**Constraints:**
+
+*   `1 <= tasks.length <= 2000`
+*   `tasks[i].length == 3`
+*   <code>1 <= start<sub>i</sub>, end<sub>i</sub> <= 2000</code>
+*   <code>1 <= duration<sub>i</sub> <= end<sub>i</sub> - start<sub>i</sub> + 1</code>