Programmeren voor het Examen: Python-Antwoorden Die Scoren

Examenbeoordeelaars voeren je code niet twintig minuten door een debugger. Ze lezen het één keer, misschien twee keer, en checken het tegen een beoordelingsschema. Een werkende oplossing die het beoordelingsschema negeert, kan nog steeds punten verliezen, terwijl een iets ruwere oplossing die elk controlepunt raakt, hoger kan scoren. Python schrijven voor een examen is een ander vaardigheid dan Python schrijven voor een echt project, en het is de moeite waard om apart te oefenen.

Lees het beoordelingsschema voordat je het probleem twee keer leest

De meeste programmeerexamens — AP CS A stijl vrije-antwoordvragen, universitaire tussentoetsen, bootcamp-beoordelingen — publiceren regels voor deelkrediet. Een typische beoordelingslijn ziet er zo uit: "1 punt voor correcte lusstructuur, 1 punt voor correcte retourwaarde, 1 punt voor het verwerken van het lege lijstgeval." Als je een dichte eenregelige oplossing schrijft die het juiste antwoord geeft maar een expliciete lus overslaat, zullen sommige beoordelaars je punten aftrekken, zelfs al is de output correct.

Voordat je iets typt, identificeer je de onderdelen die een beoordelaar waarschijnlijk apart zal controleren:

• Functiehandtekening komt precies overeen met wat werd gevraagd (naam, parametervolgordefie, retourtype)
• Basisgeval en recursief geval, als recursie wordt verwacht
• Luslimieten (off-by-one fouten zijn het meest voorkomende puntenverlies)
• Randgevallen: lege invoer, invoer met één element, negatieve getallen, duplicaten

Schrijf deze eerst als opmerkingen. # handle empty list, # base case: n == 0. Dit kost tien seconden en garandeert dat je niet het geval vergeet dat een beoordelaar specifiek zoekt.

Structureer code zodat deelkrediet zichtbaar is

Vergelijk twee antwoorden op "schrijf een functie die het op twee na grootste getal in een lijst retourneert":

def second_largest(nums):
    return sorted(nums)[-2]

def second_largest(nums):
    if len(nums) < 2:
        return None
    largest = second = float('-inf')
    for n in nums:
        if n > largest:
            second = largest
            largest = n
        elif n > second and n != largest:
            second = n
    return second

De eerste is correct voor goed gevormde invoer maar loopt vast op een lijst met minder dan twee elementen en geeft een fout antwoord bij duplicaten zoals [5, 5, 3] (retourneert 5, naar gelang de specificatie mogelijk fout). De tweede is langer maar elke beoordelingslijn — randgeval, juiste logica, juiste retourwaarde — is expliciet en krijgt een eigen regel die een beoordelaar kan afvinken. Op een getimed examen scoort de tweede versie bijna altijd hoger, hoewel het langer duurt om in te typen.

Optimaliseer niet voortijdig, laat ook geen voor de hand liggende bugs achter

Examenvragen testen zelden Big-O kennis tenzij ze dat direct zeggen. Als de opgave zegt "schrijf een functie die duplicaten vindt", is een geneste lus van O(n²) prima tenzij de opgave grote invoer specificeert of vraagt om een efficiënte oplossing. Examentiijd besteden aan conversie naar een op set gebaseerde O(n) aanpak wanneer dat niet werd gevraagd, is tiijd die je niet terugkrijgt.

Dat gezegd hebbende, zullen sommige fouten je altijd punten kosten, ongeacht het beoordelingsschema:

• == gebruiken in plaats van is inconsistent, wat logische fouten veroorzaakt (zeldzaam in Python-examens maar verschijnt in vergelijkingszware vragen)
• Een lijst muteren terwijl je erover itereert — for x in lst: lst.remove(x) is een klassieke examenvalkuil die stilzwijgend fout resultaat oplevert
• return vergeten en in plaats daarvan afdrukken — veel autograders controleren retourwaarden, niet stdout
• Off-by-one in range() — range(len(nums)) versus range(len(nums) - 1) is elke keer dat je het schrijft dubbel controleren waard

Trace je code met de hand voordat je inlevert

Bij papiertests en de meeste in-browsercodeerexamens kun je de code niet uitvoeren. Kies één klein voorbeeld en trace het regel voor regel door, schrijf variabelewaarden op terwijl je gaat. Dit vangt waarschijnlijk 80% van de logische fouten in onder twee minuten, en het is het enige wat je met overgebleven tijd kunt doen met de hoogste waarde.

Voor recursieve functies specifiek: trace minstens twee niveaus diep en schrijf expliciet uit wanneer het basisgeval wordt bereikt. Beoordelaars geven vaak een punt alleen maar voor het aantonen dat het basisgeval correct eindigt, los van het punt dat het recursieve geval correct is.

Beheer de klok als een hulpmiddel, niet als een achteraf idee

Als een vrijeantwoordsectie 9 punten waard is over drie deelvragen, budget je ruwweg gelijke tijd en ga je verder als je vast zit voorbij die budget — een half geschreven maar bijna correct onderdeel (b) is meer ruwe punten waard dan een perfect onderdeel (a) en een leeg onderdeel (c). Schrijf een stub-functie met de juiste handtekening en een pass of een gok, zelfs als je de logica niet kunt afmaken; een juiste handtekening alleen is soms alleen al een beoordelingspunt waard.

Voor meer over het schrijven van schone, testbare Python buiten de examenruimte, en over gegevensstructuren die constant in deze vragen voorkomen, check de gerelateerde Python- en Computer Science-segmenten op Korra Studio.