PO: Informatica Olympiade

Transcriptie

1 PO: Informatica Olympiade Handreiking Wt Stedelijk Gymnasum s-hertogenbosch Wat is de Informatica Olympiade? De Nederlandse Informatica Olympiade (NIO) is een programmeerwedstrijd voor de bovenbouw van het Voortgezet onderwijs. Het is een onderdeel van de International Olympiad in Informatics (IOI). De eerste ronde van de NIO bestaat uit 4 onderdelen A, B, C en D: Opgaven en links: PDF met alle opgaven van de NIO 2019 Digitaal inleverplatform van de NIO Hoofdwebsite van de NIO De 100 inzendingen met de meeste punten (mits deze minimaal 200 punten hebben gehaald) worden uitgenodigd voor de tweede ronde van de NIO in maart 2018 (meestal op de Technische Universiteit Twente). Om mee te doen aan de olympiade, moeten je uitwerkingen digitaal zijn ingeleverd bij de NIO voor 16 januari (Ze worden bij inleveren direct automatisch nagekeken en je kunt zo vaak nieuwe/verbeterde versies insturen als je wilt). De beste deelnemers van de tweede ronde gaan door naar de derde ronde om te bepalen wie er namens Nederland mee mag doen aan de Internationale Informatica Olympiade in de zomer van 2019 in Azerbeidzjan. 1

2 Inhoud Wat is de Informatica Olympiade?... 1 De PO... 3 Puntenverdeling:... 3 Inleveren en beoordeling:... 3 Automatisch nakijken... 4 Tips en tricks bij de A opgaven... 7 Algemene tips... 7 Opdracht 1: Trapezium (1 pnt)... 7 Opdracht 2: Letterbeeld (1 pnt)... 7 Opdracht 3: Cijferwoorden (1 pnt)... 9 Opdracht 4: Getallenrivieren (1,5 pnt): Globale opzet van de oplossing Een stroom functie De rivierenlijst aanleggen De rivierenlijst vullen met de hoofdrivieren De invoer verwerken Opdracht 5: Eenrichtingsverkeer (1,5 pnt) Introductie recursie Oplossings-strategie Invoer lezen De recursieve functie De functie uitvoeren De route omzetten naar letters

3 De PO Als PO voor Informatica gaan we de een deel van de opgaven van de eerste ronde van de NIO maken, namelijk die van categorie A en C. Je bent zelf vrij om ook daadwerkelijk mee te doen aan de Olympiade met je uitwerkingen (Met het maken van de PO ben je al een flink eind op weg, je kunt dan zelf de overige opgaven nog maken voor meer punten). Meer details over hoe je meedoet en welke voorwaarden er zijn, vind je op Wt helpt je natuurlijk graag als je officieel mee wilt doen. De olympiade schrijft niet voor in welke programmeertaal je de oplossingen maakt. De opgaven zijn zo gemaakt dat je in principe in elke taal een oplossing kunt schrijven. In dit document ga ik er van uit dat je het in Python doet. Als je liever een andere taal gebruikt, mag dat natuurlijk ook. Puntenverdeling: Je doet deze PO alleen of met zijn tweeën. (Let op: De deelname aan de NIO zelf is individueel, dus van een duo kan maar 1 persoon deelnemen, omdat je niet 2x dezelfde code in kunt/mag leveren. Als je toch allebei wilt deelnemen, zul je verschillende versies van je oplossingen moeten maken.) We maken voor de PO alleen opgaven A en C (en eventueel D als je wilt). Opgaven B worden uniek gegenereerd voor elke deelnemer. Deze opgaven moet je zeker ook maken als je aan de Olympiade mee wilt doen, maar voor de PO slaan we ze over, omdat deze voor Wt niet goed na te kijken zijn. De beoordeling van de PO is als volgt: 1 punt cadeau Je verslag met toelichting op je code en logboek leveren samen 1 punt op Met het maken van opgaven A1 t/m A4 kun je 4,5 punten verdienen: o A1: 1,0 punt o A2: 1,0 punt o A3: 1,0 punt o A4: 1,5 punt Met het maken van A5, en opgave C (en eventueel D als superbonus), zijn de laatste 3,5 punten te verdienen: o A5: 1,5 punt o C1: 1,0 punt o C2: 1,0 punt Deels correcte oplossingen van een opgave leveren een deel van de punten op, dus ook al kom je er niet uit, lever je beste poging van elke opgave toch in. Let op: de opgaven lopen op in moeilijkheid, maar de puntenwaardering ligt relatief zwaar op de eerste opgaven. Zo moet het voor iedereen mogelijk zijn een nette voldoende te halen en voor de doorzetters zijn hogere punten haalbaar. Inleveren en beoordeling: Je levert bij Wt je gemaakte programma s in. Daarnaast maak je een begeleidend verslag waarin je de code uitlegt. Hiermee help je mij jouw/jullie code te begrijpen en laat je zien dat je begrijpt wat je gedaan hebt (plagiaatcontrole). Tevens lever je een logboekje in met de bestede tijd per persoon. Dit 3

4 geeft mij inzicht in jullie tijdsbesteding en kan dienen als bewijsmateriaal bij eventuele onenigheid binnen een duo. Let op: Omdat deze PO plagiaat gevoelig is (Wt heeft er eerder problemen mee gehad), let ik extra op het kopiëren van andermans code en op de codetoelichting die je in je verslag geeft. Bij twijfel zal Wt om een mondelinge toelichting vragen om te checken of je je eigen code hebt geschreven en snapt wat je hebt gedaan! Elkaar een beetje helpen mag natuurlijk (en wordt zelfs aangemoedigd), maar code inleveren die je zelf niet helemaal begrijpt en dus niet kan toelichten, mag niet. Je levert alle onderdelen van de PO (de programma s en het verslag) in in een.zip file bij de opdracht die openstaat in Magister. Je hoeft per groepje uiteraard maar 1 keer in te leveren. Uiterlijke inleverdatum: Zondag 9 december om 23:59 uur Automatisch nakijken De informatica olympiade werkt met een automatisch nakijksysteem. Hierbij kun je een script dat je geschreven hebt als oplossing voor een van de opgaven inleveren. Er worden dan een aantal testcases automatisch op losgelaten en je krijgt punten voor elke testcase waarvoor je script het juiste antwoord geeft. Voor de testcases die misgaan krijg je te zien wat de foutmelding was (bv. Een fout antwoord, een error bij het runnen, maximale runtime overschreden, etc.). Met deze info kun je je script eventueel verbeteren en weer een nieuwe versie indienen. Je kunt elke opgave zo vaak proberen als je wilt, de hoogste score blijft staan. Zelfs als je niet aan de officiële olympiade wilt meedoen kun je hier dankbaar gebruik van maken om je PO opgaven te testen. Het werkt als volgt: Ga naar en maak een account aan. Als je bent ingelogd zie je links alle A, B en C opgaven staan (en 00 is een testopgave voor als je wilt checken of het inleveren werkt). Klik op de opgave je je wilt inleveren en klik Voeg inzending toe. Je kunt nu een script uploaden. Vergeet niet de juiste programmeertaal te selecteren (Python 2): 4

5 Als je op opslaan klikt wordt je script geupload en uitgevoerd. Je ziet dan je inzending in de lijst staan met de status uitvoeren. Dit betekent dat je script op dit moment uitgeveord wordt. Als je na een paar seconden de pagina ververst (F5), dan zie je als het goed is de status op klaar staan en is er een score gegeven (max 40 voor elke A opgave): Je kunt nu op de inzending klikken voor meer info en eventuele foutmeldingen als je niet alle 40 punten hebt gehaald: 5

6 Als er foutmeldingen staan in de rechtertabel kunnen die je helpen de fouten in je script op te sporen. De rest van dit document bevat tips, hints en uitleg om je te helpen de A opgaven te tackelen. 6

7 Tips en tricks bij de A opgaven Algemene tips - Bij elk van deze opgaven wordt er 1 of meer keer om input gevraagd (bij het automatisch nakijken wordt je programma getest met verschillende inputs). Gebruik hiervoor steeds simpelweg raw_input() De Olympiadesoftware gaat er vanuit dat je precies input leest zoals in de opgave is opgegeven en dat je precies het antwoord geeft zoals is voorgeschreven. Je moet dus geen extra tekst of tussenuitkomsten afdrukken. Doe dus ook niet zoiets als raw_input("geef een getal"), maar simpelweg raw_input() (met niets tussen de haakjes), zodat er niets extras op het scherm wordt geprint. Je opgave wordt anders niet goedgerekend door de nakijksoftware. - Om je programma s te testen is het vervelend steeds de invoer te moeten intypen. Zet tijdens het testen de waardes waar je mee wilt testen rechtstreeks in de code (en commentaar de input even weg). Dat scheelt je een hoop typewerk. Niet vergeten de input weer terug te zetten voordat je de opgave instuurt naar de nakijksoftware! Opdracht 1: Trapezium (1 pnt) Deze eerste opgave is een echte opwarmer en zou je met slechts enkele regels Python moeten kunnen maken. Een paar tips: Gebruik een for-loop om het juiste aantal rijen te printen Vergeet niet dat je in Python strings kunt vermenigvuldigen. Dus "x" * 6 geeft "xxxxxx". Dat komt hier bijzonder goed van pas om het juiste aantal sterren op elke rij af te drukken Opdracht 2: Letterbeeld (1 pnt) In deze opgave moet je eigenschappen van letters gaan bekijken en tellen. Om dat voor elkaar te krijgen, gaan we de volgende stappen uitvoeren in ons programma: We moeten de twee eigenschappen van elke letter (aantal gesloten gebieden en aantal uiteindes) vastleggen. Hiervoor gaan we 2 lijsten (python lists) met elk 26 waarden aanleggen (voor elke letter 1 waarde). o Eerst wat handwerk: Schrijf op een papiertje van alle letters uit de opgave op hoeveel gesloten gebieden ze hebben ( A: 1, B: 2, C:0, D: 1, etc.) en hoeveel uiteindes ze hebben (A: 2, B:0, C:2, D:0, etc) o Maak nu een lijst gesloten_gebieden en zet daar op volgorde deze 26 integer waarden in en doe hetzelfde voor een lijst uiteindes. We moeten de letters uit de invoer kunnen omrekenen naar hun positie in deze lijsten (A is positie 0, B is positie 1, C positie 2, etc.) 7

8 o Hiervoor moeten we even de ASCII tabel er bij halen: o Elke letter heeft een eigen positie (nummer) op de ASCII tabel. In deze opgave wordt alleen met de hoofdletters gewerkt. De hoofdletters zitten netjes naast elkaar in de ASCII tabel met waarde 65 (A) t/m 90 (Z). In python kun je een letter omzetten naar de bijbehorende ASCII waarde met ord(): code = ord("q") print code Uitvoer: 81 Andersom kan ook natuurlijk. Het teken opvragen van een bepaalde ASCII cijferwaarde gaat als volgt: letter = chr(87) print letter 8

9 o Uitvoer: "W" De ASCII waarde van letter A is 65, die van letter B is 66, etc. Bedenk zelf een truuk om de ASCII waardes van de letters om te rekenen naar hun positie in de lijst uit de vorige stap. (Dus zou moeten worden: A is 0, B is 1, etc.) We kunnen nu een (for) loop doen over alle letters van het woord, met de truuk uit de vorige stap de index van die letter in de lijsten bepalen en vervolgens de twee waardes van die letter opzoeken en optellen. Vergeet niet om vooraf aan de loop 2 tellers aan te maken die de totalen van deze waardes bijhouden. Als we klaar zijn met de loop, hebben we het antwoord en kunne we het afdrukken naar de output. Opdracht 3: Cijferwoorden (1 pnt) Het tackelen van deze opdracht ziet er globaal als volgt uit: Maak een list letterwoorden met daarin strings van alle mogelijke getallen ("TWEE", "DRIE", etc) Doe een for-loop over deze list (check dus een voor een alle mogelijke uitkomsten) Binnen deze for-loop doe je een tweede for-loop over alle letters van de invoer o Houd bij welke letters van het huidige letterwoord je al hebt gezien o Als je een matchende letter tegenkomt, schuif je een plek op o Heb je het einde van een letterwoord bereikt voordat je de hele invoer hebt gezien, dan is dat het goede antwoord en kun je het huidige letterwoord printen o Als je alle letterwoorden hebt gehad en geen match hebt gevonden, vergeet dan niet om geen te printen als antwoord. Extra hints: Houd in een int variabele bij op welke positie je bent in het huidige letterwoord dat je checkt Vergeet niet bij elk nieuw letterwoord weer op 0 te beginnen met deze variabele Verzin een truuk om te weten of je op het einde van je check nog geen moet printen. Dus houd in een variabele bij of je al iets geprint hebt. ZO niet, moet je op het eind geen printen. 9

10 Opdracht 4: Getallenrivieren (1,5 pnt): De opdracht beschrijft hoe getallenrivieren werken. Er wordt gesteld dat alle mogelijke rivieren uiteindelijk samengaan met de rivier van 1, 3 of 9. Gegeven een startgetal, moeten we de rivier van dat getal volgen om te bepalen met welke rivier (1, 3 of 9) hij samenstroomt. We hoeven alleen te kijken naar de getallen tot (dat is veel, maar ook weer niet zó veel). Globale opzet van de oplossing 1. Bepaal vooraf van alle getallen tussen de 1 en de of ze tot de rivier van 1, 3 of 9 behoren en leg dit vast in een lijst. Dat wil zeggen: volg de rivieren van 1, 3 en 9 en onderweg slaan we alle stappen op. 2. Volg stap voor stap de rivier van het invoergetal 3. Kijk bij elke stap van de rivier in de lijst uit 1. Om te zien of we al bij een plek uit de rivier van 1, 3 of 9 zijn aangeland. Zo ja, hebben we het antwoord gevonden, zo nee stromen we nog even verder. Een stroom functie Omdat we steeds in stapjes de stroom van een getallenrivier gaan volgens, ligt het erg voor de hand om een functie te schrijven. Deze functie neemt een invoer getal en returnt de volgende stap uit de rivier. Door vervolgens deze functie herhaaldelijk aan te roepen, kunnen we de rivier laten stromen. Schrijf een functie stroom(stap) die een integer stap als argument neemt en hiervan de afzonderlijke getallen optelt bij stap. - Maak in de functie een kopie van stap in string-vorm. (met str(9)vervang je de int 9 door de string "9" weet je nog?) - Nu kun je met een for loop door de individuele getallen van stap lopen en deze optellen (vergeet niet elk individueel getal weer terug om te zetten naar int voordat je optelt) - Tel deze som op bij stap en return het resultaat - Test je functie. Voer eens uit print stroom(345). Het antwoord zou 357 moeten zijn. De rivierenlijst aanleggen We gaan nu een lijst met integers maken. In deze lijst leggen we van alle getallen onder de vast tot welke hoofd-rivier ze behoren (1,3 of 9) of dat ze niet tot een hoofdrivier behoren (Dan zetten we die positie op 0). Om je een idee te geven, de eerste 20 getallen (posities 0 t/m 19) van deze lijst zien er als we klaar zijn zo uit: [0, 1, 1, 3, 1, 0, 3, 0, 1, 9, 0, 0, 3, 0, 0, 3, 1, 0, 9, 0] Dat wil zeggen: - 0 behoort niet tot een hoofdriver (vandaar de 0 op die plek) - 1 behoort tot de hoofdriver van 1 (vandaar de 1 op die plek - 2 behoort tot de hoofdriver van 1-3 behoort tot de hoofdriver van 3-4 behoort tot de hoofdriver van 1-5 behoort niet tot een hoofdrivier 10

11 - Etc Als de lijst klaar is, kunnen we dus simpelweg met het commando rivierenlijst[x] opzoeken tot welke hoofdrivier het getal x behoort. Om de lijst aan te maken, gaan we eerst alle getallen in de lijst op 0 zetten. Dat kan simpelweg met: rivierenlijst = [0]* Rivierenlijst is nu een lijst van nullen achter elkaar (print hem maar eens voor de grap). Nu moeten we de rivieren van 1, 3 en 9 invullen op de juiste posities in deze lijst. Hiervoor gaan we 3 loops uitvoeren, voor elke hoofdrivier een. Daarbij kunnen we dankbaar gebruik maken van de functie die we hiervoor hebben gemaakt De rivierenlijst vullen met de hoofdrivieren Ik beschrijf de stappen voor het invullen van de rivier van 1. - Maak een variabele getal en vul deze met het cijfer 1 (het startgetal) - Sla op de positie van getal in de rivierenlijst het getal 1 op om aan te geven dat deze positie tot de rivier van 1 behoort. - Maak nu een while loop die net zo lang herhaalt als dat getal kleiner is dan In de while loop doe je het volgende: o Maak getal gelijk aan de volgende stap van de rivier met behulp van je functie stroom() o Sla op de positie van getal weer in de rivierenlijst het getal 1 op om aan te geven dat deze positie tot de rivier van 1 behoort. Als de while loop eindigt, heb je alle getallen uit de hoofdrivier van 1 opgenomen in de lijst. Je doet nu dus nog eens hetzelfde voor de rivieren van 3 en 9 De invoer verwerken Nu hebben we alles klaar staan om de rivier van de invoer te laten stromen: - Lees het invoergetal uit de input - Maak weer een while loop die blijft lopen zolang dat getal niet tot een van de hoofdrivieren behoort (zoek dat dus op in rivierenlijst). In de loop doe je o Bepaal met de stroom() functie de volgende stap van de rivier o Check of deze nieuwe stap tot een hoofdrivier behoort. Zo ja, return dat als je eindantwoord. Zo niet, doe je niets. De while loop gaat dan weer verder Dus je doorloopt de rivier van het invoergetal stap voor stap met behulp van je stroom() functie. Zodra je bij een stap komt die tot en van de hoofdrivieren behoort heb je het eindantwoord gevonden. 11

12 Opdracht 5: Eenrichtingsverkeer (1,5 pnt) Het doorlopen van een graaf (een diagram met knooppunten en verbindingen zoals hier) op zoek naar een specifieke route, is niet eenvoudig. Er zijn veel mogelijkheden, zeker als het aantal knooppunten toeneemt (de opgave is voor grafen tot en met 26 knoppunten, dus dat is flink wat). Het lastigste deel is je administratie. Hoe houd je bij welke stappen je al gehad hebt en welke kanten je nog op kunt. Hoe voorkom je dat je dingen dubbel doet en oneindig door het netwerk blijft dwalen? Introductie recursie Voor het oplossen van deze opgave heb je een programmeerprincipe nodig dat recursie heet. Recursie is programmeren met een functie (def) die zichzelf aanroept (en daarbij dus zichzelf weer aanroept, die daarbij zichzelf weer aanroept, etc.) Voor een goede introductie op recursie, kijk eens hier: (Deze link werkt niet op school. Een werkende Wt kopie staat hier) Een bekend voorbeeld van recursie is het berekenen van de Fibonacci reeks (wat we vorig jaar al zonder recursie hebben gedaan in Wt Python opgave 9). Hier is een recursieve oplossing voor het Fibonacci probleem: def fib(n): if n==1 or n==2: return 1 else: return fib(n-1) + fib(n-2) Extra interessante info: Het zoeken van pad door een graaf (een diagram met verbonden punten) is een klassiek informatica-probleem met veel toepassingen in de echte wereld (denk aan een navigatiesysteem of ov routeplanner.) Een van de beroemdste algoritmes voor dit soort problemen komt van de Nederlandse informatica Dijkstra en is opgesteld in de jaren 50. Dijkstra s Kortste-Pad algoritme wordt tegenwoordig nog steeds gebruikt voor navigatiesystemen en dergelijke. Bekijk (en test) het voorbeeld eens om goed te snappen wat er gebeurt. Vergelijk de recursieve oplossing met de gewone (iteratieve) oplossing die je vorig jaar hebt gemaakt (hier zijn Wt s uitwerkingen overigens), vraag Wt eventueel om extra uitleg om de recursieve versie goed te snappen. Oplossings-strategie Nu je weet wat recursie is, kunnen we de opgave oplossen. Globaal ziet de oplossing er als volgt uit: - Lees alle invoer en sla de verbindingen tussen de steden op in een 2D lijst - We maken een recursieve functie die vanuit een startpunt alle verbonden steden gaat bezoeken. Hierbij wordt bijgehouden welke steden al bezocht zijn en in welke stad we op dit moment zijn 12

13 - Als het deze functie lukt om een pad te maken dat even lang is als het aantal steden, hebben we een antwoord gevonden - De steden zijn genummerd met letters (A, B, C, etc), dus we moeten ons antwoord nog even omzetten in de juiste stedenletters Invoer lezen De invoer bestaat uit een getal dat aangeeft hoeveel steden er zijn. Dit getal moeten we lezen en hebben we nodig als grens voor de volgende loop. Laten we het aantal noemen. We willen de verbindingen graag opslaan in een 2D lijst (een lijst met daarin weer lijsten met daarin getallen). De handigste vorm is zo (met de voorbeeldinvoer): [[0, 1, 0, 1, 1], [0, 0, 1, 0, 0], [1, 0, 0, 0, 1], [0, 1, 1, 0, 1], [0, 1, 0, 0, 0]] Begin met een lege lijst verbindingen. Maak een for loop met precies aantal stappen. Elke stap lees je een regel van de invoer als string in. Maak een nieuwe lege lijst rij. Doorloop de gelezen regel en zet elk getal uit die regel in de rij list. Als je klaar bent met de regel, append je de rij lijst aan de verbindingen lijst. Als je klaar bent met de loop, is je 2D lijst gevuld met alle verbindingen. De recursieve functie We gaan onze functie zo bouwen, dat als hij wordt aangeroepen met een startpunt, hij alle mogelijke paden vanuit dat punt gaat proberen, in de hoop alle punten te bereiken. Deze functie voeren we vervolgens uit met alle mogelijke startpunten. Omdat we uit de opgave weten dat er altijd een goede oplossing mogelijk is, moeten we zo een route tegenkomen. We maken een recursieve functie pad(huidig_pad, huidig_punt) Deze functie heeft 2 parameters: - huidig_pad is een list met alle punten die we al bezocht hebben - huidig_punt is het punt waar we ons op dit moment bevinden (in principe kun je huidig punt weglaten, want dat is simpelweg het laatste punt uit de huidig_pad lijst, maar voor het gemak nemen we deze los) Als je dus straks alle mogelijke paden vanuit punt 3 wilt checken, roep je deze functie aan met: pad([3],3) Deze gaat dan recursief alle mogelijke paden vanuit 3 langs. Als hij een pad vindt dat de alle punten aandoet, hebben we ons antwoord gevonden De implementatie (body) van de functie komt op het volgende neer: - Check of de lengte van huidig_pad gelijk is aan het aantal punten o Als dat zo is, dan zijn we klaar en returnen we huidig_pad 13

14 o Anders: Tel het aantal mogelijke stappen die je nog kunt zetten vanaf het huidige punt. Hiervoor doorloop je de verbindingen lijst om te kijken waar je heen kunt. Punten die je al gehad hebt (te zien in huidig_pad), tel je niet mee. Check of het aantal mogelijke punten 0 is Als dat zo is loopt deze route dood (je hebt immers nog niet alle punten bezocht, maar je kunt geen stappen meer zetten), dus return je False Als dat niet zo is, gaan we de pad() functie recursief aanroepen voor alle mogelijke stappen die we vanuit hier nog kunnen zetten. Vergeet niet de nieuwe stap te verwerken in de parameters die je aan de recursieve aanroep meegeeft. (Dus je pad is nu 1 langer en je huidig punt Van elke recursieve aanroep ga je checken of het resultaat False is (dan is dat pad doodgelopen) Als het False is doe je niets (het feit dat 1 subpad doodloopt, wil niet zeggen dat ze allemaal doodlopen). We wachten dus nog het resultaat van de overige paden af Als het niet False is, dan is het een list met een correcte route. Return deze weer. (Dus die geef je weer netjes door aan de vorige recursiestap) Als je alle paden gecheckt hebt return je False (als er namelijke een zinnig pad bij zat, heb je al en return waarde gegeven en om je niet op deze plek) De functie uitvoeren We moeten nu de recursieve functie opstarten (en zijn recursieve ding laten doen) voor alle mogelijke startpunten. Hiervoor kunnen we een for-loop gebruiken. We kunnen deze loop afbreken zodra we een antwoord hebben gevonden uit de functie dat niet False is. Met break kun je de loop dan stoppen. De route omzetten naar letters Omdat we met lists hebben gewerkt hebben we tot nu toe alle knooppunten als een cijfer geïnterpreteerd (A=0, B=1, C=2, etc.). De opgave vereist dat we ons antwoord als een rij letters printen. Hiervoor moeten we de getalen uit ons antwoord omzetten naar de juiste hofdletter Hiervoor kun je weer de ASCII tabel gebruiken, zoals in opgave 2. Succes met C1 en C2! 14