Unique 3-Digit Even Numbers - Practice Coding Problems

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

Understanding the Visualization

Input

Array of digits [2,1,3,0]

Process

Find all 3-digit even combinations without leading zeros

Output

Count of unique valid numbers: 2

Key Takeaway

🎯 Key Insight: Focus on even last digits first, then count valid non-zero first digits and remaining middle digits systematically

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

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n³)	O(k)	Generate all possible 3-digit permutations and filter valid even numbers
Frequency Count with Enumeration	O(1)	O(1)	Count digit frequencies and systematically enumerate valid combinations

Generate All Permutations — Algorithm Steps

Generate all permutations of 3 digits
Filter out numbers with leading zeros
Filter out odd numbers
Remove duplicates and count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Try all combinations of 3 digits

Filter Valid

Keep only even numbers without leading zeros

Count Unique

Remove duplicates and count total

Code -

solution.c — C

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

int solution(int* digits, int n) {
    int validNumbers[1000000] = {0}; // Boolean array for uniqueness
    int count = 0;
    
    // Try all permutations of 3 digits
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                if (i != j && j != k && i != k) {  // Use each digit once
                    int first = digits[i];
                    int second = digits[j];
                    int third = digits[k];
                    
                    // Check if valid 3-digit even number
                    if (first != 0 && third % 2 == 0) {
                        int number = first * 100 + second * 10 + third;
                        if (!validNumbers[number]) {
                            validNumbers[number] = 1;
                            count++;
                        }
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int digits[100];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        digits[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(digits, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops to try all combinations of digits

⚠ Quadratic Growth

Space Complexity

O(k)

Set to store unique valid numbers, where k is count of valid numbers

✓ 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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler