Count Numbers with Non-Decreasing Digits - Practice Coding Problems

Count Numbers with Non-Decreasing Digits - Problem

You're given two integers l and r represented as strings, and an integer b (the base). Your task is to count how many integers in the inclusive range [l, r] have non-decreasing digits when represented in base b.

A number has non-decreasing digits if, when reading from left to right (most significant to least significant digit), each digit is greater than or equal to the previous digit.

Example: In base 10, the number 1234 has non-decreasing digits (1 ≤ 2 ≤ 3 ≤ 4), but 4321 does not (4 > 3 > 2 > 1).

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

This problem combines number theory, dynamic programming, and digit manipulation - making it a favorite in technical interviews!

Input & Output

example_1.py — Basic Range in Base 10

$ Input: l = "1", r = "9", b = 10

› Output: 9

💡 Note: All single digits (1,2,3,4,5,6,7,8,9) have non-decreasing digits trivially, so the answer is 9.

example_2.py — Two-digit Range

$ Input: l = "10", r = "15", b = 10

› Output: 3

💡 Note: Numbers 11, 12, 13 have non-decreasing digits. Numbers 10, 14, 15 do not (1>0, 1<4 but then 4>5, 1<5 but we need to check: 10→digits[1,0]→1>0❌, 14→[1,4]→1≤4✅, 15→[1,5]→1≤5✅). So valid numbers are 11,12,13,14,15 = 5. Wait, let me recalculate: 10→[1,0]→invalid, 11→[1,1]→valid, 12→[1,2]→valid, 13→[1,3]→valid, 14→[1,4]→valid, 15→[1,5]→valid. Answer is 5.

example_3.py — Different Base

$ Input: l = "1", r = "10", b = 2

› Output: 3

💡 Note: In base 2, we check numbers 1-10 (decimal). 1→[1]✅, 2→[1,0]❌, 3→[1,1]✅, 4→[1,0,0]❌, 5→[1,0,1]❌, 6→[1,1,0]❌, 7→[1,1,1]✅, 8→[1,0,0,0]❌, 9→[1,0,0,1]❌, 10→[1,0,1,0]❌. Valid: 1,3,7. Answer is 3.

Constraints

1 ≤ l ≤ r ≤ 10¹⁵
2 ≤ b ≤ 36
l and r are given as decimal strings
Answer must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Initialize DP State

Start with position 0, no previous digit constraint, and tight bounds for both l and r

Choose Valid Digits

At each position, try all digits that satisfy: digit ≥ previous_digit and within bounds

Update Constraints

Update tight bounds and previous digit for the next recursive call

Count Valid Paths

Sum up all paths that lead to valid numbers within the range

Key Takeaway

🎯 Key Insight: Use Dynamic Programming to mathematically count valid digit patterns instead of checking every single number in the range - this transforms an O(r-l) brute force into an O(d² × b) elegant solution!

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

This problem is optimally solved using Dynamic Programming with Digit Constraints (Digit DP). Instead of checking every number in the range [l,r], we mathematically count valid numbers by building them digit by digit while maintaining the non-decreasing constraint and boundary conditions. The key insight is to use memoized recursion with states tracking position, previous digit, and tight bounds, achieving O(d² × b) complexity where d is the number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Digit Constraints	O(d² × b)	O(d² × b)	Use digit DP to count valid numbers by building them digit by digit with constraints

Dynamic Programming with Digit Constraints — Algorithm Steps

Convert l and r to base b digit arrays
Use memoized recursion with state (position, previous_digit, tight_l, tight_r, started)
At each position, try all valid digits that maintain non-decreasing property
Handle boundary constraints carefully (tight bounds)
Sum up all valid combinations using mathematical counting

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

Define DP state: (position, prev_digit, tight_bounds, started)

Digit Choice

At each position, choose valid digits ≥ previous digit

Constraint Handling

Maintain tight bounds to stay within [l, r]

Mathematical Counting

Sum all valid paths instead of enumerating numbers

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_DIGITS 20
#define MAX_STATES 1000000

typedef struct {
    int pos, prev, tightL, tightR, started;
    long long result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

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

void addMemo(int pos, int prev, int tightL, int tightR, int started, long long result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].pos = pos;
        memo[memoSize].prev = prev;
        memo[memoSize].tightL = tightL;
        memo[memoSize].tightR = tightR;
        memo[memoSize].started = started;
        memo[memoSize].result = result;
        memoSize++;
    }
}

void toBaseDigits(char* s, int base, int* digits, int* len) {
    long long num = atoll(s);
    *len = 0;
    if (num == 0) {
        digits[0] = 0;
        *len = 1;
        return;
    }
    
    while (num > 0) {
        digits[(*len)++] = num % base;
        num /= base;
    }
    
    // Reverse
    for (int i = 0; i < *len / 2; i++) {
        int temp = digits[i];
        digits[i] = digits[*len - 1 - i];
        digits[*len - 1 - i] = temp;
    }
}

long long digitDP(int pos, int prevDigit, int tightL, int tightR, int started,
                  int* lDigits, int lLen, int* rDigits, int rLen, int b) {
    if (pos == rLen) {
        return started ? 1 : 0;
    }
    
    long long cached = findMemo(pos, prevDigit, tightL, tightR, started);
    if (cached != -1) return cached;
    
    int lo = (tightL && pos < lLen) ? lDigits[pos] : 0;
    int hi = tightR ? rDigits[pos] : b - 1;
    
    long long result = 0;
    for (int digit = lo; digit <= hi; digit++) {
        int newStarted = started || (digit > 0);
        
        if (!newStarted || digit >= prevDigit) {
            int newTightL = tightL && (digit == lo);
            int newTightR = tightR && (digit == hi);
            int newPrev = newStarted ? digit : prevDigit;
            
            result = (result + digitDP(pos + 1, newPrev, newTightL,
                                     newTightR, newStarted,
                                     lDigits, lLen, rDigits, rLen, b)) % MOD;
        }
    }
    
    addMemo(pos, prevDigit, tightL, tightR, started, result);
    return result;
}

int countNumbersWithNonDecreasingDigits(char* l, char* r, int b) {
    memoSize = 0;
    
    int lDigits[MAX_DIGITS], rDigits[MAX_DIGITS];
    int lLen, rLen;
    
    toBaseDigits(l, b, lDigits, &lLen);
    toBaseDigits(r, b, rDigits, &rLen);
    
    // Pad lDigits
    while (lLen < rLen) {
        for (int i = lLen; i > 0; i--) {
            lDigits[i] = lDigits[i-1];
        }
        lDigits[0] = 0;
        lLen++;
    }
    
    return (int)digitDP(0, 0, 1, 1, 0, lDigits, lLen, rDigits, rLen, b);
}

int main() {
    char l[100], r[100];
    int b;
    scanf("%s %s %d", l, r, &b);
    printf("%d\n", countNumbersWithNonDecreasingDigits(l, r, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d² × b)

Where d is max digits in r and b is the base. We have d positions, b possible digits, and track previous digit

✓ Linear Growth

Space Complexity

O(d² × b)

Memoization table stores results for all state combinations

✓ Linear Space

47.7K Views

Medium-High Frequency

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

Dynamic Programming with Digit Constraints — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler