diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ff14a62 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.pytest_cache/ diff --git a/practicum_1_getallen_student.py b/practicum_1_getallen_student.py new file mode 100644 index 0000000..270a38b --- /dev/null +++ b/practicum_1_getallen_student.py @@ -0,0 +1,258 @@ +""" coding=utf-8 + +Analytical Skills - practicum 1: getallen + +(c) 2019 Hogeschool Utrecht +Bart van Eijkelenburg (bart.vaneijkelenburg@hu.nl) +Tijmen Muller (tijmen.muller@hu.nl) +""" + +""" + LET OP: JE MAG VOOR DEZE OPDRACHT GEEN (extra) MODULES IMPORTEREN! + + Practicum 1: Werk onderstaande functies uit. + + floor(real): + Return het grootste gehele getal, dat kleiner dan of gelijk is aan real (reël getal). + + ceil(real): + Return het kleinste gehele getal, groter dan of gelijk aan real (reël getal). + + div(n): + Return een (natuurlijk) gesorteerde verzameling (lijst) van delers van n. + Het getal a ∈ N is een deler van n ∈ N, als er een b ∈ N is, zodat a · b = n. + + is_prime(n): + Return True als n ∈ N een priemgetal is, anders False. + + primefactors(n): + Return een (natuurlijk) gesorteerde verzameling (lijst) van priemfactoren van n. + Return [n] als n een priemgetal is, of n == 1. Tip: maak gebruik van de functie 'is_prime(n)' + + primes_under_30(): + Return alle priemgetallen kleiner dan 30. + + gcd(a, b): + Return de grootste grootste gemene deler, ggd (ofwel greatest common divisor, gcd) is. + Je hebt twee opties voor deze opgave; + 1. Je programmeert hier het algoritme van Euclides (niet behandeld) + zie: https://nl.wikipedia.org/wiki/Algoritme_van_Euclides + 2. Je bedenkt zelf een oplossing waarbij je gebruik maakt van de eerder + geschreven methode div(n) om de gcd te bepalen. + + lcm(a, b): + Return het kleinste gemene veelvoud, kvg (ofwel least common multiple). + + add_frac(n1, d1, n2, d2): + Return de sommatie van twee breuken als breuk. + *n1* is de teller van de eerste breuk, *d1* is de noemer van de eerste breuk. + *n2* is de teller van de tweede breuk, *d2* is de noemer van de eerste breuk. + De returnwaarde bestaat uit eerste de teller en dan de noemer van het resultaat. + Bijvoorbeeld: 3/4 + 1/6 = 11/12 + dan: add_frac(3, 4, 1, 6) = 11, 12 +""" + + +def floor(real): + """ Return het grootste gehele getal, dat kleiner dan of gelijk is aan real (reëel getal). """ + + return 0 + + +def ceil(real): + """ Return het kleinste gehele getal, groter dan of gelijk aan real (reëel getal). """ + + return 0 + + +def div(n): + """ Return een (natuurlijk) gesorteerde verzameling (lijst) van delers van n. + Het getal a ∈ N is een deler van n ∈ N, als er een b ∈ N is, zodat a · b = n. """ + + divisors = [] + return sorted(divisors) + + +def is_prime(n): + """ Return True als n ∈ N een priemgetal is, anders False. + Je kunt gebruik maken van de functie 'div(n)' om te bepalen of n een priem is. + Optioneel: bedenk een efficiënter alternatief. """ + + return False + + +def primefactors(n): + """ Return een (natuurlijk) gesorteerde verzameling (lijst) van priemfactoren van n. + Return [n] als n een priemgetal is, of n == 1. Tip: maak gebruik van de functie 'is_prime(n)' """ + + factors = [] + return sorted(factors) + + +def primes_under_30(): + """ Return alle priemgetallen kleiner dan 30. """ + + primes = [] + return primes + + +def gcd(a, b): + """ Return de grootste grootste gemene deler, ggd (ofwel greatest common divisor, gcd) is. """ + + return 1 + + +def lcm(a, b): + """ Return het kleinste gemene veelvoud, kvg (ofwel least common multiple). """ + + return 1 + + +def add_frac(n1, d1, n2, d2): + """ Return de sommatie van twee breuken als breuk. + *n1* is de teller van de eerste breuk, *d1* is de noemer van de eerste breuk. + *n2* is de teller van de tweede breuk, *d2* is de noemer van de eerste breuk. + De returnwaarde bestaat uit eerste de teller en dan de noemer van het resultaat. + Bijvoorbeeld: 3/4 + 1/6 = 11/12 + dan: add_frac(3, 4, 1, 6) = 11, 12 + """ + + return 1, 1 + + +""" +======================================================================================================================== +Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! +Je kunt je code testen door deze file te runnen of met behulp van pytest. +""" + + +def my_assert_args(function, args, expected_output): + argstr = str(args).replace(',)', ')') + assert function(*args) == expected_output, "Fout: {}{} geeft {} in plaats van {}".format(function.__name__, argstr, function(*args), expected_output) + + +def test_floor(): + testcases = [((1.0,), 1), + ((1.05,), 1), + ((1.95,), 1), + ((-1.0,), -1), + ((-1.05,), -2), + ((-1.95,), -2)] + + for case in testcases: + my_assert_args(floor, case[0], case[1]) + + +def test_ceil(): + testcases = [((1.0,), 1), + ((1.05,), 2), + ((1.95,), 2), + ((-1.0,), -1), + ((-1.05,), -1), + ((-1.95,), -1)] + + for case in testcases: + my_assert_args(ceil, case[0], case[1]) + + +def test_div(): + testcases = [ + ((1,), [1]), + ((2,), [1, 2]), + ((3,), [1, 3]), + ((4,), [1, 2, 4]), + ((8,), [1, 2, 4, 8]), + ((12,), [1, 2, 3, 4, 6, 12]), + ((19,), [1, 19]), + ((25,), [1, 5, 25]), + ((929,), [1, 929]), + ((936,), [1, 2, 3, 4, 6, 8, 9, 12, 13, 18, 24, 26, 36, 39, 52, 72, 78, 104, 117, 156, 234, 312, 468, 936]) + ] + + for case in testcases: + my_assert_args(div, case[0], sorted(case[1])) + + +def test_primefactors(): + testcases = [ + ((1,), [1]), + ((2,), [2]), + ((3,), [3]), + ((4,), [2, 2]), + ((8,), [2, 2, 2]), + ((12,), [2, 2, 3]), + ((2352,), [2, 2, 2, 2, 3, 7, 7]), + ((9075,), [3, 5, 5, 11, 11]) + ] + + for case in testcases: + my_assert_args(primefactors, case[0], sorted(case[1])) + + +def test_primes_under_30(): + expected_output = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] + assert sorted(primes_under_30()) == expected_output, "Fout: primes_under_30() geeft {} in plaats van {}".format(primes_under_30(), expected_output) + + +def test_gcd(): + testcases = [ + ((60, 70), 10) + ] + + for case in testcases: + my_assert_args(gcd, case[0], case[1]) + + +def test_lcm(): + testcases = [ + ((15, 27), 135) + ] + + for case in testcases: + my_assert_args(lcm, case[0], case[1]) + + +def test_add_frac(): + testcases = [ + ((1, 2, 1, 4), (3, 4)), + ((3, 4, 1, 6), (11, 12)), + ((1, 6, 3, 4), (11, 12)) + ] + + for case in testcases: + my_assert_args(add_frac, case[0], case[1]) + + +if __name__ == '__main__': + try: + print("\x1b[0;32m") + + test_floor() + print("Je functie floor() werkt goed!") + + test_ceil() + print("Je functie ceil() werkt goed!") + + test_div() + print("Je functie div(n) werkt goed!") + + test_primefactors() + print("Je functie primefactors(n) werkt goed!") + + test_primes_under_30() + print("Je functie primes_under_30() werkt goed!") + + test_gcd() + print("Je functie gcd(a, b) werkt goed!") + + test_lcm() + print("Je functie lcm(a, b) werkt goed!") + + test_add_frac() + print("Je functie add_frac(n1, d1, n2, d2) werkt goed!") + + print("Gefeliciteerd, alles lijkt te werken! Lever je werk nu in op Canvas...") + + except AssertionError as ae: + print("\x1b[0;31m" + str(ae)) diff --git a/practicum_2_statistiek_student.py b/practicum_2_statistiek_student.py new file mode 100644 index 0000000..a741814 --- /dev/null +++ b/practicum_2_statistiek_student.py @@ -0,0 +1,255 @@ +""" coding=utf-8 + +Analytical Skills - practicum 2: statistiek + +(c) 2019 Hogeschool Utrecht +Tijmen Muller (tijmen.muller@hu.nl) +""" + +""" + LET OP: JE MAG VOOR DEZE OPDRACHT GEEN (extra) MODULES IMPORTEREN! + Je krijgt in deze opdracht alleen de beschikking over de functie sqrt() om een + wortel te kunnen trekken. Deze is al voor je geimporteerd en kun je direct aanroepen. + Bijvoorbeeld: sqrt(16) = 4.0 + + Practicum 2: Werk onderstaande functies uit. Elke functie krijgt een lijst *lst* met + gehele getallen (int) als argument. + + freq(lst): + Return een dictionary met als keys de waardes die voorkomen in *lst* en + als value het aantal voorkomens van die waarde. + Bijvoorbeeld: freq([0, 0, 4, 5]) = {0: 2, 4: 1, 5: 1} + + mean(lst): + Return het gemiddelde van de lijst lst. + + median(lst): + Return de mediaan van de lijst lst. + + modes(lst): + Return een gesorteerde lijst van de modi van lijst lst. + + rnge(lst): + Return het bereik van de lijst lst. + + var(lst): + Return de variantie van de lijst lst. + + std(lst): + Return de standaardafwijking van de lijst lst. + + q1(lst): + Return het eerste kwartiel Q1 van de lijst lst. + + q3(lst): + Return het derde kwartiel Q3 van de lijst lst. +""" + +from math import sqrt + + +def freq(lst): + freqs = dict() + return freqs + + +def mean(lst): + return 0.0 + + +def median(lst): + return 0.0 + + +def modes(lst): + return [] + + +def rnge(lst): + return 0 + + +def var(lst): + return 0.0 + + +def std(lst): + return 0.0 + + +def q1(lst): + return 0.0 + + +def q3(lst): + return 0.0 + + +""" +======================================================================================================================== +Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen! +Je kunt je code testen door deze file te runnen of met behulp van pytest. +""" + + +def my_assert_arg(function, arg, expected_output): + assert function(arg) == expected_output, "Fout: {}({}) geeft {} in plaats van {}".format(function.__name__, arg, function(arg), expected_output) + + +def test_mean(): + testcases = [ + ([1, 3, 2, 4, 6, 2, 4, 2], 3.0) + ] + + for case in testcases: + my_assert_arg(mean, case[0], case[1]) + + +def test_rnge(): + testcases = [ + ([1, 3, 2, 4, 6, 2, 4, 2], 5) + ] + + for case in testcases: + my_assert_arg(rnge, case[0], case[1]) + + +def test_median(): + testcases = [ + ([1, 3, 4, 6, 4, 2], 3.5), + ([1, 3, 4, 6, 2, 4, 2], 3.0), + ([1, 3, 2, 4, 6, 2, 4, 2], 2.5) + ] + + for case in testcases: + my_assert_arg(median, case[0], case[1]) + + +def test_modes(): + testcases = [ + ([1, 3, 6, 4, 2], [1, 2, 3, 4, 6]), + ([1, 3, 4, 6, 4, 2], [4]), + ([1, 3, 4, 6, 2, 4, 2], [2, 4]), + ([1, 3, 2, 4, 6, 2, 4, 2], [2]) + ] + + for case in testcases: + my_assert_arg(modes, case[0], case[1]) + + +def test_var(): + testcases = [ + ([1, 3, 2, 4, 6, 2, 4, 2], 2.25) + ] + + for case in testcases: + my_assert_arg(var, case[0], case[1]) + + +def test_std(): + testcases = [ + ([1, 3, 2, 4, 6, 2, 4, 2], 1.5) + ] + + for case in testcases: + my_assert_arg(std, case[0], case[1]) + + +def test_q1(): + testcases = [ + ([1, 3, 4, 6, 4, 2], 2.0), + ([1, 3, 5, 6, 1, 4, 2], 1.0), + ([1, 3, 3, 5, 6, 2, 4, 1], 1.5) + ] + + for case in testcases: + my_assert_arg(q1, case[0], case[1]) + + +def test_q3(): + testcases = [ + ([1, 3, 4, 6, 4, 2], 4.0), + ([1, 3, 5, 6, 2, 4, 1], 5.0), + ([1, 3, 3, 5, 6, 2, 4, 1], 4.5) + ] + + for case in testcases: + my_assert_arg(q3, case[0], case[1]) + + +def test_freq(): + testcases = [ + ([1, 3, 4, 6, 4, 2], {1: 1, 2: 1, 3: 1, 4: 2, 6: 1}), + ([1, 3, 5, 6, 2, 4, 1], {1: 2, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1}), + ([1, 3, 3, 5, 6, 2, 4, 1], {1: 2, 2: 1, 3: 2, 4: 1, 5: 1, 6: 1}) + ] + + for case in testcases: + my_assert_arg(freq, case[0], case[1]) + + +if __name__ == '__main__': + try: + print("\x1b[0;32m") + + test_mean() + print("Je functie mean(lst) werkt goed!") + + test_rnge() + print("Je functie rnge(lst) werkt goed!") + + test_median() + print("Je functie median(lst) werkt goed!") + + test_modes() + print("Je functie modes() werkt goed!") + + test_q1() + print("Je functie q1(lst) werkt goed!") + + test_q3() + print("Je functie q3(lst) werkt goed!") + + test_var() + print("Je functie var(lst) werkt goed!") + + test_std() + print("Je functie std(lst) werkt goed!") + + test_freq() + print("Je functie freq(lst) werkt goed!") + + print("Gefeliciteerd, alles lijkt te werken! Lever je werk nu in op Canvas...\n") + + + def hist(freqs): + v_min = min(freqs.keys()) + v_max = max(freqs.keys()) + + histo = str() + for i in range(v_min, v_max + 1): + histo += "{:5d} ".format(i) + if i in freqs.keys(): + histo += "█" * freqs[i] + histo += '\n' + + return histo + + + s = input("\x1b[0;30mGeef een reeks van gehele getallen (gescheiden door een spatie): ") + userlst = [int(c) for c in s.split()] + + print("\nHet gemiddelde is {:.2f}".format(mean(userlst))) + print("De modi zijn {}".format(modes(userlst))) + print("De mediaan is {:.2f}".format(median(userlst))) + print("Q1 is {:.2f}".format(q1(userlst))) + print("Q3 is {:.2f}".format(q3(userlst))) + + print("Het bereik is {}".format(rnge(userlst))) + print("De variantie is {:.2f}".format(var(userlst))) + print("De standaardafwijking is {:.2f}".format(std(userlst))) + + print("\nHistogram (gekanteld):\n\n" + hist(freq(userlst))) + + except AssertionError as ae: + print("\x1b[0;31m" + str(ae))