Unique 3-Digit Even Numbers

• Initialize a HashSet<Integer> to store the unique numbers found.
• Use three nested loops, with indices i, j, and k, to iterate through all combinations of three positions in the digits array.
• Inside the innermost loop, check if the indices i, j, and k are all distinct. If not, continue to the next iteration.
• If the indices are distinct, retrieve the digits: d1 = digits[i], d2 = digits[j], d3 = digits[k].
• Validate the formed number:
  • The first digit d1 must not be 0 (to avoid numbers less than 100).
  • The last digit d3 must be even (d3 % 2 == 0).
• If both conditions are met, form the number num = d1 * 100 + d2 * 10 + d3 and add it to the HashSet.
• After the loops complete, convert the set to an array and sort it to get the final result.

The core idea is to exhaustively check every permutation of three digits from the input array. We can implement this using three nested loops that iterate from 0 to n-1, where n is the length of the digits array. The loop variables i, j, and k represent the indices of the digits we pick.

To ensure that we use each digit at most once per number, we must verify that the indices i, j, and k are all different from each other. Once we have three distinct digits, digits[i], digits[j], and digits[k], we check if they can form a valid 3-digit even number. The conditions are:

1. digits[i] (the hundreds digit) cannot be zero.
2. digits[k] (the units digit) must be an even number.

If these conditions are satisfied, we construct the number and add it to a HashSet. The set automatically handles duplicates that might arise from different permutations of identical digits (e.g., if digits = [2, 1, 2], both (2,1,2) and (2,1,2) using different '2's would form 212, but the set stores it only once). Finally, the contents of the set are converted into a sorted integer array.

1import java.util.*;2 3class Solution {4    public int[] findEvenNumbers(int[] digits) {5        Set<Integer> uniqueNumbers = new HashSet<>();6        int n = digits.length;7 8        for (int i = 0; i < n; i++) {9            for (int j = 0; j < n; j++) {10                for (int k = 0; k < n; k++) {11                    // Ensure we are using digits from three different positions12                    if (i == j || j == k || i == k) {13                        continue;14                    }15 16                    int d1 = digits[i]; // Hundreds digit17                    int d2 = digits[j]; // Tens digit18                    int d3 = digits[k]; // Units digit19 20                    // Check for leading zero21                    if (d1 == 0) {22                        continue;23                    }24 25                    // Check if the number is even26                    if (d3 % 2 != 0) {27                        continue;28                    }29 30                    int number = d1 * 100 + d2 * 10 + d3;31                    uniqueNumbers.add(number);32                }33            }34        }35 36        // Convert set to sorted array37        int[] result = new int[uniqueNumbers.size()];38        int index = 0;39        for (int num : uniqueNumbers) {40            result[index++] = num;41        }42        Arrays.sort(result);43        return result;44    }45}

• Create a frequency map (an integer array of size 10) called digitCounts to store the counts of each digit in the input digits array.
• Initialize an empty list, resultList, to store the valid numbers.
• Iterate through all possible 3-digit even numbers. This can be done with a loop from num = 100 to 998 with a step of 2.
• For each num in the loop:
  • Extract its three digits: d1 (hundreds), d2 (tens), and d3 (units).
  • Create a frequency map for the digits of num, let's call it requiredCounts.
  • Check if num can be formed by comparing requiredCounts with digitCounts. For every digit from 0 to 9, the required count must be less than or equal to the available count (requiredCounts[d] <= digitCounts[d]).
  • If the number can be formed, add it to resultList.
• Since the loop iterates in increasing order, resultList will be sorted. Convert it to an integer array and return.

This method works by first creating a frequency count of the available digits from the input array. An array of size 10, digitCounts, is ideal for this, where digitCounts[i] stores how many times digit i appears.

Next, we iterate through every even integer from 100 to 998. For each number in this range, we check if we have the necessary digits to form it. To do this, we determine the digits required for the current number. For example, the number 552 requires two '5's and one '2'.

We then compare the required digit counts with our available digitCounts. If for every digit (0-9), the count required is less than or equal to the count available, the number is valid and can be formed. We add such valid numbers to a result list.

Because we iterate through the candidate numbers in ascending order (100, 102, 104, ...), the final list of valid numbers will naturally be sorted. This eliminates the need for a separate sorting step.

1import java.util.*;2 3class Solution {4    public int[] findEvenNumbers(int[] digits) {5        int[] digitCounts = new int[10];6        for (int digit : digits) {7            digitCounts[digit]++;8        }9 10        List<Integer> resultList = new ArrayList<>();11        for (int num = 100; num <= 998; num += 2) {12            int d1 = num / 100;13            int d2 = (num / 10) % 10;14            int d3 = num % 10;15 16            int[] requiredCounts = new int[10];17            requiredCounts[d1]++;18            requiredCounts[d2]++;19            requiredCounts[d3]++;20 21            boolean possible = true;22            for (int i = 0; i < 10; i++) {23                if (requiredCounts[i] > digitCounts[i]) {24                    possible = false;25                    break;26                }27            }28 29            if (possible) {30                resultList.add(num);31            }32        }33 34        // Convert list to array35        int[] result = new int[resultList.size()];36        for (int i = 0; i < resultList.size(); i++) {37            result[i] = resultList.get(i);38        }39        return result;40    }41}