Unique 3-Digit Even Numbers - Practice Coding Problems

Unique 3-Digit Even Numbers - Problem

Problem: You have a collection of digits, and you need to find how many distinct 3-digit even numbers you can form using them.

Rules:
• Each digit can only be used once per number
• No leading zeros allowed (numbers must be 100-999)
• The number must be even (last digit must be 0, 2, 4, 6, or 8)

Example: Given [2, 1, 3, 0], you can form: 102, 120, 130, 132, 210, 230, 302, 310, 312, 320 → 10 unique even numbers

Goal: Count all possible distinct 3-digit even numbers that can be formed.

Input & Output

example_1.py — Basic Case

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

› Output: 10

💡 Note: Possible even numbers: 102, 120, 130, 132, 210, 230, 302, 310, 312, 320. All digits 1-9 can be first digit (no leading zeros), any digit can be middle, and only even digits (0,2) can be last.

example_2.py — Duplicate Digits

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

› Output: 1

💡 Note: With three 2s and two 8s, we can form: 228, 282, 822, 288, 828, 882. However, only 228, 282, 822, 288, 828, 882 are valid... Wait, let me recalculate: we need 3 different positions. Possible: 228, 282, 822, 288, 828, 882. Actually the answer should be 6, but with uniqueness constraint, it's still 6 unique numbers.

example_3.py — Edge Case with Zero

$ Input: [0,2,0,0]

› Output: 0

💡 Note: No valid 3-digit even numbers can be formed because we only have 0 and 2, but we need a non-zero first digit. Since we only have one 2, we cannot form any valid 3-digit number.

Visualization

Tap to expand

Understanding the Visualization

Sort Your Stamps

Count how many of each digit (0-9) you have available

Choose First Digit

Pick from digits 1-9 only (no leading zeros allowed)

Choose Middle Digit

Pick from any remaining available digits (0-9)

Choose Last Digit

Pick from remaining even digits only (0,2,4,6,8)

Validate & Count

Ensure all chosen digits are available and add to result set

Key Takeaway

🎯 Key Insight: Instead of generating all permutations, we constrain our search by position requirements: first digit must be 1-9 (no leading zeros), last digit must be even (0,2,4,6,8), resulting in at most 9×10×5 = 450 combinations to check - a constant time solution!

Time & Space Complexity

Time Complexity

⏱️

O(1)

At most 10×10×5 = 500 combinations to check (digits 0-9, with constraints)

✓ Linear Growth

Space Complexity

O(1)

Fixed size frequency array for digits 0-9, result set bounded by max possible numbers

✓ Linear Space

Constraints

1 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9
Each element in digits represents a single digit
No leading zeros allowed in 3-digit numbers

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a hash table with position constraints to systematically enumerate valid 3-digit even numbers. By counting digit frequencies and then constraining choices by position (first: 1-9, middle: 0-9, last: even only), we achieve O(1) time complexity since there are at most 450 combinations to check.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n!)	O(n!)	Generate all possible 3-digit permutations and filter valid even numbers
Two-Pass Hash Table	O(1)	O(1)	First pass counts digits, second pass generates valid combinations
Hash Table with Position Constraints (Optimal)	O(1)	O(1)	Use frequency counting and systematic enumeration by position constraints

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of length 3 from the digit array
For each permutation, check if first digit is not 0
Check if last digit is even (0, 2, 4, 6, 8)
Add valid numbers to a set to ensure uniqueness
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Permutations

Create every possible 3-digit arrangement from available digits

Filter Invalid Cases

Remove numbers starting with 0 and odd numbers

Count Unique Results

Use a set to eliminate duplicates and count final results

Code -

solution.c — C

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

int countEvenNumbers(int* digits, int size) {
    int validNumbers[1000] = {0}; // Track unique numbers
    int count = 0;
    
    // Generate all 3-digit permutations
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (i == j) continue;
            for (int k = 0; k < size; k++) {
                if (k == i || k == j) continue;
                
                // Check constraints
                if (digits[i] != 0 && digits[k] % 2 == 0) {
                    int number = digits[i] * 100 + digits[j] * 10 + digits[k];
                    if (number >= 100 && number <= 999 && !validNumbers[number]) {
                        validNumbers[number] = 1;
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    int digits[100];
    int size = 0;
    char* token = strtok(input, "[],");
    
    while (token != NULL) {
        digits[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", countEvenNumbers(digits, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generating all permutations takes factorial time relative to array length

⚠ Quadratic Growth

Space Complexity

O(n!)

Need to store all permutations and unique results

⚠ Quadratic Space

Constraints

1 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9
Each element in digits represents a single digit
No leading zeros allowed in 3-digit numbers

26.7K Views

Medium Frequency

~15 min Avg. Time

892 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 (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler