From 7d802c2bea5496e999bf22c1c4aadf748cea1834 Mon Sep 17 00:00:00 2001 From: "M. Heiser" Date: Mon, 4 Apr 2022 21:27:13 +0200 Subject: [PATCH] =?UTF-8?q?Morsealphabet=20um=20Umlaute=20und=20Zahlen=20e?= =?UTF-8?q?rweitert.=20Bessere=20Namen=20f=C3=BCr=20Variablen.=20guess=5Fc?= =?UTF-8?q?hars=20in=20=C3=BCbergeordnete=20Funktion=20verpackt.=20So=20ka?= =?UTF-8?q?nn=20die=20untergeordnete=20rekursive=20Funktion=20auf=20ein=20?= =?UTF-8?q?lokales=20Array=20zur=C3=BCckgreifen,=20das=20die=20=C3=BCberge?= =?UTF-8?q?ordnete=20Funktion=20als=20R=C3=BCckgabewert=20ausgibt.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Neue Funktion: guess_vocabs_BUT_AWESOME, braucht nur noch ca. 30 Sekunden (statt ursprünglich 4h). Problem an der ursprünglichen Funktion: sie ist immer wieder von neuem durch die (fast gesamte) Wortliste gelaufen, um zu prüfen, ob ein Buchstabensalat Sinn ergibt (schätzungsweise 10.000-100.000 Mal für die 3500 Buchstabensalate, die im ersten Schritt aus dem Morsecode entstanden sind). Die neue Funktion überprüft systematisch (von hinten nach vorne länger werdende) Morseschnipsel darauf, ob sie sich zu sinnvollen Worten arrangieren lassen und merkt sich das. Lässt sich in einem Schnipsel ein bisher noch nicht gefundenes Wort finden, wird dieses mit allen Phrasen (Wortkombinationen) kombiniert, die sich aus dem Rest des Schnipsels bilden lassen. --- main.py | 128 ++++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 92 insertions(+), 36 deletions(-) diff --git a/main.py b/main.py index 7fa3361..adca94c 100644 --- a/main.py +++ b/main.py @@ -25,56 +25,112 @@ alphabet = [["A", ".-"], ["W", ".--"], ["X", "-..-"], ["Y", "-.--"], - ["Z", "--.."]] - -dictDE_file = open("wordlist-german.txt", "r") -dictEN_file = open("wordlist-english.txt", "r") - -reader = csv.reader(dictDE_file) -dictDE = [row[0].upper() for row in reader] -reader = csv.reader(dictEN_file) -dictEN = [row[0].upper() for row in reader] -dictionary = dictEN + ["Z", "--.."], + ["Ä", ".-.-"], + ["Ö", "---."], + ["Ü", "..--"], + ["ẞ", "...--.."], + [" ", " "], + ["0", "-----"], + ["1", ".----"], + ["2", "..---"], + ["3", "...--"], + ["4", "....-"], + ["5", "....."], + ["6", "-...."], + ["7", "--..."], + ["8", "---.."], + ["9", "----."]] morse_cipher = "..-..--..-......-" -def latin_to_morse(word): +def latin_to_morse(expression, delimiter=""): # expression: zu übersetzendes Wort result = "" - for letter in word: + for letter in expression: for latin, morse in alphabet: if letter == latin: result += morse + result += delimiter return result def guess_chars(morse_text, plain_text=""): - if morse_text == "": - char_guesses.append(plain_text) - else: - for latin, morse in alphabet: - if morse == morse_text[0:len(morse)]: - guess_chars(morse_text[len(morse):len(morse_text)], (plain_text + latin)) + def recursion(morse_text, plain_text=""): # morse_text = zu zerlegender Morse-Salat + if morse_text == "": + char_guesses.append(plain_text) + else: + for latin, morse in alphabet: + if morse == morse_text[0:len(morse)]: + recursion(morse_text[len(morse):len(morse_text)], (plain_text + latin)) + char_guesses = [] + recursion(morse_text, plain_text) + return char_guesses -def guess_vocabs(word, phrase=""): - if word == "": + +def guess_vocabs(query, phrase=""): # query = zu zerlegender Buchstabensalat + if query == "": vocab_guesses.append(phrase) else: for vocab in dictionary: - if vocab == word[0:len(vocab)]: - guess_vocabs(word[len(vocab):len(word)], (phrase + vocab + " ")) - - -char_guesses = [] -guess_chars(morse_cipher) -print("Chars guessed. char_guesses complete.") - -guess_list_length = len(char_guesses) -for index, word in enumerate(char_guesses): - print("(", index, "/", guess_list_length, ") - ", word, "...", end="") - vocab_guesses = [] - guess_vocabs(word) - print("\r", end="") - if vocab_guesses: - print("Found something: ", vocab_guesses) + if vocab == query[0:len(vocab)]: + guess_vocabs(query[len(vocab):len(query)], (phrase + vocab + " ")) + + +def wordlist_to_morse(dictionary_latin): # dictionary_latin = einsprachiges Wörterbuch (Wörterbuch) + result = [] + for entry in dictionary_latin: + result.append([latin_to_morse(entry), entry]) + return result + + +def guess_vocabs_BUT_AWESOME(cipher, dictionary): # cipher: zu entschlüsselnde Chiffre, dictionary: Wortliste im Morsecode + length = len(cipher) + phrase_kit = [[] for x in range(length + 2, 0, -1)] + phrase_kit[length + 1] = " " + print(phrase_kit) + for i in range(length, 0, -1): # vom hintersten Buchstaben an nach vorne wird die Chiffre in immer längere Schnipsel gehackt + query = cipher[i - 1:length] # query: Schnipsel der Chiffre wird auf sinnvolle Worte getestet + for vocab in dictionary: + if vocab[0] == query[0:len(vocab[0])]: # wird ein passendes Wort gefunden und gibt es im phrase-kit Worte, die das gefundene Wort zur Länge des zu prüfenden Wortes ergänzen... + print("i = ", i, " Appending to ", vocab[1]) + for phrase in phrase_kit[i + len(vocab[0])]: + phrase_kit[i].append(vocab[1] + " " + phrase) + return phrase_kit + + +def deciphering_1(): + char_guesses = [] + guess_chars(morse_cipher) + print("Chars guessed. char_guesses complete.") + + guess_list_len = len(char_guesses) + for index, word in enumerate(char_guesses): + print("(", index, "/", guess_list_len, ") - ", word, "...", end="") + vocab_guesses = [] + guess_vocabs(word) + print("\r", end="") + if vocab_guesses: + print("Found something: ", vocab_guesses) + + +dictDE_file = open("wordlist-german.txt", "r") +dictEN_file = open("wordlist-english.txt", "r") + +#reader = csv.reader(dictDE_file) +#dictDE = [row[0].upper() for row in reader] +reader = csv.reader(dictEN_file) +dictEN = [row[0].upper() for row in reader] +dictionary = dictEN +#dictionary = ["FEMINIST", "TERESA", "INA", "ES", "MIT", "SEIT", "ID"] + +dictMORSE = wordlist_to_morse(dictionary) +print("dictMORSE erstellt") +phrase_kit = guess_vocabs_BUT_AWESOME(morse_cipher, dictMORSE) +for result in phrase_kit[17]: + print(result) +for result in phrase_kit[16]: + print(result) +for result in phrase_kit[15]: + print(result)