Updated all exercises.

faculteit_student.py

@@ -1,13 +1,17 @@
 """
-Analytical Skills - opgave faculteit iteratief
+Analytical Skills
+Opgave: faculteit (iteratief)
 
 (c) 2019 Hogeschool Utrecht
 Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Let op! Je mag voor deze opgave geen extra modules importeren met 'import'.
 """
 
 
 def faculteit_iteratief(n):
-    """ Berekent de faculteit van *n* op een iteratieve manier. """
+    """ Berekent n! op iteratieve wijze. """
     res = 1
 
     # Voeg de iteratie in: for ...
@@ -15,13 +19,13 @@ def faculteit_iteratief(n):
     return res
 
 
-"""
-========================================================================================================================
+"""==============================================[ HU TESTRAAMWERK ]====================================================
 Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
 Je kunt je code testen door deze file te runnen of met behulp van pytest.
 """
 import math
 
+
 def test_faculteit_iteratief():
     for x in range(6):
         assert faculteit_iteratief(x) == math.factorial(x), "Fout: faculteit_iteratief({}) geeft {} in plaats van {}".format(x, faculteit_iteratief(x), math.factorial(x))
@@ -40,4 +44,5 @@ if __name__ == '__main__':
         print(str(x) + "! = " + str(faculteit_iteratief(x)))
 
     except AssertionError as ae:
-            print("\x1b[0;31m" + str(ae))
+        print("\x1b[0;31m")
+        print(str(ae))

insertion_sort_student.py

@@ -1,11 +1,14 @@
 """
-Analytical Skills - opgave insertion sort
+Analytical Skills
+Opgave: insertion sort
 
 (c) 2019 Hogeschool Utrecht
 Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Let op! Je mag voor deze opgave geen extra modules importeren met 'import'.
 """
 
-import random
 
 def insert(lst, grens, waarde):
     """ Voegt de waarde op de juiste plek in het gesorteerde deel van lijst lst """
@@ -16,58 +19,63 @@ def insert(lst, grens, waarde):
     # Aanpak: begin bij index *grens* en verplaats elementen groter dan *waarde* naar rechts.
     # Als je een waarde tegenkomt die kleiner is dan *waarde* (of het begin van lijst *lst*),
     # dan voeg je *waarde* in op de vrijgekomen plek.
-
-    pass
+    return None     # De functie retourneert niets
 
 
 def insertion_sort(lst):
-    """ Implementatie van het insertion sort algoritme die gegeven lijst lst sorteert """
-    pass
+    """ Implementatie van het insertion sort algoritme -- sortering vind plaats 'in place'. """
+    returnpan> <span class="bp">None     # De functie retourneert niets
 
 
-"""
-========================================================================================================================
+"""==============================================[ HU TESTRAAMWERK ]====================================================
 Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
 Je kunt je code testen door deze file te runnen of met behulp van pytest.
 """
+import random
+
+
 def test_insert():
     lst_test = [3, 5, 7, 11, 13, 2, 9, 14]
 
     insert(lst_test, 4, 2)
     lst_correct = [2, 3, 5, 7, 11, 13, 9, 14]
-    assert lst_test == lst_correct, "e">\x1b[0;31mFout: insert(lst_test, 4, 2) geeft {} in plaats van {}".format(lst_test, lst_correct)
+    assert lst_test == lst_correct, "Fout: insert(lst_test, 4, 2) geeft {} in plaats van {}".format(lst_test, lst_correct)
 
     insert(lst_test, 5, 9)
     lst_correct = [2, 3, 5, 7, 9, 11, 13, 14]
-    assert lst_test == lst_correct, "e">\x1b[0;31mFout: insert(lst_test, 5, 9) geeft {} in plaats van {}".format(lst_test, lst_correct)
+    assert lst_test == lst_correct, "Fout: insert(lst_test, 5, 9) geeft {} in plaats van {}".format(lst_test, lst_correct)
 
     insert(lst_test, 6, 14)
     lst_correct = [2, 3, 5, 7, 9, 11, 13, 14]
-    assert lst_test == lst_correct, "e">\x1b[0;31mFout: insert(lst_test, 6, 14) geeft {} in plaats van {}".format(lst_test, lst_correct)
+    assert lst_test == lst_correct, "Fout: insert(lst_test, 6, 14) geeft {} in plaats van {}".format(lst_test, lst_correct)
 
 
 def test_insertion_sort():
     lst_test = random.sample(range(-99, 100), 6)
     lst_copy = lst_test.copy()
     insertion_sort(lst_test)
-    assert lst_test == sorted(lst_copy), "e">\x1b[0;31mFout: insertion_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
+    assert lst_test == sorted(lst_copy), "Fout: insertion_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
 
 
 if __name__ == '__main__':
     try:
+        print("\x1b[0;32m")
+
         test_insert()
-        print("\x1b[0;32mJe functie insert() werkt goed!")
+        print("Je functie insert() werkt goed!")
 
         test_insertion_sort()
-        print("\x1b[0;32mJe insertion sort algoritme werkt goed!\n\nKnap gedaan!\n")
-    except AssertionError as ae:
-        print(ae)
+        print("Je insertion sort algoritme werkt goed!\n\nKnap gedaan!\n")
 
-    aantal = int(input("\x1b[0;30mHoeveel getallen zal ik sorteren? "))
-    lst = list(range(aantal))
-    random.shuffle(lst)
+        print("\x1b[0;30m")
+        aantal = int(input("Hoeveel getallen zal ik sorteren? "))
+        lst = list(range(aantal))
+        random.shuffle(lst)
 
-    print("De lijst: \n" + str(lst))
-    insertion_sort(lst)
-    print("is na sortering: \n" + str(lst))
+        print("De lijst: \n" + str(lst))
+        insertion_sort(lst)
+        print("is na sortering: \n" + str(lst))
 
+    except AssertionError as ae:
+        print("\x1b[0;31m")
+        print(str(ae))

recursie_student.py

@@ -1,8 +1,12 @@
 """
-Analytical Skills - opgave recursie
+Analytical Skills
+Opgave: recursie
 
 (c) 2019 Hogeschool Utrecht
 Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Let op! Je mag voor deze opgave geen extra modules importeren met 'import'.
 """
 
 
@@ -30,8 +34,7 @@ def palindroom(woord):
     return False
 
 
-"""
-========================================================================================================================
+"""==============================================[ HU TESTRAAMWERK ]====================================================
 Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
 Je kunt je code testen door deze file te runnen of met behulp van pytest.
 """
@@ -83,4 +86,5 @@ if __name__ == '__main__':
         print("'" + x + "' is " + ("" if palindroom(x) else "g") + "een palindroom!")
 
     except AssertionError as ae:
-            print("\x1b[0;31m" + str(ae))
+            print("\x1b[0;31m")
+            print(str(ae))

search_student.py

@@ -1,13 +1,13 @@
 """
-Analytical Skills - opgave zoeken
+Analytical Skills
+Opgave: zoeken
 
 (c) 2019 Hogeschool Utrecht
 Tijmen Muller (tijmen.muller@hu.nl)
-"""
 
 
-kn">import random
-kn">from math import floor
+n">Let op! Je mag voor deze opgave geen extra modules importeren met 'import'.
+sa">"""
 
 
 def linear_search(lst, target):
@@ -15,19 +15,19 @@ def linear_search(lst, target):
     return False
 
 
-
 def linear_search_index(lst, target):
     """ Geeft de positie (m.a.w. index) van *target* in lijst *lst* d.m.v. lineair zoeken. """
     index = 0
-
     return -1
 
 
 def linear_search_index_steps(lst, target):
-    """ Geeft de positie (m.a.w. index) van *target* in lijst *lst* d.m.v. lineair zoeken, en het aantal benodigde stappen. """
+    """
+    Geeft de positie (m.a.w. index) van *target* in lijst *lst*
+    d.m.v. lineair zoeken, en het aantal benodigde stappen.
+    """
     index = 0
     steps = 0
-
     return -1, steps
 
 
@@ -36,8 +36,8 @@ def binary_search(lst, target):
     # stap 1
     mini = 0
 
-    # stap 6
-    while False: # hoelang ga je door met zoeken?
+    # stap 6(!)
+    while False:    # hoelang ga je door met zoeken?
         # stap 2
         # stap 3
         return True
@@ -53,85 +53,93 @@ def binary_search_index(lst, target):
 
 
 def binary_search_index_steps(lst, target):
-    """ Geeft de positie (m.a.w. index) van *target* in lijst *lst* d.m.v. binair zoeken, en het aantal benodigde stappen. """
+    """
+    Geeft de positie (m.a.w. index) van *target* in lijst *lst* d.m.v. binair zoeken,
+    en het aantal benodigde stappen.
+    """
     steps = 0
     return (-1, steps)
 
 
-"""
-========================================================================================================================
+"""==============================================[ HU TESTRAAMWERK ]====================================================
 Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
 Je kunt je code testen door deze file te runnen of met behulp van pytest.
 """
+import random
+
+
 def test_linear_search():
     for i in range(10):
         lst_test = random.sample(range(20), 10)
         target = random.randrange(20)
-        assert linear_search(lst_test, target) == (target in lst_test), "e">\x1b[0;31mFout: linear_search({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search(lst_test, target), target in lst_test)
+        assert linear_search(lst_test, target) == (target in lst_test), "Fout: linear_search({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search(lst_test, target), target in lst_test)
 
 
 def test_linear_search_index():
     for i in range(10):
         lst_test = random.sample(range(20), 10)
         target = random.choice(lst_test)
-        assert linear_search_index(lst_test, target) == lst_test.index(target), "e">\x1b[0;31mFout: linear_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search_index(lst_test, target), lst_test.index(target))
+        assert linear_search_index(lst_test, target) == lst_test.index(target), "Fout: linear_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search_index(lst_test, target), lst_test.index(target))
 
         lst_test = [0, 1, 2]
-        assert linear_search_index(lst_test, 3) == -1, "e">\x1b[0;31mFout: linear_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, 3, linear_search_index(lst_test, 3), -1)
+        assert linear_search_index(lst_test, 3) == -1, "Fout: linear_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, 3, linear_search_index(lst_test, 3), -1)
 
 
 def test_linear_search_index_steps():
     for i in range(10):
         lst_test = random.sample(range(20), 10)
         target = random.choice(lst_test)
-        assert linear_search_index_steps(lst_test, target)[0] == lst_test.index(target), "e">\x1b[0;31mFout: linear_search_index_steps({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search_index_steps(lst_test, target)[0], lst_test.index(target))
+        assert linear_search_index_steps(lst_test, target)[0] == lst_test.index(target), "Fout: linear_search_index_steps({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search_index_steps(lst_test, target)[0], lst_test.index(target))
 
 
 def test_binary_search():
     for i in range(10):
         lst_test = sorted(random.sample(range(20), 10))
         target = random.randrange(20)
-        assert binary_search(lst_test, target) == (target in lst_test), "e">\x1b[0;31mFout: binary_search({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search(lst_test, target), target in lst_test)
+        assert binary_search(lst_test, target) == (target in lst_test), "Fout: binary_search({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search(lst_test, target), target in lst_test)
 
 
 def test_binary_search_index():
     for i in range(10):
         lst_test = sorted(random.sample(range(20), 10))
         target = random.choice(lst_test)
-        assert binary_search_index(lst_test, target) == lst_test.index(target), "e">\x1b[0;31mFout: binary_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search_index(lst_test, target), lst_test.index(target))
+        assert binary_search_index(lst_test, target) == lst_test.index(target), "Fout: binary_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search_index(lst_test, target), lst_test.index(target))
 
         lst_test = [0, 1, 2]
-        assert binary_search_index(lst_test, 3) == -1, "e">\x1b[0;31mFout: binary_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, 3, binary_search_index(lst_test, 3), -1)
+        assert binary_search_index(lst_test, 3) == -1, "Fout: binary_search_index({}, {}) geeft {} in plaats van {}".format(lst_test, 3, binary_search_index(lst_test, 3), -1)
 
 
 def test_binary_search_index_steps():
     for i in range(10):
         lst_test = sorted(random.sample(range(20), 10))
         target = random.choice(lst_test)
-        assert binary_search_index_steps(lst_test, target)[0] == lst_test.index(target), "e">\x1b[0;31mFout: binary_search_index_steps({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search_index_steps(lst_test, target)[0], lst_test.index(target))
+        assert binary_search_index_steps(lst_test, target)[0] == lst_test.index(target), "Fout: binary_search_index_steps({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search_index_steps(lst_test, target)[0], lst_test.index(target))
 
 
 if __name__ == '__main__':
     try:
+        print("\x1b[0;32m")
+
         test_linear_search()
-        print("\x1b[0;32mJe functie linear_search() werkt goed!")
+        print("Je functie linear_search() werkt goed!")
 
         test_linear_search_index()
-        print("e">\x1b[0;32mJe functie linear_search_index() werkt goed!")
+        print("Je functie linear_search_index() werkt goed!")
 
         test_binary_search()
-        print("e">\x1b[0;32mJe functie test_binary_search() werkt goed!")
+        print("Je functie binary_search() werkt goed!")
 
         test_binary_search_index()
-        print("e">\x1b[0;32mJe functie test_binary_search_index() werkt goed!")
+        print("Je functie binary_search_index() werkt goed!")
 
         test_linear_search_index_steps()
-        print("e">\x1b[0;32mJe functie test_linear_search_index_steps() werkt goed!")
+        print("Je functie linear_search_index_steps() werkt goed!")
 
         test_binary_search_index_steps()
-        print("e">\x1b[0;32mJe functie test_binary_search_index_steps() werkt goed!")
+        print("Je functie binary_search_index_steps() werkt goed!")
 
-        size = int(input("\x1b[0;30mGeef een grootte voor de lijst: "))
+        print("\x1b[0;30m")
+        size = int(input("Geef een grootte voor de lijst: "))
         lst_test = list(range(size))
         print("Ik ga zoeken in:", lst_test)
         tgt = int(input("Geef een getal: "))
@@ -143,5 +151,5 @@ if __name__ == '__main__':
         print("Het binair zoekalgoritme vond '" + str(tgt) + "' op positie '" + str(idx) + "' na " + str(cnt) + " stappen.")
 
     except AssertionError as ae:
-        print(ae)
-
+        print(sa">n class="s2">"an>">\x1b[0;31m")
+        print(str(ae))

selection_sort_student.py

@@ -1,20 +1,21 @@
 """
-Analytical Skills - opgave selection sort
+Analytical Skills
+Opgave: selection sort
 
 (c) 2019 Hogeschool Utrecht
 Tijmen Muller (tijmen.muller@hu.nl)
-"""
 
-import random
+
+Let op! Je mag voor deze opgave geen extra modules importeren met 'import'.
+"""
 
 
 def swap(lst, index1, index2):
     """ Verwisselt de waardes op positie index1 en index2 in lijst lst """
     lst[index1] = lst[index2]
-    lst[index2] = lst[index1]
 
 
-def find_index_of_minimum(lst, start_index = 0):
+def find_index_of_minimum(lst, start_index=0):
     """ Vindt de locatie van het minimum in lijst lst vanaf een gegeven start_index """
     minimum = lst[start_index]
     index_of_minimum = start_index
@@ -26,54 +27,70 @@ def find_index_of_minimum(lst, start_index = 0):
 
 
 def selection_sort(lst):
-    """ Implementatie van het selection sort algoritme die gegeven lijst lst sorteert """
+    """ Sorteer lijst lst 'in place' door middel van het selection sort algoritme """
     # Implementeer selection sort met behulp van
     # swap() en find_index_of_minimum()
     pass
 
 
-"""
-========================================================================================================================
-Hieronder staan de tests voor je code -- hier mag je niets aan veranderen!
+"""==============================================[ HU TESTRAAMWERK ]====================================================
+Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
 Je kunt je code testen door deze file te runnen of met behulp van pytest.
 """
+import random
+
+
 def test_swap():
     lst_test = [4, 9, 7]
     swap(lst_test, 0, 1)
-    assert lst_test == [9, 4, 7], "e">\x1b[0;31mFout: swap([4, 9, 7], 0, 1) geeft {} in plaats van {}".format(lst_test, [9, 4, 7])
+    assert lst_test == [9, 4, 7], "Fout: swap([4, 9, 7], 0, 1) geeft {} in plaats van {}".format(lst_test, [9, 4, 7])
 
     lst_test = [4, 9, 7]
     swap(lst_test, 1, 2)
-    assert lst_test == [4, 7, 9], "e">\x1b[0;31mFout: swap([4, 9, 7], 1, 2) geeft {} in plaats van {}".format(lst_test, [4, 7, 9])
+    assert lst_test == [4, 7, 9], "Fout: swap([4, 9, 7], 1, 2) geeft {} in plaats van {}".format(lst_test, [4, 7, 9])
 
     lst_test = [4, 9, 7]
     swap(lst_test, 0, 2)
-    assert lst_test == [7, 9, 4], "e">\x1b[0;31mFout: swap([4, 9, 7], 0, 2) geeft {} in plaats van {}".format(lst_test, [7, 9, 4])
+    assert lst_test == [7, 9, 4], "Fout: swap([4, 9, 7], 0, 2) geeft {} in plaats van {}".format(lst_test, [7, 9, 4])
 
 
 def test_find_index_of_minimum():
     lst_test = [18, 6, 21, 44, 9, 14]
-    assert find_index_of_minimum(lst_test, 0) == 1, "e">\x1b[0;31mFout: find_index_of_minimum({}, 0) geeft {} in plaats van 1".format(lst_test, find_index_of_minimum(lst_test, 0))
-    assert find_index_of_minimum(lst_test, 2) == 4, "e">\x1b[0;31mFout: find_index_of_minimum({}, 2) geeft {} in plaats van 4".format(lst_test, find_index_of_minimum(lst_test, 2))
-    assert find_index_of_minimum(lst_test, 3) == 4, "e">\x1b[0;31mFout: find_index_of_minimum({}, 3) geeft {} in plaats van 4".format(lst_test, find_index_of_minimum(lst_test, 3))
+    assert find_index_of_minimum(lst_test, 0) == 1, "Fout: find_index_of_minimum({}, 0) geeft {} in plaats van 1".format(lst_test, find_index_of_minimum(lst_test, 0))
+    assert find_index_of_minimum(lst_test, 2) == 4, "Fout: find_index_of_minimum({}, 2) geeft {} in plaats van 4".format(lst_test, find_index_of_minimum(lst_test, 2))
+    assert find_index_of_minimum(lst_test, 3) == 4, "Fout: find_index_of_minimum({}, 3) geeft {} in plaats van 4".format(lst_test, find_index_of_minimum(lst_test, 3))
 
 
 def test_selection_sort():
     lst_test = random.sample(range(-99, 100), 6)
     lst_copy = lst_test.copy()
     selection_sort(lst_test)
-    assert lst_test == sorted(lst_copy), "e">\x1b[0;31mFout: selection_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
+    assert lst_test == sorted(lst_copy), "Fout: selection_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
 
 
 if __name__ == '__main__':
     try:
+        print("\x1b[0;32m")
+
         test_swap()
-        print("\x1b[0;32mJe functie swap() werkt goed!")
+        print("Je functie swap() werkt goed!")
 
         test_find_index_of_minimum()
-        print("e">\x1b[0;32mJe functie find_index_of_minimum() werkt goed!")
+        print("Je functie find_index_of_minimum() werkt goed!")
 
         test_selection_sort()
-        print("\x1b[0;32mJe selection sort algoritme werkt goed!\n\nKnap gedaan!")
+        print("Je selection sort algoritme werkt goed!\n\nKnap gedaan!\n")
+
+        print("\x1b[0;30m")
+        aantal = int(input("Hoeveel getallen zal ik sorteren? "))
+        lst = list(range(aantal))
+        random.shuffle(lst)
+        print("De lijst: \n" + str(lst))
+        selection_sort(lst)
+        print("is na sortering: \n" + str(lst))
+
     except AssertionError as ae:
-        print(ae)
+        print("\x1b[0;31m")
+        print(str(ae))
+
+