Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- gf_informatik:algorithmen_i_sca [2024-12-05 09:58] – [Aufgabe B6] sca
+++ gf_informatik:algorithmen_i_sca [2024-12-20 09:38] (aktuell) – [Installation] sca
@@ Zeile 185: / Zeile 185: @@
 . und ziehe es in den vorbereiteten Ordner.
 . Öffne nun deinen Ordner mit VSCode und beginne darin zu arbeiten.
+Christmas Edition:
+{{ :gf_informatik:christmas_images.zip |}}
 === Erste Schritte mit dem Skunky ===
@@ Zeile 346: / Zeile 349: @@
 === Aufgabe B7 ===
-Schreibe *von Hand* einen Code, der den Skunky zum Ziel bringt. Der gleiche Code soll für die beiden Labyrinthe unten sowie alle äquivalenten funktionieren.
+Schreibe *von Hand* einen Code, der den Skunky zum Ziel bringt. Der gleiche Code soll für die beiden Labyrinthe unten sowie alle äquivalenten funktionieren. Programmiere den Code dann am Schluss am Computer.
+Verwende dazu die folgenden Funktionen. Auf Papier dürfen auch die folgenden Abkürzungen verwendet werden:
+^ Funktion ^ Abkürzung ^
+| `move()`| `m()` |
+| `left()`| `l()` |
+| `right()`| `r()` |
+| `is_in_front_of_obstacle()`| `is_in_front()` |
+| `is_left_of_obstacle()`| `is_left()` |
+| `is_right_of_obstacle()`| `is_right()` |
+{{:gf_informatik:lab_b_equiv_1.png?350|}}
+{{:gf_informatik:lab_b_equiv_2.png?400|}}
+<code python>
+lab_1 = [
+    "tttttttttttttt",
+    "tttt       p t",
+    "tttt ttttttfft",
+    "tttt t ttttttt",
+    "tf   t      gt",
+    "tttt ffff tfft",
+    "tttt ffff t  t",
+    "tttt ffff tt t",
+    "tttt      t  t",
+    "tttttttttttttt",
+]
+lab_2 = [
+    "tttttttttttttttttt",
+    "tttttt         p t",
+    "tttttt ttttttttfft",
+    "tttttt tttfff ttft",
+    "tttttt tttfff   gt",
+    "f      tttttt tfft",
+    "tttttt ffffff t ft",
+    "tttttt ffffff t ft",
+    "tttttt ffffff t ft",
+    "tttttt ffffff t  t",
+    "tttttt ffffff tt t",
+    "tttttt        t  t",
+    "tttttttttttttttttt",
+]
+</code>
 === Aufgabe B8 ===
-**Optional:**
+**Optional:** Wie die letzte Aufgabe, einfach für die folgenden Labyrinthe:
-Schreibe *von Hand* einen Code, der den Skunky zum Ziel bringt. Der gleiche Code soll für die beiden Labyrinthe unten sowie alle äquivalenten funktionieren.
+<code python>
 lab_1 = [
     "ttttttttttttttttttt",
     "tgt  t    t       t",
     "t t    t  t  t f  t",
-    "t t  t t  t  t  fft",
+    "t t  t tf t  t  fft",
-    "t t  t t tttttt   t",
+    "t t ft   tttttt   t",
-    "t t  t t t        t",
+    "t t f  t t        t",
-    "t t  t t t  ttt   t",
+    "t t ft t t  ttt   t",
-    "t t  t t t  t     t",
+    "t t  t tft  t     t",
     "t t  t tft  t ttttt",
     "t    t      t   p t",
@@ Zeile 370: / Zeile 415: @@
     "tttttttttttttttttttttt",
     "tgt  t    t       ff t",
-    "t t    t  t   t f    t",
+    "t t    tfft   t f    t",
     "t t  t t  t   t  fffft",
-    "t t  t t ttttttt     t",
+    "t t  t   ttttttt     t",
-    "t t    t t           t",
+    "t t  t t t           t",
     "t t  t t t   ttttttt t",
-    "t t  t t t   ttttttt t",
+    "t t ft t t   ttttttt t",
-    "t t  t t t   ttttttt t",
+    "t t ft t t   ttttttt t",
-    "t t  t t t   t       t",
+    "t t f  t t   t       t",
-    "t t  t t t   t fffff t",
+    "t t ft t t   t fffff t",
-    "t t  t tft   t ttttttt",
+    "t t ft tft   t ttttttt",
     "t    t       t      pt",
     "tttttttttttttttttttttt",
 ]
+</code>
+=== Aufgabe B9 ===
+Der Code unten (muss aufklappen) erzeugt ein zufälliges Labyrinth, in welchem genau ein Weg von links nach rechts zum Ziel führt. Der Funktion in der Zeile `lab = create_random_world_with_path(20,5,25)` kann man drei Werte übergeben:
+   * Wert 1 (hier 20): Anzahl Zellen in $x-$Richtung
+   * Wert 2 (hier 5): Anzahl Zellen in $y-$Richtung
+   * Wert 3 (hier 25): Wert zwischen 1 und 100, je kleiner, desto mehr Abbiegungen im Weg
+Auftrag (wenn räumlich möglich):
+. Baue Labyrinth mit Stühlen nach.
+. Arbeite in kleinen Gruppen.
+. Auf *Papier*: Schreibt Code, der Skunky für jedes solche Labyrinth zum Ziel führt.
+. Probiert Code im echten Labyrinth aus, verbessert gegebenenfalls.
+. Schreibe Code in Python. Jede(r) schreibt *eigenen* Code.
+++++Code|
+<code python>
+### IGNORE CODE FROME HERE ...
+from skunky import Skunky
+import random
+from itertools import groupby
+def create_random_world_with_path(n_x_tot=20,n_y_tot=5,probability_same=20):
+    n_y = n_y_tot - 2; n_x = n_x_tot - 2 # remove frame
+    # create list describing path
+    path = [random.randint(0,n_y-1)]; x = 0
+    while True:
+        if x > n_x: break
+        # first two entries must be identical
+        if len(path) < 2: path.append(path[-1]); x += 1; continue
+        # avoid changing lane if not at least 3 identical ones
+        if len(set(path[-3:])) > 1: path.append(path[-1]); x += 1; continue
+        # check if switch lane or not
+        p = random.randint(1,100)
+        if p < probability_same: path.append(path[-1]); x += 1
+        else:
+            if path[-1] == 0: path.append(1)
+            elif path[-1] == n_y - 1: path.append(n_y-2)
+            else: path.append(random.choice([path[-1]-1,path[-1]+1]))
+    # convert path list into world map
+    world = [['t'] for i in range(n_y)]
+    x = 0
+    for i,y in enumerate(path):
+        world[y][x] = ' '
+        if y == path[i-1] and i > 0:
+            for i in range(n_y): world[i].append('t')
+            x += 1; world[y][x] = ' '
+    world[path[0]][0] = 'p'; world[path[-1]][len(world[0])-1] = 'g'
+    # add frame around world and convert into string list
+    for w in world: w.insert(0,'t'), w.append('t')
+    world = [''.join(w) for w in world]
+    world.insert(0,'t' * len(world[0])); world.append('t' * len(world[0]))
+    return world
+### IGNORE CODE UNTIL HERE. BELOW WRITE YOUR OWN CODE
+lab = create_random_world_with_path(20,5,25)
+fritz = Skunky(world_map=lab,delay_time=200,cell_size=30)
+# here add your code
+fritz.show_indefinitely()
+</code>
+++++
+=== Aufgabe B10 ===
+Stelle dir vor, dass eines Tages dein Überleben davon abhängt, ob du aus einem Labyrinth herausfindest oder nicht. Wie gehst du vor? Es gibt einen einfachen Algorithmus, mit dem man aus fast jedem Labyrinth herausfindet. Das Ziel dieser Aufgabe ist, diesen Algorithmus selbst herauszufinden und dann für den Skunky zu implementieren.
+. Arbeite in 2er Gruppe
+. Holt beim Lehrer einen Ausdruck des folgenden Labyrinths:\\
+{{:gf_informatik:skunky_lab_1.png?200|}}
+. Verwendet ein kleines Objekt als Skunky ...
+. ... und versucht verschiedene Ideen heraus, mit der der Skunky *systematisch* aus diesem und (fast) jedem anderen Labyrinth herausfindet. Findet eine Strategie / einen Algorithmus.
+. Diskutiert eure Strategie mit dem Lehrer.
+. Sobald ihr das OK vom Lehrer habt: Implementiert euren Algorithmus für den Skunky und probiert diesen für verschiedene Labyrinthe aus.
+=== Optional: Aufgabe B11 ===
+Ziemlich anspruchsvoll. Es hilft auch, wenn man schon weitere Programmierkonzepte wie Listen kennt.
+. Mit dem Algorithmus der letzten Aufgabe findet man aus fast allen Labyrinthen heraus. Es gibt aber solche, für die dieser Algorithmus nicht funktioniert. Für welche?
+. Ein Beispiel ist das Labyrinth unten. Hole beim Lehrer einen Ausdruck und versuche, einen Algorithmus zu finden, der den Skunky aus diesem (und jedem anderen Labyrinth) herausbringt.
+. Implementiere den Algorithmus als Code.
+{{:gf_informatik:skunky_lab_floating_walls.png?200|}}
+++++Code Labyrinth|
+<code python>
+lab = [
+    "ttttttttttttttt",
+    "t             t",
+    "t t ttttt ttt t",
+    "t t t   tttgt t",
+    "t t t t   t t t",
+    "t t   ttt   t t",
+    "t ttttt  tttt t",
+    "t             t",
+    "tttttttt tttttt",
+    "t      t   t  t",
+    "tf ttt ttt t tt",
+    "t  tpt   t    t",
+    "tf t ttt t  t t",
+    "t  t      tt  t",
+    "tf tttttt tt tt",
+    "tf            t",
+    "ttttttttttttttt",
+]
+</code>
+++++