Uitwerkingen PGM1 Oefententamen

Deze pagina bevat uitvoerbare code. Activeren

Dit zijn de antwoorden op de opgaven in het Proeftentamen PGM1 en we nemen je stap voor stap mee in de uitwerkingen.

Belangrijk

Let op, de opgaven kunnen op verschillende manieren worden opgelost, het kan zijn dat jij sommige dingen anders hebt geschreven of andere stappen hebt gevolgd en dat is prima!

Opgave 1

In deze opgave wordt jou om het volgende gevraagd:

• het gebruik van variabelen (toekenning en hergebruik)

• rekenkundige operaties (optelling en vermenigvuldiging)

• de print functie voor output

Uitwerking

opbrengst_tomaten = 150
opbrengst_paprikas = 120
opbrengst_komkommers = 80

totale_opbrengst = opbrengst_tomaten + opbrengst_paprikas + opbrengst_komkommers

totale_omzet = opbrengst_tomaten * 3.24 + opbrengst_paprikas * 2.87 + opbrengst_komkommers * 1.48

print(totale_opbrengst, totale_omzet)

opbrengst_tomaten = 150 opbrengst_paprikas = 120 opbrengst_komkommers = 80 totale_opbrengst = opbrengst_tomaten + opbrengst_paprikas + opbrengst_komkommers totale_omzet = opbrengst_tomaten * 3.24 + opbrengst_paprikas * 2.87 + opbrengst_komkommers * 1.48 print(totale_opbrengst, totale_omzet)

350 948.8000000000001

Uitleg

1. Variabelen toekennen

   opbrengst_tomaten = 150
   opbrengst_paprikas = 120
   opbrengst_komkommers = 80
   

   Hier maken we drie variabelen aan en kennen er direct waarden aan toe. Een variabele is als een doos waar je een waarde in kunt bewaren om later te gebruiken. De = is een toekenningsoperator (geen ‘is gelijk aan’ zoals in wiskunde).

2. Berekening totale opbrengst

   totale_opbrengst = opbrengst_tomaten + opbrengst_paprikas + opbrengst_komkommers
   

   Hier tellen we de waardes van de drie variabelen bij elkaar op met de + operator en slaan het resultaat op in een nieuwe variabele ‘totale_opbrengst’. Dit wordt: 150 + 120 + 80 = 350 kg.

3. Berekening totale omzet

   totale_omzet = opbrengst_tomaten * 3.24 + opbrengst_paprikas * 2.87 + opbrengst_komkommers * 1.48
   

   Hier berekenen we de omzet door:

   • tomaten: 150 * €3,24

   • paprika’s: 120 * €2,87

   • komkommers: 80 * €1,48

   En tellen deze bedragen bij elkaar op. De * is de vermenigvuldigingsoperator in Python.

4. Resultaten printen

   print(totale_opbrengst, totale_omzet)
   

   De print() functie wordt gebruikt om resultaten te tonen:

   De print() functie toont de waarden van totale_opbrengst en totale_omzet, met een spatie ertussen.

Opgave 2

In deze opgave wordt jou gevraagd conditionele statements te schrijven (met andere woorden if, elif en else combinaties).

windspeed = 150 # is niet nodig, maar is handig om je code te testen.

if windspeed >= 252:
    print(5)
elif windspeed >= 209:
    print(4)
elif windspeed >= 178:
    print(3)
elif windspeed >= 154:
    print(2)
elif windspeed >= 119:
    print(1)
elif windspeed >= 63:
    print("TS")
else:
    print("TD")

windspeed = 150 # is niet nodig, maar is handig om je code te testen. if windspeed >= 252: print(5) elif windspeed >= 209: print(4) elif windspeed >= 178: print(3) elif windspeed >= 154: print(2) elif windspeed >= 119: print(1) elif windspeed >= 63: print("TS") else: print("TD")

1

Opgave 3

Deze opgave vraagt jou of je een for-lus begrijpt en fouten kan vinden en corrigeren.

def over_hundred(lst):
    """Returns whether the sum of all items in the list is larger than
    100"""
    result = 0
    for i in range(len(lst)):  # lst[i] verzaakt een indexerror, oplossing is range te gebruiken. Andere optie is om lst[i] te vervangen met i.
        result = result + lst[i]  # result wordt twee keer opgeteld door het gebruik van +=.
    if result > 100:
        return True
    return False  # De return stond in de for lus maar moet juist aan het einde van de for lus staan.

# Vergeet niet al je functies te testen! (en ze docstrings te geven)
assert over_hundred([12, 13, 14]) == False
assert over_hundred([32, 33, 34, 35]) == True
assert over_hundred([90, 14, -6]) == False

test = [12, 13, 14]
print(over_hundred(test))  # lc bestaat niet. vervangen met test. Het is ook mogelijk om test te vervangen met lc

def over_hundred(lst): """Returns whether the sum of all items in the list is larger than 100""" result = 0 for i in range(len(lst)): # lst[i] verzaakt een indexerror, oplossing is range te gebruiken. Andere optie is om lst[i] te vervangen met i. result = result + lst[i] # result wordt twee keer opgeteld door het gebruik van +=. if result > 100: return True return False # De return stond in de for lus maar moet juist aan het einde van de for lus staan. # Vergeet niet al je functies te testen! (en ze docstrings te geven) assert over_hundred([12, 13, 14]) == False assert over_hundred([32, 33, 34, 35]) == True assert over_hundred([90, 14, -6]) == False test = [12, 13, 14] print(over_hundred(test)) # lc bestaat niet. vervangen met test. Het is ook mogelijk om test te vervangen met lc

False

Opgave 4

Deze opgave vraagt jou om een while-lus te schrijven.

count = 0  # bijhouden hoeveel getallen er zijn ingevuld
total_sum = 0  # bijhouden de waarde van de getallen
inp = int(input("Geef positief getal: "))  # vragen om input

while inp >= 0:  # Blijf herhalen zolang de input positief is,
    count = count + 1  # counter verhogen
    total_sum = total_sum + inp  # nieuwe input optellen
    inp = int(input("Geef positief getal: "))  # vraag voor nieuwe input

print("som", total_sum, "aantal", count)  # print resultaat

Opgave 5

Deze opgave vraagt jou om een dubbele for-lus te schrijven.

def number_stairs(size):    # defineer de functie
    """Draws stairs of numbers, according to this example:
    
    >>> number_stairs(3)
    1
    12
    123
    """
    for y in range(1, size + 1):  # aantal rijen is gelijk aan size. De plus 1 zorgt ervoor dat er geteld wordt vanaf 1 tot en met n.
        for x in range(1, y + 1):  # aantal kolommen is gelijk aan de huidige rij.
            print(x, end="")  # print het getal. De end="" zorgt ervoor dat er geen volgende regel wordt geprint
        print()  # einde van de rij bereikt, print einde regel.

# asserts schrijven voor deze functie is mogelijk, maar valt buiten de
# leeruitkomsten van PGM1: we hebben geen manier geleerd om te kijken wat
# print() gedaan heeft. Daarom hoef je hier geen asserts te geven.

number_stairs(5) # roep de functie op. Gezien de functie zelf al print, is hier geen print nodig.

def number_stairs(size): # defineer de functie """Draws stairs of numbers, according to this example: >>> number_stairs(3) 1 12 123 """ for y in range(1, size + 1): # aantal rijen is gelijk aan size. De plus 1 zorgt ervoor dat er geteld wordt vanaf 1 tot en met n. for x in range(1, y + 1): # aantal kolommen is gelijk aan de huidige rij. print(x, end="") # print het getal. De end="" zorgt ervoor dat er geen volgende regel wordt geprint print() # einde van de rij bereikt, print einde regel. # asserts schrijven voor deze functie is mogelijk, maar valt buiten de # leeruitkomsten van PGM1: we hebben geen manier geleerd om te kijken wat # print() gedaan heeft. Daarom hoef je hier geen asserts te geven. number_stairs(5) # roep de functie op. Gezien de functie zelf al print, is hier geen print nodig.

1
12
123
1234
12345

Opgave 6

In deze opgave moet je zelf een probleem kunnen oplossen en wordt verwacht dat je gebruik kan maken van:

• lussen

• strings, en in in het bijzonder string slicing.

Bij deze opgave moet ook een docstring en drie assertions worden toegevoegd.

Uitwerking

def end_check(phrase):
    """Geeft de langste substring terug die aan het begin en
    aan het einde van phrase staat, zonder te overlappen.
    """
    max_length = len(phrase) // 2

    for i in range(max_length, 0, -1):
        begin = phrase[:i]
        end = phrase[-i:]

        if begin == end:
            return begin

    return ""


# drie assertions
assert end_check("test") == "t"
assert end_check("testing") == ""
assert end_check("123test123") == "123"

def end_check(phrase): """Geeft de langste substring terug die aan het begin en aan het einde van phrase staat, zonder te overlappen. """ max_length = len(phrase) // 2 for i in range(max_length, 0, -1): begin = phrase[:i] end = phrase[-i:] if begin == end: return begin return "" # drie assertions assert end_check("test") == "t" assert end_check("testing") == "" assert end_check("123test123") == "123"

Uitleg

Notitie

In de opgave wordt gesproken over een substring. Een substring is een deel van een string, ofwel een reeks opeenvolgende karakters binnen een langere tekst. Bijvoorbeeld:

In de tekst “programmeren” zijn dit allemaal substrings:

• “pro”

• “gram”

• “programmere”

• “eren”

• “p” (zelfs één karakter is een substring)

• “programmeren” (de hele string is ook een substring van zichzelf)

Maar “pgm” is bijvoorbeeld geen substring, omdat deze letters niet direct na elkaar staan in de originele tekst.

De strategie is om van lang naar kort te zoeken naar een overeenkomst tussen het begin en het einde van de string. Omdat de substrings niet mogen overlappen, kan de lengte van een overeenkomst maximaal de helft van de lengte van de string zijn. Deze maximale lengte wordt vastgelegd in max_length.

Met range(max_length, 0, -1) wordt vervolgens van deze maximale lengte teruggeteld naar 1. Hierbij worden de drie argumenten van range(start, stop, step) gebruikt. De negatieve stapgrootte (-1) zorgt ervoor dat de getallen in aflopende volgorde worden doorlopen, vergelijkbaar met het gebruik van een negatieve stapgrootte bij list slicing. De stopwaarde 0 wordt niet meegenomen.

De variabele i bepaalt bij iedere iteratie hoeveel tekens van het begin (phrase[:i]) en het einde (phrase[-i:]) worden vergeleken.

Zodra een overeenkomst wordt gevonden, wordt deze teruggegeven. Omdat van lang naar kort wordt gezocht, is de eerste overeenkomst automatisch de langste.

Opgave 7

In deze opgave moet er een context probleem opgelost worden met behulp van een hulpfunctie.

a.

def count_char(line, let):
    """
    Deze functie kriigt twee strings binnen waarbij zin een hele zin is en let een enkele letter.
    De functie geeft terug hoe vaak let voorkomt in zin.
    """
    result = 0 # om te tellen is er een counter nodig

    for char in line:   # ga alle characters in de zin door
        if char == let:    # als de character gelijk is aan let
            result += 1 # tel er 1 bij op

    return result   # als de lus klaar is, geef het antwoord terug

assert count_char("testing", "e") == 1
assert count_char("testing", "a") == 0
assert count_char("testing", "t") == 2

def count_char(line, let): """ Deze functie kriigt twee strings binnen waarbij zin een hele zin is en let een enkele letter. De functie geeft terug hoe vaak let voorkomt in zin. """ result = 0 # om te tellen is er een counter nodig for char in line: # ga alle characters in de zin door if char == let: # als de character gelijk is aan let result += 1 # tel er 1 bij op return result # als de lus klaar is, geef het antwoord terug assert count_char("testing", "e") == 1 assert count_char("testing", "a") == 0 assert count_char("testing", "t") == 2

b.

def max_freq_letter(text):
    """
    functie max_freq_letter(line) accepteert een string line.
    Deze functie moet het karakter in line teruggeven met de hoogste frequentie.
    """
    result = ""  # resultaat moet een string zijn
    max_let = 0  # huidige maximum

    for char in text:  # ga alle characters in de zin langs
        count = count_char(text, char)  # tel hoevaak x voorkomt in z
        if count > max_let:  # Komt x meer voor dan de huidige 'winnaar'
            max_let = count  # Zo ja, vervang met nieuwe aantal
            result = char  # vervang 'winaar'met nieuwe x

    return result  # geef resultaat terug.

assert max_freq_letter("testing") == "t"
assert max_freq_letter("ditiseentest") == "t"
assert max_freq_letter("hottentotten") == "t"

def max_freq_letter(text): """ functie max_freq_letter(line) accepteert een string line. Deze functie moet het karakter in line teruggeven met de hoogste frequentie. """ result = "" # resultaat moet een string zijn max_let = 0 # huidige maximum for char in text: # ga alle characters in de zin langs count = count_char(text, char) # tel hoevaak x voorkomt in z if count > max_let: # Komt x meer voor dan de huidige 'winnaar' max_let = count # Zo ja, vervang met nieuwe aantal result = char # vervang 'winaar'met nieuwe x return result # geef resultaat terug. assert max_freq_letter("testing") == "t" assert max_freq_letter("ditiseentest") == "t" assert max_freq_letter("hottentotten") == "t"