Codestin Search App

Sequential Digits - Problem

Enumeration Medium

Imagine a special number where each digit follows a perfect sequence - each digit is exactly one more than the previous digit! These are called sequential digits.

For example:

123 has sequential digits: 1→2→3 (each increases by 1)
89 has sequential digits: 8→9 (increases by 1)
1234567 has sequential digits: 1→2→3→4→5→6→7
132 does NOT have sequential digits (3→2 decreases)

Given a range [low, high], your task is to find all numbers with sequential digits within this range and return them in sorted order.

Goal: Return a sorted list of all integers in the range [low, high] that have sequential digits.

Input & Output

example_1.py — Basic Range

$ Input: low = 100, high = 300

› Output: [123, 234]

💡 Note: In the range [100, 300], only 123 (1→2→3) and 234 (2→3→4) have sequential digits. Both numbers have each digit exactly one more than the previous digit.

example_2.py — Small Range

$ Input: low = 1000, high = 13000

› Output: [1234, 2345, 3456, 4567, 5678, 6789, 12345]

💡 Note: All 4-digit sequential numbers (1234 through 6789) fall in this range, plus one 5-digit number (12345). Each follows the pattern where digits increase by exactly 1.

example_3.py — Edge Case

$ Input: low = 10, high = 20

› Output: [12]

💡 Note: Only the 2-digit number 12 falls in this small range. Single digits (10) don't count as sequential since we need at least two digits to form a sequence.

Constraints

10 ≤ low ≤ high ≤ 10⁹
All integers in the range must be checked for sequential digit property
Sequential digits: each digit is exactly one more than the previous digit

Visualization

Tap to expand

Understanding the Visualization

Plant Seeds

Start with single digits 1-9 as root nodes

Grow Branches

From each digit, extend by adding next consecutive digit

Prune Invalid

Stop growing when next digit > 9 or number > high

Harvest Results

Collect all numbers within [low, high] range

Sort Output

Return naturally ordered sequential numbers

Key Takeaway

🎯 Key Insight: Instead of checking every number in a potentially huge range, we generate only the limited set of valid sequential digit numbers (at most 45), making this approach extremely efficient with O(1) time complexity!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses smart enumeration to generate sequential digit numbers directly. Instead of checking every number in the range, we start with each digit 1-9 and extend sequences by adding consecutive digits. Since there are at most 45 possible sequential numbers (limited by digits 0-9), this approach runs in O(1) time regardless of range size. The key insight is that sequential digit numbers follow a predictable pattern that can be generated systematically.

Common Approaches

Approach	Time	Space	Notes
✓ Smart Generation (Optimal)	O(1)	O(1)	Generate all possible sequential digit numbers directly using enumeration

Smart Generation (Optimal) — Algorithm Steps

For each starting digit from 1 to 9, generate all possible sequential numbers
For each starting digit, keep adding the next consecutive digit
Stop extending when next digit would exceed 9 or number exceeds high
Collect all valid numbers that fall within [low, high] range
Return the naturally sorted result (generated in order)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with digit 1

Begin sequence: 1 → 12 → 123 → 1234...

Start with digit 2

Begin sequence: 2 → 23 → 234 → 2345...

Continue for all digits

Repeat for starting digits 3-9

Filter by range

Keep only numbers within [low, high]

Return sorted result

Natural ordering from generation process

Code -

solution.c — C

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

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

int* sequentialDigits(int low, int high, int* returnSize) {
    int* result = malloc(50 * sizeof(int));
    int count = 0;
    
    // Try each starting digit from 1 to 9
    for (int start = 1; start <= 9; start++) {
        int num = start;
        int nextDigit = start + 1;
        
        // Keep extending the number while possible
        while (nextDigit <= 9) {
            num = num * 10 + nextDigit;
            
            // If number is in range, add it
            if (num >= low && num <= high) {
                result[count++] = num;
            }
            // If number exceeds high, no point continuing this sequence
            else if (num > high) {
                break;
            }
            
            nextDigit++;
        }
    }
    
    qsort(result, count, sizeof(int), compare);
    *returnSize = count;
    return result;
}

int main() {
    int low, high;
    scanf("%d %d", &low, &high);
    
    int returnSize;
    int* result = sequentialDigits(low, high, &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(1)

There are at most 45 sequential digit numbers possible (limited by digit constraints), so we generate a constant number of candidates

✓ Linear Growth

Space Complexity

O(1)

Space used is proportional to the output size, which is bounded by a small constant

✓ Linear Space

89.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Smart Generation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler