├── README.md ├── pic ├── HU.svg └── Hogeschool_Utrecht.svg ├── bonusvraag_3_recursive_binary_search_student.py ├── .gitignore ├── data_iris.csv ├── bonusvraag_1_vier_kwadraten_student.py ├── bonusvraag_2_zeef_van_eratosthenes_student.py ├── getallen_student.py ├── gradient_descent_student.py ├── recursie_student.py ├── statistiek_student.py ├── insertion_sort_student.py ├── selection_sort_student.py ├── bonusvraag_4_k_nearest_neighbors_student.py ├── search_student.py ├── final_assignment_getallen_student.py ├── final_assignment_algoritmiek_student.py └── final_assignment_statistiek_student.py /README.md: -------------------------------------------------------------------------------- 1 | Hogeschool Utrecht 2 | 3 | 4 | # Oriëntatie op Artificial Intelligence 5 | 6 | 7 | Deze repository bevat raamwerken voor de verplichte programmeerpractica en de programmeeroefeningen voor het vak *Oriëntatie op Artificial Intelligence* van de Hogeschool Utrecht. 8 | 9 | Je kunt de Python-bestanden (`.py`) op je eigen computer krijgen door ze te downloaden of door de repository te clonen. Maak **géén** fork van deze repository: als je zelf ook met `git`/GitHub/GitLab wilt werken, sla je werk dan in een eigen _private_ repository op. 10 | 11 | Neem bij vragen en opmerkingen contact op met de coördinator van het vak. 12 | -------------------------------------------------------------------------------- /pic/HU.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /bonusvraag_3_recursive_binary_search_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Bonusvraag: binary search recursief 8 | 9 | (c) 2019 Hogeschool Utrecht 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | Opdracht: werk onderstaande functie uit. 13 | 14 | Je kunt je functies testen met het gegeven raamwerk door het bestand 15 | uit te voeren (of met behulp van pytest, als je weet hoe dat werkt). 16 | Lever je werk in op Canvas als alle tests slagen. 17 | 18 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 19 | gebruiken, zoals `math` en `statistics`. 20 | """ 21 | 22 | 23 | def recursive_binary_search(lst, target): 24 | """ 25 | Zoek een element in de gegeven lijst door middel van recursief binair zoeken. 26 | 27 | Je mag ervan uit gaan dat de gegeven lijst al gesorteerd is. 28 | Zorg dat de inhoud van de gegeven lijst niet verandert. 29 | 30 | Args: 31 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 32 | target (int): Het gezochte element. 33 | 34 | Returns: 35 | bool: Of het element in de lijst voorkomt. 36 | """ 37 | return False 38 | 39 | 40 | """ 41 | ==========================[ HU TESTRAAMWERK ]================================ 42 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 43 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 44 | """ 45 | import random 46 | 47 | 48 | def test_recursive_binary_search(): 49 | for _ in range(10): 50 | lst_test = sorted(random.sample(range(20), 6)) 51 | target = random.randrange(20) 52 | found = target in lst_test 53 | lst_copy = lst_test.copy() 54 | 55 | outcome = recursive_binary_search(lst_test, target) 56 | assert outcome == found, \ 57 | f"Fout: recursive_binary_search({lst_test}, {target}) geeft {outcome} in plaats van {found}" 58 | assert lst_copy == lst_test, "Fout: recursive_binary_search(lst, target) verandert de inhoud van lijst lst" 59 | 60 | 61 | def __main(): 62 | try: 63 | print("\x1b[32m") 64 | test_recursive_binary_search() 65 | print("Je functie recursive_binary_search werkt goed!\n") 66 | 67 | except AssertionError as ae: 68 | print("\x1b[31m") # Rode tekstkleur 69 | if not ae: 70 | print("Je code veroorzaakt onderstaande AssertionError:") 71 | raise ae 72 | else: 73 | print(ae) 74 | print("\x1b[0m") # Reset tekstkleur 75 | 76 | 77 | if __name__ == '__main__': 78 | __main() 79 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | 131 | 132 | # Added manually 133 | pytest.ini 134 | setup.cfg 135 | scratch_student.py 136 | scratch_test_student.py 137 | practicum_4_herkansing_student.py 138 | 139 | *.html 140 | 141 | bonusvraag/ 142 | toets/ 143 | project/data/additional/ 144 | 145 | project/algorithms_student.py 146 | project/steamapi.tijmen.json 147 | project/steamapi.template.json 148 | project/steamapi.json 149 | project/data/steam.csv 150 | project/data/steam_small.json 151 | final_assignment_herkansing_student.py 152 | faculteit_student.py 153 | iris.csv 154 | -------------------------------------------------------------------------------- /data_iris.csv: -------------------------------------------------------------------------------- 1 | 1.4,0.2,Setosa 2 | 1.4,0.2,Setosa 3 | 1.3,0.2,Setosa 4 | 1.5,0.2,Setosa 5 | 1.4,0.2,Setosa 6 | 1.7,0.4,Setosa 7 | 1.4,0.3,Setosa 8 | 1.5,0.2,Setosa 9 | 1.4,0.2,Setosa 10 | 1.5,0.1,Setosa 11 | 1.5,0.2,Setosa 12 | 1.6,0.2,Setosa 13 | 1.4,0.1,Setosa 14 | 1.1,0.1,Setosa 15 | 1.2,0.2,Setosa 16 | 1.5,0.4,Setosa 17 | 1.3,0.4,Setosa 18 | 1.4,0.3,Setosa 19 | 1.7,0.3,Setosa 20 | 1.5,0.3,Setosa 21 | 1.7,0.2,Setosa 22 | 1.5,0.4,Setosa 23 | 1.0,0.2,Setosa 24 | 1.7,0.5,Setosa 25 | 1.9,0.2,Setosa 26 | 1.6,0.2,Setosa 27 | 1.6,0.4,Setosa 28 | 1.5,0.2,Setosa 29 | 1.4,0.2,Setosa 30 | 1.6,0.2,Setosa 31 | 1.6,0.2,Setosa 32 | 1.5,0.4,Setosa 33 | 1.5,0.1,Setosa 34 | 1.4,0.2,Setosa 35 | 1.5,0.2,Setosa 36 | 1.2,0.2,Setosa 37 | 1.3,0.2,Setosa 38 | 1.4,0.1,Setosa 39 | 1.3,0.2,Setosa 40 | 1.5,0.2,Setosa 41 | 1.3,0.3,Setosa 42 | 1.3,0.3,Setosa 43 | 1.3,0.2,Setosa 44 | 1.6,0.6,Setosa 45 | 1.9,0.4,Setosa 46 | 1.4,0.3,Setosa 47 | 1.6,0.2,Setosa 48 | 1.4,0.2,Setosa 49 | 1.5,0.2,Setosa 50 | 1.4,0.2,Setosa 51 | 4.7,1.4,Versicolor 52 | 4.5,1.5,Versicolor 53 | 4.9,1.5,Versicolor 54 | 4.0,1.3,Versicolor 55 | 4.6,1.5,Versicolor 56 | 4.5,1.3,Versicolor 57 | 4.7,1.6,Versicolor 58 | 3.3,1.0,Versicolor 59 | 4.6,1.3,Versicolor 60 | 3.9,1.4,Versicolor 61 | 3.5,1.0,Versicolor 62 | 4.2,1.5,Versicolor 63 | 4.0,1.0,Versicolor 64 | 4.7,1.4,Versicolor 65 | 3.6,1.3,Versicolor 66 | 4.4,1.4,Versicolor 67 | 4.5,1.5,Versicolor 68 | 4.1,1.0,Versicolor 69 | 4.5,1.5,Versicolor 70 | 3.9,1.1,Versicolor 71 | 4.8,1.8,Versicolor 72 | 4.0,1.3,Versicolor 73 | 4.9,1.5,Versicolor 74 | 4.7,1.2,Versicolor 75 | 4.3,1.3,Versicolor 76 | 4.4,1.4,Versicolor 77 | 4.8,1.4,Versicolor 78 | 5.0,1.7,Versicolor 79 | 4.5,1.5,Versicolor 80 | 3.5,1.0,Versicolor 81 | 3.8,1.1,Versicolor 82 | 3.7,1.0,Versicolor 83 | 3.9,1.2,Versicolor 84 | 5.1,1.6,Versicolor 85 | 4.5,1.5,Versicolor 86 | 4.5,1.6,Versicolor 87 | 4.7,1.5,Versicolor 88 | 4.4,1.3,Versicolor 89 | 4.1,1.3,Versicolor 90 | 4.0,1.3,Versicolor 91 | 4.4,1.2,Versicolor 92 | 4.6,1.4,Versicolor 93 | 4.0,1.2,Versicolor 94 | 3.3,1.0,Versicolor 95 | 4.2,1.3,Versicolor 96 | 4.2,1.2,Versicolor 97 | 4.2,1.3,Versicolor 98 | 4.3,1.3,Versicolor 99 | 3.0,1.1,Versicolor 100 | 4.1,1.3,Versicolor 101 | 6.0,2.5,Virginica 102 | 5.1,1.9,Virginica 103 | 5.9,2.1,Virginica 104 | 5.6,1.8,Virginica 105 | 5.8,2.2,Virginica 106 | 6.6,2.1,Virginica 107 | 4.5,1.7,Virginica 108 | 6.3,1.8,Virginica 109 | 5.8,1.8,Virginica 110 | 6.1,2.5,Virginica 111 | 5.1,2.0,Virginica 112 | 5.3,1.9,Virginica 113 | 5.5,2.1,Virginica 114 | 5.0,2.0,Virginica 115 | 5.1,2.4,Virginica 116 | 5.3,2.3,Virginica 117 | 5.5,1.8,Virginica 118 | 6.7,2.2,Virginica 119 | 6.9,2.3,Virginica 120 | 5.0,1.5,Virginica 121 | 5.7,2.3,Virginica 122 | 4.9,2.0,Virginica 123 | 6.7,2.0,Virginica 124 | 4.9,1.8,Virginica 125 | 5.7,2.1,Virginica 126 | 6.0,1.8,Virginica 127 | 4.8,1.8,Virginica 128 | 4.9,1.8,Virginica 129 | 5.6,2.1,Virginica 130 | 5.8,1.6,Virginica 131 | 6.1,1.9,Virginica 132 | 6.4,2.0,Virginica 133 | 5.6,2.2,Virginica 134 | 5.1,1.5,Virginica 135 | 5.6,1.4,Virginica 136 | 6.1,2.3,Virginica 137 | 5.6,2.4,Virginica 138 | 5.5,1.8,Virginica 139 | 4.8,1.8,Virginica 140 | 5.4,2.1,Virginica 141 | 5.6,2.4,Virginica 142 | 5.1,2.3,Virginica 143 | 5.1,1.9,Virginica 144 | 5.9,2.3,Virginica 145 | 5.7,2.5,Virginica 146 | 5.2,2.3,Virginica 147 | 5.0,1.9,Virginica 148 | 5.2,2.0,Virginica 149 | 5.4,2.3,Virginica 150 | 5.1,1.8,Virginica 151 | -------------------------------------------------------------------------------- /bonusvraag_1_vier_kwadraten_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Bonusvraag: vier kwadraten 8 | 9 | (c) 2019 Hogeschool Utrecht 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | Opdracht: werk onderstaande functie uit. 13 | 14 | Je kunt je functies testen met het gegeven raamwerk door het bestand 15 | uit te voeren (of met behulp van pytest, als je weet hoe dat werkt). 16 | Lever je werk in op Canvas als alle tests slagen. 17 | 18 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 19 | gebruiken, zoals `math` en `statistics`. 20 | """ 21 | 22 | 23 | def vier_kwadraten(kwadraatsom): 24 | """ 25 | Geef een lijst met vier getallen, zodat de som van de kwadraten van die 26 | getallen gelijk is aan gegeven kwadraatsom (int). 27 | 28 | Args: 29 | kwadraatsom (int): De gegeven kwadraatsom. 30 | 31 | Returns: 32 | list of int: De gevonden vier kwadraten. 33 | """ 34 | return [0, 0, 0, 0] 35 | 36 | 37 | """ 38 | ==========================[ HU TESTRAAMWERK ]================================ 39 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 40 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 41 | """ 42 | from functools import reduce 43 | import random 44 | from time import perf_counter 45 | 46 | 47 | def test_vier_kwadraten(): 48 | # Simulated test cases 49 | for cnt in range(100): 50 | n = random.randrange(1, 10) 51 | 52 | for _ in range(4): 53 | n *= 10 54 | n += random.randrange(0, 10) 55 | 56 | lst = vier_kwadraten(n) 57 | assert len(lst) == 4, \ 58 | f"Fout: vier_kwadraten() geeft geen lijst met 4 maar met {len(lst)} getallen, namelijk {lst}" 59 | assert n == reduce(lambda x, y: x + y, (map(lambda x: x ** 2, lst))), \ 60 | f"Fout: vier_kwadraten({n}) geeft {lst}, maar {lst[0]}² + {lst[1]}² + {lst[2]}² + {lst[3]}² != {n}" 61 | 62 | 63 | def test_vier_kwadraten_tijd(): 64 | # Test cases 65 | testcases = [36624, 73504, 54296, 40923, 33504, 42627, 70798, 90815, 55367, 52699] 66 | 67 | for case in testcases: 68 | lst = vier_kwadraten(case) 69 | assert len(lst) == 4, \ 70 | f"Fout: vier_kwadraten() geeft geen lijst met 4 maar met {len(lst)} getallen, namelijk {lst}" 71 | assert case == reduce(lambda x, y: x + y, (map(lambda x: x ** 2, lst))), \ 72 | f"Fout: vier_kwadraten({case}) geeft {lst}, maar {lst[0]}² + {lst[1]}² + {lst[2]}² + {lst[3]}² != {case}" 73 | 74 | 75 | def __main(): 76 | try: 77 | print("\x1b[32m") 78 | test_vier_kwadraten() 79 | print("Je functie vier_kwadraten(getal) werkt goed!\n") 80 | 81 | print("\x1b[0m") 82 | print("Timing van 10 getallen...") 83 | 84 | start_time = perf_counter() 85 | test_vier_kwadraten_tijd() 86 | delta_time = perf_counter() - start_time 87 | print(f"Totale tijd: {delta_time*1000:.0f}ms") 88 | 89 | except AssertionError as ae: 90 | print("\x1b[31m") # Rode tekstkleur 91 | if not ae: 92 | print("Je code veroorzaakt onderstaande AssertionError:") 93 | raise ae 94 | else: 95 | print(ae) 96 | print("\x1b[0m") # Reset tekstkleur 97 | 98 | 99 | if __name__ == '__main__': 100 | __main() 101 | -------------------------------------------------------------------------------- /bonusvraag_2_zeef_van_eratosthenes_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Bonusvraag: Zeef van Eratosthenes 8 | 9 | (c) 2023 Hogeschool Utrecht 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | Peter van den Berg (peter.vandenberg@hu.nl) 12 | 13 | Opdracht: werk onderstaande functie uit. 14 | 15 | Je kunt je functies testen met het gegeven raamwerk door het bestand 16 | uit te voeren (of met behulp van pytest, als je weet hoe dat werkt). 17 | Lever je werk in op Canvas als alle tests slagen. 18 | 19 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 20 | gebruiken, zoals `math` en `statistics`. 21 | """ 22 | 23 | 24 | def zeef_van_eratosthenes(getal): 25 | """ 26 | Vind alle priemgetallen onder een gegeven getal met behulp van de zeef van Eratosthenes 27 | (zie https://nl.wikipedia.org/wiki/Zeef_van_Eratosthenes). 28 | 29 | Args: 30 | getal (int): Het gegeven getal. 31 | 32 | Returns: 33 | list of int: Alle gevonden priemgetallen onder het gegeven getal. 34 | """ 35 | return [] 36 | 37 | 38 | """ 39 | ==========================[ HU TESTRAAMWERK ]================================ 40 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 41 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 42 | """ 43 | 44 | 45 | def __my_assert_args(function, args, expected_output, check_type=True): 46 | """ 47 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 48 | 49 | Optioneel wordt ook het return-type gecontroleerd. 50 | """ 51 | argstr = str(args).replace(',)', ')') 52 | output = function(*args) 53 | 54 | # Controleer eerst het return-type (optioneel) 55 | if check_type: 56 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 57 | assert type(output) is type(expected_output), msg 58 | 59 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 60 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 61 | is_float = type(expected_output) is float 62 | is_float_list = type(expected_output) is list and all([type(item) is float for item in expected_output]) 63 | if is_float: 64 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 65 | assert round(output - expected_output, 7) == 0, msg 66 | elif is_float_list: 67 | # Vergelijk bij floatlijst als return-type op 7 decimalen om afrondingsfouten te omzeilen 68 | assert [round(x - y, 7) for x, y in zip(output, expected_output)] == [0.0] * len(output), msg 69 | else: 70 | assert output == expected_output, msg 71 | 72 | 73 | def test_find_primes(): 74 | testcases = [ 75 | ([10], [2, 3, 5, 7]), 76 | ([20], [2, 3, 5, 7, 11, 13, 17, 19]), 77 | ([30], [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]), 78 | ([50], [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]), 79 | ([100], [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]), 80 | ] 81 | 82 | for case in testcases: 83 | __my_assert_args(zeef_van_eratosthenes, case[0], case[1]) 84 | return 1 85 | 86 | 87 | def __main(): 88 | try: 89 | print("\x1b[32m") 90 | test_find_primes() 91 | print("De functie zeef_van_eratosthenes werkt goed!\n") 92 | 93 | except AssertionError as ae: 94 | print("\x1b[31m") # Red text color 95 | if not ae: 96 | print("Your code caused the following AssertionError:") 97 | raise ae 98 | else: 99 | print(ae) 100 | print("\x1b[0m") # Reset text color 101 | 102 | 103 | if __name__ == '__main__': 104 | __main() 105 | -------------------------------------------------------------------------------- /getallen_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: getallen 8 | 9 | (c) 2023 Hogeschool Utrecht, 10 | Peter van den Berg (peter.vandenberg@hu.nl) 11 | Tijmen Muller (tijmen.muller@hu.nl) 12 | 13 | 14 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 15 | gebruiken, zoals `math` en `statistics`. 16 | """ 17 | 18 | 19 | def floor(real): 20 | """ 21 | Bepaal het grootste gehele getal (int), dat kleiner dan of gelijk is aan het gegeven reeel getal (float). 22 | 23 | Args: 24 | real (float): Een reeel getal. 25 | 26 | Returns: 27 | int: Het grootste gehele getal (int), dat kleiner dan of gelijk is aan het gegeven reeel getal. 28 | """ 29 | return 0 30 | 31 | 32 | def rekenkundige_rij(start, verschil, lengte): 33 | """ 34 | Berekent een rekenkundige rij (an = a0 + n · c) gegeven een startgetal, een verschil en een lengte. 35 | 36 | Args: 37 | start (int): Het getal waar de rij mee begint 38 | verschil (int): de stapgrootte van de rij 39 | lengte (int): de lengte van de rij 40 | 41 | Returns: 42 | list of int: de rekenkundige rij 43 | """ 44 | 45 | rij = [] 46 | return rij 47 | 48 | 49 | """ 50 | ==========================[ HU TESTRAAMWERK ]================================ 51 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 52 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 53 | """ 54 | 55 | 56 | def __my_assert_args(function, args, expected_output, check_type=True): 57 | """ 58 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 59 | 60 | Optioneel wordt ook het return-type gecontroleerd. 61 | """ 62 | argstr = str(args).replace(',)', ')') 63 | output = function(*args) 64 | 65 | # Controleer eerst het return-type (optioneel) 66 | if check_type: 67 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 68 | assert type(output) is type(expected_output), msg 69 | 70 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 71 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 72 | if type(expected_output) is float: 73 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 74 | assert round(output - expected_output, 7) == 0, msg 75 | else: 76 | assert output == expected_output, msg 77 | 78 | 79 | def test_floor(): 80 | testcases = [ 81 | ((1.05,), 1), 82 | ((1.95,), 1), 83 | ((-1.05,), -2), 84 | ((-1.95,), -2), 85 | ((0.05,), 0), 86 | ((-0.05,), -1), 87 | ((0.0, ), 0), 88 | ((1.0, ), 1), 89 | ((-1.0, ), -1) 90 | ] 91 | 92 | for case in testcases: 93 | __my_assert_args(floor, case[0], case[1]) 94 | 95 | 96 | def test_rekenkundige_rij(): 97 | testcases = [ 98 | ((1, 2, 3), [1, 3, 5]), 99 | ((3, 4, 5), [3, 7, 11, 15, 19]), 100 | ((3, 5, 7), [3, 8, 13, 18, 23, 28, 33]), 101 | ((5, 2, 5), [5, 7, 9, 11, 13]), 102 | ((5, 3, 5), [5, 8, 11, 14, 17]), 103 | ((10, 10, 10), [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) 104 | ] 105 | 106 | for case in testcases: 107 | __my_assert_args(rekenkundige_rij, case[0], case[1]) 108 | return 1 109 | 110 | 111 | def __main(): 112 | try: 113 | print("\x1b[32m") 114 | 115 | test_floor() 116 | print("Je functie floor() werkt goed!") 117 | 118 | test_rekenkundige_rij() 119 | print("Je functie rekenkundige_rij() werkt goed!") 120 | 121 | except AssertionError as ae: 122 | print("\x1b[31m") # Rode tekstkleur 123 | if not ae: 124 | print("Je code veroorzaakt onderstaande AssertionError:") 125 | raise ae 126 | else: 127 | print(ae) 128 | print("\x1b[0m") # Reset tekstkleur 129 | 130 | 131 | if __name__ == '__main__': 132 | __main() 133 | -------------------------------------------------------------------------------- /gradient_descent_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: Lineaire regressie 8 | 9 | (c) 2023 Hogeschool Utrecht, 10 | Peter van den Berg (petervandenberg@hu.nl) 11 | 12 | 13 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 14 | gebruiken, zoals `math` en `statistics`. 15 | """ 16 | 17 | 18 | def gradient_descent(x, y, num_iterations=1000, learning_rate=0.0001): 19 | """ 20 | Traint de coefficienten a en b voor het lineaire regressiemodel ŷ = a + b * x met de gradient descent methode. 21 | 22 | Args: 23 | x (list): de onafhankelijke waarden van de observaties 24 | y (list): de afhankelijke waarden van de observaties 25 | num_iterations (int): aantal iteraties om te leren 26 | learning_rate (float): leerconstante 27 | 28 | Returns: 29 | [float, float]: de berekende coefficienten 30 | """ 31 | coefficients = [0, 0] 32 | 33 | return coefficients 34 | 35 | 36 | """ 37 | ==========================[ HU TESTRAAMWERK ]================================ 38 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 39 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 40 | """ 41 | 42 | 43 | def __my_assert_args(function, args, expected_output, check_type=True): 44 | """ 45 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 46 | 47 | Optioneel wordt ook het return-type gecontroleerd. 48 | """ 49 | argstr = str(args).replace(',)', ')') 50 | output = function(*args) 51 | 52 | # Controleer eerst het return-type (optioneel) 53 | if check_type: 54 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 55 | assert type(output) is type(expected_output), msg 56 | 57 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 58 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 59 | is_float = type(expected_output) is float 60 | is_float_list = type(expected_output) is list and all([type(item) is float for item in expected_output]) 61 | if is_float: 62 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 63 | assert round(output - expected_output, 7) == 0, msg 64 | elif is_float_list: 65 | # Vergelijk bij floatlijst als return-type op 7 decimalen om afrondingsfouten te omzeilen 66 | assert [round(x - y, 7) for x, y in zip(output, expected_output)] == [0.0] * len(output), msg 67 | else: 68 | assert output == expected_output, msg 69 | 70 | 71 | def test_gradient_descent(): 72 | data = { 73 | 'presence': [29, 36, 41, 45, 48, 50, 56, 61, 67, 67, 67, 71, 75, 79, 83, 88], 74 | 'grade': [4.1, 4.3, 4.0, 5.2, 4.8, 4.9, 5.9, 5.2, 4.9, 5.7, 6.2, 6.1, 4.4, 6.1, 6.8, 6.9] 75 | } 76 | 77 | testcases = [ 78 | ((data['presence'], data['grade'], 1), [0.00195707, 0.07867846]), 79 | ((data['presence'], data['grade'], 10), [0.00402798, 0.07866434]), 80 | ((data['presence'], data['grade'], 100), [0.02463723, 0.07842538]), 81 | ((data['presence'], data['grade'], 1000), [0.22125887, 0.07614560]), 82 | ((data['presence'], data['grade'], 10000), [1.48364100, 0.06150855]), 83 | ((data['presence'], data['grade'], 100000), [2.40810075, 0.05078965]), 84 | ] 85 | 86 | for case in testcases: 87 | __my_assert_args(gradient_descent, case[0], case[1]) 88 | return 1 89 | 90 | 91 | def __main(): 92 | try: 93 | print("\x1b[32m") 94 | 95 | test_gradient_descent() 96 | print("Je functie gradient_descent() werkt goed!") 97 | 98 | except AssertionError as ae: 99 | print("\x1b[31m") # Rode tekstkleur 100 | if not ae: 101 | print("Je code veroorzaakt onderstaande AssertionError:") 102 | raise ae 103 | else: 104 | print(ae) 105 | print("\x1b[0m") # Reset tekstkleur 106 | 107 | 108 | if __name__ == '__main__': 109 | __main() 110 | -------------------------------------------------------------------------------- /recursie_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: recursie 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | 13 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 14 | gebruiken, zoals `math` en `statistics`. 15 | """ 16 | 17 | 18 | def faculteit_iteratief(n): 19 | """ Bereken n! op iteratieve wijze. """ 20 | res = 1 21 | 22 | # Voeg de iteratie in: for ... 23 | 24 | return res 25 | 26 | 27 | def faculteit(n): 28 | """ Bereken n! op recursieve wijze. """ 29 | # Base case 30 | if n == 0: 31 | return 1 32 | # Recursie 33 | else: 34 | return faculteit(0) 35 | 36 | 37 | def exponent(n): 38 | """ Bereken 2^n op recursieve wijze. """ 39 | # Base case 40 | 41 | # Recursie 42 | return n 43 | 44 | 45 | def som(lst): 46 | """ Bereken de som van alle elementen van gegeven lijst `lst` op recursieve wijze. """ 47 | return 1 48 | 49 | 50 | def palindroom(woord): 51 | """ 52 | Bepaal of gegeven woord een palindroom (spiegelwoord) is op recursieve wijze. 53 | 54 | Args: 55 | woord (str): Een woord. 56 | 57 | Returns: 58 | bool: Of gegeven woord een palindroom is. 59 | 60 | Examples: 61 | >> palindroom("raar") 62 | True 63 | 64 | >> palindroom("maandnaam") 65 | True 66 | 67 | >> palindroom("lekker") 68 | False 69 | """ 70 | return False 71 | 72 | 73 | """ 74 | ==========================[ HU TESTRAAMWERK ]================================ 75 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 76 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 77 | """ 78 | import math 79 | import random 80 | 81 | 82 | def test_faculteit_iteratief(): 83 | for i in range(6): 84 | assert faculteit_iteratief(i) == math.factorial(i), \ 85 | f"Fout: faculteit_iteratief({i}) geeft {faculteit_iteratief(i)} in plaats van {math.factorial(i)}" 86 | 87 | 88 | def test_faculteit(): 89 | for i in range(6): 90 | assert faculteit(i) == math.factorial(i), \ 91 | f"Fout: faculteit({i}) geeft {faculteit(i)} in plaats van {math.factorial(i)}" 92 | 93 | 94 | def test_exponent(): 95 | for i in range(10): 96 | assert exponent(i) == 2**i, \ 97 | f"Fout: exponent({i}) geeft {exponent(i)} in plaats van {2**i}" 98 | 99 | 100 | def test_som(): 101 | for i in range(6): 102 | lst_test = random.sample(range(-10, 11), i) 103 | assert som(lst_test) == sum(lst_test), \ 104 | f"Fout: som({lst_test}) geeft {som(lst_test),} in plaats van {sum(lst_test)}" 105 | 106 | 107 | def test_palindroom(): 108 | testcases = [ 109 | ("", True), 110 | ("raar", True), 111 | ("maandnaam", True), 112 | ("lekker", False), 113 | ("radar", True), 114 | ("pollepel", False), 115 | ("Maandnaam", False) 116 | ] 117 | 118 | for testcase, res in testcases: 119 | assert palindroom(testcase) is res, \ 120 | f"Fout: palindroom({testcase}) geeft {palindroom(testcase)} in plaats van {res}" 121 | 122 | 123 | if __name__ == '__main__': 124 | try: 125 | print("\x1b[32m") 126 | 127 | test_faculteit_iteratief() 128 | print("Je functie faculteit_iteratief() doorstaat de tests!") 129 | 130 | test_faculteit() 131 | print("Je functie faculteit() doorstaat de tests!") 132 | 133 | test_exponent() 134 | print("Je functie exponent() doorstaat de tests!") 135 | 136 | test_som() 137 | print("Je functie som() doorstaat de tests!") 138 | 139 | test_palindroom() 140 | print("Je functie palindroom() doorstaat de tests!") 141 | 142 | print("\x1b[0m") 143 | 144 | woord = input("Geef een woord: ") 145 | print(f"'{woord}' is {'' if palindroom(woord) else 'g'}een palindroom!") 146 | 147 | except AssertionError as ae: 148 | print("\x1b[31m") # Rode tekstkleur 149 | if not ae: 150 | print("Je code veroorzaakt onderstaande AssertionError:") 151 | raise ae 152 | else: 153 | print(ae) 154 | print("\x1b[0m") # Reset tekstkleur 155 | -------------------------------------------------------------------------------- /statistiek_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: statistiek 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | Werk onderstaande functies uit. Elke functie krijgt een niet-lege en 13 | ongesorteerde lijst *lst* met gehele getallen (int) als argument. 14 | 15 | Je kunt je functies testen met het gegeven raamwerk door het bestand 16 | uit te voeren (of met behulp van `pytest`, als je weet hoe dat werkt). 17 | Lever je werk in op Canvas als alle tests slagen. 18 | 19 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 20 | gebruiken, zoals `math` en `statistics`. 21 | """ 22 | 23 | 24 | def median(lst): 25 | """ 26 | Bepaal de mediaan van een lijst getallen. 27 | 28 | Args: 29 | lst (list): Een lijst met gehele getallen. 30 | 31 | Returns: 32 | float: De mediaan van de gegeven getallen. 33 | """ 34 | return 35 | 36 | 37 | 38 | 39 | def rnge(lst): 40 | """ 41 | Bepaal het bereik van een lijst getallen. 42 | 43 | Args: 44 | lst (list): Een lijst met gehele getallen. 45 | 46 | Returns: 47 | int: Het bereik van de gegeven getallen. 48 | """ 49 | return 50 | 51 | 52 | """ 53 | ==========================[ HU TESTRAAMWERK ]================================ 54 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 55 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 56 | """ 57 | import os 58 | 59 | 60 | def __my_assert_args(function, args, expected_output, check_type=True): 61 | """ 62 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 63 | Optioneel wordt ook het return-type gecontroleerd. 64 | """ 65 | argstr = str(args).replace(',)', ')') 66 | output = function(*args) 67 | 68 | # Controleer eerst het return-type (optioneel) 69 | if check_type: 70 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 71 | assert type(output) is type(expected_output), msg 72 | 73 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 74 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 75 | if type(expected_output) is float: 76 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 77 | assert round(output - expected_output, 7) == 0, msg 78 | else: 79 | assert output == expected_output, msg 80 | 81 | 82 | def test_rnge(): 83 | testcases = [ 84 | (([4, 2, 5, 8, 6],), 6), 85 | (([1, 3, 2, 4, 6, 2, 4, 2],), 5) 86 | ] 87 | 88 | for case in testcases: 89 | __my_assert_args(rnge, case[0], case[1]) 90 | 91 | 92 | def test_median(): 93 | testcases = [ 94 | (([4, 2, 5, 8, 6],), 5.0), 95 | (([1, 3, 4, 6, 4, 2],), 3.5), 96 | (([1, 3, 4, 6, 2, 4, 2],), 3.0), 97 | (([1, 3, 2, 4, 6, 2, 4, 2],), 2.5) 98 | ] 99 | 100 | for case in testcases: 101 | __my_assert_args(median, case[0], case[1]) 102 | 103 | 104 | def test_median_simulated(): 105 | import random 106 | import statistics 107 | 108 | for lst_size in range(1, 11): 109 | lst_test = [random.choice(range(5)) for _ in range(lst_size)] 110 | __my_assert_args(median, (lst_test,), statistics.median(lst_test), False) 111 | 112 | 113 | def __main(): 114 | """ Test alle functies. """ 115 | # Noodzakelijk voor gekleurde tekst binnen een Windows terminal 116 | os.system("") 117 | 118 | try: 119 | print("\x1b[32m") # Groene tekstkleur 120 | 121 | test_median() 122 | test_median_simulated() 123 | print("Je functie median(lst) werkt goed!") 124 | 125 | test_rnge() 126 | print("Je functie rnge(lst) werkt goed!") 127 | 128 | print("\nGefeliciteerd, alles lijkt te werken!") 129 | 130 | except AssertionError as ae: 131 | print("\x1b[31m") # Rode tekstkleur 132 | if not ae: 133 | print("Je code veroorzaakt onderstaande AssertionError:") 134 | raise ae 135 | else: 136 | print(ae) 137 | 138 | print("\x1b[0m") # Reset tekstkleur 139 | 140 | 141 | if __name__ == '__main__': 142 | __main() 143 | -------------------------------------------------------------------------------- /insertion_sort_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: insertion sort 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | 13 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 14 | gebruiken, zoals `math` en `statistics`. 15 | """ 16 | 17 | 18 | def insert(lst, grens, waarde): 19 | """ 20 | Voeg gegeven waarde in op de juiste plek van het gesorteerde deel van gegeven lijst. 21 | Er wordt gekeken vanaf de gegeven grens. 22 | 23 | Args: 24 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. Deze lijst 25 | is reeds gesorteerd van index 0 tot en met index `grens`, dus het deel `lst[0]` tot en 26 | met `lst[grens]`. 27 | grens (int): De index tot waar gegeven lijst `lst` al is gesorteerd. 28 | waarde (int): Het element dat op de juiste plek moet worden ingevoegd in het reeds gesorteerde 29 | deel van de lijst. 30 | """ 31 | # Aanpak: begin bij index `grens` en verplaats elementen groter dan `waarde` naar rechts. 32 | # Als je een waarde tegenkomt die kleiner is dan `waarde` (of het begin van lijst `lst`), 33 | # dan voeg je `waarde` in op de vrijgekomen plek. 34 | return None # De functie retourneert niets 35 | 36 | 37 | def insertion_sort(lst): 38 | """ 39 | Sorteer gegeven lijst volgens het insertion sort algoritme. 40 | 41 | Zorg dat de gegeven lijst niet verandert, maar geef een nieuwe, gesorteerde variant van de lijst terug. 42 | 43 | Args: 44 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 45 | 46 | Returns: 47 | list: Een nieuwe, gesorteerde variant van lijst `lst`. 48 | """ 49 | # Kopieer de lijst, zodat de originele lijst niet verandert 50 | return 51 | 52 | 53 | """ 54 | ==========================[ HU TESTRAAMWERK ]================================ 55 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 56 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 57 | """ 58 | import random 59 | 60 | 61 | def test_insert(): 62 | lst_res = [3, 5, 7, 11, 13, 2, 9, 14] 63 | lst_test = lst_res.copy() 64 | insert(lst_res, 4, 2) 65 | lst_correct = [2, 3, 5, 7, 11, 13, 9, 14] 66 | assert lst_res == lst_correct, \ 67 | f"Fout: insert({lst_test}, 4, 2) geeft {lst_res} in plaats van {lst_correct}" 68 | 69 | lst_test = lst_res.copy() 70 | insert(lst_res, 5, 9) 71 | lst_correct = [2, 3, 5, 7, 9, 11, 13, 14] 72 | assert lst_res == lst_correct, \ 73 | f"Fout: insert({lst_test}, 5, 9) geeft {lst_res} in plaats van {lst_correct}" 74 | 75 | lst_test = lst_res.copy() 76 | insert(lst_res, 6, 14) 77 | lst_correct = [2, 3, 5, 7, 9, 11, 13, 14] 78 | assert lst_res == lst_correct, \ 79 | f"Fout: insert({lst_test}, 6, 14) geeft {lst_res} in plaats van {lst_correct}" 80 | 81 | 82 | def test_insertion_sort(): 83 | lst_test = random.choices(range(-99, 100), k=6) 84 | lst_copy = lst_test.copy() 85 | lst_output = insertion_sort(lst_test) 86 | 87 | assert lst_copy == lst_test, "Fout: insertion_sort(lst) verandert de inhoud van lijst lst" 88 | assert lst_output == sorted(lst_test), \ 89 | f"Fout: insertion_sort({lst_test}) geeft {lst_output} in plaats van {sorted(lst_test)}" 90 | 91 | 92 | if __name__ == '__main__': 93 | try: 94 | print("\x1b[32m") 95 | 96 | test_insert() 97 | print("Je functie insert() werkt goed!") 98 | 99 | test_insertion_sort() 100 | print("Je insertion sort algoritme werkt goed!\n\nKnap gedaan!\n") 101 | 102 | print("\x1b[0m") 103 | aantal = int(input("Hoeveel elementen zal ik sorteren? ")) 104 | lijst = random.choices(range(0, 100), k=aantal) 105 | 106 | print(f"De lijst: \n\t{lijst}") 107 | gesorteerde_lijst = insertion_sort(lijst) 108 | print(f"is na sortering met jouw algoritme: \n\t{gesorteerde_lijst}") 109 | 110 | except AssertionError as ae: 111 | print("\x1b[31m") # Rode tekstkleur 112 | if not ae: 113 | print("Je code veroorzaakt onderstaande AssertionError:") 114 | raise ae 115 | else: 116 | print(ae) 117 | print("\x1b[0m") # Reset tekstkleur 118 | -------------------------------------------------------------------------------- /selection_sort_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: selection sort 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | 13 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 14 | gebruiken, zoals `math` en `statistics`. 15 | """ 16 | 17 | 18 | def swap(lst, index1, index2): 19 | """ Verwissel de waardes op positie index1 (int) en index2 (int) in lijst lst. """ 20 | lst[index1] = lst[index2] 21 | 22 | 23 | def find_index_of_minimum(lst, start_index=0): 24 | """ Vind de locatie van het minimum in lijst lst vanaf een gegeven start_index (int). """ 25 | minimum = lst[start_index] 26 | index_of_minimum = start_index 27 | 28 | # Doorloop de lijst lst vanaf start_index en 29 | # update minimum en index_of_minimum waar nodig. 30 | 31 | return index_of_minimum 32 | 33 | 34 | def selection_sort(lst): 35 | """ 36 | Sorteer gegeven lijst volgens het selection sort algoritme. 37 | 38 | Zorg dat de gegeven lijst niet verandert, maar geef een nieuwe, gesorteerde variant van de lijst terug. 39 | 40 | Args: 41 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 42 | 43 | Returns: 44 | list: Een nieuwe, gesorteerde variant van lijst `lst`. 45 | """ 46 | # Kopieer de originele lijst 47 | lst_sorted = lst.copy() 48 | 49 | # Implementeer selection sort met behulp van swap() en find_index_of_minimum() 50 | 51 | # Retourneer een gesorteerde variant van de lijst 52 | return lst_sorted 53 | 54 | 55 | """ 56 | ==========================[ HU TESTRAAMWERK ]================================ 57 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 58 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 59 | """ 60 | import random 61 | 62 | 63 | def test_swap(): 64 | lst_test = [4, 9, 7] 65 | swap(lst_test, 0, 1) 66 | assert lst_test == [9, 4, 7], "Fout: swap([4, 9, 7], 0, 1) geeft {} in plaats van {}".format(lst_test, [9, 4, 7]) 67 | 68 | lst_test = [4, 9, 7] 69 | swap(lst_test, 1, 2) 70 | assert lst_test == [4, 7, 9], "Fout: swap([4, 9, 7], 1, 2) geeft {} in plaats van {}".format(lst_test, [4, 7, 9]) 71 | 72 | lst_test = [4, 9, 7] 73 | swap(lst_test, 0, 2) 74 | assert lst_test == [7, 9, 4], "Fout: swap([4, 9, 7], 0, 2) geeft {} in plaats van {}".format(lst_test, [7, 9, 4]) 75 | 76 | 77 | def test_find_index_of_minimum(): 78 | lst_test = [18, 6, 21, 44, 9, 14] 79 | assert find_index_of_minimum(lst_test, 0) == 1, \ 80 | f"Fout: find_index_of_minimum({lst_test}, 0) geeft {find_index_of_minimum(lst_test, 0)} in plaats van 1" 81 | assert find_index_of_minimum(lst_test, 2) == 4, \ 82 | f"Fout: find_index_of_minimum({lst_test}, 2) geeft {find_index_of_minimum(lst_test, 2)} in plaats van 4" 83 | assert find_index_of_minimum(lst_test, 3) == 4, \ 84 | f"Fout: find_index_of_minimum({lst_test}, 3) geeft {find_index_of_minimum(lst_test, 3)} in plaats van 4" 85 | 86 | 87 | def test_selection_sort(): 88 | lst_test = random.choices(range(-99, 100), k=6) 89 | lst_copy = lst_test.copy() 90 | lst_output = selection_sort(lst_test) 91 | 92 | assert lst_copy == lst_test, "Fout: selection_sort(lst) verandert de inhoud van lijst lst" 93 | assert lst_output == sorted(lst_test), \ 94 | f"Fout: selection_sort({lst_test}) geeft {lst_output} in plaats van {sorted(lst_test)}" 95 | 96 | 97 | if __name__ == '__main__': 98 | try: 99 | print("\x1b[32m") 100 | 101 | test_swap() 102 | print("Je functie swap() werkt goed!") 103 | 104 | test_find_index_of_minimum() 105 | print("Je functie find_index_of_minimum() werkt goed!") 106 | 107 | test_selection_sort() 108 | print("Je selection sort algoritme werkt goed!\n\nKnap gedaan!\n") 109 | 110 | print("\x1b[0m") 111 | aantal = int(input("Hoeveel getallen zal ik sorteren? ")) 112 | lijst = random.choices(range(0, 100), k=aantal) 113 | 114 | print(f"De lijst: \n\t{lijst}") 115 | gesorteerde_lijst = selection_sort(lijst) 116 | print(f"is na sortering: \n\t{gesorteerde_lijst}") 117 | 118 | except AssertionError as ae: 119 | print("\x1b[31m") # Rode tekstkleur 120 | if not ae: 121 | print("Je code veroorzaakt onderstaande AssertionError:") 122 | raise ae 123 | else: 124 | print(ae) 125 | print("\x1b[0m") # Reset tekstkleur 126 | -------------------------------------------------------------------------------- /pic/Hogeschool_Utrecht.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 20 | 21 | 22 | 23 | 27 | 31 | 32 | 37 | 41 | 42 | 46 | 50 | 51 | 54 | 55 | 58 | 59 | 63 | 65 | 66 | 67 | 68 | 69 | -------------------------------------------------------------------------------- /bonusvraag_4_k_nearest_neighbors_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Bonusvraag: k-Nearest Neighbors 8 | 9 | (c) 2023 Hogeschool Utrecht 10 | Peter van den Berg (petervandenberg@hu.nl) 11 | 12 | Opdracht: werk onderstaande functies uit. 13 | 14 | 15 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 16 | gebruiken, zoals `math` en `statistics`. 17 | """ 18 | 19 | 20 | def euclidean_distance(x1, x2): 21 | """ 22 | Bereken de euclidische afstand tussen twee datapunten (https://en.wikipedia.org/wiki/Euclidean_distance). 23 | 24 | Args: 25 | x1 (list of int): het eerste datapunt. 26 | x2 (list of int): het tweede datapunt. 27 | 28 | Returns: 29 | float: De berekende euclidische afstand. 30 | """ 31 | distance = 0.0 32 | return distance 33 | 34 | 35 | def k_nearest_neighbors(x_train, y_train, x_test, k=3): 36 | """ 37 | Voorspel de labels van datapunten uit x_test op basis van de labels (y_train) 38 | van de k dichtstbijzijnde datapunten uit x_train met het K-nearest neighbors algoritme 39 | (zie https://medium.com/swlh/k-nearest-neighbor-ca2593d7a3c4). 40 | 41 | Args: 42 | x_train (list of list of int): een lijst met datapunten waarvan het label bekend is. 43 | y_train (list of int): een lijst met labels die bij bovenstaande datapunten horen. 44 | x_test (list of list of int): een lijst met datapunten waarvan de labels voorspeld moeten worden. 45 | k (int): het aantal datapunten uit x_train dat gebruikt wordt voor het voorspellen van het label (standaard 3). 46 | 47 | Returns: 48 | list of string: De voorspelde labels voor de datapunten uit X_test. 49 | """ 50 | predictions = [] 51 | 52 | return predictions 53 | 54 | 55 | """ 56 | ==========================[ HU TESTRAAMWERK ]================================ 57 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 58 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 59 | """ 60 | 61 | 62 | def __my_assert_args(function, args, expected_output, check_type=True): 63 | """ 64 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 65 | 66 | Optioneel wordt ook het return-type gecontroleerd. 67 | """ 68 | argstr = str(args).replace(',)', ')') 69 | output = function(*args) 70 | 71 | # Controleer eerst het return-type (optioneel) 72 | if check_type: 73 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 74 | assert type(output) is type(expected_output), msg 75 | 76 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 77 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 78 | is_float = type(expected_output) is float 79 | is_float_list = type(expected_output) is list and all([type(item) is float for item in expected_output]) 80 | if is_float: 81 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 82 | assert round(output - expected_output, 7) == 0, msg 83 | elif is_float_list: 84 | # Vergelijk bij floatlijst als return-type op 7 decimalen om afrondingsfouten te omzeilen 85 | assert [round(x - y, 7) for x, y in zip(output, expected_output)] == [0.0] * len(output), msg 86 | else: 87 | assert output == expected_output, msg 88 | 89 | 90 | def test_euclidean_distance(): 91 | testcases = [ 92 | (([1, 2, 3], [4, 5, 6]), 5.1961524), 93 | (([0, 0, 0], [0, 0, 0]), 0.0), 94 | (([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]), 0.0), 95 | (([1, 2, 3], [1, 2, 3, 4, 5]), 0.0), 96 | (([1, 2, 3, 5, 7, 11, 12], [1, 1, 2, 3, 4, 5, 8]), 8.1853528), 97 | ] 98 | 99 | for case in testcases: 100 | __my_assert_args(euclidean_distance, case[0], case[1]) 101 | return 1 102 | 103 | 104 | def test_k_nearest_neighbors(): 105 | testcases = [ 106 | ([[[1, 2], [3, 4], [5, 6]], ["appel", "peer", "appel"], [[2, 3]], 2], ["appel"]), 107 | ([[[-1, -2], [-3, -4], [-5, -6]], 108 | ["tablet", "tablet", "mobiel"], 109 | [[-2, -3], [-4, -5]], 1], 110 | ["tablet", "tablet"]), 111 | ([[[2, -3], [7, -4], [11, -6]], ["vrolijk", "boos", "boos"], [[1, -3], [10, -6]], 1], ['vrolijk', 'boos']), 112 | ([ 113 | [[2, 3], [5, -4], [1, 6], [5, 3], [9, -40], [15, -16]], 114 | ["goud", "zilver", "brons", "goud", "zilver", "brons"], 115 | [[5, -4], [10, -6], [11, -30], [-7, 6]], 1], 116 | ['zilver', 'zilver', 'zilver', 'brons']), 117 | ([ 118 | [[2, 3], [5, -4], [1, 6], [5, 3], [9, -40], [15, -16]], 119 | ["goud", "zilver", "brons", "goud", "zilver", "brons"], 120 | [[2, 3], [11, -30], [-7, 6]], 3], 121 | ['goud', 'zilver', 'goud']), 122 | ] 123 | 124 | for case in testcases: 125 | __my_assert_args(k_nearest_neighbors, case[0], case[1]) 126 | return 1 127 | 128 | 129 | def __main(): 130 | try: 131 | print("\x1b[32m") 132 | 133 | test_euclidean_distance() 134 | print("Je functie euclidean_distance() werkt goed!") 135 | 136 | test_k_nearest_neighbors() 137 | print("Je functie k_nearest_neighbors() werkt goed!") 138 | 139 | except AssertionError as ae: 140 | print("\x1b[31m") # Rode tekstkleur 141 | if not ae: 142 | print("Je code veroorzaakt onderstaande AssertionError:") 143 | raise ae 144 | else: 145 | print(ae) 146 | print("\x1b[0m") # Reset tekstkleur 147 | 148 | 149 | if __name__ == '__main__': 150 | __main() 151 | -------------------------------------------------------------------------------- /search_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Oefening: zoeken 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | 13 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 14 | gebruiken, zoals `math` en `statistics`. 15 | """ 16 | 17 | 18 | def linear_search(lst, target): 19 | """ 20 | Bepaal of gegeven element voorkomt in de lijst volgens het lineair zoekalgoritme. 21 | 22 | Args: 23 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 24 | target (int): Een gezocht element. 25 | 26 | Returns: 27 | bool: Of het gezochte element voorkomt in de lijst. 28 | """ 29 | return False 30 | 31 | 32 | def linear_search_index(lst, target): 33 | """ 34 | Bepaal de positie van gegeven element in de lijst volgens het lineair zoekalgoritme. 35 | 36 | Args: 37 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 38 | target (int): Een gezocht element. 39 | 40 | Returns: 41 | int: De index waar het element in de lijst staat, of -1 als het element niet in de lijst voorkomt. 42 | """ 43 | index = 0 44 | return -1 45 | 46 | 47 | def binary_search(lst, target): 48 | """ 49 | Bepaal of gegeven element voorkomt in de lijst volgens het binair zoekalgoritme. 50 | 51 | Args: 52 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 53 | target (int): Een gezocht element. 54 | 55 | Returns: 56 | bool: Of het gezochte element voorkomt in de lijst. 57 | """ 58 | # Stap 1. 59 | mini = 0 60 | 61 | # Stap 6. (!) 62 | while False: # hoelang ga je door met zoeken? 63 | # Stap 2. 64 | # Stap 3. 65 | return True 66 | # Stap 4. 67 | # Stap 5. 68 | 69 | return False 70 | 71 | 72 | def binary_search_index(lst, target): 73 | """ 74 | Bepaal de positie van gegeven element in de lijst volgens het binair zoekalgoritme. 75 | 76 | Args: 77 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 78 | target (int): Een gezocht element. 79 | 80 | Returns: 81 | int: De index waar het element in de lijst staat, of -1 als het element niet in de lijst voorkomt. 82 | """ 83 | return -1 84 | 85 | 86 | def linear_search_index_steps(lst, target): 87 | """ 88 | Bepaal de positie van gegeven element in de lijst volgens het lineair zoekalgoritme. Geef ook het benodigd 89 | aantal zoekstappen. 90 | 91 | Args: 92 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 93 | target (int): Een gezocht element. 94 | 95 | Returns: 96 | tuple: De index waar het element in de lijst staat en het benodigde aantal zoekstappen. 97 | """ 98 | index = 0 99 | steps = 0 100 | return -1, steps 101 | 102 | 103 | def binary_search_index_steps(lst, target): 104 | """ 105 | Bepaal de positie van gegeven element in de lijst volgens het binair zoekalgoritme. Geef ook het benodigd 106 | aantal zoekstappen. 107 | 108 | Args: 109 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 110 | target (int): Een gezocht element. 111 | 112 | Returns: 113 | tuple: De index waar het element in de lijst staat en het benodigde aantal zoekstappen. 114 | """ 115 | steps = 0 116 | 117 | return -1, steps 118 | 119 | 120 | """ 121 | ==========================[ HU TESTRAAMWERK ]================================ 122 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 123 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 124 | """ 125 | import random 126 | 127 | 128 | def test_linear_search(): 129 | for i in range(10): 130 | lst_test = random.sample(range(20), 10) 131 | target = random.randrange(20) 132 | assert linear_search(lst_test, target) == (target in lst_test), \ 133 | f"Fout: linear_search({lst_test}, {target}) geeft {linear_search(lst_test, target)} " \ 134 | f"in plaats van {target in lst_test}" 135 | 136 | 137 | def test_linear_search_index(): 138 | for i in range(10): 139 | lst_test = random.sample(range(20), 10) 140 | target = random.choice(lst_test) 141 | assert linear_search_index(lst_test, target) == lst_test.index(target), \ 142 | f"Fout: linear_search_index({lst_test}, {target}) geeft {linear_search_index(lst_test, target)} " \ 143 | f"in plaats van {lst_test.index(target)}" 144 | 145 | lst_test = [0, 1, 2] 146 | assert linear_search_index(lst_test, 3) == -1, f"Fout: linear_search_index({lst_test}, {3}) geeft " \ 147 | f"{linear_search_index(lst_test, 3)} in plaats van {-1}" 148 | 149 | 150 | def test_linear_search_index_steps(): 151 | for i in range(10): 152 | lst_test = random.sample(range(20), 10) 153 | target = random.choice(lst_test) 154 | assert linear_search_index_steps(lst_test, target)[0] == lst_test.index(target), \ 155 | f"Fout: linear_search_index_steps({lst_test}, {target}) geeft " \ 156 | f"{linear_search_index_steps(lst_test, target)[0]} in plaats van {lst_test.index(target)}" 157 | 158 | 159 | def test_binary_search(): 160 | for i in range(10): 161 | lst_test = sorted(random.sample(range(20), 10)) 162 | target = random.randrange(20) 163 | assert binary_search(lst_test, target) == (target in lst_test), \ 164 | f"Fout: binary_search({lst_test}, {target}) geeft {binary_search(lst_test, target)} " \ 165 | f"in plaats van {target in lst_test}" 166 | 167 | 168 | def test_binary_search_index(): 169 | for i in range(10): 170 | lst_test = sorted(random.sample(range(20), 10)) 171 | target = random.choice(lst_test) 172 | assert binary_search_index(lst_test, target) == lst_test.index(target), \ 173 | f"Fout: binary_search_index({lst_test}, {target}) geeft {binary_search_index(lst_test, target)} " \ 174 | f"in plaats van {lst_test.index(target)}" 175 | 176 | lst_test = [0, 1, 2] 177 | assert binary_search_index(lst_test, 3) == -1, \ 178 | f"Fout: binary_search_index({lst_test}, {3}) geeft {binary_search_index(lst_test, 3)} in plaats van {-1}" 179 | 180 | 181 | def test_binary_search_index_steps(): 182 | for i in range(10): 183 | lst_test = sorted(random.sample(range(20), 10)) 184 | target = random.choice(lst_test) 185 | assert binary_search_index_steps(lst_test, target)[0] == lst_test.index(target), \ 186 | f"Fout: binary_search_index_steps({lst_test}, {target}) geeft " \ 187 | f"{binary_search_index_steps(lst_test, target)[0]} in plaats van {lst_test.index(target)}" 188 | 189 | 190 | if __name__ == '__main__': 191 | try: 192 | print("\x1b[32m") 193 | 194 | test_linear_search() 195 | print("Je functie linear_search() werkt goed!") 196 | 197 | test_linear_search_index() 198 | print("Je functie linear_search_index() werkt goed!") 199 | 200 | test_binary_search() 201 | print("Je functie binary_search() werkt goed!") 202 | 203 | test_binary_search_index() 204 | print("Je functie binary_search_index() werkt goed!") 205 | 206 | test_linear_search_index_steps() 207 | print("Je functie linear_search_index_steps() werkt goed!") 208 | 209 | test_binary_search_index_steps() 210 | print("Je functie binary_search_index_steps() werkt goed!") 211 | 212 | print("\x1b[0m") 213 | size = int(input("Geef een grootte voor de lijst: ")) 214 | lst_input = list(range(size)) 215 | print("Ik ga zoeken in:", lst_input) 216 | tgt = int(input("Geef een getal: ")) 217 | 218 | (idx, cnt) = linear_search_index_steps(lst_input, tgt) 219 | print(f"Het lineair zoekalgoritme vond '{tgt}' op index '{idx}' na {cnt} stappen.") 220 | 221 | (idx, cnt) = binary_search_index_steps(lst_input, tgt) 222 | print(f"Het binair zoekalgoritme vond '{tgt}' op index '{idx}' na {cnt} stappen.") 223 | 224 | except AssertionError as ae: 225 | print("\x1b[31m") # Rode tekstkleur 226 | if not ae: 227 | print("Je code veroorzaakt onderstaande AssertionError:") 228 | raise ae 229 | else: 230 | print(ae) 231 | print("\x1b[0m") # Reset tekstkleur 232 | -------------------------------------------------------------------------------- /final_assignment_getallen_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Final assignment: getallen 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Peter van den Berg (peter.vandenberg@hu.nl) 11 | Bart van Eijkelenburg 12 | Tijmen Muller (tijmen.muller@hu.nl) 13 | 14 | 15 | Opdracht: 16 | Beantwoord onderstaande vragen en werk onderstaande functies uit. 17 | Voeg commentaar toe om je code toe te lichten. 18 | 19 | Je kunt je functies testen met het gegeven raamwerk door het bestand 20 | uit te voeren (of met behulp van `pytest`, als je weet hoe dat werkt). 21 | Lever je werk in op Canvas als alle tests slagen. 22 | 23 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 24 | gebruiken, zoals `math` en `statistics`. 25 | """ 26 | 27 | # TODO: Vul hier je naam, klas en studentnummer in. 28 | naam = "" 29 | klas = "" 30 | studentnummer = -1 31 | 32 | """ 33 | 1. Pseudocode ceil 34 | 35 | Schrijf Nederlandse pseudocode voor een algoritme voor de functie ceil() (zie onder). 36 | Gebruik hoofdletters voor de keywords in je pseudocode. 37 | 38 | """ 39 | # TODO: [geef hier je antwoord] 40 | 41 | """ 42 | 2. Pseudocode meetkundige rij 43 | 44 | Schrijf Nederlandse pseudocode voor een algoritme voor de functie meetkundige_rij() (zie onder). 45 | Gebruik hoofdletters voor de keywords in je pseudocode. 46 | 47 | """ 48 | # TODO: [geef hier je antwoord] 49 | 50 | 51 | def ceil(real): 52 | """ 53 | Bepaal het kleinste gehele getal (int), groter dan of gelijk aan het gegeven reeele getal (float). 54 | 55 | Args: 56 | real (float): Een reeel getal. 57 | 58 | Returns: 59 | int: Het kleinste gehele getal (int), groter dan of gelijk aan het gegeven reeele getal (float). 60 | """ 61 | return 0 62 | 63 | 64 | def is_even(n): 65 | """ 66 | Bepaal of een geheel getal even is. 67 | 68 | Args: 69 | n (int): Een geheel getal. 70 | 71 | Returns: 72 | bool: True als even, False als oneven. 73 | """ 74 | return False 75 | 76 | 77 | def is_odd(n): 78 | """ 79 | Bepaal of een geheel getal oneven is. 80 | 81 | Args: 82 | n (int): Een geheel getal. 83 | 84 | Returns: 85 | bool: True als oneven, False als even. 86 | """ 87 | return False 88 | 89 | 90 | def nround(real): 91 | """ 92 | Bepaal het gehele getal (int) dat het dichtst bij het gegeven reeele getal (float) zit. 93 | 94 | Args: 95 | real (float): Een reeel getal. 96 | 97 | Returns: 98 | int: Het gehele getal (int) dat het dichtst bij het gegeven reeele getal (float) zit. 99 | """ 100 | 101 | return 0 102 | 103 | 104 | def meetkundige_rij(start, factor, exponent): 105 | """ 106 | Bereken een meetkundige rij (a_n = a_0 · r^n) gegeven een startgetal, een factor en een exponent. 107 | 108 | Args: 109 | start (int): Het getal waar de rij mee begint 110 | factor (int): de factor van de rij 111 | exponent (int): de exponent van de rij 112 | 113 | Returns: 114 | list of int: de meetkundige rij 115 | """ 116 | rij = [] 117 | return rij 118 | 119 | 120 | def dec2bin(n): 121 | """ 122 | Bepaal de binaire representatie van een getal uit het decimale talstelsel. 123 | 124 | Args: 125 | n (int): Een geheel, positief getal uit het decimale talstelsel. 126 | 127 | Returns: 128 | tuple: Binaire representatie van het gegeven getal. 129 | 130 | Examples: 131 | >> dec2bin(0) 132 | (0,) 133 | 134 | >> dec2bin(2) 135 | (1, 0) 136 | 137 | >> dec2bin(3) 138 | (1, 1) 139 | 140 | >> dec2bin(16) 141 | (1, 0, 0, 0, 0) 142 | """ 143 | return (0,) 144 | 145 | 146 | """ 147 | ==========================[ HU TESTRAAMWERK ]================================ 148 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 149 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 150 | """ 151 | # import random 152 | 153 | 154 | def __my_assert_args(function, args, expected_output, check_type=True): 155 | """ 156 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 157 | 158 | Optioneel wordt ook het return-type gecontroleerd. 159 | """ 160 | argstr = str(args).replace(',)', ')') 161 | output = function(*args) 162 | 163 | # Controleer eerst het return-type (optioneel) 164 | if check_type: 165 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 166 | assert type(output) is type(expected_output), msg 167 | 168 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 169 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 170 | if type(expected_output) is float: 171 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 172 | assert round(output - expected_output, 7) == 0, msg 173 | else: 174 | assert output == expected_output, msg 175 | 176 | 177 | def test_id(): 178 | assert naam != "", "Je moet je naam nog invullen!" 179 | assert studentnummer != -1, "Je moet je studentnummer nog invullen!" 180 | assert klas != "", "Je moet je klas nog invullen!" 181 | 182 | 183 | def test_ceil(): 184 | testcases = [ 185 | ((1.05,), 2), 186 | ((1.95,), 2), 187 | ((-1.05,), -1), 188 | ((-1.95,), -1), 189 | ((0.05,), 1), 190 | ((-0.05,), 0), 191 | ((0.0, ), 0), 192 | ((1.0, ), 1), 193 | ((-1.0, ), -1) 194 | ] 195 | 196 | for case in testcases: 197 | __my_assert_args(ceil, case[0], case[1]) 198 | 199 | 200 | def test_nround(): 201 | testcases = [ 202 | ((1.05,), 1), 203 | ((1.95,), 2), 204 | ((-1.05,), -1), 205 | ((-1.95,), -2), 206 | ((0.05,), 0), 207 | ((-0.05,), 0), 208 | ((0.0, ), 0), 209 | ((1.0, ), 1), 210 | ((-1.0, ), -1) 211 | ] 212 | 213 | for case in testcases: 214 | __my_assert_args(nround, case[0], case[1]) 215 | 216 | 217 | def test_is_even(): 218 | testcases = [ 219 | ((1,), False), 220 | ((2,), True), 221 | ((3,), False), 222 | ((4,), True), 223 | ((-1,), False), 224 | ((-2,), True) 225 | ] 226 | 227 | for case in testcases: 228 | __my_assert_args(is_even, case[0], case[1]) 229 | 230 | 231 | def test_is_odd(): 232 | testcases = [ 233 | ((1,), True), 234 | ((2,), False), 235 | ((3,), True), 236 | ((4,), False), 237 | ((-1,), True), 238 | ((-2,), False) 239 | ] 240 | 241 | for case in testcases: 242 | __my_assert_args(is_odd, case[0], case[1]) 243 | 244 | 245 | def test_meetkundige_rij(): 246 | testcases = [ 247 | ((1, 2, 3), [1, 2, 4]), 248 | ((3, 4, 5), [3, 12, 48, 192, 768]), 249 | ((3, 5, 7), [3, 15, 75, 375, 1875, 9375, 46875]), 250 | ((5, 2, 5), [5, 10, 20, 40, 80]), 251 | ((5, 3, 5), [5, 15, 45, 135, 405]), 252 | ((10, 10, 10), [10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000]) 253 | ] 254 | 255 | for case in testcases: 256 | __my_assert_args(meetkundige_rij, case[0], case[1]) 257 | return 1 258 | 259 | 260 | def test_dec2bin(): 261 | testcases = [ 262 | ((0,), (0, )), 263 | ((1,), (1, )), 264 | ((2,), (1, 0)), 265 | ((3,), (1, 1)), 266 | ((7,), (1, 1, 1)), 267 | ((8,), (1, 0, 0, 0)), 268 | ((255,), (1, 1, 1, 1, 1, 1, 1, 1)), 269 | ] 270 | 271 | for case in testcases: 272 | __my_assert_args(dec2bin, case[0], case[1]) 273 | 274 | 275 | def __main(): 276 | """ Test alle functies. """ 277 | # Noodzakelijk voor gekleurde tekst binnen een Windows terminal 278 | import os 279 | os.system("") 280 | 281 | try: 282 | print("\x1b[32m") 283 | test_id() 284 | 285 | test_ceil() 286 | print("Je functie ceil() werkt goed!") 287 | 288 | test_is_even() 289 | print("Je functie is_even() werkt goed!") 290 | 291 | test_is_odd() 292 | print("Je functie is_odd() werkt goed!") 293 | 294 | test_nround() 295 | print("Je functie nround() werkt goed!") 296 | 297 | test_meetkundige_rij() 298 | print("Je functie meetkundige_rij() werkt goed!") 299 | 300 | test_dec2bin() 301 | print("Je functie dec2bin() werkt goed!") 302 | 303 | except AssertionError as ae: 304 | print("\x1b[31m") # Rode tekstkleur 305 | if not ae: 306 | print("Je code veroorzaakt onderstaande AssertionError:") 307 | raise ae 308 | else: 309 | print(ae) 310 | print("\x1b[0m") # Reset tekstkleur 311 | 312 | 313 | if __name__ == '__main__': 314 | __main() 315 | -------------------------------------------------------------------------------- /final_assignment_algoritmiek_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | """ 5 | Oriëntatie op AI 6 | 7 | Final assignment: algoritmiek 8 | 9 | (c) 2019 Hogeschool Utrecht, 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | Opdracht: 13 | Beantwoord onderstaande vragen en werk onderstaande functies uit. 14 | Voeg commentaar toe om je code toe te lichten. 15 | 16 | Je kunt je functies testen met het gegeven raamwerk door het bestand 17 | uit te voeren (of met behulp van `pytest`, als je weet hoe dat werkt). 18 | Lever je werk in op Canvas als alle tests slagen. 19 | 20 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 21 | gebruiken, zoals `math` en `statistics`. 22 | """ 23 | 24 | # TODO: Vul hier je naam, klas en studentnummer in. 25 | naam = "" 26 | klas = "" 27 | studentnummer = -1 28 | 29 | """ 30 | 1. Sorteeralgoritme 31 | 32 | Hieronder staat de pseudocode van een sorteeralgoritme: 33 | 1. Startend vanaf het begin van een lijst, vergelijk elk element met zijn volgende buur. 34 | 2. Als het element groter is dan zijn volgende buur, verwissel ze van plaats. 35 | 3. Doorloop zo de lijst tot het eind. 36 | 4. Als er verwisselingen zijn geweest bij stap 2., ga naar stap 1. 37 | 38 | 1a. Handmatig toepassen 39 | Gegeven is de lijst l = [ 4, 3, 1, 2 ]. Geef de waardes die deze 40 | lijst aanneemt bij álle tussenstappen bij toepassing van 41 | bovenstaand sorteeralgoritme. 42 | """ 43 | # TODO: [geef hier je antwoord] 44 | """ 45 | 46 | 1b. Implementatie 47 | Implementeer het sorteeralgoritme in Python in een functie 48 | hieronder genaamd my_sort(lst). 49 | Let op: je *moet* de pseudocode volgen! 50 | 51 | 1c. Best en worst case 52 | - Stel je hebt een lijst met de waarden 1, 2 en 3. Bij welke 53 | volgorde van de waarden in de lijst is het sorteeralgoritme 54 | het snelste klaar (best-case scenario)? 55 | Hoeveel vergelijkingen (zoals beschreven in stap 1. van de 56 | pseudocode) zijn nodig geweest? 57 | """ 58 | # TODO: [geef hier je antwoord] 59 | """ 60 | 61 | 62 | - Bij welke volgorde van de waarden in de lijst is het 63 | sorteeralgoritme het minst snel klaar (worst-case scenario)? 64 | Hoeveel vergelijkingen zijn nodig geweest? 65 | """ 66 | # TODO: [geef hier je antwoord] 67 | """ 68 | 69 | 70 | - Stel je hebt een lijst met de waarden 1 tot en met 4. 71 | Wat is nu het best-case scenario? 72 | Hoeveel vergelijkingen zijn er nodig? 73 | En wat is nu het worst-case scenario? 74 | Hoeveel vergelijkingen zijn er nodig? 75 | """ 76 | # TODO: [geef hier je antwoord] 77 | """ 78 | 79 | 80 | - (Optioneel) Stel je hebt een lijst met de waarden 1 tot en met n 81 | (je weet nu dus niet precies hoeveel waarden er in de lijst 82 | zitten, het zijn er 'n'). 83 | Wat is nu het best-case scenario? 84 | Hoeveel vergelijkingen zijn er nodig? 85 | En wat is nu het worst-case scenario? 86 | Hoeveel vergelijkingen zijn er nodig? 87 | """ 88 | # TODO: [geef hier je antwoord] 89 | """ 90 | """ 91 | 92 | 93 | def my_sort(lst): 94 | """ 95 | Sorteer gegeven lijst volgens het algoritme zoals beschreven in de pseudocode. 96 | 97 | 1. Startend vanaf het begin van een lijst, vergelijk elk element met zijn volgende buur. 98 | 2. Als het element groter is dan zijn volgende buur, verwissel ze van plaats. 99 | 3. Doorloop zo de lijst tot het eind. 100 | 4. Als er verwisselingen zijn geweest bij stap 2., ga naar stap 1. 101 | 102 | Zorg dat de gegeven lijst niet verandert, maar geef een nieuwe, gesorteerde variant van de lijst terug. 103 | 104 | Args: 105 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 106 | 107 | Returns: 108 | list: Een nieuwe, gesorteerde variant van lijst `lst`. 109 | """ 110 | lst_sorted = None 111 | return lst_sorted 112 | 113 | 114 | def linear_search_recursive(lst, target): 115 | """ 116 | Zoek een element in de gegeven lijst door middel van recursief lineair zoeken. 117 | 118 | Zorg dat de inhoud van de gegeven lijst niet verandert. 119 | 120 | Args: 121 | lst (list): Een lijst met elementen van gelijk type, bijvoorbeeld gehele getallen. 122 | target (int): Het gezochte element. 123 | 124 | Returns: 125 | bool: Of het element in de lijst voorkomt. 126 | """ 127 | return False 128 | 129 | 130 | def rekenkundige_rij_element(n, a_0, c): 131 | """ 132 | Bepaal de waarde van element met index n van een rekenkundige rij op recursieve wijze. 133 | 134 | Args: 135 | n (int): De index van de gezochte waarde. 136 | a_0 (int): Het getal waar de rij mee begint. 137 | c (int): De stapgrootte van de rij. 138 | 139 | Returns: 140 | int: De waarde van element a_n. 141 | """ 142 | return 0 143 | 144 | 145 | """ 146 | ==========================[ HU TESTRAAMWERK ]================================ 147 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 148 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 149 | """ 150 | import random 151 | 152 | 153 | def __my_assert_args(function, args, expected_output, check_type=True): 154 | """ 155 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 156 | 157 | Optioneel wordt ook het return-type gecontroleerd. 158 | """ 159 | argstr = str(args).replace(',)', ')') 160 | output = function(*args) 161 | 162 | # Controleer eerst het return-type (optioneel) 163 | if check_type: 164 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 165 | assert type(output) is type(expected_output), msg 166 | 167 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 168 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 169 | if type(expected_output) is float: 170 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 171 | assert round(output - expected_output, 7) == 0, msg 172 | else: 173 | assert output == expected_output, msg 174 | 175 | 176 | def test_id(): 177 | assert naam != "", "Je moet je naam nog invullen!" 178 | assert studentnummer != -1, "Je moet je studentnummer nog invullen!" 179 | assert klas != "", "Je moet je klas nog invullen!" 180 | 181 | 182 | def test_my_sort(): 183 | lst_test = random.choices(range(-99, 100), k=6) 184 | lst_copy = lst_test.copy() 185 | lst_output = my_sort(lst_test) 186 | 187 | assert lst_copy == lst_test, "Fout: my_sort(lst) verandert de inhoud van lijst lst" 188 | assert lst_output == sorted(lst_test), \ 189 | f"Fout: my_sort({lst_test}) geeft {lst_output} in plaats van {sorted(lst_test)}" 190 | 191 | 192 | def test_linear_search_recursive(): 193 | for _ in range(10): 194 | lst_test = random.sample(range(20), 6) 195 | target = random.randrange(20) 196 | found = target in lst_test 197 | lst_copy = lst_test.copy() 198 | 199 | outcome = linear_search_recursive(lst_test, target) 200 | assert lst_copy == lst_test, "Fout: linear_search_recursive(lst, target) verandert de inhoud van lijst lst" 201 | assert outcome == found, \ 202 | f"Fout: linear_search_recursive({lst_test}, {target}) geeft {outcome} in plaats van {found}" 203 | 204 | 205 | def test_rekenkundige_rij_element(): 206 | testcases = [ 207 | ((0, 0, 0), 0), 208 | ((0, 1, 5), 1), 209 | ((0, 5, 1), 5), 210 | ((1, 1, 5), 6), 211 | ((1, 5, 5), 10), 212 | ((5, 1, 5), 26), 213 | ((5, 5, 1), 10), 214 | ((5, 5, 2), 15), 215 | ((5, 5, 5), 30), 216 | ] 217 | 218 | for case in testcases: 219 | __my_assert_args(rekenkundige_rij_element, case[0], case[1]) 220 | return 1 221 | 222 | 223 | def __main(): 224 | """ Test alle functies. """ 225 | # Noodzakelijk voor gekleurde tekst binnen een Windows terminal 226 | import os 227 | os.system("") 228 | 229 | try: 230 | print("\x1b[32m") # Groene tekstkleur 231 | test_id() 232 | 233 | test_my_sort() 234 | print("Je functie my_sort() werkt goed!") 235 | 236 | test_linear_search_recursive() 237 | print("Je functie linear_search_recursive() werkt goed!") 238 | 239 | test_rekenkundige_rij_element() 240 | print("Je functie rekenkundige_rij_element() werkt goed!") 241 | 242 | print("\nGefeliciteerd, alles lijkt te werken!") 243 | print("Lever je werk nu in op Canvas...") 244 | 245 | except AssertionError as ae: 246 | print("\x1b[31m") # Rode tekstkleur 247 | if not ae: 248 | print("Je code veroorzaakt onderstaande AssertionError:") 249 | raise ae 250 | else: 251 | print(ae) 252 | 253 | print("\x1b[0m") # Reset tekstkleur 254 | 255 | 256 | if __name__ == '__main__': 257 | __main() 258 | -------------------------------------------------------------------------------- /final_assignment_statistiek_student.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Oriëntatie op AI 5 | 6 | Final assignment: statistiek 7 | 8 | (c) 2019 Hogeschool Utrecht, 9 | Bart van Eijkelenburg 10 | Tijmen Muller (tijmen.muller@hu.nl) 11 | 12 | Opdracht: 13 | Werk onderstaande functies uit. Elke functie krijgt een niet-lege en 14 | ongesorteerde lijst *lst* met gehele getallen (int) als argument. 15 | Voeg commentaar toe om je code toe te lichten. 16 | 17 | Je kunt je functies testen met het gegeven raamwerk door het bestand 18 | uit te voeren (of met behulp van `pytest`, als je weet hoe dat werkt). 19 | Lever je werk in op Canvas als alle tests slagen. 20 | 21 | Let op! Het is niet toegestaan om bestaande modules te importeren en te 22 | gebruiken, zoals `math` en `statistics`. 23 | """ 24 | 25 | # TODO: Vul hier je naam, klas en studentnummer in. 26 | naam = "" 27 | klas = "" 28 | studentnummer = -1 29 | 30 | """ 31 | 1. Pseudocode derde kwartiel 32 | 33 | Schrijf Nederlandse pseudocode voor een algoritme voor de functie q3() (zie onder). 34 | Gebruik hoofdletters voor de keywords in je pseudocode. 35 | 36 | """ 37 | # TODO: [geef hier je antwoord] 38 | 39 | """ 40 | 2. Pseudocode frequentie 41 | 42 | Schrijf Nederlandse pseudocode voor een algoritme voor de functie freq() (zie onder). 43 | Gebruik hoofdletters voor de keywords in je pseudocode. 44 | 45 | """ 46 | # TODO: [geef hier je antwoord] 47 | 48 | 49 | def mean(lst): 50 | """ 51 | Bepaal het gemiddelde van een lijst getallen. 52 | 53 | Args: 54 | lst (list): Een lijst met gehele getallen. 55 | 56 | Returns: 57 | float: Het gemiddelde van de gegeven getallen. 58 | """ 59 | return 60 | 61 | 62 | def q1(lst): 63 | """ 64 | Bepaal het eerste kwartiel Q1 van een lijst getallen. 65 | 66 | Hint: maak gebruik van `median()` 67 | 68 | Args: 69 | lst (list): Een lijst met gehele getallen. 70 | 71 | Returns: 72 | float: Het eerste kwartiel Q1 van de gegeven getallen. 73 | """ 74 | return 75 | 76 | 77 | def q3(lst): 78 | """ 79 | Bepaal het derde kwartiel Q3 van een lijst getallen. 80 | 81 | Args: 82 | lst (list): Een lijst met gehele getallen. 83 | 84 | Returns: 85 | float: Het derde kwartiel Q3 van de gegeven getallen. 86 | """ 87 | return 88 | 89 | 90 | def var(lst): 91 | """ 92 | Bepaal de variantie van een lijst getallen. 93 | 94 | Args: 95 | lst (list): Een lijst met gehele getallen. 96 | 97 | Returns: 98 | float: De variantie van de gegeven getallen. 99 | """ 100 | return 101 | 102 | 103 | def std(lst): 104 | """ 105 | Bepaal de standaardafwijking van een lijst getallen. 106 | 107 | Args: 108 | lst (list): Een lijst met gehele getallen. 109 | 110 | Returns: 111 | float: De standaardafwijking van de gegeven getallen. 112 | """ 113 | return 114 | 115 | 116 | def freq(lst): 117 | """ 118 | Bepaal de frequenties van alle getallen in een lijst. 119 | 120 | Args: 121 | lst (list): Een lijst met gehele getallen. 122 | 123 | Returns: 124 | dict: Een dictionary met als 'key' de waardes die voorkomen in de lijst 125 | en als 'value' het aantal voorkomens (de frequentie) van die waarde. 126 | 127 | Examples: 128 | >> freq([0, 0, 4, 7, 7]) 129 | {0: 2, 4: 1, 7: 2} 130 | 131 | >> freq([1, 1, 2, 3, 2, 1]) 132 | {1: 3, 2: 2, 3: 1} 133 | """ 134 | freqs = dict() 135 | return freqs 136 | 137 | 138 | def modes(lst): 139 | """ 140 | Bepaal alle modi van een lijst getallen. 141 | 142 | Hint: maak gebruik van `freq()`. 143 | 144 | Args: 145 | lst (list): Een lijst met gehele getallen. 146 | 147 | Returns: 148 | list: Een gesorteerde lijst van de modi van de gegeven getallen. 149 | 150 | Examples: 151 | >> modes([0, 0, 4, 7, 7]) 152 | [0, 7] 153 | 154 | >> modes([1, 1, 2, 3, 2, 1]) 155 | [1] 156 | """ 157 | modi = [] 158 | return sorted(modi) 159 | 160 | 161 | """ 162 | ==========================[ HU TESTRAAMWERK ]================================ 163 | Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! 164 | Je kunt je code testen door deze file te runnen of met behulp van pytest. 165 | """ 166 | import os 167 | import sys 168 | 169 | def __my_assert_args(function, args, expected_output, check_type=True): 170 | """ 171 | Controleer of gegeven functie met gegeven argumenten het verwachte resultaat oplevert. 172 | Optioneel wordt ook het return-type gecontroleerd. 173 | """ 174 | argstr = str(args).replace(',)', ')') 175 | output = function(*args) 176 | 177 | # Controleer eerst het return-type (optioneel) 178 | if check_type: 179 | msg = f"Fout: {function.__name__}{argstr} geeft geen {type(expected_output)} terug als return-type" 180 | assert type(output) is type(expected_output), msg 181 | 182 | # Controleer of de functie-uitvoer overeenkomt met de gewenste uitvoer 183 | msg = f"Fout: {function.__name__}{argstr} geeft {output} in plaats van {expected_output}" 184 | if type(expected_output) is float: 185 | # Vergelijk bij float als return-type op 7 decimalen om afrondingsfouten te omzeilen 186 | assert round(output - expected_output, 7) == 0, msg 187 | else: 188 | assert output == expected_output, msg 189 | 190 | 191 | def test_id(): 192 | assert naam != "", "Je moet je naam nog invullen!" 193 | assert studentnummer != -1, "Je moet je studentnummer nog invullen!" 194 | assert klas != "", "Je moet je klas nog invullen!" 195 | 196 | 197 | def test_mean(): 198 | testcases = [ 199 | (([4, 2, 5, 8, 6],), 5.0), 200 | (([1, 3, 2, 4, 6, 2, 4, 2],), 3.0) 201 | ] 202 | 203 | for case in testcases: 204 | __my_assert_args(mean, case[0], case[1]) 205 | 206 | 207 | def test_mean_simulated(): 208 | import random 209 | import statistics 210 | 211 | for lst_size in range(1, 11): 212 | lst_test = [random.choice(range(5)) for _ in range(lst_size)] 213 | __my_assert_args(mean, (lst_test,), statistics.mean(lst_test), False) 214 | 215 | 216 | def test_q1(): 217 | testcases = [ 218 | (([4, 2, 5, 8, 6],), 3.0), 219 | (([1, 3, 4, 6, 4, 2],), 2.0), 220 | (([1, 3, 5, 6, 1, 4, 2],), 1.0), 221 | (([5, 7, 4, 4, 6, 2, 8],), 4.0), 222 | (([0, 5, 5, 6, 7, 7, 12],), 5.0), 223 | (([1, 4, 3, 5, 6, 2, 4, 1],), 1.5), 224 | (([3, 5, 7, 8, 9, 11, 15, 16, 20, 21],), 7.0), 225 | (([1, 2, 5, 6, 7, 9, 12, 15, 18, 19, 27],), 5.0), 226 | (([0, 1, 2, 2, 2, 2, 3, 5, 5],), 1.5), 227 | 228 | ] 229 | 230 | for case in testcases: 231 | __my_assert_args(q1, case[0], case[1]) 232 | 233 | 234 | def test_q3(): 235 | testcases = [ 236 | (([4, 2, 5, 8, 6],), 7.0), 237 | (([1, 3, 4, 6, 4, 2],), 4.0), 238 | (([1, 3, 5, 6, 2, 4, 1],), 5.0), 239 | (([5, 7, 4, 4, 6, 2, 8],), 7.0), 240 | (([0, 5, 5, 6, 7, 7, 12],), 7.0), 241 | (([1, 4, 3, 5, 6, 2, 4, 1],), 4.5), 242 | (([3, 5, 7, 8, 9, 11, 15, 16, 20, 21],), 16.0), 243 | (([1, 2, 5, 6, 7, 9, 12, 15, 18, 19, 27],), 18.0), 244 | (([0, 1, 2, 2, 2, 2, 3, 5, 5],), 4.0), 245 | 246 | ] 247 | 248 | for case in testcases: 249 | __my_assert_args(q3, case[0], case[1]) 250 | 251 | 252 | def test_var(): 253 | testcases = [ 254 | (([4, 2, 5, 8, 6],), 4.0), 255 | (([1, 3, 2, 4, 6, 2, 4, 2],), 2.25) 256 | ] 257 | 258 | for case in testcases: 259 | __my_assert_args(var, case[0], case[1]) 260 | 261 | 262 | def test_var_simulated(): 263 | import random 264 | import statistics 265 | 266 | for lst_size in range(1, 11): 267 | lst_test = [random.choice(range(5)) for _ in range(lst_size)] 268 | __my_assert_args(var, (lst_test,), statistics.pvariance(lst_test), False) 269 | 270 | 271 | def test_std(): 272 | testcases = [ 273 | (([4, 2, 5, 8, 6],), 2.0), 274 | (([1, 3, 2, 4, 6, 2, 4, 2],), 1.5) 275 | ] 276 | 277 | for case in testcases: 278 | __my_assert_args(std, case[0], case[1]) 279 | 280 | 281 | def test_std_simulated(): 282 | import random 283 | import statistics 284 | 285 | for lst_size in range(1, 11): 286 | lst_test = [random.choice(range(5)) for _ in range(lst_size)] 287 | __my_assert_args(std, (lst_test,), statistics.pstdev(lst_test), False) 288 | 289 | 290 | def test_freq(): 291 | testcases = [ 292 | (([4, 2, 5, 8, 6],), {2: 1, 4: 1, 5: 1, 6: 1, 8: 1}), 293 | (([1, 3, 4, 6, 4, 2],), {1: 1, 2: 1, 3: 1, 4: 2, 6: 1}), 294 | (([1, 3, 5, 6, 2, 4, 1],), {1: 2, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1}), 295 | (([1, 4, 3, 5, 6, 2, 4, 1],), {1: 2, 2: 1, 3: 1, 4: 2, 5: 1, 6: 1}) 296 | ] 297 | 298 | for case in testcases: 299 | __my_assert_args(freq, case[0], case[1]) 300 | 301 | 302 | def test_modes(): 303 | testcases = [ 304 | (([4, 2, 5, 8, 6],), [2, 4, 5, 6, 8]), 305 | (([1, 3, 4, 6, 4, 2],), [4]), 306 | (([1, 3, 4, 6, 2, 4, 2],), [2, 4]), 307 | (([1, 3, 2, 4, 6, 2, 4, 2],), [2]) 308 | ] 309 | 310 | for case in testcases: 311 | __my_assert_args(modes, case[0], case[1]) 312 | 313 | def test_modes_simulated(): 314 | if sys.version_info[0] >= 3 and sys.version_info[1] >= 8: 315 | import random 316 | import statistics 317 | for lst_size in range(1, 11): 318 | lst_test = [random.choice(range(5)) for _ in range(lst_size)] 319 | __my_assert_args(modes, (lst_test,), sorted(statistics.multimode(lst_test))) 320 | 321 | 322 | def __main(): 323 | """ Test alle functies. """ 324 | # Noodzakelijk voor gekleurde tekst binnen een Windows terminal 325 | os.system("") 326 | 327 | try: 328 | print("\x1b[32m") # Groene tekstkleur 329 | test_id() 330 | 331 | test_mean() 332 | test_mean_simulated() 333 | print("Je functie mean(lst) werkt goed!") 334 | 335 | test_q1() 336 | print("Je functie q1(lst) werkt goed!") 337 | 338 | test_q3() 339 | print("Je functie q3(lst) werkt goed!") 340 | 341 | test_var() 342 | test_var_simulated() 343 | print("Je functie var(lst) werkt goed!") 344 | 345 | test_std() 346 | test_std_simulated() 347 | print("Je functie std(lst) werkt goed!") 348 | 349 | test_freq() 350 | print("Je functie freq(lst) werkt goed!") 351 | 352 | test_modes() 353 | test_modes_simulated() 354 | print("Je functie modes(lst) werkt goed!") 355 | 356 | print("\nGefeliciteerd, alles lijkt te werken!") 357 | print("Lever je werk nu in op Canvas...") 358 | 359 | def hist(freqs): 360 | v_min = min(freqs.keys()) 361 | v_max = max(freqs.keys()) 362 | 363 | histo = str() 364 | for i in range(v_min, v_max + 1): 365 | histo += "{:5d} ".format(i) 366 | if i in freqs.keys(): 367 | histo += "█" * freqs[i] 368 | histo += '\n' 369 | 370 | return histo 371 | 372 | print("\x1b[0m") 373 | s = input("Geef een reeks van gehele getallen (gescheiden door een spatie): ") 374 | userlst = [int(c) for c in s.split()] 375 | 376 | print("\nHet gemiddelde is {:.2f}".format(mean(userlst))) 377 | print("De modi zijn {}".format(modes(userlst))) 378 | print("Q1 is {:.2f}".format(q1(userlst))) 379 | print("Q3 is {:.2f}".format(q3(userlst))) 380 | 381 | print("De variantie is {:.2f}".format(var(userlst))) 382 | print("De standaardafwijking is {:.2f}".format(std(userlst))) 383 | 384 | print("\nHistogram (gekanteld):\n\n" + hist(freq(userlst))) 385 | 386 | except AssertionError as ae: 387 | print("\x1b[31m") # Rode tekstkleur 388 | if not ae: 389 | print("Je code veroorzaakt onderstaande AssertionError:") 390 | raise ae 391 | else: 392 | print(ae) 393 | 394 | print("\x1b[0m") # Reset tekstkleur 395 | 396 | 397 | if __name__ == '__main__': 398 | __main() 399 | --------------------------------------------------------------------------------