Added tasks 2432, 2433, 2434.

Author: ThanhNIT

src/main/java/g2401_2500/s2432_the_employee_that_worked_on_the_longest_task/Solution.java

@@ -0,0 +1,29 @@
+package g2401_2500.s2432_the_employee_that_worked_on_the_longest_task;
+
+// #Easy #Array #2022_12_07_Time_2_ms_(74.60%)_Space_53.7_MB_(69.30%)
+
+public class Solution {
+    public int hardestWorker(int[][] logs) {
+        int result;
+        int i;
+        int max;
+        int tid;
+        int temp;
+        max = 0;
+        tid = Integer.MAX_VALUE;
+        for (i = 0; i < logs.length; i++) {
+            temp = logs[i][1];
+            if (i > 0) {
+                temp -= logs[i - 1][1];
+            }
+            if (temp > max) {
+                max = temp;
+                tid = logs[i][0];
+            } else if (temp == max && tid > logs[i][0]) {
+                tid = logs[i][0];
+            }
+        }
+        result = tid;
+        return result;
+    }
+}

src/main/java/g2401_2500/s2432_the_employee_that_worked_on_the_longest_task/readme.md

@@ -0,0 +1,74 @@
+2432\. The Employee That Worked on the Longest Task
+
+Easy
+
+There are `n` employees, each with a unique id from `0` to `n - 1`.
+
+You are given a 2D integer array `logs` where <code>logs[i] = [id<sub>i</sub>, leaveTime<sub>i</sub>]</code> where:
+
+*   <code>id<sub>i</sub></code> is the id of the employee that worked on the <code>i<sup>th</sup></code> task, and
+*   <code>leaveTime<sub>i</sub></code> is the time at which the employee finished the <code>i<sup>th</sup></code> task. All the values <code>leaveTime<sub>i</sub></code> are **unique**.
+
+Note that the <code>i<sup>th</sup></code> task starts the moment right after the <code>(i - 1)<sup>th</sup></code> task ends, and the <code>0<sup>th</sup></code> task starts at time `0`.
+
+Return _the id of the employee that worked the task with the longest time._ If there is a tie between two or more employees, return _the **smallest** id among them_.
+
+**Example 1:**
+
+**Input:** n = 10, logs = [[0,3],[2,5],[0,9],[1,15]]
+
+**Output:** 1
+
+**Explanation:** 
+
+Task 0 started at 0 and ended at 3 with 3 units of times. 
+
+Task 1 started at 3 and ended at 5 with 2 units of times. 
+
+Task 2 started at 5 and ended at 9 with 4 units of times. 
+
+Task 3 started at 9 and ended at 15 with 6 units of times. 
+
+The task with the longest time is task 3 and the employee with id 1 is the one that worked on it, so we return 1.
+
+**Example 2:**
+
+**Input:** n = 26, logs = [[1,1],[3,7],[2,12],[7,17]]
+
+**Output:** 3
+
+**Explanation:** 
+
+Task 0 started at 0 and ended at 1 with 1 unit of times. 
+
+Task 1 started at 1 and ended at 7 with 6 units of times. 
+
+Task 2 started at 7 and ended at 12 with 5 units of times. 
+
+Task 3 started at 12 and ended at 17 with 5 units of times. 
+
+The tasks with the longest time is task 1. The employees that worked on it is 3, so we return 3.
+
+**Example 3:**
+
+**Input:** n = 2, logs = [[0,10],[1,20]]
+
+**Output:** 0
+
+**Explanation:** 
+
+Task 0 started at 0 and ended at 10 with 10 units of times.
+
+Task 1 started at 10 and ended at 20 with 10 units of times. 
+
+The tasks with the longest time are tasks 0 and 1. The employees that worked on them are 0 and 1, so we return the smallest id 0.
+
+**Constraints:**
+
+*   `2 <= n <= 500`
+*   `1 <= logs.length <= 500`
+*   `logs[i].length == 2`
+*   <code>0 <= id<sub>i</sub> <= n - 1</code>
+*   <code>1 <= leaveTime<sub>i</sub> <= 500</code>
+*   <code>id<sub>i</sub> != id<sub>i+1</sub></code>
+*   <code>leaveTime<sub>i</sub></code> are sorted in a strictly increasing order.

src/main/java/g2401_2500/s2433_find_the_original_array_of_prefix_xor/Solution.java

@@ -0,0 +1,14 @@
+package g2401_2500.s2433_find_the_original_array_of_prefix_xor;
+
+// #Medium #Array #Bit_Manipulation #2022_12_07_Time_2_ms_(96.00%)_Space_54.8_MB_(93.08%)
+
+public class Solution {
+    public int[] findArray(int[] pref) {
+        int[] result = new int[pref.length];
+        result[0] = pref[0];
+        for (int i = 1; i < pref.length; i++) {
+            result[i] = pref[i] ^ pref[i - 1];
+        }
+        return result;
+    }
+}

src/main/java/g2401_2500/s2433_find_the_original_array_of_prefix_xor/readme.md

@@ -0,0 +1,42 @@
+2433\. Find The Original Array of Prefix Xor
+
+Medium
+
+You are given an **integer** array `pref` of size `n`. Find and return _the array_ `arr` _of size_ `n` _that satisfies_:
+
+*   `pref[i] = arr[0] ^ arr[1] ^ ... ^ arr[i]`.
+
+Note that `^` denotes the **bitwise-xor** operation.
+
+It can be proven that the answer is **unique**.
+
+**Example 1:**
+
+**Input:** pref = [5,2,0,3,1]
+
+**Output:** [5,7,2,3,2]
+
+**Explanation:** From the array [5,7,2,3,2] we have the following: 
+
+- pref[0] = 5. 
+
+- pref[1] = 5 ^ 7 = 2. 
+
+- pref[2] = 5 ^ 7 ^ 2 = 0. 
+
+- pref[3] = 5 ^ 7 ^ 2 ^ 3 = 3. 
+
+- pref[4] = 5 ^ 7 ^ 2 ^ 3 ^ 2 = 1.
+
+**Example 2:**
+
+**Input:** pref = [13]
+
+**Output:** [13]
+
+**Explanation:** We have pref[0] = arr[0] = 13.
+
+**Constraints:**
+
+*   <code>1 <= pref.length <= 10<sup>5</sup></code>
+*   <code>0 <= pref[i] <= 10<sup>6</sup></code>

