Prozeduren − MainLab

Aufgabe 1: Quadrathamster − Ausprobieren und Speichern

Gegeben ist rechtsstehendes Territorium.

Der Hamster soll nun eine Runde drehen, und dabei an jedem Gangende (also in jeder Ecke) jeweils ein Korn aufsammeln. Zum Schluss sollen also alle Körner abgeräumt worden sein.

Das folgende Programm löst dies unter Verwendung der extra definierten Prozedur rechtsUm. Der Vorteil der Definition dieser Prozedur ist, dass wir nicht jedes Mal linksUm(); linksUm(); linksUm(); tippen müssen, sondern ein einziger Aufruf von rechtsUm(); genügt. Der Computer springt beim Aufruf dann zu der Prozedur rechtsUm, arbeitet diese ab, und springt anschließend wieder zurück an die Aufrufstelle, um in der nächsten Zeile weiterzuarbeiten.

void main()
{
    // 1. Gang
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
       // 2. Gang
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
    // 3. Gang
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
    // 4. Gang
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
    // Fertig!
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}

Aufgaben

Erstelle zunächst das Territorium.
Tippe das Programm ab.
Speichere es.
Kompiliere das Programm.
Führe das Programm aus.

Das Öffnen/Speichern von Dateien funktioniert wie folgt. Grundsätzlich werden alle Hamsterprogramme (.ham-Datei = der Quelltext) und Territorien (.ter-Datei = die Kachelwelt) links im Hauptordner angezeigt. Die Dateiendung .ham und .ter wird dabei ausgeblendet. Diese zwei Buttons sind wichtig:

Aktuelles Programm speichern
Aktuelles Programm und aktuelles Territorium speichern

Aufgabe 2: Hürdenläufer

Der Hamster hat den Hürdenlauf für sich entdeckt. Hilf ihm, die Hürden zu nehmen und abschließend das Korn zur Belohung einzusammeln. Definiere dazu eine Prozedur für wiederkehrende Abläufe.

Tipp 1

Definiere eine Prozedur nimmHuerde, welche den Hamster genau eine Hürde nehmen lässt. Diese Prozedur soll dann in der main-Prozedur mehrfach aufgerufen werden.

Tipp 2

Du solltest die folgenden Prozeduren definieren: main, nimmHuerde und (um dir Tipparbeit zu ersparen) rechtsUm. Die main-Prozedur ist im Folgenden bereits vorgegeben. Vervollständige die übrigen Prozeduren.

void main()
{
    // Erst 5 Huerden...
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    // ... dann die Belohnung!
    nimm();
}

void nimmHuerde()
{
    // TODO    
}

void rechtsUm()
{
    // TODO
}

Lösungsvorschlag

void main()
{
    // Erst 5 Huerden...
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    nimmHuerde();
    // ... dann die Belohnung!
    nimm();
}

void nimmHuerde()
{
    linksUm();
    vor();
    vor();
    vor();
    rechtsUm();
    vor();
    vor();
    rechtsUm();
    vor();
    vor();
    vor();
    linksUm();
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}

Aufgabe 3: Kletterhamster

Der Hamster hat das Klettern für sich entdeckt. Hilf ihm, den Berg zu erklimmen, alle Körner auf dem Gipfel einzusammeln, und anschließend wieder auf der anderen Seite hinabzusteigen. Definiere dazu Prozeduren für wiederkehrende Abläufe.

Tipp 1

Definiere die Prozeduren stufeHoch, stufeRunter und frissDreiKoerner. Diese Prozeduren sollen dann in der main-Prozedur mehrfach aufgerufen werden.

Tipp 2

Du solltest die folgenden Prozeduren definieren: main, stufeHoch, stufeRunter, frissDreiKoerner und (um dir Tipparbeit zu ersparen) rechtsUm. Die main-Prozedur ist im Folgenden bereits vorgegeben. Vervollständige die übrigen Prozeduren

void main()
{
    stufeHoch();
    stufeHoch();
    stufeHoch();
    stufeHoch();
    stufeHoch();
    frissDreiKoerner();
    stufeHoch();
    frissDreiKoerner();
    stufeRunter();
    frissDreiKoerner();
    stufeRunter();
    stufeRunter();
    stufeRunter();
    stufeRunter();
    stufeRunter();
}

void stufeHoch()
{
    // TODO
}

void stufeRunter()
{
    // TODO
}

void frissDreiKoerner()
{
    // TODO
}

void rechtsUm()
{
    // TODO
}

Lösungsvorschlag

void main()
{
    stufeHoch();
    stufeHoch();
    stufeHoch();
    stufeHoch();
    stufeHoch();
    frissDreiKoerner();
    stufeHoch();
    frissDreiKoerner();
    stufeRunter();
    frissDreiKoerner();
    stufeRunter();
    stufeRunter();
    stufeRunter();
    stufeRunter();
    stufeRunter();
}

void stufeHoch()
{
    linksUm();
    vor();
    rechtsUm();
    vor();
}

void stufeRunter()
{
    vor();
    rechtsUm();
    vor();
    linksUm();
}

void frissDreiKoerner()
{
    nimm();
    nimm();
    nimm();
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}

Aufgabe 4: Transporthamster

Der Hamster will einen sieben Kacheln entfernten Körnerhaufen von zehn Körnern zu sich transportieren. Leider ist er schon etwas gebrechlich und kann immer nur ein Korn gleichzeitig tragen. Er muss also immer hin- und herlaufen und die zehn Körner einzeln zu sich holen.

Vorher

Nachher

Schreibe ein entsprechendes Programm. Definiere dafür passende Prozeduren für wiederkehrende Abläufe.

Tipp 1

Der Hamster läuft ganz schön viel hin und her. Es bietet sich an, z.B. eine Prozedur laufeGang zu definieren, welche den Hamster sieben Schritte vorgehen lässt. Auch die Prozedur kehrt (Hamster dreht sich um) wäre praktisch. Letztendlich wäre es gut, eine Prozedur holeKorn einfach nur zehn Mal aufrufen zu müssen.

Tipp 2

Verwende das folgende Grundgerüst. Ergänze die Programmzeilen bei TODO entsprechend.

void main()
{
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
}

void holeKorn()
{
    // TODO
    // Einmal hin, dann ein Korn nehmen,
    // dann zurueck, anschliessend wieder umdrehen.
}

void laufeGang()
{
    // TODO
    // Sieben Schritte nach vorne gehen
}

void kehrt()
{
    // TODO
    // Hamster umdrehen
}

Lösungsvorschlag

void main()
{
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
    holeKorn();
}

void holeKorn()
{
    laufeGang();
    nimm();
    kehrt();
    laufeGang();
    gib();
    kehrt();
}

void laufeGang()
{
    vor();
    vor();
    vor();
    vor();
    vor();
    vor();
    vor();
}

void kehrt()
{
    linksUm();
    linksUm();
}

Aufgabe 5: Quadrathamster − Weitere Prozeduren definieren

Das Progamm aus Aufgabe 1 ist ganz schön lang! Wäre es nicht geschickt, wiederkehrende Muster als eigene Prozedur zu definieren?

Definiere eine Prozedur namens laufeGang, welche den Hamster bis zum Ende eines Gangs laufen lässt, ihn ein Korn aufnehmen lässt und den Hamster anschließend nach rechts dreht. Rufe diese Prozedur dann vier Mal in der main-Prozedur auf.

Lösungsvorschlag

void main()
{
    laufeGang();    // 1. Gang
    laufeGang();    // 2. Gang
    laufeGang();    // 3. Gang
    laufeGang();    // 4. Gang
    // Fertig!
}

void laufeGang()
{
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}

Aufgabe 6: Marathonläufer

Zwölf Runden im Quadrat entspricht einem Hamster-Marathon. Es handelt sich beim Laufen mehrerer Runden also um ein wiederkehrendes Muster − das ruft förmlich nach der Definition einer Prozedur!

Definiere die Prozedur laufeRunde, welche den Hamster eine ganze Runde laufen lässt, inklusive Aufnehmen je eines Korns in den vier Ecken. Rufe diese Prozedur laufeRunde anschließend zwölf Mal in der main-Prozedur auf.

Lösungsvorschlag

void main()
{
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    laufeRunde();
    // Fertig!
}

void laufeRunde()
{
    laufeGang();    // 1. Gang
    laufeGang();    // 2. Gang
    laufeGang();    // 3. Gang
    laufeGang();    // 4. Gang
}

void laufeGang()
{
    vor();
    vor();
    vor();
    vor();
    nimm();
    rechtsUm();
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}