2 changed files with 0 additions and 193 deletions
--- a/28.2.2.c
+++ b/28.2.2.c
@ -1,117 +0,0 @@
 #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;
 }
--- a/28.5.2.c
+++ b/28.5.2.c
@ -1,76 +0,0 @@
 #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;
 }