packageg2801_2900.s2895_minimum_processing_time;

importjava.util.Arrays;

importjava.util.List;

publicclassSolution {

publicintminProcessingTime(List<Integer>processorTime,List<Integer>tasks) {

int[]proc =newint[processorTime.size()];

for (inti =0,n =processorTime.size();i <n;i++) {

proc[i] =processorTime.get(i);

}

int[]jobs =newint[tasks.size()];

for (inti =0,n =tasks.size();i <n;i++) {

jobs[i] =tasks.get(i);

}

Arrays.sort(proc);

Arrays.sort(jobs);

intmaxTime =0;

for (inti =0,n =proc.length;i <n;i++) {

intprocTime =proc[i] +jobs[jobs.length -1 -i *4];

if (procTime >maxTime) {

maxTime =procTime;

}

}

returnmaxTime;

}

}

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:**

* <code>1 <= tasks.length <= 10⁵</code>

* <code>0 <= processorTime[i] <= 10⁹</code>

* <code>1 <= tasks[i] <= 10⁹</code>

packageg2801_2900.s2896_apply_operations_to_make_two_strings_equal;

importjava.util.ArrayList;

publicclassSolution {

publicintminOperations(Strings1,Strings2,intx) {

intn =s1.length();

ArrayList<Integer>diffs =newArrayList<>();

for (inti =0;i <n;i++) {

if (s1.charAt(i) !=s2.charAt(i)) {

diffs.add(i);

}

}

intm =diffs.size();

if ((m &1) ==1) {

return -1;

}elseif (m ==0) {

return0;

}

int[]dp =newint[m];

dp[0] =0;

dp[1] =Math.min(x,diffs.get(1) -diffs.get(0));

for (inti =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));

}

}

returndp[m -1];

}

}

2896\.

packageg2801_2900.s2897_apply_operations_on_array_to_maximize_sum_of_squares;

importjava.util.List;

publicclassSolution {

publicintmaxSum(List<Integer>nums,intk) {

int[]bits =newint[32];

for (intn :nums) {

for (inti =0;i <32; ++i) {

bits[i] += (n >>i) &1;

}

}

intmod =1_000_000_007;

longsum =0;

for (inti =0;i <k; ++i) {

longn =0;

for (intj =0;j <32; ++j) {

if (bits[j] >i) {

n |=1 <<j;

}

}

sum = (sum +n *n %mod) %mod;

}

return (int)sum;

}

}

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⁹ + 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² + 6² = 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² + 5² + 4² = 90.

It can be shown that this is the maximum value we can get.

**Constraints:**

* <code>1 <= k <= nums.length <= 10⁵</code>

* <code>1 <= nums[i] <= 10⁹</code>

packageg2801_2900.s2899_last_visited_integers;

importjava.util.ArrayList;

importjava.util.List;

publicclassSolution {

publicList<Integer>lastVisitedIntegers(List<String>words) {

List<String>prevEle =newArrayList<>();

List<Integer>res =newArrayList<>();

intcount =0;

for (inti =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++;

}

returnres;

}

}

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)^th</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:**

*`words[i] == "prev"` or`1 <= int(words[i]) <= 100`

packageg2801_2900.s2900_longest_unequal_adjacent_groups_subsequence_i;

importjava.util.ArrayList;

importjava.util.List;

@SuppressWarnings("java:S1172")

publicclassSolution {

publicList<String>getWordsInLongestSubsequence(intn,String[]words,int[]groups) {

List<String>ans =newArrayList<>();

ans.add(words[0]);

intprev =groups[0];

for (inti =1;i <groups.length;i++) {

if (prev !=groups[i]) {

ans.add(words[i]);

prev =groups[i];

}

}

returnans;

}

}

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₀, i₁, ..., i_{k - 1}]</code> having length`k`, <code>groups[i_j] != groups[i_{j + 1}]</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:**

*`words` consists of**distinct** strings.

*`words[i]` consists of lowercase English letters.

packageg2801_2900.s2895_minimum_processing_time;

importstaticorg.hamcrest.CoreMatchers.equalTo;

importstaticorg.hamcrest.MatcherAssert.assertThat;

importjava.util.Arrays;

importorg.junit.jupiter.api.Test;

classSolutionTest {

voidminProcessingTime() {

assertThat(

newSolution()

.minProcessingTime(

Arrays.asList(8,10),Arrays.asList(2,2,3,1,8,7,4,5)),

equalTo(16));

}

voidminProcessingTime2() {

assertThat(

newSolution()

.minProcessingTime(

Arrays.asList(10,20),Arrays.asList(2,3,1,2,5,8,4,3)),

equalTo(23));

}

}

packageg2801_2900.s2896_apply_operations_to_make_two_strings_equal;

importstaticorg.hamcrest.CoreMatchers.equalTo;

importstaticorg.hamcrest.MatcherAssert.assertThat;

importorg.junit.jupiter.api.Test;

classSolutionTest {

voidminOperations() {

assertThat(newSolution().minOperations("1100011000","0101001010",2),equalTo(4));

}

voidminOperations2() {

assertThat(newSolution().minOperations("10110","00011",4),equalTo(-1));

}

}