Digit DP Counter - Problem

Advanced DP DP Digits Hard

Given a positive integer N, count how many numbers from 1 to N (inclusive) satisfy a specific digit property.

For this problem, we need to count numbers where no two adjacent digits are the same.

For example:

123 is valid (all adjacent digits are different)
112 is invalid (digits 1 and 1 are adjacent and same)
5 is valid (single digit numbers are always valid)

Constraints:

1 ≤ N ≤ 10^18

Input & Output

Example 1 — Small Range

$ Input: n = 25

› Output: 22

💡 Note: Valid numbers: 1,2,3,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19,20,21,23,24,25. Invalid: 11,22 (adjacent same digits). Total: 22 valid numbers.

Example 2 — Single Digit

$ Input: n = 9

› Output: 9

💡 Note: All single digit numbers 1,2,3,4,5,6,7,8,9 are valid (no adjacent digits to compare). Count: 9

Example 3 — Larger Range

$ Input: n = 100

› Output: 90

💡 Note: All single digits (1-9): 9 valid. Two-digit numbers: 10,12,13...98 excluding 11,22,33,44,55,66,77,88,99. Count: 9 + 81 = 90

Constraints

1 ≤ n ≤ 10¹⁸

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Amazon 15

The key insight is to use digit DP instead of checking every number. Build valid numbers digit by digit, tracking position, previous digit, and constraints. Optimal approach uses memoized recursion. Time: O(log N), Space: O(log N)

Common Approaches

✓ Brute Force Check Every Number

⏱️ Time: O(N × log N) Space: O(1)

Iterate through every number from 1 to N, convert each to string, and check if any two adjacent digits are the same. Count valid numbers.

Digit DP with Memoization

⏱️ Time: O(log N × 10 × 2 × 2) Space: O(log N × 10 × 2 × 2)

Build numbers digit by digit using dynamic programming. Track position, previous digit, and tight constraint to count valid combinations efficiently without generating actual numbers.

Brute Force Check Every Number — Algorithm Steps

Convert each number from 1 to N to string
For each number, check all adjacent digit pairs
If no adjacent digits match, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to String

Convert each number to string to access digits

Check Adjacent Pairs

Compare each adjacent digit pair

Count Valid

Increment counter if all pairs are different

Code -

solution.c — C

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

int solution(int n) {
    int count = 0;
    for (int num = 1; num <= n; num++) {
        char s[20];
        sprintf(s, "%d", num);
        int valid = 1;
        for (int i = 0; i < strlen(s) - 1; i++) {
            if (s[i] == s[i + 1]) {
                valid = 0;
                break;
            }
        }
        if (valid) count++;
    }
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(N × log N)

N iterations, each taking O(log N) time to check digits

⚡ Linearithmic

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

28.0K Views

Medium Frequency

~35 min Avg. Time

890 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

Digit DP Counter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check Every Number — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler