Added tasks 1734, 1735, 1736, 1737, 1738.

Author: ThanhNIT

src/main/java/g1701_1800/s1734_decode_xored_permutation/Solution.java

@@ -0,0 +1,19 @@
+package g1701_1800.s1734_decode_xored_permutation;
+
+// #Medium #Array #Bit_Manipulation #2022_04_29_Time_6_ms_(34.52%)_Space_140.9_MB_(66.67%)
+
+public class Solution {
+    public int[] decode(int[] encoded) {
+        int[] decoded = new int[encoded.length + 1];
+        for (int i = 1; i < encoded.length; i = i + 2) {
+            decoded[0] = decoded[0] ^ encoded[i];
+            decoded[0] = decoded[0] ^ i;
+            decoded[0] = decoded[0] ^ i + 1;
+        }
+        decoded[0] = decoded[0] ^ decoded.length;
+        for (int i = 1; i < decoded.length; i++) {
+            decoded[i] = decoded[i - 1] ^ encoded[i - 1];
+        }
+        return decoded;
+    }
+}

src/main/java/g1701_1800/s1734_decode_xored_permutation/readme.md

@@ -0,0 +1,29 @@
+1734\. Decode XORed Permutation
+
+Medium
+
+There is an integer array `perm` that is a permutation of the first `n` positive integers, where `n` is always **odd**.
+
+It was encoded into another integer array `encoded` of length `n - 1`, such that `encoded[i] = perm[i] XOR perm[i + 1]`. For example, if `perm = [1,3,2]`, then `encoded = [2,1]`.
+
+Given the `encoded` array, return _the original array_ `perm`. It is guaranteed that the answer exists and is unique.
+
+**Example 1:**
+
+**Input:** encoded = [3,1]
+
+**Output:** [1,2,3]
+
+**Explanation:** If perm = [1,2,3], then encoded = [1 XOR 2,2 XOR 3] = [3,1]
+
+**Example 2:**
+
+**Input:** encoded = [6,5,4,6]
+
+**Output:** [2,4,1,5,3]
+
+**Constraints:**
+
+*   <code>3 <= n < 10<sup>5</sup></code>
+*   `n` is odd.
+*   `encoded.length == n - 1`

src/main/java/g1701_1800/s1735_count_ways_to_make_array_with_product/Solution.java

@@ -0,0 +1,64 @@
+package g1701_1800.s1735_count_ways_to_make_array_with_product;
+
+// #Hard #Array #Dynamic_Programming #Math #2022_04_29_Time_189_ms_(43.75%)_Space_50.3_MB_(56.25%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private static final int MOD = 1_000_000_007;
+    private long[][] tri;
+    private List<Integer> primes;
+
+    public int[] waysToFillArray(int[][] queries) {
+        int len = queries.length;
+        int[] res = new int[len];
+        primes = getPrimes(100);
+        tri = getTri(10015, 15);
+        for (int i = 0; i < len; i++) {
+            res[i] = calculate(queries[i][0], queries[i][1]);
+        }
+        return res;
+    }
+
+    private List<Integer> getPrimes(int limit) {
+        boolean[] notPrime = new boolean[limit + 1];
+        List<Integer> res = new ArrayList<>();
+        for (int i = 2; i <= limit; i++) {
+            if (!notPrime[i]) {
+                res.add(i);
+                for (int j = i * i; j <= limit; j += i) {
+                    notPrime[j] = true;
+                }
+            }
+        }
+        return res;
+    }
+
+    private long[][] getTri(int m, int n) {
+        long[][] res = new long[m + 1][n + 1];
+        for (int i = 0; i <= m; i++) {
+            res[i][0] = 1;
+            for (int j = 1; j <= Math.min(n, i); j++) {
+                res[i][j] = (res[i - 1][j - 1] + res[i - 1][j]) % MOD;
+            }
+        }
+        return res;
+    }
+
+    private int calculate(int n, int target) {
+        long res = 1;
+        for (int prime : primes) {
+            if (prime > target) {
+                break;
+            }
+            int cnt = 0;
+            while (target % prime == 0) {
+                cnt++;
+                target /= prime;
+            }
+            res = (res * tri[cnt + n - 1][cnt]) % MOD;
+        }
+        return target > 1 ? (int) (res * n % MOD) : (int) res;
+    }
+}

src/main/java/g1701_1800/s1735_count_ways_to_make_array_with_product/readme.md

@@ -0,0 +1,26 @@
+1735\. Count Ways to Make Array With Product
+
+Hard
+
+You are given a 2D integer array, `queries`. For each `queries[i]`, where <code>queries[i] = [n<sub>i</sub>, k<sub>i</sub>]</code>, find the number of different ways you can place positive integers into an array of size <code>n<sub>i</sub></code> such that the product of the integers is <code>k<sub>i</sub></code>. As the number of ways may be too large, the answer to the <code>i<sup>th</sup></code> query is the number of ways **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Return _an integer array_ `answer` _where_ `answer.length == queries.length`_, and_ `answer[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query._
+
+**Example 1:**
+
+**Input:** queries = [[2,6],[5,1],[73,660]]
+
+**Output:** [4,1,50734910]
+
+**Explanation:** Each query is independent. [2,6]: There are 4 ways to fill an array of size 2 that multiply to 6: [1,6], [2,3], [3,2], [6,1]. [5,1]: There is 1 way to fill an array of size 5 that multiply to 1: [1,1,1,1,1]. [73,660]: There are 1050734917 ways to fill an array of size 73 that multiply to 660. 1050734917 modulo 10<sup>9</sup> + 7 = 50734910.
+
+**Example 2:**
+
+**Input:** queries = [[1,1],[2,2],[3,3],[4,4],[5,5]]
+
+**Output:** [1,2,3,10,5]
+
+**Constraints:**
+
+*   <code>1 <= queries.length <= 10<sup>4</sup></code>
+*   <code>1 <= n<sub>i</sub>, k<sub>i</sub> <= 10<sup>4</sup></code>

src/main/java/g1701_1800/s1736_latest_time_by_replacing_hidden_digits/Solution.java

@@ -0,0 +1,53 @@
+package g1701_1800.s1736_latest_time_by_replacing_hidden_digits;
+
+// #Easy #String #Greedy #2022_04_29_Time_3_ms_(35.96%)_Space_42.5_MB_(22.81%)
+
+public class Solution {
+    public String maximumTime(String time) {
+        StringBuilder sb = new StringBuilder();
+        String[] strs = time.split(":");
+        String hour = strs[0];
+        String min = strs[1];
+        if (hour.charAt(0) == '?') {
+            if (hour.charAt(1) == '?') {
+                sb.append("23");
+            } else if (hour.charAt(1) > '3') {
+                sb.append("1");
+                sb.append(hour.charAt(1));
+            } else {
+                sb.append("2");
+                sb.append(hour.charAt(1));
+            }
+        } else if (hour.charAt(0) == '0' || hour.charAt(0) == '1') {
+            if (hour.charAt(1) == '?') {
+                sb.append(hour.charAt(0));
+                sb.append("9");
+            } else {
+                sb.append(hour);
+            }
+        } else if (hour.charAt(0) == '2') {
+            if (hour.charAt(1) == '?') {
+                sb.append("23");
+            } else {
+                sb.append(hour);
+            }
+        }
+        sb.append(":");
+        if (min.charAt(0) == '?') {
+            if (min.charAt(1) == '?') {
+                sb.append("59");
+            } else {
+                sb.append("5");
+                sb.append(min.charAt(1));
+            }
+            return sb.toString();
+        }
+        sb.append(min.charAt(0));
+        if (min.charAt(1) == '?') {
+            sb.append("9");
+        } else {
+            sb.append(min.charAt(1));
+        }
+        return sb.toString();
+    }
+}

src/main/java/g1701_1800/s1736_latest_time_by_replacing_hidden_digits/readme.md

@@ -0,0 +1,34 @@
+1736\. Latest Time by Replacing Hidden Digits
+
+Easy
+
+You are given a string `time` in the form of `hh:mm`, where some of the digits in the string are hidden (represented by `?`).
+
+The valid times are those inclusively between `00:00` and `23:59`.
+
+Return _the latest valid time you can get from_ `time` _by replacing the hidden_ _digits_.
+
+**Example 1:**
+
+**Input:** time = "2?:?0"
+
+**Output:** "23:50"
+
+**Explanation:** The latest hour beginning with the digit '2' is 23 and the latest minute ending with the digit '0' is 50.
+
+**Example 2:**
+
+**Input:** time = "0?:3?"
+
+**Output:** "09:39"
+
+**Example 3:**
+
+**Input:** time = "1?:22"
+
+**Output:** "19:22"
+
+**Constraints:**
+
+*   `time` is in the format `hh:mm`.
+*   It is guaranteed that you can produce a valid time from the given string.

src/main/java/g1701_1800/s1737_change_minimum_characters_to_satisfy_one_of_three_conditions/Solution.java

@@ -0,0 +1,31 @@
+package g1701_1800.s1737_change_minimum_characters_to_satisfy_one_of_three_conditions;
+
+// #Medium #String #Hash_Table #Prefix_Sum #Counting
+// #2022_04_29_Time_8_ms_(87.70%)_Space_54.4_MB_(51.42%)
+
+public class Solution {
+    public int minCharacters(String s1, String s2) {
+        int[] a = new int[26];
+        int[] b = new int[26];
+        int l1 = s1.length();
+        int l2 = s2.length();
+        for (char i : s1.toCharArray()) {
+            a[i - 'a']++;
+        }
+        for (char i : s2.toCharArray()) {
+            b[i - 'a']++;
+        }
+        int min = Integer.MAX_VALUE;
+        int t1 = 0;
+        int t2 = 0;
+        int max = -1;
+        for (int i = 0; i < 25; i++) {
+            t1 += a[i];
+            t2 += b[i];
+            min = Math.min(min, Math.min(t1 + l2 - t2, t2 + l1 - t1));
+            max = Math.max(max, a[i] + b[i]);
+        }
+        max = Math.max(max, a[25] + b[25]);
+        return Math.min(min, l1 + l2 - max);
+    }
+}

src/main/java/g1701_1800/s1737_change_minimum_characters_to_satisfy_one_of_three_conditions/readme.md

@@ -0,0 +1,40 @@
+1737\. Change Minimum Characters to Satisfy One of Three Conditions
+
+Medium
+
+You are given two strings `a` and `b` that consist of lowercase letters. In one operation, you can change any character in `a` or `b` to **any lowercase letter**.
+
+Your goal is to satisfy **one** of the following three conditions:
+
+*   **Every** letter in `a` is **strictly less** than **every** letter in `b` in the alphabet.
+*   **Every** letter in `b` is **strictly less** than **every** letter in `a` in the alphabet.
+*   **Both** `a` and `b` consist of **only one** distinct letter.
+
+Return _the **minimum** number of operations needed to achieve your goal._
+
+**Example 1:**
+
+**Input:** a = "aba", b = "caa"
+
+**Output:** 2
+
+**Explanation:** Consider the best way to make each condition true: 
+
+1) Change b to "ccc" in 2 operations, then every letter in a is less than every letter in b. 
+
+2) Change a to "bbb" and b to "aaa" in 3 operations, then every letter in b is less than every letter in a. 
+
+3) Change a to "aaa" and b to "aaa" in 2 operations, then a and b consist of one distinct letter. The best way was done in 2 operations (either condition 1 or condition 3).
+
+**Example 2:**
+
+**Input:** a = "dabadd", b = "cda"
+
+**Output:** 3
+
+**Explanation:** The best way is to make condition 1 true by changing b to "eee".
+
+**Constraints:**
+
+*   <code>1 <= a.length, b.length <= 10<sup>5</sup></code>
+*   `a` and `b` consist only of lowercase letters.

src/main/java/g1701_1800/s1738_find_kth_largest_xor_coordinate_value/Solution.java

@@ -0,0 +1,62 @@
+package g1701_1800.s1738_find_kth_largest_xor_coordinate_value;
+
+// #Medium #Array #Matrix #Bit_Manipulation #Heap_Priority_Queue #Prefix_Sum #Divide_and_Conquer
+// #Quickselect #2022_04_29_Time_40_ms_(97.08%)_Space_208.6_MB_(58.39%)
+
+public class Solution {
+    public int kthLargestValue(int[][] matrix, int k) {
+        int t = 0;
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        int[][] prefixXor = new int[rows + 1][cols + 1];
+        int[] array = new int[rows * cols];
+
+        for (int r = 1; r <= rows; r++) {
+            for (int c = 1; c <= cols; c++) {
+                prefixXor[r][c] =
+                        matrix[r - 1][c - 1]
+                                ^ prefixXor[r - 1][c]
+                                ^ prefixXor[r][c - 1]
+                                ^ prefixXor[r - 1][c - 1];
+                array[t++] = prefixXor[r][c];
+            }
+        }
+
+        int target = array.length - k;
+        quickSelect(array, 0, array.length - 1, target);
+        return array[target];
+    }
+
+    private int quickSelect(int[] array, int left, int right, int target) {
+        if (left == right) {
+            return left;
+        }
+
+        int pivot = array[right];
+        int j = left;
+        int k = right - 1;
+        while (j <= k) {
+            if (array[j] < pivot) {
+                j++;
+            } else if (array[k] > pivot) {
+                k--;
+            } else {
+                swap(array, j++, k--);
+            }
+        }
+        swap(array, j, right);
+        if (j == target) {
+            return j;
+        } else if (j > target) {
+            return quickSelect(array, left, j - 1, target);
+        } else {
+            return quickSelect(array, j + 1, right, target);
+        }
+    }
+
+    private void swap(int[] array, int i, int j) {
+        int tmp = array[i];
+        array[i] = array[j];
+        array[j] = tmp;
+    }
+}