Added tasks 1834, 1835, 1837, 1838, 1839.

Author: ThanhNIT

src/main/java/g1801_1900/s1834_single_threaded_cpu/Solution.java

@@ -0,0 +1,53 @@
+package g1801_1900.s1834_single_threaded_cpu;
+
+// #Medium #Array #Sorting #Heap_Priority_Queue
+// #2022_05_07_Time_134_ms_(83.22%)_Space_100.6_MB_(75.23%)
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int[] getOrder(int[][] tasks1) {
+        int n = tasks1.length;
+
+        int[][] tasks = new int[n][3];
+
+        for (int i = 0; i < n; i++) {
+            tasks[i] = new int[] {tasks1[i][0], tasks1[i][1], i};
+        }
+
+        Arrays.sort(tasks, Comparator.comparingInt(a -> a[0]));
+        PriorityQueue<int[]> minHeap =
+                new PriorityQueue<>(
+                        (a, b) -> {
+                            if (a[1] == b[1]) {
+                                return a[2] - b[2];
+                            } else {
+                                return a[1] - b[1];
+                            }
+                        });
+
+        int time = tasks[0][0];
+
+        int[] taskOrderResult = new int[n];
+
+        int i = 0;
+        int index = 0;
+        while (!minHeap.isEmpty() || i < n) {
+            while (i < n && time >= tasks[i][0]) {
+                minHeap.add(tasks[i++]);
+            }
+
+            if (!minHeap.isEmpty()) {
+                int[] task = minHeap.remove();
+                taskOrderResult[index++] = task[2];
+                time += task[1];
+            } else {
+                time = tasks[i][0];
+            }
+        }
+
+        return taskOrderResult;
+    }
+}

src/main/java/g1801_1900/s1834_single_threaded_cpu/readme.md

