Differences
This shows you the differences between two versions of the page.
Both sides previous revision Previous revision Next revision | Previous revision Last revision Both sides next revision | ||
lehrkraefte:blc:informatik:ffprg1-2020:funktionen [2020/02/22 10:31] Ivo Blöchliger [Summe über ein Array] |
lehrkraefte:blc:informatik:ffprg1-2020:funktionen [2022/05/19 12:43] Ivo Blöchliger [Beispiel: Buchstaben verwürfeln] |
||
---|---|---|---|
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. | + | 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 ===== | ||
+ | |||
+ | Hinweis: Diese Aufgabe gibt auch mit einer [[lehrkraefte: | ||
+ | |||
+ | 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 0 oder ein . stellt ein leeres Feld dar. | ||
+ | * Alle anderen Zeichen werden komplett ignoriert, so dass 81 Zeichen übrigbleiben. Diese stellen die Einträge zeilenweise von links nach rechts 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! | ||
+ | |||
+ | Beispiel-Eingaben: | ||
+ | <code python> | ||
+ | sudoku1 = " | ||
+ | sudoku2 = " | ||
+ | sodoku3 = " | ||
+ | </ | ||
+ | Ausgaben: | ||
+ | <code text> | ||
+ | [[0, 9, 0, 0, 7, 0, 0, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 1, 8, 0, 6, 2, 0, 5], [0, 3, 8, 1, 0, 7, 6, 2, 0], [2, 0, 0, 0, 0, 0, 0, 0, 1], [0, 5, 6, 2, 0, 8, 9, 3, 0], [6, 0, 4, 9, 0, 2, 5, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 8, 0, 0, 9, 0]] | ||
+ | [[2, 0, 0, 0, 0, 4, 3, 7, 0], [0, 6, 3, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 2, 1, 0, 4], [0, 0, 5, 1, 0, 7, 0, 0, 0], [8, 7, 0, 0, 0, 0, 0, 4, 1], [0, 0, 0, 5, 0, 6, 7, 0, 0], [3, 0, 2, 4, 0, 0, 0, 0, 0], [0, 8, 0, 0, 0, 0, 4, 6, 0], [0, 4, 9, 8, 0, 0, 0, 0, 3]] | ||
+ | [[0, 0, 0, 1, 0, 0, 9, 0, 5], [0, 0, 0, 0, 5, 0, 2, 3, 0], [0, 0, 0, 0, 0, 0, 0, 4, 7], [0, 4, 7, 9, 0, 5, 1, 0, 0], [0, 2, 0, 0, 0, 0, 0, 5, 0], [0, 0, 5, 4, 0, 7, 8, 9, 0], [9, 1, 0, 0, 0, 0, 0, 0, 0], [0, 8, 2, 0, 4, 0, 0, 0, 0], [7, 0, 6, 0, 0, 9, 0, 0, 0]] | ||
+ | </ | ||
+ | |||
+ | <hidden Lösungsvorschlag> | ||
+ | <code python sudokuparser.py> | ||
+ | sudoku1 = " | ||
+ | sudoku2 = " | ||
+ | sudoku3 = " | ||
+ | |||
+ | def parse(s): | ||
+ | res = [[0 for y in range(9)] for x in range(9)] | ||
+ | x=0 | ||
+ | y=0 | ||
+ | for c in s: | ||
+ | if (c> | ||
+ | if c==" | ||
+ | c=" | ||
+ | res[x][y] = int(c) | ||
+ | x+=1 | ||
+ | if (x==9): | ||
+ | x=0; | ||
+ | y+=1 | ||
+ | return res | ||
+ | |||
+ | print(parse(sudoku1)) | ||
+ | print(parse(sudoku2)) | ||
+ | print(parse(sudoku3)) | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ===== Sudoku schön ausgeben ===== | ||
+ | Gegeben ist ein 9x9-Array (siehe vorhergenden Aufgabe), wobei die Unter-Arrays Spalten sind. Die Eintäge sind 0 bis 9 (0 heisst leer). Schreiben Sie eine Funktion, die ein schönes Sudoku in ASCII-Art als String produziert: | ||
+ | <code txt> | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # 9 | | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # 7 | | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | # 8 | | ||
+ | # | ||
+ | # | ||
+ | # | ||
+ | </ | ||
+ | |||
+ | <hidden Lösungsvorschlag> | ||
+ | <code python asciisudoku.py> | ||
+ | sudoku1 = " | ||
+ | sudoku2 = " | ||
+ | sudoku3 = " | ||
+ | |||
+ | def parse(s): | ||
+ | res = [[0 for y in range(9)] for x in range(9)] | ||
+ | x=0 | ||
+ | y=0 | ||
+ | for c in s: | ||
+ | if (c> | ||
+ | if c==" | ||
+ | c=" | ||
+ | res[x][y] = int(c) | ||
+ | x+=1 | ||
+ | if (x==9): | ||
+ | x=0; | ||
+ | y+=1 | ||
+ | return res | ||
+ | |||
+ | def ascii(f): | ||
+ | hbar1 = ("# | ||
+ | hbar2 = ("# | ||
+ | symbols = [str(i) for i in range(10)] | ||
+ | symbols[0] = " " | ||
+ | separators = [" | ||
+ | res = hbar1 | ||
+ | for y in range(9): | ||
+ | res += "#" | ||
+ | for x in range(9): | ||
+ | res += " " | ||
+ | res+=" | ||
+ | if y%3==2: | ||
+ | res += hbar1 | ||
+ | else: | ||
+ | res += hbar2 | ||
+ | return res | ||
+ | |||
+ | |||
+ | print(ascii(parse(sudoku1))) | ||
+ | print(ascii(parse(sudoku2))) | ||
+ | print(ascii(parse(sudoku3))) | ||
+ | |||
+ | </ | ||
+ | </ | ||
+ | |||
+ | ===== 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)) | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ |