S11B Weg aus Labyrinth programmieren
Formal Metadata
Title |
| |
Title of Series | ||
Number of Parts | 36 | |
Author | ||
License | CC Attribution - NonCommercial - ShareAlike 3.0 Germany: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
Identifiers | 10.5446/9644 (DOI) | |
Publisher | ||
Release Date | ||
Language | ||
Producer |
Content Metadata
Subject Area | |
Genre |
19
00:00
CalculationZahlComputer programmingData storage deviceRecursionBitFunctional (mathematics)PositionSoftware developerNumberCellular automatonRecursive languageSystem callArrow of timeField (computer science)Point (geometry)Shape (magazine)Direction (geometry)Desire pathView (database)SpeciesNeuroinformatikFerry CorstenSingle-precision floating-point formatMultiplication signSpacetimeRight anglePosition operator1 (number)Computer animationDiagramEngineering drawing
08:58
CodeData structureOrder (biology)ZahlType theoryMaizeArithmetic meanFunctional (mathematics)Line (geometry)PositionQuantum stateNumberC++System callLogical constantProcess (computing)Unitäre GruppePoint (geometry)Interior (topology)Direction (geometry)Enumerated typeTypFerry CorstenMultiplication signClique-widthRight anglePosition operatorTelephone number mappingInformationComputer animation
17:56
CodeInformationMathematicsMatrix (mathematics)Computer programmingType theoryMatrix (mathematics)Level (video gaming)Variable (mathematics)RecursionArithmetic meanBitFunctional (mathematics)Line (geometry)Loop (music)Pairwise comparisonPositionVirtual machineRecursive languageTheoretical computer scienceSystem callProcess (computing)Point (geometry)Data storage deviceInterior (topology)RandDirection (geometry)Sound effectTypSpacetimeRight anglePosition operatorInformationDEBUG <Programm>World Wide WebComputer animation
26:53
CodeMathematicsNatural languageComputer programmingRecursionAnalogyBitFunctional (mathematics)Group actionObject-oriented programmingPositionQuantum stateRecursive languageC++System callQuery languageGoodness of fitArrow of timeException handlingCASE <Informatik>Process (computing)Error messagePoint (geometry)makeInterior (topology)Direction (geometry)Equaliser (mathematics)Statement (computer science)Aktion <Informatik>Program codeMultiplication signClique-widthRight anglePosition operatorInformationDownloadDEBUG <Programm>makeWorld Wide WebFilm editingMultitier architectureComputer animationDiagram
35:51
Video gameComputer programmingFluid staticsBitCompilerDebuggerFunctional (mathematics)Line (geometry)Loop (music)Moment (mathematics)Local ringNumberSystem callRevision controlReal numberCASE <Informatik>Point (geometry)Control flowmakeOnline helpSound effectEnumerated typeView (database)File viewerCondition numberSwitch <Kommunikationstechnik>Image resolutionMultiplication signWritingInformationStatisticsVariable (mathematics)Data terminal equipmentVersion <Informatik>Configuration spaceDownloadUpdateVALLarge eddy simulationmakeTiefeWorld Wide WebVirtual memoryCOM <Programmierumgebung>TypOvoidComputer animation
44:49
BitLine (geometry)Error messageRandNummerierungSingle-precision floating-point formatRight angleInformationVariable (mathematics)DownloadWeightError messageVALTypComputer animation
47:14
Image processingSemiconductor memoryFluid staticsForm (programming)Line (geometry)MultilaterationCoordinate systemLocal ringNumberCellular automatonCASE <Informatik>Heegaard splittingPoint (geometry)Array data structureGreatest elementMultiplication signSpacetimeRight angleCodeInformationStatisticsVariable (mathematics)DownloadArtificial neural networkESERVALAbsolute valueTrans-European NetworksTiefeWorld Wide WebMultitier architectureStack (abstract data type)Telephone number mappingComputer animation
Transcript: German(auto-generated)
00:01
Ein Labyrinth lösen. Was mir vorschwebt, um das einfach zu halten, ist quasi ein Schachbrett zu nehmen. Nehmen quasi ein Schachbrett und malen Felder aus, die Wände sein sollen und durchdringliche Wände.
00:23
Von mir aus, da soll ein Wand sein und irgendwo soll es euch tatsächlich einen Ausgang geben. Da gibt es einen Ausgang und dann machen wir noch weitere Wände rein. Mal jetzt einfach wild, ich weiß auch nicht, ob das sinnvoll ist.
00:41
So was. Und dann soll irgendwo eine Startposition definiert sein. Und man soll versuchen, von der Startposition einen Weg nach draußen zu finden. Der Rechner soll versuchen, von der Startposition einen Weg nach draußen zu finden.
01:02
Vollautomatisch. Das ist nochmal ein bisschen was komplizierteres zum Ende des Semesters. Einen Weg aus einem Labyrinth finden. Wie würden Sie dieses Labyrinth im Rechner darstellen? Die Form der Wände, die Platzierung der Wände, wie würden Sie die im Rechner ablegen?
01:27
Also das Nahelingste, so wie ich es aufgezeichnet habe, ist offensichtlich ein Array. Aus von mir aus 8 mal 8 Zellen oder wie viele es auch immer werden mögen. Und in das Array schreibe ich als Einträge eben rein, Wand oder nicht Wand.
01:41
Wie ich dann gleich die Einträge baue, von wegen Wand und nicht Wand, ist noch eine größere Kunst. Man könnte was machen, eine große Zahl in das Array reinschreiben und zu sagen, hier ist Feierabend und eine kleine Zahl. Zum Beispiel 1 und 0 würden es ja auch tun. Ich würde es gleich noch ein bisschen anders machen, aber das wäre schon der erste Gedanke.
02:04
Dass man sagt, ok, eigentlich steht da so etwas wie 1, 1, 1, 1, 1, 1, 1, 1 und dann 0, 1, 0, 1, 0, 0, 1. Vielleicht so etwas in der Art. Aber das kann man noch ein bisschen raffinierter machen. Auf diese Weise kann ich zumindest schon mal die Form des Labyrinths im Rechner ablegen.
02:27
Hier so eine Position, die Startposition, da geben Sie einfach X und Y an, das ist ja keine große Kunst. Sie sagen, wo diese Startposition ist, in der so und sovielten Spalte, in der so und sovielten Zeile. Die richtig spannende Frage ist, wie man jetzt vorgeht, nachdem man diese Daten hat.
02:46
Ich weiß, wie das Labyrinth aussieht, wie die Wände gebaut sind, wo die Wände gebaut sind. Ich weiß, wo ich starte. Die richtig spannende Frage ist, was dann? Wie kriege ich denn jetzt tatsächlich einen Weg aus dem Labyrinth raus?
03:05
Ja, links, rechts, oben, unten prüfen, ob frei ist. Wenn Sie das vorstellen, oben, rechts, probieren wir vielleicht mal links hier. Wenn ich finde, dass links Platz ist und Sie sagen, da bewege ich mich dann
03:21
hin, kann es ja sein, dass ich in die Irre laufe, dass es nicht weitergeht. Genau, man müsste sich noch merken, wo man schon gewesen ist und dass man hier sieht, das haut nicht hin. Ich müsste ganz viele Möglichkeiten durchprobieren und feststellen, welche nicht funktioniert haben.
03:47
Genau, das wäre der Gedanke. Ich probiere aus, was ich ausprobieren kann. Kann ich dahin? Schwierig, da laufe ich in die Irre. Dann müssen wir das vergessen. Ich muss was anderes ausprobieren. Kann ich das machen? Geht auch nicht weiter.
04:01
Dann laufe ich dahin und vielleicht dahin. Geht auch nicht weiter. Das ist natürlich total ungeschickt, wenn ich den Ausweg hier wirklich als allerletztes finde. Man könnte alle möglichen Arten ausprobieren, gucken, welche in der Sackgasse enden. Dann muss man eben wieder zurück sozusagen und nochmal neu probieren.
04:23
Das ist, wenn Sie das so sehen, wäre das schon eine ganz schön heftige Arbeit, das zu programmieren. Lustigerweise, darauf will ich heute hinaus, kriegt man das mit Rekursion total willig hin. Man muss gar nicht selbst buchführen, was man alles schon abgearbeitet hat.
04:41
Das passiert hinter den Kulissen automatisch, wenn man Rekursion richtig anwendet. Und zwar so dann. Jetzt habe ich alles vollgemalt. Ich mache mal ganz viel Ando. Folgender Gedanke. Ich gucke in alle vier Himmelsrichtungen. Wo eine Wand ist, vergesse ich sofort. Offensichtlich. Da muss ich nicht hingucken.
05:03
Da wo ich angekommen bin, nicht auf einer Wand, da wo ich wirklich angekommen bin auf Spielfeldern sozusagen, gucke ich wieder in alle vier Himmelsrichtungen. Da kann ich nur noch dahin. Hier kann ich nur dahin. Jetzt bin ich da angekommen. Ich gucke wieder in alle Himmelsrichtungen. Da und da und da. Hier gucke ich in alle Himmelsrichtungen. Da und da.
05:24
Da sehe ich, hier ist Feierabend, aber hier geht es noch weiter. Hier in alle vier Himmelsrichtungen gucken, da in alle Himmelsrichtungen gucken und so weiter. Hier kann ich wieder in zwei mögliche Richtungen gucken. Wenn ich das weiter verfolge, hier in alle Richtungen gucken, kann ich nur dahin, hier kann ich nur dahin.
05:42
Hier kann ich nur dahin, hier kann ich dahin und dahin. Hier bin ich in der Sackgasse, kann ich vergessen. Hier kann ich dahin, da kann ich dahin, da kann ich dahin. Hier bin ich in der Sackgasse, hier geht es weiter und so weiter. Also was ich schreiben wollen würde, ist nicht direkt ein Programm, das alle Pfade einzeln durchgeht.
06:06
Wir gehen hier bis zu Ende durch, da bis zu Ende durch, sondern ein Programm, das gefühlt ganz viele Sachen gleichzeitig macht. Ich hoffe, ich vergesse am Ende nicht zu erzählen. Es ist dann trotzdem genau das macht, was ich gerade aufgezählt habe. Aber vom Gefühl her würde ich lieber ein Programm schreiben, das sagt, mach doch alles gleichzeitig.
06:23
Von jedem erreichbaren Punkt gucke ich in alle vier Himmelsrichtungen. So einen einzelnen Schritt programmieren. Von dem aktuellen Punkt gucke ich in alle vier Himmelsrichtungen. Und dann von den erreichten Punkten, das rufe ich dann selbst wieder auf, in alle vier Himmelsrichtungen.
06:41
Außer die, aus der ich komme natürlich gucken. Das lohnt sich nicht. In jedem Punkt, an dem ich ankomme, in alle Richtungen gucken, außer die, aus der ich komme und so weiter. Das ist ein einziger Funktionsaufruf dann. Von der Stelle, auf der ich gerade sitze, man wird also offensichtlich in eine Position übergeben müssen,
07:03
was ist die aktuelle Stelle, an der ich gucken will. Von der aktuellen Stelle rumgucken. Hübsch wäre, wenn ich noch ignoriere, wo ich hergekommen bin. Muss mal gucken, wie das gleich zu machen ist. Wie sinnvoll zu machen ist.
07:20
Auf diese Weise könnte ich mich durchgraben und würde dann irgendwann feststellen, ich bin außen angekommen. Nur, wenn ich da jetzt angekommen bin, habe ich den Ärger, dass ich nicht genau weiß, was denn nun der Weg war. Ich bin angekommen und ich weiß, es gibt einen Weg raus. Aber ich kann schlecht nachvollziehen, was denn der Weg eigentlich war.
07:42
Deshalb würde ich mir noch ein bisschen mehr speichern. Ich würde mir speichern, wo ich hergekommen bin. Also, wenn ich von dem starte, würde ich mir merken,
08:03
aha, ich bin von dem hergekommen. Hier merke ich mir quasi so einen Pfeil. Wenn ich da bin, bin ich von dem hergekommen. Wenn ich hier bin, bin ich von dem hergekommen. Hier von dem, hier von dem, von dem.
08:22
Hier bin ich von dem gekommen, da bin ich von dem gekommen und so weiter. Dass jede Zelle quasi einen Verweis hat, wo bin ich hergekommen. Und dann bin ich zum Schluss. Sehen Sie, dieser wird so einen Pfeil kriegen. Dieser wird so einen Pfeil gekriegt haben, so einen Pfeil gekriegt haben.
08:41
Und wenn ich dann einfach die Pfeile verfolge, von dem Ausweg, den ich gefunden habe, von dem Ausgang, sollte ich sagen, von dem Ausgang, den ich gefunden habe, wenn ich diese Pfeile einfach verfolge, habe ich tatsächlich einen Weg reingefunden. Aber der Weg rein ist natürlich auf einen Weg raus. Also ich sortiere dann zusammen, habe einen Weg rein und den gebe ich rückwärts aus, dann habe ich einen Weg raus.
09:06
Das war kompliziert. Also, wir brauchen ein Ray, das sich merkt, wo die Wände sind. Das sich merkt, in welche Richtung ich zum Anfangspunkt komme.
09:27
Das sich aber auch merken kann, dass gerade noch nicht bekannt ist, aus welcher Richtung ich komme. Wenn Sie da anfangen, wissen Sie da oben noch nicht, aus welcher Richtung Sie kommen. Später wissen wir dann, okay, wir kommen aus der Richtung. Am Anfang wissen wir das noch nicht.
09:44
Und irgendwie hat der Startpunkt eine besondere Bedeutung, vielleicht sollte man den auch noch getrennt markieren. Also ich bräuchte ein Ray, in dem ich pro Eintrag sieben verschiedene Möglichkeiten. Ich weiß es noch nicht.
10:00
Es ist eine Wand, es ist der Startpunkt, oder es ist eine der vier Himmelsrichtungen. Ein Ray, das sich das merkt, oder merken kann, für jeden der Punkte. Sie könnten Int machen, als Typ in dem Ray, oder sogar Char. 256 Möglichkeiten reichen ja auch für diese sieben hier.
10:22
Was wäre schöner, geschickter? Eine Enumeration. Also, wir bauen erstmal eine Enumeration. Wegpunkt gefällt mir gerade am besten, wobei es ja nicht ganz stimmt.
10:42
Eine Wand ist ja kein Wegpunkt. Lassen wir es dabei jetzt, Waypoint. Bevor ich da jetzt noch fünf Minuten drüber nachdenke. Keine so schöne Bezeichnung, aber es sollte gehen. So, was soll diese Enum tun?
11:01
Ich schreib es doch mal. Ach doch, ich schreib es so untereinander. Sie soll sagen können, wir wissen es noch nicht. Wie nennen wir das mal? Vielleicht undefined. Ich bin noch nicht da gewesen, es ist keine Wand. Ich bin aber auch noch nicht da gewesen, ich weiß es nicht.
11:21
Undefined. Dann kann es eine Wand sein. Das Wall. Dann kann es der Startpunkt sein. Oder eine der vier Himmelsrichtungen, in die ich dann gehe. Left. Noch mal was in der Reihenfolge. Left, up, right, down.
11:44
Das wäre die Enum. Und wenn C sind, halb der Enum. Waypoint, Waypoint. Na ja, Waypoint sei es so. Das ist dann zumindest in vier von sieben Bedeutungen.
12:01
Undefined auch noch. Also in fast fünf von sieben Bedeutungen ist es ja wirklich so was. Punkt auf dem Weg. Da schreibe ich in das Array rein. Das hat also jetzt den Typ, Waypoint. Drinnen das Array.
12:21
Und jetzt kann man es glaube ich wirklich als Labyrinth bezeichnen. Wobei der englische Name wäre Maze. Aber lass uns das, ich lasse es jetzt bei Labyrinth. Maze wäre einfacher zu schreiben.
12:41
Schachbrett wäre acht mal acht. Schöner wäre, wenn man es so baut, dass diese Zahl acht nachher nicht einfach nur acht heißt. Sondern dass ich weiß, was sie ist. Und dass sie auch zentral zu ändern ist. Dass ich hier eine Konstante habe namens Width. Und hier eine Konstante namens Height.
13:00
Ganz in C Art müsste ich jetzt sagen, Width soll acht sein erst mal. Und Height soll auch acht sein. In C Art dann leider mit einem Define. In C++ könnte man das mit Const machen. An dieser Stelle braucht C einen Define. Blöderweise.
13:20
Width soll acht sein und Height soll acht sein. Dann kann ich das hier zentral ändern. Und vor allen Dingen weiß ich nachher im Code, was gemeint ist, wenn ich nur acht hinschreibe. Irgendwo im Code weiß ich nicht, wo kommt denn jetzt die Acht her? Ist acht, neun, minus eins? Oder ist es die Beinte, ist es die Höhe?
13:41
Nachher kann ich das tatsächlich im Code. Diese hier nehmen. So. Und jetzt muss ich hier dieses Labyrinth irgendwie füllen. Wie Sie sehen, das wäre am geschicktesten, wenn ich hier sofort anfange zu initialisieren.
14:06
Zeilen, nicht zu füllen. Erste Zeile. Eins, zwei, drei, vier, fünf, sechs, sieben, acht. Und die anderen Acht Zeilen.
14:22
Da muss natürlich jetzt noch was rein, keine Angst. So, da gehört jetzt was rein. Und Sie sehen, das ist ja ungeschickt, wenn ich da jetzt überall undefined wall, undefined wall, undefined wall reinschreibe. Dann wird das ja viel zu lang.
14:41
Ich mache mal das undefined zu einem U und das wall zu einem W. Damit das etwas kürzer wird. Und schreibe jetzt hier irgendwie rein, das soll eine Wand sein. Außen rum soll es ja alles Wand sein. Bis auf einen Ausgang vielleicht.
15:06
Und dann brauche ich hier noch ein paar andere Wände rein. Ich glaube, jetzt muss ich ein paar U's da reinschrauben, um überhaupt noch zu sehen, was hier los ist. U und W war nicht gut, das ist nicht sehr übersichtlich.
15:24
Ich hätte was nehmen sollen wie I und M.
15:42
Gucken, hier ist noch ein bisschen wenig los. Noch ein bisschen mehr rein. Noch einmal den. Ah, da kommen wir nun nicht mehr raus. Egal.
16:00
Und irgendwo soll ein Startpunkt sein. Ich gucke mal gerade, wenn ich den hier oben hinsetze. Ach, was weiß ich, wenn ich den da oben hinsetze. Man sieht, das ist auch ungeschickt. Start. Dann nennen wir den S und ich starte. Dann sagen wir, hier ist der Startpunkt. Damit hätte ich jetzt zumindest schon mal die Datenstruktur da stehen.
16:23
Und der nächste Job wäre jetzt tatsächlich so eine Funktion zu schreiben, die bei dem Startpunkt startet, sich den Nachbarn anguckt, die keine Wände sind. Also den und den. Und sich dann dort merkt, von wo sie gekommen ist, nämlich von da.
16:41
Und für diese Nachbarpunkte sich selbst wieder aufruft. Und zum Schluss wird diese Funktion nach dem Aufruf, vom Aufruf, vom Aufruf, vom Aufruf, irgendwo feststellen, dass sie da angelangt ist, hoffentlich. Und am Rand ist. Und wenn sie am Rand ist, heißt das, wir sind fertig geworden.
17:05
Wie müsste diese Funktion aussehen, wenn Sie die in C hinschreiben? Was nimmt die? Was gibt die zurück? Gegeben eine Position soll die Funktion gucken, was mit den vier Nachbarn ringsrum ist.
17:26
Welche sind Wände? Kann sie sofort vergessen. Welche sind schon behandelt worden? Können wir auch vergessen. Und bei den Unbehandelten soll sie sich merken, aus welcher Richtung wir die erreicht haben.
17:40
Und für die Unbehandelten soll sie sich selbst wieder aufrufen. Und einen weiteren Sinn hat diese Funktion, wenn die Funktion feststellt, dass sie am Rand ist, soll sie uns irgendwie mitteilen, dass das Labyrinth gelöst ist. Das sind die Jobs dieser Funktion. Wie muss sie von außen aussehen? Was nimmt sie und was liefert sie zurück?
18:08
Also, die Funktion kriegt einfach nur Spalte, Zeile, Koordinaten, um zu sagen, an dieser Stelle, guck mal bitte nach den Nachbarn.
18:21
Und das, was ich wissen muss, was rausgeht aus der Funktion, ist einfach nur, ob ich am Rand gewesen bin oder nicht. Die Frage ist nachher, dass wir mal gucken, auf welchem Niveau das passiert. Eigentlich könnte ich ja schon vorher sagen, bevor ich die Funktion aufrufe, ob ich am Rand gewesen bin.
18:44
Wenn ich hier bin und gucke mir die Nachbarn an, kann ich sofort sagen, wenn ich den Nachbarn erreicht habe, dass ich am Rand bin. Okay, also die Funktion sagt mir, oh, ich bin am Rande.
19:02
Beziehungsweise, das muss man dann nachher durchreichen, wenn ich die Funktion nachher hier aufrufe und diese Funktion sich die Nachbarn anguckt. Und diese sich die Nachbarn angucken und diese sich die Nachbarn angucken. Das ist so eine Kaskade von Funktionsaufrufen. Irgendeiner wird am Rande laden und dieser Funktionsaufruf sagt mir dann, oh, ich habe es geschafft, an den Rand zu kommen.
19:25
Das ist, was die Funktion nachher zurückliefert. Also schlicht und ergreifend Bool. Das wird zurückkommen. Wir brauchen also Standard Bool.
19:41
Dann checkt Neighbors, guckt die Nachbarn an. Auf Amerikanisch mit O. Und er kriegt eine X-Koordinate und eine Y-Koordinate, Spalte und Zeile. Diese Funktion rufe ich nachher auf.
20:03
Für meinen Startpunkt. Das ist das, was hier passiert. Bool. Ich nenne es hier mal Solved. Gelöst. Ist das Labyrinth gelöst? Ich rufe Check Neighbors auf. Für meinen Startpunkt.
20:20
Der war in der X-Koordinate 0, 1, 2, 3, 4, 5, 6. Und in der Y-Koordinate 1. Das ist vielleicht sogar noch etwas ungeschickt, dass ich diese Information über den Startpunkt an zwei Stellen habe.
20:40
Da habe ich die Information über den Startpunkt drin. Da habe ich es über den Startpunkt drin. Könnte man auch hübscher machen. Wenn die Informationen an zwei Stellen haben, ist die Gefahr zu groß, dass diese Information auseinander driftet. Jemand editiert das Programm und fragt den Startpunkt hier woanders rein. Editiert aber das nicht. Ups. Das ist immer ungeschickt.
21:02
Egal. So ist es jetzt erst mal richtig. Zumindest noch nicht ganz sicher für die Weiterverwendung, aber erst mal richtig. Das ist nachher alles, was ich machen will. Das ist alles in der Hauptfunktion. Ich sage, guck dir die Nachbarn von dem Startpunkt an. Und diese Funktion hier, guckt sich eben dann der Aufruf, guckt sich direkt die Nachbarn an.
21:27
Und beim Angucken der Nachbarn ruft er sich selbst ja wieder auf. Und von den Nachbarn die Funktion, die ruft sich auch wieder selbst auf. Und so weiter und so weiter. Irgendwann kommt sie dann zurück mit dem Wert wahr.
21:41
Und der muss dann durchgereicht werden. So sieht das nachher aus. Also ein scheinbar total simples Ding. In der Mathematik gibt man Rekursion. Und in der theoretischen Informatik. Wollen wir gleich noch mal gucken, ob das wirklich so effizient ist. Ich hoffe ich denke dran. Aber man kann diese Lösung relativ schnell hinschreiben. Der eine Punkt soll sich seine Nachbarn angucken.
22:03
Und wir schreiben diese Funktion, die Nachbarn angucken so, dass sie sich selbst immer wieder aufruft. Dann haben wir nachher den Effekt tatsächlich, dass alle Wege durchprobiert werden, bis wir einen Ausweg gefunden haben. So, die Funktion kriegt jetzt also eine Position.
22:25
Und soll sich die vier Nachbarn angucken, dieser Position. Wie gehen sie das durch? Die vier Nachbarn durchgehen. Also die erste Idee ist, sie schreiben es viermal hin. Sie gucken einmal nach oben.
22:40
Sie gucken einmal nach rechts. Sie gucken einmal nach unten. Sie gucken einmal nach links. Dann steht natürlich derselbe Code viermal. Was wieder nicht schön ist, aus dem gleichen Grund, wie ich eben gesagt habe. Irgendjemand wird etwas editieren und grantiert nur eine Kopie erwischen. Oder nicht alle Kopien zumindest erwischen.
23:03
Schon das ist nicht schön. Obendrein braucht man mehr Speicherplatz, was auch auf so einer kleinen Maschine ein Problem sein kann. Diese vier Möglichkeiten auszuprobieren. Was sehen Sie da noch an Chancen? Wie kann ich es verhindern, den Code viermal zu schreiben?
23:26
Also ich werde vermeiden wollen, hier für gehe einen Schritt nach oben zu schreiben. Sind wir da jetzt an der Wand? Sind wir da am Rand? Gucke die vier Nachbarn an. Und dann mache ich dasselbe nochmal für rechts. Sind wir an der Wand? Das ist ja ganz nervig, denselben Code viermal zu schreiben.
23:43
Ich würde probieren, das in einer Vorschleife zu machen. Eine Vorschleife, die sich die vier Himmelsrichtungen anguckt. Das ist vielleicht ein bisschen schwierig vorzustellen. Wie kann das funktionieren? Stellen Sie sich vor, Sie würden noch ein Array anlegen.
24:02
In dem Sie folgendes reinschreiben. Nehmen wir das mal int dx dy. Ein Array, in das Sie reinschreiben, wo denn die Nachbarn liegen. Ich bin mir noch nicht ganz sicher, ob ich es jetzt wirklich so machen will. Es könnte sein, dass es länger dauert, es so zu schreiben.
24:22
Das ist nachher schönerer Code, aber es kann sein, dass es länger dauert, es so zu schreiben. Ich will zumindest gerade erzählen, wie man es machen könnte. Ein Array, in dem ich ablege, wie ich denn die Nachbarn finden kann. Gehe einen nach rechts und bleibe auf demselben y. Gehe einen nach oben oder unten.
24:44
Bei uns y läuft ja bei uns nach unten. Und bleibe auf demselben x. Gehe einen nach links und bleibe auf demselben y. Und gehe mit y eins zurück. Das wäre ein Array, mit dem ich jetzt feststellen kann, wo die Nachbarn liegen.
25:02
Vier Nachbarn und das Array sagt mir, wo ich die Nachbarn finde. Rechts und so weiter, die Himmelsrichtungen durch. Und jetzt kann ich eine Vorschleife schreiben, dass dieses Array durchgeht. Und dann wüsst es, wo die Nachbarn sind. Das wäre die hübschere Lösung.
25:21
Aber ich glaube, das ist zu heftig für 35 Minuten. Man würde zum Schluss versuchen, es so zu machen, um alles zusammen zu haben. Um den Code nicht viermal zu schreiben. Ich glaube, jetzt auf die Schnell ist es leichter, den Code viermal zu schreiben. Es ist nicht schön, aber es ist leichter.
25:41
So, ich möchte mir also den Nachbarn da drüber angucken. Da drüber heißt, nach der C-Art solche Matrizen hier durchzunummerieren, da drüber heißt, y eins nach oben, y minus eins zu nehmen.
26:09
Ich muss also irgendwie y minus eins, irgendwas mit x und y minus eins veranstalten. Was veranstalte ich damit? Ich gucke mir an, was da denn steht.
26:25
Irgendein Vergleich wird es werden müssen. Und nun muss ich mal gucken, was denn denn Spannendes stehen könnte. Wo muss ich denn eigentlich mit einem großen L bezeichnen? Jetzt sollte ich mit einem kleinen L bezeichnen. Im Vorgriff auf nächstes Semester die Typen mit einem Großbuchstaben und die Variable mit einem kleinen Buchstaben.
26:45
Also ich gucke mir an, was denn oben steht. Das wollte ich mal hinschreiben überhaupt. Da wäre ein Kommentar mal nicht schlecht.
27:02
So, was steht auf dem Feld da drüber? Wenn es eine Wand ist, muss ich nicht gucken, ist das Thema durch. Wenn da schon eine Richtung drin steht, ist das Thema auch durch. Denn da war ich da ja schon.
27:22
Wenn das der Startpunkt ist, ist das Thema auch durch. Die einzige Frage ist, ist das noch nicht definiert? Das sollte ja dieser hier gewesen sein. U für undefined. Nur dann ist das spannend. Nur dann muss ich da weiter gucken, wenn der noch nicht definiert ist.
27:44
Wenn es keine Wand ist, wenn es nicht der Startpunkt ist, wenn ich da noch nicht gewesen bin. Dann gucke ich da rein. Was mache ich dann?
28:02
Der ist noch undefiniert. Und dann war ja eine der Geschichten, die passieren muss, dass sich die Funktion selbst wieder aufruft. Ich gehe da hin und die Funktion ruft sich selbst wieder auf. Rekursion. Check neighbors. An dieser Stelle, x, y, minus eins.
28:21
Er guckt sich von da aus dann die Nachbarn an. Ein rekursiver Aufruf. Aber das war nicht das einzige. Es gab noch andere Sachen, die passieren mussten. Die allerwichtigste Abfrage bin ich rausgekommen. Ich gehe einen Schritt nach oben. Das heißt, ich kann jetzt oben am Rand sein. Das prüfe ich doch erst mal.
28:40
Wenn ich oben am Rand bin, das heißt, wenn y gleich eins ist, ich habe über mir keine Wand, sondern nicht definiert, war noch nicht da, dann habe ich da einen Ausweg gefunden.
29:00
Das ist wahrscheinlich schwer zu verstehen. Ich schreibe mal y, minus eins, gleich null. Bedeutet dasselbe. Wenn dieser hier, den ich da gerade angeguckt habe, wenn der am Rand ist, dann habe ich ja gewonnen. Dann habe ich einen Ausweg gefunden. Was tue ich, wenn ich einen Ausweg gefunden habe?
29:20
Dann geben Sie Truz zurück in der Tat. Dann wissen wir, wir haben einen Ausweg. Das Erre ist dann ja soweit mit Richtungen gefüllt. Da muss man vielleicht einen noch nachtragen. Aber im Prinzip ist das Erre ja mit den Pfeilen gefüllt. Jetzt muss ich einfach nur noch sagen, okay, fertig. Das Ding ist gelöst. Und wenn nicht, naja gut, dann muss ich mir meine Nachbarn angucken.
29:43
Sie sehen mal wieder ein verstecktes Return. Na ja. Es gibt noch einen Job, der hier passieren muss. Ja, also ich muss den Pfeil noch reinmalen in den Nachbarn sozusagen. Der Nachbar steht ja derzeit noch auf undefined.
30:00
Und ich weiß jetzt, von wo ich komme. Ich komme ja von unten. Und wenn ich sage, ich möchte die Pfeile so malen, dass sie zum Startpunkt zeigen. Rein zeigen ist Labyrinth. Dann muss der also nach unten zeigen. Das kann ja nicht nur da passieren. Das kann ja auch genau so was hier passieren. Er zeigt zum Startpunkt hin.
30:22
Meinem Weg entgegen. Also hier muss ein Down stehen. Er zeigt runter. Das könnte es an der Stelle sogar schon gewesen sein. Ich muss nochmal gerade in mich gehen. Wir gucken uns den oberen Nachbarn an. Wenn der nicht definiert ist.
30:42
Jetzt keine Wand. Und wir waren noch nicht da. Er ist auch nicht der Startpunkt. Wenn der nicht definiert ist, merke ich mir, dass ich ihn von unten besucht habe. Ich gucke, ob ich am Rand bin. Wenn ich am Rand bin, habe ich gewonnen. Gebe bar zurück.
31:00
Obendrein gucke ich mir die Nachbarn an. Wenn der am Rand schon ist, ist das Ding ja gelöst. Dann muss ich nicht mehr noch die Nachbarn angucken. Das sieht so weit plausibel aus. Und jetzt kommt das Ganze auch für die 3 anderen Himmelsrichtungen. Das ist ärgerlich. Das ist das, was ich eben angedroht habe. Den selben Code nochmal zu schreiben.
31:20
Das wird man tunlichst vermeiden. Vielleicht haben wir gleich tatsächlich sogar noch Zeit, das hübsch zu machen. Copy und Paste. Sobald Sie bemerken, dass Sie Copy und Paste machen bei Programmcode innerhalb des selben Programms, sollten Sie sich fragen, ob das eine gute Idee ist. Normalerweise ist das keine gute Idee.
31:42
Oben. Dann machen wir hier rechts weiter. Reit wollte ich schon schreiben. Rechts. Unten. Links. So, jetzt rechts.
32:02
Wie gucke ich rechts? Genau. X um 1 erhöhen. Sie sehen, da käme das Reh ins Spiel, was ich eben aufgemalt habe. Ich würde X, Y um diese Plus, Minus 1 jeweils verändern.
32:20
X erhöhen. Und jetzt gucke ich natürlich, ob ich mit dem X plus 1 am Rand bin. Womit vergleiche ich X plus 1? 7 oder hübscher Breite minus 1. Wenn Sie hier 7 reinschreiben, fragt man sich, ist das 7, weil da 3 Bits gesetzt sind? Oder wenn Sie hier schreiben,
32:42
Wips minus 1, ist klar, wo es herkommt. Es ist nicht nur pflegeleichter, weil man diese Breite insgesamt ändern kann, sondern es ist sogar noch leichter zu lesen. Obendrein. Und hier unten natürlich wieder von der Position die Nachbarn prüfen.
33:01
Oh, und hier. Ups. Man kann sogar mit Copy und Paste Fehler reinbauen, ohne lange zu warten. Dann natürlich nicht down. Ich bin nach rechts gegangen. Ich muss den Pfeil also nach links malen.
33:21
Mal sehen. Nach unten. Hier gehe ich also Y plus 1. Das ist jetzt einfacher. Das ist überall Y plus 1, Y plus 1. Ich gehe nach unten. Hier muss es dann also ab sein. Hier steht dann auch Y plus 1. Und wie eben vergleiche ich natürlich analog mit height.
33:41
Minus 1. Und dann haben wir noch nach links. Das heißt also X minus 1. Und hier X minus 1. Und, ohje. Ich gucke nach links. Das heißt ich mache den Verweis nach rechts.
34:04
Und hier habe ich X minus 1. Jetzt wirklich gleich 0. Ich bin am linken Rand. Hier X minus 1, Y. Wenn es das schon gewesen wäre, wäre ich überrascht. Aber manchmal ist man wirklich überrascht.
34:21
Müssen wir uns jetzt die Aktion angucken. Mal sehen was da jetzt passiert. Zwei Warnings machen mich gerade nicht glücklich. Oh, und 12 Errors machen mich gar nicht glücklich. Okay, wir haben so ein paar Fehlerchen zu bereinigen. Wann habe ich da...
34:46
Oh, wie habe ich denn das geschafft? Wie habe ich denn das geschafft? Wieso habe ich da Semikolons hintergesetzt, bitte? Sehr peinlich. In C++ und den anderen etwas moderneren Sprachen würden sie schreiben
35:01
Const int width gleich 8 Semikolons. Ich schaue mal sogar dazu. Da kein Semikolon. Bei dem Define kommt kein Semikolon. Das mache ich regelmäßig falsch.
35:24
Ich mache erstmal noch einen Make hier. Jetzt nur die Lage. Oh, das war schon alles bis auf eine... Oh, ja, Sie sehen. Missing return statement. Ich gebe immer nur
35:43
true zurück hier. Das ist spannend. Das ist spannend. Und hier bei checkNeighbors ignoriere ich was zurückkommt. checkNeighbors könnte hier ja sagen ich habe einen Ausweg gefunden, aber ich würde es nicht merken.
36:00
Oder hier, der könnte sagen ich habe einen Ausweg gefunden und ich würde es nicht merken. Und hier, da ist noch etwas faul. Was ist mit den Rückgabewerten? Was machen Sie mit den Rückgabewerten, die da kommen? Genau, der erste Schritt
36:21
wäre erstmal hier ganz unten drunter ein return false zu schreiben. Wenn alles nicht gefruchtet hat, dann haben wir wohl Pech gehabt. Und geben mein false zurück. Dann habe ich aber immer noch ignoriert, dass zwischendurch einer dieser Aufrufe
36:41
sagen könnte, hallo, ich habe einen Ausweg gefunden. Diese Funktion hier könnte doch sagen, durch einen Aufruf, eines dass sie einen Ausweg gefunden hat. Und dann sollte die hier auch wieder sagen es gibt einen Ausweg. Derzeit ignoriere ich das aber.
37:00
Sie können hier nicht, leider nicht direkt return checkNeighbors reinschrauben, denn dann würde es ja sofort beendet werden. Sobald ich hier reingehe in das if, wäre hier Ende des Funktionsaufrufes insgesamt, weil hier ein return steht. Es würde enden, wenn es wahr ist und wenn es falsch ist. Es soll hier aber nur enden, wenn checkNeighbors
37:21
wahr ist. Das wäre noch nicht 100%ig das, was ich will. Sie müssen prüfen, was hier zurückkommt. Ich schreibe das mal in Lang hin. bool nennen wir es R, gleich checkNeighbors. Und wenn das wahr ist, if R,
37:41
dann können wir sagen, wunderschön, wir haben gewonnen. Das wäre die Langfassung. Wenn dieser Aufruf, der ja selbst wieder eine Kaskade von Aufrufen startet, wenn der Aufruf wahr zurück liefert, dann gibt es einen Ausweg und ich liefere
38:02
wahr zurück. Das ist die Langfassung. Ehrlich gesagt, ich würde es fast so stehen lassen. Die meisten Programme, die man so im wahren Leben sieht, in denen ist das Kürzer geschrieben. Wie können Sie das kürzer schreiben? Ja, in der Tat,
38:24
das ist haarsträubend. Wie gesagt, ich würde es allein schon aus didaktischen Gründen lieber so lassen, aber um sie abzuhärten, was man im wahren Leben sieht, dann die Variante fürs wahre Leben sehe typischerweise so aus.
38:41
Ein Break würde nicht helfen, weil ein Break ja eine Schleife ist aber keine Schleife. Ohne Schleife kein Break. Beziehungsweise Break gibt es auch im Switch, aber einen Switch haben wir hier erst recht nicht. Insofern hilft das nichts.
39:01
So hätten wir das. Jetzt ruft er die Funktion auf, die sich die Nachbarn anguckt und wenn die Funktion wahr zurückliefert, ist hier Ende. Wenn die Funktion falsch zurückliefert, ist da nicht Ende. Das ist insofern unschön, als dass hier dieses Check Neighbors so
39:20
aussieht, als ob es eine Bedingung ist. So ist 7 kleiner gleich 8 irgendeine harmlose Bedingung, aber es ist keine harmlose Bedingung, hier wird ja richtig Arbeit verrichtet. Also wenn hier einfach nur steht, 2013 ein Schaltjahr, ja oder nein, so ein Aufruf ohne Nebeneffekte,
39:41
Side-Effects, ohne Nebeneffekte, als Bedingung. Das ist das, was man erwarten würde, eine Bedingung, in der etwas getestet wird. Ist das so oder nicht? Aber hier dieses Check Neighbors hat ja ganz viele Effekte nebenbei, da guckt sich die Nachbarn an und macht alles Mögliche. Das ist gefährlich, das so zu schreiben. Trotzdem werden die meisten Leute es so schreiben.
40:03
Und wenn Sie sich jetzt das angucken, dann werden die meisten Leute es sogar noch kürzer schreiben. Ein oder, wunderbar. Also die können Sie mit einem oder hintereinander setzen.
40:24
Und hier ist jetzt auch mal wieder dieses doppelte oder extrem wichtig. Wenn der erste war, guckt er sich den nicht an, bei diesem doppelten oder, sondern sagt sofort Feierabend. Das ist auch gut, wenn hier nämlich null drin steht,
40:40
könnte ich auf den Gedanken kommen, bei minus eins zu gucken. Also diese Funktion möchte ich lieber vielleicht gar nicht mit null aufrufen. So, das können wir bei den anderen hier auch gerade noch bauen. Also hier setze ich den noch mit da rein.
41:07
Das selbe hier. Wird es ja halbwegs übersichtlich. Viermal das praktisch dasselbe, aber jetzt wird es halbwegs übersichtlich.
41:26
Dann sollten jetzt zumindest alle syntaktischen Probleme erledigt sein. Die Frage ist, ob es dann auch funktioniert. Das ist die größere Frage. Das ist ja doch schon eine ziemlich komplizierte Geschichte hier. Mal sehen, ich sag mal nochmal make. Ob der Compiler zufrieden ist.
41:43
Der Compiler ist zufrieden. Die Frage ist, ob es geht. Mal sehen.
42:00
Statics. Unser Labyrinth ist ja Static. Sehr schön. Ich hätte mir für die Enumeration doch überlegen sollen, welche Werte man da geschickterweise nimmt, dass hier auch was ordentliches zu sehen ist. So muss es jetzt aufklappen, denn es ist nicht gerade sehr übersichtlich. Check Neighbors. Ich mache es jetzt mal
42:21
ganz dreist. Ein Aufruf hier. Nächste Zeile. Und ich gucke mir Solved an. Ob jetzt zumindest auch Solved. Immerhin, Sie sehen, das war keine Endlosschleife. Er hat schon mal abgebrochen. Wir sind tatsächlich fertig geworden mit diesem Ding. View Locals. Er kriegt tatsächlich
42:41
daraus Solved 1. Soweit so gut, aber das heißt natürlich noch nicht, dass das Programm jetzt funktioniert hat. Wir gucken uns mal vorsichtig an, was in dem Ray drin steht. View Statics. In der ersten
43:01
Zeile hatte mir netterweise nichts überschrieben. Da stand ja auch Wand überall drin. Das wäre jetzt ärgerlich, wenn hier was anders stehen würde. Hier sind ganz viele immer noch nicht beachtet worden. Der Startpunkt steht da drinnen.
43:23
Okay. Auch da ist keiner besucht worden. Das sieht am ehrlich komisch aus. Ist nirgendwo einer besucht worden? Oh, doch! Da ist doch einer besucht worden. Down and Right. Also
43:43
in der Zeile Nummer 5 fängt er an mit Down und Right. Das sieht sehr komisch aus, würde ich mal sagen. Mal gerade gucken, wie das hier oben war. In der Zeile Nummer 5 0, 1, 2, 3,
44:00
4, 5 fängt er an mit Down. Da soll ja nicht Down stehen. Da soll Right stehen und da soll Down stehen. Das ist lustigerweise genau falsch herum. Also er kommt an der Stelle raus. Das ist ja schon mal gut, aber da steht das Falsche drinnen. Da ist noch was faul. Hier soll nicht Down stehen, sondern da soll Right stehen und hier soll Down stehen.
44:22
Mal sehen, wie es hier weiter geht. Was er in die Nummer ne, die haben wir gerade nicht. Was er in die Nummer 6 reingeschrieben hat. Die hat er gar nicht besucht. Oh, oh. Sie sehen, da ist noch ganz was faul. Also wir kommen lustigerweise raus, aber aus falschem Grund,
44:41
sozusagen. Da ist noch ein bisschen Debugging angesagt. Da sind wir wieder richtig. Einmal noch mal lesen hier. Das ist so der erste Schritt. Wahrscheinlich ist irgendwas ganz blödes erstmal.
45:02
Ich gehe eine Zeile rauf. Wenn da nichts steht, merke ich mir da, ich bin von unten gekommen und gucke mir die Nachbarn an. Oder ob ich schon am Rande bin. Ja. Ich gehe eine nach rechts. Dann bin ich von links
45:20
gekommen. Wenn ich am Rande bin, sage ich, das ist okay. Oder wenn die Nachbarn sagen, das ist okay. Dann gehe ich eine nach unten. Dann muss ich sagen, ich muss rauf gehen, um wieder zurückzulaufen.
45:44
Das hatten wir eben auch. Und x-1. Ich gehe nach links. Also muss ich hier wieder zurück nach rechts. So weit sieht das richtig aus. Es muss noch irgendeinen ganz dummen Fehler geben, der sich so nicht offenbart. Wir gucken mal in einzelnen Schritten durch.
46:07
So. In einzelnen Schritten. Also ich gehe hier rein. Step into. Der erste Schritt. Ich sollte nochmal die Locals haben. Ist das richtig?
46:22
6 und 1. Und was steht in dem Array bei 6 und 1? x ist gleich 6, y ist gleich 1. Das ist doch richtig. Das ist ja mein y. Das ist ja blöderweise... Aha. Jetzt habe ich es auch verstanden.
46:42
Sehen Sie es? Das ist total finster. Ich sage, mein Start ist bei x gleich 6, y gleich 1. x ist gleich 6, y ist gleich 1. Da steht jetzt aber nicht Start drin.
47:02
Bei x gleich 6, y gleich 1. Weil ich es ein bisschen blöd finde. Warum steht hier jetzt nicht Start? Bei x gleich 6, y gleich 1. Was habe ich falsch gedacht? Wir müssen uns nochmal die Nummerierung angucken. Das ist aber echt auch immer ein Drama in C. Nehmen wir mal diese Zelle. Wie rufen Sie die in C
47:21
auf? Diese Zelle hier. Jupp. Erst die Zeile und dann die Spalte. Andersrum, als man es denn so meinen mag. Das ist 1, 2. Das ist gemein. Wenn Sie mit dem hinteren durchlaufen, dann stehen die alle
47:40
schön im Speicher hintereinander. Und der erste, der vordere, der wird springen im Speicher. 1, 2 wird es sein. In der ersten Zeile, daraus der zweite. Das ist genau andersrum, als man das früh morgens gemeinen möchte. Das heißt, ich habe überall x und y vertauscht.
48:00
Also hier muss das heißen. Y minus 1, x. Das kostet natürlich echt Überwindung. Man könnte auch irgendwo eine Randnotiz machen und sagen, Leute, das ist irgendwie total ungeschickt, dass C das so rummacht. Wir sagen mal für heute, es soll andersrum sein. Das ist ja nur eine Konvention, das so zu interpretieren.
48:22
Aber jetzt habe ich eben so angefangen und dann muss ich es auch konsequent machen, dass die beiden eben andersrum stehen. Das ist auch bei Bildverarbeitung. Da haben wir ständig mit solchen Arrays zu tun. Das sind dann Bilder, ein mittleres Drama, dass man daran denken muss,
48:42
dass im Zweifelsfall diese Koordinaten andersrum stehen. Die C-Arrays sind eben so gestrickt, dass erst die Nummer der Zeile steht und dann die Nummer der Spalte steht. Hier müssen Sie die Plätze nicht vertauschen. Das soll ja ausdrücklich x und
49:00
y sein. Das ist ja kein Array. Hier übergebe ich das x, da das y. Die kommen dann auch wirklich in x und y an. Das Problem ist bei dem Array. Wenn ich das Array so aufmale, wie man C-Arrays normalerweise eben aufmalt, so, in dieser Form, dann ist der erste Eintrag hier die Nummer der Zeile und der zweite Eintrag
49:20
die Nummer der Spalte. Also sobald ich das so aufmale, wie es da steht, habe ich ein Problem, dass dies hier die y-Koordinate ist und das die x-Koordinate. Mal sehen. Also wir hatten lustigerweise eben das wichtigere Soldat, aber aus dem falschen Grund, der falschen Wert gestartet. Das sind, mal sehen,
49:47
Locals und die Statics. So die Locals, einen Schritt weiter. Er sagt, er habe es gelöst, aber das kann ja wieder aus dem falschen Grund sein. Wir gucken uns an, was denn da zwischendurch so
50:02
passiert ist. In der Zeile 5. Ach so, und hier soll ich noch raufscrollen zu dem So. Ich bin bei hier rausgekommen. Und da hat er sich gemerkt, er muss, wenn er jetzt auf dem Weg rein ist, nach rechts gehen. Okay, dann bin ich da.
50:21
Hier hat er sich gemerkt, auf dem Weg rein muss er nach oben gehen. Und dann bin ich bei 4,1. Bei 4,1 hat er sich gemerkt, er muss nach rechts gehen, auf dem Weg rein. Und hier hat er sich gemerkt, das ist wirklich zigzag, er muss runtergehen auf dem Weg rein.
50:40
Und dann bin ich jetzt bei der Nummer 5 wieder. 5,2 und muss nach rechts gehen, auf dem Weg rein. Dann bin ich bei 5,3. Da muss ich raufgehen, das ist total zigzag, aber er hat einen Weg gefunden, anscheinend. So, nochmal der Weg in den Startpunkt rein.
51:00
Das Ende des Ganzen ist ja ziemlich zigzag. Das war der Startpunkt. Wie kommen wir rein? In den Startpunkt. Wir könnten später von links nach rechts oder von unten nach oben gehen. Der links davon, absurderweise, sieht man, das ist ja ganz lustig,
51:20
da scheinen wir erst runtergehen zu müssen. An dem Ding. Was macht er da drunter? die Zeile Nummer 2, die Zeile Nummer 2, an dieser Stelle. Okay, da müssen wir nach rechts gehen.
51:40
Und was sagt er hier? Da müssen wir nach oben gehen. Also, es ist ein total verwickelter Weg ins Ziel. Was daran liegt, dass ja immer diese vier Möglichkeiten, eine nach der anderen, durchprobiert werden. Ich gehe erst nach oben und dann dieser hier, wird auch wieder erst nach oben gehen. Und wenn der jemand wieder aufruft, wird der auch wieder nach oben gehen. So weiter. Das führt dazu, dass das nachher ganz verwickelt wird.
52:03
Letzte Kommentare, Wenn ich in einer Sackgasse lande, hier keine Chance habe, oben nicht, rechts nichts, unten nichts, links nichts. Wenn ich in einer Sackgasse lande, muss ich ja sagen, okay, Pech gehabt, ich habe keinen Ausweg gefunden. An der
52:20
Stelle, zum Beispiel, brauche ich das False.