Extra¶

Deze pagina bevat uitvoerbare code.

Potjeslatijn¶

Opdracht: Potjeslatijn

Stap 1: `piglet_latin(s)`¶

def piglet_latin(s):
    """Vertaalt het woord s naar potjeslatijn, met hoogstens één beginmedeklinker."""
    if s == "":
        return ""
    elif s[0] in "aeiou":
        return s + "hee"
    else:
        return s[1:] + s[0] + "ee"


assert piglet_latin("") == ""
assert piglet_latin("aap") == "aaphee"
assert piglet_latin("noot") == "ootnee"
assert piglet_latin("straat") == "traatsee"

Stap 2: `initial_consonants(s)`¶

def initial_consonants(s):
    """Geeft de medeklinkers waarmee s begint."""
    if s == "" or s[0] in "aeiou":
        return ""
    else:
        return s[0] + initial_consonants(s[1:])


assert initial_consonants("straat") == "str"
assert initial_consonants("noot") == "n"
assert initial_consonants("aap") == ""
assert initial_consonants("") == ""

Stap 3: `pig_latin(s)`¶

De y gevolgd door een medeklinker telt als klinker; die tak staat daarom vóór de aanroep van initial_consonants. Een y gevolgd door een klinker is voor initial_consonants gewoon een medeklinker.

def pig_latin(s):
    """Vertaalt het woord s naar potjeslatijn."""
    if s == "":
        return ""
    elif s[0] in "aeiou":
        return s + "hee"
    elif s[0] == "y" and len(s) > 1 and s[1] not in "aeiou":
        return s + "hee"
    else:
        start = initial_consonants(s)
        return s[len(start) :] + start + "ee"


assert pig_latin("") == ""
assert pig_latin("aap") == "aaphee"
assert pig_latin("noot") == "ootnee"
assert pig_latin("straat") == "aatstree"
assert pig_latin("ypsilon") == "ypsilonhee"
assert pig_latin("yoghurt") == "oghurtyee"

Stap 4: `back_to_front(s)`¶

De recursieve aanroep krijgt een string die even lang is als s. De recursie stopt omdat er bij elke aanroep één medeklinker minder aan het eind staat; dat werkt alleen als er een klinker in s staat.

def back_to_front(s):
    """Geeft de woorden met de medeklinkers van het eind van s vooraan gezet.

    Eerst alleen de laatste, dan de laatste twee, enzovoort. s bevat minstens één
    klinker.
    """
    if s[-1] in "aeiou":  # basisgeval
        return []
    else:  # recursief geval
        word = s[-1] + s[:-1]
        return [word] + back_to_front(word)


assert back_to_front("ootn") == ["noot", "tnoo"]
assert back_to_front("aatstr") == ["raatst", "traats", "straat", "tstraa"]
assert back_to_front("zee") == []
assert back_to_front("a") == []

Stap 5: `originals(p)`¶

def originals(p):
    """Geeft alle woorden die p als vertaling hebben.

    p is de vertaling van een woord met minstens één klinker en zonder y.
    """
    if p[-3:] == "hee":
        return [p[:-3]] + back_to_front(p[:-2])
    else:
        return back_to_front(p[:-2])


assert originals("ootnee") == ["noot", "tnoo"]
assert originals("aaphee") == ["aap", "haap", "phaa"]
assert originals("aatstree") == ["raatst", "traats", "straat", "tstraa"]
assert "straat" in originals(pig_latin("straat"))
assert "eend" in originals(pig_latin("eend"))