Numbers With Repeated Digits - Practice Coding Problems

Numbers With Repeated Digits - Problem

Given an integer n, you need to find how many positive integers in the range [1, n] contain at least one repeated digit.

For example, the number 1223 has repeated digits (the digit '2' appears twice), while 1234 has all unique digits.

Goal: Count all numbers from 1 to n that have duplicate digits.
Input: A positive integer n
Output: The count of numbers with at least one repeated digit

Note: This is a challenging combinatorics problem that can be solved by calculating the complement - finding numbers with all unique digits and subtracting from the total.

Input & Output

example_1.py — Small Number

$ Input: n = 20

› Output: 1

💡 Note: Only number 11 has repeated digits in range [1,20]. Numbers 1-10 and 12-20 all have unique digits.

example_2.py — Larger Number

$ Input: n = 100

› Output: 10

💡 Note: Numbers with repeated digits: 11, 22, 33, 44, 55, 66, 77, 88, 99, 100. Total = 10 numbers.

example_3.py — Edge Case

$ Input: n = 1000

› Output: 262

💡 Note: Many numbers have repeated digits: all numbers like 11, 22, ..., 99, 100, 101, 110, 111, 112, etc. The mathematical approach counts unique digits and subtracts.

Visualization

Tap to expand

Understanding the Visualization

The Problem

Count how many license plates from 1 to n have duplicate digits (invalid plates)

Brute Force Method

Check each plate individually - very slow for large n

Smart Method

Count valid plates (unique digits) using math, then subtract from total

Mathematical Magic

Use permutations: P(10,k) ways to arrange k unique digits from 0-9

Key Takeaway

🎯 Key Insight: Rather than checking each number for duplicates, we use the complement principle - count numbers with unique digits using permutation mathematics, then subtract from the total. This transforms an O(n) problem into O(log n)!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We only process each digit position of n once, so time is proportional to number of digits in n

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for calculations, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer
The answer fits in a 32-bit signed integer

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses mathematical combinatorics instead of checking each number individually. We count numbers with unique digits using permutation formulas, then subtract from the total. This reduces time complexity from O(n) to O(log n), making it feasible for large inputs up to 10⁹.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Number)	O(n * d)	O(d)	Check every number from 1 to n for duplicate digits
Mathematical Combinatorics (Optimal)	O(log n)	O(1)	Count numbers with unique digits using permutations, then subtract from total

Brute Force (Check Each Number) — Algorithm Steps

Iterate through all numbers from 1 to n
For each number, convert to string or extract digits
Use a set or frequency map to detect duplicate digits
Count numbers that have at least one duplicate digit

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n=20

We need to check numbers 1 through 20

Check number 11

Convert 11 to digits: [1,1] - found duplicate!

Check number 12

Convert 12 to digits: [1,2] - no duplicates

Continue checking

Keep checking each number until we reach 20

Code -

solution.c — C

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

bool hasDuplicateDigits(int num) {
    char digits[12];
    sprintf(digits, "%d", num);
    int len = strlen(digits);
    
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j < len; j++) {
            if (digits[i] == digits[j]) {
                return true;
            }
        }
    }
    return false;
}

int numDupDigitsAtMostN(int n) {
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (hasDuplicateDigits(i)) {
            count++;
        }
    }
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

We check n numbers, and for each number we process d digits (where d is the number of digits in n)

✓ Linear Growth

Space Complexity

O(d)

We use a set to store digits of current number, which can have at most d digits

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer
The answer fits in a 32-bit signed integer

41.2K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force (Check Each Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler