245 lines
8.3 KiB
Python
Executable File
245 lines
8.3 KiB
Python
Executable File
#!/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)
|