Added tasks 2439, 2440, 2441, 2442, 2443.

Author: ThanhNIT

src/main/java/g2401_2500/s2439_minimize_maximum_of_array/Solution.java

@@ -0,0 +1,16 @@
+package g2401_2500.s2439_minimize_maximum_of_array;
+
+// #Medium #Array #Dynamic_Programming #Greedy #Binary_Search #Prefix_Sum
+// #2022_12_13_Time_10_ms_(90.25%)_Space_83_MB_(30.03%)
+
+public class Solution {
+    public int minimizeArrayValue(int[] nums) {
+        long max = 0;
+        long sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i];
+            max = Math.max(max, (sum + i) / (i + 1));
+        }
+        return (int) max;
+    }
+}

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

@@ -0,0 +1,42 @@
+2439\. Minimize Maximum of Array
+
+Medium
+
+You are given a **0-indexed** array `nums` comprising of `n` non-negative integers.
+
+In one operation, you must:
+
+*   Choose an integer `i` such that `1 <= i < n` and `nums[i] > 0`.
+*   Decrease `nums[i]` by 1.
+*   Increase `nums[i - 1]` by 1.
+
+Return _the **minimum** possible value of the **maximum** integer of_ `nums` _after performing **any** number of operations_.
+
+**Example 1:**
+
+**Input:** nums = [3,7,1,6]
+
+**Output:** 5
+
+**Explanation:** One set of optimal operations is as follows: 
+1. Choose i = 1, and nums becomes [4,6,1,6]. 
+2. Choose i = 3, and nums becomes [4,6,2,5].
+3. Choose i = 1, and nums becomes [5,5,2,5]. 
+
+The maximum integer of nums is 5. It can be shown that the maximum number cannot be less than 5. 
+
+Therefore, we return 5.
+
+**Example 2:**
+
+**Input:** nums = [10,1]
+
+**Output:** 10
+
+**Explanation:** It is optimal to leave nums as is, and since 10 is the maximum value, we return 10.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2440_create_components_with_same_value/Solution.java

@@ -0,0 +1,68 @@
+package g2401_2500.s2440_create_components_with_same_value;
+
+// #Hard #Array #Math #Tree #Enumeration #Depth_First_Search
+// #2022_12_13_Time_114_ms_(73.23%)_Space_115.7_MB_(68.01%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private int[] nums;
+
+    public int componentValue(int[] nums, int[][] edges) {
+        int n = nums.length;
+        this.nums = nums;
+        List[] graph = new ArrayList[n];
+        for (int i = 0; i < n; i++) {
+            graph[i] = new ArrayList<>();
+        }
+        for (int[] e : edges) {
+            graph[e[0]].add(e[1]);
+            graph[e[1]].add(e[0]);
+        }
+        int sum = 0;
+        for (int i : nums) {
+            sum += i;
+        }
+        for (int k = n; k > 0; k--) {
+            if (sum % k != 0) {
+                continue;
+            }
+            int ans = helper(graph, 0, -1, sum / k);
+            if (ans == 0) {
+                return k - 1;
+            }
+        }
+        return 0;
+    }
+
+    private int helper(List<Integer>[] graph, int i, int prev, int target) {
+        if (graph[i].size() == 1 && graph[i].get(0) == prev) {
+            if (nums[i] > target) {
+                return -1;
+            }
+            if (nums[i] == target) {
+                return 0;
+            }
+            return nums[i];
+        }
+        int sum = nums[i];
+        for (int k : graph[i]) {
+            if (k == prev) {
+                continue;
+            }
+            int ans = helper(graph, k, i, target);
+            if (ans == -1) {
+                return -1;
+            }
+            sum += ans;
+        }
+        if (sum > target) {
+            return -1;
+        }
+        if (sum == target) {
+            return 0;
+        }
+        return sum;
+    }
+}

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

@@ -0,0 +1,39 @@
+2440\. Create Components With Same Value
+
+Hard
+
+There is an undirected tree with `n` nodes labeled from `0` to `n - 1`.
+
+You are given a **0-indexed** integer array `nums` of length `n` where `nums[i]` represents the value of the <code>i<sup>th</sup></code> node. You are also given a 2D integer array `edges` of length `n - 1` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.
+
+You are allowed to **delete** some edges, splitting the tree into multiple connected components. Let the **value** of a component be the sum of **all** `nums[i]` for which node `i` is in the component.
+
+Return _the **maximum** number of edges you can delete, such that every connected component in the tree has the same value._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/08/26/diagramdrawio.png)
+
+**Input:** nums = [6,2,2,2,6], edges = [[0,1],[1,2],[1,3],[3,4]]
+
+**Output:** 2
+
+**Explanation:** The above figure shows how we can delete the edges [0,1] and [3,4]. The created components are nodes [0], [1,2,3] and [4]. The sum of the values in each component equals 6. It can be proven that no better deletion exists, so the answer is 2.
+
+**Example 2:**
+
+**Input:** nums = [2], edges = []
+
+**Output:** 0
+
+**Explanation:** There are no edges to be deleted.
+
+**Constraints:**
+
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   `nums.length == n`
+*   `1 <= nums[i] <= 50`
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   `0 <= edges[i][0], edges[i][1] <= n - 1`
+*   `edges` represents a valid tree.

src/main/java/g2401_2500/s2441_largest_positive_integer_that_exists_with_its_negative/Solution.java

@@ -0,0 +1,27 @@
+package g2401_2500.s2441_largest_positive_integer_that_exists_with_its_negative;
+
+// #Easy #Array #Hash_Table #2022_12_13_Time_8_ms_(79.93%)_Space_42.7_MB_(84.42%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int findMaxK(int[] nums) {
+        int[] arr = new int[nums.length];
+        int j = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] < 0) {
+                arr[j++] = nums[i];
+            }
+        }
+        Arrays.sort(arr);
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length; i++) {
+            for (int num : nums) {
+                if ((arr[i] * -1) == num) {
+                    return num;
+                }
+            }
+        }
+        return -1;
+    }
+}

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

@@ -0,0 +1,37 @@
+2441\. Largest Positive Integer That Exists With Its Negative
+
+Easy
+
+Given an integer array `nums` that **does not contain** any zeros, find **the largest positive** integer `k` such that `-k` also exists in the array.
+
+Return _the positive integer_ `k`. If there is no such integer, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [-1,2,-3,3]
+
+**Output:** 3
+
+**Explanation:** 3 is the only valid k we can find in the array.
+
+**Example 2:**
+
+**Input:** nums = [-1,10,6,7,-7,1]
+
+**Output:** 7
+
+**Explanation:** Both 1 and 7 have their corresponding negative values in the array. 7 has a larger value.
+
+**Example 3:**
+
+**Input:** nums = [-10,8,6,7,-2,-3]
+
+**Output:** -1
+
+**Explanation:** There is no a single valid k, we return -1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `-1000 <= nums[i] <= 1000`
+*   `nums[i] != 0`

src/main/java/g2401_2500/s2442_count_number_of_distinct_integers_after_reverse_operations/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2442_count_number_of_distinct_integers_after_reverse_operations;
+
+// #Medium #Array #Hash_Table #Math #2022_12_13_Time_73_ms_(96.81%)_Space_61.1_MB_(96.28%)
+
+import java.util.HashSet;
+
+public class Solution {
+    public int countDistinctIntegers(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+        for (int i : nums) {
+            set.add(i);
+            set.add(reverseInt(i));
+        }
+        return set.size();
+    }
+
+    private static int reverseInt(int num) {
+        int ret = 0;
+        while (num != 0) {
+            ret = (num % 10) + ret * 10;
+            num /= 10;
+        }
+        return ret;
+    }
+}

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

@@ -0,0 +1,30 @@
+2442\. Count Number of Distinct Integers After Reverse Operations
+
+Medium
+
+You are given an array `nums` consisting of **positive** integers.
+
+You have to take each integer in the array, **reverse its digits**, and add it to the end of the array. You should apply this operation to the original integers in `nums`.
+
+Return _the number of **distinct** integers in the final array_.
+
+**Example 1:**
+
+**Input:** nums = [1,13,10,12,31]
+
+**Output:** 6
+
+**Explanation:** After including the reverse of each number, the resulting array is [1,13,10,12,31,<ins>1,31,1,21,13</ins>]. The reversed integers that were added to the end of the array are underlined. Note that for the integer 10, after reversing it, it becomes 01 which is just 1. The number of distinct integers in this array is 6 (The numbers 1, 10, 12, 13, 21, and 31).
+
+**Example 2:**
+
+**Input:** nums = [2,2,2]
+
+**Output:** 1
+
+**Explanation:** After including the reverse of each number, the resulting array is [2,2,2,<ins>2,2,2</ins>]. The number of distinct integers in this array is 1 (The number 2).
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g2401_2500/s2443_sum_of_number_and_its_reverse/Solution.java

@@ -0,0 +1,20 @@
+package g2401_2500.s2443_sum_of_number_and_its_reverse;
+
+// #Medium #Math #Enumeration #2022_12_13_Time_265_ms_(80.33%)_Space_39.5_MB_(89.70%)
+
+public class Solution {
+    public boolean sumOfNumberAndReverse(int num) {
+        for (int i = 0; i <= num; ++i) {
+            int n = i;
+            int r = 0;
+            while (n != 0) {
+                r = r * 10 + n % 10;
+                n = n / 10;
+            }
+            if (r + i == num) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,33 @@
+2443\. Sum of Number and Its Reverse
+
+Medium
+
+Given a **non-negative** integer `num`, return `true` _if_ `num` _can be expressed as the sum of any **non-negative** integer and its reverse, or_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** num = 443
+
+**Output:** true
+
+**Explanation:** 172 + 271 = 443 so we return true.
+
+**Example 2:**
+
+**Input:** num = 63
+
+**Output:** false
+
+**Explanation:** 63 cannot be expressed as the sum of a non-negative integer and its reverse so we return false.
+
+**Example 3:**
+
+**Input:** num = 181
+
+**Output:** true
+
+**Explanation:** 140 + 041 = 181 so we return true. Note that when a number is reversed, there may be leading zeros.
+
+**Constraints:**
+
+*   <code>0 <= num <= 10<sup>5</sup></code>