AI lesopdrachten toevoegen

Les opdrachten/AI opdrachten/FA1/practicum_1_getallen_student.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Oriëntatie op AI
+
+Practicum 1: getallen
+
+(c) 2019 Hogeschool Utrecht
+Bart van Eijkelenburg (bart.vaneijkelenburg@hu.nl)
+Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Opdracht: werk onderstaande functies uit.
+
+Je kunt je functies testen met het gegeven raamwerk door het bestand
+uit te voeren (of met behulp van pytest, als je weet hoe dat werkt).
+Lever je werk in op Canvas als alle tests slagen.
+
+Let op! Het is niet toegestaan om bestaande modules te importeren en te
+        gebruiken, zoals `math` en `statistics`.
+"""
+
+# Vul hier je naam, klas en studentnummer in
+naam = "Taha Genc"
+klas = "TICT-PV-SG5-20"
+studentnummer = 1788230
+
+
+def is_even(n):
+    """ Retourneer True als n (int) even is en False als n oneven is. """
+    if n%2 == 0:
+        return True
+    else:
+        return False
+
+
+def floor(real):
+    """ Retourneer het grootste gehele getal (int), dat kleiner dan of gelijk is aan real (float). """
+    return int(real//1)
+
+
+def ceil(real):
+    """ Retourneer het kleinste gehele getal (int), groter dan of gelijk aan real (float). """
+    return int(-(real // -1))
+
+def div(n):
+    """
+    Retourneer een (natuurlijk) gesorteerde verzameling (list) van delers van n (int).
+    Het positieve gehele getal a is een deler van n, als er een positief geheel getal b is, zodat a x b = n.
+    """
+    divisors = []
+
+    for x in range(1, n+1):
+        if n % x == 0:
+            divisors.append(x)
+
+    return sorted(divisors)
+
+
+def is_prime(n):
+    """
+    Retourneer True als n (int) een priemgetal is, anders False. Je kunt gebruik maken van de functie 'div(n)'
+    om te bepalen of n een priem is.
+    Optioneel: bedenk een efficiënter alternatief.
+    """
+    if n != 1:
+        for x in range(2, n):
+            if n % x == 0:
+                return False
+        else:
+            return True
+    else:
+        return False
+
+
+def primefactors(n):
+    """
+    Retourneer een (natuurlijk) gesorteerde verzameling (list) van priemfactoren van n (int).
+    Return [] als n kleiner dan 2 is.
+    Tip: maak gebruik van de functie 'is_prime(n)'
+    """
+    factors = []
+
+    if n < 2:
+        return factors
+    else:
+        divs = div(n)
+        divs.pop(0)
+        primedivs = []
+        for x in divs:
+            if is_prime(x):
+                primedivs.append(x)
+
+        count = 0
+        total = len(primedivs)
+        numb = n
+        cont = True
+        while cont:
+            if numb % primedivs[count] == 0:
+                factors.append(primedivs[count])
+                numb = numb / primedivs[count]
+            else:
+                count = count + 1
+
+            if count == total:
+                cont= False
+        return sorted(factors)
+
+
+
+
+def primes(num):
+    """ Retourneer alle priemgetallen kleiner dan num (int). Je kunt gebruik maken van de functie 'is_prime(n)'. """
+    primelist = []
+
+    for x in range(1, num):
+        if is_prime(x):
+            primelist.append(x)
+
+    return primelist
+
+
+def gcd(a, b):
+    """
+    Retourneer de grootste grootste gemene deler (oftewel greatest common divisor, gcd) (int) van
+    natuurlijke getallen a en b (beide int).
+
+    Je hebt twee opties voor deze opgave:
+    1.  Je programmeert hier het algoritme van Euclides.
+        Zie: https://nl.wikipedia.org/wiki/Algoritme_van_Euclides
+    2.  Je bedenkt zelf een oplossing waarbij je gebruik maakt van de eerder
+        geschreven methode div(n) om de gcd te bepalen.
+    """
+
+    while a != b:
+        if a > b:
+            a = a - b
+        else:
+            b = b - a
+
+    return a
+
+
+def lcm(a, b):
+    """
+    Retourneer het kleinste gemene veelvoud, kgv (ofwel least common multiple, lcm) (int) van natuurlijke
+    getallen a en b (beide int).
+    """
+
+    return a*b // gcd(a, b)
+
+
+def add_frac(n1, d1, n2, d2):
+    """
+    Retourneer de sommatie van twee breuken als breuk. Vereenvoudig de breuk zover als mogelijk.
+
+    Args:
+        n1 (int) -- de teller van de eerste breuk
+        d1 (int) -- de noemer van de eerste breuk
+        n2 (int) -- de teller van de tweede breuk
+        d2 (int) -- de noemer van de tweede breuk
+
+    Returns:
+        tuple: De som *als breuk*, met eerst de teller en dan de noemer van het resultaat.
+
+    Examples:
+        Gegeven 1/3 + 1/5 = 8/15, dan
+
+        >>> add_frac(1, 3, 1, 5)
+        (8, 15)
+
+        Gegeven 1/2 + 1/4 = 3/4, dan
+
+        >>> add_frac(1, 2, 1, 4)
+        (3, 4)
+
+        Gegeven 2/3 + 3/2 = 13/6, dan
+
+        >>> add_frac(2, 3, 3, 2)
+        (13, 6)
+
+    """
+
+    if d1 == d2:
+        divisor = gcd(n1 + n2, d1)
+        return (divisor, d1 / divisor)
+    else:
+        total = n1 * d2 + n2 * d1
+        return (total / gcd(total, d1 * d2), d1 * d2 / gcd(total, d1 * d2))
+
+
+"""
+==========================[ 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
+import random
+
+
+def my_assert_args(function, args, expected_output, check_type=True):
+    """
+    Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert.
+    Optioneel wordt ook het return-type gecontroleerd.
+    """
+    argstr = str(args).replace(',)', ')')
+    output = function(*args)
+
+    # Controleer eerst het return-type (optioneel)
+    if check_type:
+        msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type"
+        assert type(output) is type(expected_output), msg
+
+    # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer
+    msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}"
+    if type(expected_output) is float:
+        # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen
+        assert round(output - expected_output, 7) == 0, msg
+    else:
+        assert output == expected_output, msg
+
+
+def test_id():
+    assert naam != "", "Je moet je naam nog invullen!"
+    assert studentnummer != -1, "Je moet je studentnummer nog invullen!"
+    assert klas != "", "Je moet je klas nog invullen!"
+
+
+def test_is_even():
+    testcases = [
+        ((1,), False),
+        ((2,), True),
+        ((3,), False),
+        ((4,), True)
+    ]
+
+    for case in testcases:
+        my_assert_args(is_even, case[0], case[1])
+
+
+def test_floor():
+    testcases = [
+        ((1.05,), 1),
+        ((1.95,), 1),
+        ((-1.05,), -2),
+        ((-1.95,), -2),
+        ((0.05,), 0),
+        ((-0.05,), -1),
+        ((0.0, ), 0),
+        ((1.0, ), 1),
+        ((-1.0, ), -1)
+    ]
+
+    for case in testcases:
+        my_assert_args(floor, case[0], case[1])
+
+    for _ in range(10):
+        x = random.uniform(-10.0, 10.0)
+        my_assert_args(floor, (x,), math.floor(x))
+
+
+def test_ceil():
+    testcases = [
+        ((1.05,), 2),
+        ((1.95,), 2),
+        ((-1.05,), -1),
+        ((-1.95,), -1),
+        ((0.05,), 1),
+        ((-0.05,), 0),
+        ((0.0, ), 0),
+        ((1.0, ), 1),
+        ((-1.0, ), -1)
+    ]
+
+    for case in testcases:
+        my_assert_args(ceil, case[0], case[1])
+
+    for _ in range(10):
+        x = random.uniform(-10.0, 10.0)
+        my_assert_args(ceil, (x,), math.ceil(x))
+
+
+def test_div():
+    testcases = [
+        ((1,), [1]),
+        ((2,), [1, 2]),
+        ((3,), [1, 3]),
+        ((4,), [1, 2, 4]),
+        ((8,), [1, 2, 4, 8]),
+        ((12,), [1, 2, 3, 4, 6, 12]),
+        ((19,), [1, 19]),
+        ((25,), [1, 5, 25]),
+        ((929,), [1, 929]),
+        ((936,), [1, 2, 3, 4, 6, 8, 9, 12, 13, 18, 24, 26, 36, 39, 52, 72, 78, 104, 117, 156, 234, 312, 468, 936])
+    ]
+
+    for case in testcases:
+        my_assert_args(div, case[0], sorted(case[1]))
+
+
+def test_is_prime():
+    testcases = [
+        ((1,), False),
+        ((2,), True),
+        ((3,), True),
+        ((4,), False),
+        ((5,), True),
+        ((6,), False),
+        ((9,), False),
+        ((29,), True)
+    ]
+
+    for case in testcases:
+        my_assert_args(is_prime, case[0], case[1])
+
+
+def test_primefactors():
+    testcases = [
+        ((-1,), []),
+        ((1,), []),
+        ((2,), [2]),
+        ((3,), [3]),
+        ((4,), [2, 2]),
+        ((8,), [2, 2, 2]),
+        ((12,), [2, 2, 3]),
+        ((2352,), [2, 2, 2, 2, 3, 7, 7]),
+        ((9075,), [3, 5, 5, 11, 11])
+    ]
+
+    for case in testcases:
+        my_assert_args(primefactors, case[0], sorted(case[1]))
+
+
+def test_primes():
+    testcases = [
+        ((1,), []),
+        ((2,), []),
+        ((3,), [2]),
+        ((4,), [2, 3]),
+        ((5,), [2, 3]),
+        ((6,), [2, 3, 5]),
+        ((30,), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29])
+    ]
+
+    for case in testcases:
+        my_assert_args(primes, case[0], sorted(case[1]))
+
+
+def test_gcd():
+    testcases = [
+        ((60, 1), 1),
+        ((60, 6), 6),
+        ((60, 7), 1),
+        ((60, 8), 4),
+        ((60, 9), 3),
+        ((60, 11), 1),
+        ((60, 13), 1),
+        ((60, 14), 2),
+        ((60, 15), 15),
+        ((60, 16), 4),
+        ((60, 18), 6)
+    ]
+
+    for case in testcases:
+        my_assert_args(gcd, case[0], case[1])
+
+    for _ in range(10):
+        a = random.randrange(3, 201, 3)
+        b = random.randrange(4, 201, 4)
+        my_assert_args(gcd, (a, b), math.gcd(a, b))
+
+
+def test_lcm():
+    testcases = [
+        ((60, 1), 60),
+        ((60, 2), 60),
+        ((60, 7), 420),
+        ((60, 8), 120),
+        ((60, 9), 180),
+        ((60, 10), 60),
+        ((60, 11), 660),
+        ((60, 18), 180)
+    ]
+
+    for case in testcases:
+        my_assert_args(lcm, case[0], case[1])
+
+
+def test_add_frac():
+    testcases = [
+        ((1, 3, 1, 5), (8, 15)),
+        ((1, 2, 1, 4), (3, 4)),
+        ((2, 3, 3, 2), (13, 6)),
+        ((1, 2, 1, 6), (2, 3)),
+        ((3, 4, 1, 6), (11, 12)),
+        ((1, 6, 3, 4), (11, 12)),
+        ((1, 2, 1, 3), (5, 6)),
+        ((1, 2, 2, 3), (7, 6))
+    ]
+
+    for case in testcases:
+        my_assert_args(add_frac, case[0], case[1])
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+        test_id()
+
+        test_is_even()
+        print("Je functie is_even(n) werkt goed!")
+
+        test_floor()
+        print("Je functie floor(real) werkt goed!")
+
+        test_ceil()
+        print("Je functie ceil(real) werkt goed!")
+
+        test_div()
+        print("Je functie div(n) werkt goed!")
+
+        test_is_prime()
+        print("Je functie is_prime(n) werkt goed!")
+
+        test_primefactors()
+        print("Je functie primefactors(n) werkt goed!")
+
+        test_primes()
+        print("Je functie primes(num) werkt goed!")
+
+        test_gcd()
+        print("Je functie gcd(a, b) werkt goed!")
+
+        test_lcm()
+        print("Je functie lcm(a, b) werkt goed!")
+
+        test_add_frac()
+        print("Je functie add_frac(n1, d1, n2, d2) werkt goed!")
+
+        print("\nGefeliciteerd, alles lijkt te werken!")
+        print("Lever je werk nu in op Canvas...")
+
+    except AssertionError as ae:
+        print("\x1b[0;31m")
+        print(ae)

Les opdrachten/AI opdrachten/FA2/practicum_2_algoritmiek_student.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Oriëntatie op AI
+
+Practicum 2: algoritmiek
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Opdracht: beantwoord onderstaande vragen en werk onderstaande functies uit.
+
+Je kunt je functies testen met het gegeven raamwerk door het bestand
+uit te voeren (of met behulp van pytest, als je weet hoe dat werkt).
+Lever je werk in op Canvas als alle tests slagen.
+
+Let op! Het is niet toegestaan om bestaande modules te importeren en te
+        gebruiken, zoals `math` en `statistics`.
+"""
+
+# Vul hier je naam, klas en studentnummer in
+naam = "Taha Genc"
+klas = "TICT-PV-SG5-20"
+studentnummer = 1788230
+
+"""
+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 deze
+        lijst aanneemt bij álle tussenstappen bij toepassing van
+        bovenstaand sorteeralgoritme.
+
+        0 = [ 4, 3, 1, 2 ]
+        1 = [ 3, 4, 1, 2 ]
+        2 = [ 3, 1, 4, 2 ]
+        3 = [ 1, 3, 4, 2 ]
+        4 = [ 1, 3, 2, 4 ]
+        5 = [ 1, 2, 3, 4 ]
+
+    1b. Implementatie
+        Implementeer het sorteeralgoritme in Python in een functie
+        hieronder genaamd my_sort(lst).
+
+    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?
+
+            bij een array van [1,2,3] zijn er minimaal 2 vergelijkingen nodig
+
+
+        -   Bij welke volgorde van de waarden in de lijst is het
+            sorteeralgoritme het minst snel klaar (worst-case scenario)?
+            Hoeveel vergelijkingen zijn nodig geweest?
+
+            bij een array van [3,2,1] zijn er maximaal 3 vergelijkingen nodig
+
+
+        -   Stel je hebt een lijst met de waarden 1 tot en met 4.
+            Wat is nu het best-case scenario?      [1,2,3,4]
+            Hoeveel vergelijkingen zijn er nodig?  3 vergelijkingen
+            En wat is nu het worst-case scenario?  [4,3,2,1]
+            Hoeveel vergelijkingen zijn er nodig?  7 vergelijkingen
+
+
+
+        -   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?      een gesorteerde lijst of n=1
+            Hoeveel vergelijkingen zijn er nodig?  n-1
+            En wat is nu het worst-case scenario?  gesorteerd in de verkeerde richting
+            Hoeveel vergelijkingen zijn er nodig?  1/2 * n + 1
+
+
+2.  Recursie
+
+    2a. Lineair zoeken
+        Implementeer het lineair zoekalgoritme in Python op een
+        *recursieve* manier. Gebruik hiervoor de functie genaamd
+        linear_search_recursive(lst, target).
+
+    2b. Binair zoeken
+        Implementeer het binair zoekalgoritme in Python op een
+        *recursieve* manier. Gebruik hiervoor de functie genaamd
+        binary_search_recursive(lst, target).
+"""
+
+
+def my_sort(lst):
+    """
+    Sorteer gegeven lijst lst volgens het algoritme zoals beschreven in de pseudocode bij 1. hierboven.
+    Zorg dat de gegeven lijst niet verandert, maar geef een nieuwe, gesorteerde variant van de lijst terug.
+    """
+    lst_sorted = lst.copy()  # kopie maken van ingegeven list
+
+    for _ in range(len(lst) - 1):
+        for x in range(len(lst)-1):
+            if lst_sorted[x] > lst_sorted[x+1]:
+                lst_sorted[x], lst_sorted[x+1] = lst_sorted[x+1], lst_sorted[x]
+
+
+
+
+    return lst_sorted
+
+
+def linear_search_recursive(lst, target):
+    """
+    Zoek een element target in gegeven lijst lst door middel van recursief lineair zoeken.
+    De inhoud van de gegeven lijst verandert niet.
+
+    Args:
+        lst    -- de lijst waarin gezocht wordt (list)
+        target -- het element dat gezocht wordt
+
+    Returns:
+        of het element in de lijst voorkomt (bool)
+    """
+    if len(lst) == 0:  # als lijst geen entries meer bevat false returnen
+        return False
+    elif lst[0] == target:  # als positie 0 de target bevat true returnen
+        return True
+    else:
+        return linear_search_recursive(lst[1:], target)  # zichzelf starten min de eerste entry in de list
+
+
+
+
+def binary_search_recursive(lst, target):
+    """
+    Zoek een element target in gegeven lijst door middel van recursief binair zoeken.
+    De inhoud van de gegeven lijst verandert niet.
+
+    Args:
+        lst    -- de (reeds gesorteerde) lijst waarin gezocht wordt (list)
+        target -- het element dat gezocht wordt
+
+    Returns:
+        of het element in de lijst voorkomt (bool)
+    """
+
+    laag = 0  # laagste positie
+    hoog = len(lst) - 1 # hoogste positie
+    cur = (len(lst) - 1) // 2  # middenste index berekenen afrondend naar beneden
+
+    if target == lst[cur]:  # als cursor positie al de target is true returnen
+        return True
+
+    if hoog > laag:  # als de lijst meer dan 1 item bevat, anders bevat de lijst 1 item die niet de target is
+        if lst[cur] > target:  # als target lager ligt dan de cursor
+            return binary_search_recursive(lst[0:cur+1], target)  # functie oproepen met de lijst lager dan de cursor
+        elif lst[cur] < target:  # als de target hoger ligt dan de cursor
+            return binary_search_recursive(lst[cur+1:hoog+1], target)  # functie oproepen met de lijst hoger dan de cursor
+
+    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.
+"""
+import random
+
+
+def test_id():
+    assert naam != "", "Je moet je naam nog invullen!"
+    assert studentnummer != -1, "Je moet je studentnummer nog invullen!"
+    assert klas != "", "Je moet je klas nog invullen!"
+
+
+def test_my_sort():
+    lst_test = random.choices(range(-99, 100), k=6)
+    lst_copy = lst_test.copy()
+    lst_output = my_sort(lst_test)
+
+    assert lst_copy == lst_test, "Fout: my_sort(lst) verandert de inhoud van lijst lst"
+    assert lst_output == sorted(lst_test), \
+        f"Fout: my_sort({lst_test}) geeft {lst_output} in plaats van {sorted(lst_test)}"
+
+
+def test_linear_search_recursive():
+    for _ in range(99):  # ik heb deze waarde van 10 naar 99 aangepast zodat ik iteratie bugs kan vinden
+        lst_test = random.sample(range(20), 6)
+        target = random.randrange(20)
+        found = target in lst_test
+        lst_copy = lst_test.copy()
+
+        outcome = linear_search_recursive(lst_test, target)
+        assert lst_copy == lst_test, "Fout: linear_search_recursive(lst, target) verandert de inhoud van lijst lst"
+        assert outcome == found, \
+            f"Fout: linear_search_recursive({lst_test}, {target}) geeft {outcome} in plaats van {found}"
+
+
+def test_binary_search_recursive():
+    for _ in range(99):  # ik heb deze waarde van 10 naar 99 aangepast zodat ik iteratie bugs kan vinden
+        lst_test = sorted(random.sample(range(20), 6))
+        target = random.randrange(20)
+        found = target in lst_test
+        lst_copy = lst_test.copy()
+
+        outcome = binary_search_recursive(lst_test, target)
+        assert outcome == found, \
+            f"Fout: binary_search_recursive({lst_test}, {target}) geeft {outcome} in plaats van {found}"
+        assert lst_copy == lst_test, "Fout: binary_search_recursive(lst, target) verandert de inhoud van lijst lst"
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+        test_id()
+
+        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("\nGefeliciteerd, alles lijkt te werken!")
+        print("Lever je werk nu in op Canvas...")
+
+    except AssertionError as ae:
+        print("\x1b[0;31m")
+        print(ae)

Les opdrachten/AI opdrachten/FA3/practicum_3_statistiek_student.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Oriëntatie op AI
+
+Practicum 3: statistiek
+
+(c) 2019 Hogeschool Utrecht
+Bart van Eijkelenburg (bart.vaneijkelenburg@hu.nl)
+Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Opdracht: werk onderstaande functies uit. Elke functie krijgt een
+          niet-lege en ongesorteerde lijst *lst* met gehele
+          getallen (int) als argument.
+
+Je kunt je functies testen met het gegeven raamwerk door het bestand
+uit te voeren (of met behulp van pytest, als je weet hoe dat werkt).
+Lever je werk in op Canvas als alle tests slagen.
+
+Let op! Het is niet toegestaan om bestaande modules te importeren en te
+        gebruiken, zoals `math` en `statistics`.
+"""
+
+# Vul hier je naam, klas en studentnummer in
+naam = "Taha Genc"
+klas = "TICT-PV-SG5-20"
+studentnummer = 1788230
+
+
+def mean(lst):
+    """ Retourneer het gemiddelde (float) van de lijst lst. """
+    return float(sum(lst) / len(lst))  # totaal waarde van lijst - aantal waardes in lijst in float returnen
+
+
+def rnge(lst):
+    """ Retourneer het bereik (int) van de lijst lst. """
+    lst.sort()  # sorteer lijst
+    return int(lst[-1] - lst[0])  # hoogste waarde - laagste waarde in int returnen
+
+
+def median(lst):
+    """ Retourneer de mediaan (float) van de lijst lst. """
+    lst.sort()  # sorteer lijst
+    p = len(lst)  # lengte lijst opvragen
+
+    if p % 2:  # als lengte van lijst oneven is
+        return float(lst[p // 2])  # return middelste waarde in gesorteerde lijst als float
+    else:  # lijst heeft 2 waardes in het midden
+        return float(sum(lst[p // 2 - 1:p // 2 + 1]) / 2)  # return het gemiddelde van de middelste 2 waardes als float
+
+
+def q1(lst):
+    """
+    Retourneer het eerste kwartiel Q1 (float) van de lijst lst.
+    Tip: maak gebruik van median()
+    """
+    lst.sort()  # sorteer de lijst
+    return float(median(lst[:len(lst) // 2]))  # voer median() uit met de gegeven lijst tot mediaan
+
+
+def q3(lst):
+    """ Retourneer het derde kwartiel Q3 (float) van de lijst lst. """
+    # dit is echt omslachtig, maar het werkt
+    lst.sort()  # sorteer de lijst
+    leng = len(lst)  # lengte lijst
+
+    if leng % 2:  # als lengte oneven is
+        return float(median(lst[len(lst) // 2 + 1:]))  # voer median() uit met midden lijst+1 tot einde lijst
+    else:
+        return float(median(lst[len(lst) // 2:]))  # voer median() uit met middenlijst tot einde lijst
+
+
+def var(lst):
+    """ Retourneer de variantie (float) van de lijst lst. """
+    t = []  # tijdelijke lijst aanmaken
+    m = mean(lst)  # mean van de lijst opslaan
+    for i in lst:  # voor elke entry in lijst
+        t.append((i - m) ** 2)  # kwadraat van i - mean opslaan in tijdelijke lijst
+    return float(sum(t) / len(lst))  # float van totaal waarde lijst - lengte lijst returnen
+
+
+def std(lst):
+    """ Retourneer de standaardafwijking (float) van de lijst lst. """
+    return float(var(lst)**0.5)  # wortel trekken van variatie
+
+
+def freq(lst):
+    """
+    Retourneer een dictionary met als keys de waardes die voorkomen in lst en
+    als value het aantal voorkomens van die waarde.
+
+    Examples:
+        >>> freq([0, 0, 4, 5])
+        {0: 2, 4: 1, 5: 1}
+    """
+    t = {}  # lege dict aanmaken
+
+    for i in lst:  # voor elk cijfer in lijst
+        if i in t:  # als cijfer in dict bestaat
+            t[i] = t[i] + 1  # +1 doen op de huidige aantal in dict
+        else:  # cijfer bestaat niet in dict
+            t[i] = 1  # voeg cijfer toe met waarde 1
+
+    return t  # return de dict
+
+
+def modes(lst):
+    """ Retourneer een gesorteerde lijst (list) van de modi van lijst lst. """
+    # als dit een inefficient algoritme is zeg het maar, ik had namelijk niet zo veel tijd meer door de kwartielen
+
+    m = []  # lijst aanmaken om de values op te slaan
+    r = []  # lijst maken om de keys op te slaan(de waardes die we gaan retourneren)
+    f = freq(lst)  # een frequentie dict maken
+
+    for x in f:  # voor elke key in de dict
+        m.append(f[x])  # de waarde opslaan in de lijst m
+
+    maximum_v = max(m)  # pak de hoogste waarde in de lijst met waardes
+
+    for x in f:  # voor elke key in de dict
+        if f[x] == maximum_v:  # als de waarde van de dict overeenkomt met de maximum berekende waarde
+            r.append(x)  # de key opslaan in de resultaten lijst
+
+    return sorted(r)  # geef de r lijst terug gesorteerd
+
+
+"""
+==========================[ 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
+import statistics
+
+
+def my_assert_args(function, args, expected_output, check_type=True):
+    """
+    Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert.
+    Optioneel wordt ook het return-type gecontroleerd.
+    """
+    argstr = str(args).replace(',)', ')')
+    output = function(*args)
+
+    # Controleer eerst het return-type (optioneel)
+    if check_type:
+        msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type"
+        assert type(output) is type(expected_output), msg
+
+    # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer
+    msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}"
+    if type(expected_output) is float:
+        # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen
+        assert round(output - expected_output, 7) == 0, msg
+    else:
+        assert output == expected_output, msg
+
+
+def test_id():
+    assert naam != "", "Je moet je naam nog invullen!"
+    assert studentnummer != -1, "Je moet je studentnummer nog invullen!"
+    assert klas != "", "Je moet je klas nog invullen!"
+
+
+def test_mean():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 5.0),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), 3.0)
+    ]
+
+    for case in testcases:
+        my_assert_args(mean, case[0], case[1])
+
+    for lst_size in range(1, 11):
+        lst_test = [random.choice(range(5)) for _ in range(lst_size)]
+        my_assert_args(mean, (lst_test,), statistics.mean(lst_test), False)
+
+
+def test_rnge():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 6),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), 5)
+    ]
+
+    for case in testcases:
+        my_assert_args(rnge, case[0], case[1])
+
+
+def test_median():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 5.0),
+        (([1, 3, 4, 6, 4, 2],), 3.5),
+        (([1, 3, 4, 6, 2, 4, 2],), 3.0),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), 2.5)
+    ]
+
+    for case in testcases:
+        my_assert_args(median, case[0], case[1])
+
+    for lst_size in range(1, 11):
+        lst_test = [random.choice(range(5)) for _ in range(lst_size)]
+        my_assert_args(median, (lst_test,), statistics.median(lst_test), False)
+
+
+def test_q1():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 3.0),
+        (([1, 3, 4, 6, 4, 2],), 2.0),
+        (([1, 3, 5, 6, 1, 4, 2],), 1.0),
+        (([5, 7, 4, 4, 6, 2, 8],), 4.0),
+        (([0, 5, 5, 6, 7, 7, 12],), 5.0),
+        (([1, 3, 3, 5, 6, 2, 4, 1],), 1.5),
+        (([3, 5, 7, 8, 9, 11, 15, 16, 20, 21],), 7.0),
+        (([1, 2, 5, 6, 7, 9, 12, 15, 18, 19, 27],), 5.0)
+
+    ]
+
+    for case in testcases:
+        my_assert_args(q1, case[0], case[1])
+
+
+def test_q3():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 7.0),
+        (([1, 3, 4, 6, 4, 2],), 4.0),
+        (([1, 3, 5, 6, 2, 4, 1],), 5.0),
+        (([5, 7, 4, 4, 6, 2, 8],), 7.0),
+        (([0, 5, 5, 6, 7, 7, 12],), 7.0),
+        (([1, 3, 3, 5, 6, 2, 4, 1],), 4.5),
+        (([3, 5, 7, 8, 9, 11, 15, 16, 20, 21],), 16.0),
+        (([1, 2, 5, 6, 7, 9, 12, 15, 18, 19, 27],), 18.0)
+
+    ]
+
+    for case in testcases:
+        my_assert_args(q3, case[0], case[1])
+
+
+def test_var():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 4.0),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), 2.25)
+    ]
+
+    for case in testcases:
+        my_assert_args(var, case[0], case[1])
+
+    for lst_size in range(1, 11):
+        lst_test = [random.choice(range(5)) for _ in range(lst_size)]
+        my_assert_args(var, (lst_test,), statistics.pvariance(lst_test), False)
+
+
+def test_std():
+    testcases = [
+        (([4, 2, 5, 8, 6],), 2.0),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), 1.5)
+    ]
+
+    for case in testcases:
+        my_assert_args(std, case[0], case[1])
+
+    for lst_size in range(1, 11):
+        lst_test = [random.choice(range(5)) for _ in range(lst_size)]
+        my_assert_args(std, (lst_test,), statistics.pstdev(lst_test), False)
+
+
+def test_freq():
+    testcases = [
+        (([4, 2, 5, 8, 6],), {2: 1, 4: 1, 5: 1, 6: 1, 8: 1}),
+        (([1, 3, 4, 6, 4, 2],), {1: 1, 2: 1, 3: 1, 4: 2, 6: 1}),
+        (([1, 3, 5, 6, 2, 4, 1],), {1: 2, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1}),
+        (([1, 3, 3, 5, 6, 2, 4, 1],), {1: 2, 2: 1, 3: 2, 4: 1, 5: 1, 6: 1})
+    ]
+
+    for case in testcases:
+        my_assert_args(freq, case[0], case[1])
+
+
+def test_modes():
+    testcases = [
+        (([4, 2, 5, 8, 6],), [2, 4, 5, 6, 8]),
+        (([1, 3, 4, 6, 4, 2],), [4]),
+        (([1, 3, 4, 6, 2, 4, 2],), [2, 4]),
+        (([1, 3, 2, 4, 6, 2, 4, 2],), [2])
+    ]
+
+    for case in testcases:
+        my_assert_args(modes, case[0], case[1])
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+        test_id()
+
+        test_mean()
+        print("Je functie mean(lst) werkt goed!")
+
+        test_rnge()
+        print("Je functie rnge(lst) werkt goed!")
+
+        test_median()
+        print("Je functie median(lst) werkt goed!")
+
+        test_q1()
+        print("Je functie q1(lst) werkt goed!")
+
+        test_q3()
+        print("Je functie q3(lst) werkt goed!")
+
+        test_var()
+        print("Je functie var(lst) werkt goed!")
+
+        test_std()
+        print("Je functie std(lst) werkt goed!")
+
+        test_freq()
+        print("Je functie freq(lst) werkt goed!")
+
+        test_modes()
+        print("Je functie modes(lst) werkt goed!")
+
+        print("\nGefeliciteerd, alles lijkt te werken!")
+        print("Lever je werk nu in op Canvas...")
+
+
+        def hist(freqs):
+            v_min = min(freqs.keys())
+            v_max = max(freqs.keys())
+
+            histo = str()
+            for i in range(v_min, v_max + 1):
+                histo += "{:5d} ".format(i)
+                if i in freqs.keys():
+                    histo += "█" * freqs[i]
+                histo += '\n'
+
+            return histo
+
+
+        print("\x1b[0;30m")
+        s = input("Geef een reeks van gehele getallen (gescheiden door een spatie): ")
+        userlst = [int(c) for c in s.split()]
+
+        print("\nHet gemiddelde is {:.2f}".format(mean(userlst)))
+        print("De modi zijn {}".format(modes(userlst)))
+        print("De mediaan is {:.2f}".format(median(userlst)))
+        print("Q1 is {:.2f}".format(q1(userlst)))
+        print("Q3 is {:.2f}".format(q3(userlst)))
+
+        print("Het bereik is {}".format(rnge(userlst)))
+        print("De variantie is {:.2f}".format(var(userlst)))
+        print("De standaardafwijking is {:.2f}".format(std(userlst)))
+
+        print("\nHistogram (gekanteld):\n\n" + hist(freq(userlst)))
+
+    except AssertionError as ae:
+        print("\x1b[0;31m")
+        print(ae)