From a73e4adf332b811b2f41ade31df9508c5e5eea39 Mon Sep 17 00:00:00 2001 From: Tijmen Joppe Muller Date: Fri, 13 Sep 2019 17:08:41 +0200 Subject: [PATCH] Added student versions of exercises and assignment 4 (algoritmiek). --- faculteit_student.py | 43 +++++++++ insertion_sort_student.py | 73 ++++++++++++++ practicum_4_algoritmiek_student.py | 130 +++++++++++++++++++++++++ recursie_student.py | 86 +++++++++++++++++ search_student.py | 147 +++++++++++++++++++++++++++++ selection_sort_student.py | 79 ++++++++++++++++ 6 files changed, 558 insertions(+) create mode 100644 faculteit_student.py create mode 100644 insertion_sort_student.py create mode 100644 practicum_4_algoritmiek_student.py create mode 100644 recursie_student.py create mode 100644 search_student.py create mode 100644 selection_sort_student.py diff --git a/faculteit_student.py b/faculteit_student.py new file mode 100644 index 0000000..3851ba6 --- /dev/null +++ b/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)) diff --git a/insertion_sort_student.py b/insertion_sort_student.py new file mode 100644 index 0000000..533ca7e --- /dev/null +++ b/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)) + diff --git a/practicum_4_algoritmiek_student.py b/practicum_4_algoritmiek_student.py new file mode 100644 index 0000000..a6c0a2d --- /dev/null +++ b/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)) + + diff --git a/recursie_student.py b/recursie_student.py new file mode 100644 index 0000000..8225a76 --- /dev/null +++ b/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)) diff --git a/search_student.py b/search_student.py new file mode 100644 index 0000000..59ee673 --- /dev/null +++ b/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) + diff --git a/selection_sort_student.py b/selection_sort_student.py new file mode 100644 index 0000000..cbd9578 --- /dev/null +++ b/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)