# 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 = [] for key in anzahl: s.append(key) s.sort() ausgabetext += f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen gefunden. \n" ausgabetext += "| :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: 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 (":green[Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion " "benutzt.]") else: ausgabetext = (":green[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:] :orange[GENERATE] " ":green[ins Eingabefeld eingeben und die Funktion starten.] \n \n") return ausgabetext + helper.remorse_germandic(eingabetext) except FileNotFoundError: return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]" else: ausgabetext = ":blue[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 ":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" 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 ":green[t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt.]" else: ausgabetext = (":green[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:] :orange[GENERATE] " ":green[ins Eingabefeld eingeben und die Funktion starten.] \n \n") return ausgabetext + helper.t9_germandic(eingabetext) 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" 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 ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]" else: ausgabetext = ":blue[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 ":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 < -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 = ":violet[Maptiles->DEG,DEC] \n|:blue[Zoom]|:blue[DEG]|:blue[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 ":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