Added tasks 2570-2574

Author: ThanhNIT

src/main/java/g2501_2600/s2570_merge_two_2d_arrays_by_summing_values/Solution.java

@@ -0,0 +1,47 @@
+package g2501_2600.s2570_merge_two_2d_arrays_by_summing_values;
+
+// #Easy #Array #Hash_Table #Two_Pointers #2023_08_21_Time_0_ms_(100.00%)_Space_44.2_MB_(83.67%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[][] mergeArrays(int[][] nums1, int[][] nums2) {
+        int n1 = nums1.length;
+        int n2 = nums2.length;
+        int[][] res = new int[n1 + n2][2];
+        int i = 0;
+        int j = 0;
+        int idx = 0;
+        while (i < n1 && j < n2) {
+            if (nums1[i][0] == nums2[j][0]) {
+                res[idx][0] = nums1[i][0];
+                res[idx][1] = nums1[i][1] + nums2[j][1];
+                i++;
+                j++;
+            } else if (nums1[i][0] < nums2[j][0]) {
+                res[idx][0] = nums1[i][0];
+                res[idx][1] = nums1[i][1];
+                i++;
+            } else {
+                res[idx][0] = nums2[j][0];
+                res[idx][1] = nums2[j][1];
+                j++;
+            }
+            idx++;
+        }
+        while (i < n1) {
+            res[idx][0] = nums1[i][0];
+            res[idx][1] = nums1[i][1];
+            i++;
+            idx++;
+        }
+        while (j < n2) {
+            res[idx][0] = nums2[j][0];
+            res[idx][1] = nums2[j][1];
+            j++;
+            idx++;
+        }
+
+        return Arrays.copyOf(res, idx);
+    }
+}

src/main/java/g2501_2600/s2570_merge_two_2d_arrays_by_summing_values/readme.md

@@ -0,0 +1,46 @@
+2570\. Merge Two 2D Arrays by Summing Values
+
+Easy
+
+You are given two **2D** integer arrays `nums1` and `nums2.`
+
+*   <code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code> indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.
+*   <code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code> indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.
+
+Each array contains **unique** ids and is sorted in **ascending** order by id.
+
+Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:
+
+*   Only ids that appear in at least one of the two arrays should be included in the resulting array.
+*   Each id should be included **only once** and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays then its value in that array is considered to be `0`.
+
+Return _the resulting array_. The returned array must be sorted in ascending order by id.
+
+**Example 1:**
+
+**Input:** nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
+
+**Output:** [[1,6],[2,3],[3,2],[4,6]]
+
+**Explanation:** The resulting array contains the following: 
+
+- id = 1, the value of this id is 2 + 4 = 6.
+- id = 2, the value of this id is 3. 
+- id = 3, the value of this id is 2. 
+- id = 4, the value of this id is 5 + 1 = 6.
+
+**Example 2:**
+
+**Input:** nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
+
+**Output:** [[1,3],[2,4],[3,6],[4,3],[5,5]]
+
+**Explanation:** There are no common ids, so we just include each id with its value in the resulting list.
+
+**Constraints:**
+
+*   `1 <= nums1.length, nums2.length <= 200`
+*   `nums1[i].length == nums2[j].length == 2`
+*   <code>1 <= id<sub>i</sub>, val<sub>i</sub> <= 1000</code>
+*   Both arrays contain unique ids.
+*   Both arrays are in strictly ascending order by id.

src/main/java/g2501_2600/s2571_minimum_operations_to_reduce_an_integer_to_0/Solution.java

@@ -0,0 +1,22 @@
+package g2501_2600.s2571_minimum_operations_to_reduce_an_integer_to_0;
+
+// #Medium #Dynamic_Programming #Greedy #Bit_Manipulation
+// #2023_08_21_Time_0_ms_(100.00%)_Space_39.4_MB_(38.98%)
+
+public class Solution {
+    public int minOperations(int n) {
+        int cnt = 1;
+        while (n != 0) {
+            int num = 1;
+            while (num <= n) {
+                if (num == n) {
+                    return cnt;
+                }
+                num *= 2;
+            }
+            n = Math.min(num - n, n - num / 2);
+            cnt++;
+        }
+        return cnt;
+    }
+}

src/main/java/g2501_2600/s2571_minimum_operations_to_reduce_an_integer_to_0/readme.md

@@ -0,0 +1,43 @@
+2571\. Minimum Operations to Reduce an Integer to 0
+
+Medium
+
+You are given a positive integer `n`, you can do the following operation **any** number of times:
+
+*   Add or subtract a **power** of `2` from `n`.
+
+Return _the **minimum** number of operations to make_ `n` _equal to_ `0`.
+
+A number `x` is power of `2` if <code>x == 2<sup>i</sup></code> where `i >= 0`_._
+
+**Example 1:**
+
+**Input:** n = 39
+
+**Output:** 3
+
+**Explanation:** We can do the following operations: 
+
+- Add 2<sup>0</sup> = 1 to n, so now n = 40. 
+
+- Subtract 2<sup>3</sup> = 8 from n, so now n = 32. 
+
+- Subtract 2<sup>5</sup> = 32 from n, so now n = 0. It can be shown that 3 is the minimum number of operations we need to make n equal to 0.
+
+**Example 2:**
+
+**Input:** n = 54
+
+**Output:** 3
+
+**Explanation:** We can do the following operations: 
+
+- Add 2<sup>1</sup> = 2 to n, so now n = 56. 
+
+- Add 2<sup>3</sup> = 8 to n, so now n = 64. 
+
+- Subtract 2<sup>6</sup> = 64 from n, so now n = 0. So the minimum number of operations is 3.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>

src/main/java/g2501_2600/s2572_count_the_number_of_square_free_subsets/Solution.java

@@ -0,0 +1,60 @@
+package g2501_2600.s2572_count_the_number_of_square_free_subsets;
+
+// #Medium #Array #Dynamic_Programming #Math #Bit_Manipulation #Bitmask
+// #2023_08_21_Time_1_ms_(100.00%)_Space_41.5_MB_(79.12%)
+
+public class Solution {
+    private final int[] count = new int[31];
+    private final int[] masks = new int[31];
+    private final long[][] cache = new long[31][1 << 6];
+    private static final long MOD = 1_000_000_007;
+
+    public int squareFreeSubsets(int[] nums) {
+        int[] p = {1, 2, 3, 5, 7, 11, 13};
+        for (int i = 0; i < 7; ++i) {
+            int mask = i == 0 ? 0 : 1 << (i - 1);
+            for (int j = i + 1; j < 7; ++j) {
+                if (p[i] * p[j] > 30) {
+                    break;
+                }
+                masks[p[i] * p[j]] = mask | (1 << (j - 1));
+            }
+        }
+        masks[30] = 7;
+        for (int k : nums) {
+            if (k % 4 != 0 && k % 9 != 0 && k % 25 != 0) {
+                ++count[k];
+            }
+        }
+        count[1] = powof2(count[1]);
+        return (int) ((dfs(30, 0) + MOD - 1) % MOD);
+    }
+
+    private long dfs(int k, int mask) {
+        if (k == 1) {
+            return count[1];
+        }
+        if (cache[k][mask] != 0) {
+            return cache[k][mask];
+        }
+        long res = dfs(k - 1, mask);
+        if (count[k] > 0 && (masks[k] & mask) == 0) {
+            res = (res + (count[k] * dfs(k - 1, mask | masks[k])) % MOD) % MOD;
+        }
+        cache[k][mask] = res;
+        return cache[k][mask];
+    }
+
+    private int powof2(int k) {
+        long pow2 = 2;
+        long res = 1;
+        while (k > 0) {
+            if (k % 2 == 1) {
+                res = (res * pow2) % MOD;
+            }
+            pow2 = (pow2 * pow2) % MOD;
+            k >>= 1;
+        }
+        return (int) res;
+    }
+}

src/main/java/g2501_2600/s2572_count_the_number_of_square_free_subsets/readme.md

