Como criar um tradutor de código Morse usando Python

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.

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.

  • Crie um dicionário com os mapeamentos de padrões de código morse com alfabetos, números e pontuações em inglês.
  • Itere sobre o texto e adicione o padrão de código morse de cada caractere de texto ao resultado.
    • 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.
  • A string resultante será o código morse que precisávamos.
  • Por fim, retorne o resultado.
  •   9 WordPress WAF para evitar ameaças à segurança

    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.

      Como encontrar e baixar os melhores rostos do Apple Watch

    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.

  • Inverta o dicionário CHARS_TO_MORSE_CODE_MAPPING usando a função util que escrevemos.
  • Itere sobre o código morse e acompanhe o caractere do código morse atual.
    • 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.
  • Se houver o último caractere, adicione-o ao resultado após a decodificação usando o dicionário.
  • Devolva o resultado no final.
  • 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.

      Como funcionará o novo "bloco pornográfico" da Internet do Reino Unido

    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.