Added tasks 2343, 2344.

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.11'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2344 |[Minimum Deletions to Make Array Divisible](src/main/java/g2301_2400/s2344_minimum_deletions_to_make_array_divisible/Solution.java)| Hard || 13 | 88.89
+| 2343 |[Query Kth Smallest Trimmed Number](src/main/java/g2301_2400/s2343_query_kth_smallest_trimmed_number/Solution.java)| Medium || 61 | 75.00
 | 2342 |[Max Sum of a Pair With Equal Sum of Digits](src/main/java/g2301_2400/s2342_max_sum_of_a_pair_with_equal_sum_of_digits/Solution.java)| Medium || 99 | 100.00
 | 2341 |[Maximum Number of Pairs in Array](src/main/java/g2301_2400/s2341_maximum_number_of_pairs_in_array/Solution.java)| Easy || 2 | 80.00
 | 2338 |[Count the Number of Ideal Arrays](src/main/java/g2301_2400/s2338_count_the_number_of_ideal_arrays/Solution.java)| Hard | Math, Dynamic_Programming, Combinatorics, Number_Theory | 21 | 99.04

src/main/java/g2301_2400/s2343_query_kth_smallest_trimmed_number/Solution.java

@@ -0,0 +1,57 @@
+package g2301_2400.s2343_query_kth_smallest_trimmed_number;
+
+// #Medium #2022_07_19_Time_52_ms_(75.00%)_Space_58.8_MB_(37.50%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
+        int numberOfDigits = nums[0].length();
+        int placeValue = numberOfDigits;
+        List<int[]> list = new ArrayList<>(numberOfDigits);
+        while (--placeValue >= 0) {
+            countSort(nums, placeValue, numberOfDigits, list);
+        }
+        int[] op = new int[queries.length];
+        int i = 0;
+        for (int[] query : queries) {
+            int listIndex = query[1] - 1;
+            int place = query[0] - 1;
+            op[i++] = list.get(listIndex)[place];
+        }
+        return op;
+    }
+
+    private void countSort(String[] arr, int exp, int numberOfDigits, List<int[]> list) {
+        int n = arr.length;
+        String[] output = new String[n];
+        int i;
+        int[] count = new int[10];
+        Arrays.fill(count, 0);
+        // Store count of occurrences in count[]
+        for (i = 0; i < n; i++) {
+            int digit = arr[i].charAt(exp) - '0';
+            count[digit]++;
+        }
+        for (i = 1; i < 10; i++) {
+            count[i] += count[i - 1];
+        }
+        // Build the output array
+        int[] op = new int[n];
+        for (i = n - 1; i >= 0; i--) {
+            int digit = arr[i].charAt(exp) - '0';
+            int place = count[digit] - 1;
+            output[place] = arr[i];
+            if (exp == numberOfDigits - 1) {
+                op[place] = i;
+            } else {
+                op[place] = list.get(list.size() - 1)[i];
+            }
+            count[digit]--;
+        }
+        list.add(op);
+        System.arraycopy(output, 0, arr, 0, n);
+    }
+}

src/main/java/g2301_2400/s2343_query_kth_smallest_trimmed_number/readme.md

@@ -0,0 +1,63 @@
+2343\. Query Kth Smallest Trimmed Number
+
+Medium
+
+You are given a **0-indexed** array of strings `nums`, where each string is of **equal length** and consists of only digits.
+
+You are also given a **0-indexed** 2D integer array `queries` where <code>queries[i] = [k<sub>i</sub>, trim<sub>i</sub>]</code>. For each `queries[i]`, you need to:
+
+*   **Trim** each number in `nums` to its **rightmost** <code>trim<sub>i</sub></code> digits.
+*   Determine the **index** of the <code>k<sub>i</sub><sup>th</sup></code> smallest trimmed number in `nums`. If two trimmed numbers are equal, the number with the **lower** index is considered to be smaller.
+*   Reset each number in `nums` to its original length.
+
+Return _an array_ `answer` _of the same length as_ `queries`, _where_ `answer[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query._
+
+**Note**:
+
+*   To trim to the rightmost `x` digits means to keep removing the leftmost digit, until only `x` digits remain.
+*   Strings in `nums` may contain leading zeros.
+
+**Example 1:**
+
+**Input:** nums = ["102","473","251","814"], queries = [[1,1],[2,3],[4,2],[1,2]]
+
+**Output:** [2,2,1,0]
+
+**Explanation:**
+
+1. After trimming to the last digit, nums = ["2","3","1","4"]. The smallest number is 1 at index 2.
+
+2. Trimmed to the last 3 digits, nums is unchanged. The 2<sup>nd</sup> smallest number is 251 at index 2.
+
+3. Trimmed to the last 2 digits, nums = ["02","73","51","14"]. The 4<sup>th</sup> smallest number is 73.
+
+4. Trimmed to the last 2 digits, the smallest number is 2 at index 0.
+
+   Note that the trimmed number "02" is evaluated as 2. 
+
+**Example 2:**
+
+**Input:** nums = ["24","37","96","04"], queries = [[2,1],[2,2]]
+
+**Output:** [3,0]
+
+**Explanation:**
+
+1. Trimmed to the last digit, nums = ["4","7","6","4"]. The 2<sup>nd</sup> smallest number is 4 at index 3.
+
+   There are two occurrences of 4, but the one at index 0 is considered smaller than the one at index 3.
+   
+2. Trimmed to the last 2 digits, nums is unchanged. The 2<sup>nd</sup> smallest number is 24. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i].length <= 100`
+*   `nums[i]` consists of only digits.
+*   All `nums[i].length` are **equal**.
+*   `1 <= queries.length <= 100`
+*   `queries[i].length == 2`
+*   <code>1 <= k<sub>i</sub> <= nums.length</code>
+*   <code>1 <= trim<sub>i</sub> <= nums[i].length</code>
+
+**Follow up:** Could you use the **Radix Sort Algorithm** to solve this problem? What will be the complexity of that solution?

src/main/java/g2301_2400/s2344_minimum_deletions_to_make_array_divisible/Solution.java

@@ -0,0 +1,34 @@
+package g2301_2400.s2344_minimum_deletions_to_make_array_divisible;
+
+// #Hard #2022_07_19_Time_13_ms_(88.89%)_Space_77.2_MB_(77.78%)
+
+public class Solution {
+    public int minOperations(int[] nums, int[] numsDivide) {
+        int g = numsDivide[0];
+        for (int i : numsDivide) {
+            g = gcd(g, i);
+        }
+        int minOp = 0;
+        int smallest = Integer.MAX_VALUE;
+        for (int num : nums) {
+            if (g % num == 0) {
+                smallest = Math.min(smallest, num);
+            }
+        }
+        for (int num : nums) {
+            if (num < smallest) {
+                ++minOp;
+            }
+        }
+        return smallest == Integer.MAX_VALUE ? -1 : minOp;
+    }
+
+    private int gcd(int a, int b) {
+        while (b > 0) {
+            int tmp = a;
+            a = b;
+            b = tmp % b;
+        }
+        return a;
+    }
+}

src/main/java/g2301_2400/s2344_minimum_deletions_to_make_array_divisible/readme.md

@@ -0,0 +1,42 @@
+2344\. Minimum Deletions to Make Array Divisible
+
+Hard
+
+You are given two positive integer arrays `nums` and `numsDivide`. You can delete any number of elements from `nums`.
+
+Return _the **minimum** number of deletions such that the **smallest** element in_ `nums` _**divides** all the elements of_ `numsDivide`. If this is not possible, return `-1`.
+
+Note that an integer `x` divides `y` if `y % x == 0`.
+
+**Example 1:**
+
+**Input:** nums = [2,3,2,4,3], numsDivide = [9,6,9,3,15]
+
+**Output:** 2
+
+**Explanation:**
+
+The smallest element in [2,3,2,4,3] is 2, which does not divide all the elements of numsDivide.
+
+We use 2 deletions to delete the elements in nums that are equal to 2 which makes nums = [3,4,3].
+
+The smallest element in [3,4,3] is 3, which divides all the elements of numsDivide.
+
+It can be shown that 2 is the minimum number of deletions needed. 
+
+**Example 2:**
+
+**Input:** nums = [4,3,6], numsDivide = [8,2,6,10]
+
+**Output:** -1
+
+**Explanation:**
+
+We want the smallest element in nums to divide all the elements of numsDivide.
+
+There is no way to delete elements from nums to allow this.
+
+**Constraints:**
+
+*   <code>1 <= nums.length, numsDivide.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], numsDivide[i] <= 10<sup>9</sup></code>

src/test/java/g2301_2400/s2343_query_kth_smallest_trimmed_number/SolutionTest.java

@@ -0,0 +1,28 @@
+package g2301_2400.s2343_query_kth_smallest_trimmed_number;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void smallestTrimmedNumbers() {
+        assertThat(
+                new Solution()
+                        .smallestTrimmedNumbers(
+                                new String[] {"102", "473", "251", "814"},
+                                new int[][] {{1, 1}, {2, 3}, {4, 2}, {1, 2}}),
+                equalTo(new int[] {2, 2, 1, 0}));
+    }
+
+    @Test
+    void smallestTrimmedNumbers2() {
+        assertThat(
+                new Solution()
+                        .smallestTrimmedNumbers(
+                                new String[] {"24", "37", "96", "04"},
+                                new int[][] {{2, 1}, {2, 2}}),
+                equalTo(new int[] {3, 0}));
+    }
+}

src/test/java/g2301_2400/s2344_minimum_deletions_to_make_array_divisible/SolutionTest.java

@@ -0,0 +1,22 @@
+package g2301_2400.s2344_minimum_deletions_to_make_array_divisible;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minOperations() {
+        assertThat(
+                new Solution().minOperations(new int[] {2, 3, 2, 4, 3}, new int[] {9, 6, 9, 3, 15}),
+                equalTo(2));
+    }
+
+    @Test
+    void minOperations2() {
+        assertThat(
+                new Solution().minOperations(new int[] {4, 3, 6}, new int[] {8, 2, 6, 10}),
+                equalTo(-1));
+    }
+}