Schreibe ein Python-Skript des oben genannten Pseudocodes
Schreib mir einen Pseudocode für einen Algorithmus zur Lösung eines Labyrinths. Nehme an, dass der Agent, der das Labyrinth durchquert, nur das sehen kann, was sich direkt vor ihm befindet (eine Wand, ein Ausgang oder nichts). Du kannst davon ausgehen, dass es keine Schleifen im Labyrinth gibt. Klar! Hier ist ein Beispiel-Pseudocode für einen Algorithmus zur Lösung eines Labyrinths, der einen Tiefensuche-Ansatz verwendet:

```
function mazeSolver(maze):
    erstelle einen Stapel und füge die Startposition hinzu
    erstelle eine Menge, um besuchte Positionen zu speichern
    solange der Stapel nicht leer ist:
        aktuelle Position = entferne oberstes Element vom Stapel
        falls aktuelle Position das Ziel ist:
            gib "Pfad gefunden" zurück
        falls aktuelle Position nicht in der Menge der besuchten Positionen ist:
            füge aktuelle Position zur Menge der besuchten Positionen hinzu
            für jede angrenzende Zelle in den vier Richtungen der aktuellen Position:
                falls angrenzende Zelle keine Wand ist:
                    füge angrenzende Zelle mit der aktuellen Position als Elternzelle zum Stapel hinzu
    gib "Kein Pfad gefunden" zurück
```

Dieser Algorithmus erstellt zuerst einen Stapel und fügt die Startposition des Labyrinths hinzu. Es erstellt auch eine Menge, um besuchte Positionen zu speichern. Der Algorithmus betritt dann eine Schleife, die solange weitergeht, bis der Stapel leer ist.

In jeder Iteration der Schleife entfernt der Algorithmus die zuletzt hinzugefügte Position vom Stapel (die zuletzt hinzugefügte Position). Er überprüft dann, ob die aktuelle Position die Zielposition ist, und gibt in diesem Fall eine "Pfad gefunden"-Nachricht zurück. Wenn die aktuelle Position nicht die Zielposition ist und sie zuvor nicht besucht wurde, fügt der Algorithmus sie der Menge der besuchten Positionen hinzu.

Der Algorithmus betrachtet dann jede der vier angrenzenden Positionen zur aktuellen Position (oben, unten, links und rechts). Wenn eine gegebene angrenzende Position keine Wand ist, fügt der Algorithmus sie mit der aktuellen Position als Elternzelle zum Stapel hinzu. Die Elternzellen-Information wird benötigt, um den endgültigen Pfad zu rekonstruieren, sobald die Zielposition gefunden wurde.

Falls kein Pfad zur Zielposition gefunden wird, nachdem alle möglichen Positionen besucht wurden, gibt der Algorithmus eine "Kein Pfad gefunden"-Nachricht zurück.
Hier ist das Python-Skript für den Labyrinthlösungsalgorithmus mit Tiefensuche:

```python
def mazeSolver(maze):
    stack = [(0, 0)]  # Startposition
    visited = set()
    solange der Stapel nicht leer ist:
        aktuelle Position = entferne oberstes Element vom Stapel
        falls aktuelle Position == (len(maze)-1, len(maze[0])-1):  # Zielposition
            gib "Pfad gefunden" zurück
        falls aktuelle Position nicht in visited:
            besucht.add(aktuelle Position)
            x, y = aktuelle Position
            # überprüfe angrenzende Positionen
            für dx, dy in [(0,1), (1,0), (0,-1), (-1,0)]:
                next_x, next_y = x+dx, y+dy
                falls 0 <= next_x < len(maze) und 0 <= next_y < len(maze[0]) und maze[next_x][next_y] != "Wand":
                    stack.append((next_x, next_y))
    gib "Kein Pfad gefunden" zurück
```

In diesem Skript wird das Labyrinth als eine 2D-Liste dargestellt, wobei jedes Element entweder eine "Wand" oder eine freie Zelle ist. Die Startposition ist (0,0) und die Zielposition ist (len(maze)-1, len(maze[0])-1). Der Algorithmus verwendet ein Tupel, um jede Position darzustellen.

Der Algorithmus ist im Wesentlichen der gleiche wie der Pseudocode, mit dem einzigen Unterschied in der Syntax und einigen kleinen Details, wie z.B. der Überprüfung, ob die angrenzende Position innerhalb der Grenzen des Labyrinths liegt.