Count Numbers with Non-Decreasing Digits

Count Numbers with Non-Decreasing Digits - Problem

You are given two integers, l and r, represented as strings, and an integer b. Return the count of integers in the inclusive range [l, r] whose digits are in non-decreasing order when represented in base b.

An integer is considered to have non-decreasing digits if, when read from left to right (from the most significant digit to the least significant digit), each digit is greater than or equal to the previous one.

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

Input & Output

Example 1 — Basic Range in Base 10

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

› Output: 4

💡 Note: Numbers 12, 13, 14, 15 all have non-decreasing digits. 12→[1,2], 13→[1,3], 14→[1,4], 15→[1,5].

Example 2 — Small Range in Base 2

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

› Output: 2

💡 Note: In base 2: 1→[1], 2→[1,0], 3→[1,1], 4→[1,0,0], 5→[1,0,1]. Valid: 1 and 3 (count = 2)

Example 3 — Single Number

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

› Output: 1

💡 Note: Only number 123 in range, digits 1≤2≤3 so it's valid

Constraints

1 ≤ l ≤ r ≤ 10¹⁸
2 ≤ b ≤ 10
l and r are given as strings

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use digit dynamic programming instead of checking each number individually. We build valid numbers digit by digit while maintaining the non-decreasing constraint. Best approach is memoized digit DP with time O(d × b²) and space O(d × b), where d is number of digits and b is the base.

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force - Check Every Number

⏱️ Time: O((r-l) × log_b(r)) Space: O(log_b(r))

Iterate through all numbers from l to r, convert each to base b, and check if digits are in non-decreasing order. This approach is simple but inefficient for large ranges.

Digit Dynamic Programming

⏱️ Time: O(d × b²) Space: O(d × b)

Build numbers digit by digit using recursive approach with memoization. For each position, try all valid digits that maintain non-decreasing property and stay within bounds.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007

void toBaseB(long long num, int base, int* digits, int* length) {
    if (num == 0) {
        digits[0] = 0;
        *length = 1;
        return;
    }
    
    int temp[64];
    int count = 0;
    while (num > 0) {
        temp[count++] = num % base;
        num /= base;
    }
    
    // Reverse to get most significant digit first
    for (int i = 0; i < count; i++) {
        digits[i] = temp[count - 1 - i];
    }
    *length = count;
}

int isNonDecreasing(int* digits, int length) {
    for (int i = 1; i < length; i++) {
        if (digits[i] < digits[i-1]) {
            return 0;
        }
    }
    return 1;
}

int solution(const char* l, const char* r, int b) {
    long long lNum = strtoll(l, NULL, 10);
    long long rNum = strtoll(r, NULL, 10);
    int count = 0;
    
    for (long long num = lNum; num <= rNum; num++) {
        int digits[64];
        int length;
        toBaseB(num, b, digits, &length);
        if (isNonDecreasing(digits, length)) {
            count++;
        }
    }
    
    return count % MOD;
}

int main() {
    char l[100], r[100];
    int b;
    
    fgets(l, sizeof(l), stdin);
    fgets(r, sizeof(r), stdin);
    scanf("%d", &b);
    
    // Remove newlines
    l[strcspn(l, "\n")] = 0;
    r[strcspn(r, "\n")] = 0;
    
    printf("%d\n", solution(l, r, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~35 min Avg. Time

850 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