tebarius/Mysteryhelfer-web
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kenny + primzahlen

Browse Source
This commit is contained in:
Martin Kayser
2025-07-22 23:41:04 +02:00
parent 76caa8a218
commit 3edee3c19e
3 changed files with 153 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
app/app.py
View File

@@ -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",
"",
"",
"",

25
app/helper.py
View File

@@ -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

267
app/tools.py
View File

@@ -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 = ("|,", "_", "/", ";", ",")