Program: ma3

23.1.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+int i = 0;      // Variable, die nie verwendet wird, da in der main eine neue is definieren
+
+int main(void)
+{
+    int i = 1;  // Wir definieren lokal die Variable i mit dem Wert 1
+    printf("i=%d\n", i); // Ausgabe i=1
+
+    {
+        int i = 2;   // Neuer Block und wir definieren eine neue i --> i=1 wird verdeckt und stattdessen nun i=2 übernommen
+        printf("i=%d\n", i); // Ausgabe i=2
+
+        {
+            i++;   // Das vorherige i=2 wird um 1 erhöht
+            printf("i=%d\n", i); // Ausgabe i=3
+        }
+
+        printf("i=%d\n", i); // Nun wieder im äußeren Block --> Ausgabe i=3, da das i gerade eben zu 3 wurde durch das i++
+    }
+
+    printf("i=%d\n", i); // Ausgabe i=1, da wir hier den äußersten Block nehmen, wo i=1 war --> Wurde dabei nicht verändert
+
+    return(0);
+}

25.3.2.c

@@ -0,0 +1,53 @@
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <time.h>
+
+int generiere_neue_folge(int len, int folge[]);
+
+int main(void)
+{
+    int folge[1001]; ///Array für bis zu 1000 Zufallszahlen (angefangen wird ab Index 1 nicht 0)
+    int i, laenge; ///i = Schleifenvariable; laenge speichert wie viele Zahlen in der Folge sein sollen
+
+    do
+    {
+        printf("Länge der 0/1-Folge (max. 1000): ");
+        scanf("%d", &laenge);
+    } while (laenge < 0 || laenge > 1000);   ///Solange man zwischen 0 und 1000 eingibt geht es weiter
+
+    srand(time(NULL));   ///Startwert für Zufallsgenerator
+
+    for (i = 1; i <= laenge; i++)  ///Start bei 1; Ende bei laenge (Zahl die man eingibt); jeder Durchlauf wird um i um 1 erhöht
+        folge[i] = rand() % 2;    ///rand() erzeugt Zufallszahl und %2 teilt die Zahl durch 2 und gibt den Rest 0 oder 1 aus
+                                 ///Zahlen werden in folge [i] gespeichert
+
+    for (i = 1; i <= laenge; i++) ///gleich wie oben
+        printf("%d", folge[i]);  ///gibt die jede Zahl als Dezimalzahl wieder von folge [i]
+    printf("\n");  ///erzeugt einen Zeilenumbruch
+
+    while (laenge > 1)  ///Solange mehr als eine Zahl vorhanden ist, wiederholt sich die Folge
+    {
+        laenge = generiere_neue_folge(laenge, folge);  ///neue, kürzere Folge wird generiert und in laenge gespeichert
+        for (i = 1; i <= laenge; i++) ///nach jedem verkleinern wird die Folge wieder ausgegeben untereinander
+            printf("%d", folge[i]);
+        printf("\n");
+    }
+    return (0);
+}
+
+/*------------------------------------------ generiere_neue_folge ---------------------------------------*/
+int generiere_neue_folge(int len, int folge[])  ///len: aktuelle Folge, wie viele Zahlen drin sind; folge[]: Array mit 0/1en
+{
+    int i, j;   ///i: wir starten beim ersten Element; j: der Platz an den die neue Zahl kommen soll
+
+    for (i = 1, j = 1; i < len; i += 2, j++)   ///i springt immer 2 Schritte, also zu Paaren 1&2 3&4
+        folge[j] = !(folge[i] == folge[i + 1]);  ///folge[i + 1] -> ist 1 gleich 0? -> Nein -> false = 0
+                                                ///!0 heißt "nicht" also = 1
+
+    if (i == len)                  ///Wenn i Zahl ungerade ist, dann hat die Zahl keinen Partner -> Zahl wird einfach übernommen
+        folge[j] = folge[len];
+    else
+        j--;
+
+    return (j);  ///Zahl wird zurückgegeben damit die main weiß wie viele Zahlen die Folge jetzt hat
+}

25.4.1.c

@@ -1,30 +1,30 @@
 #include <stdio.h>
 #include <string.h>
 
-void streichen(char *zeichKet, char streich)
+void streichen(char *zeichKet, char streich)  ///zeichKet: Text und streich: Zeichen, dass entfernt werden soll
 {
-    int i = 0;
-    int p = 0;
+    int i = 0;  ///i schaut sich jedes Zeichen an
+    int p = 0;  ///p ist die Stelle an der wir schreiben, wenn es nicht gelöscht werden soll
 
-    while(zeichKet[i] != '\0')
+    while(zeichKet[i] != '\0')  ///Solange der Text weitergeht, prüft man Zeichen für Zeichen weiter
     {
 
-        if(zeichKet[i] != streich)
+        if(zeichKet[i] != streich)   ///Wenn das aktuelle Zeichen nicht gelöscht werden soll...
         {
-            zeichKet[p] = zeichKet[i];
-            p++;
+            zeichKet[p] = zeichKet[i];  ///...schreiben wir es an p (neue Stelle des Zeichens)
+            p++;  ///p wird hochgezählt
 
         }
         i++;
     }
-    zeichKet[p] = '\0';
+    zeichKet[p] = '\0'; ///Ende des Textes
 
 }
 
 int main()
 {
-    char zeichenkette[1001];
-    char loeschen;
+    char zeichenkette[1001];  ///Index fängt bei 1 an deshalb 1001 und nicht 1000
+    char loeschen;   ///Zeichen das gelöscht werden soll
 
     printf("Geben Sie eine Zeichenkette (max. 1000 Zeichen) ein: \n");
     scanf("%1000[^\n]s", zeichenkette);
@@ -35,7 +35,7 @@ int main()
 
     printf("...Die neue Zeichenkette ist dann: \n");
 
-    streichen(zeichenkette, loeschen);
+    streichen(zeichenkette, loeschen);  ///Aufruf der Funktion, die den Buchstaben rauswirft
 
     printf("%s\n", zeichenkette);
 

25.4.3.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+int is_palindrome(char *wort)  ///Funktion, die prüft ob das Wort ein Palindrom ist oder nicht
+{
+    int len = strlen(wort);  ///hier wird die Länge des Wortes ermittelt
+    int i;
+    for (i = 0; i < len / 2; i++)   ///Da Wort wird von außen nach innen verglichen: erster und letzter Buchstabe usw.
+    {
+        if (tolower(wort[i]) != tolower(wort[len - 1 - i])) ///prüft ob die Zeichen, die verglichen werden gleich oder ungleich sind
+        {                                                   ///Groß- und Kleinschreibung wird außer Acht gelassen
+            return 0;  ///Wort ist kein Palindrom sofort return 0
+        }
+    }
+    return 1;  ///Wort ist ein Palindrom --> alle Zeichen waren gleich
+}
+
+int main()
+{
+    char text[1001];  ///Index beginnt immer bei 1 deshalb 1001
+    char *teiler = " ,:";  ///Diese Zeichen gelten als Trennzeichen
+    char *token;  ///Zeiger der dann später auf jedes Wort zeigt
+
+    printf("Geben Sie Zeilen ein:\n");
+    scanf("%1000[^\n]s",text);
+
+    token = strtok(text, teiler);  ///teilt den Text beim ersten Trennzeichen und gibt das erste Wort zurück
+
+    while (token != NULL)   ///Solange es noch weitere Wörter gibt...
+    {
+        if (is_palindrome(token) == 1)   ///prüft man ob es ein Palindrom ist und wenn ja gibt man es wieder aus
+        {
+            printf("........ %s\n", token);
+        }
+        token = strtok(NULL, teiler);  ///gehe zum nächsten Wort
+    }
+
+
+    return 0;
+}

25.5.1.c

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int kaeferIrrfahrt()
+{
+    int a = 0; // Startposition 0
+    int strecke = 0; // zählt wie viele Schritte der Käfer macht (anfangs 0)
+
+    while (a != 3)   // Solange Käfer nicht bei Position 3 (Ziel), wiederholt sich die Schleife --> Ziel erreicht, wenn a == 3
+    {
+        int richtung = rand() % 3; // Erzeugen einer Zufallszahl --> %3 teilt die Zahl durch 3 und nimmt den Rest (0,1 oder 2)
+
+        if (a == 0)
+        {
+            a = 1;  //Wenn der Käfer bei 0 ist, kann er NUR zu 1 gehen
+        }
+
+        else if (a == 1)         // Wenn er bei 1 ist, gibt es 2 Möglichkeiten:
+        {
+            if (richtung == 0)   // Wenn richtung == 0, dann zurück nach 0
+            {
+                a = 0;
+            }
+
+            else
+            {
+                a = 2;           // Wenn richtung == 1 oder 2, dann geht er nach 2
+            }
+        }
+
+        else if (a == 2)         // Wenn er bei 2 ist, gibt es zwei Möglichkeiten:
+        {
+            if (richtung < 2)    // Wenn richtung kleiner 2, dann zurück nach 1
+            {
+                a = 1;
+            }
+
+            else
+            {
+                a = 3;           // Wenn richtung 2, geht er zum Ziel (Position 3)
+            }
+        }
+
+        strecke++;               // Nach jedem Schritt zählt die Variable +1 dazu
+    }
+
+    return strecke;              // Wenn Käfer am Ziel, geben wir zurück, wie viele Schritte er gebraucht hat
+}
+
+int main()
+{
+    int anzahl;    // Speichert, wie oft gelaufen werden soll
+
+    printf("Geben Sie die Anzahl der Irrfahrten ein: ");
+    scanf("%d", &anzahl);
+
+    srand(time(NULL));   // Sorgt dafür, dass bei jedem Neustart die Zufallszahlen anders sind
+
+    int haeufigkeit[100] = {0};  // Array mit 100 Zahlen (Weglänge 0-99) --> Alle beginnen bei 0
+    int summe = 0;               // Wird später verwendet, um alle Weglängen zusammenzuzählen
+
+    for (int i = 0; i < anzahl; i++)   // Wir wiederholen den Vorgang "anzahl"-mal
+    {
+        int weg = kaeferIrrfahrt();    // Funktion der Irrfahrt wird aufgerufen und Anzahl der Schritte in "weg" gespeichert
+
+        if (weg < 100)                 // Ist die Weglänge kleiner als 100, dann
+        {
+            haeufigkeit[weg]++;        // Erhöhe die Anzahl für diese Weglänge um 1 --> damit man am Ende weiss, wie oft jede Weglänge vorkam
+        }
+
+        summe += weg;                  // Rechnet alle Weglängen zusammen
+    }
+
+    printf("\n| Weglaenge | Haeufigkeit |\n");
+    printf("---------------------------\n");
+
+    for (int i = 0; i < 100; i++)       // Für jede Weglänge
+    {
+        if (haeufigkeit[i] > 0)         // Wurde jede Weglänge mindestens einmal erreicht?
+        {
+            printf("     %2d        %5d\n", i, haeufigkeit[i]);    // Wenn ja, printe sie so
+        }
+    }
+
+    double durchschnitt = (double) summe / anzahl;    //Berechnet den Durchschnitt, wie viele Schritte der Käfer gebraucht hat --> double, weil Kommazahl
+
+    printf("\nDurchschnittliche Weglaenge: %.2f\n", durchschnitt);
+
+    return 0;
+}

25.6.3.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+
+int finde_zahlwort(char *wort) {
+    if (strcasestr(wort, "eins")) return 1;
+    if (strcasestr(wort, "zwei")) return 2;
+    if (strcasestr(wort, "drei")) return 3;
+    if (strcasestr(wort, "vier")) return 4;
+    if (strcasestr(wort, "fünf")) return 5;
+    if (strcasestr(wort, "sechs")) return 6;
+    if (strcasestr(wort, "sieben")) return 7;
+    if (strcasestr(wort, "acht")) return 8;
+    if (strcasestr(wort, "neun")) return 9;
+    if (strcasestr(wort, "zehn")) return 10;
+    if (strcasestr(wort, "elf")) return 11;
+    if (strcasestr(wort, "zwölf")) return 12;
+    return 0;
+}
+
+int main() {
+    char *worte[] = {
+        "Endreim", "Kurzweil", "Nachtfalter", "Wohnviertel", "Neunauge",
+        "Weinstein", "Erdreich", "Achtung", "Segelflieger", "Pfalzwein",
+        "Radreifen", "Gehhelfer", "Leinsamen"
+    };
+    int summe = 0;
+
+    for (int i = 0; i < sizeof(worte)/sizeof(worte[0]); i++) {
+        int wert = finde_zahlwort(worte[i]);
+        if (wert > 0)
+            printf("%s: ... %d\n", worte[i], wert);
+        summe += wert;
+    }
+
+    printf("------------------------------\n");
+    printf("Summe: %d\n", summe);
+    return 0;
+}

25.6.4.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+
+#define MAX_LEN 10  // Eingabe des Wortes kann max. 10 Zeichen lang sein
+
+int eingabefarbe()  // Liest eine Farbe und gibt eine Zahl zurück --> Gruen 1, Rot 2, Violett 3
+{
+    int eingabe_als_zahl = 0;   // 0 = noch keine gültige Farbe
+    char *grundfarbe[] = {"Gruen", "Rot", "Violett"};   // Array aus Strings: Erlaubte Farben, die der Benutzer eingeben darf
+    char eingabeFarbe[MAX_LEN];    // Hier wird die Eingabe des Benutzers gespeichert --> 9 Buchstaben und 1 Enterzeichen
+
+    printf("Geben Sie eine Farbe ein (Gruen, Rot, Violett): ");
+
+    fgets(eingabeFarbe, MAX_LEN, stdin);    // Liest die Eingabe des Benutzers als Text ein und speichert sie in eingabeFarbe
+
+    if(eingabeFarbe[strlen(eingabeFarbe)-1] == '\n')    // Prüft, ob ein Zeilenumbruch da ist und löscht ihn, damit Vergleich der Farben später funktioniert
+        eingabeFarbe[strlen(eingabeFarbe)-1] = '\0';    // \n wird ersetzt mit \0 --> Ende Zeichen
+
+    for (int i = 0; i < 3; ++i)   // Schritt wird 3 mal wiederholt, da drei Farben verfügbar sind
+    {
+        if (strcmp(eingabeFarbe, grundfarbe[i]) == 0)  // Vergleicht 2 Texte: Der eingegeben wurde & erlaubte Farbe --> Wenn genau gleich, dann gibt strcmp() den Wert 0 zurück
+        {
+            eingabe_als_zahl = i + 1;   // Wir speichern die Farbe als Zahl --> Gruen 1, Rot 2, Violett 3
+            return eingabe_als_zahl;    // Wird zurück an die main gegeben
+        }
+    }
+    return eingabe_als_zahl;    // Wenn keine Zahl passt --> Ungültig (0)
+}
+
+int main()
+{
+    int farbe1, farbe2, posTabelle;   // 3 Platzhalter werden definiert; posTabelle = um die Mischfarbe aus Tabelle zu holen
+    char *auswahl[] = {"Gruen", "Gelb", "Blau", "Gelb", "Rot", "Purpur", "Blau", "Purpur", "Violett"};  // 1D-Array: Tabelle mit den Mischfarben, insgesamt 9 zur Auswahl beginnend bei Index 0, also 8
+
+    farbe1 = eingabefarbe();  // Farbe 1 wird gespeichert
+    farbe2 = eingabefarbe();  // Farbe 2 wird gespeichert
+
+    if (farbe1 == 0 || farbe2 == 0)   // Wenn eine Farbe ungültig ist, dann brechen wir ab und printen
+    {
+        printf("Ungültige Eingabe");
+        return 0;
+    }
+
+    posTabelle = (farbe1 -1) * 3 + farbe2 -1;     // Umrechnung von 2D-Tabelle in 1D-Array: farbe1 ist die Zeile und farbe2 ist die Spalte, 3 ist die Anzahl der Spalten pro Zeile
+    printf("Die Mischfarbe ist dann: %s", auswahl[posTabelle]);
+
+    return 0;
+}

26.1.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+long int ZahlBinaer(int num)
+{
+    int sum = 0;
+    for (int mult = 1, mod = 2; num > 0; mult *= 10, mod *= 2)
+    {
+        if (num % mod)
+        {
+            sum += mult;
+            num -= mod / 2;
+        }
+    }
+    return sum;
+}
+int ZahlOktal(int num)
+{
+    int sum = 0;
+    for (int mult = 1, mod = 8, div = 1; num > 0; mult *= 10, mod *= 8, div *= 8)
+    {
+        if (num % mod)
+        {
+            sum += (num % mod / div) * mult;
+            num -= num % mod;
+        }
+    }
+    return sum;
+}
+int main(int argc, char *argv[])
+{
+    int doBin = 0;
+    int doHex = 0;
+    int doOct = 0;
+    int num = 0;
+
+    for (int i = 1; i < argc; i++)
+    {
+        if (argv[i][0] != '-')
+        {
+            if (num == 0)
+            {
+                num = atoi(argv[i]);
+                printf("Dezimal: %d\n", num);
+                if (argc == 2)
+                {
+                    doBin = 1, doHex = 1, doOct = 1;
+                }
+            }
+            else
+            {
+                printf("Nur eine Zahl ist erlaubt!\n\n");
+                printf("Nur folgende Parameter sind erlaubt:\n--b Binaersystem\n--o Oktalsystem\n--h Hexadezimalsystem");
+                return 0;
+            }
+        }
+        else
+        {
+            int j = 2;
+            while (argv[i][j] != '\0')
+            {
+                if (argv[i][j] == 'b')
+                {
+                    doBin = 1;
+                }
+                else if (argv[i][j] == 'o')
+                {
+                    doOct = 1;
+                }
+                else if (argv[i][j] == 'h')
+                {
+                    doHex = 1;
+                }
+                else
+                {
+                    printf("Unerlaubte Option: --%c\n", argv[i][j]);
+                    return 0;
+                }
+                j++;
+            }
+        }
+    }
+    if (doBin)
+    {
+        printf("Binär: %ld\n", ZahlBinaer(num));
+    }
+    if (doHex)
+    {
+        printf("Hexadezimal: %X\n", num);
+    }
+    if (doOct)
+    {
+        printf("Oktal: %d\n", ZahlOktal(num));
+    }
+    return 1;
+}

27.2.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>   //malloc und free
+
+void ausgabe_liste(const char **listen)     //Zeiger auf Array von (listen) als Parameter
+{
+    for (int i = 0; i < 10; i++)            //Schleife geht von 0-9 - Gibt jedes Element des Arrays mit Position aus
+    {
+        printf("%d: %s\n", i, listen[i]);   //Gibt die Nummer und die dazugehörige Liste aus, springt in die nächste Zeile
+    }
+}
+
+
+void strichliste_erstellen(char **listen, int *zaehler)   //Ein Array von Zeichenketten (listen) und eins von Zählern (zaehler)
+{
+    char eingabe;            //speichert die eingegebene Zahl
+    int index = 0;          //Welcher Zähler aktualisiert werden soll
+    int laenge = 0;         //Die Länge des neuen Strich-Strings
+    char *neuerSpeicher;    //Platzhalter für den neuen Speicher
+
+    printf("Gib Zahlen ein von 0-9: \n");
+
+    while ((eingabe = getchar()) != EOF && eingabe != '\n')       //getchar liest Zeichen vom Benutzer bis entweder EndOfFile oder \n erkannt wird
+    {
+        if (eingabe >= '0' && eingabe <= '9')                    //Prüft ob dieEingabe eine Ziffer ist zwischen 0 und 9
+        {
+            index = eingabe - '0';                            //Wandelt das entsprechende Zeichen in die Zahl um
+            zaehler[index]++;                                //Erhöht den Zähler für die eingegebene Zahl '0' --> 0
+            laenge = zaehler[index] + 1;                    //Anzahl der Striche +1 für das 0-Zeichen, dass das Ende markiert
+
+            neuerSpeicher = (char *)malloc(laenge);                     //Reserviert Speicher für den neuen Text: char* wandelt den Rückgabewert von malloc in einen Zeichenzeiger um
+            snprintf(neuerSpeicher, laenge, "%s|", listen[index]);     //snprintf erstellt den neuen Text: %s| fügt den alten Text und einen neuen Strich zusammen
+            free(listen[index]);                  //gibt den alten Speicher frei, damit nichts belegt bleibt
+            listen[index] = neuerSpeicher;        //Speichert neuen Text in der Liste
+        }
+    }
+}
+
+int main()
+{
+    int zaehler[10];   //Array für die Zähler (jede Zahl von 0 bis 9)
+    char **strichlisten = (char **)malloc(10 * sizeof(char *));   //Array von Zeichenketten für Strichlisten: Reserviert Platz für 10 Zeichenketten (eine für jede Zahl)
+
+    for (int i = 0; i < 10; i++)    //durchläuft 10 mal, da 10 Zähler und Strichlisten jeweils gebraucht werden
+    {
+        strichlisten[i] = (char *)malloc(1);   //malloc reserviert 1 Byte für jeden Eintrag in der Strichliste, char* wandelt den Rückgabewert von malloc in einen Zeiger auf Zeichen (char *) um
+        strichlisten[i][0] = '\0';     //greift auf das erste (und einzige) Zeichen der gerade reservierten Zeichenkette zu, Nullzeichen: Zeichenkette leer, aber gültig
+        zaehler[i] = 0;               //setzt Zähler auf 0, damit man weiss dass für diese Zahl noch keine Striche hinzugefügt wurden
+    }
+
+    strichliste_erstellen(strichlisten, zaehler);
+    ausgabe_liste((const char **)strichlisten);    //ruft die Funktionen auf, um die Listen zu erstellen und anzuzeigen
+
+    free(strichlisten);     //gibt den Hauptspeicher der Listen frei
+
+    return 0;
+}

28.2.2.c

@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>    //power
+#include <stdbool.h>
+#define MAX_LEN 100
+
+struct Zahl
+{
+    int vorkomma;
+    int nachkomma;
+    int len;
+};
+
+int EingabeKomma(struct Zahl *i)    //die Funktion gibt einen ganzzahligen Wert zurück (0 für Erfolg, 1 für Abbruch); struct Zahl *i – Erwartet einen Zeiger auf eine Zahl-Struktur
+{
+    char str[MAX_LEN];               //Reserviert einen Zeichenarray mit der Länge MAX_LEN
+    fgets(str, MAX_LEN, stdin);  //fgets() liest eine ganze Zeile vom Standard-Input (stdin) ein; str – Der Puffer, in den der Text geschrieben wird
+
+    if (str[0] == '\n')
+    {
+        return 1;
+    }
+
+    sscanf(str, "%d,%d", &i->vorkomma, &i->nachkomma);
+
+    char *str2 = strtok(str, ",");
+    str2 = strtok(NULL, ",");   //strtok() verändert den Original-String direkt
+
+    i->len = strlen(str2);         ////strlen() – Bestimmt die Länge des Nachkommateils (str2)
+    if (str2[i->len - 1] == '\n')   //i->len - 1: Der letzte Buchstabe hat den Index Länge - 1
+    {
+        i->len--;   //Wenn '\n' gefunden wird, wird die Länge um 1 reduziert
+    }
+
+    return 0;
+}
+
+void Kommaaddieren(struct Zahl *sum, struct Zahl *summand)    //Diese Funktion addiert eine neue Kommazahl (summand) zur bestehenden Summe (sum)
+{
+    if (summand->len > sum->len)
+    {
+        for (int i = 0; i < (summand->len - sum->len); i++)  //Multipliziert den Nachkommateil der Summe so oft mit 10, bis beide die gleiche Anzahl an Nachkommastellen haben
+        {
+            sum->nachkomma *= 10;
+        }
+        sum->len = summand->len;   //Passt die Länge der Summe an die des Summanden an, damit die Addition korrekt funktioniert
+    }
+    else if (summand->len < sum->len)    //Prüft, ob die Nachkommastellen des Summanden länger sind als die der aktuellen Summe
+    {
+        for (int i = 0; i < (sum->len - summand->len); i++)
+        {
+            summand->nachkomma *= 10;
+        }
+    }
+
+    sum->nachkomma += summand->nachkomma;
+
+    int power_of_ten = 1;
+    for (int i = 0; i < sum->len; i++)
+    {
+        power_of_ten *= 10;
+    }
+
+    if (sum->nachkomma >= power_of_ten)    // Wenn die Nachkommastellen größer oder gleich 10^len sind:
+    {
+        sum->nachkomma -= power_of_ten;
+        sum->vorkomma += 1;
+    }
+
+    sum->vorkomma += summand->vorkomma;
+}
+
+void AusgabeKomma(struct Zahl *sum)
+{
+    printf("Ergebnis:\n%d,", sum->vorkomma);
+    printf("%0*d", sum->len, sum->nachkomma);
+}
+
+int AnzahlNachkommastellen(struct Zahl *i)
+{
+    int temp = i->nachkomma;
+    int len = 0;
+
+    if (temp == 0)
+    {
+        return 1;
+    }
+
+    while (temp > 0)
+    {
+        len++;
+        temp /= 10;
+    }
+    return len;
+}
+
+int main()
+{
+    struct Zahl sum = {0, 0, 0};
+    struct Zahl summand = {0, 0, 0};
+
+    bool abbruch = false;
+    printf("Bitte gib eine deutsche Kommazahl ein:\n");
+
+    while (!abbruch)
+    {
+        abbruch = EingabeKomma(&summand);
+        if (!abbruch)
+        {
+            Kommaaddieren(&sum, &summand);
+        }
+    }
+
+    AusgabeKomma(&sum);
+    return 0;
+}

28.4.4.c

@@ -0,0 +1,114 @@
+#include <stdio.h>
+#include <string.h>
+
+#define ANZ_SCHUELER 30
+
+typedef struct
+{
+    char name[10];
+    char vorname[10];
+    unsigned note;
+} Person;
+
+int eingabe(Person *p, int i)
+{
+    printf("---Eingabe des %d. Schuelers----\n", i);
+    printf("Name: ");
+    fgets(p->name, sizeof(p->name), stdin);
+    if (p->name[strlen(p->name) - 1] == '\n')
+    {
+        p->name[strlen(p->name) - 1] = '\0';
+    }
+
+    if (strlen(p->name) == 0)
+    {
+        return 0;
+    }
+
+    printf("Vorname: ");
+    fgets(p->vorname, sizeof(p->vorname), stdin);
+    if (p->vorname[strlen(p->vorname) - 1] == '\n')
+    {
+        p->vorname[strlen(p->vorname) - 1] = '\0';
+    }
+
+    if (strlen(p->vorname) == 0)
+    {
+        return 0;
+    }
+
+    printf("Note: ");
+    if (scanf("%u", &p->note) != 1 || p->note < 0 || p->note > 6)
+    {
+        return 0;
+    }
+    while (getchar() != '\n');
+
+    return 1;
+}
+
+float durchschnittsnote(Person *n, int anzahl)
+{
+    float sum = 0;
+    float durchschnitt;
+    for (int i = 0; i < anzahl; ++i)
+    {
+        sum += n[i].note;
+    }
+    durchschnitt = sum / anzahl;
+    return durchschnitt;
+
+}
+
+void notenspiegel(Person *n, int anzahl)
+{
+    int notenHaeufigkeit[6] = {0};
+
+    for (int i = 0; i < anzahl; ++i)
+    {
+        notenHaeufigkeit[n[i].note - 1]++;
+    }
+
+    printf("\nNotenspiegel:\n");
+    for (int i = 0; i < 6; ++i)
+    {
+        printf("Note %d: ", i + 1);
+        for (int j = 0; j < notenHaeufigkeit[i]; ++j)
+        {
+            printf("*");
+        }
+        printf("\n");
+    }
+}
+
+void printListe(Person *liste, int anzahl)
+{
+    printf("Name \t\t ,Vorname \t\t ,Note ");
+    printf("\n------------------------------------------------------------------------\n");
+    for (int i = 0; i < anzahl; ++i)
+    {
+        if (strlen(liste[i].name) > 0)
+        {
+            printf("%s \t\t ,%s \t\t ,%u\n", liste[i].name, liste[i].vorname, liste[i].note);
+        }
+    }
+}
+
+int main()
+{
+    Person schueler[ANZ_SCHUELER];
+    int i;
+
+    for (i = 0; i < ANZ_SCHUELER; ++i)
+    {
+        if (!eingabe(&schueler[i], i + 1))
+        {
+            break;
+        }
+    }
+
+    printListe(schueler, i);
+    printf("Durchschnittsnote = %2.f ", durchschnittsnote(schueler, i));
+    notenspiegel(schueler,i);
+    return 0;
+}

28.5.2.c

@@ -0,0 +1,76 @@
+#include <stdio.h>
+
+struct zeit    // Struktur "zeit", die aus vier ganzen Zahlen (int) besteht --> Container, in dem wir verschiedene Daten zusammenfassen können
+{
+    int tag;   // Anzahl Tage
+    int std;   // Anzahl Stunden
+    int min;   // Anzahl Minuten
+    int sek;   // Anzahl Sekunden
+};
+
+unsigned long zeit_in_sek (struct zeit z)   //Zeit-Struktur; unsigned long weil Zahl groß sein kann; Gesamtzeit in sek
+{
+    int gesamtSek = (z.tag*86400) + (z.std*3600) + (z.min*60) + (z.sek);   // Umrechnungen in sek. --> z. greift auf Zeit-Struktur
+    return gesamtSek;
+}
+
+struct zeit sek_in_zeit (unsigned long sek) // Ausgabe: Zeit-Struktur, die sek. in Tage, Stunden, Minuten angibt
+{
+    struct zeit umrechnung;
+    umrechnung.tag = sek / 86400;   // Tage berechnen
+    sek %= 86400;                   // Rest berechnen und übrig lassen für weitere Berechnung
+    umrechnung.std = sek / 3600;    // Stunden berechnen
+    sek %= 3600;                    // Rest berechnen und übrig lassen für weitere Berechnung
+    umrechnung.min = sek / 60;      // Minuten berechnen
+    umrechnung.sek = sek % 60;      // Rest der übrig gebliebenen Sekunden
+    return umrechnung;
+}
+
+int ueberpruefe (struct zeit eingabe)  // Überprüft die Eingabe, ob alle Eintragungen im erlaubten Bereich sind
+{
+    // Erlaubte Stunden 0-23; Erlaubte Minuten 0-59; Erlaubte Sekunden 0-59 --> Alles darüber ist ungültig
+    if (eingabe.std < 0 || eingabe.std >= 24 || eingabe.min < 0 || eingabe.min >= 60 || eingabe.sek < 0 || eingabe.sek >= 60)
+    {
+        return 0;
+    }
+    else return 1;
+}
+
+int main()
+{
+    struct zeit zeit1;    // Eingabezeit 1
+    struct zeit zeit2;    // Eingabezeit 2
+    struct zeit zeitAdd;  // Ergebnis der Addition
+    printf("Gib 1. Zeit ein: (tt.hh.mm.ss): ");
+
+    if (scanf("%d.%d.%d.%d", &zeit1.tag, &zeit1.std, &zeit1.min, &zeit1.sek)!=4)  //4 Angaben getrennt durch Punkt --> !=4 prüft ob genau 4 Zahlen eingegeben wurden
+    {
+        return 0;   //Programm beendet
+    }
+
+    if (ueberpruefe(zeit1)==0)  //Prüft ob die Eingaben im gültigen Bereich liegen
+    {
+        return 0;  //Programm beendet
+    }
+
+    printf("Gib 2. Zeit ein: (tt.hh.mm.ss): ");  //Selber Ablauf für 2 Eingabe
+
+    if (scanf("%d.%d.%d.%d", &zeit2.tag, &zeit2.std, &zeit2.min, &zeit2.sek)!=4)
+    {
+        return 0;
+    }
+
+    if (ueberpruefe(zeit2)==0)
+    {
+        return 0;
+    }
+
+    int gesamtSec1 = zeit_in_sek(zeit1);  //Rechnet 1. Eingabe in Sekunden um
+    int gesamtSec2 = zeit_in_sek(zeit2);  //Rechnet 2. Eingabe in Sekunden um
+    int gesamtSec = gesamtSec1+gesamtSec2;  //Addiert beide Sekundenzahlen
+    zeitAdd = sek_in_zeit(gesamtSec);    //Wandelt Sekunden in Zeit-Struktur --> Ausgabe in Tage, Stunden, Minuten, Sekunden, Gesamtsekunden
+
+    printf("\n...... = %d Tage,%d: %d.%d; %d Gesamtsekunden", zeitAdd.tag, zeitAdd.std, zeitAdd.min, zeitAdd.sek, gesamtSec);
+
+    return 0;
+}

28.6.2.c

@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct Eintrag
+{
+    char name[25];
+    char tel[15];
+    struct Eintrag *naechster_Name;
+    struct Eintrag *naechste_Tel;
+    struct Eintrag *vorheriger_Name;
+    struct Eintrag *vorheriger_Tel;
+} Eintrag;
+
+
+void einfuegen(Eintrag **Anfang_Name, Eintrag **Anfang_Tel, char name[], char tel[])
+{
+    Eintrag *neuerEintrag = (Eintrag *)malloc(sizeof(Eintrag));
+    strcpy(neuerEintrag->name, name);
+    strcpy(neuerEintrag->tel, tel);
+    neuerEintrag->naechster_Name = NULL;
+    neuerEintrag->naechste_Tel = NULL;
+
+    Eintrag *aktuellerEintrag_Name = *Anfang_Name;
+    Eintrag *vorherigerEintrag_Name = NULL;
+
+    while (aktuellerEintrag_Name != NULL && strcmp(aktuellerEintrag_Name->name, neuerEintrag->name) < 0)
+    {
+        vorherigerEintrag_Name = aktuellerEintrag_Name;
+        aktuellerEintrag_Name = aktuellerEintrag_Name->naechster_Name;
+    }
+    if (vorherigerEintrag_Name == NULL)
+    {
+        neuerEintrag->naechster_Name = *Anfang_Name;
+        *Anfang_Name = neuerEintrag;
+    }
+    else
+    {
+        neuerEintrag->naechster_Name = aktuellerEintrag_Name;
+        vorherigerEintrag_Name->naechster_Name = neuerEintrag;
+    }
+    if (neuerEintrag->naechster_Name != NULL)
+    {
+        neuerEintrag->naechster_Name->vorheriger_Name = neuerEintrag;
+    }
+    Eintrag *aktuellerEintrag_tel = *Anfang_Tel;
+    Eintrag *vorherigerEintrag_tel = NULL;
+
+    while (aktuellerEintrag_tel != NULL && strcmp(aktuellerEintrag_tel->tel, neuerEintrag->tel) < 0)
+    {
+        vorherigerEintrag_tel = aktuellerEintrag_tel;
+        aktuellerEintrag_tel = aktuellerEintrag_tel->naechste_Tel;
+    }
+    if (vorherigerEintrag_tel == NULL)
+    {
+        neuerEintrag->naechste_Tel = *Anfang_Tel;
+        *Anfang_Tel = neuerEintrag;
+    }
+    else
+    {
+        neuerEintrag->naechste_Tel = aktuellerEintrag_tel;
+        vorherigerEintrag_tel->naechste_Tel = neuerEintrag;
+    }
+
+    if (neuerEintrag->naechste_Tel != NULL)
+    {
+        neuerEintrag->naechste_Tel->vorheriger_Tel = neuerEintrag;
+    }
+}
+
+void ausgebenNachName(Eintrag *Anfang_Name)
+{
+    printf("....Liste nach Namen sortiert..........\n");
+    while (Anfang_Name != NULL)
+    {
+        printf("%s \t (Tel. %s)\n", Anfang_Name->name, Anfang_Name->tel);
+        Anfang_Name = Anfang_Name->naechster_Name;
+    }
+}
+
+void ausgebenNachTel(Eintrag *Anfang_Tel)
+{
+    printf("....Liste nach Telefonnummern sortiert..........\n");
+
+    while (Anfang_Tel != NULL)
+    {
+        printf("(Tel. %s) \t %s\n", Anfang_Tel->tel, Anfang_Tel->name);
+        Anfang_Tel = Anfang_Tel->naechste_Tel;
+    }
+
+    printf("\n");
+}
+
+void speicherfreigeben(Eintrag *Anfang_Name)
+{
+    Eintrag *aktuellerEintrag = Anfang_Name;
+    Eintrag *naechsterEintrag;
+
+    while (aktuellerEintrag != NULL)
+    {
+        naechsterEintrag = aktuellerEintrag->naechster_Name;
+        free(aktuellerEintrag);
+        aktuellerEintrag = naechsterEintrag;
+    }
+}
+
+int main()
+{
+    struct Eintrag *head_name = NULL;
+    struct Eintrag *head_telefon = NULL;
+
+    char name[50];
+    char telefonnummer[15];
+    char eingabe;
+
+    do
+    {
+        printf("Namens- und Telefonliste\n");
+        printf("========================\n");
+        printf("N Einfügen neuer Namen mit Telefonnummer\n");
+        printf("A Ausgeben der Liste\n");
+        printf("E Ende Deine Wahl: ");
+        if (scanf(" %c", &eingabe) != 1)
+        {
+            return 0;
+        }
+        getchar();
+
+        if (eingabe == 'N' || eingabe == 'n')
+        {
+            while (1)
+            {
+                printf("Name: ");
+                fgets(name, sizeof(name), stdin);
+                if (name[0] == '\n')
+                {
+                    break;
+                }
+                if (name[strlen(name) - 1] == '\n')
+                {
+                    name[strlen(name) - 1] = '\0';
+                }
+                printf("Tel: ");
+                fgets(telefonnummer, sizeof(telefonnummer), stdin);
+                if (telefonnummer[strlen(telefonnummer) - 1] == '\n')
+                {
+                    telefonnummer[strlen(telefonnummer) - 1] = '\0';
+                }
+                einfuegen(&head_name, &head_telefon, name, telefonnummer);
+            }
+        }
+
+        if (eingabe == 'A' || eingabe == 'a')
+        {
+            ausgebenNachName(head_name);
+            ausgebenNachTel(head_telefon);
+        }
+        printf("\n");
+
+    } while (eingabe != 'E' && eingabe != 'e');
+
+    return 0;
+}

28.6.c

@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LEN 100
+
+typedef struct listElement {
+    char name[LEN];
+    struct listElement *next;
+} listElement;
+
+typedef struct {
+    listElement *head;
+} liste;
+
+listElement *eingabeName() {
+    listElement *name = malloc(sizeof(listElement));
+    if (name == NULL) {
+        printf("Speicher konnte nicht zugewiesen werden.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Name: ");
+    fgets(name->name, LEN, stdin);
+    name->next = NULL;
+
+    if (strcmp(name->name, "\n") == 0) {
+        free(name);
+        return NULL;
+    }
+
+    if (name->name[strlen(name->name) - 1] == '\n') {
+        name->name[strlen(name->name) - 1] = '\0';
+    }
+
+    return name;
+}
+
+void einfuegenName(listElement *newElement, liste *liste1, liste *liste2) {
+    int index;
+    printf("\tWelche Liste (1 oder 2): ");
+    if (scanf("%d", &index) != 1 || index < 1 || index > 2) {
+        printf("Falsche Eingabe.\n");
+        exit(EXIT_FAILURE);
+    }
+    getchar();
+
+    listElement **targetList = (index == 1) ? &liste1->head : &liste2->head;
+
+    listElement *temp = *targetList;
+    if (temp == NULL) {
+        *targetList = newElement;
+    } else {
+        while (temp->next != NULL) {
+            temp = temp->next;
+        }
+        temp->next = newElement;
+    }
+}
+
+void sortiereListe(liste *lst) {
+    if (!lst->head) return;
+    listElement *current, *index;
+    char temp[LEN];
+
+    for (current = lst->head; current->next != NULL; current = current->next) {
+        for (index = current->next; index != NULL; index = index->next) {
+            if (strcmp(current->name, index->name) > 0) {
+                strcpy(temp, current->name);
+                strcpy(current->name, index->name);
+                strcpy(index->name, temp);
+            }
+        }
+    }
+}
+
+void mergeLists(liste *liste1, liste *liste2, liste *mergedList) {
+    listElement *temp;
+
+    for (temp = liste1->head; temp != NULL; temp = temp->next) {
+        listElement *newElement = malloc(sizeof(listElement));
+        strcpy(newElement->name, temp->name);
+        newElement->next = mergedList->head;
+        mergedList->head = newElement;
+    }
+
+    for (temp = liste2->head; temp != NULL; temp = temp->next) {
+        listElement *newElement = malloc(sizeof(listElement));
+        strcpy(newElement->name, temp->name);
+        newElement->next = mergedList->head;
+        mergedList->head = newElement;
+    }
+}
+
+void printliste(liste *lst) {
+    listElement *temp = lst->head;
+    while (temp != NULL) {
+        printf("%s\n", temp->name);
+        temp = temp->next;
+    }
+}
+
+int main() {
+    liste liste1 = {NULL};
+    liste liste2 = {NULL};
+    liste gemischteListe = {NULL};
+
+    listElement *name;
+    while ((name = eingabeName()) != NULL) {
+        einfuegenName(name, &liste1, &liste2);
+    }
+
+    sortiereListe(&liste1);
+    sortiereListe(&liste2);
+
+    mergeLists(&liste1, &liste2, &gemischteListe);
+    sortiereListe(&gemischteListe);
+
+    printf("\n......1. Liste......\n");
+    printliste(&liste1);
+    printf("....Listenende....\n");
+
+    printf("\n......2. Liste......\n");
+    printliste(&liste2);
+    printf("....Listenende....\n");
+
+    printf("\n....Gemischte Liste....\n");
+    printliste(&gemischteListe);
+    printf("....Listenende....\n");
+
+    return 0;
+}}

29.1.c

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <string.h>
+
+// Aufzählung der Säuren
+typedef enum
+{
+    Salzsaure,
+    Schwefelsaure,
+    Salpetersaure,
+    Kohlensaure
+} Saeure;
+
+// Aufzählung der Laugen
+typedef enum
+{
+    Natronlauge,
+    Kalilauge,
+    Kalkwasser
+} Lauge;
+
+// Namen der Säuren für die Ausgabe
+char *Saeuren[] = {"Salzsäure", "Schwefelsäure", "Salpetersäure", "Kohlensäure"};
+
+// Namen der Laugen für die Ausgabe
+char *Laugen[] = {"Natronlauge", "Kalilauge", "Kalkwasser"};
+
+// Ergebnisse der Reaktionen (Laugen x Säuren = 3 x 4 = 12 Einträge)
+char *Ausgabe[] = {
+    " Natriumchlorid", " Natriumsulfat", " Natriumnitrat", " Natriumcarbonat",
+    " Kaliumchlorid", "  Kaliumsulfat", "  Kaliumnitrat", " Kaliumcarbonat",
+    " Calciumchlorid", " Calciumsulfat", " Calciumnitrat", " Calciumcarbonat"
+};
+
+int main()
+{
+    Saeure b;
+    Lauge a;
+
+    // Tabellenkopf: Säuren als Spaltenüberschriften
+    printf("\t \t");
+    printf("||  ");
+
+    for (b = Salzsaure; b < Kohlensaure; b++)
+    {
+        printf(" %s", Saeuren[b]); // Säurename ausgeben
+        printf("\t");
+        printf("|");
+    }
+    printf(" %s |", Saeuren[3]); // Letzte Säure extra ausgeben (weil Schleife nur bis <)
+    printf("\n");
+
+    // Trennlinie unter dem Kopf
+    printf("---------------------------------------------------------------------------------|");
+
+    // Für jede Lauge (Zeilen)
+    for (a = Natronlauge; a <= Kalkwasser; ++a)
+    {
+        printf("\n");
+        printf("%s\t||", Laugen[a]); // Laugenname links am Rand
+
+        // Für jede Säure (Spalten)
+        for (b = Salzsaure; b <= Kohlensaure; ++b)
+        {
+            // Index berechnen: (Lauge * 4) + Säure
+            // 4 Säuren pro Lauge = 4 Spalten pro Zeile
+            printf(Ausgabe[b + a * 4]); // Reaktionsprodukt ausgeben
+            printf("| ");
+        }
+        printf("\n");
+    }
+
+    return 0;
+}

30.1.3.c

@@ -0,0 +1,98 @@
+#include <stdio.h>
+#include <string.h>
+
+#define MAXLEN 50
+
+
+void getstring(char *ptr)
+{
+    fgets(ptr, MAXLEN, stdin);              // Liest bis zu MAXLEN Zeichen aus der Standardeingabe
+    ptr[strcspn(ptr, "\n")] = '\0';       // Ersetzt das '\n' Zeichen durch '\0' (String-Ende)
+    fflush(stdin);                          // Leert den Eingabepuffer
+}
+
+// Funktion zur Eingabe der Adressdaten
+// Gibt die Anzahl der gewünschten Wiederholungen zurück oder 0 bei fehlerhafter Eingabe
+int eingabe(char *vorname, char *nachname, char *strasse, char *wohnort, char *hausnr, int *postleitzahl, char *telefon, char *fax)
+{
+    printf("Vorname\t\t:");
+    getstring(vorname);
+
+    printf("Nachname\t:");
+    getstring(nachname);
+
+    printf("Strasse\t\t:");
+    getstring(strasse);
+
+    printf("Hausnummer\t:");
+    getstring(hausnr);
+
+    printf("Postleitzahl\t:");
+    // Überprüft die Eingabe auf einen gültigen Integer
+    if(scanf("%d", postleitzahl) != 1)
+    {
+        return 0;  // Fehler bei der Eingabe
+    }
+
+    fflush(stdin);  // Eingabepuffer leeren
+
+    printf("Wohnort\t\t:");
+    getstring(wohnort);
+
+    printf("Telefon\t\t:");
+    getstring(telefon);
+
+    printf("Fax\t\t:");
+    getstring(fax);
+
+    printf("Wie oft soll die Adresse in die Datei geschrieben werden?\t:");
+    int anzahl;
+    // Überprüft die Eingabe auf einen gültigen Integer
+    if(scanf("%d", &anzahl) != 1)
+    {
+        return 0;  // Fehler bei der Eingabe
+    }
+
+    return anzahl;  // Gibt die Anzahl der Wiederholungen zurück
+}
+
+int main()
+{
+    // Öffnet die Datei "datei.txt" im Anhangmodus ("a")
+    FILE *ziel;
+    ziel = fopen("datei.txt", "a");
+
+    // Überprüft, ob die Datei erfolgreich geöffnet wurde
+    if (ziel == NULL)
+    {
+        printf("Fehler beim Öffnen der Datei\n");
+        return 1;  // Fehlercode 1: Datei konnte nicht geöffnet werden
+    }
+
+    // Definition der Variablen für die Adressdaten
+    char vorname[MAXLEN], nachname[MAXLEN], strasse[MAXLEN], wohnort[MAXLEN], hausnr[MAXLEN], telefon[MAXLEN], fax[MAXLEN];
+    int postleitzahl, anzahl;
+
+    // Ruft die Eingabefunktion auf und prüft, ob die Eingabe erfolgreich war
+    if((anzahl = eingabe(vorname, nachname, strasse, wohnort, hausnr, &postleitzahl, telefon, fax)) == 0)
+    {
+        return 0;  // Fehlerhafte Eingabe, Programm wird beendet
+    }
+
+    // Schreibt einen Trenner in die Datei
+    fprintf(ziel, "-----------------------------------------------------\n");
+
+    // Schleife zum mehrfachen Schreiben der Daten in die Datei
+    for (int i = 0; i < anzahl; i++)
+    {
+        fprintf(ziel, "%s %s\n", vorname, nachname);                // Vorname und Nachname
+        fprintf(ziel, "%s %s\n", strasse, hausnr);                  // Straße und Hausnummer
+        fprintf(ziel, "%d %s\n\n", postleitzahl, wohnort);         // Postleitzahl und Wohnort
+        fprintf(ziel, "Tel. %s\n", telefon);                        // Telefonnummer
+        fprintf(ziel, "Fax  %s\n", fax);                            // Faxnummer
+        fprintf(ziel, "-----------------------------------------------------\n");
+    }
+
+    fclose(ziel);  // Schließt die Datei
+    return 0;      // Programmende
+}

MA3/josephus.c

@@ -0,0 +1,57 @@
+/**********************************************************************\
+* Kurzbeschreibung:
+* Realisiert das Josephus Spiel zum Test einer Queue
+* 
+* Datum:     Autor:
+* 30.9.2015  Prof. Dr. Helmut Herold
+*
+\**********************************************************************/
+
+/*--- #includes ------------------------------------------------------*/
+#define _CRT_SECURE_NO_WARNINGS //VC++: keine scanf() Warnungen
+#include <stdio.h>              // Einbinden der Standard-Ein-/Ausgabefunktionen
+#include "queue.h"              // Einbinden der selbstgeschriebenen Queue-Funktionen
+
+/*--- #defines -------------------------------------------------------*/
+
+/*--- Datentypen (typedef) -------------------------------------------*/
+
+/*--- Prototypen lokaler Funktionen ----------------------------------*/
+
+/*--- main -----------------------------------------------------------*/
+int main(void)
+{
+   int n, z, i=1, nr; // n = Personenanzahl, z = wievielte wird entfernt, i = Laufvariable, nr = zum Prüfen von scanf
+
+   // Abfrage wie viele Personen mitspielen, solange wiederholen bis richtige Zahl eingegeben wurde
+   do {
+      printf("Wie viele Personen: ");  // Frage ausgeben
+      nr = scanf("%d", &n); getchar(); // Zahl einlesen und Eingabe bestätigen lassen
+   } while (nr != 1 || n < 0);         // solange wiederholen bis gültige Zahl
+
+   // Abfrage wievielte Person entfernt wird, auch hier wird auf korrekte Eingabe geprüft
+   do {
+      printf("Wie vielte ist auszusondern: "); // Frage ausgeben
+      nr = scanf("%d", &z); getchar();         // Zahl einlesen und Eingabe bestätigen lassen
+   } while (nr != 1 || z < 0);                // solange wiederholen bis gültige Zahl
+
+   // Die Queue wird mit Zahlen von 1 bis n gefüllt
+   for (i = 1; i <= n; i++) // von 1 bis n
+      put(i);               // füge die Zahl in die Queue ein
+
+   // Solange die Queue nicht leer ist (also noch Personen da sind)
+   while (!isEmpty()) {
+      // Wiederhole z-1 mal: hole die vorderste Zahl aus der Queue und füge sie hinten wieder ein
+      for (i = 1; i < z; i++) {
+         if (put(get()) == FALSE) {    // Zahl nach hinten verschieben, wenn das schief geht:
+            fprintf(stderr, "Fehler beim Einfügen\n"); // Fehlermeldung
+            return 1;                  // Programm abbrechen mit Fehler
+         }
+      }
+      // Jetzt hole die vorderste Zahl (die z-te) und gib sie aus (sie wird entfernt)
+      printf("%d, ", get());      // Zahl ausgeben und aus Queue entfernen (nicht mehr einfügen)
+   }
+   printf("\n"); // Zeilenumbruch am Ende
+
+   return 0;     // Programm endet erfolgreich
+}

MA3/queue.c

@@ -0,0 +1,122 @@
+/**********************************************************************\
+* Kurzbeschreibung:
+* queue.c - realisiert eine Queue (Warteschlange)
+*
+* Datum:     Autor:
+* 
+*
+\**********************************************************************/
+
+/*--- #includes ------------------------------------------------------*/
+#include <stdio.h>      // Standard Ein-/Ausgabe
+#include <stdlib.h>     // Für malloc und free
+#include "queue.h"      // Für die Typen und Funktionsdeklarationen
+
+/*--- Modulglobale static Variablen ----------------------------------*/
+// Das sind Zeiger auf das erste und letzte Element der Queue.
+// Sie sind nur hier sichtbar (static = nur in dieser Datei).
+static Queue_Elem *Anfang_Element = NULL; // Zeigt auf das erste Element in der Queue
+static Queue_Elem *Ende_Element = NULL;   // Zeigt auf das letzte Element in der Queue
+
+/*--------------------------------------------------------------------*\
+ * Einfuegen in Liste
+ * Parameter:
+ *    zahl  fügt die übergebene Zahl 'zahl' am Ende der Liste ein
+ * Return Wert:
+ *    TRUE  wenn noch genug Speicherplatz vorhanden
+ *    FALSE wenn kein Speicherplatz mehr allokiert werden konnte
+ *--------------------------------------------------------------------*/
+Bool put(int zahl)
+{
+    // Speicherplatz für ein neues Element anfordern
+    Queue_Elem* neues_Element = (Queue_Elem*)malloc(sizeof(Queue_Elem));
+
+    // Prüfen, ob der Speicher angelegt werden konnte
+    if (neues_Element == NULL)
+    {
+        return FALSE; // Fehler, kein Speicher mehr
+    }
+    else
+    {
+        neues_Element->wert = zahl;            // Wert setzen
+        neues_Element->Element_next = NULL;    // Nächstes Element gibt es noch nicht
+        neues_Element->Element_prev = NULL;    // Vorheriges Element gibt es noch nicht
+
+        // Wenn Queue noch leer ist (erstes Element)
+        if (Anfang_Element == NULL)
+        {
+            Anfang_Element = neues_Element; // Sowohl Anfang als auch Ende zeigen auf das neue Element
+            Ende_Element = neues_Element;
+        }
+        else // Sonst: Am Ende anhängen
+        {
+            if (Ende_Element != NULL)
+            {
+                Ende_Element->Element_next = neues_Element; // Das aktuelle Ende zeigt auf das neue Element
+                neues_Element->Element_prev = Ende_Element; // Das neue Element weiß, was vorher war
+                Ende_Element = neues_Element;               // Das neue Element ist jetzt das Ende
+            }
+        }
+    }
+    return TRUE; // Hat geklappt!
+}
+
+/*--------------------------------------------------------------------*\
+ * Auslesen aus Liste
+ * Parameter:
+ *    keine
+ * Return Wert:
+ *    Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
+ *--------------------------------------------------------------------*/
+int get(void)
+{
+   int zahl;
+   // Zeiger auf das erste Element (wird gleich gelöscht)
+   Queue_Elem* temp = Anfang_Element;
+
+   // Wenn mindestens ein Element in der Queue ist
+   if(Anfang_Element != NULL && Ende_Element != NULL)
+   {
+      zahl = (Anfang_Element)->wert; // Wert des ersten Elements speichern
+
+      // Wenn es noch mehr als ein Element gibt
+      if(Anfang_Element->Element_next != NULL)
+      {
+         Anfang_Element->Element_next->Element_prev = NULL; // Das neue Erste zeigt auf nix vorher
+         Anfang_Element = Anfang_Element->Element_next;     // Anfang_Element zeigt jetzt auf das neue Erste
+      }
+      else // Es gibt nur ein Element (das wird jetzt gelöscht)
+      {
+         Anfang_Element = NULL;
+         Ende_Element = NULL;
+      }
+
+      free(temp); // Speicherplatz freigeben
+   }
+   else // Die Queue ist leer
+   {
+      zahl = QLEER; // Rückgabewert für "leer"
+   }
+
+   return zahl; // Zahl oder QLEER zurückgeben
+}
+
+/*--------------------------------------------------------------------*\
+ * Pruefen der Liste
+ * Parameter:
+ *    keine
+ * Return Wert:
+ *    liefert TRUE, wenn Queue leer ist, sonst FALSE
+ *--------------------------------------------------------------------*/
+Bool isEmpty(void)
+{
+   // Ist Anfang und Ende auf NULL -> Queue ist leer
+   if(Anfang_Element == NULL && Ende_Element == NULL)
+   {
+      return TRUE;
+   }
+   else
+   {
+      return FALSE;
+   }
+}

MA3/queue.h

@@ -0,0 +1,63 @@
+/**********************************************************************\
+* Kurzbeschreibung:
+* queue.h - realisiert eine Queue (Warteschlange) als verkettete Liste
+* 
+* Datum:     Autor:
+* 30.9.2015  Prof. Dr. Helmut Herold
+*
+\**********************************************************************/
+#ifndef QUEUE_H
+#define QUEUE_H
+
+/*--- #includes ------------------------------------------------------*/
+#include <limits.h>    // Für INT_MIN
+
+/*--- #defines -------------------------------------------------------*/
+#define TRUE  1
+#define FALSE 0
+#define QLEER INT_MIN   // Konstante, um "Queue ist leer" zu kennzeichnen
+
+/*--- Datentypen (typedef) -------------------------------------------*/
+typedef int Bool;      // Bool ist einfach nur ein int
+
+// Struktur für ein Queue-Element
+typedef struct Queue_Element {
+    int wert;                      // Der gespeicherte Wert (die Zahl)
+    struct Queue_Element* Element_next; // Zeiger auf das nächste Element
+    struct Queue_Element* Element_prev; // Zeiger auf das vorherige Element
+} Queue_Elem;
+
+/*--- Prototypen globaler Funktionen ---------------------------------*/
+
+/*--------------------------------------------------------------------*\
+ * Einfuegen in Liste
+ * Parameter:
+ *    zahl  fügt die übergebene Zahl 'zahl' am Ende der Liste ein
+ * Return Wert:
+ *    TRUE  wenn noch genug Speicherplatz vorhanden
+ *    FALSE wenn kein Speicherplatz mehr allokiert werden konnte
+ * Hinweis:
+ * - dynamische Verwaltung von Speicher muss mit malloc() und free()
+ *   durchgeführt werden; dynamische Arrays sind nicht erlaubt !!!
+ *--------------------------------------------------------------------*/
+Bool put(int zahl);
+
+/*--------------------------------------------------------------------*\
+ * Auslesen aus Liste
+ * Parameter:
+ *    keine
+ * Return Wert:
+ *    Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
+ *--------------------------------------------------------------------*/
+int get(void);
+
+/*--------------------------------------------------------------------*\
+ * Pruefen der Liste
+ * Parameter:
+ *    keine
+ * Return Wert:
+ *    liefert TRUE, wenn Queue leer ist, sonst FALSE
+ *--------------------------------------------------------------------*/
+Bool isEmpty(void);
+
+#endif /*QUEUE_H*/