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 one_to_sum(n):
"""Geeft de som van de getallen 1 tot en met n."""
if n == 0:
return 0
else:
return n + one_to_sum(n - 1)
assert one_to_sum(0) == 0
assert one_to_sum(1) == 1
assert one_to_sum(3) == 6
assert one_to_sum(5) == 15
Opdracht 6¶
def sum_list(L):
"""Geeft de som van de getallen in L."""
if L == []:
return 0
else:
return L[0] + sum_list(L[1:])
assert sum_list([2, 6, 9]) == 17
assert sum_list([4]) == 4
assert sum_list([]) == 0
Opdracht 7¶
def double_letters(s):
"""Geeft s terug met elk teken twee keer."""
if s == "":
return ""
else:
return s[0] * 2 + double_letters(s[1:])
assert double_letters("hi") == "hhii"
assert double_letters("hallo") == "hhaalllloo"
assert double_letters("") == ""
Opdracht 8¶
def no_x(s):
"""Geeft s terug zonder de x'en."""
if s == "":
return ""
elif s[0] == "x":
return no_x(s[1:])
else:
return s[0] + no_x(s[1:])
assert no_x("x1xx2x3") == "123"
assert no_x("xxx") == ""
assert no_x("") == ""
Opdracht 9¶
def divisible_by(n, L):
"""Geeft de getallen uit L die deelbaar zijn door n."""
if L == []:
return []
elif L[0] % n == 0:
return [L[0]] + divisible_by(n, L[1:])
else:
return divisible_by(n, L[1:])
assert divisible_by(5, [15, 0, 23, 4]) == [15, 0]
assert divisible_by(3, [2, 4, 8, 10]) == []
assert divisible_by(2, []) == []
Opdracht 10¶
def all_star(s):
"""Geeft s terug met een * tussen elk paar tekens."""
if len(s) <= 1:
return s
else:
return s[0] + "*" + all_star(s[1:])
assert all_star("hallo") == "h*a*l*l*o"
assert all_star("hi") == "h*i"
assert all_star("a") == "a"
assert all_star("") == ""
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([]) == []