Added student versions of exercises and assignment 4 (algoritmiek).

faculteit_student.py

@@ -0,0 +1,43 @@
+"""
+Analytical Skills - opgave faculteit iteratief
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+
+def faculteit_iteratief(n):
+    """ Berekent de faculteit van *n* op een iteratieve manier. """
+    res = 1
+
+    # Voeg de iteratie in: for ...
+
+    return res
+
+
+"""
+========================================================================================================================
+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))
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+
+        test_faculteit_iteratief()
+        print("Je functie faculteit_iteratief() doorstaat de tests!")
+
+        print("\x1b[0;30m")
+
+        x = int(input("Geef een getal: "))
+        print(str(x) + "! = " + str(faculteit_iteratief(x)))
+
+    except AssertionError as ae:
+            print("\x1b[0;31m" + str(ae))

insertion_sort_student.py

@@ -0,0 +1,73 @@
+"""
+Analytical Skills - opgave insertion sort
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+import random
+
+def insert(lst, grens, waarde):
+    """ Voegt de waarde op de juiste plek in het gesorteerde deel van lijst lst """
+    # De lijst *lst* is gesorteerd van lst[0] t/m lst[grens]
+    # Het element *waarde* wordt ingevoegd op de juiste plek in bovengenoemde gesorteerde deel,
+    # dus hierna is de lijst *lst* gesorteerd van lst[0] t/m lst[grens+1]
+
+    # 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
+
+
+def insertion_sort(lst):
+    """ Implementatie van het insertion sort algoritme die gegeven lijst lst sorteert """
+    pass
+
+
+"""
+========================================================================================================================
+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.
+"""
+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, "\x1b[0;31mFout: 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, "\x1b[0;31mFout: 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, "\x1b[0;31mFout: 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), "\x1b[0;31mFout: insertion_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
+
+
+if __name__ == '__main__':
+    try:
+        test_insert()
+        print("\x1b[0;32mJe 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)
+
+    aantal = int(input("\x1b[0;30mHoeveel 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))
+

practicum_4_algoritmiek_student.py

@@ -0,0 +1,130 @@
+"""
+Analytical Skills - practicum 4: algoritmiek
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+
+"""
+Naam:
+Klas: 
+Studentnummer:
+
+1.    Sorteeralgoritme
+
+      Hieronder staat de pseudocode van een sorteeralgoritme:
+      1. Startend vanaf het begin van een lijst, vergelijk elk element met zijn volgende buur.
+      2. Als het element groter is dan zijn volgende buur, verwissel ze van plaats.
+      3. Doorloop zo de lijst tot het eind.
+      4. Als er verwisselingen zijn geweest bij stap 2., ga naar stap 1.
+
+  1a. Handmatig toepassen
+      Gegeven is de lijst l = [ 4, 3, 1, 2 ]. Geef de waardes die de lijst aanneemt bij álle tussenstappen bij 
+      toepassing van bovenstaand sorteeralgoritme.
+
+      [antwoord]
+
+  1b. Implementatie
+      Implementeer het sorteeralgoritme in Python in een functie genaamd  my_sort(lst). Lever je code pas in als alle
+      tests geen foutmeldingen meer geven.
+  
+  1c. Best en worst case
+      - Stel je hebt een lijst met de waarden 1, 2 en 3. Bij welke volgorde van de waarden in de lijst is het
+        sorteeralgoritme het snelste klaar (best-case scenario)? Hoeveel vergelijkingen (zoals beschreven in stap 1. 
+        van de pseudocode) zijn nodig geweest?
+        
+        [antwoord]
+        
+      - Bij welke volgorde van de waarden in de lijst is het sorteeralgoritme het minst snel klaar
+        (worst-case scenario)? Hoeveel vergelijkingen zijn nodig geweest?
+        
+        [anwoord]
+        
+      - Stel je hebt een lijst met de waarden 1 tot en met 4. Wat is nu het best-case scenario? Hoeveel vergelijkingen
+        zijn er nodig? 
+        En wat is nu het worst-case scenario? Hoeveel vergelijkingen zijn er nodig?
+        
+        [antwoord]
+        
+      - Stel je hebt een lijst met de waarden 1 tot en met n (je weet nu dus niet precies hoeveel waarden er in de lijst
+        zitten, het zijn er 'n'). Wat is nu het best-case scenario? Hoeveel vergelijkingen zijn er nodig?
+        En wat is nu het worst-case scenario? Hoeveel vergelijkingen zijn er nodig?
+
+        [antwoord]
+        
+2.    Recursie
+
+  2a. Lineair zoeken
+      Implementeer het lineair zoekalgoritme in Python op een *recursieve* manier. Maak hiervoor de functie genaamd 
+      linear_search_recursive(lst, target). Lever je code pas in als alle tests geen foutmeldingen meer geven.
+
+  2b. Binair zoeken
+      Implementeer het binair zoekalgoritme in Python op een *recursieve* manier. Maak hiervoor de functie genaamd 
+      binary_search_recursive(lst, target). Lever je code pas in als alle tests geen foutmeldingen meer geven.
+"""
+
+
+def my_sort(lst):
+    """ Implementatie van het sorteeralgoritme die gegeven lijst lst sorteert """
+    pass
+
+
+def linear_search_recursive(lst, target):
+    """ Bepaalt of *target* voorkomt in lijst *lst* door middel van recursief lineair zoeken. """
+    return False
+
+
+def binary_search_recursive(lst, target):
+    """ Bepaalt of *target* voorkomt in lijst *lst* door middel van recursief binair zoeken. """
+    return False
+
+
+"""
+========================================================================================================================
+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_my_sort():
+    lst_test = random.sample(range(-99, 100), 6)
+    lst_copy = lst_test.copy()
+    my_sort(lst_test)
+    assert lst_test == sorted(lst_copy), "Fout: my_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
+
+
+def test_linear_search_recursive():
+    for i in range(10):
+        lst_test = random.sample(range(20), 10)
+        target = random.randrange(20)
+        assert linear_search_recursive(lst_test, target) == (target in lst_test), "Fout: linear_search_recursive({}, {}) geeft {} in plaats van {}".format(lst_test, target, linear_search_recursive(lst_test, target), target in lst_test)
+
+
+def test_binary_search_recursive():
+    for i in range(10):
+        lst_test = sorted(random.sample(range(20), 10))
+        target = random.randrange(20)
+        assert binary_search_recursive(lst_test, target) == (target in lst_test), "Fout: binary_search_recursive({}, {}) geeft {} in plaats van {}".format(lst_test, target, binary_search_recursive(lst_test, target), target in lst_test)
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+
+        test_my_sort()
+        print("Je functie my_sort() werkt goed!")
+
+        test_linear_search_recursive()
+        print("Je functie linear_search_recursive() werkt goed!")
+
+        test_binary_search_recursive()
+        print("Je functie binary_search_recursive() werkt goed!")
+
+        print("Gefeliciteerd, alles lijkt te werken! Lever je werk nu in op Canvas...")
+
+    except AssertionError as ae:
+        print("\x1b[0;31m" + str(ae))
+
+

recursie_student.py

@@ -0,0 +1,86 @@
+"""
+Analytical Skills - opgave recursie
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+
+def faculteit(n):
+    # Base case
+    if n == 0:
+        return 1
+    # Recursie
+    else:
+        return faculteit(0)
+
+
+def exponent(n):
+    # Base case
+
+    # Recursie
+    return n
+
+
+def som(lst):
+    return 1
+
+
+def palindroom(woord):
+    return False
+
+
+"""
+========================================================================================================================
+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, random
+
+def test_faculteit():
+    for x in range(6):
+        assert faculteit(x) == math.factorial(x), "Fout: faculteit({}) geeft {} in plaats van {}".format(x, faculteit(x), math.factorial(x))
+
+
+def test_exponent():
+    for x in range(10):
+        assert exponent(x) == 2**x, "Fout: exponent({}) geeft {} in plaats van {}".format(x, exponent(x), 2**x)
+
+
+def test_som():
+    for i in range(6):
+        lst_test = random.sample(range(-10, 11), i)
+        assert som(lst_test) == sum(lst_test), "Fout: som({}) geeft {} in plaats van {}".format(lst_test, som(lst_test), sum(lst_test))
+
+
+def test_palindroom():
+    assert palindroom("") is True, "Fout: palindroom({}) geeft {} in plaats van {}".format("", palindroom(""), True)
+    assert palindroom("radar") is True, "Fout: palindroom({}) geeft {} in plaats van {}".format("radar", palindroom("radar"), True)
+    assert palindroom("maandnaam") is True, "Fout: palindroom({}) geeft {} in plaats van {}".format("maandnaam", palindroom("maandnaam"), True)
+    assert palindroom("pollepel") is False, "Fout: palindroom({}) geeft {} in plaats van {}".format("pollepel", palindroom("pollepel"), False)
+    assert palindroom("Maandnaam") is False, "Fout: palindroom({}) geeft {} in plaats van {}".format("Maandnaam", palindroom("Maandnaam"), False)
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+
+        test_faculteit()
+        print("Je functie faculteit() doorstaat de tests!")
+
+        test_exponent()
+        print("Je functie exponent() doorstaat de tests!")
+
+        test_som()
+        print("Je functie som() doorstaat de tests!")
+
+        test_palindroom()
+        print("Je functie palindroom() doorstaat de tests!")
+
+        print("\x1b[0;30m")
+
+        x = input("Geef een woord: ")
+        print("'" + x + "' is " + ("" if palindroom(x) else "g") + "een palindroom!")
+
+    except AssertionError as ae:
+            print("\x1b[0;31m" + str(ae))

search_student.py

@@ -0,0 +1,147 @@
+"""
+Analytical Skills - opgave zoeken
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+
+import random
+from math import floor
+
+
+def linear_search(lst, target):
+    """ Bepaalt of *target* voorkomt in lijst *lst* door middel van lineair zoeken. """
+    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. """
+    index = 0
+    steps = 0
+
+    return -1, steps
+
+
+def binary_search(lst, target):
+    """ Bepaalt of *target* voorkomt in lijst *lst* door middel van binair zoeken. """
+    # stap 1
+    mini = 0
+
+    # stap 6
+    while False: # hoelang ga je door met zoeken?
+        # stap 2
+        # stap 3
+        return True
+        # stap 4
+        # stap 5
+
+    return False
+
+
+def binary_search_index(lst, target):
+    """ Geeft de positie (m.a.w. index) van *target* in lijst *lst* d.m.v. binair zoeken. """
+    return -1
+
+
+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. """
+    steps = 0
+    return (-1, steps)
+
+
+"""
+========================================================================================================================
+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.
+"""
+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), "\x1b[0;31mFout: 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), "\x1b[0;31mFout: 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, "\x1b[0;31mFout: 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), "\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))
+
+
+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), "\x1b[0;31mFout: 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), "\x1b[0;31mFout: 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, "\x1b[0;31mFout: 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), "\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))
+
+
+if __name__ == '__main__':
+    try:
+        test_linear_search()
+        print("\x1b[0;32mJe functie linear_search() werkt goed!")
+
+        test_linear_search_index()
+        print("\x1b[0;32mJe functie linear_search_index() werkt goed!")
+
+        test_binary_search()
+        print("\x1b[0;32mJe functie test_binary_search() werkt goed!")
+
+        test_binary_search_index()
+        print("\x1b[0;32mJe functie test_binary_search_index() werkt goed!")
+
+        test_linear_search_index_steps()
+        print("\x1b[0;32mJe functie test_linear_search_index_steps() werkt goed!")
+
+        test_binary_search_index_steps()
+        print("\x1b[0;32mJe functie test_binary_search_index_steps() werkt goed!")
+
+        size = int(input("\x1b[0;30mGeef een grootte voor de lijst: "))
+        lst_test = list(range(size))
+        print("Ik ga zoeken in:", lst_test)
+        tgt = int(input("Geef een getal: "))
+
+        (idx, cnt) = linear_search_index_steps(lst_test, tgt)
+        print("Het lineair zoekalgoritme vond '" + str(tgt) + "' op positie '" + str(idx) + "' na " + str(cnt) + " stappen.")
+
+        (idx, cnt) = binary_search_index_steps(lst_test, tgt)
+        print("Het binair zoekalgoritme vond '" + str(tgt) + "' op positie '" + str(idx) + "' na " + str(cnt) + " stappen.")
+
+    except AssertionError as ae:
+        print(ae)
+

selection_sort_student.py

@@ -0,0 +1,79 @@
+"""
+Analytical Skills - opgave selection sort
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+"""
+
+import random
+
+
+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):
+    """ Vindt de locatie van het minimum in lijst lst vanaf een gegeven start_index """
+    minimum = lst[start_index]
+    index_of_minimum = start_index
+
+    # Doorloop de lijst lst vanaf start_index en
+    # update minimum en index_of_minimum waar nodig.
+
+    return index_of_minimum
+
+
+def selection_sort(lst):
+    """ Implementatie van het selection sort algoritme die gegeven lijst lst sorteert """
+    # 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!
+Je kunt je code testen door deze file te runnen of met behulp van pytest.
+"""
+def test_swap():
+    lst_test = [4, 9, 7]
+    swap(lst_test, 0, 1)
+    assert lst_test == [9, 4, 7], "\x1b[0;31mFout: 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], "\x1b[0;31mFout: 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], "\x1b[0;31mFout: 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, "\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, "\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, "\x1b[0;31mFout: 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), "\x1b[0;31mFout: selection_sort({}) geeft {} in plaats van {}".format(lst_copy, lst_test, sorted(lst_copy))
+
+
+if __name__ == '__main__':
+    try:
+        test_swap()
+        print("\x1b[0;32mJe functie swap() werkt goed!")
+
+        test_find_index_of_minimum()
+        print("\x1b[0;32mJe functie find_index_of_minimum() werkt goed!")
+
+        test_selection_sort()
+        print("\x1b[0;32mJe selection sort algoritme werkt goed!\n\nKnap gedaan!")
+    except AssertionError as ae:
+        print(ae)