Added tasks 3038-3049

Author: ThanhNIT

src/main/java/g3001_3100/s3038_maximum_number_of_operations_with_the_same_score_i/Solution.java

@@ -0,0 +1,19 @@
+package g3001_3100.s3038_maximum_number_of_operations_with_the_same_score_i;
+
+// #Easy #Array #Simulation #2024_03_04_Time_0_ms_(100.00%)_Space_41.5_MB_(92.21%)
+
+public class Solution {
+    public int maxOperations(int[] nums) {
+        int c = 1;
+        for (int i = 2, s = nums[0] + nums[1], l = nums.length - (nums.length % 2 == 0 ? 0 : 1);
+                i < l;
+                i += 2) {
+            if (nums[i] + nums[i + 1] == s) {
+                c++;
+            } else {
+                break;
+            }
+        }
+        return c;
+    }
+}

src/main/java/g3001_3100/s3038_maximum_number_of_operations_with_the_same_score_i/readme.md

@@ -0,0 +1,41 @@
+3038\. Maximum Number of Operations With the Same Score I
+
+Easy
+
+Given an array of integers called `nums`, you can perform the following operation while `nums` contains **at least** `2` elements:
+
+*   Choose the first two elements of `nums` and delete them.
+
+The **score** of the operation is the sum of the deleted elements.
+
+Your task is to find the **maximum** number of operations that can be performed, such that **all operations have the same score**.
+
+Return _the **maximum** number of operations possible that satisfy the condition mentioned above_.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,4,5]
+
+**Output:** 2
+
+**Explanation:** We perform the following operations: 
+- Delete the first two elements, with score 3 + 2 = 5, nums = [1,4,5]. 
+- Delete the first two elements, with score 1 + 4 = 5, nums = [5]. 
+
+We are unable to perform any more operations as nums contain only 1 element.
+
+**Example 2:**
+
+**Input:** nums = [3,2,6,1,4]
+
+**Output:** 1
+
+**Explanation:** We perform the following operations: 
+- Delete the first two elements, with score 3 + 2 = 5, nums = [6,1,4]. 
+
+We are unable to perform any more operations as the score of the next operation isn't the same as the previous one.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`

src/main/java/g3001_3100/s3039_apply_operations_to_make_string_empty/Solution.java

@@ -0,0 +1,25 @@
+package g3001_3100.s3039_apply_operations_to_make_string_empty;
+
+// #Medium #Array #Hash_Table #Sorting #Counting
+// #2024_03_04_Time_18_ms_(93.00%)_Space_48.3_MB_(94.05%)
+
+public class Solution {
+    public String lastNonEmptyString(String s) {
+        int[] freq = new int[26];
+        char[] ar = s.toCharArray();
+        int n = ar.length;
+        int max = 1;
+        StringBuilder sb = new StringBuilder();
+        for (char c : ar) {
+            freq[c - 'a']++;
+            max = Math.max(freq[c - 'a'], max);
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            if (freq[ar[i] - 'a'] == max) {
+                sb.append(ar[i]);
+                freq[ar[i] - 'a'] = 0;
+            }
+        }
+        return sb.reverse().toString();
+    }
+}

src/main/java/g3001_3100/s3039_apply_operations_to_make_string_empty/readme.md

@@ -0,0 +1,41 @@
+3039\. Apply Operations to Make String Empty
+
+Medium
+
+You are given a string `s`.
+
+Consider performing the following operation until `s` becomes **empty**:
+
+*   For **every** alphabet character from `'a'` to `'z'`, remove the **first** occurrence of that character in `s` (if it exists).
+
+For example, let initially `s = "aabcbbca"`. We do the following operations:
+
+*   Remove the underlined characters <code>s = "<ins>**a**</ins>a**<ins>bc</ins>**bbca"</code>. The resulting string is `s = "abbca"`.
+*   Remove the underlined characters <code>s = "<ins>**ab**</ins>b<ins>**c**</ins>a"</code>. The resulting string is `s = "ba"`.
+*   Remove the underlined characters <code>s = "<ins>**ba**</ins>"</code>. The resulting string is `s = ""`.
+
+Return _the value of the string_ `s` _right **before** applying the **last** operation_. In the example above, answer is `"ba"`.
+
+**Example 1:**
+
+**Input:** s = "aabcbbca"
+
+**Output:** "ba"
+
+**Explanation:** Explained in the statement.
+
+**Example 2:**
+
+**Input:** s = "abcd"
+
+**Output:** "abcd"
+
+**Explanation:** We do the following operation: 
+- Remove the underlined characters s = "<ins>**abcd**</ins>". The resulting string is s = "". 
+
+The string just before the last operation is "abcd".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>5</sup></code>
+*   `s` consists only of lowercase English letters.

src/main/java/g3001_3100/s3040_maximum_number_of_operations_with_the_same_score_ii/Solution.java

@@ -0,0 +1,84 @@
+package g3001_3100.s3040_maximum_number_of_operations_with_the_same_score_ii;
+
+// #Medium #Array #Dynamic_Programming #Memoization
+// #2024_03_04_Time_3_ms_(99.75%)_Space_44.6_MB_(99.29%)
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public class Solution {
+    private int[] nums;
+
+    private int maxOps = 1;
+
+    private final Map<Pos, Integer> dp = new HashMap<>();
+
+    private static class Pos {
+        int start;
+        int end;
+        int sum;
+
+        Pos(int start, int end, int sum) {
+            this.start = start;
+            this.end = end;
+            this.sum = sum;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null) {
+                return false;
+            }
+            if (!(o instanceof Pos)) {
+                return false;
+            }
+            return start == ((Pos) o).start && end == ((Pos) o).end && sum == ((Pos) o).sum;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(start, end, sum);
+        }
+    }
+
+    public int maxOperations(int[] nums) {
+        this.nums = nums;
+        var length = nums.length;
+
+        maxOperations(2, length - 1, nums[0] + nums[1], 1);
+        maxOperations(0, length - 3, nums[length - 2] + nums[length - 1], 1);
+        maxOperations(1, length - 2, nums[0] + nums[length - 1], 1);
+
+        return maxOps;
+    }
+
+    private void maxOperations(int start, int end, int sum, int nOps) {
+        if (start >= end) {
+            return;
+        }
+
+        if ((((end - start) / 2) + nOps) < maxOps) {
+            return;
+        }
+
+        Pos pos = new Pos(start, end, sum);
+        Integer posNops = dp.get(pos);
+        if (posNops != null && posNops >= nOps) {
+            return;
+        }
+        dp.put(pos, nOps);
+        if (nums[start] + nums[start + 1] == sum) {
+            maxOps = Math.max(maxOps, nOps + 1);
+            maxOperations(start + 2, end, sum, nOps + 1);
+        }
+        if (nums[end - 1] + nums[end] == sum) {
+            maxOps = Math.max(maxOps, nOps + 1);
+            maxOperations(start, end - 2, sum, nOps + 1);
+        }
+        if (nums[start] + nums[end] == sum) {
+            maxOps = Math.max(maxOps, nOps + 1);
+            maxOperations(start + 1, end - 1, sum, nOps + 1);
+        }
+    }
+}

src/main/java/g3001_3100/s3040_maximum_number_of_operations_with_the_same_score_ii/readme.md

@@ -0,0 +1,45 @@
+3040\. Maximum Number of Operations With the Same Score II
+
+Medium
+
+Given an array of integers called `nums`, you can perform **any** of the following operation while `nums` contains **at least** `2` elements:
+
+*   Choose the first two elements of `nums` and delete them.
+*   Choose the last two elements of `nums` and delete them.
+*   Choose the first and the last elements of `nums` and delete them.
+
+The **score** of the operation is the sum of the deleted elements.
+
+Your task is to find the **maximum** number of operations that can be performed, such that **all operations have the same score**.
+
+Return _the **maximum** number of operations possible that satisfy the condition mentioned above_.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,2,3,4]
+
+**Output:** 3
+
+**Explanation:** We perform the following operations: 
+- Delete the first two elements, with score 3 + 2 = 5, nums = [1,2,3,4]. 
+- Delete the first and the last elements, with score 1 + 4 = 5, nums = [2,3].
+- Delete the first and the last elements, with score 2 + 3 = 5, nums = []. 
+
+We are unable to perform any more operations as nums is empty.
+
+**Example 2:**
+
+**Input:** nums = [3,2,6,1,4]
+
+**Output:** 2
+
+**Explanation:** We perform the following operations: 
+- Delete the first two elements, with score 3 + 2 = 5, nums = [6,1,4]. 
+- Delete the last two elements, with score 1 + 4 = 5, nums = [6]. 
+
+It can be proven that we can perform at most 2 operations.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 2000`
+*   `1 <= nums[i] <= 1000`

src/main/java/g3001_3100/s3047_find_the_largest_area_of_square_inside_two_rectangles/Solution.java

@@ -0,0 +1,30 @@
+package g3001_3100.s3047_find_the_largest_area_of_square_inside_two_rectangles;
+
+// #Medium #Array #Math #Geometry #2024_03_04_Time_50_ms_(97.63%)_Space_44.7_MB_(98.11%)
+
+public class Solution {
+    public long largestSquareArea(int[][] bottomLeft, int[][] topRight) {
+        int n = bottomLeft.length;
+        long maxArea = 0;
+        for (int i = 0; i < n; i++) {
+            int ax = bottomLeft[i][0];
+            int ay = bottomLeft[i][1];
+            int bx = topRight[i][0];
+            int by = topRight[i][1];
+            for (int j = i + 1; j < n; j++) {
+                int cx = bottomLeft[j][0];
+                int cy = bottomLeft[j][1];
+                int dx = topRight[j][0];
+                int dy = topRight[j][1];
+                int x1 = Math.max(ax, cx);
+                int y1 = Math.max(ay, cy);
+                int x2 = Math.min(bx, dx);
+                int y2 = Math.min(by, dy);
+                int minSide = Math.min(x2 - x1, y2 - y1);
+                long area = (long) Math.pow(Math.max(minSide, 0), 2);
+                maxArea = Math.max(maxArea, area);
+            }
+        }
+        return maxArea;
+    }
+}

src/main/java/g3001_3100/s3047_find_the_largest_area_of_square_inside_two_rectangles/readme.md

@@ -0,0 +1,53 @@
+3047\. Find the Largest Area of Square Inside Two Rectangles
+
+Medium
+
+There exist `n` rectangles in a 2D plane. You are given two **0-indexed** 2D integer arrays `bottomLeft` and `topRight`, both of size `n x 2`, where `bottomLeft[i]` and `topRight[i]` represent the **bottom-left** and **top-right** coordinates of the <code>i<sup>th</sup></code> rectangle respectively.
+
+You can select a region formed from the **intersection** of two of the given rectangles. You need to find the **largest** area of a **square** that can fit **inside** this region if you select the region optimally.
+
+Return _the **largest** possible area of a square, or_ `0` _if there **do not** exist any intersecting regions between the rectangles_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2024/01/05/example12.png)
+
+**Input:** bottomLeft = [[1,1],[2,2],[3,1]], topRight = [[3,3],[4,4],[6,6]]
+
+**Output:** 1
+
+**Explanation:** A square with side length 1 can fit inside either the intersecting region of rectangle 0 and rectangle 1, or the intersecting region of rectangle 1 and rectangle 2. Hence the largest area is side \* side which is 1 \* 1 == 1.
+
+It can be shown that a square with a greater side length can not fit inside any intersecting region.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2024/01/04/rectanglesexample2.png)
+
+**Input:** bottomLeft = [[1,1],[2,2],[1,2]], topRight = [[3,3],[4,4],[3,4]]
+
+**Output:** 1
+
+**Explanation:** A square with side length 1 can fit inside either the intersecting region of rectangle 0 and rectangle 1, the intersecting region of rectangle 1 and rectangle 2, or the intersection region of all 3 rectangles. Hence the largest area is side \* side which is 1 \* 1 == 1.
+
+It can be shown that a square with a greater side length can not fit inside any intersecting region. Note that the region can be formed by the intersection of more than 2 rectangles.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2024/01/04/rectanglesexample3.png)
+
+**Input:** bottomLeft = [[1,1],[3,3],[3,1]], topRight = [[2,2],[4,4],[4,2]]
+
+**Output:** 0
+
+**Explanation:** No pair of rectangles intersect, hence, we return 0.
+
+**Constraints:**
+
+*   `n == bottomLeft.length == topRight.length`
+*   <code>2 <= n <= 10<sup>3</sup></code>
+*   `bottomLeft[i].length == topRight[i].length == 2`
+*   <code>1 <= bottomLeft[i][0], bottomLeft[i][1] <= 10<sup>7</sup></code>
+*   <code>1 <= topRight[i][0], topRight[i][1] <= 10<sup>7</sup></code>
+*   `bottomLeft[i][0] < topRight[i][0]`
+*   `bottomLeft[i][1] < topRight[i][1]`