Digit Count in Range - Practice Coding Problems

Digit Count in Range - Problem

You're working with digit analysis! Given a single-digit integer d (from 0-9) and two integers low and high, your task is to count how many times the digit d appears in all numbers within the inclusive range [low, high].

For example, if you're looking for digit 1 in the range [1, 13], you need to examine each number: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13. The digit 1 appears in: 1 (once), 10 (once), 11 (twice), 12 (once), 13 (once) = 6 times total.

Note: Multi-digit numbers can contain the target digit multiple times (like 11 contains two 1's), and each occurrence should be counted separately.

Input & Output

example_1.py — Basic Range

$ Input: d = 1, low = 1, high = 13

› Output: 6

💡 Note: Numbers: 1(1 occurrence), 10(1), 11(2), 12(1), 13(1). Total = 6 occurrences of digit '1'.

example_2.py — Zero Digit

$ Input: d = 0, low = 10, high = 20

› Output: 2

💡 Note: Only numbers 10 and 20 contain digit '0' in this range, each contributing 1 occurrence.

example_3.py — Large Range

$ Input: d = 3, low = 100, high = 250

› Output: 66

💡 Note: Digit '3' appears in units, tens, and hundreds places across the range [100, 250].

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We need to count digit 'd' in all numbers from low to high

Brute Force Approach

Check each number individually - simple but slow

Mathematical Insight

Calculate contributions by digit position instead of individual numbers

Optimize with DP

Use digit DP formula to count efficiently in O(log n) time

Key Takeaway

🎯 Key Insight: Instead of brute force iteration, use mathematical formulas to calculate digit contributions by position. This transforms O(n × log n) brute force into O(log n) optimal solution, making it scalable for very large ranges.

Time & Space Complexity

Time Complexity

⏱️

O(n * log n)

We iterate through n numbers, and for each number we need O(log n) time to process its digits

⚡ Linearithmic

Space Complexity

O(log n)

Space needed to store string representation of largest number

⚡ Linearithmic Space

Constraints

0 ≤ d ≤ 9 (single digit)
1 ≤ low ≤ high ≤ 2 × 10⁸
Note: For digit 0, leading zeros are not counted

Asked in

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

This problem can be solved using Digit Dynamic Programming for optimal O(log n) complexity. While brute force checking every number works for small ranges, the mathematical approach calculates digit contributions by position, making it scalable for large ranges up to 2×10⁸. Key insight: count(high) - count(low-1) with special handling for digit 0 and leading zeros.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n * log n)	O(log n)	Iterate through every number in range and count digit occurrences
Dynamic Programming (Digit DP)	O(log n)	O(log n)	Use mathematical digit DP to count digit occurrences efficiently

Brute Force (Check Every Number) — Algorithm Steps

Loop through each number from low to high
Convert current number to string
Count occurrences of target digit d in the string
Add count to total result
Return final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with range

Begin scanning from low to high

Convert to string

Transform each number into string form

Count digits

Count target digit occurrences in each number

Accumulate total

Add counts together for final result

Code -

solution.c — C

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

int digitCount(int d, int low, int high) {
    int count = 0;
    for (int num = low; num <= high; num++) {
        int temp = num;
        if (temp == 0 && d == 0) {
            count++;
            continue;
        }
        while (temp > 0) {
            if (temp % 10 == d) {
                count++;
            }
            temp /= 10;
        }
    }
    return count;
}

int main() {
    int d, low, high;
    scanf("%d %d %d", &d, &low, &high);
    printf("%d\n", digitCount(d, low, high));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log n)

We iterate through n numbers, and for each number we need O(log n) time to process its digits

⚡ Linearithmic

Space Complexity

O(log n)

Space needed to store string representation of largest number

⚡ Linearithmic Space

Constraints

0 ≤ d ≤ 9 (single digit)
1 ≤ low ≤ high ≤ 2 × 10⁸
Note: For digit 0, leading zeros are not counted

27.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler