Differences
This shows you the differences between two versions of the page.
Both sides previous revision Previous revision Next revision | Previous revision | ||
lehrkraefte:blc:informatik:ffprg1-2020:funktionen [2020/02/22 11:02] Ivo Blöchliger [Tic-Tac-Toe schön ausgeben] |
lehrkraefte:blc:informatik:ffprg1-2020:funktionen [2022/06/23 12:58] Ivo Blöchliger [Sudoku parsen] |
||
---|---|---|---|
Line 5: | Line 5: | ||
===== Theorie ===== | ===== Theorie ===== | ||
- | Unterpogramme | + | Unterprogramme |
<code python> | <code python> | ||
def hello(wer): | def hello(wer): | ||
Line 35: | Line 35: | ||
return a | return a | ||
| | ||
- | def kompliziert(a, | + | def kompliziert(a, |
a = summe(a,b) | a = summe(a,b) | ||
b = produkt(a, | b = produkt(a, | ||
Line 59: | Line 59: | ||
* Zwei Buchstaben in einem Wort vertauschen | * Zwei Buchstaben in einem Wort vertauschen | ||
* Den neuen Text zusammensetzen. | * Den neuen Text zusammensetzen. | ||
- | |||
- | <code python buchstabenvertauschen.py> | ||
- | import random | ||
- | |||
- | # Vertauscht zwei Buchstaben an der Stelle i und j im Wort und gibt das Resultat zurueck | ||
- | def buchstabenTauschen(wort, | ||
- | pass # Das ist zu ersetzen | ||
- | |||
- | # Bestimmt zwei Positionen im Wort, um die Buchstaben zu verstauschen, | ||
- | def buchstabenWuerfeln(wort): | ||
- | # Hier fehlt der Code, der i und j bestimmt. | ||
- | return buchstabenVertauschen(wort, | ||
- | |||
- | # Diese Funktion kann noch ausgebaut werden (z.B. mehr Vertauschungen fuer laengere Woerter | ||
- | def wortWuerfeln(wort): | ||
- | wort = buchstabenTauschen(wort) | ||
- | return wort | ||
- | |||
- | # Entscheidet, | ||
- | def wortTeil(b): | ||
- | pass # Ersetzen durch Ihren Code | ||
- | |||
- | # Den Text Position um Position durchgehen, schauen, ob der Buchstaben zu einem Wort gehoehrt, das Wort verlaengern und wenn das Wort fertig ist, das Wort verwuerfeln | ||
- | def textWuerfeln(text): | ||
- | pass # Ersetzen! | ||
- | |||
- | mytext = "Sie kennen sicher die Tatsache, dass man Text auch gut lesen kann, wenn die Buchstaben innerhalb der Woerter vertauscht werden, vorausgesetzt, | ||
- | |||
- | print(textWuerfeln(mytext)) | ||
- | </ | ||
<hidden Lösungsvorschlag> | <hidden Lösungsvorschlag> | ||
Line 103: | Line 73: | ||
if len(wort)< | if len(wort)< | ||
return wort | return wort | ||
- | i = random.randint(1, | + | i = random.randint(1, |
- | j = random.randint(1, | + | j = random.randint(1, |
- | if (j==i): | + | if (j==i): |
j+=1 | j+=1 | ||
- | return | + | return |
def wortWuerfeln(wort): | def wortWuerfeln(wort): | ||
- | wort = buchstabenTauschen(wort) | + | wort = buchstabenWuerfeln(wort) |
if (len(wort)> | if (len(wort)> | ||
- | wort = buchstabenTauschen(wort) | + | wort = buchstabenWuerfeln(wort) |
return wort | return wort | ||
Line 151: | Line 121: | ||
for element in a: | for element in a: | ||
s+=element | s+=element | ||
+ | return s | ||
+ | | ||
+ | a = list(range(1, | ||
+ | print(a) | ||
+ | print(summe(a)) | ||
+ | |||
</ | </ | ||
</ | </ | ||
===== Tic-Tac-Toe schön ausgeben ===== | ===== Tic-Tac-Toe schön ausgeben ===== | ||
+ | |||
+ | Hinweis: Diese Aufgabe gibt auch als [[lehrkraefte: | ||
+ | |||
Ein Tic-Tac-Toe Feld kann mit einem 3x3-Array dargestellt werden. Wir verwenden 0,1,2 als Einträge (leer, Kreis, Kreuz). | Ein Tic-Tac-Toe Feld kann mit einem 3x3-Array dargestellt werden. Wir verwenden 0,1,2 als Einträge (leer, Kreis, Kreuz). | ||
Hier ein Beispiel: | Hier ein Beispiel: | ||
Line 160: | Line 139: | ||
feld = [[0,1,1], [2,1,2], [0,2,2]] | feld = [[0,1,1], [2,1,2], [0,2,2]] | ||
</ | </ | ||
- | Wobei feld[2][0] die recht obere Ecke sein soll. Die Unter-Arrays stellen Spalten dar! | + | Wobei feld[2][0] die rechte |
Schreiben Sie eine Funktion, die ein 3x3-Feld als Parameter bekommt, und einen String (inklusive Zeilenumbrüche " | Schreiben Sie eine Funktion, die ein 3x3-Feld als Parameter bekommt, und einen String (inklusive Zeilenumbrüche " | ||
Line 172: | Line 151: | ||
O | X | X | O | X | X | ||
</ | </ | ||
- | Hinweis: Verwenden Sie ein Array, um die möglichen Symbole festzulegen. Der Eintrag im Array liefert dann den Index vom Symbol. | + | Hinweis: Verwenden Sie ein Array, um die möglichen Symbole festzulegen. Der Eintrag im Spielfeld-Array liefert dann den Index vom Symbol. |
<hidden Lösungsvorschlag> | <hidden Lösungsvorschlag> | ||
+ | <code python tictactoe.py> | ||
feld = [[0,1,1], [2,1,2], [0,2,2]] | feld = [[0,1,1], [2,1,2], [0,2,2]] | ||
Line 191: | Line 171: | ||
print(ascii(feld)) | print(ascii(feld)) | ||
+ | </ | ||
</ | </ | ||
===== Sudoku parsen ===== | ===== Sudoku parsen ===== | ||
+ | |||
+ | Hinweis: Diese Aufgabe gibt auch mit einer [[lehrkraefte: | ||
+ | |||
Gegeben ist ein String, der ein Sudoku darstellt. Die Regeln sind wie folgt: | Gegeben ist ein String, der ein Sudoku darstellt. Die Regeln sind wie folgt: | ||
* Eine Ziffer von 1 bis 9 stellt ein gegebenes Feld dar. | * Eine Ziffer von 1 bis 9 stellt ein gegebenes Feld dar. | ||
* Eine Ziffer 0 oder ein . stellt ein leeres Feld dar. | * Eine Ziffer 0 oder ein . stellt ein leeres Feld dar. | ||
- | * Alle anderen Zeichen werden komplett ignoriert, so dass 81 Zeichen übrigbleiben. Diese Stellen | + | * Alle anderen Zeichen werden komplett ignoriert, so dass 81 Zeichen übrigbleiben. Diese stellen |
Ihre Aufgabe ist es daraus ein 9x9 - Array mit **Zahlen** (nicht Strings) von 0-9 zu erzeugen, wobei der Eintrag 0 für ein leeres Feld steht. Die Unter-Arrays stellen Spalten dar! | Ihre Aufgabe ist es daraus ein 9x9 - Array mit **Zahlen** (nicht Strings) von 0-9 zu erzeugen, wobei der Eintrag 0 für ein leeres Feld steht. Die Unter-Arrays stellen Spalten dar! | ||
Line 205: | Line 189: | ||
sudoku1 = " | sudoku1 = " | ||
sudoku2 = " | sudoku2 = " | ||
- | sodoku3 | + | sudoku3 |
</ | </ | ||
Ausgaben: | Ausgaben: | ||
Line 311: | Line 295: | ||
</ | </ | ||
</ | </ | ||
+ | |||
+ | ===== Challenge: Permutationen erzeugen ===== | ||
+ | Schreiben Sie eine Funktion permuationen(n), | ||
+ | Z.B. ist die Ausgabe von permutationen(4) folgende: | ||
+ | <code txt> | ||
+ | [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1], [1, 0, 2, 3], [1, 0, 3, 2], [1, 2, 0, 3], [1, 2, 3, 0], [1, 3, 0, 2], [1, 3, 2, 0], [2, 0, 1, 3], [2, 0, 3, 1], [2, 1, 0, 3], [2, 1, 3, 0], [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 0, 2, 1], [3, 1, 0, 2], [3, 1, 2, 0], [3, 2, 0, 1], [3, 2, 1, 0]] | ||
+ | </ | ||
+ | |||
+ | <hidden Lösungsvorschläge> | ||
+ | Element als erstes auswählen, dahinter alle möglichen Vertauschungen der restlichen Elemente anhängen. | ||
+ | <code python permutationen.py> | ||
+ | # Vertausche alle Element im Array a | ||
+ | def vertausche(a): | ||
+ | if len(a)==1: | ||
+ | return [a] | ||
+ | res = [] | ||
+ | for i in range(len(a)): | ||
+ | # Alle Vertauschungen ohne das Element i | ||
+ | temp = vertausche(a[: | ||
+ | for p in temp: | ||
+ | # Das Element i vorne anfuegen | ||
+ | res.append([a[i]]+p) | ||
+ | return res | ||
+ | |||
+ | def permutationen(n): | ||
+ | return vertausche(list(range(n))) | ||
+ | |||
+ | print(permutationen(3)) | ||
+ | |||
+ | </ | ||
+ | |||
+ | Mit map und lambda-Funktionen: | ||
+ | <code python permutationen_map_lambda.py> | ||
+ | def permutationen(n): | ||
+ | if n==1: | ||
+ | return [[0]] | ||
+ | res = [] | ||
+ | for first in range(n): | ||
+ | res += map(lambda x : [first]+map(lambda e: (e+1 if e>=first else e), x), permutationen(n-1)) | ||
+ | return res | ||
+ | |||
+ | print(permutationen(4)) | ||
+ | </ | ||
+ | |||
+ | Umwandlung des Index der lexikografischen Ordnung der Permutation: | ||
+ | <code python permutation_number.py> | ||
+ | def factorial(n): | ||
+ | r = 1 | ||
+ | for i in range(2, | ||
+ | r*=i | ||
+ | return r | ||
+ | |||
+ | # Berechnet die n-te Permutation vom Array a (nummeriert von 0 bis n!-1) | ||
+ | def num2perm(num, | ||
+ | if len(a)==1: | ||
+ | return a | ||
+ | total = factorial(len(a)-1) | ||
+ | first = num// | ||
+ | rest = num % total # Nummer der restlichen Permutation | ||
+ | return [a[first]] + num2perm(rest, | ||
+ | |||
+ | def permutationen(n): | ||
+ | a = list(range(n)) | ||
+ | return [num2perm(j, | ||
+ | |||
+ | print(permutationen(4)) | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ |