Lexicographical Numbers - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each number from 1 to n exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables (excluding output array)

✓ Linear Space

Constraints

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

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
✓ 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)	O(n log n)	O(n)	Generate all numbers, convert to strings, and sort lexicographically

DFS Tree Traversal (Optimal) — Algorithm Steps

Start with current number = 1
Add current number to result
If current * 10 ≤ n, go deeper (multiply by 10)
Otherwise, try next sibling (increment last digit)
If no sibling possible, backtrack (divide by 10 and increment)
Repeat until all n numbers are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at 1

Begin DFS traversal from root node 1

Go Deeper

If current * 10 ≤ n, traverse to deeper level

Next Sibling

When can't go deeper, try next sibling (+1)

Backtrack

When no more siblings, backtrack to parent level

Code -

solution.c — C

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

int* lexicalOrder(int n, int* returnSize) {
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    int current = 1;
    
    for (int i = 0; i < n; i++) {
        result[i] = current;
        
        // Try to go deeper (multiply by 10)
        if (current * 10 <= n) {
            current *= 10;
        } else {
            // Try to go to next sibling or backtrack
            while (current % 10 == 9 || current + 1 > n) {
                current /= 10;  // backtrack
            }
            current++;  // next sibling
        }
    }
    
    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)

We visit each number from 1 to n exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables (excluding output array)

✓ Linear Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS Tree Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler