# 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") '''