diff --git a/app/app.py b/app/app.py index 5c25f82..9f24f51 100644 --- a/app/app.py +++ b/app/app.py @@ -93,11 +93,32 @@ def auswahl_verarbeiten(): elif auswahl == "BIN->ASCII-Text": st.session_state.output_text = tools.bin_to_ascii(text) st.session_state.map_data = None - elif auswahl == "REPLACE": - st.session_state.output_text = tools.REPLACE(text) + elif auswahl == "Zahlwortsuche-DE (0-12)": + st.session_state.output_text = tools.zahlwortsuche_de(text) st.session_state.map_data = None - elif auswahl == "REPLACE": - st.session_state.output_text = tools.REPLACE(text) + elif auswahl == "Zahlwortsuche-EN (0-15)": + st.session_state.output_text = tools.zahlwortsuche_en(text) + st.session_state.map_data = None + elif auswahl == "KENNYspeak kodieren": + st.session_state.output_text = tools.kenny_kodieren(text) + st.session_state.map_data = None + elif auswahl == "KENNYspeak dekodieren": + st.session_state.output_text = tools.kenny_dekodieren(text) + st.session_state.map_data = None + elif auswahl == "KENNYspeak raten": + st.session_state.output_text = tools.kenny_raten(text) + st.session_state.map_data = None + elif auswahl == "Primz.Alpha dekodieren": + st.session_state.output_text = tools.primzahlalphabet_dekodieren(text) + st.session_state.map_data = None + elif auswahl == "ist (n.te) Primzahl?": + st.session_state.output_text = tools.primzahlpruefen(text) + st.session_state.map_data = None + elif auswahl == "zeige n.te Primzahl": + st.session_state.output_text = tools.nte_primzahl(text) + st.session_state.map_data = None + elif auswahl == "Primfaktorenzerlegung": + st.session_state.output_text = tools.primfaktoren(text) st.session_state.map_data = None elif auswahl == "REPLACE": st.session_state.output_text = tools.REPLACE(text) @@ -156,6 +177,15 @@ option = st.sidebar.radio("hidden_label", "HEX->ASCII-Text", "DEZ->ASCII-Text", "Octal->ASCII-Text", + "Zahlwortsuche-DE (0-12)", + "Zahlwortsuche-EN (0-15)", + "KENNYspeak kodieren", + "KENNYspeak dekodieren", + "KENNYspeak raten", + "Primz.Alpha dekodieren", + "ist (n.te) Primzahl?", + "zeige n.te Primzahl", + "Primfaktorenzerlegung", "", "", "", diff --git a/app/helper.py b/app/helper.py index af60627..2dd245e 100644 --- a/app/helper.py +++ b/app/helper.py @@ -1,4 +1,6 @@ import math +from re import match # für unkennify +import streamlit as st # ***recursive quersummenfunktion*** def q_sum(n): @@ -20,6 +22,7 @@ def iq_sum(n): # ***produziert eine Liste mit Primzahlen kleiner als grenze*** # ***nach dem Prinzip des "Sieb des Eratosthenes"*** +@st.cache_resource def primzahlliste(grenze): primes = [] is_prime = [True] * grenze @@ -36,6 +39,7 @@ def primzahlliste(grenze): # ***alle permutationen generieren*** +@st.cache_resource def all_perms(liste): if len(liste) <= 1: yield liste @@ -154,3 +158,24 @@ def rwig_to_coords(a, b, c): + (c % 100000 - c % 10000) / 100000000 + (b % 100000 - b % 10000) / 1000000000) return round(lat, 5), round(lon, 5) + +def unkennify(text): + # Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py + decoded = '' + codemap = str.maketrans('MmPpFf', '001122') + n_len = len(text) + i = 0 + while i + 3 <= n_len: + if match('[MmPpFf]{3,}', text[i:i + 3]): + num = int(text[i:i + 3].translate(codemap), 3) # 'mpf' -> '012' -> 5 + cypher = chr(num + ord('a')) # 5 -> 'f' + if text[i].isupper(): + cypher = cypher.upper() + decoded = decoded + cypher + i = i + 3 + else: + decoded = decoded + text[i] + i = i + 1 + if i < n_len: + decoded = decoded + text[i:] + return decoded \ No newline at end of file diff --git a/app/tools.py b/app/tools.py index 068ad24..b2e9c28 100644 --- a/app/tools.py +++ b/app/tools.py @@ -1,3 +1,4 @@ +from itertools import chain import helper import pandas as pd @@ -674,19 +675,13 @@ def bin_to_ascii(eingabetext): ausgabetext += atxt return ausgabetext -''' -def zahlwortsuche_de(): - - eingabetext = Eingabe.get(1.0, END) +def zahlwortsuche_de(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche DE 0-12] -Diese Funktion versucht deutsche Zahlworte -zwischen 0 und 12 in einem Text aufzuspüren. -Da alle Zeichen ignoriert werden, welche -keine Buchstaben sind, werden auch Zahlwörter -gefunden welche sich z.B. über zwei Worte -verteilen.""" + "\n\n") + return ("### Zahlwortsuche DE 0-12\n" + "Diese Funktion versucht deutsche Zahlworte zwischen 0 und 12 in einem Text aufzuspüren. Da alle " + "Zeichen ignoriert werden, welche keine Buchstaben sind, werden auch Zahlwörter gefunden welche sich " + "z.B. über zwei Worte verteilen.") else: zahlen = ["null", "eins", "zwei", "drei", "vier", "fünf", "fuenf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf", "zwoelf", "zwanzig", "hundert", "tausend"] @@ -711,26 +706,21 @@ verteilen.""" + "\n\n") if tt: atxt = atxt + b if atxt == "": - Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re") + return "Leider keine Zahlwörter gefunden!" else: - Ausgabe.insert(1.0, ntxt + "\n") - Ausgabe.insert(1.0, "Eingangstext:", "bu") - Ausgabe.insert(1.0, atxt + "\n\n") - Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu") + ausgabetext = "_Gefundene Zahlwörter:_ \n" + ausgabetext += atxt + " \n" + ausgabetext += "_Eingangstext:_ \n" + ausgabetext += ntxt + return ausgabetext - -def zahlwortsuche_en(): - - eingabetext = Eingabe.get(1.0, END) +def zahlwortsuche_en(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche EN 0-15] -Diese Funktion versucht englische Zahlworte -zwischen 0 und 15 in einem Text aufzuspüren. -Da alle Zeichen ignoriert werden, welche -keine Buchstaben sind, werden auch Zahlwörter -gefunden welche sich z.B. über zwei Worte -verteilen.""" + "\n\n") + return ("### Zahlwortsuche EN 0-15\n" + "Diese Funktion versucht englische Zahlworte zwischen 0 und 15 in einem Text aufzuspüren. " + "Da alle Zeichen ignoriert werden, welche keine Buchstaben sind, werden auch Zahlwörter gefunden " + "welche sich z.B. über zwei Worte verteilen.") else: zahlen = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "fourty", "sixty", "seventy", "eighty", "ninety", "zero", "one", "two", "three", "four", "five", "six", "seven", @@ -756,15 +746,15 @@ verteilen.""" + "\n\n") if tt: atxt = atxt + b if atxt == "": - Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re") + return "Leider keine Zahlwörter gefunden!" else: - Ausgabe.insert(1.0, ntxt + "\n") - Ausgabe.insert(1.0, "Eingangstext:", "bu") - Ausgabe.insert(1.0, atxt + "\n\n") - Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu") + ausgabetext = "_Gefundene Zahlwörter:_ \n" + ausgabetext += atxt + " \n" + ausgabetext += "_Eingangstext:_ \n" + ausgabetext += ntxt + return ausgabetext - -def kenny_kodieren(): +def kenny_kodieren(eingabetext): alphabet = {"a": "mmm", "b": "mmp", "c": "mmf", "d": "mpm", "e": "mpp", "f": "mpf", "g": "mfm", "h": "mfp", "i": "mff", "j": "pmm", "k": "pmp", "l": "pmf", "m": "ppm", "n": "ppp", "o": "ppf", "p": "pfm", "q": "pfp", "r": "pff", "s": "fmm", @@ -777,18 +767,12 @@ def kenny_kodieren(): "Y": "Ffm", "Z": "Ffp", "Ä": "Mmmmpp", "Ö": "Ppfmpp", "Ü": "Fmfmpp" } - - eingabetext = Eingabe.get(1.0, END) eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Kennyspeak codieren] -Hilfe sie haben Kenny getötet.. ach nee er kann -ja noch seine unverständlichen m p f -Laute von -sich geben und hier geht es darum normalen -Text in genau diese Laute umzusetzen, wo jedem -Buchstaben A-Z eine 3 Zeichen-Kombination -zugeordnet ist die sich aus m,p,f -zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n") + return ("### Kennyspeak kodieren\n" + "Hilfe sie haben Kenny getötet.. ach nee er kann ja noch seine unverständlichen m p f -Laute von " + "sich geben und hier geht es darum normalen Text in genau diese Laute umzusetzen, wo jedem Buchstaben " + "A-Z eine 3 Zeichen-Kombination zugeordnet ist die sich aus m,p,f zusammensetzt.(a=mmm h=mfp x=fpf)") else: atxt = "" for b in eingabetext: @@ -796,65 +780,34 @@ zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n") atxt = atxt + alphabet[b] else: atxt = atxt + b - Ausgabe.insert(1.0, atxt + "\n") + return atxt - -def unkennify(text): - # Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py - decoded = '' - codemap = str.maketrans('MmPpFf', '001122') - n_len = len(text) - i = 0 - while i + 3 <= n_len: - if match('[MmPpFf]{3,}', text[i:i + 3]): - num = int(text[i:i + 3].translate(codemap), 3) # 'mpf' -> '012' -> 5 - cypher = chr(num + ord('a')) # 5 -> 'f' - if text[i].isupper(): - cypher = cypher.upper() - decoded = decoded + cypher - i = i + 3 - else: - decoded = decoded + text[i] - i = i + 1 - if i < n_len: - decoded = decoded + text[i:] - return decoded - - -def kenny_dekodieren(): - - eingabetext = Eingabe.get(1.0, END) +def kenny_dekodieren(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Kennyspeak decodieren] -Wie? Du verstehst Kenny's mpf-Gebrabbel nicht? -Na gut da kann ich helfen!! -Nicht kennifiziertes wird unverändert ausgegeben.""" + "\n\n") + return ("### Kennyspeak dekodieren\n" + "Wie? Du verstehst Kenny's mpf-Gebrabbel nicht? Na gut da kann ich helfen!! Nicht kennifiziertes " + "wird unverändert ausgegeben.") else: - Ausgabe.insert(1.0, unkennify(eingabetext) + "\n") + return helper.unkennify(eingabetext) - -def kenny_raten(): +def kenny_raten(eingabetext): wbk = {"000": "a", "001": "b", "002": "c", "010": "d", "011": "e", "012": "f", "020": "g", "021": "h", "022": "i", "100": "j", "101": "k", "102": "l", "110": "m", "111": "n", "112": "o", "120": "p", "121": "q", "122": "r", "200": "s", "201": "t", "202": "u", "210": "v", "211": "w", "212": "x", "220": "y", "221": "z" } - - eingabetext = Eingabe.get(1.0, END) eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [KENNYspeak raten] -Diese Funktion dient zum dekodieren von kennyfizierten -Texten, bei denen die 3 Buchstaben mpf vertauscht oder durch -andere Zeichen ersetzt wurden. Hierzu werden vor der -Dekodierung die 3 häufigsten Zeichen im Text ermittelt und -alle anderen Zeichen entfernt bevor die 6 möglichen Lösungen -ausgegeben werden. -(Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden, -werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n") + return ("### KENNYspeak raten\n" + "Diese Funktion dient zum dekodieren von kennyfizierten Texten, bei denen die 3 Buchstaben mpf " + "vertauscht oder durch andere Zeichen ersetzt wurden. Hierzu werden vor der Dekodierung die 3 " + "häufigsten Zeichen im Text ermittelt und alle anderen Zeichen entfernt bevor die 6 möglichen " + "Lösungen ausgegeben werden. (Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden, werden " + "sie durch Buchstaben a,b,c.. ersetzt)") else: wtxt = "" + ausgabetext = "" for b in eingabetext: if b == chr(9) or b == chr(32) or b == chr(10): continue # erstmal leerzeichen, tab, linefeed raus @@ -886,7 +839,7 @@ werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n") cwtxt = cwtxt.replace(abc3[i], j) abc3[i] = j break - for p in all_perms(abc3): + for p in helper.all_perms(abc3): txt0 = cwtxt.replace(p[0], "0") txt1 = txt0.replace(p[1], "1") txt2 = txt1.replace(p[2], "2") @@ -895,25 +848,20 @@ werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n") tri = txt2[i:i + 3] if tri in wbk: atxt = atxt + wbk[tri] - Ausgabe.insert(1.0, "{}\n".format(atxt)) - Ausgabe.insert(1.0, "{}\n".format(p), "bu") + ausgabetext += f"_{p}_ \n" + ausgabetext += f"{atxt} \n" + return ausgabetext - -def primzahlalphabet_dekodieren(): - - eingabetext = Eingabe.get(1.0, END) +def primzahlalphabet_dekodieren(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Primzahlalphabet dekodieren] -Hier können Primzahlen kleiner als 1 Million -in Buchstaben umgewandelt werden. Es wird dabei -davon ausgegangen, daß den Primzahlen -wiederholend die Buchstaben A-Z zugeordnet -werden,2=A 3=B 5=C 7=D 11=E....... -....97=Y 101=Z 103=A 107=B ... usw.""" + "\n\n") + return ("### Primzahlalphabet dekodieren\n" + "Hier können Primzahlen kleiner als 1 Million in Buchstaben umgewandelt werden. Es wird dabei davon " + "ausgegangen, daß den Primzahlen wiederholend die Buchstaben A-Z zugeordnet werden,2=A 3=B 5=C 7=D " + "11=E ... 97=Y 101=Z 103=A 107=B ... usw.") else: grenze = 1000000 - primes = primzahlliste(grenze) + primes = helper.primzahlliste(grenze) pdict = {} bz = 65 for p in primes: @@ -932,14 +880,14 @@ werden,2=A 3=B 5=C 7=D 11=E....... try: ausz = int(eingabetext) except ValueError: - Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n", - "re") + return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!" else: if ausz in pdict: - Ausgabe.insert(1.0, pdict[ausz] + "\n") + return pdict[ausz] else: - Ausgabe.insert(1.0, eingabetext + " ist keine Primzahl oder größer als 1 Million!\n") + return eingabetext + " ist keine Primzahl oder größer als 1 Million!" else: + ausgabetext = "" txt = eingabetext.split(se) atxt = "" ignor = "" @@ -953,111 +901,84 @@ werden,2=A 3=B 5=C 7=D 11=E....... atxt = atxt + pdict[az] else: ignor = ignor + str(z) + " " - Ausgabe.insert(1.0, atxt + "\n") - Ausgabe.insert(1.0, "umgewandelte Zahlen:\n", "bu") if ignor != "": - Ausgabe.insert(1.0, ignor + "\n") - Ausgabe.insert(1.0, "ignoriert wurde:\n", "re") + ausgabetext += "_ignoriert wurde:_ \n" + ausgabetext += ignor + " \n" + ausgabetext += "_umgewandelte Zahlen:_ \n" + ausgabetext += atxt + return ausgabetext - -def primzahlpruefen(): - - eingabetext = Eingabe.get(1.0, END) +def primzahlpruefen(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Primzahl prüfen] -Für eine eingegebene Zahl wird überprüft, -ob es sich um eine Primzahl handelt. -Ist die eingegebene Zahl eine Primzahl -wird auch informiert, die wievielte -Primzahl es ist. -Zahlen über 1299709 (der 100000. Primzahl) -werden abgelehnt.""" + "\n\n") + return ("### Primzahl prüfen\n" + "Für eine eingegebene Zahl wird überprüft, ob es sich um eine Primzahl handelt. Ist die eingegebene " + "Zahl eine Primzahl wird auch informiert, die wievielte Primzahl es ist. Zahlen über 1299709 (der " + "100000. Primzahl) werden abgelehnt.") else: try: ausz = int(eingabetext) except ValueError: - Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re") + return "Keine Zahl erkannt!" else: if ausz > 1299709: - Ausgabe.insert(1.0, - "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen" - " bis maximal 1299709 !\n", "re") - return - primes = primzahlliste(1299710) + return ("Sorry, aber ich mag nur die ersten 100000 Primzahlen, das sind Zahlen bis maximal " + "1299709 !") + primes = helper.primzahlliste(1299710) if ausz not in primes: - Ausgabe.insert(1.0, "{} ist keine Primzahl\n".format(ausz)) + return f"{ausz} ist keine Primzahl" else: - Ausgabe.insert(1.0, "{} ist die {}. Primzahl\n".format(ausz, primes.index(ausz) + 1)) + return f"{ausz} ist die {primes.index(ausz) + 1}. Primzahl" - -def nte_primzahl(): - - eingabetext = Eingabe.get(1.0, END) +def nte_primzahl(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [n.te Primzahl] -Du willst wissen wie z.B. die 1000. Primzahl lautet, -dann bist du hier genau richtig. -Die Funktion liefert maximal die 100000. Primzahl. -""" + "\n\n") + return ("### n.te Primzahl\n" + "Du willst wissen wie z.B. die 1000. Primzahl lautet, dann bist du hier genau richtig. Die Funktion " + "liefert maximal die 100000. Primzahl.") else: try: ausz = int(eingabetext) except ValueError: - Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re") + return "Keine Zahl erkannt!" + if ausz > 100000: + return "Sorry, aber ich mag nur die ersten 100000 Primzahlen, das sind Zahlen bis maximal 1299709 !" else: - if ausz > 100000: - Ausgabe.insert(1.0, - "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen bis" - " maximal 1299709 !\n", "re") - return - primes = primzahlliste(1299710) - Ausgabe.insert(1.0, "Die {}. Primzahl lautet:{}\n".format(ausz, primes[ausz - 1])) + primes = helper.primzahlliste(1299710) + return f"Die {ausz}. Primzahl lautet:{primes[ausz - 1]}" - -def primfaktoren(): - hilfetext = """HILFE: [Primfaktorenzerlegung] -Für die eingegebene Zahl werden die Primfaktoren ermittelt -und ausgegeben. Sollte die Zahl einen Primfaktoren haben, welcher -größer als 100 Millionen ist, wird die Suche abgebrochen, da die -Suche sonst zu lange dauert. -Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200 -Millionen, dazu benutzen um festzustellen, ob die eingegebene Zahl eine -Primzahl ist. -""" - - eingabetext = Eingabe.get(1.0, END) +def primfaktoren(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, hilfetext + "\n") + return ("### Primfaktorenzerlegung\n" + "Für die eingegebene Zahl werden die Primfaktoren ermittelt und ausgegeben. Sollte die Zahl einen " + "Primfaktoren haben, welcher größer als 100 Millionen ist, wird die Suche abgebrochen, da die Suche " + "sonst zu lange dauert. Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200 Millionen, " + "dazu benutzen um festzustellen, ob die eingegebene Zahl eine Primzahl ist.") else: try: n = int(eingabetext) except ValueError: - Ausgabe.insert(1.0, "Es konnte leider keine Zahl erkannt werden.\n", "re") - return + return "Es konnte leider keine Zahl erkannt werden." faktoren = [] for i in chain([2], range(3, n // 2 + 1, 2)): if i > 100000000: - Ausgabe.insert(1.0, - "Sorry, aber die Primfaktorensuche wurde abgebrochen,\nda mindestens 1 Faktor" - " größer als 100 Millionen ist.\n", "re") - return + return ("Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als " + "100 Millionen ist.") while n % i == 0: faktoren.append(i) n = n // i if i > n: break - out = "Die Zahl {} hat folgende Primfaktoren:\n".format(eingabetext) + out = f"_Die Zahl {eingabetext} hat folgende Primfaktoren:_ \n" if not faktoren: - Ausgabe.insert(1.0, "Die Zahl {} ist eine Primzahl!!\n".format(eingabetext)) + return f"Die Zahl {eingabetext} ist eine Primzahl!!" else: for z in faktoren: out += str(z) + ", " - return Ausgabe.insert(1.0, out[:-2] + "\n") - + return out[:-2] +''' def deztohexoctbin(): seperator = ("|,", "_", "/", ";", ",")