@@ -0,0 +1,46 @@
+2572\. Count the Number of Square-Free Subsets
+
+Medium
+
+You are given a positive integer **0-indexed** array `nums`.
+
+A subset of the array `nums` is **square-free** if the product of its elements is a **square-free integer**.
+
+A **square-free integer** is an integer that is divisible by no square number other than `1`.
+
+Return _the number of square-free non-empty subsets of the array_ **nums**. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **non-empty** **subset** of `nums` is an array that can be obtained by deleting some (possibly none but not all) elements from `nums`. Two subsets are different if and only if the chosen indices to delete are different.
+
+**Example 1:**
+
+**Input:** nums = [3,4,4,5]
+
+**Output:** 3
+
+**Explanation:** There are 3 square-free subsets in this example: 
+
+- The subset consisting of the 0<sup>th</sup> element [3]. The product of its elements is 3, which is a square-free integer.
+
+- The subset consisting of the 3<sup>rd</sup> element [5]. The product of its elements is 5, which is a square-free integer. 
+
+- The subset consisting of 0<sup>th</sup> and 3<sup>rd</sup> elements [3,5]. The product of its elements is 15, which is a square-free integer. 
+
+It can be proven that there are no more than 3 square-free subsets in the given array.
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 1
+
+**Explanation:** There is 1 square-free subset in this example: 
+
+- The subset consisting of the 0<sup>th</sup> element [1]. The product of its elements is 1, which is a square-free integer. 
+
+It can be proven that there is no more than 1 square-free subset in the given array.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 30`

src/main/java/g2501_2600/s2573_find_the_string_with_lcp/Solution.java

@@ -0,0 +1,54 @@
+package g2501_2600.s2573_find_the_string_with_lcp;
+
+// #Hard #String #Dynamic_Programming #Greedy #Union_Find
+// #2023_08_21_Time_5_ms_(100.00%)_Space_142.3_MB_(10.34%)
+
+public class Solution {
+    public String findTheString(int[][] lcp) {
+        int n = lcp.length;
+        char[] arr = new char[n];
+        arr[0] = 'a';
+        char test;
+        boolean found;
+        for (int i = 1; i < n; ++i) {
+            test = 'a';
+            found = false;
+            for (int j = 0; j < i; ++j) {
+                test = (char) Math.max(test, arr[j]);
+                if (lcp[i][j] != 0) {
+                    found = true;
+                    arr[i] = arr[j];
+                    break;
+                }
+            }
+            if (found) {
+                continue;
+            }
+            ++test;
+            arr[i] = test;
+            if (test > 'z') {
+                return "";
+            }
+        }
+        int[][] dp = new int[n + 1][n + 1];
+        int val;
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = n - 1; j >= 0; --j) {
+                if (arr[i] != arr[j]) {
+                    val = 0;
+                } else {
+                    val = 1 + dp[i + 1][j + 1];
+                }
+                dp[i][j] = val;
+            }
+        }
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = n - 1; j >= 0; --j) {
+                if (dp[i][j] != lcp[i][j]) {
+                    return "";
+                }
+            }
+        }
+        return String.valueOf(arr);
+    }
+}

src/main/java/g2501_2600/s2573_find_the_string_with_lcp/readme.md

@@ -0,0 +1,40 @@
+2573\. Find the String with LCP
+
+Hard
+
+We define the `lcp` matrix of any **0-indexed** string `word` of `n` lowercase English letters as an `n x n` grid such that:
+
+*   `lcp[i][j]` is equal to the length of the **longest common prefix** between the substrings `word[i,n-1]` and `word[j,n-1]`.
+
+Given an `n x n` matrix `lcp`, return the alphabetically smallest string `word` that corresponds to `lcp`. If there is no such string, return an empty string.
+
+A string `a` is lexicographically smaller than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`. For example, `"aabd"` is lexicographically smaller than `"aaca"` because the first position they differ is at the third letter, and `'b'` comes before `'c'`.
+
+**Example 1:**
+
+**Input:** lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
+
+**Output:** "abab"
+
+**Explanation:** lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is "abab".
+
+**Example 2:**
+
+**Input:** lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
+
+**Output:** "aaaa"
+
+**Explanation:** lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is "aaaa".
+
+**Example 3:**
+
+**Input:** lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
+
+**Output:** ""
+
+**Explanation:** lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.
+
+**Constraints:**
+
+*   `1 <= n == ``lcp.length ==` `lcp[i].length` `<= 1000`
+*   `0 <= lcp[i][j] <= n`

src/main/java/g2501_2600/s2574_left_and_right_sum_differences/Solution.java

@@ -0,0 +1,19 @@
+package g2501_2600.s2574_left_and_right_sum_differences;
+
+// #Easy #Array #Prefix_Sum #2023_08_21_Time_2_ms_(74.57%)_Space_43.7_MB_(76.84%)
+
+public class Solution {
+    public int[] leftRightDifference(int[] nums) {
+        int ls = 0;
+        int rs = 0;
+        for (int i : nums) {
+            rs += i;
+        }
+        for (int i = 0; i < nums.length; ++i) {
+            ls += nums[i];
+            rs -= nums[i];
+            nums[i] = Math.abs(rs - (ls - nums[i]));
+        }
+        return nums;
+    }
+}