Added tasks 3487-3490

Author: javadev

src/main/java/g3401_3500/s3487_maximum_unique_subarray_sum_after_deletion/Solution.java

@@ -0,0 +1,29 @@
+package g3401_3500.s3487_maximum_unique_subarray_sum_after_deletion;
+
+// #Easy #2025_03_16_Time_2_ms_(100.00%)_Space_42.42_MB_(100.00%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int maxSum(int[] nums) {
+        int sum = 0;
+        Set<Integer> st = new HashSet<>();
+        int mxNeg = Integer.MIN_VALUE;
+        for (int num : nums) {
+            if (num > 0) {
+                st.add(num);
+            } else {
+                mxNeg = Math.max(mxNeg, num);
+            }
+        }
+        for (int val : st) {
+            sum += val;
+        }
+        if (!st.isEmpty()) {
+            return sum;
+        } else {
+            return mxNeg;
+        }
+    }
+}

src/main/java/g3401_3500/s3487_maximum_unique_subarray_sum_after_deletion/readme.md

@@ -0,0 +1,47 @@
+3487\. Maximum Unique Subarray Sum After Deletion
+
+Easy
+
+You are given an integer array `nums`.
+
+You are allowed to delete any number of elements from `nums` without making it **empty**. After performing the deletions, select a non-empty subarrays of `nums` such that:
+
+1.  All elements in the subarray are **unique**.
+2.  The sum of the elements in the subarray is **maximized**.
+
+Return the **maximum sum** of such a subarray.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5]
+
+**Output:** 15
+
+**Explanation:**
+
+Select the entire array without deleting any element to obtain the maximum sum.
+
+**Example 2:**
+
+**Input:** nums = [1,1,0,1,1]
+
+**Output:** 1
+
+**Explanation:**
+
+Delete the element `nums[0] == 1`, `nums[1] == 1`, `nums[2] == 0`, and `nums[3] == 1`. Select the entire array `[1]` to obtain the maximum sum.
+
+**Example 3:**
+
+**Input:** nums = [1,2,-1,-2,1,0,-1]
+
+**Output:** 3
+
+**Explanation:**
+
+Delete the elements `nums[2] == -1` and `nums[3] == -2`, and select the subarray `[2, 1]` from `[1, 2, 1, 0, -1]` to obtain the maximum sum.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `-100 <= nums[i] <= 100`

src/main/java/g3401_3500/s3488_closest_equal_element_queries/Solution.java

@@ -0,0 +1,38 @@
+package g3401_3500.s3488_closest_equal_element_queries;
+
+// #Medium #2025_03_16_Time_50_ms_(100.00%)_Space_78.29_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public List<Integer> solveQueries(int[] nums, int[] queries) {
+        int sz = nums.length;
+        Map<Integer, List<Integer>> indices = new HashMap<>();
+        for (int i = 0; i < sz; i++) {
+            indices.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i);
+        }
+        for (List<Integer> arr : indices.values()) {
+            int m = arr.size();
+            if (m == 1) {
+                nums[arr.get(0)] = -1;
+                continue;
+            }
+            for (int i = 0; i < m; i++) {
+                int j = arr.get(i);
+                int f = arr.get((i + 1) % m);
+                int b = arr.get((i - 1 + m) % m);
+                int forward = Math.min((sz - j - 1) + f + 1, Math.abs(j - f));
+                int backward = Math.min(Math.abs(b - j), j + (sz - b));
+                nums[j] = Math.min(backward, forward);
+            }
+        }
+        List<Integer> res = new ArrayList<>();
+        for (int q : queries) {
+            res.add(nums[q]);
+        }
+        return res;
+    }
+}

src/main/java/g3401_3500/s3488_closest_equal_element_queries/readme.md

@@ -0,0 +1,39 @@
+3488\. Closest Equal Element Queries
+
+Medium
+
+You are given a **circular** array `nums` and an array `queries`.
+
+For each query `i`, you have to find the following:
+
+*   The **minimum** distance between the element at index `queries[i]` and **any** other index `j` in the **circular** array, where `nums[j] == nums[queries[i]]`. If no such index exists, the answer for that query should be -1.
+
+Return an array `answer` of the **same** size as `queries`, where `answer[i]` represents the result for query `i`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,1,4,1,3,2], queries = [0,3,5]
+
+**Output:** [2,-1,3]
+
+**Explanation:**
+
+*   Query 0: The element at `queries[0] = 0` is `nums[0] = 1`. The nearest index with the same value is 2, and the distance between them is 2.
+*   Query 1: The element at `queries[1] = 3` is `nums[3] = 4`. No other index contains 4, so the result is -1.
+*   Query 2: The element at `queries[2] = 5` is `nums[5] = 3`. The nearest index with the same value is 1, and the distance between them is 3 (following the circular path: `5 -> 6 -> 0 -> 1`).
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4], queries = [0,1,2,3]
+
+**Output:** [-1,-1,-1,-1]
+
+**Explanation:**
+
+Each value in `nums` is unique, so no index shares the same value as the queried element. This results in -1 for all queries.
+
+**Constraints:**
+
+*   <code>1 <= queries.length <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
+*   `0 <= queries[i] < nums.length`

src/main/java/g3401_3500/s3489_zero_array_transformation_iv/Solution.java

@@ -0,0 +1,38 @@
+package g3401_3500.s3489_zero_array_transformation_iv;
+
+// #Medium #2025_03_16_Time_136_ms_(100.00%)_Space_55.84_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int solve(int[][] q, int i, int target, int k, int[][] dp) {
+        // we found  a valid sum equal to target so return current index of query.
+        if (target == 0) {
+            return k;
+        }
+        // return a larger number to invalidate this flow
+        if (k >= q.length || target < 0) {
+            return q.length + 1;
+        }
+        if (dp[target][k] != -1) {
+            return dp[target][k];
+        }
+        // skip current query val
+        int res = solve(q, i, target, k + 1, dp);
+        // pick the val if its range is in the range of target index
+        if (q[k][0] <= i && i <= q[k][1]) {
+            res = Math.min(res, solve(q, i, target - q[k][2], k + 1, dp));
+        }
+        return dp[target][k] = res;
+    }
+
+    public int minZeroArray(int[] nums, int[][] queries) {
+        int ans = -1;
+        for (int i = 0; i < nums.length; ++i) {
+            int[][] dp = new int[nums[i] + 1][queries.length];
+            Arrays.stream(dp).forEach(row -> Arrays.fill(row, -1));
+            ans = Math.max(ans, solve(queries, i, nums[i], 0, dp));
+        }
+        return (ans > queries.length) ? -1 : ans;
+    }
+}

src/main/java/g3401_3500/s3489_zero_array_transformation_iv/readme.md

@@ -0,0 +1,75 @@
+3489\. Zero Array Transformation IV
+
+Medium
+
+You are given an integer array `nums` of length `n` and a 2D array `queries`, where <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>, val<sub>i</sub>]</code>.
+
+Each `queries[i]` represents the following action on `nums`:
+
+*   Select a **subset** of indices in the range <code>[l<sub>i</sub>, r<sub>i</sub>]</code> from `nums`.
+*   Decrement the value at each selected index by **exactly** <code>val<sub>i</sub></code>.
+
+A **Zero Array** is an array with all its elements equal to 0.
+
+Return the **minimum** possible **non-negative** value of `k`, such that after processing the first `k` queries in **sequence**, `nums` becomes a **Zero Array**. If no such `k` exists, return -1.
+
+**Example 1:**
+
+**Input:** nums = [2,0,2], queries = [[0,2,1],[0,2,1],[1,1,3]]
+
+**Output:** 2
+
+**Explanation:**
+
+*   **For query 0 (l = 0, r = 2, val = 1):**
+    *   Decrement the values at indices `[0, 2]` by 1.
+    *   The array will become `[1, 0, 1]`.
+*   **For query 1 (l = 0, r = 2, val = 1):**
+    *   Decrement the values at indices `[0, 2]` by 1.
+    *   The array will become `[0, 0, 0]`, which is a Zero Array. Therefore, the minimum value of `k` is 2.
+
+**Example 2:**
+
+**Input:** nums = [4,3,2,1], queries = [[1,3,2],[0,2,1]]
+
+**Output:** \-1
+
+**Explanation:**
+
+It is impossible to make nums a Zero Array even after all the queries.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3,2,1], queries = [[0,1,1],[1,2,1],[2,3,2],[3,4,1],[4,4,1]]
+
+**Output:** 4
+
+**Explanation:**
+
+*   **For query 0 (l = 0, r = 1, val = 1):**
+    *   Decrement the values at indices `[0, 1]` by `1`.
+    *   The array will become `[0, 1, 3, 2, 1]`.
+*   **For query 1 (l = 1, r = 2, val = 1):**
+    *   Decrement the values at indices `[1, 2]` by 1.
+    *   The array will become `[0, 0, 2, 2, 1]`.
+*   **For query 2 (l = 2, r = 3, val = 2):**
+    *   Decrement the values at indices `[2, 3]` by 2.
+    *   The array will become `[0, 0, 0, 0, 1]`.
+*   **For query 3 (l = 3, r = 4, val = 1):**
+    *   Decrement the value at index 4 by 1.
+    *   The array will become `[0, 0, 0, 0, 0]`. Therefore, the minimum value of `k` is 4.
+
+**Example 4:**
+
+**Input:** nums = [1,2,3,2,6], queries = [[0,1,1],[0,2,1],[1,4,2],[4,4,4],[3,4,1],[4,4,5]]
+
+**Output:** 4
+
+**Constraints:**
+
+*   `1 <= nums.length <= 10`
+*   `0 <= nums[i] <= 1000`
+*   `1 <= queries.length <= 1000`
+*   <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>, val<sub>i</sub>]</code>
+*   <code>0 <= l<sub>i</sub> <= r<sub>i</sub> < nums.length</code>
+*   <code>1 <= val<sub>i</sub> <= 10</code>

src/main/java/g3401_3500/s3490_count_beautiful_numbers/Solution.java

@@ -0,0 +1,64 @@
+package g3401_3500.s3490_count_beautiful_numbers;
+
+// #Hard #2025_03_16_Time_512_ms_(100.00%)_Space_55.59_MB_(100.00%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public int beautifulNumbers(int l, int r) {
+        return countBeautiful(r) - countBeautiful(l - 1);
+    }
+
+    private int countBeautiful(int x) {
+        if (x < 0) {
+            return 0;
+        }
+        char[] digits = getCharArray(x);
+        HashMap<String, Integer> dp = new HashMap<>();
+        return solve(0, 1, 0, 1, digits, dp);
+    }
+
+    private char[] getCharArray(int x) {
+        String str = String.valueOf(x);
+        return str.toCharArray();
+    }
+
+    private int solve(
+            int i, int tight, int sum, int prod, char[] digits, HashMap<String, Integer> dp) {
+        if (i == digits.length) {
+            if (sum > 0 && prod % sum == 0) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        String str = i + " - " + tight + " - " + sum + " - " + prod;
+        if (dp.containsKey(str)) {
+            return dp.get(str);
+        }
+        int limit;
+        if (tight == 1) {
+            limit = digits[i] - '0';
+        } else {
+            limit = 9;
+        }
+        int count = 0, j = 0;
+        while (j <= limit) {
+            int newTight = 0;
+            if (tight == 1 && j == limit) {
+                newTight = 1;
+            }
+            int newSum = sum + j;
+            int newProd;
+            if (j == 0 && sum == 0) {
+                newProd = 1;
+            } else {
+                newProd = prod * j;
+            }
+            count += solve(i + 1, newTight, newSum, newProd, digits, dp);
+            j++;
+        }
+        dp.put(str, count);
+        return count;
+    }
+}

src/main/java/g3401_3500/s3490_count_beautiful_numbers/readme.md

@@ -0,0 +1,31 @@
+3490\. Count Beautiful Numbers
+
+Hard
+
+You are given two positive integers, `l` and `r`. A positive integer is called **beautiful** if the product of its digits is divisible by the sum of its digits.
+
+Return the count of **beautiful** numbers between `l` and `r`, inclusive.
+
+**Example 1:**
+
+**Input:** l = 10, r = 20
+
+**Output:** 2
+
+**Explanation:**
+
+The beautiful numbers in the range are 10 and 20.
+
+**Example 2:**
+
+**Input:** l = 1, r = 15
+
+**Output:** 10
+
+**Explanation:**
+
+The beautiful numbers in the range are 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10.
+
+**Constraints:**
+
+*   <code>1 <= l <= r < 10<sup>9</sup></code>

src/test/java/g3401_3500/s3487_maximum_unique_subarray_sum_after_deletion/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3401_3500.s3487_maximum_unique_subarray_sum_after_deletion;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxSum() {
+        assertThat(new Solution().maxSum(new int[] {1, 2, 3, 4, 5}), equalTo(15));
+    }
+
+    @Test
+    void maxSum2() {
+        assertThat(new Solution().maxSum(new int[] {1, 1, 0, 1, 1}), equalTo(1));
+    }
+
+    @Test
+    void maxSum3() {
+        assertThat(new Solution().maxSum(new int[] {1, 2, -1, -2, 1, 0, -1}), equalTo(3));
+    }
+}

src/test/java/g3401_3500/s3488_closest_equal_element_queries/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3401_3500.s3488_closest_equal_element_queries;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void solveQueries() {
+        assertThat(
+                new Solution().solveQueries(new int[] {1, 3, 1, 4, 1, 3, 2}, new int[] {0, 3, 5}),
+                equalTo(List.of(2, -1, 3)));
+    }
+
+    @Test
+    void solveQueries2() {
+        assertThat(
+                new Solution().solveQueries(new int[] {1, 2, 3, 4}, new int[] {0, 1, 2, 3}),
+                equalTo(List.of(-1, -1, -1, -1)));
+    }
+}

src/test/java/g3401_3500/s3489_zero_array_transformation_iv/SolutionTest.java

@@ -0,0 +1,49 @@
+package g3401_3500.s3489_zero_array_transformation_iv;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minZeroArray() {
+        assertThat(
+                new Solution()
+                        .minZeroArray(
+                                new int[] {2, 0, 2}, new int[][] {{0, 2, 1}, {0, 2, 1}, {1, 1, 3}}),
+                equalTo(2));
+    }
+
+    @Test
+    void minZeroArray2() {
+        assertThat(
+                new Solution()
+                        .minZeroArray(new int[] {4, 3, 2, 1}, new int[][] {{1, 3, 2}, {0, 2, 1}}),
+                equalTo(-1));
+    }
+
+    @Test
+    void minZeroArray3() {
+        assertThat(
+                new Solution()
+                        .minZeroArray(
+                                new int[] {1, 2, 3, 2, 1},
+                                new int[][] {
+                                    {0, 1, 1}, {1, 2, 1}, {2, 3, 2}, {3, 4, 1}, {4, 4, 1}
+                                }),
+                equalTo(4));
+    }
+
+    @Test
+    void minZeroArray4() {
+        assertThat(
+                new Solution()
+                        .minZeroArray(
+                                new int[] {1, 2, 3, 2, 6},
+                                new int[][] {
+                                    {0, 1, 1}, {0, 2, 1}, {1, 4, 2}, {4, 4, 4}, {3, 4, 1}, {4, 4, 5}
+                                }),
+                equalTo(4));
+    }
+}

src/test/java/g3401_3500/s3490_count_beautiful_numbers/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3401_3500.s3490_count_beautiful_numbers;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void beautifulNumbers() {
+        assertThat(new Solution().beautifulNumbers(10, 20), equalTo(2));
+    }
+
+    @Test
+    void beautifulNumbers2() {
+        assertThat(new Solution().beautifulNumbers(1, 15), equalTo(10));
+    }
+}