@@ -0,0 +1,66 @@
+1834\. Single-Threaded CPU
+
+Medium
+
+You are given `n` tasks labeled from `0` to `n - 1` represented by a 2D integer array `tasks`, where <code>tasks[i] = [enqueueTime<sub>i</sub>, processingTime<sub>i</sub>]</code> means that the <code>i<sup>th</sup></code> task will be available to process at <code>enqueueTime<sub>i</sub></code> and will take <code>processingTime<sub>i</sub></code> to finish processing.
+
+You have a single-threaded CPU that can process **at most one** task at a time and will act in the following way:
+
+*   If the CPU is idle and there are no available tasks to process, the CPU remains idle.
+*   If the CPU is idle and there are available tasks, the CPU will choose the one with the **shortest processing time**. If multiple tasks have the same shortest processing time, it will choose the task with the smallest index.
+*   Once a task is started, the CPU will **process the entire task** without stopping.
+*   The CPU can finish a task then start a new one instantly.
+
+Return _the order in which the CPU will process the tasks._
+
+**Example 1:**
+
+**Input:** tasks = [[1,2],[2,4],[3,2],[4,1]]
+
+**Output:** [0,2,3,1]
+
+**Explanation:** The events go as follows: 
+
+- At time = 1, task 0 is available to process. Available tasks = {0}. 
+
+- Also at time = 1, the idle CPU starts processing task 0. Available tasks = {}. 
+
+- At time = 2, task 1 is available to process. Available tasks = {1}.
+
+- At time = 3, task 2 is available to process. Available tasks = {1, 2}. 
+
+- Also at time = 3, the CPU finishes task 0 and starts processing task 2 as it is the shortest. Available tasks = {1}. 
+
+- At time = 4, task 3 is available to process. Available tasks = {1, 3}. - At time = 5, the CPU finishes task 2 and starts processing task 3 as it is the shortest. Available tasks = {1}. 
+
+- At time = 6, the CPU finishes task 3 and starts processing task 1. Available tasks = {}. 
+
+- At time = 10, the CPU finishes task 1 and becomes idle.
+
+**Example 2:**
+
+**Input:** tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
+
+**Output:** [4,3,2,0,1]
+
+**Explanation:****:** The events go as follows: 
+
+- At time = 7, all the tasks become available. Available tasks = {0,1,2,3,4}. 
+
+- Also at time = 7, the idle CPU starts processing task 4. Available tasks = {0,1,2,3}. 
+
+- At time = 9, the CPU finishes task 4 and starts processing task 3. Available tasks = {0,1,2}. 
+
+- At time = 13, the CPU finishes task 3 and starts processing task 2. Available tasks = {0,1}. 
+
+- At time = 18, the CPU finishes task 2 and starts processing task 0. Available tasks = {1}. 
+
+- At time = 28, the CPU finishes task 0 and starts processing task 1. Available tasks = {}. 
+
+- At time = 40, the CPU finishes task 1 and becomes idle.
+
+**Constraints:**
+
+*   `tasks.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= enqueueTime<sub>i</sub>, processingTime<sub>i</sub> <= 10<sup>9</sup></code>

src/main/java/g1801_1900/s1835_find_xor_sum_of_all_pairs_bitwise_and/Solution.java

@@ -0,0 +1,17 @@
+package g1801_1900.s1835_find_xor_sum_of_all_pairs_bitwise_and;
+
+// #Hard #Array #Math #Bit_Manipulation #2022_05_07_Time_1_ms_(100.00%)_Space_57.9_MB_(83.33%)
+
+public class Solution {
+    public int getXORSum(int[] arr1, int[] arr2) {
+        int xor1 = 0;
+        int xor2 = 0;
+        for (int i : arr1) {
+            xor1 ^= i;
+        }
+        for (int j : arr2) {
+            xor2 ^= j;
+        }
+        return xor1 & xor2;
+    }
+}

src/main/java/g1801_1900/s1835_find_xor_sum_of_all_pairs_bitwise_and/readme.md

@@ -0,0 +1,34 @@
+1835\. Find XOR Sum of All Pairs Bitwise AND
+
+Hard
+
+The **XOR sum** of a list is the bitwise `XOR` of all its elements. If the list only contains one element, then its **XOR sum** will be equal to this element.
+
+*   For example, the **XOR sum** of `[1,2,3,4]` is equal to `1 XOR 2 XOR 3 XOR 4 = 4`, and the **XOR sum** of `[3]` is equal to `3`.
+
+You are given two **0-indexed** arrays `arr1` and `arr2` that consist only of non-negative integers.
+
+Consider the list containing the result of `arr1[i] AND arr2[j]` (bitwise `AND`) for every `(i, j)` pair where `0 <= i < arr1.length` and `0 <= j < arr2.length`.
+
+Return _the **XOR sum** of the aforementioned list_.
+
+**Example 1:**
+
+**Input:** arr1 = [1,2,3], arr2 = [6,5]
+
+**Output:** 0
+
+**Explanation:** The list = [1 AND 6, 1 AND 5, 2 AND 6, 2 AND 5, 3 AND 6, 3 AND 5] = [0,1,2,0,2,1]. The XOR sum = 0 XOR 1 XOR 2 XOR 0 XOR 2 XOR 1 = 0.
+
+**Example 2:**
+
+**Input:** arr1 = [12], arr2 = [4]
+
+**Output:** 4
+
+**Explanation:** The list = [12 AND 4] = [4]. The XOR sum = 4.
+
+**Constraints:**
+
+*   <code>1 <= arr1.length, arr2.length <= 10<sup>5</sup></code>
+*   <code>0 <= arr1[i], arr2[j] <= 10<sup>9</sup></code>

src/main/java/g1801_1900/s1837_sum_of_digits_in_base_k/Solution.java

@@ -0,0 +1,14 @@
+package g1801_1900.s1837_sum_of_digits_in_base_k;
+
+// #Easy #Math #2022_05_07_Time_1_ms_(10.42%)_Space_38.9_MB_(91.55%)
+
+public class Solution {
+    public int sumBase(int n, int k) {
+        String str = Integer.toString(Integer.parseInt(n + "", 10), k);
+        int sum = 0;
+        for (char c : str.toCharArray()) {
+            sum += Character.getNumericValue(c);
+        }
+        return sum;
+    }
+}

src/main/java/g1801_1900/s1837_sum_of_digits_in_base_k/readme.md

@@ -0,0 +1,28 @@
+1837\. Sum of Digits in Base K
+
+Easy
+
+Given an integer `n` (in base `10`) and a base `k`, return _the **sum** of the digits of_ `n` _**after** converting_ `n` _from base_ `10` _to base_ `k`.
+
+After converting, each digit should be interpreted as a base `10` number, and the sum should be returned in base `10`.
+
+**Example 1:**
+
+**Input:** n = 34, k = 6
+
+**Output:** 9
+
+**Explanation:** 34 (base 10) expressed in base 6 is 54. 5 + 4 = 9.
+
+**Example 2:**
+
+**Input:** n = 10, k = 10
+
+**Output:** 1
+
+**Explanation:** n is already in base 10. 1 + 0 = 1.
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   `2 <= k <= 10`

src/main/java/g1801_1900/s1838_frequency_of_the_most_frequent_element/Solution.java

@@ -0,0 +1,46 @@
+package g1801_1900.s1838_frequency_of_the_most_frequent_element;
+
+// #Medium #Array #Sorting #Greedy #Binary_Search #Prefix_Sum #Sliding_Window
+// #Binary_Search_II_Day_9 #2022_05_07_Time_11_ms_(100.00%)_Space_57_MB_(97.86%)
+
+public class Solution {
+    public int maxFrequency(int[] nums, int k) {
+        countingSort(nums);
+        int start = 0;
+        int preSum = 0;
+        int total = 1;
+        for (int i = 0; i < nums.length; i++) {
+            int length = i - start + 1;
+            int product = nums[i] * length;
+            preSum += nums[i];
+            while (product - preSum > k) {
+                preSum -= nums[start++];
+                length--;
+                product = nums[i] * length;
+            }
+            total = Math.max(total, length);
+        }
+
+        return total;
+    }
+
+    private void countingSort(int[] nums) {
+        int max = Integer.MIN_VALUE;
+        for (int num : nums) {
+            max = Math.max(max, num);
+        }
+        int[] map = new int[max + 1];
+        for (int num : nums) {
+            map[num]++;
+        }
+        int i = 0;
+        int j = 0;
+        while (i <= max) {
+            if (map[i]-- > 0) {
+                nums[j++] = i;
+            } else {
+                i++;
+            }
+        }
+    }
+}

src/main/java/g1801_1900/s1838_frequency_of_the_most_frequent_element/readme.md

@@ -0,0 +1,43 @@
+1838\. Frequency of the Most Frequent Element
+
+Medium
+
+The **frequency** of an element is the number of times it occurs in an array.
+
+You are given an integer array `nums` and an integer `k`. In one operation, you can choose an index of `nums` and increment the element at that index by `1`.
+
+Return _the **maximum possible frequency** of an element after performing **at most**_ `k` _operations_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,4], k = 5
+
+**Output:** 3
+
+**Explanation:** Increment the first element three times and the second element two times to make nums = [4,4,4]. 4 has a frequency of 3.
+
+**Example 2:**
+
+**Input:** nums = [1,4,8,13], k = 5
+
+**Output:** 2
+
+**Explanation:** There are multiple optimal solutions: 
+
+- Increment the first element three times to make nums = [4,4,8,13]. 4 has a frequency of 2.
+
+- Increment the second element four times to make nums = [1,8,8,13]. 8 has a frequency of 2. 
+
+- Increment the third element five times to make nums = [1,4,13,13]. 13 has a frequency of 2.
+
+**Example 3:**
+
+**Input:** nums = [3,9,6], k = 2
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= k <= 10<sup>5</sup></code>

src/main/java/g1801_1900/s1839_longest_substring_of_all_vowels_in_order/Solution.java

@@ -0,0 +1,27 @@
+package g1801_1900.s1839_longest_substring_of_all_vowels_in_order;
+
+// #Medium #String #Sliding_Window #2022_05_07_Time_24_ms_(86.13%)_Space_58.7_MB_(49.58%)
+
+public class Solution {
+    public int longestBeautifulSubstring(String word) {
+        int cnt = 1;
+        int len = 1;
+        int maxLen = 0;
+        for (int i = 1; i != word.length(); ++i) {
+            if (word.charAt(i - 1) == word.charAt(i)) {
+                ++len;
+            } else if (word.charAt(i - 1) < word.charAt(i)) {
+                ++len;
+                ++cnt;
+            } else {
+                cnt = 1;
+                len = 1;
+            }
+
+            if (cnt == 5) {
+                maxLen = Math.max(maxLen, len);
+            }
+        }
+        return maxLen;
+    }
+}

src/main/java/g1801_1900/s1839_longest_substring_of_all_vowels_in_order/readme.md

@@ -0,0 +1,43 @@
+1839\. Longest Substring Of All Vowels in Order
+
+Medium
+
+A string is considered **beautiful** if it satisfies the following conditions:
+
+*   Each of the 5 English vowels (`'a'`, `'e'`, `'i'`, `'o'`, `'u'`) must appear **at least once** in it.
+*   The letters must be sorted in **alphabetical order** (i.e. all `'a'`s before `'e'`s, all `'e'`s before `'i'`s, etc.).
+
+For example, strings `"aeiou"` and `"aaaaaaeiiiioou"` are considered **beautiful**, but `"uaeio"`, `"aeoiu"`, and `"aaaeeeooo"` are **not beautiful**.
+
+Given a string `word` consisting of English vowels, return _the **length of the longest beautiful substring** of_ `word`_. If no such substring exists, return_ `0`.
+
+A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** word = "aeiaaioaaaaeiiiiouuuooaauuaeiu"
+
+**Output:** 13
+
+**Explanation:** The longest beautiful substring in word is "aaaaeiiiiouuu" of length 13.
+
+**Example 2:**
+
+**Input:** word = "aeeeiiiioooauuuaeiou"
+
+**Output:** 5
+
+**Explanation:** The longest beautiful substring in word is "aeiou" of length 5.
+
+**Example 3:**
+
+**Input:** word = "a"
+
+**Output:** 0
+
+**Explanation:** There is no beautiful substring, so return 0.
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 5 * 10<sup>5</sup></code>
+*   `word` consists of characters `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`.