Add solutions.

.clang-format

@@ -1,57 +0,0 @@
----
-Language: Cpp
-BasedOnStyle: LLVM
-AccessModifierOffset: -4
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignOperands: true
-AlignTrailingComments: false
-AlwaysBreakTemplateDeclarations: Yes
-BraceWrapping: 
-  AfterCaseLabel: false
-  AfterClass: false
-  AfterControlStatement: false
-  AfterEnum: false
-  AfterFunction: false
-  AfterNamespace: false
-  AfterStruct: false
-  AfterUnion: false
-  AfterExternBlock: false
-  BeforeCatch: false
-  BeforeElse: false
-  BeforeLambdaBody: false
-  BeforeWhile: false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
-BreakBeforeBraces: Custom
-BreakConstructorInitializers: AfterColon
-BreakConstructorInitializersBeforeComma: false
-ColumnLimit: 240
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ContinuationIndentWidth: 8
-IncludeCategories: 
-  - Regex: '^<.*'
-    Priority: 1
-  - Regex: '^".*'
-    Priority: 2
-  - Regex: '.*'
-    Priority: 3
-IncludeIsMainRegex: '([-_](test|unittest))?$'
-IndentCaseLabels: true
-IndentWidth: 4
-InsertNewlineAtEOF: true
-MacroBlockBegin: ''
-MacroBlockEnd: ''
-MaxEmptyLinesToKeep: 2
-NamespaceIndentation: All
-SpaceAfterCStyleCast: true
-SpaceAfterTemplateKeyword: false
-SpaceBeforeRangeBasedForLoopColon: false
-SpaceInEmptyParentheses: false
-SpacesInAngles: false
-SpacesInConditionalStatement: false
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-TabWidth: 4
-...

.gitignore

@@ -1,4 +1,3 @@
 *.zip
 *.exe
-*.o
-.idea/
+*.o

01/bmi.c

@@ -3,29 +3,38 @@
  * Body Mass Index mit zwei Nachkommastellen ausgibt (bmi = gewicht / (groesse in m)²).          *
  *************************************************************************************************/
 
-#include <stdio.h>
+ #include <stdio.h>
 
-int main() {
-    unsigned int gewicht_kg = 0;
-    unsigned int groesse_cm = 0;
 
-    printf("Geben sie ihr Gewicht in Kg ein: ");
-    scanf("%d", &gewicht_kg);
+ int main()
+ {
+    unsigned int gewichtInKg = 0;
+    unsigned int groesseInCm = 0;
+    double bmi = 0;
 
-    printf("Geben sie Ihre Groesse in cm: ");
-    scanf("%d", &groesse_cm);
+    printf("Geben Sie bitte Ihr Gewicht in Kg ein: ");
+    scanf("%d", &gewichtInKg);
 
-    printf("Gewicht: %i Kg\n", gewicht_kg);
-    printf("Groesse: %i cm\n", groesse_cm);
+    printf("Geben Sie bitte Ihre Groesse in cm ein: ");
+    scanf("%d", &groesseInCm);
 
-    double bmi = gewicht_kg / ((groesse_cm / 100.f) * (groesse_cm / 100.f));
-    printf("Fuer ein Gewicht mit %d Kg und %d cm lautet der BMI: %.2lf\n", gewicht_kg, groesse_cm, bmi);
-    if (bmi < 18.5)
-        printf("Das ist untergewichtig!");
-    else if (bmi > 25)
-        printf("Das ist uebergewichtig!");
+    bmi = gewichtInKg / ((groesseInCm / 100.0) * (groesseInCm / 100.0));
+
+    printf("Fuer ein Gewicht mit %u kg und einer Groesse von %u cm lautet der BMI %lf.\n", gewichtInKg, groesseInCm, bmi);
+    printf("Das ist ");
+
+    if(bmi < 18.5)
+    {
+        printf("Untergewicht.\n");
+    }
+    else if(bmi > 25)
+    {
+        printf("Uebergewicht.\n");
+    }
     else
-        printf("Das ist Normalgewicht.");
+    {
+        printf("Normalgewicht.\n");
+    }
 
     return 0;
-}
+ }

02/alphabet.c

@@ -0,0 +1,50 @@
+/*****************************************************************************************
+ * Schreiben Sie ein Programm, das vom Benutzer einen Buchstaben einliest und ausgibt,   *
+ * der wievielte Buchstabe im Alphabet die Eingabe ist. Groß- und Kleinschreibung sollen *
+ * keine Rolle spielen. Zudem soll das Programm vorher ausgeben, ob der Benutzer einen   *
+ * Buchstaben eingegeben hat und die Ausgabe somit richtig ist.                          *
+ *                                                                                       *
+ * 1. Beispiel:                                                                          *
+ * >> Geben Sie einen Buchstaben ein: B                                                  *
+ * Die folgende Ausgabe ist richtig, weil das Zeichen B ein Buchstabe ist: 1             *
+ * Der Buchstabe B ist der 2. Buchstabe im Alphabet.                                     *
+ *                                                                                       *
+ * 2. Beispiel:                                                                          *
+ * >> Geben Sie einen Buchstaben ein: b                                                  *
+ * Die folgende Ausgabe ist richtig, weil das Zeichen b ein Buchstabe ist: 1             *
+ * Der Buchstabe b ist der 2. Buchstabe im Alphabet.                                     *
+ *                                                                                       *
+ * 3. Beispiel:                                                                          *
+ * >> Geben Sie einen Buchstaben ein: 3                                                  *
+ * Die folgende Ausgabe ist richtig, weil das Zeichen 3 ein Buchstabe ist: 0             *
+ * Der Buchstabe 3 ist der -13. Buchstabe im Alphabet.                                   *
+ *****************************************************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "../io/myio.h"
+
+
+int main()
+{
+    unsigned char character = 'a';
+
+    while(character != '\n')
+    {
+        unsigned char lowerChar;
+
+        printf("Eingabe einzelnes Zeichen: ");
+        character = getSingleChar();
+
+        lowerChar = tolower(character);
+
+        if(lowerChar >= 'a' && lowerChar <= 'z')
+        {
+            unsigned int alphaPos = lowerChar - 'a' + 1; 
+            printf("Der Buchstabe %c liegt an %u. Stelle im Alphabet.\n", character, alphaPos);
+        }
+    }
+
+    return 0;
+}

02/anteile.c

@@ -0,0 +1,37 @@
+/****************************************************************************************************
+ * Aufgaben
+ * 1. Begeben Sie sich zunaechst ohne Compiler auf Fehlersuche. Welche Fehler können Sie entdecken? *
+ *    Wuerde das Programm uebersetzen? Wuerde das Programm korrekt laufen?                          *
+ * 2. Uebersetzen Sie nun das Programm ohne -Wall. Hilft Ihnen dies bei der Fehlersuche?            *
+ * 3. Uebersetzen Sie nun das Programme mit -Wall. Hilft Ihnen dies bei der Fehlersuche?            *
+ * 4. Finden und korrigieren Sie nun alle Fehler, sodass das Programm korrekte Ausgaben liefert.    *
+ *    Nehmen Sie dabei so wenig Veraenderungen wie moeglich vor.                                    *
+*****************************************************************************************************/
+
+#include <stdio.h>
+
+#define MAX_PUNKTE_TEIL_A 60
+#define MAX_PUNKTE_TEIL_B 44
+#define MAX_GESAMT_PUNKTE MAX_PUNKTE_TEIL_A + MAX_PUNKTE_TEIL_B
+
+int main()
+{
+    int pktTeilA, pktTeilB;
+    double ergInProzentTeilA, ergInProzentTeilB, gesamtErgInProzent;
+
+    printf("Wie viele Punkte wurden in Teil A erzielt: ");
+    scanf("%d", pktTeilA);
+
+    printf("Wie viele Punkte wurden in Teil B erzielt: ");
+    scanf("%d", pktTeilB);
+
+    ergInProzentTeilA = pktTeilA * 100 / MAX_PUNKTE_TEIL_A;
+    ergInProzentTeilB = pktTeilB * 100 / MAX_PUNKTE_TEIL_B;
+    gesamtErgInProzent = (pktTeilA + pktTeilB) * 100 / MAX_GESAMT_PUNKTE;
+
+    printf("Es wurden %d %% der moeglichen Punkte in Teil A erzielt.\n", ergInProzentTeilA);
+    printf("Es wurden %d %% der moeglichen Punkte in Teil B erzielt.\n", ergInProzentTeilB);
+    printf("Es wurden %d %% der moeglichen Punkte insgesamt erzielt.\n", gesamtErgInProzent);
+
+    return 0;
+}

02/mwst.c

@@ -0,0 +1,9 @@
+/***************************************************************************************************************
+ * Schreiben Sie ein Programm, das vom Benutzer einen Nettopreis in Euro einliest und dazu den Bruttopreis     *
+ * ausgibt. Verwenden Sie fuer die Mehrwertsteuer eine symbolische Konstante und lagern Sie diese in eine      *
+ * separate Header-Datei aus. Die Mehrwertsteuer betraegt derzeit 19 % (Buecher und Lebensmittel ausgenommen). *
+ *                                                                                                             *
+ * Beispiel:                                                                                                   *
+ * >> Geben Sie einen Nettopreis in Euro ein: 10                                                               *
+ * Der Bruttopreis betraegt 11.90 Euro                                                                         *
+ ***************************************************************************************************************/

02/rechner.c

@@ -0,0 +1,17 @@
+/************************************************************************************************
+ * Schreiben Sie ein Programm, das zwei Zahlen und anschliessend + oder - vom Benutzer einliest *
+ * und das Ergebnis der Rechenoperation ausgibt. Hinweis: Diese Aufgabe ist ohne if zu loesen,  *
+ * das erst spaeter eingefuehrt wird.                                                           *
+ *                                                                                              *
+ * 1. Beispiel:                                                                                 *
+ * >> Geben Sie die 1. Zahl ein: 2                                                              *
+ * >> Geben Sie die 2. Zahl ein: 3                                                              *
+ * >> Geben Sie die gewuenschte Rechenoperation ein (+/-): -                                    *
+ * 2 - 3 = -1                                                                                   *
+ *                                                                                              *
+ * 2. Beispiel:                                                                                 *
+ * >> Geben Sie die 1. Zahl ein: 2                                                              *
+ * >> Geben Sie die 2. Zahl ein: 3                                                              *
+ * >> Geben Sie die gewuenschte Rechenoperation ein (+/-): +                                    *
+ * 2 + 3 = 5                                                                                    *
+ ************************************************************************************************/

02/winkel.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+/***************************************************************************************************************************************
+* Schreiben Sie ein Programm, das einen Winkel in Grad als ganze Zahl einliest und diesen in rad (als Fliesskommazahl) wieder ausgibt. *
+* Nutzen Sie dabei sinnvoll mindestens eine Makro-Konstante. Der Winkel in rad soll dabei mit drei Nachkommastellen ausgegeben werden. *
+****************************************************************************************************************************************/

02/zahlenVergleich.c

@@ -0,0 +1,32 @@
+/****************************************************************************************************************
+ * Schreiben Sie ein Programm, das vom Benutzer zwei ganze, positive,                                           *
+ * dreistellige Zahlen einliest und ausgibt, ob beide Zahlen gleich sind.                                       *
+ * Dabei soll die erste Zahl mit scanf und die zweite mit getchar eingelesen                                    *
+ * werden. Zudem soll das Programm ausgeben, ob die erste Eingabe des Benutzers                                 *
+ * korrekt war.                                                                                                 *
+ *                                                                                                              *
+ * Wie erklaeren Sie sich den Verlauf des 2. Beispiels?                                                         *
+ *                                                                                                              *
+ * 1. Beispiel:                                                                                                 *
+ * >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 345                                             *
+ * Es wurde eine dreistellige, positive Zahl eingegeben: 1                                                      *
+ * >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 345                                 *
+ * 345 == 345? -> 1                                                                                             *
+ *                                                                                                              *
+ * 2. Beispiel (Hier kann man die Ausgabe ignorieren, nachdem angezeigt wurde, dass die Eingabe nicht stimmt.): *
+ * >> Geben Sie eine dreistellige, ganze und positive Zahl ein: dfg                                             *
+ * Es wurde eine dreistellige, positive Zahl eingegeben: 0                                                      *
+ * >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 0 == 5912? -> 0                     *
+ *                                                                                                              *
+ * 3. Beispiel:                                                                                                 *
+ * >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 567                                             *
+ * Es wurde eine dreistellige, positive Zahl eingegeben: 1                                                      *
+ * >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 111                                 *
+ * 567 == 111? -> 0                                                                                             *
+ *                                                                                                              *
+ * 4. Beispiel:                                                                                                 *
+ * >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 20                                              *
+ * Es wurde eine dreistellige, positive Zahl eingegeben: 0                                                      *
+ * >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 300                                 *
+ * 20 == 300? -> 0                                                                                              *
+ ****************************************************************************************************************/

03/bedingteBewertung.c

@@ -0,0 +1,36 @@
+/********************************************************************************************
+ * Bedingte Zuweisung
+ * Schreiben Sie ein Programm, das abfragt, in welchem Studiensemester Sie sich befinden 
+ * und dann ausgibt, ob Sie damit noch in Regelstudienzeit sind oder nicht.
+ * Beide Varianten der Ausgabe sollen ohne if-Anweisung in einem einzigen printf getätigt 
+ * werden. Fangen Sie ungültige Eingaben mit einer entsprechenende Fehlermeldung ab.
+ * 
+ * 1. Beispiel
+ * >> Wieviele Semester studieren Sie bereits? 2
+ * Sie studieren im 2. Semester. Damit sind Sie in Regelstudienzeit.
+ * 
+ * 2. Beispiel
+ * >> Wieviele Semester studieren Sie bereits? 8
+ * Sie studieren im 8. Semester. Damit sind Sie NICHT MEHR in Regelstudienzeit.
+ ********************************************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+#define MAX_REGULAR_SEMESTERS 7
+#define MAX_SEMESTERS_INPUT 30
+
+
+int main()
+{
+    unsigned int numberOfSemesters = 0;
+
+    while(numberOfSemesters == 0 || numberOfSemesters > MAX_SEMESTERS_INPUT)
+    {
+        numberOfSemesters = getNumber("Wie viele Semester studieren Sie bereits? ");
+    }
+
+    printf("Sie studieren %sin Regelstudienzeit.\n", (numberOfSemesters <= MAX_REGULAR_SEMESTERS) ? "" : "NICHT ");
+
+    return 0;
+}

03/castingLesen.c

@@ -0,0 +1,30 @@
+/********************************************************************************************
+ * Sehen Sie sich untenstehenden Code und markieren Sie alle Stellen mit einem Kommentar,   *
+ * an denen eine Datentypumwandlung stattfindet. Erklaeren Sie zudem, von welchem Datentyp  * 
+ * in welchen anderen umgewandelt wird und warum.                                           *
+ ********************************************************************************************/
+
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+    int punkt1x, punkt1y;
+    unsigned int punkt2x, punkt2y;
+    float zeit, geschwindigkeit;
+
+    printf("Geben Sie die Koordinaten des 1. Punkts in Metern ein (x, y): ");
+    scanf("%d, %d", &punkt1x, &punkt1y);
+
+    printf("Geben Sie die Koordinaten des 2. Punkts in Metern ein (x, y): ");
+    scanf("%u, %u", &punkt2x, &punkt2y);
+
+    printf("Geben Sie die benoetigte Zeit in Sekunden ein: ");
+    scanf("%f", &zeit);
+
+    geschwindigkeit = sqrt((punkt1x - punkt2x) * (punkt1x - punkt2x) + (punkt1y - punkt2y) * (punkt1y - punkt2y)) / zeit;
+
+    printf("Um von der Koordinate (%d, %d) nach Koordinate (%d, %d) in %.2f Sekunden zu kommen, wird eine Geschwindigkeit von %.2f m/s benoetigt.\n", punkt1x, punkt1y, (int)punkt2x, (int)punkt2y, zeit, geschwindigkeit);
+
+    return 0;
+}

03/expliztesCasting.c

@@ -0,0 +1,37 @@
+/********************************************************************************************
+ * Schreiben Sie ein Programm, das einen Preis in Euro als Kommazahl vom Benutzer abfragt 
+ * und diesen dann mittels explizitem casting in Euros und Cents zerlegt und ausgibt.
+ * Brechen Sie die Ausführung des Programms ab, wenn der Benutzer eine falsche Eingabe 
+ * (z.B. keine gültige Zahl) gemacht hat.       
+ * 
+ * 1. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: 12.53
+ * Der Preis ist 12 Euro und 53 Cents.
+ * 
+ * 2. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: abc
+ * Ungültige Eingabe!
+ ********************************************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+
+int main()
+{
+    double price = 0;
+    unsigned int priceEuro = 0;
+    unsigned int priceCents = 0;
+
+    do
+    {
+        price = getDoubleNumber("Geben Sie einen Preis ein: ");
+    } while (price < 0);
+    
+    priceEuro = (unsigned int)price;
+    priceCents = (unsigned int)((price - priceEuro)*100);
+
+    printf("Preis: %d Euros, %d Cents\n", priceEuro, priceCents);
+
+    return 0;
+}

03/ifElseGrab.c

@@ -0,0 +1,77 @@
+/********************************************************************************************
+ * If-Else Grab
+ ********************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+    int status = 201;
+    int fehler = 0;
+    int warnung = 1;
+    int aktion = 1;
+
+    /********************************************************************************************
+     * Aufgabe: Schauen Sie sich folgende if/else Konstruktion an.
+     * a) Ist diese Ihrer Meinung nach gut lesbar?
+     * b) Identifizieren Sie Pfade, die überflüssig sind bzw. niemals ausgeführt werden.
+     * c) Vereinfachen Sie den Code unter Verwendung von so wenigen Verzweigungsebenen wie
+     *    möglich, ohne die Ausgabe bzw. das Verhalten des Programms zu verändern
+     ********************************************************************************************/
+
+    if (status == 200)
+    {
+        if (fehler)
+        {
+            printf("Fehler");
+            return -1;
+        }
+
+        if (aktion == 1)
+        {
+            if (!fehler)
+            {
+                if (!warnung)
+                {
+                    printf("Aktion 1 erfolgreich ausgeführt.");
+                }
+                else if (warnung)
+                {
+                    printf("Aktion 1 mit Warnung ausgeführt.");
+                    
+                    if(status != 200)
+                    {
+                        printf("Ungültiger Status!");
+                    }
+                }
+            }
+            else
+            {
+                printf("Fehler");
+                return -1;
+            }
+        }
+        else if (aktion == 2)
+        {
+            if (!fehler)
+            {
+                printf("Aktion 2 erfolgreich ausgeführt.");
+            }
+        }
+        else
+        {
+            printf("Unbekannte Aktion");
+        }
+
+    }
+    else if (status != 200)
+    {
+        if (fehler)
+        {
+            printf("Fehler");
+            return -1;
+        }
+    }
+
+    return 0;
+}

03/taschenrechner.c

@@ -0,0 +1,41 @@
+/*************************************************************
+ * Schreiben Sie ein Programm, das zwei positive Zahlen vom  *
+ * Benutzer einliest sowie einen Rechenoperator und          *
+ * anschliessend das Ergebnis ausgibt. Bei falschen Eingaben *
+ * soll das Programm kontrolliert beendet werden.            *
+ *                                                           *
+ * 1. Beispiel:                                              *
+ * >> Geben Sie eine positive, ganze Zahl ein: 50            *
+ * >> Geben Sie noch eine positive, ganze Zahl ein: 20       *
+ * >> Geben Sie einen Rechenoperator ein (+, -, *, /): -     *
+ * 50 - 20 = 30                                              *
+ *                                                           *
+ * 2. Beispiel:                                              *
+ * >> Geben Sie eine positive, ganze Zahl ein: 50            *
+ * >> Geben Sie noch eine positive, ganze Zahl ein: 20       *
+ * >> Geben Sie einen Rechenoperator ein (+, -, *, /): +     *
+ * 50 + 20 = 70                                              *
+ *                                                           *
+ * 3. Beispiel:                                              *
+ * >> Geben Sie eine positive, ganze Zahl ein: -50           *
+ * Falsche Eingabe!                                          *
+ *                                                           *
+ * 4. Beispiel:                                              *
+ * >> Geben Sie eine positive, ganze Zahl ein: 50            *
+ * >> Geben Sie noch eine positive, ganze Zahl ein: -20      *
+ * Falsche Eingabe!                                          *
+ *                                                           *
+ * 5. Beispiel:                                              *
+ * >> Geben Sie eine positive, ganze Zahl ein: 50            *
+ * >> Geben Sie noch eine positive, ganze Zahl ein: 20       *
+ * >> Geben Sie einen Rechenoperator ein (+, -, *, /): dfgfd *
+ * Unbekannter Rechenoperator d                              *
+ *************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}

03/verkehrsteilnehmer.c

@@ -0,0 +1,34 @@
+/********************************************************************************************
+ * Verkehrsteilnehmer
+ * 
+ * In einer Verkehrssimulation gibt es Fußgänger, Fahrräder, PKW, LKW/Bus und Motorräder.
+ * Schreiben Sie ein Programm, dass die Merkmale "Anzahl Räder" und "motorisiert" vom
+ * Benutzer abfragt und einen Verkehrsteilnehmer anhand dieser Merkmale identifiziert. 
+ * Hinweise: Fußgänger haben 0 Räder, LKW/Bus haben eine gerade Anzahl Räder > 4.
+ * Für eine nicht existierende Merkmalskombination geben Sie eine entsprechende 
+ * Meldung aus!
+ * 
+ * 1. Beispiel
+ * >> Wieviele Räder? 2
+ * >> Motorisiert? 0
+ * Es handelt sich um ein Fahrrad.
+ * 
+ * 2. Beispiel
+ * >> Wieviele Räder? 0
+ * >> Motorisiert? 1
+ * Es handelt sich um ein unbekannten Verkehrsteilnehmer.
+ * 
+ * 3. Beispiel
+ * >> Wieviele Räder? 6
+ * >> Motorisiert? 1
+ * Es handelt sich um einen Bus oder LKW.
+ * 
+ ********************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+    
+    return 0;
+}

04/asciiTabelle.c

@@ -0,0 +1,30 @@
+/********************************************************************************************
+ * Ascii-Tabelle
+ * 
+ * Schreiben Sie ein Programm, das zwei Zeichen abfragt und dann alle Zeichen der Ascii-
+ * Tabelle ausgibt, die zwischen diesen zwei Zeichen liegen. Falls das Ende der Ascii-Tabelle 
+ * erreicht wird, soll die Ausgabe wieder am Anfang beginnen! Geben Sie nur sichtbare Zeichen
+ * aus, keine Kontrollzeichen (Hinweis: Sie können die Funktion iscntrl() aus ctype.h dafür 
+ * verwenden).
+ * 
+ * 1. Beispiel:
+ * >> Geben Sie ein einzelnes Zeichen ein: C
+ * >> Geben Sie noch ein einzelnes Zeichen ein: c
+ * Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
+ * DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab
+ * 
+ * 2. Beispiel:
+ * >> Geben Sie ein einzelnes Zeichen ein: c
+ * >> Geben Sie noch ein einzelnes Zeichen ein: C
+ * Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
+ * defghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@AB
+ *********************************************************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+
+int main()
+{
+
+    return 0;
+}

04/binaerUmrechnungSchleife1.c

@@ -0,0 +1,48 @@
+/***********************************************************************************
+ * Aufgabe                                                                         *
+ * Schreiben Sie ein Programm, das eine ganze Zahl einliest und die Rechenschritte *
+ * anzeigt, um die Bits der entsprechenden Binaerzahl zu ermitteln. Nutzen Sie     *
+ * eine geeignete Schleife, sodass das Programm alle Stellen der Binärzahl anzeigt.*
+ * Lesen Sie zudem solange ein, bis eine positive Zahl eingegeben wird.            *
+ *                                                                                 *
+ * Beispiel:                                                                       *
+ * >> Geben Sie eine ganze, positive Zahl ein: abc                                 *
+ * >> Geben Sie eine ganze, positive Zahl ein: -5                                  *
+ * >> Geben Sie eine ganze, positive Zahl ein: 21                                  *
+ *  21 / 2 =   10, Rest:    1                                                      *
+ *  10 / 2 =    5, Rest:    0                                                      *
+ *   5 / 2 =    2, Rest:    1                                                      *
+ *   2 / 2 =    1, Rest:    0                                                      *
+ *                                                                                 *
+ * Schreiben Sie danach das Programm so um, dass es Bit- und Shiftoperatoren       *
+ * verwendet sowie negative Zahlen verarbeiten kann. Die Rechenschritte werden     *
+ * nicht mehr anzeigt, sondern nur noch das Bitmuster aller gespeicherten Bits.    *
+ *                                                                                 *
+ * Beispiele:                                                                      *
+ * >> Geben Sie eine ganze Zahl ein: abc                                           *
+ * >> Geben Sie eine ganze Zahl ein: 21                                            *
+ * 00000000000000000000000000010101                                                *
+ *                                                                                 *
+ * >> Geben Sie eine ganze Zahl ein: -9                                            *
+ * 11111111111111111111111111110111                                                *
+ ***********************************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+
+int main()
+{
+    unsigned int number = getNumber("Ganze Zahl: ");
+
+    while(number > 0)
+    {
+        int remainder = number % 2;
+        int division = number / 2;
+        printf("%5d / 2 = %5d; Rest %d\n", number, division, remainder);
+
+        number = division;
+    }
+
+    return 0;
+}

04/binaerUmrechnungSchleife2.c

@@ -0,0 +1,44 @@
+/***********************************************************************************
+ * Aufgabe                                                                         *
+ * Schreiben Sie ein Programm, das eine ganze Zahl einliest und die Rechenschritte *
+ * anzeigt, um die Bits der entsprechenden Binaerzahl zu ermitteln. Nutzen Sie     *
+ * eine geeignete Schleife, sodass das Programm alle Stellen der Binärzahl anzeigt.*
+ * Lesen Sie zudem solange ein, bis eine positive Zahl eingegeben wird.            *
+ *                                                                                 *
+ * Beispiel:                                                                       *
+ * >> Geben Sie eine ganze, positive Zahl ein: abc                                 *
+ * >> Geben Sie eine ganze, positive Zahl ein: -5                                  *
+ * >> Geben Sie eine ganze, positive Zahl ein: 21                                  *
+ *  21 / 2 =   10, Rest:    1                                                      *
+ *  10 / 2 =    5, Rest:    0                                                      *
+ *   5 / 2 =    2, Rest:    1                                                      *
+ *   2 / 2 =    1, Rest:    0                                                      *
+ *                                                                                 *
+ * Schreiben Sie danach das Programm so um, dass es Bit- und Shiftoperatoren       *
+ * verwendet sowie negative Zahlen verarbeiten kann. Die Rechenschritte werden     *
+ * nicht mehr anzeigt, sondern nur noch das Bitmuster aller gespeicherten Bits.    *
+ *                                                                                 *
+ * Beispiele:                                                                      *
+ * >> Geben Sie eine ganze Zahl ein: abc                                           *
+ * >> Geben Sie eine ganze Zahl ein: 21                                            *
+ * 00000000000000000000000000010101                                                *
+ *                                                                                 *
+ * >> Geben Sie eine ganze Zahl ein: -9                                            *
+ * 11111111111111111111111111110111                                                *
+ ***********************************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+
+int main()
+{
+    unsigned int number = getNumber("Ganze Zahl: ");
+
+    for(int i = sizeof(number)*8-1; i >= 0; i--)
+    {
+        printf("%d", 1 & (number >> i));
+    }
+
+    return 0;
+}

04/eingabePruefung.c

@@ -0,0 +1,29 @@
+/********************************************************************************************
+ * Eingabeprüfung
+ * 
+ * Schreiben Sie ein Programm, das einen Preis in Euro als Kommazahl vom Benutzer abfragt 
+ * und diesen dann mittels explizitem casting in Euros und Cents zerlegt und ausgibt.
+ * Falls eine ungültige Eingabe gemacht wird (z.B. eine negative Zahl oder Buchstaben), 
+ * geben Sie eine entsprechende Meldung aus und wiederholen sie die Eingabeabfrage solange,
+ * bis eine gültige Eingabe erfolgt ist.
+ * 
+ * 1. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: 12.53
+ * Der Preis ist 12 Euro und 53 Cents.
+ * 
+ * 2. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: abc
+ * Eingabe ungueltig. Geben Sie eine positive Zahl ein!
+ * >> Geben Sie einen Preis in Euro ein: 32.12
+ * Der Preis ist 32 Euro und 12 Cents.
+ *********************************************************************************************/
+
+#include <stdio.h>
+
+// siehe 03: explizitesCasting.c
+
+int main()
+{
+
+    return 0;
+}

04/heron.c

@@ -0,0 +1,29 @@
+/****************************************************************************************************************************************************
+ * Schreiben Sie ein Programm, das eine Gleitkommazahl vom Benutzer einliest und dessen Quadratwurzel approximiert, ohne math.h zu verwenden.       *
+ * Lesen Sie dafür zunächst solange Eingaben ein, bis eine Zahl eingegeben wird, die mindestens 0 ist. Andere Eingaben werden verworfen.            *
+ * Implementieren Sie danach den Algorithmus nach Heron. Dafür gehen wir davon aus, dass die eingegebene Zahl der Flächeninhalt eines Quadrats ist, *
+ * die Seitenlänge aber unbekannt ist. Wir versuchen nun ein Rechteck mit dem angegebenen Flächeninhalt zu konstruieren und stückweise beide        *
+ * Seitenlängen aneinander anzugleichen, bis ein Quadrat mit dem gewünschten Flächeninhalt entsteht.                                                *
+ * Wir initialisieren die beiden unbekannten Seitenlängen mit dem halben Flächeninhalt und dem Flächeninhalt geteilt durch die erste Seitenlänge.   *
+ * Wie erwartet erhalten wir kein Quadrat, sondern ein allgemeines Rechteck. Wir nähern nun die beiden Seitenlängen aneinander an, müssen aber      *
+ * dafür sorgen, dass der Flächeninhalt immer gleich bleibt. Dazu halbieren wir für die erste Seitenlänge die Summe beider Seitenlängen. Für        *
+ * die zweite Seitenlänge teilen wir wieder den Flächeninhalt durch die erste Seitenlänge, um                                                       *
+ * Seitenlänge 1 * Seitenlänge 2 = Flächeninhalt = eingegebener Zahl                                                                                *
+ * zu erhalten. Dies wiederholen wir, bis (Seitenlänge 1 - Seitenlänge 2)² <= 10^-9 ist. So konstruieren wir schrittweise ein Quadrat mit dem       *
+ * eingegebenen Flächeninhalt und approximieren gleichzeitig die Quadratwurzel der eingegebenen Zahl. Am Ende geben wir das Ergebnis aus.           *
+ *                                                                                                                                                  *
+ * Beispiel:                                                                                                                                        *
+ * >> Geben Sie eine Zahl ein: abc                                                                                                                  *
+ * >> Geben Sie eine Zahl ein: -5                                                                                                                   *
+ * >> Geben Sie eine Zahl ein: 5.5                                                                                                                  *
+ * 2.345208 * 2.345208 = 5.500000                                                                                                                   *
+ *                                                                                                                                                  *
+ ****************************************************************************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}

05/geminiAufgabe1.c

@@ -0,0 +1,66 @@
+/*Die Aufgabe: "Zahlen-Jongleur"
+
+Schreibe ein Programm, das eine vom Benutzer festgelegte Anzahl an Zufallszahlen generiert. Das Programm soll für jede Zahl entscheiden, ob sie gerade oder ungerade ist, und am Ende einige statistische Werte ausgeben.
+
+Anforderungen:
+
+    Erstelle eine Funktion analysiereZahlen(int anzahl).
+
+    Diese Funktion soll anzahl Zufallszahlen im Bereich von 1 bis 100 generieren.
+
+    Für jede generierte Zahl soll auf der Konsole ausgegeben werden, ob sie gerade oder ungrade ist.
+
+    Am Ende der Funktion sollen die Summe aller generierten Zahlen sowie der Durchschnitt (als Fließkommazahl) ausgegeben werden.
+
+    Verwende rand() zur Erzeugung der Zahlen und den Modulo-Operator % zur Prüfung der Parität.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+// --- HIER die Funktion analysiereZahlen ergänzen ---
+void analysiereZahlen(int anzahl);
+
+// --------------------------------------------------
+
+int main() {
+    int menge;
+
+    // Initialisierung des Zufallszahlengenerators mit der aktuellen Zeit
+    srand((unsigned int)time(NULL));
+
+    printf("Wie viele Zufallszahlen sollen generiert werden? ");
+    if (scanf("%d", &menge) != 1 || menge <= 0) {
+        printf("Bitte gib eine positive Ganzzahl ein.\n");
+        return 1;
+    }
+
+    printf("\nStarte Analyse von %d Zahlen:\n", menge);
+    printf("------------------------------------\n");
+    
+    analysiereZahlen(menge);
+
+    printf("------------------------------------\n");
+    printf("Analyse beendet.\n");
+
+    return 0;
+}
+
+void analysiereZahlen(int anzahl)
+{
+    unsigned int summe = 0;
+
+    for(int i = 0; i < anzahl; i++)
+    {
+        unsigned int zufallszahl = rand() % 100 + 1;
+
+        if(zufallszahl % 2 == 0)
+            printf("Die Zahl %d ist gerade.\n", zufallszahl);
+        else
+            printf("Die Zahl %d ist ungerade.\n", zufallszahl);
+
+        summe += zufallszahl;
+    }
+
+    printf("Durchschnitt: %lf.\n", (double)summe / anzahl);
+}

05/geminiAufgabe2.c

@@ -0,0 +1,85 @@
+/*
+Die Aufgabe: „Der statistische Würfel-Check“
+
+Stell dir vor, du möchtest prüfen, wie „fair“ ein virtueller Würfel ist. Da wir keine Arrays nutzen dürfen, konzentrieren wir uns auf ein bestimmtes Ziel: Wir wollen zählen, wie oft eine vom Benutzer gewählte Glückszahl hintereinander gewürfelt wird (Streak).
+Deine Mission:
+
+Implementiere die Funktion simulateDiceStreaks. Diese soll:
+
+    In einer Schleife so viele Zufallszahlen (zwischen 1 und 6) generieren, wie der Parameter trials angibt.
+
+    Prüfen, ob die gewürfelte Zahl der luckyNumber entspricht.
+
+    Die längste Folge (Streak) ermitteln, in der die luckyNumber direkt hintereinander erschienen ist.
+
+    Diesen Maximalwert am Ende zurückgeben.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+// --- DEINE FUNKTION HIER ERGÄNZEN ---
+// Funktionsname: simulateDiceStreaks
+// Parameter: int trials (Anzahl Würfe), int luckyNumber (Zahl 1-6)
+// Rückgabewert: int (die längste Serie der luckyNumber)
+
+unsigned int simulateDiceStreaks(unsigned int trials, int luckyNumber);
+unsigned int rollDice();
+
+// ------------------------------------
+
+int main() {
+    int trials = 1000;
+    int luckyNumber;
+    int longestStreak;
+
+    // Seed für den Zufallszahlengenerator setzen
+    srand((unsigned int)time(NULL));
+
+    printf("Willkommen beim Würfel-Statistik-Tool!\n");
+    printf("Welche Zahl (1-6) ist deine Glückszahl? ");
+    scanf("%d", &luckyNumber);
+
+    if (luckyNumber < 1 || luckyNumber > 6) {
+        printf("Ungültige Eingabe. Bitte eine Zahl zwischen 1 und 6 wählen.\n");
+        return 1;
+    }
+
+    printf("Simuliere %d Würfe...\n", trials);
+
+    // Funktionsaufruf
+    longestStreak = simulateDiceStreaks(trials, luckyNumber);
+
+    printf("\nErgebnis:\n");
+    printf("Deine Glückszahl %d erschien maximal %d Mal direkt hintereinander.\n", 
+            luckyNumber, longestStreak);
+
+    return 0;
+}
+
+unsigned int simulateDiceStreaks(unsigned int trials, int luckyNumber)
+{
+    unsigned int highestStreak = 0;
+    unsigned int currentStreak = 0;
+
+    for(int i = 0; i < trials; i++)
+    {
+        unsigned int randNumber = rollDice();
+
+        if(randNumber == luckyNumber)
+            currentStreak++;
+        else
+        {
+            if(currentStreak > highestStreak)
+                highestStreak = currentStreak;
+            currentStreak = 0;
+        }
+    }
+
+    return highestStreak;
+}
+
+unsigned int rollDice()
+{
+    return rand() % 6 + 1;
+}

05/maexchen.c

@@ -0,0 +1,35 @@
+/***********************************************************************************************************************************************
+ * Schreiben Sie ein Programm, dass das Würfelspiel Mäxchen simuliert. Dabei würfeln mehrere Spieler nach einander mit zwei Würfeln.           *
+ * Jeder Spieler muss ein höheres Ergebnis erzielen als der Spieler zuvor, ansonsten endet das Spiel und der aktuelle Spieler verliert.        *
+ * Das Ergebnis ist wird immer durch Kombination der größeren und der kleineren Augenzahl gebildet, also z.B. 3 und 5 ergibt 53. Ein Pasch ist *
+ * höher als ungleiche Ergebnisse, also höher als 65. Wird wieder ein Pasch gewürfelt, so muss dieser mit höheren Augenzahlen erzielt werden   *
+ * als zuvor. Das höchste Ergebnis ist 21. Normalerweise sieht nur der aktuelle Spieler sein Ergebnis und kann gegebenenfalls lügen. Der       *
+ * nächste Spieler muss entscheiden, ob er das Ergebnis glaubt oder nicht. Tut er dies, geht das Spiel mit dem Ergebnis ganz normal weiter.    *
+ * Glaubt er das Ergebnis nicht, wird aufgedeckt. Wurde gelogen, verliert der Lügner. Wurde nicht gelogen, verliert der Spieler, der           *
+ * sehen wollte.                                                                                                                               *
+ *                                                                                                                                             *
+ * Implementieren Sie das Spiel mit zwei Spielern, dem Computer und Ihnen. Der Computer beginnt immer. In dieser ersten Version verzichten     *
+ * wir darauf, zu lügen.                                                                                                                       *
+ *                                                                                                                                             *
+ * 1. beispielhafter Ablauf:                                                                                                                   *
+ * Der Computer wuerfelt 3 und 5.                                                                                                              *
+ * Der Spieler wuerfelt 1 und 1.                                                                                                               *
+ * Der Computer wuerfelt 1 und 6.                                                                                                              *
+ * Das Spiel ist vorbei! Sie gewinnen!                                                                                                         *
+ *                                                                                                                                             *
+ * 2. beispielhafter Ablauf:                                                                                                                   *
+ * Der Computer wuerfelt 2 und 3.                                                                                                              *
+ * Der Spieler wuerfelt 5 und 3.                                                                                                               *
+ * Der Computer wuerfelt 2 und 6.                                                                                                              *
+ * Der Spieler wuerfelt 1 und 5.                                                                                                               *
+ * Das Spiel ist vorbei! Sie verlieren!                                                                                                        *
+ *                                                                                                                                             *
+ ***********************************************************************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}

05/quadPlatten.c

@@ -0,0 +1,58 @@
+/****************************************************************************************
+ * Schreiben Sie ein Programm, das die Laenge und Breite eines Platzes einliest und     *
+ * ausgibt, wie viele quadratische Platten benoetigt werden, um die Flaeche komplett    *
+ * zu bedecken. Dabei sollen so wenig Platten wie möglich verwendet werden.             *
+ *                                                                                      *
+ * Beispiel:                                                                            *
+ * Geben Sie die Laenge des Platzes ein.                                                *
+ * >> Geben Sie eine positive, ganze Zahl ein: gfdgfd                                   *
+ * >> Geben Sie eine positive, ganze Zahl ein: -5                                       *
+ * >> Geben Sie eine positive, ganze Zahl ein: 55                                       *
+ * Geben Sie die Breite des Platzes ein.                                                *
+ * >> Geben Sie eine positive, ganze Zahl ein: 0                                        *
+ * >> Geben Sie eine positive, ganze Zahl ein: rtre                                     *
+ * >> Geben Sie eine positive, ganze Zahl ein: 100                                      *
+ * Sie benoetigen 220 Platten der Groesse 5x5.                                          *
+ ****************************************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+unsigned int inputPositiveNumber(const char *text);
+unsigned int getGreatestCommonDivisor(unsigned int number1, unsigned int number2);
+
+int main()
+{
+    unsigned int squareWidth = inputPositiveNumber("Geben Sie die Breite des Platzes ein: ");
+    unsigned int sqaureHeight = inputPositiveNumber("Geben Sie die Hoehe des Platzes ein: ");
+    unsigned int tileSize = getGreatestCommonDivisor(squareWidth, sqaureHeight);
+    unsigned int tileCount = (squareWidth * sqaureHeight) / (tileSize * tileSize);
+
+    printf("Sie benoetigen %d Platten der Groesse %dx%d.\n", tileCount, tileSize, tileSize);
+
+    return 0;
+}
+
+unsigned int inputPositiveNumber(const char *text)
+{
+    int number = -1;
+    
+    while(number <= 0)
+    {
+        number = getNumber(text);
+    }
+
+    return number;
+}
+
+unsigned int getGreatestCommonDivisor(unsigned int number1, unsigned int number2)
+{
+    while(number2 > 0)
+    {
+        unsigned int error = number1 % number2;
+        number1 = number2;
+        number2 = error;
+    }
+
+    return number1;
+}

05/wuerfelSpiel.h

@@ -0,0 +1 @@
+#define RANDOM_INIT -1

05/wuerfelSpielMain.c

@@ -0,0 +1,64 @@
+/****************************************************************************
+ * Ergänzen Sie die fehlenden Komponenten des untenstehenden Programmteils, *
+ * sodass das Würfelspiel lauffähig wird.                                   *
+ * Diese Datei darf dabei NICHT verändert werden!!!                         *
+ * Hinweis: Bei Gleichstand gewinnt der Computer.
+ *                                                                          *
+ * Beispielhafter Ablauf des Spiels 1:                                      *
+ * >> Geben Sie eine positive Zahl ein: fdfsd                               *
+ * Fehler! Keine Zahl!                                                      *
+ * >> Geben Sie eine positive Zahl ein: -5                                  *
+ * Fehler! Die Zahl ist kleiner 1!                                          *
+ * >> Geben Sie eine positive Zahl ein: 5                                   *
+ *                                                                          *
+ * Endstand                                                                 *
+ * --------------                                                           *
+ * Spieler:   21                                                            *
+ * Computer:  19                                                            *
+ * --------------                                                           *
+ * Gewonnen!                                                                *
+ *                                                                          *
+ * Beispielhafter Ablauf des Spiels 2:                                      *
+ * >> Geben Sie eine positive Zahl ein: -1                                  *
+ * Fehler! Die Zahl ist kleiner 1!                                          *
+ * >> Geben Sie eine positive Zahl ein: abc                                 *
+ * Fehler! Keine Zahl!                                                      *
+ * >> Geben Sie eine positive Zahl ein: 10                                  *
+ *                                                                          *
+ * Endstand                                                                 *
+ * --------------                                                           *
+ * Spieler:   33                                                            *
+ * Computer:  45                                                            *
+ * --------------                                                           *
+ * Leider verloren!                                                         *
+ *                                                                          *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include "wuerfelSpiel.h"
+
+#define MIN_WUERFEL_ZAHL 1
+#define MAX_WUERFEL_ZAHL 6
+
+int main()
+{
+    int anzahlWuerfe, summeSpieler = 0, summeCpu = 0;
+
+    INIT_WUERFEL(RANDOM_INIT);
+
+    anzahlWuerfe = gibPositiveZahlEin();
+
+    for(int i = 0; i < anzahlWuerfe; i++)
+    {
+        summeSpieler += wuerfel(MIN_WUERFEL_ZAHL, MAX_WUERFEL_ZAHL);
+    }
+
+    for(int i = 0; i < anzahlWuerfe; i++)
+    {
+        summeCpu += wuerfel(MIN_WUERFEL_ZAHL, MAX_WUERFEL_ZAHL);
+    }
+
+    gibEndstandAus(summeSpieler, summeCpu);
+
+    return 0;
+}

06/divisionMitRest.c

@@ -0,0 +1,54 @@
+/********************************************************************************************
+ * Schreiben Sie ein Programm, das zwei ganze Zahlen einliest und das Ergebnis der
+ * ganzzahligen Division der beiden Zahlen sowie den Rest ausgibt. Schreiben Sie eine Funktion,
+ * die beide Ergebnisse (Division + Rest) zurückgibt. Das Programm soll, wie gehabt, solange
+ * nach einer Eingabe fragen, bis diese gültig ist.
+ * 
+ * Beispielablauf:
+ * Dividend
+ *      Geben Sie eine Zahl ein: qwert
+ *      Fehler! Keine Zahl!
+ *      Geben Sie eine Zahl ein: 32
+ * Divisor
+ *      Geben Sie eine Zahl ein: 0
+ *      Fehler! Die Zahl darf nicht 0 sein!
+ *      Geben Sie eine Zahl ein: 5
+ * Ergebnis: 32 / 5 ist 6 mit Rest 2.
+ ********************************************************************************************/ 
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+int inputNonZeroNumber(const char* text);
+int divideWithRemainder(int number1, int number2, int* remainder);
+
+
+int main()
+{
+    int number1 = getNumber("Geben Sie eine Zahl ein: ");
+    int number2 = inputNonZeroNumber("Geben Sie eine Zahl ein (!=0): ");
+    int remainder = 0;
+    int divisonResult = divideWithRemainder(number1, number2, &remainder);
+
+    printf("%d / %d = %d, R: %d\n", number1, number2, divisonResult, remainder);
+
+    return 0;
+}
+
+int inputNonZeroNumber(const char* text)
+{
+    int result = 0;
+
+    while(result == 0)
+    {
+        result = getNumber(text);
+    }
+
+    return result;
+}
+
+int divideWithRemainder(int n1, int n2, int* remainder)
+{
+    *remainder = n1 % n2;
+    return n1 / n2;
+}

06/reverseEngineering.c

@@ -0,0 +1,39 @@
+/********************************************************************************************
+ * Das folgende Programm liest drei ganze Zahlen ein und macht dann etwas damit.
+ * 
+ * 1) Überlegen Sie, was der Zweck des Programms ist und was es ausgibt (ohne es auszuführen).
+ * 2) Benennen Sie die Variablen und Funktionen sinnvoll, um den Quelltext verständlicher zu
+ *    machen.
+ * 3) Probieren Sie das Programm aus und verifizieren Sie Ihre Vermutung.
+ * 
+ ********************************************************************************************/
+
+#include <stdio.h>
+
+void funktion(int a, int b, int* c, int* d)
+{
+    if(a > b) {
+        *d = a;
+        *c = b;
+    }
+    else {
+        *d = b;
+        *c = a;
+    }
+}
+
+int main()
+{
+    int a, b, c, d, e;
+
+    printf("Geben Sie drei ganze Zahlen ein: ");
+    scanf("%d, %d, %d", &a, &b, &c);
+
+    funktion(a, b, &d, &e);
+    funktion(b, c, &d, &e);
+    funktion(a, c, &d, &e);
+
+    printf("Die Ausgabe ist %d, %d.\n", d, e);
+
+    return 0;
+}

06/rotiere.c

@@ -0,0 +1,55 @@
+/********************************************************************************************
+ * Das folgende Programm liest eine Folge aus vier ganzen Zahlen sowie eine Anzahl n
+ * ein und und soll die Zahlenfolge n mal rotieren. Dabei soll die Zahlenfolge nach jeder
+ * Rotation ausgegeben werden. 
+ * 
+ * Implementieren Sie die Rotation, in dem Sie die Variablen geschickt tauschen. 
+ * 1) Überlegen Sie, wie Sie durch Tauschen eine Zahlenfolge rotieren könnten.
+ * 2) Implementieren Sie eine geeignete Funktion, die zwei Variablen mittels call-by-reference
+ *    tauscht.
+ * 3) Nutzen Sie diese Funktion, um die vier Variablen n mal zu rotieren.
+ * 
+ * Beispiel:
+ * >> Geben Sie vier ganze Zahlen ein (getrennt durch Kommata): 1, 2, 3, 4
+ * >> Wie oft soll rotiert werden? 10
+ * Vor der Rotation: 1, 2, 3, 4.
+ * Nach der 1. Rotation: 4, 1, 2, 3
+ * Nach der 2. Rotation: 3, 4, 1, 2
+ * Nach der 3. Rotation: 2, 3, 4, 1
+ * Nach der 4. Rotation: 1, 2, 3, 4
+ * Nach der 5. Rotation: 4, 1, 2, 3
+ * Nach der 6. Rotation: 3, 4, 1, 2
+ * Nach der 7. Rotation: 2, 3, 4, 1
+ * Nach der 8. Rotation: 1, 2, 3, 4
+ * Nach der 9. Rotation: 4, 1, 2, 3
+ * Nach der 10. Rotation: 3, 4, 1, 2
+ * 
+ ********************************************************************************************/
+
+#include <stdio.h>
+
+int main() 
+{
+    int a, b, c, d, n = 0;
+
+    printf("Geben Sie vier ganze Zahlen ein (getrennt durch Kommata): ");
+    if (scanf("%d, %d, %d, %d", &a, &b, &c, &d) != 4)
+    {
+        printf("Fehlerhafte Eingabe!\n");
+        return -1;
+    }
+
+    while(getchar() != '\n');
+    printf("Wie oft soll rotiert werden? ");
+    if(scanf("%d", &n) != 1 || n < 0)
+    {
+        printf("Fehlerhafte Eingabe!\n");
+        return -1;
+    }
+    
+    printf("Vor der Rotation: %d, %d, %d, %d.\n", a, b, c, d);
+
+   // TODO
+                                                                 
+    return 0;
+}

06/wechselgeld.c

@@ -0,0 +1,116 @@
+/**************************************************************************************************************************
+ * Schreiben Sie die fehlenden Funktionen für das untenstehende Programm und ergänzen Sie die mit TODO markierten         *
+ * Funktionsaufrufe. Der Rest des Programms darf nicht verändert werden.                                                  *
+ *                                                                                                                        *
+ * Das Programm simuliert einen Ticketautomaten, der einen Preis anzeigt und der mittels Eingabe bezahlt werden soll. Der *
+ * Automat gibt dann mittels Ausgabe das Restgeld in 2-Euro-Münzen, 50-Cent-Münzen und 10-Cent-Münzen zurück. Dabei       *
+ * sollen immer möglichst viele der Münzen mit höheren Wert zurückgegeben werden. Wenn der Restbetrag nicht komplett      *
+ * durch diese Münzen ausbezahlt werden kann, wird die Differenz einbehalten. Der zu bezahlende Preis wird als Simulation *
+ * zufällig im Intervall [MIN_PREIS_IN_EUROS; MAX_PREIS_IN_EUROS] ermittelt.                                              *
+ *                                                                                                                        *
+ * 1. Möglicher Ablauf:                                                                                                   *
+ *                                                                                                                        *
+ * Ticketautomat: Achtung! Restbetraege kleiner 10 Cents koennen nicht ausbezahlt werden!                                 *
+ *                                                                                                                        *
+ * >> Bezahlen Sie bitte 6.31 Euro: 5                                                                                     *
+ * >> Bezahlen Sie bitte 6.31 Euro: ghgf                                                                                  *
+ * >> Bezahlen Sie bitte 6.31 Euro: 10.5199999999                                                                         *
+ * Sie haben 10.51 Euro bezahlt. Der Restbetrag von 4.20 wird nun ausgezahlt.                                             *
+ *                                                                                                                        *
+ * Ihr Wechselgeld:  2x 2-Euro-Muenzen,  0x 50-Cent-Muenzen,  2x 10-Cent-Muenzen.                                         *
+ *                                                                                                                        *
+ * 2. Möglicher Ablauf:                                                                                                   *
+ *                                                                                                                        *
+ * Ticketautomat: Achtung! Restbetraege kleiner 10 Cents koennen nicht ausbezahlt werden!                                 *
+ *                                                                                                                        *
+ * >> Bezahlen Sie bitte 9.28 Euro: 9                                                                                     *
+ * >> Bezahlen Sie bitte 9.28 Euro: 10                                                                                    *
+ * Sie haben 10.00 Euro bezahlt. Der Restbetrag von 0.72 wird nun ausgezahlt.                                             *
+ *                                                                                                                        *
+ * Ihr Wechselgeld:  0x 2-Euro-Muenzen,  1x 50-Cent-Muenzen,  2x 10-Cent-Muenzen.                                         *
+ *                                                                                                                        *
+ * Der Betrag konnte nicht komplett ausgezahlt werden.                                                                    *
+ *                                                                                                                        *
+ **************************************************************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "../io/myio.h"
+
+#define MIN_PREIS_IN_EUROS  5.15
+#define MAX_PREIS_IN_EUROS 12.95
+
+double ermittlePreis();
+double wirfGeldEin(double preisInEuro);
+int errechneWechselgeld(double restBetrag, int *anzahlZweiEuro, int *anzahlFuenzigCent, int *anzahlZehnCent);
+
+int main()
+{
+    int zweiEuroMuenzen, fuenzigCentMuenzen, zehnCentMuenzen, istWechselGeldKomplett;
+    double preisInEuro, bezahlterBetragInEuro, restBetragInEuro;
+
+    printf("\nTicketautomat: Achtung! Restbetraege kleiner 10 Cents koennen nicht ausbezahlt werden!\n\n");
+
+    srand(time(NULL));
+
+    // TODO: Der Preis soll in dieser Simulation zufällig ermittelt werden. Die Preisspanne ist oben als Konstanten hinterlegt.
+    preisInEuro = ermittlePreis();
+
+    // TODO: Das einzuwerfende Geld muss einer validen Eingabe entsprechen. Dafür muss u.a. mindestens der Preis bezahlt werden.
+    bezahlterBetragInEuro = wirfGeldEin(preisInEuro);
+    restBetragInEuro = bezahlterBetragInEuro - preisInEuro;
+
+    printf("Sie haben %.2lf Euro bezahlt. Der Restbetrag von %.2lf wird nun ausgezahlt.\n", bezahlterBetragInEuro, restBetragInEuro);
+
+    istWechselGeldKomplett = errechneWechselgeld(restBetragInEuro, &zweiEuroMuenzen, &fuenzigCentMuenzen, &zehnCentMuenzen);// TODO: Argumente übergeben. Hier sollen u.a.die Anzahl an Münzen gesetzt werden.);
+
+    printf("\nIhr Wechselgeld: %2dx 2-Euro-Muenzen, %2dx 50-Cent-Muenzen, %2dx 10-Cent-Muenzen.\n", zweiEuroMuenzen, fuenzigCentMuenzen, zehnCentMuenzen);
+
+    if(!istWechselGeldKomplett)
+    {
+        printf("\nDer Betrag konnte nicht komplett ausgezahlt werden.\n");
+    }
+
+    return 0;
+}
+
+double ermittlePreis()
+{
+
+    int minCents = 100 * MIN_PREIS_IN_EUROS;
+    int maxCents = 100 * MAX_PREIS_IN_EUROS;
+
+    int zufallsPreisInCent = rand() % (maxCents - minCents + 1) + minCents;
+
+    return zufallsPreisInCent / 100.0;
+}
+
+double wirfGeldEin(double preisInEuro)
+{
+    double eingabe = 0;
+
+    printf("Bitte bezahlen Sie %.2lf Euro.\n", preisInEuro);
+    
+    while(eingabe < preisInEuro)
+    {
+        eingabe = getDoubleNumber("Bitte Geld einwerfen: ");
+    }
+
+    return eingabe;
+}
+
+int errechneWechselgeld(double restBetrag, int *anzahlZweiEuro, int *anzahlFuenzigCent, int *anzahlZehnCent)
+{
+    unsigned int restBetragCent = restBetrag * 100;
+
+    *anzahlZweiEuro = restBetragCent / 200;
+    restBetragCent %= 200;
+    *anzahlFuenzigCent = restBetragCent / 50;
+    restBetragCent %= 50;
+    *anzahlZehnCent = restBetragCent / 10;
+    restBetragCent %= 10;
+
+    return restBetragCent == 0;
+}

io/myio.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include "myio.h"
+
+unsigned char getSingleChar()
+{
+    unsigned char result = 'a';
+
+    result = getchar();
+    while(result != '\n' && getchar() != '\n') {}
+
+    return result;
+}
+
+int getNumber(const char *text)
+{
+    int number = 0;
+    int wasSuccessful = 0;
+
+    do
+    {
+        printf("%s", text);
+        wasSuccessful = scanf("%d", &number);
+        while(getchar() != '\n') {} 
+    } while(!wasSuccessful);
+
+    return number;
+}
+
+double getDoubleNumber(const char *text)
+{
+    double number = 0;
+    int wasSuccessful = 0;
+
+    do
+    {
+        printf("%s", text);
+        wasSuccessful = scanf("%lf", &number);
+        while(getchar() != '\n') {} 
+    } while(!wasSuccessful);
+
+    return number;
+}

io/myio.h

@@ -0,0 +1,8 @@
+#ifndef MYIO_H
+#define MYIO_H
+
+unsigned char getSingleChar();
+int getNumber(const char *text);
+double getDoubleNumber(const char *text);
+
+#endif

io/testInput.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include "../io/myio.h"
+
+int main()
+{
+    int number = getNumber("Geben Sie eine Zahl ein: ");
+
+    printf("number: %d\n", number);
+
+    return 0;
+}