You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
311 lines
8.2 KiB
311 lines
8.2 KiB
""" 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)
|
|
|
|
|
|
Naam: Marcel Haazen
|
|
Klas: DU1B
|
|
Studentnummer:1770145
|
|
|
|
|
|
Opdracht: werk onderstaande functies uit.
|
|
|
|
Je kunt je functies testen met het gegeven raamwerk door het bestand uit te voeren (of met behulp
|
|
van pytest, als je weet hoe dat werkt). Lever je werk in op Canvas als alle tests slagen.
|
|
|
|
Let op! Je mag voor deze opdracht geen extra modules importeren met 'import'.
|
|
"""
|
|
|
|
|
|
def floor(real):
|
|
""" Retourneert het grootste gehele getal (int), dat kleiner dan of gelijk is aan real (float). """
|
|
num = real//1
|
|
return num
|
|
|
|
def ceil(real):
|
|
""" Retourneert het kleinste gehele getal (int), groter dan of gelijk aan real (float). """
|
|
num = -(-real//1)
|
|
return num
|
|
|
|
|
|
def div(n):
|
|
""" Retourneert een (natuurlijk) gesorteerde verzameling (list) van delers van n (int).
|
|
Het getal a ∈ N is een deler van n ∈ N, als er een b ∈ N is, zodat a × b = n. """
|
|
divisors = []
|
|
for i in range(1, int(n / 2) + 1):
|
|
if n % i == 0:
|
|
divisors.append(i)
|
|
divisors.append(n)
|
|
return sorted(divisors)
|
|
|
|
|
|
def is_prime(n):
|
|
""" Return True als n (int) een priemgetal is, anders False.
|
|
Je kunt gebruik maken van de functie 'div(n)' om te bepalen of n een priem is.
|
|
Optioneel: bedenk een efficiënter alternatief. """
|
|
if n <= 1:
|
|
return False
|
|
|
|
for x in range(2, n):
|
|
# if number is divisble by x, return False
|
|
if not n % x:
|
|
return False
|
|
return True
|
|
|
|
|
|
|
|
def primefactors(n):
|
|
""" Return een (natuurlijk) gesorteerde verzameling (list) van priemfactoren van n (int)
|
|
Return [n] als n een priemgetal is, of wanneer n == 1.
|
|
Tip: maak gebruik van de functie 'is_prime(n)' """
|
|
sqrt = n**(1/2.0)
|
|
factors = []
|
|
if n == 1:
|
|
factors.append(1)
|
|
while n % 2 == 0:
|
|
factors.append(2),
|
|
n = n / 2
|
|
for i in range(3,int(sqrt)+1,2):
|
|
|
|
# while i divides n , print i ad divide n
|
|
while n % i== 0:
|
|
factors.append(i),
|
|
n = n / i
|
|
if n > 2:
|
|
factors.append(n)
|
|
|
|
|
|
return sorted(factors)
|
|
|
|
|
|
def primes(num):
|
|
""" Return alle priemgetallen kleiner dan num (int). """
|
|
primes = []
|
|
for n in range(1, num + 1):
|
|
is_prime = True
|
|
for i in range(2, n):
|
|
if n % i == 0:
|
|
is_prime = False
|
|
break
|
|
if is_prime and n > 1 and n != num: #EDIT HERE
|
|
primes.append(n)
|
|
return primes
|
|
|
|
|
|
def gcd(a, b):
|
|
""" Return de grootste grootste gemene deler , ggd (ofwel greatest common divisor, gcd) (int) van
|
|
natuurlijke getallen a en b (beide int).
|
|
|
|
Je hebt twee opties voor deze opgave;
|
|
1. Je programmeert hier het algoritme van Euclides
|
|
zie: https://nl.wikipedia.org/wiki/Algoritme_van_Euclides
|
|
2. Je bedenkt zelf een oplossing waarbij je gebruik maakt van de eerder
|
|
geschreven methode div(n) om de gcd te bepalen.
|
|
"""
|
|
while(b):
|
|
a, b = b, a % b
|
|
|
|
return a
|
|
|
|
|
|
def lcm(a, b):
|
|
""" Return het kleinste gemene veelvoud, kvg (ofwel least common multiple, lcm) (int)
|
|
van natuurlijke getallen a en b (beide int). """
|
|
lcm = (a*b)//gcd(a,b)
|
|
return lcm
|
|
|
|
|
|
|
|
def add_frac(n1, d1, n2, d2):
|
|
""" Retourneer de sommatie van twee breuken als breuk.
|
|
|
|
Argumenten:
|
|
n1 -- de teller van de eerste breuk
|
|
d1 -- de noemer van de eerste breuk
|
|
n2 -- de teller van de tweede breuk
|
|
d2 -- de noemer van de tweede breuk
|
|
|
|
Retourneert de som *als breuk*, met eerst de teller en dan de noemer van het resultaat (tuple).
|
|
|
|
Bijvoorbeeld: 3/4 + 1/6 = 11/12
|
|
dan: add_frac(3, 4, 1, 6) = (11, 12)
|
|
"""
|
|
d3 = gcd(d1,d2)
|
|
d3 = (d1 * d2) / d3
|
|
n3 = ((n1) * (d3/d1) + (n2) * (d3/d2))
|
|
|
|
|
|
|
|
return n3, d3
|
|
|
|
|
|
"""==============================================[ HU TESTRAAMWERK ]====================================================
|
|
Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
|
|
Je kunt je code testen door deze file te runnen of met behulp van pytest.
|
|
"""
|
|
|
|
|
|
def my_assert_args(function, args, expected_output):
|
|
argstr = str(args).replace(',)', ')')
|
|
assert function(*args) == expected_output, \
|
|
f"Fout: {function.__name__}{argstr} geeft { function(*args)} in plaats van {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_is_prime():
|
|
testcases = [
|
|
((1,), False),
|
|
((2,), True),
|
|
((3,), True),
|
|
((4,), False),
|
|
((5,), True),
|
|
((6,), False),
|
|
((29,), True)
|
|
]
|
|
|
|
for case in testcases:
|
|
my_assert_args(is_prime, case[0], case[1])
|
|
|
|
|
|
def test_primefactors():
|
|
testcases = [
|
|
((1,), [1]),
|
|
((2,), [2]),
|
|
((3,), [3]),
|
|
((4,), [2, 2]),
|
|
((8,), [2, 2, 2]),
|
|
((12,), [2, 2, 3]),
|
|
((2352,), [2, 2, 2, 2, 3, 7, 7]),
|
|
((9075,), [3, 5, 5, 11, 11])
|
|
]
|
|
|
|
for case in testcases:
|
|
my_assert_args(primefactors, case[0], sorted(case[1]))
|
|
|
|
|
|
def test_primes():
|
|
testcases = [
|
|
((1,), []),
|
|
((2,), []),
|
|
((3,), [2]),
|
|
((4,), [2, 3]),
|
|
((5,), [2, 3]),
|
|
((6,), [2, 3, 5]),
|
|
((30,), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29])
|
|
]
|
|
|
|
for case in testcases:
|
|
my_assert_args(primes, case[0], sorted(case[1]))
|
|
|
|
|
|
def test_gcd():
|
|
testcases = [
|
|
((60, 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_is_prime()
|
|
print("Je functie is_prime(n) werkt goed!")
|
|
|
|
test_primefactors()
|
|
print("Je functie primefactors(n) werkt goed!")
|
|
|
|
test_primes()
|
|
print("Je functie primes() 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")
|
|
print(ae)
|