g2301_2400.s2343_query_kth_smallest_trimmed_number.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g2301_2400.s2343_query_kth_smallest_trimmed_number;

// #Medium #Array #String #Sorting #Heap_Priority_Queue #Divide_and_Conquer #Quickselect #Radix_Sort
// #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;

/**
 * 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 queries[i] = [k_i, trim_i]. For each `queries[i]`, you need to:
 *
 * *   **Trim** each number in `nums` to its **rightmost** trim_i digits.
 * *   Determine the **index** of the k_i^th 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_ i^th _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^nd smallest number is 251 at index 2.
 *
 * 3. Trimmed to the last 2 digits, nums = ["02","73","51","14"]. The 4^th 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^nd 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^nd 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`
 * *   1 <= k_i <= nums.length
 * *   1 <= trim_i <= nums[i].length
 *
 * **Follow up:** Could you use the **Radix Sort Algorithm** to solve this problem? What will be the complexity of that solution?
**/
public class Solution {
    public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
        int numberOfDigits = nums[0].length();
        int placeValue = numberOfDigits;
        List 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 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);
    }
}