Numbers At Most N Given Digit Set

Numbers At Most N Given Digit Set - Problem

Array Math String Binary Search Dynamic Programming Hard

Given an array of digits which is sorted in non-decreasing order. You can write numbers using each digits[i] as many times as we want.

For example, if digits = ['1','3','5'], we may write numbers such as '13', '551', and '1351315'.

Return the number of positive integers that can be generated that are less than or equal to a given integer n.

Input & Output

Example 1 — Basic Case

$ Input: digits = ["1","3","5"], n = 100

› Output: 12

💡 Note: 1-digit: 1,3,5 (count=3). 2-digit: 11,13,15,31,33,35,51,53,55 (count=9). 3-digit ≤ 100: none (smallest 3-digit number possible is 111 > 100). Total = 3+9 = 12

Example 2 — Single Digit

$ Input: digits = ["1","4","9"], n = 1000000000

› Output: 29523

💡 Note: Count systematically: 1-digit (3), 2-digit (9), 3-digit (27), ..., up to 9-digit numbers, plus valid 10-digit numbers ≤ 1000000000

Example 3 — Small Target

$ Input: digits = ["7"], n = 8

› Output: 1

💡 Note: Only digit 7 available. Only valid number ≤ 8 is 7 itself. Count = 1

Constraints

1 ≤ digits.length ≤ 9
digits[i].length == 1
digits[i] is a digit from '1' to '9'
All the values in digits are unique
digits is sorted in non-decreasing order
1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 A Amazon 8

The key insight is to count valid numbers mathematically without generating them. First count all numbers with fewer digits (using powers), then handle same-length numbers by comparing digit-by-digit. Best approach uses mathematical counting with Time: O(k), Space: O(1).

Common Approaches

✓ Brute Force Generation

⏱️ Time: O(d^k) Space: O(d^k)

Generate all possible numbers using the given digits by trying all combinations of different lengths, then count how many are less than or equal to n.

Mathematical Counting

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

Calculate the count directly using mathematical formulas. Count numbers with fewer digits separately, then handle same-length numbers by comparing digit-by-digit with n.

Recursive with Memoization

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

Build numbers digit by digit using recursion, with memoization to cache results for positions we've already computed. This avoids redundant calculations.

Brute Force Generation — Algorithm Steps

Generate all 1-digit numbers from digits
Generate all 2-digit numbers from digits
Continue until numbers exceed n
Count all valid numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate 1-digit

Create all single digit numbers

Generate 2-digit

Create all two digit combinations

Filter Valid

Count numbers ≤ n

Code -

solution.c — C

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

static char digits[10];
static int numDigits;
static char nStr[12];
static int nLen;

int countNumbers(int pos, int tight, int started) {
    if (pos == nLen) {
        return started;
    }

    int result = 0;

    // Option: skip this position (only if we haven't started)
    if (!started) {
        result += countNumbers(pos + 1, 0, 0);
    }

    // Try placing each digit
    for (int i = 0; i < numDigits; i++) {
        if (tight && digits[i] > nStr[pos]) {
            break; // digits are sorted, no point continuing
        }
        if (!started) {
            // Starting a new number - any digit works (digits are '1'-'9' per problem)
            int newTight = tight && (digits[i] == nStr[pos]);
            result += countNumbers(pos + 1, newTight, 1);
        } else {
            int newTight = tight && (digits[i] == nStr[pos]);
            result += countNumbers(pos + 1, newTight, 1);
        }
    }

    return result;
}

int solution(int n) {
    sprintf(nStr, "%d", n);
    nLen = strlen(nStr);
    return countNumbers(0, 1, 0);
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);

    numDigits = 0;
    char *ptr = line;
    while (*ptr) {
        if (*ptr >= '1' && *ptr <= '9') {
            digits[numDigits++] = *ptr;
        }
        ptr++;
    }

    int n;
    scanf("%d", &n);

    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d^k)

Where d is number of digits and k is number of digits in n - generates all possible combinations

✓ Linear Growth

Space Complexity

O(d^k)

Stores all generated numbers in memory

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

856 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 Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler