Count Numbers with Unique Digits - Practice Coding Problems

Count Numbers with Unique Digits - Problem

Given an integer n, return the count of all numbers with unique digits, x, where 0 ≤ x < 10ⁿ.

A number has unique digits if no digit appears more than once. For example, 123 has unique digits, but 112 does not because the digit 1 appears twice.

Examples:

When n = 2, we need to count numbers from 0 to 99 with unique digits
Numbers like 0, 1, 2, ..., 9, 10, 12, 13, ..., 98 are valid (unique digits)
Numbers like 11, 22, 33, 44, 55, 66, 77, 88, 99 are invalid (repeated digits)

This problem combines combinatorics and dynamic programming concepts to efficiently count valid numbers without generating them all.

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 91

💡 Note: For n=2, we count numbers 0-99. Single digits (0-9): 10 numbers. Two-digit numbers with unique digits: 9×9=81 (first digit 1-9, second digit can be 0-9 except first). Total: 10 + 81 = 91.

example_2.py — Minimum Case

$ Input: n = 0

› Output: 1

💡 Note: For n=0, the range is [0, 10^0) = [0, 1), which contains only the number 0. Since 0 has unique digits (trivially), the answer is 1.

example_3.py — Edge Case

$ Input: n = 1

› Output: 10

💡 Note: For n=1, we count numbers 0-9. All single-digit numbers have unique digits by definition. So the answer is 10.

Visualization

Tap to expand

Understanding the Visualization

Count by length

Separate plates by number of digits (1-digit, 2-digit, etc.)

Apply constraints

First position: 9 choices (1-9), can't start with 0

Permutation math

Each subsequent position has one fewer choice

Sum all cases

Add up valid combinations for all digit lengths

Key Takeaway

🎯 Key Insight: Mathematical counting using permutations is exponentially faster than brute force generation and checking.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We calculate the result for each digit length from 1 to n, each taking O(1) time

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store intermediate calculations

✓ Linear Space

Constraints

0 ≤ n ≤ 8
For n > 10, the answer would be the same as n = 10 since we only have 10 unique digits (0-9)
Note: The maximum meaningful value is n = 10

Asked in

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

The optimal solution uses combinatorial mathematics instead of brute force checking. For each digit length k, calculate valid combinations using permutation formulas: first digit has 9 choices (1-9), subsequent digits have decreasing choices (9, 8, 7, ...). Sum results for all lengths from 1 to n. Time complexity: O(n) vs brute force O(n × 10^n).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical/Combinatorial Approach	O(n)	O(1)	Use permutation mathematics to count valid numbers directly without generating them

Mathematical/Combinatorial Approach — Algorithm Steps

Handle special case: n=0 returns 1 (only number 0)
Start with single-digit numbers: 10 valid numbers (0-9)
For each length k from 2 to n: calculate valid k-digit numbers
First digit: 9 choices (1-9, can't start with 0)
Remaining digits: 9×8×7×...×(11-k) choices (permutations)
Sum all lengths to get total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Single digits

Count 0-9: 10 numbers

Two digits

9 × 9 = 81 combinations

Three digits

9 × 9 × 8 = 648 combinations

Sum all lengths

Add results for all digit lengths

Code -

solution.c — C

#include <stdio.h>

int countNumbersWithUniqueDigits(int n) {
    if (n == 0) return 1;
    
    // All single digit numbers have unique digits (0-9)
    int result = 10;
    
    // For each length k from 2 to n
    for (int k = 2; k <= n; k++) {
        // First digit: 9 choices (1-9, can't be 0)
        int countForLengthK = 9;
        int availableDigits = 9;
        
        // Calculate permutations for remaining positions
        for (int i = 1; i < k; i++) {
            countForLengthK *= availableDigits;
            availableDigits--;
        }
        
        result += countForLengthK;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We calculate the result for each digit length from 1 to n, each taking O(1) time

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store intermediate calculations

✓ Linear Space

Constraints

0 ≤ n ≤ 8
For n > 10, the answer would be the same as n = 10 since we only have 10 unique digits (0-9)
Note: The maximum meaningful value is n = 10

28.4K Views

Medium Frequency

~15 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

Mathematical/Combinatorial Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler