1038EasyArrayHash TableRecursionSortingEnumeration

Three-Digit Even Numbers From the Tiles

Tracked in this browser only

Trains the technique from

LeetCode 2094Finding 3-Digit Even Numbers

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A tray holds tiles, each stamped with a single digit, given as tiles.

Form three-digit numbers by choosing three tiles and laying them out in some order. No tile may be used more often than the tray holds it, the number may not begin with a zero, and the number must be even.

Return every distinct number obtainable, in increasing order.

Examples

Example 1

Input: tiles = [1, 2, 4]
Output: [124, 142, 214, 412]

The three tiles must all be used. Of the six orders, only those ending on 2 or 4 are even, which gives four numbers.

Example 2

Input: tiles = [0, 0, 0]
Output: []

Every tile is a zero, so any three-tile number would begin with a zero.

Example 3

Input: tiles = [4, 4, 4]
Output: [444]

Three tiles all stamped 4, so the only number is 444, which is even and does not begin with a zero.

Constraints

3 <= tiles.length <= 100
0 <= tiles[i] <= 9

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def find_even_numbers(tiles: list[int]) -> list[int]:

Java

public int[] findEvenNumbers(int[] tiles)

The intended approach

Time O(n) for the tally, then a fixed amount of work.Space O(1) beyond the answer.

Which tile is which never matters, only how many of each digit the tray holds, so tally the ten digits in one pass. Then turn the question round and try the candidates rather than the tiles. Walk the numbers from one hundred up to nine hundred and ninety-eight in steps of two, which is exactly the three-digit even numbers with no leading zero and nothing else. For each candidate, count what its own three digits demand, a repeated digit counting as many times as it appears, and keep the candidate when the tray holds enough of every digit. There are only four hundred and fifty candidates whatever the tray, so past the tally the work is a fixed amount. The candidates are tried in increasing order, so the answer comes out sorted with no sorting step.

Pythonentry point: find_even_numbers

def find_even_numbers(tiles):
    tally = [0] * 10
    for digit in tiles:
        tally[digit] += 1
    out = []
    for value in range(100, 999, 2):
        need = [0] * 10
        need[value // 100] += 1
        need[value // 10 % 10] += 1
        need[value % 10] += 1
        ok = True
        for digit in range(10):
            if need[digit] > tally[digit]:
                ok = False
                break
        if ok:
            out.append(value)
    return out

The obvious version

Go at the tiles instead. Take every choice of three different positions in the tray, in every order, skip the ones starting on a zero or ending on an odd digit, and gather the numbers into a set to drop the repeats. Sorting the set at the end gives the answer. Costs the tray's size cubed rather than a fixed sweep of candidates.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_find_even_numbers(tiles):
    n = len(tiles)
    found = set()
    for i in range(n):
        if tiles[i] == 0:
            continue
        for j in range(n):
            if j == i:
                continue
            for k in range(n):
                if k == i or k == j:
                    continue
                if tiles[k] % 2:
                    continue
                found.add(tiles[i] * 100 + tiles[j] * 10 + tiles[k])
    return sorted(found)

How this problem was checked

Reference solution executed against 15 test cases — 15 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in