Finding 3-Digit Even Numbers solution and explanation

def print_unique_elements(array):
    seen = set()
    for element in array:
        if element not in seen:
            seen.add(element)
            print(element, end=' ')

array = [5, 8, 2, 5, 9]
print_unique_elements(array)

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        int[] array = {5, 8, 2, 5, 9};
        for (int element : array) {
            if (set.add(element)) {
                System.out.print(element + " ");
            }
        }
    }
}

#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> set;
    int array[] = {5, 8, 2, 5, 9};
    int n = sizeof(array) / sizeof(array[0]);
    for (int i = 0; i < n; ++i) {
        if (set.insert(array[i]).second) {
            std::cout << array[i] << " ";
        }
    }
    return 0;
}

function printUniqueElements(array) {
    const set = new Set();
    array.forEach(element => {
        if (!set.has(element)) {
            set.add(element);
            process.stdout.write(element + ' ');
        }
    });
}

const array = [5, 8, 2, 5, 9];
printUniqueElements(array);

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TABLE_SIZE 1000

typedef struct Node {
    int key;
    struct Node* next;
} Node;

Node* hashTable[TABLE_SIZE];

unsigned int hashFunction(int key) {
    return key % TABLE_SIZE;
}

bool search(int key) {
    unsigned int hashIndex = hashFunction(key);
    Node* node = hashTable[hashIndex];
    while (node != NULL) {
        if (node->key == key) return true;
        node = node->next;
    }
    return false;
}

void insert(int key) {
    unsigned int hashIndex = hashFunction(key);
    Node* newNode = (Node*) malloc(sizeof(Node));
    newNode->key = key;
    newNode->next = hashTable[hashIndex];
    hashTable[hashIndex] = newNode;
}

int main() {
    int array[] = {5, 8, 2, 5, 9};
    int n = sizeof(array) / sizeof(array[0]);
    for (int i = 0; i < n; i++) {
        if (!search(array[i])) {
            insert(array[i]);
            printf("%d ", array[i]);
        }
    }
    return 0;
}

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        HashSet<int> set = new HashSet<int>();
        int[] array = {5, 8, 2, 5, 9};
        foreach (var element in array) {
            if (set.Add(element)) {
                Console.Write(element + " ");
            }
        }
    }
}

def print_unique_sorted(array):
    array.sort()
    print(array[0], end=' ')
    for i in range(1, len(array)):
        if array[i] != array[i - 1]:
            print(array[i], end=' ')

array = [5, 2, 9, 8, 2]
print_unique_sorted(array)

import java.util.Arrays;

public class Main {
    public static void printUniqueSorted(int[] array) {
        Arrays.sort(array);
        System.out.print(array[0] + " ");
        for (int i = 1; i < array.length; i++) {
            if (array[i] != array[i - 1]) {
                System.out.print(array[i] + " ");
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {5, 2, 9, 8, 2};
        printUniqueSorted(array);
    }
}

#include <iostream>
#include <algorithm>

void printUniqueSorted(int array[], int size) {
    std::sort(array, array + size);
    std::cout << array[0] << " ";
    for (int i = 1; i < size; ++i) {
        if (array[i] != array[i - 1]) {
            std::cout << array[i] << " ";
        }
    }
}

int main() {
    int array[] = {5, 2, 9, 8, 2};
    int size = sizeof(array) / sizeof(array[0]);
    printUniqueSorted(array, size);
    return 0;
}

function printUniqueSorted(array) {
    array.sort((a, b) => a - b);
    process.stdout.write(array[0] + ' ');
    for (let i = 1; i < array.length; i++) {
        if (array[i] !== array[i - 1]) {
            process.stdout.write(array[i] + ' ');
        }
    }
}

const array = [5, 2, 9, 8, 2];
printUniqueSorted(array);

#include <stdio.h>
#include <stdlib.h>

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

void printUniqueSorted(int *array, int size) {
    qsort(array, size, sizeof(int), compare);
    printf("%d ", array[0]);
    for (int i = 1; i < size; i++) {
        if (array[i] != array[i - 1]) {
            printf("%d ", array[i]);
        }
    }
    printf("\n");
}

int main() {
    int array[] = {5, 2, 9, 8, 2};
    int size = sizeof(array) / sizeof(array[0]);
    printUniqueSorted(array, size);
    return 0;
}

using System;

class Program {
    static void PrintUniqueSorted(int[] array) {
        Array.Sort(array);
        Console.Write(array[0] + " ");
        for (int i = 1; i < array.Length; i++) {
            if (array[i] != array[i - 1]) {
                Console.Write(array[i] + " ");
            }
        }
    }

    static void Main() {
        int[] array = {5, 2, 9, 8, 2};
        PrintUniqueSorted(array);
    }
}

function findEvenNumbers(digits: number[]): number[] {
    const cnt: number[] = Array(10).fill(0);
    for (const x of digits) {
        ++cnt[x];
    }
    const ans: number[] = [];
    for (let x = 100; x < 1000; x += 2) {
        const cnt1: number[] = Array(10).fill(0);
        for (let y = x; y; y = Math.floor(y / 10)) {
            ++cnt1[y % 10];
        }
        let ok = true;
        for (let i = 0; i < 10 && ok; ++i) {
            ok = cnt[i] >= cnt1[i];
        }
        if (ok) {
            ans.push(x);
        }
    }
    return ans;
}

func findEvenNumbers(digits []int) (ans []int) {
	cnt := [10]int{}
	for _, x := range digits {
		cnt[x]++
	}
	for x := 100; x < 1000; x += 2 {
		cnt1 := [10]int{}
		for y := x; y > 0; y /= 10 {
			cnt1[y%10]++
		}
		ok := true
		for i := 0; i < 10 && ok; i++ {
			ok = cnt[i] >= cnt1[i]
		}
		if ok {
			ans = append(ans, x)
		}
	}
	return
}