En este post de programación en Python te mostraré cómo codificar y decodificar código Morse. Es decir, hacer un programa que lea una cadena y la transforme a Morse, o la operación contraria, leer una cadena Morse y decodificarla a texto.

De modo que la final haremos un programa en Python que convierte la palabra PYTHON a .--. -.-- - .... --- -. y lo contrario.

Traductor Morse

Comencemos viendo las equivalencias de cada letra del texto a su representación Morse. Me he dado a la tarea de escribir los códigos ASCII y sus equivalencias:

Signo,Código
A,.-
B,-...
C,-.-.
CH,----
D,-..
E,.
F,..-.
G,--.
H,....
I,..
J,.---
K,-.-
L,.-..
M,--
N,-.
Ñ,--.--
O,---
P,.--.
Q,--.-
R,.-.
S,...
T,-
U,..-
V,...-
W,.--
X,-..-
Y,-.--
Z,--..
0,-----
1,.----
2,..---
3,...--
4,....-
5,.....
6,-....
7,--...
8,---..
9,----.
.,.-.-.-
",",--..--
:,---...
?,..--..
',.----.
-,-....-
/,-..-.
comilla doble,.-..-.
@,.--.-.
=,-...-
!,−.−.−−

Ahora lo único que hay que hacer en el programa es pasar estas equivalencias a una estructura de datos como un arreglo o diccionario que nos permita buscar el ASCII de un Morse, y el Morse de un ASCII.

Una vez que tengamos la estructura de datos vamos a hacer funciones que, dado un carácter ASCII, devuelve su codificación Morse. Y lo mismo para la operación contraria.

Finalmente para pasar de texto a Morse y viceversa vamos a hacer unas funciones que recibirán cadenas (o palabras, como quieras llamarle), se van a recorrer todas y cada unas de las letras de la misma y se van a ir codificando con las funciones anteriormente descritas.

Verás que será relativamente sencillo; así que manos a la obra.

Equivalencias

He colocado las equivalencias en un diccionario de Python. Si quieres un programa mucho más rápido (ni siquiera se nota la velocidad, créeme) puedes hacer dos diccionarios: uno en donde las claves sean los ASCII, y otros en donde las claves sean los Morse.

equivalencias = {
    "A": ".-",
    "B": "-...",
    "C": "-.-.",
    "CH": "----",
    "D": "-..",
    "E": ".",
    "F": "..-.",
    "G": "--.",
    "H": "....",
    "I": "..",
    "J": ".---",
    "K": "-.-",
    "L": ".-..",
    "M": "--",
    "N": "-.",
    "Ñ": "--.--",
    "O": "---",
    "P": ".--.",
    "Q": "--.-",
    "R": ".-.",
    "S": "...",
    "T": "-",
    "U": "..-",
    "V": "...-",
    "W": ".--",
    "X": "-..-",
    "Y": "-.--",
    "Z": "--..",
    "0": "-----",
    "1": ".----",
    "2": "..---",
    "3": "...--",
    "4": "....-",
    "5": ".....",
    "6": "-....",
    "7": "--...",
    "8": "---..",
    "9": "----.",
    ".": ".-.-.-",
    ",": "--..--",
    ":": "---...",
    "?": "..--..",
    "'": ".----.",
    "-": "-....-",
    "/": "-..-.",
    "\"": ".-..-.",
    "@": ".--.-.",
    "=": "-...-",
    "!": "−.−.−−",
}

Codificando a Morse

Como mencioné anteriormente, necesitamos una función para convertir una letra a Morse y después invocar a esa función por cada letra de la cadena a codificar.

El código Python en donde se hace la conversión de texto a Morse queda así:

def caracter_plano_a_morse(caracter):
    if caracter in equivalencias:
        return equivalencias[caracter]
    else:
        # Si no existe, regresamos una cadena vacía
        return ""


def codificar_morse(texto_plano):
    # A mayúsculas para evitar hacer más comparaciones
    texto_plano = texto_plano.upper()
    morse = ""  # Aquí alojamos el resultado
    for caracter in texto_plano:
        # Por cada carácter, buscamos su equivalencia
        caracter_codificado = caracter_plano_a_morse(caracter)
        # Lo concatenamos al resultado, además de agregar un espacio
        morse += caracter_codificado + " "
    return morse

Los comentarios explican el funcionamiento del programa. Estamos dividiendo las tareas para que el código sea más fácil de entender. Ahora es momento de ver cómo transformar de Morse a texto plano.

De texto a Morse con Python

Las funciones serán muy parecidas, solo cambiará la parte en donde buscamos la equivalencia pues ahora no buscaremos por clave del diccionario, sino por valor.

def morse_a_caracter_plano(morse):
    for caracter in equivalencias:
        if equivalencias[caracter] == morse:
            return caracter
    # Si no encontramos equivalencia, regresamos una cadena vacía
    return ""


def decodificar_morse(morse):
    texto_plano = ""  # Aquí alojamos el resultado
    for caracter_morse in morse.split(" "):
        # Por cada carácter, buscamos su equivalencia
        caracter_plano = morse_a_caracter_plano(caracter_morse)
        # Lo concatenamos al resultado.
        texto_plano += caracter_plano
    return texto_plano

Codificando y decodificando

Ya tenemos las funciones, ahora es momento de usarlas. Como ejemplo tenemos lo siguiente:

palabra = "PYTHON"
print("Codificado:")
codificado = codificar_morse(palabra)
print(codificado)
print("Decodificado:")
decodificado = decodificar_morse(codificado)
print(decodificado)

La función que transforma a Morse recibe la palabra original y la devuelve codificada. La función que decodifica el Morse recibe la cadena modificada y la devuelve en texto plano.

Obviamente tú puedes adaptar todo esto a tus necesidades.

Poniendo todo junto

He separado las equivalencias y las funciones del programa así que en total son dos archivos que componen el código fuente, mismo que te dejaré en mi GitHub.

Recuerda que en mi blog tengo más contenido de Python y que he hecho el mismo traductor en C y Java.