Compare commits
3
Commits
ced22cc6fc
...
master
| Author | SHA1 | Date | |
|---|---|---|---|
 chilabal90797
|
517c976643 | ||
|
chilabal90797
|
be0e538ff4 | ||
|
chilabal90797
|
ed92d64f65 |
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,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,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