Added tasks 2517, 2518, 2520, 2521, 2522

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.20'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2522 |[Partition String Into Substrings With Values at Most K](src/main/java/g2501_2600/s2522_partition_string_into_substrings_with_values_at_most_k/Solution.java)| Medium | String, Dynamic_Programming, Greedy | 6 | 84.66
+| 2521 |[Distinct Prime Factors of Product of Array](src/main/java/g2501_2600/s2521_distinct_prime_factors_of_product_of_array/Solution.java)| Medium | Array, Hash_Table, Math, Number_Theory | 2 | 100.00
+| 2520 |[Count the Digits That Divide a Number](src/main/java/g2501_2600/s2520_count_the_digits_that_divide_a_number/Solution.java)| Easy | Math | 0 | 100.00
+| 2518 |[Number of Great Partitions](src/main/java/g2501_2600/s2518_number_of_great_partitions/Solution.java)| Hard | Array, Dynamic_Programming | 4 | 100.00
+| 2517 |[Maximum Tastiness of Candy Basket](src/main/java/g2501_2600/s2517_maximum_tastiness_of_candy_basket/Solution.java)| Medium | Array, Sorting, Binary_Search | 38 | 100.00
 | 2516 |[Take K of Each Character From Left and Right](src/main/java/g2501_2600/s2516_take_k_of_each_character_from_left_and_right/Solution.java)| Medium | String, Hash_Table, Sliding_Window | 6 | 94.24
 | 2515 |[Shortest Distance to Target String in a Circular Array](src/main/java/g2501_2600/s2515_shortest_distance_to_target_string_in_a_circular_array/Solution.java)| Easy | Array, String | 1 | 62.21
 | 2514 |[Count Anagrams](src/main/java/g2501_2600/s2514_count_anagrams/Solution.java)| Hard | String, Hash_Table, Math, Counting, Combinatorics | 22 | 100.00

src/main/java/g2501_2600/s2517_maximum_tastiness_of_candy_basket/Solution.java

@@ -0,0 +1,38 @@
+package g2501_2600.s2517_maximum_tastiness_of_candy_basket;
+
+// #Medium #Array #Sorting #Binary_Search #2023_04_18_Time_38_ms_(100.00%)_Space_51.8_MB_(53.92%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maximumTastiness(int[] price, int k) {
+        Arrays.sort(price);
+        int n = price.length;
+        int left = 1;
+        int right = (price[n - 1] - price[0]) / (k - 1) + 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (check(mid, price, k)) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left - 1;
+    }
+
+    private boolean check(int target, int[] price, int k) {
+        int count = 1;
+        int x0 = price[0];
+        for (int x : price) {
+            if (x >= x0 + target) {
+                count++;
+                if (count >= k) {
+                    return true;
+                }
+                x0 = x;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,46 @@
+2517\. Maximum Tastiness of Candy Basket
+
+Medium
+
+You are given an array of positive integers `price` where `price[i]` denotes the price of the <code>i<sup>th</sup></code> candy and a positive integer `k`.
+
+The store sells baskets of `k` **distinct** candies. The **tastiness** of a candy basket is the smallest absolute difference of the **prices** of any two candies in the basket.
+
+Return _the **maximum** tastiness of a candy basket._
+
+**Example 1:**
+
+**Input:** price = [13,5,1,8,21,2], k = 3
+
+**Output:** 8
+
+**Explanation:** Choose the candies with the prices [13,5,21]. 
+
+The tastiness of the candy basket is: min(|13 - 5|, |13 - 21|, |5 - 21|) = min(8, 8, 16) = 8. 
+
+It can be proven that 8 is the maximum tastiness that can be achieved.
+
+**Example 2:**
+
+**Input:** price = [1,3,1], k = 2
+
+**Output:** 2
+
+**Explanation:** Choose the candies with the prices [1,3]. 
+
+The tastiness of the candy basket is: min(|1 - 3|) = min(2) = 2. 
+
+It can be proven that 2 is the maximum tastiness that can be achieved.
+
+**Example 3:**
+
+**Input:** price = [7,7,7,7], k = 2
+
+**Output:** 0
+
+**Explanation:** Choosing any two distinct candies from the candies we have will result in a tastiness of 0.
+
+**Constraints:**
+
+*   <code>2 <= k <= price.length <= 10<sup>5</sup></code>
+*   <code>1 <= price[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2518_number_of_great_partitions/Solution.java

@@ -0,0 +1,44 @@
+package g2501_2600.s2518_number_of_great_partitions;
+
+// #Hard #Array #Dynamic_Programming #2023_04_18_Time_4_ms_(100.00%)_Space_41.4_MB_(98.28%)
+
+public class Solution {
+    private static final int MOD = 1000000007;
+
+    public int countPartitions(int[] nums, int k) {
+        // edge cases
+        int n = nums.length;
+        long sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
+        if (sum < 2L * k) {
+            return 0;
+        }
+        // normal cases
+        int[] dp = new int[k];
+        dp[0] = 1;
+        for (int num : nums) {
+            for (int i = k - 1; i >= num; i--) {
+                dp[i] = (dp[i] + dp[i - num]) % MOD;
+            }
+        }
+        int smaller = 0;
+        for (int i = 0; i < k; i++) {
+            smaller = (smaller + dp[i]) % MOD;
+        }
+        return (pow(2, n) - (smaller * 2) % MOD + MOD) % MOD;
+    }
+
+    private int pow(long num, int pow) {
+        long result = 1;
+        while (pow != 0) {
+            if (pow % 2 == 1) {
+                result = (result * num) % MOD;
+            }
+            pow /= 2;
+            num = (num * num) % MOD;
+        }
+        return (int) result;
+    }
+}

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

@@ -0,0 +1,40 @@
+2518\. Number of Great Partitions
+
+Hard
+
+You are given an array `nums` consisting of **positive** integers and an integer `k`.
+
+**Partition** the array into two ordered **groups** such that each element is in exactly **one** group. A partition is called great if the **sum** of elements of each group is greater than or equal to `k`.
+
+Return _the number of **distinct** great partitions_. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Two partitions are considered distinct if some element `nums[i]` is in different groups in the two partitions.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4], k = 4
+
+**Output:** 6
+
+**Explanation:** The great partitions are: ([1,2,3], [4]), ([1,3], [2,4]), ([1,4], [2,3]), ([2,3], [1,4]), ([2,4], [1,3]) and ([4], [1,2,3]).
+
+**Example 2:**
+
+**Input:** nums = [3,3,3], k = 4
+
+**Output:** 0
+
+**Explanation:** There are no great partitions for this array.
+
+**Example 3:**
+
+**Input:** nums = [6,6], k = 2
+
+**Output:** 2
+
+**Explanation:** We can either put nums[0] in the first partition or in the second partition. The great partitions will be ([6], [6]) and ([6], [6]).
+
+**Constraints:**
+
+*   `1 <= nums.length, k <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2520_count_the_digits_that_divide_a_number/Solution.java

@@ -0,0 +1,18 @@
+package g2501_2600.s2520_count_the_digits_that_divide_a_number;
+
+// #Easy #Math #2023_04_18_Time_0_ms_(100.00%)_Space_39.3_MB_(62.57%)
+
+public class Solution {
+    public int countDigits(int num) {
+        int a = num;
+        int count = 0;
+        while (a > 0) {
+            int r = a % 10;
+            if (r != 0 && num % r == 0) {
+                count++;
+            }
+            a /= 10;
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,36 @@
+2520\. Count the Digits That Divide a Number
+
+Easy
+
+Given an integer `num`, return _the number of digits in `num` that divide_ `num`.
+
+An integer `val` divides `nums` if `nums % val == 0`.
+
+**Example 1:**
+
+**Input:** num = 7
+
+**Output:** 1
+
+**Explanation:** 7 divides itself, hence the answer is 1.
+
+**Example 2:**
+
+**Input:** num = 121
+
+**Output:** 2
+
+**Explanation:** 121 is divisible by 1, but not 2. Since 1 occurs twice as a digit, we return 2.
+
+**Example 3:**
+
+**Input:** num = 1248
+
+**Output:** 4
+
+**Explanation:** 1248 is divisible by all of its digits, hence the answer is 4.
+
+**Constraints:**
+
+*   <code>1 <= num <= 10<sup>9</sup></code>
+*   `num` does not contain `0` as one of its digits.

src/main/java/g2501_2600/s2521_distinct_prime_factors_of_product_of_array/Solution.java

@@ -0,0 +1,42 @@
+package g2501_2600.s2521_distinct_prime_factors_of_product_of_array;
+
+// #Medium #Array #Hash_Table #Math #Number_Theory
+// #2023_04_18_Time_2_ms_(100.00%)_Space_44.1_MB_(18.47%)
+
+@SuppressWarnings("java:S1119")
+public class Solution {
+    static final int[] PRIMES = new int[] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
+
+    public int distinctPrimeFactors(int[] nums) {
+        final boolean[] hasPrime = new boolean[PRIMES.length];
+        final boolean[] nr = new boolean[1001];
+        int r = 0;
+        a:
+        for (int n : nums) {
+            if (nr[n]) {
+                continue;
+            }
+            nr[n] = true;
+            for (int i = 0; i < PRIMES.length && n > 1; i++) {
+                final int prime = PRIMES[i];
+                while (n % prime == 0) {
+                    n /= prime;
+                    hasPrime[i] = true;
+                    if (nr[n]) {
+                        continue a;
+                    }
+                    nr[n] = true;
+                }
+            }
+            if (n > 1) {
+                r++;
+            }
+        }
+        for (boolean p : hasPrime) {
+            if (p) {
+                r++;
+            }
+        }
+        return r;
+    }
+}

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

@@ -0,0 +1,35 @@
+2521\. Distinct Prime Factors of Product of Array
+
+Medium
+
+Given an array of positive integers `nums`, return _the number of **distinct prime factors** in the product of the elements of_ `nums`.
+
+**Note** that:
+
+*   A number greater than `1` is called **prime** if it is divisible by only `1` and itself.
+*   An integer `val1` is a factor of another integer `val2` if `val2 / val1` is an integer.
+
+**Example 1:**
+
+**Input:** nums = [2,4,3,7,10,6]
+
+**Output:** 4
+
+**Explanation:** The product of all the elements in nums is: 2 \* 4 \* 3 \* 7 \* 10 \* 6 = 10080 = 2<sup>5</sup> \* 3<sup>2</sup> \* 5 \* 7. 
+
+There are 4 distinct prime factors so we return 4.
+
+**Example 2:**
+
+**Input:** nums = [2,4,8,16]
+
+**Output:** 1
+
+**Explanation:** The product of all the elements in nums is: 2 \* 4 \* 8 \* 16 = 1024 = 2<sup>10</sup>. 
+
+There is 1 distinct prime factor so we return 1.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `2 <= nums[i] <= 1000`

src/main/java/g2501_2600/s2522_partition_string_into_substrings_with_values_at_most_k/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2522_partition_string_into_substrings_with_values_at_most_k;
+
+// #Medium #String #Dynamic_Programming #Greedy #2023_04_18_Time_6_ms_(84.66%)_Space_43_MB_(76.70%)
+
+public class Solution {
+    public int minimumPartition(String s, int k) {
+        if (k == 9) {
+            return s.length();
+        }
+        int partitions = 1;
+        long partitionValue = 0;
+        long digit;
+        for (int i = 0; i < s.length(); i++) {
+            digit = (long) s.charAt(i) - '0';
+            if (digit > k) {
+                return -1;
+            }
+            partitionValue = partitionValue * 10 + digit;
+            if (partitionValue > k) {
+                partitionValue = digit;
+                partitions++;
+            }
+        }
+        return partitions;
+    }
+}