paulusja/info1_uebungen
1
0
Fork 2
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: paulusja:main
Branches Tags
paulusja:main
matheisfa104319:main
..
compare: matheisfa104319:main
Branches Tags
matheisfa104319:main
paulusja:main

No commits in common. "main" and "main" have entirely different histories.
main ... main

11 changed files with 0 additions and 656 deletions
Show Stats Expand all files Collapse all files

82
07/mastermind.c
View File

@ -1,82 +0,0 @@
/**********************************************************************
* 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;
}

61
07/mastermind_eingabe.c
View File

@ -1,61 +0,0 @@
#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: ");
}
}

9
07/mastermind_eingabe.h
View File

@ -1,9 +0,0 @@
#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

1
07/mastermind_logik.c
View File

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

11
07/mastermind_logik.h
View File

@ -1,11 +0,0 @@
#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

24
07/rotiereArray.c
View File

@ -1,24 +0,0 @@
/********************************************************************************************
* 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;
}

123
07/selectionsort.c
View File

@ -1,123 +0,0 @@
/*****************************************************************
* 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;
}

124
07/selectionsort_zgr.c
View File

@ -1,124 +0,0 @@
/*****************************************************************
* 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;
}

142
08/codeNachricht.c
View File

@ -1,142 +0,0 @@
/**************************************************************************************************************
* 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;
}

60
08/noten.c
View File

@ -1,60 +0,0 @@
/**********************************************
* 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;
}

19
08/sortiereMatrix.c
View File

@ -1,19 +0,0 @@
/*******************************************************************************
* 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;
}