Opdracht 3: Dodo verdeelt haar werk

Opdracht 3: Dodo verdeelt haar werk Algoritmisch Denken en Gestructureerd Programmeren (in Greenfoot) c 2017 Renske Smetsers-Weeda & Sjaak Smetsers 1 Inhoudsopgave Inleiding 1 Leerdoelen 1 Instructies 1 Theorie 2 3.1 Submethodes ontwerpen......................................... 2 3.2 Een probleem opdelen in kleinere delen................................ 3 3.3 Lay-out van code.............................................. 3 3.4 Logische operatoren............................................ 4 3.5 Je initiële wereld instellen......................................... 4 3.6 Een wereld opslaan............................................. 5 3.7 Tekst gebruiken............................................... 5 Uitdagingen 7 3.1 Submethodes gebruiken.......................................... 7 3.2 Oefenen met logische operatoren.................................... 8 3.3 Leg een ei in ieder nest........................................... 9 3.4 Geen dubbele eieren............................................ 10 3.5 Door een tunnel lopen........................................... 10 3.6 Naar het nest lopen en hekken ontwijken................................ 11 3.7 Om een omheining lopen......................................... 11 3.8 Spoor van eieren volgen tot het nest................................... 12 3.9 Eenvoudige doolhof............................................ 13 3.10 Lastigere doolhof............................................. 14 3.11 Dodo maakt wilde sprongen....................................... 14 Reflectie 17 Opslaan en inleveren 18 1 Licensed under the Creative Commons Attribution 4.0 license: https://creativecommons.org/licenses/by/4.0/

Inleiding In de vorige opgaven maakte je kennis met Greenfoot en algoritmisch denken. Je bent in staat om code te lezen, deze aan te passen en om zelf code te schrijven. Ook kun je generieke oplossingen bedenken en implementeren. In deze opdracht zul je leren om je oplossing te ontwerpen door deze op te splitsen in verschillende losse onderdelen. Zo wordt het makkelijker om te programmeren, te testen en je geschreven code opnieuw te gebruiken. Door problemen op te delen in kleinere stukken wordt het makkelijker om complexere problemen op te lossen. Doelen Het doel van deze opdracht is: Problemen opdelen in kleinere behapbare delen. Leerdoelen Na het voltooien van deze opdracht kun je: een (complex) probleem opdelen in deelproblemen. decompositie toepassen in stroomdiagrammen en code door submethodes te herkennen. submethodes afzonderlijk ontwerpen, schrijven en testen. de rol van het resultaattype en de parameter(s) van een methode omschrijven. bestaande submethodes en oplossingen opnieuw gebruiken. conditionele expressies samenstellen door logische operatoren te combineren. nesting toepassen als strategie voor het oplossen van complexere problemen. generieke oplossingen ontwikkelen. jouw oplossing beoordelen. Instructies In deze opdracht ga je verder met je eigen code uit de vorige opdracht. Maak een kopie van jouw scenario zodat je altijd nog terug kan naar een vorige versie. Een kopie maken doe je zo: Open jouw scenario van de vorige opdracht. In de Greenfoot menu, bovenaan het scherm, selecteer je Scenario en dan Save As.... Ga naar de folder waarin je jouw werk voor opdracht 3 wilt opslaan. Kies een bestandsnaam met jouw eigen naam en opdrachtnummer, bijvoorbeeld: Opdr3_John. Tijdens de opdracht zul je wat vragen moeten beantwoorden. Je moet het volgende inleveren: Alle stroomdiagrammen: gebruik potlood en papier, of maak gebruik van de software op https: //www.draw.io/; Jouw code: het bestand MyDodo.java bevat al jouw code en moet ingeleverd worden; Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 1

Het reflectieblad: vul in en lever het in. Je moet al jouw antwoorden met je partner te bespreken. Noteer kort jullie antwoorden. Er zijn drie soorten taken: Aanbevolen. Leerlingen met weinig programmeerervaring, of leerlingen die wat meer oefening nodig hebben, moeten deze taken allemaal afmaken. Verplicht. Iedereen moet deze taken afmaken. Uitdagend. Complexere taken, ontwikkeld voor leerlingen die de 2-ster opdrachten voltooid hebben en klaar zijn voor een grotere uitdaging. Leerlingen die 1-ster taken overslaan moeten alle 3-ster taken maken. Opmerking: In deze opdracht mag je alleen aanpassingen maken in MyDodo; Je mag methodes gebruiken uit de MyDodo of Dodo klasse, maar niet uit de Actor klasse; Teleporteren is niet toegestaan: als Mimi ergens moet zijn, dan moet ze daar zelf stap voor stap heenlopen (ze mag er niet in één keer naar toe springen). Theorie Theorie 3.1: Submethodes ontwerpen Wanneer een reeks taken herhaald wordt, kan het handig zijn om deze in een aparte submethode te zetten. Als je dan die reeks nodig hebt, hoef je alleen die submethode aan te roepen. Dat scheelt veel foutgevoelig typewerk en maakt daarnaast het testen en hergebruik makkelijker. Voorbeeld Om een stap achteruit te zetten moet Mimi: 180 graden draaien (bijvoorbeeld door twee keer turnright( ) aan te roepen), een stap zetten en dan, weer 180 graden draaien (weer door twee keer turnright( ) aan te roepen). Als Mimi nu een paar stappen achteruit moet zetten en je zou, om dit te realiseren, de code voor het zetten van één stap achteruit steeds dupliceren dan krijg je op die manier wel erg veel instructies. In zo n geval is het veel beter om een submethode public void steponecellbackwards( ) te schrijven. / ** * Move one cell backwards * * <p>initial situation is same as final situation. * * / public void steponecellbackwards( ) { turnright( ); turnright( ); Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 2

} move(); turnright( ); turnright( ); Die methode kun je steeds aanroepen met steponecellbackwards( );. Zie de code hieronder. public void methodeonecellbackwardsgebruiken( ) { // deel van een methode steponecellbackwards( ); // rest van de methode } Theorie 3.2: Een probleem opdelen in kleinere delen Een complex probleem (en zijn oplossing), wordt eenvoudiger als je het opdeelt in kleinere behapbare onderdelen. In programmacode vormen deze delen aparte submethodes. Elke submethode kan afzonderlijk ontworpen, ontwikkeld en getest worden (zie Theorie 3.1). Submethodes worden daarna gecombineerd tot een totaaloplossing voor het probleem als geheel. Deze aanpak waarin een groot probleem wordt opgedeeld in meerdere kleinere deelproblemen heet decompositie. Figuur 1: Een probleem in kleine problemen opdelen en deze afzonderlijk aanpakken Decompositie wordt toegepast bij: complexe problemen: als een probleem of reeks van taken zo ingewikkeld is dat het beter (overzichtelijker en minder foutgevoelig) is om deze afzonderlijk te ontwerpen, te ontwikkelen en te testen. herhaling: als dezelfde reeks van stappen meerdere keren wordt herhaald. veel afzonderlijke stappen: als een algoritme moeilijk te lezen of te begrijpen is doordat het bestaat uit heel veel gedetailleerde stappen (bijvoorbeeld, meer dan zeven). samenhangende stappen: als een reeks van stappen samen een redelijk op zichzelf staande taak of module vormen (die mogelijk ergens anders of in een later stadium opnieuw gebruikt kan worden). Door decompositie wordt code makkelijker te begrijpen (lezen), te testen, opnieuw te gebruiken, aan te passen en uit te breiden. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 3

Theorie 3.3: Lay-out van code Code wordt beter leesbaar door steeds dezelfde stijl te gebruiken. Net als naamgeving, zijn er ook stijlafspraken. Door steeds op dezelfde wijze in te springen kun je bepaalde fouten voorkomen. Zo zie je bijvoorbeeld sneller of je een haakje of accolade te veel of te weinig hebt. De volgende twee voorbeelden laten duidelijk het voordeel zien van het uitlijnen van code. public void move() { if ( canmove() ) { step(); } else { showerror( "I m stuck!" ); // prints to the console. } } public void move( ) { if ( canmove( ) ) { step( ); } else { showerror( "I m stuck!" ); // prints to the console. } } Zie http://google-styleguide.googlecode.com/svn/trunk/javaguide.html voor een compleet overzicht van stijl- en naamgevingsafspraken. Greenfoot kan je trouwens helpen om jouw code uit te lijnen. Gebruik hiervoor Ctrl-Shift-I. Theorie 3.4: Logische operatoren De EN (in programmacode: &&), de OF (in code: ) en de NIET (in code:!) heten logische operatoren. Logische operatoren kunnen handig zijn bij het vormen van beslissingen, omdat ze je in staat stellen boolean methodes te combineren. Op die manier kun je conditionele expressies samenstellen die bepaalde keuzes heel specifiek omschrijven. Operator Betekenis Voorbeeld && EN facingnorth( )&& fenceahead( ) OF fenceahead( ) borderahead( )! NIET!fenceAhead( ) Logische operatoren combineren Met logische operatoren kun je complexere conditionele expressies maken. Hierdoor wordt jouw code mogelijk eenvoudiger. Echter, het combineren van logische operatoren, in het bijzonder met een negatie (de NIET) kan ook tot lastig te begrijpen uitdrukkingen leiden. Daarnaast is het raadzaam om haakjes te gebruiken om duidelijk te maken wat bij elkaar hoort. Expressie Is gelijk aan Betekenis!( A && B )!A!B Is waar zodra één van beide A of B niet waar is!( A B )!A &&!B Is alleen waar als geen van beide A or B waar is Voorbeelden NIET (slaan OF trappen) wordt!(slaan trappen) wat hetzelfde betekent als!slaan &&! trappen. Oftewel je mag geen van beide doen. NIET (sokken EN sandalen) wordt!(sokken && sandalen) wat hetzelfde betekent als!sokken!sandalen. Oftewel, je mag of het een of de ander, maar niet allebei (wat er ook en beetje gek uitziet, vind je niet?). Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 4

Theorie 3.5: Je initiële wereld instellen Wil je dat steeds een bepaalde wereld geopend wordt en dat je dus niet telkens weer opnieuw alle objecten in de wereld hoeft te plaatsen (bijvoorbeeld nadat je je code hebt aangepast), volg dan deze instructies waarmee we de wereld, als voorbeeld, de wereld worldemptyneststoprow laden: 1. Klik in het klassendiagram met de rechtermuisknop op Mauritius. 2. Kies Open Editor 3. Bovenin staat de volgende declaratie: Figuur 2: Opent een lege wereld (beginsituatie) 4. Vervang de bestandsnaam van de wereld (hetgeen vóór de.txt ) met de wereld die je wil openen (bijvoorbeeld worldemptyneststoprow ). Het ziet er dan zo uit: Figuur 3: Opent worldemptyneststoprow bestand Theorie 3.6: Een wereld opslaan Volg deze stappen om een wereld op te slaan: 1. Klik in de wereld met de rechtermuisknop op een lege cel. 2. Kies savetofile( ). 3. De wereld is nu opgeslagen met de naam saved.txt in de map worlds. Je kunt in deze map het bestand zelf een andere, zinvollere naam geven. Bedenk ook dat wanneer je twee of meerdere keren savetofile( ) gebruikt, de oude saved.txt zal worden overschreven. Theorie 3.5 omschrijft hoe je elke keer een bepaalde wereld kan laden. Theorie 3.7: Tekst gebruiken In Java (en ook in veel andere programmeertalen) wordt een tekst een String genoemd. String is een type, net zoals int en boolean. Methodes kunnen een String (oftewel tekst) als parameter meekrijgen. Je hebt er al een gebruikt om tekst naar de console af te drukken (zie Theorie 1.14). Om een tekst in een programma te kunnen gebruiken, moet je deze altijd tussen dubbele aanhalingstekens zetten. Zo definieer je een String: String text1 = "Hello"; Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 5

Zo geef je een String als parameter mee: String textgreeting = "Hello"; System.out.println ( textgreeting ); Het resultaat ziet er zo uit: Twee Strings plak je aan elkaar (concatenatie) met +. String textgreetingmimi = "Hello " + "Mimi"; System.out.println ( textgreetingmimi ); Het resultaat ziet er zo uit: Een String en een int variable int nrofeggsfound voeg je ook samen met +. int nrofeggs = 5; String textifound = "I have found "; System.out.println ( textifound + nrofeggs + " eggs today" ); Het resultaat ziet er zo uit: Dit is soms een beetje verwarrend omdat de + ook gebruikt kan worden voor het optellen van twee ints. Zoek zelf maar eens uit wat het verschil is tussen 1 + 1 + "= 2" en "2 = "+ 1 + 1. De methode showcompliment(string compliment) krijgt een String met de naam compliment als parameter mee. De methode levert een smiley op samen met het compliment zelf. De volgende twee voorbeelden van programmacode leveren precies hetzelfde resultaat op. Het resultaat zie je in figuur 4. showcompliment( "Congradulations!" ); en String textcongradulations = "Congradulations!"; showcompliment( textcongradulations ); Figuur 4: Resultaat van beide stukjes code Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 6

Uitdagingen Lees eerst Theorie 3.1: Submethodes ontwerpen. Lees eerst Theorie 3.2: Een probleem opdelen in kleinere delen. Opgave 3.1: Submethodes gebruiken Bij taak 2.5 heb je de methode boolean grainahead( ) geschreven die controleerde of er een graan in de cel voor Mimi lag (zie stroomdiagram 5). Figuur 5: Stroomdiagram voor grainahead De volgende taak is om submethodes te gebruiken om de code van boolean grainahead( ) op te schonen. a) Schrijf een methode stepback ( ) waarmee Mimi één stapje achteruit zet. Na afloop moet ze nog altijd in de oorspronkelijke richting kijken. Voeg ook JavaDoc commentaar toe. b) Vervang de omcirkelde code door een aanroep van stepback, zoals in het volgende stroomdiagram: Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 7

Figuur 6: Stroomdiagram voor grainahead door gebruik te maken van de submethode stepback c) Test jouw programma. d) Kun je nog meer code opruimen in de grainahead methode? e) Test jouw programma opnieuw ook al heb je slechts kleine wijzigingen aangebracht. Lees eerst Theorie 3.3: Lay-out van code. Lees eerst Theorie 3.4: Logische operatoren. Opgave 3.2: Oefenen met logische operatoren De logische operatoren EN, OF NIET worden vaak verkeerd begrepen, zeker als ze in combinaties voorkomen. Daarom oefenen we er nu even mee. a) In een bus hangt een bord: Zittend 15 staand 3 OF 13 zittend + 1 rolstoel. Vul de volgende twee uitspraken aan: Specifieker: (zittend IS GELIJK AAN 15 EN staand IS GELIJK AAN 3)OF... En dit vertalen naar programmacode wordt: (zittend == 15 && staand == 3)... b) Wat wil je vanavond eten? Plaats haakjes op de juiste plek en vertaal het vervolgens naar programmacode: Frietjes en frikandel of kroket en een blikje. c) Honden en katten gaan niet samen, dat wordt ruzie. Haal de haakjes weg en pas de uitspraak aan zodat deze nog altijd hetzelfde betekent: NIET (honden EN katten) d) We kunnen niet naar buiten als het regent of onweert. Haal de haakjes weg en pas de uitspraak aan zodat deze nog altijd hetzelfde betekent: NIET (regen OF onweer) Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 8

Lees eerst Theorie 3.5: Je initiële wereld instellen. Lees eerst Theorie 3.6: Een wereld opslaan. Opgave 3.3: Leg een ei in ieder nest Jouw taak is: Mimi loopt naar de grens van de wereld. Als ze onderweg een nest tegenkomt, legt ze er een ei in. Zorg ervoor dat jouw algoritme generiek is. Het moet dus werken in elke wereld, ook als een nest iets naar links of rechts wordt verplaatst, of als er een extra nest wordt toegevoegd. a) Open de worldemptyneststoprow wereld. b) Vul de lege plekken in de stroomdiagram in figuur 7 aan. Figuur 7: Stroomdiagram voor het vullen van nestjes tot aan de grens van de wereld c) Schrijf de bijbehorende programmacode (en commentaar). Zorg er ook voor dat jouw code uitgelijnd is (zie Theorie 3.3). d) Test jouw methode door met je rechtermuisknop op Mimi te klikken en de methode aan te roepen. Tip: Theorie 3.5 omschrijft hoe je elke keer een bepaalde wereld kan laden. e) Werkt het programma zoals je verwacht? Er zit een fout in het stroomdiagram. Kun jij die vinden? f) Hoe zou je het stroomdiagram aan kunnen passen? Pas de code aan met jouw verbetervoorstel. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 9

g) Test opnieuw. Je hebt nu een if..then..else.. genest in een while-loop. Opgave 3.4: Geen dubbele eieren Jouw volgende taak is: Mimi loopt naar de grens van de wereld. Als ze onderweg een nest tegenkomt waar nog geen ei in ligt, legt ze er een ei in. a) Open de worldemptyneststoprow wereld en plaats een ei in een aantal nestjes. Tip: Theorie 3.5 omschrijft hoe je elke keer een bepaalde wereld kan laden. b) Omschrijf de begin- en eindsituaties. c) Teken een stroomdiagram. d) Schrijf en test de bijbehorende code (met commentaar). Zorg er ook voor dat jouw code netjes uitgelijnd is (zie Theorie 3.3). Afhankelijk van de door jouw gekozen oplossing heb je nu nesting (van if..else..) of combinaties van logische operatoren gebruikt om een complexere voorwaarde te omschrijven. Opgave 3.5: Door een tunnel lopen Jouw taak is om Mimi te leren om door een tunnel (van hekjes) te lopen (zie figuur 8), en te stoppen als ze uit de tunnel komt (zie figuur 9). Figuur 8: Beginsituatie Figuur 9: Eindsituatie We delen dit probleem eerst op in deelproblemen die ieder afzonderlijk aangepakt kunnen worden: Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 10

Figuur 10: Het probleem opdelen in deelproblemen die ieder afzonderlijk aangepakt worden a) Schrijf en test een submethode die controleert of er links van Mimi een hek staat. b) Schrijf en test een vergelijkbare submethode die controleert of er rechts van Mimi een hek staat. Je mag natuurlijk gebruik maken van jouw methodes boolean fenceonleft( ) en boolean fenceonright ( ). c) Maak gebruik van deze submethodes om een methode void walkthroughtunnel( ) te schrijven. Je kunt de worldtunnel wereld gebruiken om te testen (Theorie 3.5 beschrijft hoe je deze kan openen). d) Test jouw void walkthroughtunnel( ) methode. Je hebt nu zelf gebruik gemaakt van abstractie om een groter probleem op te splitsen in kleinere delen. Met het verdeel-en-heers principe heb je de kleinere delen ontworpen, geïmplementeerd en getest (methodes fenceonright ( ) en fenceonleft ( )). Daarna heb je deze gebruikt in walkthroughtunnel( ) en het geheel getest. Wie weet, misschien wil je straks in een volgende opgave gebruik maken van één van jouw methodes (bijvoorbeeld fenceonright ( )). Omdat je er nu een aparte methode van gemaakt hebt is hergebruik een stuk makkelijker. Dit noemen we ook wel modularisatie. Lees eerst Theorie 3.7: Tekst gebruiken. Opgave 3.6: Naar het nest lopen en hekken ontwijken Mimi zoekt haar nest. Als ze onderweg een hek tegenkomt, moet ze daar overheen klimmen. Als ze haar nest heeft gevonden moet ze er een ei in leggen en stoppen. Heeft ze het einde van de wereld bereikt voordat ze haar nest gevonden heeft, dan moet ze stoppen en in een pop-up venster een geschikte foutmelding geven. Tips: Schets eerst een stroomdiagram op hoog niveau. Het kan handig zijn om terug te kijken naar taak 2.9 waar je de code hebt geschreven voor walktoworldedgeclimbingoverfences( ). Laad de worldfencesandnest wereld. Om een pop-up foutmelding te tonen maak je gebruik van: showerror( String message) Opgave 3.7: Om een omheining lopen In deze opdracht laat je Mimi om een omheining heen lopen. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 11

a) Open de worldfencedarea wereld. b) Bepaal de begin- en eindsituaties. Bedenk een geschikt algoritme. Tip: Om te voorkomen dat Mimi oneindig veel rondjes om het hek heen wandelt gaan we ervan uit dat in het laatste vakje van de route om de omheining een ei ligt. Als ze gaat lopen en dat ei tegenkomt, dan weet ze dat ze klaar is. c) Schrijf de bijbehorende methode void walkaroundfencedarea( ) waarmee Mimi om de omheining heen loopt. Schrijf daar ook (JavaDoc) commentaar bij. d) Compileer en test het programma. Controleer ook of jouw programma werkt bij een grotere omheining. e) Voor welke beginsituaties werkt jouw programma? Indien nodig, pas de beschrijving van jouw beginsituatie aan. f) Test ook of jouw methode werkt met een andere wereld, zoals: worldotherfencedarea. Pas het algoritme (en dus ook het stroomdiagram en code) dusdanig aan dat het ook hiervoor werkt. Figuur 11: Een andere omheining Je hebt nu een generieke methode geschreven waarmee Mimi om een willekeurige omheining kan lopen. Je hebt daarbij mogelijk gebruik gemaakt van modularisatie door (bestaande en geteste) methodes te opnieuw te gebruiken. Opgave 3.8: Spoor van eieren volgen tot het nest Er ligt een spoor van eieren naar het nest van Mimi. Kan jij Mimi helpen om haar nest te vinden? (zie wereld: worldeggtrailtonest ). Figuur 12: Taak: volg het spoor van eieren tot aan het nest Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 12

We delen het probleem op in deelproblemen die stapsgewijs los van elkaar opgelost kunnen worden. a) Teken een stroomdiagram op hoog niveau dat aangeeft welke submethodes je moet ontwerpen en schrijven. b) Voor elke submethode: Kies een geschikte naam (en returntype); Bepaal de begin- en eindsituaties. Schrijf en test de submethode. c) Gebruik makend van deze submethodes, schrijf en test jouw oplossing als geheel. d) Controleer of jouw programma ook werkt voor een ander pad van eieren. Test deze ook met world followeggtrailbehinduntilnest. Wellicht kom je tot de ontdekking dat je nog wat moet verbeteren. e) Reflecteer over jouw aanpak. Wat ging goed? Wat kun je volgende keer beter anders doen? Opgave 3.9: Eenvoudige doolhof Help jij Dodo weer haar nest te vinden? Hiervoor moet je haar helpen om haar weg door de doolhof te vinden. Jouw oplossing moet natuurlijk weer generiek zijn: Dodo moet haar weg door een willekeurige doolhof vinden, niet alleen voor de doolhof uit het plaatje. Je mag van het volgende uitgaan: De wereld is omgeven door hekken. Er is precies één nest. Er bestaat een route naar het nest. Het nest ligt direct naast een hek. Aan het begin is er maar één richting waarin Dodo kan lopen. Het doolhof bevat geen doodlopende paden. Verder zijn er geen eilanden van hekjes: ieder hekje is verbonden met de omheining. Schrijf een methode waarmee Dodo het nest vindt. a) Bedenk een geschikt algoritme en teken een stroomdiagram op hoog niveau. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 13

b) Ontwikkel, implementeer en test de submethodes voor jouw algoritme één voor één. c) Test jouw programma voor de volgende doolhoven: world doolhoflevel1a. world doolhoflevel1b. world doolhoflevel1c. d) Beoordeel jouw programma. Welke verbeteringen kun je bedenken? Je hoeft ze niet per se door te voeren, je hoeft ze alleen op te sommen. Opgave 3.10: Lastigere doolhof Help jij Dodo haar nest te vinden door een wat ingewikkeldere doolhof? Geef Mimi ook een complimentje (maak gebruik van een pop-up venster) als ze haar nest gevonden heeft. Jouw oplossing moet natuurlijk weer generiek zijn. Je mag van het volgende uitgaan: Er is één nest. Er bestaat een route naar het nest. De wereld is omgeven door een hekken. Het nest ligt direct naast een hek. Er zijn geen eilanden van hekjes: ieder hekje is verbonden met de omheining. Schrijf een methode waarmee Dodo het nest vindt. a) Bedenk een geschikt algoritme en teken een stroomdiagram op hoog niveau. b) Ontwikkel, implementeer en test de submethodes voor jouw algoritme één voor één. c) Test jouw programma als geheel voor de volgende doolhoven: worldmazelevel2a. worldmazelevel2b. worldmazelevel2c. d) Maak zelf ook een nieuwe doolhof. Wissel jouw doolhof uit met een medeleerling. Test jouw programma daarmee. Vergelijk elkaars oplossingen. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 14

Opgave 3.11: Dodo maakt wilde sprongen Nu is het tijd voor een meer uitdagende algoritmisch denken puzzel. Stel we hebben een methode jumptoend( ). Hiermee kan Mimi herhaaldelijk stappen zetten totdat ze niet meer verder kan (er staat een hek in de weg of ze heeft de grens van de wereld bereikt): public void jumptoend( ) { while (! borderahead( ) &&! fenceahead( ) ){ step( ); } } De jumptoend( ) methode wordt aangeroepen in gowild( ). Figuur 13: Stroomdiagram voor de methode gowild( ) Het scenario wordt uitgevoerd door gowild aan te roepen. Hieronder staan drie verschillende beginsituaties: Figuur 14: A Figuur 15: B Figuur 16: C a) Stopt Mimi als je uitgaat van beginsituatie A? Zo ja, hoe vaak wordt de jumptoend( ) methode aangeroepen? Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 15

b) Stopt Mimi als je uitgaat van beginsituatie B? Zo ja, hoe vaak wordt de jumptoend( ) methode aangeroepen? c) Controleer jouw antwoorden door een printopdracht toe te voegen aan de code. (Theorie 1.14 en Theorie 3.7 beschrijven hoe je tekst naar de console kunt afdrukken). d) We gaan uit van beginsituatie C. Door in de wereld hekken op bepaalde plekken neer te zetten kun je ervoor zorgen dat Mimi het ei vindt. Kun je hekken in figuur C neerzetten zodat Mimi haar ei vindt als je de gowild( ) methode aanroept? Er zijn twee eisen: Je mag hooguit vijf hekken gebruiken. Je mag geen hek naast een wereldgrens plaatsen. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 16

Reflectie In deze opdracht heb je geoefend met het ontwerpen van code als losse componenten. Daardoor wordt het makkelijk om oplossingen te bedenken, schrijven, testen en opnieuw te gebruiken. Als je ergens echt goed in wilt worden, dan is een van de meest belangrijke stappen om even terug te blikken op wat je deed en hoe dat ging: Resultaat Ik weet dat mijn oplossing werkt omdat... Ik ben trots op mijn oplossing omdat... Ik kan mijn oplossing verbeteren door... Aanpak Mijn aanpak was goed omdat... Wat ik volgende keer beter anders kan doen is... Geef met een smiley aan hoe het ging. Ik kan het Het is me een beetje gelukt maar ik begreep het niet helemaal Ik snapte er helemaal niks van Ik kan een algoritme beschrijven in een hoog-niveau stroomdiagram. Ik kan submethodes in een algoritme herkennen. Ik kan submethodes afzonderlijk ontwerpen, schrijven en testen. Ik kan conditionele expressies samenstellen door logische operatoren te combineren. Ik kan generieke oplossingen ontwikkelen. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 17

Opslaan en inleveren Sla je werk op. Je hebt het nodig voor de volgende opdrachten. Opslaan Selecteer Scenario in het Greenfoot menu, en dan Save. Alle bestanden die bij het scenario horen zitten nu in één map. Inleveren Lever het volgende in: Naam: van jou (en je partner); Jouw code: Het MyDodo.jav java bestand; Stroomdiagrammen: Als je ze op papier hebt gemaakt: plak (foto s van) jouw stroomdiagrammen in een (Word) bestand. Als je software gebruikt hebt: sla het bestand op als.pdf of.jpg. Algoritmisch denken en gestructureerd programmeren (in Greenfoot) 18