Count Numbers with Unique Digits

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 is repeated in the number. For example, 123 has unique digits but 121 does not.

Input & Output

Example 1 — Small Case

$ Input: n = 2

› Output: 91

💡 Note: Count all numbers from 0 to 99 with unique digits: single digits (0-9) = 10, two-digits with unique digits (10,12,13,...,98) = 81. Total = 10 + 81 = 91

Example 2 — Minimal Case

$ Input: n = 0

› Output: 1

💡 Note: Range is [0, 1), so only number 0 exists, which has unique digits

Example 3 — Larger Case

$ Input: n = 3

› Output: 739

💡 Note: Numbers 0 to 999: 1-digit = 10, 2-digit = 81, 3-digit = 648. Total = 10 + 81 + 648 = 739

Constraints

0 ≤ n ≤ 8

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18

The key insight is to use mathematical permutations instead of checking every number. For k-digit numbers, the first digit has 9 choices (1-9), and each subsequent digit has one fewer choice from the remaining unused digits. Best approach uses mathematical formula with Time: O(n), Space: O(1).

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(10!) Space: O(n)

Generate all valid numbers by placing digits one by one, using a boolean array to track used digits. Prune branches early when digits are exhausted.

Brute Force Check Every Number

⏱️ Time: O(10^n × n) Space: O(n)

Generate all numbers in the range and check if each has unique digits by converting to string and using a set to detect duplicates.

Mathematical Permutation

⏱️ Time: O(n) Space: O(1)

Use combinatorics to directly calculate how many numbers with unique digits exist for each length, then sum them up. For k-digit numbers, first digit has 9 choices (1-9), remaining digits have decreasing choices.

Backtracking with Pruning — Algorithm Steps

Start with empty number
Try each available digit at current position
Recursively build remaining positions
Count complete valid numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First

Pick first digit from 1-9 (can't be 0)

Choose Next

Pick remaining digits from unused set

Count & Backtrack

Count valid numbers, backtrack when done

Code -

solution.c — C

#include <stdio.h>

int countUniqueDigitsWithLength(int length) {
    if (length == 1) {
        return 10; // 0, 1, 2, ..., 9
    }
    
    // For multi-digit numbers
    // First digit: 1-9 (9 choices)
    // Remaining digits: can't repeat any used digits
    int result = 9;
    for (int i = 1; i < length; i++) {
        result *= (10 - i);
    }
    return result;
}

int solution(int n) {
    if (n == 0) return 1;
    
    int total = 0;
    for (int length = 1; length <= n; length++) {
        total += countUniqueDigitsWithLength(length);
    }
    
    return total;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(10!)

At most 10 factorial permutations to explore

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and used digits array

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler