Basis

Opdracht 1b

b. Maak nu een nieuwe functie power(b, p) door de bovenstaande functie te kopiëren en aan te passen, of door de functie zelf te schrijven op dezelfde manier. Deze functie moet aan de volgende eisen voldoen:

• Accepteert een numerieke waarde b (base, grondtal)

• Accepteert een niet-negatieve integer p (power, macht) (p kan 0 zijn)

• Geeft de waarde van b ** p terug

• De functie moet een for-lus gebruiken! Je mag niet gewoon b ** p gebruiken…

• In dit geval doen we alsof power(0, 0) gelijk is aan 1.0, ook als dat wiskundig niet helemaal juist is.

def power(b,p):
    result = 1
    for x in range(0,p):
        result = result * b
    return result

print("power(2, 5): is 32 ==", power(2, 5))
print("power(5, 2): is 25 ==", power(5, 2))
print("power(42, 0): is 1 ==", power(42, 0))
print("power(0, 42): is 0 ==", power(0, 42))
print("power(0, 0): is 1 ==", power(0, 0))

power(2, 5): is 32 == 32
power(5, 2): is 25 == 25
power(42, 0): is 1 == 1
power(0, 42): is 0 == 0
power(0, 0): is 1 == 1

Opdracht 2b

b. Maak nu zelf een functie summed_odds(L) door deze functie als voorbeeld te gebruiken, die

• Een lijst integers L accepteert.

• Je mag ervan uitgaan dat de lijst alleen integers bevat.

• De functie moet de som teruggeven van alle oneven getallen in L.

• Als er geen oneven getallen in de lijst zijn, moet de functie 0 teruggeven.

• Maak gebruik van een lus!

def summed_odds(l):
    result = 0
    for x in l:
        if x % 2 == 1:
            result = result + x
    return result

assert summed_odds([4, 5, 6]) == 5
assert summed_odds(range(3, 10)) == 24

Opdracht 3b

b. Gebruik count_guesses als voorbeeld om een variant te schrijven die we until_a_repeat(high) gaan noemen.

• Deze functie houdt een lijst L bij van alle getallen die geraden zijn. Begin met L = []!

• We blijven getallen raden zolang alle elementen van L uniek zijn (dus zolang er geen herhalingen zijn).

  • Gebruik een while-lus!

  • Gebruik de functie unique(L) hieronder die een boolean teruggeeft.

• Binnen de while-lus doet de funtie het volgende:

  • Gok een getal van 0 tot high met behulp van range(0, high)

  • Houd het aantal geraden getallen bij (bijvoorbeeld met een telvariabele)

  • Voeg het getal toe aan de lijst L

• Als de while-lus klaar is moet de functie het aantal geraden getallen teruggeven dat nodig was om een dubbel getal te krijgen.

import random

def unique(L):
    """Returns whether all elements in L are unique.

    Argument: L, a list of any elements.
    Return value: True, if all elements in L are unique,
            or False, if there is any repeated element
    """
    if len(L) == 0:
        return True
    elif L[0] in L[1:]:
        return False
    else:
        return unique(L[1:])  # in deze functie mag je WEL recursie gebruiken!

def until_a_repeat(high):
    result = []
    while unique(result):
        ran = random.choice(range(0,high))
        result = result + [ran]
    return len(result)

print(until_a_repeat(365))

41