14 immer seltsamere Wege, „Hello World!“ zu lösen

Einleitung

Für die Zwecke dieses Artikels ist der gesamte Code in Python.

In ihrer #48in24-Challenge geht Exercism der Frage nach, wie die Community verschiedene Coding-Challenges angeht. „Hello, World!“ ist die einfachste Übung auf Exercism und wurde als zu simpel erachtet, um ein offizielles Video dafür zu drehen. Aber ich bin mir da nicht so sicher, und dachte, es könnte Spaß machen, mir ein paar interessantere Ansätze für diese einfache Übung anzusehen!

Lerne „Hello, World!“ kennen

„Hello, World!“ ist wahrscheinlich das berühmteste Programm der Welt. Praktisch jeder, der Programmieren gelernt hat, hat es mindestens einmal geschrieben. Seine Einfachheit und die freundliche Botschaft stehen oft für den ersten Schritt in die wunderbare Welt der Programmierung.

Auf Exercism bekommst du eine Funktion namens hello, die „Goodbye, Mars!“ zurückgibt.

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

Deine Aufgabe ist es, sie so zu ändern, dass sie stattdessen „Hello, World!“ zurückgibt.

Der traditionelle Ansatz

Zuerst der einfachste Ansatz, und der, von dem Exercism hofft, dass du ihn umsetzt. Mit einer einfachen Änderung des Strings von „Goodbye, Mars!“ zu „Hello, World!“ können wir ihn jetzt getrost zurückgeben!

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

Alternative Ansätze

Ich werde diese Übung mit allen möglichen Methoden lösen, die mir einfallen.

Aus erzählerischen Gründen nenne ich diese einfache Funktion die „Maschine“, eine Maschine, deren einzige Aufgabe es ist, einen „Hello, World!“-Gruß zurückzugeben.

Schauen wir mal, wohin das führt...!

Das Join

Die Maschine kennt bereits einige der Wörter, aber sie scheint sie nicht aneinanderreihen zu können, äh, ähm, na ja, eben zu einem String zusammenzufügen.

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

Der Titel

Die Batterie der Maschine ist heute etwas schwach, denn allen Wörtern fehlt die Energie und sie werden nicht richtig großgeschrieben.

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

Die Umkehrung

Der Maschine ist der Gruß irgendwie bekannt, aber irgendetwas daran wirkt ein wenig ... rückwärts.

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

Hinweis: Reverse String ist eine hervorgehobene Übung für die #48in24-Challenge. Schau dir unbedingt die verschiedenen Ansätze an, wie man das in unterschiedlichen Sprachen macht!

Das Slice 'n Dice

Vielleicht muss bei der Maschine mal das Öl gewechselt werden, denn die normale Grußnachricht scheint etwas durcheinandergeraten zu sein.

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

Das Currying

Oh oh, einige Teile der Maschine sind im Wartungsmodus. Sie hat die Grußnachricht vergessen und kann jetzt die Nachricht nur noch Stück für Stück entgegennehmen.

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

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

Das ASCII

Du hast aus Versehen etwas Limonade über die Maschine verschüttet, und jetzt zeigt sie dir statt der üblichen Zeichen in der Nachricht nur noch diese seltsamen Zahlen.

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)

Das Wörterbuch

Du hast die Nachrichten gesehen und einen Beitrag über einen Mann, der mit einem S.O.S.-Signal gerettet wurde. „Vielleicht sollte die Maschine auch Morseschrift verstehen können!“ - dachtest du, ohne genau zu wissen, warum. Ihre einzige Aufgabe ist es schließlich, die Grußnachricht zurückzugeben...

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

Das Funktionale

Da deine aktuelle Maschine anfällig für Veränderungen und Schäden ist, beschließt du, eine kleinere, aber unveränderliche und unzerstörbare Maschine zu bauen, die genau dasselbe tut. Wann immer die reguläre Maschine nicht funktioniert oder verrücktspielt, aktiviert sie stattdessen die kleinere. Moment mal, warum benutzen wir nicht einfach von jetzt an die kleinere...

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

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

Die Permutation

Ein starkes Gewitter zog vorbei, und deine arme, unglückliche Maschine wurde vom Blitz getroffen. Sie startet noch, aber jetzt verhält sie sich seltsam. Alle Zeichen zum Zusammensetzen der Grußnachricht sind noch da, aber sie sind nicht in der richtigen Reihenfolge, und der Schaden an der Platine sorgt dafür, dass die Maschine die richtige Reihenfolge für die Nachricht nicht mehr hinbekommt. Und wie es der Zufall will, war die unglaublich zuverlässige und unzerstörbare kleinere Maschine, die du vorhin gebaut hast, tatsächlich stehlbar (ja, sie ist weg!). Deshalb beschließt du, deinen guten alten Kumpel einfach jede mögliche Art ausprobieren zu lassen, diese Buchstaben zur richtigen Nachricht zusammenzuwürfeln. Schließlich sind es nur 13 Zeichen, und die Maschine hat jede Menge Speicher. Das sollte schnell gehen...

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)

Die Suche

Du hast beschlossen, die Maschine zu aktualisieren, damit sie in verschiedenen Sprachen grüßen kann. Aber ihre EINZIGE Aufgabe ist es, „Hello, World!“ auf Englisch zu sagen, also beschließt sie in ihrer Verwirrung, unzählige Arten herunterzuladen, „Hello, World!“ zu sagen, jede mit leicht unterschiedlich großgeschriebenen Zeichen und Positionen. Das verwirrte dich, und du warst nicht sicher, welche du wählen sollst, aber zumindest sind sie alle in irgendeiner Reihenfolge. Du musst der Maschine sagen, wie die richtige Phrase lautet, damit sie die Phrase finden kann und wieder normal ist (vielleicht).

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

Dein jüngerer Bruder, der das Ganze beobachtet hat, fragte, warum du nicht einfach das ganze Chaos gelöscht und der Maschine dann die richtige Phrase gegeben hast, damit sie sie sich merkt. Du hast nicht geantwortet und ihn nur finster angestarrt.

Das Vornehme

Du beschließt zu experimentieren und die Maschine so anzupassen, dass sie sich je nach gedrückter Taste unterschiedlich verhält. Du hast darüber nachgedacht, es etwas lockerer anzugehen und mit „Hi“ zu beginnen, aber als vornehme Person beschließt du, nur die Methode hello zu verwenden und die andere zuzukleben. Du merkst, dass du ziemlich viel Zeit für solche Dinge übrig hast...

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()

Die Rekursion

Aus irgendeinem Grund hast du beschlossen, es wäre lustig, wenn die Maschine ein wenig hinterherhinkt und erst 10 Sekunden später antwortet. Dein Bruder wirft erneut die Frage nach der Logik hinter dieser Funktion auf, denn seiner Meinung nach bist du der Einzige, der die Maschine benutzt.

import time

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

Die Zufälligkeit

Plötzlich, eines Tages, hast du einfach genug von dem immer gleichen Gruß, also beschließt du, sie dich ein letztes Mal grüßen zu lassen und die Maschine endgültig in Rente zu schicken, um sie nie wieder anzufassen. Da die Maschine dir durch dick und dünn und über lange Zeit zur Seite stand, beschließt du, dieses letzte Treffen zwischen „Freunden“ dem Schicksal zu überlassen. Du schaltest sie ein letztes Mal ein und lässt sie einfach drehen...

import random

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

Das Ende

Das war eine wilde Tour durch meinen Kopf. Ich bin mir nicht sicher, ob sie nützlich war, aber sie hat definitiv Spaß gemacht.

Danke fürs Lesen und viel Spaß beim Programmieren!