Stepping Numbers - Practice Coding Problems

Stepping Numbers - Problem

A stepping number is a fascinating mathematical concept where each digit in the number has a very special relationship with its neighbors. Specifically, every pair of adjacent digits must have an absolute difference of exactly 1.

Think of it like climbing stairs - you can only go up or down by exactly one step at a time! For example:

321 is a stepping number: |3-2| = 1, |2-1| = 1 ✓
4321 is a stepping number: |4-3| = 1, |3-2| = 1, |2-1| = 1 ✓
421 is NOT a stepping number: |4-2| = 2 ✗

Your task is to find all stepping numbers within a given range [low, high] (inclusive) and return them in sorted order.

Goal: Generate all valid stepping numbers in the range efficiently.
Input: Two integers low and high representing the inclusive range.
Output: A sorted list of all stepping numbers in the range.

Input & Output

example_1.py — Basic Range

$ Input: low = 0, high = 21

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

💡 Note: All single digits (0-9) are stepping numbers. For two digits: 10 (|1-0|=1), 12 (|1-2|=1), 21 (|2-1|=1) are valid. Numbers like 11 (|1-1|=0) and 20 (|2-0|=2) are not stepping numbers.

example_2.py — Larger Range

$ Input: low = 10, high = 15

› Output: [10, 12]

💡 Note: In range [10,15]: 10 is valid (|1-0|=1), 12 is valid (|1-2|=1), but 11 (|1-1|=0), 13 (|1-3|=2), 14 (|1-4|=3), 15 (|1-5|=4) are all invalid.

example_3.py — Edge Case

$ Input: low = 0, high = 0

› Output: [0]

💡 Note: Single digit 0 is considered a stepping number by definition (no adjacent digits to compare).

Visualization

Tap to expand

Understanding the Visualization

Foundation Level

Start with single-digit staircases (1,2,3,4,5,6,7,8,9) - these are our building blocks

Build Second Floor

From each single digit, add steps that are exactly ±1: from 1 we can build 10 or 12

Expand Systematically

Continue building higher floors: from 10 we can build 101, from 12 we can build 121 or 123

Filter by Range

Collect only staircases that fit within our required height range [low, high]

Key Takeaway

🎯 Key Insight: Generate only valid stepping numbers using BFS rather than testing every number in the range - this transforms an O(n) checking problem into an O(k) generation problem where k << n!

Time & Space Complexity

Time Complexity

⏱️

O(k * log(high))

Where k is the number of stepping numbers ≤ high. We generate each valid number once.

⚡ Linearithmic

Space Complexity

O(k)

Space for the queue and result array containing k stepping numbers

✓ Linear Space

Constraints

0 ≤ low ≤ high ≤ 2 × 10⁹
The answer is guaranteed to fit within a 32-bit integer
Single digits (0-9) are considered stepping numbers

Asked in

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

The optimal approach uses BFS generation starting from single digits (1-9) and systematically building longer stepping numbers by appending digits that differ by exactly 1. This avoids checking invalid numbers and achieves O(k × log(high)) time complexity where k is the count of valid stepping numbers.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Generation (Optimal)	O(k * log(high))	O(k)	Generate stepping numbers using BFS starting from single digits

BFS Generation (Optimal) — Algorithm Steps

Initialize queue with single digits 0-9 (all are stepping numbers)
For each number in queue, try appending digits that differ by 1
If last digit is d, we can append (d-1) or (d+1) if they're valid (0-9)
Add newly generated numbers to queue if they're ≤ high
Collect all generated numbers that fall within [low, high] range

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with single digits 1,2,3,4,5,6,7,8,9 in queue

Process 1

From 1: can append 0→10, or 2→12. Add both to queue

Process 2

From 2: can append 1→21, or 3→23. Add both to queue

Continue BFS

Keep expanding until numbers exceed high limit

Code -

solution.c — C

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

struct Queue {
    long long* data;
    int front, rear, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->data = (long long*)malloc(capacity * sizeof(long long));
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(struct Queue* q, long long val) {
    q->data[q->rear++] = val;
}

long long dequeue(struct Queue* q) {
    return q->data[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

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

int* steppingNumbers(int low, int high, int* returnSize) {
    int* result = (int*)malloc(100000 * sizeof(int));
    *returnSize = 0;
    
    if (high == 0) {
        result[0] = 0;
        *returnSize = 1;
        return result;
    }
    
    struct Queue* q = createQueue(100000);
    
    // Initialize with 1-9
    for (int i = 1; i <= 9; i++) {
        enqueue(q, i);
    }
    
    // Handle 0 separately
    if (low <= 0) {
        result[(*returnSize)++] = 0;
    }
    
    while (!isEmpty(q)) {
        long long num = dequeue(q);
        
        if (num > high) continue;
        
        if (num >= low) {
            result[(*returnSize)++] = (int)num;
        }
        
        int lastDigit = num % 10;
        
        // Try appending lastDigit - 1
        if (lastDigit > 0) {
            long long nextNum = num * 10 + (lastDigit - 1);
            if (nextNum <= high) {
                enqueue(q, nextNum);
            }
        }
        
        // Try appending lastDigit + 1
        if (lastDigit < 9) {
            long long nextNum = num * 10 + (lastDigit + 1);
            if (nextNum <= high) {
                enqueue(q, nextNum);
            }
        }
    }
    
    qsort(result, *returnSize, sizeof(int), compare);
    
    free(q->data);
    free(q);
    return result;
}

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

Where k is the number of stepping numbers ≤ high. We generate each valid number once.

⚡ Linearithmic

Space Complexity

O(k)

Space for the queue and result array containing k stepping numbers

✓ Linear Space

Constraints

0 ≤ low ≤ high ≤ 2 × 10⁹
The answer is guaranteed to fit within a 32-bit integer
Single digits (0-9) are considered stepping numbers

38.5K Views

Medium Frequency

~25 min Avg. Time

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

BFS Generation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler