Count Stepping Numbers in Range - Practice Coding Problems

Count Stepping Numbers in Range - Problem

Imagine you're a mathematician studying a special type of number called a stepping number. These are fascinating integers where each adjacent digit differs by exactly 1 - like climbing stairs digit by digit!

A stepping number is an integer where all adjacent digits have an absolute difference of exactly 1. For example:

123 is a stepping number (|2-1|=1, |3-2|=1)
4321 is a stepping number (|3-4|=1, |2-3|=1, |1-2|=1)
456 is NOT a stepping number (|5-4|=1 ✓, but |6-5|=1 ✓ - wait, this IS stepping!)
135 is NOT a stepping number (|3-1|=2 ≠ 1)

Given two positive integers low and high represented as strings (because they can be very large!), your mission is to count all stepping numbers in the inclusive range [low, high].

Important: Stepping numbers cannot have leading zeros (so 01, 012 are invalid).

Since the answer can be astronomically large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Range

$ Input: low = "1", high = "11"

› Output: 10

💡 Note: The stepping numbers are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. All single digits are stepping numbers by definition, and 10 is stepping because |1-0|=1.

example_2.py — Larger Range

$ Input: low = "90", high = "101"

› Output: 2

💡 Note: The stepping numbers in this range are: 98 (|9-8|=1) and 101 (|0-1|=1, |1-0|=1). Note that 90, 91, 92, etc. are not stepping numbers because the difference between adjacent digits is not 1.

example_3.py — Single Number

$ Input: low = "123", high = "123"

› Output: 1

💡 Note: Only checking the number 123. Since |2-1|=1 and |3-2|=1, it is a stepping number, so the count is 1.

Constraints

1 ≤ low.length, high.length ≤ 100
low and high consist of only digits
low and high don't have leading zeros
low ≤ high
Answer fits in 32-bit integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Start the staircase

Begin with any digit 1-9 (no leading zeros)

Add valid steps

From digit d, we can only go to d-1 or d+1 (if they exist)

Track boundaries

Ensure we stay within the [low, high] range using tight bounds

Count valid paths

Sum all complete staircases that form valid stepping numbers

Key Takeaway

🎯 Key Insight: Use Digit DP to build stepping numbers systematically, avoiding the need to check every number in the potentially huge range!

Asked in

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

The optimal solution uses Digit Dynamic Programming to count stepping numbers efficiently. Instead of checking every number in the range, we build valid stepping numbers digit by digit, maintaining state about position, last digit, and boundary constraints. This avoids the exponential time complexity of brute force and handles very large string inputs with O(d × 10 × 2³) time complexity where d is the number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O((high - low) × d)	O(d)	Iterate through all numbers in range and check if each is a stepping number
Dynamic Programming with Digit DP (Optimal)	O(d × 10 × 2 × 2 × 2)	O(d × 10 × 2 × 2 × 2)	Use digit DP to build stepping numbers digit by digit without generating all numbers

Brute Force (Check Every Number) — Algorithm Steps

Convert low and high strings to integers
Iterate through each number from low to high
For each number, convert to string and check adjacent digits
Count valid stepping numbers
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with low

Begin checking from the lower bound

Check each digit pair

For each number, verify adjacent digits differ by 1

Count valid numbers

Increment counter for stepping numbers

Continue to high

Repeat until reaching upper bound

Code -

solution.c — C

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

int isStepping(char* numStr) {
    int len = strlen(numStr);
    if (len <= 1) return 1;
    for (int i = 1; i < len; i++) {
        if (abs(numStr[i] - numStr[i-1]) != 1) {
            return 0;
        }
    }
    return 1;
}

int countSteppingNumbers(char* low, char* high) {
    const int MOD = 1000000007;
    
    long long lowInt = atoll(low);
    long long highInt = atoll(high);
    
    // This approach only works for small ranges
    if (highInt - lowInt > 1000000) return -1;
    
    int count = 0;
    char numStr[20];
    for (long long num = lowInt; num <= highInt; num++) {
        sprintf(numStr, "%lld", num);
        if (isStepping(numStr)) {
            count++;
        }
    }
    
    return count % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O((high - low) × d)

Where d is the average number of digits. We check each number and examine all its digits

✓ Linear Growth

Space Complexity

O(d)

Space needed to store string representation of current number

✓ Linear Space

54.2K Views

Medium-High Frequency

~35 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

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler