Parameter: Aufgaben

Der Hamster soll ein Rechteck ablaufen. Die main-Prozedur ist bereits vorgegeben. Ersetze das // TODO durch geeignete Code-Zeilen. 

void main()
{
    mehrereVor(8);
    linksUm();
    mehrereVor(4);
    linksUm();
    mehrereVor(8);
    linksUm();
    mehrereVor(4);
    linksUm();
}

void mehrereVor(int n)
{
    // TODO
}

Orientiere dich an der Prozedur nimmMehrere aus dem Beispiel. Beachte, dass du den Parameter beliebig nennen darfst: Hier heißt er n (für „natürliche Zahl“), im Beispiel heißt er wieviele.

Verwende eine for-Schleife für das Zählen der Schritte. Beachte, dass in der for-Schleife eine eigene weitere Zählvariable eingeführt wird. Dieser darfst du dann eben nicht den Namen n verleihen, da der Name n ja bereits als Parameter definiert wurde. 

void main()
{
    mehrereVor(8);
    linksUm();
    mehrereVor(4);
    linksUm();
    mehrereVor(8);
    linksUm();
    mehrereVor(4);
    linksUm();
}

void mehrereVor(int n)
{
    for (int i = 0; i < n; i++)
    {
        vor();
    }
}

Der Hamster soll mehrere Rechtecke ablaufen. Die main-Prozedur ist bereits vorgegeben. Ersetze das // TODO durch geeignete Code-Zeilen. 

void main()
{
    laufeRechteck(8, 4);
    laufeRechteck(4, 8);
    laufeRechteck(3, 3);
}

void laufeRechteck(int breite, int hoehe)
{
    // TODO
}

void mehrereVor(int n)
{
    // TODO
}

Die Prozedur mehrereVor kannst du direkt aus der letzten Aufgabe übernehmen. Bei der Prozedur laufeRechteck kannst du die Befehle aus der main-Prozedur der letzten Aufgabe übernehmen.

Was musst du ändern, damit die Parameter breite und hoehe zum Tragen kommen, anstelle der festgeschriebenen Breite 8 und Höhe 4? 

void main()
{
    laufeRechteck(8, 4);
    laufeRechteck(4, 8);
    laufeRechteck(3, 3);
}

void laufeRechteck(int breite, int hoehe)
{
    mehrereVor(breite);
    linksUm();
    mehrereVor(hoehe);
    linksUm();
    mehrereVor(breite);
    linksUm();
    mehrereVor(hoehe);
    linksUm();
}

void mehrereVor(int n)
{
    for (int i = 0; i < n; i++)
    {
        vor();
    }
}

Der Hürdenläufer hat sich ein neues Ziel gesetzt: Beliebig hohe Hürden überwinden. Definiere dazu eine Prozedur nimmFlexHuerde(int h), welche die Hürdenhöhe als Parameter h entgegen nimmt. Rufe diese Prozedur anschließend mit verschiedenen Argumenten (4, 2, 5, 1 und 3) in der main-Prozedur auf.

Orientiere dich an der bereits bekannten Hürdenläufer-Aufgabe. Das Einzige, was du ändern musst: Anstatt $3$ Schritte hoch und runter zu klettern, müssen nun h Schritte hoch und runter geklettert werden. Verwende dafür eine for-Schleife

Du kannst folgende Vorlage verwenden. Definiere nun noch die Prozedur nimmFlexHuerde(int h). 

void main()
{
    // Erst 5 Huerden...
    nimmFlexHuerde(4);
    nimmFlexHuerde(2);
    nimmFlexHuerde(5);
    nimmFlexHuerde(1);
    nimmFlexHuerde(3);
    // ... dann die Belohnung!
    nimm();
}

void nimmFlexHuerde(int h)
{
    // TODO
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}
void main()
{
    // Erst 5 Huerden...
    nimmFlexHuerde(4);
    nimmFlexHuerde(2);
    nimmFlexHuerde(5);
    nimmFlexHuerde(1);
    nimmFlexHuerde(3);
    // ... dann die Belohnung!
    nimm();
}

void nimmFlexHuerde(int h)
{
    linksUm();
    for (int i = 0; i < h; i++)
    {
        vor();
    }
    rechtsUm();
    vor();
    vor();
    rechtsUm();
    for (int i = 0; i < h; i++)
    {
        vor();
    }
    linksUm();
}

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

Der Hamster soll in der Mitte seines Territoriums starten und eine Spirale ablaufen. Dabei soll er eine Körnerspur hinterlassen (er benötigt also einen initialen Körnervorrat).

Die main-Prozedur ist bereits vorgegeben. Gehe in zwei Schritten vor.

  1. Definiere eine parametrisierte Prozedur, welche eine Körnerlinie über eine angegebene Länge legt.
  2. Ersetze das TODO in main durch geeignete Code-Zeilen. 
void main()
{
    for (int i = 1; i < 15; i++)
    {
        // TODO
    }
}

// TODO
void main()
{
    for (int i = 0; i < 15; i++)
    {
        mehrereVor(i);
        linksUm();
    }
}

void mehrereVor(int n)
{
    for (int i = 0; i < n; i++)
    {
        vor();
        gib();
    }
}
Vorher
Nachher

Der Hamster soll lernen, einen Graphen in ein Koordinatensystem einzutragen. Der Einfachheit halber werden nur ganzzahlige nicht-negative X- und Y-Koordinaten dargestellt.

Im rechtsstehenden Beispiel soll der Hamster eine Normalparabel von $x = 0$ bis $x = 4$ zeichnen.

Vervollständige das folgende Programm, indem du das // TODO ersetzt. 

void main()
{
    markierePunkt(0, 0);
    markierePunkt(1, 1);
    markierePunkt(2, 4);
    markierePunkt(3, 9);
    markierePunkt(4, 16);
}

void markierePunkt(int x, int y)
{
    // TODO
}

Welche Schritte muss der Hamster nun ausführen, um einen Punkt zu setzen? Letztlich kann man ihn einfach ein Rechteck ablaufen lassen, und dabei an der richtigen Ecke ein Korn ablegen lassen... Orientiere dich also an der Aufgabe „Rechteckläufer, Version 2“. 

void main()
{
    markierePunkt(0, 0);
    markierePunkt(1, 1);
    markierePunkt(2, 4);
    markierePunkt(3, 9);
    markierePunkt(4, 16);
}

void markierePunkt(int x, int y)
{
    mehrereVor(x);
    linksUm();
    mehrereVor(y);
    gib();
    linksUm();
    mehrereVor(x);
    linksUm();
    mehrereVor(y);
    linksUm();
}

void mehrereVor(int n)
{
    for (int i = 0; i < n; i++)
    {
        vor();
    }
}