src/main/java/g2401_2500/s2434_using_a_robot_to_print_the_lexicographically_smallest_string/Solution.java

@@ -0,0 +1,32 @@
+package g2401_2500.s2434_using_a_robot_to_print_the_lexicographically_smallest_string;
+
+// #Medium #String #Hash_Table #Greedy #Stack #2022_12_07_Time_32_ms_(99.61%)_Space_72.8_MB_(76.43%)
+
+public class Solution {
+    public String robotWithString(String s) {
+        int n = s.length();
+        char[] c = s.toCharArray();
+        char[] next = new char[n + 1];
+        next[n] = (char) ('z' + 1);
+        for (int i = n - 1; i >= 0; i--) {
+            next[i] = (char) ('a' + Math.min(c[i] - 'a', next[i + 1] - 'a'));
+        }
+        char[] stack = new char[n];
+        int j = 0;
+        int k = 0;
+        for (int i = 0; i < n; ++i) {
+            if (c[i] == next[i]) {
+                c[j++] = c[i];
+                while (k > 0 && stack[k - 1] <= next[i + 1]) {
+                    c[j++] = stack[--k];
+                }
+            } else {
+                stack[k++] = c[i];
+            }
+        }
+        while (k > 0) {
+            c[j++] = stack[--k];
+        }
+        return new String(c);
+    }
+}

src/main/java/g2401_2500/s2434_using_a_robot_to_print_the_lexicographically_smallest_string/readme.md

@@ -0,0 +1,59 @@
+2434\. Using a Robot to Print the Lexicographically Smallest String
+
+Medium
+
+You are given a string `s` and a robot that currently holds an empty string `t`. Apply one of the following operations until `s` and `t` **are both empty**:
+
+*   Remove the **first** character of a string `s` and give it to the robot. The robot will append this character to the string `t`.
+*   Remove the **last** character of a string `t` and give it to the robot. The robot will write this character on paper.
+
+Return _the lexicographically smallest string that can be written on the paper._
+
+**Example 1:**
+
+**Input:** s = "zza"
+
+**Output:** "azz"
+
+**Explanation:** Let p denote the written string. 
+
+Initially p="", s="zza", t="". 
+
+Perform first operation three times p="", s="", t="zza". 
+
+Perform second operation three times p="azz", s="", t="".
+
+**Example 2:**
+
+**Input:** s = "bac"
+
+**Output:** "abc"
+
+**Explanation:** Let p denote the written string. 
+
+Perform first operation twice p="", s="c", t="ba".
+
+Perform second operation twice p="ab", s="c", t="". 
+
+Perform first operation p="ab", s="", t="c". 
+
+Perform second operation p="abc", s="", t="".
+
+**Example 3:**
+
+**Input:** s = "bdda"
+
+**Output:** "addb"
+
+**Explanation:** Let p denote the written string. 
+
+Initially p="", s="bdda", t="". 
+
+Perform first operation four times p="", s="", t="bdda". 
+
+Perform second operation four times p="addb", s="", t="".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only English lowercase letters.

src/test/java/g2401_2500/s2432_the_employee_that_worked_on_the_longest_task/SolutionTest.java

@@ -0,0 +1,27 @@
+package g2401_2500.s2432_the_employee_that_worked_on_the_longest_task;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void hardestWorker() {
+        assertThat(
+                new Solution().hardestWorker(new int[][] {{0, 3}, {2, 5}, {0, 9}, {1, 15}}),
+                equalTo(1));
+    }
+
+    @Test
+    void hardestWorker2() {
+        assertThat(
+                new Solution().hardestWorker(new int[][] {{1, 1}, {3, 7}, {2, 12}, {7, 17}}),
+                equalTo(3));
+    }
+
+    @Test
+    void hardestWorker3() {
+        assertThat(new Solution().hardestWorker(new int[][] {{0, 10}, {10, 20}}), equalTo(0));
+    }
+}

src/test/java/g2401_2500/s2433_find_the_original_array_of_prefix_xor/SolutionTest.java

@@ -0,0 +1,20 @@
+package g2401_2500.s2433_find_the_original_array_of_prefix_xor;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findArray() {
+        assertThat(
+                new Solution().findArray(new int[] {5, 2, 0, 3, 1}),
+                equalTo(new int[] {5, 7, 2, 3, 2}));
+    }
+
+    @Test
+    void findArray2() {
+        assertThat(new Solution().findArray(new int[] {13}), equalTo(new int[] {13}));
+    }
+}

src/test/java/g2401_2500/s2434_using_a_robot_to_print_the_lexicographically_smallest_string/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2401_2500.s2434_using_a_robot_to_print_the_lexicographically_smallest_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void robotWithString() {
+        assertThat(new Solution().robotWithString("zza"), equalTo("azz"));
+    }
+
+    @Test
+    void robotWithString2() {
+        assertThat(new Solution().robotWithString("bac"), equalTo("abc"));
+    }
+
+    @Test
+    void robotWithString3() {
+        assertThat(new Solution().robotWithString("bdda"), equalTo("addb"));
+    }
+}