Oplossingen PGM1 Oefententamen

Oplossingen PGM1 Oefententamen#

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!

Opdracht 1#

In deze opdracht wordt jou om het volgende gevraagd:

  • het gebruik van variabelen (toekenning en hergebruik)

  • rekenkundige operaties (optelling en vermenigvuldiging)

  • de print functie voor output

Oplossing#

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_opbrengst, round(totale_omzet,2))

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

    • De tekst “Totale opbrengst =” wordt letterlijk getoond

    • totale_opbrengst toont de berekende kilogrammen

    • round(totale_omzet,2) rondt de berekende omzet af op 2 decimalen

    • De komma’s in de print functie zorgen voor spaties tussen de onderdelen

Opdracht 2#

In deze opdracht 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")

1

Opdracht 3#

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

def over_hundred(L):
    result = 0
    for i in range(len(L)): # L[i] verzaakt een indexerror, oplossing is range te gebruiken. Andere optie is om L[i] te vervangen met i.
        result = result + L[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.

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

Opdracht 4#

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

count = 0  # bijhouden hoeveel getallen er zijn ingevuld
som = 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
    som = som + inp  # nieuwe input optellen
    inp = int(input("Geef positief getal: "))  # vraag voor nieuwe input

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

Opdracht 5#

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

def number_stairs(size):    # defineer de functie
    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.

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 opdracht moet je zelf een probleem kunnen oplossen en verwacht dat je gebruik kan maken van:

  • lussen

  • strings, en in in het bijzonder string slicing.

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

Oplossing#

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

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

        max_length -= 1

        if begin == end:
            return begin

    return ""


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

Uitleg#

  1. Ten eerste, laten we kijken naar wat de functie moet doen:

    • We zoeken een substring (een deel van de tekst) die zowel aan het begin als einde staat

    • Deze substrings mogen niet overlappen

    • We willen de langste mogelijke substring vinden die aan deze voorwaarden voldoet

  2. Laten we de code regel voor regel doornemen:

    max_length = len(phrase) // 2

    • Dit bepaalt de maximale lengte van de substring die we kunnen zoeken

    • We delen door 2 omdat de substrings niet mogen overlappen

    • Bijvoorbeeld: bij “123test123” is len(phrase) = 10, dus max_length = 5

    • De // betekent delen en naar beneden afronden naar een heel getal

  3. Dan hebben we een lus:

    for i in range(max_length):

    • Let op, de variabele i wordt nergens in de lus gebruikt, maar is nodig vanwege de Python syntax. We hadden ook for _ in range(max_length): kunnen schrijven om aan te geven dat we de variabele niet gebruiken (dit is een Python conventie)

    • We gebruiken de lus puur om een bepaald aantal keren iets te proberen, namelijk steeds max_length keer

  4. Een belangrijk onderdeel! We gebruiken hier gebruik van de mogelijkheid om met negatieve indices te werken:

    begin = phrase[:max_length]
end = phrase[0 - max_length:]

    • phrase[:max_length] pakt een substring vanaf het begin tot max_length

    • phrase[0 - max_length:] gebruikt een negatieve index om een substring vanaf het einde te pakken

    • Dit is een heel handige eigenschap van Python: negatieve indices tellen vanaf het einde!

    • Bij “123test123” met max_length = 3:

    • begin = “123” (substring van eerste drie karakters)

    • end = “123” (substring van laatste drie karakters want -3 betekent: pak de laatste 3)

    • Je kunt het zien als: -3 betekent “3 vanaf rechts”

  5. We maken max_length steeds kleiner:

    max_length -= 1

    • Dit is hetzelfde als max_length = max_length - 1

    • Het beïnvloedt alleen welk deel van de string we bekijken in de volgende iteratie

    • Als max_length start met 5, gebeurt dit:

      • Eerste iteratie: i=0, max_length wordt 4

      • Tweede iteratie: i=1, max_length wordt 3

      • Derde iteratie: i=2, max_length wordt 2

      • Vierde iteratie: i=3, max_length wordt 1

      • Vijfde iteratie: i=4, max_length wordt 0

    Belangrijk

    Dat we max_length steeds verminderen heeft geen invloed op hoeveel keer de lus uitgevoerd wordt! range(max_length) wordt namelijk maar één keer bepaald, aan het begin van de lus

    • Als max_length start met 5, dan maakt range(5) een vaste reeks [0, 1, 2, 3, 4]

    • Ook al verminderen we max_length binnen de lus, deze reeks blijft hetzelfde

    • De lus zal dus gewoon 5 keer uitgevoerd worden

  6. We controleren of we een match hebben:

    if begin == end:
    return begin

    • Als de substring aan het begin gelijk is aan de substring aan het einde, hebben we een match

    • We geven deze substring meteen terug omdat we weten dat dit de langste is

  7. Als we geen match vinden:

    return ""

    • Als we de hele lus doorlopen zonder match, geven we een lege string terug

Laten we een voorbeeld doorlopen met “123test123”:

  1. Eerste iteratie (i=0, max_length=5):

    • begin substring = “123te”

    • end substring = “t123”

    • Geen match, max_length wordt 4

  2. Tweede iteratie (i=1, max_length=4):

    • begin substring = “123t”

    • end substring = “t123”

    • Geen match, max_length wordt 3

  3. Derde iteratie (i=2, max_length=3):

    • begin substring = “123”

    • end substring = “123”

    • Match gevonden! Return “123”

Dit verklaart ook de andere voorbeelden:

  • “test” → vindt substring “t” (langste match aan begin en eind)

  • “testing” → vindt geen enkele matchende substring, dus “”

  • “123test123” → vindt substring “123”

  • “xxx” → vindt substring “x” (langere substrings zouden overlappen)

Opdracht 7#

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

a.

def count_char(zin, 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 x in zin:   # ga alle characters in de zin door
        if x == 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(z):
    """
    functie max_freq_letter(z) accepteert een string z .
    Deze functie moet het karakter in z teruggeven met de hoogste frequentie.
    """
    result = "" # resultaat moet een string zijn
    max_let = 0 # huidige maximum

    for x in z: # ga alle characters in de zin langs
        count = count_char(z, x)    # 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 = x  # 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"