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

Add new exercises 05 and 06.

Browse Source
This commit is contained in:
Jan Paulus 2026-04-30 10:33:24 +02:00
parent 943fbf6ffa
commit 292b3c6650
8 changed files with 317 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
05/maexchen.c Normal file
View File

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

24
05/quadPlatten.c Normal file
View File

@ -0,0 +1,24 @@
/****************************************************************************************
* Schreiben Sie ein Programm, das die Laenge und Breite eines Platzes einliest und *
* ausgibt, wie viele quadratische Platten benoetigt werden, um die Flaeche komplett *
* zu bedecken. Dabei sollen so wenig Platten wie möglich verwendet werden. *
* *
* Beispiel: *
* Geben Sie die Laenge des Platzes ein. *
* >> Geben Sie eine positive, ganze Zahl ein: gfdgfd *
* >> Geben Sie eine positive, ganze Zahl ein: -5 *
* >> Geben Sie eine positive, ganze Zahl ein: 55 *
* Geben Sie die Breite des Platzes ein. *
* >> Geben Sie eine positive, ganze Zahl ein: 0 *
* >> Geben Sie eine positive, ganze Zahl ein: rtre *
* >> Geben Sie eine positive, ganze Zahl ein: 100 *
* Sie benoetigen 220 Platten der Groesse 5x5. *
****************************************************************************************/
#include <stdio.h>
int main()
{
return 0;
}

1
05/wuerfelSpiel.h Normal file
View File

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

64
05/wuerfelSpielMain.c Normal file
View File

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

25
06/divisionMitRest.c Normal file
View File

@ -0,0 +1,25 @@
/********************************************************************************************
* Schreiben Sie ein Programm, das zwei ganze Zahlen einliest und das Ergebnis der
* ganzzahligen Division der beiden Zahlen sowie den Rest ausgibt. Schreiben Sie eine Funktion,
* die beide Ergebnisse (Division + Rest) zurückgibt. Das Programm soll, wie gehabt, solange
* nach einer Eingabe fragen, bis diese gültig ist.
*
* Beispielablauf:
* Dividend
* Geben Sie eine Zahl ein: qwert
* Fehler! Keine Zahl!
* Geben Sie eine Zahl ein: 32
* Divisor
* Geben Sie eine Zahl ein: 0
* Fehler! Die Zahl darf nicht 0 sein!
* Geben Sie eine Zahl ein: 5
* Ergebnis: 32 / 5 ist 6 mit Rest 2.
********************************************************************************************/
#include <stdio.h>
int main()
{
return 0;
}

39
06/reverseEngineering.c Normal file
View File

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

55
06/rotiere.c Normal file
View File

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

74
06/wechselgeld.c Normal file
View File

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