357. Count Numbers with Unique Digits – Leetcode Solutions

Example 1:

Input: n = 2
Output: 91
Explanation: The answer should be the total numbers in the range of 0 ≤ x < 100, excluding 11,22,33,44,55,66,77,88,99

Example 2:

Input: n = 0
Output: 1

class Solution:
    def countNumbersWithUniqueDigits(self, n: int) -> int:
        # If n is 0, the only number is 0, so the result is 1
        if n == 0:
            return 1

        # Initialize the total count of unique numbers
        total_count = 10  # For n = 1, we have 10 numbers (0-9)
        
        # Variable to keep track of the unique digits calculation
        unique_digits = 9  # For the first digit, we have 9 options (1-9, excluding 0)
        available_digits = 9  # For subsequent digits, we have decreasing available digits
        
        # Loop through each digit length from 2 to n
        for i in range(2, n + 1):
            unique_digits *= available_digits  # Multiply the unique digits by available options
            total_count += unique_digits  # Add the number of unique-digit numbers for i digits
            available_digits -= 1  # Decrease the available digits for the next position
        
        return total_count

class Solution {
public:
    int countNumbersWithUniqueDigits(int n) {
        // If n is 0, the only number is 0, so return 1
        if (n == 0) return 1;
        
        // Start with 10 because for n = 1, the numbers are from 0 to 9 (inclusive)
        int uniqueCount = 10;
        int availableDigits = 9;  // To keep track of remaining digits to use
        int currentMultiplier = 9; // To select digits for places
        
        // For each n > 1, calculate the number of unique digit numbers
        for (int i = 2; i <= n && availableDigits > 0; ++i) {
            currentMultiplier *= availableDigits;
            uniqueCount += currentMultiplier;
            --availableDigits;
        }
        
        return uniqueCount;
    }
};

var countNumbersWithUniqueDigits = function(n) {
    // Base case: if n is 0, the only number is 0 itself, so return 1.
    if (n === 0) {
        return 1;
    }

    // Initialize the result with the count of single-digit numbers (0 to 9).
    let result = 10; // For n = 1, there are 10 unique numbers (0-9).

    // Variable to keep track of the current count of unique digit numbers.
    let uniqueDigits = 9;  // For the first non-zero digit, we can choose 9 (1-9).
    let availableDigits = 9; // After picking the first digit, we have 9 digits left to choose.

    // Loop through the remaining digit places (from 2 digits up to n digits).
    for (let i = 2; i <= n; i++) {
        // Multiply the number of choices for this place by the remaining available digits.
        uniqueDigits = uniqueDigits * availableDigits;

        // Add the unique numbers with i digits to the result.
        result += uniqueDigits;

        // Decrease available digits for the next place.
        availableDigits--;
    }

    return result;
};

class Solution {
    public int countNumbersWithUniqueDigits(int n) {
        // Base case: if n is 0, there is only one number which is 0
        if (n == 0) return 1;
        
        // Start with 10 because for n = 1 (0 <= x < 10), all digits are unique (0 to 9)
        int result = 10;
        
        // The count of unique digit numbers for numbers with more than 1 digit.
        int uniqueDigits = 9;  // The first digit can only be from 1 to 9 (9 choices)
        int availableDigits = 9; // For the remaining digits (after the first), 0-9 except the used one
        
        // Iterate from 2 to n to calculate for numbers with more digits
        for (int i = 2; i <= n; i++) {
            uniqueDigits *= availableDigits;  // Multiply by the number of available digits left
            result += uniqueDigits;  // Add to result
            availableDigits--;  // Reduce the number of available digits for the next iteration
        }
        
        return result;  // Return the final result
    }
}