From 5d3189d7345dd3b26a5753a16020ed4f7df0c4b1 Mon Sep 17 00:00:00 2001 From: schneefux Date: Sun, 23 Nov 2014 12:18:04 +0100 Subject: Verschieben aller Dateien in Unterordner --- alphametiken.md | 52 ---------------------- alphametiken.py | 116 ------------------------------------------------- buffet_lotterie.md | 63 --------------------------- buffet_lotterie.py | 46 -------------------- doc/alphametiken.md | 52 ++++++++++++++++++++++ doc/buffet_lotterie.md | 63 +++++++++++++++++++++++++++ doc/faehre_fuellen.md | 76 ++++++++++++++++++++++++++++++++ doc/faires_fuellen.md | 9 ++++ doc/mobile.md | 42 ++++++++++++++++++ doc/pong.md | 7 +++ doc/zahlenspiel.md | 39 +++++++++++++++++ faehre_fuellen.md | 76 -------------------------------- faehre_fuellen.py | 100 ------------------------------------------ faires_fuellen.md | 9 ---- mobile.md | 42 ------------------ mobile.py | 76 -------------------------------- pong.md | 7 --- pong.py | 79 --------------------------------- src/alphametiken.py | 116 +++++++++++++++++++++++++++++++++++++++++++++++++ src/buffet_lotterie.py | 46 ++++++++++++++++++++ src/faehre_fuellen.py | 100 ++++++++++++++++++++++++++++++++++++++++++ src/mobile.py | 76 ++++++++++++++++++++++++++++++++ src/pong.py | 79 +++++++++++++++++++++++++++++++++ src/zahlenspiel.py | 52 ++++++++++++++++++++++ zahlenspiel.md | 39 ----------------- zahlenspiel.py | 52 ---------------------- 26 files changed, 757 insertions(+), 757 deletions(-) delete mode 100644 alphametiken.md delete mode 100755 alphametiken.py delete mode 100644 buffet_lotterie.md delete mode 100755 buffet_lotterie.py create mode 100644 doc/alphametiken.md create mode 100644 doc/buffet_lotterie.md create mode 100644 doc/faehre_fuellen.md create mode 100644 doc/faires_fuellen.md create mode 100644 doc/mobile.md create mode 100644 doc/pong.md create mode 100644 doc/zahlenspiel.md delete mode 100644 faehre_fuellen.md delete mode 100755 faehre_fuellen.py delete mode 100644 faires_fuellen.md delete mode 100644 mobile.md delete mode 100755 mobile.py delete mode 100644 pong.md delete mode 100644 pong.py create mode 100755 src/alphametiken.py create mode 100755 src/buffet_lotterie.py create mode 100755 src/faehre_fuellen.py create mode 100755 src/mobile.py create mode 100644 src/pong.py create mode 100755 src/zahlenspiel.py delete mode 100644 zahlenspiel.md delete mode 100755 zahlenspiel.py diff --git a/alphametiken.md b/alphametiken.md deleted file mode 100644 index de06565..0000000 --- a/alphametiken.md +++ /dev/null @@ -1,52 +0,0 @@ -Alphametiken -============ - -Das Programm ist in zwei Teile gegliedert: - -* `löse(zu_lösendes_Alphametikum)` gibt eine Liste mit allen Lösungen eines Alphametikums in dem Format `[['Rechnung', {'Buchstabe': zugehörige_Zahl, ...}], ...]` zurück (zum Beispiel `[['8928-3164=5764', {'Ü': 9, 'F': 8, 'W': 7, 'N': 2, 'Z': 5, 'I': 4, 'E': 6, 'D': 3, 'R': 1}]]` für `FÜNF-DREI=ZWEI`). - -* `generiere(Länge)` gibt ein Alphametikum als String zurück (zum Beispiel `FÜNF-DREI=ZWEI`), für welches mindestens eine Lösung vorhanden ist. - -Alphametikum lösen ------------------- - -Die Funktion `ersetze`, aufgerufen durch `löse`, ersetzt jeweils den ersten Buchstaben im Alphametikum durch eine Zahl, nacheinander 0 bis 9. Für den Rest des Alphametikum-Strings wird die Funktion rekursiv aufgerufen. Ist der letzte Buchstabe ersetzt, wird mithilfe von Pythons `eval`-Funktion überprüft, ob die ersetzten Zahlen zu einer wahren Gleichung führen. Ist dies der Fall, wird die gefundene Lösung in einer Liste festgehalten und nach Überprüfen aller Kombinationen zurückgegeben. -Der Ausnahmefall, dass die Lösung eine Null als erste Ziffer einer Zahl hat, wird durch einen regulären Ausdruck `re.search` überprüft. Um gleiche Zahlen nicht an mehrere Buchstaben zu verteilen wird in der rekursiven Funktion die Liste an bereits verwendeten Zahlen mitgegeben. - -Beispiel für eine Lösung: -``` ->>> import alphametiken ->>> alphametiken.löse("SEND + MORE = MONEY") -[['9567 + 1085 = 10652', {'O': 0, 'N': 6, 'M': 1, 'E': 5, 'Y': 2, 'S': 9, 'D': 7, 'R': 8}]] -``` - -Alphametikum finden -------------------- - -Zum Finden von Alphametiken in der Form `FÜNF-DREI=ZWEI` ist es zuerst nötig, eine valide Gleichung - hier `5-3=2` zu finden. Um dies für eine beliebige Länge zu tun, wird in der Funktion `generiere` ein Template erstellt, in dem `_` dann durch ein zufälliges Rechenzeichen, `x` und `y` durch eine zufällige Zahl von 0-9 ersetzte wird, sodass bei einer Länge von 1 dieses Schema entsteht: -``` -x_x=y -``` -das nun auf Richtigkeit, wieder durch `eval`, geprüft wird. Eine Gleichung wie `5-3=2` wird schließlich mithilfe von Zahlwörtern abgebildet: `FÜNF-DREI=ZWEI`. Jetzt wird mit `löse` geprüft, ob eine Lösung vorhanden ist. Wenn ja, endet die Funktion, sonst wird nach einer neuen Gleichung gesucht. -`random.choice` und `random.randrange` dienen hier zum Finden zufälliger Rechenzeichen und Zahlen. - - -Beispiel für ein Alphametikum mit mehr als 20 Zeichen: -``` ->>> import alphametiken ->>> alphametiken.generiere(3) -'FÜNF-ZWEI+VIER-ZWEI=FÜNF' ->>> alphametiken.löse('FÜNF-ZWEI+VIER-ZWEI=FÜNF') -... -['9589-3102+6204-3102=9589', {'Z': 3, 'V': 6, 'I': 2, 'Ü': 5, 'R': 4, 'E': 0, 'N': 8, 'F': 9, 'W': 1}] -... ->>> alphametiken.generiere() -'SECHS-VIER=ZWEI' ->>> alphametiken.löse('SECHS-VIER=ZWEI') -[['12051-3427=8624', {'H': 5, 'W': 6, 'E': 2, 'Z': 8, 'I': 4, 'S': 1, 'C': 0, 'R': 7, 'V': 3}], ->>> alphametiken.generiere(2) -'ACHT-ZWEI-DREI=DREI' ->>> alphametiken.löse('ACHT-ZWEI-DREI=DREI') -[['4567-2389-1089=1089', {'T': 7, 'A': 4, 'W': 3, 'E': 8, 'Z': 2, 'I': 9, 'H': 6, 'C': 5, 'D': 1, 'R': 0}], -... -``` diff --git a/alphametiken.py b/alphametiken.py deleted file mode 100755 index fb4324c..0000000 --- a/alphametiken.py +++ /dev/null @@ -1,116 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# getestet mit Python 2.7.8 und 3.4.2 -'''Generiert oder löst Alphametiken''' -# Nicht als root ausführen. -# Die Ausführung dauert bis zu zwei Minuten, abhängig von der Länge des -# Alphametiks. Die Generierung dauert unter Umständen 5 Minuten oder länger. - -# Programm löst das Alphametik "SUCHEN-MACHT=SPASS" -# und generiert eines mit einem Rechenzeichen - -import re, random - -ALPHAMETIK = "SUCHEN-MACHT=SPASS" - -ZAHLEN = ["EINS", "ZWEI", "DREI", "VIER", "FÜNF", \ - "SECHS", "SIEBEN", "ACHT", "NEUN", "ZEHN"] -#RECHENZEICHEN = ["+", "-", "*", "/"] -RECHENZEICHEN = ["+", "-"] # schneller - -def buchstaben_liste(wort): - '''Erstellt eine Liste der Buchstaben''' - buchstaben = [] - for char in wort: - if (char not in RECHENZEICHEN) \ - and (char not in buchstaben) \ - and (char not in " ="): - - buchstaben.append(char) - - return buchstaben - -def ersetze(buchst, wort, \ - benutzte_zahlen=None, loesungen=None, alle_buchstaben=None): - '''Ersetzt einen Buchstaben aus `buchst` in einem Wort `wort` \ -nacheinander durch `0-9` und ruft sich selbst auf. \ -Ist `buchst` leer, wird das Alphametik auf Richtigkeit getestet -und ggf. zu `loesungen` hinzugefügt. \ -Zurückgegeben wird eine Liste mit Lösungen. \ -Element der Liste ist der Rechnungsstring und ein dict.''' - - if alle_buchstaben == None: - alle_buchstaben = buchst - if benutzte_zahlen == None: - benutzte_zahlen = [] - if loesungen == None: - loesungen = [] - - if len(buchst): - for j in range(10): - if j in benutzte_zahlen: # jede Zahl nur einmal verwenden - continue - - m_benutzte_zahlen = benutzte_zahlen[:] - m_benutzte_zahlen.append(j) - - m_wort = wort.replace(buchst[0], str(j)) - ersetze(buchst[1:], m_wort, m_benutzte_zahlen, \ - loesungen, alle_buchstaben) - else: - if re.search(r"\b0", wort): - # 0 als erste Ziffer in einer Zahl ist nicht erlaubt - return - - if eval(wort.replace("=", "==")): - lsg = [wort, dict()] - for j, k in zip(alle_buchstaben, benutzte_zahlen): - lsg[1][j] = k - - loesungen.append(lsg) - - return loesungen - -def loese(alpham): - '''kleiner Wrapper, der die Benutzung von `ersetze` vereinfacht''' - return ersetze(buchstaben_liste(alpham), alpham, None, None, None) - -def generiere(laenge=1): - '''gibt ein zufälliges Alphametik mit `laenge` \ -"Ziffern" vor dem Gleichheitszeichen zurück''' - while True: - rechnung_ok = False - while rechnung_ok == False: # sucht nach wahren Gleichungen - alphametik = "x" + "_x" * laenge + "=y" # Template für Rechnung - - for j in range(laenge + 1): # zufällige Rechenzeichen einsetzen - alphametik = alphametik.replace("_", \ - random.choice(RECHENZEICHEN), 1) - - alphametik = alphametik.replace("y", str(random.randrange(1, 9))) - # Ergebnis - - for j in range(laenge + 2): - alphametik = alphametik.replace("x", \ - str(random.randrange(1, 9)), 1) - - rechnung_ok = eval(alphametik.replace("=", "==")) - - # jetzt passende Alphametiken suchen oder weitersuchen - for j in range(1, 10): - alphametik = alphametik.replace(str(j), ZAHLEN[j - 1]) - - loe = loese(alphametik) - if len(loe) > 0: - return alphametik # Geschafft, wir haben eines gefunden! - -if __name__ == "__main__": - LOESUNG = loese(ALPHAMETIK) - - if len(LOESUNG) == 0: - print("Keine Lösungen vorhanden") - else: - print("Es konnten folgende Lösungen gefunden werden:") - print(LOESUNG) - - print(generiere()) diff --git a/buffet_lotterie.md b/buffet_lotterie.md deleted file mode 100644 index 8a125c0..0000000 --- a/buffet_lotterie.md +++ /dev/null @@ -1,63 +0,0 @@ -Buffet-Lotterie -=============== - -Das Programm besteht aus der Funktion `denke(Anzahl_Teilnehmer, Silben_als_Liste)`, die die Lösung auf der Konsole ausgibt. - -Gedanken dazu -------------- - -* Es ist egal, wer welche Silbe sagt. Wichtig ist nur, wer die letzte spricht und wie oft das Geburtstagskind die Möglichkeit hat, zwei zu sprechen. -* Es ist - für das Geburtstagskind - egal, in welcher Reihenfolge es Eine und Zwei Silben spricht, solange die Anzahl an Zweisilbern insgesamt gleich bleibt, denn -* Es ist von Anfang an klar, nach wie vielen Runden das Geburtstagskind drankommt und wie viele Silben es spricht. Bei der gleichen Anzahl an Silben und Start-Teilnehmern ist die Anzahl an Runden, die das Geburtstagskind braucht, um zum Essen zu kommen konstant. - -Lösung ------- - -Nach langem Nachdenken ergaben sich die Formeln -``` -e = floor((len(silben) + offset) / teilnehmer) -offset = ((len(silben) + offset - 1) % teilnehmer) % (teilnehmer - 1) -``` -wobei `e` die Anzahl Runden darstellt, die das Geburtstagskind eine Silbe sagen durfte, bis jemand zum Essen ging und -`offset` - mit dem Startwert 0 - die Nummer des Teilnehmers, der als nächstes anfangt hat. -Um dann noch auszurechnen, wie weit diese Teilnehmernummer `offset` vom Geburtstagskind entfernt ist, kann man -``` -fehlt_noch = (offset - 1) % (teilnehmer - 1) + 1 -``` -benutzen. -Diese Berechnungen werden in einer Schleife durchgeführt. Um zu berechnen, wie oft das Geburtstagskind optimalerweise zwei Silben sagen muss, ist es nötig, die Gesamtzahl an `e`s zu behalten. Das geschieht in `einfluss`. -Jedes Mal, nachdem ein Teilnehmer in der Rechnung die Runde verlässt, wird geprüft, ob der `einfluss` groß genug ist, um die Lücke `fehlt_noch` auszugleichen. Wenn ja, ist die Aufgabe gelöst und das Geburtstagskind kann `fehlt_noch`-mal zwei Silben nennen und früher Essen gehen. -Die Lösung wird durch Zustands-Nachrichten verständlicher gemacht. - -Beispiele ---------- - -6 Teilnehmer mit "Informatik kann uns..." -``` ->>> import buffet_lotterie ->>> buffet_lotterie.denke(6, ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen']) -Nach 2 Runden fängt der 4. an. Es sind dann noch 5 Teilnehmer im Spiel. -Es fehlten 3 bis zum Geburtstagskind -Nach 3 Runden fängt der 4. an. Es sind dann noch 4 Teilnehmer im Spiel. -Es fehlten 3 bis zum Geburtstagskind -Das Geburtstagskind muss erst 3-mal 'zwei Silben' und dann nur noch 'eine Silbe' sagen, bis es dran ist. -``` - -28 Teilnehmer, wie in der Aufgabe -``` ->>> buffet_lotterie.denke(28, ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen']) -Nach 0 Runden fängt der 16. an. Es sind dann noch 27 Teilnehmer im Spiel. -Nach 1 Runden fängt der 4. an. Es sind dann noch 26 Teilnehmer im Spiel. -Es fehlten 3 bis zum Geburtstagskind -Nach 0 Runden fängt der 19. an. Es sind dann noch 25 Teilnehmer im Spiel. -Nach 1 Runden fängt der 9. an. Es sind dann noch 24 Teilnehmer im Spiel. -Es fehlten 8 bis zum Geburtstagskind -Nach 1 Runden fängt der 1. an. Es sind dann noch 23 Teilnehmer im Spiel. -Es fehlten 23 bis zum Geburtstagskind -Nach 0 Runden fängt der 16. an. Es sind dann noch 22 Teilnehmer im Spiel. -Nach 1 Runden fängt der 9. an. Es sind dann noch 21 Teilnehmer im Spiel. -Es fehlten 8 bis zum Geburtstagskind -Nach 1 Runden fängt der 3. an. Es sind dann noch 20 Teilnehmer im Spiel. -Es fehlten 2 bis zum Geburtstagskind -Das Geburtstagskind muss erst 2-mal 'zwei Silben' und dann nur noch 'eine Silbe' sagen, bis es dran ist. -``` diff --git a/buffet_lotterie.py b/buffet_lotterie.py deleted file mode 100755 index 82a7796..0000000 --- a/buffet_lotterie.py +++ /dev/null @@ -1,46 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# getestet mit Python 2.7.8 und 3.4.2 -'''Findet die optimale Lösung für die Buffet-Lotterie''' - -from math import floor - -ANZAHL_TEILNEHMER = 6 -SILBEN = ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', \ - 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen'] - -def denke(anzahl_teilnehmer, silben): - '''Findet die optimale Lösung für die Buffet-Lotterie''' - teilnehmer = anzahl_teilnehmer - fehlt_noch = float("inf") - einfluss = 0 - offset = 0 - while fehlt_noch > 0: - runden = floor((len(silben) + offset) / teilnehmer) - # runden Runden ist das Geburtstagskind dran, bis einer gehen darf - - offset = ((len(silben) + offset - 1) % teilnehmer) % (teilnehmer - 1) - # nach runden Runden fängt Teilnehmer Nummer `offset` an, - # 0 ist das Geburtstagskind - - einfluss += runden - # Geburtstagskind kann insgesamt `runden`-mal dem Essen näher kommen - fehlt_noch = (offset - 1) % (teilnehmer - 1) + 1 - # um jetzt dran sein zu müssen, hätte das Geburtstagskind - # `fehlt_noch`-mal zwei SILBEN sagen müssen - - print("Nach " + str(runden) + " Runden fängt der " + str(offset + 1) + \ - ". an. Es sind dann noch " + str(teilnehmer - 1) + \ - " Teilnehmer im Spiel.") - if runden > 0: # falls das Geburtstagskind dran kam - print("Es fehlten " + str(fehlt_noch) + " bis zum Geburtstagskind") - if fehlt_noch < einfluss: - print("Das Geburtstagskind muss erst " + str(fehlt_noch) + \ - "-mal 'zwei Silben' und dann nur noch 'eine Silbe'" + \ - "sagen, bis es dran ist.") - break - - teilnehmer -= 1 # einer geht - -if __name__ == "__main__": - denke(ANZAHL_TEILNEHMER, SILBEN) diff --git a/doc/alphametiken.md b/doc/alphametiken.md new file mode 100644 index 0000000..de06565 --- /dev/null +++ b/doc/alphametiken.md @@ -0,0 +1,52 @@ +Alphametiken +============ + +Das Programm ist in zwei Teile gegliedert: + +* `löse(zu_lösendes_Alphametikum)` gibt eine Liste mit allen Lösungen eines Alphametikums in dem Format `[['Rechnung', {'Buchstabe': zugehörige_Zahl, ...}], ...]` zurück (zum Beispiel `[['8928-3164=5764', {'Ü': 9, 'F': 8, 'W': 7, 'N': 2, 'Z': 5, 'I': 4, 'E': 6, 'D': 3, 'R': 1}]]` für `FÜNF-DREI=ZWEI`). + +* `generiere(Länge)` gibt ein Alphametikum als String zurück (zum Beispiel `FÜNF-DREI=ZWEI`), für welches mindestens eine Lösung vorhanden ist. + +Alphametikum lösen +------------------ + +Die Funktion `ersetze`, aufgerufen durch `löse`, ersetzt jeweils den ersten Buchstaben im Alphametikum durch eine Zahl, nacheinander 0 bis 9. Für den Rest des Alphametikum-Strings wird die Funktion rekursiv aufgerufen. Ist der letzte Buchstabe ersetzt, wird mithilfe von Pythons `eval`-Funktion überprüft, ob die ersetzten Zahlen zu einer wahren Gleichung führen. Ist dies der Fall, wird die gefundene Lösung in einer Liste festgehalten und nach Überprüfen aller Kombinationen zurückgegeben. +Der Ausnahmefall, dass die Lösung eine Null als erste Ziffer einer Zahl hat, wird durch einen regulären Ausdruck `re.search` überprüft. Um gleiche Zahlen nicht an mehrere Buchstaben zu verteilen wird in der rekursiven Funktion die Liste an bereits verwendeten Zahlen mitgegeben. + +Beispiel für eine Lösung: +``` +>>> import alphametiken +>>> alphametiken.löse("SEND + MORE = MONEY") +[['9567 + 1085 = 10652', {'O': 0, 'N': 6, 'M': 1, 'E': 5, 'Y': 2, 'S': 9, 'D': 7, 'R': 8}]] +``` + +Alphametikum finden +------------------- + +Zum Finden von Alphametiken in der Form `FÜNF-DREI=ZWEI` ist es zuerst nötig, eine valide Gleichung - hier `5-3=2` zu finden. Um dies für eine beliebige Länge zu tun, wird in der Funktion `generiere` ein Template erstellt, in dem `_` dann durch ein zufälliges Rechenzeichen, `x` und `y` durch eine zufällige Zahl von 0-9 ersetzte wird, sodass bei einer Länge von 1 dieses Schema entsteht: +``` +x_x=y +``` +das nun auf Richtigkeit, wieder durch `eval`, geprüft wird. Eine Gleichung wie `5-3=2` wird schließlich mithilfe von Zahlwörtern abgebildet: `FÜNF-DREI=ZWEI`. Jetzt wird mit `löse` geprüft, ob eine Lösung vorhanden ist. Wenn ja, endet die Funktion, sonst wird nach einer neuen Gleichung gesucht. +`random.choice` und `random.randrange` dienen hier zum Finden zufälliger Rechenzeichen und Zahlen. + + +Beispiel für ein Alphametikum mit mehr als 20 Zeichen: +``` +>>> import alphametiken +>>> alphametiken.generiere(3) +'FÜNF-ZWEI+VIER-ZWEI=FÜNF' +>>> alphametiken.löse('FÜNF-ZWEI+VIER-ZWEI=FÜNF') +... +['9589-3102+6204-3102=9589', {'Z': 3, 'V': 6, 'I': 2, 'Ü': 5, 'R': 4, 'E': 0, 'N': 8, 'F': 9, 'W': 1}] +... +>>> alphametiken.generiere() +'SECHS-VIER=ZWEI' +>>> alphametiken.löse('SECHS-VIER=ZWEI') +[['12051-3427=8624', {'H': 5, 'W': 6, 'E': 2, 'Z': 8, 'I': 4, 'S': 1, 'C': 0, 'R': 7, 'V': 3}], +>>> alphametiken.generiere(2) +'ACHT-ZWEI-DREI=DREI' +>>> alphametiken.löse('ACHT-ZWEI-DREI=DREI') +[['4567-2389-1089=1089', {'T': 7, 'A': 4, 'W': 3, 'E': 8, 'Z': 2, 'I': 9, 'H': 6, 'C': 5, 'D': 1, 'R': 0}], +... +``` diff --git a/doc/buffet_lotterie.md b/doc/buffet_lotterie.md new file mode 100644 index 0000000..8a125c0 --- /dev/null +++ b/doc/buffet_lotterie.md @@ -0,0 +1,63 @@ +Buffet-Lotterie +=============== + +Das Programm besteht aus der Funktion `denke(Anzahl_Teilnehmer, Silben_als_Liste)`, die die Lösung auf der Konsole ausgibt. + +Gedanken dazu +------------- + +* Es ist egal, wer welche Silbe sagt. Wichtig ist nur, wer die letzte spricht und wie oft das Geburtstagskind die Möglichkeit hat, zwei zu sprechen. +* Es ist - für das Geburtstagskind - egal, in welcher Reihenfolge es Eine und Zwei Silben spricht, solange die Anzahl an Zweisilbern insgesamt gleich bleibt, denn +* Es ist von Anfang an klar, nach wie vielen Runden das Geburtstagskind drankommt und wie viele Silben es spricht. Bei der gleichen Anzahl an Silben und Start-Teilnehmern ist die Anzahl an Runden, die das Geburtstagskind braucht, um zum Essen zu kommen konstant. + +Lösung +------ + +Nach langem Nachdenken ergaben sich die Formeln +``` +e = floor((len(silben) + offset) / teilnehmer) +offset = ((len(silben) + offset - 1) % teilnehmer) % (teilnehmer - 1) +``` +wobei `e` die Anzahl Runden darstellt, die das Geburtstagskind eine Silbe sagen durfte, bis jemand zum Essen ging und +`offset` - mit dem Startwert 0 - die Nummer des Teilnehmers, der als nächstes anfangt hat. +Um dann noch auszurechnen, wie weit diese Teilnehmernummer `offset` vom Geburtstagskind entfernt ist, kann man +``` +fehlt_noch = (offset - 1) % (teilnehmer - 1) + 1 +``` +benutzen. +Diese Berechnungen werden in einer Schleife durchgeführt. Um zu berechnen, wie oft das Geburtstagskind optimalerweise zwei Silben sagen muss, ist es nötig, die Gesamtzahl an `e`s zu behalten. Das geschieht in `einfluss`. +Jedes Mal, nachdem ein Teilnehmer in der Rechnung die Runde verlässt, wird geprüft, ob der `einfluss` groß genug ist, um die Lücke `fehlt_noch` auszugleichen. Wenn ja, ist die Aufgabe gelöst und das Geburtstagskind kann `fehlt_noch`-mal zwei Silben nennen und früher Essen gehen. +Die Lösung wird durch Zustands-Nachrichten verständlicher gemacht. + +Beispiele +--------- + +6 Teilnehmer mit "Informatik kann uns..." +``` +>>> import buffet_lotterie +>>> buffet_lotterie.denke(6, ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen']) +Nach 2 Runden fängt der 4. an. Es sind dann noch 5 Teilnehmer im Spiel. +Es fehlten 3 bis zum Geburtstagskind +Nach 3 Runden fängt der 4. an. Es sind dann noch 4 Teilnehmer im Spiel. +Es fehlten 3 bis zum Geburtstagskind +Das Geburtstagskind muss erst 3-mal 'zwei Silben' und dann nur noch 'eine Silbe' sagen, bis es dran ist. +``` + +28 Teilnehmer, wie in der Aufgabe +``` +>>> buffet_lotterie.denke(28, ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen']) +Nach 0 Runden fängt der 16. an. Es sind dann noch 27 Teilnehmer im Spiel. +Nach 1 Runden fängt der 4. an. Es sind dann noch 26 Teilnehmer im Spiel. +Es fehlten 3 bis zum Geburtstagskind +Nach 0 Runden fängt der 19. an. Es sind dann noch 25 Teilnehmer im Spiel. +Nach 1 Runden fängt der 9. an. Es sind dann noch 24 Teilnehmer im Spiel. +Es fehlten 8 bis zum Geburtstagskind +Nach 1 Runden fängt der 1. an. Es sind dann noch 23 Teilnehmer im Spiel. +Es fehlten 23 bis zum Geburtstagskind +Nach 0 Runden fängt der 16. an. Es sind dann noch 22 Teilnehmer im Spiel. +Nach 1 Runden fängt der 9. an. Es sind dann noch 21 Teilnehmer im Spiel. +Es fehlten 8 bis zum Geburtstagskind +Nach 1 Runden fängt der 3. an. Es sind dann noch 20 Teilnehmer im Spiel. +Es fehlten 2 bis zum Geburtstagskind +Das Geburtstagskind muss erst 2-mal 'zwei Silben' und dann nur noch 'eine Silbe' sagen, bis es dran ist. +``` diff --git a/doc/faehre_fuellen.md b/doc/faehre_fuellen.md new file mode 100644 index 0000000..125d5cd --- /dev/null +++ b/doc/faehre_fuellen.md @@ -0,0 +1,76 @@ +Fähre füllen +============ + +Die Lösung zu Fähre füllen beinhaltet wie gefordert zwei Strategien `strategie_a`, `strategie_b`. +Beide Funktionen nehmen eine Liste mit Autolängen als Eingabe und geben ein `dict` mit der Länge und Anzahl aller Autos zurück. Mit `print` wird angegeben, wo die Autos einsortiert werden. + +Strategie A +----------- + +Die Fahrzeuge werden möglichst weit links angeordnet. Am effizienten ist das bei einer Folge wie beispielsweise +``` +6, 6, 6, 15, 15, 15, ... +``` +da hierbei die meiste Anzahl an Fahrzeugen hineinpasst, verglichen mit B. + +Strategie B +----------- + +Die Fahrzeuge werden möglichst gleichmäßig auf die drei Spalten verteilt. Die Folge vom Beispiel in A) würde dazu führen, dass nur 3 Fahrzeuge (`6, 6, 6`) Platz hätten. In dem Beispiel +``` +8, 8, 8, 5, 5, 5, 5, 5, 5, ... +``` +werden für A) 8 Fahrzeuge eingeordnet und für B) 9. + +Beispiele +--------- + +``` +>>> # Optimales Beispiel für A +>>> import faehre_fuellen +>>> faehre_fuellen.strategie_a([15, 15, 15, 15, 15, 6, 6, 6]) +6 wurde eingeordnet in die Reihe 0 +6 wurde eingeordnet in die Reihe 0 +6 wurde eingeordnet in die Reihe 0 +15 wurde eingeordnet in die Reihe 1 +15 wurde eingeordnet in die Reihe 2 +Das Fahrzeug 15 hat nicht mehr gepasst +{'anzahl': [3, 1, 1], 'länge': [18, 15, 15]} +>>> faehre_fuellen.strategie_b([15, 15, 15, 15, 15, 6, 6, 6]) +6 wurde eingeordnet in Reihe 0 +6 wurde eingeordnet in Reihe 1 +6 wurde eingeordnet in Reihe 2 +Das Fahrzeug 15 hat nicht mehr gepasst +{'anzahl': [1, 1, 1], 'länge': [6, 6, 6]} +>>> +>>> # Optimales Beispiel für B +>>> faehre_fuellen.strategie_a([5, 5, 5, 5, 5, 5, 5, 8, 8, 8]) +... +Das Fahrzeug 5 hat nicht mehr gepasst +{'anzahl': [2, 3, 3], 'länge': [16, 18, 15]} +>>> faehre_fuellen.strategie_b([5, 5, 5, 5, 5, 5, 5, 8, 8, 8]) +... +Das Fahrzeug 5 hat nicht mehr gepasst +{'anzahl': [3, 3, 3], 'länge': [18, 18, 18]} +>>> +>>> +>>> # Gegebene Beispiele befinden sich in einer Liste `Beispiel` +>>> # (Die Ausgabe ist hier auf das Ergebnis beschränkt) +>>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[0]) +{'anzahl': [3, 3, 1], 'länge': [18.47, 16.09, 9.12]} +>>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[0]) +{'anzahl': [2, 3, 2], 'länge': [15.989999999999998, 19.2, 8.49]} +>>> # Beispiel 1: weder A) noch B) ist effizienter (jeweils 7 Fahrzeuge) +>>> +>>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[1]) +{'anzahl': [2, 3, 3], 'länge': [19.92, 16.48, 11.69]} +>>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[1]) +{'anzahl': [2, 3, 3], 'länge': [18.69, 18.04, 11.36]} +>>> # Beispiel 2: weder A) noch B) ist effizienter (jeweils 8 Fahrzeuge) +>>> +>>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[2]) +{'anzahl': [5, 4, 3], 'länge': [18.91, 17.630000000000003, 12.780000000000001]} +>>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[2]) +{'anzahl': [4, 4, 4], 'länge': [15.030000000000001, 16.86, 17.43]} +>>> # Beispiel 3: weder A) noch B) ist effizienter (jeweils 12 Fahrzeuge) +``` diff --git a/doc/faires_fuellen.md b/doc/faires_fuellen.md new file mode 100644 index 0000000..7591b7b --- /dev/null +++ b/doc/faires_fuellen.md @@ -0,0 +1,9 @@ +Faires Füllen +============== + +Die Aufgabe ist unbearbeitet, nur Lösungsideen sind vorhanden. +Ideen zur Aufgabe: +* Lösen durch (rekursives) Probieren aller Kombinationen +* oder: sortieren nach Größe; nacheinander immer in das rechte Gefäß kippen und (anschließend) nach der richtigen Summe suchen; zurückkippen +* nur lösbar, wenn + * eine Differenz zweier Behälter Teiler der Hälfte der Flüssigkeit ist? diff --git a/doc/mobile.md b/doc/mobile.md new file mode 100644 index 0000000..af55d3d --- /dev/null +++ b/doc/mobile.md @@ -0,0 +1,42 @@ +Mobile +====== + +Textuelle Darstellung +--------------------- + +Die textuelle Darstellung setzt sich aus einer Liste von Position-Gewichts-Tuples zusammen. Ein Gewicht ist hierbei ebenfalls eine Liste. Positionen sind auf der einen Seite negativ, auf der anderen positiv. +Ein Balken lässt sich daran erkennen, dass er mehr als ein Gewicht hat. Eine Figur ist an der Position 0 mit dem Gewicht der entsprechenden Figur. +Beispiel für ein Mobile mit einer Figur des Gewichts 2: `[(0, 2)]` +Beispiel für einen Balken mit zwei Figuren des Gewichts 3: `[(-3, 3), (3, 3)]` + +Das abgebildete Mobile sieht in der textuellen Darstellung wie folgt aus: +``` +[(-4, [(-2, [(0, 1)]), (1, [(0, 2)])]), (-1, [(0, 2)]), (2, [(0, 3)]), (4, [(0, 2)])] +``` + +Umsetzung +--------- + +Die Lösung besteht aus zwei Funktionen, `split(alle_Figuren_an_einem_Balken)`, welche eine textuelle Darstellung verteilt. Diese eingehende Darstellung ist ein einziger Balken mit allen Figuren, die mithilfe dieser Funktion ausgeglichen werden. Im Endergebnis hat dann jeder Balken maximal vier Gewichte. Die Liste, die zurückgegeben wird, ähnelt der textuellen Darstellung, jedoch ist statt der Position das Gewicht des Gewichts in dem Tuple enthalten. +Diese Liste wird von der zweiten Funktion `weight(Liste_erstellt_durch_split)` angeglichen. +Aus Benutzerfreundlichkeitsgründen fasst eine dritte Funktion `mobile(List)` diese zwei zusammen. Sie benötigt nur noch eine Liste aller Gewichte für das Mobile. + +Die Funktion `split` sortiert alle Items der mitgelieferten Liste in vier Plätze ein (realisiert mit dem Modulo-Operator). Das Gesamtgewicht dieser vier Plätze wird berchnet, dann wird jedes Gewicht in diesen vier Plätzen durch einen rekursiven Funktionsaufruf erneut verteilt. + +`weight` berechnet die Position mit der Gegenzahl des Gesamtewichts des Gewichts an der gegenüberliegenden Position. Ist die Anzahl an Gewichten auf dem Balken ungerade, wird ein Gewichte in die Mitte (Position 0) platziert. +Durch diese Verteilung gleichen sich die jeweils äußersten und innersten Gewichtpaare aus. Auch diese Funktion ruft sich selbst auf, um die Gewichte von der Spitze des Mobiles hinab bis zu den Figuren alle zu verteilen. + +Beispiele +--------- + +``` +>>> import mobile +>>> mobile.mobile([1, 4]) +[(-4, 1), (1, 4)] +>>> mobile.mobile([4, 6, 2, 3]) +[(-3, 4), (-2, 6), (6, 2), (4, 3)] +>>> mobile.mobile([1, 3, 5, 2, 3, 6]) +[(-2, [(-3, 1), (1, 3)]), (-5, [(-6, 3), (3, 6)]), (9, [(0, 5)]), (4, [(0, 2)])] +>>> mobile.mobile([4, 6, 2, 3, 45, 6, 3, 6, 1, 8, 5, 3, 67, 24]) +[(-12, [(-67, 4), (-1, 45), (45, 1), (4, 67)]), (-10, [(-24, 6), (-8, 6), (6, 8), (6, 24)]), (44, [(0, 3), (-5, 2), (2, 5)]), (117, [(0, 6), (-3, 3), (3, 3)])] +``` diff --git a/doc/pong.md b/doc/pong.md new file mode 100644 index 0000000..5e3e553 --- /dev/null +++ b/doc/pong.md @@ -0,0 +1,7 @@ +Pong +==== + +Der Pong-Bot ist als 'TPong' des Benutzers 'tmo' angemeldet. +Der Bot berechnet die Flugbahn des Balls und versucht, diese mit einem Delta-X und Delta-Y verschiedener Messwerte hervorzusagen. Ist der Ball für eine Berechnung zu nahe, begibt sich der Schläger auf Höhe des Balls. + +Aufgrund Zeitmangels ist der Code nicht fertig geworden und der Bot erfüllt seine Funktion nicht perfekt. diff --git a/doc/zahlenspiel.md b/doc/zahlenspiel.md new file mode 100644 index 0000000..50768d8 --- /dev/null +++ b/doc/zahlenspiel.md @@ -0,0 +1,39 @@ +Zahlenspiel +=========== + +Die Aufgabe ließe sich mit `random`s `randrange()` lösen. Zu Beginn der Bruchsuche müssen `p` und `q` gefunden werden, die der Anforderung des Schwierigkeitsgrades entsprechen und sich, geschrieben als Bruch, nicht kürzen lassen. +Das Nicht-Kürzen-Lassen lässt sich mit dem Greatest Common Divisor (größter gemeinsamer Teiler) berechnen - ist er eins, lässt sich `p/q` nicht kürzen. +Um die Zahlen `p` `q` innerhalb der Schwierigkeitsgrenzen zu halten ist es sinnvoll, nach dem Generieren einer zufälligen Zahl `Maximum > p > 1` die Zahl `q` abhängig davon zu finden: `Maximum - p > q > Minimum - p` + +TODO Minimum - p? + +Als Nächstes gilt es, einen Bruch zu finden, der der Schwierigkeitsstufe entsprechend lang genug ist. Dazu sucht die Funktion, angefangen bei einem Wert von 2, nach einem `x` welches für eine zufriedenstellende Länge des Bruches sorgt. Schießt die Länge über das Ziel hinaus, wird ein neuer Bruch gesucht. + +`bruch(Stufe)` gibt die Variablen `a, b, p, q` zurück, mit denen ein Bruch `a/b = p/q` der Schwierigkeitsstufe gebildet werden kann. Durch `aufgaben(Stufe, Anzahl)` können mehrere Aufgaben der gleichen Stufe mit `print` ausgegeben werden. +Schwierigkeitsstufen gehen von 0 - leicht über 1 - mittel bis 2 - schwer. + +Beispiele +--------- + +``` +>>> import zahlenspiel +>>> zahlenspiel.aufgaben(1, 5) +75 / 105 = 5 / 7 +104 / 39 = 8 / 3 +100 / 10 = 10 / 1 +112 / 24 = 14 / 3 +108 / 45 = 12 / 5 +>>> zahlenspiel.aufgaben(2, 1) +49 / 105 = 7 / 15 +>>> zahlenspiel.aufgaben(0, 10) +60 / 10 = 6 / 1 +70 / 10 = 7 / 1 +10 / 15 = 2 / 3 +70 / 10 = 7 / 1 +10 / 40 = 1 / 4 +15 / 12 = 5 / 4 +10 / 50 = 1 / 5 +10 / 30 = 1 / 3 +20 / 12 = 5 / 3 +80 / 10 = 8 / 1 +``` diff --git a/faehre_fuellen.md b/faehre_fuellen.md deleted file mode 100644 index 125d5cd..0000000 --- a/faehre_fuellen.md +++ /dev/null @@ -1,76 +0,0 @@ -Fähre füllen -============ - -Die Lösung zu Fähre füllen beinhaltet wie gefordert zwei Strategien `strategie_a`, `strategie_b`. -Beide Funktionen nehmen eine Liste mit Autolängen als Eingabe und geben ein `dict` mit der Länge und Anzahl aller Autos zurück. Mit `print` wird angegeben, wo die Autos einsortiert werden. - -Strategie A ------------ - -Die Fahrzeuge werden möglichst weit links angeordnet. Am effizienten ist das bei einer Folge wie beispielsweise -``` -6, 6, 6, 15, 15, 15, ... -``` -da hierbei die meiste Anzahl an Fahrzeugen hineinpasst, verglichen mit B. - -Strategie B ------------ - -Die Fahrzeuge werden möglichst gleichmäßig auf die drei Spalten verteilt. Die Folge vom Beispiel in A) würde dazu führen, dass nur 3 Fahrzeuge (`6, 6, 6`) Platz hätten. In dem Beispiel -``` -8, 8, 8, 5, 5, 5, 5, 5, 5, ... -``` -werden für A) 8 Fahrzeuge eingeordnet und für B) 9. - -Beispiele ---------- - -``` ->>> # Optimales Beispiel für A ->>> import faehre_fuellen ->>> faehre_fuellen.strategie_a([15, 15, 15, 15, 15, 6, 6, 6]) -6 wurde eingeordnet in die Reihe 0 -6 wurde eingeordnet in die Reihe 0 -6 wurde eingeordnet in die Reihe 0 -15 wurde eingeordnet in die Reihe 1 -15 wurde eingeordnet in die Reihe 2 -Das Fahrzeug 15 hat nicht mehr gepasst -{'anzahl': [3, 1, 1], 'länge': [18, 15, 15]} ->>> faehre_fuellen.strategie_b([15, 15, 15, 15, 15, 6, 6, 6]) -6 wurde eingeordnet in Reihe 0 -6 wurde eingeordnet in Reihe 1 -6 wurde eingeordnet in Reihe 2 -Das Fahrzeug 15 hat nicht mehr gepasst -{'anzahl': [1, 1, 1], 'länge': [6, 6, 6]} ->>> ->>> # Optimales Beispiel für B ->>> faehre_fuellen.strategie_a([5, 5, 5, 5, 5, 5, 5, 8, 8, 8]) -... -Das Fahrzeug 5 hat nicht mehr gepasst -{'anzahl': [2, 3, 3], 'länge': [16, 18, 15]} ->>> faehre_fuellen.strategie_b([5, 5, 5, 5, 5, 5, 5, 8, 8, 8]) -... -Das Fahrzeug 5 hat nicht mehr gepasst -{'anzahl': [3, 3, 3], 'länge': [18, 18, 18]} ->>> ->>> ->>> # Gegebene Beispiele befinden sich in einer Liste `Beispiel` ->>> # (Die Ausgabe ist hier auf das Ergebnis beschränkt) ->>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[0]) -{'anzahl': [3, 3, 1], 'länge': [18.47, 16.09, 9.12]} ->>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[0]) -{'anzahl': [2, 3, 2], 'länge': [15.989999999999998, 19.2, 8.49]} ->>> # Beispiel 1: weder A) noch B) ist effizienter (jeweils 7 Fahrzeuge) ->>> ->>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[1]) -{'anzahl': [2, 3, 3], 'länge': [19.92, 16.48, 11.69]} ->>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[1]) -{'anzahl': [2, 3, 3], 'länge': [18.69, 18.04, 11.36]} ->>> # Beispiel 2: weder A) noch B) ist effizienter (jeweils 8 Fahrzeuge) ->>> ->>> faehre_fuellen.strategie_a(faehre_fuellen.Beispiel[2]) -{'anzahl': [5, 4, 3], 'länge': [18.91, 17.630000000000003, 12.780000000000001]} ->>> faehre_fuellen.strategie_b(faehre_fuellen.Beispiel[2]) -{'anzahl': [4, 4, 4], 'länge': [15.030000000000001, 16.86, 17.43]} ->>> # Beispiel 3: weder A) noch B) ist effizienter (jeweils 12 Fahrzeuge) -``` diff --git a/faehre_fuellen.py b/faehre_fuellen.py deleted file mode 100755 index 2c84b5d..0000000 --- a/faehre_fuellen.py +++ /dev/null @@ -1,100 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# getestet mit Python 2.7.8 und 3.4.2 -'''Stellt zwei Strategien zur Lösung der Fähre-Füllen-Aufgabe''' - -BEISPIEL = [] -BEISPIEL.append( - "5,23; 4,41; 3,33; 13,13; 9,12; 4,38; 6,34; 5,37; 4,11; 3,74; 10,62") -BEISPIEL.append( - "4,14; 3,63; 3,92; 7,95; 5,23; 3,30; 4,86; 15,06") -BEISPIEL.append("6,96; 5,06; 3,77; 3,95; 3,91; 3,54; 4,26; " + \ - "4,03; 5,43; 4,04; 4,43; 4,12; 2,78") - - -# das BEISPIEL wird geparst -for j in range(len(BEISPIEL)): - BEISPIEL[j] = [float(k.replace(",", ".")) for k in BEISPIEL[j].split("; ")] - -# vorgegebene Konstanten in Meter umgerechnet -FAEHRENLAENGE = 20 -FAEHRENBREITE = 3 -ABSTAND = 0.3 - -# `abfolge`: Eine Liste mit Längen von Autos -# gibt ein dict zurück, welches "anzahl" und "länge" aller Autos enthält -def strategie_a(vabfolge): - '''Sortiert eine Abfolge von Fahrzeugen möglichst weit links ein''' - abfolge = vabfolge[:] - # `faehre` hält die Anzahl an Fahrzeugen und deren Gesamtlänge in einem dict - faehre = {"anzahl": [0] * FAEHRENBREITE, "länge": [0] * FAEHRENBREITE} - - while len(abfolge): - success = False - # Fahrzeuge werden aus der Schlange gepopt - fahrzeug = abfolge.pop() - - # jetzt wird das Fahrzeug möglichst weit links eingeordnet - for k in range(FAEHRENBREITE): - # dazu wird bei allen Parkreihen überprüft, ob das Fahrzeug passt - if fahrzeug + faehre["länge"][k] < \ - FAEHRENLAENGE - ABSTAND * (faehre["anzahl"][k] - 1): - - faehre["länge"][k] += fahrzeug - faehre["anzahl"][k] += 1 - - print(str(fahrzeug) + " wurde eingeordnet in die Reihe " + \ - str(k)) - success = True - break - - if success == False: - print("Das Fahrzeug " + str(fahrzeug) + " hat nicht mehr gepasst") - # ...und abfahren - break - - # Wichtig: in `faehre["länge"][x]` ist der ABSTAND nicht einberechnet - return faehre - -# siehe `strategie_a` -def strategie_b(vabfolge): - '''Sortiert eine Abfolge von Fahrzeugen möglichst gleichmäßig ein''' - abfolge = vabfolge[:] - faehre = {"anzahl": [0] * FAEHRENBREITE, "länge": [0] * FAEHRENBREITE} - - spalte = 0 - while len(abfolge): - success = False - fahrzeug = abfolge.pop() - # Fahrzeuge werden möglichst gleichmäßig von links nach rechts verteilt - for k in range(FAEHRENBREITE): - diese_spalte = spalte + k - if diese_spalte >= FAEHRENBREITE: - diese_spalte -= FAEHRENBREITE - - if fahrzeug + faehre["länge"][diese_spalte] < FAEHRENLAENGE \ - - ABSTAND * (faehre["anzahl"][diese_spalte] - 1): - - faehre["länge"][diese_spalte] += fahrzeug - faehre["anzahl"][diese_spalte] += 1 - - print(str(fahrzeug) + " wurde eingeordnet in Reihe " + \ - str(diese_spalte)) - success = True - break - - if success == False: - print("Das Fahrzeug " + str(fahrzeug) + " hat nicht mehr gepasst") - break - - spalte += 1 - if spalte == FAEHRENBREITE: - spalte = 0 - - return faehre - -if __name__ == "__main__": - print("\n=== Strategie A ===\n") - print(strategie_a(BEISPIEL[0][:])) - print("\n=== Strategie B ===\n") - print(strategie_b(BEISPIEL[0][:])) diff --git a/faires_fuellen.md b/faires_fuellen.md deleted file mode 100644 index 7591b7b..0000000 --- a/faires_fuellen.md +++ /dev/null @@ -1,9 +0,0 @@ -Faires Füllen -============== - -Die Aufgabe ist unbearbeitet, nur Lösungsideen sind vorhanden. -Ideen zur Aufgabe: -* Lösen durch (rekursives) Probieren aller Kombinationen -* oder: sortieren nach Größe; nacheinander immer in das rechte Gefäß kippen und (anschließend) nach der richtigen Summe suchen; zurückkippen -* nur lösbar, wenn - * eine Differenz zweier Behälter Teiler der Hälfte der Flüssigkeit ist? diff --git a/mobile.md b/mobile.md deleted file mode 100644 index af55d3d..0000000 --- a/mobile.md +++ /dev/null @@ -1,42 +0,0 @@ -Mobile -====== - -Textuelle Darstellung ---------------------- - -Die textuelle Darstellung setzt sich aus einer Liste von Position-Gewichts-Tuples zusammen. Ein Gewicht ist hierbei ebenfalls eine Liste. Positionen sind auf der einen Seite negativ, auf der anderen positiv. -Ein Balken lässt sich daran erkennen, dass er mehr als ein Gewicht hat. Eine Figur ist an der Position 0 mit dem Gewicht der entsprechenden Figur. -Beispiel für ein Mobile mit einer Figur des Gewichts 2: `[(0, 2)]` -Beispiel für einen Balken mit zwei Figuren des Gewichts 3: `[(-3, 3), (3, 3)]` - -Das abgebildete Mobile sieht in der textuellen Darstellung wie folgt aus: -``` -[(-4, [(-2, [(0, 1)]), (1, [(0, 2)])]), (-1, [(0, 2)]), (2, [(0, 3)]), (4, [(0, 2)])] -``` - -Umsetzung ---------- - -Die Lösung besteht aus zwei Funktionen, `split(alle_Figuren_an_einem_Balken)`, welche eine textuelle Darstellung verteilt. Diese eingehende Darstellung ist ein einziger Balken mit allen Figuren, die mithilfe dieser Funktion ausgeglichen werden. Im Endergebnis hat dann jeder Balken maximal vier Gewichte. Die Liste, die zurückgegeben wird, ähnelt der textuellen Darstellung, jedoch ist statt der Position das Gewicht des Gewichts in dem Tuple enthalten. -Diese Liste wird von der zweiten Funktion `weight(Liste_erstellt_durch_split)` angeglichen. -Aus Benutzerfreundlichkeitsgründen fasst eine dritte Funktion `mobile(List)` diese zwei zusammen. Sie benötigt nur noch eine Liste aller Gewichte für das Mobile. - -Die Funktion `split` sortiert alle Items der mitgelieferten Liste in vier Plätze ein (realisiert mit dem Modulo-Operator). Das Gesamtgewicht dieser vier Plätze wird berchnet, dann wird jedes Gewicht in diesen vier Plätzen durch einen rekursiven Funktionsaufruf erneut verteilt. - -`weight` berechnet die Position mit der Gegenzahl des Gesamtewichts des Gewichts an der gegenüberliegenden Position. Ist die Anzahl an Gewichten auf dem Balken ungerade, wird ein Gewichte in die Mitte (Position 0) platziert. -Durch diese Verteilung gleichen sich die jeweils äußersten und innersten Gewichtpaare aus. Auch diese Funktion ruft sich selbst auf, um die Gewichte von der Spitze des Mobiles hinab bis zu den Figuren alle zu verteilen. - -Beispiele ---------- - -``` ->>> import mobile ->>> mobile.mobile([1, 4]) -[(-4, 1), (1, 4)] ->>> mobile.mobile([4, 6, 2, 3]) -[(-3, 4), (-2, 6), (6, 2), (4, 3)] ->>> mobile.mobile([1, 3, 5, 2, 3, 6]) -[(-2, [(-3, 1), (1, 3)]), (-5, [(-6, 3), (3, 6)]), (9, [(0, 5)]), (4, [(0, 2)])] ->>> mobile.mobile([4, 6, 2, 3, 45, 6, 3, 6, 1, 8, 5, 3, 67, 24]) -[(-12, [(-67, 4), (-1, 45), (45, 1), (4, 67)]), (-10, [(-24, 6), (-8, 6), (6, 8), (6, 24)]), (44, [(0, 3), (-5, 2), (2, 5)]), (117, [(0, 6), (-3, 3), (3, 3)])] -``` diff --git a/mobile.py b/mobile.py deleted file mode 100755 index 481325c..0000000 --- a/mobile.py +++ /dev/null @@ -1,76 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# getestet mit Python 2.7.8 und 3.4.2 -'''Verteilt und gleicht ein Mobile aus''' - -from math import floor - -# python list mit Elementen in der Form -# (Position, [Gewicht oder Liste]), -# wobei Position auf der linken Seite negativ ist -MOBILE = [(-4, [(-2, [(0, 1)]), (1, [(0, 2)])]), \ - (-1, [(0, 2)]), (2, [(0, 3)]), (4, [(0, 2)])] - -FIGUREN = [2, 3, 1, 2, 3] - -def split(fig): - '''gibt eine Liste zurück, in der die Elemente -aus `fig` auf 4er-Balken aufgeteilt sind''' - _fig = fig[:] - if len(_fig) > 4: - temp = [[] for j in range(4)] - for k, item in enumerate(_fig): - temp[k % 4].append(item) - - _fig = list(filter(None, temp)) - - temp = [] - for afig in _fig: - summe = 0 - for (_, k) in afig: - summe += k - - myweight = summe - # Gewicht Inhalt - temp.append((myweight, split(afig))) - - _fig = temp - return _fig - -def weight(fig): - '''gibt ein ausgeglichenes Mobile zurück''' - res = [] - - if len(fig) % 2 == 1: - # ist die Anzahl an Elementen ungerade, - # muss eines - hier das mittlerste - auf die Position 0 - middle = int(floor(len(fig) / 2)) - res.append((0, fig[middle][1])) - del fig[middle] - - for j in range(len(fig)): - # Die Position des Elements wird auf das Gewicht des - # gegenüberliegenden Elements gesetzt, sodass sich - # jeweils das Element mit dem Gegenüber ausgleicht - side = -1 if j < len(fig) / 2 else 1 - opposite = len(fig) - j - 1 - - figure = list(fig[j]) - if type(figure[1]) is list: - figure[1] = weight(figure[1]) - - # Position Inhalt - element = (fig[opposite][0] * side, figure[1]) - res.append(element) - - return res - -def mobile(liste): - '''erstellt ein Mobile aus einer Liste von Figuren''' - inp = list([(j, j) for j in liste]) # der Input wird aufbereitet - splitted = split(inp) - weighted = weight(splitted) - return weighted - -if __name__ == "__main__": - print(mobile(FIGUREN)) diff --git a/pong.md b/pong.md deleted file mode 100644 index 5e3e553..0000000 --- a/pong.md +++ /dev/null @@ -1,7 +0,0 @@ -Pong -==== - -Der Pong-Bot ist als 'TPong' des Benutzers 'tmo' angemeldet. -Der Bot berechnet die Flugbahn des Balls und versucht, diese mit einem Delta-X und Delta-Y verschiedener Messwerte hervorzusagen. Ist der Ball für eine Berechnung zu nahe, begibt sich der Schläger auf Höhe des Balls. - -Aufgrund Zeitmangels ist der Code nicht fertig geworden und der Bot erfüllt seine Funktion nicht perfekt. diff --git a/pong.py b/pong.py deleted file mode 100644 index 574253a..0000000 --- a/pong.py +++ /dev/null @@ -1,79 +0,0 @@ -# zustand.Ball -# Ball.xKoordinate() -# Ball.yKoordinate() -# -# zustand.listeBall() -# zustand.Schlaeger -# Schlaeger.identifikation() -# Schlaeger.yKoordinate() -# Schlaeger.punktzahl() -# zustand.listeSchlaeger() -# -# zug.ausgabe(text) -# zug.nachOben() -# zug.nachUnten() - -import math - -def zug(id, zustand, zug): - if not "round" in globals(): - # in der ersten Runde nur initialisieren - globals()["t_ballX"] = globals()["letztes_ballX"] = getBall(zustand).xKoordinate() - globals()["t_ballY"] = globals()["letztes_ballY"] = getBall(zustand).yKoordinate() - globals()["deltaX"] = globals()["deltaY"] = globals()["round"] = globals()["count"] = 0 - return - - globals()["round"] += 1 - -# zug.ausgabe("Runde " + str(globals()["round"])) - - globals()["t_ballX"] = getBall(zustand).xKoordinate() - globals()["t_ballY"] = getBall(zustand).yKoordinate() - - if (globals()["t_ballX"] < 15 and globals()["deltaX"] <= 0) or (globals()["t_ballX"] > 50 and globals()["deltaX"] >= 0) \ - or (globals()["t_ballY"] < 5) or (globals()["t_ballY"] > 55): - globals()["letztes_ballX"], globals()["letztes_ballY"] = globals()["t_ballX"], globals()["t_ballY"] - globals()["count"] = 0 - - if globals()["count"] != 0: - globals()["deltaX"] = float((globals()["t_ballX"] - globals()["letztes_ballX"]) / globals()["count"]) - globals()["deltaY"] = float((globals()["t_ballY"] - globals()["letztes_ballY"]) / globals()["count"]) - globals()["count"] += 1 - - bounces = 0 - if globals()["deltaX"] != 0: - schritte = abs(0 + globals()["t_ballX"] / globals()["deltaX"]) - #nach `schritte` Runden ist der Ball beim anderen Spieler - bounces = math.floor((globals()["t_ballY"] + abs(globals()["deltaY"] * schritte)) / 60) -# zug.ausgabe("Achtung: ") -# zug.ausgabe(bounces) -# zug.ausgabe(schritte) - - if globals()["deltaX"] < 0: - schritte = abs(0 - globals()["t_ballX"]) / globals()["deltaX"] - target_ballY = ((globals()["t_ballY"] + abs(globals()["deltaY"] * schritte)) % 60) - else: - target_ballY = 30 - - if globals()["t_ballX"] > 55 or globals()["t_ballX"] < 10: - target_ballY = globals()["t_ballY"] - - if getMe(zustand, id).yKoordinate() > target_ballY - 3: - zug.nachOben() - else: - if getMe(zustand, id).yKoordinate() < target_ballY - 3: - zug.nachUnten() - -### -def getMe(zustand, id): - if zustand.listeSchlaeger()[0].identifikation() == id: - return zustand.listeSchlaeger()[0] - return zustand.listeSchlaeger()[1] - -def getEnemy(zustand, id): - if zustand.listeSchlaeger()[0].identifikation() == id: - return zustand.listeSchlaeger()[1] - return zustand.listeSchlaeger()[0] - -def getBall(zustand): - return zustand.listeBall()[0] diff --git a/src/alphametiken.py b/src/alphametiken.py new file mode 100755 index 0000000..fb4324c --- /dev/null +++ b/src/alphametiken.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# getestet mit Python 2.7.8 und 3.4.2 +'''Generiert oder löst Alphametiken''' +# Nicht als root ausführen. +# Die Ausführung dauert bis zu zwei Minuten, abhängig von der Länge des +# Alphametiks. Die Generierung dauert unter Umständen 5 Minuten oder länger. + +# Programm löst das Alphametik "SUCHEN-MACHT=SPASS" +# und generiert eines mit einem Rechenzeichen + +import re, random + +ALPHAMETIK = "SUCHEN-MACHT=SPASS" + +ZAHLEN = ["EINS", "ZWEI", "DREI", "VIER", "FÜNF", \ + "SECHS", "SIEBEN", "ACHT", "NEUN", "ZEHN"] +#RECHENZEICHEN = ["+", "-", "*", "/"] +RECHENZEICHEN = ["+", "-"] # schneller + +def buchstaben_liste(wort): + '''Erstellt eine Liste der Buchstaben''' + buchstaben = [] + for char in wort: + if (char not in RECHENZEICHEN) \ + and (char not in buchstaben) \ + and (char not in " ="): + + buchstaben.append(char) + + return buchstaben + +def ersetze(buchst, wort, \ + benutzte_zahlen=None, loesungen=None, alle_buchstaben=None): + '''Ersetzt einen Buchstaben aus `buchst` in einem Wort `wort` \ +nacheinander durch `0-9` und ruft sich selbst auf. \ +Ist `buchst` leer, wird das Alphametik auf Richtigkeit getestet +und ggf. zu `loesungen` hinzugefügt. \ +Zurückgegeben wird eine Liste mit Lösungen. \ +Element der Liste ist der Rechnungsstring und ein dict.''' + + if alle_buchstaben == None: + alle_buchstaben = buchst + if benutzte_zahlen == None: + benutzte_zahlen = [] + if loesungen == None: + loesungen = [] + + if len(buchst): + for j in range(10): + if j in benutzte_zahlen: # jede Zahl nur einmal verwenden + continue + + m_benutzte_zahlen = benutzte_zahlen[:] + m_benutzte_zahlen.append(j) + + m_wort = wort.replace(buchst[0], str(j)) + ersetze(buchst[1:], m_wort, m_benutzte_zahlen, \ + loesungen, alle_buchstaben) + else: + if re.search(r"\b0", wort): + # 0 als erste Ziffer in einer Zahl ist nicht erlaubt + return + + if eval(wort.replace("=", "==")): + lsg = [wort, dict()] + for j, k in zip(alle_buchstaben, benutzte_zahlen): + lsg[1][j] = k + + loesungen.append(lsg) + + return loesungen + +def loese(alpham): + '''kleiner Wrapper, der die Benutzung von `ersetze` vereinfacht''' + return ersetze(buchstaben_liste(alpham), alpham, None, None, None) + +def generiere(laenge=1): + '''gibt ein zufälliges Alphametik mit `laenge` \ +"Ziffern" vor dem Gleichheitszeichen zurück''' + while True: + rechnung_ok = False + while rechnung_ok == False: # sucht nach wahren Gleichungen + alphametik = "x" + "_x" * laenge + "=y" # Template für Rechnung + + for j in range(laenge + 1): # zufällige Rechenzeichen einsetzen + alphametik = alphametik.replace("_", \ + random.choice(RECHENZEICHEN), 1) + + alphametik = alphametik.replace("y", str(random.randrange(1, 9))) + # Ergebnis + + for j in range(laenge + 2): + alphametik = alphametik.replace("x", \ + str(random.randrange(1, 9)), 1) + + rechnung_ok = eval(alphametik.replace("=", "==")) + + # jetzt passende Alphametiken suchen oder weitersuchen + for j in range(1, 10): + alphametik = alphametik.replace(str(j), ZAHLEN[j - 1]) + + loe = loese(alphametik) + if len(loe) > 0: + return alphametik # Geschafft, wir haben eines gefunden! + +if __name__ == "__main__": + LOESUNG = loese(ALPHAMETIK) + + if len(LOESUNG) == 0: + print("Keine Lösungen vorhanden") + else: + print("Es konnten folgende Lösungen gefunden werden:") + print(LOESUNG) + + print(generiere()) diff --git a/src/buffet_lotterie.py b/src/buffet_lotterie.py new file mode 100755 index 0000000..82a7796 --- /dev/null +++ b/src/buffet_lotterie.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# getestet mit Python 2.7.8 und 3.4.2 +'''Findet die optimale Lösung für die Buffet-Lotterie''' + +from math import floor + +ANZAHL_TEILNEHMER = 6 +SILBEN = ['In', 'for', 'ma', 'tik', 'kann', 'uns', 'wei', 'sen', 'wer', 'als', \ + 'Nächs', 'ter', 'kommt', 'zum', 'Spei', 'sen'] + +def denke(anzahl_teilnehmer, silben): + '''Findet die optimale Lösung für die Buffet-Lotterie''' + teilnehmer = anzahl_teilnehmer + fehlt_noch = float("inf") + einfluss = 0 + offset = 0 + while fehlt_noch > 0: + runden = floor((len(silben) + offset) / teilnehmer) + # runden Runden ist das Geburtstagskind dran, bis einer gehen darf + + offset = ((len(silben) + offset - 1) % teilnehmer) % (teilnehmer - 1) + # nach runden Runden fängt Teilnehmer Nummer `offset` an, + # 0 ist das Geburtstagskind + + einfluss += runden + # Geburtstagskind kann insgesamt `runden`-mal dem Essen näher kommen + fehlt_noch = (offset - 1) % (teilnehmer - 1) + 1 + # um jetzt dran sein zu müssen, hätte das Geburtstagskind + # `fehlt_noch`-mal zwei SILBEN sagen müssen + + print("Nach " + str(runden) + " Runden fängt der " + str(offset + 1) + \ + ". an. Es sind dann noch " + str(teilnehmer - 1) + \ + " Teilnehmer im Spiel.") + if runden > 0: # falls das Geburtstagskind dran kam + print("Es fehlten " + str(fehlt_noch) + " bis zum Geburtstagskind") + if fehlt_noch < einfluss: + print("Das Geburtstagskind muss erst " + str(fehlt_noch) + \ + "-mal 'zwei Silben' und dann nur noch 'eine Silbe'" + \ + "sagen, bis es dran ist.") + break + + teilnehmer -= 1 # einer geht + +if __name__ == "__main__": + denke(ANZAHL_TEILNEHMER, SILBEN) diff --git a/src/faehre_fuellen.py b/src/faehre_fuellen.py new file mode 100755 index 0000000..2c84b5d --- /dev/null +++ b/src/faehre_fuellen.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# getestet mit Python 2.7.8 und 3.4.2 +'''Stellt zwei Strategien zur Lösung der Fähre-Füllen-Aufgabe''' + +BEISPIEL = [] +BEISPIEL.append( + "5,23; 4,41; 3,33; 13,13; 9,12; 4,38; 6,34; 5,37; 4,11; 3,74; 10,62") +BEISPIEL.append( + "4,14; 3,63; 3,92; 7,95; 5,23; 3,30; 4,86; 15,06") +BEISPIEL.append("6,96; 5,06; 3,77; 3,95; 3,91; 3,54; 4,26; " + \ + "4,03; 5,43; 4,04; 4,43; 4,12; 2,78") + + +# das BEISPIEL wird geparst +for j in range(len(BEISPIEL)): + BEISPIEL[j] = [float(k.replace(",", ".")) for k in BEISPIEL[j].split("; ")] + +# vorgegebene Konstanten in Meter umgerechnet +FAEHRENLAENGE = 20 +FAEHRENBREITE = 3 +ABSTAND = 0.3 + +# `abfolge`: Eine Liste mit Längen von Autos +# gibt ein dict zurück, welches "anzahl" und "länge" aller Autos enthält +def strategie_a(vabfolge): + '''Sortiert eine Abfolge von Fahrzeugen möglichst weit links ein''' + abfolge = vabfolge[:] + # `faehre` hält die Anzahl an Fahrzeugen und deren Gesamtlänge in einem dict + faehre = {"anzahl": [0] * FAEHRENBREITE, "länge": [0] * FAEHRENBREITE} + + while len(abfolge): + success = False + # Fahrzeuge werden aus der Schlange gepopt + fahrzeug = abfolge.pop() + + # jetzt wird das Fahrzeug möglichst weit links eingeordnet + for k in range(FAEHRENBREITE): + # dazu wird bei allen Parkreihen überprüft, ob das Fahrzeug passt + if fahrzeug + faehre["länge"][k] < \ + FAEHRENLAENGE - ABSTAND * (faehre["anzahl"][k] - 1): + + faehre["länge"][k] += fahrzeug + faehre["anzahl"][k] += 1 + + print(str(fahrzeug) + " wurde eingeordnet in die Reihe " + \ + str(k)) + success = True + break + + if success == False: + print("Das Fahrzeug " + str(fahrzeug) + " hat nicht mehr gepasst") + # ...und abfahren + break + + # Wichtig: in `faehre["länge"][x]` ist der ABSTAND nicht einberechnet + return faehre + +# siehe `strategie_a` +def strategie_b(vabfolge): + '''Sortiert eine Abfolge von Fahrzeugen möglichst gleichmäßig ein''' + abfolge = vabfolge[:] + faehre = {"anzahl": [0] * FAEHRENBREITE, "länge": [0] * FAEHRENBREITE} + + spalte = 0 + while len(abfolge): + success = False + fahrzeug = abfolge.pop() + # Fahrzeuge werden möglichst gleichmäßig von links nach rechts verteilt + for k in range(FAEHRENBREITE): + diese_spalte = spalte + k + if diese_spalte >= FAEHRENBREITE: + diese_spalte -= FAEHRENBREITE + + if fahrzeug + faehre["länge"][diese_spalte] < FAEHRENLAENGE \ + - ABSTAND * (faehre["anzahl"][diese_spalte] - 1): + + faehre["länge"][diese_spalte] += fahrzeug + faehre["anzahl"][diese_spalte] += 1 + + print(str(fahrzeug) + " wurde eingeordnet in Reihe " + \ + str(diese_spalte)) + success = True + break + + if success == False: + print("Das Fahrzeug " + str(fahrzeug) + " hat nicht mehr gepasst") + break + + spalte += 1 + if spalte == FAEHRENBREITE: + spalte = 0 + + return faehre + +if __name__ == "__main__": + print("\n=== Strategie A ===\n") + print(strategie_a(BEISPIEL[0][:])) + print("\n=== Strategie B ===\n") + print(strategie_b(BEISPIEL[0][:])) diff --git a/src/mobile.py b/src/mobile.py new file mode 100755 index 0000000..481325c --- /dev/null +++ b/src/mobile.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# getestet mit Python 2.7.8 und 3.4.2 +'''Verteilt und gleicht ein Mobile aus''' + +from math import floor + +# python list mit Elementen in der Form +# (Position, [Gewicht oder Liste]), +# wobei Position auf der linken Seite negativ ist +MOBILE = [(-4, [(-2, [(0, 1)]), (1, [(0, 2)])]), \ + (-1, [(0, 2)]), (2, [(0, 3)]), (4, [(0, 2)])] + +FIGUREN = [2, 3, 1, 2, 3] + +def split(fig): + '''gibt eine Liste zurück, in der die Elemente +aus `fig` auf 4er-Balken aufgeteilt sind''' + _fig = fig[:] + if len(_fig) > 4: + temp = [[] for j in range(4)] + for k, item in enumerate(_fig): + temp[k % 4].append(item) + + _fig = list(filter(None, temp)) + + temp = [] + for afig in _fig: + summe = 0 + for (_, k) in afig: + summe += k + + myweight = summe + # Gewicht Inhalt + temp.append((myweight, split(afig))) + + _fig = temp + return _fig + +def weight(fig): + '''gibt ein ausgeglichenes Mobile zurück''' + res = [] + + if len(fig) % 2 == 1: + # ist die Anzahl an Elementen ungerade, + # muss eines - hier das mittlerste - auf die Position 0 + middle = int(floor(len(fig) / 2)) + res.append((0, fig[middle][1])) + del fig[middle] + + for j in range(len(fig)): + # Die Position des Elements wird auf das Gewicht des + # gegenüberliegenden Elements gesetzt, sodass sich + # jeweils das Element mit dem Gegenüber ausgleicht + side = -1 if j < len(fig) / 2 else 1 + opposite = len(fig) - j - 1 + + figure = list(fig[j]) + if type(figure[1]) is list: + figure[1] = weight(figure[1]) + + # Position Inhalt + element = (fig[opposite][0] * side, figure[1]) + res.append(element) + + return res + +def mobile(liste): + '''erstellt ein Mobile aus einer Liste von Figuren''' + inp = list([(j, j) for j in liste]) # der Input wird aufbereitet + splitted = split(inp) + weighted = weight(splitted) + return weighted + +if __name__ == "__main__": + print(mobile(FIGUREN)) diff --git a/src/pong.py b/src/pong.py new file mode 100644 index 0000000..574253a --- /dev/null +++ b/src/pong.py @@ -0,0 +1,79 @@ +# zustand.Ball +# Ball.xKoordinate() +# Ball.yKoordinate() +# +# zustand.listeBall() +# zustand.Schlaeger +# Schlaeger.identifikation() +# Schlaeger.yKoordinate() +# Schlaeger.punktzahl() +# zustand.listeSchlaeger() +# +# zug.ausgabe(text) +# zug.nachOben() +# zug.nachUnten() + +import math + +def zug(id, zustand, zug): + if not "round" in globals(): + # in der ersten Runde nur initialisieren + globals()["t_ballX"] = globals()["letztes_ballX"] = getBall(zustand).xKoordinate() + globals()["t_ballY"] = globals()["letztes_ballY"] = getBall(zustand).yKoordinate() + globals()["deltaX"] = globals()["deltaY"] = globals()["round"] = globals()["count"] = 0 + return + + globals()["round"] += 1 + +# zug.ausgabe("Runde " + str(globals()["round"])) + + globals()["t_ballX"] = getBall(zustand).xKoordinate() + globals()["t_ballY"] = getBall(zustand).yKoordinate() + + if (globals()["t_ballX"] < 15 and globals()["deltaX"] <= 0) or (globals()["t_ballX"] > 50 and globals()["deltaX"] >= 0) \ + or (globals()["t_ballY"] < 5) or (globals()["t_ballY"] > 55): + globals()["letztes_ballX"], globals()["letztes_ballY"] = globals()["t_ballX"], globals()["t_ballY"] + globals()["count"] = 0 + + if globals()["count"] != 0: + globals()["deltaX"] = float((globals()["t_ballX"] - globals()["letztes_ballX"]) / globals()["count"]) + globals()["deltaY"] = float((globals()["t_ballY"] - globals()["letztes_ballY"]) / globals()["count"]) + globals()["count"] += 1 + + bounces = 0 + if globals()["deltaX"] != 0: + schritte = abs(0 + globals()["t_ballX"] / globals()["deltaX"]) + #nach `schritte` Runden ist der Ball beim anderen Spieler + bounces = math.floor((globals()["t_ballY"] + abs(globals()["deltaY"] * schritte)) / 60) +# zug.ausgabe("Achtung: ") +# zug.ausgabe(bounces) +# zug.ausgabe(schritte) + + if globals()["deltaX"] < 0: + schritte = abs(0 - globals()["t_ballX"]) / globals()["deltaX"] + target_ballY = ((globals()["t_ballY"] + abs(globals()["deltaY"] * schritte)) % 60) + else: + target_ballY = 30 + + if globals()["t_ballX"] > 55 or globals()["t_ballX"] < 10: + target_ballY = globals()["t_ballY"] + + if getMe(zustand, id).yKoordinate() > target_ballY - 3: + zug.nachOben() + else: + if getMe(zustand, id).yKoordinate() < target_ballY - 3: + zug.nachUnten() + +### +def getMe(zustand, id): + if zustand.listeSchlaeger()[0].identifikation() == id: + return zustand.listeSchlaeger()[0] + return zustand.listeSchlaeger()[1] + +def getEnemy(zustand, id): + if zustand.listeSchlaeger()[0].identifikation() == id: + return zustand.listeSchlaeger()[1] + return zustand.listeSchlaeger()[0] + +def getBall(zustand): + return zustand.listeBall()[0] diff --git a/src/zahlenspiel.py b/src/zahlenspiel.py new file mode 100755 index 0000000..e8891f9 --- /dev/null +++ b/src/zahlenspiel.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# getestet mit Python 2.7.8 und 3.4.2 +'''Berechnet einen Bruch zur Übung des Kürzens''' + +from random import randrange + +def gcd(vala, valb): + '''Berechnet den größten gemeinsamen Teiler nach Euklid''' + while valb: + vala, valb = valb, vala % valb + return vala + +def bruch(stufe): + '''Berechnet einen ungekürzten Bruch vala/valb +mit gekürztem Bruch valp/valq nach Schwierigkeits`stufe`. +`stufe` ist 0 (leicht), 1 (mittel) oder 2 (schwer)''' + + length = 4 if stufe == 0 else 5 + + erfolg = False + while not erfolg: + suchen = True + while suchen: + valp = randrange(1, (stufe + 1) * 10) + valq = randrange(stufe * 10 - valp, (stufe + 1) * 10 - valp) + suchen = (gcd(valp, valq) != 1) # falls nicht kürzbar + + valx = 2 + suchen = True + while suchen: + vala, valb = valp * valx, valq * valx + + if len(str(vala)) + len(str(valb)) == length: + suchen = False + erfolg = True + else: + valx += 1 + if len(str(vala)) + len(str(valb)) > length: + suchen = erfolg = False # neue Zahlen generieren + + return vala, valb, valp, valq + +def aufgaben(stufe, anzahl): + '''gibt `anzahl` Aufgaben mit `stufe` (0 - leicht, 2 - schwer) aus''' + for _ in range(anzahl): + vala, valb, valp, valq = bruch(stufe) + print(str(vala) + " / " + str(valb) + \ + " = " + str(valp) + " / " + str(valq)) + +if __name__ == "__main__": + aufgaben(randrange(4), randrange(1, 10)) diff --git a/zahlenspiel.md b/zahlenspiel.md deleted file mode 100644 index 50768d8..0000000 --- a/zahlenspiel.md +++ /dev/null @@ -1,39 +0,0 @@ -Zahlenspiel -=========== - -Die Aufgabe ließe sich mit `random`s `randrange()` lösen. Zu Beginn der Bruchsuche müssen `p` und `q` gefunden werden, die der Anforderung des Schwierigkeitsgrades entsprechen und sich, geschrieben als Bruch, nicht kürzen lassen. -Das Nicht-Kürzen-Lassen lässt sich mit dem Greatest Common Divisor (größter gemeinsamer Teiler) berechnen - ist er eins, lässt sich `p/q` nicht kürzen. -Um die Zahlen `p` `q` innerhalb der Schwierigkeitsgrenzen zu halten ist es sinnvoll, nach dem Generieren einer zufälligen Zahl `Maximum > p > 1` die Zahl `q` abhängig davon zu finden: `Maximum - p > q > Minimum - p` - -TODO Minimum - p? - -Als Nächstes gilt es, einen Bruch zu finden, der der Schwierigkeitsstufe entsprechend lang genug ist. Dazu sucht die Funktion, angefangen bei einem Wert von 2, nach einem `x` welches für eine zufriedenstellende Länge des Bruches sorgt. Schießt die Länge über das Ziel hinaus, wird ein neuer Bruch gesucht. - -`bruch(Stufe)` gibt die Variablen `a, b, p, q` zurück, mit denen ein Bruch `a/b = p/q` der Schwierigkeitsstufe gebildet werden kann. Durch `aufgaben(Stufe, Anzahl)` können mehrere Aufgaben der gleichen Stufe mit `print` ausgegeben werden. -Schwierigkeitsstufen gehen von 0 - leicht über 1 - mittel bis 2 - schwer. - -Beispiele ---------- - -``` ->>> import zahlenspiel ->>> zahlenspiel.aufgaben(1, 5) -75 / 105 = 5 / 7 -104 / 39 = 8 / 3 -100 / 10 = 10 / 1 -112 / 24 = 14 / 3 -108 / 45 = 12 / 5 ->>> zahlenspiel.aufgaben(2, 1) -49 / 105 = 7 / 15 ->>> zahlenspiel.aufgaben(0, 10) -60 / 10 = 6 / 1 -70 / 10 = 7 / 1 -10 / 15 = 2 / 3 -70 / 10 = 7 / 1 -10 / 40 = 1 / 4 -15 / 12 = 5 / 4 -10 / 50 = 1 / 5 -10 / 30 = 1 / 3 -20 / 12 = 5 / 3 -80 / 10 = 8 / 1 -``` diff --git a/zahlenspiel.py b/zahlenspiel.py deleted file mode 100755 index e8891f9..0000000 --- a/zahlenspiel.py +++ /dev/null @@ -1,52 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# getestet mit Python 2.7.8 und 3.4.2 -'''Berechnet einen Bruch zur Übung des Kürzens''' - -from random import randrange - -def gcd(vala, valb): - '''Berechnet den größten gemeinsamen Teiler nach Euklid''' - while valb: - vala, valb = valb, vala % valb - return vala - -def bruch(stufe): - '''Berechnet einen ungekürzten Bruch vala/valb -mit gekürztem Bruch valp/valq nach Schwierigkeits`stufe`. -`stufe` ist 0 (leicht), 1 (mittel) oder 2 (schwer)''' - - length = 4 if stufe == 0 else 5 - - erfolg = False - while not erfolg: - suchen = True - while suchen: - valp = randrange(1, (stufe + 1) * 10) - valq = randrange(stufe * 10 - valp, (stufe + 1) * 10 - valp) - suchen = (gcd(valp, valq) != 1) # falls nicht kürzbar - - valx = 2 - suchen = True - while suchen: - vala, valb = valp * valx, valq * valx - - if len(str(vala)) + len(str(valb)) == length: - suchen = False - erfolg = True - else: - valx += 1 - if len(str(vala)) + len(str(valb)) > length: - suchen = erfolg = False # neue Zahlen generieren - - return vala, valb, valp, valq - -def aufgaben(stufe, anzahl): - '''gibt `anzahl` Aufgaben mit `stufe` (0 - leicht, 2 - schwer) aus''' - for _ in range(anzahl): - vala, valb, valp, valq = bruch(stufe) - print(str(vala) + " / " + str(valb) + \ - " = " + str(valp) + " / " + str(valq)) - -if __name__ == "__main__": - aufgaben(randrange(4), randrange(1, 10)) -- cgit v1.3.1