Jahrgangsstufe Q1 - Informatik - Dienstag, der 16. März 2021


Rekursions-Musterlösungen

Rekursionsaufgabe 1 vom 02.03.2021:


Kara soll rekursiv ein irgendwo vor ihm liegendes Blatt finden und am Ziel eine Erfolgsmeldung ausgeben. Gib dann das komplette Programm hier ein.

import javakara.JavaKaraProgram;
public class FindeBlattNeu extends JavaKaraProgram {

  public void findeBlatt()
  {  if (!kara.onLeaf())
          {  kara.move();  // Problem um einen Schritt vereinfachen
             findeBlatt();  // vereinfachtes Problem loesen
          }
     else { kara.turnLeft();
            kara.turnLeft();
            tools.showMessage("Ich habe das Blatt gefunden.");
          }
  }

  public void myProgram()
  {  findeBlatt();  }
} // End der Klasse

Rekursionsaufgabe 2 vom 02.03.2021:


Kara soll rekursiv ein irgendwo vor ihm liegendes Blatt finden und dieses Blatt an seine Startposition zurückbringen und dort ablegen.

import javakara.JavaKaraProgram;
public class FindeBlattNeuZurueck extends JavaKaraProgram {

  public void findeBlatt()
  {  if (!kara.onLeaf())
          {  kara.move(); // Problem um einen Schritt vereinfachen,
             findeBlatt(); // vereinfachtes Problem loesen
             kara.move(); // und einen Schritt auf dem Rueckweg gehen.
          }
     else { kara.removeLeaf();
            kara.turnLeft();
            kara.turnLeft();
          }
  }

  public void myProgram()
  {  findeBlatt();
     kara.putLeaf();
     kara.turnLeft();
     kara.turnLeft();
  }
} // End der Klasse

Rekursionsaufgabe 1 vom 04.03.2021:


Kara steht in einer Reihe, an deren Ende ein Baum steht. Kara soll bis zum Baum laufen, dabei alle Blätter einsammeln, sich dort umdrehen, zurücklaufen und die Blätter an den alten Plätzen ablegen. Gib das komplette Programm hier ein.
Hinweis:
Wenn er ein Blatt an einer Stelle findet, soll er es aufnehmen, das reduzierte Problem von der nächsten Position aus lösen und danach (auf dem Rückweg) dort wieder ein Blatt ablegen.
Sonst soll er das reduzierte Problem von der nächsten Position aus lösen und danach (auf dem Rückweg) nichts weiter machen als einen Schritt.
Das muss man jetzt "nur" noch in die Sprache Java mit if und else übersetzen.

public class BlaetterAufsammelnUndAblegen extends JavaKaraProgram {

  public void geheWeg()
  {  if (!kara.treeFront())
          { if (kara.onLeaf())
                 { kara.removeLeaf();
                   kara.move();
                   geheWeg();
                   kara.move();
                   kara.putLeaf();
                 }
            else { kara.move();
                   geheWeg();
                   kara.move();
                 }
          }
     else { kara.turnLeft();
            kara.turnLeft();
          }
  }

  public void myProgram()
  {  geheWeg();
     kara.turnLeft();
     kara.turnLeft();
  }
}

Rekursionsaufgabe 2 vom 04.03.2021:

Vorher:


Nachher:



Kara steht in einer Reihe, an deren Ende ein Baum steht. Kara soll bis zum Baum laufen, dabei alle Blätter einsammeln und die Blätter hinter dem Baum spiegelbildlich ablegen. Es gibt keine weiteren Bäume, die stören könnten.
Hinweis:
Der Unterschied zum oberen Programm liegt eigentlich nur am Verhalten direkt am Baum.

public class BlaetterGespiegeltAblegen extends JavaKaraProgram {

  public void geheWeg()
  {  if (!kara.treeFront())
          { if (kara.onLeaf())
                 { kara.removeLeaf();
                   kara.move();
                   geheWeg();
                   kara.move();
                   kara.putLeaf();
                 }
            else { kara.move();
                   geheWeg();
                   kara.move();
                 }
          }
     else { kara.turnLeft();
            kara.move();
            kara.turnRight();
            kara.move();
            kara.move();
            kara.turnRight();
            kara.move();
            kara.turnLeft();
          }
  }

  public void myProgram()
  {  geheWeg();
  }
}

Rekursionsaufgabe vom 09.03.2021:


Kara steht am Eingang eines einfachen "Labyrinths. Die Gänge sind so gebaut, dass sie immer nur einen Baum breit sind, es keine Löcher auf dem Weg und auch keine Verzweigungen gibt. Das Ende des Weges ist sozusagen eine Sackgasse. Kara soll den Weg bis zum Ende gehen und sich quasi durch Rekursion den Rückweg merken. Kara merkt sich z. B., dass er auf dem Rückweg links abbiegen muss, wenn er auf dem Hinweg rechts abgebogen ist. Wenn man Kara irgendwo auf dem Weg startet, findet er das Ende und auch wieder den Anfang seines Weges.

import javakara.JavaKaraProgram;

public class LabyrinthRekursiv extends JavaKaraProgram {

public void einenSchrittWeiter()
  { if (!kara.treeFront())
         { kara.move();
           einenSchrittWeiter();
           kara.move();
         }
    else if (!kara.treeRight())
         { kara.turnRight();
           einenSchrittWeiter();
           kara.turnLeft();
         }
    else if (!kara.treeLeft())
         { kara.turnLeft();
           einenSchrittWeiter();
           kara.turnRight();
         }
    else { kara.turnRight();
           kara.turnRight();
         }
  }

public void myProgram()
{  einenSchrittWeiter(); }
}