14 formas cada vez más extrañas de resolver Hello World!

Introducción

Para los fines de este artículo, todo el código estará en Python.

En su desafío #48in24, Exercism explora cómo la comunidad aborda distintos desafíos de programación. «Hello, World!» es el ejercicio más básico de Exercism y se consideró demasiado simple como para hacer un video oficial. Pero yo no estoy tan seguro, y pensé que podría ser divertido ver algunos enfoques más interesantes para este sencillo ejercicio.

Conoce «Hello, World!»

«Hello, World!» es probablemente el programa más famoso del mundo. Prácticamente cualquiera que haya aprendido a programar lo ha escrito al menos una vez. Su sencillez y su mensaje amistoso suelen significar el primer paso hacia el maravilloso mundo de la programación.

En Exercism, se te da una función llamada hello que devuelve «Goodbye, Mars!».

def hello():
    return 'Goodbye, Mars!'

Tu tarea es cambiarla para que devuelva «Hello, World!» en su lugar.

El enfoque tradicional

Para empezar, tenemos el enfoque más simple, y el que Exercism espera que implementes. Con solo cambiar el string de «Goodbye, Mars!» a «Hello, World!», ¡ahora podemos devolverlo sin problema!

def hello() -> str:
    return 'Hello, World'

Enfoques alternativos

Voy a resolver este ejercicio usando todos los métodos distintos que se me ocurran.

Por motivos narrativos, me referiré a esta sencilla función como la «máquina», una máquina cuyo único trabajo es devolver un saludo de «Hello, World!».

¡Veamos a dónde nos lleva esto...!

El join

La máquina ya conoce algunas de las palabras, pero parece que no logra, eh, digamos, unirlas.

def hello() -> str:
    words = ["Hello", " world!"]
    return ",".join(words)

El title

La batería de la máquina está un poco baja hoy, porque a todas las palabras les falta energía y no se les están poniendo bien las mayúsculas.

def hello() -> str:
    words = "hello, world!"
    return words.title()

La inversión

La máquina de algún modo conoce el saludo, pero algo en él se ve un poco... al revés.

def hello() -> str:
    sdrow = "!dlroW ,olleH"
    return sdrow[::-1]

Nota: Reverse String es un ejercicio destacado del desafío #48in24. ¡Recuerda revisar los distintos enfoques de cómo hacerlo en diferentes lenguajes!

El corta y trocea

Quizá la máquina necesita un cambio de aceite, porque el mensaje de saludo normal parece estar un poco desordenado.

def hello() -> str:
    w = "Holld, Werlo!"
    return f"{w[0]}{w[8]}{w[2:4]}{w[1]}{w[5:8]}{w[-2]}{w[-4:-2]}{w[4]}{w[-1]}"

El curry

Uh oh, algunas partes de la máquina están en modo mantenimiento. Olvidó el mensaje de saludo y ahora solo puede aceptar el mensaje parte por parte.

def hello(greet: str):
    def world(location: str) -> str:
        return f"{greet}, {location}!"
    return world

hello = hello("Hello")
hello("World")

El ASCII

Derramaste limonada sin querer sobre la máquina y ahora solo te muestra estos números extraños en lugar de los caracteres habituales del mensaje.

def hello() -> str:
    ascii = [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
    return ''.join(chr(value) for value in ascii)

El diccionario

Viste las noticias y un fragmento sobre un hombre rescatado usando una señal S.O.S. «¡Quizá la máquina también debería poder manejar código Morse!», pensaste, aunque no sabes bien por qué. Su único trabajo es devolver el mensaje de saludo...

def hello(morse) -> str:
    morse_code = {
        "...."  : "H",
        "."     : "e",
        ".-.."  : "l",
        "---"   : "o",
        "--..--": ",",
        "/"     : " ",
        ".--"   : "W",
        ".-."   : "r",
        "-.."   : "d",
        "-.-.--": "!"

    }
    return "".join(morse_code[value] for value in morse.split())

print(hello(".... . .-.. .-.. --- --..-- / .-- --- .-. .-.. -.. -.-.--"))

El funcional

Como tu máquina actual es propensa a cambios y daños, decides construir una máquina más pequeña, pero inmutable e indestructible, que hace exactamente lo mismo. Cada vez que la máquina normal no funcione o se comporte raro, activará la pequeña en su lugar. Espera, ¿y por qué no usamos directamente la pequeña de ahora en adelante...?

def hi() -> str:
	return "Hello, World!"

def hello() -> str:
    return hi()

La permutación

Pasó una fuerte tormenta eléctrica y tu pobre y desafortunada máquina recibió un rayo. Todavía enciende, pero ahora se comporta de forma extraña. Todos los caracteres para armar el mensaje de saludo siguen ahí, pero no están en orden, y el daño en la placa lógica hace que la máquina ya no pueda acertar con el orden del mensaje. Y para tu suerte, la máquina pequeña, increíblemente confiable e indestructible que construiste antes resultó ser robable (sí, ¡ya no está!). Así que decides dejar que tu viejo amigo pruebe todas las formas posibles de mezclar estas letras hasta dar con el mensaje correcto. Después de todo, solo son 13 caracteres y la máquina tiene mucha memoria. Esto debería ser rápido...

from itertools import permutations

def hello() -> str:
    chars = ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

    all_permutations = permutations(chars)
    for perm in all_permutations:
        if ("".join(perm) == "Hello, World!"):
            return ''.join(perm)

La búsqueda

Decidiste actualizar la máquina para que pudiera saludar en distintos idiomas. Pero su ÚNICO trabajo es decir «Hello, World!» en inglés, así que, confundida, decide descargar un montón de formas de decir «Hello, World!», cada una con caracteres en mayúscula y posiciones un poco distintas. Eso te dejó confundido, sin saber cuál elegir, pero al menos todas están en algún tipo de orden. Tienes que decirle a la máquina la forma correcta de expresarlo, para que encuentre la frase y vuelva a la normalidad (quizá).

def hello(my_fav_phrase) -> str:
    combinations = [
        "HELLO, WORLD!",
        # many many many items later,
        "hello, world!"
    ]

    lower = 0
    upper = len(combinations)
    while lower <= upper:
        mid = (lower + upper) // 2
        mid_val = combinations[mid]

        if mid_val == my_fav_phrase:
            return combinations[mid]
        elif mid_val < my_fav_phrase:
            lower = mid + 1
        else:
            high = mid - 1
    return "Error: Can't find {my_fav_phrase}"

hello("Hello, World!")

Tu hermano menor, que estuvo mirando todo el asunto, te preguntó por qué no borrabas todo ese desastre y luego le dabas a la máquina la frase correcta para que la recordara. No le respondiste y solo lo miraste con el ceño fruncido.

Con clase

Decides experimentar y ajustar la máquina para que se comporte distinto según el botón que se presione. Pensaste en hacerla un poco más informal, que empezara a decir «Hi», pero, como eres una persona con clase, decides usar siempre el método hello y tapar el otro con cinta adhesiva. Te das cuenta de que tienes bastante tiempo libre para estas cosas...

class Greeting:
    location = "World"

    def __init__(self) -> None:
        pass

    def hello(self):
        return f"Hello, {self.location}!"

    def hi(self):
        return f"Hi, {self.location}!"

salutation = Greeting()
salutation.hello()

La recursión

Por alguna razón, decidiste que sería gracioso que la máquina se retrasara un poco y solo respondiera 10 segundos más tarde. Tu hermano vuelve a preguntar cuál es la lógica detrás de esta funcionalidad, porque, según él, eres el único que usa la máquina.

import time

def hello(n=10):
    if n == 0:
        return "Hello, World!"
    else:
        time.sleep(1)
        return hello(n-1)

El azar

De repente, un día te cansas del mismo saludo una y otra vez, así que decides dejar que te salude una última vez y jubilar la máquina para siempre, sin volver a tocarla jamás. Como la máquina ha estado contigo en las buenas y en las malas durante mucho tiempo, decides dejar esta reunión final entre «amigos» en manos del destino. La enciendes una última vez y la dejas girar...

import random

def hello():
    chars = list("Helo,Wrld!")
    greeting = ""
    while (greeting != "Hello, World!"):
        greeting = "".join(random.choices(chars, k=13))
    return greeting

El final

Ese fue un recorrido salvaje por mi mente. No estoy seguro de que haya sido útil, pero sin duda fue divertido.

¡Gracias por leer y feliz programación!