Add solution for code.

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;
+}