Merge branch 'main' of https://git.efi.th-nuernberg.de/gitea/turtschinba100320/info2Praktikum-DobleSpielBastiBjoern

makefile

@@ -32,18 +32,23 @@ doble : main.o $(program_obj_files)
 $(program_obj_filesobj_files): %.o: %.c
 	$(CC) -c $(FLAGS) $^ -o $@
 
+numbers.o: numbers.c
+	$(CC) -c $(CFLAGS) numbers.c
+
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+
+
+numbersTests: numbers.o numbersTests.c $(unityfolder)/unity.c
+	$(CC) $(CFLAGS) -I$(unityfolder) -o runNumbersTests numbersTests.c numbers.o $(unityfolder)/unity.c
 
 # --------------------------
 # Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble
+	del /f *.o doble *.exe
 else
-	rm -f *.o doble
+	rm -f *.o doble *runNumbersTests
 endif

numbers.c

@@ -2,8 +2,8 @@
 #include <stdio.h>
 #include <time.h>
 #include <string.h>
+#include <stdbool.h>
 #include "numbers.h"
-#include "bintree.h"
 
 //TODO: getDuplicate und createNumbers implementieren
 /*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
@@ -16,11 +16,83 @@
 // creating random numbers.
 unsigned int *createNumbers(unsigned int len)
 {
+    if (len < 2) {
+        // Mindestens zwei Elemente nötig, damit ein Duplikat existiert
+        return NULL;
+    }
 
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+    if (!numbers) return NULL;
+
+    bool *used = calloc(2 * len + 1, sizeof(bool));
+    if (!used) {
+        free(numbers);
+        return NULL;
+    }
+
+    static int initialized = 0;
+    if (!initialized) {
+        srand((unsigned int)time(NULL));
+        initialized = 1;
+    }
+
+    // Einzigartige Zufallszahlen generieren
+    for (unsigned int i = 0; i < len - 1; ) {
+        unsigned int num = (rand() % (2 * len)) + 1;
+        if (!used[num]) {
+            used[num] = true;
+            numbers[i++] = num;
+        }
+    }
+
+    // Eine der Zahlen duplizieren
+    unsigned int duplicateIndex = rand() % (len - 1);
+    numbers[len - 1] = numbers[duplicateIndex];
+
+    // Fisher–Yates shuffle
+    for (unsigned int i = len - 1; i > 0; i--) {
+        unsigned int j = rand() % (i + 1);
+        unsigned int tmp = numbers[i];
+        numbers[i] = numbers[j];
+        numbers[j] = tmp;
+    }
+
+    free(used);
+    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)
 {
+    if (numbers == NULL || len < 2) {
+        return 0;
+    }
 
+    unsigned int *sortedNumbers = malloc(len * sizeof(unsigned int));
+    if (sortedNumbers == NULL) {
+        return 0;
+    }
+    memcpy(sortedNumbers, numbers, len * sizeof(unsigned int));
+
+    // Einfacher bubble sort
+    for (unsigned int i = 0; i < len - 1; i++) {
+        for (unsigned int j = 0; j < len - i - 1; j++) {
+            if (sortedNumbers[j] > sortedNumbers[j + 1]) {
+                unsigned int temp = sortedNumbers[j];
+                sortedNumbers[j] = sortedNumbers[j + 1];
+                sortedNumbers[j + 1] = temp;
+            }
+        }
+    }
+
+    unsigned int duplicate = 0;
+    for (unsigned int i = 0; i < len - 1; i++) {
+        if (sortedNumbers[i] == sortedNumbers[i + 1]) {
+            duplicate = sortedNumbers[i];
+            break;
+        }
+    }
+
+    free(sortedNumbers);
+    return duplicate;
 }

numbersTests.c

@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "numbers.h"
+#include "unity.h"
+
+//Initialisierung
+void setUp(void){}
+void tearDown(void){}
+
+// Hilfsfunktion: zählt Vorkommen eines Werts
+static unsigned int countOccurrences(unsigned int* arr, unsigned int n, unsigned int value)
+{
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < n; i++)
+        if (arr[i] == value)
+            count++;
+    return count;
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: createNumbers erzeugt ein Array der richtigen Größe
+// ---------------------------------------------------------------------------
+void test_createNumbers_returns_valid_array(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Ein paar Werte prüfen (dürfen alles sein, nur kein Segfault)
+    for (unsigned int i = 0; i < n; i++)
+        TEST_ASSERT_TRUE(arr[i] >= 0);
+
+    free(arr);
+}
+
+// ---------------------------------------------------------------------------
+// Test 2: createNumbers erzeugt GENAU EIN Duplikat
+// ---------------------------------------------------------------------------
+void test_createNumbers_contains_exactly_one_duplicate(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // zähle wie viele Werte doppelt vorkommen
+    unsigned int duplicateValue = 0;
+    unsigned int totalDuplicateAppearances = 0;
+
+    for (unsigned int i = 0; i < n; i++)
+    {
+        unsigned int c = countOccurrences(arr, n, arr[i]);
+        if (c == 2)   // genau zweimal → Bestandteil des Duplikats
+        {
+            duplicateValue = arr[i];
+            totalDuplicateAppearances++;
+        }
+    }
+
+    // Wenn genau eine Zahl doppelt vorkommt,
+    // finden wir sie zweimal → totalDuplicateAppearances == 2
+    TEST_ASSERT_EQUAL_UINT(2, totalDuplicateAppearances);
+
+    free(arr);
+}
+// ---------------------------------------------------------------------------
+// Test 3: getDuplicated findet genau die richtige doppelte Zahl
+// ---------------------------------------------------------------------------
+void test_getDuplicated_finds_correct_duplicate(void)
+{
+    unsigned int n = 50;
+    unsigned int* arr = createNumbers(n);
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Ermittle das Duplikat manuell
+    unsigned int expected = 0;
+
+    for (unsigned int i = 0; i < n; i++)
+    {
+        if (countOccurrences(arr, n, arr[i]) == 2)
+        {
+            expected = arr[i];
+            break;
+        }
+    }
+
+    unsigned int result = getDuplicate(arr, n);
+
+    TEST_ASSERT_EQUAL_UINT(expected, result);
+
+    free(arr);
+}
+
+// ---------------------------------------------------------------------------
+// main() für Unity
+// ---------------------------------------------------------------------------
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_returns_valid_array);
+    RUN_TEST(test_createNumbers_contains_exactly_one_duplicate);
+    RUN_TEST(test_getDuplicated_finds_correct_duplicate);
+
+    return UNITY_END();
+}

stack.c

@@ -10,7 +10,10 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-
+    StackNode *top = malloc(sizeof(StackNode));
+    top->next= stack;
+    top->data= data;
+    return top;
 }
 
 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be

stack.h

@@ -8,6 +8,11 @@ The latest element is taken from the stack. */
 #include <stdlib.h>
 
 //TODO: passenden Datentyp als struct anlegen
+typedef struct StackNode
+{
+    void *data;
+    struct StackNode *next;
+}StackNode;
 
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data);