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

PSE, Nak-Nak, Navajo, PI

Browse Source 
and patching favicon.ico and index.html in streamlit-lib
This commit is contained in:
Martin Kayser
2025-07-23 20:51:02 +02:00
parent 8b5cd8c10e
commit aa153c4ec9
5 changed files with 261 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
app/app.py
View File

@@ -7,8 +7,9 @@ standard_output = ('#### Um den HILFE-Text zu einzelnen Funktionen aufzurufen bi
' Eingabefeld aufrufen.')
st.set_page_config(
page_title="tebarius Mysteryhelfer (web)",
page_icon="./favicon.ico",
# we do this by patching static-files of streamlit in the container
# page_title="tebarius Mysteryhelfer (web)",
# page_icon="./favicon.ico",
layout="wide"
)
@@ -144,6 +145,21 @@ def auswahl_verarbeiten():
elif auswahl == "Slash and Pipe->Text":
st.session_state.output_text = tools.slashpipe_to_text(text)
st.session_state.map_data = None
elif auswahl == "PSE: O.zahl<->Symbol":
st.session_state.output_text = tools.periodensystem(text)
st.session_state.map_data = None
elif auswahl == "Nak-Nak -> Text":
st.session_state.output_text = tools.naknak_to_text(text)
st.session_state.map_data = None
elif auswahl == "Navajo -> Text":
st.session_state.output_text = tools.navajo_to_text(text)
st.session_state.map_data = None
elif auswahl == "Kreiszahl PI":
st.session_state.output_text = tools.pi_suche(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
st.session_state.map_data = None
@@ -212,6 +228,15 @@ option = st.sidebar.radio("hidden_label",
"Tomtom->Text",
"Text->Slash and Pipe",
"Slash and Pipe->Text",
"PSE: O.zahl<->Symbol",
"Nak-Nak -> Text",
"Navajo -> Text",
"Kreiszahl PI",
"",
"",
"",
"",
"",
"",
),
key='option',

416
app/tools.py
View File

@@ -1,6 +1,7 @@
from itertools import chain
from itertools import chain # für primfaktoren zerlegung
import helper
import pandas as pd
from urllib.parse import unquote as urllib_parse_unquote # für nak-nak
def funktion_mit_karte(text,param):
"""Verarbeitet Text und liefert Daten für eine Karte (z.B. Potsdam Zentrum)."""
@@ -978,7 +979,6 @@ def primfaktoren(eingabetext):
out += str(z) + ", "
return out[:-2]
def dez_to_hex_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
@@ -1025,7 +1025,6 @@ def dez_to_hex_oct_bin(eingabetext):
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
return ausgabetext
def hex_to_dez_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
@@ -1221,7 +1220,6 @@ def tomtom_to_abc(eingabetext):
atxt = atxt + alphabet[sign]
return atxt
def text_to_slashpipe(eingabetext):
alphabet = {"a": "| ", "b": "|\\\\ ", "c": "|| ", "d": "|/ ", "e": "\\\\ ", "f": "||\\\\ ", "g": "||| ",
"h": "\\\\\\\\ ", "i": "/ ", "j": "|\\\\\\\\ ", "k": "//|| ", "l": "|\\\\/ ", "m": "|\\\\| ",
@@ -1276,8 +1274,7 @@ def slashpipe_to_text(eingabetext):
atxt = atxt + alphabet[sign]
return atxt
'''
def periodensystem():
def periodensystem(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
pse = {1: "H", 2: "He", 3: "Li", 4: "Be", 5: "B", 6: "C", 7: "N", 8: "O", 9: "F", 10: "Ne", 11: "Na", 12: "Mg",
13: "Al",
@@ -1294,23 +1291,16 @@ def periodensystem():
103: "Lr", 104: "Rf", 105: "Db", 106: "Sg", 107: "Bh", 108: "Hs", 109: "Mt", 110: "Ds", 111: "Rg", 112: "Cn",
113: "Nh", 114: "Fl", 115: "Mc", 116: "Lv", 117: "Ts", 118: "Og"}
um_pse = {v: k for k, v in pse.items()}
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Periodensystem: Ordnungszahl<->Symbol]
Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der
Elemente werden in die ihnen zugehörigen Elementsymbole umgewandelt
und anschließend als Text ausgegeben, außerdem erscheint noch eine
Ausgabe bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben
werden.
Werden in der Eingabe Symbole (z.B. N, He) erkannt werde diese
zusammen mit ihren Ordnungszahlen ausgegeben.
Als Trennungszeichen zwischen den Zahlen und/oder Symbolen sind
folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen.
Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen
zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden
sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
return ("### Periodensystem: Ordnungszahl<->Symbol\n"
"Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der Elemente werden in die ihnen zugehörigen "
"Elementsymbole umgewandelt und anschließend als Text ausgegeben, außerdem erscheint noch eine Ausgabe "
"bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben werden. Werden in der Eingabe Symbole "
"(z.B. N, He) erkannt werde diese zusammen mit ihren Ordnungszahlen ausgegeben. Als Trennungszeichen "
"zwischen den Zahlen und/oder Symbolen sind folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen. "
"Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen zwischen den Zahlen verwendet "
"werden (überzählige Leerzeichen werden sonst als nicht erkannte Zeichen behandelt).")
else:
se = ""
for s in seperator:
@@ -1323,12 +1313,13 @@ sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
ausz = int(eingabetext)
except ValueError:
if eingabetext in um_pse:
Ausgabe.insert(1.0, str(um_pse[eingabetext]) + "\n")
return str(um_pse[eingabetext])
else:
Ausgabe.insert(1.0, "Keine gültige Eingabe erkannt!\n", "re")
return "Keine gültige Eingabe erkannt!"
else:
Ausgabe.insert(1.0, pse[ausz] + "\n")
return pse[ausz]
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
atxt2 = ""
@@ -1344,159 +1335,34 @@ sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
ignor = ignor + z + " "
else:
if az in pse:
atxt = atxt + pse[az]
atxt = atxt + pse[az] + " "
atxt2 = atxt2 + pse[az][0]
else:
ignor = ignor + z + " "
if atxt3 != "":
Ausgabe.insert(1.0, " " + atxt3 + "\n")
Ausgabe.insert(1.0, "Symbol:Ordnungszahl:", "bu")
if atxt2 != "":
Ausgabe.insert(1.0, " " + atxt2 + "\n")
Ausgabe.insert(1.0, "Nur Anfangsbuchstaben:", "bu")
if atxt != "":
Ausgabe.insert(1.0, " " + atxt + "\n")
Ausgabe.insert(1.0, "Symbole:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
ausgabetext += "_Achtung nicht erkannte Zeichen:_ \n" + ignor + " \n"
if atxt != "":
ausgabetext += "_Symbole:_ \n" + atxt + " \n"
if atxt2 != "":
ausgabetext += "_Nur Anfangsbuchstaben:_ \n" + atxt2 + " \n"
if atxt3 != "":
ausgabetext += "_Symbol:Ordnungszahl_ \n" + atxt3 + " \n"
return ausgabetext
def brainfuck_interpreter():
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Brainfuckinterpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Brainfuck gehört zu den sogenannten esoterischen
Programmiersprachen. Der Programmcode setzt sich
hier aus den 8 Zeichen ><+-.,[]' zusammen.
Diese Funktion führt einen derartigen Programmcode
aus, und gibt das Ergebnis aus, welches bei Geocaches
meist eine kurze Nachricht oder die Koordinaten sind.
Für eine umgekehrte Umwandlung von Text in Brainfuckcode
gibt es im Internet genügend Möglichkeiten zu finden.
Folgender Code wäre z.B. "Hello World!" in Brainfuck:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.
>.+++.------.--------.>+.>.""" + "\n\n")
else:
# ein kleiner feiner Code von https://gist.github.com/kates/986792
c = [0] * 300000
p = 0
loop = []
rv = []
ts = list(eingabetext)
li = len(ts)
i = 0
while i < li:
t = ts[i]
if t == ">":
p += 1
elif t == "<":
p -= 1
elif t == "+":
c[p] += 1
elif t == "-":
c[p] -= 1
elif t == ".":
rv.append(chr(c[p]))
elif t == ",":
pass
elif t == "[":
if c[p] == 0:
while ts[i] != "]":
i += 1
loop.pop()
else:
loop.append(i - 1)
elif t == "]":
i = loop[-1]
i += 1
Ausgabe.insert(1.0, "".join(rv) + "\n")
def ook_interpreter():
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Ook ist eine Abwandlung von Brainfuck wobei die
8 Zeichen von Brainfuck hier durch eine Kombination
von je zwei der folgenden 3 Satzzeichen .!? ersetzt
werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
geschrieben. z.B.: Ook! Ook? Ook. Ook!
Da Ook auch durch andere Wörter ersetzt oder auch
ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
Funktion alle anderen Zeichen außer .!? bevor versucht wird
den Code auszuführen.""" + "\n\n")
else:
ookzeichen = [".", "!", "?"]
ooktext = ""
for z in eingabetext: # erstmal Short-Ook draus machen
if z in ookzeichen:
ooktext = ooktext + z
ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
bftext = ""
for o in range(0, len(ooktext), 2): # jetzt in Brainfuck umwandeln
ooz = ooktext[o:o + 2]
if ooz in ookbf:
bftext = bftext + ookbf[ooz]
c = [0] * 300000
p = 0
loop = []
rv = []
ts = list(bftext)
li = len(ts)
i = 0
while i < li:
t = ts[i]
if t == ">":
p += 1
elif t == "<":
p -= 1
elif t == "+":
c[p] += 1
elif t == "-":
c[p] -= 1
elif t == ".":
rv.append(chr(c[p]))
elif t == ",":
pass
elif t == "[":
if c[p] == 0:
while ts[i] != "]":
i += 1
loop.pop()
else:
loop.append(i - 1)
elif t == "]":
i = loop[-1]
i += 1
Ausgabe.insert(1.0, "".join(rv) + "\n")
def naknaktotext():
def naknak_to_text(eingabetext):
nakwb = {"Nak": "0", "Naknak": "6", "nanak": "B", "Nanak": "1", "Naknaknak": "7", "naknak": "C", "Nananak": "2",
"Nak.": "8", "nak!": "D", "Nanananak": "3", "Naknak.": "9", "nak.": "E", "Nak?": "4", "Naknaknaknak": "A",
"naknaknak": "F", "nak?": "5"}
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [NakNak to Text]
Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache,
welche vom Owner der Website schnatterente.net entwickelt
wurde.
Diese Funktion übersetzt das Geschnatter in verständliche
Buchstaben/Zeichen.
!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!!
Wer diesen Quatsch unbedingt umgekehrt übersetzten will,
findet auf hier den passenden Übersetzer:
http://uebersetzer.schnatterente.net""" + "\n\n")
return ("### NakNak to Text\n"
"Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache, welche vom Owner der Website "
"[https://schnatterente.net](https://web.archive.org/web/20230807065421/https://www.schnatterente.net/)"
" entwickelt wurde. Diese Funktion übersetzt das Geschnatter in verständliche Buchstaben/Zeichen. "
"!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!! Wer diesen Quatsch unbedingt umgekehrt "
"übersetzten will, wird wohl etwas suchen müssen, da der Original-Übersetzer, der unter "
"http://uebersetzer.schnatterente.net erreichbar war, nicht mehr online ist und ich ganz bestimmt "
"keinen hier integrieren werde.")
else:
txt = eingabetext.split()
utxt = ""
@@ -1509,11 +1375,9 @@ http://uebersetzer.schnatterente.net""" + "\n\n")
utxt = utxt + nakwb[nak]
z = 1
atxt = urllib_parse_unquote(utxt)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "dekodiertes Geschnatter:", "bu")
return "_dekodiertes Geschnatter:_ \n" + atxt
def navajototext():
def navajo_to_text(eingabetext):
nabc = {"WOL-LA-CHEE": "A", "BE-LA-SANA": "A", "TSE-NILL": "A", "NA-HASH-CHID": "B", "SHUSH": "B", "TOISH-JEH": "B",
"MOASI": "C", "TLA-GIN": "C", "BA-GOSHI": "C", "BE": "D", "CHINDI": "D", "LHA-CHA-EH": "D", "AH-JAH": "E",
"DZEH": "E", "AH-NAH": "E", "CHUO": "F", "TSA-E-DONIN-EE": "F", "MA-E": "F", "AH-TAD": "G", "KLIZZIE": "G",
@@ -1526,25 +1390,19 @@ def navajototext():
"DIBEH": "S", "KLESH": "S", "D-AH": "T", "A-WOH": "T", "THAN-ZIE": "T", "SHI-DA": "U", "NO-DA-IH": "U",
"A-KEH-DI-GLINI": "V", "GLOE-IH": "W", "AL-NA-AS-DZOH": "X", "AL-AN-AS-DZOH": "X", "TSAH-AS-ZIH": "Y",
"BESH-DO-TLIZ": "Z", "BESH-DO-GLIZ": "Z", "BE-TKAH": " "}
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Navajo-ABC to Text]
Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für
den verschlüßelten Funkverkehr eingesetzt. Vorteile waren, daß
nahezu niemand außer Navajo-Volk die Sprache verstand und es keine
schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet
und die Codewörter wurden dabei von den Codesprechern (natürlich
Navajo's) auswendig gelernt.
Die Dekodierfunktion hier übersetzt das Codealphabet (A-Z), bei welchem es
auch so ist, daß unterschiedliche Worte für den selben Buchstaben stehen,
in normalen Text. Leider existieren leicht unterschiedliche Alphabete was
die Wörter bzw. deren Schreibweise angeht im Netz, mit welchen codiert wird,
weshalb ich hier nur die Dekodierung anbiete.
weitere Codewörter und Erklärungen gibt es z.B. hier:
https://ww2db.com/other.php?other_id=29
http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" + "\n\n")
return ("### Navajo-ABC to Text\n"
"Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für den verschlüßelten Funkverkehr "
"eingesetzt. Vorteile waren, daß nahezu niemand außer Navajo-Volk die Sprache verstand und es keine "
"schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet und die Codewörter wurden dabei von "
"den Codesprechern (natürlich Navajo's) auswendig gelernt. Die Dekodierfunktion hier übersetzt das "
"Codealphabet (A-Z), bei welchem es auch so ist, daß unterschiedliche Worte für den selben Buchstaben "
"stehen, in normalen Text. Leider existieren leicht unterschiedliche Alphabete was die Wörter bzw. "
"deren Schreibweise angeht im Netz, mit welchen codiert wird, weshalb ich hier nur die Dekodierung "
"anbiete. weitere Codewörter und Erklärungen gibt es z.B. hier: "
"https://ww2db.com/other.php?other_id=29 oder hier: "
"http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf")
else:
txt = eingabetext.split()
atxt = ""
@@ -1552,38 +1410,21 @@ http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" +
w = wort.upper()
if w in nabc:
atxt = atxt + nabc[w]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "dekodierter Text:", "bu")
return "_dekodierter Text:_ \n" + atxt
def pi_suche():
hilfetext = """HILFE: [PI Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von PI (3.141592653589793238462643...) zu ermitteln.
Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen
wird die Datei pi.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl PI mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit
dem Tool y-cruncher (http://numberworld.org/y-cruncher/)
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und pi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
eingabetext = Eingabe.get(1.0, END)
def pi_suche(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
return ("### PI Nachkommastellensuche\n"
"Für die eingegebene Zahl/Zahlenreihe X wird versucht die entsprechende X. Nachkommastelle auszugeben "
"und das erst Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen von PI "
"(3.141592653589793238462643...) zu ermitteln. Aus Performance- und Speicherplatzgründen ist die Suche "
"auf die ersten 10 Millionen Nachkommastellen beschränkt.")
else:
try:
piread = open("./data/pi.txt", "r")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
return "Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird."
else:
pistr = ""
for zeile in piread:
@@ -1593,34 +1434,31 @@ die Abfrage dauert auch etwas länger)
try:
zahlx = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
return "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
else:
ausgabetext = "_PI (Kreiszahl)_ \n"
pos = pistr.find(eingabetext)
if pos == -1:
Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(pilen), "re")
else:
Ausgabe.insert(1.0,
"20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, pistr[pos:pos + 20]))
Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
eingabetext.rstrip(), pos - 1))
if pilen >= zahlx > 0:
Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle: "
"{}...\n\n".format(zahlx, pistr[zahlx + 1:zahlx + 21]))
Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, pistr[zahlx + 1]))
ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {pistr[zahlx + 1]} \n_20 Stellen ab "
f"{zahlx}. Nachkommstelle:_ {pistr[zahlx + 1:zahlx + 21]}... \n")
else:
Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n\n".format(pilen),
"re")
Ausgabe.insert(1.0, "PI (Kreiszahl)\n\n", "gr")
ausgabetext += f"_Die verwendete pi.txt kennt leider nur {pilen:,} Nachkommstellen._ \n"
if pos == -1:
ausgabetext += f"_Zahlenreihe in {pilen:,} Nachkommastellen nicht zu finden._"
else:
ausgabetext += (f'erstes Vorkommen von Zahlenfolge "{eingabetext.rstrip()}" ab {pos - 1}. '
f'Nachkommastelle \n20 Stellen ab {pos - 1}. Nachkommstelle: '
f'{pistr[pos:pos + 20]}...')
return ausgabetext
'''
def anagramm_suche_de():
hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
Diese Funktion benutzt eine deutsche Wörterbuchdatei
vom Project https://sourceforge.net/projects/germandict um
zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörtebuch vorkommen.
Die Datei german.dic muß sich dafür im Unterverzeichnis "data"
befinden.
"""
eingabetext = Eingabe.get(1.0, END)
@@ -3717,4 +3555,120 @@ für alle Zeilenanzahlen von 2-12.""" + "\n\n")
except ValueError:
Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
def brainfuck_interpreter():
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Brainfuckinterpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Brainfuck gehört zu den sogenannten esoterischen
Programmiersprachen. Der Programmcode setzt sich
hier aus den 8 Zeichen ><+-.,[]' zusammen.
Diese Funktion führt einen derartigen Programmcode
aus, und gibt das Ergebnis aus, welches bei Geocaches
meist eine kurze Nachricht oder die Koordinaten sind.
Für eine umgekehrte Umwandlung von Text in Brainfuckcode
gibt es im Internet genügend Möglichkeiten zu finden.
Folgender Code wäre z.B. "Hello World!" in Brainfuck:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.
>.+++.------.--------.>+.>.""" + "\n\n")
else:
# ein kleiner feiner Code von https://gist.github.com/kates/986792
c = [0] * 300000
p = 0
loop = []
rv = []
ts = list(eingabetext)
li = len(ts)
i = 0
while i < li:
t = ts[i]
if t == ">":
p += 1
elif t == "<":
p -= 1
elif t == "+":
c[p] += 1
elif t == "-":
c[p] -= 1
elif t == ".":
rv.append(chr(c[p]))
elif t == ",":
pass
elif t == "[":
if c[p] == 0:
while ts[i] != "]":
i += 1
loop.pop()
else:
loop.append(i - 1)
elif t == "]":
i = loop[-1]
i += 1
Ausgabe.insert(1.0, "".join(rv) + "\n")
def ook_interpreter():
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Ook ist eine Abwandlung von Brainfuck wobei die
8 Zeichen von Brainfuck hier durch eine Kombination
von je zwei der folgenden 3 Satzzeichen .!? ersetzt
werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
geschrieben. z.B.: Ook! Ook? Ook. Ook!
Da Ook auch durch andere Wörter ersetzt oder auch
ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
Funktion alle anderen Zeichen außer .!? bevor versucht wird
den Code auszuführen.""" + "\n\n")
else:
ookzeichen = [".", "!", "?"]
ooktext = ""
for z in eingabetext: # erstmal Short-Ook draus machen
if z in ookzeichen:
ooktext = ooktext + z
ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
bftext = ""
for o in range(0, len(ooktext), 2): # jetzt in Brainfuck umwandeln
ooz = ooktext[o:o + 2]
if ooz in ookbf:
bftext = bftext + ookbf[ooz]
c = [0] * 300000
p = 0
loop = []
rv = []
ts = list(bftext)
li = len(ts)
i = 0
while i < li:
t = ts[i]
if t == ">":
p += 1
elif t == "<":
p -= 1
elif t == "+":
c[p] += 1
elif t == "-":
c[p] -= 1
elif t == ".":
rv.append(chr(c[p]))
elif t == ",":
pass
elif t == "[":
if c[p] == 0:
while ts[i] != "]":
i += 1
loop.pop()
else:
loop.append(i - 1)
elif t == "]":
i = loop[-1]
i += 1
Ausgabe.insert(1.0, "".join(rv) + "\n")
'''