Opstap¶
De uitwerkingen staan in dezelfde volgorde als de twaalf opdrachten in de opstap. Bij de leesopdrachten voert de cel de code uit.
Opdracht 1¶
function telt af: ze drukt x af en roept zichzelf aan met x - 1, tot x
gelijk is aan 0. Ook de 0 wordt afgedrukt, want het afdrukken komt vóór de
controle.
def function(x):
print(x)
if x == 0:
return
function(x - 1)
function(10)
10
9
8
7
6
5
4
3
2
1
0
Opdracht 2¶
function telt af in stappen van y, en stopt bij precies 0.
def function(x, y):
print(x)
if x == 0:
return
function(x - y, y)
function(10, 2)
10
8
6
4
2
0
Bij function(5, 0) wordt x nooit 0: 5 - 0 is weer 5. Het basisgeval wordt
dus nooit bereikt, en dit is een oneindige recursie. De functie drukt bijna
duizend keer een 5 af, en dan stopt Python met een RecursionError. Hieronder
staat dezelfde functie zonder de print, zodat je alleen de foutmelding ziet.
def function(x, y):
if x == 0:
return
function(x - y, y)
function(5, 0)
RecursionError: maximum recursion depth exceeded
Opdracht 3¶
function telt op in stappen van y, en stopt zodra x 20 of meer is. De 22
wordt nog afgedrukt: het afdrukken komt vóór de controle.
def function(x, y):
print(x)
if x >= 20:
return
function(x + y, y)
function(10, 6)
10
16
22
Opdracht 4¶
function keert een string om. Pas na de recursieve aanroep plakt ze het eerste
teken achter de omgekeerde rest. Op het diepste punt staan er vier frames op de
stack: voor "abc", "bc", "c" en "". Het laatste is het basisgeval, en dat
geeft als eerste zijn antwoord terug.
def function(s):
if s == "":
return ""
rest = function(s[1:])
return rest + s[0]
print(function("abc"))
cba
Opdracht 5¶
def add(m, n):
"""Geeft de som m + n; n is 0 of groter."""
if n == 0:
return m
else:
return add(m, n - 1) + 1
assert add(5, 0) == 5
assert add(0, 0) == 0
assert add(3, 4) == 7
assert add(0, 3) == 3
Opdracht 6¶
def product(L):
"""Geeft het product van de getallen in L."""
if L == []:
return 1
else:
return L[0] * product(L[1:])
assert product([2, 3, 4]) == 24
assert product([5]) == 5
assert product([7, 0, 3]) == 0
assert product([]) == 1
Opdracht 7¶
def flip_bits(s):
"""Geeft s terug met elke 0 vervangen door een 1, en elke 1 door een 0."""
if s == "":
return ""
elif s[0] == "0":
return "1" + flip_bits(s[1:])
else:
return "0" + flip_bits(s[1:])
assert flip_bits("0110") == "1001"
assert flip_bits("1") == "0"
assert flip_bits("") == ""
Opdracht 8¶
def no_punctuation(s):
"""Geeft s terug zonder de leestekens . , ! en ?."""
if s == "":
return ""
elif s[0] in ".,!?":
return no_punctuation(s[1:])
else:
return s[0] + no_punctuation(s[1:])
assert no_punctuation("Hallo, wereld!") == "Hallo wereld"
assert no_punctuation("?!") == ""
assert no_punctuation("") == ""
Opdracht 9¶
def only_odds(L):
"""Geeft een lijst met de oneven getallen uit L."""
if L == []:
return []
elif L[0] % 2 == 1:
return [L[0]] + only_odds(L[1:])
else:
return only_odds(L[1:])
assert only_odds([3, 8, 5, 0, 7]) == [3, 5, 7]
assert only_odds([2, 4]) == []
assert only_odds([]) == []
Opdracht 10¶
def is_palindrome(s):
"""Geeft True als s achterstevoren hetzelfde is."""
if len(s) <= 1:
return True
elif s[0] != s[-1]:
return False
else:
return is_palindrome(s[1:-1])
assert is_palindrome("lepel") == True
assert is_palindrome("kok") == True
assert is_palindrome("lepels") == False
assert is_palindrome("ab") == False
assert is_palindrome("a") == True
assert is_palindrome("") == True
Opdracht 11¶
def rhymes(word1, word2, n):
"""Geeft True als de laatste n letters van word1 en word2 gelijk zijn."""
if n == 0:
return True
elif word1 == "" or word2 == "":
return False
elif word1[-1] != word2[-1]:
return False
else:
return rhymes(word1[:-1], word2[:-1], n - 1)
assert rhymes("kater", "water", 4) == True
assert rhymes("kat", "rat", 2) == True
assert rhymes("kat", "kip", 1) == False
assert rhymes("aap", "schaap", 3) == True
assert rhymes("aap", "schaap", 4) == False
Opdracht 12¶
def positives_loop(L):
"""Geeft de getallen uit L die groter zijn dan 0, met een lus."""
result = []
for x in L:
if x > 0:
result = result + [x]
return result
def positives_lc(L):
"""Geeft de getallen uit L die groter zijn dan 0, met een list comprehension."""
return [x for x in L if x > 0]
def positives_rec(L):
"""Geeft de getallen uit L die groter zijn dan 0, met recursie."""
if L == []:
return []
elif L[0] > 0:
return [L[0]] + positives_rec(L[1:])
else:
return positives_rec(L[1:])
assert positives_loop([3, -1, 0, 7, -5]) == [3, 7]
assert positives_loop([-2, 0]) == []
assert positives_loop([]) == []
assert positives_lc([3, -1, 0, 7, -5]) == [3, 7]
assert positives_lc([-2, 0]) == []
assert positives_lc([]) == []
assert positives_rec([3, -1, 0, 7, -5]) == [3, 7]
assert positives_rec([-2, 0]) == []
assert positives_rec([]) == []