Descubra como criar um tradutor de código Morse em Python!

Por

O código Morse, um método engenhoso de codificação de mensagens, utiliza pontos, traços e espaços como elementos fundamentais. Sua aplicação é notável na comunicação secreta, servindo como uma ferramenta valiosa para transmitir informações de maneira discreta e eficiente.

Em inúmeros filmes, especialmente aqueles que retratam cenas navais, é possível observar o uso do código Morse para comunicação. Aqui, exploraremos este mesmo código, mas com uma abordagem inovadora: desenvolveremos um programa em Python capaz de traduzir mensagens do inglês para o código Morse, e vice-versa.

O que é Código Morse?

O código Morse é composto por padrões distintos que representam cada letra do alfabeto inglês, números, sinais de pontuação e caracteres não latinos. Ao dominar estes padrões, a codificação e decodificação de mensagens torna-se uma tarefa intuitiva. Para uma exploração mais profunda e detalhes sobre os padrões, a página do código Morse na Wikipédia é um excelente recurso.

Neste guia, vamos focar na conversão de texto simples em inglês para código Morse, e vice-versa, utilizando alfabetos, números e pontuação comuns. Caso deseje expandir o conjunto de caracteres suportados, a base que você aprenderá aqui permitirá adicionar outros facilmente.

É importante ressaltar que o código Morse não distingue entre letras maiúsculas e minúsculas; ambas são representadas pelo mesmo padrão. Isso reflete o fato de que o código Morse é primariamente utilizado para comunicação onde a capitalização das letras não é relevante, diferentemente das conversas cotidianas.

Agora, vamos mergulhar na codificação e decodificação.

Tradução de Inglês para Código Morse

A lógica para transformar um texto em inglês para código Morse é bastante direta. Abaixo, detalhamos o algoritmo:

  • Inicialmente, criaremos um dicionário que associa cada letra, número e sinal de pontuação em inglês ao seu respectivo padrão em código Morse.
  • Em seguida, percorreremos cada caractere do texto, adicionando o código Morse correspondente ao resultado.
    • No código Morse, cada caractere é seguido por um espaço, e cada palavra é separada por um espaço duplo.
    • Portanto, ao encontrar um espaço no texto original, o que indica o fim de uma palavra, adicionaremos um espaço duplo no resultado.
  • A sequência resultante constituirá o código Morse da mensagem original.
  • Finalmente, retornaremos o código Morse gerado.

Experimente implementar este algoritmo em Python! Não se preocupe se não conseguir completar tudo de imediato.

Vamos analisar o código que converte texto simples em inglês para código Morse:

# Dicionário que associa caracteres ao código 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': '-----',
    '.': '.-.-.-',
    ',': '--..--',
    '?': '..--..',
    '\'': '· − − − − ·',
    '!': '− · − · − −',
    '/': '− · · − ·',
    '(': '− · − − ·',
    ')': '− · − − · −',
    '&': '· − · · ·',
    ':': '− − − · · ·',
    ';': '− · − · − ·',
    '=': '− · · · −',
    '+': '· − · − ·',
    '-': '− · · · · −',
    '_': '· · − − · −',
    '"': '· − · · − ·',
    '$': '· · · − · · −',
    '@': '· − − · − ·',
}

# Função para codificar texto simples em inglês para código Morse
def to_morse_code(english_plain_text):
    morse_code = ""
    for char in english_plain_text:
        # Verificar se o caractere é um espaço
        if char == ' ':
            morse_code += '  '
        else:
            # Adicionar o código Morse codificado ao resultado
            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)

O código Morse resultante é apresentado abaixo. Se você executar o código acima sem alterações na mensagem, deverá obter um resultado similar em seu terminal.

--. . . -.- ..-. .-.. .- .-. .   .--. .-. --- -.. ..- -.-. . ...   .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.--   - . -.-. .... -. --- .-.. --- --. -.--   · − · · ·   ..-. .. -. .- -. -.-. .   .- .-. - .. -.-. .-.. . ... --..--   -- .- -.- . ...   - --- --- .-.. ... --..--   .- -. -..   .- .--. .. ...   - ---   .... . .-.. .--.   -... ..- ... .. -. . ... ... . ...   .- -. -..   .--. . --- .--. .-.. .   --. .-. --- .-- .-.-.-

Ótimo! Conseguimos gerar o código Morse. Agora, o próximo passo natural é aprender a decodificá-lo.

Antes de iniciarmos o processo de decodificação, vamos parar um instante e refletir sobre como abordar a escrita do código para essa finalidade.

…

Uma das etapas cruciais deve ser a inversão do dicionário `CHARS_TO_MORSE_CODE_MAPPING`. Fazer isso manualmente seria um processo repetitivo, que exigiria atualizações sempre que o mapeamento original fosse alterado. Vamos criar uma função para automatizar essa inversão:

def reverse_mapping(mapping):
    reversed_mapping = {}
    for key, value in mapping.items():
        reversed_mapping[value] = key
    return reversed_mapping

Com este código, invertemos os pares chave-valor do dicionário, transformando os valores em chaves e as chaves em valores. Agora, temos todas as ferramentas para decodificar o código Morse de volta para texto simples em inglês.

Tradução de Código Morse para Inglês

Para desenvolver o algoritmo de decodificação, vamos inverter o processo de codificação. Abaixo, apresentamos o algoritmo que converte código Morse para texto simples em inglês:

  • Começaremos invertendo o dicionário `CHARS_TO_MORSE_CODE_MAPPING` utilizando a função auxiliar que criamos.
  • Em seguida, percorreremos o código Morse, mantendo o controle do caractere Morse atual.
    • Quando um espaço é detectado, significa que temos um código Morse completo para ser decodificado.
      • Se o código Morse atual estiver vazio e houver dois espaços consecutivos, isso indica uma separação entre palavras, adicionando um único espaço ao resultado final.
      • Caso contrário, obtemos o caractere decodificado do dicionário e o adicionamos ao resultado, reiniciando o código Morse atual.
    • Se não encontrarmos um espaço, adicionamos o caractere ao código Morse atual.
  • Finalmente, se ainda houver um caractere Morse pendente, decodificamo-lo e o adicionamos ao resultado.
  • No final, retornamos o texto simples em inglês.

Vamos conferir o código que implementa o algoritmo apresentado:

def reverse_mapping(mapping):
  # Código da função do snippet anterior...
    reversed_mapping = {}
    for key, value in mapping.items():
        reversed_mapping[value] = key
    return reversed_mapping

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:
        if morse_code[i] == ' ':
            if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
                english_plain_text += ' '
                i += 1
            else:
                english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
                    current_char_morse_code]
                current_char_morse_code = ""
        else:
            current_char_morse_code += morse_code[i]
        i += 1
    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)

Ao fornecer o código Morse gerado pela função de codificação como entrada, obteremos a seguinte saída:

etechpt.com PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.

Importante notar que a saída é em letras maiúsculas, pois o dicionário utilizado para mapeamento também usa letras maiúsculas.

Considerações Finais

Como vimos, a função de decodificação retorna o texto em letras maiúsculas. Um possível aprimoramento seria preservar as letras maiúsculas e minúsculas da mensagem original. Embora isso não tenha relação direta com o código Morse, onde maiúsculas e minúsculas são representadas pelo mesmo padrão, seria um excelente exercício de programação. Explore essa possibilidade e divirta-se programando!

Este é o resumo do tutorial. Utilize os programas criados aqui sempre que se deparar com código Morse.

Feliz programação! 👨‍💻

E se tiver curiosidade, explore como criar senhas aleatórias em Python.