2727 lines
104 KiB
Python
2727 lines
104 KiB
Python
# 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
|
|
|
|
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"__{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 += "|_Buchstabenwerte:_|"
|
|
ausgabe += az[0:-1] + "|\n"
|
|
ausgabe += "|_Buchstabenwortwerte:_|"
|
|
ausgabe += eworttxt[0:-1] + "|\n"
|
|
ausgabe += "|_Summe aller Buchstabenwerte:_|"
|
|
ausgabe += str(wortsumme) + "|\n"
|
|
ausgabe += "|_Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:_|"
|
|
ausgabe += str(helper.q_sum(wortsumme)) + " / " + str(helper.iq_sum(wortsumme)) + "|\n"
|
|
ausgabe += "|_Buchstabenanzahl pro Wort:_|"
|
|
ausgabe += banzwtxt[0:-1] + "|\n"
|
|
ausgabe += "|_Gesamtanzahl aller Buchstaben:_|"
|
|
ausgabe += str(banzahla) + "|\n"
|
|
ausgabe += "|_Wortprodukte(0 wenn kein Buchstabe gefunden):_|"
|
|
ausgabe += ewortptxt[0:-1] + "|\n"
|
|
ausgabe += "|_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 "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n"
|
|
else:
|
|
if ausz not in bw:
|
|
return "Die eingegebene Zahl ist kein gültiger Buchstabenwert!\n"
|
|
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 += "_Achtung folgendes wurde ignoriert:_ \n"
|
|
ausgabe_text += ignor + " \n \n"
|
|
ausgabe_text += "_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 = []
|
|
for key in anzahl:
|
|
s.append(key)
|
|
s.sort()
|
|
ausgabetext += f"Es wurden {len(anzahl)} unterschiedliche Zeichen gefunden. \n"
|
|
ausgabetext += "| Zeichen | 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 "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
return f"_Quersumme:_ {helper.q_sum(ausz)} \n_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 += "_Achtung nicht erkannte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_Quersummen:_ \n"
|
|
ausgabetext += qtxt[:-1] + " \n \n"
|
|
ausgabetext += "_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 = "__mit 4__ \n"
|
|
ausgabetext += "_insgesamt gefundene Einschlüsse:_ "
|
|
ausgabetext += f"{sum(wortsummenliste_mit)} \n"
|
|
ausgabetext += "_Einschlüsse pro Wort:_ "
|
|
for z in wortsummenliste_mit:
|
|
ausgabetext += f"{z} "
|
|
ausgabetext += " \n \n"
|
|
ausgabetext += "__ohne 4__ \n"
|
|
ausgabetext += "_insgesamt gefundene Einschlüsse:_ "
|
|
ausgabetext += f"{sum(wortsummenliste_ohne)} \n"
|
|
ausgabetext += "_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 + "#"
|
|
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 "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 += "_Achtung nicht erkannte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 "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 += "_Achtung nicht erkannte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 "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 += "_Achtung nicht erkannte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 ("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 "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 += "_Achtung nicht erkannte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 "Leider keine Zahlwörter gefunden!"
|
|
else:
|
|
ausgabetext = "_Gefundene Zahlwörter:_ \n"
|
|
ausgabetext += atxt + " \n \n"
|
|
ausgabetext += "_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 "Leider keine Zahlwörter gefunden!"
|
|
else:
|
|
ausgabetext = "_Gefundene Zahlwörter:_ \n"
|
|
ausgabetext += atxt + " \n \n"
|
|
ausgabetext += "_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"_{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 "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
if ausz in pdict:
|
|
return pdict[ausz]
|
|
else:
|
|
return 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 += "_ignoriert wurde:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 "Keine Zahl erkannt!"
|
|
else:
|
|
if ausz > 1299709:
|
|
return ("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"{ausz:,} ist keine Primzahl"
|
|
else:
|
|
return f"{ausz:,} ist die {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 "Keine Zahl erkannt!"
|
|
if ausz > 100000:
|
|
return "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 {ausz:,}. Primzahl lautet: {primes[ausz - 1]:,}"
|
|
|
|
def primfaktoren(eingabetext):
|
|
eingabetext = eingabetext.rstrip()
|
|
if eingabetext == "":
|
|
return hilfetexte.primfaktoren
|
|
else:
|
|
try:
|
|
n = int(eingabetext)
|
|
except ValueError:
|
|
return "Es konnte leider keine Zahl erkannt werden."
|
|
faktoren = []
|
|
for i in chain([2], range(3, n // 2 + 1, 2)):
|
|
if i > 100000000:
|
|
return ("Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als "
|
|
"100 Millionen ist.")
|
|
while n % i == 0:
|
|
faktoren.append(i)
|
|
n = n // i
|
|
if i > n:
|
|
break
|
|
out = f"_Die Zahl {eingabetext} hat folgende Primfaktoren:_ \n"
|
|
if not faktoren:
|
|
return f"Die Zahl {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 "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
return "Dez: {0:} \nHEX: {0:X} \nOCT: {0:o} \nBIN: {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"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
|
|
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
|
|
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
|
|
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
|
|
ausgabetext += f"_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 "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
return "HEX: {0:X} \nDez: {0:} \nOCT: {0:o} \nBIN: {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"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
|
|
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
|
|
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
|
|
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
|
|
ausgabetext += f"_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 "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
return "OCT: {0:o} \nHEX: {0:X} \nDez: {0:} \nBIN: {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"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
|
|
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
|
|
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
|
|
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
|
|
ausgabetext += f"_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 "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
return "BIN: {0:b} \nHEX: {0:X} \nDez: {0:} \nOCT: {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"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
|
|
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
|
|
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
|
|
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
|
|
ausgabetext += f"_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 += "_ignorierte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 += "_ignorierte Zeichen:_ \n"
|
|
ausgabetext += ignor + " \n \n"
|
|
ausgabetext += "_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 "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 += z + ":" + str(um_pse[z]) + " "
|
|
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 += "_Achtung nicht erkannte Zeichen:_ \n" + ignor + " \n \n"
|
|
if atxt != "":
|
|
ausgabetext += "_Symbole:_ \n" + atxt + " \n \n"
|
|
if atxt2 != "":
|
|
ausgabetext += "_Nur Anfangsbuchstaben:_ \n" + atxt2 + " \n \n"
|
|
if atxt3 != "":
|
|
ausgabetext += "_Symbol:Ordnungszahl_ \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 "_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 "_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 "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 "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
|
|
else:
|
|
ausgabetext = "_PI (Kreiszahl)_ \n \n"
|
|
pos = pistr.find(eingabetext)
|
|
if pilen >= zahlx > 0:
|
|
ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {pistr[zahlx + 1]} \n_20 Stellen ab "
|
|
f"{zahlx}. Nachkommstelle:_ {pistr[zahlx + 1:zahlx + 21]}... \n \n")
|
|
else:
|
|
ausgabetext += f"_Die verwendete pi.txt kennt leider nur {pilen:,} Nachkommstellen._ \n \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 euler_suche(eingabetext):
|
|
eingabetext = eingabetext.rstrip()
|
|
if eingabetext == "":
|
|
return hilfetexte.euler_suche
|
|
else:
|
|
try:
|
|
eread = open("./data/e.txt", "r")
|
|
except FileNotFoundError:
|
|
return "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 "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
|
|
else:
|
|
ausgabetext = "_e (Eulersche Zahl)_ \n \n"
|
|
pos = estr.find(eingabetext)
|
|
if elen >= zahlx > 0:
|
|
ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {estr[zahlx + 1]} \n_20 Stellen ab "
|
|
f"{zahlx}. Nachkommstelle:_ {estr[zahlx + 1:zahlx + 21]}... \n \n")
|
|
else:
|
|
ausgabetext += f"_Die verwendete pi.txt kennt leider nur {elen:,} Nachkommstellen._ \n \n"
|
|
if pos == -1:
|
|
ausgabetext += f"_Zahlenreihe in {elen:,} 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'{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 "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 "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
|
|
else:
|
|
ausgabetext = "_phi (Goldener Schnitt)_ \n \n"
|
|
pos = phistr.find(eingabetext)
|
|
if philen >= zahlx > 0:
|
|
ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {phistr[zahlx + 1]} \n_20 Stellen ab "
|
|
f"{zahlx}. Nachkommstelle:_ {phistr[zahlx + 1:zahlx + 21]}... \n \n")
|
|
else:
|
|
ausgabetext += f"_Die verwendete pi.txt kennt leider nur {philen:,} Nachkommstellen._ \n \n"
|
|
if pos == -1:
|
|
ausgabetext += f"_Zahlenreihe in {philen:,} 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'{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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
eingabezaehl = helper.wortzaehl(eingabetext)
|
|
ausgabetext = "_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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
eingabezaehl = helper.wortzaehl(eingabetext)
|
|
ausgabetext = "_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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_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:
|
|
try:
|
|
wbfile = open("./data/morse-de.dic", "r",
|
|
encoding="iso-8859-15") # german.dic von https://sourceforge.net/projects/germandict/
|
|
except FileNotFoundError:
|
|
try:
|
|
testfile = open("./data/german.dic", "r")
|
|
testfile.close()
|
|
if eingabetext == "GENERATE":
|
|
helper.remorse_generate_morsede()
|
|
return "Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
|
|
else:
|
|
ausgabetext = ("_Da das Remorse-Wörterbuch noch nicht generiert wurde, wurde das normale_ "
|
|
"_Wörterbuch für die Suche benutzt, das dauert zwar ca. 5x so lange, aber geht_ "
|
|
"_auch._ \n"
|
|
"_Um das Remorse-Wörterbuch zu erzeugen bitte das Wort:_ __GENERATE__ _ins_ "
|
|
"_Eingabefeld eingeben und die Funktion starten._ \n \n")
|
|
return ausgabetext + helper.remorse_germandic(eingabetext)
|
|
except FileNotFoundError:
|
|
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_ \n"
|
|
for zeile in wbfile:
|
|
zeile = zeile.strip(" \t\n\r")
|
|
mline = zeile.split(",")
|
|
if eingabetext == mline[0]:
|
|
ausgabetext += mline[1] + " \n"
|
|
wbfile.close()
|
|
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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_ \n"
|
|
if eingabetext in ualphabet:
|
|
ausgabetext += ualphabet[eingabetext] + " \n"
|
|
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"
|
|
wbfile.close()
|
|
return ausgabetext
|
|
|
|
def t9_de(eingabetext):
|
|
eingabetext = eingabetext.rstrip()
|
|
if eingabetext == "":
|
|
return hilfetexte.t9_de
|
|
else:
|
|
try:
|
|
wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
|
|
except FileNotFoundError:
|
|
try:
|
|
testfile = open("./data/german.dic", "r")
|
|
testfile.close()
|
|
if eingabetext == "GENERATE":
|
|
helper.t9_generate_t9de()
|
|
return "t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
|
|
else:
|
|
ausgabetext = ("_Da das T9-Wörterbuch nicht vorhanden ist, wurde das normale Wörterbuch für die_ "
|
|
"_Suche benutzt. Das dauert zwar ca. 7x so lange, aber geht auch._ \n"
|
|
"_Um das spezielle T9-Wörterbuch zu erzeugen bitte das Wort:_ __GENERATE__ _ins_ "
|
|
"_Eingabefeld eingeben und die Funktion starten._ \n \n")
|
|
return ausgabetext + helper.t9_germandic(eingabetext)
|
|
except FileNotFoundError:
|
|
return "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_ \n"
|
|
for zeile in wbfile:
|
|
zeile = zeile.strip(" \t\n\r")
|
|
mline = zeile.split(",")
|
|
if eingabetext == mline[0]:
|
|
ausgabetext += mline[1] + " \n"
|
|
wbfile.close()
|
|
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 "Leider konnte die Wörterbuchdatei nicht geladen werden."
|
|
else:
|
|
ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_ \n"
|
|
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"
|
|
wbfile.close()
|
|
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 "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"_Dekodiert - normal:_ \n{decoded_text} \n \n_Kodiert - normal:_ \n{encoded_text} \n \n"
|
|
ausgabetext += f"_Dekodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:_ \n{decoded_text_s} \n \n"
|
|
ausgabetext += f"_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 "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 "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"_Dekodiert:_ \n{decoded_txt} \n \n"
|
|
ausgabetext += f"_Kodiert:_ \n{encoded_txt} \n \n"
|
|
if len(pw) < len(abc):
|
|
ausgabetext += f"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 "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"_Dekodiert:_ \n{decoded_text} \n \n"
|
|
ausgabetext += f"_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 = "|Polybios 5x5 (j=i)| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Klartext|{text5ij}|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw5ij}|\n"
|
|
ausgabetext += f"|kodiert|{ctext5ij}\n \n"
|
|
ausgabetext += "|Polybios 5x5 (v=u)| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Klartext|{text5uv}|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw5uv}|\n"
|
|
ausgabetext += f"|kodiert|{ctext5uv}|\n \n"
|
|
ausgabetext += "|Polybios 6x6| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Klartext|{text6}|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw6}|\n"
|
|
ausgabetext += f"|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 = "|Polybios 5x5 (j=i)| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw5ij}|\n"
|
|
ausgabetext += f"|dekodiert|{ctext5ij}|\n \n"
|
|
ausgabetext += "|Polybios 5x5 (v=u)| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw5uv}|\n"
|
|
ausgabetext += f"|dekodiert|{ctext5uv}|\n \n"
|
|
ausgabetext += "|Polybios 6x6| |\n"
|
|
ausgabetext += "|-|-|\n"
|
|
ausgabetext += f"|Schlüsselwort|{passw6}|\n"
|
|
ausgabetext += f"|dekodiert|{ctext6}|\n"
|
|
return ausgabetext
|
|
|
|
def klopfcode_encode(eingabetext):
|
|
text = eingabetext.rstrip()
|
|
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]
|
|
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"Klartext: {text5} \n"
|
|
ausgabetext += f"kodiert: {ctext}"
|
|
return ausgabetext
|
|
|
|
def klopfcode_decode(eingabetext):
|
|
text = eingabetext.rstrip()
|
|
if text == "":
|
|
return hilfetexte.polybios_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"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 = "DEC -> Maptiles \n|Zoom|X|Y|\n|-|-|-|\n"
|
|
for zoom in range(1, 26):
|
|
try:
|
|
la = float(text[0])
|
|
lo = float(text[1])
|
|
if not la < -85.05113 and not la > 85.05113 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 = "Maptiles->DEG,DEC \n|Zoom|DEG|DEC|\n|-|-|-|\n"
|
|
lat_list, lon_list = [], []
|
|
for zoom in range(2, 26):
|
|
try:
|
|
la, lo = helper.maptiles_to_dec(int(text[0]), int(text[1]), zoom)
|
|
if not la < -85.05113 and not la > 85.05113 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)
|
|
except OverflowError:
|
|
pass
|
|
return ausgabetext, pd.DataFrame({'lat': lat_list, 'lon': lon_list})
|
|
else:
|
|
return "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"Maptiles: X:{tile_x} Y:{tile_y} Zoom:{zoom} \n"
|
|
ausgabetext += f"DEC: {round(la, 5)} {round(lo, 5)} \n"
|
|
ausgabetext += f"DEG: {helper.dec_to_deg(la, lo)}"
|
|
return ausgabetext, pd.DataFrame({'lat': [la], 'lon': [lo]})
|
|
else:
|
|
return ("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 = "|Buchstabe|Wert|Anzahl|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"Summe einfach(I,V,X,L,C,D,M): {sum_einfach} \n"
|
|
ausgabetext += f"Summe erweitert(inkl. I,U): {sum_erweitert} \n"
|
|
ausgabetext += f"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 "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 "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"dekodierte URL: `{atxt}`"
|
|
|
|
def reversewig(eingabetext):
|
|
seperator = ("|,", "_", "/", ";", ",")
|
|
eingabetext = eingabetext.rstrip()
|
|
if eingabetext == "":
|
|
return hilfetexte.reversewig
|
|
else:
|
|
se = ""
|
|
for s in seperator:
|
|
if s in eingabetext:
|
|
se = s
|
|
if se == "" and " " in eingabetext:
|
|
se = " "
|
|
if se == "":
|
|
return "Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
|
|
else:
|
|
txt = eingabetext.split(se)
|
|
if len(txt) == 3:
|
|
ausgabetext = ""
|
|
error = 0
|
|
for z in txt:
|
|
try:
|
|
int(z)
|
|
except ValueError:
|
|
ausgabetext += "Bitte die Eingabezahlen überprüfen \n"
|
|
error += 1
|
|
if error == 0:
|
|
final = helper.rwig_to_coords(txt[0], txt[1], txt[2])
|
|
ausgabetext += "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + " \n"
|
|
ausgabetext += "DEC: " + str(final[0]) + " " + str(final[1]) + " \n"
|
|
ausgabetext += "DEG: " + helper.dec_to_deg(final[0], final[1]) + " \n"
|
|
return ausgabetext
|
|
else:
|
|
return "Es wurden nicht 3 Zahlen erkannt. \n"
|
|
|
|
def base64_ascii(eingabetext):
|
|
eingabetext = eingabetext.rstrip()
|
|
if eingabetext == "":
|
|
return hilfetexte.base64_ascii
|
|
else:
|
|
try:
|
|
ascii_string = binascii.a2b_base64(eingabetext).decode()
|
|
return f"Base64 -> ASCII: \n{ascii_string} \n"
|
|
except ValueError:
|
|
base64_string = binascii.b2a_base64(eingabetext.encode())
|
|
return f"Umwandlung Base64 -> ASCII war nicht möglich. \nASCII -> 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 "Bitte eine Zahl im Schlüsselfeld eingeben!!"
|
|
else:
|
|
try:
|
|
if int(pw) < 2:
|
|
raise ValueError("Zahl zu klein")
|
|
return (f"_inkl. Leerzeichen_ \n{helper.rail_encrypt(eingabetext, int(pw))} \n \n"
|
|
f"_ohne Leerzeichen_ \n{helper.rail_encrypt(eingabetext.replace(" ", ""), int(pw))}")
|
|
except ValueError:
|
|
return "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 = ""
|
|
ausgabtext += "_inkl. Leerzeichen_ \n"
|
|
for i in range(12, 1, -1):
|
|
ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext, i)} \n'
|
|
ausgabtext += " \n_ohne Leerzeichen_ \n"
|
|
for i in range(12, 1, -1):
|
|
ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext.replace(" ", ""), i)} \n'
|
|
return ausgabtext
|
|
elif not pw.isdigit():
|
|
return "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 "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"_Passwort 1:_ {pw[0]} \n"
|
|
ausgabetext += f"_Passwort 2:_ {pw2} \n \n"
|
|
ausgabetext += f"_kodiert mit Variante A-Z:_ \n{ausgabe_az} \n \n"
|
|
ausgabetext += f"_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 "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"_Passwort 1:_ {pw[0]} \n"
|
|
ausgabetext += f"_Passwort 2:_ {pw2} \n \n"
|
|
ausgabetext += f"_dekodiert mit Variante A-Z:_ \n{klartext_az} \n \n"
|
|
ausgabetext += f"_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 "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"_Passwort 1:_ {pw[0]} \n"
|
|
ausgabetext += f"_Passwort 2:_ {pw2} \n \n"
|
|
ausgabetext += f"_kodiert mit Variante A-Z,0-9:_ \n{ausgabe_az09} \n \n"
|
|
ausgabetext += f"_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 "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"_Passwort 1:_ {pw[0]} \n"
|
|
ausgabetext += f"_Passwort 2:_ {pw2} \n \n"
|
|
ausgabetext += f"_dekodiert mit Variante A-Z,0-9:_ \n{klartext_az09} \n \n"
|
|
ausgabetext += f"_dekodiert mit Variante 9-0,Z-A:_ \n{klartext_90za}"
|
|
return ausgabetext
|
|
|
|
# noch nicht implementierte Funktionen:
|
|
'''
|
|
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")
|
|
'''
|