Added tasks 2895-2900

Author: javadev

src/main/java/g2801_2900/s2895_minimum_processing_time/Solution.java

@@ -0,0 +1,29 @@
+package g2801_2900.s2895_minimum_processing_time;
+
+// #Medium #Array #Sorting #Greedy #2023_12_20_Time_23_ms_(99.30%)_Space_59.9_MB_(23.37%)
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public int minProcessingTime(List<Integer> processorTime, List<Integer> tasks) {
+        int[] proc = new int[processorTime.size()];
+        for (int i = 0, n = processorTime.size(); i < n; i++) {
+            proc[i] = processorTime.get(i);
+        }
+        int[] jobs = new int[tasks.size()];
+        for (int i = 0, n = tasks.size(); i < n; i++) {
+            jobs[i] = tasks.get(i);
+        }
+        Arrays.sort(proc);
+        Arrays.sort(jobs);
+        int maxTime = 0;
+        for (int i = 0, n = proc.length; i < n; i++) {
+            int procTime = proc[i] + jobs[jobs.length - 1 - i * 4];
+            if (procTime > maxTime) {
+                maxTime = procTime;
+            }
+        }
+        return maxTime;
+    }
+}

src/main/java/g2801_2900/s2895_minimum_processing_time/readme.md

@@ -0,0 +1,43 @@
+2895\. Minimum Processing Time
+
+Medium
+
+You have `n` processors each having `4` cores and `n * 4` tasks that need to be executed such that each core should perform only **one** task.
+
+Given a **0-indexed** integer array `processorTime` representing the time at which each processor becomes available for the first time and a **0-indexed** integer array `tasks` representing the time it takes to execute each task, return _the **minimum** time when all of the tasks have been executed by the processors._
+
+**Note:** Each core executes the task independently of the others.
+
+**Example 1:**
+
+**Input:** processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
+
+**Output:** 16
+
+**Explanation:**
+
+It's optimal to assign the tasks at indexes 4, 5, 6, 7 to the first processor which becomes available at time = 8, and the tasks at indexes 0, 1, 2, 3 to the second processor which becomes available at time = 10.
+
+Time taken by the first processor to finish execution of all tasks = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16.
+
+Time taken by the second processor to finish execution of all tasks = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13.
+
+Hence, it can be shown that the minimum time taken to execute all the tasks is 16.
+
+**Example 2:**
+
+**Input:** processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
+
+**Output:** 23
+
+**Explanation:**
+
+It's optimal to assign the tasks at indexes 1, 4, 5, 6 to the first processor which becomes available at time = 10, and the tasks at indexes 0, 2, 3, 7 to the second processor which becomes available at time = 20. Time taken by the first processor to finish execution of all tasks = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18. Time taken by the second processor to finish execution of all tasks = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23. Hence, it can be shown that the minimum time taken to execute all the tasks is 23. 
+
+**Constraints:**
+
+*   `1 <= n == processorTime.length <= 25000`
+*   <code>1 <= tasks.length <= 10<sup>5</sup></code>
+*   <code>0 <= processorTime[i] <= 10<sup>9</sup></code>
+*   <code>1 <= tasks[i] <= 10<sup>9</sup></code>
+*   `tasks.length == 4 * n`

src/main/java/g2801_2900/s2896_apply_operations_to_make_two_strings_equal/Solution.java

@@ -0,0 +1,34 @@
+package g2801_2900.s2896_apply_operations_to_make_two_strings_equal;
+
+// #Medium #String #Dynamic_Programming #2023_12_20_Time_1_ms_(100.00%)_Space_43_MB_(50.87%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    public int minOperations(String s1, String s2, int x) {
+        int n = s1.length();
+        ArrayList<Integer> diffs = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                diffs.add(i);
+            }
+        }
+        int m = diffs.size();
+        if ((m & 1) == 1) {
+            return -1;
+        } else if (m == 0) {
+            return 0;
+        }
+        int[] dp = new int[m];
+        dp[0] = 0;
+        dp[1] = Math.min(x, diffs.get(1) - diffs.get(0));
+        for (int i = 2; i < m; i++) {
+            if ((i & 1) == 1) {
+                dp[i] = Math.min(dp[i - 1] + x, dp[i - 2] + diffs.get(i) - diffs.get(i - 1));
+            } else {
+                dp[i] = Math.min(dp[i - 1], dp[i - 2] + diffs.get(i) - diffs.get(i - 1));
+            }
+        }
+        return dp[m - 1];
+    }
+}

src/main/java/g2801_2900/s2896_apply_operations_to_make_two_strings_equal/readme.md

@@ -0,0 +1 @@
+2896\.

