K-th Smallest in Lexicographical Order

K-th Smallest in Lexicographical Order - Problem

Trie Hard

Given two integers n and k, return the k-th lexicographically smallest integer in the range [1, n].

Lexicographical order means dictionary order - numbers are compared digit by digit from left to right. For example: 1, 10, 11, 12, 2, 20, 21, 3, 30...

Note: This is different from numerical order where 2 comes before 10.

Input & Output

Example 1 — Basic Case

$ Input: n = 13, k = 2

› Output: 10

💡 Note: Lexicographical order: 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9. The 2nd element is 10.

Example 2 — First Element

$ Input: n = 1, k = 1

› Output: 1

💡 Note: Only one number exists, so the 1st element is 1.

Example 3 — Larger Range

$ Input: n = 100, k = 10

› Output: 17

💡 Note: Lexicographical order starts: 1, 10, 100, 11, 12, 13, 14, 15, 16, 17... The 10th element is 17.

Constraints

1 ≤ k ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is to navigate a virtual trie structure without generating all numbers. Instead of creating all numbers from 1 to n, we calculate how many numbers exist in each subtree and skip entire branches when the k-th element isn't there. Best approach uses trie navigation with Time: O((log n)²), Space: O(1).

Common Approaches

✓ Brute Force - Generate and Sort

⏱️ Time: O(n log n) Space: O(n)

Convert all numbers from 1 to n into strings, sort them lexicographically like dictionary words, then return the k-th element. This works but is very inefficient for large n.

Trie Navigation (Optimal)

⏱️ Time: O((log n)²) Space: O(1)

Instead of generating all numbers, we conceptually navigate through a trie (prefix tree) structure. We calculate how many numbers exist in each subtree and skip entire branches when we know the k-th element isn't there.

Brute Force - Generate and Sort — Algorithm Steps

Step 1: Generate all numbers from 1 to n as strings
Step 2: Sort the strings lexicographically
Step 3: Return the k-th string converted back to integer

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create array of all numbers 1 to n as strings

Sort

Sort strings lexicographically (dictionary order)

Select

Return the k-th element from sorted array

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return strcmp(*(char**)a, *(char**)b);
}

int solution(int n, int k) {
    // Generate all numbers from 1 to n as strings
    char** numbers = malloc(n * sizeof(char*));
    for (int i = 1; i <= n; i++) {
        numbers[i-1] = malloc(20 * sizeof(char));
        sprintf(numbers[i-1], "%d", i);
    }
    
    // Sort lexicographically
    qsort(numbers, n, sizeof(char*), compare);
    
    // Get k-th element (k is 1-indexed)
    int result = atoi(numbers[k-1]);
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(numbers[i]);
    }
    free(numbers);
    
    return result;
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    int result = solution(n, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Generating n strings takes O(n), sorting them takes O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Need to store all n numbers as strings in memory

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler