Add solutions for searching.

07/mastermind.c

@@ -0,0 +1,82 @@
+/**********************************************************************
+ * Vervollständigen Sie die vorliegende Variante des                  *
+ * Mastermind-Spiels. Der Computer erstellt eine Ziffern-Kombination, *
+ * die erraten werden soll. Dazu hat der Spieler ein gewisse Anzahl   *
+ * an Versuchen. Für jeden Versuch erhält der Spieler die             *
+ * Rückmeldung, wie viele Positionen korrekt erraten wurden, also wie *
+ * häufig der Spieler eine Ziffer an die richtige Position gesetzt    *
+ * hat. Außerdem wird ausgegeben, wie viele Ziffern zwar in der       *
+ * Kombination vorkommen, aber an falscher Stelle liegen. Dabei wird  *
+ * für jede Ziffer in der Zielkombination maximal ein Tipp            *
+ * ausgegeben. Der Benutzer soll die Länge des zu erratenden Codes    *
+ * einstellen können.                                                 *
+ *                                                                    *
+ * Für die Spiellogik fehlen noch Funktionen, die in                  *
+ * mastermind_logik.h und mastermind_logik.c ergänzt werden müssen.   *
+ * Alle anderen Dateien dürfen nicht verändert werden.                *
+ *                                                                    *
+ * Beispiel:                                                          *
+ * >> Geben Sie die Anzahl an Rateslots an (max. 20): 4               *
+ * Zielkombination wird erstellt ...                                  *
+ * (Wird im Spiel nicht ausgegeben: Die Kombination lautet 5 1 3 1)   *
+ * >> Versuch   1 /  12: Geben Sie Ihren Rateversuch ein: 1 1 1 1     *
+ *        Anzahl an richtig erkannten Positionen:               2     *
+ *        Anzahl an richtig erkannten Ziffern (falsche Pos.):   0     *
+ *                                                                    *
+ *  ...                                                               *
+ *                                                                    *
+ * >> Versuch   9 /  12: Geben Sie Ihren Rateversuch ein: 1 4 5 6     *
+ *        Anzahl an richtig erkannten Positionen:               0     *
+ *        Anzahl an richtig erkannten Ziffern (falsche Pos.):   2     *
+ *                                                                    *
+ *  ...                                                               *
+ *                                                                    *
+ * >> Versuch  12 /  12: Geben Sie Ihren Rateversuch ein: 4 1 3 6     *
+ *        Anzahl an richtig erkannten Positionen:               2     *
+ *        Anzahl an richtig erkannten Ziffern (falsche Pos.):   0     *
+ *                                                                    *
+ * Sie haben leider verloren! Die Richtige Kombination war 5 1 3 1    *
+ *                                                                    *
+ **********************************************************************/
+
+#include <stdio.h>
+#include "mastermind_eingabe.h"
+#include "mastermind_logik.h"
+
+int main()
+{   
+    int anzahlRateSlots = 0;
+    int zielKombination[MAX_ANZAHL_RATE_SLOTS];
+    int rateSlots[MAX_ANZAHL_RATE_SLOTS];
+    int erkanntePos = 0, erkannteZiffern = 0;
+    int aktuellerVersuch;
+
+    printf("Geben Sie die Anzahl an Rateslots an (max. %d): ", MAX_ANZAHL_RATE_SLOTS);
+    anzahlRateSlots = gibMinMaxZahlEin(1, MAX_ANZAHL_RATE_SLOTS);
+
+    printf("Zielkombination wird erstellt ...\n");
+    initZielKombination(zielKombination, anzahlRateSlots);
+    
+    for(aktuellerVersuch = 0; (aktuellerVersuch < MAX_VERSUCHE) && (erkanntePos < anzahlRateSlots); aktuellerVersuch++)
+    {
+        printf("Versuch %3d / %3d: Geben Sie Ihren Rateversuch ein: ", aktuellerVersuch+1, MAX_VERSUCHE);
+        gibRateVersuchEin(rateSlots, anzahlRateSlots, MIN_CODE, MAX_CODE);
+
+        werteVersuchAus(&erkanntePos, &erkannteZiffern, rateSlots, zielKombination, anzahlRateSlots);
+
+        printf("    Anzahl an richtig erkannten Positionen:               %d\n", erkanntePos);
+        printf("    Anzahl an richtig erkannten Ziffern (falsche Pos.):   %d\n", erkannteZiffern);
+    }
+
+    if(erkanntePos == anzahlRateSlots)
+        printf("\nSie haben gewonnen!\n");
+    else
+    {
+        printf("\nSie haben leider verloren! Die Richtige Kombination war");
+        for(int i = 0; i < anzahlRateSlots; i++)
+            printf(" %d", zielKombination[i]);
+        printf("\n");
+    }
+
+    return 0;
+}

07/mastermind_eingabe.c

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <ctype.h>
+#include "mastermind_eingabe.h"
+
+int gibZiffernEin(int zahlen[], int anzahl, int minZiffer, int maxZiffer)
+{
+    char zeichen;
+    int anzahlGelesenerZiffern = 0;
+
+    do
+    {
+        zeichen = getchar();
+
+        if(isdigit(zeichen))
+        {
+            int ziffer = zeichen - '0';
+
+            if((ziffer >= minZiffer) && (ziffer <= maxZiffer))
+            {
+                zahlen[anzahlGelesenerZiffern] = ziffer;
+                anzahlGelesenerZiffern++;
+            }
+            else
+            {
+                ziffer = 0;
+            }
+        }
+
+    } while((anzahlGelesenerZiffern < anzahl) && (isdigit(zeichen) || zeichen == ' '));
+
+    while(zeichen != '\n' && getchar() != '\n') {}
+
+    return anzahlGelesenerZiffern;
+}
+
+int gibMinMaxZahlEin(int min, int max)
+{
+    int zahl, geleseneWerte, istEingabeFehlerhaft;
+
+    do
+    {
+        geleseneWerte = scanf("%d", &zahl);
+        while(getchar() != '\n') {}
+
+        istEingabeFehlerhaft = (geleseneWerte != 1) || (zahl < min) || (zahl > max); 
+
+        if(istEingabeFehlerhaft)
+            printf("Fehler! Erneute Eingabe: ");
+
+    } while(istEingabeFehlerhaft);
+
+    return zahl;
+}
+
+void gibRateVersuchEin(int rateSlots[], int anzahl, int minCode, int maxCode)
+{
+    while(gibZiffernEin(rateSlots, anzahl, minCode, maxCode) != anzahl)
+    {
+        printf("Fehler! Erneute Eingabe: ");
+    }
+}

07/mastermind_eingabe.h

@@ -0,0 +1,9 @@
+#ifndef MASTERMIND_EINGABE_H
+#define MASTERMIND_EINGABE_H
+
+int gibZiffernEin(int zahlen[], int anzahl, int minZiffer, int maxZiffer);
+void gibRateVersuchEin(int rateSlots[], int anzahl, int minCode, int maxCode);
+int gibMinMaxZahlEin(int min, int max);
+
+
+#endif

07/mastermind_logik.c

@@ -0,0 +1 @@
+#include "mastermind_logik.h"

07/mastermind_logik.h

@@ -0,0 +1,11 @@
+#ifndef MASTERMIND_LOGIK_H
+#define MASTERMIND_LOGIK_H
+
+#define MAX_VERSUCHE          12
+#define MAX_ANZAHL_RATE_SLOTS 20
+#define MIN_CODE               1
+#define MAX_CODE               6
+
+// TODO
+
+#endif

07/rotiereArray.c

@@ -0,0 +1,24 @@
+/********************************************************************************************
+ * Das folgende Programm basiert auf dem Programm "rotiere" aus dem vorigen Termin.
+ * Es 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. 
+ * 
+ * Aufgabe 1): Implementieren Sie das Programm. Nutzen Sie dieses Mal zu Speicherung der Zahlen
+ * ein Array! Implementieren Sie die Rotation als eigene Funktion, die Arrays beliebiger
+ * Länge rotiert. Implementieren Sie Ihre Ausgabe des Arrays als eigene Funktion, 
+ * die Arrays beliebiger Länge ausgibt.
+ * 
+ * Aufgabe 2): Ändern Sie nun die Rotationsreihenfolge (wenn Sie in Aufgabe 1 nach links
+ * rotiert haben, rotieren Sie nun nach rechts und umgekehrt).
+ * 
+ ********************************************************************************************/
+
+#include <stdio.h>
+
+
+int main() 
+{
+
+    return 0;
+}

07/selectionsort.c

@@ -0,0 +1,123 @@
+/*****************************************************************
+ * Schreiben Sie ein Programm, das vom Benutzer abfragt,         *
+ * wie viele Zahlen eingelesen werden sollen und diese           *
+ * dann mittels SelectionSort sortiert. SelectionSort            *
+ * geht eine Liste von Zahlen von links nach rechts durch,       *
+ * ermittelt das Minimum der Zahlen, die rechts der aktuellen    *
+ * Position liegen inklusive der Zahl der aktuellen Position,    *
+ * und tauscht das Minimum mit der Zahl auf die aktuelle         *
+ * Position. Alle Zahlen bis zu dieser Position inklusive gelten *
+ * dann als sortiert. Diese Prozedur wird für jede Position von  *
+ * links nach rechts durchgeführt, bis alle Zahlen sortiert sind.*
+ *                                                               *
+ * Beispiel für Sortierung einer Liste 5 3 0 2:                  *
+ * Setze Minimum der Restliste an 1. Position: 0 3 5 2           *
+ * Setze Minimum der Restliste an 2. Position: 0 2 5 3           *
+ * Setze Minimum der Restliste an 3. Position: 0 2 3 5           *
+ *                                                               *
+ * Beispielhafte Ausgabe:                                        *
+ * >> Wie viele Zahlen (max. 100)? fsdf                          *
+ * >> Fehler! Erneute Eingabe: -1                                *
+ * >> Fehler! Erneute Eingabe: 101                               *
+ * >> Fehler! Erneute Eingabe: 5                                 *
+ * >> Geben Sie die 1. Zahl ein: dsf                             *
+ * >> Fehler! Erneute Eingabe: 45                                *
+ * >> Geben Sie die 2. Zahl ein: 1                               *
+ * >> Geben Sie die 3. Zahl ein: 0                               *
+ * >> Geben Sie die 4. Zahl ein: -4                              *
+ * >> Geben Sie die 5. Zahl ein: 1423                            *
+ * Sortierte Zahlen: -4 0 1 45 1423                              *
+ *                                                               *
+ *****************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+#define MAX_ZAHLEN 100
+
+void selectionsort(int array[], unsigned int len);
+unsigned int findeMaxIdx(int array[], unsigned int len);
+void tausche(int *elem1, int *elem2);
+void zeigeArray(int array[], unsigned int len);
+unsigned int gibLaengeEin(unsigned int max);
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN] = {0};
+    unsigned int len = gibLaengeEin(MAX_ZAHLEN);
+
+    for(int i = 0; i < len; i++)
+    {
+        printf("%d. Zahl:\n", i+1);
+        zahlen[i] = getNumber("Geben Sie eine Zahl ein: ");
+    }
+
+    printf("\nEingebene Zahlen: ");
+    zeigeArray(zahlen, len);
+    selectionsort(zahlen, len);
+    printf("\nSortierte Zahlen: ");
+    zeigeArray(zahlen, len);
+    
+    
+    return 0;
+}
+
+void zeigeArray(int array[], unsigned int len)
+{
+    for(int i = 0; i < len; i++)
+    {
+        printf("%3d ", array[i]);
+    }
+    printf("\n");
+}
+
+unsigned int findeMaxIdx(int array[], unsigned int len)
+{
+    unsigned int maxIdx = 0;
+
+    for(int i = 1; i < len; i++)
+    {
+        if(array[i] > array[maxIdx])
+        {
+            maxIdx = i;
+        }
+    }
+
+    return maxIdx;
+}
+
+void selectionsort(int array[], unsigned int len)
+{
+    for(int unsortierteLaenge = len; unsortierteLaenge >= 2; unsortierteLaenge--)
+    {
+        unsigned int maxIdx = findeMaxIdx(array, unsortierteLaenge);
+
+        tausche(&array[maxIdx], &array[unsortierteLaenge-1]);
+    }
+}
+
+/*void tausche(int array[], unsigned int idx1, unsigned int idx2)
+{
+    int tmp = array[idx1];
+    array[idx1] = array[idx2];
+    array[idx2] = tmp;
+}*/
+
+void tausche(int *elem1, int *elem2)
+{
+    int tmp = *elem1;
+    *elem1 = *elem2;
+    *elem2 = tmp;
+}
+
+unsigned int gibLaengeEin(unsigned int max)
+{
+    unsigned int laenge = 0;
+    
+    printf("Maximale Laenge: %d\n", max);
+
+    while(laenge <= 0 || laenge > max)
+        laenge = getNumber("Geben Sie die Anzahl an Zahlen ein: ");
+
+    return laenge;
+}

07/selectionsort_zgr.c

@@ -0,0 +1,124 @@
+/*****************************************************************
+ * Schreiben Sie ein Programm, das vom Benutzer abfragt,         *
+ * wie viele Zahlen eingelesen werden sollen und diese           *
+ * dann mittels SelectionSort sortiert. SelectionSort            *
+ * geht eine Liste von Zahlen von links nach rechts durch,       *
+ * ermittelt das Minimum der Zahlen, die rechts der aktuellen    *
+ * Position liegen inklusive der Zahl der aktuellen Position,    *
+ * und tauscht das Minimum mit der Zahl auf die aktuelle         *
+ * Position. Alle Zahlen bis zu dieser Position inklusive gelten *
+ * dann als sortiert. Diese Prozedur wird für jede Position von  *
+ * links nach rechts durchgeführt, bis alle Zahlen sortiert sind.*
+ *                                                               *
+ * Beispiel für Sortierung einer Liste 5 3 0 2:                  *
+ * Setze Minimum der Restliste an 1. Position: 0 3 5 2           *
+ * Setze Minimum der Restliste an 2. Position: 0 2 5 3           *
+ * Setze Minimum der Restliste an 3. Position: 0 2 3 5           *
+ *                                                               *
+ * Beispielhafte Ausgabe:                                        *
+ * >> Wie viele Zahlen (max. 100)? fsdf                          *
+ * >> Fehler! Erneute Eingabe: -1                                *
+ * >> Fehler! Erneute Eingabe: 101                               *
+ * >> Fehler! Erneute Eingabe: 5                                 *
+ * >> Geben Sie die 1. Zahl ein: dsf                             *
+ * >> Fehler! Erneute Eingabe: 45                                *
+ * >> Geben Sie die 2. Zahl ein: 1                               *
+ * >> Geben Sie die 3. Zahl ein: 0                               *
+ * >> Geben Sie die 4. Zahl ein: -4                              *
+ * >> Geben Sie die 5. Zahl ein: 1423                            *
+ * Sortierte Zahlen: -4 0 1 45 1423                              *
+ *                                                               *
+ *****************************************************************/
+
+#include <stdio.h>
+#include "../io/myio.h"
+
+#define MAX_ZAHLEN 100
+
+void selectionsort(int array[], unsigned int len);
+int *findeMax(int *anfang, int *ende);
+void tausche(int *elem1, int *elem2);
+void zeigeArray(int array[], unsigned int len);
+unsigned int gibLaengeEin(unsigned int max);
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN] = {0};
+    unsigned int len = gibLaengeEin(MAX_ZAHLEN);
+
+    for(int i = 0; i < len; i++)
+    {
+        printf("%d. Zahl:\n", i+1);
+        zahlen[i] = getNumber("Geben Sie eine Zahl ein: ");
+    }
+
+    printf("\nEingebene Zahlen: ");
+    zeigeArray(zahlen, len);
+    selectionsort(zahlen, len);
+    printf("\nSortierte Zahlen: ");
+    zeigeArray(zahlen, len);
+    
+    
+    return 0;
+}
+
+void zeigeArray(int array[], unsigned int len)
+{
+    for(int i = 0; i < len; i++)
+    {
+        printf("%3d ", array[i]);
+    }
+    printf("\n");
+}
+
+int *findeMax(int *anfang, int *ende)
+{
+    int *max = anfang;
+
+    while(anfang <= ende)
+    {
+        if(*anfang > *max)
+        {
+            max = anfang;
+        }
+        anfang++;
+    }
+
+    return max;
+}
+
+void selectionsort(int array[], unsigned int len)
+{
+    for(int unsortierteLaenge = len; unsortierteLaenge >= 2; unsortierteLaenge--)
+    {
+        int *max = findeMax(array, array+unsortierteLaenge-1);
+
+        tausche(max, &array[unsortierteLaenge-1]);
+    }
+}
+
+/*void tausche(int array[], unsigned int idx1, unsigned int idx2)
+{
+    int tmp = array[idx1];
+    array[idx1] = array[idx2];
+    array[idx2] = tmp;
+}*/
+
+void tausche(int *elem1, int *elem2)
+{
+    int tmp = *elem1;
+    *elem1 = *elem2;
+    *elem2 = tmp;
+}
+
+unsigned int gibLaengeEin(unsigned int max)
+{
+    unsigned int laenge = 0;
+    
+    printf("Maximale Laenge: %d\n", max);
+
+    while(laenge <= 0 || laenge > max)
+        laenge = getNumber("Geben Sie die Anzahl an Zahlen ein: ");
+
+    return laenge;
+}

08/codeNachricht.c

@@ -0,0 +1,142 @@
+/**************************************************************************************************************
+ * Schreiben Sie ein Programm, das einen Text einliest, diesen dabei zeilenweise in einer Tabelle speichert   *
+ * und anschließend codiert ausgibt, indem es ihn spaltenweise ausliest. Die Zeilen- und Spaltenzahlen sind   *
+ * vom Benutzer festzulegen. Überschüssige Zeichen in der Tabelle werden zufällig mit Kleinbuchstaben belegt. *
+ * Überlegen Sie sich, wie Sie einen codierten Text decodieren könnten, wenn Sie die Zeilen- und Spaltenzahl  *
+ * der Codierung kennen.                                                                                      *
+ *                                                                                                            *
+ * 1. Hinweis:                                                                                                *
+ * Die Aufgabe ist ohne scanf und Strings zu lösen.                                                           *
+ *                                                                                                            *
+ * 2. Hinweis:                                                                                                *
+ * Im untenstehenden Beispiel wird der Text "Das ist ein Text." folgendermaßen in einer Tabelle mit vier      *
+ * Zeilen und fünf Spalten abgelegt:                                                                          *
+ * |D|a|s| |i|                                                                                                *
+ * |s|t| |e|i|                                                                                                *
+ * |n| |T|e|x|                                                                                                *
+ * |t|.|?|?|?|                                                                                                *
+ *                                                                                                            *
+ * Die Stellen mit Fragezeichen sind überschüssig und werden mit zufälligen Kleinbuchstaben belegt.           *
+ *                                                                                                            *
+ * Beispielhafter Ablauf:                                                                                     *
+ *                                                                                                            *
+ * Die maximale Laenge der Nachricht ergibt sich aus dem Produkt der beiden Codes.                            *
+ *                                                                                                            *
+ * >> Geben Sie die Anzahl an Zeilen ein: 4                                                                   *
+ * >> Geben Sie die Anzahl an Spalten ein: 5                                                                  *
+ * >> Geben Sie Ihren Text ein (max. 20 Zeichen): Das ist ein Text.                                           *
+ * Der umgeformte Text lautet: Dsntat .s Tr eekiixq                                                           *
+ *                                                                                                            *
+ **************************************************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define MAX_ZEILEN  10
+#define MAX_SPALTEN 10
+
+int gibZahlEin(int min, int max);
+void fuelleTabelleZufall(char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten);
+void fuelleTabelle(char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten);
+void gibTabelleAus(const char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten);
+void gibCodeAus(const char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten);
+
+int main()
+{
+    char tabelle[MAX_ZEILEN][MAX_SPALTEN] = {0};
+    unsigned int spalten = 0;
+    unsigned int zeilen = 0;
+
+    srand(time(NULL));
+
+    printf("Wie viele Zeilen (max. %d): ", MAX_ZEILEN);
+    zeilen = gibZahlEin(1, MAX_ZEILEN);
+
+    printf("Wie viele Spalten (max. %d): ", MAX_SPALTEN);
+    spalten = gibZahlEin(1, MAX_SPALTEN);
+
+    fuelleTabelleZufall(tabelle, zeilen, spalten);
+
+    printf("Text: ");
+    fuelleTabelle(tabelle, zeilen, spalten);
+    printf("Tabelle:\n");
+    gibTabelleAus(tabelle, zeilen, spalten);
+    printf("Code: ");
+    gibCodeAus(tabelle, zeilen, spalten);
+
+    return 0;
+}
+
+void fuelleTabelleZufall(char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten)
+{
+    for(unsigned int i = 0; i < zeilen; i++)
+    {
+        for(unsigned int j = 0; j < spalten; j++)
+        {
+            tabelle[i][j] = rand() % ('z' - 'a' + 1) + 'a';
+        }
+    }
+}
+
+void gibCodeAus(const char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten)
+{
+    for(unsigned int j = 0; j < spalten; j++)
+    {
+        for(unsigned int i = 0; i < zeilen; i++)
+        {
+            printf("%c", tabelle[i][j]);
+        }
+    }
+}
+
+void fuelleTabelle(char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten)
+{
+    char eingabe = '\0';
+
+    for(unsigned int i = 0; i < zeilen && eingabe != '\n'; i++)
+    {
+        for(unsigned int j = 0; j < spalten && eingabe != '\n'; j++)
+        {
+            eingabe = getchar();
+
+            if(eingabe != '\n')
+                tabelle[i][j] = eingabe;
+            else
+                j--;
+        }
+    }
+}
+
+void gibTabelleAus(const char tabelle[MAX_ZEILEN][MAX_SPALTEN], unsigned int zeilen, unsigned int spalten)
+{
+    for(unsigned int i = 0; i < zeilen; i++)
+    {
+        for(unsigned int j = 0; j < spalten; j++)
+        {
+            printf("%c", tabelle[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+int gibZahlEin(int min, int max)
+{
+    int zahl, geleseneWerte;
+
+    do
+    {
+        geleseneWerte = scanf("%d", &zahl);
+        while(getchar() != '\n') {}
+
+        if(geleseneWerte != 1)
+            printf("Keine Zahl! Erneute Eingabe: ");
+        else if(zahl < min)
+            printf("Zahl zu klein! Erneute Eingabe: ");
+        else if(zahl > max)
+            printf("Zahl zu gross! Erneute Eingabe: ");
+
+    } while(geleseneWerte != 1 || zahl < min || zahl > max);
+
+    return zahl;
+}

08/noten.c

@@ -0,0 +1,60 @@
+/**********************************************
+ * Schreiben Sie ein Programm, das die Anzahl *
+ * an Studierenden und Fächern erfragt,       *
+ * entsprechend viele Noten einliest und am   *
+ * Ende die Noten samt Durchschnitt ausgibt.  *
+ *                                            *
+ * Beispiel:                                  *
+ *                                            *
+ * >> Wie viele Studis (max. 20)? 4           *
+ * >> Wie viele Faecher (max. 10)? 3          *
+ * >> 1. Studi, 1. Fach: 1.0                  *
+ * >> 1. Studi, 2. Fach: 1.3                  *
+ * >> 1. Studi, 3. Fach: 1.7                  *
+ * >> 2. Studi, 1. Fach: 3.0                  *
+ * >> 2. Studi, 2. Fach: 3.3                  *
+ * >> 2. Studi, 3. Fach: 1.3                  *
+ * >> 3. Studi, 1. Fach: 5.0                  *
+ * >> 3. Studi, 2. Fach: 4.0                  *
+ * >> 3. Studi, 3. Fach: 1.7                  *
+ * >> 4. Studi, 1. Fach: 2.7                  *
+ * >> 4. Studi, 2. Fach: 2.3                  *
+ * >> 4. Studi, 3. Fach: 1.0                  *
+ *                                            *
+ * Noten:                                     *
+ * 1. Studi:   1.0   1.3   1.7 ->  1.33       *
+ * 2. Studi:   3.0   3.3   1.3 ->  2.53       *
+ * 3. Studi:   5.0   4.0   1.7 ->  3.57       *
+ * 4. Studi:   2.7   2.3   1.0 ->  2.00       *
+ *                                            *
+ **********************************************/
+
+#include <stdio.h>
+
+#define MAX_STUDIS  20
+#define MAX_FAECHER 10
+
+int gibGanzeZahlEin(int min, int max);
+
+int main()
+{
+
+    return 0;
+}
+
+int gibGanzeZahlEin(int min, int max)
+{
+    int zahl, geleseneWerte;
+
+    do
+    {
+        geleseneWerte = scanf("%d", &zahl);
+        while(getchar() != '\n') {}
+
+        if(geleseneWerte != 1 || zahl < min || zahl > max)
+            printf("Fehler! Erneute Eingabe: ");
+
+    } while(geleseneWerte != 1 || zahl < min || zahl > max);
+
+    return zahl;
+}

08/sortiereMatrix.c

@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Schreiben Sie ein Programm, das eine quadratische Zufallsmatrix mit Werten 
+ * zwischen 1 und 100 erstellt und diese zunächst zeilenweise und anschließend 
+ * spaltenweise aufsteigend sortiert. Nutzen Sie für die Sortierung Ihre 
+ * SelectionSort-Implementierung aus den letzten Übungen.
+ *******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define ZEILEN  10
+#define SPALTEN 10
+
+int main()
+{
+    
+    return 0;
+}

09/sortierung/makefile

@@ -0,0 +1,9 @@
+SORTIERUNGLIBFILES = sortierung.c
+SORTIERUNGTESTLIBFILES = $(SORTIERUNGLIBFILES) ../utils/zahlenEingabe.c
+SORTIERUNGSVERGLEICHLIBFILES = $(SORTIERUNGLIBFILES) ../utils/stoppuhr.c ../utils/zufallsarray.c
+
+sortierungTest:
+	gcc -Wall -o sortierungTest sortierungTest.c $(SORTIERUNGTESTLIBFILES)
+	
+sortierungsvergleich:
+	gcc -Wall -o sortierungsvergleich sortierungsvergleich.c $(SORTIERUNGSVERGLEICHLIBFILES)

09/sortierung/sortierung.c

@@ -0,0 +1,51 @@
+#include "sortierung.h"
+
+void tausche(int *zahl1, int *zahl2)
+{
+    int tmp = *zahl1;
+    *zahl1 = *zahl2;
+    *zahl2 = tmp;
+}
+
+unsigned int findeMaxIdx(int array[], unsigned int len)
+{
+    unsigned int maxIdx = 0;
+
+    for(int i = 1; i < len; i++)
+    {
+        if(array[i] > array[maxIdx])
+        {
+            maxIdx = i;
+        }
+    }
+
+    return maxIdx;
+}
+
+void selectionsort(int array[], unsigned int len)
+{
+    for(int unsortierteLaenge = len; unsortierteLaenge >= 2; unsortierteLaenge--)
+    {
+        unsigned int maxIdx = findeMaxIdx(array, unsortierteLaenge);
+
+        tausche(&array[maxIdx], &array[unsortierteLaenge-1]);
+    }
+}
+
+void bubblesort(int array[], unsigned int anzahl)
+{
+    int wurdeGetauscht = 1;
+
+    for(int i = anzahl-1; i >= 1 && wurdeGetauscht; i--)
+    {
+        wurdeGetauscht = 0;
+        for(int j = 0; j < i; j++)
+        {
+            if(array[j] > array[j+1])
+            {
+                tausche(&array[j], &array[j+1]);
+                wurdeGetauscht = 1;
+            }
+        }
+    }
+}

09/sortierung/sortierung.h

@@ -0,0 +1,10 @@
+#ifndef SORTIERUNG_H
+#define SORTIERUNG_H
+
+void tausche(int *zahl1, int *zahl2);
+void selectionsort(int array[], unsigned int anzahl);
+void insertionsort(int array[], unsigned int anzahl);
+void bubblesort(int array[], unsigned int anzahl);
+unsigned int findeMaxIdx(int array[], unsigned int len);
+
+#endif

09/sortierung/sortierungTest.c

@@ -0,0 +1,58 @@
+/*****************************************************************
+ * Verwenden Sie Ihre Lösung für Selection Sort, die Sie zur     *
+ * Übung von eindimensionalen Arrays geschrieben haben.          *
+ * Implementieren Sie nun die Sortierungsfunktion nur mit        *
+ * Zeigern. Implementieren Sie Ihre Lösung in sortierung.h bzw.  *
+ * sortierung.c                                                  *
+ *                                                               *
+ * Beispiel für Sortierung einer Liste 5 3 0 2:                  *
+ * Setze Minimum der Restliste an 1. Position: 0 3 5 2           *
+ * Setze Minimum der Restliste an 2. Position: 0 2 5 3           *
+ * Setze Minimum der Restliste an 3. Position: 0 2 3 5           *
+ *                                                               *
+ * Beispielhafte Ausgabe:                                        *
+ * >> Wie viele Zahlen (max. 100)? fsdf                          *
+ * >> Fehler! Erneute Eingabe: -1                                *
+ * >> Fehler! Erneute Eingabe: 101                               *
+ * >> Fehler! Erneute Eingabe: 5                                 *
+ * >> Geben Sie die 1. Zahl ein: dsf                             *
+ * >> Fehler! Erneute Eingabe: 45                                *
+ * >> Geben Sie die 2. Zahl ein: 1                               *
+ * >> Geben Sie die 3. Zahl ein: 0                               *
+ * >> Geben Sie die 4. Zahl ein: -4                              *
+ * >> Geben Sie die 5. Zahl ein: 1423                            *
+ * Sortierte Zahlen: -4 0 1 45 1423                              *
+ *                                                               *
+ *****************************************************************/
+
+#include <stdio.h>
+#include "../utils/zahlenEingabe.h"
+#include "sortierung.h"
+
+#define MAX_ZAHLEN 100
+
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN];
+    int anzahl;
+
+    printf("Wie viele Zahlen (max. %d)? ", MAX_ZAHLEN);
+    anzahl = gibMinMaxZahlEin(0, MAX_ZAHLEN);
+
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf("Geben Sie die %d. Zahl ein: ", i+1);
+        zahlen[i] = gibZahlEin();
+    }
+
+    //selectionsort(zahlen, anzahl);
+    bubblesort(zahlen, anzahl);
+
+    printf("Sortierte Zahlen:\n");
+    for(int i = 0; i < anzahl; i++)
+        printf("%3d ", zahlen[i]);
+    printf("\n");
+    
+    return 0;
+}

09/sortierung/sortierungsvergleich.c

@@ -0,0 +1,60 @@
+/************************************************************************************************
+ * Implementieren Sie die folgenden Sortieralgorithmen und vergleichen Sie deren Laufzeit mit 
+ * untenstehendem Programm:
+ * 1. Nutzen Sie zunächst Ihre Lösung für SelectionSort.
+ * 2. Erweitern Sie nun sortierung.h bzw. sortierung.c um InsertionSort.
+ * 3. Erweitern Sie nun sortierung.h bzw. sortierung.c um BubbleSort.
+ * 4. Nutzen Sie abschließend die von der C-Standardbibliothek bereitgestellte qsort-Funktion.
+ * 
+ * Hinweis: Sie können das Programm sortierungTest.c nutzen, um Ihre Implementierungen zu testen.
+ * 
+ * Welche Laufzeit-Unterschiede ergeben sich?
+ *************************************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "sortierung.h"
+#include "../utils/zufallsarray.h"
+#include "../utils/stoppuhr.h"
+
+#define ANZAHL_MAX 100000
+#define ANZAHL ANZAHL_MAX
+#define ANZEIGE_MAX 100
+
+void gibArrayAus(int array[], int anzahl)
+{
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf(" %3d", array[i]);
+    }
+    printf("\n");
+}
+
+int vergleiche(const void *arg1, const void *arg2)
+{
+    return *(const int *)arg1 - *(const int *)arg2;
+}
+
+int main()
+{
+    int zufallszahlen[ANZAHL];
+    srand(0);
+
+    fuelleArray(zufallszahlen, ANZAHL, -ANZAHL, ANZAHL);
+
+    if(ANZAHL <= ANZEIGE_MAX)
+        gibArrayAus(zufallszahlen, ANZAHL);
+
+    starteUhr();
+    //selectionsort(zufallszahlen, ANZAHL);
+    //bubblesort(zufallszahlen, ANZAHL);
+    qsort(zufallszahlen, ANZAHL, sizeof(zufallszahlen[0]), vergleiche);
+
+    printf("Zahlen sortiert nach %lf Sekunden.\n", messeZeitInSek());
+
+    if(ANZAHL <= ANZEIGE_MAX)
+        gibArrayAus(zufallszahlen, ANZAHL);
+
+    return 0;
+}

09/suche/makefile

@@ -0,0 +1,7 @@
+LIBFILES = suche.c ../utils/zahlenEingabe.c ../utils/stoppuhr.c ../utils/zufallsarray.c
+
+sucheTest:
+	gcc -Wall -o sucheTest sucheTest.c $(LIBFILES)
+	
+zaehleVorkommen:
+	gcc -Wall -o zaehleVorkommen zaehleVorkommen.c $(LIBFILES)

09/suche/suche.c

@@ -0,0 +1,26 @@
+// TODO: Beginn
+
+#include <stdlib.h>
+#include "suche.h"
+
+int *binsucheZgr(int suchElem, int *startZgr, int *endZgr)
+{
+    while(startZgr <= endZgr)
+    {
+        int *mitte = startZgr + (endZgr - startZgr) / 2;
+
+        if(suchElem < *mitte)
+            endZgr = mitte - 1;
+        else if(suchElem > *mitte)
+            startZgr = mitte + 1;
+        else
+            return mitte;
+    }
+
+    return NULL;
+}
+
+int *binsuche(int suchElem, int array[], unsigned int anzahl)
+{
+    return binsucheZgr(suchElem, array, array + anzahl - 1);
+}

09/suche/suche.h

@@ -0,0 +1,6 @@
+#ifndef SUCHE_H
+#define SUCHE_H
+
+int *binsuche(int suchElem, int array[], unsigned int anzahl);
+
+#endif

09/suche/sucheTest.c

@@ -0,0 +1,78 @@
+/************************************************************************
+ * Das untenstehende Programm ist ein Testlauf für eine Binärsuche. Bei 
+ * einer Binärsuche geht man von (hier im Beispiel aufsteigend) 
+ * sortierten Daten aus, die durchsucht werden sollen. Dabei wird für 
+ * das in der Mitte befindliche Element geprüft, ob das zu suchende 
+ * Element größer oder kleiner ist. Ist es kleiner, wird der Teil links des 
+ * Mittelelements durchsucht, andernfalls der rechte Teil. Für den 
+ * entsprechende Datenanteil beginnt die Suche wie eben beschrieben von 
+ * vorne. Dies wiederholt man, bis man entweder das Element gefunden hat 
+ * oder keine Daten mehr zu durchsuchen sind und das zu suchende Element 
+ * folglich nicht enthalten ist.
+ * 
+ * Vervollständigen Sie das Programm unter suche.h und suche.c, indem Sie
+ * die fehlenden Funktionen ergänzen. Implementieren Sie die Binärsuche 
+ * einmal mit Array-Schreibweise und einmal mit Zeigerschreibweise.
+ * 
+ ***************************************************************************/
+
+#include <stdio.h>
+#include "suche.h"
+#include "../utils/zahlenEingabe.h"
+
+#define MAX_ZAHLEN 100
+
+void gibArrayEin(int array[], int anzahl);
+void gibArrayAus(int array[], int anzahl);
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN];
+    int suchZahl, anzahl;
+    int *suchErg;
+
+    printf("Wie viele Zahlen (max. %d)? ", MAX_ZAHLEN);
+    anzahl = gibMinMaxZahlEin(1, MAX_ZAHLEN);
+
+    printf("Geben Sie %d Zahlen in aufsteigender Reihenfolge ein:\n", anzahl);
+    gibArrayEin(zahlen, anzahl);
+
+    printf("\nDie Daten liegen folgendermassen im Speicher:\n");
+    gibArrayAus(zahlen, anzahl);
+
+    printf("Welche Zahl soll gesucht werden? ");
+    suchZahl = gibZahlEin();
+
+    suchErg = binsuche(suchZahl, zahlen, anzahl);
+
+    if(suchErg == NULL)
+        printf("\nDie Zahl konnte nicht gefunden werden.\n");
+    else
+        printf("\nDie Zahl %d befindet sich an Adresse %p, also an %d. Stelle im sortierten Array.\n", 
+            *suchErg, suchErg, (int)(suchErg - zahlen + 1));
+
+    return 0;
+}
+
+void gibArrayEin(int array[], int anzahl)
+{
+    printf("Geben Sie die 1. Zahl ein: ");
+    array[0] = gibZahlEin();
+
+    for(int i = 1; i < anzahl; i++)
+    {
+        printf("Geben Sie die %d. Zahl ein (min. %d): ", i+1, array[i-1]);
+        array[i] = gibMinZahlEin(array[i-1]);
+    }
+}
+
+void gibArrayAus(int array[], int anzahl)
+{
+    printf("     Adresse     |       Wert\n");
+    printf("-----------------------------------\n");
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf("%p | %16d\n", array+i, array[i]);
+    }
+    printf("\n");
+}

09/suche/zaehleVorkommen.c

@@ -0,0 +1,122 @@
+/**************************************************************
+ * Das untenstehende Programm soll ein Array mit Zufallswerten
+ * belegen, das Array aufsteigend sortieren und anschließend 
+ * ermitteln, wie häufig ein einzugebender Wert im Array vorkommt.
+ * Die Häufigkeit soll einmal naiv ermittelt werden und einmal 
+ * durch Verwendung Ihrer Implementierung für die binäre Suche. 
+ * Das Programm vergleicht anschließend die benötigten Laufzeiten 
+ * für beide Implementierungen.
+ * 
+ * 1. Implementieren Sie zunächst die Sortierung des Zufallsarrays.
+ *    (Die Funktionsaufrufe zur Ermittlung der Vorkommenszahlen müssen 
+ *     dafür auskommentiert werden.)
+ * 2. Implementieren Sie nun die naive Ermittlung der Anzahl an 
+ *    Vorkommen (ohne Binärsuche).
+ * 3. Implementieren Sie nun die Ermittlung der Anzahl an Vorkommen 
+ *    unter Verwendung Ihrer Implementierung der Binärsuche.
+ * 
+ ***************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include "../utils/zufallsarray.h"
+#include "../utils/stoppuhr.h"
+#include "../utils/zahlenEingabe.h"
+#include "suche.h"
+
+#define MAX_ANZAHL 500000
+#define ANZAHL MAX_ANZAHL
+#define MAX    ((int)(ANZAHL * 0.2))
+#define MIN    (-MAX)
+#define MAX_100(n) ((n) < 100 ? n : 100)
+
+int zaehleVorkommenNaiv(int suchElem, int array[], int anzahl);
+int zaehleVorkommenBs(int suchElem, int array[], int anzahl);
+int vergleiche(const void *arg1, const void *arg2);
+void gibArrayAus(int array[], int anzahl);
+
+int main()
+{
+    int suchZahl, anzahlVorkommen;
+    int zufallszahlen[ANZAHL];
+
+    srand(0);
+
+    fuelleArray(zufallszahlen, ANZAHL, MIN, MAX);
+    qsort(zufallszahlen, ANZAHL, sizeof(zufallszahlen[0]), vergleiche);
+
+    gibArrayAus(zufallszahlen, MAX_100(ANZAHL));
+
+    printf("Welche Zahl soll gesucht werden? ");
+    suchZahl = gibZahlEin();
+
+    printf("Zaehle naiv:\n");
+    starteUhr();
+    anzahlVorkommen = zaehleVorkommenNaiv(suchZahl, zufallszahlen, ANZAHL);
+
+    printf("Die Zahl %d ist %dx enthalten. (%lf Sekunden)\n", suchZahl, anzahlVorkommen, messeZeitInSek());
+
+    printf("Zaehle mit Binaersuche:\n");
+    starteUhr();
+    anzahlVorkommen = zaehleVorkommenBs(suchZahl, zufallszahlen, ANZAHL);
+
+    printf("Die Zahl %d ist %dx enthalten. (%lf Sekunden)\n", suchZahl, anzahlVorkommen, messeZeitInSek());
+    
+    return 0;
+}
+
+void gibArrayAus(int array[], int anzahl)
+{
+    printf("Die ersten %d Zufallszahlen: ", anzahl);
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf(" %4d", array[i]);
+    }
+    printf("\n");
+}
+
+int vergleiche(const void *arg1, const void *arg2)
+{
+    return *(const int *)arg1 - *(const int *)arg2;
+}
+
+int zaehleVorkommenNaiv(int suchElem, int array[], int anzahl)
+{
+    int vorkommen = 0;
+
+    for(int i = 0; i < anzahl && array[i] <= suchElem; i++)
+    {
+        if(array[i] == suchElem)
+            vorkommen++;
+    }
+
+    return vorkommen;
+}
+
+int zaehleVorkommenBs(int suchElem, int array[], int anzahl)
+{
+    int vorkommen = 0;
+
+    int *pos = binsuche(suchElem, array, anzahl);
+
+    if(pos != NULL)
+    {
+        int *start = pos;
+        int *ende = array + anzahl - 1;
+
+        while(*start == suchElem && start <= ende)
+        {
+            vorkommen++;
+            start++;
+        }
+        
+        start = pos-1;
+
+        while(*start == suchElem && start >= array)
+        {
+            vorkommen++;
+            start--;
+        }
+    }
+
+    return vorkommen;
+}

09/utils/stoppuhr.c

@@ -0,0 +1,14 @@
+#include <time.h>
+#include "stoppuhr.h"
+
+static clock_t zeitStempel = 0;
+
+void starteUhr()
+{
+    zeitStempel = clock();
+}
+
+double messeZeitInSek()
+{
+    return (double)(clock() - zeitStempel) / CLOCKS_PER_SEC;
+}

09/utils/stoppuhr.h

@@ -0,0 +1,7 @@
+#ifndef STOPPUHR_H
+#define STOPPUHR_H
+
+void starteUhr();
+double messeZeitInSek();
+
+#endif

09/utils/zahlenEingabe.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include "zahlenEingabe.h"
+
+int gibZahlEin()
+{
+    return gibMinMaxZahlEin(0x80000000, 0x7fffffff);
+}
+
+int gibMinZahlEin(int min)
+{
+    return gibMinMaxZahlEin(min, 0x7fffffff);
+}
+
+int gibMinMaxZahlEin(int min, int max)
+{
+    int zahl, geleseneWerte;
+
+    do
+    {
+        geleseneWerte = scanf("%d", &zahl);
+        while(getchar() != '\n') {}
+
+        if(geleseneWerte != 1 || zahl < min || zahl > max)
+            printf("Fehler! Erneute Eingabe: ");
+
+    } while(geleseneWerte != 1 || zahl < min || zahl > max);
+
+    return zahl;
+}

09/utils/zahlenEingabe.h

@@ -0,0 +1,8 @@
+#ifndef ZAHLEN_EINGABE_H
+#define ZAHLEN_EINGABE_H
+
+int gibZahlEin();
+int gibMinZahlEin(int min);
+int gibMinMaxZahlEin(int min, int max);
+
+#endif

09/utils/zufallsarray.c

@@ -0,0 +1,8 @@
+#include <stdlib.h>
+#include "zufallsarray.h"
+
+void fuelleArray(int array[], int anzahl, int min, int max)
+{
+    for(int i = 0; i < anzahl; i++)
+        array[i] = rand() % (max - min + 1) + min;
+}

09/utils/zufallsarray.h

@@ -0,0 +1,6 @@
+#ifndef ZUFALLSARRAY_H
+#define ZUFALLSARRAY_H
+
+void fuelleArray(int array[], int anzahl, int min, int max);
+
+#endif