3483. Unique 3-Digit Even Numbers
Difficulty: Easy | Published on 2026-09-11
Let's teach this one from absolute zero, same structure as before. Good news: this problem's input is tiny (INLINECODE0 is at most 10), so we can lean on a very direct brute-force approach and it'll be plenty fast — but we'll still build up the reasoning carefully.
1. Problem in Very Simple Language
You're given a small list of single digits, INLINECODE1 (each between 0 and 9). Some digits might repeat in the list (like INLINECODE2, which has two INLINECODE3s).
You want to build 3-digit numbers by picking three of these digits and arranging them in some order, following two rules:
No leading zero — the very first digit of your 3-digit number can't be INLINECODE4 (otherwise it wouldn't really be a 3-digit number, e.g., INLINECODE5 is really just INLINECODE6, a 2-digit number). Must be even — the last digit of your number must be even (INLINECODE7 or INLINECODE8), since a number is even exactly when its last digit is even.
You can only use each copy of a digit once per number. So if INLINECODE9, you have two separate INLINECODE10s available (you could use both of them in the same number, like INLINECODE11), but you couldn't use a INLINECODE12 a third time, since only two copies exist.
Goal: count how many distinct (different-looking) 3-digit even numbers can be formed this way.
What's given: an array of digits (with possible repeats). What to find: how many different 3-digit even numbers can be built, respecting the no-leading-zero and "use each copy at most once" rules. What to return: that count.
2. Real-Life Analogy
Imagine you have a small pile of numbered tiles — say, tiles showing INLINECODE13. You want to lay out exactly three of these tiles in a row to form a 3-digit number. Two rules apply: you can't start the row with a INLINECODE14 tile (that would look silly, like a phone number starting with a blank), and the last tile in the row must show an even digit (so the whole number reads as even). If your pile has two tiles that look identical (like two INLINECODE15s), you're allowed to use both of them in the same row — but you can never use more copies of a tile than you physically have in your pile. You want to know: how many genuinely different-looking 3-tile rows can you form this way?
3. Important Programming Concepts I Need First
Array
Concept: A numbered list of values. Example: INLINECODE16 — a list of 4 single-digit numbers. Why we need it: Our input is exactly this kind of list.Set (for tracking distinct results)
Concept: A collection that automatically ignores duplicate entries — adding the same value twice has no extra effect; the size of the set tells you how many distinct values it holds. Example: Adding INLINECODE17, then INLINECODE18 again, then INLINECODE19 to a set leaves it with just INLINECODE20 — size 2, not 3. Why we need it: Different choices of which digit copies we use might still produce the exact same-looking 3-digit number — a INLINECODE21 naturally handles this deduplication for us.Nested loops (trying every combination of positions)
Concept: To try "every possible choice for the first digit, and for each of those, every possible choice for the second digit, and for each of those, every possible choice for the third digit," we nest three loops inside each other. Why we need it: With INLINECODE22 at most 10, trying every ordered triple of distinct positions (not distinct values — positions!) is only up to INLINECODE23 combinations at most — completely fast enough to brute-force directly.Using positions (indices), not just values, to respect "copies"
Concept: Since a digit might repeat in the array (like two INLINECODE24s at, say, index 1 and index 2), we must be careful to select three different positions in the array (never reusing the same position twice), even if two different positions happen to hold the same value. Why we need it: This is exactly how the problem's "each copy used once" rule gets enforced correctly — by picking distinct array indices, not by trying to track "how many 2's have I used" separately.Building a number from its digits
Concept: If you have three digits INLINECODE25 (hundreds place), INLINECODE26 (tens place), INLINECODE27 (ones place), the actual number they form is INLINECODE28. Example: digits INLINECODE29 in that order → INLINECODE30. Why we need it: Once we've picked three positions (in some order), we need to convert that ordered triple of digit-values into the actual 3-digit number.4. Understand the Input
Take Example 2: CODEBLOCK0
Index 0 holds INLINECODE31, index 1 holds INLINECODE32, index 2 holds INLINECODE33. Even though the values INLINECODE34 and INLINECODE35 look identical, they live at two genuinely different positions (index 1 and index 2) — so we're allowed to use "the INLINECODE36 at index 1" and "the INLINECODE37 at index 2" together in the same number, since that only uses each position once. We want: distinct 3-digit even numbers, using exactly 3 of these positions (all of them, actually, since there are only 3 total), with no leading zero and an even last digit.
5. Understand the Output
Output: INLINECODE38
Let's think about which arrangements of INLINECODE39 (using each position exactly once, since there are exactly 3 positions and we need exactly 3 digits) give valid, distinct 3-digit even numbers. Arrangement INLINECODE40 → number INLINECODE41 → invalid, leading zero. Arrangement INLINECODE42 → number INLINECODE43 → valid! Leading digit INLINECODE44 (fine), last digit INLINECODE45 (even, fine). Arrangement INLINECODE46 → number INLINECODE47 → valid! Leading digit INLINECODE48 (fine), last digit INLINECODE49 (even, fine). Distinct valid numbers found: INLINECODE50 → count = 2. ✔️ matches!
6. Solve the Example Manually
Let's manually work through Example 1: INLINECODE51 (all distinct values, 4 positions total).
Since we need exactly 3 digits out of these 4 available positions, and order matters, let's reason smartly using our two rules:
Rule for the last digit (must be even): Out of INLINECODE52, only INLINECODE53 and INLINECODE54 are even. So the last digit of our number must be either INLINECODE55 or INLINECODE56.
Rule for the first digit (can't be 0): None of INLINECODE57 are INLINECODE58 anyway, so this rule doesn't eliminate anything here — any of the 4 digits is fine as a leading digit.
Case A: last digit = 2. Remaining available digits: INLINECODE59. Ordered pairs for first two positions: INLINECODE60 → INLINECODE61 (6 numbers). Case B: last digit = 4. Remaining available digits: INLINECODE62. Ordered pairs for first two positions: INLINECODE63 → INLINECODE64 (6 numbers).
Total: 6 + 6 = 12 distinct numbers. ✔️ matches!
7. Think Like a Programmer
What do I know? I have up to 10 digit positions; I need to pick 3 distinct positions, arrange them in an order, and check two simple rules. What do I need to find? How many distinct-looking valid 3-digit numbers can result. What can I try? Try every possible ordered choice of 3 distinct positions (three nested loops, each picking a different index), build the resulting number, check the two validity rules, and if valid, add it to a INLINECODE65 (which automatically handles deduplication). What happens if I try every possibility? With at most 10 positions, trying every ordered triple of distinct positions is at most INLINECODE66 combinations — trivially fast for any computer. What information should I remember? A INLINECODE67 to collect every valid number we form, so duplicates are automatically only counted once. What pattern do I notice? Enumerate all valid arrangements of a small set of positions, filter by simple rules, deduplicate results using a hash set.
8. Start With the Brute Force Solution
Brute force idea: Use three nested loops, each iterating over all indices of INLINECODE68, to try every possible ordered triple of distinct indices INLINECODE69. For each such triple, form the number INLINECODE70, and if it satisfies "first digit isn't 0" and "last digit is even," add it to a INLINECODE71. At the end, return the set's size.
CODEBLOCK1
CODEBLOCK2
9. Explain the Brute Force Code Line by Line
INLINECODE72 — total number of available digit positions. INLINECODE73 — will collect every distinct valid number we successfully form. The three nested INLINECODE74 loops (INLINECODE75, INLINECODE76, INLINECODE77) — each ranges over all valid array indices (INLINECODE78 to INLINECODE79), attempting to try every possible ordered assignment of positions. INLINECODE80 — skip this combination if INLINECODE81 is the same position as INLINECODE82. INLINECODE83 — skip if INLINECODE84 collides with either INLINECODE85 or INLINECODE86. INLINECODE87 — read out the actual digit values at these three chosen positions. INLINECODE88 — enforce the "no leading zero" rule. INLINECODE89 — enforce the "must be even" rule. INLINECODE90 — compute the actual 3-digit integer. INLINECODE91 — record the number; duplicate values are automatically ignored. INLINECODE92 — return the count of distinct numbers formed.
10. Why Might We Want to Understand This More Deeply?
With INLINECODE93, the enumeration takes at most 720 iterations. The INLINECODE94 does critical work when duplicate values exist at different indices.
11. When Do Duplicate-Looking Numbers Arise?
Duplicate-looking numbers arise when the array contains repeated values at different positions (e.g., INLINECODE95). There are $3 \times 2 \times 1 = 6$ index permutations: INLINECODE96. All 6 permutations evaluate to INLINECODE97. Without a INLINECODE98, a plain counter would return INLINECODE99 (wrong). With a INLINECODE100, only INLINECODE101 unique number INLINECODE102 is kept (correct).
⭐ Key Insight
Before the insight
It might seem like we should count the number of valid index permutations directly.The problem
That counts arrangements of indices, not distinct-looking numbers. Repeated digits cause severe overcounting.The insight
The problem asks for distinct numbers, not distinct position choices. Enumerate index triples to respect physical tile counts, construct the number, and insert into a INLINECODE103 for automatic deduplication.After the insight
No complex combinatorial formulas or exclusion-inclusion logic needed — brute force with a Set is simple, foolproof, and takes under 1 ms.13. Dry Run the Solution
Let's dry-run Example 4: INLINECODE104. All values are odd. The check INLINECODE105 skips every single combination. INLINECODE106. ✔️ Output = INLINECODE107.
14. Optimized Code
CODEBLOCK3
CODEBLOCK4
15. Explain the Code Line by Line
See Section 9 for complete line-by-line documentation.
16. Test With Multiple Examples
Example 1 — Normal Case
INLINECODE108 → Output: INLINECODE109 ✔️Example 2 — Different Case
INLINECODE110 → Output: INLINECODE111 (INLINECODE112, INLINECODE113) ✔️Example 3 — All identical values
INLINECODE114 → Output: INLINECODE115 (INLINECODE116) ✔️Example 4 — No even digits
INLINECODE117 → Output: INLINECODE118 ✔️17. Edge Cases
All digits odd: Output INLINECODE119. All digits identical: Output INLINECODE120 if valid even 3-digit number, otherwise INLINECODE121. Array contains 0: INLINECODE122 cannot be leading, but is valid in tens/ones place. $N = 3$ (minimum size): Exactly 6 permutations evaluated. $N = 10$ (maximum size): Up to 720 combinations evaluated instantly.
18. Time Complexity
Time Complexity: $O(N^3)$ where $N \le 10$, yielding at most 720 iterations — executes in microseconds ($O(1)$ effectively).
19. Space Complexity
Space Complexity: $O(1)$ auxiliary space — at most 900 unique 3-digit integers (100 to 999) can be stored in the hash set.
20. Common Mistakes Beginners Make
❌ "Tracking values used instead of array indices." ✅ You must track distinct index positions to allow using multiple copies of identical digits. ❌ "Using a counter instead of a Set." ✅ Repeated digit values cause different index triplets to yield identical numbers. ❌ "Disallowing 0 in middle or last positions." ✅ INLINECODE123 is only forbidden as the leading hundreds digit; INLINECODE124 and INLINECODE125 are valid.
21. How to Recognize This Pattern in Other Problems
Watch for: CODEBLOCK5 When $N \le 15$, exhaustive permutation search with a Hash Set is optimal, clear, and bug-resistant.
22. Interview Thinking
CODEBLOCK6
23. Mini Challenge
Try these before checking the answers:
1. Why do we check INLINECODE126 and INLINECODE127 separately instead of INLINECODE128? 2. If INLINECODE129, how many index triples pass checks, and what is the final set size? 3. Why does the order of checking INLINECODE130 vs INLINECODE131 not matter?
Answer to Mini Challenge
1. INLINECODE132 would miss partial collisions like INLINECODE133 (reusing index $i$ twice). 2. All 24 index permutations produce INLINECODE134; the final set size is INLINECODE135. 3. Both checks are independent filter conditions; their evaluation order does not affect the outcome.
24. Final Revision
🧠 Problem in One Sentence
Count the distinct 3-digit even numbers (no leading zero) formable by arranging 3 distinct positions from the given digit array.🔑 Main Idea
Enumerate all pairwise-distinct index triplets INLINECODE136, validate INLINECODE137 and INLINECODE138, and collect valid values in a INLINECODE139.⚙️ Algorithm
1. Loop $i$ from $0$ to $n-1$, $j$ from $0$ to $n-1$ ($j \ne i$), $k$ from $0$ to $n-1$ ($k \ne i, k \ne j$). 2. Check INLINECODE140 and INLINECODE141. 3. Compute INLINECODE142 and insert into INLINECODE143. 4. Return INLINECODE144.⏱️ Complexity
Time: $O(N^3)$ Space: $O(1)$25. Beginner Quiz
1. (Understanding) Why must we select distinct array positions rather than checking values? 2. (Basic concept) Why is a INLINECODE145 required instead of an incrementing integer counter? 3. (Logic) Why does INLINECODE146 always yield INLINECODE147? 4. (Dry run) For INLINECODE148, list the valid permutations and find the final count. 5. (Complexity/pattern) Why is $O(N^3)$ optimal for $N \le 10$?