tebarius/Mysteryhelfer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
Mysteryhelfer/Mysteryhelfer.pyw

4920 lines
212 KiB
Python
Raw Permalink Blame History

#!/usr/bin/env python3
# -*- coding: utf8 -*-
#######################################
from tkinter import * # unter linux wahrscheinlich nachzuinstallieren via: sudo apt-get install python3-tk
from tkinter import font
from tkinter import ttk
from tkinter import messagebox
import math
from re import match # für unkennify
from urllib.parse import unquote as urllib_parse_unquote # für nak-nak
from urllib import request
from itertools import chain # für primfaktoren zerlegung
import webbrowser # für website in Infofenster
import binascii # für base64_ascii
#######################################
versionsnummer = "Version: 1.10 (17. März 2024)"
website = "http://mysteryhelfer.tba-tm.bplaced.net"
#######################################
# Standard falls laden der data/config.txt schief geht
schriftart, schriftgroesse, schriftstyle = "Times New Roman", 10, "normal"
# Schrift-entsprechend data/config.txt anpassen
try:
configfile = open("./data/config.txt", "r", encoding="UTF-8")
for line in configfile:
line = line.strip(" \t\n\r")
if line[:1] == "#":
continue
elif line[:4] == "size":
line = line.split("=")
schriftgroesse = int(line[1].strip(" \t\n\r"))
elif line[:4] == "font":
line = line.split("=")
schriftart = line[1].strip(" \t\n\r")
elif line[:5] == "style":
line = line.split("=")
schriftstyle = line[1].strip(" \t\n\r")
configfile.close()
except FileNotFoundError:
pass
schrift = (schriftart, schriftgroesse, schriftstyle)
# allgemeine Funktionen
def trennlinie():
Ausgabe.insert(1.0, "-------------------------------------------------\n")
def check_update():
url = website + "/version.txt"
try:
response = request.urlopen(url)
latest_version = response.read().decode().strip()
if latest_version == versionsnummer: # Vergleiche die abgerufene Version mit der aktuellen Version
message = "Du verwendest die aktuellste Version."
else:
message = f"Ein Update ist verfügbar!\n\nDu verwendest {versionsnummer}\n{latest_version} ist " \
f"auf {website} verfügbar.\n\n (Einen anklickbaren Link zur Webseite findest du,\n wenn" \
f" du auf das Logo klickst.)"
except request.HTTPError:
message = "Es konnte leider keine Verbindung zum Update-Server hergestellt werden."
# Zeige das Ergebnis in einem Dialogfenster an
messagebox.showinfo("Update-Check", message)
# ***recursive quersummenfunktion***
def q_sum(n):
if n < 10:
return n
else:
n = q_sum(n // 10) + n % 10
return n
# ***recursive iterierte quersummenfunktion***
def iq_sum(n):
if n < 10:
return n
else:
n = iq_sum(q_sum(n))
return n
# ***produziert eine Liste mit Primzahlen kleiner als grenze***
# ***nach dem Prinzip des "Sieb des Eratosthenes"***
def primzahlliste(grenze):
primes = []
is_prime = [True] * grenze
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(math.sqrt(grenze))):
if is_prime[i]:
for j in range((i * i), grenze, i):
is_prime[j] = False
for i in range(len(is_prime)):
if is_prime[i]:
primes.append(i)
return primes
# ***alle permutationen generieren***
def all_perms(liste):
if len(liste) <= 1:
yield liste
else:
for perm in all_perms(liste[1:]):
for i in range(len(perm) + 1):
yield perm[:i] + liste[0:1] + perm[i:]
# ***zählfunktionen für anagramm suche
def buchstabenzaehl(buchstabe, anzahl):
if buchstabe in anzahl:
anzahl[buchstabe] = anzahl[buchstabe] + 1
else:
anzahl[buchstabe] = 1
def wortzaehl(wort):
anzahl = {}
for buchstabe in wort:
buchstabenzaehl(buchstabe.upper(), anzahl)
return anzahl
# ***Funktionen für Kachelkoordinaten/Maptiles-Funktion
def dec_to_maptiles(lat_deg, lon_deg, zoom):
lat_rad = math.radians(lat_deg)
n = 2.0 ** zoom
xtile = int((lon_deg + 180.0) / 360.0 * n)
ytile = int((1.0 - math.log(math.tan(lat_rad) + (1 / math.cos(lat_rad))) / math.pi) / 2.0 * n)
return xtile, ytile
def maptiles_to_dec(xtile, ytile, zoom):
n = 2.0 ** zoom
lon_dec = xtile / n * 360.0 - 180.0
lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
lat_dec = math.degrees(lat_rad)
return lat_dec, lon_dec
# ***Dezimalgrad in Dezimalminuten (Ausgabe als String)
def dec_to_deg(lat_dec, lon_dec):
if lat_dec < 0:
lat_pre = "S"
else:
lat_pre = "N"
if lon_dec < 0:
lon_pre = "W"
else:
lon_pre = "E"
lat = abs(lat_dec)
lon = abs(lon_dec)
lat_degree = int(lat)
lon_degree = int(lon)
lat_minutes = (lat - lat_degree) * 60
lon_minutes = (lon - lon_degree) * 60
return ("{}{} {:.3f} {}{} {:.3f}".format(lat_pre, lat_degree, round(lat_minutes, 3), lon_pre, lon_degree,
round(lon_minutes, 3)))
# ***ReverseWherIGo zu Dezimalgrad
def rwig_to_coords(a, b, c):
lat, lon = 0, 0
a = int(a)
b = int(b)
c = int(c)
if (a % 1000 - a % 100) / 100 == 1:
lat_sign = 1
lon_sign = 1
elif (a % 1000 - a % 100) / 100 == 2:
lat_sign = -1
lon_sign = 1
elif (a % 1000 - a % 100) / 100 == 3:
lat_sign = 1
lon_sign = -1
elif (a % 1000 - a % 100) / 100 == 4:
lat_sign = -1
lon_sign = -1
else:
return 0, 0
if ((c % 100000 - c % 10000) / 10000 + (c % 100 - c % 10) / 10) % 2 == 0:
lat = lat_sign * (
(a % 10000 - a % 1000) / 100
+ (b % 100 - b % 10) / 10
+ (b % 100000 - b % 10000) / 100000
+ (c % 1000 - c % 100) / 10000
+ (a % 1000000 - a % 100000) / 100000000
+ (c % 100 - c % 10) / 100000
+ a % 10 * 1.0E-5)
elif ((c % 100000 - c % 10000) / 10000 + (c % 100 - c % 10) / 10) % 2 != 0:
lat = lat_sign * (
(b % 1000000 - b % 100000) / 10000
+ a % 10 + (a % 10000 - a % 1000) / 10000
+ (c % 1000000 - c % 100000) / 10000000
+ (c % 1000 - c % 100) / 100000
+ (c % 100 - c % 10) / 100000
+ (a % 1000000 - a % 100000) / 10000000000)
if ((c % 100000 - c % 10000) / 10000 + (c % 100 - c % 10) / 10) % 2 == 0:
lon = lon_sign * (
(a % 100000 - a % 10000) / 100
+ (c % 1000000 - c % 100000) / 10000
+ c % 10 + (b % 1000 - b % 100) / 1000
+ (b % 1000000 - b % 100000) / 10000000
+ (a % 100 - a % 10) / 10000
+ (c % 100000 - c % 10000) / 100000000
+ b % 10 * 1.0E-5)
elif ((c % 100000 - c % 10000) / 10000 + (c % 100 - c % 10) / 10) % 2 != 0:
lon = lon_sign * (
(b % 100 - b % 10) * 10
+ c % 10 * 10
+ (a % 100 - a % 10) / 10
+ (a % 100000 - a % 10000) / 100000
+ (b % 1000 - b % 100) / 10000
+ b % 10 * 0.001
+ (c % 100000 - c % 10000) / 100000000
+ (b % 100000 - b % 10000) / 1000000000)
return round(lat, 5), round(lon, 5)
LOGOIMG = """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"""
# ***************************Buttonactions***************************
def ausgabe_leeren():
Ausgabe.delete(1.0, END)
def eingabe_leeren():
Eingabe.delete(1.0, END)
def eingabe_einfuegen():
Eingabe.delete(1.0, END)
Eingabe.event_generate("<<Paste>>")
def auswahl_kopieren():
Ausgabe.event_generate("<<Copy>>")
def cesar_all():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Cesar-Verschiebe-Chiffre]
Von der eingegebenen Zeichenkette werden,
alle möglichen Verschiebungen gemäß der
Cesarchiffre generiert und ausgegeben.
Sonderzeichen und Zahlen werden unverändert
wiedergegeben.""" + "\n\n")
else:
abcgross = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
abcklein = "abcdefghijklmnopqrstuvwxyz"
txt = eingabetext
for r in range(25, 0, -1):
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.insert(1.0, " " + atxt + "\n")
Ausgabe.insert(1.0, "{:0>2}({:0>2}):".format(r, 26 - r), "bu")
# {:0>2} bedeutet: 0 = Füllzeichen, > = rechtsbündig, 2 = Ausgabebreite
def buchstabenwortwert():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Buchstabenwortwerte ermitteln]
Diese Funktion berechnet den Buchstabenwert
der eingegeben Zeichenkette. (A=1 B=2 ....
Ä=27 Ö=28 Ü=29 ß=30) Bei mehreren durch
Leerzeichen getrennten Wörtern wird auch
für jedes einzelne Wort der Wortwert errechnet.
Desweiteren wird die Quersumme und die iterierte
Quersumme des Gesamtbuchstabenwertes als auch für
jedes Wort das Buchstabenwertprodukt und das
Gesamtbuchstabenwertprodukt ermittelt.""" + "\n\n")
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,
'Ä': 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.insert(1.0, str(wortprodukt) + "\n")
Ausgabe.insert(1.0, "Buchstabenwert-Produkt:(Nullen werden ignoriert):\n", "bu")
Ausgabe.insert(1.0, ewortptxt[0:-1] + "\n")
Ausgabe.insert(1.0, "Wortprodukte(0 wenn kein Buchstabe gefunden):\n", "bu")
Ausgabe.insert(1.0, str(banzahla) + "\n")
Ausgabe.insert(1.0, "Gesamtanzahl aller Buchstaben:", "bu")
Ausgabe.insert(1.0, banzwtxt[0:-1] + "\n")
Ausgabe.insert(1.0, "Buchstabenanzahl pro Wort:", "bu")
Ausgabe.insert(1.0, str(q_sum(wortsumme)) + " / " + str(iq_sum(wortsumme)) + "\n")
Ausgabe.insert(1.0, "Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:", "bu")
Ausgabe.insert(1.0, str(wortsumme) + "\n")
Ausgabe.insert(1.0, "Summe aller Buchstabenwerte:", "bu")
Ausgabe.insert(1.0, eworttxt[0:-1] + "\n")
Ausgabe.insert(1.0, "Buchstabenwortwerte:", "bu")
Ausgabe.insert(1.0, az[0:-1] + "\n")
Ausgabe.insert(1.0, "Buchstabenwerte:", "bu")
Ausgabe.insert(1.0, atxt + "\n")
def buchstabenwertzutext():
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: 'ß'}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Buchstabenwerte zu Text]
Die eingegebenen Buchstabenwert werden in die
entsprechenden Buchstaben umgewandelt.
(A=1 B=2 .... Ä=27 Ö=28 Ü=29 ß=30)
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
if ausz not in bw:
Ausgabe.insert(1.0, "Die eingegebene Zahl ist kein gültiger Buchstabenwert!\n", "re")
else:
Ausgabe.insert(1.0, bw[ausz] + "\n")
else:
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) + " "
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung folgendes wurde ignoriert:\n", "re")
def zeichenkette_rueckwaerts():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Zeichenkette rückwärts]
Diese Funktion gibt die eingegebene Zeichenkette
von hinten nach vorn gelesen aus.\n""")
else:
Ausgabe.insert(1.0, eingabetext[::-1] + "\n")
def zeichenzaehlen():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Zeichenzählen]
Es wird das Vorkommen jedes einzelnen Zeichens gezählt
und ausgegeben.
Achtung! Leerzeichen, Tabulatorzeichen und Zeilenumbrüche
werden nur vor dem letzten sichtbaren Zeichen gezählt!!!""" + "\n\n")
else:
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(reverse=True)
for i in s:
if ord(i) == 9:
Ausgabe.insert(1.0, "[TAB] = {} mal\n".format(anzahl[i]))
elif ord(i) == 32:
Ausgabe.insert(1.0, "[SPACE] = {} mal\n".format(anzahl[i]))
elif ord(i) == 10:
Ausgabe.insert(1.0, "[LINEFEED] = {} mal\n".format(anzahl[i]))
else:
Ausgabe.insert(1.0, "{} = {} mal\n".format(i, anzahl[i]))
Ausgabe.insert(1.0, "Es wurden {} unterschiedliche Zeichen gefunden.\n".format(len(anzahl)))
def quersummen():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Quersumme(n)]
Von den eingegebenen Zahlen werden die
Quersummen und iterierten Quersummen errechnet
und ausgegeben.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, "Quersumme: {} iterierte Quersumme: {}\n".format(q_sum(ausz), iq_sum(ausz)))
else:
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(q_sum(az)) + "/"
iqtxt = iqtxt + str(iq_sum(az)) + "/"
Ausgabe.insert(1.0, iqtxt[:-1] + "\n")
Ausgabe.insert(1.0, "iterierte Quersummen\n", "bu")
Ausgabe.insert(1.0, qtxt[:-1] + "\n")
Ausgabe.insert(1.0, "Quersummen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def einschluessemit4():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Einschlüsse zählen]
Es werden die Einschlüsse in Buchstaben und
Ziffern gezählt. Neben der Anzahl der Einschlüss
für jeden einzelnen Buchstaben, für jedes Wort und
die gesammte Eingabe ermittelt.
Da es sich bei der Zahl 4 je nach Schreibweise um
eine Zahl mit oder ohne Einschluß handeln kann gibt
es zwei Versionen.
!!! Hier ist Klein- und Großschreibung wichtig, denn
z.B. b=1 aber B=2 !!!""" + "\n\n")
else:
bw1 = "ADOPQRabdegopq4690"
wortsummenliste = []
wortliste = eingabetext.split()
az = ""
for wort in wortliste:
wz = 0
for b in wort:
if b == "B" or b == "8":
az = az + "2"
wz = wz + 2
elif b in bw1:
az = az + "1"
wz = wz + 1
else:
az = az + "0"
az = az + " "
wortsummenliste.append(wz)
Ausgabe.insert(1.0, str(sum(wortsummenliste)) + "\n")
Ausgabe.insert(1.0, "insgesamt gefundene Einschlüsse:", "bu")
wtxt = ""
for z in wortsummenliste:
wtxt = wtxt + str(z) + " "
Ausgabe.insert(1.0, wtxt + "\n")
Ausgabe.insert(1.0, "Einschlüsse pro Wort:", "bu")
Ausgabe.insert(1.0, az + "\n")
Ausgabe.insert(1.0, "Einschlüsse je Zeichen:\n", "bu")
def einschluesseohne4():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Einschlüsse zählen]
Es werden die Einschlüsse in Buchstaben und
Ziffern gezählt. Neben der Anzahl der Einschlüss
für jeden einzelnen Buchstaben, für jedes Wort und
die gesammte Eingabe ermittelt.
Da es sich bei der Zahl 4 je nach Schreibweise um
eine Zahl mit oder ohne Einschluß handeln kann gibt
es zwei Versionen.
!!! Hier ist Klein- und Großschreibung wichtig, denn
z.B. b=1 aber B=2 !!!""" + "\n\n")
else:
bw1 = "ADOPQRabdegopq690"
wortsummenliste = []
wortliste = eingabetext.split()
az = ""
for wort in wortliste:
wz = 0
for b in wort:
if b == "B" or b == "8":
az = az + "2"
wz = wz + 2
elif b in bw1:
az = az + "1"
wz = wz + 1
else:
az = az + "0"
az = az + " "
wortsummenliste.append(wz)
Ausgabe.insert(1.0, str(sum(wortsummenliste)) + "\n")
Ausgabe.insert(1.0, "insgesamt gefundene Einschlüsse:", "bu")
wtxt = ""
for z in wortsummenliste:
wtxt = wtxt + str(z) + " "
Ausgabe.insert(1.0, wtxt + "\n")
Ausgabe.insert(1.0, "Einschlüsse pro Wort:", "bu")
Ausgabe.insert(1.0, az + "\n")
Ausgabe.insert(1.0, "Einschlüsse je Zeichen:\n", "bu")
def morsetoabc():
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", "--.--": "Ñ",
"..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
"-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
".----.": "'", "...--..": "ß"
}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Morsecode zu Text]
Die Eingabe des Morsecodes hat wie folgt zu erfolgen:
- für lang und . für kurz, zwischen den Buchstaben ein
Leerzeichen und als Worttrennung ein / wobei davor und
danach ein Leerzeichen steht.
Für unbekannte Morsecodes erscheint in der Ausgabe ein #.""" + "\n\n")
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]
Ausgabe.insert(1.0, atxt + "\n")
def abctomorse():
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
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Morsecode]
Eingabetext wird als Morsecode ausgegeben.
Nicht kodierbare Zeichen erscheinen unverändert
in der Ausgabe.""" + "\n\n")
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()] + " "
Ausgabe.insert(1.0, atxt + "\n")
def rot5():
ro5 = {"0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [ROT 5]
ROT 5 bezeichnet eine Verschiebechiffrierung, bei
welcher die Ziffern 0-9 um je 5 Stellen verschoben
werden. Aus 0 wird 5, aus 1 wird 6, aus 7 wird 2,usw.
Kodieren und Dekodieren geschieht hier mit ein und
derselben Funktion, alle Zeichen die keine Ziffern
sind werden unverändert wiedergegeben.""" + "\n\n")
else:
atxt = ""
for z in eingabetext:
if z not in ro5:
atxt = atxt + z
else:
atxt = atxt + ro5[z]
Ausgabe.insert(1.0, atxt + "\n")
def rot13():
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'}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [ROT 13]
ROT 13 bezeichnet eine Verschiebechiffrierung, bei
welcher die 26 Buchstaben (A-Z) um genau 13 Stellen
verschoben werden. Da dies genau die Hälfte des Alphabets
ist, wird z.B. aus einem A ein N und aus einem N ein A
und somit wird über die selbe Funktion sowohl kodiert als
auch dekodiert. Die Klein- und Großschreibung bleibt
erhalten und alle Zeichen die keine Buchstaben sind
werden unverändert wiedergegeben.""" + "\n\n")
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()]
Ausgabe.insert(1.0, atxt + "\n")
def rot18():
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"}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [ROT 18]
ROT 18 ist eigentlich nix anderes als, daß hier ROT 5
mit ROT 13 kombiniert wird. Die Buchstaben A-Z werden
um 13 Stellen verschoben und die Ziffern 0-9 um 5 Stellen.
Alle sonstigen Zeichen bleiben unverändert und die Kleine-
oder Großschreibung bleibt auch erhalten, und auch hier
kodiert/dekodiert ein und dieselbe Funktion.""" + "\n\n")
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()]
Ausgabe.insert(1.0, atxt + "\n")
def rot47():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [ROT 47]
Bei ROT47 geschieht eigentlich nix anderes als
bei ROT5 oder ROT13 nur das hier die druckbaren
ASCII-Zeichen mit den Werten 33-126(dezimal) zur
Auswahl stehen, also nahezu alle Zeichen die auf
eine Standardtastatur aufgedruckt sind.
Das Ergebnis ist aber deutlich unlesbarer als
z.B. bei ROT13. Alle weiteren Zeichen (z.B. ÄÖÜß)
werden unverändert wiedergegeben und auch hier
kodiert/dekodiert ein und dieselbe Funktion.""" + "\n\n")
else:
x = []
for i in eingabetext:
j = ord(i)
if 33 <= j <= 126:
x.append(chr(33 + ((j + 14) % 94)))
else:
x.append(i)
Ausgabe.insert(1.0, ''.join(x) + "\n")
def asciitodez():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Dezimalzahlen]
Der eingegebene Text wird in Dezimalzahlen umgewandelt. """ + "\n\n")
else:
z = []
for i in eingabetext:
z.append(str(ord(i)))
Ausgabe.insert(1.0, ' '.join(z) + "\n")
def deztoascii():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Dezimalzahlen zu Text]
Die eingegebenen Dezimalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, chr(ausz) + "\n")
else:
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)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def asciitohex():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Hexadezimalzahlen]
Der eingegebene Text wird in Hexadezimalzahlen umgewandelt. """ + "\n\n")
else:
z = []
for i in eingabetext:
hexstr = ("{:X}".format(ord(i))) # großes X für Hex in Großbuchstaben
z.append(hexstr)
Ausgabe.insert(1.0, ' '.join(z) + "\n")
def hextoascii():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Hexadezimalzahlen zu Text]
Die eingegebenen Hexadezimalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, chr(ausz) + "\n")
else:
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)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def asciitooctal():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Octalzahlen]
Der eingegebene Text wird in Octalzahlen umgewandelt. """ + "\n\n")
else:
z = []
for i in eingabetext:
z.append("{:o}".format(ord(i)))
Ausgabe.insert(1.0, ' '.join(z) + "\n")
def octaltoascii():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Octalzahlen zu Text]
Die eingegebenen Octalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, chr(ausz) + "\n")
else:
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)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def asciitobin16():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Binärzahlen]
Der eingegebene Text wird in Binärzahlen mit
einer festgelegten Breite von 16bit (16 Zeichen)
umgewandelt. """ + "\n\n")
else:
z = []
for i in eingabetext:
z.append("{:0>16b}".format(ord(i)))
Ausgabe.insert(1.0, ' '.join(z) + "\n")
def asciitobin8():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Binärzahlen]
Der eingegebene Text wird in Binärzahlen mit
einer festgelegten Breite von 8bit (8 Zeichen)
umgewandelt. """ + "\n\n")
else:
z = []
for i in eingabetext:
if ord(i) > 255:
Ausgabe.insert(1.0,
"Sorry der Eingabetext enthält Zeichen,\nwelche sich nicht"
" mit 8 bit in binär darstellen lassen!\n")
return
z.append("{:0>8b}".format(ord(i)))
Ausgabe.insert(1.0, ' '.join(z) + "\n")
def bintoascii():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Binärzahlen zu Text]
Die eingegebenen Binärzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, chr(ausz) + "\n")
else:
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)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def zahlwortsuche_de():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche DE 0-12]
Diese Funktion versucht deutsche Zahlworte
zwischen 0 und 12 in einem Text aufzuspüren.
Da alle Zeichen ignoriert werden, welche
keine Buchstaben sind, werden auch Zahlwörter
gefunden welche sich z.B. über zwei Worte
verteilen.""" + "\n\n")
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 == "":
Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
else:
Ausgabe.insert(1.0, ntxt + "\n")
Ausgabe.insert(1.0, "Eingangstext:", "bu")
Ausgabe.insert(1.0, atxt + "\n\n")
Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")
def zahlwortsuche_en():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche EN 0-15]
Diese Funktion versucht englische Zahlworte
zwischen 0 und 15 in einem Text aufzuspüren.
Da alle Zeichen ignoriert werden, welche
keine Buchstaben sind, werden auch Zahlwörter
gefunden welche sich z.B. über zwei Worte
verteilen.""" + "\n\n")
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 == "":
Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
else:
Ausgabe.insert(1.0, ntxt + "\n")
Ausgabe.insert(1.0, "Eingangstext:", "bu")
Ausgabe.insert(1.0, atxt + "\n\n")
Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")
def kenny_kodieren():
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"
}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Kennyspeak codieren]
Hilfe sie haben Kenny getötet.. ach nee er kann
ja noch seine unverständlichen m p f -Laute von
sich geben und hier geht es darum normalen
Text in genau diese Laute umzusetzen, wo jedem
Buchstaben A-Z eine 3 Zeichen-Kombination
zugeordnet ist die sich aus m,p,f
zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n")
else:
atxt = ""
for b in eingabetext:
if b in alphabet:
atxt = atxt + alphabet[b]
else:
atxt = atxt + b
Ausgabe.insert(1.0, atxt + "\n")
def unkennify(text):
# Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py
decoded = ''
codemap = str.maketrans('MmPpFf', '001122')
n_len = len(text)
i = 0
while i + 3 <= n_len:
if match('[MmPpFf]{3,}', text[i:i + 3]):
num = int(text[i:i + 3].translate(codemap), 3) # 'mpf' -> '012' -> 5
cypher = chr(num + ord('a')) # 5 -> 'f'
if text[i].isupper():
cypher = cypher.upper()
decoded = decoded + cypher
i = i + 3
else:
decoded = decoded + text[i]
i = i + 1
if i < n_len:
decoded = decoded + text[i:]
return decoded
def kenny_dekodieren():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Kennyspeak decodieren]
Wie? Du verstehst Kenny's mpf-Gebrabbel nicht?
Na gut da kann ich helfen!!
Nicht kennifiziertes wird unverändert ausgegeben.""" + "\n\n")
else:
Ausgabe.insert(1.0, unkennify(eingabetext) + "\n")
def kenny_raten():
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"
}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [KENNYspeak raten]
Diese Funktion dient zum dekodieren von kennyfizierten
Texten, bei denen die 3 Buchstaben mpf vertauscht oder durch
andere Zeichen ersetzt wurden. Hierzu werden vor der
Dekodierung die 3 häufigsten Zeichen im Text ermittelt und
alle anderen Zeichen entfernt bevor die 6 möglichen Lösungen
ausgegeben werden.
(Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden,
werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n")
else:
wtxt = ""
for b in eingabetext:
if b == chr(9) or b == chr(32) or b == chr(10):
continue # erstmal leerzeichen, tab, linefeed raus
wtxt = wtxt + b.lower()
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
for p in 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]
Ausgabe.insert(1.0, "{}\n".format(atxt))
Ausgabe.insert(1.0, "{}\n".format(p), "bu")
def primzahlalphabet_dekodieren():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Primzahlalphabet dekodieren]
Hier können Primzahlen kleiner als 1 Million
in Buchstaben umgewandelt werden. Es wird dabei
davon ausgegangen, daß den Primzahlen
wiederholend die Buchstaben A-Z zugeordnet
werden,2=A 3=B 5=C 7=D 11=E.......
....97=Y 101=Z 103=A 107=B ... usw.""" + "\n\n")
else:
grenze = 1000000
primes = 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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
"re")
else:
if ausz in pdict:
Ausgabe.insert(1.0, pdict[ausz] + "\n")
else:
Ausgabe.insert(1.0, eingabetext + " ist keine Primzahl oder größer als 1 Million!\n")
else:
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) + " "
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "umgewandelte Zahlen:\n", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "ignoriert wurde:\n", "re")
def primzahlpruefen():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Primzahl prüfen]
Für eine eingegebene Zahl wird überprüft,
ob es sich um eine Primzahl handelt.
Ist die eingegebene Zahl eine Primzahl
wird auch informiert, die wievielte
Primzahl es ist.
Zahlen über 1299709 (der 100000. Primzahl)
werden abgelehnt.""" + "\n\n")
else:
try:
ausz = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
else:
if ausz > 1299709:
Ausgabe.insert(1.0,
"Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen"
" bis maximal 1299709 !\n", "re")
return
primes = primzahlliste(1299710)
if ausz not in primes:
Ausgabe.insert(1.0, "{} ist keine Primzahl\n".format(ausz))
else:
Ausgabe.insert(1.0, "{} ist die {}. Primzahl\n".format(ausz, primes.index(ausz) + 1))
def nte_primzahl():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [n.te Primzahl]
Du willst wissen wie z.B. die 1000. Primzahl lautet,
dann bist du hier genau richtig.
Die Funktion liefert maximal die 100000. Primzahl.
""" + "\n\n")
else:
try:
ausz = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
else:
if ausz > 100000:
Ausgabe.insert(1.0,
"Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen bis"
" maximal 1299709 !\n", "re")
return
primes = primzahlliste(1299710)
Ausgabe.insert(1.0, "Die {}. Primzahl lautet:{}\n".format(ausz, primes[ausz - 1]))
def primfaktoren():
hilfetext = """HILFE: [Primfaktorenzerlegung]
Für die eingegebene Zahl werden die Primfaktoren ermittelt
und ausgegeben. Sollte die Zahl einen Primfaktoren haben, welcher
größer als 100 Millionen ist, wird die Suche abgebrochen, da die
Suche sonst zu lange dauert.
Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200
Millionen, dazu benutzen um festzustellen, ob die eingegebene Zahl eine
Primzahl ist.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
n = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Es konnte leider keine Zahl erkannt werden.\n", "re")
return
faktoren = []
for i in chain([2], range(3, n // 2 + 1, 2)):
if i > 100000000:
Ausgabe.insert(1.0,
"Sorry, aber die Primfaktorensuche wurde abgebrochen,\nda mindestens 1 Faktor"
" größer als 100 Millionen ist.\n", "re")
return
while n % i == 0:
faktoren.append(i)
n = n // i
if i > n:
break
out = "Die Zahl {} hat folgende Primfaktoren:\n".format(eingabetext)
if not faktoren:
Ausgabe.insert(1.0, "Die Zahl {} ist eine Primzahl!!\n".format(eingabetext))
else:
for z in faktoren:
out += str(z) + ", "
return Ausgabe.insert(1.0, out[:-2] + "\n")
def deztohexoctbin():
seperator = ("|,", "_", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Dezimal zu HEX, Octal, Binär]
Die eingegebenen dezimalen Ganzzahlen werden in die
entsprechenden hexadezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, "Dez: {0:} HEX:{0:X} OCT:{0:o} BIN:{0:b}\n".format(ausz))
else:
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) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
def hextodezoctbin():
seperator = ("|,", "_", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Hexadezimal zu Dezimal, Octal, Binär]
Die eingegebenen hexadezimalen Zahlen werden in die
entsprechenden dezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, "HEX:{0:X} Dez: {0:} OCT:{0:o} BIN:{0:b}\n".format(ausz))
else:
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) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
def octtohexdezbin():
seperator = ("|,", "_", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Octal zu HEX, Dezimal, Binär]
Die eingegebenen octalen Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, "OCT:{0:o} HEX:{0:X} Dez: {0:} BIN:{0:b}\n".format(ausz))
else:
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) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
def bintohexdezoct():
seperator = ("|,", "_", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Binär zu HEX, Dezimal, Octal]
Die eingegebenen binären Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und octalen
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
else:
Ausgabe.insert(1.0, "BIN:{0:b} HEX:{0:X} Dez: {0:} OCT:{0:o}\n".format(ausz))
else:
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) + "/"
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
def abctotomtom():
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 als versucht Escapecodes draus zu machen \\ = \
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Tomtom]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die
Buchstaben A-Z.""" + "\n\n")
else:
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()]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "kodierter Text:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")
def tomtomtoabc():
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 \\ = \
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Tomtom zu Text]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die
Buchstaben A-Z.""" + "\n\n")
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]
Ausgabe.insert(1.0, atxt + "\n")
def texttoslashpipe():
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 \\ = \
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Slash and Pipe]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird.
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
else:
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()]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "kodierter Text:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")
def slashpipetotext():
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 \\ = \
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Slash and Pipe zu Text]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird.
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
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]
Ausgabe.insert(1.0, atxt + "\n")
def periodensystem():
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()}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Periodensystem: Ordnungszahl<->Symbol]
Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der
Elemente werden in die ihnen zugehörigen Elementsymbole umgewandelt
und anschließend als Text ausgegeben, außerdem erscheint noch eine
Ausgabe bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben
werden.
Werden in der Eingabe Symbole (z.B. N, He) erkannt werde diese
zusammen mit ihren Ordnungszahlen ausgegeben.
Als Trennungszeichen zwischen den Zahlen und/oder Symbolen sind
folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen.
Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen
zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden
sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
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:
Ausgabe.insert(1.0, str(um_pse[eingabetext]) + "\n")
else:
Ausgabe.insert(1.0, "Keine gültige Eingabe erkannt!\n", "re")
else:
Ausgabe.insert(1.0, pse[ausz] + "\n")
else:
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 atxt3 != "":
Ausgabe.insert(1.0, " " + atxt3 + "\n")
Ausgabe.insert(1.0, "Symbol:Ordnungszahl:", "bu")
if atxt2 != "":
Ausgabe.insert(1.0, " " + atxt2 + "\n")
Ausgabe.insert(1.0, "Nur Anfangsbuchstaben:", "bu")
if atxt != "":
Ausgabe.insert(1.0, " " + atxt + "\n")
Ausgabe.insert(1.0, "Symbole:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")
def brainfuck_interpreter():
trennlinie()
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():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Ook ist eine Abwandlung von Brainfuck wobei die
8 Zeichen von Brainfuck hier durch eine Kombination
von je zwei der folgenden 3 Satzzeichen .!? ersetzt
werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
geschrieben. z.B.: Ook! Ook? Ook. Ook!
Da Ook auch durch andere Wörter ersetzt oder auch
ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
Funktion alle anderen Zeichen außer .!? bevor versucht wird
den Code auszuführen.""" + "\n\n")
else:
ookzeichen = [".", "!", "?"]
ooktext = ""
for z in eingabetext: # erstmal Short-Ook draus machen
if z in ookzeichen:
ooktext = ooktext + z
ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
bftext = ""
for o in range(0, len(ooktext), 2): # jetzt in Brainfuck umwandeln
ooz = ooktext[o:o + 2]
if ooz in ookbf:
bftext = bftext + ookbf[ooz]
c = [0] * 300000
p = 0
loop = []
rv = []
ts = list(bftext)
li = len(ts)
i = 0
while i < li:
t = ts[i]
if t == ">":
p += 1
elif t == "<":
p -= 1
elif t == "+":
c[p] += 1
elif t == "-":
c[p] -= 1
elif t == ".":
rv.append(chr(c[p]))
elif t == ",":
pass
elif t == "[":
if c[p] == 0:
while ts[i] != "]":
i += 1
loop.pop()
else:
loop.append(i - 1)
elif t == "]":
i = loop[-1]
i += 1
Ausgabe.insert(1.0, "".join(rv) + "\n")
def naknaktotext():
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"}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [NakNak to Text]
Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache,
welche vom Owner der Website schnatterente.net entwickelt
wurde.
Diese Funktion übersetzt das Geschnatter in verständliche
Buchstaben/Zeichen.
!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!!
Wer diesen Quatsch unbedingt umgekehrt übersetzten will,
findet auf hier den passenden Übersetzer:
http://uebersetzer.schnatterente.net""" + "\n\n")
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)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "dekodiertes Geschnatter:", "bu")
def navajototext():
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": " "}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Navajo-ABC to Text]
Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für
den verschlüßelten Funkverkehr eingesetzt. Vorteile waren, daß
nahezu niemand außer Navajo-Volk die Sprache verstand und es keine
schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet
und die Codewörter wurden dabei von den Codesprechern (natürlich
Navajo's) auswendig gelernt.
Die Dekodierfunktion hier übersetzt das Codealphabet (A-Z), bei welchem es
auch so ist, daß unterschiedliche Worte für den selben Buchstaben stehen,
in normalen Text. Leider existieren leicht unterschiedliche Alphabete was
die Wörter bzw. deren Schreibweise angeht im Netz, mit welchen codiert wird,
weshalb ich hier nur die Dekodierung anbiete.
weitere Codewörter und Erklärungen gibt es z.B. hier:
https://ww2db.com/other.php?other_id=29
http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" + "\n\n")
else:
txt = eingabetext.split()
atxt = ""
for wort in txt:
w = wort.upper()
if w in nabc:
atxt = atxt + nabc[w]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "dekodierter Text:", "bu")
def pi_suche():
hilfetext = """HILFE: [PI Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von PI (3.141592653589793238462643...) zu ermitteln.
Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen
wird die Datei pi.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl PI mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit
dem Tool y-cruncher (http://numberworld.org/y-cruncher/)
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und pi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
piread = open("./data/pi.txt", "r")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
pistr = ""
for zeile in piread:
pistr = pistr + zeile.rstrip()
piread.close()
pilen = len(pistr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
else:
pos = pistr.find(eingabetext)
if pos == -1:
Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(pilen), "re")
else:
Ausgabe.insert(1.0,
"20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, pistr[pos:pos + 20]))
Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
eingabetext.rstrip(), pos - 1))
if pilen >= zahlx > 0:
Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle: "
"{}...\n\n".format(zahlx, pistr[zahlx + 1:zahlx + 21]))
Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, pistr[zahlx + 1]))
else:
Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n\n".format(pilen),
"re")
Ausgabe.insert(1.0, "PI (Kreiszahl)\n\n", "gr")
def anagramm_suche_de():
hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict um
zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörtebuch vorkommen.
Die Datei german.dic muß sich dafür im Unterverzeichnis "data"
befinden.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/german.dic", "r",
encoding="iso-8859-1") # german.dic von https://sourceforge.net/projects/germandict/
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
eingabezaehl = wortzaehl(eingabetext)
Ausgabe.insert(1.0, "\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 == wortzaehl(zeile):
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")
def wortsuche_de():
hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i** -> Geocaching
ge*ca**i** -> Geocaching
T*****dose -> Tupperdose, Tabaksdose
Da diese Funktion die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict benutzt
muß sich natürlich die Datei german.dic im Unterverzeichnis "data"
befinden.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/german.dic", "r", encoding="iso-8859-1")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")
def wortsuche_en():
hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i** -> geocaching
ge*ca**i** -> geocaching
say*s -> say's (Die Wortliste kennt viele Wörter mit Apostroph)
coordinat** -> coordinator, coordinates, coordinated
Da diese Funktion die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist benutzt,
muß sich natürlich die Datei en_US-large.txt im Unterverzeichnis "data"
befinden.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")
def anagramm_suche_en():
hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch EN]
Diese Funktion benutzt die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
um zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörterbuch vorkommen.
Die Datei en_US-large.txt muß sich dafür im Unterverzeichnis
"data" befinden. Dieses Wörterbuch kennt übrigens auch viele
Wörter mit Apostroph wie z.B. "say's".
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
eingabezaehl = wortzaehl(eingabetext)
Ausgabe.insert(1.0, "\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 == wortzaehl(zeile):
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")
def remorse_de():
hilfetext = """HILFE: [RE-Morse DE]
Es gibt ja so Leute, die finden es lustig einen Morsecode
so aufzuschreiben, daß zwar Wort für Wort getrennt wird,
aber ansonsten einfach mal die Leerzeichen weggelassen werden.
Bei genau solchen fiesen Gemeinheiten hilft diese Funktion.
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 100 MB großes remorse-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 20% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des remorse-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/morse-de.dic", "r",
encoding="iso-8859-1") # german.dic von https://sourceforge.net/projects/germandict/
except FileNotFoundError:
try:
testfile = open("./data/german.dic", "r")
testfile.close()
if eingabetext == "GENERATE":
remorse_generate_morsede()
Ausgabe.insert(1.0,
"/data/remorse-de wurde erzeugt und \nwird ab dem nächsten Aufruf "
"der Funktion benutzt.\n", "gr")
else:
Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
Ausgabe.insert(1.0,
"Um das ca. 100 MB große morse-de.dic einmalig aus\ndem german.dic zu "
"erzeugen bitte das Wort: GENERATE\n", "gr")
Ausgabe.insert(1.0, "das dauert zwar ca. 5x so lange, aber geht auch.\n", "gr")
Ausgabe.insert(1.0,
"Da das Morsewörter /data/morse-de.dic nicht vorhanden ist,\n"
"wurde /data/german.dic für die Suche benutzt\n", "gr")
remorse_germandic()
return
except FileNotFoundError:
Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/morse-de.dic gefunden werden!\n", "re")
else:
Ausgabe.insert(1.0, "\n")
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
Ausgabe.insert(1.0, mline[1] + "\n")
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
def remorse_germandic():
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 = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-1")
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
if eingabetext in ualphabet:
Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
def remorse_generate_morsede():
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': '...--..'}
with open("./data/morse-de.dic", "w", encoding="iso-8859-1") as ofile:
for symbol, morse in alphabet.items():
ofile.write(f"{morse},{symbol}\n")
with open("./data/german.dic", "r", encoding="iso-8859-1") as infile:
for line in infile:
word = line.strip()
try:
morse_word = ''.join(alphabet[char.upper()] for char in word)
ofile.write(f"{morse_word},{word}\n")
except KeyError:
# Überspringe Wörter mit nicht-unterstützten Zeichen
continue
infile.close()
ofile.close()
def remorse_en():
hilfetext = """HILFE: [RE-Morse EN]
Es gibt ja so Leute, die finden es lustig einen
Morsecode so aufzuschreiben, daß zwar Wort für
Wort getrennt wird, aber ansonsten einfach mal
die Leerzeichen weggelassen werden. Bei genau
solchen fiesen Gemeinheiten hilft diese Funktion.
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
wird überprüft, für welches Wort der eingegebene Morsecode
stehen könnte. Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
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["...--.."] = "ß"
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
if eingabetext in ualphabet:
Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")
def t9_de():
hilfetext = """HILFE: [T9-DE]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.
Bsp. 56673462836 liefert das Wort Koordinaten
Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 60 MB großes t9-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 15% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des t9-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-1")
except FileNotFoundError:
try:
testfile = open("./data/german.dic", "r")
testfile.close()
if eingabetext == "GENERATE":
t9_generate_t9de()
Ausgabe.insert(1.0,
"/data/t9-de.dic wurde erzeugt und \n"
"wird ab dem nächsten Aufruf der Funktion benutzt.\n", "gr")
else:
Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
Ausgabe.insert(1.0,
"Um das ca. 60 MB große t9-de.dic einmalig aus\n"
"dem german.dic zu erzeugen bitte das Wort: GENERATE\n", "gr")
Ausgabe.insert(1.0, "das dauert zwar ca. 7x so lange, aber geht auch.\n", "gr")
Ausgabe.insert(1.0,
"Da das T9-Wörterbuch /data/t9-de.dic nicht vorhanden ist,\n"
"wurde /data/german.dic für die Suche benutzt\n", "gr")
t9_germandic()
return
except FileNotFoundError:
Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/t9-de.dic gefunden werden!\n", "re")
else:
Ausgabe.insert(1.0, "\n")
for zeile in wbfile:
zeile = zeile.strip(" \t\n\r")
mline = zeile.split(",")
if eingabetext == mline[0]:
Ausgabe.insert(1.0, mline[1] + "\n")
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
def t9_germandic():
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 = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
wbfile = open("./data/german.dic", "r", encoding="iso-8859-1")
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
def t9_generate_t9de():
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'}
ofile = open("./data/t9-de.dic", "a", encoding="iso-8859-1")
file = open("./data/german.dic", "r", encoding="iso-8859-1")
for zeile in file:
omsg = ""
zeile = zeile.rstrip()
try:
for char in zeile:
omsg = omsg + alphabet[char.upper()]
except KeyError:
continue
else:
ofile.write(omsg + "," + zeile + "\n")
file.close()
ofile.close()
def t9_en():
hilfetext = """HILFE: [T9 EN]
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.
Bsp. 26673462837 liefert das Wort coordinates
Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
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'}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
Ausgabe.insert(1.0, "\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:
Ausgabe.insert(1.0, zeile + "\n")
wbfile.close()
Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")
def vigenere():
hilfetext = """HILFE: [Vigenere-Chiffre]
Die Eingabe eines Schlüsselwortes ist hier erforderlich!!!
Die Vigenere-Chiffre baut auf dem Prinzip der Cesar-Chiffre
auf, wobei hier die Verschiebung jedes einzelnen Buchstaben
durch die Buchstabenwerte eines Schlüsselwortes definiert
werden. Da der zu verschlüsselnde Text im allgemeinen
länger als das Schlüsselwort ist, wird das Schlüsselwort immer
wieder wiederholt. Ist der Schlüssel mindestens genauso lang wie
der Klartext entspricht dies dann dem One-Time-Pad-Chiffre.
Der eingegebene Text wird hier mit dem eingegebenen Schlüsselwort
kodiert und dekodiert ausgegeben und zwar sowohl in der
Variante, daß Sonderzeichen Schlüsselbuchstaben verbrauchen
als auch nicht.
"""
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()}
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "" or pw == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
for b in pw:
if b.upper() not in bw:
Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
return
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()
Ausgabe.insert(1.0, encoded_text_s + "\n")
Ausgabe.insert(1.0, "Kodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:\n", "bu")
Ausgabe.insert(1.0, decoded_text_s + "\n")
Ausgabe.insert(1.0, "Dekodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:\n", "bu")
Ausgabe.insert(1.0, encoded_text + "\n")
Ausgabe.insert(1.0, "Kodiert - normal:\n", "bu")
Ausgabe.insert(1.0, decoded_text + "\n")
Ausgabe.insert(1.0, "Dekodiert - normal:\n", "bu")
def wolseley():
hilfetext = """HILFE: [Wolseley-Chiffre]
Die Eingabe eines Schlüsselwortes ist hier erforderlich!!!
Die Woseley-Chiffre arbeitet mit einem Schlüsselwort über
welches dann ein Codequadrat/Codealphabet gebildet wird
mit welchem dann sowohl kodiert als auch dekodiert wird.
Angefangen wird dabei mit dem jeweils ersten Vorkommen
eines Buchstaben im Schlüsselwort und danach folgen die
restlichen Buchstaben des Alphabets die nicht im
Schlüsselwort vorkommen. Da hier nur 25 Zeichen zur
Verfügung stehen wird das J mit dem I zusammengefasst
und als I behandelt und dargestellt. Sonstige Zeichen
die nicht im Codealphabet vorhanden sind werden unverändert
ausgegeben.
Codequadrat mit Schlüsselwort: Teebaum
1 2 3 4 5
1 T E B A U
2 M C D F G
3 H I K L N
4 O P Q R S
5 V W X Y Z
Bei der Chiffrierung/Dechiffrierung wird im Text nun der
erste Buchstabe mit dem letzten getauscht, der 2. mit dem
Vorletzten, usw.
also aus T wird Z und umgekehrt,E<->Y, B<->X, A<->W usw..
nur ein K bleibt ein K
"""
abc = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird als i chiffriert
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "" or pw == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
for b in pw:
if b.upper() not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
return
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
Ausgabe.insert(1.0, atxt + "\n")
def atbash():
hilfetext = """HILFE: [Atbash-Chiffre]
Atbash ist eine einfache Ersetzungschiffre die für
das hebräische Alphabet entwickelt wurde, welche
später auf das lateinische Alphabet übertragen wurde.
Dabei wird dem normalen Alphabet ein rückwärtsgelesenes
Alphabet gegenüber gestellt. A wird zu Z, B zu Y usw.
Kodierung und Dekodierung erfolgt über die selbe Funktion.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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
Ausgabe.insert(1.0, atxt + "\n")
def monoalphasubstitution():
hilfetext = """HILFE: [Monoalphabetische Substitutions-Chiffre]
Bei der monoalphabetischen Substitution wird jedem Buchstaben des
Alphabet dem Buchstaben eines Schlüsselalphabets zugeordnet:
Bsp. Klartextalphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Schlüsselalphabet: DSBJFALKNVPOQXYWCEGHIMRTUZ
Spezialformen dieser Chiffre sind Atbash, Cesar, Rot13
Die Funktion hier arbeitet so, daß entweder ein komplettes
Schlüsselalphabet oder ein Schlüsselwort verwendet werden kann.
Wird ein Schlüsselwort genutzt wird der Rest des Schlüsselalphabet
automatisch aufgefüllt.
Aus dem Schlüsselwort GutenMorgenLiebeSonne wird dabei dann das
Schlüsselalphabet: GUTENMORLIBSACDFHJKPQVWXYZ
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "" or pw == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for b in pw:
if b.upper() not in abc:
Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
return
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
if len(pw) < len(abc):
Ausgabe.insert(1.0, "Schlüsselalphabet wurde wie folgt aufgefüllt: " + cabc + "\n", "gr")
Ausgabe.insert(1.0, encoded_txt + "\n")
Ausgabe.insert(1.0, "Kodiert:\n", "bu")
Ausgabe.insert(1.0, decoded_txt + "\n")
Ausgabe.insert(1.0, "Dekodiert:\n", "bu")
def autokey():
hilfetext = """HILFE: [Autokey-Chiffre]
Die Autokey-Chiffre arbeitet nach dem selben
Prinzip wie Vignere-Chiffre mit dem Unterschied,
daß hier am Ende des Schlüsselwortes nicht wieder
und wieder das Schlüsselwort angehängt wird,
sondern der Klartext an das Schlüsselwort
angehangen wird.
Der eingegebene Text wird hier mit dem eingegebenen
Schlüsselwort kodiert und dekodiert ausgegeben.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "" or pw == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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:
Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
return
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()
Ausgabe.insert(1.0, encoded_text + "\n")
Ausgabe.insert(1.0, "Kodiert:\n", "bu")
Ausgabe.insert(1.0, decoded_text + "\n")
Ausgabe.insert(1.0, "Dekodiert:\n", "bu")
def polybios_encode():
hilfetext = """HILFE: [Polybios-Chiffre kodieren]
Die 5x5 Polybios-Chiffre kodiert Buchstaben zu zweistelligen
Zahlen dazu wird das Schlüsselalphabet in ein 5x5-Quadrat
eingetragen. Die Buchstaben werden dann sozusagen zu ihren
entsprechenden "Koordinaten" kodiert. Im unten gezeigten
Quadrat wird so aus A 11, aus B 12, aus Q 41, usw.
Da in ein 5x5 Quadrat nur 25 Buchstaben passen wird
typischer Weise J und I zusammengefasst,
(alternativ auch U und V), sollen auch Ziffern kodiert
werden wird mit einem 6x6-Quadrat gearbeitet, bei welchem
dann für das komplette Alphabet und die Ziffern 0-9 Platz ist.
1 2 3 4 5
1 A B C D E
2 F G H I K
3 L M N O P
4 Q R S T U
5 V W X Y Z
Kommt für die Chiffre ein Passwort zum Einsatz wird das
Code-Quadrat so abgeändert wie es in der Hilfe zur
Woseley-Chiffre beschrieben ist.
Die Funktion ist so gestaltet, daß alle nicht im jeweiligen
Codealphabet vorhandenen Zeichen herausgefiltert werden.
Zur Information wird für jede Polybios-Variante auch noch
einmal der verwendete Klartext und das verwendete Passwort
ausgegeben wird.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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]
Ausgabe.insert(1.0, ctext6 + "\n")
Ausgabe.insert(1.0, "Passwort: " + passw6 + "\n", "gr")
Ausgabe.insert(1.0, "Klartext: " + text6 + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 6x6\n", "bu")
Ausgabe.insert(1.0, ctext5uv + "\n\n")
Ausgabe.insert(1.0, "Passwort: " + passw5uv + "\n", "gr")
Ausgabe.insert(1.0, "Klartext: " + text5uv + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 5x5 (v=u)\n", "bu")
Ausgabe.insert(1.0, ctext5ij + "\n\n")
Ausgabe.insert(1.0, "Passwort: " + passw5ij + "\n", "gr")
Ausgabe.insert(1.0, "Klartext: " + text5ij + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 5x5 (j=i)\n", "bu")
def polybios_decode():
hilfetext = """HILFE: [Polybios-Chiffre dekodieren]
Die 5x5 Polybios-Chiffre kodiert Buchstaben zu zweistelligen
Zahlen dazu wird das Schlüsselalphabet in ein 5x5-Quadrat
eingetragen. Die Buchstaben werden dann sozusagen zu ihren
entsprechenden "Koordinaten" kodiert. Im unten gezeigten
Quadrat wird so aus A 11, aus B 12, aus Q 41, usw.
Da in ein 5x5 Quadrat nur 25 Buchstaben passen wird
typischer Weise J und I zusammengefasst,
(alternativ auch U und V), sollen auch Ziffern kodiert
werden wird mit einem 6x6-Quadrat gearbeitet, bei welchem
dann für das komplette Alphabet und die Ziffern 0-9 Platz ist.
1 2 3 4 5
1 A B C D E
2 F G H I K
3 L M N O P
4 Q R S T U
5 V W X Y Z
Kommt für die Chiffre ein Passwort zum Einsatz wird das
Code-Quadrat so abgeändert wie es in der Hilfe zur
Woseley-Chiffre beschrieben ist.
Die Funktion ist so gestaltet, daß alle nicht im jeweiligen
Codealphabet vorhandenen Zeichen herausgefiltert werden.
Zur Information wird für jede Polybios-Variante auch noch
einmal das verwendete Passwort ausgegeben wird.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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 += " "
Ausgabe.insert(1.0, ctext6 + "\n")
Ausgabe.insert(1.0, "Passwort: " + passw6 + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 6x6\n", "bu")
Ausgabe.insert(1.0, ctext5uv + "\n\n")
Ausgabe.insert(1.0, "Passwort: " + passw5uv + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 5x5 (v=u)\n", "bu")
Ausgabe.insert(1.0, ctext5ij + "\n\n")
Ausgabe.insert(1.0, "Passwort: " + passw5ij + "\n", "gr")
Ausgabe.insert(1.0, "Polybios 5x5 (j=i)\n", "bu")
def klopfcode_encode():
hilfetext = """HILFE: [Klopfcode kodieren]
Der Klopfcode ist im Prinzip eine Polybios Chiffre
mit einem festen Schlüsselquadrat bei welchem nicht
I und J sondern C und K zusammengefasst werden.
siehe hier:
1 2 3 4 5
1 A B C D E
2 F G H I J
3 L M N O P
4 Q R S T U
5 V W X Y Z
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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]
Ausgabe.insert(1.0, ctext + "\n")
Ausgabe.insert(1.0, "Klartext: " + text5 + "\n", "gr")
def klopfcode_decode():
hilfetext = """HILFE: [Klopfcode dekodieren]
Der Klopfcode ist im Prinzip eine Polybios Chiffre
mit einem festen Schlüsselquadrat bei welchem nicht
I und J sondern C und K zusammengefasst werden.
siehe hier:
1 2 3 4 5
1 A B C D E
2 F G H I J
3 L M N O P
4 Q R S T U
5 V W X Y Z
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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 += " "
Ausgabe.insert(1.0, ctext + "\n")
Ausgabe.insert(1.0, "Klopfcode dekodiert:\n", "bu")
def maptiles_kachelkoordinaten():
hilfetext = """HILFE: [Maptiles / Kachelkoordinaten]
Bei vielen Online-Kartendiensten wie Openstreetmap oder Google-Maps erfolgt die
Kartendarstellung über vorberechnete "Kachel"-Grafikdateien, welche ein
Adressierungssystem benötigen damit je nach Koordinate und Zoomstufe auch der
richtige Kartenausschnitt dargestellt und klar ist welche Kacheln daneben
darzustellen ist wird.Bei OSM ist eine solche Kachel eine PNG-Grafik mit 256x256
Pixeln und je nach Zoomstufe ist eine unterschiedliche Anzahl solcher
Kacheln/Tiles notwendig um die ganze Welt abzubilden. Da je Zoomstufe sich die
Anzahl der benötigten Kacheln vervierfacht ist bei den meisten Diensten bei
Zoomlevel 18 Schluß, OSM geht bis Zoomlevel 19.
Um die einzelnen Kacheln beim tilemap-Server abzufragen braucht man die
Zoomstufe, einen X und einen Y-Wert wobei dies alles ganzzahlige Werte sind.
Aufgerufen von den Servern werden die Kacheln dann nach dem Muster:
"http://servername/Zoom/X/Y.png" Den Fernsehturm mit Zoomstufe 18 findet man
z.B. bei Openstreetmap hier:https://tile.openstreetmap.org/18/140836/85970.png
Die Funktion arbeitet hier auf die Art und Weise, daß man 2 durch ein
Freizeichen getrennte Zahlen eingibt. Handelt es sich bei den angegebenen Zahlen
um "Kommazahlen" welche allerdings mit Punkt anzugeben sind
(Bsp: 52.520803 13.4088653 ) geht die Funktion davon aus, daß es sich um
Koordinaten in Dezimalgrad handelt und sofern es gültige Koordinaten sind
erfolgt eine Ausgabe der X und Y Werte für die Zoomstufen und 1-30.
(Positive Zahlen stehen für Nord und Ost, negative für Süd und West)
Handelt es sich bei den beiden Zahlen um Ganzzahlen wird davon ausgegangen, daß
es sich um X und Y Werte handelt und es werde für alle Zoomstufen von 1-30
Koordinaten in Dezimalminuten und Dezimalgrad ausgegeben, sofern dies sinnvolle
Koordinaten ergibt.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
text = text.split()
if "." in text[0] and len(text) == 2:
for zoom in range(30, 0, -1):
try:
la = float(text[0])
lo = float(text[1])
if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
x, y = dec_to_maptiles(la, lo, zoom)
Ausgabe.insert(1.0, "Zoom:{:>2} X:{:<10} Y:{}\n".format(zoom, x, y))
except ValueError:
pass
Ausgabe.insert(1.0, "DEC -> Maptiles\n", "bu")
elif len(text) == 2:
for zoom in range(30, 0, -1):
try:
la, lo = maptiles_to_dec(int(text[0]), int(text[1]), zoom)
if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
Ausgabe.insert(1.0, "Zoom:{:>2} DEG: {:<23} DEC: {} {}\n".format(zoom, dec_to_deg(la, lo),
round(la, 5), round(lo, 5)))
except ValueError:
pass
Ausgabe.insert(1.0, "Maptiles->DEG,DEC\n", "bu")
else:
Ausgabe.insert(1.0, "Zahlen konnten nicht ermittelt werden!\n", "re")
def quadtreekoordinaten():
hilfetext = """HILFE: [Quadtree-/Quadkeykoordinaten]
Diese Koordinatenkodierung spielt in der alltäglichen Praxis eigentlich
kaum noch ein Rolle, außer scheinbar bei bing-maps und beim Geocaching.
Sie dient ähnlich wie das Maptiles-System dazu Grafikdateien für
unterschiedliche Zoomstufen einer Karte zu adressieren.
Die Länge der Zahl entspricht hier zugleich auch dem Detailgrad bzw.
der Zoomstufe. Es finden nur die Zahlen 0,1,2 und 3 Verwendung, wobei
die 0 den Nordwestlichen Quadranten, 1 den Nordöstlichen, 2 SW und 3 SO.
Ein kleines Beispiel: 230 würde bedeuten es geht im südwestlichen
Quadranten (2) um den südöstlichen Quadranten(3) und in diesem wiederum
um den nordwestlichen Quadranten.
Je länger also diese Zahlenreihe aus 0,1,2 und 3 wird um so genauer wird
ein bestimmter Ort angegeben.
Weitere Infos gibt es unter folgendem Link zu finden:
https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system
Die Funktion ermittelt aus einer Quadtreekoordinate die Maptileskoordinaten
und die WGS-Koordinaten.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
tilex = 0
tiley = 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":
tilex |= mask
continue
if quadkey[zoom - i] == "2":
tiley |= mask
continue
if quadkey[zoom - i] == "3":
tilex |= mask
tiley |= mask
continue
else:
fehler += 1
la, lo = maptiles_to_dec(tilex, tiley, zoom)
if fehler == 0:
Ausgabe.insert(1.0, "DEG: {}\n".format(dec_to_deg(la, lo)))
Ausgabe.insert(1.0, "DEC: {} {}\n".format(round(la, 5), round(lo, 5)))
Ausgabe.insert(1.0, "Maptiles: X:{} Y:{} Zoom:{}\n".format(tilex, tiley, zoom))
else:
Ausgabe.insert(1.0,
"Es konnte keine gültige Quadtree-Koordinate erkannt werden.\n"
"(eine Zahl die nur die Ziffern 0,1,2,3 enthält)\n")
def chronogramm():
hilfetext = """HILFE: [Chronogramm/ römische Ziffern zählen]
Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch
oder eine Inschrift, meist ein Vers in lateinischer Sprache, in dem diejenigen
Buchstaben, die auch als römische Zahlzeichen gelesen werden können
(I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des Ereignisses angeben,
auf das sich der Text bezieht. Entscheidend ist allein die Summe der
Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion
kleinerer Zahlenwerte von folgenden größeren erfolgt nicht.
Die Zahlbuchstaben sind meist hervorgehoben, etwa durch Großschreibung oder
Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder
Vergoldung. Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die
Zahlbuchstaben nicht gekennzeichnet sind und "verborgen" bleiben.
Bei der einfachen Analyse werden hier die Buchstaben I(1),V(5),X(10),L(50),
C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten
Analyse wird zunächst einmal berücksichtigt, daß im Lateinischen Alphabet
der Buchstabe J als I und der Buchstabe U als V geschrieben wird. Außerdem
erfolgt wird in der extremen Variante auch noch W=10(V+V) und Y=2(I+I)
berücksichtigt. Desweiteren wird auch für jeden relevanten Buchstaben
einzeln noch einmal die Anzahl und Summe angezeigt.
Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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)
Ausgabe.insert(1.0, "Summe extrem(inkl.J,U,Y,W): {}\n".format(sum_extrem))
Ausgabe.insert(1.0, "Summe erweitert(inkl. I,U): {}\n".format(sum_erweitert))
Ausgabe.insert(1.0, "Summe einfach(I,V,X,L,C,D,M): {}\n".format(sum_einfach))
Ausgabe.insert(1.0, "W(V+V=10):{:5}x \tSumme W: {}\n".format(w, w * 10), "gr")
Ausgabe.insert(1.0, " Y(I+I=2):{:5}x \tSumme Y: {}\n".format(y, y * 2), "gr")
Ausgabe.insert(1.0, " U(V=5):{:5}x \tSumme U: {}\n".format(u, u * 5), "gr")
Ausgabe.insert(1.0, " J(I=1):{:5}x \tSumme U: {}\n".format(j, j), "gr")
Ausgabe.insert(1.0, " M(1000):{:5}x \tSumme M: {}\n".format(m, m * 1000), "gr")
Ausgabe.insert(1.0, " D(500):{:5}x \tSumme D: {}\n".format(d, d * 500), "gr")
Ausgabe.insert(1.0, " C(100):{:5}x \tSumme C: {}\n".format(c, c * 100), "gr")
Ausgabe.insert(1.0, " L(50):{:5}x \tSumme L: {}\n".format(ll, ll * 50), "gr")
Ausgabe.insert(1.0, " X(10):{:5}x \tSumme X: {}\n".format(x, x * 10), "gr")
Ausgabe.insert(1.0, " V(5):{:5}x \tSumme V: {}\n".format(v, v * 5), "gr")
Ausgabe.insert(1.0, " I(1):{:5}x \tSumme I: {}\n".format(i, i), "gr")
def adfgx_kodieren():
hilfetext = """HILFE: [ADFGX kodieren]
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
T E S T E R nun werden diese Spalten dem Passwort entsprechend
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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:
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
return
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
Ausgabe.insert(1.0, ausgabe_za + "\n")
Ausgabe.insert(1.0, "kodiert mit Variante Z-A:\n")
Ausgabe.insert(1.0, ausgabe_az + "\n")
Ausgabe.insert(1.0, "kodiert mit Variante A-Z:\n")
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
def adfgx_dekodieren():
hilfetext = """HILFE: [ADFGX dekodieren]
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
T E S T E R nun werden diese Spalten dem Passwort entsprechend
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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:
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
return
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]
Ausgabe.insert(1.0, klartext_za + "\n")
Ausgabe.insert(1.0, "dekodiert mit Variante Z-A:\n")
Ausgabe.insert(1.0, klartext_az + "\n")
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z:\n")
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
def adfgvx_kodieren():
hilfetext = """HILFE: [ADFGVX kodieren]
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
wird (A->Z + 0->9 oder 9->0 + Z->A).
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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:
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
return
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
Ausgabe.insert(1.0, ausgabe_90za + "\n")
Ausgabe.insert(1.0, "kodiert mit Variante 9-0,Z-A:\n")
Ausgabe.insert(1.0, ausgabe_az09 + "\n")
Ausgabe.insert(1.0, "kodiert mit Variante A-Z,0-9:\n")
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
def adfgvx_dekodieren():
hilfetext = """HILFE: [ADFGVX dekodieren]
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
wird (A->Z + 0->9 oder 9->0 + Z->A).
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
text = eingabetext.rstrip()
pw = PW_Eingabe.get()
pw = pw.strip()
if text == "":
Ausgabe.insert(1.0, hilfetext + "\n")
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:
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
return
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]
Ausgabe.insert(1.0, klartext_90za + "\n")
Ausgabe.insert(1.0, "dekodiert mit Variante 0-0,Z-A:\n")
Ausgabe.insert(1.0, klartext_az09 + "\n")
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z,0-9:\n")
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
def zahlen_roemisch_arabisch_umwandeln():
hilfetext = """HILFE: [Römische in Arabische Zahlen umwandeln und umgekehrt]
Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion
arbeitet dabei bei der Umwandlung von arabisch zu römisch mit Werten bis
maximal 500000. Es werden folgende Zeichen verwendet: I=1, V=5, X=10, L=50,
C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, \u2188=100000
Etwas Vorsicht sollte bei einer Umwandlung von römischen in arabische Zahlen
geboten sein, wenn mit untypischen Schreibweisen gearbeitet wird bei welchen
mehr als ein Zeichen von dem nachfolgenden Zeichen abgezogen werden soll.
Die eigentlich inkorrekte Schreibweise IIX für die Zahl 8 wird hier die Zahl
10 als Ergebnis haben (+1-1+10), dafür wird aber allerdings die ebenfalls
falsche Schreibweise IM genauso als 999 wie die korrekte Schreibweise CMXCIX
erkannt.
"""
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')]
trennlinie()
eingabetext = Eingabe.get(1.0, END)
rz = eingabetext.rstrip()
if rz == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
rz = rz.upper()
try:
az = 0
for i in range(len(rz)):
if i == len(rz) - 1:
az += rza[rz[i]]
Ausgabe.insert(1.0, "{} = {}\n".format(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:
Ausgabe.insert(1.0, "arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!\n", "re")
return
rom = ""
for az, romz in azr:
count = zahl // az
zahl -= az * count
rom += romz * count
Ausgabe.insert(1.0, "{} = {}\n".format(rz, rom))
except ValueError:
Ausgabe.insert(1.0, "Es konnte keine römische oder arabische Zahl erkannt werden!\n", "re")
def euler_suche():
hilfetext = """HILFE: [Eulersche Zahl - Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von e (2.71828182845904523.....) zu ermitteln.
Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen
wird die Datei e.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl e mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit
dem Tool y-cruncher (http://numberworld.org/y-cruncher/)
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und e.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
eread = open("./data/e.txt", "r")
except FileNotFoundError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
estr = ""
for zeile in eread:
estr = estr + zeile.rstrip()
eread.close()
elen = len(estr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
else:
pos = estr.find(eingabetext)
if pos == -1:
Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(elen), "re")
else:
Ausgabe.insert(1.0,
"20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, estr[pos:pos + 20]))
Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
eingabetext.rstrip(), pos - 1))
if elen >= zahlx > 0:
Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle:"
" {}...\n\n".format(zahlx, estr[zahlx + 1:zahlx + 21]))
Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, estr[zahlx + 1]))
else:
Ausgabe.insert(1.0, "Die verwendete e.txt kennt leider nur {} Nachkommstellen.\n\n".format(elen),
"re")
Ausgabe.insert(1.0, "e (Eulersche Zahl)\n\n", "gr")
def goldener_schnitt_suche():
hilfetext = """HILFE: [phi(Goldener Schnitt) Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von phi (1.6180339887498948482045...) zu ermitteln.
Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen
wird die Datei phi.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl phi mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit
dem Tool y-cruncher (http://numberworld.org/y-cruncher/)
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und phi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, hilfetext + "\n")
else:
try:
phiread = open("./data/phi.txt", "r")
except ValueError:
Ausgabe.insert(1.0, hilfetext + "\n")
else:
phistr = ""
for zeile in phiread:
phistr = phistr + zeile.rstrip()
phiread.close()
philen = len(phistr) - 2
try:
zahlx = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
else:
pos = phistr.find(eingabetext)
if pos == -1:
Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(philen), "re")
else:
Ausgabe.insert(1.0,
"20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, phistr[pos:pos + 20]))
Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
eingabetext.rstrip(), pos - 1))
if philen >= zahlx > 0:
Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle:"
" {}...\n\n".format(zahlx, phistr[zahlx + 1:zahlx + 21]))
Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, phistr[zahlx + 1]))
else:
Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n".format(philen),
"re")
Ausgabe.insert(1.0, "Phi (Goldener Schnitt)\n\n", "gr")
def url_decode():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [URL-decode]
Nachdem Groundspeak nun inzwischen sämtliche Bilddateien
über einen Proxy umleitet bevor sie im Listing erscheinen
wird es manchmal schwer die ursprüngliche URL und/oder
den Dateinamen des Bildes noch lesen zu können.
Die URL hat dort nun jeweils folgendes Muster:
https://imgproxy.geocaching.com/......?url=.....
wobei nach dem ?url= dann die ursprüngliche Bild-URL
folgt, allerdings wird dabei dann aus
http:// folgendes http%3A%2F%2F und um genau dieses
wieder normal lesbar zu machen dient diese Funktion\n\n""")
else:
atxt = urllib_parse_unquote(eingabetext)
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "dekodierte URL:\n", "bu")
def reversewig():
seperator = ("|,", "_", "/", ";", ",")
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Reverse Wherigo zu Koordinaten]
Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache
erfunden. Man hat anfangs keine Koordinaten sondern nur 3 Zahlen, welche
man nach Start des Wherigo-Cartridges eingibt und dann erfährt man wie weit
der Cache entfernt ist. Nun kann man immer wieder von unterschiedlichen
Positionen aus diese Entfernungsfragen durchführen und sich damit dem
Cache nähern. Je weniger Abfragen man braucht umso besser.
Leider gibt es inzwischen genügend Tools die genau wie diese Funktion
hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können.
Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem
viele dieser Reverse-Wherigos gibt wo sich die Owner anscheinend auch
denken "Die spielt doch sowieso keiner mehr normal..." anders kann ich
mir ganze Trails mit Reverse-Wherigos nicht erklären.
Um die Funktion zu nutzen braucht man nur die 3 Zahlen durch ein entsprechendes
Trennzeichen: | , _ / ; , oder Leerzeichen eingeben und auf den Knopp klicken
und bekommt Koordinaten.
""" + "\n\n")
else:
se = ""
for s in seperator:
if s in eingabetext:
se = s
if se == "" and " " in eingabetext:
se = " "
if se == "":
Ausgabe.insert(1.0, "Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n", "re")
else:
txt = eingabetext.split(se)
if len(txt) == 3:
error = 0
for z in txt:
try:
int(z)
except ValueError:
Ausgabe.insert(1.0, "Bitte die Eingabezahlen überprüfen\n", "re")
error += 1
if error == 0:
final = rwig_to_coords(txt[0], txt[1], txt[2])
Ausgabe.insert(1.0, "DEG: " + dec_to_deg(final[0], final[1]) + "\n")
Ausgabe.insert(1.0, "DEC: " + str(final[0]) + " " + str(final[1]) + "\n")
Ausgabe.insert(1.0, "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + "\n")
else:
Ausgabe.insert(1.0, "Es wurden nicht 3 Zahlen erkannt.\n", "re")
def base64_ascii():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Base64 <-> ASCII]
Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird
um beliebige Binärdaten nur Hilfe einer Zeichenkette aus A-Z,
a-z, 0-9, +, / sowie am Ende = übertragen zu können. Ein Einsatzzweck
dafür ist z.B. wenn bei EMails Dateianhänge verwendet werden, dort
werden nahezu alle Dateiformate base64-kodiert übertragen.
Auch bei dem einem oder anderen Mystery sind mir solche kodierten
Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein
oder zwei "="-Zeichen stehen ist die Wahrscheinlichkeit recht groß,
das hier base64 verwendet wurde. Das "="-Zeichen dient hier nämlich
als "Lückenfüller" am Ende.
Die Funktion hier versucht zunächst eine Dekodierung Base64->ASCII
gelingt dies nicht, erscheint ein Hinweis und der eingegeben Text
wird dann Base64-kodiert ausgegeben.
""" + "\n\n")
else:
try:
ascii_string = binascii.a2b_base64(eingabetext).decode()
Ausgabe.insert(1.0, ascii_string + "\n")
Ausgabe.insert(1.0, "Base64 -> ASCII:\n", "bu")
except ValueError:
base64_string = binascii.b2a_base64(eingabetext.encode())
Ausgabe.insert(1.0, base64_string.decode() + "\n")
Ausgabe.insert(1.0, "ASCII -> Base64:\n", "bu")
Ausgabe.insert(1.0, "Umwandlung Base64 -> ASCII war nicht möglich.\n", "re")
def rail_encrypt(plain_text: str, rails: int):
arr = [["" for _ in range(len(plain_text))] for _ in range(rails)]
r = 0
z = 0
plus = True
for b in plain_text:
arr[r][z] = b
z += 1
if r + 1 == rails and plus:
plus = False
r -= 1
elif r - 1 < 0 and not plus:
plus = True
r += 1
elif plus:
r += 1
else:
r -= 1
out = ""
for i in range(rails):
for j in range(len(plain_text)):
out += arr[i][j]
return out
def jaegerzaun_encrypt():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.strip().replace("\n", " ")
pw = PW_Eingabe.get()
pw = pw.strip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [encrypt Jägerzaun]
Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt)
Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster
in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist
schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1
weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw.
Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben.
Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich
vielen Zeilen arbeitet welche im Schlüsselfeld anzugeben ist.
Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen
mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.
""" + "\n\n")
elif pw == "" or not pw.isdigit():
Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re")
else:
try:
if int(pw) < 2:
raise ValueError("Zahl zu klein")
Ausgabe.insert(1.0, rail_encrypt(eingabetext.replace(" ", ""), int(pw)) + "\n")
Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
Ausgabe.insert(1.0, rail_encrypt(eingabetext, int(pw)) + "\n")
Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
except ValueError:
Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
def rail_decrypt(cipher: str, rails: int):
arr = [["_" for _ in range(len(cipher))] for _ in range(rails)]
# cipher ins array reinbasteln
x, y = 0, 0
first_x = True
for b in cipher:
if x >= len(cipher) and y < rails:
y += 1
x = y
first_x = True
arr[y][x] = b
if y == 0 or (first_x and y != rails - 1):
x = x + (rails - y - 1) * 2
first_x = False
elif y == rails - 1 or first_x is False:
x = x + (y * 2)
first_x = True
# dekodierten Text aus array holen
out = ""
x, y = 0, 0
down = True
for _ in range(len(cipher)):
out += arr[y][x]
x += 1
if down and y + 1 == rails:
down = False
y -= 1
elif down:
y += 1
elif down is False and y == 0:
down = True
y += 1
elif down is False:
y -= 1
return out
def jaegerzaun_decrypt():
trennlinie()
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.strip().replace("\n", " ")
pw = PW_Eingabe.get()
pw = pw.strip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [decrypt Jägerzaun]
Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt)
Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster
in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist
schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1
weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw.
Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben.
Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich
vielen Zeilen arbeitet welche im Schlüsselfeld angegeben werden kann.
Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen
mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.
Wird im Schlüsselfeld keine Zahl angegeben erfolgt automatisch die Dekodierung
für alle Zeilenanzahlen von 2-12.""" + "\n\n")
elif pw == "":
for i in range(12, 1, -1):
Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext.replace(" ", ""), i)}\n')
Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
for i in range(12, 1, -1):
Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext, i)}\n')
Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
elif not pw.isdigit():
Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re")
else:
try:
if int(pw) < 2:
raise ValueError("Zahl zu klein")
Ausgabe.insert(1.0, rail_decrypt(eingabetext.replace(" ", ""), int(pw)) + "\n")
Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
Ausgabe.insert(1.0, rail_decrypt(eingabetext, int(pw)) + "\n")
Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
except ValueError:
Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
# ------------------------------------------------------------------------------------------
def knoeppe_aendern2():
B44.config(text="Button88", command="", bg=bgcolor_default, cursor="")
B45.config(text="Button89", command="", bg=bgcolor_default, cursor="")
B46.config(text="Button90", command="", bg=bgcolor_default, cursor="")
B47.config(text="Button91", command="", bg=bgcolor_default, cursor="")
B48.config(text="Button92", command="", bg=bgcolor_default, cursor="")
B49.config(text="Button93", command="", bg=bgcolor_default, cursor="")
B50.config(text="Button94", command="", bg=bgcolor_default, cursor="")
B51.config(text="Button95", command="", bg=bgcolor_default, cursor="")
B52.config(text="Button96", command="", bg=bgcolor_default, cursor="")
B53.config(text="Button97", command="", bg=bgcolor_default, cursor="")
B54.config(text="Button98", command="", bg=bgcolor_default, cursor="")
B55.config(text="Button99", command="", bg=bgcolor_default, cursor="")
B56.config(text="Button100", command="", bg=bgcolor_default, cursor="")
B57.config(text="Button101", command="", bg=bgcolor_default, cursor="")
B58.config(text="Button102", command="", bg=bgcolor_default, cursor="")
B59.config(text="Button103", command="", bg=bgcolor_default, cursor="")
B60.config(text="Button104", command="", bg=bgcolor_default, cursor="")
B61.config(text="Button105", command="", bg=bgcolor_default, cursor="")
B62.config(text="Button106", command="", bg=bgcolor_default, cursor="")
B63.config(text="Button107", command="", bg=bgcolor_default, cursor="")
B64.config(text="Button108", command="", bg=bgcolor_default, cursor="")
B65.config(text="_____Button109_____", command="", bg=bgcolor_default, cursor="")
BC0.config(fg="#ffffff", bg="#000000")
BC1.config(fg="#ffffff", bg="#000000")
BC2.config(fg="#000000", bg="#ffffff")
BC3.config(fg="#ffffff", bg="#000000")
BC4.config(fg="#ffffff", bg="#000000")
def knoeppe_aendern1():
B44.config(text="KENNYspeak kodieren", command=kenny_kodieren, bg='#FF897F', cursor='question_arrow', font=schrift)
B45.config(text="KENNYspeak dekodieren", command=kenny_dekodieren, bg='#FF897F', cursor='question_arrow',
font=schrift)
B46.config(text="KENNYspeak raten", command=kenny_raten, bg='#FF897F', cursor='question_arrow', font=schrift)
B47.config(text="Maptiles/Kachelkoord.", command=maptiles_kachelkoordinaten, bg='#FF59AF', cursor='question_arrow',
font=schrift)
B48.config(text="Quadtree/Quadkey", command=quadtreekoordinaten, bg='#FF59AF', cursor='question_arrow',
font=schrift)
B49.config(text="URL decode", command=url_decode, bg='#2FE94F', cursor='question_arrow', font=schrift)
B50.config(text="T9-DE dekodieren", command=t9_de, bg="#ff3300", cursor='question_arrow', font=schrift)
B51.config(text="T9-EN dekodieren", command=t9_en, bg="#ff3300", cursor='question_arrow', font=schrift)
B52.config(text="Wortsuche-DE", command=wortsuche_de, bg="#33aa00", cursor='question_arrow', font=schrift)
B53.config(text="Wortsuche-EN", command=wortsuche_en, bg="#33aa00", cursor='question_arrow', font=schrift)
B54.config(text="Reverse-Wherigo", command=reversewig, bg="#FFA94F", cursor='question_arrow', font=schrift)
B55.config(text="Base64<->ASCII", command=base64_ascii, bg="#7777ff", cursor='question_arrow', font=schrift)
B56.config(text="Jägerzaun kodieren", command=jaegerzaun_encrypt, bg="#3388aa", cursor='question_arrow',
font=schrift)
B57.config(text="Jägerzaun dekodieren", command=jaegerzaun_decrypt, bg="#3388aa", cursor='question_arrow',
font=schrift)
B58.config(text="Button80", command="", bg=bgcolor_default, cursor="")
B59.config(text="Button81", command="", bg=bgcolor_default, cursor="")
B60.config(text="Button82", command="", bg=bgcolor_default, cursor="")
B61.config(text="Button83", command="", bg=bgcolor_default, cursor="")
B62.config(text="Button84", command="", bg=bgcolor_default, cursor="")
B63.config(text="Button85", command="", bg=bgcolor_default, cursor="")
B64.config(text="Button86", command="", bg=bgcolor_default, cursor="")
B65.config(text="Button87", command="", bg=bgcolor_default, cursor="")
BC0.config(fg="#ffffff", bg="#000000")
BC1.config(fg="#000000", bg="#ffffff")
BC2.config(fg="#ffffff", bg="#000000")
BC3.config(fg="#ffffff", bg="#000000")
BC4.config(fg="#ffffff", bg="#000000")
def knoeppe_aendern0():
B44.config(text="Kreiszahl PI", command=pi_suche, bg='#5555ff', cursor='question_arrow', font=schrift)
B45.config(text="Eulersche Zahl", command=euler_suche, bg='#5555ff', cursor='question_arrow', font=schrift)
B46.config(text="phi (goldener Schnitt)", command=goldener_schnitt_suche, bg='#5555ff', cursor='question_arrow',
font=schrift)
B47.config(text="! Brainfuck-Interpreter", command=brainfuck_interpreter, bg='#FFA94F', cursor='question_arrow',
font=schrift)
B48.config(text="! Ook/ShortOok-Interp.", command=ook_interpreter, bg='#FFA94F', cursor='question_arrow',
font=schrift)
B49.config(text="Text->Tomtom", command=abctotomtom, bg='#FFA98F', cursor='question_arrow', font=schrift)
B50.config(text="Tomtom->Text", command=tomtomtoabc, bg='#FFA98F', cursor='question_arrow', font=schrift)
B51.config(text="Text->Slash and Pipe", command=texttoslashpipe, bg='#FFA98F', cursor='question_arrow',
font=schrift)
B52.config(text="Slash and Pipe->Text", command=slashpipetotext, bg='#FFA98F', cursor='question_arrow',
font=schrift)
B53.config(text="Mono.-Substitution", command=monoalphasubstitution, bg='#8888ff', cursor='question_arrow',
font=schrift)
B54.config(text="Woseley-Chiffre", command=wolseley, bg='#8888ff', cursor='question_arrow', font=schrift)
B55.config(text="Atbash-Chiffre", command=atbash, bg='#8888ff', cursor='question_arrow', font=schrift)
B56.config(text="Autokey-Chiffre", command=autokey, bg='#8888ff', cursor='question_arrow', font=schrift)
B57.config(text="Vigenere-Chiffre", command=vigenere, bg='#8888ff', cursor='question_arrow', font=schrift)
B58.config(text="Polybios kodieren", command=polybios_encode, bg='#8888ff', cursor='question_arrow', font=schrift)
B59.config(text="Polybios dekodieren", command=polybios_decode, bg='#8888ff', cursor='question_arrow', font=schrift)
B60.config(text="Klopfcode kodieren", command=klopfcode_encode, bg='#8888ff', cursor='question_arrow', font=schrift)
B61.config(text="Klopfcode dekodieren", command=klopfcode_decode, bg='#8888ff', cursor='question_arrow',
font=schrift)
B62.config(text="ADFGX kodieren", command=adfgvx_kodieren, bg='#8888ff', cursor='question_arrow', font=schrift)
B63.config(text="ADFGX dekodieren", command=adfgx_dekodieren, bg='#8888ff', cursor='question_arrow', font=schrift)
B64.config(text="ADFGVX kodieren", command=adfgvx_kodieren, bg='#8888ff', cursor='question_arrow', font=schrift)
B65.config(text="ADFGVX dekodieren", command=adfgvx_dekodieren, bg='#8888ff', cursor='question_arrow', font=schrift)
BC0.config(fg="#000000", bg="#ffffff")
BC1.config(fg="#ffffff", bg="#000000")
BC2.config(fg="#ffffff", bg="#000000")
BC3.config(fg="#ffffff", bg="#000000")
BC4.config(fg="#ffffff", bg="#000000")
# -----------------------------------------------------------------------------------------------------------
def infofenster():
ifenster = Tk()
ifenster.title("Info")
itext = """INFO!
Viel Spaß beim Benutzen des Programms!
Ich hoffe dem ein oder anderen hilft es ein wenig.
Happy hunting! tebarius
"""
info_text = Label(ifenster, text=itext, font=schrift)
website_link = Label(ifenster, text="Homepage", fg="blue", cursor="hand2", font=schrift)
website_link.bind("<Button-1>", lambda event: webbrowser.open_new(website))
gc_link = Label(ifenster, text="meine geocaching.com-Profilseite", fg="blue", cursor="hand2", font=schrift)
gc_link.bind("<Button-1>", lambda event: webbrowser.open_new("https://www.geocaching.com/p/?u=tebarius"))
info_exit = Button(ifenster, text="Danke!", command=ifenster.destroy, bg='#FF4444', cursor='target', font=schrift)
info_text.grid(row=0, column=0, pady=5)
website_link.grid(row=1, column=0, pady=5)
gc_link.grid(row=2, column=0, pady=5)
info_exit.grid(row=3, column=0, pady=5)
# --Konfig-----------------------------------------------------------------------------------------------------
def configfenster():
def standard_font():
font_family.set("Times New Roman")
font_size.set(10)
font_style.set("normal")
selected_font = font_family.get()
selected_size = font_size.get()
selected_style = font_style.get()
config_text_label.config(font=(selected_font, selected_size, selected_style))
config_text_label.config(text=f"Vorschau: {selected_font}, {selected_size}, {selected_style}")
def preview_font():
selected_font = font_family.get()
selected_size = font_size.get()
selected_style = font_style.get()
config_text_label.config(font=(selected_font, selected_size, selected_style))
config_text_label.config(text=f"Vorschau: {selected_font}, {selected_size}, {selected_style}")
def save_font():
selected_font = font_family.get()
selected_size = font_size.get()
selected_style = font_style.get()
config_text_label.config(font=(selected_font, selected_size, selected_style))
try:
config_file = open("./data/config.txt", "w", encoding="utf-8")
config_file.write(f"font = {selected_font}\n")
config_file.write(f"size = {selected_size}\n")
config_file.write(f"style = {selected_style}\n")
config_text_label.config(text="Gespeichert! Bitte Programm neu starten!")
except FileNotFoundError:
config_text_label.config(text="Speichern fehlgeschlagen!")
# Erstelle das Konfigfenster
config_fenster = Tk()
config_fenster.title("Font Configuration")
# Schriftarten auswählen
font_families = font.families()
# Schriftartauswahl
font_family_label = Label(config_fenster, text="Font Family:")
font_family_label.grid(row=0, column=0, sticky="w")
font_family = StringVar(config_fenster)
font_family.set(font_families[0]) # Standard-Schriftart
font_family_menu = ttk.Combobox(config_fenster, textvariable=font_family, values=font_families, state="readonly")
font_family_menu.grid(row=0, column=1, columnspan=2, padx=10, pady=5)
font_sizes = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
# Schriftartauswahl
font_size_label = Label(config_fenster, text="Font Size:")
font_size_label.grid(row=1, column=0, sticky="w")
font_size = IntVar(config_fenster)
font_size.set(font_sizes[5]) # Standard-groesse 10
font_size_menu = ttk.Combobox(config_fenster, textvariable=font_size, values=font_sizes, state="readonly")
font_size_menu.grid(row=1, column=1, columnspan=2, padx=10, pady=5)
# Schriftart-Stilauswahl
font_style_label = Label(config_fenster, text="Font Style:")
font_style_label.grid(row=2, column=0, sticky="w")
font_styles = ["normal", "bold", "italic", "underline"]
font_style = StringVar(config_fenster)
font_style.set(font_styles[0]) # Standard-Schriftart-Stil
font_style_menu = ttk.Combobox(config_fenster, textvariable=font_style, values=font_styles, state="readonly")
font_style_menu.grid(row=2, column=1, columnspan=2, padx=10, pady=5)
# Schriftart anwenden Button
defaultfont_button = Button(config_fenster, text="Standard", command=standard_font)
defaultfont_button.grid(row=3, column=0, padx=10, pady=5)
preview_button = Button(config_fenster, text="Vorschau", command=preview_font)
preview_button.grid(row=3, column=1, padx=10, pady=5)
save_button = Button(config_fenster, text="Speichern", command=save_font)
save_button.grid(row=3, column=2, padx=10, pady=5)
# Textlabel für Vorschau
config_text_label = Label(config_fenster, text="Vorschau: Beispieltext", font=(font_families[0], 10))
config_text_label.grid(row=4, column=0, columnspan=3, padx=10, pady=5)
# Exit-Button
save_button = Button(config_fenster, text="Schließen", command=config_fenster.destroy, bg='#FF4444',
cursor='target')
save_button.grid(row=5, column=1, padx=10, pady=5)
config_fenster.mainloop()
# -Hauptfenster-------------------------------------------------------------------------------------------------------
fenster = Tk()
fenster.title("tebarius kleiner Mysteryhelfer " + versionsnummer)
# fenster.resizable(False, False) # Auschalten der Möglichkeit das Hauptfenster größer/kleiner zu machen
bgcolor_default = fenster.cget("bg")
# LOGO
logodata = PhotoImage(data=LOGOIMG)
Logo = Button(image=logodata, command=infofenster, cursor="trek")
# Konfig
Konfig = Button(fenster, text="\u2699 Konfig", command=configfenster, bg='#83a88e', cursor='trek',
font=("Times New Roman", 10))
# Updatecheck
updatecheck_button = Button(fenster, text="Update-Check", command=check_update, bg='#83a88e', cursor='trek',
font=("Times New Roman", 10))
# Anweisungs-Label
Aufforderung = Label(fenster,
text="Hier zu untersuchende Zeichenkette eingeben (Hilfetexte erscheinen bei leerem Eingabefeld)",
font=schrift)
# Hier kann der Benutzer eine Eingabe machen
eingabe_scrollbar = Scrollbar(fenster)
Eingabe = Text(fenster, bd=2, width=80, height=10, relief=RAISED, cursor='xterm', font=schrift,
yscrollcommand=eingabe_scrollbar.set)
eingabe_scrollbar.config(command=Eingabe.yview)
# Schlüsseleingabefeld
PW_Label = Label(fenster, text="Schlüssel:", font=schrift)
PW_Eingabe = Entry(fenster, bd=2, width=25, relief=RAISED, cursor='xterm', font=schrift)
# In diesem Label erfolgt die Ausgabe der Funde
ausgabe_scrollbar = Scrollbar(fenster)
Ausgabe = Text(fenster, bd=2, width=80, height=28, relief=RAISED, cursor='xterm', font=schrift,
yscrollcommand=ausgabe_scrollbar.set)
ausgabe_scrollbar.config(command=Ausgabe.yview)
Ausgabe.insert(1.0, """
Ausgabefeld:
In diesem Feld erfolgt die Ausgabe der Funktionen.
Neueste Ergebnisse erscheinen immer zuoberst!!!!!
!!!!!ACHTUNG!!!!!
Mit ! gekennzeichnete Funktionen können unter ungünstigen
Umständen das Programm zum Absturz oder Einfrieren bringen!
Um den HILFE-Text zu einzelnen Funktionen
aufzurufen bitte mit leerem Eingabefeld den
jeweiligen Funktionsknopf betätigen.""")
Ausgabe.tag_config("bu", foreground="blue", underline=True)
Ausgabe.tag_config("re", foreground="red")
Ausgabe.tag_config("gr", foreground="green")
# Actionknöppe
B1 = Button(fenster, text="Ausgabefeld leeren!!!", command=ausgabe_leeren, bg='#FFFFFF', cursor='hand2', font=schrift)
B1a = Button(fenster, text="EINFÜGEN (Ersetzen)", command=eingabe_einfuegen, bg='#FFFFFF', cursor='hand2', font=schrift)
B1b = Button(fenster, text="Eingabe leeren!!!", command=eingabe_leeren, bg='#FFFFFF', cursor='hand2', font=schrift)
B1c = Button(fenster, text="Auswahl von Ausgabe in Zwischenablage", command=auswahl_kopieren, bg='#FFFFE0',
cursor='hand2', font=schrift)
B2 = Button(fenster, text="Cesarchiffre_all", command=cesar_all, bg='#FFE97F', cursor='question_arrow', font=schrift)
B3 = Button(fenster, text="BW,BWW,... ermitteln", command=buchstabenwortwert, bg='#FFE97F', cursor='question_arrow',
font=schrift)
B4 = Button(fenster, text="Buchstabenwert->Text", command=buchstabenwertzutext, bg='#FFE97F', cursor='question_arrow',
font=schrift)
B5 = Button(fenster, text="Zeichenzählen", command=zeichenzaehlen, bg='#FFE97F', cursor='question_arrow', font=schrift)
B6 = Button(fenster, text="Quersumme(n)", command=quersummen, bg='#FFE97F', cursor='question_arrow', font=schrift)
B7 = Button(fenster, text="Text rückwärts", command=zeichenkette_rueckwaerts, bg='#FFE97F', cursor='question_arrow',
font=schrift)
B8 = Button(fenster, text="ABC -> Morse", command=abctomorse, bg='#FFA98F', cursor='question_arrow', font=schrift)
B9 = Button(fenster, text="Morse -> ABC", command=morsetoabc, bg='#FFA98F', cursor='question_arrow', font=schrift)
B10 = Button(fenster, text="ROT5", command=rot5, bg='#FFE97F', cursor='question_arrow', font=schrift)
B11 = Button(fenster, text="ROT13", command=rot13, bg='#FFE97F', cursor='question_arrow', font=schrift)
B12 = Button(fenster, text="ROT18", command=rot18, bg='#FFE97F', cursor='question_arrow', font=schrift)
B13 = Button(fenster, text="ROT47", command=rot47, bg='#FFE97F', cursor='question_arrow', font=schrift)
B14 = Button(fenster, text="Zahlwortsuche-DE (0-12)", command=zahlwortsuche_de, bg='#4FE97F', cursor='question_arrow',
font=schrift)
B15 = Button(fenster, text="Zahlwortsuche-EN (0-15)", command=zahlwortsuche_en, bg='#4FE97F', cursor='question_arrow',
font=schrift)
B16 = Button(fenster, text="Einschlüsse(mit 4)", command=einschluessemit4, bg='#FFA94F', cursor='question_arrow',
font=schrift)
B17 = Button(fenster, text="Einschlüsse(ohne 4)", command=einschluesseohne4, bg='#FFA94F', cursor='question_arrow',
font=schrift)
B18 = Button(fenster, text="Primz.Alpha dekodieren", command=primzahlalphabet_dekodieren, bg='#00A4AA',
cursor='question_arrow', font=schrift)
B19 = Button(fenster, text="ist (n.te) Primzahl?", command=primzahlpruefen, bg='#00A4AA', cursor='question_arrow',
font=schrift)
B20 = Button(fenster, text="zeige n.te Primzahl", command=nte_primzahl, bg='#00A4AA', cursor='question_arrow',
font=schrift)
B21 = Button(fenster, text="Primfaktorenzerlegung", command=primfaktoren, bg='#00a4aa', cursor='question_arrow',
font=schrift)
B22 = Button(fenster, text="PSE: O.zahl<->Symbol", command=periodensystem, bg='#2FE94F', cursor='question_arrow',
font=schrift)
B23 = Button(fenster, text="Anagrammsuche-DE", command=anagramm_suche_de, bg='#ff55ff', cursor='question_arrow',
font=schrift)
B24 = Button(fenster, text="Anagrammsuche-EN", command=anagramm_suche_en, bg='#ff55ff', cursor='question_arrow',
font=schrift)
B25 = Button(fenster, text="ASCII-Text->HEX", command=asciitohex, bg='#EFE97F', cursor='question_arrow', font=schrift)
B26 = Button(fenster, text="ASCII-Text->DEZ", command=asciitodez, bg='#EFE97F', cursor='question_arrow', font=schrift)
B27 = Button(fenster, text="ASCII-Text->Octal", command=asciitooctal, bg='#EFE97F', cursor='question_arrow',
font=schrift)
B28 = Button(fenster, text="ASCII-Text->BIN (16bit)", command=asciitobin16, bg='#EFE97F', cursor='question_arrow',
font=schrift)
B29 = Button(fenster, text="ASCII-Text->BIN (8bit)", command=asciitobin8, bg='#EFE97F', cursor='question_arrow',
font=schrift)
B30 = Button(fenster, text="HEX->ASCII-Text", command=hextoascii, bg='#DFA97F', cursor='question_arrow', font=schrift)
B31 = Button(fenster, text="DEZ->ASCII-Text", command=deztoascii, bg='#DFA97F', cursor='question_arrow', font=schrift)
B32 = Button(fenster, text="Octal->ASCII-Text", command=octaltoascii, bg='#DFA97F', cursor='question_arrow',
font=schrift)
B33 = Button(fenster, text="BIN->ASCII-Text", command=bintoascii, bg='#DFA97F', cursor='question_arrow', font=schrift)
B34 = Button(fenster, text="HEX -> DEZ,OCT,BIN", command=hextodezoctbin, bg='#2FE94F', cursor='question_arrow',
font=schrift)
B35 = Button(fenster, text="DEZ -> HEX,OCT,BIN", command=deztohexoctbin, bg='#2FE94F', cursor='question_arrow',
font=schrift)
B36 = Button(fenster, text="OCT -> HEX,DEZ,BIN", command=octtohexdezbin, bg='#2FE94F', cursor='question_arrow',
font=schrift)
B37 = Button(fenster, text="BIN -> HEX,DEZ,OCT", command=bintohexdezoct, bg='#2FE94F', cursor='question_arrow',
font=schrift)
B38 = Button(fenster, text="Nak-Nak -> Text", command=naknaktotext, bg='#FFFF00', cursor='question_arrow', font=schrift)
B39 = Button(fenster, text="Navajo -> Text", command=navajototext, bg='#009900', cursor='question_arrow', font=schrift)
B40 = Button(fenster, text="Re-Morse-DE", command=remorse_de, bg='#55ff55', cursor='question_arrow', font=schrift)
B41 = Button(fenster, text="Re-Morse-EN", command=remorse_en, bg='#55ff55', cursor='question_arrow', font=schrift)
B42 = Button(fenster, text="Chronogramm", command=chronogramm, bg='#FFA98F', cursor='question_arrow', font=schrift)
B43 = Button(fenster, text="Zahl röm.<->arabisch", command=zahlen_roemisch_arabisch_umwandeln, bg='#FF897F',
cursor='question_arrow', font=schrift)
B44 = Button(fenster, text="Kreiszahl PI", command=pi_suche, bg='#5555ff', cursor='question_arrow', font=schrift)
B45 = Button(fenster, text="Eulersche Zahl", command=euler_suche, bg='#5555ff', cursor='question_arrow', font=schrift)
B46 = Button(fenster, text="phi (goldener Schnitt)", command=goldener_schnitt_suche, bg='#5555ff',
cursor='question_arrow', font=schrift)
B47 = Button(fenster, text="! Brainfuck-Interpreter", command=brainfuck_interpreter, bg='#FFA94F',
cursor='question_arrow', font=schrift)
B48 = Button(fenster, text="! Ook/ShortOok-Interp.", command=ook_interpreter, bg='#FFA94F', cursor='question_arrow',
font=schrift)
B49 = Button(fenster, text="Text->Tomtom", command=abctotomtom, bg='#FFA98F', cursor='question_arrow', font=schrift)
B50 = Button(fenster, text="Tomtom->Text", command=tomtomtoabc, bg='#FFA98F', cursor='question_arrow', font=schrift)
B51 = Button(fenster, text="Text->Slash and Pipe", command=texttoslashpipe, bg='#FFA98F', cursor='question_arrow',
font=schrift)
B52 = Button(fenster, text="Slash and Pipe->Text", command=slashpipetotext, bg='#FFA98F', cursor='question_arrow',
font=schrift)
B53 = Button(fenster, text="Mono.-Substitution", command=monoalphasubstitution, bg='#8888ff', cursor='question_arrow',
font=schrift)
B54 = Button(fenster, text="Woseley-Chiffre", command=wolseley, bg='#8888ff', cursor='question_arrow', font=schrift)
B55 = Button(fenster, text="Atbash-Chiffre", command=atbash, bg='#8888ff', cursor='question_arrow', font=schrift)
B56 = Button(fenster, text="Autokey-Chiffre", command=autokey, bg='#8888ff', cursor='question_arrow', font=schrift)
B57 = Button(fenster, text="Vigenere-Chiffre", command=vigenere, bg='#8888ff', cursor='question_arrow', font=schrift)
B58 = Button(fenster, text="Polybios kodieren", command=polybios_encode, bg='#8888ff', cursor='question_arrow',
font=schrift)
B59 = Button(fenster, text="Polybios dekodieren", command=polybios_decode, bg='#8888ff', cursor='question_arrow',
font=schrift)
B60 = Button(fenster, text="Klopfcode kodieren", command=klopfcode_encode, bg='#8888ff', cursor='question_arrow',
font=schrift)
B61 = Button(fenster, text="Klopfcode dekodieren", command=klopfcode_decode, bg='#8888ff', cursor='question_arrow',
font=schrift)
B62 = Button(fenster, text="ADFGX kodieren", command=adfgx_kodieren, bg='#8888ff', cursor='question_arrow',
font=schrift)
B63 = Button(fenster, text="ADFGX dekodieren", command=adfgx_dekodieren, bg='#8888ff', cursor='question_arrow',
font=schrift)
B64 = Button(fenster, text="ADFGVX kodieren", command=adfgvx_kodieren, bg='#8888ff', cursor='question_arrow',
font=schrift)
B65 = Button(fenster, text="ADFGVX dekodieren", command=adfgvx_dekodieren, bg='#8888ff', cursor='question_arrow',
font=schrift)
BC0 = Button(fenster, text="0", command=knoeppe_aendern0, fg="#000000", bg="#ffffff", font=schrift)
BC1 = Button(fenster, text="1", command=knoeppe_aendern1, fg="#ffffff", bg="#000000", font=schrift)
BC2 = Button(fenster, text="2", command=knoeppe_aendern2, fg="#ffffff", bg="#000000", font=schrift)
BC3 = Button(fenster, text="3", command="", fg="#ffffff", bg="#000000", font=schrift)
BC4 = Button(fenster, text="4", command="", fg="#ffffff", bg="#000000", font=schrift)
Bexit = Button(fenster, text="Beenden", command=fenster.quit, bg='#FF4444', cursor='target', font=schrift)
# Nun fügen wir die Komponenten unserem Fenster hinzu
Logo.grid(row=0, column=5, rowspan=3)
Konfig.grid(row=0, column=0, pady=1, padx=10, sticky=W)
updatecheck_button.grid(row=0, column=2, pady=1, padx=10, sticky=E)
Aufforderung.grid(row=1, column=0, columnspan=3)
Eingabe.grid(row=2, column=0, rowspan=6, columnspan=3, pady=1, padx=(10, 0), sticky=N + S + E + W)
eingabe_scrollbar.grid(row=2, rowspan=6, column=3, padx=(0, 5), sticky=N + S)
Ausgabe.grid(row=9, column=0, rowspan=15, columnspan=3, pady=5, padx=(10, 0), sticky=N + S + E + W)
ausgabe_scrollbar.grid(row=9, rowspan=15, column=3, padx=(0, 5), sticky=N + S)
PW_Label.grid(row=8, column=0, pady=1, padx=(10, 0), sticky=E)
PW_Eingabe.grid(row=8, column=1, pady=1, padx=(0, 10), sticky=W)
B1c.grid(row=8, column=2, pady=1, sticky=E)
B1.grid(row=0, column=4, padx=5, sticky=W + E)
B1a.grid(row=2, column=4, padx=5, sticky=W + E)
B1b.grid(row=1, column=4, padx=5, sticky=W + E)
B2.grid(row=3, column=4, padx=5, pady=1, sticky=W + E)
B3.grid(row=4, column=4, padx=5, pady=1, sticky=W + E)
B4.grid(row=5, column=4, padx=5, pady=1, sticky=W + E)
B5.grid(row=6, column=4, padx=5, pady=1, sticky=W + E)
B6.grid(row=7, column=4, padx=5, pady=1, sticky=W + E)
B7.grid(row=8, column=4, padx=5, pady=1, sticky=W + E)
B8.grid(row=9, column=4, padx=5, pady=1, sticky=W + E)
B9.grid(row=10, column=4, padx=5, pady=1, sticky=W + E)
B10.grid(row=11, column=4, padx=5, pady=1, sticky=W + E)
B11.grid(row=12, column=4, padx=5, pady=1, sticky=W + E)
B12.grid(row=13, column=4, padx=5, pady=1, sticky=W + E)
B13.grid(row=14, column=4, padx=5, pady=1, sticky=W + E)
B14.grid(row=15, column=4, padx=5, pady=1, sticky=W + E)
B15.grid(row=16, column=4, padx=5, pady=1, sticky=W + E)
B16.grid(row=17, column=4, padx=5, pady=1, sticky=W + E)
B17.grid(row=18, column=4, padx=5, pady=1, sticky=W + E)
B18.grid(row=19, column=4, padx=5, pady=1, sticky=W + E)
B19.grid(row=20, column=4, padx=5, pady=1, sticky=W + E)
B20.grid(row=21, column=4, padx=5, pady=1, sticky=W + E)
B21.grid(row=22, column=4, padx=5, pady=1, sticky=W + E)
B22.grid(row=23, column=4, padx=5, pady=1, sticky=W + E)
B23.grid(row=3, column=5, padx=5, pady=1, sticky=W + E)
B24.grid(row=4, column=5, padx=5, pady=1, sticky=W + E)
B25.grid(row=5, column=5, padx=5, pady=1, sticky=W + E)
B26.grid(row=6, column=5, padx=5, pady=1, sticky=W + E)
B27.grid(row=7, column=5, padx=5, pady=1, sticky=W + E)
B28.grid(row=8, column=5, padx=5, pady=1, sticky=W + E)
B29.grid(row=9, column=5, padx=5, pady=1, sticky=W + E)
B30.grid(row=10, column=5, padx=5, pady=1, sticky=W + E)
B31.grid(row=11, column=5, padx=5, pady=1, sticky=W + E)
B32.grid(row=12, column=5, padx=5, pady=1, sticky=W + E)
B33.grid(row=13, column=5, padx=5, pady=1, sticky=W + E)
B34.grid(row=14, column=5, padx=5, pady=1, sticky=W + E)
B35.grid(row=15, column=5, padx=5, pady=1, sticky=W + E)
B36.grid(row=16, column=5, padx=5, pady=1, sticky=W + E)
B37.grid(row=17, column=5, padx=5, pady=1, sticky=W + E)
B38.grid(row=18, column=5, padx=5, pady=1, sticky=W + E)
B39.grid(row=19, column=5, padx=5, pady=1, sticky=W + E)
B40.grid(row=20, column=5, padx=5, pady=1, sticky=W + E)
B41.grid(row=21, column=5, padx=5, pady=1, sticky=W + E)
B42.grid(row=22, column=5, padx=5, pady=1, sticky=W + E)
B43.grid(row=23, column=5, padx=5, pady=1, sticky=W + E)
BC0.grid(row=0, column=6, pady=1)
BC1.grid(row=0, column=7, pady=1)
BC2.grid(row=0, column=8, pady=1)
BC3.grid(row=0, column=9, pady=1)
BC4.grid(row=0, column=10, pady=1)
B44.grid(row=1, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B45.grid(row=2, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B46.grid(row=3, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B47.grid(row=4, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B48.grid(row=5, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B49.grid(row=6, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B50.grid(row=7, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B51.grid(row=8, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B52.grid(row=9, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B53.grid(row=10, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B54.grid(row=11, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B55.grid(row=12, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B56.grid(row=13, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B57.grid(row=14, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B58.grid(row=15, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B59.grid(row=16, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B60.grid(row=17, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B61.grid(row=18, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B62.grid(row=19, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B63.grid(row=20, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B64.grid(row=21, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
B65.grid(row=22, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
Bexit.grid(row=23, column=6, padx=5, pady=1, sticky=W + E, columnspan=5)
mainloop()
Reference in New Issue View Git Blame Copy Permalink