Count of Integers - Practice Coding Problems

Count of Integers - Problem

Count of Integers is a fascinating digit dynamic programming problem that challenges you to count numbers within a range based on their digit sum constraints.

You're given two numeric strings num1 and num2 representing the lower and upper bounds of a range, along with two integers min_sum and max_sum that define the valid digit sum range.

Your task is to count how many integers x satisfy both conditions:
• num1 ≤ x ≤ num2 (x is within the numeric range)
• min_sum ≤ digit_sum(x) ≤ max_sum (x's digit sum is within bounds)

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

Example: If num1 = "1", num2 = "12", min_sum = 1, max_sum = 8, then numbers like 1 (digit sum: 1), 10 (digit sum: 1), 11 (digit sum: 2), 12 (digit sum: 3) are all valid, but we exclude any numbers whose digit sum exceeds 8.

Input & Output

example_1.py — Basic Range

$ Input: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8

› Output: 11

💡 Note: Numbers 1,2,3,4,5,6,7,8,10,11,12 have digit sums [1,2,3,4,5,6,7,8,1,2,3] respectively. All are within [1,8] range, so count = 11.

example_2.py — Tight Constraints

$ Input: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5

› Output: 5

💡 Note: Numbers 1,2,3,4,5 have digit sums [1,2,3,4,5]. All satisfy the constraints 1 ≤ digit_sum ≤ 5.

example_3.py — No Valid Numbers

$ Input: num1 = "1", num2 = "9", min_sum = 15, max_sum = 20

› Output: 0

💡 Note: Single digit numbers (1-9) have digit sums 1-9, none of which fall in range [15,20], so count = 0.

Visualization

Tap to expand

Understanding the Visualization

Set Boundaries

Define the counting range [num1, num2] and digit sum constraints [min_sum, max_sum]

Build Digit Tree

Construct numbers digit by digit, exploring only valid branches

Track Constraints

Monitor tight bounds and current digit sum at each level

Prune Invalid Paths

Skip branches that violate digit sum or range constraints

Memoize States

Cache results for repeated subproblems to avoid redundant calculations

Key Takeaway

🎯 Key Insight: Digit DP transforms an impossible brute force problem (up to 10²² iterations) into a tractable polynomial solution by intelligently exploring only the valid portion of the solution space using memoization.

Time & Space Complexity

Time Complexity

⏱️

O(n × sum_range × 2 × 2)

n is the number of digits, sum_range is max_sum - min_sum, and we have 2 boolean states for tight constraints

✓ Linear Growth

Space Complexity

O(n × sum_range × 2 × 2)

Memoization table stores all possible DP states

⚡ Linearithmic Space

Constraints

1 ≤ num1 ≤ num2 < 10²²
1 ≤ min_sum ≤ max_sum ≤ 400
num1 and num2 consist of digits only and don't have leading zeros
The range can contain up to 10²² numbers, making brute force impossible

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses Digit Dynamic Programming to count valid numbers efficiently. Instead of checking every number in the range (which could be up to 10²² numbers), we build valid numbers digit by digit while tracking range constraints and digit sum bounds. The key insight is using memoization to store computed states defined by (position, current_sum, tight_lower, tight_upper), reducing time complexity from exponential to polynomial.

Common Approaches

Approach	Time	Space	Notes
✓ Digit Dynamic Programming (Optimal)	O(n × sum_range × 2 × 2)	O(n × sum_range × 2 × 2)	Use digit DP with memoization to count valid numbers efficiently
Brute Force (Direct Iteration)	O(num2 - num1)	O(1)	Iterate through every number in range and check digit sum constraints

Digit Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: (position, current_sum, is_lower_bound_tight, is_upper_bound_tight)
For each position, try all possible digits (0-9)
Check if placing each digit violates range constraints
Recursively count valid numbers for remaining positions
Use memoization to store computed states
Handle the count of numbers from [0, num2] - [0, num1-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP state

Start at position 0 with sum=0, tight bounds active

Try each valid digit

For current position, try digits 0-9 (or up to limit if tight)

Update constraints

Adjust tight bounds and current sum based on chosen digit

Recurse or terminate

Continue to next position or count valid complete numbers

Memoize results

Cache computed states to avoid redundant calculations

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 25
#define MAXSUM 1000

int memo[MAXN][MAXSUM][2][2];
char numStr[MAXN];
int minSum, maxSum, n;

int dp(int pos, int currentSum, int tight, int started) {
    if (pos == n) {
        return (minSum <= currentSum && currentSum <= maxSum && started) ? 1 : 0;
    }
    
    if (memo[pos][currentSum][tight][started] != -1) {
        return memo[pos][currentSum][tight][started];
    }
    
    int limit = tight ? (numStr[pos] - '0') : 9;
    int result = 0;
    
    for (int digit = 0; digit <= limit; digit++) {
        int newSum = currentSum + digit;
        int newTight = tight && (digit == limit);
        int newStarted = started || (digit > 0);
        
        if (newSum > maxSum) continue;
        
        result = (result + dp(pos + 1, newSum, newTight, newStarted)) % MOD;
    }
    
    memo[pos][currentSum][tight][started] = result;
    return result;
}

int countValid(char* numString, int minS, int maxS) {
    strcpy(numStr, numString);
    n = strlen(numStr);
    minSum = minS;
    maxSum = maxS;
    
    memset(memo, -1, sizeof(memo));
    return dp(0, 0, 1, 0);
}

char* subtractOne(char* numStr) {
    long long num = atoll(numStr);
    if (num == 0) {
        static char zero[] = "0";
        return zero;
    }
    static char result[MAXN];
    sprintf(result, "%lld", num - 1);
    return result;
}

int countOfIntegers(char* num1, char* num2, int minSum, int maxSum) {
    int countUpToNum2 = countValid(num2, minSum, maxSum);
    int countUpToNum1Minus1 = countValid(subtractOne(num1), minSum, maxSum);
    
    return (countUpToNum2 - countUpToNum1Minus1 + MOD) % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × sum_range × 2 × 2)

n is the number of digits, sum_range is max_sum - min_sum, and we have 2 boolean states for tight constraints

✓ Linear Growth

Space Complexity

O(n × sum_range × 2 × 2)

Memoization table stores all possible DP states

⚡ Linearithmic Space

Constraints

1 ≤ num1 ≤ num2 < 10²²
1 ≤ min_sum ≤ max_sum ≤ 400
num1 and num2 consist of digits only and don't have leading zeros
The range can contain up to 10²² numbers, making brute force impossible

31.2K Views

Medium Frequency

~35 min Avg. Time

856 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

Digit Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler