Codestin Search App

Lexicographical Numbers - Problem

🔤 Lexicographical Numbers

Imagine you need to arrange numbers from 1 to n as if they were words in a dictionary! In lexicographical (dictionary) order, we compare numbers as strings character by character.

For example, with n = 13:

Normal order: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Lexicographical order: [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

Notice how 10 comes after 1 but before 2 because when comparing as strings, "10" starts with "1" and "0" comes before "2".

The challenge: You must solve this in O(n) time and use only O(1) extra space (excluding the output array)!

Input & Output

example_1.py — Basic Case

$ Input: n = 13

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

💡 Note: Numbers 1-13 arranged lexicographically. Notice how 10,11,12,13 all come after 1 but before 2, since they start with '1' when compared as strings.

example_2.py — Single Digit

$ Input: n = 5

› Output: [1,2,3,4,5]

💡 Note: When n ≤ 9, lexicographical order is the same as numerical order since all numbers are single digits.

example_3.py — Larger Range

$ Input: n = 25

› Output: [1,10,11,12,13,14,15,16,17,18,19,2,20,21,22,23,24,25,3,4,5,6,7,8,9]

💡 Note: With n=25, we see the full pattern: 1 followed by all numbers starting with 1 (10-19), then 2 followed by numbers starting with 2 (20-25), then remaining single digits.

Constraints

1 ≤ n ≤ 5 × 10⁴
Must run in O(n) time complexity
Must use O(1) extra space (excluding output array)

Visualization

Tap to expand

Understanding the Visualization

Root Level

Start with digits 1-9 as root nodes

Branch Out

Each number can branch to 10 children by appending digits 0-9

DFS Traversal

Traverse depth-first: go as deep as possible before trying siblings

Natural Order

DFS order gives lexicographical order automatically!

Key Takeaway

🎯 Key Insight: By treating numbers as nodes in a 10-ary tree and performing DFS traversal, we get lexicographical order naturally without any sorting, achieving optimal O(n) time and O(1) space complexity.

Asked in

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

The optimal solution uses a DFS tree traversal approach where we treat numbers as nodes in a 10-ary tree. Starting from 1, we go as deep as possible (1→10→100), then backtrack and try siblings. This naturally generates numbers in lexicographical order without sorting, achieving O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate and Sort)	O(n log n)	O(n)	Generate all numbers, convert to strings, and sort lexicographically
DFS Tree Traversal (Optimal)	O(n)	O(1)	Use DFS to traverse numbers as a 10-ary tree in lexicographical order

Brute Force (Generate and Sort) — Algorithm Steps

Generate all numbers from 1 to n
Convert each number to string
Sort the strings lexicographically
Convert back to integers and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Numbers

Create array [1, 2, 3, ..., n]

Convert to Strings

Convert each number to string for comparison

Sort Lexicographically

Sort strings alphabetically

Convert Back

Convert sorted strings back to integers

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    char str_a[20], str_b[20];
    sprintf(str_a, "%d", *(int*)a);
    sprintf(str_b, "%d", *(int*)b);
    return strcmp(str_a, str_b);
}

int* lexicalOrder(int n, int* returnSize) {
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    // Generate all numbers from 1 to n
    for (int i = 1; i <= n; i++) {
        result[i-1] = i;
    }
    
    // Sort lexicographically
    qsort(result, n, sizeof(int), compare);
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* result = lexicalOrder(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Converting n numbers to strings takes O(n log n) time, sorting takes O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Need O(n) space to store string representations of all numbers

⚡ Linearithmic Space

67.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

🔤 Lexicographical Numbers

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate and Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler