Finding 3-Digit Even Numbers

Finding 3-Digit Even Numbers - Problem

You are given an integer array digits, where each element is a digit. The array may contain duplicates.

You need to find all the unique integers that follow the given requirements:

The integer consists of the concatenation of three elements from digits in any arbitrary order.
The integer does not have leading zeros.
The integer is even.

For example, if the given digits were [1, 2, 3], integers 132 and 312 follow the requirements.

Return a sorted array of the unique integers.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: All valid 3-digit even numbers using digits from [2,1,3,0]: First digit cannot be 0, last digit must be even (0 or 2). Numbers like 102, 120, 130, etc. are formed and sorted.

Example 2 — Limited Even Digits

$ Input: digits = [2,7,4]

› Output: [274,472,724,742]

💡 Note: Even digits available: 2, 4. Valid combinations: 274, 472, 724, 742. All start with non-zero and end with even digit.

Example 3 — No Valid Numbers

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

› Output: []

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

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 20 M Microsoft 15

The key insight is that we need to form 3-digit even numbers with no leading zeros. A number is even if its last digit is 0, 2, 4, 6, or 8. The brute force approach tries all combinations, while the optimized version pre-filters even digits. Best approach generates all valid combinations in O(n³) time, using a set to handle duplicates. Space: O(k) where k is the number of unique valid numbers.

Common Approaches

✓ Brute Force - Triple Nested Loop

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

Use three nested loops to pick all possible combinations of digits from the array. For each combination, check if it forms a valid 3-digit even number (no leading zeros, even last digit).

Optimized - Direct Even Digit Check

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

First identify all even digits available, then systematically build 3-digit numbers by placing even digits in the units position and non-zero digits in hundreds position.

Brute Force - Triple Nested Loop — Algorithm Steps

Pick first digit (cannot be 0)
Pick second digit from remaining
Pick third digit (must be even) from remaining
Add valid numbers to result set
Return sorted unique numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick First Digit

Choose non-zero digit for hundreds place

Pick Second Digit

Choose any remaining digit for tens place

Pick Third Digit

Choose even digit for units place

Collect Results

Add valid numbers to set and sort

Code -

solution.c — C

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

static int results[100000];
static int resultCount = 0;

void addResult(int num) {
    // Check if already exists
    for (int i = 0; i < resultCount; i++) {
        if (results[i] == num) return;
    }
    results[resultCount++] = num;
}

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

void solution(int* digits, int n) {
    resultCount = 0;
    
    // Try all combinations of 3 digits (allowing reuse)
    for (int i = 0; i < n; i++) {
        if (digits[i] == 0) continue; // First digit cannot be 0
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                if (digits[k] % 2 == 0) { // Last digit must be even
                    int num = digits[i] * 100 + digits[j] * 10 + digits[k];
                    addResult(num);
                }
            }
        }
    }
    
    qsort(results, resultCount, sizeof(int), compare);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array [1,2,3] format
    int digits[100];
    int n = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* ptr = line + 1; // Skip '['
        while (*ptr && *ptr != ']') {
            if (*ptr >= '0' && *ptr <= '9') {
                digits[n++] = *ptr - '0';
            }
            ptr++;
        }
    }
    
    solution(digits, n);
    
    // Output as JSON array
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("%d", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially iterating through all n digits

⚠ Quadratic Growth

Space Complexity

O(k)

Set to store unique results, where k is number of valid combinations

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Triple Nested Loop — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler