Finding 3-Digit Even Numbers - Practice Coding Problems

Finding 3-Digit Even Numbers - Problem

You have a collection of digit tiles, where each tile contains a single digit (0-9). Your task is to create 3-digit even numbers using exactly three tiles from your collection.

Goal: Find all unique 3-digit even numbers that can be formed by selecting and arranging three digits from your collection.

Rules:

Each number must be exactly 3 digits long
No leading zeros allowed (must be between 100-999)
The number must be even (last digit is 0, 2, 4, 6, or 8)
You can use the same digit multiple times if it appears multiple times in your collection

Example: With digits [1, 2, 3], you can form 132 and 312 (both are 3-digit even numbers), but not 123 (odd) or 021 (leading zero).

Return the results in sorted ascending order with no duplicates.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3]

› Output: [132, 312]

💡 Note: From digits [1,2,3], we can form two 3-digit even numbers: 132 (ends with 2) and 312 (ends with 2). Numbers like 123 are invalid (odd), and 321 is invalid (odd).

example_2.py — With Duplicates

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

› Output: [102, 120, 130, 132, 210, 230, 302, 310, 312, 320]

💡 Note: With digits [2,1,3,0], we can form various even numbers. Note that 102 is valid (even, no leading zero), but 012 would be invalid (leading zero). The 0 can be used in tens or units position.

example_3.py — Multiple Same Digits

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

› Output: [222, 228, 282, 288, 822, 828, 882]

💡 Note: With three 2's and two 8's, we can create numbers like 222 (uses all three 2's), 228 (uses two 2's and one 8), etc. All results must be even and have no leading zeros.

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

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

Choose Hundreds

Select a non-zero digit for the first position (1-9 only)

Choose Tens

Pick any available digit for the middle position (0-9)

Choose Units

Select an even digit for the last position (0,2,4,6,8)

Validate Coins

Ensure we have enough digit coins for repeated digits

Key Takeaway

🎯 Key Insight: Instead of generating all permutations, we systematically build valid numbers by enforcing constraints at each position, making the algorithm much more efficient with O(1) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Since we iterate through at most 9×10×5 = 450 combinations (constant), this is O(1)

✓ Linear Growth

Space Complexity

O(1)

Frequency array is fixed size 10, result size is bounded by 450 maximum valid numbers

✓ Linear Space

Constraints

3 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9
Each element in digits is a single digit (0-9)
The array may contain duplicate digits
Return results in sorted ascending order

Asked in

G Google 12 a Amazon 8 Apple 6 ⊞ Microsoft 4

The optimal approach uses a frequency counter to systematically enumerate all valid 3-digit even numbers. By counting digit frequencies and checking reuse constraints, we avoid generating invalid permutations and achieve O(1) time complexity since we iterate through at most 450 fixed combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n³)	O(k)	Generate all possible 3-digit permutations and filter valid ones
Frequency Counter (Optimal)	O(1)	O(1)	Use digit frequency counting for systematic enumeration

Generate All Permutations — Algorithm Steps

Count frequency of each digit in the input array
Use three nested loops to try all possible first, second, and third digit combinations
Check if combination is valid: first digit ≠ 0, last digit is even, digits are available
Add valid numbers to result set to avoid duplicates
Sort and return the unique results

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Digits

Count frequency of each available digit

Choose First

Select non-zero digits for first position

Choose Second

Select any available digit for middle position

Choose Third

Select even digits for last position

Validate & Store

Add valid combinations to result set

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* findNumbers(int* digits, int digitSize, int* returnSize) {
    int freq[10] = {0};
    for (int i = 0; i < digitSize; i++) {
        freq[digits[i]]++;
    }
    
    int* result = (int*)malloc(1000 * sizeof(int));
    int count = 0;
    
    for (int first = 1; first <= 9; first++) {
        if (freq[first] == 0) continue;
        freq[first]--;
        
        for (int second = 0; second <= 9; second++) {
            if (freq[second] == 0) continue;
            freq[second]--;
            
            for (int third = 0; third <= 9; third += 2) {
                if (freq[third] == 0) continue;
                
                int number = first * 100 + second * 10 + third;
                result[count++] = number;
            }
            
            freq[second]++;
        }
        freq[first]++;
    }
    
    qsort(result, count, sizeof(int), compare);
    *returnSize = count;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially iterating through all available digits

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of valid results (at most 900 for all possible 3-digit numbers)

✓ Linear Space

Constraints

3 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9
Each element in digits is a single digit (0-9)
The array may contain duplicate digits
Return results in sorted ascending order

26.8K 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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler