tebarius/Mysteryhelfer-web
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
851016949502fcba9df5ff5b803414908efa250a
Mysteryhelfer-web/app/tools.py
tebarius 8510169495 erweiterung zeichenzählen
2025-08-30 13:37:00 +02:00

2679 lines
104 KiB
Python
Raw Blame History

# Copyright (c) 2025 Martin Kayser (tebarius)
# Licensed under the MIT License. See LICENSE file in the project root.
from itertools import chain # für primfaktoren zerlegung
import helper
import hilfetexte
import pandas as pd
from urllib.parse import unquote as urllib_parse_unquote # für nak-nak
import binascii # für base64_ascii
import brainfuckery
def cesar_all(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.cesar_all
else:
abcgross = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
abcklein = "abcdefghijklmnopqrstuvwxyz"
txt = eingabetext
ausgabe = ""
for r in range(1, 27):
atxt = ""
for i in txt:
if i.upper() not in abcgross:
atxt = atxt + i # nicht codierbare Zeichen direkt zur Ausgabe bitte!
continue
abc = abcgross
if i == i.lower():
abc = abcklein
for j in range(26):
if i == abc[j]:
if j + r >= 26:
atxt = atxt + abc[j + r - 26]
else:
atxt = atxt + abc[j + r]
ausgabe += f":blue[{r:02}:] {atxt} \n"
return ausgabe
def buchstabenwortwert(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.buchstabenwortwert
else:
ausgabe = ""
bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
'M': 13, 'N': 14,
'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
'Z': 26,
'Ä': 27, 'Ö': 28, 'Ü': 29, 'SS': 30}
wortsumme = 0
wortprodukt = 1
atxt = ""
az = ""
eworttxt = ""
ewortptxt = ""
banzahla = 0
banzwtxt = ""
einzelworte = eingabetext.split()
for wort in einzelworte:
ewortsumme = 0
ewortprod = 1
banzahlw = 0
ewtr = False
for b in wort:
if b.upper() not in bw:
atxt = atxt + b + "=0 "
az = az + "0,"
continue
else:
ewtr = True
ewortprod *= bw[b.upper()]
ewortsumme += bw[b.upper()]
wortsumme += bw[b.upper()]
wortprodukt *= bw[b.upper()]
atxt = atxt + b + "=" + str(bw[b.upper()]) + " "
az = az + str(bw[b.upper()]) + ","
banzahla += 1
banzahlw += 1
banzwtxt = banzwtxt + str(banzahlw) + "/"
eworttxt = eworttxt + str(ewortsumme) + "/"
if not ewtr:
ewortptxt = ewortptxt + "0/"
else:
ewortptxt = ewortptxt + str(ewortprod) + "/"
ausgabe += atxt + " \n"
ausgabe += '| | |\n'
ausgabe += '|----|----|\n'
ausgabe += "|:blue[Buchstabenwerte:]|"
ausgabe += az[0:-1] + "|\n"
ausgabe += "|:blue[Buchstabenwortwerte:]|"
ausgabe += eworttxt[0:-1] + "|\n"
ausgabe += "|:blue[Summe aller Buchstabenwerte:]|"
ausgabe += str(wortsumme) + "|\n"
ausgabe += "|:blue[Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:]|"
ausgabe += str(helper.q_sum(wortsumme)) + " / " + str(helper.iq_sum(wortsumme)) + "|\n"
ausgabe += "|:blue[Buchstabenanzahl pro Wort:]|"
ausgabe += banzwtxt[0:-1] + "|\n"
ausgabe += "|:blue[Gesamtanzahl aller Buchstaben:]|"
ausgabe += str(banzahla) + "|\n"
ausgabe += "|:blue[Wortprodukte(0 wenn kein Buchstabe gefunden):]|"
ausgabe += ewortptxt[0:-1] + "|\n"
ausgabe += "|:blue[Buchstabenwert-Produkt:(Nullen werden ignoriert):]|"
ausgabe += str(wortprodukt) + "|\n"
return ausgabe
def buchstabenwert_zu_text(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
bw = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k',
12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u',
22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 27: 'ä', 28: 'ö', 29: 'ü', 30: 'ß'}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.buchstabenwert_zu_text
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
if ausz not in bw:
return ":red[Die eingegebene Zahl ist kein gültiger Buchstabenwert!]"
else:
return bw[ausz]
else:
ausgabe_text = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z)
except ValueError:
ignor = ignor + str(z) + " "
else:
if az in bw:
atxt = atxt + bw[az]
else:
ignor = ignor + str(z) + " "
if ignor != "":
ausgabe_text += ":red[Achtung folgendes wurde ignoriert:] \n"
ausgabe_text += ignor + " \n \n"
ausgabe_text += ":blue[umgewandelte Zeichen:] \n"
ausgabe_text += atxt
return ausgabe_text
def zeichenkette_reverse(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.zeichenkette_reverse
else:
return eingabetext[::-1]
def zeichenanzahl(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.zeichenanzahl
else:
ausgabetext = ""
anzahl = {}
for b in eingabetext:
if b in anzahl:
anzahl[b] = anzahl[b] + 1
else:
anzahl[b] = 1
s = []
zeichensumme = 0
for key in anzahl:
s.append(key)
zeichensumme += anzahl[key]
s.sort()
ausgabetext += (f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen in insgesamt "
f"__:orange[{zeichensumme}]__ Zeichen gefunden. \n"
f"| :blue[Zeichen] | :blue[Anzahl] |\n|----|----|\n")
for i in s:
if ord(i) == 9:
ausgabetext += f"|TAB|{anzahl[i]}|\n"
elif ord(i) == 32:
ausgabetext += f"|SPACE|{anzahl[i]}|\n"
elif ord(i) == 10:
ausgabetext += f"|LINEFEED| = {anzahl[i]}|\n"
else:
ausgabetext += f"|{i}|{anzahl[i]}|\n"
return ausgabetext
def quersummen(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.quersummen
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
return f" :blue[Quersumme:] {helper.q_sum(ausz)} \n:blue[iterierte Quersumme:] {helper.iq_sum(ausz)}"
else:
ausgabetext = ""
txt = eingabetext.split(se)
qtxt = ""
iqtxt = ""
ignor = ""
for z in txt:
try:
az = int(z)
except ValueError:
ignor = ignor + str(z) + " "
else:
qtxt = qtxt + str(helper.q_sum(az)) + "/"
iqtxt = iqtxt + str(helper.iq_sum(az)) + "/"
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen:] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[Quersummen:] \n"
ausgabetext += qtxt[:-1] + " \n \n"
ausgabetext += ":blue[iterierte Quersummen] \n"
ausgabetext += iqtxt[:-1]
return ausgabetext
def einschluss_count(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.einschluss_count
else:
bw = "ADOPQRabdegopq690"
wortsummenliste_ohne = []
wortsummenliste_mit = []
wortliste = eingabetext.split()
for wort in wortliste:
wz_ohne = 0
wz_mit = 0
for b in wort:
if b == "4":
wz_mit += 1
if b == "B" or b == "8":
wz_ohne += 2
wz_mit += 2
elif b in bw:
wz_mit += 1
wz_ohne += 1
wortsummenliste_ohne.append(wz_ohne)
wortsummenliste_mit.append(wz_mit)
ausgabetext = "__:orange[mit 4]__ \n"
ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
ausgabetext += f"{sum(wortsummenliste_mit)} \n"
ausgabetext += ":blue[Einschlüsse pro Wort:] "
for z in wortsummenliste_mit:
ausgabetext += f"{z} "
ausgabetext += " \n \n"
ausgabetext += "__:orange[ohne 4]__ \n"
ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
ausgabetext += f"{sum(wortsummenliste_ohne)} \n"
ausgabetext += ":blue[Einschlüsse pro Wort:] "
for z in wortsummenliste_ohne:
ausgabetext += f"{z} "
return ausgabetext
def morse_to_abc(eingabetext):
alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
"..": "I", ".---": "J", "-.-": "K", ".-..": "L",
"--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
"..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
"--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
"--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
"..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
"-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
".----.": "'", "...--..": "ß"
}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.morse_to_abc
else:
morse = eingabetext.split()
atxt = ""
for sign in morse:
if sign == "/":
atxt = atxt + " "
elif sign not in alphabet:
atxt = atxt + ":red[#]"
else:
atxt = atxt + alphabet[sign]
return atxt
def abc_to_morse(eingabetext):
alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
"..": "I", ".---": "J", "-.-": "K", ".-..": "L",
"--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
"..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
"--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
"--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
"..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
"-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
".----.": "'", "...--..": "SS"
}
umkehr_alpha = {v: k for k, v in alphabet.items()} # Alphabet mit getauschten key und values generieren
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.abc_to_morse
else:
atxt = ""
for b in eingabetext:
if b == " ":
atxt = atxt + "/ "
elif b.upper() not in umkehr_alpha:
atxt = atxt + b + " "
else:
atxt = atxt + umkehr_alpha[b.upper()] + " "
return atxt
def rot5(eingabetext):
ro5 = {"0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.rot5
else:
atxt = ""
for z in eingabetext:
if z not in ro5:
atxt = atxt + z
else:
atxt = atxt + ro5[z]
return atxt
def rot13(eingabetext):
ro13 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
'K': 'X', 'L': 'Y', 'M': 'Z',
'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
'X': 'K', 'Y': 'L', 'Z': 'M'}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.rot13
else:
atxt = ""
for z in eingabetext:
if z.upper() not in ro13:
atxt = atxt + z
elif z.lower() == z:
a = ro13[z.upper()]
atxt = atxt + a.lower()
else:
atxt = atxt + ro13[z.upper()]
return atxt
def rot18(eingabetext):
ro18 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
'K': 'X', 'L': 'Y', 'M': 'Z',
'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
'X': 'K', 'Y': 'L', 'Z': 'M',
"0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.rot18
else:
atxt = ""
for z in eingabetext:
if z.upper() not in ro18:
atxt = atxt + z
elif z.lower() == z:
a = ro18[z.upper()]
atxt = atxt + a.lower()
else:
atxt = atxt + ro18[z.upper()]
return atxt
def rot47(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.rot47
else:
x = []
for i in eingabetext:
j = ord(i)
if 33 <= j <= 126:
x.append(chr(33 + ((j + 14) % 94)))
else:
x.append(i)
return f"```\n{''.join(x)}\n```"
def ascii_to_dez(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ascii_to_dez
else:
z = []
for i in eingabetext:
z.append(str(ord(i)))
return ' '.join(z)
def dez_to_ascii(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.dez_to_ascii
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
return chr(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z)
except ValueError:
ignor = ignor + str(z) + " "
else:
atxt = atxt + chr(az)
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen:] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[umgewandelte Zeichen:] \n"
ausgabetext += atxt
return ausgabetext
def ascii_to_hex(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ascii_to_hex
else:
z = []
for i in eingabetext:
hexstr = ("{:X}".format(ord(i))) # großes X für Hex in Großbuchstaben
z.append(hexstr)
return ' '.join(z)
def hex_to_ascii(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.hex_to_ascii
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 16)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
return chr(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z, 16)
except ValueError:
ignor = ignor + str(z) + " "
else:
atxt = atxt + chr(az)
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[umgewandelte Zeichen:] \n"
ausgabetext += atxt
return ausgabetext
def ascii_to_octal(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ascii_to_octal
else:
z = []
for i in eingabetext:
z.append("{:o}".format(ord(i)))
return ' '.join(z)
def octal_to_ascii(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.octal_to_ascii
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 8)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
return chr(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z, 8)
except ValueError:
ignor = ignor + str(z) + " "
else:
atxt = atxt + chr(az)
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[umgewandelte Zeichen:] \n"
ausgabetext += atxt
return ausgabetext
def ascii_to_bin16(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ascii_to_bin16
else:
z = []
for i in eingabetext:
z.append("{:0>16b}".format(ord(i)))
return ' '.join(z)
def ascii_to_bin8(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ascii_to_bin8
else:
z = []
for i in eingabetext:
if ord(i) > 255:
return (":red[Sorry der Eingabetext enthält Zeichen,welche sich nicht mit 8 bit in binär darstellen "
"lassen!]")
z.append("{:0>8b}".format(ord(i)))
return ' '.join(z)
def bin_to_ascii(eingabetext):
seperator = ("|,", "_", ".", "-", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.bin_to_ascii
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 2)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
return chr(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z, 2)
except ValueError:
ignor = ignor + str(z) + " "
else:
atxt = atxt + chr(az)
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[umgewandelte Zeichen:] \n"
ausgabetext += atxt
return ausgabetext
def zahlwortsuche_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.zahlwortsuche_de
else:
zahlen = ["null", "eins", "zwei", "drei", "vier", "fünf", "fuenf", "sechs", "sieben", "acht",
"neun", "zehn", "elf", "zwölf", "zwoelf", "zwanzig", "hundert", "tausend"]
ntxt = ""
abc = "abcdefghijklmnopqrstuvwxyzäöüß"
for b in eingabetext:
if b.lower() not in abc:
continue
ntxt = ntxt + b.lower()
for z in zahlen:
if z.lower() in ntxt:
ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
atxt = ""
tt = False
for b in ntxt:
if b == "-":
tt = True
continue
if b == "_":
tt = False
atxt = atxt + " "
if tt:
atxt = atxt + b
if atxt == "":
return ":red[Leider keine Zahlwörter gefunden!]"
else:
ausgabetext = ":blue[Gefundene Zahlwörter:] \n"
ausgabetext += atxt + " \n \n"
ausgabetext += ":blue[Eingangstext:] \n"
ausgabetext += ntxt
return ausgabetext
def zahlwortsuche_en(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.zahlwortsuche_en
else:
zahlen = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "fourty", "sixty", "seventy",
"eighty", "ninety", "zero", "one", "two", "three", "four", "five", "six", "seven",
"eight", "nine", "ten", "twenty", "thirty", "fifty"]
ntxt = ""
abc = "abcdefghijklmnopqrstuvwxyz"
for b in eingabetext:
if b.lower() not in abc:
continue
ntxt = ntxt + b.lower()
for z in zahlen:
if z.lower() in ntxt:
ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
atxt = ""
tt = False
for b in ntxt:
if b == "-":
tt = True
continue
if b == "_":
tt = False
atxt = atxt + " "
if tt:
atxt = atxt + b
if atxt == "":
return ":red[Leider keine Zahlwörter gefunden!]"
else:
ausgabetext = ":blue[Gefundene Zahlwörter:] \n"
ausgabetext += atxt + " \n \n"
ausgabetext += ":blue[Eingangstext:] \n"
ausgabetext += ntxt
return ausgabetext
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",
"t": "fmp", "u": "fmf", "v": "fpm", "w": "fpp",
"x": "fpf", "y": "ffm", "z": "ffp", "ä": "mmmmpp", "ö": "ppfmpp", "ü": "fmfmpp", "ß": "fmmfmm",
"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", "T": "Fmp", "U": "Fmf", "V": "Fpm", "W": "Fpp", "X": "Fpf",
"Y": "Ffm", "Z": "Ffp", "Ä": "Mmmmpp",
"Ö": "Ppfmpp", "Ü": "Fmfmpp"
}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.kenny_kodieren
else:
atxt = ""
for b in eingabetext:
if b in alphabet:
atxt = atxt + alphabet[b]
else:
atxt = atxt + b
return atxt
def kenny_dekodieren(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.kenny_dekodieren
else:
return helper.unkennify(eingabetext)
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 = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.kenny_raten
else:
wtxt = eingabetext.replace(chr(9),"").replace(chr(32),"").replace(chr(10),"").lower()
# erstmal leerzeichen, tab, linefeed raus und alles klein
anzahl = {} # restliche zeichen zählen und in ein wörterbuch
for c in wtxt:
if c in anzahl:
anzahl[c] = anzahl[c] + 1
else:
anzahl[c] = 1
s = [] # zum Sortieren lieber eine liste
for key in anzahl:
s.append([anzahl[key], key])
s.sort(reverse=True)
abc3 = [s[0][1], s[1][1], s[2][1]] # die 3 häufigsten Zeichen im Text wären gefunden
cwtxt = ""
for b in wtxt: # alles raus außer den 3 häufigsten Zeichen
if b not in abc3:
continue
cwtxt = cwtxt + b
abca = ["a", "b", "c", "d"] # falls 0,1,2 verwendet wurden in a, b, c... ändern
if "0" in abc3 or "1" in abc3 or "2" in abc3:
for i in range(3):
if abc3[i] in ["0", "1", "2"]:
for j in abca:
if j in abc3:
continue
else:
cwtxt = cwtxt.replace(abc3[i], j)
abc3[i] = j
break
ausgabetext = ""
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")
atxt = ""
for i in range(0, len(txt2), 3):
tri = txt2[i:i + 3]
if tri in wbk:
atxt = atxt + wbk[tri]
ausgabetext += f":blue[{p}] \n"
ausgabetext += f"{atxt} \n \n"
return ausgabetext
def primzahlalphabet_dekodieren(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.primzahlalphabet_dekodieren
else:
grenze = 1000000
primes = helper.primzahlliste(grenze)
pdict = {}
bz = 65
for p in primes:
if bz == 91:
bz = 65
pdict[p] = chr(bz)
bz += 1
seperator = ("|,", "_", ".", "-", "/", ";", ",")
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
else:
if ausz in pdict:
return pdict[ausz]
else:
return f":red[{eingabetext} ist keine Primzahl oder größer als 1 Million!]"
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
ignor = ""
for z in txt:
try:
az = int(z)
except ValueError:
ignor = ignor + str(z) + " "
else:
if az in pdict:
atxt = atxt + pdict[az]
else:
ignor = ignor + str(z) + " "
if ignor != "":
ausgabetext += ":red[ignoriert wurde:] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[umgewandelte Zahlen:] \n"
ausgabetext += atxt
return ausgabetext
def primzahlpruefen(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.primzahlpruefen
else:
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl erkannt!]"
else:
if ausz > 1299709:
return (":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal "
"1,299,709 !]")
primes = helper.primzahlliste(1299710)
if ausz not in primes:
return f":orange[{ausz:,}] ist keine Primzahl"
else:
return f":orange[{ausz:,}] ist die :orange[{primes.index(ausz) + 1:,}.] Primzahl"
def nte_primzahl(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.nte_primzahl
else:
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl erkannt!]"
if ausz > 100000:
return ":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal 1,299,709 !]"
else:
primes = helper.primzahlliste(1299710)
return f"Die :orange[{ausz:,}.] Primzahl lautet: :orange[{primes[ausz - 1]:,}]"
def primfaktoren(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.primfaktoren
else:
try:
n = int(eingabetext)
except ValueError:
return ":red[Es konnte leider keine Zahl erkannt werden.]"
faktoren = []
for i in chain([2], range(3, n // 2 + 1, 2)):
if i > 100000000:
return (":red[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 = f"_Die Zahl :orange[{eingabetext}] hat folgende Primfaktoren:_ \n"
if not faktoren:
return f"Die Zahl :orange[{eingabetext}] ist eine Primzahl!!"
else:
for z in faktoren:
out += str(z) + ", "
return out[:-2]
def dez_to_hex_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.dez_to_hex_oct_bin
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
else:
return ":blue[DEZ:] {0:} \n:blue[HEX:] {0:X} \n:blue[OCT:] {0:o} \n:blue[BIN:] {0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
try:
az = int(z)
except ValueError:
ignor = ignor + str(z) + " "
else:
deztxt = deztxt + str(az) + "/"
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
if ignor != "":
ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor} \n"
ausgabetext += f":blue[DEZ:] {deztxt[:-1]} \n"
ausgabetext += f":blue[HEX:] {hextxt[:-1]} \n"
ausgabetext += f":blue[OCT:] {octtxt[:-1]} \n"
ausgabetext += f":blue[BIN:] {bintxt[:-1]} \n"
return ausgabetext
def hex_to_dez_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.hex_to_dez_oct_bin
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 16)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
else:
return ":blue[HEX:] {0:X} \n:blue[DEZ:] {0:} \n:blue[OCT:] {0:o} \n:blue[BIN:] {0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
try:
az = int(z, 16)
except ValueError:
ignor = ignor + str(z) + " "
else:
deztxt = deztxt + str(az) + "/"
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
if ignor != "":
ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor} \n"
ausgabetext += f":blue[HEX:] {hextxt[:-1]} \n"
ausgabetext += f":blue[DEZ:] {deztxt[:-1]} \n"
ausgabetext += f":blue[OCT:] {octtxt[:-1]} \n"
ausgabetext += f":blue[BIN:] {bintxt[:-1]} \n"
return ausgabetext
def oct_to_hex_dez_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.oct_to_hex_dez_bin
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 8)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
else:
return ":blue[OCT:] {0:o} \n:blue[HEX:] {0:X} \n:blue[DEZ:] {0:} \n:blue[BIN:] {0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
try:
az = int(z, 8)
except ValueError:
ignor = ignor + str(z) + " "
else:
deztxt = deztxt + str(az) + "/"
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
if ignor != "":
ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor} \n"
ausgabetext += f":blue[OCT:] {octtxt[:-1]} \n"
ausgabetext += f":blue[HEX:] {hextxt[:-1]} \n"
ausgabetext += f":blue[DEZ:] {deztxt[:-1]} \n"
ausgabetext += f":blue[BIN:] {bintxt[:-1]} \n"
return ausgabetext
def bin_to_hex_dez_oct(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.bin_to_hex_dez_oct
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext, 2)
except ValueError:
return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
else:
return ":blue[BIN:] {0:b} \n:blue[HEX:] {0:X} \n:blue[DEZ:] {0:} \n:blue[OCT:] {0:o}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
try:
az = int(z, 2)
except ValueError:
ignor = ignor + str(z) + " "
else:
deztxt = deztxt + str(az) + "/"
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
if ignor != "":
ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor} \n"
ausgabetext += f":blue[BIN:] {bintxt[:-1]} \n"
ausgabetext += f":blue[HEX:] {hextxt[:-1]} \n"
ausgabetext += f":blue[DEZ:] {deztxt[:-1]} \n"
ausgabetext += f":blue[OCT:] {octtxt[:-1]} \n"
return ausgabetext
def abc_to_tomtom(eingabetext):
alphabet = {"a": "/ ", "b": "// ", "c": "/// ", "d": "//// ", "e": "/\\\\ ", "f": "//\\\\ ", "g": "///\\\\ ",
"h": "/\\\\\\\\ ", "i": "/\\\\\\\\\\ ", "j": "\\\\/ ", "k": "\\\\\\\\/ ", "l": "\\\\\\\\\\\\/ ",
"m": "\\\\// ", "n": "\\\\/// ", "o": "/\\\\/ ", "p": "//\\\\/ ", "q": "/\\\\\\\\/ ", "r": "/\\\\// ",
"s": "\\\\/\\\\ ", "t": "\\\\\\\\/\\\\ ", "u": "\\\\//\\\\ ", "v": "\\\\/\\\\\\\\ ", "w": "//\\\\\\\\ ",
"x": "\\\\\\\\// ", "y": "\\\\/\\\\/ ", "z": "/\\\\/\\\\ "
} # schräg aber wir brauchen zum kodieren doppel-doppelte backslashs damit die Ausgabe im Browser passt
if eingabetext == "":
return hilfetexte.abc_to_tomtom
else:
ausgabetext = ""
atxt = ""
ignor = ""
for b in eingabetext:
if b == " ":
atxt = atxt + " "
elif b.lower() not in alphabet:
ignor = ignor + b + " "
else:
atxt = atxt + alphabet[b.lower()]
if ignor != "":
ausgabetext += ":red[ignorierte Zeichen:] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[kodierter Text:] \n"
ausgabetext += atxt
return ausgabetext
def tomtom_to_abc(eingabetext):
alphabet = {'/': 'A', '//': 'B', '///': 'C', '////': 'D', '/\\': 'E', '//\\': 'F', '///\\': 'G', '/\\\\': 'H',
'/\\\\\\': 'I', '\\/': 'J',
'\\\\/': 'K', '\\\\\\/': 'L', '\\//': 'M', '\\///': 'N', '/\\/': 'O', '//\\/': 'P', '/\\\\/': 'Q',
'/\\//': 'R', '\\/\\': 'S',
'\\\\/\\': 'T', '\\//\\': 'U', '\\/\\\\': 'V', '//\\\\': 'W', '\\\\//': 'X', '\\/\\/': 'Y',
'/\\/\\': 'Z'
} # schräg aber wir brauchen zum kodieren doppel-doppelte backslashs damit die Ausgabe im Browser passt
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.tomtom_to_abc
else:
tomtom = eingabetext.replace(" ", " _ ")
tomtom = tomtom.split()
atxt = ""
for sign in tomtom:
if sign == "_":
atxt = atxt + " "
elif sign not in alphabet:
atxt = atxt + "#"
else:
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": "|\\\\| ",
"n": "|/| ", "o": "||/| ", "p": "|\\\\|\\\\ ", "q": "/\\\\ ", "r": "\\\\/ ", "s": "/| ", "t": "|// ",
"u": "// ", "v": "||\\\\\\\\ ", "w": "\\\\/|| ",
"x": "||/ ", "y": "|||\\\\ ", "z": "|||| "
} # jweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.text_to_slashpipe
else:
ausgabetext = ""
atxt = ""
ignor = ""
for b in eingabetext:
if b == " ":
atxt = atxt + " "
elif b.lower() not in alphabet:
ignor = ignor + b + " "
else:
atxt = atxt + alphabet[b.lower()]
if ignor != "":
ausgabetext += ":red[ignorierte Zeichen:] \n"
ausgabetext += ignor + " \n \n"
ausgabetext += ":blue[kodierter Text:] \n"
ausgabetext += atxt
return ausgabetext
def slashpipe_to_text(eingabetext):
alphabet = {'|': 'A', '|\\': 'B', '||': 'C', '|/': 'D', '\\': 'E', '||\\': 'F', '|||': 'G', '\\\\': 'H', '/': 'I',
'|\\\\': 'J', '//||': 'K', '|\\/': 'L', '|\\|': 'M', '|/|': 'N', '||/|': 'O', '|\\|\\': 'P', '/\\': 'Q',
'\\/': 'R',
'/|': 'S', '|//': 'T', '//': 'U', '||\\\\': 'V', '\\/||': 'W', '||/': 'X', '|||\\': 'Y', '||||': 'Z'}
# jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.slashpipe_to_text
else:
tomtom = eingabetext.replace(" ", " _ ")
tomtom = tomtom.split()
atxt = ""
for sign in tomtom:
if sign == "_":
atxt = atxt + " "
elif sign not in alphabet:
atxt = atxt + "#"
else:
atxt = atxt + alphabet[sign]
return atxt
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",
14: "Si", 15: "P", 16: "S", 17: "Cl", 18: "Ar", 19: "K", 20: "Ca", 21: "Sc", 22: "Ti", 23: "V", 24: "Cr",
25: "Mn",
26: "Fe", 27: "Co", 28: "Ni", 29: "Cu", 30: "Zn", 31: "Ga", 32: "Ge", 33: "As", 34: "Se", 35: "Br", 36: "Kr",
37: "Rb", 38: "Sr", 39: "Y", 40: "Zr", 41: "Nb", 42: "Mo", 43: "Tc", 44: "Ru", 45: "Rh", 46: "Pd", 47: "Ag",
48: "Cd", 49: "In", 50: "Sn", 51: "Sb", 52: "Te", 53: "I", 54: "Xe", 55: "Cs", 56: "Ba", 57: "La", 58: "Ce",
59: "Pr", 60: "Nd", 61: "Pm", 62: "Sm", 63: "Eu", 64: "Gd", 65: "Tb", 66: "Dy", 67: "Ho", 68: "Er", 69: "Tm",
70: "Yb", 71: "Lu", 72: "Hf", 73: "Ta", 74: "W", 75: "Re", 76: "Os", 77: "Ir", 78: "Pt", 79: "Au", 80: "Hg",
81: "Tl", 82: "Pb", 83: "Bi", 84: "Po", 85: "At", 86: "Rn", 87: "Fr", 88: "Ra", 89: "Ac", 90: "Th", 91: "Pa",
92: "U", 93: "Np", 94: "Pu", 95: "Am", 96: "Cm", 97: "Bk", 98: "Cf", 99: "Es", 100: "Fm", 101: "Md",
102: "No",
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 = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.periodensystem
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
try:
ausz = int(eingabetext)
except ValueError:
if eingabetext in um_pse:
return str(um_pse[eingabetext])
else:
return ":red[Keine gültige Eingabe erkannt!]"
else:
return pse[ausz]
else:
ausgabetext = ""
txt = eingabetext.split(se)
atxt = ""
atxt2 = ""
atxt3 = ""
ignor = ""
for z in txt:
try:
az = int(z)
except ValueError:
if z in um_pse:
atxt3 += f"|{z}|{str(um_pse[z])}|\n"
else:
ignor = ignor + z + " "
else:
if az in pse:
atxt = atxt + pse[az] + " "
atxt2 = atxt2 + pse[az][0]
else:
ignor = ignor + z + " "
if ignor != "":
ausgabetext += ":red[Achtung nicht erkannte Zeichen] \n" + ignor + " \n \n"
if atxt != "":
ausgabetext += ":blue[Symbole:] \n" + atxt + " \n \n"
if atxt2 != "":
ausgabetext += ":blue[Nur Anfangsbuchstaben:] \n" + atxt2 + " \n \n"
if atxt3 != "":
ausgabetext += "|:blue[Symbol]|:blue[Ordnungszahl]|\n|-|-|\n" + atxt3
return ausgabetext
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 = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.naknak_to_text
else:
txt = eingabetext.split()
utxt = ""
z = 1
for nak in txt:
if nak in nakwb and z == 1:
utxt = utxt + "%" + nakwb[nak]
z += 1
elif nak in nakwb:
utxt = utxt + nakwb[nak]
z = 1
atxt = urllib_parse_unquote(utxt)
return f":blue[dekodiertes Geschnatter:] \n{atxt}"
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",
"JEHA": "G", "TSE-GAH": "H", "CHA": "H", "LIN": "H", "TKIN": "I", "YEH-HES": "I", "A-CHI": "I",
"TKELE-CHO-G": "J", "TKELE-CHO-GI": "J", "AH-YA-TSINNE": "J", "YIL-DOI": "J", "JAD-HO-LONI": "K",
"BA-AH-NE-DI-TININ": "K", "KLIZZIE-YAZZIE": "K", "DIBEH-YAZZIE": "L", "AH-JAD": "L", "NASH-DOIE-TSO": "L",
"TSIN-TLITI": "M", "BE-TAS-TNI": "M", "NA-AS-TSO-SI": "M", "TSAH": "N", "A-CHIN": "N", "NESH-CHEE": "N",
"A-KHA": "O", "TLO-CHIN": "O", "NE-AHS-JAH": "O", "NE-ASH-JAH": "O", "CLA-GI-AIH": "P", "BI-SO-DIH": "P",
"BI-SODIH": "P", "NE-ZHONI": "P", "CA-YEILTH": "Q", "GAH": "R", "DAH-NES-TSA": "R", "AH-LOSZ": "R",
"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 = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.navajo_to_text
else:
txt = eingabetext.split()
atxt = ""
for wort in txt:
w = wort.upper()
if w in nabc:
atxt = atxt + nabc[w]
return ":blue[dekodierter Text:] \n" + atxt
def pi_suche(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.pi_suche
else:
try:
piread = open("./data/pi.txt", "r")
except FileNotFoundError:
return ":red[Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
else:
pistr = ""
for zeile in piread:
pistr = pistr + zeile.rstrip()
piread.close()
pilen = len(pistr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
else:
ausgabetext = ":blue[PI (Kreiszahl)] \n \n"
pos = pistr.find(eingabetext)
if pilen >= zahlx > 0:
ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{pistr[zahlx + 1]}] \n"
f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
f":orange[{pistr[zahlx + 1:zahlx + 21]}...] \n \n")
else:
ausgabetext += f"Die verwendete pi.txt kennt leider nur :orange[{pilen:,}] Nachkommstellen. \n \n"
if pos == -1:
ausgabetext += f"Zahlenreihe in :orange[{pilen:,}] Nachkommastellen nicht zu finden."
else:
ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
f':orange[{pos - 1}.] Nachkommastelle \n20 Stellen ab :orange[{pos - 1}.] '
f'Nachkommstelle: :orange[{pistr[pos:pos + 20]}...]')
return ausgabetext
def euler_suche(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.euler_suche
else:
try:
eread = open("./data/e.txt", "r")
except FileNotFoundError:
return ":red[Sorry es scheint die Datei e.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
else:
estr = ""
for zeile in eread:
estr = estr + zeile.rstrip()
eread.close()
elen = len(estr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
else:
ausgabetext = ":blue[e (Eulersche Zahl)] \n \n"
pos = estr.find(eingabetext)
if elen >= zahlx > 0:
ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{estr[zahlx + 1]}] \n"
f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
f":orange[{estr[zahlx + 1:zahlx + 21]}...] \n \n")
else:
ausgabetext += f"Die verwendete e.txt kennt leider nur :orange[{elen:,}] Nachkommstellen. \n \n"
if pos == -1:
ausgabetext += f"Zahlenreihe in :orange[{elen:,}] Nachkommastellen nicht zu finden."
else:
ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
f':orange[{pos - 1}.] Nachkommastelle \n20 Stellen ab :orange[{pos - 1}.] '
f'Nachkommstelle: :orange[{estr[pos:pos + 20]}...]')
return ausgabetext
def goldener_schnitt_suche(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.goldener_schnitt_suche
else:
try:
phiread = open("./data/phi.txt", "r")
except ValueError:
return ":red[Sorry es scheint die Datei phi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
else:
phistr = ""
for zeile in phiread:
phistr = phistr + zeile.rstrip()
phiread.close()
philen = len(phistr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
else:
ausgabetext = ":blue[phi (Goldener Schnitt)] \n \n"
pos = phistr.find(eingabetext)
if philen >= zahlx > 0:
ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{phistr[zahlx + 1]}] \n"
f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
f":orange[{phistr[zahlx + 1:zahlx + 21]}...] \n \n")
else:
ausgabetext += (f"Die verwendete pi.txt kennt leider nur :orange[{philen:,}] "
f"Nachkommstellen. \n \n")
if pos == -1:
ausgabetext += f"Zahlenreihe in :orange[{philen:,}] Nachkommastellen nicht zu finden."
else:
ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
f':orange[{pos - 1}.] Nachkommastelle \n20 Stellen ab :orange[{pos - 1}.] '
f'Nachkommstelle: :orange[{phistr[pos:pos + 20]}...]')
return ausgabetext
def anagramm_suche_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.anagramm_suche_de
else:
try:
wbfile = open("./data/german.dic", "r",
encoding="iso-8859-15") # german.dic von https://sourceforge.net/projects/germandict/
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
eingabezaehl = helper.wortzaehl(eingabetext)
ausgabetext = ":blue[gefundene Anagramme:] \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if eingabetext.upper() == zeile.upper():
continue
if len(eingabetext) != len(zeile):
continue
if eingabezaehl == helper.wortzaehl(zeile):
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def anagramm_suche_en(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.anagramm_suche_en
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
eingabezaehl = helper.wortzaehl(eingabetext)
ausgabetext = ":blue[gefundene Anagramme:] \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if eingabetext.upper() == zeile.upper():
continue
if len(eingabetext) != len(zeile):
continue
if eingabezaehl == helper.wortzaehl(zeile):
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def wortsuche_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.wortsuche_de
else:
try:
wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:] \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if len(eingabetext) != len(zeile):
continue
fehler = 0
for c in range(len(eingabetext)):
if eingabetext[c] == "*":
continue
if eingabetext[c].upper() != zeile[c].upper():
fehler += 1
if fehler == 0:
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def wortsuche_en(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.wortsuche_en
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:] \n"
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
if len(eingabetext) != len(zeile):
continue
fehler = 0
for c in range(len(eingabetext)):
if eingabetext[c] == "*":
continue
if eingabetext[c].upper() != zeile[c].upper():
fehler += 1
if fehler == 0:
ausgabetext += zeile + " \n"
wbfile.close()
return ausgabetext
def remorse_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.remorse_de
else:
wbfile = open("./data/morse-de.dic", "r", encoding="iso-8859-15")
ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:] \n"
count = 0
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
ausgabetext += mline[1] + " \n"
count += 1
wbfile.close()
if count == 0:
return ":red[leider nichts gefunden :disappointed:]"
else:
return ausgabetext
def remorse_en(eingabetext):
alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
'2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
'?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
'.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
'(': '-.--.', "'": '.----.', 'SS': '...--..'}
ualphabet = {v: k for k, v in alphabet.items()}
ualphabet["...--.."] = "ß"
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.remorse_en
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:] \n"
if eingabetext in ualphabet:
ausgabetext += ualphabet[eingabetext] + " \n"
count = 0
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
ausgabetext += zeile + " \n"
count += 1
wbfile.close()
if count == 0:
return ":red[leider nichts gefunden :disappointed:]"
else:
return ausgabetext
def t9_de(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.t9_de
else:
wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:] \n"
count = 0
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
ausgabetext += mline[1] + " \n"
count += 1
wbfile.close()
if count == 0:
return ":red[leider nichts gefunden :disappointed:]"
else:
return ausgabetext
def t9_en(eingabetext):
alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
'3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
'0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
'-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.t9_en
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
else:
ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:] \n"
count = 0
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mzeile = ""
try:
for char in zeile:
mzeile += alphabet[char.upper()]
except KeyError:
continue
if eingabetext == mzeile:
ausgabetext += zeile + " \n"
count += 1
wbfile.close()
if count == 0:
return ":red[leider nichts gefunden :disappointed:]"
else:
return ausgabetext
def vigenere(eingabetext, pw):
bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12, 'M': 13,
'N': 14,
'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25, 'Z': 26}
ubw = {v: k for k, v in bw.items()}
if pw is None:
return hilfetexte.vigenere
pw = pw.strip()
text = eingabetext.rstrip()
if text == "" or pw == "":
return hilfetexte.vigenere
else:
for b in pw:
if b.upper() not in bw:
return ":red[Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!]"
pwl = len(pw)
encoded_text = ""
encoded_text_s = "" # wenn Leer und Sonderzeichen Schlüsselbuchstaben verbrauchen
auslz = 0 # auslasszähler zählt zeichen die im text nicht codiert wurden
for i in range(len(text)):
if text[i].upper() not in bw:
encoded_text += text[i]
auslz += 1
encoded_text_s += text[i]
else:
b1 = bw[text[i].upper()]
b2 = bw[pw[(i - auslz) % pwl].upper()]
b2s = bw[pw[i % pwl].upper()]
ba = (b1 + b2 - 1) % 26
bas = (b1 + b2s - 1) % 26
if ba == 0:
ba = 26
if bas == 0:
bas = 26
if text[i] == text[i].upper():
encoded_text += ubw[ba]
encoded_text_s += ubw[bas]
else:
encoded_text += ubw[ba].lower()
encoded_text_s += ubw[bas].lower()
decoded_text = ""
decoded_text_s = ""
auslz = 0 # auslasszähler zählt zeichen die im text nicht codiert wurden
for i in range(len(text)):
if text[i].upper() not in bw:
decoded_text += text[i]
auslz += 1
decoded_text_s += text[i]
else:
b1 = bw[text[i].upper()]
b2 = bw[pw[(i - auslz) % pwl].upper()]
b2s = bw[pw[i % pwl].upper()]
ba = (b1 - b2 + 1) % 26
bas = (b1 - b2s + 1) % 26
if ba == 0:
ba = 26
if bas == 0:
bas = 26
if text[i] == text[i].upper():
decoded_text += ubw[ba]
decoded_text_s += ubw[bas]
else:
decoded_text += ubw[ba].lower()
decoded_text_s += ubw[bas].lower()
ausgabetext = (f":blue[Dekodiert - normal:] \n{decoded_text} \n \n"
f":blue[Kodiert - normal:] \n{encoded_text} \n \n"
f":blue[Dekodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:] \n{decoded_text_s} \n \n"
f":blue[Kodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:] \n{encoded_text_s}")
return ausgabetext
def wolseley(eingabetext, pw):
abc = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird als i chiffriert
if pw is None:
return hilfetexte.wolseley
text = eingabetext.rstrip()
pw = pw.strip()
if text == "" or pw == "":
return hilfetexte.wolseley
else:
for b in pw:
if b.upper() not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
return ":red[Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!]"
text = text.upper()
pw = pw.upper()
if "J" in text:
text = text.replace("J", "I")
if "J" in pw:
pw = pw.replace("J", "I")
calpha = ""
for b in pw:
if b not in calpha:
calpha += b
for b in abc:
if b not in calpha:
calpha += b
cabc = {calpha[12]: calpha[12]}
c1 = calpha[:12]
c2 = calpha[13:]
c2 = c2[::-1]
for i in range(12):
cabc[c1[i]] = c2[i]
ucabc = {v: k for k, v in cabc.items()}
cabc.update(ucabc)
atxt = ""
for b in text:
if b in cabc:
atxt += cabc[b]
else:
atxt += b
return atxt
def atbash(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.atbash
else:
abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
uabc = abc[::-1]
cabc = {}
for i in range(26):
cabc[abc[i]] = uabc[i]
atxt = ""
for b in text:
if b.upper() in cabc:
if b == b.upper():
atxt += cabc[b]
else:
atxt += cabc[b.upper()].lower()
else:
atxt += b
return atxt
def monoalphasubstitution(eingabetext, pw):
if pw is None:
return hilfetexte.monoalphasubstitution
text = eingabetext.rstrip()
pw = pw.strip()
if text == "" or pw == "":
return hilfetexte.monoalphasubstitution
else:
abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for b in pw:
if b.upper() not in abc:
return ":red[Das Schlüsselwort/Schlüsselalphabet darf nur die Buchstaben A-Z / a-z enthalten!]"
cabc = ""
for b in pw.upper() + abc:
if b not in cabc:
cabc += b
cab = {}
for i in range(26):
cab[abc[i]] = cabc[i]
ucab = {v: k for k, v in cab.items()}
encoded_txt = ""
for b in text:
if b.upper() in cab:
if b == b.upper():
encoded_txt += cab[b]
else:
encoded_txt += cab[b.upper()].lower()
else:
encoded_txt += b
decoded_txt = ""
for b in text:
if b.upper() in ucab:
if b == b.upper():
decoded_txt += ucab[b]
else:
decoded_txt += ucab[b.upper()].lower()
else:
decoded_txt += b
ausgabetext = f":blue[Dekodiert:] \n{decoded_txt} \n \n"
ausgabetext += f":blue[Kodiert:] \n{encoded_txt} \n \n"
if len(pw) < len(abc):
ausgabetext += f":blue[Schlüsselalphabet wurde wie folgt aufgefüllt:] {cabc}"
return ausgabetext
def autokey(eingabetext, pw):
if pw is None:
return hilfetexte.autokey
text = eingabetext.rstrip()
pw = pw.strip()
if text == "" or pw == "":
return hilfetexte.autokey
else:
bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
'M': 13, 'N': 14,
'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
'Z': 26}
ubw = {v: k for k, v in bw.items()}
p_we = ""
p_wd = ""
for b in pw:
if b.upper() not in bw:
return ":red[Das Schlüsselwort darf nur die Buchstaben A-Z / a-z enthalten!]"
else:
p_we += b.upper() # Sonderzeichen aus PW entfernen und
p_wd += b.upper()
if len(p_we) < len(text):
for b in text:
if b.upper() in bw:
p_we += b.upper()
encoded_text = ""
auslz = 0 # auslasszähler zählt zeichen die im text nicht codiert wurden
for i in range(len(text)):
if text[i].upper() not in bw:
encoded_text += text[i]
auslz += 1
else:
b1 = bw[text[i].upper()]
b2 = bw[p_we[(i - auslz)]]
ba = (b1 + b2 - 1) % 26
if ba == 0:
ba = 26
if text[i] == text[i].upper():
encoded_text += ubw[ba]
else:
encoded_text += ubw[ba].lower()
decoded_text = ""
auslz = 0
for i in range(len(text)):
if text[i].upper() not in bw:
decoded_text += text[i]
auslz += 1
else:
b1 = bw[text[i].upper()]
b2 = bw[p_wd[(i - auslz)].upper()]
ba = (b1 - b2 + 1) % 26
if ba == 0:
ba = 26
p_wd += ubw[ba]
if text[i] == text[i].upper():
decoded_text += ubw[ba]
else:
decoded_text += ubw[ba].lower()
ausgabetext = (f":blue[Dekodiert:] \n{decoded_text} \n \n"
f":blue[Kodiert:] \n{encoded_text}")
return ausgabetext
def polybios_encode(eingabetext, pw):
if pw is None:
return hilfetexte.polybios_encode
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.polybios_encode
else:
qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ" # v wird durch u ersetzt
qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
text = text.upper()
textij = text.replace("J", "I")
textuv = text.replace("V", "U")
pw = pw.upper()
p_wi = pw.replace("J", "I")
p_wu = pw.replace("V", "U")
passw5ij = ""
for i in p_wi:
if i in alpha5ij:
passw5ij += i
passw5uv = ""
for i in p_wu:
if i in alpha5uv:
passw5uv += i
passw6 = ""
for i in p_wi:
if i in alpha6:
passw6 += i
text5ij = ""
for i in textij:
if i in alpha5ij or i == " ":
text5ij += i
text5uv = ""
for i in textuv:
if i in alpha5uv or i == " ":
text5uv += i
text6 = ""
for i in text:
if i in alpha6 or i == " ":
text6 += i
pw5ij = ""
for b in p_wi + alpha5ij:
if b in alpha5ij and b not in pw5ij:
pw5ij += b
pw5uv = ""
for b in p_wu + alpha5uv:
if b in alpha5uv and b not in pw5uv:
pw5uv += b
pw6 = ""
for b in pw + alpha6:
if b in alpha6 and b not in pw6:
pw6 += b
wb5ij = {" ": " "}
for i in range(25):
wb5ij[pw5ij[i]] = str(qz5[i])
wb5uv = {" ": " "}
for i in range(25):
wb5uv[pw5uv[i]] = str(qz5[i])
wb6 = {" ": " "}
for i in range(36):
wb6[pw6[i]] = str(qz6[i])
ctext5ij = ""
for b in text5ij:
ctext5ij += wb5ij[b]
ctext5uv = ""
for b in text5uv:
ctext5uv += wb5uv[b]
ctext6 = ""
for b in text6:
ctext6 += wb6[b]
ausgabetext = "|:green[Polybios 5x5 (j=i)]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Klartext]|{text5ij}|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw5ij}|\n"
ausgabetext += f"|:blue[kodiert]|{ctext5ij}\n \n"
ausgabetext += "|:green[Polybios 5x5 (v=u)]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Klartext]|{text5uv}|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw5uv}|\n"
ausgabetext += f"|:blue[kodiert]|{ctext5uv}|\n \n"
ausgabetext += "|:green[Polybios 6x6]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Klartext]|{text6}|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw6}|\n"
ausgabetext += f"|:blue[kodiert]|{ctext6}|\n"
return ausgabetext
def polybios_decode(eingabetext, pw):
if pw is None:
return hilfetexte.polybios_decode
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.polybios_decode
else:
qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ" # v wird durch u ersetzt
qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
pw = pw.upper()
p_wi = pw.replace("J", "I")
p_wu = pw.replace("V", "U")
passw5ij = ""
for i in p_wi:
if i in alpha5ij:
passw5ij += i
passw5uv = ""
for i in p_wu:
if i in alpha5uv:
passw5uv += i
passw6 = ""
for i in p_wi:
if i in alpha6:
passw6 += i
pw5ij = ""
for b in p_wi + alpha5ij:
if b in alpha5ij and b not in pw5ij:
pw5ij += b
pw5uv = ""
for b in p_wu + alpha5uv:
if b in alpha5uv and b not in pw5uv:
pw5uv += b
pw6 = ""
for b in pw + alpha6:
if b in alpha6 and b not in pw6:
pw6 += b
wb5ij = {" ": " "}
for i in range(25):
wb5ij[str(qz5[i])] = pw5ij[i]
wb5uv = {" ": " "}
for i in range(25):
wb5uv[str(qz5[i])] = pw5uv[i]
wb6 = {" ": " "}
for i in range(36):
wb6[str(qz6[i])] = pw6[i]
text = text.split()
ctext5ij = ""
ctext5uv = ""
ctext6 = ""
for wort in text:
for i in range(0, len(wort), 2):
cc = wort[i:i + 2]
if cc in wb5ij:
ctext5ij += wb5ij[cc]
if cc in wb5uv:
ctext5uv += wb5uv[cc]
if cc in wb6:
ctext6 += wb6[cc]
ctext5ij += " "
ctext5uv += " "
ctext6 += " "
ausgabetext = "|:green[Polybios 5x5 (j=i)]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw5ij}|\n"
ausgabetext += f"|:blue[dekodiert]|{ctext5ij}|\n \n"
ausgabetext += "|:green[Polybios 5x5 (v=u)]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw5uv}|\n"
ausgabetext += f"|:blue[dekodiert]|{ctext5uv}|\n \n"
ausgabetext += "|:green[Polybios 6x6]| |\n"
ausgabetext += "|-|-|\n"
ausgabetext += f"|:blue[Schlüsselwort]|{passw6}|\n"
ausgabetext += f"|:blue[dekodiert]|{ctext6}|\n"
return ausgabetext
def klopfcode_encode(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.klopfcode_encode
else:
qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
alpha = "ABCDEFGHIJLMNOPQRSTUVWXYZ" # k wird durch c ersetzt
text = text.upper()
text = text.replace("K", "C")
text5 = ""
for i in text:
if i in alpha or i == " ":
text5 += i
wb5 = {" ": " "}
for i in range(25):
wb5[alpha[i]] = str(qz5[i])
ctext = ""
for b in text5:
ctext += wb5[b]
ausgabetext = f":blue[Klartext:] {text5} \n"
ausgabetext += f":blue[kodiert:] {ctext}"
return ausgabetext
def klopfcode_decode(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.klopfcode_decode
else:
qz5 = [11, 12, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
alpha = "ABDEFGHIJLMNOPQRSTUVWXYZ" # k wird durch c ersetzt
wb = {" ": " ", "13": "[C/K]"}
for i in range(24):
wb[str(qz5[i])] = alpha[i]
text = text.split()
ctext = ""
for wort in text:
for i in range(0, len(wort), 2):
cc = wort[i:i + 2]
if cc in wb:
ctext += wb[cc]
ctext += " "
return f":blue[Klopfcode dekodiert]: \n{ctext}"
def maptiles_kachelkoordinaten(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.maptiles_kachelkoordinaten, None
else:
text = text.split()
if "." in text[0] and len(text) == 2:
ausgabetext = ":violet[DEC -> Maptiles] \n|:blue[Zoom]|:blue[X]|:blue[Y]|\n|-|-|-|\n"
for zoom in range(1, 26):
try:
la = float(text[0])
lo = float(text[1])
if not la < -83.0 and not la > 83.0 and not lo < -180 and not lo > 180:
x, y = helper.dec_to_maptiles(la, lo, zoom)
ausgabetext += f"|{zoom:>2}|{x:<10}|{y}|\n"
except ValueError:
pass
return ausgabetext, None
elif len(text) == 2:
ausgabetext = ":violet[Maptiles->DEG,DEC] \n|:blue[Zoom]|:blue[DEG]|:blue[DEC]|\n|-|-|-|\n"
lat_list, lon_list, label_list = [], [], []
for zoom in range(2, 26):
try:
la, lo = helper.maptiles_to_dec(int(text[0]), int(text[1]), zoom)
if not la < -83.0 and not la > 83.0 and not lo < -180 and not lo > 180:
ausgabetext += f"|{zoom:>2}|{helper.dec_to_deg(la, lo):<23}|{round(la, 5)} {round(lo, 5)}| \n"
lat_list.append(la)
lon_list.append(lo)
label_list.append(zoom)
except OverflowError:
pass
return ausgabetext, pd.DataFrame({'lat': lat_list, 'lon': lon_list, 'label': label_list})
else:
return ":red[Zahlen konnten nicht ermittelt werden!]", None
def quadtree_koordinaten(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.quadtree_koordinaten, None
else:
tile_x = 0
tile_y = 0
quadkey = text
fehler = 0
zoom = len(quadkey)
for i in range(zoom, 0, -1):
mask = 1 << (i - 1)
if quadkey[zoom - i] == "0":
continue
if quadkey[zoom - i] == "1":
tile_x |= mask
continue
if quadkey[zoom - i] == "2":
tile_y |= mask
continue
if quadkey[zoom - i] == "3":
tile_x |= mask
tile_y |= mask
continue
else:
fehler += 1
la, lo = helper.maptiles_to_dec(tile_x, tile_y, zoom)
if fehler == 0:
ausgabetext = f":blue[Maptiles: X:] {tile_x} :blue[Y:] {tile_y} :blue[Zoom:] {zoom} \n"
ausgabetext += f":blue[DEC:] {round(la, 5)} {round(lo, 5)} \n"
ausgabetext += f":blue[DEG:] {helper.dec_to_deg(la, lo)}"
return ausgabetext, pd.DataFrame({'lat': [la], 'lon': [lo]})
else:
return (":red[Es konnte keine gültige Quadtree-Koordinate erkannt werden. (eine Zahl die nur die Ziffern "
"0,1,2,3 enthält)]"), None
def chronogramm(eingabetext):
text = eingabetext.rstrip()
if text == "":
return hilfetexte.chronogramm
else:
text = text.upper()
i, v, x, ll, c, d, m, y, w, u, j = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
for r_chr in text:
if r_chr == "I":
i += 1
if r_chr == "V":
v += 1
if r_chr == "X":
x += 1
if r_chr == "L":
ll += 1
if r_chr == "C":
c += 1
if r_chr == "D":
d += 1
if r_chr == "M":
m += 1
if r_chr == "U":
u += 1
if r_chr == "J":
j += 1
if r_chr == "Y":
y += 1
if r_chr == "W":
w += 1
sum_einfach = i + (v * 5) + (x * 10) + (ll * 50) + (c * 100) + (d * 500) + (m * 1000)
sum_erweitert = sum_einfach + (u * 5) + j
sum_extrem = sum_erweitert + (y * 2) + (w * 10)
ausgabetext = "|:blue[Buchstabe]|:blue[Wert]|:blue[Anzahl]|:blue[Summe]|\n|-|-|-|-|\n"
ausgabetext += f"|I|1|{i}|{i}|\n"
ausgabetext += f"|V|5|{v}|{v*5}|\n"
ausgabetext += f"|X|10|{x}|{x*10}|\n"
ausgabetext += f"|L|50|{ll}|{ll*50}|\n"
ausgabetext += f"|C|100|{c}|{c*100}|\n"
ausgabetext += f"|D|500|{d}|{d*500}|\n"
ausgabetext += f"|M|1000|{m}|{m*1000}\n"
ausgabetext += f"|J(=I)|1|{j}|{j}|\n"
ausgabetext += f"|U(=V)|5|{u}|{u*5}|\n"
ausgabetext += f"|Y(=I+I)|2|{y}|{y*2}|\n"
ausgabetext += f"|W(=V+V)|10|{w}|{w*10}\n \n"
ausgabetext += f":blue[Summe einfach(I,V,X,L,C,D,M):] {sum_einfach} \n"
ausgabetext += f":blue[Summe erweitert(inkl. I,U):] {sum_erweitert} \n"
ausgabetext += f":blue[Summe extrem(inkl.J,U,Y,W):] {sum_extrem}"
return ausgabetext
def zahlen_roemisch_arabisch_umwandeln(eingabetext):
rza = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000, '\u2181': 5000, '\u2182': 10000,
'\u2187': 50000, '\u2188': 100000}
azr = [(100000, '\u2188'), (90000, '\u2182\u2188'), (50000, '\u2187'), (40000, '\u2182\u2187'),
(10000, '\u2182'), (9000, 'M\u2182'), (5000, '\u2181'), (4000, 'M\u2181'), (1000, 'M'), (900, 'CM'),
(500, 'D'),
(400, 'CD'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'),
(1, 'I')]
rz = eingabetext.rstrip()
if rz == "":
return hilfetexte.zahlen_roemisch_arabisch_umwandeln
else:
rz = rz.upper()
try:
az = 0
for i in range(len(rz)):
if i == len(rz) - 1:
az += rza[rz[i]]
return f"{rz} = {az}"
else:
if rza[rz[i]] < rza[rz[i + 1]]:
az -= rza[rz[i]]
else:
az += rza[rz[i]]
except KeyError:
try:
zahl = int(rz)
if zahl > 500000:
return ":red[arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!]"
rom = ""
for az, romz in azr:
count = zahl // az
zahl -= az * count
rom += romz * count
return f"{rz} = {rom}"
except ValueError:
return ":red[Es konnte keine römische oder arabische Zahl erkannt werden!]"
return ""
def url_decode(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.url_decode
else:
atxt = urllib_parse_unquote(eingabetext)
return f":blue[dekodierte URL:] `{atxt}`"
def reversewig(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.reversewig, None
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
return ":red[Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]" , None
else:
txt = eingabetext.split(se)
if len(txt) == 3:
for z in txt:
try:
int(z)
except ValueError:
return ":red[Bitte die Eingabezahlen überprüfen!]", None
la, lo = helper.rwig_to_coords(txt[0], txt[1], txt[2])
if (not la < -85.05113 and not la > 85.05113 and not lo < -180 and not lo > 180 and
not (la == 0 and lo == 0)):
ausgabetext = f":blue[WIG:] {txt[0]}, {txt[1]}, {txt[2]} \n"
ausgabetext += f":blue[DEC:] {round(la, 5)} {round(lo, 5)} \n"
ausgabetext += f":blue[DEG:] {helper.dec_to_deg(la, lo)} \n"
return ausgabetext, pd.DataFrame({'lat': [la], 'lon': [lo]})
else:
return f":red[Die Zahlen ergeben keine sinnvolle Koordinate!!! {la, lo}]", None
else:
return ":red[Es wurden nicht 3 Zahlen erkannt.]", None
def base64_ascii(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.base64_ascii
else:
try:
ascii_string = binascii.a2b_base64(eingabetext).decode()
return f":blue[Base64 -> ASCII:] \n{ascii_string} \n"
except ValueError:
base64_string = binascii.b2a_base64(eingabetext.encode())
return (f":red[Umwandlung Base64 -> ASCII war nicht möglich.] \n"
f":blue[ASCII -> Base64:] \n{base64_string.decode()}")
def jaegerzaun_encrypt(eingabetext, pw):
if pw is None:
return hilfetexte.jaegerzaun_encrypt
eingabetext = eingabetext.strip().replace("\n", " ")
pw = pw.strip()
if eingabetext == "":
return hilfetexte.jaegerzaun_encrypt
elif pw == "" or not pw.isdigit():
return ":red[Bitte eine Zahl im Schlüsselfeld eingeben!!]"
else:
try:
if int(pw) < 2:
raise ValueError("Zahl zu klein")
return (f":blue[inkl. Leerzeichen] \n{helper.rail_encrypt(eingabetext, int(pw))} \n \n"
f":blue[ohne Leerzeichen] \n{helper.rail_encrypt(eingabetext.replace(" ", ""), int(pw))}")
except ValueError:
return ":red[Schlüsselzahl fehlerhaft oder kleiner als 2.]"
def jaegerzaun_decrypt(eingabetext, pw):
if pw is None:
return hilfetexte.jaegerzaun_decrypt
eingabetext = eingabetext.strip().replace("\n", " ")
pw = pw.strip()
if eingabetext == "":
return hilfetexte.jaegerzaun_decrypt
elif pw == "":
ausgabtext = ":blue[inkl. Leerzeichen] \n"
for i in range(12, 1, -1):
ausgabtext += f':blue[{i:02}:] {helper.rail_decrypt(eingabetext, i)} \n'
ausgabtext += " \n:blue[ohne Leerzeichen] \n"
for i in range(12, 1, -1):
ausgabtext += f':blue[{i:02}:] {helper.rail_decrypt(eingabetext.replace(" ", ""), i)} \n'
return ausgabtext
elif not pw.isdigit():
return ":red[Bitte eine Zahl im Schlüsselfeld eingeben!!]"
else:
try:
if int(pw) < 2:
raise ValueError("Zahl zu klein")
ausgabetext = (f"_inkl. Leerzeichen_ \n{helper.rail_decrypt(eingabetext, int(pw))} \n \n"
f"_ohne Leerzeichen_ \n{helper.rail_decrypt(eingabetext.replace(" ", ""), int(pw))}")
return ausgabetext
except ValueError:
return "Schlüsselzahl fehlerhaft oder kleiner als 2.\n"
def adfgx_kodieren(eingabetext, pw):
if pw is None:
return hilfetexte.adfgx_kodieren
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.adfgx_kodieren
else:
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
text = text.upper().replace("J", "I")
pw = pw.upper().replace("J", "I").split(",")
if len(pw) != 2:
return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
pw[0] = pw[0].strip()
pw[1] = pw[1].strip()
pw1az = ""
for b in pw[0] + alpha_az:
if b in alpha_az and b not in pw1az:
pw1az += b
pw1za = ""
for b in pw[0] + alpha_za:
if b in alpha_za and b not in pw1za:
pw1za += b
pw2 = ""
for i in pw[1]:
if i in alpha_az:
pw2 += i
klartext = ""
for i in text:
if i in alpha_az:
klartext += i
w_baz = {}
for i in range(25):
w_baz[pw1az[i]] = rn[i]
w_bza = {}
for i in range(25):
w_bza[pw1za[i]] = rn[i]
ctext1az = ""
for b in klartext:
ctext1az += w_baz[b]
print(ctext1az)
ctext1za = ""
for b in klartext:
ctext1za += w_bza[b]
ctext2az = []
for i in range(len(pw2)):
ctext2az.append([pw2[i] + str(i + 10)])
for i in range(len(ctext1az)):
ctext2az[i % len(pw2)].append(ctext1az[i])
ctext2az.sort()
ausgabe_az = ""
z = 1
for i in ctext2az:
for j in range(len(i) - 1):
if z == 5:
ausgabe_az += i[j + 1] + " "
z = 1
else:
ausgabe_az += i[j + 1]
z += 1
ctext2za = []
for i in range(len(pw2)):
ctext2za.append([pw2[i] + str(i + 10)])
for i in range(len(ctext1za)):
ctext2za[i % len(pw2)].append(ctext1za[i])
ctext2za.sort()
ausgabe_za = ""
z = 1
for i in ctext2za:
for j in range(len(i) - 1):
if z == 5:
ausgabe_za += i[j + 1] + " "
z = 1
else:
ausgabe_za += i[j + 1]
z += 1
ausgabetext = f":blue[Passwort 1:] {pw[0]} \n"
ausgabetext += f":blue[Passwort 2:] {pw2} \n \n"
ausgabetext += f":blue[kodiert mit Variante A-Z:] \n{ausgabe_az} \n \n"
ausgabetext += f":blue[kodiert mit Variante Z-A:] \n{ausgabe_za}"
return ausgabetext
def adfgx_dekodieren(eingabetext, pw):
if pw is None:
return hilfetexte.adfgx_dekodieren
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.adfgx_dekodieren
else:
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
text = text.upper()
text = text.replace("J", "I")
pw = pw.upper()
pw = pw.replace("J", "I")
pw = pw.split(",")
if len(pw) != 2:
return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
pw[0] = pw[0].strip()
pw[1] = pw[1].strip()
pw1az = ""
for b in pw[0] + alpha_az:
if b in alpha_az and b not in pw1az:
pw1az += b
pw1za = ""
for b in pw[0] + alpha_za:
if b in alpha_za and b not in pw1za:
pw1za += b
pw2 = ""
for i in pw[1]:
if i in alpha_az:
pw2 += i
ctext = ""
for i in text:
if i in alpha_az:
ctext += i
w_baz = {}
for i in range(25):
w_baz[rn[i]] = pw1az[i]
w_bza = {}
for i in range(25):
w_bza[rn[i]] = pw1za[i]
ret = ['_'] * len(ctext)
lt, lp = len(ctext), len(pw2)
t1 = [(pw2[i], i) for i in range(len(pw2))]
ind = [q[1] for q in sorted(t1)]
upto = 0
for i in range(len(pw2)):
tic = int(lt / lp)
if ind[i] < lt % lp:
tic += 1
ret[ind[i]::lp] = ctext[upto:upto + tic]
upto += tic
ctext = ''.join(ret)
klartext_az = ""
for i in range(0, len(ctext), 2):
bi = ctext[i:i + 2]
if bi in w_baz:
klartext_az += w_baz[bi]
klartext_za = ""
for i in range(0, len(ctext), 2):
bi = ctext[i:i + 2]
if bi in w_bza:
klartext_za += w_bza[bi]
ausgabetext = f":blue[Passwort 1:] {pw[0]} \n"
ausgabetext += f":blue[Passwort 2:] {pw2} \n \n"
ausgabetext += f":blue[dekodiert mit Variante A-Z:] \n{klartext_az} \n \n"
ausgabetext += f":blue[dekodiert mit Variante Z-A:] \n{klartext_za}"
return ausgabetext
def adfgvx_kodieren(eingabetext, pw):
if pw is None:
return hilfetexte.adfgvx_kodieren
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.adfgvx_kodieren
else:
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
"XV", "XX"]
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
text = text.upper()
pw = pw.upper().split(",")
if len(pw) != 2:
return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
pw[0] = pw[0].strip()
pw[1] = pw[1].strip()
pw1az09 = ""
for b in pw[0] + alpha_az09:
if b in alpha_az09 and b not in pw1az09:
pw1az09 += b
pw190za = ""
for b in pw[0] + alpha_90za:
if b in alpha_90za and b not in pw190za:
pw190za += b
pw2 = ""
for i in pw[1]:
if i in alpha_az09:
pw2 += i
klartext = ""
for i in text:
if i in alpha_az09:
klartext += i
w_baz09 = {}
for i in range(36):
w_baz09[pw1az09[i]] = rn[i]
wb90za = {}
for i in range(36):
wb90za[pw190za[i]] = rn[i]
ctext1az09 = ""
for b in klartext:
ctext1az09 += w_baz09[b]
ctext190za = ""
for b in klartext:
ctext190za += wb90za[b]
ctext2az09 = []
for i in range(len(pw2)):
ctext2az09.append([pw2[i] + str(i + 10)])
for i in range(len(ctext1az09)):
ctext2az09[i % len(pw2)].append(ctext1az09[i])
ctext2az09.sort()
ausgabe_az09 = ""
z = 1
for i in ctext2az09:
for j in range(len(i) - 1):
if z == 5:
ausgabe_az09 += i[j + 1] + " "
z = 1
else:
ausgabe_az09 += i[j + 1]
z += 1
ctext290za = []
for i in range(len(pw2)):
ctext290za.append([pw2[i] + str(i + 10)])
for i in range(len(ctext190za)):
ctext290za[i % len(pw2)].append(ctext190za[i])
ctext290za.sort()
ausgabe_90za = ""
z = 1
for i in ctext290za:
for j in range(len(i) - 1):
if z == 5:
ausgabe_90za += i[j + 1] + " "
z = 1
else:
ausgabe_90za += i[j + 1]
z += 1
ausgabetext = f":blue[Passwort 1:] {pw[0]} \n"
ausgabetext += f":blue[Passwort 2:] {pw2} \n \n"
ausgabetext += f":blue[kodiert mit Variante A-Z,0-9:] \n{ausgabe_az09} \n \n"
ausgabetext += f":blue[kodiert mit Variante 9-0,Z-A:] \n{ausgabe_90za}"
return ausgabetext
def adfgvx_dekodieren(eingabetext, pw):
if pw is None:
return hilfetexte.adfgvx_dekodieren
text = eingabetext.rstrip()
pw = pw.strip()
if text == "":
return hilfetexte.adfgvx_dekodieren
else:
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
"XV", "XX"]
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
text = text.upper()
pw = pw.upper()
pw = pw.split(",")
if len(pw) != 2:
return ":red[Es es werden genau zwei durch Komma getrennte Passwörter benötigt!]"
pw[0] = pw[0].strip()
pw[1] = pw[1].strip()
pw1az09 = ""
for b in pw[0] + alpha_az09:
if b in alpha_az09 and b not in pw1az09:
pw1az09 += b
pw190za = ""
for b in pw[0] + alpha_90za:
if b in alpha_90za and b not in pw190za:
pw190za += b
pw2 = ""
for i in pw[1]:
if i in alpha_az09:
pw2 += i
ctext = ""
for i in text:
if i in alpha_az09:
ctext += i
w_baz09 = {}
for i in range(36):
w_baz09[rn[i]] = pw1az09[i]
wb90za = {}
for i in range(36):
wb90za[rn[i]] = pw190za[i]
ret = ['_'] * len(ctext)
lt, lp = len(ctext), len(pw2)
t1 = [(pw2[i], i) for i in range(len(pw2))]
ind = [q[1] for q in sorted(t1)]
upto = 0
for i in range(len(pw2)):
tic = int(lt / lp)
if ind[i] < lt % lp:
tic += 1
ret[ind[i]::lp] = ctext[upto:upto + tic]
upto += tic
ctext = ''.join(ret)
klartext_az09 = ""
for i in range(0, len(ctext), 2):
bi = ctext[i:i + 2]
if bi in w_baz09:
klartext_az09 += w_baz09[bi]
klartext_90za = ""
for i in range(0, len(ctext), 2):
bi = ctext[i:i + 2]
if bi in wb90za:
klartext_90za += wb90za[bi]
ausgabetext = f":blue[Passwort 1:] {pw[0]} \n"
ausgabetext += f":blue[Passwort 2:] {pw2} \n \n"
ausgabetext += f":blue[dekodiert mit Variante A-Z,0-9:] \n{klartext_az09} \n \n"
ausgabetext += f":blue[dekodiert mit Variante 9-0,Z-A:] \n{klartext_90za}"
return ausgabetext
def brainfuck_to_text(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.brainfuck_interpreter
else:
return f"```\n{brainfuckery.Brainfuckery().interpret(eingabetext)}\n```"
def text_to_brainfuck(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.brainfuck_interpreter
else:
return brainfuckery.Brainfuckery().convert(eingabetext)
def ook_to_text(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ook_interpreter
else:
ook_zeichen = [".", "!", "?"]
ook_text = ""
for z in eingabetext: # erstmal Short-Ook draus machen
if z in ook_zeichen:
ook_text = ook_text + z
ook_bf_dict = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
bf_text = ""
for o in range(0, len(ook_text), 2): # jetzt in Brainfuck umwandeln
ooz = ook_text[o:o + 2]
if ooz in ook_bf_dict:
bf_text = bf_text + ook_bf_dict[ooz]
return f"```\n{brainfuckery.Brainfuckery().interpret(bf_text)}\n```"
def text_to_ook(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.ook_interpreter
else:
bf_text = brainfuckery.Brainfuckery().convert(eingabetext)
ook_bf_dict = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
bf_ook_dict = {v: k for k, v in ook_bf_dict.items()}
short_ook = ""
for b in bf_text:
short_ook += bf_ook_dict[b]
ook_txt = ""
for z in short_ook:
ook_txt += f"Ook{z} "
return f":blue[Short-Ook:] \n{short_ook} \n \n:blue[Ook:] \n{ook_txt}"
def rlou_to_graph(eingabetext):
eingabetext = eingabetext.rstrip()
if eingabetext == "":
return hilfetexte.rlou_to_graph, None
else:
if "O" in eingabetext.upper():
moves = {'R': (1, 0), 'L': (-1, 0), 'O': (0, 1), 'U': (0, -1)}
elif "D" in eingabetext.upper():
moves = {'R': (1, 0), 'L': (-1, 0), 'U': (0, 1), 'D': (0, -1)}
else:
return (":red[Es wurde weder ein O oder ein D gefunden um festzustellen ob RLOU oder RLUD verwendet werden"
"soll]"), None
directions_list = eingabetext.split()
x, y = 0, 0
path = []
for directions in directions_list:
part = [(x,y)]
for d in directions.upper():
if d in moves:
dx, dy = moves[d]
x += dx
y += dy
part.append((x, y))
path.append(part)
x += 3
return f":blue[Graph:]", path
Reference in New Issue View Git Blame Copy Permalink