Count Special Integers

Count Special Integers - Problem

We call a positive integer special if all of its digits are distinct.

Given a positive integer n, return the number of special integers that belong to the interval [1, n].

A special integer has no repeated digits. For example, 123 is special, but 112 is not special because digit 1 appears twice.

Input & Output

Example 1 — Small Range

$ Input: n = 20

› Output: 18

💡 Note: Special integers from 1 to 20: 1,2,3,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19,20. We exclude 11 because digit 1 repeats. All other numbers have distinct digits.

Example 2 — Single Digit

$ Input: n = 5

› Output: 5

💡 Note: All numbers from 1 to 5 have distinct digits: 1,2,3,4,5. Each single-digit number is automatically special.

Example 3 — Edge Case

$ Input: n = 100

› Output: 90

💡 Note: Includes all 1-digit (9) and 2-digit numbers with distinct digits (9×9=81), but excludes 100 because it has repeated 0s. Total: 9 + 81 = 90.

Constraints

1 ≤ n ≤ 2 × 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 6

The key insight is that most numbers follow predictable patterns for distinct digits, so we can use mathematical formulas or digit DP instead of checking each number individually. Best approach is Digit DP with memoization for O(d × 2¹⁰) time complexity where d is the number of digits in n.

Common Approaches

✓ Brute Force

⏱️ Time: O(n × d) Space: O(d)

For each number from 1 to n, convert it to string and check if all digits are unique by comparing the length of the digit set with the total number of digits.

Digit DP with Memoization

⏱️ Time: O(d × 2^10 × 2 × 2) Space: O(d × 2^10 × 2 × 2)

Use digit DP to count valid numbers by building them position by position, keeping track of used digits, whether we're still bounded by n, and whether we've started placing non-zero digits.

Mathematical Combinatorics

⏱️ Time: O(d²) Space: O(1)

Count special integers by grouping them by number of digits. For d-digit numbers, we have permutations of 10 digits taken d at a time, with special handling for leading zeros.

Brute Force — Algorithm Steps

Iterate through each number from 1 to n
Convert number to string to examine digits
Use a set to check if all digits are distinct
Count numbers with distinct digits

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Number

Go through 1, 2, 3, ... up to n

Examine Digits

For each number, check if all digits are unique

Count Valid

Increment counter for numbers with distinct digits

Code -

solution.c — C

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

static char s[20];
static int length;

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

int solution(int n) {
    if (n == 0) {
        return 1;
    }
    
    sprintf(s, "%d", n);
    length = strlen(s);
    
    // Count numbers with fewer digits
    int result = 0;
    
    // 1-digit numbers: 1,2,3,4,5,6,7,8,9
    if (length > 1) {
        result += 9;
    }
    
    // 2-digit, 3-digit, ... up to (length-1)-digit numbers
    for (int digits = 2; digits < length; digits++) {
        // First digit: 9 choices (1-9)
        // Remaining digits: 9 * 8 * 7 * ... choices
        int count = 9;
        int remaining = 9;
        for (int i = 1; i < digits; i++) {
            count *= remaining;
            remaining -= 1;
        }
        result += count;
    }
    
    // Count numbers with same number of digits as n
    result += countValid(0, 0, 1, 0);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

Check n numbers, each taking O(d) time to verify digit uniqueness where d is number of digits

✓ Linear Growth

Space Complexity

O(d)

Set to store digits of current number, at most d digits

✓ Linear Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler