14 façons de plus en plus étranges de résoudre Hello World!

Introduction

Dans le cadre de cet article, tout le code sera en Python.

Dans leur défi #48in24, Exercism explore comment la communauté aborde différents défis de programmation. « Hello, World! » est l'exercice le plus basique sur Exercism et a été jugé trop simple pour qu'une vidéo officielle lui soit consacrée. Mais je ne suis pas si sûr, et j'ai pensé que ce serait amusant de regarder quelques approches plus intéressantes de ce simple exercice !

Fais connaissance avec « Hello, World! »

« Hello, World! » est probablement le programme le plus célèbre au monde. Pratiquement toute personne qui a appris à coder l'a écrit au moins une fois. Sa simplicité et son message convivial marquent souvent le premier pas dans le monde merveilleux de la programmation.

Sur Exercism, on te fournit une fonction nommée hello qui renvoie « Goodbye, Mars! ».

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

Ta tâche est de la modifier pour qu'elle renvoie « Hello, World! » à la place.

L'approche traditionnelle

Pour commencer, nous avons l'approche la plus simple, et celle qu'Exercism espère que tu implémenteras. Avec un simple changement de la string, de « Goodbye, Mars! » à « Hello, World! », on peut maintenant la renvoyer sans problème !

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

Approches alternatives

Je vais résoudre cet exercice en utilisant toutes les méthodes variées auxquelles j'ai pu penser.

Pour les besoins du récit, je vais appeler cette simple fonction la « machine », une machine dont l'unique tâche est de renvoyer un salut « Hello, World! ».

Voyons où cela nous mène... !

Le join

La machine connaît déjà certains des mots, mais elle n'arrive pas à... euh... les assembler.

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

Le titre

La batterie de la machine est un peu faible aujourd'hui, car tous les mots manquent d'énergie et ne prennent pas correctement leurs majuscules.

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

L'inversion

La machine connaît tant bien que mal le salut, mais quelque chose semble un peu... à l'envers.

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

Note : Reverse String est un exercice à l'honneur du défi #48in24. N'oublie pas d'aller voir les différentes approches pour le faire dans divers langages !

Le découpage

La machine a peut-être besoin d'une vidange, car le message d'accueil normal semble un peu mélangé.

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]}"

La curryfication

Oh oh, certaines parties de la machine sont en mode maintenance. Elle a oublié le message de salutation et ne peut plus désormais accepter le message que partie par partie.

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

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

L'ASCII

Tu as accidentellement renversé de la limonade sur la machine, et maintenant elle ne t'affiche que ces étranges nombres à la place des caractères habituels du message.

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)

Le dictionnaire

Tu as regardé les informations et tu as vu un extrait sur un homme secouru grâce à un signal S.O.S. « Peut-être que la machine devrait aussi pouvoir gérer le code Morse ! » as-tu pensé, sans trop savoir pourquoi. Son unique tâche est de renvoyer le message de salutation...

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(".... . .-.. .-.. --- --..-- / .-- --- .-. .-.. -.. -.-.--"))

Le fonctionnel

Avec ta machine actuelle sujette aux changements et aux dégâts, tu décides de construire une machine plus petite, mais immuable et indestructible, qui fait exactement la même chose. Chaque fois que la machine habituelle ne fonctionne pas ou fait des siennes, elle activera la plus petite à la place. Attends, pourquoi ne pas simplement utiliser la petite à partir de maintenant...

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

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

La permutation

Un fort orage est passé et ta pauvre machine malchanceuse a été frappée par la foudre. Elle s'allume encore, mais elle se comporte bizarrement maintenant. Tous les caractères pour assembler le message de salutation sont toujours là, mais ils ne sont pas dans l'ordre, et les dégâts sur la carte logique signifient que la machine n'arrive plus à remettre le message dans le bon ordre. Et comme par malchance, la machine plus petite, incroyablement fiable et indestructible, que tu avais construite plus tôt, était en fait volable (oui, elle a disparu !). Par conséquent, tu décides de laisser ton bon vieux compagnon essayer toutes les façons possibles de mélanger ces lettres pour former le bon message. Après tout, cela ne fait que 13 caractères et la machine a beaucoup de mémoire. Cela devrait être rapide...

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 recherche

Tu as décidé de mettre à jour la machine pour lui permettre de saluer dans différentes langues. Mais son UNIQUE tâche est de dire « Hello, World! » en anglais, alors dans sa confusion, elle décide de télécharger un nombre incalculable de façons de dire « Hello, World! », chacune avec des majuscules et un placement légèrement différents. Cela t'a laissé perplexe, sans savoir laquelle choisir, mais au moins elles sont toutes dans un certain ordre. Tu dois indiquer à la machine la bonne façon de formuler la phrase, pour qu'elle puisse la trouver et redevenir normale (peut-être).

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!")

Ton petit frère, qui a regardé toute la scène, t'a demandé pourquoi tu n'avais pas simplement tout supprimé, ce fouillis, puis donné à la machine la bonne phrase à retenir. Tu n'as pas répondu et tu t'es contenté de le fusiller du regard.

La classe

Tu décides d'expérimenter et de modifier la machine pour qu'elle se comporte différemment selon le bouton pressé. Tu as pensé à la rendre plus décontractée, en commençant à dire « Hi », mais comme tu es une personne classe, tu décides de n'utiliser toujours que la méthode hello et de scotcher l'autre. Tu réalises que tu as vraiment beaucoup de temps à perdre pour ce genre de choses...

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 récursion

Pour une raison quelconque, tu as décidé que ce serait drôle si la machine prenait un peu de retard et ne répondait que 10 secondes plus tard. Ton frère soulève une fois de plus la question de la logique derrière cette fonctionnalité, car selon lui, tu es le seul à utiliser la machine.

import time

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

L'aléatoire

Soudain, un jour, tu te lasses du même salut encore et encore, alors tu décides de la laisser te saluer une dernière fois et de mettre la machine à la retraite pour de bon, sans jamais y retoucher. Comme la machine t'a accompagné dans les bons comme dans les mauvais moments, et ce depuis longtemps, tu décides de laisser cette dernière rencontre entre « amis » entre les mains du destin. Tu l'allumes une dernière fois et tu la laisses tourner...

import random

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

La fin

C'était un tour sauvage dans mon esprit. Je ne suis pas sûr que ce soit utile, mais c'était vraiment amusant.

Merci d'avoir lu et bon code !