Added tasks 2435, 2437, 2438.

Author: ThanhNIT

src/main/java/g2401_2500/s2435_paths_in_matrix_whose_sum_is_divisible_by_k/Solution.java

@@ -0,0 +1,42 @@
+package g2401_2500.s2435_paths_in_matrix_whose_sum_is_divisible_by_k;
+
+// #Hard #Array #Dynamic_Programming #Matrix #2022_12_07_Time_70_ms_(99.20%)_Space_84.5_MB_(87.93%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int[][] p = new int[50005][50];
+    private int[][] r = new int[50005][50];
+
+    public int numberOfPaths(int[][] grid, int k) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int x = 0;
+        for (int i = 0; i < n; ++i) {
+            Arrays.fill(r[i], 0, k, 0);
+            x += grid[0][i];
+            r[i][x % k] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            int[][] t = p;
+            p = r;
+            r = t;
+            x = grid[i][0] % k;
+            for (int j = 0; j < k; ++j) {
+                r[0][(x + j) % k] = p[0][j];
+            }
+            for (int j = 1, pj = 0; j < n; ++j, ++pj) {
+                x = grid[i][j] % k;
+                int y = (x > 0) ? (k - x) : 0;
+                for (int l = 0; l < k; ++l, ++y) {
+                    if (y == k) {
+                        y = 0;
+                    }
+                    int modulo = 1000000007;
+                    r[j][l] = (p[j][y] + r[pj][y]) % modulo;
+                }
+            }
+        }
+        return r[n - 1][0];
+    }
+}

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

@@ -0,0 +1,46 @@
+2435\. Paths in Matrix Whose Sum Is Divisible by K
+
+Hard
+
+You are given a **0-indexed** `m x n` integer matrix `grid` and an integer `k`. You are currently at position `(0, 0)` and you want to reach position `(m - 1, n - 1)` moving only **down** or **right**.
+
+Return _the number of paths where the sum of the elements on the path is divisible by_ `k`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/08/13/image-20220813183124-1.png)
+
+**Input:** grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
+
+**Output:** 2
+
+**Explanation:** There are two paths where the sum of the elements on the path is divisible by k. The first path highlighted in red has a sum of 5 + 2 + 4 + 5 + 2 = 18 which is divisible by 3. The second path highlighted in blue has a sum of 5 + 3 + 0 + 5 + 2 = 15 which is divisible by 3.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/08/17/image-20220817112930-3.png)
+
+**Input:** grid = [[0,0]], k = 5
+
+**Output:** 1
+
+**Explanation:** The path highlighted in red has a sum of 0 + 0 = 0 which is divisible by 5.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2022/08/12/image-20220812224605-3.png)
+
+**Input:** grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
+
+**Output:** 10
+
+**Explanation:** Every integer is divisible by 1 so the sum of the elements on every possible path is divisible by k.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m, n <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= m * n <= 5 * 10<sup>4</sup></code>
+*   `0 <= grid[i][j] <= 100`
+*   `1 <= k <= 50`

src/main/java/g2401_2500/s2437_number_of_valid_clock_times/Solution.java

