Basis

Deze pagina bevat uitvoerbare code. Activeren

Opdracht 1

b. Maak nu een nieuwe functie power(base, exponent) 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 base (grondtal)

• Accepteert een niet-negatieve integer exponent (macht) (exponent kan 0 zijn)

• Geeft de waarde van base ** exponent terug

• De functie moet een for-lus gebruiken! Je mag niet gewoon base ** exponent 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(base, exponent):
    """Geeft base tot de macht exponent terug."""
    result = 1
    for x in range(0, exponent):
        result = result * base
    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))

def power(base, exponent): """Geeft base tot de macht exponent terug.""" result = 1 for x in range(0, exponent): result = result * base 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 2

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

• Een lijst integers lst accepteert.

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

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

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

• Maak gebruik van een lus!

def summed_odds(lst):
    """Geeft de som van de oneven getallen in lst terug."""
    result = 0
    for num in lst:
        if num % 2 == 1:
            result = result + num
    return result


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

def summed_odds(lst): """Geeft de som van de oneven getallen in lst terug.""" result = 0 for num in lst: if num % 2 == 1: result = result + num return result assert summed_odds([4, 5, 6]) == 5 assert summed_odds(range(3, 10)) == 24

Opdracht 3

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

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

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

  • Gebruik een while-lus!

  • Gebruik de functie unique(guessed_numbers) 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 verzamelvariabele)

  • Voeg het getal toe aan de lijst guessed_numbers

• 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(lst):
    """Geeft terug of alle elementen in lst verschillend zijn."""
    seen = []
    for element in lst:
        if element in seen:
            return False
        seen += [element]
    return True


assert unique([]) is True
assert unique([1, 2, 3]) is True
assert unique([1, 2, 1]) is False


def until_a_repeat(high):
    """Geeft het aantal getrokken getallen tot de eerste herhaling terug."""
    result = []  # 1. verzamelen, startwaarde
    while unique(result):  # 2. en 4. doorgaan zolang alles verschillend is
        result = result + [random.choice(range(0, high))]  # 3. per stap trekken
    return len(result)  # 5. na de lus


random.seed(0)
assert until_a_repeat(365) == 16

# Elke seed geeft een andere reeks trekkingen, en dus een ander aantal. De
# getallen blijven verrassend klein: met 365 mogelijkheden is een herhaling er
# meestal al na een stuk of twintig, dertig trekkingen.
random.seed(1)
print(until_a_repeat(365))

random.seed(2)
print(until_a_repeat(365))

random.seed(3)
print(until_a_repeat(365))

import random def unique(lst): """Geeft terug of alle elementen in lst verschillend zijn.""" seen = [] for element in lst: if element in seen: return False seen += [element] return True assert unique([]) is True assert unique([1, 2, 3]) is True assert unique([1, 2, 1]) is False def until_a_repeat(high): """Geeft het aantal getrokken getallen tot de eerste herhaling terug.""" result = [] # 1. verzamelen, startwaarde while unique(result): # 2. en 4. doorgaan zolang alles verschillend is result = result + [random.choice(range(0, high))] # 3. per stap trekken return len(result) # 5. na de lus random.seed(0) assert until_a_repeat(365) == 16 # Elke seed geeft een andere reeks trekkingen, en dus een ander aantal. De # getallen blijven verrassend klein: met 365 mogelijkheden is een herhaling er # meestal al na een stuk of twintig, dertig trekkingen. random.seed(1) print(until_a_repeat(365)) random.seed(2) print(until_a_repeat(365)) random.seed(3) print(until_a_repeat(365))

36
11
18