Der Algorithmus der Türme von Hanoi

procedure hanoi(n, source, target, spare)
    if n == 0 then
        return
    hanoi(n - 1, source, spare, target)
    move disk n from source to target
    hanoi(n - 1, spare, target, source)
end procedure

Worauf zu achten ist

• Die Rollen wandern. Turm B ist der Hilfsturm des ersten Aufrufs und das Ziel des Aufrufs, den dieser macht. Jede Rekursionsebene beschriftet die drei Türme neu, und dieses Umbeschriften ist der ganze Trick.
• Der Stapel wird nie tief. Bei drei Scheiben laufen nie mehr als 4 Aufrufe gleichzeitig — einer je Scheibenzahl von 3 bis 0 —, obwohl das Programm insgesamt 15 Aufrufe macht.
• Die Hälfte der Aufrufe tut nichts. Von diesen 15 Aufrufen sind 8 Aufrufe für null Scheiben und kehren sofort zurück. Sie sind der Preis für den einfachsten möglichen Basisfall.
• Die Zeile, die bewegt, läuft genau 2ⁿ − 1-mal. Siebenmal bei drei Scheiben, verteilt über die 43 Schritte des Laufs.

Der erste Punkt ist am schwersten zu erwischen, während das Programm läuft, denn auf dem Brett bewegt sich dabei nichts — nur die Namen unter den Türmen ändern sich. Hier steht er still: der erste Aufruf, die beiden darunter auf dem Weg zu Zug 1, und der Aufruf, der den Stapel zurückholt.

1. hanoi(3, A, C, B)

   Der erste Aufruf: alle 3 Scheiben von A nach C bringen. Damit bleibt B als Hilfsturm. Start A, Ziel C, Hilfsturm B.

2. hanoi(2, A, B, C)

   Sein erster Aufruf. Scheibe 3 kann sich nicht bewegen, solange die Scheiben 1 und 2 auf ihr liegen, und die können nicht nach C, wohin Scheibe 3 unterwegs ist. Also wird B, eben noch der Hilfsturm, zum Ziel, und C wird zum Hilfsturm. Start A, Ziel B, Hilfsturm C.

3. hanoi(1, A, C, B)

   Eine Ebene tiefer derselbe Tausch noch einmal. Um Scheibe 2 frei zu legen, geht Scheibe 1 nach C, und B ist wieder der Hilfsturm. Start A, Ziel C, Hilfsturm B.

4. hanoi(2, B, C, A)

   Scheibe 3 ist gewechselt. Der zweite Aufruf der Wurzel holt die Scheiben 1 und 2 von B auf sie herüber, also ist jetzt B der Start und A, wo alle Scheiben angefangen haben, der Hilfsturm. Start B, Ziel C, Hilfsturm A.

Der zweite lässt sich leichter bezweifeln als prüfen, also hier der ganze Lauf mit der Höhe des Stapels bei jedem seiner Schritte:

• Der Lauf braucht 43 Schritte und macht insgesamt 15 Aufrufe.
• Die Zahl der Aufrufe auf dem Stapel steigt und fällt zwischen 0 und 4 und erreicht 4 bei 8 dieser Schritte — jedes Mal, wenn ein Aufruf ohne zu bewegende Scheibe beginnt und zurückkehrt.
• Tiefe 4 ist n + 1 für n = 3, und kein Schritt des Laufs geht darüber hinaus.

Der Rekursionsbaum

Zeichnen Sie jeden Aufruf als Kasten unter den Aufruf, der ihn gemacht hat, und das Programm wird zu einem Baum. Setzen Sie jeden Kasten über die Nummer des Zuges, den er macht, und etwas anderes wird sichtbar: Liest man die Kästen von links nach rechts, ergeben sie die Züge in der richtigen Reihenfolge. Bei drei Scheiben ist der eigene Zug des ersten Aufrufs — die größte Scheibe — Zug 4, genau in der Mitte, mit der vollständigen Drei-Zug-Lösung für zwei Scheiben auf jeder Seite.

1. Zug 1: Der Aufruf mit n = 1, von A nach C, bewegt Scheibe 1.
2. Zug 2: Der Aufruf mit n = 2, von A nach B, bewegt Scheibe 2, zwischen seinen beiden Aufrufen mit n = 1.
3. Zug 3: Der Aufruf mit n = 1, von C nach B, bewegt Scheibe 1.
4. Zug 4: Der Aufruf mit n = 3, von A nach C, bewegt Scheibe 3, zwischen seinen beiden Aufrufen mit n = 2.
5. Zug 5: Der Aufruf mit n = 1, von B nach A, bewegt Scheibe 1.
6. Zug 6: Der Aufruf mit n = 2, von B nach C, bewegt Scheibe 2, zwischen seinen beiden Aufrufen mit n = 1.
7. Zug 7: Der Aufruf mit n = 1, von A nach C, bewegt Scheibe 1.

Diese Symmetrie gilt bei jeder Größe. Zug 2ⁿ⁻¹ ist immer die größte Scheibe beim Wechsel, und die Züge davor und danach sind die Lösung für (n − 1) Scheiben, zweimal gespielt, mit zwei getauschten Turmrollen. Deshalb lässt sich eine Zugliste beliebiger Länge auf einen Blick lesen, und deshalb ist die Lösung für fünf Scheiben die für vier, ein Zug, und noch einmal die für vier.

Warum er korrekt ist

Der Algorithmus verstößt nie gegen eine Regel und endet immer, und der Beweis ist kurz genug, um ihn ganz zu geben. Die Behauptung lautet für jedes n:

Wenn die obersten n Scheiben des Startturms die Scheiben 1 bis n sind und jede Scheibe anderswo größer als n ist, dann bewegt hanoi(n, source, target, spare) diese n Scheiben regelkonform auf das Ziel und rührt nichts anderes an.

Für n = 0 gibt es nichts zu bewegen, und nichts wird angerührt.

Nehmen wir an, die Behauptung gilt für n − 1. Dann ist jeder der drei Schritte erlaubt:

1. Der erste Aufruf bewegt die Scheiben 1 bis n − 1 auf den Hilfsturm. Er darf das: Jede andere Scheibe, auch Scheibe n, ist größer als n − 1.
2. Scheibe n wechselt auf das Ziel. Jetzt liegt nichts mehr auf ihr, und auf dem Ziel liegen nur Scheiben, die größer als n sind.
3. Der zweite Aufruf bewegt die Scheiben 1 bis n − 1 vom Hilfsturm auf das Ziel. Erlaubt aus demselben Grund: Scheibe n, nun unter ihnen, ist größer.

Alle n Scheiben liegen auf dem Ziel, und sonst hat sich nichts bewegt. Per Induktion gilt die Behauptung für jedes n, und das vollständige Rätsel ist der Fall, in dem der Startturm alle Scheiben trägt.

1. Angenommendie Behauptung für n − 1

   Die Hypothese sagt, dass ein Aufruf auf n − 1 Scheiben sie regelkonform dorthin bewegt, wohin man ihm sagt, und nichts anderes anrührt. Hier angewandt, trägt er die Scheiben 1 bis n − 1 vom Start auf den Hilfsturm. Er darf das: Jede Scheibe, auf der er landen könnte — Scheibe n eingeschlossen — ist größer als jede, die er trägt.

2. Hier bewiesenein erlaubter Zug

   Das ist der einzige Schritt, den der Beweis selbst begründen muss, und er ist ein einziger Zug. Scheibe n ist frei, weil der Schritt davor sie frei geräumt hat. Auf dem Ziel liegen nur Scheiben, die größer als n sind, weil alles Kleinere auf dem Hilfsturm liegt. Also ist der Zug erlaubt.

3. Angenommendie Behauptung für n − 1, noch einmal

   Dieselbe Hypothese, ein zweites Mal benutzt, bringt die Scheiben 1 bis n − 1 vom Hilfsturm auf das Ziel. Erlaubt aus demselben Grund wie vorher: Scheibe n liegt jetzt unter ihnen und ist größer. Alle n Scheiben liegen auf dem Ziel, und sonst hat sich nichts bewegt — das ist die Behauptung für n.

Die Rekursionsgleichung, richtig gelöst

T(n) sei die Zahl der Züge, die der Algorithmus für n Scheiben macht. Die Funktion macht zwei Aufrufe auf n − 1 Scheiben und einen eigenen Zug, und ohne Scheiben macht sie überhaupt keinen Zug:

Zum Lösen setzen Sie die Gleichung in sich selbst ein und suchen das Muster. Das heißt Ausrollen oder Teleskopieren:

Ein Muster zu erkennen heißt nicht, es bewiesen zu haben — bestätigen Sie es per Induktion. T(0) = 0 = 2⁰ − 1. Und wenn T(n − 1) = 2ⁿ⁻¹ − 1 ist, dann ist T(n) = 2(2ⁿ⁻¹ − 1) + 1 = 2ⁿ − 2 + 1 = 2ⁿ − 1. Die geschlossene Form stimmt für jedes n exakt.

Es gibt einen dritten Weg, und er ist ein Bild, das Sie schon gesehen haben. Der Rekursionsbaum oben ist ein vollständiger Binärbaum: Die Wurzel bewegt n Scheiben, die zwei Aufrufe darunter je n − 1, die vier darunter je n − 2, und so weiter. Tiefe k enthält also 2ᵏ Aufrufe, die unterste Ebene ist Tiefe n − 1, und jeder dieser Aufrufe macht genau einen Zug. Addieren Sie die Ebenen, und die Summe fällt als geometrische Reihe heraus:

Drei Methoden — Ausrollen, Induktion und der Baum — und eine Antwort. Das ist gut zu wissen, denn es gibt eine vierte, die ständig angeboten wird, und die ist falsch.

Dieselbe Rechnung zählt die Aufrufe. Jeder Aufruf mit n {">"} 0 Scheiben macht zwei weitere, also gilt C(n) = 2C(n − 1) + 1 mit C(0) = 1, was sich zu 2ⁿ⁺¹ − 1 ausrollt. Das sind 2ⁿ − 1 Aufrufe, die eine Scheibe bewegen, plus 2ⁿ, die sofort zurückkehren.

Zeit- und Speicherkosten

Jeder Aufruf leistet neben seinen beiden rekursiven Aufrufen eine konstante Menge Arbeit, also ist die Laufzeit proportional zur Zahl der Aufrufe: Θ(2ⁿ). Kein klügerer Algorithmus kann das unterbieten, weil die Ausgabe selbst 2ⁿ − 1 Züge lang ist — und 2ⁿ − 1 ist ein bewiesenes Minimum, nicht nur das Beste, was jemand gefunden hat. Der Beweis, dass keine Lösung kürzer ist, hat eine eigene Seite: warum das Minimum 2ⁿ − 1 ist.

Mit dem Speicher verhält es sich anders. Die Aufrufe existieren nicht alle gleichzeitig: Ein Aufruf endet, bevor sein Geschwister beginnt, also hält der Stapel nur einen Aufruf je Ebene, von n hinunter bis 0. Der Platzbedarf ist Θ(n) — fünfundsechzig Stapelrahmen für die vierundsechzig Scheiben der Legende, was jeder Rechner wegsteckt, ohne es zu merken. Was ausgeht, ist die Zeit: 18.446.744.073.709.551.615 Züge sind bei einer Milliarde pro Sekunde immer noch 584 Jahre.

Diese Zahl gehört der Legende, und die Legende ist jünger, als sie klingt. Ein Tempel, in dem Priester vierundsechzig goldene Scheiben bewegen, und das Ende der Welt, wenn sie fertig sind, taucht 1884 zum ersten Mal im Druck auf — in einem Artikel, der ein Rätsel bewarb, das im Jahr zuvor in Paris in den Handel gekommen war, unter dem Namen eines Professors, den es nicht gab. Im Tempo der Mönche, ein Zug pro Sekunde, bleiben der Welt noch 585 Milliarden Jahre, ungefähr das Vierzigfache des heutigen Alters des Universums. Der Mathematiker hinter dem Rätsel und der Geschichte war Édouard Lucas, der von Hand bewies, dass 2¹²⁷ − 1 eine Primzahl ist, und mit 49 Jahren an einer Infektion starb, die von einem Schnitt durch einen Teller herrührte, den ein Kellner bei einem Bankett hatte fallen lassen.

Setzen Sie Zahlen in diese Formeln ein, und die beiden Kostenarten gehen auseinander. Jede weitere Scheibe macht Züge und Aufrufe etwas mehr als doppelt so zahlreich und fügt dem tiefsten Stand des Stapels einen einzigen Rahmen hinzu:

Der Rechner für die minimale Zugzahl ermittelt Züge und Zeit für jede Scheibenzahl, und die letzte Zeile — die Größe der Legende — hat eine eigene Seite.

Ohne Rekursion

Dieselben Züge lassen sich auch mit einer schlichten Schleife und zwei Regeln erzeugen:

• Ungerade Züge: Die kleinste Scheibe rückt einen Turm weiter, auf einem festen Rundweg — A → C → B bei ungerader Scheibenzahl, A → B → C bei gerader.
• Gerade Züge: Machen Sie den einzigen erlaubten Zug, der die kleinste Scheibe nicht anfasst. Es gibt immer genau einen.

Diese beiden Regeln geben die rekursive Lösung Zug für Zug wieder; die Seite zur iterativen Lösung zeigt, warum, und spielt sie auf einem Brett ab.

Es gibt eine noch seltsamere Fassung, die überhaupt keine Türme speichert: Scheibe, Start und Ziel von Zug m lassen sich jeweils an den Binärziffern von m ablesen. Dieser Zusammenhang, und der Gray-Code, der darin steckt, stehen in Türme von Hanoi, Binär und Gray-Code.

Aus einer Stellung, die nicht der Anfang ist

Die Lehrbuchfunktion setzt voraus, dass alle Scheiben auf dem Startturm beginnen. Geben Sie ihr ein halb fertiges Rätsel, und sie hat nichts dazu zu sagen. Ein weiterer Fall behebt das. Sehen Sie sich die größte Scheibe an:

• Schon auf dem Turm, den sie erreichen soll? Dann braucht sie keinen Zug. Lösen Sie die kleineren Scheiben und schicken Sie sie auf denselben Turm.
• Irgendwo anders? Räumen Sie die kleineren Scheiben auf den Turm, der weder ihr jetziger noch ihr Zielturm ist, bewegen Sie sie, und machen Sie weiter wie zuvor.

Diese Fassung findet die kürzeste Lösung aus jeder erlaubten Stellung, und genau sie lässt der Türme-von-Hanoi-Löser laufen.

Prüfen Sie sich selbst

Drei Fragen, die die Seite schon beantwortet hat. Denken Sie sie durch, bevor Sie aufklappen — kommt eine nicht, ist der Abschnitt, der bei der Antwort genannt wird, der zum Nachlesen.

1. Drei Scheiben sind sieben Züge. Wie viele sind 5 Scheiben, und wie viele davon bewegen Scheibe 5 selbst?

   Antwort anzeigen

   31 Züge, also 2⁵ − 1 — und genau einer davon bewegt die größte Scheibe. Jede Scheibe außer der größten bewegt sich mehr als einmal, weil jede der beiden Hälften der Lösung sie bewegen muss. Die Rekursionsgleichung, richtig gelöst.

2. hanoi(3, A, C, B) macht hanoi(2, A, B, C) als ersten Aufruf. Warum ist B das Ziel dieses Aufrufs und nicht C?

   Antwort anzeigen

   Weil Scheibe 3 nach C soll und dort nur landen kann, wenn C leer ist. Die beiden Scheiben darüber müssen also woanders geparkt werden, und dieses Woanders ist nur B. Der Turm, auf den ein Aufruf zielt, wird zu dem Turm, den sein erster Aufruf frei halten muss — deshalb tauschen zwei der drei Argumente beim Hineingehen die Plätze. Worauf zu achten ist.

3. 20 Scheiben zu lösen macht 2.097.151 Aufrufe. Wie viele davon sind höchstens im selben Moment auf dem Stapel?

   Antwort anzeigen

   21 — einer je Scheibenzahl von 20 bis 0. Ein Aufruf endet, bevor sein Geschwister beginnt, also existieren die Aufrufe nie alle gleichzeitig: Die Arbeit ist exponentiell und der Speicher linear. Zeit- und Speicherkosten.

Der Algorithmus in Ihrer Sprache

Dieselbe Funktion in sechs Programmiersprachen, jede mit einem lauffähigen Programm, einer Erklärung Zeile für Zeile, dem Brett daneben und den Dingen, die für diese Sprache eigen sind — und die zählen, sobald man die Züge für vierundsechzig Scheiben zählen will. Diese sechs Seiten sind auf Englisch.

• Türme von Hanoi in PythonENRecursive and iterative programs, why Python's recursion limit never bites here, and integers that simply do not overflow.
• Türme von Hanoi in JavaScriptENWhy 2 ** 64 − 1 prints the wrong number, BigInt, and a generator that hands out one move at a time.
• Türme von Hanoi in JavaENWhy (1L << 64) − 1 is zero, counting with BigInteger, and the same solution driven by an explicit stack.
• Türme von Hanoi in CENUndefined shifts, uint64_t, and a loop that reads every move straight off the bits of the move number.
• Türme von Hanoi in C++ENCollecting the moves in a std::vector, the 64-disk count checked by the compiler, and three pairs of towers in a loop.
• Türme von Hanoi in C#ENTop-level statements, an iterator whose moves LINQ can query, and ulong, checked arithmetic and UInt128 for the move count.

Die Wörter auf dieser Seite

Basisfall

Die Fassung des Problems, die eine rekursive Funktion unmittelbar beantwortet, ohne sich selbst aufzurufen. Er ist es, der die Rekursion anhält. Hier ist es n = 0: keine Scheibe zu bewegen, also nichts zu tun, und der Aufruf kehrt zurück. Jede Kette von Aufrufen, wie tief auch immer, endet in einem davon.

Rekursiver Fall

Alles, was nicht der Basisfall ist: der Teil der Funktion, der eine kleinere Fassung desselben Problems löst und seine Antwort daraus aufbaut. Hier sind es die drei Zeilen, die n − 1 Scheiben aus dem Weg räumen, Scheibe n bewegen und die n − 1 zurückbringen.

Aufrufstapel

Die Liste der Funktionsaufrufe, die begonnen und noch nicht geendet haben, der jüngste zuletzt. Ein Aufruf kommt hinzu, wenn er beginnt, und fällt weg, wenn er zurückkehrt — der Stapel ist also die Art, wie ein Programm sich merkt, wohin es zurück muss. Genau ihn zeichnet das Feld oben, und er ist echter Speicher: deshalb ist seine Tiefe der Platzbedarf des Algorithmus.

Stapelrahmen

Ein Eintrag auf dem Aufrufstapel: die Argumente und lokalen Variablen eines einzelnen Aufrufs. Jede Zeile des Stapels im Feld oben ist ein Rahmen, mit dem eigenen n dieses Aufrufs und seiner eigenen Auffassung davon, welcher Turm Start, Ziel und Hilfsturm ist. Vierundsechzig Scheiben brauchen fünfundsechzig Rahmen, was nichts ist; das Problem sind die Züge.

Teleskopieren

Auch Ausrollen genannt: eine Rekursionsgleichung lösen, indem man sie so lange in sich selbst einsetzt, bis das Muster offensichtlich ist, und dann die Zahl der Einsetzungen so wählt, dass nur der bekannte Startwert übrig bleibt. Teleskopieren heißt es, weil die mittleren Glieder zusammenfallen wie die Auszüge eines Fernrohrs.

Θsaid “Groß-Theta”

Eine Wachstumsrate, die zugleich obere und untere Schranke ist: Θ(2ⁿ) heißt, dass die Kosten wie 2ⁿ wachsen, nicht bloß nicht schneller. O(2ⁿ) würde nur die Decke versprechen. Θ ist hier die ehrliche Schreibweise, weil dieser Algorithmus tatsächlich 2ⁿ − 1 Züge macht — er kann kein Glück haben und früher fertig sein.

Häufige Fragen

Wie funktioniert der rekursive Algorithmus der Türme von Hanoi?

Um n Scheiben von einem Startturm auf einen Zielturm zu bringen, bewegt er zuerst die oberen n − 1 Scheiben auf den Hilfsturm, dann die größte Scheibe auf das Ziel, dann die n − 1 Scheiben vom Hilfsturm auf das Ziel. Jede dieser beiden kleineren Umschichtungen ist dasselbe Problem mit einer Scheibe weniger, also ruft sich die Funktion dafür selbst auf, und ein Aufruf ohne zu bewegende Scheibe kehrt einfach zurück.

Sind die Türme von Hanoi Teile und herrsche oder dynamische Programmierung?

Teile und herrsche. Das Problem wird in zwei Teilprobleme mit n − 1 Scheiben geteilt, jedes per Rekursion erledigt, und der Kombinationsschritt ist ein einzelner Zug der größten Scheibe. Dynamische Programmierung ist es nicht, und Memoisierung hilft nicht — obwohl sich die Teilprobleme tatsächlich wiederholen. Mit drei Türmen gibt es nur sechs Arten, Start, Ziel und Hilfsturm zu benennen, also wird hanoi(1, A, C, B) beim Lösen von drei Scheiben wirklich zweimal aufgerufen. Das zwischenzuspeichern bringt nichts, denn die Antwort auf ein Teilproblem ist eine Liste von 2ᵏ − 1 Zügen, und eine gespeicherte Liste dieser Länge abzuspielen kostet so viel, wie sie zu erzeugen. Die Arbeit ist hier die Ausgabe, und keine Tabelle macht die Ausgabe kürzer.

Gilt das Master-Theorem für die Rekursionsgleichung der Türme von Hanoi?

Nein. Das Master-Theorem deckt Gleichungen der Form T(n) = aT(n/b) + f(n) ab, bei denen jedes Teilproblem ein Bruchteil des ursprünglichen ist. Die Gleichung der Türme von Hanoi ist T(n) = 2T(n − 1) + 1: Das Teilproblem ist eine Scheibe kleiner, nicht um einen Faktor. Ausrollen ergibt direkt T(n) = 2ⁿ − 1, und Induktion bestätigt es.

Wie tief geht die Rekursion?

Mit einem Basisfall bei n = 0 liegen höchstens n + 1 Aufrufe gleichzeitig auf dem Stapel: einer je Scheibenzahl von n bis 0. Mit einem Basisfall bei n = 1 sind es n. So oder so wächst die Tiefe linear, und deshalb braucht die rekursive Lösung nur O(n) Speicher, obwohl sie exponentiell viele Züge macht.

Wie viele Funktionsaufrufe macht die rekursive Lösung?

2ⁿ⁺¹ − 1 Aufrufe, wenn der Basisfall n = 0 ist: die 2ⁿ − 1 Aufrufe, die eine Scheibe bewegen, plus 2ⁿ Aufrufe, die nichts zu bewegen finden und zurückkehren. Drei Scheiben machen 15 Aufrufe. Mit einem Basisfall bei n = 1 geschrieben, macht dasselbe Programm genau 2ⁿ − 1 Aufrufe, einen je Zug.

Ist der iterative Algorithmus schneller als der rekursive?

Nicht auf eine Weise, die zählt. Beide müssen 2ⁿ − 1 Züge erzeugen, also brauchen beide Zeit proportional zu 2ⁿ. Die iterative Fassung spart die Kosten der Funktionsaufrufe und kann den Stapel nicht überlaufen lassen, aber die Rekursion ist hier nur n Ebenen tief: Ein Stapelüberlauf ist für keine Scheibenzahl, auf die Sie warten könnten, ein echtes Risiko.

Wie sieht der Algorithmus der Türme von Hanoi als Flussdiagramm aus?

Nach nicht viel, und das ist die ehrliche Antwort. Ein Flussdiagramm zeigt, wie die Steuerung einmal durch Kästen läuft, und der zweite Kasten dieses Algorithmus ist das ganze Flussdiagramm noch einmal — drei Ebenen tiefer, mit zwei vertauschten Türmen und einer Scheibe weniger. Dafür hat ein Flussdiagramm keine Notation: Ein Flussdiagramm der rekursiven Lösung ist also entweder falsch, oder es ist das Bild eines einzelnen Aufrufs mit zwei Kästen, auf denen „hanoi aufrufen“ steht — und das lehrt nichts, was der vierzeilige Pseudocode nicht auch lehrt. Das Diagramm, das es ausdrückt, ist der Rekursionsbaum: jeder Aufruf unter dem Aufruf gezeichnet, der ihn gemacht hat, jeder Kasten über dem Zug, den er macht. Er steht auf dieser Seite, und seine Kästen von links nach rechts gelesen ergeben die Züge der Reihe nach.

Kann der Algorithmus ein schon halb gelöstes Rätsel lösen?

Die Lehrbuchfassung nicht: Sie setzt voraus, dass alle Scheiben auf einem Turm beginnen. Sie lässt sich mit einem zusätzlichen Fall verallgemeinern — liegt die größte Scheibe schon auf ihrem Ziel, überspringen Sie sie und lösen Sie die Scheiben darüber — und diese Fassung findet die kürzeste Lösung aus jeder erlaubten Stellung. Der Löser dieser Seite lässt genau das laufen. Den Löser öffnen →