Count Stepping Numbers in Range

Count Stepping Numbers in Range - Problem

Given two positive integers low and high represented as strings, find the count of stepping numbers in the inclusive range [low, high].

A stepping number is an integer such that all of its adjacent digits have an absolute difference of exactly 1.

Return an integer denoting the count of stepping numbers in the inclusive range [low, high].

Since the answer may be very large, return it modulo 10⁹ + 7.

Note: A stepping number should not have a leading zero.

Input & Output

Example 1 — Basic Range

$ Input: low = "0", high = "21"

› Output: 13

💡 Note: Stepping numbers in [0,21]: 0,1,2,3,4,5,6,7,8,9,10,12,21. Count = 13

Example 2 — Single Digit Range

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

› Output: 9

💡 Note: All single digits 1-9 are stepping numbers. Count = 9

Example 3 — Larger Range

$ Input: low = "10", high = "15"

› Output: 2

💡 Note: Stepping numbers in [10,15]: 10,12. Count = 2

Constraints

1 ≤ low.length, high.length ≤ 15
low and high consist of only digits
low ≤ high
low and high don't have leading zeros

Visualization

Tap to expand

Asked in

G Google 45 f Meta 38 a Amazon 32

The key insight is to use digit DP to count stepping numbers efficiently without generating them all. A stepping number has adjacent digits differing by exactly 1. Best approach uses memoized digit DP with states (position, last_digit, tight, started). Time: O(d × 10), Space: O(d × 10).

Common Approaches

✓ Brute Force - Check Every Number

⏱️ Time: O(n × d) Space: O(1)

Iterate through every number from low to high and check if each number is a stepping number by comparing adjacent digits. This approach is straightforward but inefficient for large ranges.

Digit DP with Memoization

⏱️ Time: O(d × 10 × 2 × 2) Space: O(d × 10 × 2 × 2)

Build numbers digit by digit using dynamic programming. For each position, try placing digits that differ by exactly 1 from the previous digit. Use memoization to avoid recomputing the same states.

Brute Force - Check Every Number — Algorithm Steps

Convert low and high strings to integers
For each number in range, check if it's stepping
Count valid stepping numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Range

Check numbers from low to high

Validate

Check if each number is stepping

Count

Count valid stepping numbers

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 100000

typedef struct {
    int pos, lastDigit;
    int tight, started;
    int result;
} MemoEntry;

static MemoEntry memo[MAX_STATES];
static int memoSize = 0;

int findMemo(int pos, int lastDigit, int tight, int started) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].lastDigit == lastDigit && 
            memo[i].tight == tight && memo[i].started == started) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, int lastDigit, int tight, int started, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].pos = pos;
        memo[memoSize].lastDigit = lastDigit;
        memo[memoSize].tight = tight;
        memo[memoSize].started = started;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int pos, int lastDigit, int tight, int started, const char* numStr, int n) {
    if (pos == n) {
        return started ? 1 : 0;
    }
    
    int cached = findMemo(pos, lastDigit, tight, started);
    if (cached != -1) {
        return cached;
    }
    
    int limit = tight ? (numStr[pos] - '0') : 9;
    int result = 0;
    
    for (int digit = 0; digit <= limit; digit++) {
        int newTight = tight && (digit == limit);
        int newStarted = started || (digit > 0);
        
        if (!started && digit == 0) {
            result = (result + dp(pos + 1, -1, newTight, newStarted, numStr, n)) % MOD;
        } else if (!started || abs(digit - lastDigit) == 1) {
            result = (result + dp(pos + 1, digit, newTight, newStarted, numStr, n)) % MOD;
        }
    }
    
    addMemo(pos, lastDigit, tight, started, result);
    return result;
}

int countStepping(const char* numStr) {
    memoSize = 0;
    return dp(0, -1, 1, 0, numStr, strlen(numStr));
}

void subtractOne(const char* s, char* result) {
    int num = atoi(s);
    if (num == 0) {
        strcpy(result, "0");
    } else {
        sprintf(result, "%d", num - 1);
    }
}

int solution(const char* low, const char* high) {
    int highCount = countStepping(high);
    
    char lowMinus1[20];
    subtractOne(low, lowMinus1);
    int lowCount = countStepping(lowMinus1);
    
    return (highCount - lowCount + MOD) % MOD;
}

int main() {
    char low[20], high[20];
    fgets(low, sizeof(low), stdin);
    fgets(high, sizeof(high), stdin);
    low[strcspn(low, "\n")] = 0;
    high[strcspn(high, "\n")] = 0;
    printf("%d\n", solution(low, high));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

Where n is the range size and d is average digits per number

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 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