Count Special Integers - Practice Coding Problems

Count Special Integers - Problem

Imagine you're working at a digital security company that needs to identify "special" numbers for encryption purposes. A positive integer is considered special if all of its digits are distinct (no repeated digits).

For example:

123 is special ✅ (all digits 1, 2, 3 are different)
1001 is NOT special ❌ (digit 1 appears twice, digit 0 appears twice)
987654321 is special ✅ (all 9 digits are unique)

Given a positive integer n, your task is to count how many special integers exist in the range [1, n] inclusive.

Goal: Return the count of special integers from 1 to n.
Input: A positive integer n
Output: Number of special integers in range [1, n]

Input & Output

example_1.py — Basic Case

$ Input: n = 20

› Output: 19

💡 Note: All numbers from 1 to 20 have unique digits except 11. Numbers 1,2,3,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19,20 are special (19 total).

example_2.py — Larger Case

$ Input: n = 100

› Output: 91

💡 Note: All 1-digit numbers (1-9) are special: 9 numbers. For 2-digit numbers (10-99), we exclude those with repeated digits: 11,22,33,44,55,66,77,88,99. So 90-9=81 two-digit special numbers. Total: 9+81+1=91 (including 100 which is NOT special due to repeated 0s, so actually 9+81=90, plus 100 is not special, so 90).

example_3.py — Edge Case

$ Input: n = 1000

› Output: 738

💡 Note: Includes all 1-digit (9), valid 2-digit (81), valid 3-digit numbers, but 1000 itself has repeated 0s so is not special.

Constraints

1 ≤ n ≤ 2 × 10⁹
n is a positive integer
Special integer: All digits in the number are distinct

Visualization

Tap to expand

Understanding the Visualization

Count by Length

First count all valid 1-digit plates (1-9), then 2-digit plates, etc.

Use Combinatorics

For k-digit plates: first position has 9 choices (1-9), second has 9 choices (0-9 except first), third has 8 choices, etc.

Handle Boundaries

Use digit DP to carefully count numbers with same length as n but ≤ n

Combine Results

Sum up counts from all different lengths to get final answer

Key Takeaway

🎯 Key Insight: Mathematical counting using digit DP is exponentially faster than checking each number individually, making the solution scalable for large inputs.

Asked in

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

The optimal solution uses Digit Dynamic Programming (Digit DP) to count special integers efficiently. Instead of checking each number individually, we mathematically count valid combinations by building numbers digit by digit while tracking used digits and boundary constraints. This reduces time complexity from O(n×d) to O(d²×2^10), making it feasible for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Combinatorics Approach	O(d²)	O(1)	Calculate special numbers using combinatorial mathematics
Brute Force (Check Every Number)	O(n × d)	O(d)	Check each number from 1 to n individually for distinct digits

Mathematical Combinatorics Approach — Algorithm Steps

Count 1-digit numbers: all digits 1-9 are special (9 numbers)
Count 2-digit numbers: first digit has 9 choices (1-9), second has 9 choices (0-9 except first)
Count k-digit numbers: use permutation formula P(10,k) with adjustments
Handle the boundary case where n has specific number of digits
Sum up all counts for different digit lengths

Visualization

Tap to expand

Step-by-Step Walkthrough

Count shorter numbers

1-digit: 9 numbers, 2-digit: 9×9 numbers, etc.

Build same-length numbers

Use digit DP to count valid combinations

Track constraints

Maintain tight bound and used digits mask

Code -

solution.c — C

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

int memo[12][1024][2][2];
char s[12];
int slen;

int dfs(int pos, int mask, int tight, int started) {
    if (pos == slen) {
        return started;
    }
    
    if (memo[pos][mask][tight][started] != -1) {
        return memo[pos][mask][tight][started];
    }
    
    int limit = tight ? (s[pos] - '0') : 9;
    int count = 0;
    
    for (int digit = 0; digit <= limit; digit++) {
        if (mask & (1 << digit)) continue;
        
        int newMask = mask;
        if (started || digit > 0) {
            newMask |= (1 << digit);
        }
        
        int newTight = tight && (digit == limit);
        int newStarted = started || (digit > 0);
        
        count += dfs(pos + 1, newMask, newTight, newStarted);
    }
    
    return memo[pos][mask][tight][started] = count;
}

int countNumbersWithUniqueDigits(int n) {
    if (n == 0) return 1;
    
    sprintf(s, "%d", n);
    slen = strlen(s);
    memset(memo, -1, sizeof(memo));
    
    int result = 0;
    
    // Count numbers with fewer digits
    if (slen >= 1) result += 9;
    
    for (int k = 2; k < slen; k++) {
        if (k <= 10) {
            int count = 9;
            for (int i = 1; i < k; i++) {
                count *= (10 - i);
            }
            result += count;
        }
    }
    
    result += dfs(0, 0, 1, 0);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(d²)

Where d is the number of digits in n. We iterate through digit lengths and calculate combinations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

47.5K Views

Medium Frequency

~25 min Avg. Time

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

Mathematical Combinatorics Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler