Added tasks 2381, 2382, 2383.

Author: javadev

README.md

@@ -1848,6 +1848,9 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2383 |[Minimum Hours of Training to Win a Competition](src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/Solution.java)| Easy | Array, Greedy | 0 | 100.00
+| 2382 |[Maximum Segment Sum After Removals](src/main/java/g2301_2400/s2382_maximum_segment_sum_after_removals/Solution.java)| Hard | Array, Prefix_Sum, Union_Find, Ordered_Set | 28 | 100.00
+| 2381 |[Shifting Letters II](src/main/java/g2301_2400/s2381_shifting_letters_ii/Solution.java)| Medium | Array, String, Prefix_Sum | 10 | 75.00
 | 2380 |[Time Needed to Rearrange a Binary String](src/main/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/Solution.java)| Medium | String, Dynamic_Programming, Simulation | 3 | 70.00
 | 2379 |[Minimum Recolors to Get K Consecutive Black Blocks](src/main/java/g2301_2400/s2379_minimum_recolors_to_get_k_consecutive_black_blocks/Solution.java)| Easy | String, Sliding_Window | 1 | 80.00
 | 2376 |[Count Special Integers](src/main/java/g2301_2400/s2376_count_special_integers/Solution.java)| Hard | Dynamic_Programming, Math | 0 | 100.00

src/main/java/g2301_2400/s2381_shifting_letters_ii/Solution.java

@@ -0,0 +1,37 @@
+package g2301_2400.s2381_shifting_letters_ii;
+
+// #Medium #Array #String #Prefix_Sum #2022_08_25_Time_10_ms_(75.00%)_Space_82.7_MB_(75.00%)
+
+public class Solution {
+    public String shiftingLetters(String s, int[][] shifts) {
+        int[] diff = new int[s.length() + 1];
+        int l;
+        int r;
+        for (int[] shift : shifts) {
+            l = shift[0];
+            r = shift[1] + 1;
+            diff[l] += 26;
+            diff[r] += 26;
+            if (shift[2] == 0) {
+                diff[l]--;
+                diff[r]++;
+            } else {
+                diff[l]++;
+                diff[r]--;
+            }
+            diff[l] %= 26;
+            diff[r] %= 26;
+        }
+        StringBuilder sb = new StringBuilder();
+        int current = 0;
+        int val;
+        for (int i = 0; i < s.length(); ++i) {
+            current += diff[i];
+            val = s.charAt(i) - 'a';
+            val += current;
+            val %= 26;
+            sb.append((char) ('a' + val));
+        }
+        return sb.toString();
+    }
+}

src/main/java/g2301_2400/s2381_shifting_letters_ii/readme.md

@@ -0,0 +1,39 @@
+2381\. Shifting Letters II
+
+Medium
+
+You are given a string `s` of lowercase English letters and a 2D integer array `shifts` where <code>shifts[i] = [start<sub>i</sub>, end<sub>i</sub>, direction<sub>i</sub>]</code>. For every `i`, **shift** the characters in `s` from the index <code>start<sub>i</sub></code> to the index <code>end<sub>i</sub></code> (**inclusive**) forward if <code>direction<sub>i</sub> = 1</code>, or shift the characters backward if <code>direction<sub>i</sub> = 0</code>.
+
+Shifting a character **forward** means replacing it with the **next** letter in the alphabet (wrapping around so that `'z'` becomes `'a'`). Similarly, shifting a character **backward** means replacing it with the **previous** letter in the alphabet (wrapping around so that `'a'` becomes `'z'`).
+
+Return _the final string after all such shifts to_ `s` _are applied_.
+
+**Example 1:**
+
+**Input:** s = "abc", shifts = [[0,1,0],[1,2,1],[0,2,1]]
+
+**Output:** "ace"
+
+**Explanation:** Firstly, shift the characters from index 0 to index 1 backward. Now s = "zac".
+
+Secondly, shift the characters from index 1 to index 2 forward. Now s = "zbd".
+
+Finally, shift the characters from index 0 to index 2 forward. Now s = "ace".
+
+**Example 2:**
+
+**Input:** s = "dztz", shifts = [[0,0,0],[1,1,1]]
+
+**Output:** "catz"
+
+**Explanation:** Firstly, shift the characters from index 0 to index 0 backward. Now s = "cztz".
+
+Finally, shift the characters from index 1 to index 1 forward. Now s = "catz".
+
+**Constraints:**
+
+*   <code>1 <= s.length, shifts.length <= 5 * 10<sup>4</sup></code>
+*   `shifts[i].length == 3`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> < s.length</code>
+*   <code>0 <= direction<sub>i</sub> <= 1</code>
+*   `s` consists of lowercase English letters.

src/main/java/g2301_2400/s2382_maximum_segment_sum_after_removals/Solution.java

@@ -0,0 +1,71 @@
+package g2301_2400.s2382_maximum_segment_sum_after_removals;
+
+// #Hard #Array #Prefix_Sum #Union_Find #Ordered_Set
+// #2022_08_25_Time_28_ms_(100.00%)_Space_139.3_MB_(42.86%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static class UF {
+        int[] root;
+        long[] sum;
+
+        public UF(int n) {
+            this.root = new int[n];
+            Arrays.fill(this.root, -1);
+            this.sum = new long[n];
+        }
+
+        public void insert(int x, int value) {
+            if (root[x] != -1 || sum[x] != 0) {
+                return;
+            }
+            this.root[x] = x;
+            this.sum[x] = value;
+        }
+
+        public int find(int x) {
+            while (root[x] != x) {
+                int fa = root[x];
+                int ga = root[fa];
+                root[x] = ga;
+                x = fa;
+            }
+            return x;
+        }
+
+        public void union(int x, int y) {
+            int rx = find(x);
+            int ry = find(y);
+            if (x == y) {
+                return;
+            }
+            root[rx] = ry;
+            sum[ry] += sum[rx];
+        }
+
+        public boolean has(int x) {
+            return root[x] != -1 || sum[x] != 0;
+        }
+    }
+
+    public long[] maximumSegmentSum(int[] nums, int[] removeQueries) {
+        int n = removeQueries.length;
+        long[] ret = new long[n];
+        long max = 0L;
+        UF uf = new UF(n);
+        for (int i = n - 1; i >= 0; i--) {
+            int u = removeQueries[i];
+            uf.insert(u, nums[u]);
+            for (int v = u - 1; v <= u + 1; v += 2) {
+                if (v >= 0 && v < n && uf.has(v)) {
+                    uf.union(v, u);
+                }
+            }
+            ret[i] = max;
+            int ru = uf.find(u);
+            max = Math.max(max, uf.sum[ru]);
+        }
+        return ret;
+    }
+}

src/main/java/g2301_2400/s2382_maximum_segment_sum_after_removals/readme.md

