Unique 3-Digit Even Numbers

Unique 3-Digit Even Numbers - Problem

You are given an array of digits called digits. Your task is to determine the number of distinct three-digit even numbers that can be formed using these digits.

Note: Each copy of a digit can only be used once per number, and there may not be leading zeros.

Input & Output

Example 1 — Basic Case

$ Input: digits = [2,1,3,0]

› Output: 2

💡 Note: Can form: 210 (2×100+1×10+0), 230 (2×100+3×10+0). Both are even 3-digit numbers with no leading zeros.

Example 2 — Multiple Even Digits

$ Input: digits = [2,2,8,8,2]

› Output: 3

💡 Note: Can form: 228, 282, 822. All are distinct 3-digit even numbers using available digits.

Example 3 — No Valid Numbers

$ Input: digits = [3,7,5]

› Output: 0

💡 Note: All digits are odd, so no 3-digit even numbers can be formed.

Constraints

1 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to systematically enumerate valid 3-digit even numbers by fixing the last digit (must be even) and counting valid combinations for hundreds and tens places. The frequency count approach is optimal with O(1) time complexity since we only deal with digits 0-9.

Common Approaches

✓ Frequency Count with Enumeration

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

Count how many times each digit appears, then for each valid last digit (even), count possible combinations for hundreds and tens places.

Generate All Permutations

⏱️ Time: O(n³) Space: O(k)

Try all combinations of 3 digits from the array, check if they form valid even numbers (no leading zero, last digit even), and count unique results.

Frequency Count with Enumeration — Algorithm Steps

Count frequency of each digit
For each even digit as last position
Count valid hundreds place options (non-zero)
Count valid tens place options (remaining digits)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Track how many of each digit we have

Fix Last Digit

Choose even digit for units place

Count Valid Combinations

Calculate valid hundreds and tens combinations

Code -

solution.c — C

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

int solution(int* digits, int n) {
    // Count frequency of each digit
    int freq[10] = {0};
    for (int i = 0; i < n; i++) {
        freq[digits[i]]++;
    }
    
    int distinct_numbers[10000];
    int count = 0;
    
    // Try each even digit as the last digit
    int evenDigits[] = {0, 2, 4, 6, 8};
    for (int i = 0; i < 5; i++) {
        int last = evenDigits[i];
        if (freq[last] == 0) {
            continue;
        }
            
        // Use this digit as last
        freq[last]--;
        
        // Try each non-zero digit as first digit
        for (int first = 1; first < 10; first++) {
            if (freq[first] == 0) {
                continue;
            }
                
            // Use this digit as first
            freq[first]--;
            
            // Try each available digit as second digit
            for (int second = 0; second < 10; second++) {
                if (freq[second] == 0) {
                    continue;
                }
                    
                // Form the 3-digit number
                int number = first * 100 + second * 10 + last;
                
                // Check if number already exists
                int exists = 0;
                for (int j = 0; j < count; j++) {
                    if (distinct_numbers[j] == number) {
                        exists = 1;
                        break;
                    }
                }
                
                if (!exists) {
                    distinct_numbers[count++] = number;
                }
            }
            
            // Restore first digit
            freq[first]++;
        }
        
        // Restore last digit
        freq[last]++;
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int digits[100];
    int n;
    parseArray(line, digits, &n);
    
    int result = solution(digits, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed number of operations since we only have 10 possible digits (0-9)

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses frequency array of size 10 and a few variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 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

Frequency Count with Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler