Count Numbers With Unique Digits II - Practice Coding Problems

Count Numbers With Unique Digits II - Problem

Given two positive integers a and b, your task is to count how many numbers in the range [a, b] (inclusive) have unique digits. A number has unique digits if no digit appears more than once in its decimal representation.

For example, the number 123 has unique digits because each digit (1, 2, 3) appears only once. However, 1223 does not have unique digits because the digit 2 appears twice.

Goal: Return the count of numbers with unique digits in the given range.

Input: Two positive integers a and b where a ≤ b
Output: An integer representing the count of numbers with unique digits in range [a, b]

Input & Output

example_1.py — Basic Range

$ Input: a = 1, b = 20

› Output: 19

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

example_2.py — Small Range

$ Input: a = 80, b = 120

› Output: 27

💡 Note: In range [80,120], numbers like 88, 99, 100, 110, 111, etc. have repeated digits. Only numbers with all unique digits are counted.

example_3.py — Single Number

$ Input: a = 123, b = 123

› Output: 1

💡 Note: Only checking number 123, which has digits 1, 2, 3 - all unique, so count is 1.

Constraints

1 ≤ a ≤ b ≤ 10⁸
The range [a, b] will contain at most 10⁶ numbers
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Number Processing

Each number passes through our digit scanner

Digit Extraction

Scanner extracts each digit one by one

Duplicate Detection

Boolean array tracks which digits we've seen

Immediate Rejection

If duplicate found, reject immediately

Count Valid

Only numbers with unique digits pass through

Key Takeaway

🎯 Key Insight: Using a boolean array to track seen digits allows O(1) duplicate detection per digit, making the algorithm efficient while processing each number in the range.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 Apple 22

The optimal approach uses boolean array tracking to efficiently check digit uniqueness. For each number, we mathematically extract digits using modulo operations and track seen digits in a boolean array. This avoids string conversion overhead while maintaining O(n×d) time complexity where n is range size and d is average digits per number.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Digit Checking	O(n * d)	O(1)	Use bit manipulation or boolean array for faster digit uniqueness checking
Brute Force (Check Each Number)	O(n * d)	O(d)	Iterate through each number in range and check if all digits are unique

Optimized Digit Checking — Algorithm Steps

For each number in range, extract digits mathematically
Use boolean array of size 10 to track seen digits
For each digit, check if already seen
If duplicate found, mark as invalid and continue to next number
Count numbers with all unique digits

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create boolean array for digits 0-9

Extract Digits

Use modulo and division to get each digit

Check & Mark

Check if digit seen, mark as seen if not

Early Exit

Break immediately if duplicate found

Count Valid

Increment counter for numbers with unique digits

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int countNumbersWithUniqueDigits(int a, int b) {
    int count = 0;
    
    for (int num = a; num <= b; num++) {
        bool seen[10] = {false};
        int temp = num;
        bool unique = true;
        
        while (temp > 0) {
            int digit = temp % 10;
            if (seen[digit]) {
                unique = false;
                break;
            }
            seen[digit] = true;
            temp /= 10;
        }
        
        if (unique) count++;
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

n is range size, d is digits per number, but with better constants

✓ Linear Growth

Space Complexity

O(1)

Fixed size boolean array of 10 elements for digits 0-9

✓ Linear Space

42.6K Views

Medium Frequency

~15 min Avg. Time

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

Optimized Digit Checking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler