AI lesopdrachten toevoegen
This commit is contained in:
ventilaar
parent
5f587f1f49
commit
305dad62a1
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
Reference in New Issue