Codul Morse este o metodă de a codifica un mesaj folosind puncte, liniuțe și spații. Este folosit pe scară largă pentru a comunica mesaje în secret.
S-ar putea să fi văzut utilizarea codului morse în scenele marinei din multe filme pentru a comunica mesaje. Vorbim aici despre același cod morse, dar singura diferență este că vom scrie un program Python pentru a traduce din engleză în codul Morse și invers.
Cuprins
Codul Morse
Codul Morse are modele diferite pentru fiecare alfabet englezesc, număr, punctuație și caractere non-latine. Odată ce cunoașteți modelele de cod morse pentru diferite caractere, va fi ușor să le codificați și să le decodați. Puteți consulta pagina Wikipedia de cod morse pentru mai multe detalii și modele.
În acest tutorial, vom învăța cum să codificăm text în limba engleză simplă în cod morse și invers. Vom folosi alfabete engleze, numere și semne de punctuație în timp ce codificăm decodificarea. Dacă doriți să adăugați mai multe tipuri de caractere, o puteți face cu ușurință odată ce învățați baza de codificare și decodare.
Un lucru de reținut este că atât alfabetul majuscule, cât și literele mici au același model de cod morse. Acest lucru se datorează faptului că codul Morse este folosit în principal pentru comunicare, care nu îi pasă de cazurile alfabetice, cum ar fi conversațiile de zi cu zi.
Să intrăm în partea de codificare pentru codificare și decodare.
Din engleză în codul Morse
Algoritmul de conversie a textului în limba engleză simplă în cod morse este simplu. Să verificăm algoritmul.
- Codul Morse conține un spațiu după fiecare caracter și un spațiu dublu după fiecare cuvânt.
- Deci, atunci când întâlnim spațiu în text, care este separatorul pentru cuvinte, trebuie să adăugăm spațiu dublu rezultatului.
Încercați să scrieți codul în Python. Nu-ți face griji, chiar dacă nu ești în stare să-l scrii complet.
Să verificăm codul pentru codificarea textului simplu în limba engleză în cod 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(
'tipstrick.ro produces high-quality technology & finance articles, makes tools, and APIs to help businesses and people grow.'
)
print(morse_code)
Puteți vedea rezultatul codului Morse mai jos. Ar trebui să vedeți și un cod morse similar în terminalul dvs. dacă nu ați schimbat mesajul.
--. . . -.- ..-. .-.. .- .-. . .--. .-. --- -.. ..- -.-. . ... .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.-- - . -.-. .... -. --- .-.. --- --. -.-- · − · · · ..-. .. -. .- -. -.-. . .- .-. - .. -.-. .-.. . ... --..-- -- .- -.- . ... - --- --- .-.. ... --..-- .- -. -.. .- .--. .. ... - --- .... . .-.. .--. -... ..- ... .. -. . ... ... . ... .- -. -.. .--. . --- .--. .-.. . --. .-. --- .-- .-.-.-
Ura! avem codul morse. Știi ce urmează după.
Înainte de a sări în programul de decodare, să ne oprim puțin și să ne gândim cum să scriem cod pentru a-l decoda.
…
Ar fi trebuit să vă gândiți să inversați dicționarul CHARS_TO_MORSE_CODE_MAPPING ca unul dintre pași. Efectuarea manuală este agitată și trebuie actualizată ori de câte ori maparea originală este schimbată. Să scriem cod pentru a inversa dicționarul.
def reverse_mapping(mapping):
reversed = {}
for key, value in mapping.items():
reversed[value] = key
return reversed
Doar inversăm perechile cheie-valoare ale dicționarului dat cu codul de mai sus. Dicționarul rezultat va conține valori sunt chei noi și chei ca valori noi.
Avem toate piesele pentru a decoda codul morse în text simplu în engleză. Fără alte prelungiri, să decodificăm codul morse.
Cod Morse în engleză
Putem inversa procesul de codificare a codului Morse pentru a obține algoritmul de decodare. Să vedem algoritmul pentru decodarea codului morse în text simplu în limba engleză.
- Dacă întâlnim un spațiu, înseamnă că avem un caracter complet de cod Morse de decodat.
- Dacă caracterul curent de cod morse este gol și avem două spații consecutive, atunci adăugați un separator de cuvinte care este un singur spațiu în textul simplu în limba engleză.
- Dacă condiția de mai sus este falsă, atunci obțineți caracterul decodat din dicționar și adăugați-l la rezultat. Resetați caracterul curent de cod morse.
- Dacă nu am întâlnit spațiu, adăugați-l la caracterul morse curent.
Să verificăm codul pentru algoritmul de mai sus.
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)
Am dat codul morse care este generat din funcția de codificare. Vom obține următorul rezultat dacă rulăm programul de mai sus.
tipstrick.ro PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.
Notă: rezultatul este în alfabetul majuscul englez, deoarece am folosit alfabetul majuscul pentru mapare în dicționar.
Cuvinte finale
Am văzut că rezultatul funcției de decodare este cu majuscule. Puteți îmbunătăți programul făcând ieșirea așa cum este în timpul dat, urmărind literele mici și mari ale alfabetului englez. Acest lucru nu este legat de codul Morse, deoarece atât litere mari, cât și minuscule au același model. Încercați, deoarece este mai distractiv de codat.
Asta e pentru acest tutorial. Utilizați programele pe care le-am scris când întâlniți codul Morse data viitoare.
Codare fericită 👨💻
De asemenea, puteți vedea cum să creați o parolă aleatorie în Python.