@@ -0,0 +1,28 @@
+package g2401_2500.s2437_number_of_valid_clock_times;
+
+// #Easy #String #Enumeration #2022_12_07_Time_0_ms_(100.00%)_Space_42.2_MB_(29.58%)
+
+public class Solution {
+    public int countTime(String time) {
+        int[] counts = new int[] {3, 10, 0, 6, 10};
+        char[] ch = time.toCharArray();
+        int result = 1;
+        if (ch[0] == '2') {
+            counts[1] = 4;
+        }
+        if ((ch[1] - '0') > 3) {
+            counts[0] = 2;
+        }
+        if (ch[0] == '?' && ch[1] == '?') {
+            counts[0] = 1;
+            counts[1] = 24;
+        }
+        for (int i = 0; i < 5; i++) {
+            char ch1 = ch[i];
+            if (ch1 == '?') {
+                result *= counts[i];
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,40 @@
+2437\. Number of Valid Clock Times
+
+Easy
+
+You are given a string of length `5` called `time`, representing the current time on a digital clock in the format `"hh:mm"`. The **earliest** possible time is `"00:00"` and the **latest** possible time is `"23:59"`.
+
+In the string `time`, the digits represented by the `?` symbol are **unknown**, and must be **replaced** with a digit from `0` to `9`.
+
+Return _an integer_ `answer`_, the number of valid clock times that can be created by replacing every_ `?`_with a digit from_ `0` _to_ `9`.
+
+**Example 1:**
+
+**Input:** time = "?5:00"
+
+**Output:** 2
+
+**Explanation:** We can replace the ? with either a 0 or 1, producing "05:00" or "15:00". Note that we cannot replace it with a 2, since the time "25:00" is invalid. In total, we have two choices.
+
+**Example 2:**
+
+**Input:** time = "0?:0?"
+
+**Output:** 100
+
+**Explanation:** Each ? can be replaced by any digit from 0 to 9, so we have 100 total choices.
+
+**Example 3:**
+
+**Input:** time = "??:??"
+
+**Output:** 1440
+
+**Explanation:** There are 24 possible choices for the hours, and 60 possible choices for the minutes. In total, we have 24 \* 60 = 1440 choices.
+
+**Constraints:**
+
+*   `time` is a valid string of length `5` in the format `"hh:mm"`.
+*   `"00" <= hh <= "23"`
+*   `"00" <= mm <= "59"`
+*   Some of the digits might be replaced with `'?'` and need to be replaced with digits from `0` to `9`.

src/main/java/g2401_2500/s2438_range_product_queries_of_powers/Solution.java

@@ -0,0 +1,50 @@
+package g2401_2500.s2438_range_product_queries_of_powers;
+
+// #Medium #Array #Bit_Manipulation #Prefix_Sum
+// #2022_12_07_Time_73_ms_(65.07%)_Space_134.1_MB_(41.58%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int[] productQueries(int n, int[][] queries) {
+        int length = queries.length;
+        final long mod = (long) (1e9 + 7);
+        // convert n to binary form
+        // take the set bit and find the corresponding 2^i
+        // now answer for the query
+        int[] powerTracker = new int[32];
+        List<Long> productTakingPowers = new ArrayList<>();
+        int[] result = new int[length];
+        fillPowerTracker(powerTracker, n);
+        fillProductTakingPowers(productTakingPowers, powerTracker);
+        int index = 0;
+        for (int[] query : queries) {
+            int left = query[0];
+            int right = query[1];
+            long product = 1;
+            for (int i = left; i <= right; i++) {
+                product = (product * productTakingPowers.get(i)) % mod;
+            }
+            result[index++] = (int) (product % mod);
+        }
+        return result;
+    }
+
+    private void fillPowerTracker(int[] powerTracker, int n) {
+        int index = 0;
+        while (n > 0) {
+            powerTracker[index++] = n & 1;
+            n >>= 1;
+        }
+    }
+
+    private void fillProductTakingPowers(List<Long> productTakingPowers, int[] powerTracker) {
+        for (int i = 0; i < 32; i++) {
+            if (powerTracker[i] == 1) {
+                long power = (long) (Math.pow(2, i));
+                productTakingPowers.add(power);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+2438\. Range Product Queries of Powers
+
+Medium
+
+Given a positive integer `n`, there exists a **0-indexed** array called `powers`, composed of the **minimum** number of powers of `2` that sum to `n`. The array is sorted in **non-decreasing** order, and there is **only one** way to form the array.
+
+You are also given a **0-indexed** 2D integer array `queries`, where <code>queries[i] = [left<sub>i</sub>, right<sub>i</sub>]</code>. Each `queries[i]` represents a query where you have to find the product of all `powers[j]` with <code>left<sub>i</sub> <= j <= right<sub>i</sub></code>.
+
+Return _an array_ `answers`_, equal in length to_ `queries`_, where_ `answers[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query_. Since the answer to the <code>i<sup>th</sup></code> query may be too large, each `answers[i]` should be returned **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 15, queries = [[0,1],[2,2],[0,3]]
+
+**Output:** [2,4,64]
+
+**Explanation:** 
+
+For n = 15, powers = [1,2,4,8]. It can be shown that powers cannot be a smaller size. 
+
+Answer to 1st query: powers[0] * powers[1] = 1 * 2 = 2. 
+
+Answer to 2nd query: powers[2] = 4. 
+
+Answer to 3rd query: powers[0] * powers[1] * powers[2] * powers[3] = 1 * 2 * 4 * 8 = 64. 
+
+Each answer modulo 10<sup>9</sup> + 7 yields the same answer, so [2,4,64] is returned.
+
+**Example 2:**
+
+**Input:** n = 2, queries = [[0,0]]
+
+**Output:** [2]
+
+**Explanation:** For n = 2, powers = [2]. The answer to the only query is powers[0] = 2. The answer modulo 10<sup>9</sup> + 7 is the same, so [2] is returned.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> < powers.length</code>

src/test/java/g2401_2500/s2435_paths_in_matrix_whose_sum_is_divisible_by_k/SolutionTest.java

@@ -0,0 +1,28 @@
+package g2401_2500.s2435_paths_in_matrix_whose_sum_is_divisible_by_k;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numberOfPaths() {
+        assertThat(
+                new Solution().numberOfPaths(new int[][] {{5, 2, 4}, {3, 0, 5}, {0, 7, 2}}, 3),
+                equalTo(2));
+    }
+
+    @Test
+    void numberOfPairs2() {
+        assertThat(new Solution().numberOfPaths(new int[][] {{0, 0}}, 5), equalTo(1));
+    }
+
+    @Test
+    void numberOfPairs3() {
+        assertThat(
+                new Solution()
+                        .numberOfPaths(new int[][] {{7, 3, 4, 9}, {2, 3, 6, 2}, {2, 3, 7, 0}}, 1),
+                equalTo(10));
+    }
+}

src/test/java/g2401_2500/s2437_number_of_valid_clock_times/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2401_2500.s2437_number_of_valid_clock_times;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countTime() {
+        assertThat(new Solution().countTime("?5:00"), equalTo(2));
+    }
+
+    @Test
+    void countTime2() {
+        assertThat(new Solution().countTime("0?:0?"), equalTo(100));
+    }
+
+    @Test
+    void countTime3() {
+        assertThat(new Solution().countTime("??:??"), equalTo(1440));
+    }
+}

src/test/java/g2401_2500/s2438_range_product_queries_of_powers/SolutionTest.java

@@ -0,0 +1,20 @@
+package g2401_2500.s2438_range_product_queries_of_powers;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void productQueries() {
+        assertThat(
+                new Solution().productQueries(15, new int[][] {{0, 1}, {2, 2}, {0, 3}}),
+                equalTo(new int[] {2, 4, 64}));
+    }
+
+    @Test
+    void productQueries2() {
+        assertThat(new Solution().productQueries(2, new int[][] {{0, 0}}), equalTo(new int[] {2}));
+    }
+}