Merge branch 'main' into Stack

I2_Dobble/number.md

@@ -0,0 +1,27 @@
+*createNumbers: 
+
+-> check if len is greater than 2
+-> create new array numbers, use malloc and check if correct
+-> set seed for rand()
+-> create new TreeNode root
+-> add new value to tree using addToTree and rand()
+-> addToTree sets isDup to 1, if value already exists
+-> if value does not already exist -> add to numbers[]
+-> 
+
+
+getDublicate:
+
+-> numbers (Zeiger != NULL) und len (min. 2) check
+-> define new array numbersCopy
+-> copy numbers to numbersCopy 
+    -> simple loop to copy each element number -> numbersCopy
+-> sort numbersCopy with qsort
+-> compare each element of numbersCopy with next element (if numbersCopy[i] == numbersCopy[i+1] -> dublicate was found, because same values are right next to each other)
+-> return found dublicate
+
+compare:
+
+-> gibt 1 aus, wenn a größer ist
+-> gibt -1 aus, wenn b größer ist
+-> gibt 0 aus wenn a==b

I2_Dobble/numbers.c

@@ -14,13 +14,74 @@
 // 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.
+static int compare(const void *a, const void *b) 
+{
+    return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b);
+}
+
 unsigned int *createNumbers(unsigned int len)
 {
+    if (len < 2) 
+        return NULL;
 
+    unsigned int *numbers = malloc(sizeof(unsigned int) * len);
+
+    if (!numbers) 
+        return NULL;
+
+    srand(time(NULL));
+
+    TreeNode *root = NULL;
+
+    unsigned int i = 0;
+    while (i < len - 1) 
+    {
+        unsigned int val = (rand() % (2 * len)) + 1;
+        int isDup = 0;
+
+        root = addToTree(root, &val, sizeof(unsigned int), compare, &isDup);
+
+        if (!isDup) 
+        {
+            numbers[i++] = val;
+        }
+    }
+
+    // Duplicate one random entry
+    unsigned int dupIndex = rand() % (len - 1);
+    numbers[len - 1] = numbers[dupIndex];
+
+    clearTree(root); //Notwendigkeit muss noch restlichem Code entnommen werden
+    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 || len < 2) 
+        return 0;
 
+    unsigned int *numbersCopy = malloc(sizeof(unsigned int) * len);
+    if (!numbersCopy) 
+        return 0;
+
+    for (unsigned int i = 0; i < len; i++) 
+    {
+        numbersCopy[i] = numbers[i];
+    }
+
+    qsort(numbersCopy, len, sizeof(unsigned int), compare);
+
+    unsigned int duplicate = 0;
+    for (unsigned int i = 0; i < len - 1; i++) 
+    {
+        if (numbersCopy[i] == numbersCopy[i+1]) 
+        {
+            duplicate = numbersCopy[i];
+            break;
+        }
+    }
+
+    free(numbersCopy);
+    return duplicate;
 }

I2_Dobble/numbersTest.c

@@ -0,0 +1,89 @@
+#include "numbers.h"
+#include "unity.h"
+#include "unity_internals.h"
+
+void test_createNumbers_no_null(void) 
+{
+    unsigned int *arr = createNumbers(10);
+    TEST_ASSERT_NOT_NULL(arr);
+    free(arr);
+}
+
+void test_createNumbers_has_exactly_one_duplicate(void) 
+{
+    unsigned int len = 100;
+    unsigned int *arr = createNumbers(len);
+    TEST_ASSERT_NOT_NULL(arr);
+
+    unsigned int dup = getDuplicate(arr, len);
+    TEST_ASSERT_NOT_EQUAL(0, dup);
+
+    int count = 0;
+    for (unsigned int i = 0; i < len; i++) 
+    {
+        if (arr[i] == dup) 
+            count++;
+    }
+    
+    TEST_ASSERT_EQUAL(2, count);
+
+    free(arr);
+}
+
+void test_createNumbers_has_correct_value_range(void)
+{
+    unsigned int len = 10;
+    unsigned int *arr = createNumbers(len);
+    TEST_ASSERT_NOT_NULL(arr);
+
+    // Check all numbers are within valid range (1 to 2*len)
+    for (unsigned int i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(arr[i] >= 1);
+        TEST_ASSERT_TRUE(arr[i] <= 2 * len);
+    }
+
+    free(arr);
+}
+
+void test_getDuplicate_returns_correct_value(void) 
+{
+    unsigned int arr[6] = {4, 1, 7, 7, 3, 2};
+    unsigned int d = getDuplicate(arr, 6);
+    TEST_ASSERT_EQUAL_UINT(7, d);
+}
+
+void test_complete_function_of_numbers(void) 
+{
+    unsigned int len = 50;
+    unsigned int *arr = createNumbers(len);
+    TEST_ASSERT_NOT_NULL(arr);
+
+    unsigned int d1 = getDuplicate(arr, len);
+    TEST_ASSERT_NOT_EQUAL(0, d1);
+
+    int count = 0;
+
+    for (unsigned int i = 0; i < len; i++) 
+    {
+        if (arr[i] == d1) 
+            count++;
+    }
+
+    TEST_ASSERT_EQUAL(2, count);
+
+    free(arr);
+}
+
+int main(void) 
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_no_null);
+    RUN_TEST(test_createNumbers_has_exactly_one_duplicate);
+    RUN_TEST(test_createNumbers_has_correct_value_range);
+    RUN_TEST(test_getDuplicate_returns_correct_value);
+    RUN_TEST(test_complete_function_of_numbers);
+
+    return UNITY_END();
+}