src/main/java/g2801_2900/s2897_apply_operations_on_array_to_maximize_sum_of_squares/Solution.java

@@ -0,0 +1,29 @@
+package g2801_2900.s2897_apply_operations_on_array_to_maximize_sum_of_squares;
+
+// #Hard #Array #Hash_Table #Greedy #Bit_Manipulation
+// #2023_12_20_Time_29_ms_(98.00%)_Space_63.8_MB_(14.00%)
+
+import java.util.List;
+
+public class Solution {
+    public int maxSum(List<Integer> nums, int k) {
+        int[] bits = new int[32];
+        for (int n : nums) {
+            for (int i = 0; i < 32; ++i) {
+                bits[i] += (n >> i) & 1;
+            }
+        }
+        int mod = 1_000_000_007;
+        long sum = 0;
+        for (int i = 0; i < k; ++i) {
+            long n = 0;
+            for (int j = 0; j < 32; ++j) {
+                if (bits[j] > i) {
+                    n |= 1 << j;
+                }
+            }
+            sum = (sum + n * n % mod) % mod;
+        }
+        return (int) sum;
+    }
+}

src/main/java/g2801_2900/s2897_apply_operations_on_array_to_maximize_sum_of_squares/readme.md

@@ -0,0 +1,48 @@
+2897\. Apply Operations on Array to Maximize Sum of Squares
+
+Hard
+
+You are given a **0-indexed** integer array `nums` and a **positive** integer `k`.
+
+You can do the following operation on the array **any** number of times:
+
+*   Choose any two distinct indices `i` and `j` and **simultaneously** update the values of `nums[i]` to `(nums[i] AND nums[j])` and `nums[j]` to `(nums[i] OR nums[j])`. Here, `OR` denotes the bitwise `OR` operation, and `AND` denotes the bitwise `AND` operation.
+
+You have to choose `k` elements from the final array and calculate the sum of their **squares**.
+
+Return _the **maximum** sum of squares you can achieve_.
+
+Since the answer can be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [2,6,5,8], k = 2
+
+**Output:** 261
+
+**Explanation:** We can do the following operations on the array:
+
+- Choose i = 0 and j = 3, then change nums[0] to (2 AND 8) = 0 and nums[3] to (2 OR 8) = 10. The resulting array is nums = [0,6,5,10].
+
+- Choose i = 2 and j = 3, then change nums[2] to (5 AND 10) = 0 and nums[3] to (5 OR 10) = 15. The resulting array is nums = [0,6,0,15].
+
+We can choose the elements 15 and 6 from the final array. The sum of squares is 15<sup>2</sup> + 6<sup>2</sup> = 261.
+
+It can be shown that this is the maximum value we can get.
+
+**Example 2:**
+
+**Input:** nums = [4,5,4,7], k = 3
+
+**Output:** 90
+
+**Explanation:** We do not need to apply any operations.
+
+We can choose the elements 7, 5, and 4 with a sum of squares: 7<sup>2</sup> + 5<sup>2</sup> + 4<sup>2</sup> = 90.
+
+It can be shown that this is the maximum value we can get.
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2801_2900/s2899_last_visited_integers/Solution.java

@@ -0,0 +1,28 @@
+package g2801_2900.s2899_last_visited_integers;
+
+// #Easy #Array #String #Simulation #2023_12_20_Time_2_ms_(96.41%)_Space_44.5_MB_(5.24%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> lastVisitedIntegers(List<String> words) {
+        List<String> prevEle = new ArrayList<>();
+        List<Integer> res = new ArrayList<>();
+        int count = 0;
+        for (int i = 0; i < words.size(); i++) {
+            if (!words.get(i).equals("prev")) {
+                count = 0;
+                prevEle.add(words.get(i));
+                continue;
+            }
+            if (count >= prevEle.size()) {
+                res.add(-1);
+            } else {
+                res.add(Integer.parseInt(prevEle.get(prevEle.size() - count - 1)));
+            }
+            count++;
+        }
+        return res;
+    }
+}

src/main/java/g2801_2900/s2899_last_visited_integers/readme.md

@@ -0,0 +1,45 @@
+2899\. Last Visited Integers
+
+Easy
+
+Given a **0-indexed** array of strings `words` where `words[i]` is either a positive integer represented as a string or the string `"prev"`.
+
+Start iterating from the beginning of the array; for every `"prev"` string seen in `words`, find the **last visited integer** in `words` which is defined as follows:
+
+*   Let `k` be the number of consecutive `"prev"` strings seen so far (containing the current string). Let `nums` be the **0-indexed** array of **integers** seen so far and `nums_reverse` be the reverse of `nums`, then the integer at <code>(k - 1)<sup>th</sup></code> index of `nums_reverse` will be the **last visited integer** for this `"prev"`.
+*   If `k` is **greater** than the total visited integers, then the last visited integer will be `-1`.
+
+Return _an integer array containing the last visited integers._
+
+**Example 1:**
+
+**Input:** words = ["1","2","prev","prev","prev"]
+
+**Output:** [2,1,-1]
+
+**Explanation:**
+
+For "prev" at index = 2, last visited integer will be 2 as here the number of consecutive "prev" strings is 1, and in the array reverse\_nums, 2 will be the first element.
+
+For "prev" at index = 3, last visited integer will be 1 as there are a total of two consecutive "prev" strings including this "prev" which are visited, and 1 is the second last visited integer.
+
+For "prev" at index = 4, last visited integer will be -1 as there are a total of three consecutive "prev" strings including this "prev" which are visited, but the total number of integers visited is two.
+
+**Example 2:**
+
+**Input:** words = ["1","prev","2","prev","prev"]
+
+**Output:** [1,2,1]
+
+**Explanation:**
+
+For "prev" at index = 1, last visited integer will be 1.
+
+For "prev" at index = 3, last visited integer will be 2.
+
+For "prev" at index = 4, last visited integer will be 1 as there are a total of two consecutive "prev" strings including this "prev" which are visited, and 1 is the second last visited integer.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `words[i] == "prev"` or `1 <= int(words[i]) <= 100`

src/main/java/g2801_2900/s2900_longest_unequal_adjacent_groups_subsequence_i/Solution.java

@@ -0,0 +1,23 @@
+package g2801_2900.s2900_longest_unequal_adjacent_groups_subsequence_i;
+
+// #Medium #Array #String #Dynamic_Programming #Greedy
+// #2023_12_20_Time_1_ms_(100.00%)_Space_45_MB_(7.16%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("java:S1172")
+public class Solution {
+    public List<String> getWordsInLongestSubsequence(int n, String[] words, int[] groups) {
+        List<String> ans = new ArrayList<>();
+        ans.add(words[0]);
+        int prev = groups[0];
+        for (int i = 1; i < groups.length; i++) {
+            if (prev != groups[i]) {
+                ans.add(words[i]);
+                prev = groups[i];
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2801_2900/s2900_longest_unequal_adjacent_groups_subsequence_i/readme.md

@@ -0,0 +1,57 @@
+2900\. Longest Unequal Adjacent Groups Subsequence I
+
+Medium
+
+You are given an integer `n`, a **0-indexed** string array `words`, and a **0-indexed** **binary** array `groups`, both arrays having length `n`.
+
+You need to select the **longest** **subsequence** from an array of indices `[0, 1, ..., n - 1]`, such that for the subsequence denoted as <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> having length `k`, <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code>, for each `j` where `0 < j + 1 < k`.
+
+Return _a string array containing the words corresponding to the indices **(in order)** in the selected subsequence_. If there are multiple answers, return _any of them_.
+
+A **subsequence** of an array is a new array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements.
+
+**Note:** strings in `words` may be **unequal** in length.
+
+**Example 1:**
+
+**Input:** n = 3, words = ["e","a","b"], groups = [0,0,1]
+
+**Output:** ["e","b"]
+
+**Explanation:** A subsequence that can be selected is [0,2] because groups[0] != groups[2].
+
+So, a valid answer is [words[0],words[2]] = ["e","b"].
+
+Another subsequence that can be selected is [1,2] because groups[1] != groups[2].
+
+This results in [words[1],words[2]] = ["a","b"].
+
+It is also a valid answer.
+
+It can be shown that the length of the longest subsequence of indices that satisfies the condition is 2.
+
+**Example 2:**
+
+**Input:** n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
+
+**Output:** ["a","b","c"]
+
+**Explanation:** A subsequence that can be selected is [0,1,2] because groups[0] != groups[1] and groups[1] != groups[2].
+
+So, a valid answer is [words[0],words[1],words[2]] = ["a","b","c"].
+
+Another subsequence that can be selected is [0,1,3] because groups[0] != groups[1] and groups[1] != groups[3].
+
+This results in [words[0],words[1],words[3]] = ["a","b","d"].
+
+It is also a valid answer.
+
+It can be shown that the length of the longest subsequence of indices that satisfies the condition is 3.
+
+**Constraints:**
+
+*   `1 <= n == words.length == groups.length <= 100`
+*   `1 <= words[i].length <= 10`
+*   `0 <= groups[i] < 2`
+*   `words` consists of **distinct** strings.
+*   `words[i]` consists of lowercase English letters.