Il codice Morse è un metodo per codificare un messaggio utilizzando punti, trattini e spazi. È ampiamente utilizzato per comunicare messaggi in segreto.
Potresti aver visto l’uso del codice morse nelle scene della marina di molti film per comunicare messaggi. Stiamo parlando dello stesso codice Morse qui, ma l’unica differenza è che scriveremo un programma Python per tradurre dall’inglese al codice Morse e viceversa.
Sommario:
codice Morse
Il codice Morse ha modelli diversi per ogni alfabeto inglese, numero, punteggiatura e caratteri non latini. Una volta che conosci i modelli di codice Morse per caratteri diversi, sarà facile codificarli e decodificarli. Puoi fare riferimento alla pagina Wikipedia del codice morse per maggiori dettagli e schemi.
In questo tutorial impareremo come codificare un semplice testo inglese in codice morse e viceversa. Utilizzeremo alfabeti, numeri e punteggiatura inglesi durante la codifica della decodifica. Se vuoi aggiungere più tipi di caratteri, puoi farlo facilmente una volta apprese le basi della codifica e della decodifica.
Una cosa da ricordare è che sia l’alfabeto maiuscolo che quello minuscolo hanno lo stesso schema di codice morse. Questo perché il codice morse viene utilizzato principalmente per la comunicazione a cui non interessano le lettere dell’alfabeto come le conversazioni quotidiane.
Entriamo nella parte di codifica per la codifica e la decodifica.
Da inglese a codice Morse
L’algoritmo per convertire il semplice testo inglese in codice Morse è semplice. Controlliamo l’algoritmo.
- Il codice Morse contiene uno spazio dopo ogni carattere e un doppio spazio dopo ogni parola.
- Quindi, quando incontriamo spazio nel testo, che è il separatore per le parole, dobbiamo aggiungere doppio spazio al risultato.
Prova a scrivere il codice in Python. Non preoccuparti, anche se non sei in grado di scriverlo completamente.
Controlliamo il codice per la codifica del testo in inglese semplice in codice morse.
# dictionary for mapping characters to morse code
CHARS_TO_MORSE_CODE_MAPPING = {
'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': '-----',
'.': '.-.-.-',
',': '--..--',
'?': '..--..',
''': '· − − − − ·',
'!': '− · − · − −',
'/': '− · · − ·',
'(': '− · − − ·',
')': '− · − − · −',
'&': '· − · · ·',
':': '− − − · · ·',
';': '− · − · − ·',
'=': '− · · · −',
'+': '· − · − ·',
'-': '− · · · · −',
'_': '· · − − · −',
'"': '· − · · − ·',
'$': '· · · − · · −',
'@': '· − − · − ·',
}
# function to encode plain English text to morse code
def to_morse_code(english_plain_text):
morse_code=""
for char in english_plain_text:
# checking for space
# to add single space after every character and double space after every word
if char == ' ':
morse_code += ' '
else:
# adding encoded morse code to the result
morse_code += CHARS_TO_MORSE_CODE_MAPPING[char.upper()] + ' '
return morse_code
morse_code = to_morse_code(
'winadmin.it produces high-quality technology & finance articles, makes tools, and APIs to help businesses and people grow.'
)
print(morse_code)
Puoi vedere l’output del codice Morse di seguito. Dovresti anche vedere un codice Morse simile nel tuo terminale se non hai cambiato il messaggio.
--. . . -.- ..-. .-.. .- .-. . .--. .-. --- -.. ..- -.-. . ... .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.-- - . -.-. .... -. --- .-.. --- --. -.-- · − · · · ..-. .. -. .- -. -.-. . .- .-. - .. -.-. .-.. . ... --..-- -- .- -.- . ... - --- --- .-.. ... --..-- .- -. -.. .- .--. .. ... - --- .... . .-.. .--. -... ..- ... .. -. . ... ... . ... .- -. -.. .--. . --- .--. .-.. . --. .-. --- .-- .-.-.-
Evviva! abbiamo il codice morse. Sai cosa viene dopo.
Prima di buttarci nel programma di decodifica, fermiamoci un attimo e pensiamo a come scrivere il codice per decodificarlo.
…
Avresti dovuto pensare di invertire il dizionario CHARS_TO_MORSE_CODE_MAPPING come uno dei passaggi. Farlo manualmente è frenetico e deve essere aggiornato ogni volta che viene modificata la mappatura originale. Scriviamo il codice per invertire il dizionario.
def reverse_mapping(mapping):
reversed = {}
for key, value in mapping.items():
reversed[value] = key
return reversed
Stiamo semplicemente invertendo le coppie chiave-valore del dato dizionario con il codice sopra. Il dizionario risultante conterrà i valori sono nuove chiavi e le chiavi come nuovi valori.
Abbiamo tutti i pezzi per decodificare il codice morse in un semplice testo inglese. Senza ulteriori indugi, decodifichiamo il codice morse.
Codice Morse in inglese
Possiamo invertire il processo di codifica del codice morse per ottenere l’algoritmo di decodifica. Vediamo l’algoritmo per decodificare il codice morse in un semplice testo inglese.
- Se incontriamo uno spazio, significa che abbiamo un carattere di codice morse completo da decodificare.
- Se il carattere del codice morse corrente è vuoto e abbiamo due spazi consecutivi, aggiungi un separatore di parole che è un singolo spazio in un testo inglese semplice.
- Se la condizione precedente è falsa, prendi il carattere decodificato dal dizionario e aggiungilo al risultato. Reimposta il carattere del codice Morse corrente.
- Se non abbiamo incontrato lo spazio, aggiungilo al carattere morse corrente.
Controlliamo il codice per l’algoritmo sopra.
def reverse_mapping(mapping):
# add function code from the previous snippet...
CHARS_TO_MORSE_CODE_MAPPING = {} # add dictionary values
MORSE_CODE_TO_CHARS_MAPPING = reverse_mapping(CHARS_TO_MORSE_CODE_MAPPING)
def to_english_plain_text(morse_code):
english_plain_text=""
current_char_morse_code=""
i = 0
while i < len(morse_code) - 1:
# checking for each character
if morse_code[i] == ' ':
# checking for word
if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
english_plain_text += ' '
i += 1
else:
# adding decoded character to the result
english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
current_char_morse_code]
current_char_morse_code=""
else:
# adding morse code char to the current character
current_char_morse_code += morse_code[i]
i += 1
# adding last character to the result
if len(current_char_morse_code) > 0:
english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
current_char_morse_code]
return english_plain_text
english_plain_text = to_english_plain_text(
'--. . . -.- ..-. .-.. .- .-. . .--. .-. --- -.. ..- -.-. . ... .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.-- - . -.-. .... -. --- .-.. --- --. -.-- · − · · · ..-. .. -. .- -. -.-. . .- .-. - .. -.-. .-.. . ... --..-- -- .- -.- . ... - --- --- .-.. ... --..-- .- -. -.. .- .--. .. ... - --- .... . .-.. .--. -... ..- ... .. -. . ... ... . ... .- -. -.. .--. . --- .--. .-.. . --. .-. --- .-- .-.-.- '
)
print(english_plain_text)
Ho fornito il codice morse generato dalla funzione di codifica. Otterremo il seguente output se eseguiamo il programma sopra.
winadmin.it PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.
Nota: l’output è nell’alfabeto maiuscolo inglese perché abbiamo usato l’alfabeto maiuscolo per la mappatura nel dizionario.
Parole finali
Abbiamo visto che l’output della funzione di decodifica è in maiuscolo. Puoi migliorare il programma facendo in modo che l’output sia così com’è nel tempo indicato tracciando le lettere minuscole e maiuscole dell’alfabeto inglese. Questo non è correlato al codice morse, poiché sia le maiuscole che le minuscole hanno lo stesso schema. Provalo, perché è più divertente programmare.
Questo è tutto per questo tutorial. Usa i programmi che abbiamo scritto quando incontri il codice morse la prossima volta.
Buona codifica 👨💻
Puoi anche vedere come creare una password casuale in Python.