Skip to main content
Talentd

Finding 3-Digit Even Numbers - Solution & Explanation

EasyArrayHash TableSortingEnumeration15 min readAsked at: Amazon, Microsoft, Meta +2
Practice this problem

Problem Statement

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.

 

Example 1:

Input: digits = [2,1,3,0]
Output: [102,120,130,132,210,230,302,310,312,320]
Explanation: All the possible integers that follow the requirements are in the output array. 
Notice that there are no odd integers or integers with leading zeros.

Example 2:

Input: digits = [2,2,8,8,2]
Output: [222,228,282,288,822,828,882]
Explanation: The same digit can be used as many times as it appears in digits. 
In this example, the digit 8 is used twice each time in 288, 828, and 882.

Example 3:

Input: digits = [3,7,5]
Output: []
Explanation: No even integers can be formed using the given digits.

 

Constraints:

  • 3 <= digits.length <= 100
  • 0 <= digits[i] <= 9

Approach Overview

Problem Overview: You receive an array of digits (0–9). Use these digits to construct all unique 3-digit even numbers. Each digit can only be used as many times as it appears in the array. The result must contain every valid number exactly once and be returned in sorted order.

Approach 1: Using a Hash Map (Digit Frequency) (Time: O(450 * 10) ≈ O(1), Space: O(10))

Create a frequency map of digits using a small array or hash table. Then enumerate every possible 3-digit even number from 100 to 998. For each candidate number, extract the hundreds, tens, and units digits. The key check: verify the units digit is even and ensure the digit frequency in the candidate does not exceed the available frequency in the input map. This works because there are only 450 possible 3-digit even numbers, so enumeration is effectively constant time. The approach relies on fast frequency comparison rather than generating permutations, which avoids duplicate work.

Use this method when the domain of valid numbers is small and bounded. Instead of exploring combinations from the array, you validate candidates against available digits. This pattern appears frequently in hash table and array counting problems.

Approach 2: Sorting and Linear Enumeration (Time: O(n^3), Space: O(1) extra)

Sort the digits first. Then iterate over all triples of indices i, j, and k to form numbers using three distinct positions. Skip invalid combinations early: the first digit cannot be 0, and the last digit must be even. Sorting allows easy duplicate control because identical digits appear next to each other, so you can skip repeated combinations during iteration. Construct the number as 100*a + 10*b + c and store unique results.

This approach directly generates candidate numbers from the input digits rather than validating against a fixed range. Sorting simplifies duplicate handling and is a common pattern in sorting-based enumeration problems. It is slightly slower asymptotically but still efficient since the input size is small (digits length ≤ 10).

Recommended for interviews: The hash map enumeration approach is usually preferred. It demonstrates awareness of constraints and converts the problem into constant-size validation rather than combinatorial generation. Interviewers appreciate recognizing the small search space (only 3-digit even numbers). The sorting + enumeration method still shows solid reasoning about duplicates and index usage, so it remains a good fallback when the range-based insight does not immediately come to mind.

Approach 1: Approach 1: Using a Hash Map

This approach revolves around using a hash map (or dictionary in Python) to keep track of the elements we have encountered so far. The primary idea is to utilize the hash map's average O(1) time complexity for insertion and lookup to solve the problem efficiently.

This C implementation uses separate chaining to handle hash collisions. The hashTable is an array of linked lists (represented by Node structures). The program inserts each unique element from the input array into the hash table and prints unique elements.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(n) for both insertion and lookup in the average case.
Space Complexity: O(n) for storing the elements.

Try this approach in the editor →

Approach 2: Approach 2: Sorting and Linear Pass

This approach involves first sorting the array and then performing a linear pass to ensure uniqueness. By sorting, duplicate elements appear consecutively, making it easy to skip them during the final pass.

The C solution first sorts the array using qsort and then iterates through the sorted array. Only elements different from their predecessors are printed, achieving uniqueness.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(n log n) due to sorting.
Space Complexity: O(1) additional space if in-place sorting is feasible.

Try this approach in the editor →

Approach 3: Counting + Enumeration

First, we count the occurrence of each digit in digits, recording it in an array or hash table cnt.

Then, we enumerate all even numbers in the range [100, 1000), checking if each digit of the even number does not exceed the corresponding digit's count in cnt. If so, we add this even number to the answer array.

Finally, we return the answer array.

The time complexity is O(k times 10^k), where k is the number of digits of the target even number, which is 3 in this problem. Ignoring the space consumed by the answer, the space complexity is O(1).

Code

PythonJavaC++GoTypeScriptJavaScript

Python

Java

C++

Go

TypeScript

JavaScript

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Approach 1: Using a Hash Map

Time Complexity: O(n) for both insertion and lookup in the average case.
Space Complexity: O(n) for storing the elements.

Approach 2: Sorting and Linear Pass

Time Complexity: O(n log n) due to sorting.
Space Complexity: O(1) additional space if in-place sorting is feasible.

Counting + Enumeration—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Hash Map Frequency + Enumerate 3-digit Even NumbersO(450 * 10) ≈ O(1)O(10)Best when the possible result range is small and fixed
Sorting + Triple EnumerationO(n^3)O(1)Useful when generating combinations directly from digits

Video Solution

Finding 3-Digit Even Numbers | 2 Simple Approaches | Leetcode 2094 | codestorywithMIK • codestorywithMIK • 10,467 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Finding 3-Digit Even Numbers easy or hard?
Finding 3-Digit Even Numbers is classified as an Easy problem. The core idea involves simple digit checks, enumeration, and optional use of a hash map for frequency counting.
Finding 3-Digit Even Numbers Python/Java solution
Implementations typically build a frequency map from the input digits, then iterate through all 3-digit even numbers and validate digit usage. This approach is straightforward to implement in Python, Java, C++, C#, and JavaScript using arrays or hash maps.
How to solve Finding 3-Digit Even Numbers in O(n)?
A practical solution close to O(n) builds a digit frequency map in O(n) time, then validates each possible 3-digit even number using constant-time frequency checks. Because the candidate range is fixed (100–998 with even last digit), the overall runtime behaves like O(n).
What is the best approach for Finding 3-Digit Even Numbers?
The most efficient approach uses a hash map (or frequency array) to count digits and then enumerates all 3-digit even numbers from 100 to 998. For each candidate, verify that the digit counts do not exceed the available frequencies. Since only 450 numbers need checking, the time complexity is effectively O(1).
Is Finding 3-Digit Even Numbers asked at Google/Amazon/Meta?
Problems involving digit construction, frequency counting, and enumeration patterns appear in interviews at companies like Amazon, Google, and Meta. Variants often test hash map usage, permutation constraints, and handling duplicates efficiently.
What data structure is used in Finding 3-Digit Even Numbers?
The main data structure is a hash map or fixed-size frequency array that stores counts for digits 0–9. This allows quick validation that a candidate number does not use any digit more times than available in the input array.
What is the time complexity of Finding 3-Digit Even Numbers?
The hash map enumeration solution runs in O(1) time because it checks a fixed set of 450 possible 3-digit even numbers. The alternative sorting and triple-loop enumeration approach runs in O(n^3) time, where n is the number of digits in the input array (typically ≤10).

Ready to solve this problem?

Practice Finding 3-Digit Even Numbers with our built-in code editor and test cases.

Practice on FleetCode
Previous

Find Numbers with Even Number of Digits

Next

Unique 3-Digit Even Numbers