@@ -0,0 +1,57 @@
+2382\. Maximum Segment Sum After Removals
+
+Hard
+
+You are given two **0-indexed** integer arrays `nums` and `removeQueries`, both of length `n`. For the <code>i<sup>th</sup></code> query, the element in `nums` at the index `removeQueries[i]` is removed, splitting `nums` into different segments.
+
+A **segment** is a contiguous sequence of **positive** integers in `nums`. A **segment sum** is the sum of every element in a segment.
+
+Return _an integer array_ `answer`_, of length_ `n`_, where_ `answer[i]` _is the **maximum** segment sum after applying the_ <code>i<sup>th</sup></code> _removal._
+
+**Note:** The same index will **not** be removed more than once.
+
+**Example 1:**
+
+**Input:** nums = [1,2,5,6,1], removeQueries = [0,3,2,4,1]
+
+**Output:** [14,7,2,2,0]
+
+**Explanation:** Using 0 to indicate a removed element, the answer is as follows:
+
+Query 1: Remove the 0th element, nums becomes [0,2,5,6,1] and the maximum segment sum is 14 for segment [2,5,6,1].
+
+Query 2: Remove the 3rd element, nums becomes [0,2,5,0,1] and the maximum segment sum is 7 for segment [2,5].
+
+Query 3: Remove the 2nd element, nums becomes [0,2,0,0,1] and the maximum segment sum is 2 for segment [2].
+
+Query 4: Remove the 4th element, nums becomes [0,2,0,0,0] and the maximum segment sum is 2 for segment [2].
+
+Query 5: Remove the 1st element, nums becomes [0,0,0,0,0] and the maximum segment sum is 0, since there are no segments.
+
+Finally, we return [14,7,2,2,0].
+
+**Example 2:**
+
+**Input:** nums = [3,2,11,1], removeQueries = [3,2,1,0]
+
+**Output:** [16,5,3,0]
+
+**Explanation:** Using 0 to indicate a removed element, the answer is as follows:
+
+Query 1: Remove the 3rd element, nums becomes [3,2,11,0] and the maximum segment sum is 16 for segment [3,2,11].
+
+Query 2: Remove the 2nd element, nums becomes [3,2,0,0] and the maximum segment sum is 5 for segment [3,2].
+
+Query 3: Remove the 1st element, nums becomes [3,0,0,0] and the maximum segment sum is 3 for segment [3].
+
+Query 4: Remove the 0th element, nums becomes [0,0,0,0] and the maximum segment sum is 0, since there are no segments.
+
+Finally, we return [16,5,3,0].
+
+**Constraints:**
+
+*   `n == nums.length == removeQueries.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   `0 <= removeQueries[i] < n`
+*   All the values of `removeQueries` are **unique**.

src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/Solution.java

@@ -0,0 +1,29 @@
+package g2301_2400.s2383_minimum_hours_of_training_to_win_a_competition;
+
+// #Easy #Array #Greedy #2022_08_25_Time_0_ms_(100.00%)_Space_42.4_MB_(42.86%)
+
+public class Solution {
+    public int minNumberOfHours(
+            int initialEnergy, int initialExperience, int[] energy, int[] experience) {
+        int totalEnergy = 0;
+        for (int e : energy) {
+            totalEnergy += e;
+        }
+        int result = Math.max(0, totalEnergy - initialEnergy + 1);
+        int currentExp = initialExperience;
+        int exp;
+        for (int i = 0; i < experience.length - 1; ++i) {
+            exp = experience[i];
+            if (currentExp <= exp) {
+                result += exp - currentExp + 1;
+                currentExp = exp + 1;
+            }
+            currentExp += exp;
+        }
+        int last = experience[experience.length - 1];
+        if (currentExp <= last) {
+            result += last - currentExp + 1;
+        }
+        return result;
+    }
+}

src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/readme.md

@@ -0,0 +1,59 @@
+2383\. Minimum Hours of Training to Win a Competition
+
+Easy
+
+You are entering a competition, and are given two **positive** integers `initialEnergy` and `initialExperience` denoting your initial energy and initial experience respectively.
+
+You are also given two **0-indexed** integer arrays `energy` and `experience`, both of length `n`.
+
+You will face `n` opponents **in order**. The energy and experience of the <code>i<sup>th</sup></code> opponent is denoted by `energy[i]` and `experience[i]` respectively. When you face an opponent, you need to have both **strictly** greater experience and energy to defeat them and move to the next opponent if available.
+
+Defeating the <code>i<sup>th</sup></code> opponent **increases** your experience by `experience[i]`, but **decreases** your energy by `energy[i]`.
+
+Before starting the competition, you can train for some number of hours. After each hour of training, you can **either** choose to increase your initial experience by one, or increase your initial energy by one.
+
+Return _the **minimum** number of training hours required to defeat all_ `n` _opponents_.
+
+**Example 1:**
+
+**Input:** initialEnergy = 5, initialExperience = 3, energy = [1,4,3,2], experience = [2,6,3,1]
+
+**Output:** 8
+
+**Explanation:** You can increase your energy to 11 after 6 hours of training, and your experience to 5 after 2 hours of training.
+
+You face the opponents in the following order:
+
+- You have more energy and experience than the 0<sup>th</sup> opponent so you win.
+
+  Your energy becomes 11 - 1 = 10, and your experience becomes 5 + 2 = 7.
+  
+- You have more energy and experience than the 1<sup>st</sup> opponent so you win.
+
+  Your energy becomes 10 - 4 = 6, and your experience becomes 7 + 6 = 13.
+  
+- You have more energy and experience than the 2<sup>nd</sup> opponent so you win.
+
+  Your energy becomes 6 - 3 = 3, and your experience becomes 13 + 3 = 16.
+  
+- You have more energy and experience than the 3<sup>rd</sup> opponent so you win.
+
+  Your energy becomes 3 - 2 = 1, and your experience becomes 16 + 1 = 17.
+  
+You did a total of 6 + 2 = 8 hours of training before the competition, so we return 8.
+
+It can be proven that no smaller answer exists. 
+
+**Example 2:**
+
+**Input:** initialEnergy = 2, initialExperience = 4, energy = [1], experience = [3]
+
+**Output:** 0
+
+**Explanation:** You do not need any additional energy or experience to win the competition, so we return 0. 
+
+**Constraints:**
+
+*   `n == energy.length == experience.length`
+*   `1 <= n <= 100`
+*   `1 <= initialEnergy, initialExperience, energy[i], experience[i] <= 100`

src/test/java/g2301_2400/s2381_shifting_letters_ii/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2301_2400.s2381_shifting_letters_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void shiftingLetters() {
+        assertThat(
+                new Solution()
+                        .shiftingLetters("abc", new int[][] {{0, 1, 0}, {1, 2, 1}, {0, 2, 1}}),
+                equalTo("ace"));
+    }
+
+    @Test
+    void shiftingLetters2() {
+        assertThat(
+                new Solution().shiftingLetters("dztz", new int[][] {{0, 0, 0}, {1, 1, 1}}),
+                equalTo("catz"));
+    }
+}

src/test/java/g2301_2400/s2382_maximum_segment_sum_after_removals/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2301_2400.s2382_maximum_segment_sum_after_removals;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumSegmentSum() {
+        assertThat(
+                new Solution()
+                        .maximumSegmentSum(new int[] {1, 2, 5, 6, 1}, new int[] {0, 3, 2, 4, 1}),
+                equalTo(new long[] {14, 7, 2, 2, 0}));
+    }
+
+    @Test
+    void maximumSegmentSum2() {
+        assertThat(
+                new Solution().maximumSegmentSum(new int[] {3, 2, 11, 1}, new int[] {3, 2, 1, 0}),
+                equalTo(new long[] {16, 5, 3, 0}));
+    }
+}

src/test/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/SolutionTest.java

@@ -0,0 +1,21 @@
+package g2301_2400.s2383_minimum_hours_of_training_to_win_a_competition;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minNumberOfHours() {
+        assertThat(
+                new Solution()
+                        .minNumberOfHours(5, 3, new int[] {1, 4, 3, 2}, new int[] {2, 6, 3, 1}),
+                equalTo(8));
+    }
+
+    @Test
+    void minNumberOfHours2() {
+        assertThat(new Solution().minNumberOfHours(2, 4, new int[] {1}, new int[] {3}), equalTo(0));
+    }
+}