diff --git a/bintree.c b/bintree.c
index 29588cd..7239d27 100644
--- a/bintree.c
+++ b/bintree.c
@@ -51,7 +51,6 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
     return root;
 }
 
-
 // Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction.
 // Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
 // push the top node and push all its left nodes.
@@ -90,7 +89,6 @@ void *nextTreeData(TreeNode *root) {
     return node->data;
 }
 
-
 // Releases all memory resources (including data copies).
 void clearTree(TreeNode *root) {
     if (root == NULL)
diff --git a/doble.exe b/doble.exe
new file mode 100644
index 0000000..f8de930
Binary files /dev/null and b/doble.exe differ
diff --git a/highscores.txt b/highscores.txt
index b871699..3fe3727 100644
--- a/highscores.txt
+++ b/highscores.txt
@@ -4,5 +4,6 @@ player_name;9929
 Kamto;7946
 player_name;5987
 Warren;4986
+player_name;4983
 player1;3999
 player_name;2991
diff --git a/numbers.c b/numbers.c
index 179dcf9..bde8485 100644
--- a/numbers.c
+++ b/numbers.c
@@ -14,14 +14,72 @@
 // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
-unsigned int *createNumbers(unsigned int len)
-{
-  srand(0);
-  int r = rand();
+unsigned int *createNumbers(unsigned int len) {
+    if (len < 2)
+      return NULL;
+
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+    if (!numbers)
+      return NULL;
+
+    srand((unsigned int)time(NULL));
+
+    for (unsigned int i = 0; i < len - 1; i++) {
+        unsigned int n;
+        int duplicate;
+        do {
+            duplicate = 0;
+            n = rand() % (2 * len) + 1;
+
+            for (unsigned int j = 0; j < i; j++) {
+                if (numbers[j] == n) {
+                    duplicate = 1;
+                    break;
+                }
+            }
+        } while (duplicate);
+
+        numbers[i] = n;
+    }
+
+    // zufälliges Duplikat am Ende
+    unsigned int idx1 = rand() % (len - 1);
+    numbers[len - 1] = numbers[idx1];
+
+    return numbers;
 }
 
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
-unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
-{
 
-}
\ No newline at end of file
+// Returns only the only number in numbers which is present twice. Returns zero on errors.
+unsigned int getDuplicate(const unsigned int numbers[], unsigned int len) {
+    if (!numbers || len < 2) return 0;
+
+    // Kopie erstellen, damit Original nicht verändert wird
+    unsigned int *copy = malloc(len * sizeof(unsigned int));
+    if (!copy) return 0;
+    memcpy(copy, numbers, len * sizeof(unsigned int));
+
+    // Einfacher Bubble Sort oder Insert Sort direkt in dieser Funktion
+    // damit wir keine Hilfsfunktionen brauchen
+    for (unsigned int i = 0; i < len - 1; i++) {
+        for (unsigned int j = 0; j < len - i - 1; j++) {
+            if (copy[j] > copy[j + 1]) {
+                unsigned int tmp = copy[j];
+                copy[j] = copy[j + 1];
+                copy[j + 1] = tmp;
+            }
+        }
+    }
+
+    // benachbarte Elemente vergleichen
+    for (unsigned int i = 0; i < len - 1; i++) {
+        if (copy[i] == copy[i + 1]) {
+            unsigned int dup = copy[i];
+            free(copy);
+            return dup;
+        }
+    }
+
+    free(copy);
+    return 0;
+}
diff --git a/test_numbers.c b/test_numbers.c
new file mode 100644
index 0000000..bb1b14a
--- /dev/null
+++ b/test_numbers.c
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "numbers.h"
+
+int main() {
+    unsigned int len = 10; // Beispielgröße
+    unsigned int *numbers = createNumbers(len);
+
+    if (!numbers) {
+        printf("Fehler: Konnte Zahlen nicht erzeugen.\n");
+        return 1;
+    }
+
+    // 1 Test: Alle Zahlen ausgeben
+    printf("Erzeugtes Array:\n");
+    for (unsigned int i = 0; i < len; i++) {
+        printf("%u ", numbers[i]);
+    }
+    printf("\n");
+
+    // 2 Test: Prüfen, ob genau ein Duplikat vorhanden ist
+    unsigned int duplicate = getDuplicate(numbers, len);
+    if (duplicate == 0) {
+        printf("Fehler: Kein Duplikat gefunden.\n");
+    } else {
+        printf("Gefundenes Duplikat: %u\n", duplicate);
+    }
+
+    // 3 Test: Prüfen, ob nur ein Duplikat existiert
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < len; i++) {
+        if (numbers[i] == duplicate)
+            count++;
+    }
+    if (count == 2) {
+        printf("Test bestanden: Genau ein Duplikat vorhanden.\n");
+    } else {
+        printf("Test fehlgeschlagen: Duplikatanzahl = %u\n", count);
+    }
+
+    // Speicher freigeben
+    free(numbers);
+
+    return 0;
+}
diff --git a/test_numbers.exe b/test_numbers.exe
new file mode 100644
index 0000000..f648461
Binary files /dev/null and b/test_numbers.exe differ