Codul Morse reprezintă o metodă de a transmite mesaje prin utilizarea unor combinații de puncte, linii și spații. Acesta este frecvent utilizat pentru a comunica informații confidențiale.
Este posibil să fi observat utilizarea codului Morse în scene cu marinari din diverse filme, pentru a transmite mesaje. Aici ne referim la același cod Morse, însă vom crea un program Python capabil să convertească din limba engleză în cod Morse și invers.
Despre Codul Morse
Codul Morse include modele unice pentru fiecare literă a alfabetului englez, număr, semn de punctuație și caractere non-latine. Odată ce înțelegi aceste modele, codificarea și decodificarea devin simple. Pentru mai multe detalii și exemple, puteți consulta pagina Wikipedia dedicată codului Morse.
În acest material, vom învăța cum să transformăm texte simple în limba engleză în cod Morse și viceversa. Vom folosi litere ale alfabetului englez, cifre și semne de punctuație în timpul procesului de codificare și decodificare. Dacă doriți să adăugați mai multe tipuri de caractere, o puteți face cu ușurință după ce înțelegeți bazele procesului.
Un aspect important de reținut este că literele mari și mici au același model în codul Morse. Acest lucru se întâmplă deoarece codul Morse este folosit în primul rând pentru comunicare, unde nu este relevant dacă folosim majuscule sau minuscule, precum în conversațiile obișnuite.
Haideți să trecem la partea de programare pentru codificare și decodificare.
Conversia din engleză în cod Morse
Algoritmul de conversie a unui text simplu din engleză în cod Morse este destul de simplu. Să analizăm etapele algoritmului:
- Se creează un dicționar în care se asociază modelele codului Morse cu litere, cifre și semne de punctuație din limba engleză.
- Se parcurge textul, adăugând modelul corespunzător din codul Morse pentru fiecare caracter la rezultat.
- În codul Morse, se adaugă un spațiu după fiecare caracter și un spațiu dublu după fiecare cuvânt.
- Atunci când se întâlnește un spațiu în text, care marchează separarea cuvintelor, trebuie să adăugăm un spațiu dublu la rezultat.
- Șirul rezultat va reprezenta codul Morse dorit.
- În final, se returnează rezultatul.
Încercați să scrieți codul în Python. Nu vă faceți griji dacă nu reușiți să-l scrieți integral.
Să vedem codul pentru a transforma un text simplu din engleză în cod Morse.
# dicționar pentru asocierea caracterelor cu codul Morse
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': '-----',
'.': '.-.-.-',
',': '--..--',
'?': '..--..',
''': '· − − − − ·',
'!': '− · − · − −',
'/': '− · · − ·',
'(': '− · − − ·',
')': '− · − − · −',
'&': '· − · · ·',
':': '− − − · · ·',
';': '− · − · − ·',
'=': '− · · · −',
'+': '· − · − ·',
'-': '− · · · · −',
'_': '· · − − · −',
'"': '· − · · − ·',
'$': '· · · − · · −',
'@': '· − − · − ·',
}
# funcție pentru a codifica text simplu din engleză în cod Morse
def to_morse_code(english_plain_text):
morse_code=""
for char in english_plain_text:
# verificăm dacă este spațiu
# adăugăm spațiu simplu după fiecare caracter și spațiu dublu după fiecare cuvânt
if char == ' ':
morse_code += ' '
else:
# adăugăm codul Morse corespunzător la rezultat
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)
Rezultatul codului Morse ar trebui să fie similar cu următorul. Dacă nu ați modificat mesajul, ar trebui să vedeți un cod similar în terminalul dumneavoastră.
--. . . -.- ..-. .-.. .- .-. . .--. .-. --- -.. ..- -.-. . ... .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.-- - . -.-. .... -. --- .-.. --- --. -.-- · − · · · ..-. .. -. .- -. -.-. . .- .-. - .. -.-. .-.. . ... --..-- -- .- -.- . ... - --- --- .-.. ... --..-- .- -. -.. .- .--. .. ... - --- .... . .-.. .--. -... ..- ... .. -. . ... ... . ... .- -. -.. .--. . --- .--. .-.. . --. .-. --- .-- .-.-.-
Excelent! Am obținut codul Morse. Știm ce urmează.
Înainte de a trece la programul de decodificare, să ne oprim puțin și să ne gândim cum vom scrie codul pentru a decoda.
…
V-ați gândit probabil că unul dintre pași ar fi inversarea dicționarului CHARS_TO_MORSE_CODE_MAPPING. Efectuarea manuală a acestui lucru este laborioasă și trebuie actualizată de fiecare dată când se schimbă maparea originală. Așadar, vom scrie cod pentru a inversa dicționarul.
def reverse_mapping(mapping):
reversed = {}
for key, value in mapping.items():
reversed[value] = key
return reversed
Cu codul de mai sus, inversăm pur și simplu perechile cheie-valoare din dicționarul dat. Dicționarul rezultat va conține valorile ca noi chei și cheile ca noi valori.
Avem toate elementele necesare pentru a decoda codul Morse în text simplu în limba engleză. Să decodificăm codul Morse fără a mai amâna.
Conversia din cod Morse în engleză
Putem inversa procesul de codificare a codului Morse pentru a obține algoritmul de decodificare. Să vedem algoritmul pentru decodificarea codului Morse într-un text simplu din limba engleză.
- Se inversează dicționarul CHARS_TO_MORSE_CODE_MAPPING folosind funcția auxiliară pe care am scris-o.
- Se parcurge codul Morse, ținând evidența caracterului curent din codul Morse.
- Dacă se întâlnește un spațiu, înseamnă că avem un caracter complet în cod Morse de decodat.
- Dacă caracterul curent din codul Morse este gol și avem două spații consecutive, atunci se adaugă un separator de cuvinte, care este un spațiu simplu în textul simplu din limba engleză.
- Dacă nu se îndeplinește condiția de mai sus, atunci se obține caracterul decodat din dicționar și se adaugă la rezultat. Se resetează caracterul curent din codul Morse.
- Dacă nu s-a întâlnit un spațiu, se adaugă la caracterul curent din codul Morse.
- Dacă se întâlnește un spațiu, înseamnă că avem un caracter complet în cod Morse de decodat.
- Dacă mai există un caracter, acesta se adaugă la rezultat după decodare, folosind dicționarul.
- La final, se returnează rezultatul.
Să vedem codul pentru algoritmul de mai sus.
def reverse_mapping(mapping):
# adaugă codul funcției din fragmentul anterior...
reversed = {}
for key, value in mapping.items():
reversed[value] = key
return reversed
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': '-----',
'.': '.-.-.-',
',': '--..--',
'?': '..--..',
''': '· − − − − ·',
'!': '− · − · − −',
'/': '− · · − ·',
'(': '− · − − ·',
')': '− · − − · −',
'&': '· − · · ·',
':': '− − − · · ·',
';': '− · − · − ·',
'=': '− · · · −',
'+': '· − · − ·',
'-': '− · · · · −',
'_': '· · − − · −',
'"': '· − · · − ·',
'$': '· · · − · · −',
'@': '· − − · − ·',
}
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:
# verificăm fiecare caracter
if morse_code[i] == ' ':
# verificăm dacă e cuvânt
if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
english_plain_text += ' '
i += 1
else:
# adăugăm caracterul decodat la rezultat
english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
current_char_morse_code]
current_char_morse_code=""
else:
# adăugăm caracterul din codul Morse la caracterul curent
current_char_morse_code += morse_code[i]
i += 1
# adăugăm ultimul caracter la rezultat
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 folosit codul Morse generat de funcția de codificare. Dacă rulăm programul de mai sus, vom obține următorul rezultat.
TIPSTRICK.RO PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.
Notă: rezultatul este în alfabetul englez majuscul, deoarece am folosit alfabetul majuscul pentru asociere în dicționar.
Concluzie
Am observat că rezultatul funcției de decodificare este în majuscule. Puteți îmbunătăți programul pentru a menține formatarea originală a textului, ținând cont de majuscule și minuscule. Acest lucru nu ține de codul Morse, deoarece atât majusculele, cât și minusculele au același model. Încercați, pentru că este o provocare interesantă de programare.
Acesta este tot pentru acest tutorial. Folosiți programele pe care le-am scris atunci când vă întâlniți cu codul Morse data viitoare.
Spor la codat! 👨💻
De asemenea, puteți arunca o privire și asupra modului de a genera o parolă aleatorie în Python.