Compare commits
5
Commits
ea24c91501
...
master
| Author | SHA1 | Date | |
|---|---|---|---|
 chilabal90797
|
517c976643 | ||
|
chilabal90797
|
be0e538ff4 | ||
|
chilabal90797
|
ed92d64f65 | ||
|
chilabal90797
|
ced22cc6fc | ||
|
chilabal90797
|
188c47585b |
No files matched your search
@@ -0,0 +1,96 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
long int ZahlBinaer(int num)
|
||||
{
|
||||
int sum = 0;
|
||||
for (int mult = 1, mod = 2; num > 0; mult *= 10, mod *= 2)
|
||||
{
|
||||
if (num % mod)
|
||||
{
|
||||
sum += mult;
|
||||
num -= mod / 2;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int ZahlOktal(int num)
|
||||
{
|
||||
int sum = 0;
|
||||
for (int mult = 1, mod = 8, div = 1; num > 0; mult *= 10, mod *= 8, div *= 8)
|
||||
{
|
||||
if (num % mod)
|
||||
{
|
||||
sum += (num % mod / div) * mult;
|
||||
num -= num % mod;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int doBin = 0;
|
||||
int doHex = 0;
|
||||
int doOct = 0;
|
||||
int num = 0;
|
||||
|
||||
for (int i = 1; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] != '-')
|
||||
{
|
||||
if (num == 0)
|
||||
{
|
||||
num = atoi(argv[i]);
|
||||
printf("Dezimal: %d\n", num);
|
||||
if (argc == 2)
|
||||
{
|
||||
doBin = 1, doHex = 1, doOct = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Nur eine Zahl ist erlaubt!\n\n");
|
||||
printf("Nur folgende Parameter sind erlaubt:\n--b Binaersystem\n--o Oktalsystem\n--h Hexadezimalsystem");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int j = 2;
|
||||
while (argv[i][j] != '\0')
|
||||
{
|
||||
if (argv[i][j] == 'b')
|
||||
{
|
||||
doBin = 1;
|
||||
}
|
||||
else if (argv[i][j] == 'o')
|
||||
{
|
||||
doOct = 1;
|
||||
}
|
||||
else if (argv[i][j] == 'h')
|
||||
{
|
||||
doHex = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Unerlaubte Option: --%c\n", argv[i][j]);
|
||||
return 0;
|
||||
}
|
||||
j++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (doBin)
|
||||
{
|
||||
printf("Binär: %ld\n", ZahlBinaer(num));
|
||||
}
|
||||
if (doHex)
|
||||
{
|
||||
printf("Hexadezimal: %X\n", num);
|
||||
}
|
||||
if (doOct)
|
||||
{
|
||||
printf("Oktal: %d\n", ZahlOktal(num));
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h> //malloc und free
|
||||
|
||||
void ausgabe_liste(const char **listen) //Array von (listen) als Parameter
|
||||
void ausgabe_liste(const char **listen) //Zeiger auf Array von (listen) als Parameter
|
||||
{
|
||||
for (int i = 0; i < 10; i++) //Schleife geht von 0-9 - Gibt jedes Element des Arrays mit Position aus
|
||||
{
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h> //power
|
||||
#include <stdbool.h>
|
||||
#define MAX_LEN 100
|
||||
|
||||
struct Zahl
|
||||
{
|
||||
int vorkomma;
|
||||
int nachkomma;
|
||||
int len;
|
||||
};
|
||||
|
||||
int EingabeKomma(struct Zahl *i) //die Funktion gibt einen ganzzahligen Wert zurück (0 für Erfolg, 1 für Abbruch); struct Zahl *i – Erwartet einen Zeiger auf eine Zahl-Struktur
|
||||
{
|
||||
char str[MAX_LEN]; //Reserviert einen Zeichenarray mit der Länge MAX_LEN
|
||||
fgets(str, MAX_LEN, stdin); //fgets() liest eine ganze Zeile vom Standard-Input (stdin) ein; str – Der Puffer, in den der Text geschrieben wird
|
||||
|
||||
if (str[0] == '\n')
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
sscanf(str, "%d,%d", &i->vorkomma, &i->nachkomma);
|
||||
|
||||
char *str2 = strtok(str, ",");
|
||||
str2 = strtok(NULL, ","); //strtok() verändert den Original-String direkt
|
||||
|
||||
i->len = strlen(str2); ////strlen() – Bestimmt die Länge des Nachkommateils (str2)
|
||||
if (str2[i->len - 1] == '\n') //i->len - 1: Der letzte Buchstabe hat den Index Länge - 1
|
||||
{
|
||||
i->len--; //Wenn '\n' gefunden wird, wird die Länge um 1 reduziert
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Kommaaddieren(struct Zahl *sum, struct Zahl *summand) //Diese Funktion addiert eine neue Kommazahl (summand) zur bestehenden Summe (sum)
|
||||
{
|
||||
if (summand->len > sum->len)
|
||||
{
|
||||
for (int i = 0; i < (summand->len - sum->len); i++) //Multipliziert den Nachkommateil der Summe so oft mit 10, bis beide die gleiche Anzahl an Nachkommastellen haben
|
||||
{
|
||||
sum->nachkomma *= 10;
|
||||
}
|
||||
sum->len = summand->len; //Passt die Länge der Summe an die des Summanden an, damit die Addition korrekt funktioniert
|
||||
}
|
||||
else if (summand->len < sum->len) //Prüft, ob die Nachkommastellen des Summanden länger sind als die der aktuellen Summe
|
||||
{
|
||||
for (int i = 0; i < (sum->len - summand->len); i++)
|
||||
{
|
||||
summand->nachkomma *= 10;
|
||||
}
|
||||
}
|
||||
|
||||
sum->nachkomma += summand->nachkomma;
|
||||
|
||||
int power_of_ten = 1;
|
||||
for (int i = 0; i < sum->len; i++)
|
||||
{
|
||||
power_of_ten *= 10;
|
||||
}
|
||||
|
||||
if (sum->nachkomma >= power_of_ten) // Wenn die Nachkommastellen größer oder gleich 10^len sind:
|
||||
{
|
||||
sum->nachkomma -= power_of_ten;
|
||||
sum->vorkomma += 1;
|
||||
}
|
||||
|
||||
sum->vorkomma += summand->vorkomma;
|
||||
}
|
||||
|
||||
void AusgabeKomma(struct Zahl *sum)
|
||||
{
|
||||
printf("Ergebnis:\n%d,", sum->vorkomma);
|
||||
printf("%0*d", sum->len, sum->nachkomma);
|
||||
}
|
||||
|
||||
int AnzahlNachkommastellen(struct Zahl *i)
|
||||
{
|
||||
int temp = i->nachkomma;
|
||||
int len = 0;
|
||||
|
||||
if (temp == 0)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
while (temp > 0)
|
||||
{
|
||||
len++;
|
||||
temp /= 10;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
struct Zahl sum = {0, 0, 0};
|
||||
struct Zahl summand = {0, 0, 0};
|
||||
|
||||
bool abbruch = false;
|
||||
printf("Bitte gib eine deutsche Kommazahl ein:\n");
|
||||
|
||||
while (!abbruch)
|
||||
{
|
||||
abbruch = EingabeKomma(&summand);
|
||||
if (!abbruch)
|
||||
{
|
||||
Kommaaddieren(&sum, &summand);
|
||||
}
|
||||
}
|
||||
|
||||
AusgabeKomma(&sum);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define ANZ_SCHUELER 30
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char name[10];
|
||||
char vorname[10];
|
||||
unsigned note;
|
||||
} Person;
|
||||
|
||||
int eingabe(Person *p, int i)
|
||||
{
|
||||
printf("---Eingabe des %d. Schuelers----\n", i);
|
||||
printf("Name: ");
|
||||
fgets(p->name, sizeof(p->name), stdin);
|
||||
if (p->name[strlen(p->name) - 1] == '\n')
|
||||
{
|
||||
p->name[strlen(p->name) - 1] = '\0';
|
||||
}
|
||||
|
||||
if (strlen(p->name) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
printf("Vorname: ");
|
||||
fgets(p->vorname, sizeof(p->vorname), stdin);
|
||||
if (p->vorname[strlen(p->vorname) - 1] == '\n')
|
||||
{
|
||||
p->vorname[strlen(p->vorname) - 1] = '\0';
|
||||
}
|
||||
|
||||
if (strlen(p->vorname) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
printf("Note: ");
|
||||
if (scanf("%u", &p->note) != 1 || p->note < 0 || p->note > 6)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
while (getchar() != '\n');
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
float durchschnittsnote(Person *n, int anzahl)
|
||||
{
|
||||
float sum = 0;
|
||||
float durchschnitt;
|
||||
for (int i = 0; i < anzahl; ++i)
|
||||
{
|
||||
sum += n[i].note;
|
||||
}
|
||||
durchschnitt = sum / anzahl;
|
||||
return durchschnitt;
|
||||
|
||||
}
|
||||
|
||||
void notenspiegel(Person *n, int anzahl)
|
||||
{
|
||||
int notenHaeufigkeit[6] = {0};
|
||||
|
||||
for (int i = 0; i < anzahl; ++i)
|
||||
{
|
||||
notenHaeufigkeit[n[i].note - 1]++;
|
||||
}
|
||||
|
||||
printf("\nNotenspiegel:\n");
|
||||
for (int i = 0; i < 6; ++i)
|
||||
{
|
||||
printf("Note %d: ", i + 1);
|
||||
for (int j = 0; j < notenHaeufigkeit[i]; ++j)
|
||||
{
|
||||
printf("*");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
void printListe(Person *liste, int anzahl)
|
||||
{
|
||||
printf("Name \t\t ,Vorname \t\t ,Note ");
|
||||
printf("\n------------------------------------------------------------------------\n");
|
||||
for (int i = 0; i < anzahl; ++i)
|
||||
{
|
||||
if (strlen(liste[i].name) > 0)
|
||||
{
|
||||
printf("%s \t\t ,%s \t\t ,%u\n", liste[i].name, liste[i].vorname, liste[i].note);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
Person schueler[ANZ_SCHUELER];
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ANZ_SCHUELER; ++i)
|
||||
{
|
||||
if (!eingabe(&schueler[i], i + 1))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printListe(schueler, i);
|
||||
printf("Durchschnittsnote = %2.f ", durchschnittsnote(schueler, i));
|
||||
notenspiegel(schueler,i);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
#include <stdio.h>
|
||||
|
||||
struct zeit // Struktur "zeit", die aus vier ganzen Zahlen (int) besteht --> Container, in dem wir verschiedene Daten zusammenfassen können
|
||||
{
|
||||
int tag; // Anzahl Tage
|
||||
int std; // Anzahl Stunden
|
||||
int min; // Anzahl Minuten
|
||||
int sek; // Anzahl Sekunden
|
||||
};
|
||||
|
||||
unsigned long zeit_in_sek (struct zeit z) //Zeit-Struktur; unsigned long weil Zahl groß sein kann; Gesamtzeit in sek
|
||||
{
|
||||
int gesamtSek = (z.tag*86400) + (z.std*3600) + (z.min*60) + (z.sek); // Umrechnungen in sek. --> z. greift auf Zeit-Struktur
|
||||
return gesamtSek;
|
||||
}
|
||||
|
||||
struct zeit sek_in_zeit (unsigned long sek) // Ausgabe: Zeit-Struktur, die sek. in Tage, Stunden, Minuten angibt
|
||||
{
|
||||
struct zeit umrechnung;
|
||||
umrechnung.tag = sek / 86400; // Tage berechnen
|
||||
sek %= 86400; // Rest berechnen und übrig lassen für weitere Berechnung
|
||||
umrechnung.std = sek / 3600; // Stunden berechnen
|
||||
sek %= 3600; // Rest berechnen und übrig lassen für weitere Berechnung
|
||||
umrechnung.min = sek / 60; // Minuten berechnen
|
||||
umrechnung.sek = sek % 60; // Rest der übrig gebliebenen Sekunden
|
||||
return umrechnung;
|
||||
}
|
||||
|
||||
int ueberpruefe (struct zeit eingabe) // Überprüft die Eingabe, ob alle Eintragungen im erlaubten Bereich sind
|
||||
{
|
||||
// Erlaubte Stunden 0-23; Erlaubte Minuten 0-59; Erlaubte Sekunden 0-59 --> Alles darüber ist ungültig
|
||||
if (eingabe.std < 0 || eingabe.std >= 24 || eingabe.min < 0 || eingabe.min >= 60 || eingabe.sek < 0 || eingabe.sek >= 60)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else return 1;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
struct zeit zeit1; // Eingabezeit 1
|
||||
struct zeit zeit2; // Eingabezeit 2
|
||||
struct zeit zeitAdd; // Ergebnis der Addition
|
||||
printf("Gib 1. Zeit ein: (tt.hh.mm.ss): ");
|
||||
|
||||
if (scanf("%d.%d.%d.%d", &zeit1.tag, &zeit1.std, &zeit1.min, &zeit1.sek)!=4) //4 Angaben getrennt durch Punkt --> !=4 prüft ob genau 4 Zahlen eingegeben wurden
|
||||
{
|
||||
return 0; //Programm beendet
|
||||
}
|
||||
|
||||
if (ueberpruefe(zeit1)==0) //Prüft ob die Eingaben im gültigen Bereich liegen
|
||||
{
|
||||
return 0; //Programm beendet
|
||||
}
|
||||
|
||||
printf("Gib 2. Zeit ein: (tt.hh.mm.ss): "); //Selber Ablauf für 2 Eingabe
|
||||
|
||||
if (scanf("%d.%d.%d.%d", &zeit2.tag, &zeit2.std, &zeit2.min, &zeit2.sek)!=4)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ueberpruefe(zeit2)==0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int gesamtSec1 = zeit_in_sek(zeit1); //Rechnet 1. Eingabe in Sekunden um
|
||||
int gesamtSec2 = zeit_in_sek(zeit2); //Rechnet 2. Eingabe in Sekunden um
|
||||
int gesamtSec = gesamtSec1+gesamtSec2; //Addiert beide Sekundenzahlen
|
||||
zeitAdd = sek_in_zeit(gesamtSec); //Wandelt Sekunden in Zeit-Struktur --> Ausgabe in Tage, Stunden, Minuten, Sekunden, Gesamtsekunden
|
||||
|
||||
printf("\n...... = %d Tage,%d: %d.%d; %d Gesamtsekunden", zeitAdd.tag, zeitAdd.std, zeitAdd.min, zeitAdd.sek, gesamtSec);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct Eintrag
|
||||
{
|
||||
char name[25];
|
||||
char tel[15];
|
||||
struct Eintrag *naechster_Name;
|
||||
struct Eintrag *naechste_Tel;
|
||||
struct Eintrag *vorheriger_Name;
|
||||
struct Eintrag *vorheriger_Tel;
|
||||
} Eintrag;
|
||||
|
||||
|
||||
void einfuegen(Eintrag **Anfang_Name, Eintrag **Anfang_Tel, char name[], char tel[])
|
||||
{
|
||||
Eintrag *neuerEintrag = (Eintrag *)malloc(sizeof(Eintrag));
|
||||
strcpy(neuerEintrag->name, name);
|
||||
strcpy(neuerEintrag->tel, tel);
|
||||
neuerEintrag->naechster_Name = NULL;
|
||||
neuerEintrag->naechste_Tel = NULL;
|
||||
|
||||
Eintrag *aktuellerEintrag_Name = *Anfang_Name;
|
||||
Eintrag *vorherigerEintrag_Name = NULL;
|
||||
|
||||
while (aktuellerEintrag_Name != NULL && strcmp(aktuellerEintrag_Name->name, neuerEintrag->name) < 0)
|
||||
{
|
||||
vorherigerEintrag_Name = aktuellerEintrag_Name;
|
||||
aktuellerEintrag_Name = aktuellerEintrag_Name->naechster_Name;
|
||||
}
|
||||
if (vorherigerEintrag_Name == NULL)
|
||||
{
|
||||
neuerEintrag->naechster_Name = *Anfang_Name;
|
||||
*Anfang_Name = neuerEintrag;
|
||||
}
|
||||
else
|
||||
{
|
||||
neuerEintrag->naechster_Name = aktuellerEintrag_Name;
|
||||
vorherigerEintrag_Name->naechster_Name = neuerEintrag;
|
||||
}
|
||||
if (neuerEintrag->naechster_Name != NULL)
|
||||
{
|
||||
neuerEintrag->naechster_Name->vorheriger_Name = neuerEintrag;
|
||||
}
|
||||
Eintrag *aktuellerEintrag_tel = *Anfang_Tel;
|
||||
Eintrag *vorherigerEintrag_tel = NULL;
|
||||
|
||||
while (aktuellerEintrag_tel != NULL && strcmp(aktuellerEintrag_tel->tel, neuerEintrag->tel) < 0)
|
||||
{
|
||||
vorherigerEintrag_tel = aktuellerEintrag_tel;
|
||||
aktuellerEintrag_tel = aktuellerEintrag_tel->naechste_Tel;
|
||||
}
|
||||
if (vorherigerEintrag_tel == NULL)
|
||||
{
|
||||
neuerEintrag->naechste_Tel = *Anfang_Tel;
|
||||
*Anfang_Tel = neuerEintrag;
|
||||
}
|
||||
else
|
||||
{
|
||||
neuerEintrag->naechste_Tel = aktuellerEintrag_tel;
|
||||
vorherigerEintrag_tel->naechste_Tel = neuerEintrag;
|
||||
}
|
||||
|
||||
if (neuerEintrag->naechste_Tel != NULL)
|
||||
{
|
||||
neuerEintrag->naechste_Tel->vorheriger_Tel = neuerEintrag;
|
||||
}
|
||||
}
|
||||
|
||||
void ausgebenNachName(Eintrag *Anfang_Name)
|
||||
{
|
||||
printf("....Liste nach Namen sortiert..........\n");
|
||||
while (Anfang_Name != NULL)
|
||||
{
|
||||
printf("%s \t (Tel. %s)\n", Anfang_Name->name, Anfang_Name->tel);
|
||||
Anfang_Name = Anfang_Name->naechster_Name;
|
||||
}
|
||||
}
|
||||
|
||||
void ausgebenNachTel(Eintrag *Anfang_Tel)
|
||||
{
|
||||
printf("....Liste nach Telefonnummern sortiert..........\n");
|
||||
|
||||
while (Anfang_Tel != NULL)
|
||||
{
|
||||
printf("(Tel. %s) \t %s\n", Anfang_Tel->tel, Anfang_Tel->name);
|
||||
Anfang_Tel = Anfang_Tel->naechste_Tel;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void speicherfreigeben(Eintrag *Anfang_Name)
|
||||
{
|
||||
Eintrag *aktuellerEintrag = Anfang_Name;
|
||||
Eintrag *naechsterEintrag;
|
||||
|
||||
while (aktuellerEintrag != NULL)
|
||||
{
|
||||
naechsterEintrag = aktuellerEintrag->naechster_Name;
|
||||
free(aktuellerEintrag);
|
||||
aktuellerEintrag = naechsterEintrag;
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
struct Eintrag *head_name = NULL;
|
||||
struct Eintrag *head_telefon = NULL;
|
||||
|
||||
char name[50];
|
||||
char telefonnummer[15];
|
||||
char eingabe;
|
||||
|
||||
do
|
||||
{
|
||||
printf("Namens- und Telefonliste\n");
|
||||
printf("========================\n");
|
||||
printf("N Einfügen neuer Namen mit Telefonnummer\n");
|
||||
printf("A Ausgeben der Liste\n");
|
||||
printf("E Ende Deine Wahl: ");
|
||||
if (scanf(" %c", &eingabe) != 1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
getchar();
|
||||
|
||||
if (eingabe == 'N' || eingabe == 'n')
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
printf("Name: ");
|
||||
fgets(name, sizeof(name), stdin);
|
||||
if (name[0] == '\n')
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (name[strlen(name) - 1] == '\n')
|
||||
{
|
||||
name[strlen(name) - 1] = '\0';
|
||||
}
|
||||
printf("Tel: ");
|
||||
fgets(telefonnummer, sizeof(telefonnummer), stdin);
|
||||
if (telefonnummer[strlen(telefonnummer) - 1] == '\n')
|
||||
{
|
||||
telefonnummer[strlen(telefonnummer) - 1] = '\0';
|
||||
}
|
||||
einfuegen(&head_name, &head_telefon, name, telefonnummer);
|
||||
}
|
||||
}
|
||||
|
||||
if (eingabe == 'A' || eingabe == 'a')
|
||||
{
|
||||
ausgebenNachName(head_name);
|
||||
ausgebenNachTel(head_telefon);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
} while (eingabe != 'E' && eingabe != 'e');
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define LEN 100
|
||||
|
||||
typedef struct listElement {
|
||||
char name[LEN];
|
||||
struct listElement *next;
|
||||
} listElement;
|
||||
|
||||
typedef struct {
|
||||
listElement *head;
|
||||
} liste;
|
||||
|
||||
listElement *eingabeName() {
|
||||
listElement *name = malloc(sizeof(listElement));
|
||||
if (name == NULL) {
|
||||
printf("Speicher konnte nicht zugewiesen werden.\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("Name: ");
|
||||
fgets(name->name, LEN, stdin);
|
||||
name->next = NULL;
|
||||
|
||||
if (strcmp(name->name, "\n") == 0) {
|
||||
free(name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (name->name[strlen(name->name) - 1] == '\n') {
|
||||
name->name[strlen(name->name) - 1] = '\0';
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
void einfuegenName(listElement *newElement, liste *liste1, liste *liste2) {
|
||||
int index;
|
||||
printf("\tWelche Liste (1 oder 2): ");
|
||||
if (scanf("%d", &index) != 1 || index < 1 || index > 2) {
|
||||
printf("Falsche Eingabe.\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
getchar();
|
||||
|
||||
listElement **targetList = (index == 1) ? &liste1->head : &liste2->head;
|
||||
|
||||
listElement *temp = *targetList;
|
||||
if (temp == NULL) {
|
||||
*targetList = newElement;
|
||||
} else {
|
||||
while (temp->next != NULL) {
|
||||
temp = temp->next;
|
||||
}
|
||||
temp->next = newElement;
|
||||
}
|
||||
}
|
||||
|
||||
void sortiereListe(liste *lst) {
|
||||
if (!lst->head) return;
|
||||
listElement *current, *index;
|
||||
char temp[LEN];
|
||||
|
||||
for (current = lst->head; current->next != NULL; current = current->next) {
|
||||
for (index = current->next; index != NULL; index = index->next) {
|
||||
if (strcmp(current->name, index->name) > 0) {
|
||||
strcpy(temp, current->name);
|
||||
strcpy(current->name, index->name);
|
||||
strcpy(index->name, temp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void mergeLists(liste *liste1, liste *liste2, liste *mergedList) {
|
||||
listElement *temp;
|
||||
|
||||
for (temp = liste1->head; temp != NULL; temp = temp->next) {
|
||||
listElement *newElement = malloc(sizeof(listElement));
|
||||
strcpy(newElement->name, temp->name);
|
||||
newElement->next = mergedList->head;
|
||||
mergedList->head = newElement;
|
||||
}
|
||||
|
||||
for (temp = liste2->head; temp != NULL; temp = temp->next) {
|
||||
listElement *newElement = malloc(sizeof(listElement));
|
||||
strcpy(newElement->name, temp->name);
|
||||
newElement->next = mergedList->head;
|
||||
mergedList->head = newElement;
|
||||
}
|
||||
}
|
||||
|
||||
void printliste(liste *lst) {
|
||||
listElement *temp = lst->head;
|
||||
while (temp != NULL) {
|
||||
printf("%s\n", temp->name);
|
||||
temp = temp->next;
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
liste liste1 = {NULL};
|
||||
liste liste2 = {NULL};
|
||||
liste gemischteListe = {NULL};
|
||||
|
||||
listElement *name;
|
||||
while ((name = eingabeName()) != NULL) {
|
||||
einfuegenName(name, &liste1, &liste2);
|
||||
}
|
||||
|
||||
sortiereListe(&liste1);
|
||||
sortiereListe(&liste2);
|
||||
|
||||
mergeLists(&liste1, &liste2, &gemischteListe);
|
||||
sortiereListe(&gemischteListe);
|
||||
|
||||
printf("\n......1. Liste......\n");
|
||||
printliste(&liste1);
|
||||
printf("....Listenende....\n");
|
||||
|
||||
printf("\n......2. Liste......\n");
|
||||
printliste(&liste2);
|
||||
printf("....Listenende....\n");
|
||||
|
||||
printf("\n....Gemischte Liste....\n");
|
||||
printliste(&gemischteListe);
|
||||
printf("....Listenende....\n");
|
||||
|
||||
return 0;
|
||||
}}
|
||||
@@ -0,0 +1,73 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
// Aufzählung der Säuren
|
||||
typedef enum
|
||||
{
|
||||
Salzsaure,
|
||||
Schwefelsaure,
|
||||
Salpetersaure,
|
||||
Kohlensaure
|
||||
} Saeure;
|
||||
|
||||
// Aufzählung der Laugen
|
||||
typedef enum
|
||||
{
|
||||
Natronlauge,
|
||||
Kalilauge,
|
||||
Kalkwasser
|
||||
} Lauge;
|
||||
|
||||
// Namen der Säuren für die Ausgabe
|
||||
char *Saeuren[] = {"Salzsäure", "Schwefelsäure", "Salpetersäure", "Kohlensäure"};
|
||||
|
||||
// Namen der Laugen für die Ausgabe
|
||||
char *Laugen[] = {"Natronlauge", "Kalilauge", "Kalkwasser"};
|
||||
|
||||
// Ergebnisse der Reaktionen (Laugen x Säuren = 3 x 4 = 12 Einträge)
|
||||
char *Ausgabe[] = {
|
||||
" Natriumchlorid", " Natriumsulfat", " Natriumnitrat", " Natriumcarbonat",
|
||||
" Kaliumchlorid", " Kaliumsulfat", " Kaliumnitrat", " Kaliumcarbonat",
|
||||
" Calciumchlorid", " Calciumsulfat", " Calciumnitrat", " Calciumcarbonat"
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
Saeure b;
|
||||
Lauge a;
|
||||
|
||||
// Tabellenkopf: Säuren als Spaltenüberschriften
|
||||
printf("\t \t");
|
||||
printf("|| ");
|
||||
|
||||
for (b = Salzsaure; b < Kohlensaure; b++)
|
||||
{
|
||||
printf(" %s", Saeuren[b]); // Säurename ausgeben
|
||||
printf("\t");
|
||||
printf("|");
|
||||
}
|
||||
printf(" %s |", Saeuren[3]); // Letzte Säure extra ausgeben (weil Schleife nur bis <)
|
||||
printf("\n");
|
||||
|
||||
// Trennlinie unter dem Kopf
|
||||
printf("---------------------------------------------------------------------------------|");
|
||||
|
||||
// Für jede Lauge (Zeilen)
|
||||
for (a = Natronlauge; a <= Kalkwasser; ++a)
|
||||
{
|
||||
printf("\n");
|
||||
printf("%s\t||", Laugen[a]); // Laugenname links am Rand
|
||||
|
||||
// Für jede Säure (Spalten)
|
||||
for (b = Salzsaure; b <= Kohlensaure; ++b)
|
||||
{
|
||||
// Index berechnen: (Lauge * 4) + Säure
|
||||
// 4 Säuren pro Lauge = 4 Spalten pro Zeile
|
||||
printf(Ausgabe[b + a * 4]); // Reaktionsprodukt ausgeben
|
||||
printf("| ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define MAXLEN 50
|
||||
|
||||
|
||||
void getstring(char *ptr)
|
||||
{
|
||||
fgets(ptr, MAXLEN, stdin); // Liest bis zu MAXLEN Zeichen aus der Standardeingabe
|
||||
ptr[strcspn(ptr, "\n")] = '\0'; // Ersetzt das '\n' Zeichen durch '\0' (String-Ende)
|
||||
fflush(stdin); // Leert den Eingabepuffer
|
||||
}
|
||||
|
||||
// Funktion zur Eingabe der Adressdaten
|
||||
// Gibt die Anzahl der gewünschten Wiederholungen zurück oder 0 bei fehlerhafter Eingabe
|
||||
int eingabe(char *vorname, char *nachname, char *strasse, char *wohnort, char *hausnr, int *postleitzahl, char *telefon, char *fax)
|
||||
{
|
||||
printf("Vorname\t\t:");
|
||||
getstring(vorname);
|
||||
|
||||
printf("Nachname\t:");
|
||||
getstring(nachname);
|
||||
|
||||
printf("Strasse\t\t:");
|
||||
getstring(strasse);
|
||||
|
||||
printf("Hausnummer\t:");
|
||||
getstring(hausnr);
|
||||
|
||||
printf("Postleitzahl\t:");
|
||||
// Überprüft die Eingabe auf einen gültigen Integer
|
||||
if(scanf("%d", postleitzahl) != 1)
|
||||
{
|
||||
return 0; // Fehler bei der Eingabe
|
||||
}
|
||||
|
||||
fflush(stdin); // Eingabepuffer leeren
|
||||
|
||||
printf("Wohnort\t\t:");
|
||||
getstring(wohnort);
|
||||
|
||||
printf("Telefon\t\t:");
|
||||
getstring(telefon);
|
||||
|
||||
printf("Fax\t\t:");
|
||||
getstring(fax);
|
||||
|
||||
printf("Wie oft soll die Adresse in die Datei geschrieben werden?\t:");
|
||||
int anzahl;
|
||||
// Überprüft die Eingabe auf einen gültigen Integer
|
||||
if(scanf("%d", &anzahl) != 1)
|
||||
{
|
||||
return 0; // Fehler bei der Eingabe
|
||||
}
|
||||
|
||||
return anzahl; // Gibt die Anzahl der Wiederholungen zurück
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// Öffnet die Datei "datei.txt" im Anhangmodus ("a")
|
||||
FILE *ziel;
|
||||
ziel = fopen("datei.txt", "a");
|
||||
|
||||
// Überprüft, ob die Datei erfolgreich geöffnet wurde
|
||||
if (ziel == NULL)
|
||||
{
|
||||
printf("Fehler beim Öffnen der Datei\n");
|
||||
return 1; // Fehlercode 1: Datei konnte nicht geöffnet werden
|
||||
}
|
||||
|
||||
// Definition der Variablen für die Adressdaten
|
||||
char vorname[MAXLEN], nachname[MAXLEN], strasse[MAXLEN], wohnort[MAXLEN], hausnr[MAXLEN], telefon[MAXLEN], fax[MAXLEN];
|
||||
int postleitzahl, anzahl;
|
||||
|
||||
// Ruft die Eingabefunktion auf und prüft, ob die Eingabe erfolgreich war
|
||||
if((anzahl = eingabe(vorname, nachname, strasse, wohnort, hausnr, &postleitzahl, telefon, fax)) == 0)
|
||||
{
|
||||
return 0; // Fehlerhafte Eingabe, Programm wird beendet
|
||||
}
|
||||
|
||||
// Schreibt einen Trenner in die Datei
|
||||
fprintf(ziel, "-----------------------------------------------------\n");
|
||||
|
||||
// Schleife zum mehrfachen Schreiben der Daten in die Datei
|
||||
for (int i = 0; i < anzahl; i++)
|
||||
{
|
||||
fprintf(ziel, "%s %s\n", vorname, nachname); // Vorname und Nachname
|
||||
fprintf(ziel, "%s %s\n", strasse, hausnr); // Straße und Hausnummer
|
||||
fprintf(ziel, "%d %s\n\n", postleitzahl, wohnort); // Postleitzahl und Wohnort
|
||||
fprintf(ziel, "Tel. %s\n", telefon); // Telefonnummer
|
||||
fprintf(ziel, "Fax %s\n", fax); // Faxnummer
|
||||
fprintf(ziel, "-----------------------------------------------------\n");
|
||||
}
|
||||
|
||||
fclose(ziel); // Schließt die Datei
|
||||
return 0; // Programmende
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* Realisiert das Josephus Spiel zum Test einer Queue
|
||||
*
|
||||
* Datum: Autor:
|
||||
* 30.9.2015 Prof. Dr. Helmut Herold
|
||||
*
|
||||
\**********************************************************************/
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#define _CRT_SECURE_NO_WARNINGS //VC++: keine scanf() Warnungen
|
||||
#include <stdio.h> // Einbinden der Standard-Ein-/Ausgabefunktionen
|
||||
#include "queue.h" // Einbinden der selbstgeschriebenen Queue-Funktionen
|
||||
|
||||
/*--- #defines -------------------------------------------------------*/
|
||||
|
||||
/*--- Datentypen (typedef) -------------------------------------------*/
|
||||
|
||||
/*--- Prototypen lokaler Funktionen ----------------------------------*/
|
||||
|
||||
/*--- main -----------------------------------------------------------*/
|
||||
int main(void)
|
||||
{
|
||||
int n, z, i=1, nr; // n = Personenanzahl, z = wievielte wird entfernt, i = Laufvariable, nr = zum Prüfen von scanf
|
||||
|
||||
// Abfrage wie viele Personen mitspielen, solange wiederholen bis richtige Zahl eingegeben wurde
|
||||
do {
|
||||
printf("Wie viele Personen: "); // Frage ausgeben
|
||||
nr = scanf("%d", &n); getchar(); // Zahl einlesen und Eingabe bestätigen lassen
|
||||
} while (nr != 1 || n < 0); // solange wiederholen bis gültige Zahl
|
||||
|
||||
// Abfrage wievielte Person entfernt wird, auch hier wird auf korrekte Eingabe geprüft
|
||||
do {
|
||||
printf("Wie vielte ist auszusondern: "); // Frage ausgeben
|
||||
nr = scanf("%d", &z); getchar(); // Zahl einlesen und Eingabe bestätigen lassen
|
||||
} while (nr != 1 || z < 0); // solange wiederholen bis gültige Zahl
|
||||
|
||||
// Die Queue wird mit Zahlen von 1 bis n gefüllt
|
||||
for (i = 1; i <= n; i++) // von 1 bis n
|
||||
put(i); // füge die Zahl in die Queue ein
|
||||
|
||||
// Solange die Queue nicht leer ist (also noch Personen da sind)
|
||||
while (!isEmpty()) {
|
||||
// Wiederhole z-1 mal: hole die vorderste Zahl aus der Queue und füge sie hinten wieder ein
|
||||
for (i = 1; i < z; i++) {
|
||||
if (put(get()) == FALSE) { // Zahl nach hinten verschieben, wenn das schief geht:
|
||||
fprintf(stderr, "Fehler beim Einfügen\n"); // Fehlermeldung
|
||||
return 1; // Programm abbrechen mit Fehler
|
||||
}
|
||||
}
|
||||
// Jetzt hole die vorderste Zahl (die z-te) und gib sie aus (sie wird entfernt)
|
||||
printf("%d, ", get()); // Zahl ausgeben und aus Queue entfernen (nicht mehr einfügen)
|
||||
}
|
||||
printf("\n"); // Zeilenumbruch am Ende
|
||||
|
||||
return 0; // Programm endet erfolgreich
|
||||
}
|
||||
Executable
BIN
Binary file not shown.
Binary file not shown.
Binary file not shown.
+122
@@ -0,0 +1,122 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* queue.c - realisiert eine Queue (Warteschlange)
|
||||
*
|
||||
* Datum: Autor:
|
||||
*
|
||||
*
|
||||
\**********************************************************************/
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#include <stdio.h> // Standard Ein-/Ausgabe
|
||||
#include <stdlib.h> // Für malloc und free
|
||||
#include "queue.h" // Für die Typen und Funktionsdeklarationen
|
||||
|
||||
/*--- Modulglobale static Variablen ----------------------------------*/
|
||||
// Das sind Zeiger auf das erste und letzte Element der Queue.
|
||||
// Sie sind nur hier sichtbar (static = nur in dieser Datei).
|
||||
static Queue_Elem *Anfang_Element = NULL; // Zeigt auf das erste Element in der Queue
|
||||
static Queue_Elem *Ende_Element = NULL; // Zeigt auf das letzte Element in der Queue
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Einfuegen in Liste
|
||||
* Parameter:
|
||||
* zahl fügt die übergebene Zahl 'zahl' am Ende der Liste ein
|
||||
* Return Wert:
|
||||
* TRUE wenn noch genug Speicherplatz vorhanden
|
||||
* FALSE wenn kein Speicherplatz mehr allokiert werden konnte
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool put(int zahl)
|
||||
{
|
||||
// Speicherplatz für ein neues Element anfordern
|
||||
Queue_Elem* neues_Element = (Queue_Elem*)malloc(sizeof(Queue_Elem));
|
||||
|
||||
// Prüfen, ob der Speicher angelegt werden konnte
|
||||
if (neues_Element == NULL)
|
||||
{
|
||||
return FALSE; // Fehler, kein Speicher mehr
|
||||
}
|
||||
else
|
||||
{
|
||||
neues_Element->wert = zahl; // Wert setzen
|
||||
neues_Element->Element_next = NULL; // Nächstes Element gibt es noch nicht
|
||||
neues_Element->Element_prev = NULL; // Vorheriges Element gibt es noch nicht
|
||||
|
||||
// Wenn Queue noch leer ist (erstes Element)
|
||||
if (Anfang_Element == NULL)
|
||||
{
|
||||
Anfang_Element = neues_Element; // Sowohl Anfang als auch Ende zeigen auf das neue Element
|
||||
Ende_Element = neues_Element;
|
||||
}
|
||||
else // Sonst: Am Ende anhängen
|
||||
{
|
||||
if (Ende_Element != NULL)
|
||||
{
|
||||
Ende_Element->Element_next = neues_Element; // Das aktuelle Ende zeigt auf das neue Element
|
||||
neues_Element->Element_prev = Ende_Element; // Das neue Element weiß, was vorher war
|
||||
Ende_Element = neues_Element; // Das neue Element ist jetzt das Ende
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE; // Hat geklappt!
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Auslesen aus Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
|
||||
*--------------------------------------------------------------------*/
|
||||
int get(void)
|
||||
{
|
||||
int zahl;
|
||||
// Zeiger auf das erste Element (wird gleich gelöscht)
|
||||
Queue_Elem* temp = Anfang_Element;
|
||||
|
||||
// Wenn mindestens ein Element in der Queue ist
|
||||
if(Anfang_Element != NULL && Ende_Element != NULL)
|
||||
{
|
||||
zahl = (Anfang_Element)->wert; // Wert des ersten Elements speichern
|
||||
|
||||
// Wenn es noch mehr als ein Element gibt
|
||||
if(Anfang_Element->Element_next != NULL)
|
||||
{
|
||||
Anfang_Element->Element_next->Element_prev = NULL; // Das neue Erste zeigt auf nix vorher
|
||||
Anfang_Element = Anfang_Element->Element_next; // Anfang_Element zeigt jetzt auf das neue Erste
|
||||
}
|
||||
else // Es gibt nur ein Element (das wird jetzt gelöscht)
|
||||
{
|
||||
Anfang_Element = NULL;
|
||||
Ende_Element = NULL;
|
||||
}
|
||||
|
||||
free(temp); // Speicherplatz freigeben
|
||||
}
|
||||
else // Die Queue ist leer
|
||||
{
|
||||
zahl = QLEER; // Rückgabewert für "leer"
|
||||
}
|
||||
|
||||
return zahl; // Zahl oder QLEER zurückgeben
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Pruefen der Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* liefert TRUE, wenn Queue leer ist, sonst FALSE
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool isEmpty(void)
|
||||
{
|
||||
// Ist Anfang und Ende auf NULL -> Queue ist leer
|
||||
if(Anfang_Element == NULL && Ende_Element == NULL)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* queue.h - realisiert eine Queue (Warteschlange) als verkettete Liste
|
||||
*
|
||||
* Datum: Autor:
|
||||
* 30.9.2015 Prof. Dr. Helmut Herold
|
||||
*
|
||||
\**********************************************************************/
|
||||
#ifndef QUEUE_H
|
||||
#define QUEUE_H
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#include <limits.h> // Für INT_MIN
|
||||
|
||||
/*--- #defines -------------------------------------------------------*/
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define QLEER INT_MIN // Konstante, um "Queue ist leer" zu kennzeichnen
|
||||
|
||||
/*--- Datentypen (typedef) -------------------------------------------*/
|
||||
typedef int Bool; // Bool ist einfach nur ein int
|
||||
|
||||
// Struktur für ein Queue-Element
|
||||
typedef struct Queue_Element {
|
||||
int wert; // Der gespeicherte Wert (die Zahl)
|
||||
struct Queue_Element* Element_next; // Zeiger auf das nächste Element
|
||||
struct Queue_Element* Element_prev; // Zeiger auf das vorherige Element
|
||||
} Queue_Elem;
|
||||
|
||||
/*--- Prototypen globaler Funktionen ---------------------------------*/
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Einfuegen in Liste
|
||||
* Parameter:
|
||||
* zahl fügt die übergebene Zahl 'zahl' am Ende der Liste ein
|
||||
* Return Wert:
|
||||
* TRUE wenn noch genug Speicherplatz vorhanden
|
||||
* FALSE wenn kein Speicherplatz mehr allokiert werden konnte
|
||||
* Hinweis:
|
||||
* - dynamische Verwaltung von Speicher muss mit malloc() und free()
|
||||
* durchgeführt werden; dynamische Arrays sind nicht erlaubt !!!
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool put(int zahl);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Auslesen aus Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
|
||||
*--------------------------------------------------------------------*/
|
||||
int get(void);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Pruefen der Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* liefert TRUE, wenn Queue leer ist, sonst FALSE
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool isEmpty(void);
|
||||
|
||||
#endif /*QUEUE_H*/
|
||||
BIN
Binary file not shown.
Reference in new issue
Block a user