Finding 3-Digit Even Numbers - Practice Coding Problems

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

Understanding the Visualization

Input Analysis

Given digits [2,1,3,0], identify constraints

Apply Rules

First digit ≠ 0, last digit must be even

Generate & Sort

Form all valid combinations and sort uniquely

Key Takeaway

🎯 Key Insight: A 3-digit number is valid if it doesn't start with 0 and ends with an even digit (0,2,4,6,8)

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

Approach	Time	Space	Notes
✓ Brute Force - Triple Nested Loop	O(n³)	O(k)	Try all possible combinations of three digits from the array
Optimized - Direct Even Digit Check	O(n³)	O(k)	Filter for even digits first, then generate combinations more efficiently

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>

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

int* solution(int* digits, int digitsSize, int* returnSize) {
    int* tempResult = (int*)malloc(1000 * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < digitsSize; i++) {
        if (digits[i] == 0) continue; // First digit cannot be 0
        for (int j = 0; j < digitsSize; j++) {
            if (i == j) continue;
            for (int k = 0; k < digitsSize; k++) {
                if (k == i || k == j) continue;
                if (digits[k] % 2 == 0) { // Last digit must be even
                    int num = digits[i] * 100 + digits[j] * 10 + digits[k];
                    
                    // Check if already exists
                    int exists = 0;
                    for (int l = 0; l < count; l++) {
                        if (tempResult[l] == num) {
                            exists = 1;
                            break;
                        }
                    }
                    if (!exists) {
                        tempResult[count++] = num;
                    }
                }
            }
        }
    }
    
    qsort(tempResult, count, sizeof(int), compare);
    *returnSize = count;
    return tempResult;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse digits array
    int digits[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        digits[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(digits, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    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