Basis¶
Scrabble¶
In Scrabble leg je woorden met tegels. Op elke tegel staat een letter en een waarde, en een woord is evenveel punten waard als zijn tegels samen. Letters die weinig voorkomen, zoals de q en de x, zijn meer waard. In deze opgave schrijf je functies die de score van een woord uitrekenen en uit een rij woorden het beste kiezen. Op één na gebruiken ze allemaal recursie.
De tegels¶
Waarde |
Letters |
|---|---|
1 |
a, d, e, i, n, o, r, s, t |
2 |
g, h, l |
3 |
b, c, m, p |
4 |
j, k, u, v, w |
5 |
f |
6 |
z |
8 |
x, y |
10 |
q |
Het woord kat is dus 4 + 1 + 1 = 6 punten waard. Dat sommige tegels in het echte spel maar een paar keer in de zak zitten, laat je buiten beschouwing.
Wat je gaat maken¶
Stap |
Functie |
Doet |
Wat je oefent |
|---|---|---|---|
1 |
|
de waarde van één letter |
geen recursie: |
2 |
|
de score van een woord |
een getal uit een string |
3 |
|
staan er twee dezelfde letters naast elkaar? |
buurletters, met een boolean; zelf een docstring en assertions schrijven |
4 |
|
de woorden met een hoge score |
een lijst filteren |
5 |
|
het woord met de hoogste score |
de beste uit een lijst |
Stap 1: letter_score(c)¶
Geeft de waarde van de tegel met de letter c. c is een string van één teken.
Is c geen kleine letter van a tot en met z, dan geeft de functie 0
terug. Deze functie heeft geen recursie nodig.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
Hint
Moet je nu 25 of 26 keer if of elif schrijven? Nee! Gebruik in, zoals in
het tweede college, en één tak per rij van de tabel:
if c in "xy":
return 8
# jouw oplossing
assert letter_score("w") == 4
assert letter_score("q") == 10
assert letter_score("e") == 1
assert letter_score("%") == 0
Stap 2: scrabble_score(s)¶
Geeft de score van de string s: de waarden van al zijn letters bij elkaar
opgeteld.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
|
|
Hint
Deze functie heeft dezelfde vorm als vwl uit het tweede college. Alleen tel je
nu voor het eerste teken niet 1 of 0 op, maar letter_score(s[0]).
# jouw oplossing
assert scrabble_score("quotums") == 24
assert scrabble_score("jacquet") == 24
assert scrabble_score("pyjama") == 20
assert scrabble_score("abcdefghijklmnopqrstuvwxyz") == 84
assert scrabble_score("?!@#$%^&*()") == 0
assert scrabble_score("") == 0
Stap 3: double_letter(s)¶
Geeft True als er ergens in s twee dezelfde letters direct naast elkaar
staan, en anders False. Voor zo’n woord heb je twee dezelfde tegels nodig.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
Deze keer schrijf je zelf een docstring bij de functie, en drie assertions eronder.
Kies de assertions zo dat er een woord bij zit met True als uitkomst, een woord
met False, en een randgeval, zoals een lege string. Voer daarna de testcel uit.
Hint
Nu vergelijk je twee buren: s[0] en s[1]. Een string met minder dan twee
tekens heeft geen buren, en dat is het basisgeval. Zodra je twee dezelfde buren
vindt, weet je het antwoord en hoef je niet verder te kijken.
# jouw oplossing, met een docstring en drie assertions
assert double_letter("pizza") == True
assert double_letter("taart") == True
assert double_letter("quiz") == False
assert double_letter("a") == False
assert double_letter("") == False
Stap 4: high_scoring(words, n)¶
words is een lijst van woorden. Geeft een lijst met de woorden uit words die
minstens n punten waard zijn, in dezelfde volgorde.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
Hint
Het eerste woord is words[0] en de rest is words[1:]. Hou je het eerste
woord, dan plak je [words[0]] voor het antwoord op de rest.
# jouw oplossing
assert high_scoring(["kat", "quiz", "zee", "pizza"], 10) == ["quiz", "pizza"]
assert high_scoring(["kat", "zee"], 10) == []
assert high_scoring([], 10) == []
Stap 5: best_word(words)¶
words is een lijst van woorden, en is niet leeg. Geeft het woord met de hoogste
score. Hebben twee woorden dezelfde score, dan wint het woord dat het eerst in de
lijst staat.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
Hint
Deze functie heeft dezelfde vorm als largest uit het tweede college. Vergelijk
het eerste woord met het beste woord uit de rest, maar vergelijk hun scores en
niet de woorden zelf. Let op gelijke scores: dan moet het eerste woord winnen,
dus kies het eerste woord ook als zijn score gelijk is aan die van het beste
woord uit de rest.
# jouw oplossing
assert best_word(["kat", "quiz", "zee", "pizza"]) == "quiz"
assert best_word(["kat", "tak"]) == "kat"
assert best_word(["zee"]) == "zee"
Tot slot¶
Van de vier woorden kat, quiz, zee en pizza is quiz met 21 punten het
beste; pizza haalt 17. Kijk nog eens naar stap 2, 4 en 5. Ze liepen allemaal een
rij langs, een string of een lijst, en elke keer was het kleinere probleem de
rest na het eerste element. Wat verschilde, was het combineren: optellen,
filteren, of kiezen. Meer voorbeelden van recursieve functies staan bij de
Voorbeelden van recursie.