Hausaufgabe 1:

Schreiben Sie ein Programm, das Ihr Geburtsdatum (tt.mm.jjjj)
einliest und dann Ihr Lebensalter in Tagen berechnet und anzeigt.
Verzichten Sie auf Schaltjahre.

////////////////////////////////////

#include <stdio.h> // Bibliothek

 void main( ) {

    char vorname[20];
    char nachname[20];
    int tag, monat, jahr;

    printf("Bitte geben Sie Ihren Vor- und Namen ein: ");
    scanf("%s %s", vorname, nachname);

    // bei elementaren Datentypen (int, double, char)
    // ist der Adressoperator zwingend!
    // Aber: Zeichenketten gehören NICHT
    // zu den elementaren Datentypen
    // Deshalb: KEIN & vor Strings / Vektoren

    printf("Bitte geben Sie ihr Geburtsdatum ein: tt.mm.jjjj ");
    scanf("%i.%i.%i", &tag, &monat, &jahr);
    printf("Ihr Name lautet %s, %s \n",nachname, vorname);
    printf("Ihr Geburtstag ist %i.%i.%i", tag, monat, jahr);

    // Hier folgt Ihre BERECHNUNG !!!

    getchar();
    getchar();
}


Ergaenzung zur Hausaufgabe 1: 

Formulieren Sie die Berechnung innerhalb einer Funktion,
der die Geburtsdaten uebergeben werden (int tag, int monat, int jahr).

----------------------------------------------------------------------------------------------

Hausaufgabe 2:

Schreiben Sie ein C-Programm, das einen globalen int-Vektor
mit Hilfe des BUBBLE-SORT-Algorithmus' sortiert.

Implementieren Sie die FUNKTION void sortieren( int ),
die einen Parameter übernimmt, der die gewünschte Sortierreihenfolge
bestimmt (aufsteigend bzw. absteigend).

///////////////////////////
// INT-Vektor sortieren
// (einfaches Sortier-Verfahren: BUBBLE-SORT)
// n-1 Durchläufe

#include <stdio.h>
# define MAX 10

int vektor[MAX];      // INT-Vektor anlegen

void main() {

    int i=0, j=0, k=0;
    int temp=0;      // Temporäre Variable für den Tauschvorgang

    printf("Vektor unsortiert einlesen:\n");

    for(i = 0; i < MAX; i++) {
        printf("%i: ",i+1);
        scanf("%i", &vektor[i]);
    }

    ///////////////////////// SORTIEREN //////////////////////
    // Dieser Code kommt in die FUNKTION hinein

    printf("\n\nVektor sortieren: \n");

    while( k++ < MAX ) {

        i=0;              // wieder beim ersten Element anfangen

        while(i++ < MAX-1) {   // Alle Elemente des Vektors nacheinander durchlaufen

            if(vektor[i-1] > vektor[i]) { // Zwei aufeinanderfolgende
                                          // Elemente vergleichen:
                                          // Falls Vorgänger kleiner ist:

                temp = vektor[i-1];       // Tauschen
                vektor[i-1] = vektor[i];
                vektor[i]=temp;
             }
         }
         for(j=0; j < MAX; j++)            // Diesen Durchlauf ausgeben
            printf("%i ",vektor[j]);
         printf("\n\n");
     }

     //////////// Endgültig sortierten Vektor ausgeben //////////////////////////////

     for(i=0; i < MAX; i++) {
        printf(" %i ",vektor[i]);
     }
     getchar();
     getchar();
}

--------------------------------------------------------------------------------------------------

Hausaufgabe 3:

Schreiben Sie das folgende Programm um:
Implementieren Sie die FUNKTION sortieren( int ),
die einen Parameter übernimmt, der die Sortierreihenfolge angibt
(aufsteigend bzw. absteigend).

//////////////////////////////
// Zeichenketten-Vektor sortieren
// mit BUBBLE-SORT

#include <stdio.h>
#include <string.h>

#define MAX 10

void main() {

    int i=0, j=0;

    char st[MAX][MAX]={"xyz","stu","stz","abc",
                       "erf","edf","qwe","qwa",
                       "aaaaaaab","aaab"};

    puts("String-Array unsortiert: ");

    for(i=0; i <MAX; i++)
            printf("Element %i, Inhalt %s\n",i,st[i]);

    while (j++ < MAX) {    // solange Vektor unsortiert

        for(i=1; i < MAX; i++) {

            //puts(st[i]);

            if (strcmp(st[i-1], st[i]) > 0 ) {

                  char temp[10]; // temporärer Tauschstring
                  strcpy(temp, st[i-1]);
                  strcpy(st[i-1], st[i]);
                  strcpy(st[i], temp);
            }
        }
    }
    puts("\nString-Array sortiert: ");

    for(i=0; i < MAX; i++)
            printf("Element %i, Inhalt %s\n",i,st[i]);

    getchar();
}

---------------------------------------------------------------------------------------

HAUSAUFGABE 4:


Schreiben Sie ein C-Programm, das eine Literaturverwaltung (Bibliothek)
definiert. Deklarieren Sie eine Struktur namens Bibliothek
und eine Reihe von Komponenten, die den Standort eines Buches angeben :

Titel, Autor, Jahrgang, Zeitschrift,
Regal, ID, Schlagwort,

Schreiben Sie Funktionen zum Einlesen und Ausgeben
einer vorgegebenen Anzahl Bücher.
Benutzen Sie das folgende Programm als Vorgabe.

///////////////////////////////////////////

# include <stdio.h>

# define MAX 3          // Globale Konstante

typedef struct {        // Struktur-Deklaration

    int matrikel;
    char vorname [20];
    char nachname [20];
    double einkommen ;
} Student;

/////////////////////////////////////
// Globale Definition des Vektors:

Student vektor [MAX];  // Vektor von MAX Studenten anlegen

/////////////////////////////////////

void einlesen( void );       // Prototypen

void ausgeben( void );

//////////////////////////////////////////

void main() {

    einlesen( );

    ausgeben( );
}

///////////////////////////////////////////

void einlesen( ) {

     int i; // Laufvariable

     for (i = 0; i < MAX; i++ ) {
        puts("Bitte geben Sie den Vornamen ein:");
        gets(vektor[i].vorname);
        puts("Bitte geben Sie den Nachnamen ein:");
        gets(vektor[i].nachname);
        puts("Bitte geben Sie die Matrikelnr ein:");
        scanf("%i",&vektor[i].matrikel);
        puts("Bitte geben Sie das Einkommen ein:");
        scanf("%lf",&vektor[i].einkommen);
        fflush(stdin);
    }

}

//////////////////////////////////////////////

void ausgeben ( ) {

    int i; // Laufvariable

    for(i=0; i < MAX; i++) {
        printf("\nVorname:   %s "
               "\nNachname:  %s "
               "\nEinkommen: %.2lf"
               "\nMatrikel:  %i \n",
                         vektor[i].vorname,
                         vektor[i].nachname,
                         vektor[i].einkommen,
                         vektor[i].matrikel);
    }
    getchar();
    getchar();
}

---------------------------------------------------------------------------------------

HAUSAUFGABE 5:

Benutzen Sie Ihre Lösung von Hausaufgabe4 und ergänzen
Sie sie folgendermassen:

Der Strukturvektor wird nicht global, sondern innerhalb von main() angelegt.
Er wird dann beim Aufruf der Funktionen übergeben.

also:

///////////////////////////////////////////

# include <stdio.h>

# define MAX 3          // Globale Konstante

typedef struct {        // Struktur-Deklaration

    int matrikel;
    char vorname [20];
    char nachname [20];
    double einkommen ;
} Student;

/////////////////////////////////////

void einlesen( ???? );       // Prototypen

void ausgeben( ???? );

//////////////////////////////////////////

void main() {

    // Lokale Definition des Vektors:

    Student vektor [MAX];  // Vektor von MAX Studenten anlegen

    einlesen( ???? );

    ausgeben( ???? );
}

///////////////////////////////////////////


void einlesen( ???? ) {
    ???????????
    ???????????
    ???????????
}

void ausgeben ( ???? ) {
    ???????????
    ???????????
    ???????????
}


Zusatzfrage: Implementieren Sie einen Rückgabewert aus der Funktion
einlesen(), der die Anzahl aktuell eingelesener Datensätze angibt.


also:

int einlesen( ???? );

---------------------------------------------------------------------------------------

HAUSAUFGABE 6:

Benutzen Sie Ihre Lösung von Hausaufgabe 5 und ergänzen
Sie sie durch eine SUCHFUNKTION nach dem Nachnamen.
Der Rückgabewert enthält den Index des ersten Treffers.
Die Datensatz-Ausgabe erfolgt in main.

Vorgabe unten:  Suchfunktion nach int matrikelnr.
Bitte abändern: Suchfunktion -> char vorname []!

/////////////////////////////////////
// Lokaler struct-vektor (in main)
// mit Suchfunktion

# include <stdio.h>
# include <string.h>

#define MAX 50 // Maximale Anzahl der Elemente im struct-Vektor

// Deklaration des structs

typedef struct {
        int    matrikelnr;
        double einkommen;
        char   vorname [20];
        char   nachname[20];
} STUDENT ;

//////////////////////////////////
// Funktions-Prototypen

int eingabe ( STUDENT [ ] );

void ausgabe( STUDENT [ ] , int);

int suche   ( STUDENT [ ] , int, int); // Parameter: Vektorname, aktuelle Anzahl, matrikelnr

///////////////////////////////////

void main() {

    int akt;
    int mnr;
    int gef;

    STUDENT vektor[MAX]; // lokaler Vektor von structs

    akt = eingabe(vektor); // Übergabe der Anfangsadresse des Vektors

    puts("Welche Matrikelnummer suchen Sie:");

    scanf("%i",&mnr);

    gef = suche( vektor, mnr, akt);

    // Ausgabe des gefundenen Datensatzes:

    printf("Vorname:   %s\n",   vektor[ gef ].vorname);
    printf("Nachname:  %s\n",   vektor[ gef ].nachname);
    printf("Matrikel:  %i\n",   vektor[ gef ].matrikelnr);
    printf("Einkommen: %.2lf\n",vektor[ gef ].einkommen);

    //ausgabe(vektor, akt);

    getchar();
    getchar();
}

/////////////////////////////////

int eingabe(STUDENT st[]) { // Referenz auf struct-Vektor

  int i;

  for(i = 0; i < MAX; i++) {

    puts("Dateneingabe wird mit RETURN beendet");

    puts("Bitte Vornamen:");
    gets(st[i].vorname);

    if(strlen(st[i].vorname) == 0) break;

    puts("Bitte Nachnamen");
    gets(st[i].nachname);

    puts("Bitte MatrikelNummer:");
    scanf("%i", &st[i].matrikelnr);

    puts("Bitte Einkommen:");
    scanf("%lf", &st[i].einkommen);

    fflush(stdin);
  }

  return i;  // Anzahl oder Index ?
}

/////////////////////////////////////////

void ausgabe(STUDENT st[], int anzahl) {

  int i;

  for(i = 0; i < anzahl; i++) {

    puts("Datenausgabe:");

    puts(st[i].vorname );
    puts(st[i].nachname);
    printf("%i    \n", st[i].matrikelnr);
    printf("%.2lf \n", st[i].einkommen );

    //getchar();
  }
}

//////////////////////////////////
// Suchfunktion:

int suche( STUDENT t [] , int matr, int akt ) {

    int i;
    int ret = -1;

    for( i = 0; i< akt; i++) {

        if( t[i].matrikelnr == matr ) {
            ret = i;
            break;
        }
    }
    return ret;
}

---------------------------------------------------

HAUSAUFGABE 7:

Schreiben Sie Ihr Programm aus Aufgabe 6
folgendermassen um:

Erzeugen Sie in main einen dynamischen Vektor vom Typ Ihrer Struktur
(Speicherbereich auf dem Heap).
Anzahl Elemente (max) wird vom Nutzer eingegeben.
Übergeben Sie den Pointer an die Funktionen
einlesen( ... ), ausgeben ( ... ) und suchen ( ... ) und
implementieren Sie diese Funktionen.

ZUSATZAUFGABE: Weitere Funktion mit realloc:
Verdoppeln Sie die Grösse des dyn. Vektors,
auf das Doppelte (realloc), sobald er seine Grenze erreicht hat.

# include <stdio.h>
# include <string.h>
# include <stdlib.h>


typedef struct {
        int matrikelnr;
        double einkommen;
        char vorname [20];
        char nachname[20];
} STUDENT ;

// Prototypen

int einlesen  ( ????, int);
void ausgeben ( ????, int);
void suchen   ( ????, int);


//////////////////////////////////

void main( ) {

    int max, akt;

    STUDENT* st;

    puts("Wieviele Studenten:");
    scanf("%i",&max);

    if((st = malloc( max * sizeof(STUDENT)))== NULL) {
        printf("no Memory");
        return -1;
    }
    
    // Funktionsaufrufe:

    akt = einlesen( ????, ???? );

    ausgeben( ????,  akt );

    suchen  ( ????,  akt );
    
    getchar();
}

//////////////////////////////////

// Funktions-Implementierung:

int einlesen ( ????, ???? ) {
    ...
    ...
}

void ausgeben ( ????, ???? ) {
    ...
    ...
}

void suchen ( ????, ???? ) {
    ...
    ...
}