Add solution with hard coded array content.

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,104 @@
+/*****************************************************************
+ * 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>
+
+#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);
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN] = {10, 5, 3, -1, 0, 2};
+    unsigned int len = sizeof(zahlen) / sizeof(zahlen[0]); 
+    unsigned int benutzteLaenge = 6;
+
+    zeigeArray(zahlen, benutzteLaenge);
+
+    selectionsort(zahlen, benutzteLaenge);
+
+    zeigeArray(zahlen, benutzteLaenge);
+    
+    
+    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;
+}