Added student versions of assignment 1 (getallen) and 2 (statistiek).

.gitignore

@@ -0,0 +1 @@
+.pytest_cache/

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))

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))