Query Kth Smallest Trimmed Number - Practice Coding Problems

Query Kth Smallest Trimmed Number - Problem

Array String Divide and Conquer Sorting Heap (Priority Queue) Radix Sort Quickselect Medium

You're given an array of equal-length numeric strings and need to answer multiple queries efficiently. Each query asks you to:

Trim all numbers to their rightmost trim digits
Find the k-th smallest trimmed number
Return the original index of that number

🔍 Key Challenge: When two trimmed numbers are equal, the one with the smaller original index is considered smaller.

Example: Given ["102", "473", "251", "814"] and query [2, 1] (2nd smallest, trim to 1 digit):

Trimmed: ["2", "3", "1", "4"]
Sorted by value then index: ["1"(idx 2), "2"(idx 0), "3"(idx 1), "4"(idx 3)]
2nd smallest → return index 0

Input & Output

example_1.py — Basic Query Processing

$ Input: nums = ["102", "473", "251", "814"] queries = [[1,1],[2,3],[4,2],[1,2]]

› Output: [2, 2, 3, 0]

💡 Note: Query 1: trim=1 → ["2","3","1","4"] → sorted: ["1"(idx2), "2"(idx0), "3"(idx1), "4"(idx3)] → 1st smallest is index 2. Query 2: trim=3 → ["102","473","251","814"] → sorted: ["102"(idx0), "251"(idx2), "473"(idx1), "814"(idx3)] → 2nd smallest is index 2.

example_2.py — Equal Values Test

$ Input: nums = ["24", "37", "96", "04"] queries = [[2,1],[1,2]]

› Output: [3, 3]

💡 Note: Query 1: trim=1 → ["4","7","6","4"] → sorted: ["4"(idx0), "4"(idx3), "6"(idx2), "7"(idx1)] → 2nd smallest is index 3 (tie-breaker by index). Query 2: trim=2 → ["24","37","96","04"] → sorted: ["04"(idx3), "24"(idx0), "37"(idx1), "96"(idx2)] → 1st smallest is index 3.

example_3.py — Single Character

$ Input: nums = ["1", "2", "3", "4"] queries = [[3,1],[2,1]]

› Output: [2, 1]

💡 Note: All numbers are single characters. After trim=1: ["1","2","3","4"] → already sorted by index. Query 1: 3rd smallest is "3" at index 2. Query 2: 2nd smallest is "2" at index 1.

Visualization

Tap to expand

Understanding the Visualization

Patron Request

Patron wants 2nd smallest book looking at last 1 digit of catalog

Trim Catalogs

Extract last digit from each catalog number

Sort & Cache

Sort books by trimmed numbers, cache the result

Future Requests

When another patron asks for same trim pattern, use cached result

Key Takeaway

🎯 Key Insight: Cache sorted results for each trim length. Multiple queries with the same trim can reuse cached data, dramatically improving performance from O(q × n log n) to O(unique_trims × n log n + q).

Time & Space Complexity

Time Complexity

⏱️

O(unique_trims × n log n + q)

Sort once per unique trim length, then O(1) lookup per query

⚡ Linearithmic

Space Complexity

O(unique_trims × n)

Store sorted results for each unique trim length

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i].length ≤ 100
nums[i] consists of only digits
All strings in nums have equal length
1 ≤ queries.length ≤ 100
queries[i] = [k_i, trim_i]
1 ≤ k_i ≤ nums.length
1 ≤ trim_i ≤ nums[i].length

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses caching to avoid redundant sorting. For each unique trim length, we sort once and store the result. When queries repeat trim lengths, we get O(1) lookup instead of O(n log n) sorting. This reduces time complexity from O(q × n log n) to O(unique_trims × n log n + q).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Caching	O(unique_trims × n log n + q)	O(unique_trims × n)	Cache sorted results for each trim length to avoid redundant sorting
Brute Force (Sort for Each Query)	O(q × n log n)	O(n)	For each query, trim all numbers, sort them, and find the k-th smallest

Optimized with Caching — Algorithm Steps

Create a cache/map to store sorted results for each trim length
For each query, check if we've already computed results for this trim length
If not cached, compute trimmed pairs, sort them, and store in cache
If cached, directly use the pre-sorted result
Return the k-th element's original index from the cached result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Query

Process trim=1, cache result

Different Trim

Process trim=3, cache result

Cache Hit

Query with trim=1 again, use cached result

Instant Lookup

O(1) retrieval from cache

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TRIM 100

typedef struct {
    char value[101];
    int index;
} Pair;

typedef struct {
    Pair* pairs;
    int size;
} CacheEntry;

static CacheEntry cache[MAX_TRIM + 1];
static int cache_initialized[MAX_TRIM + 1] = {0};

int compare(const void* a, const void* b) {
    Pair* pa = (Pair*)a;
    Pair* pb = (Pair*)b;
    int cmp = strcmp(pa->value, pb->value);
    if (cmp != 0) return cmp;
    return pa->index - pb->index;
}

int* smallestTrimmedNumbers(char** nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        int k = queries[q][0];
        int trim = queries[q][1];
        
        if (!cache_initialized[trim]) {
            cache[trim].pairs = (Pair*)malloc(numsSize * sizeof(Pair));
            cache[trim].size = numsSize;
            
            for (int i = 0; i < numsSize; i++) {
                int len = strlen(nums[i]);
                int start = len - trim;
                if (start < 0) start = 0;
                strcpy(cache[trim].pairs[i].value, nums[i] + start);
                cache[trim].pairs[i].index = i;
            }
            
            qsort(cache[trim].pairs, numsSize, sizeof(Pair), compare);
            cache_initialized[trim] = 1;
        }
        
        result[q] = cache[trim].pairs[k-1].index;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(unique_trims × n log n + q)

Sort once per unique trim length, then O(1) lookup per query

⚡ Linearithmic

Space Complexity

O(unique_trims × n)

Store sorted results for each unique trim length

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i].length ≤ 100
nums[i] consists of only digits
All strings in nums have equal length
1 ≤ queries.length ≤ 100
queries[i] = [k_i, trim_i]
1 ≤ k_i ≤ nums.length
1 ≤ trim_i ≤ nums[i].length

38.0K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized with Caching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler