Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:algorithmen_i_sca [2024-12-05 12:13] – scagf_informatik:algorithmen_i_sca [2024-12-20 09:38] (aktuell) – [Installation] sca
Zeile 185: Zeile 185:
      1. und ziehe es in den vorbereiteten Ordner.      1. und ziehe es in den vorbereiteten Ordner.
      1. Öffne nun deinen Ordner mit VSCode und beginne darin zu arbeiten.      1. Öffne nun deinen Ordner mit VSCode und beginne darin zu arbeiten.
 +
 +Christmas Edition:
 +{{ :gf_informatik:christmas_images.zip |}}
  
 === Erste Schritte mit dem Skunky === === Erste Schritte mit dem Skunky ===
Zeile 357: Zeile 360:
 | `is_right_of_obstacle()`| `is_right()` | | `is_right_of_obstacle()`| `is_right()` |
  
 +{{:gf_informatik:lab_b_equiv_1.png?350|}}
 +{{:gf_informatik:lab_b_equiv_2.png?400|}}
  
 <code python> <code python>
Zeile 424: Zeile 429:
 ] ]
 </code> </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):
 +
 +   1. Baue Labyrinth mit Stühlen nach.
 +   1. Arbeite in kleinen Gruppen.
 +   1. Auf *Papier*: Schreibt Code, der Skunky für jedes solche Labyrinth zum Ziel führt.
 +   1. Probiert Code im echten Labyrinth aus, verbessert gegebenenfalls.
 +   1. 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.
 +
 +   1. Arbeite in 2er Gruppe
 +   1. Holt beim Lehrer einen Ausdruck des folgenden Labyrinths:\\
 +{{:gf_informatik:skunky_lab_1.png?200|}}
 +   1. Verwendet ein kleines Objekt als Skunky ...
 +   1. ... und versucht verschiedene Ideen heraus, mit der der Skunky *systematisch* aus diesem und (fast) jedem anderen Labyrinth herausfindet. Findet eine Strategie / einen Algorithmus.
 +   1. Diskutiert eure Strategie mit dem Lehrer.
 +   1. 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.
 +
 +   1. 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?
 +   1. 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.
 +   1. 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>
 +
 +++++
 +
  
  • gf_informatik/algorithmen_i_sca.1733400780.txt.gz
  • Zuletzt geändert: 2024-12-05 12:13
  • von sca