K-th Smallest in Lexicographical Order - Practice Coding Problems

K-th Smallest in Lexicographical Order - Problem

Trie Hard

Given two integers n and k, you need to find the k-th lexicographically smallest integer in the range [1, n].

Lexicographical order means dictionary order - where numbers are treated as strings and sorted alphabetically. For example, in lexicographical order: 1, 10, 11, 12, 2, 20, 21, 3, 30, 4, 5...

Example: If n = 13, the lexicographical order is: [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

Your task is to return the k-th number from this ordered sequence efficiently, without generating all numbers.

Input & Output

example_1.py — Basic Case

$ Input: n = 13, k = 3

› Output: 11

💡 Note: Lexicographical order: [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]. The 3rd number is 11.

example_2.py — Edge Case

$ Input: n = 1, k = 1

› Output: 1

💡 Note: Only one number exists in range [1,1], so the 1st lexicographically smallest is 1.

example_3.py — Larger Range

$ Input: n = 100, k = 10

› Output: 17

💡 Note: In lexicographical order: [1, 10, 100, 11, 12, 13, 14, 15, 16, 17, ...]. The 10th number is 17.

Visualization

Tap to expand

Understanding the Visualization

Index System

Like a dictionary index showing how many words start with each letter

Section Skipping

Skip entire sections when you know the target isn't there

Drill Down

Go deeper into subsections when you find the right area

Precise Location

Continue until you reach the exact k-th item

Key Takeaway

🎯 Key Insight: By treating numbers as a trie structure and calculating subtree sizes, we can navigate directly to the k-th position without generating intermediate values.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to generate numbers + O(n log n) for sorting

⚡ Linearithmic

Space Complexity

O(n)

Need to store all n numbers as strings

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ n ≤ 10⁹
k is guaranteed to be valid (within range [1, n])
The answer will fit in a 32-bit integer

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses a trie-based approach that treats numbers as a 10-ary tree. Instead of generating all numbers, we navigate through prefixes by calculating how many numbers exist in each subtree. This allows us to skip entire branches and find the k-th number in O((log n)²) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate and Sort)	O(n log n)	O(n)	Generate all numbers from 1 to n, sort lexicographically, return k-th element
Trie Traversal with Counting (Optimal)	O((log n)²)	O(1)	Navigate through number prefixes like a tree, counting elements in each subtree

Brute Force (Generate and Sort) — Algorithm Steps

Generate all integers from 1 to n
Convert each integer to string
Sort the strings lexicographically
Return the k-th element (k-1 index)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create array with all numbers [1,2,3,...,n]

Sort

Sort lexicographically: [1,10,11,12,13,2,3,4,5,6,7,8,9]

Select

Return element at index k-1

Code -

solution.c — C

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

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

int findKthNumber(int n, int k) {
    // Generate all numbers from 1 to n
    char** numbers = (char**)malloc(n * sizeof(char*));
    for (int i = 1; i <= n; i++) {
        numbers[i-1] = (char*)malloc(20 * sizeof(char));
        sprintf(numbers[i-1], "%d", i);
    }
    
    // Sort lexicographically
    qsort(numbers, n, sizeof(char*), compare);
    
    // Return k-th number
    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, %d]", &n, &k);
    printf("%d\n", findKthNumber(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to generate numbers + O(n log n) for sorting

⚡ Linearithmic

Space Complexity

O(n)

Need to store all n numbers as strings

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ n ≤ 10⁹
k is guaranteed to be valid (within range [1, n])
The answer will fit in a 32-bit integer

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate and Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler