Test2

# Conflicts:
#	farben.c

Elipsen_Prototypen.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdarg.h>
+
+  int vielmax(int count, ...) {
+      va_list args;
+      va_start(args, count);
+
+      int max = va_arg(args, int);
+
+      for (int i = 1; i < count; i++) {
+          int num = va_arg(args, int);
+          if (num>max) {
+              max = num;
+          } else if (num == 0) {
+              break;
+          }
+      }
+      va_end(args);
+      return max;
+  }
+int main() {
+
+      printf("Testprogramm fuer Funktion vielmax ()");
+      printf("=====================================\n\n");
+
+      //int max1 = vielmax(6, 12, 17, 3, 6, 24, 8);
+      //printf("Das Maximum der Zahlen 12, 17, 3, 6, 24, 8: %d", max1);
+
+      int max2 = vielmax(5, 1, 11, 33, 12, 9);
+      printf("Das Maxiumum der Zahlen 1, 11, 33, 12, 9: %d", max2);
+
+  }
+
+
+
+//
+// Created by Lennart Pecher on 04.04.25.
+//

Quersumme.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+
+int umdrehen(int zahl, int umgekehrt) {
+    if (zahl == 0) {
+        return umgekehrt;
+    }
+    return umdrehen(zahl / 10, umgekehrt * 10 + (zahl % 10));
+}
+
+int quersumme(int zahl) {
+    int result;
+    int temp;
+    if(zahl<10) {
+        return zahl;
+    }
+    temp = zahl%10;
+    result = temp + quersumme(zahl / 10);
+    return result;
+}
+
+int input() {
+        int eingabe;
+        int ok = 0;
+        char c;
+        printf("Gib eine Zahl ein: ");
+        ok = scanf("%d%c", &eingabe, &c);
+
+        while (ok != 2 || c != '\n') {
+            ok = scanf("%d%c", &eingabe, &c);
+            while ((c = getchar()) != '\n' && c != EOF) {}
+            printf("Ungueltige Eingabe!\n");
+        }
+    return eingabe;
+}
+
+
+int main() {
+    int eingabe, ergebnisQuer, ergebnisGedreht;
+
+    eingabe = input();
+    ergebnisQuer = quersumme(eingabe);
+    ergebnisGedreht = umdrehen(eingabe, 0);
+    printf("----Quersumme: %d\n", ergebnisQuer);
+    printf ("----Umgedreht: %d\n", ergebnisGedreht);
+
+    return 0;
+}

bucstreich.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <string.h>
+#define MAX 1000
+
+int main() {
+    char kette[MAX], neueKette[MAX];
+    char zeichen;
+    int laenge, j = 0;
+
+    printf("Geben Sie eine Zeichenkette (max. 1000 Zeichen) ein: ");
+    if (fgets(kette, MAX, stdin) != NULL) {
+        laenge = strlen(kette);
+        if (kette[laenge - 1] == '\n')
+            kette[laenge - 1] = '\0';
+    }
+
+    printf("Geben Sie das zu loeschende Zeichen ein: ");
+    scanf(" %c", &zeichen);
+
+
+    for (int i = 0; i < laenge; i++) {
+        if (kette[i] != zeichen) {
+            neueKette[j++] = kette[i];
+        }
+    }
+    neueKette[j] = '\0';
+
+    printf("Neue Zeichenkette: %s\n", neueKette);
+
+    return 0;
+}

datediff.c

@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#define SIZE_EINGABE 11
+
+typedef struct {
+    int tag;
+    int monat;
+    int jahr;
+} Datum;
+
+
+int datum_einlesen(Datum *datum, int i) {
+    char eingabe[SIZE_EINGABE] = {0};
+    printf("%d. Datum (tt.mm.jjjj): ", i);
+
+    if (fgets(eingabe, SIZE_EINGABE, stdin) != NULL) {
+
+        int laenge = strlen(eingabe);
+        if (eingabe[laenge - 1] == '\n') {
+            eingabe[laenge - 1] = '\0';
+        }
+
+        if (sscanf(eingabe, "%d.%d.%d", &datum->tag, &datum->monat, &datum->jahr) == 3) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+int schaltjahr_berechnen(int jahr) {
+    return (jahr % 4 == 0 && (jahr % 100 != 0 || jahr % 400 == 0)) ? 1 : 0;
+}
+
+int alle_tage_bis_datum_berechnen(Datum *datum) {
+    int aktuelles_datum_tage = 0;
+    const int monate_kein_schaltjahr[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    const int monate_schaltjahr[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+
+    for(int i = 0; i < datum->jahr; i++){
+        int schaltjahr = schaltjahr_berechnen(i);
+        if(schaltjahr == 1) {
+            aktuelles_datum_tage += 366;
+        }
+        else if(schaltjahr == 0) {
+            aktuelles_datum_tage += 365;
+        }
+    }
+    for(int j = 0; j < (datum->monat) - 1 ; j++) {
+        int schaltjahr = schaltjahr_berechnen(datum->jahr);
+        if(schaltjahr == 1) {
+            aktuelles_datum_tage += monate_schaltjahr[j];
+        }
+        else if(schaltjahr == 0) {
+            aktuelles_datum_tage += monate_kein_schaltjahr[j];
+        }
+    }
+    for(int k = 0; k < datum->tag; k++) {
+        aktuelles_datum_tage++;
+    }
+    return aktuelles_datum_tage;
+}
+
+
+int tage_diff(Datum *datum_1, Datum *datum_2) {
+
+    int tage_diff_gesamt = 0;
+
+    int tage_datum_1 = alle_tage_bis_datum_berechnen(datum_1);
+    int tage_datum_2 = alle_tage_bis_datum_berechnen(datum_2);
+
+    tage_diff_gesamt = abs(tage_datum_1 - tage_datum_2);
+
+    return tage_diff_gesamt;
+
+}
+
+int main() {
+    Datum datum_1, datum_2;
+
+
+    if (!datum_einlesen(&datum_1, 1)) {
+        printf("Fehler beim Einlesen von Datum 1.\n");
+    }
+
+    fflush(stdin);
+
+    if (!datum_einlesen(&datum_2, 2)) {
+        printf("Fehler beim Einlesen von Datum 2.\n");
+    }
+
+    int tage_diff_aus  = tage_diff(&datum_1, &datum_2); {
+
+    }
+
+    printf("..... Differenz: %d Tage .....", tage_diff_aus);
+
+    return 0;
+}
+
+
+//
+// Created by Lennart Pecher on 16.05.25.
+//
+
+
+
+
+//
+// Created by Lennart Pecher on 16.05.25.
+//

dualwand.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+
+void decBinary(unsigned int zahl) {
+    if(zahl == 0){
+        return;
+    }
+    decBinary(zahl/2);
+    printf("%d", zahl % 2);
+
+}
+
+int input() {
+    int eingabe;
+    int ok = 0;
+    char c;
+    printf("Gib eine Zahl ein: ");
+    ok = scanf("%d%c", &eingabe, &c);
+
+    while (ok != 2 || c != '\n') {
+        ok = scanf("%d%c", &eingabe, &c);
+        while ((c = getchar()) != '\n' && c != EOF) {}
+        printf("Ungueltige Eingabe!\n");
+    }
+    return eingabe;
+}
+
+
+int main() {
+    int zahl;
+    zahl = input();
+    decBinary(zahl);
+    return 0;
+}

farben.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+
+#define SIZE 3
+
+int main() {
+
+    const char *mischungen[SIZE][SIZE] = {
+        {"Gelb", "Rot", "Purpur"},
+        {"Blau", "Purpur", "Violett"}
+    };
+
+    char eingabe1[20], eingabe2[20];
+    int index1 = -1, index2 = -1;
+
+    while (1) {
+        scanf("%s", eingabe1);
+
+        for (int i = 0; i < SIZE; i++) {
+            if (strcasecmp(eingabe1, farben[i]) == 0) {
+                index1 = i;
+                break;
+            }
+        }
+
+        if (index1 != -1) break;
+        else printf("... unbekannte Grundfarbe '%s'. Bitte erneut eingeben.\n", eingabe1);
+    }
+
+    while (1) {
+        scanf("%s", eingabe2);
+
+        for (int i = 0; i < SIZE; i++) {
+            if (strcasecmp(eingabe2, farben[i]) == 0) {
+                index2 = i;
+                break;
+            }
+        }
+
+        if (index2 != -1) break;
+        else printf("... unbekannte Grundfarbe '%s'. Bitte erneut eingeben.\n", eingabe2);
+    }
+
+    const char *ergebnis = mischungen[index1][index2];
+    printf("Die Mischung aus %s und %s ergibt: %s\n", farben[index1], farben[index2], ergebnis);
+
+    return 0;
+}

jahrtag.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+
+void textAusgabe() {
+    printf("0   Ende\n"
+           "1   Tagesnummer zu einem Datum bestimmen\n"
+           "2   Datum zu einer Tagesnummer bestimmen\n");
+}
+
+void eingabeDatum(int *tag, int *monat, int *jahr) {
+    printf("Gib dein Datum (tt.mm.jjjj) ein: ");
+    scanf("%d.%d.%d", tag, monat, jahr);
+}
+
+void eingabeTag(int *tag, int *jahr) {
+    printf("Gib Tagesnummer und Jahr (nr,jahr) ein: ");
+    scanf("%d,%d", tag, jahr);
+}
+
+int eingabeWahl() {
+    int input;
+    printf("Deine Wahl: ");
+    scanf("%d", &input);
+    return input;
+}
+
+int istSchaltjahr(int jahr) {
+    return (jahr % 4 == 0 && (jahr % 100 != 0 || jahr % 400 == 0));
+}
+
+
+int main() {
+    int input, tag, monat, jahr, TagImJahr,schalt;
+
+    int monat_tage[2][13] = {
+            { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+            { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+    };
+    input = 1;
+
+    do{
+        textAusgabe();
+        input = eingabeWahl();
+
+        switch(input) {
+            case 0:
+                printf("Programm beendet.\n");
+                break;
+            case 1:
+                eingabeDatum(&tag, &monat, &jahr);
+                schalt = istSchaltjahr(jahr);
+                TagImJahr = 0;
+
+                    for(int i = 1;i<monat;i++) {
+                        TagImJahr += monat_tage[schalt] [i];
+                    }
+                    TagImJahr += tag;
+
+                    printf("%d.%d.%d = %d. Tag im Jahr\n", tag, monat, jahr, TagImJahr);
+
+                break;
+            case 2:
+                int i = 1;
+                eingabeTag(&TagImJahr, &jahr);
+                schalt = istSchaltjahr(jahr);
+                tag = TagImJahr;
+
+                while (tag > monat_tage[schalt][i]) {
+                    tag -= monat_tage[schalt][i];
+                    i++;
+                }
+                monat = i;
+                printf(".... %d. Tag im Jahr = %d.%d.%d\n", TagImJahr, tag, monat, jahr);
+
+        }
+    } while (input != 0);
+    return 0;
+}

kommaadd.c

@@ -0,0 +1,92 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX 100
+
+typedef struct {
+    long vorkomma;
+    long nachkomma;
+    int nachkomma_stellen;
+} Kommazahl;
+
+// Funktion zum Potenzieren (10^n)
+long potenz(int basis, int exponent) {
+    long result = 1;
+    for (int i = 0; i < exponent; i++) {
+        result *= basis;
+    }
+    return result;
+}
+
+// Funktion zum Aufteilen der Zahl in Vor- und Nachkommateil
+Kommazahl parseKommazahl(char *eingabe) {
+    Kommazahl z = {0, 0, 0};
+    char *komma = strchr(eingabe, ',');                             //Überprüfung ob Zahl ein Komma besitzt
+
+    if (komma) {
+        *komma = '\0';                                                // 0 ersetzt Komma
+        z.vorkomma = atol(eingabe);                                   // Wandelt Vorkomma in Ganzzahl um
+        char *nachkomma_str = komma + 1;
+        z.nachkomma = atol(nachkomma_str);                            // Wandelt nachkomma in Ganzzahl um
+        z.nachkomma_stellen = strlen(nachkomma_str);
+    } else {
+        z.vorkomma = atol(eingabe);
+        z.nachkomma = 0;
+        z.nachkomma_stellen = 0;
+    }
+
+    return z;
+}
+
+int main() {
+    Kommazahl eingaben[MAX];
+    int anzahl = 0;
+    int max_nachkomma_stellen = 0;
+
+    printf("Gib Deine Kommazahlen ein (Abschluss mit Leerzeile)\n");
+
+    char zeile[100];
+    while (fgets(zeile, sizeof(zeile), stdin)) {
+        // Entferne Zeilenumbruch
+        size_t len = strlen(zeile);
+        if (len > 0 && zeile[len - 1] == '\n') zeile[len - 1] = '\0';
+        if (strlen(zeile) == 0) break;
+
+        // Entferne Leerzeichen
+        for (int i = 0; zeile[i]; i++) {
+            if (zeile[i] == ' ') {
+                memmove(&zeile[i], &zeile[i + 1], strlen(&zeile[i]));
+                i--;
+            }
+        }
+
+        Kommazahl k = parseKommazahl(zeile);
+        eingaben[anzahl] = k;
+        if (k.nachkomma_stellen > max_nachkomma_stellen)
+            max_nachkomma_stellen = k.nachkomma_stellen;
+        anzahl++;
+    }
+
+    Kommazahl summe = {0, 0, max_nachkomma_stellen};
+
+    for (int i = 0; i < anzahl; i++) {
+        Kommazahl z = eingaben[i];
+        summe.vorkomma += z.vorkomma;
+
+        int faktor = potenz(10, max_nachkomma_stellen - z.nachkomma_stellen);
+        summe.nachkomma += z.nachkomma * faktor;
+    }
+
+    // Übertrag
+    long übertrag = summe.nachkomma / potenz(10, max_nachkomma_stellen);
+    summe.vorkomma += übertrag;
+    summe.nachkomma = summe.nachkomma % potenz(10, max_nachkomma_stellen);
+
+    printf("= %ld,%0*ld\n", summe.vorkomma, max_nachkomma_stellen, summe.nachkomma);
+
+    return 0;
+}
+
+

kommahinzufügen.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX 100
+
+typedef struct {
+    long vorkomma;
+    long nachkomma;
+    int nachkomma_stellen;
+} Kommazahl;
+
+// Funktion zum Potenzieren (10^n)
+long potenz(int basis, int exponent) {
+    long result = 1;
+    for (int i = 0; i < exponent; i++) {
+        result *= basis;
+    }
+    return result;
+}
+
+// Funktion zum Aufteilen der Zahl in Vor- und Nachkommateil
+Kommazahl parseKommazahl(char *eingabe) {
+    Kommazahl z = {0, 0, 0};
+    char *komma = strchr(eingabe, ',');                             //Überprüfung ob Zahl ein Komma besitzt
+
+    if (komma) {
+        *komma = '\0';                                                // 0 ersetzt Komma
+        z.vorkomma = atol(eingabe);                                   // Wandelt Vorkomma in Ganzzahl um
+        char *nachkomma_str = komma + 1;
+        z.nachkomma = atol(nachkomma_str);                            // Wandelt nachkomma in Ganzzahl um
+        z.nachkomma_stellen = strlen(nachkomma_str);
+    } else {
+        z.vorkomma = atol(eingabe);
+        z.nachkomma = 0;
+        z.nachkomma_stellen = 0;
+    }
+
+    return z;
+}
+
+int main() {
+    Kommazahl eingaben[MAX];
+    int anzahl = 0;
+    int max_nachkomma_stellen = 0;
+
+    printf("Gib Deine Kommazahlen ein (Abschluss mit Leerzeile)\n");
+
+    char zeile[100];
+    while (fgets(zeile, sizeof(zeile), stdin)) {
+        // Entferne Zeilenumbruch
+        size_t len = strlen(zeile);
+        if (len > 0 && zeile[len - 1] == '\n') zeile[len - 1] = '\0';
+        if (strlen(zeile) == 0) break;
+
+        // Entferne Leerzeichen
+        for (int i = 0; zeile[i]; i++) {
+            if (zeile[i] == ' ') {
+                memmove(&zeile[i], &zeile[i + 1], strlen(&zeile[i]));
+                i--;
+            }
+        }
+
+        Kommazahl k = parseKommazahl(zeile);
+        eingaben[anzahl] = k;
+        if (k.nachkomma_stellen > max_nachkomma_stellen)
+            max_nachkomma_stellen = k.nachkomma_stellen;
+        anzahl++;
+    }
+
+    Kommazahl summe = {0, 0, max_nachkomma_stellen};
+
+    for (int i = 0; i < anzahl; i++) {
+        Kommazahl z = eingaben[i];
+        summe.vorkomma += z.vorkomma;
+
+        int faktor = potenz(10, max_nachkomma_stellen - z.nachkomma_stellen);
+        summe.nachkomma += z.nachkomma * faktor;
+    }
+
+    // Übertrag
+    long übertrag = summe.nachkomma / potenz(10, max_nachkomma_stellen);
+    summe.vorkomma += übertrag;
+    summe.nachkomma = summe.nachkomma % potenz(10, max_nachkomma_stellen);
+
+    printf("= %ld,%0*ld\n", summe.vorkomma, max_nachkomma_stellen, summe.nachkomma);
+
+    return 0;
+}
+

laugsaeu.c

@@ -0,0 +1,62 @@
+#include <stdio.h>
+
+
+typedef enum {
+    NATRONLAUGE,
+    KALILAUGE,
+    KALKWASSER,
+    ANZAHL_LAUGEN
+} Lauge;
+
+
+typedef enum {
+    SALZSAEURE,
+    SCHWEFELSAEURE,
+    SALPETERSAEURE,
+    KOHLENSAEURE,
+    ANZAHL_SAEUREN
+} Saeure;
+
+
+const char* mischtabelle[ANZAHL_LAUGEN][ANZAHL_SAEUREN] = {
+        {"Natriumchlorid", "Natriumsulfat", "Natriumnitrat", "Natriumcarbonat"},
+        {"Kaliumchlorid",  "Kaliumsulfat",  "Kaliumnitrat",  "Kaliumcarbonat"},
+        {"Calciumchlorid", "Calciumsulfat", "Calciumnitrat", "Calciumcarbonat"}
+};
+
+const char* laugen_namen[ANZAHL_LAUGEN] = {
+        "Natronlauge",
+        "Kalilauge",
+        "Kalkwasser"
+};
+
+const char* saeure_namen[ANZAHL_SAEUREN] = {
+        "Salzsäure",
+        "Schwefelsäure",
+        "Salpetersäure",
+        "Kohlensäure"
+};
+
+int main() {
+    printf("           ||");
+    for (int s = 0; s < ANZAHL_SAEUREN; s++) {
+        printf(" %-14s|", saeure_namen[s]);
+    }
+    printf("\n");
+    printf("-----------++");
+    for (int s = 0; s < ANZAHL_SAEUREN; s++) {
+        printf("---------------|");
+    }
+    printf("\n");
+
+
+    for (int l = 0; l < ANZAHL_LAUGEN; l++) {
+        printf("%-11s||", laugen_namen[l]);
+        for (int s = 0; s < ANZAHL_SAEUREN; s++) {
+            printf(" %-14s|", mischtabelle[l][s]);
+        }
+        printf("\n");
+    }
+
+    return 0;
+}

listmisc.c

@@ -0,0 +1,141 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define SIZE_NAME 100
+
+typedef struct knotenNamensliste {
+    char name[SIZE_NAME];
+    struct knotenNamensliste* next;
+    struct knotenNamensliste* prev;
+} knotenNamensliste_t;
+
+knotenNamensliste_t* neuenKnotenErstellen(char *aktuellerName) {
+    knotenNamensliste_t *neuerKnoten = (knotenNamensliste_t*)malloc(sizeof(knotenNamensliste_t));
+    if (neuerKnoten == NULL) {
+        printf("Speicher konnte nicht zugewiesen werden!\n");
+        return NULL;
+    }
+    strncpy(neuerKnoten->name, aktuellerName, SIZE_NAME - 1);
+    neuerKnoten->prev = NULL;
+    neuerKnoten->next = NULL;
+
+    return neuerKnoten;
+}
+
+
+int namenEinlesen(char *aktuellerName) {
+    printf("Name (Leere Eingabe zum Beenden):\t");
+    if (fgets(aktuellerName, SIZE_NAME, stdin) != NULL) {
+        int laenge = strlen(aktuellerName);
+        if (aktuellerName[laenge-1] == '\n') {
+            aktuellerName[laenge-1] = '\0';
+        }
+
+        if (strlen(aktuellerName) == 0) {
+            return 0;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+int wahlListe() {
+    int wahl;
+    printf("Welche Liste (1 oder 2):\t");
+    scanf("%d", &wahl);
+    while (getchar() != '\n');
+    return wahl;
+}
+
+void listeSortieren(knotenNamensliste_t **listeHead, char *aktuellerName) {
+
+    knotenNamensliste_t *neuerKnoten = neuenKnotenErstellen(aktuellerName);
+
+    knotenNamensliste_t *temp = *listeHead;
+
+        //Überprüfung ob Name bereits vorhanden
+    while (temp != NULL) {
+        if (strcmp(temp->name, aktuellerName) == 0) {
+            free(neuerKnoten);
+            return;
+        }
+        temp = temp->next;
+    }
+
+
+    if (*listeHead == NULL) {
+        *listeHead = neuerKnoten;
+    } else {
+        temp = *listeHead;
+
+        //Alphabetische Sortierung
+        while (temp->next != NULL && strcmp(temp->name, aktuellerName) < 0) {
+            temp = temp->next;
+        }
+
+
+        if (strcmp(temp->name, aktuellerName) > 0) {
+
+            neuerKnoten->next = temp;
+            neuerKnoten->prev = temp->prev;
+            if (temp->prev != NULL) {
+                temp->prev->next = neuerKnoten;
+            } else {
+                *listeHead = neuerKnoten;
+            }
+            temp->prev = neuerKnoten;
+        } else {
+
+            temp->next = neuerKnoten;
+            neuerKnoten->prev = temp;
+        }
+    }
+}
+
+
+
+void ausgabeListe(knotenNamensliste_t *listeHead) {
+    knotenNamensliste_t *temp = listeHead;
+    while (temp != NULL) {
+        printf("Name: %s\n", temp->name);
+        temp = temp->next;
+    }
+}
+
+int main() {
+    knotenNamensliste_t *listeGemischtHead = NULL;
+    knotenNamensliste_t *listeEinsHead = NULL;
+    knotenNamensliste_t *listeZweiHead = NULL;
+    char aktuellerName[SIZE_NAME];
+
+    while (namenEinlesen(aktuellerName) == 1) {
+        int listeZuweisen = wahlListe();
+        if (listeZuweisen == 1) {
+            listeSortieren(&listeEinsHead, aktuellerName);
+        } else if (listeZuweisen == 2) {
+            listeSortieren(&listeZweiHead, aktuellerName);
+        }
+
+        listeSortieren(&listeGemischtHead, aktuellerName);
+    }
+
+    printf("Liste 1:\n");
+    ausgabeListe(listeEinsHead);
+    printf("Liste 2:\n");
+    ausgabeListe(listeZweiHead);
+    printf("Liste gemischt:\n");
+    ausgabeListe(listeGemischtHead);
+
+    return 0;
+}
+
+
+//
+// Created by Lennart Pecher on 23.05.25.
+//
+
+
+//
+// Created by Lennart Pecher on 23.05.25.
+//

nulleins.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+
+int input() {
+    int eingabe;
+    char check;
+
+    printf("Länge der 0/1-Folge (max. 1000): ");
+
+    while (scanf("%d%c", &eingabe, &check) != 2 || check != '\n' || eingabe <= 0 || eingabe > 1000) {
+        printf("Ungueltige Eingabe! Bitte eine Zahl zwischen 1 und 1000 eingeben: ");
+        while (getchar() != '\n');
+    }
+
+    return eingabe;
+}
+
+void zahlenfolge(int eingabe, int arr[]) {
+    srand(time(NULL));
+    for (int i = 0; i < eingabe; i++) {
+        arr[i] = rand() % 2;
+    }
+}
+
+
+void vergleich(int arr[], int laenge) {
+    while (laenge > 1) {
+        int neueLaenge = laenge / 2;
+        if (laenge % 2 != 0) {
+            neueLaenge++;
+        }
+
+        int neuesArray[neueLaenge];
+
+
+        for (int i = 0; i < laenge / 2; i++) {
+            neuesArray[i] = arr[i * 2] ^ arr[i * 2 + 1];
+        }
+
+
+        if (laenge % 2 != 0) {
+            neuesArray[neueLaenge - 1] = arr[laenge - 1];
+        }
+
+
+        for (int i = 0; i < neueLaenge; i++) {
+            printf("%d", neuesArray[i]);
+        }
+        printf("\n");
+
+
+        for (int i = 0; i < neueLaenge; i++) {
+            arr[i] = neuesArray[i];
+        }
+
+        laenge = neueLaenge;
+    }
+}
+
+
+int main() {
+    int array[1000];
+    int eingabe = input();
+    zahlenfolge(eingabe, array);
+
+
+    for (int i = 0; i < eingabe; i++) {
+        printf("%d ", array[i]);
+    }
+    printf("\n");
+
+
+    vergleich(array, eingabe);
+
+    return 0;
+}
+//
+// Created by Lennart Pecher on 09.04.25.
+//

primza.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+
+int eingabe() {
+    int x;
+    scanf("%d", &x);
+    return x;
+}
+
+
+int main() {
+    int input = 1;
+    bool *primzahlen;
+
+    while (input != 0) {
+        printf("Bis wohin sollen die Primzahlen berechnet werden (Ende=0) ? ");
+        input = eingabe();
+
+        if(input == 0){
+            break;
+        }
+
+        primzahlen = (bool *) malloc(input * sizeof(bool));
+
+        for (int i = 2; i * i <= input; i++) {
+            if (primzahlen[i] == true) {
+                for (int j = i * i; j <= input; j += i) {
+                    primzahlen[j] = false;
+                }
+            }
+        }
+
+        for (int i = 2; i <= input; i++) {
+            if (primzahlen[i] == true) {
+                printf("%d ", i);
+            }
+        }
+        printf("\n");
+
+        free(primzahlen);
+    }
+    printf("Programm beendet");
+    return 0;
+}

test.c

@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main() {
-    printf("Hello world!");
-    return 0;
-}

test2.c

@@ -1,4 +0,0 @@
-#include <stdio.h>
-int main() {
-  printf("Hello World!");
-}

wordrepl.c

@@ -0,0 +1,122 @@
+/*
+
+1. Einlesen einer Zeichenkette
+2. Bestimmtes Wort kann durch ein anderes eretzt werden
+3. Alle vorkommen des ausgewählten Wortes werden in der gesamten
+   Zeichenkette automatisch durch das neue Wort ersetzt
+4. Ausgabe der neuen Zeichenkette
+
+
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define MAX_LENGTH 1001
+#define MAX_WORD_LENGTH 101
+#define MAX_EXCHANGE_WORD_LENGTH 201
+#define MAX_POSITION 100
+
+void get_input_string(char * input ) {
+  printf("Geben Sie einen Text mit maximal %d Zeichen ein: ", MAX_LENGTH-1);
+  scanf("%1000[^\n]", input);
+  while (getchar() != '\n');
+}
+
+void get_word_to_replace(char*get_word) {
+  printf("Welches Wort soll ersetzt werden? (Maximale Wortlänge:  %d): ", MAX_WORD_LENGTH-1);
+  scanf("%100[^\n]", get_word);
+  while (getchar() != '\n');
+}
+
+void get_new_word(char*new_word) {
+  printf("Durch welches Wort soll dieses ersetzt werden? (Maximale Wortlänge des neuen Wortes: %d): ", MAX_EXCHANGE_WORD_LENGTH-1);
+  scanf("%200[^\n]", new_word);
+  while (getchar() != '\n');
+}
+
+int find_word_positions(const char *input_sentence, const char *target_word, int position_target_word[]) {
+
+    int counter_word_found = 0;
+    char *sentence_ptr = (char*)input_sentence;
+    if(strstr(sentence_ptr, target_word) == NULL) {
+        return 0;
+    }
+
+    do  {
+        char *ptr_position_target_word = strstr(sentence_ptr, target_word);
+        int position_before_target_word = ptr_position_target_word - input_sentence - 1;
+
+        int position_after_target_word = ptr_position_target_word - input_sentence + strlen(target_word);
+        if (isalpha(input_sentence[position_before_target_word]) || isalpha(input_sentence[position_after_target_word])) {
+            sentence_ptr = ptr_position_target_word + strlen(target_word);
+        }
+
+        else {
+            position_target_word[counter_word_found] = ptr_position_target_word - input_sentence;
+            sentence_ptr = ptr_position_target_word + strlen(target_word);
+            counter_word_found++;
+        }
+
+        }while(strstr(sentence_ptr, target_word) != NULL);
+
+    return counter_word_found;
+}
+
+void replace_word_in_sentence(char *input_sentence, const char *replacement_word, const char *target_word, int positions_target_word[], int counter_word_found) {
+
+    char updated_sentence[MAX_LENGTH] = {0};
+
+    int last_position = 0;
+
+    for (int i = 0; i < counter_word_found; i++) {
+        strncat(updated_sentence, input_sentence + last_position, positions_target_word[i] - last_position);
+        strncat(updated_sentence, replacement_word, MAX_EXCHANGE_WORD_LENGTH - 1);
+        last_position = positions_target_word[i] + strlen(target_word);
+    }
+
+    strncat(updated_sentence, input_sentence + last_position, MAX_LENGTH - strlen(updated_sentence) - 1);
+    strncpy(input_sentence, updated_sentence, MAX_LENGTH - 1);
+    input_sentence[MAX_LENGTH] = '\0';
+}
+
+int main(void) {
+    char input_sentence[MAX_LENGTH] = {0};
+    char target_word[MAX_WORD_LENGTH] = {0};
+    char replacement_word[MAX_EXCHANGE_WORD_LENGTH] = {0};
+    int positions_target_word[MAX_POSITION] = {0};
+    char continue_choice;
+    int word_found = 0;
+
+
+    get_input_string(input_sentence);
+
+    do {
+        get_word_to_replace(target_word);
+        get_new_word(replacement_word);
+        word_found = find_word_positions(input_sentence, target_word, positions_target_word);
+
+        if (word_found == 0) {
+            printf("Wort nicht gefunden:\n");
+            printf("Der Satz lautet: %s\n", input_sentence);
+        }
+        else {
+            replace_word_in_sentence(input_sentence, replacement_word, target_word, positions_target_word, word_found);
+            printf("\n....Neuer String: %s\n", input_sentence);
+        }
+
+            printf("Noch eine Einsetzung (j/n)? ");
+            continue_choice = getchar();
+            while (getchar() != '\n');
+
+    } while (continue_choice != 'n' && continue_choice != 'N');
+
+    return 0;
+}
+
+
+//
+// Created by Lennart Pecher on 25.04.25.
+//
+