chronogramm

app/app.py

@@ -218,7 +218,7 @@ def auswahl_verarbeiten():
         st.session_state.output_text = output
         st.session_state.map_data = mapd
     elif auswahl == "Quadtree/Quadkey":
-        output, mapd = tools.quadtreekoordinaten(text)
+        output, mapd = tools.quadtree_koordinaten(text)
         st.session_state.output_text = output
         st.session_state.map_data = mapd
     elif auswahl == "REPLACE":

app/tools.py

@@ -2438,7 +2438,7 @@ def maptiles_kachelkoordinaten(eingabetext):
         else:
             return "Zahlen konnten nicht ermittelt werden!", None
 
-def quadtreekoordinaten(eingabetext):
+def quadtree_koordinaten(eingabetext):
     hilfetext = ("### Quadtree-/Quadkeykoordinaten\n"
                  "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 "
@@ -2487,35 +2487,27 @@ def quadtreekoordinaten(eingabetext):
             return ("Es konnte keine gültige Quadtree-Koordinate erkannt werden. (eine Zahl die nur die Ziffern "
                     "0,1,2,3 enthält)"), None
 
-'''
+def chronogramm(eingabetext):
-def chronogramm():
+    hilfetext = ('### Chronogramm/ römische Ziffern zählen\n'
-    hilfetext = """HILFE: [Chronogramm/ römische Ziffern zählen]
+                 'Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch oder eine Inschrift, '
-Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch
+                 'meist ein Vers in lateinischer Sprache, in dem diejenigen Buchstaben, die auch als römische '
-oder eine Inschrift, meist ein Vers in lateinischer Sprache, in dem diejenigen
+                 'Zahlzeichen gelesen werden können (I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des '
-Buchstaben, die auch als römische Zahlzeichen gelesen werden können 
+                 'Ereignisses angeben, auf das sich der Text bezieht. Entscheidend ist allein die Summe der '
-(I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des Ereignisses angeben,
+                 'Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion kleinerer Zahlenwerte von '
-auf das sich der Text bezieht. Entscheidend ist allein die Summe der
+                 'folgenden größeren erfolgt nicht. Die Zahlbuchstaben sind meist hervorgehoben, etwa durch '
-Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion
+                 'Großschreibung oder Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder '
-kleinerer Zahlenwerte von folgenden größeren erfolgt nicht.
+                 'Vergoldung.  \n'
-Die Zahlbuchstaben sind meist hervorgehoben, etwa durch Großschreibung oder
+                 'Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die Zahlbuchstaben nicht gekennzeichnet '
-Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder
+                 'sind und "verborgen" bleiben. Bei der einfachen Analyse werden hier die Buchstaben I(1), V(5), '
-Vergoldung. Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die
+                 'X(10), L(50), C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten Analyse wird '
-Zahlbuchstaben nicht gekennzeichnet sind und "verborgen" bleiben.
+                 '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 '
-Bei der einfachen Analyse werden hier die Buchstaben I(1),V(5),X(10),L(50),
+                 'W=10(V+V) und Y=2(I+I) berücksichtigt.  \n'
-C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten
+                 'Des Weiteren wird auch für jeden relevanten Buchstaben einzeln noch einmal die Anzahl und Summe'
-Analyse wird zunächst einmal berücksichtigt, daß im Lateinischen Alphabet
+                 ' angezeigt. Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.')
-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.
-"""
-    
-    eingabetext = Eingabe.get(1.0, END)
     text = eingabetext.rstrip()
     if text == "":
-        Ausgabe.insert(1.0, hilfetext + "\n")
+        return hilfetext
     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
@@ -2545,407 +2537,23 @@ Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.
         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))
+        ausgabetext = "|Buchstabe|Wert|Anzahl|Summe\n|-|-|-|-|\n"
-        Ausgabe.insert(1.0, "Summe erweitert(inkl. I,U): {}\n".format(sum_erweitert))
+        ausgabetext += f"|I|1|{i}|{i}|\n"
-        Ausgabe.insert(1.0, "Summe einfach(I,V,X,L,C,D,M): {}\n".format(sum_einfach))
+        ausgabetext += f"|V|5|{v}|{v*5}|\n"
-        Ausgabe.insert(1.0, "W(V+V=10):{:5}x \tSumme W: {}\n".format(w, w * 10), "gr")
+        ausgabetext += f"|X|10|{x}|{x*10}|\n"
-        Ausgabe.insert(1.0, " Y(I+I=2):{:5}x \tSumme Y: {}\n".format(y, y * 2), "gr")
+        ausgabetext += f"|L|50|{ll}|{ll*50}|\n"
-        Ausgabe.insert(1.0, "   U(V=5):{:5}x \tSumme U: {}\n".format(u, u * 5), "gr")
+        ausgabetext += f"|C|100|{c}|{c*100}|\n"
-        Ausgabe.insert(1.0, "   J(I=1):{:5}x \tSumme U: {}\n".format(j, j), "gr")
+        ausgabetext += f"|D|500|{d}|{d*500}|\n"
-        Ausgabe.insert(1.0, "  M(1000):{:5}x \tSumme M: {}\n".format(m, m * 1000), "gr")
+        ausgabetext += f"|M|1000|{m}|{m*1000}\n"
-        Ausgabe.insert(1.0, "   D(500):{:5}x \tSumme D: {}\n".format(d, d * 500), "gr")
+        ausgabetext += f"|J(=I)|1|{j}|{j}|\n"
-        Ausgabe.insert(1.0, "   C(100):{:5}x \tSumme C: {}\n".format(c, c * 100), "gr")
+        ausgabetext += f"|U(=V)|5|{u}|{u*5}|\n"
-        Ausgabe.insert(1.0, "    L(50):{:5}x \tSumme L: {}\n".format(ll, ll * 50), "gr")
+        ausgabetext += f"|Y(=I+I)|2|{y}|{y*2}|\n"
-        Ausgabe.insert(1.0, "    X(10):{:5}x \tSumme X: {}\n".format(x, x * 10), "gr")
+        ausgabetext += f"|W(=V+V)|10|{w}|{w*10}\n  \n"
-        Ausgabe.insert(1.0, "     V(5):{:5}x \tSumme V: {}\n".format(v, v * 5), "gr")
+        ausgabetext += f"Summe einfach(I,V,X,L,C,D,M): {sum_einfach}  \n"
-        Ausgabe.insert(1.0, "     I(1):{:5}x \tSumme I: {}\n".format(i, i), "gr")
+        ausgabetext += f"Summe erweitert(inkl. I,U): {sum_erweitert}  \n"
-
+        ausgabetext += f"Summe extrem(inkl.J,U,Y,W): {sum_extrem}"
-
+        return ausgabetext
-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. 
-"""
-    
-    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. 
-"""
-    
-    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). 
-"""
-    
-    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). 
-"""
-    
-    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
@@ -3249,6 +2857,391 @@ für alle Zeilenanzahlen von 2-12.""" + "\n\n")
             Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
 
 
+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. 
+"""
+
+    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. 
+"""
+
+    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). 
+"""
+
+    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). 
+"""
+
+    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 brainfuck_interpreter():
     eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()