O código Morse é um método para codificar uma mensagem usando pontos, traços e espaços. É amplamente utilizado para comunicar mensagens secretamente.
Você pode ter visto o uso de código morse em cenas da marinha de muitos filmes para comunicar mensagens. Estamos falando sobre o mesmo código morse aqui, mas a única diferença é que vamos escrever um programa Python para traduzir do inglês para o código Morse e vice-versa.
últimas postagens
Código Morse
O código Morse tem padrões diferentes para cada alfabeto inglês, número, pontuação e caracteres não latinos. Depois de conhecer os padrões de código morse para diferentes caracteres, será fácil codificá-los e decodificá-los. Você pode consultar a página de código morse da Wikipedia para obter mais detalhes e padrões.
Neste tutorial, aprenderemos como codificar texto simples em inglês em código morse e vice-versa. Usaremos alfabetos, números e pontuação em inglês ao codificar a decodificação. Se você quiser adicionar mais tipos de caracteres, poderá fazê-lo facilmente depois de aprender a base de codificação e decodificação.
Uma coisa a lembrar é que os alfabetos maiúsculos e minúsculos têm o mesmo padrão de código morse. Isso ocorre porque o código morse é usado principalmente para comunicação que não se preocupa com casos de alfabeto como conversas cotidianas.
Vamos entrar na parte de codificação para codificação e decodificação.
Inglês para código Morse
O algoritmo para converter texto simples em inglês em código morse é direto. Vamos verificar o algoritmo.
- O código Morse contém um espaço após cada caractere e um espaço duplo após cada palavra.
- Então, quando encontramos espaço no texto, que é o separador de palavras, precisamos adicionar espaço duplo ao resultado.
Tente escrever o código em Python. Não se preocupe, mesmo que você não consiga escrevê-lo completamente.
Vamos verificar o código para codificar texto simples em inglês em código 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(
'etechpt.com produces high-quality technology & finance articles, makes tools, and APIs to help businesses and people grow.'
)
print(morse_code)
Você pode ver a saída do código morse abaixo. Você também deve ver um código morse semelhante em seu terminal se não tiver alterado a mensagem.
--. . . -.- ..-. .-.. .- .-. . .--. .-. --- -.. ..- -.-. . ... .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.-- - . -.-. .... -. --- .-.. --- --. -.-- · − · · · ..-. .. -. .- -. -.-. . .- .-. - .. -.-. .-.. . ... --..-- -- .- -.- . ... - --- --- .-.. ... --..-- .- -. -.. .- .--. .. ... - --- .... . .-.. .--. -... ..- ... .. -. . ... ... . ... .- -. -.. .--. . --- .--. .-.. . --. .-. --- .-- .-.-.-
Viva! temos o código morse. Você sabe o que vem depois.
Antes de entrar no programa de decodificação, vamos parar um pouco e pensar em como escrever código para decodificá-lo.
…
Você deveria ter pensado em reverter o dicionário CHARS_TO_MORSE_CODE_MAPPING como uma das etapas. Fazê-lo manualmente é agitado e precisa ser atualizado sempre que o mapeamento original for alterado. Vamos escrever código para reverter o dicionário.
def reverse_mapping(mapping):
reversed = {}
for key, value in mapping.items():
reversed[value] = key
return reversed
Estamos apenas invertendo os pares chave-valor do dicionário fornecido com o código acima. O dicionário resultante conterá valores como novas chaves e chaves como novos valores.
Temos todas as peças para decodificar o código morse em texto simples em inglês. Sem mais delongas, vamos decodificar o código morse.
Código Morse para inglês
Podemos reverter o processo de codificação do código morse para obter o algoritmo de decodificação. Vamos ver o algoritmo para decodificar o código morse em texto simples em inglês.
- Se encontrarmos um espaço, significa que temos um caractere de código morse completo para decodificar.
- Se o caractere do código morse atual estiver vazio e tivermos dois espaços consecutivos, adicione um separador de palavras que seja um único espaço em texto simples em inglês.
- Se a condição acima for falsa, obtenha o caractere decodificado do dicionário e adicione-o ao resultado. Redefina o caractere de código morse atual.
- Se não encontrarmos espaço, adicione-o ao caractere morse atual.
Vamos verificar o código para o algoritmo acima.
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)
Eu dei o código morse que é gerado a partir da função de codificação. Obteremos a seguinte saída se executarmos o programa acima.
etechpt.com PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.
Observação: a saída está no alfabeto maiúsculo inglês porque usamos o alfabeto maiúsculo para mapeamento no dicionário.
Palavras finais
Vimos que a saída da função de decodificação está em letras maiúsculas. Você pode melhorar o programa fazendo a saída como está no tempo determinado, rastreando as letras maiúsculas e minúsculas do alfabeto inglês. Isso não está relacionado ao código morse, pois tanto as maiúsculas quanto as minúsculas têm o mesmo padrão. Experimente, pois é mais divertido codificar.
Isso é tudo para este tutorial. Use os programas que escrevemos quando você encontrar código morse na próxima vez.
Boa codificação 👨💻
Você também pode ver como criar uma senha aleatória em Python.