lehrkraefte:blc:informatik:glf25:labyrinthe:lib [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Klassen Laby und Zelle ======

===== Klassen =====
Klassen sind Teil eines verbreiteten und sehr nützlichen Programmierkonzepts.

Für unsere Zwecke sind Klassen eine Zusammenfassung von Daten (Variablen, genannt Attribute) und Funktionen (gennant Methoden), die mit diesen Attributen interagieren.

Diese Einheit erlaubt es sicherzustellen, dass die Daten immer konsistent sind. 

Z.B. im Falle unseres Labyrinths stellen die Klassen sicher, dass wenn die Mauer von einer Zelle zur anderen geöffnet wird, dass das auch automatisch in umgekehrter Richtung geschieht.

===== Einrichten =====
  * Legen Sie einen neuen Ordner an (z.B. mit dem Namen labyrinth), wo dann alle diesbezüglichen Programme gespeichert werden.
  * Speichern Sie die beiden folgenden Dateien im neuen Ordner (**Rechtslick -> Ziel speichern unter** oder so ähnlich, nicht öffnen und kopieren bitte!)

{{lehrkraefte:blc:informatik:glf25:labyrinthe:laby.py}} {{lehrkraefte:blc:informatik:glf25:labyrinthe:zelle.py}}

===== Hello Laby =====
  * Mit VS-Code, öffnen Sie den neuen Ordner labyrinth mit File -> Open Folder. (Das ist der Ordner, der die beiden Dateien ''laby.py'' und ''zelle.py'' enthält).
  * Legen Sie dort eine neue Datei ''hello.py'' an.

<code python hello.py>
from laby import Laby
from zelle import Zelle

lab = Laby(5,3)
print(lab)
</code>

Die Zeilen mit ''import'' und die Initialisierung des Labyrinths ''lab = Laby(5,3)'' sind in den folgenen Codes der Übersichtlichkeit halber weggelassen.
==== Zellen markieren ====
<code python>
lab[2,1].mark = 'Z'
print(lab)
print(f"Zelle (2,1) ist mit {lab[2,1].mark} markiert")
</code>

==== Mauern öffnen/schliessen ====
Der erste Parameter gibt die Richtung an, in welche die Mauer geöffnet werden soll (0 rechts, 1 unten, 2 links, 3 oben).
<code python>
lab[1,1].oeffneMauer(0)
lab[2,1].oeffneMauer(1)
</code>

Ist der zweite, optionale Parameter ''False'', wird die Mauer geschlossen:
<code python>
lab[2,1].oeffneMauer(1, False)
</code>

==== Labyrinthe speichern und einlesen ====
  * Beispiellabyrinthe gibt es hier: {{lehrkraefte:blc:informatik:glf25:labyrinthe:labs.zip}}. 
  * Entpacken Sie die Dateien in ein Unterordner ihres Ordners, wo sich ihre Programme und die Klassen befinden.
  * Nennen Sie diesen Ordner ''labs''.

**Von Datei laden**
<code python>
from laby import Laby
from zelle import Zelle

lab = Laby.load("labs/10x07-06.txt")  # Mit Angabe des Unterordners vor dem /
print(lab)
</code>

**In Datei speichern**
<code python>
# l enthält eine Instanz der Klasse Laby
lab.save("meineloesung.txt")
</code>

===== Aufgaben =====
Die Aufgaben (ohne Zusatzaufgaben) sollten von allen gelöst werden. 

Die Zusatzaufgaben sind dazu da, damit sich jene mit mehr Übung nicht langweilen ;-)

==== Kreuz ====
Programmieren Sie in Labyrinth das wie folgt aussieht:
<code txt>
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+   +---+---+
|   |   |   |   |   |
+---+---+   +---+---+
|                   |
+---+---+   +---+---+
|   |   |   |   |   |
+---+---+   +---+---+
|   |   |   |   |   |
+---+---+---+---+---+
</code>

**Zusatzaufgabe**: Schreiben Sie ein Programm so, dass es für alle Labyrinthgrössen funktioniert. Hinweise:
<code python>
breite = l.breite  # Anzahl Zellen horizontal
hoehe = l.hoehe    # Anzahl Zellen vertikal

print(7//2)  # Ganzzahldivision, wird immer abgerundet, ergibt also 3 (und nicht 3.5)
</code>
==== Heizkörper ====
Produzieren Sie folgendes Labyrinth:
<code txt>
+---+---+---+---+---+---+---+---+
|                               |
+---+---+---+---+---+---+---+   +
|                               |
+   +---+---+---+---+---+---+---+
|                               |
+---+---+---+---+---+---+---+   +
|                               |
+   +---+---+---+---+---+---+---+
|                               |
+---+---+---+---+---+---+---+---+
</code>

**Hinweis**: 
  * Überprüfen ob eine Zahl ''y'' gerade ist: ''if y%2 == 0:''

**Zusatzaufgabe**: Programm funktioniert für beliebige Labyrinthgrössen.

==== Text ====
Programmieren Sie folgende Ausgabe:
<code text>
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   | P | r | o | g | r | a | m | m | i | e | r | e | n |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   | m | a | c | h | t |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   | S | p | a | s | s |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
</code>
**Hinweis**:
mit ''<nowiki>for buchstabe in "blabla":</nowiki>'' kann etwas für jeden Buchstaben wiederholt werden.

**Zusatzaufgabe**: Das Programm funktioniert mit beliebigen Texten als einzige Vorgabe

<code python>
# Vorgegebener Text
text = "Das geht auch voll automatisiert"

# Der Rest ist automatisch
woerter = text.split(" ")     # Text nach Leerschlägen aufteilen und als Liste speichern.
anzahlWoerter = len(woerter)  # Anzahl Wörter

lmax = max([len(w) for w in woerter])   # Anzahl Buchstaben im längsten Wort

# ...

for index, wort in enumerate(woerter):  # Wiederhole für jedes Wort, inkl. index
   pass  # Tu erst mal nix
</code>