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
pelzsa105867:upstream
pelzsa105867:main
..
compare: pelzsa105867:main
Branches Tags
pelzsa105867:upstream
pelzsa105867:main
paulusja:main

3 Commits
main ... main

Author SHA1 Message Date
Sam 'snaens' Pelz
81336ee063 bmi.c 2026-03-26 13:40:35 +01:00
Sam 'snaens' Pelz
d9083cf4c1 bmi.c 2026-03-26 13:32:28 +01:00
Sam 'snaens' Pelz
1e431c8f1e Add clion files to gitignore + Add clang-format 2026-03-26 13:31:08 +01:00
44 changed files with 77 additions and 1904 deletions
Show Stats Expand all files Collapse all files

57
.clang-format Normal file
View File

@ -0,0 +1,57 @@
---
Language: Cpp
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignOperands: true
AlignTrailingComments: false
AlwaysBreakTemplateDeclarations: Yes
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBraces: Custom
BreakConstructorInitializers: AfterColon
BreakConstructorInitializersBeforeComma: false
ColumnLimit: 240
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ContinuationIndentWidth: 8
IncludeCategories:
- Regex: '^<.*'
Priority: 1
- Regex: '^".*'
Priority: 2
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '([-_](test|unittest))?$'
IndentCaseLabels: true
IndentWidth: 4
InsertNewlineAtEOF: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 2
NamespaceIndentation: All
SpaceAfterCStyleCast: true
SpaceAfterTemplateKeyword: false
SpaceBeforeRangeBasedForLoopColon: false
SpaceInEmptyParentheses: false
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
TabWidth: 4
...

3
.gitignore vendored
View File

@ -1,3 +1,4 @@
*.zip
*.exe
*.o
*.o
.idea/

45
01/bmi.c
View File

@ -3,38 +3,29 @@
* Body Mass Index mit zwei Nachkommastellen ausgibt (bmi = gewicht / (groesse in m)²). *
*************************************************************************************************/
#include <stdio.h>
#include <stdio.h>
int main() {
unsigned int gewicht_kg = 0;
unsigned int groesse_cm = 0;
int main()
{
unsigned int gewichtInKg = 0;
unsigned int groesseInCm = 0;
double bmi = 0;
printf("Geben sie ihr Gewicht in Kg ein: ");
scanf("%d", &gewicht_kg);
printf("Geben Sie bitte Ihr Gewicht in Kg ein: ");
scanf("%d", &gewichtInKg);
printf("Geben sie Ihre Groesse in cm: ");
scanf("%d", &groesse_cm);
printf("Geben Sie bitte Ihre Groesse in cm ein: ");
scanf("%d", &groesseInCm);
printf("Gewicht: %i Kg\n", gewicht_kg);
printf("Groesse: %i cm\n", groesse_cm);
bmi = gewichtInKg / ((groesseInCm / 100.0) * (groesseInCm / 100.0));
printf("Fuer ein Gewicht mit %u kg und einer Groesse von %u cm lautet der BMI %lf.\n", gewichtInKg, groesseInCm, bmi);
printf("Das ist ");
if(bmi < 18.5)
{
printf("Untergewicht.\n");
}
else if(bmi > 25)
{
printf("Uebergewicht.\n");
}
double bmi = gewicht_kg / ((groesse_cm / 100.f) * (groesse_cm / 100.f));
printf("Fuer ein Gewicht mit %d Kg und %d cm lautet der BMI: %.2lf\n", gewicht_kg, groesse_cm, bmi);
if (bmi < 18.5)
printf("Das ist untergewichtig!");
else if (bmi > 25)
printf("Das ist uebergewichtig!");
else
{
printf("Normalgewicht.\n");
}
printf("Das ist Normalgewicht.");
return 0;
}
}

50
02/alphabet.c
View File

@ -1,50 +0,0 @@
/*****************************************************************************************
* Schreiben Sie ein Programm, das vom Benutzer einen Buchstaben einliest und ausgibt, *
* der wievielte Buchstabe im Alphabet die Eingabe ist. Groß- und Kleinschreibung sollen *
* keine Rolle spielen. Zudem soll das Programm vorher ausgeben, ob der Benutzer einen *
* Buchstaben eingegeben hat und die Ausgabe somit richtig ist. *
* *
* 1. Beispiel: *
* >> Geben Sie einen Buchstaben ein: B *
* Die folgende Ausgabe ist richtig, weil das Zeichen B ein Buchstabe ist: 1 *
* Der Buchstabe B ist der 2. Buchstabe im Alphabet. *
* *
* 2. Beispiel: *
* >> Geben Sie einen Buchstaben ein: b *
* Die folgende Ausgabe ist richtig, weil das Zeichen b ein Buchstabe ist: 1 *
* Der Buchstabe b ist der 2. Buchstabe im Alphabet. *
* *
* 3. Beispiel: *
* >> Geben Sie einen Buchstaben ein: 3 *
* Die folgende Ausgabe ist richtig, weil das Zeichen 3 ein Buchstabe ist: 0 *
* Der Buchstabe 3 ist der -13. Buchstabe im Alphabet. *
*****************************************************************************************/
#include <stdio.h>
#include <ctype.h>
#include "../io/myio.h"
int main()
{
unsigned char character = 'a';
while(character != '\n')
{
unsigned char lowerChar;
printf("Eingabe einzelnes Zeichen: ");
character = getSingleChar();
lowerChar = tolower(character);
if(lowerChar >= 'a' && lowerChar <= 'z')
{
unsigned int alphaPos = lowerChar - 'a' + 1;
printf("Der Buchstabe %c liegt an %u. Stelle im Alphabet.\n", character, alphaPos);
}
}
return 0;
}

37
02/anteile.c
View File

@ -1,37 +0,0 @@
/****************************************************************************************************
* Aufgaben
* 1. Begeben Sie sich zunaechst ohne Compiler auf Fehlersuche. Welche Fehler können Sie entdecken? *
* Wuerde das Programm uebersetzen? Wuerde das Programm korrekt laufen? *
* 2. Uebersetzen Sie nun das Programm ohne -Wall. Hilft Ihnen dies bei der Fehlersuche? *
* 3. Uebersetzen Sie nun das Programme mit -Wall. Hilft Ihnen dies bei der Fehlersuche? *
* 4. Finden und korrigieren Sie nun alle Fehler, sodass das Programm korrekte Ausgaben liefert. *
* Nehmen Sie dabei so wenig Veraenderungen wie moeglich vor. *
*****************************************************************************************************/
#include <stdio.h>
#define MAX_PUNKTE_TEIL_A 60
#define MAX_PUNKTE_TEIL_B 44
#define MAX_GESAMT_PUNKTE MAX_PUNKTE_TEIL_A + MAX_PUNKTE_TEIL_B
int main()
{
int pktTeilA, pktTeilB;
double ergInProzentTeilA, ergInProzentTeilB, gesamtErgInProzent;
printf("Wie viele Punkte wurden in Teil A erzielt: ");
scanf("%d", pktTeilA);
printf("Wie viele Punkte wurden in Teil B erzielt: ");
scanf("%d", pktTeilB);
ergInProzentTeilA = pktTeilA * 100 / MAX_PUNKTE_TEIL_A;
ergInProzentTeilB = pktTeilB * 100 / MAX_PUNKTE_TEIL_B;
gesamtErgInProzent = (pktTeilA + pktTeilB) * 100 / MAX_GESAMT_PUNKTE;
printf("Es wurden %d %% der moeglichen Punkte in Teil A erzielt.\n", ergInProzentTeilA);
printf("Es wurden %d %% der moeglichen Punkte in Teil B erzielt.\n", ergInProzentTeilB);
printf("Es wurden %d %% der moeglichen Punkte insgesamt erzielt.\n", gesamtErgInProzent);
return 0;
}

9
02/mwst.c
View File

@ -1,9 +0,0 @@
/***************************************************************************************************************
* Schreiben Sie ein Programm, das vom Benutzer einen Nettopreis in Euro einliest und dazu den Bruttopreis *
* ausgibt. Verwenden Sie fuer die Mehrwertsteuer eine symbolische Konstante und lagern Sie diese in eine *
* separate Header-Datei aus. Die Mehrwertsteuer betraegt derzeit 19 % (Buecher und Lebensmittel ausgenommen). *
* *
* Beispiel: *
* >> Geben Sie einen Nettopreis in Euro ein: 10 *
* Der Bruttopreis betraegt 11.90 Euro *
***************************************************************************************************************/

17
02/rechner.c
View File

@ -1,17 +0,0 @@
/************************************************************************************************
* Schreiben Sie ein Programm, das zwei Zahlen und anschliessend + oder - vom Benutzer einliest *
* und das Ergebnis der Rechenoperation ausgibt. Hinweis: Diese Aufgabe ist ohne if zu loesen, *
* das erst spaeter eingefuehrt wird. *
* *
* 1. Beispiel: *
* >> Geben Sie die 1. Zahl ein: 2 *
* >> Geben Sie die 2. Zahl ein: 3 *
* >> Geben Sie die gewuenschte Rechenoperation ein (+/-): - *
* 2 - 3 = -1 *
* *
* 2. Beispiel: *
* >> Geben Sie die 1. Zahl ein: 2 *
* >> Geben Sie die 2. Zahl ein: 3 *
* >> Geben Sie die gewuenschte Rechenoperation ein (+/-): + *
* 2 + 3 = 5 *
************************************************************************************************/

6
02/winkel.c
View File

@ -1,6 +0,0 @@
#include <stdio.h>
/***************************************************************************************************************************************
* Schreiben Sie ein Programm, das einen Winkel in Grad als ganze Zahl einliest und diesen in rad (als Fliesskommazahl) wieder ausgibt. *
* Nutzen Sie dabei sinnvoll mindestens eine Makro-Konstante. Der Winkel in rad soll dabei mit drei Nachkommastellen ausgegeben werden. *
****************************************************************************************************************************************/

32
02/zahlenVergleich.c
View File

@ -1,32 +0,0 @@
/****************************************************************************************************************
* Schreiben Sie ein Programm, das vom Benutzer zwei ganze, positive, *
* dreistellige Zahlen einliest und ausgibt, ob beide Zahlen gleich sind. *
* Dabei soll die erste Zahl mit scanf und die zweite mit getchar eingelesen *
* werden. Zudem soll das Programm ausgeben, ob die erste Eingabe des Benutzers *
* korrekt war. *
* *
* Wie erklaeren Sie sich den Verlauf des 2. Beispiels? *
* *
* 1. Beispiel: *
* >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 345 *
* Es wurde eine dreistellige, positive Zahl eingegeben: 1 *
* >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 345 *
* 345 == 345? -> 1 *
* *
* 2. Beispiel (Hier kann man die Ausgabe ignorieren, nachdem angezeigt wurde, dass die Eingabe nicht stimmt.): *
* >> Geben Sie eine dreistellige, ganze und positive Zahl ein: dfg *
* Es wurde eine dreistellige, positive Zahl eingegeben: 0 *
* >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 0 == 5912? -> 0 *
* *
* 3. Beispiel: *
* >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 567 *
* Es wurde eine dreistellige, positive Zahl eingegeben: 1 *
* >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 111 *
* 567 == 111? -> 0 *
* *
* 4. Beispiel: *
* >> Geben Sie eine dreistellige, ganze und positive Zahl ein: 20 *
* Es wurde eine dreistellige, positive Zahl eingegeben: 0 *
* >> Geben Sie noch einmal eine dreistellige, ganze und positive Zahl ein: 300 *
* 20 == 300? -> 0 *
****************************************************************************************************************/

36
03/bedingteBewertung.c
View File

@ -1,36 +0,0 @@
/********************************************************************************************
* Bedingte Zuweisung
* Schreiben Sie ein Programm, das abfragt, in welchem Studiensemester Sie sich befinden
* und dann ausgibt, ob Sie damit noch in Regelstudienzeit sind oder nicht.
* Beide Varianten der Ausgabe sollen ohne if-Anweisung in einem einzigen printf getätigt
* werden. Fangen Sie ungültige Eingaben mit einer entsprechenende Fehlermeldung ab.
*
* 1. Beispiel
* >> Wieviele Semester studieren Sie bereits? 2
* Sie studieren im 2. Semester. Damit sind Sie in Regelstudienzeit.
*
* 2. Beispiel
* >> Wieviele Semester studieren Sie bereits? 8
* Sie studieren im 8. Semester. Damit sind Sie NICHT MEHR in Regelstudienzeit.
********************************************************************************************/
#include <stdio.h>
#include "../io/myio.h"
#define MAX_REGULAR_SEMESTERS 7
#define MAX_SEMESTERS_INPUT 30
int main()
{
unsigned int numberOfSemesters = 0;
while(numberOfSemesters == 0 || numberOfSemesters > MAX_SEMESTERS_INPUT)
{
numberOfSemesters = getNumber("Wie viele Semester studieren Sie bereits? ");
}
printf("Sie studieren %sin Regelstudienzeit.\n", (numberOfSemesters <= MAX_REGULAR_SEMESTERS) ? "" : "NICHT ");
return 0;
}

30
03/castingLesen.c
View File

@ -1,30 +0,0 @@
/********************************************************************************************
* Sehen Sie sich untenstehenden Code und markieren Sie alle Stellen mit einem Kommentar, *
* an denen eine Datentypumwandlung stattfindet. Erklaeren Sie zudem, von welchem Datentyp *
* in welchen anderen umgewandelt wird und warum. *
********************************************************************************************/
#include <stdio.h>
#include <math.h>
int main()
{
int punkt1x, punkt1y;
unsigned int punkt2x, punkt2y;
float zeit, geschwindigkeit;
printf("Geben Sie die Koordinaten des 1. Punkts in Metern ein (x, y): ");
scanf("%d, %d", &punkt1x, &punkt1y);
printf("Geben Sie die Koordinaten des 2. Punkts in Metern ein (x, y): ");
scanf("%u, %u", &punkt2x, &punkt2y);
printf("Geben Sie die benoetigte Zeit in Sekunden ein: ");
scanf("%f", &zeit);
geschwindigkeit = sqrt((punkt1x - punkt2x) * (punkt1x - punkt2x) + (punkt1y - punkt2y) * (punkt1y - punkt2y)) / zeit;
printf("Um von der Koordinate (%d, %d) nach Koordinate (%d, %d) in %.2f Sekunden zu kommen, wird eine Geschwindigkeit von %.2f m/s benoetigt.\n", punkt1x, punkt1y, (int)punkt2x, (int)punkt2y, zeit, geschwindigkeit);
return 0;
}

37
03/expliztesCasting.c
View File

@ -1,37 +0,0 @@
/********************************************************************************************
* Schreiben Sie ein Programm, das einen Preis in Euro als Kommazahl vom Benutzer abfragt
* und diesen dann mittels explizitem casting in Euros und Cents zerlegt und ausgibt.
* Brechen Sie die Ausführung des Programms ab, wenn der Benutzer eine falsche Eingabe
* (z.B. keine gültige Zahl) gemacht hat.
*
* 1. Beispiel:
* >> Geben Sie einen Preis in Euro ein: 12.53
* Der Preis ist 12 Euro und 53 Cents.
*
* 2. Beispiel:
* >> Geben Sie einen Preis in Euro ein: abc
* Ungültige Eingabe!
********************************************************************************************/
#include <stdio.h>
#include "../io/myio.h"
int main()
{
double price = 0;
unsigned int priceEuro = 0;
unsigned int priceCents = 0;
do
{
price = getDoubleNumber("Geben Sie einen Preis ein: ");
} while (price < 0);
priceEuro = (unsigned int)price;
priceCents = (unsigned int)((price - priceEuro)*100);
printf("Preis: %d Euros, %d Cents\n", priceEuro, priceCents);
return 0;
}

77
03/ifElseGrab.c
View File

@ -1,77 +0,0 @@
/********************************************************************************************
* If-Else Grab
********************************************************************************************/
#include <stdio.h>
int main()
{
int status = 201;
int fehler = 0;
int warnung = 1;
int aktion = 1;
/********************************************************************************************
* Aufgabe: Schauen Sie sich folgende if/else Konstruktion an.
* a) Ist diese Ihrer Meinung nach gut lesbar?
* b) Identifizieren Sie Pfade, die überflüssig sind bzw. niemals ausgeführt werden.
* c) Vereinfachen Sie den Code unter Verwendung von so wenigen Verzweigungsebenen wie
* möglich, ohne die Ausgabe bzw. das Verhalten des Programms zu verändern
********************************************************************************************/
if (status == 200)
{
if (fehler)
{
printf("Fehler");
return -1;
}
if (aktion == 1)
{
if (!fehler)
{
if (!warnung)
{
printf("Aktion 1 erfolgreich ausgeführt.");
}
else if (warnung)
{
printf("Aktion 1 mit Warnung ausgeführt.");
if(status != 200)
{
printf("Ungültiger Status!");
}
}
}
else
{
printf("Fehler");
return -1;
}
}
else if (aktion == 2)
{
if (!fehler)
{
printf("Aktion 2 erfolgreich ausgeführt.");
}
}
else
{
printf("Unbekannte Aktion");
}
}
else if (status != 200)
{
if (fehler)
{
printf("Fehler");
return -1;
}
}
return 0;
}

41
03/taschenrechner.c
View File

@ -1,41 +0,0 @@
/*************************************************************
* Schreiben Sie ein Programm, das zwei positive Zahlen vom *
* Benutzer einliest sowie einen Rechenoperator und *
* anschliessend das Ergebnis ausgibt. Bei falschen Eingaben *
* soll das Programm kontrolliert beendet werden. *
* *
* 1. Beispiel: *
* >> Geben Sie eine positive, ganze Zahl ein: 50 *
* >> Geben Sie noch eine positive, ganze Zahl ein: 20 *
* >> Geben Sie einen Rechenoperator ein (+, -, *, /): - *
* 50 - 20 = 30 *
* *
* 2. Beispiel: *
* >> Geben Sie eine positive, ganze Zahl ein: 50 *
* >> Geben Sie noch eine positive, ganze Zahl ein: 20 *
* >> Geben Sie einen Rechenoperator ein (+, -, *, /): + *
* 50 + 20 = 70 *
* *
* 3. Beispiel: *
* >> Geben Sie eine positive, ganze Zahl ein: -50 *
* Falsche Eingabe! *
* *
* 4. Beispiel: *
* >> Geben Sie eine positive, ganze Zahl ein: 50 *
* >> Geben Sie noch eine positive, ganze Zahl ein: -20 *
* Falsche Eingabe! *
* *
* 5. Beispiel: *
* >> Geben Sie eine positive, ganze Zahl ein: 50 *
* >> Geben Sie noch eine positive, ganze Zahl ein: 20 *
* >> Geben Sie einen Rechenoperator ein (+, -, *, /): dfgfd *
* Unbekannter Rechenoperator d *
*************************************************************/
#include <stdio.h>
int main()
{
return 0;
}

34
03/verkehrsteilnehmer.c
View File

@ -1,34 +0,0 @@
/********************************************************************************************
* Verkehrsteilnehmer
*
* In einer Verkehrssimulation gibt es Fußgänger, Fahrräder, PKW, LKW/Bus und Motorräder.
* Schreiben Sie ein Programm, dass die Merkmale "Anzahl Räder" und "motorisiert" vom
* Benutzer abfragt und einen Verkehrsteilnehmer anhand dieser Merkmale identifiziert.
* Hinweise: Fußgänger haben 0 Räder, LKW/Bus haben eine gerade Anzahl Räder > 4.
* Für eine nicht existierende Merkmalskombination geben Sie eine entsprechende
* Meldung aus!
*
* 1. Beispiel
* >> Wieviele Räder? 2
* >> Motorisiert? 0
* Es handelt sich um ein Fahrrad.
*
* 2. Beispiel
* >> Wieviele Räder? 0
* >> Motorisiert? 1
* Es handelt sich um ein unbekannten Verkehrsteilnehmer.
*
* 3. Beispiel
* >> Wieviele Räder? 6
* >> Motorisiert? 1
* Es handelt sich um einen Bus oder LKW.
*
********************************************************************************************/
#include <stdio.h>
int main()
{
return 0;
}

30
04/asciiTabelle.c
View File

@ -1,30 +0,0 @@
/********************************************************************************************
* Ascii-Tabelle
*
* Schreiben Sie ein Programm, das zwei Zeichen abfragt und dann alle Zeichen der Ascii-
* Tabelle ausgibt, die zwischen diesen zwei Zeichen liegen. Falls das Ende der Ascii-Tabelle
* erreicht wird, soll die Ausgabe wieder am Anfang beginnen! Geben Sie nur sichtbare Zeichen
* aus, keine Kontrollzeichen (Hinweis: Sie können die Funktion iscntrl() aus ctype.h dafür
* verwenden).
*
* 1. Beispiel:
* >> Geben Sie ein einzelnes Zeichen ein: C
* >> Geben Sie noch ein einzelnes Zeichen ein: c
* Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
* DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab
*
* 2. Beispiel:
* >> Geben Sie ein einzelnes Zeichen ein: c
* >> Geben Sie noch ein einzelnes Zeichen ein: C
* Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
* defghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@AB
*********************************************************************************************/
#include <stdio.h>
#include <ctype.h>
int main()
{
return 0;
}

48
04/binaerUmrechnungSchleife1.c
View File

@ -1,48 +0,0 @@
/***********************************************************************************
* Aufgabe *
* Schreiben Sie ein Programm, das eine ganze Zahl einliest und die Rechenschritte *
* anzeigt, um die Bits der entsprechenden Binaerzahl zu ermitteln. Nutzen Sie *
* eine geeignete Schleife, sodass das Programm alle Stellen der Binärzahl anzeigt.*
* Lesen Sie zudem solange ein, bis eine positive Zahl eingegeben wird. *
* *
* Beispiel: *
* >> Geben Sie eine ganze, positive Zahl ein: abc *
* >> Geben Sie eine ganze, positive Zahl ein: -5 *
* >> Geben Sie eine ganze, positive Zahl ein: 21 *
* 21 / 2 = 10, Rest: 1 *
* 10 / 2 = 5, Rest: 0 *
* 5 / 2 = 2, Rest: 1 *
* 2 / 2 = 1, Rest: 0 *
* *
* Schreiben Sie danach das Programm so um, dass es Bit- und Shiftoperatoren *
* verwendet sowie negative Zahlen verarbeiten kann. Die Rechenschritte werden *
* nicht mehr anzeigt, sondern nur noch das Bitmuster aller gespeicherten Bits. *
* *
* Beispiele: *
* >> Geben Sie eine ganze Zahl ein: abc *
* >> Geben Sie eine ganze Zahl ein: 21 *
* 00000000000000000000000000010101 *
* *
* >> Geben Sie eine ganze Zahl ein: -9 *
* 11111111111111111111111111110111 *
***********************************************************************************/
#include <stdio.h>
#include "../io/myio.h"
int main()
{
unsigned int number = getNumber("Ganze Zahl: ");
while(number > 0)
{
int remainder = number % 2;
int division = number / 2;
printf("%5d / 2 = %5d; Rest %d\n", number, division, remainder);
number = division;
}
return 0;
}

44
04/binaerUmrechnungSchleife2.c
View File

@ -1,44 +0,0 @@
/***********************************************************************************
* Aufgabe *
* Schreiben Sie ein Programm, das eine ganze Zahl einliest und die Rechenschritte *
* anzeigt, um die Bits der entsprechenden Binaerzahl zu ermitteln. Nutzen Sie *
* eine geeignete Schleife, sodass das Programm alle Stellen der Binärzahl anzeigt.*
* Lesen Sie zudem solange ein, bis eine positive Zahl eingegeben wird. *
* *
* Beispiel: *
* >> Geben Sie eine ganze, positive Zahl ein: abc *
* >> Geben Sie eine ganze, positive Zahl ein: -5 *
* >> Geben Sie eine ganze, positive Zahl ein: 21 *
* 21 / 2 = 10, Rest: 1 *
* 10 / 2 = 5, Rest: 0 *
* 5 / 2 = 2, Rest: 1 *
* 2 / 2 = 1, Rest: 0 *
* *
* Schreiben Sie danach das Programm so um, dass es Bit- und Shiftoperatoren *
* verwendet sowie negative Zahlen verarbeiten kann. Die Rechenschritte werden *
* nicht mehr anzeigt, sondern nur noch das Bitmuster aller gespeicherten Bits. *
* *
* Beispiele: *
* >> Geben Sie eine ganze Zahl ein: abc *
* >> Geben Sie eine ganze Zahl ein: 21 *
* 00000000000000000000000000010101 *
* *
* >> Geben Sie eine ganze Zahl ein: -9 *
* 11111111111111111111111111110111 *
***********************************************************************************/
#include <stdio.h>
#include "../io/myio.h"
int main()
{
unsigned int number = getNumber("Ganze Zahl: ");
for(int i = sizeof(number)*8-1; i >= 0; i--)
{
printf("%d", 1 & (number >> i));
}
return 0;
}

29
04/eingabePruefung.c
View File

@ -1,29 +0,0 @@
/********************************************************************************************
* Eingabeprüfung
*
* Schreiben Sie ein Programm, das einen Preis in Euro als Kommazahl vom Benutzer abfragt
* und diesen dann mittels explizitem casting in Euros und Cents zerlegt und ausgibt.
* Falls eine ungültige Eingabe gemacht wird (z.B. eine negative Zahl oder Buchstaben),
* geben Sie eine entsprechende Meldung aus und wiederholen sie die Eingabeabfrage solange,
* bis eine gültige Eingabe erfolgt ist.
*
* 1. Beispiel:
* >> Geben Sie einen Preis in Euro ein: 12.53
* Der Preis ist 12 Euro und 53 Cents.
*
* 2. Beispiel:
* >> Geben Sie einen Preis in Euro ein: abc
* Eingabe ungueltig. Geben Sie eine positive Zahl ein!
* >> Geben Sie einen Preis in Euro ein: 32.12
* Der Preis ist 32 Euro und 12 Cents.
*********************************************************************************************/
#include <stdio.h>
// siehe 03: explizitesCasting.c
int main()
{
return 0;
}

29
04/heron.c
View File

@ -1,29 +0,0 @@
/****************************************************************************************************************************************************
* Schreiben Sie ein Programm, das eine Gleitkommazahl vom Benutzer einliest und dessen Quadratwurzel approximiert, ohne math.h zu verwenden. *
* Lesen Sie dafür zunächst solange Eingaben ein, bis eine Zahl eingegeben wird, die mindestens 0 ist. Andere Eingaben werden verworfen. *
* Implementieren Sie danach den Algorithmus nach Heron. Dafür gehen wir davon aus, dass die eingegebene Zahl der Flächeninhalt eines Quadrats ist, *
* die Seitenlänge aber unbekannt ist. Wir versuchen nun ein Rechteck mit dem angegebenen Flächeninhalt zu konstruieren und stückweise beide *
* Seitenlängen aneinander anzugleichen, bis ein Quadrat mit dem gewünschten Flächeninhalt entsteht. *
* Wir initialisieren die beiden unbekannten Seitenlängen mit dem halben Flächeninhalt und dem Flächeninhalt geteilt durch die erste Seitenlänge. *
* Wie erwartet erhalten wir kein Quadrat, sondern ein allgemeines Rechteck. Wir nähern nun die beiden Seitenlängen aneinander an, müssen aber *
* dafür sorgen, dass der Flächeninhalt immer gleich bleibt. Dazu halbieren wir für die erste Seitenlänge die Summe beider Seitenlängen. Für *
* die zweite Seitenlänge teilen wir wieder den Flächeninhalt durch die erste Seitenlänge, um *
* Seitenlänge 1 * Seitenlänge 2 = Flächeninhalt = eingegebener Zahl *
* zu erhalten. Dies wiederholen wir, bis (Seitenlänge 1 - Seitenlänge 2)² <= 10^-9 ist. So konstruieren wir schrittweise ein Quadrat mit dem *
* eingegebenen Flächeninhalt und approximieren gleichzeitig die Quadratwurzel der eingegebenen Zahl. Am Ende geben wir das Ergebnis aus. *
* *
* Beispiel: *
* >> Geben Sie eine Zahl ein: abc *
* >> Geben Sie eine Zahl ein: -5 *
* >> Geben Sie eine Zahl ein: 5.5 *
* 2.345208 * 2.345208 = 5.500000 *
* *
****************************************************************************************************************************************************/
#include <stdio.h>
int main()
{
return 0;
}

66
05/geminiAufgabe1.c
View File

@ -1,66 +0,0 @@
/*Die Aufgabe: "Zahlen-Jongleur"
Schreibe ein Programm, das eine vom Benutzer festgelegte Anzahl an Zufallszahlen generiert. Das Programm soll für jede Zahl entscheiden, ob sie gerade oder ungerade ist, und am Ende einige statistische Werte ausgeben.
Anforderungen:
Erstelle eine Funktion analysiereZahlen(int anzahl).
Diese Funktion soll anzahl Zufallszahlen im Bereich von 1 bis 100 generieren.
Für jede generierte Zahl soll auf der Konsole ausgegeben werden, ob sie gerade oder ungrade ist.
Am Ende der Funktion sollen die Summe aller generierten Zahlen sowie der Durchschnitt (als Fließkommazahl) ausgegeben werden.
Verwende rand() zur Erzeugung der Zahlen und den Modulo-Operator % zur Prüfung der Parität.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// --- HIER die Funktion analysiereZahlen ergänzen ---
void analysiereZahlen(int anzahl);
// --------------------------------------------------
int main() {
int menge;
// Initialisierung des Zufallszahlengenerators mit der aktuellen Zeit
srand((unsigned int)time(NULL));
printf("Wie viele Zufallszahlen sollen generiert werden? ");
if (scanf("%d", &menge) != 1 || menge <= 0) {
printf("Bitte gib eine positive Ganzzahl ein.\n");
return 1;
}
printf("\nStarte Analyse von %d Zahlen:\n", menge);
printf("------------------------------------\n");
analysiereZahlen(menge);
printf("------------------------------------\n");
printf("Analyse beendet.\n");
return 0;
}
void analysiereZahlen(int anzahl)
{
unsigned int summe = 0;
for(int i = 0; i < anzahl; i++)
{
unsigned int zufallszahl = rand() % 100 + 1;
if(zufallszahl % 2 == 0)
printf("Die Zahl %d ist gerade.\n", zufallszahl);
else
printf("Die Zahl %d ist ungerade.\n", zufallszahl);
summe += zufallszahl;
}
printf("Durchschnitt: %lf.\n", (double)summe / anzahl);
}

85
05/geminiAufgabe2.c
View File

@ -1,85 +0,0 @@
/*
Die Aufgabe: „Der statistische Würfel-Check“
Stell dir vor, du möchtest prüfen, wie „fair“ ein virtueller Würfel ist. Da wir keine Arrays nutzen dürfen, konzentrieren wir uns auf ein bestimmtes Ziel: Wir wollen zählen, wie oft eine vom Benutzer gewählte Glückszahl hintereinander gewürfelt wird (Streak).
Deine Mission:
Implementiere die Funktion simulateDiceStreaks. Diese soll:
In einer Schleife so viele Zufallszahlen (zwischen 1 und 6) generieren, wie der Parameter trials angibt.
Prüfen, ob die gewürfelte Zahl der luckyNumber entspricht.
Die längste Folge (Streak) ermitteln, in der die luckyNumber direkt hintereinander erschienen ist.
Diesen Maximalwert am Ende zurückgeben.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// --- DEINE FUNKTION HIER ERGÄNZEN ---
// Funktionsname: simulateDiceStreaks
// Parameter: int trials (Anzahl Würfe), int luckyNumber (Zahl 1-6)
// Rückgabewert: int (die längste Serie der luckyNumber)
unsigned int simulateDiceStreaks(unsigned int trials, int luckyNumber);
unsigned int rollDice();
// ------------------------------------
int main() {
int trials = 1000;
int luckyNumber;
int longestStreak;
// Seed für den Zufallszahlengenerator setzen
srand((unsigned int)time(NULL));
printf("Willkommen beim Würfel-Statistik-Tool!\n");
printf("Welche Zahl (1-6) ist deine Glückszahl? ");
scanf("%d", &luckyNumber);
if (luckyNumber < 1 || luckyNumber > 6) {
printf("Ungültige Eingabe. Bitte eine Zahl zwischen 1 und 6 wählen.\n");
return 1;
}
printf("Simuliere %d Würfe...\n", trials);
// Funktionsaufruf
longestStreak = simulateDiceStreaks(trials, luckyNumber);
printf("\nErgebnis:\n");
printf("Deine Glückszahl %d erschien maximal %d Mal direkt hintereinander.\n",
luckyNumber, longestStreak);
return 0;
}
unsigned int simulateDiceStreaks(unsigned int trials, int luckyNumber)
{
unsigned int highestStreak = 0;
unsigned int currentStreak = 0;
for(int i = 0; i < trials; i++)
{
unsigned int randNumber = rollDice();
if(randNumber == luckyNumber)
currentStreak++;
else
{
if(currentStreak > highestStreak)
highestStreak = currentStreak;
currentStreak = 0;
}
}
return highestStreak;
}
unsigned int rollDice()
{
return rand() % 6 + 1;
}

35
05/maexchen.c
View File

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

58
05/quadPlatten.c
View File

@ -1,58 +0,0 @@
/****************************************************************************************
* 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>
#include "../io/myio.h"
unsigned int inputPositiveNumber(const char *text);
unsigned int getGreatestCommonDivisor(unsigned int number1, unsigned int number2);
int main()
{
unsigned int squareWidth = inputPositiveNumber("Geben Sie die Breite des Platzes ein: ");
unsigned int sqaureHeight = inputPositiveNumber("Geben Sie die Hoehe des Platzes ein: ");
unsigned int tileSize = getGreatestCommonDivisor(squareWidth, sqaureHeight);
unsigned int tileCount = (squareWidth * sqaureHeight) / (tileSize * tileSize);
printf("Sie benoetigen %d Platten der Groesse %dx%d.\n", tileCount, tileSize, tileSize);
return 0;
}
unsigned int inputPositiveNumber(const char *text)
{
int number = -1;
while(number <= 0)
{
number = getNumber(text);
}
return number;
}
unsigned int getGreatestCommonDivisor(unsigned int number1, unsigned int number2)
{
while(number2 > 0)
{
unsigned int error = number1 % number2;
number1 = number2;
number2 = error;
}
return number1;
}

1
05/wuerfelSpiel.h
View File

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

64
05/wuerfelSpielMain.c
View File

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

54
06/divisionMitRest.c
View File

@ -1,54 +0,0 @@
/********************************************************************************************
* 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>
#include "../io/myio.h"
int inputNonZeroNumber(const char* text);
int divideWithRemainder(int number1, int number2, int* remainder);
int main()
{
int number1 = getNumber("Geben Sie eine Zahl ein: ");
int number2 = inputNonZeroNumber("Geben Sie eine Zahl ein (!=0): ");
int remainder = 0;
int divisonResult = divideWithRemainder(number1, number2, &remainder);
printf("%d / %d = %d, R: %d\n", number1, number2, divisonResult, remainder);
return 0;
}
int inputNonZeroNumber(const char* text)
{
int result = 0;
while(result == 0)
{
result = getNumber(text);
}
return result;
}
int divideWithRemainder(int n1, int n2, int* remainder)
{
*remainder = n1 % n2;
return n1 / n2;
}

39
06/reverseEngineering.c
View File

@ -1,39 +0,0 @@
/********************************************************************************************
* 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
View File

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

116
06/wechselgeld.c
View File

@ -1,116 +0,0 @@
/**************************************************************************************************************************
* 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>
#include "../io/myio.h"
#define MIN_PREIS_IN_EUROS 5.15
#define MAX_PREIS_IN_EUROS 12.95
double ermittlePreis();
double wirfGeldEin(double preisInEuro);
int errechneWechselgeld(double restBetrag, int *anzahlZweiEuro, int *anzahlFuenzigCent, int *anzahlZehnCent);
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);
istWechselGeldKomplett = errechneWechselgeld(restBetragInEuro, &zweiEuroMuenzen, &fuenzigCentMuenzen, &zehnCentMuenzen);// 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;
}
double ermittlePreis()
{
int minCents = 100 * MIN_PREIS_IN_EUROS;
int maxCents = 100 * MAX_PREIS_IN_EUROS;
int zufallsPreisInCent = rand() % (maxCents - minCents + 1) + minCents;
return zufallsPreisInCent / 100.0;
}
double wirfGeldEin(double preisInEuro)
{
double eingabe = 0;
printf("Bitte bezahlen Sie %.2lf Euro.\n", preisInEuro);
while(eingabe < preisInEuro)
{
eingabe = getDoubleNumber("Bitte Geld einwerfen: ");
}
return eingabe;
}
int errechneWechselgeld(double restBetrag, int *anzahlZweiEuro, int *anzahlFuenzigCent, int *anzahlZehnCent)
{
unsigned int restBetragCent = restBetrag * 100;
*anzahlZweiEuro = restBetragCent / 200;
restBetragCent %= 200;
*anzahlFuenzigCent = restBetragCent / 50;
restBetragCent %= 50;
*anzahlZehnCent = restBetragCent / 10;
restBetragCent %= 10;
return restBetragCent == 0;
}

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

42
io/myio.c
View File

@ -1,42 +0,0 @@
#include <stdio.h>
#include "myio.h"
unsigned char getSingleChar()
{
unsigned char result = 'a';
result = getchar();
while(result != '\n' && getchar() != '\n') {}
return result;
}
int getNumber(const char *text)
{
int number = 0;
int wasSuccessful = 0;
do
{
printf("%s", text);
wasSuccessful = scanf("%d", &number);
while(getchar() != '\n') {}
} while(!wasSuccessful);
return number;
}
double getDoubleNumber(const char *text)
{
double number = 0;
int wasSuccessful = 0;
do
{
printf("%s", text);
wasSuccessful = scanf("%lf", &number);
while(getchar() != '\n') {}
} while(!wasSuccessful);
return number;
}

8
io/myio.h
View File

@ -1,8 +0,0 @@
#ifndef MYIO_H
#define MYIO_H
unsigned char getSingleChar();
int getNumber(const char *text);
double getDoubleNumber(const char *text);
#endif

11
io/testInput.c
View File

@ -1,11 +0,0 @@
#include <stdio.h>
#include "../io/myio.h"
int main()
{
int number = getNumber("Geben Sie eine Zahl ein: ");
printf("number: %d\n", number);
return 0;
}