In deze module leer je de basisconcepten van programmeren, zoals algoritmes, variabelen, loops, condities, functies. Je gebruikt geen programmeertaal, maar het programma Flowgorithm. Met dit (gratis te downloaden) programma (let op: dit is alleen beschikbaar voor Windows! Werk je op Mac dan kun je een executable downloaden er hiermee werken onder Wine) maak je flowcharts: schema´s waarmee je het verloop van een programma inzichtelijk maakt. Het mooie van Flowgorithm is, dat je de flowcharts kunt runnen, oftewel uitvoeren, en zo kun je zien of je het goed hebt aangepakt en het betreffende concept goed hebt toegepast. Omdat je geen programmeertaal leert, hoef je geen tijd te besteden aan het leren van de syntax van een specifieke taal. Die tijd kun je namelijk beter besteden aan het doorgronden van de basisconcepten van programmeren. Kennis van deze basisconcepten zijn namelijk voor iedere programmeertaal noodzakelijk.
In elk hoofdstuk wordt een volgend basisconcept behandeld. De stof wordt verduidelijkt met een aantal instructievideo´s en er zijn veel oefeningen in opklimmende moeilijkheidsgraad toegevoegd. Ook zijn van alle opdrachten uitwerkingen beschikbaar. In een aantal hoofdstukken wordt gewezen op fouten, die veel voorkomen.
Dit lesmateriaal is gemaakt in voorjaar 2020 en leerlingen uit 5VWO hebben het lesmateriaal kritisch bekeken, becommentarieerd en zelf oefeningen en video´s toegevoegd. Het lesmateriaal is zo veel duidelijker en uitgebreider geworden.
Maar het kan altijd beter of uitgebreider. Mocht je een goed idee hebben om toe te voegen of een fout tegenkomen, laat het me weten. Of als je wat aan de module gehad hebt, is het ook leuk om te horen!
Wat in ieder geval nog toegevoegd zou moeten worden is een hoofdstuk over recursie, met de Torens van Hanoi.
Veel plezier met dit materiaal!
Marjolein van Hooff
m.van.hooff@vlietlandcollege.nl
Algoritmes
Een algoritme is een stappenplan, een recept, een routine, een aantal stappen, die gezet worden om een bepaald doel te bereiken.
Een algoritme kan van alles zijn. Een recept om appeltaart te bakken is een algoritme. Een weg, die je moet fietsen om naar een eindpunt te gaan, is een stappenplan en dus een algoritme. Maar zomaar genieten van de zon is geen algoritme. Of zomaar wat rondfietsen zonder doel, is geen algoritme.
Maar een handleiding om lego in elkaar te zetten is wel een algoritme.
Een computerprogramma is niets anders dan een algoritme: Een stappenplan om een doel te bereiken en dat doel wordt bereikt door vanaf een beginpunt een eindig aantal instructies uit te voeren.
Als een computerprogramma gerund wordt, wordt er dus een algoritme uitgevoerd.
Programmeren: Een algoritme omzetten naar een computerprogramma
Als je gaat programmeren, maak je een programma wat van begin- naar eindpunt gaat. Je zet een algoritme om naar een programma.
Een computerprogramma voert een algoritme uit. In een eindig aantal stappen wordt vanaf een beginpunt het eindpunt bereikt.
Dit kun je visualiseren: Je maakt dan een schema welke stappen in het programma doorlopen worden.
Zo´n schema kan er zo uitzien:
Flowchart
Deze eerste afbeelding is een voorbeeld van een programma in Flowgorithm.
Het is een flowchart. Wat dat is leer je hierna.
Flowcharts
Flowcharts - Uitleg
Een computerprogramma is een opeenvolging van instructies om een computer een bepaalde taak uit te laten voeren. Om deze opeenvolging inzichtelijk te maken kan gebruik gemaakt worden van een flowchart, oftewel stroomdiagram. Dit is een schematische voorstelling van een proces. Door de flowchart wordt duidelijk welke invoer er gebruikt of vereist wordt, welke uitvoer er gegenereerd wordt en welke stappen in welke volgorde genomen worden. Met een flowchart kan de werking van een programma makkelijker getest worden en wordt de doorloop van een programma inzichtelijk gemaakt.
Flowcharts in Flowgorithm
Onderdelen van een flowchart in Flowgorithm:
Startpunt: Main
Eindpunt: End
Pijlen om van het ene onderdeel naar het andere onderdeel of terug te gaan
Invoer: Input
Uitvoer: Output
Beslissingsmogelijkheden, oftewel keuzemomenten
Herhalingsmogelijkheden
Eerste flowchart in Flowgorithm
De onderdelen van flowcharts in 3 puzzels
Flowgorithm
Flowgorithm is gratis en moet geïnstalleerd worden. Hier staat hoe dat gaat.
Systeemvereisten
Flowgorithm draait op Windows, nog niet op Macintosh of Linux. Het is ongeveer 6MB groot
In Flowgorithm maak je bestanden, die opgeslagen worden met de extensie .fprg: Dit betekent FlogorithmPRoGram.
De extensie van een bestand zijn de letters van een bestandsnaam na de punt. Aan de extensie kan jouw besturingssysteem zien met welk programma een bestand geopend moet worden. Bv. de extensie .docx betekent dat het bestand met Word geopend moet worden. De extensie .fprg betekent dat het met Flowgorithm geopend moet worden.
Volg de video en maak " Hello World" in Flowgorithm
"Hello World" - Simpel
"Hello World" - iets ingewikkelder
Voordelen van Flowgorithm
Met Flowgorithm maak je heel makkelijk flowcharts
De flowcharts kunnen gerund worden
Via het variable window en de stapsgewijze uitvoering kunnen de waarden van variabelen en ook array’s gevolgd worden. Dit geeft veel duidelijkheid en helpt bij het opsporen van fouten
Flowgorithm is robuust. Het dwingt goede programmeergewoonten af, bv. het declareren van een variabele is verplicht voordat deze gebruikt kan worden
Flowgorithm is programmeertaalonafhankelijk. Alle aandacht kan daarom gericht worden op het begrijpen en gebruiken van programmeerconcepten, zonder dat er tijd besteed moet worden aan het leren van een programmeertaal.
Een plaatje zegt meer dan 1000 woorden: De doorloop van het programma wordt inzichtelijk
Foutopsporing is minder tijdrovend
De programmeerconcepten kunnen hier goed mee geleerd worden
Er hoeft geen tijd besteed te worden aan foutopsporing van syntaxfouten. Komma´s, haakjes die verkeerd staan. Kleine foutjes kosten soms uren werk en dat kan heel demotiverend zijn
Het is om te zetten naar allerlei programmeertalen, bv. C++, Java, PHP, Python
Variabelen
Waardes in een programma opslaan met variabelen
In een programma werk je vaak met waardes. Zoals de som van 2 getallen, de lengte van een tafel, de grootte van een doosje, de straal van een cirkel. Ook bv. pi heeft een waarde, nl 3,14……
Die waardes wil je gedurende het uitvoeren van het programma niet kwijtraken, je hebt ze misschien vaker nodig. Dat kan gelukkig, de waardes kunnen namelijk ergens opgeslagen worden. Dit opslaan gebeurt in het werkgeheugen van de computer. Het werkgeheugen heeft enorm veel opslagplekken en op elke plek kan precies 1 waarde opgeslagen worden. Waar die waarde precies opgeslagen wordt, dat bepaalt het programma. Vergelijk het met een magazijn. Jij weet niet waar jouw pakje ligt, maar de magazijnmeester weet het precies.
Sleep de woorden rechts naar de tekst links en bekijk of je het snapt:
Terug naar de magazijnmeester
Om jouw pakje te kunnen vinden, heeft de magazijnmeester wel een identificatie nodig. Op jouw pakje staat een barcode of andere identificatie, die aangeeft waar jouw pakje zich bevindt. Wat er verder in het pakje zit, weet de magazijnmeester niet en dat is ook niet belangrijk voor hem.
Variabele
In programmeren is deze identificatie de variabele, namelijk een plek in het geheugen.
Variabele declareren
De variabele in programmeren is dus eigenlijk een geheugenplek. Om die plek te vinden moet de variabele een naam krijgen.
De programmeur geeft de naam. Met het geven van een naam wordt aangegeven dat er
een geheugenplek gereserveerd moet worden. Dit reserveren wordt declareren genoemd.
De variabele declareren = De programmeur vertelt het programma dat er een plek gereserveerd
moet worden, met een bepaalde naam, om daar een waarde op te kunnen slaan.
Klik in onderstaande tekst de juiste woorden aan en controleer je antwoorden:
Een waarde aan een variabele toekennen
Hieronder een schematische voorstelling van een variabele: Een geheugenplek met een bepaalde waarde
De variabele lengte heeft de waarde 42. Bekijk dit in de video hieronder.
Een variabele declareren en een waarde geven en daarna het programma stapsgewijs runnen
Voorbeeld in Flowgorithm
Maak onderstaand programma na in Flowgorithm en run het
Variabele lengte declareren en een waarde aan toekennen
Variabele een andere waarde geven
Als nu de waarde 42 niet meer nodig is, maar een andere waarde opgeslagen moet worden, dan kan dezelfde geheugenplek voor een andere waarde gebruikt worden. De oude waarde verdwijnt dan: De oude waarde wordt overschreven
De oude waarde 42 wordt overschreven door de nieuwe waarde 147, 42 verdwijnt
Toekenning: Het =-teken
Als op een bepaalde geheugenplek een waarde wordt opgeslagen, dan zeggen we: Aan de variabele wordt een waarde toegekend. In programmeren wordt hiervoor het =-teken gebruikt. Het =-teken wordt in programmeren ook gebruikt op de manier, die we in wiskunde zien: 3 + 5 = 8
Belangrijk: De toekenning gebeurt van rechts naar links: De variabele, die links van het =-teken staat, krijgt de waarde die rechts van het =-teken staat. Als er staat lengte = 42, dan lees je: de variabele lengte krijgt de waarde 42 toegekend.
Oefenen in Flowgorithm - Variabelen 1
Oefening 1
In onderstaande oefeningen staan programmeerstatements tussen accolades: {statements} Er wordt gekeken welke waarden de variabelen lengte en hoogte krijgen als deze statements uitgevoerd worden. Statements worden uitgevoerd van boven naar beneden en van links naar rechts.
Bekijk de statements: Tussen de haakjes staat wat er gebeurt. Daarna wordt het resultaat van de statements gegeven
Kijk of je de statements kunt volgen en het resultaat snapt
Maak daarna deze programma´s zelf of open het bestand lengte42.fprg en gebruik dat als startpunt voor onderstaand oefeningen.
Volg eventueel de gegeven stappenplannen
Laat de waarden van de variabelen naar het console schrijven. Zo controleer je of het goed gaat
Open bij het runnen ook het Variable Watch Window en het Console en ga er stapsgewijs doorheen
In de video worden deze oefeningen 2-4 voorgedaan. Oefening 1 kun je hier terugkijken.
Oefening 1
{lengte = 42}: Resultaat: de variabele lengte krijgt de waarde 42
Oefening 2
{hoogte = 215; lengte = hoogte}: Resultaat: de variabele hoogte krijgt de waarde 215, en daarna krijgt de variabele lengte de waarde van variabele hoogte, dus 215. Na deze 2 statements hebben de variabelen lengte en hoogte dan dezelfde waarde, namelijk 215
Stappenplan in Flowgorithm:
Maak een nieuw programma in Flowgorithm
Declareer 2 variabelen: lengte en hoogte
Geef hoogte de waarde 215, geef lengte de waarde van hoogte
Laat de waarden van lengte en hoogte naar het scherm schrijven
{lengte = 24; hoogte = 215; lengte = hoogte} Resultaat: De variabele lengte krijgt eerst de waarde 24. De variabele hoogte krijgt de waarde 215. Dan krijgt de variabele lengte de waarde van hoogte, dus 215. Na deze 3 statements hebben de variabelen lengte en hoogte dezelfde waarde, namelijk 215
Stappenplan in Flowgorithm
Maak een nieuw programma in Flowgorithm
Declareer 2 variabelen: lengte en hoogte
Geef lengte de waarde 24, geef hoogte de waarde 215, geef lengte de waarde van hoogte
Laat de waarden van lengte en hoogte naar het scherm schrijven
{lengte = 24; hoogte = 215; hoogte = lengte} Resultaat: De variabele lengte krijgt eerst de waarde 24. De variabele hoogte krijgt de waarde 215. Dan krijgt de variabele hoogte de waarde van variabele lengte, dus 24. Na deze 3 statements hebben de variabelen lengte en hoogte dezelfde waarde, namelijk 24
Stappenplan in Flowgorithm
Maak een nieuw programma in Flowgorithm
Declareer 2 variabelen: lengte en hoogte
Geef lengte de waarde 24, geef hoogte de waarde 215, geef hoogte de waarde van lengte
Laat de waarden van lengte en hoogte naar het scherm schrijven
Een variabele kan ook het resultaat van een berekening toegekend krijgen. Tijdens het uitvoeren van het programma wordt dan eerst de berekening uitgevoerd en daarna wordt het resultaat aan de variabele toegekend
Maak op dezelfde manier als de oefeningen van de vorige pagina de volgende programma´s in Flowgorithm
{hoogte = 678; lengte = hoogte/2} Resultaat: de variabele hoogte krijgt de waarde 678, de variabele lengte krijgt de waarde 339. Eerst wordt hiervoor hoogte/2 uitgerekend, dat geeft 339. Daarna wordt deze waarde aan de variabele lengte toegekend
{lengte = 45 * 32} Resultaat: Eerst wordt uitgerekend 45 * 32, 1440. Daarna wordt deze waarde aan de variabele lengte toegekend. Op de geheugenplek wordt dan 1440 opgeslagen. Níet 45*32!
Maak bovenstaande programma´s in Flowgorithm of bekijke ze in de bestanden:
Als je een naam aan een variabele geeft, gelden er regels. In Flowgorithm gelden de volgende regels:
De naam moet beginnen met een letter
Na de 1e letter kunnen er meer letters of cijfers komen
Er mogen geen spaties in de naam voorkomen
Het lage streepje, de underscore, _, mag in Flowgorithm niet gebruikt worden in namen
Hoofd- of kleine letters mogen allebei
In Flowgorithm zijn bepaalde woorden gereserveerd, zoals pi, and, or. Die mogen niet gebruikt worden als namen van variabelen. Voor een lijst gereserveerde woorden, zie hier:
Zelf maken in Flowgorithm
Hoe oud ben je of word je in dit huidige jaar?
Maak een nieuw programma aan in Flowgorithm. Noem het oefenen_leeftijd.fprg. Declareer 2 integer variabelen, huidigjaar en geboortejaar. Geef de variabele huidigjaar de waarde van dit jaar en laat de gebruiker zijn geboortejaar invoeren. Welke berekening moet gemaakt worden om te bepalen hoe oud de gebruiker wordt in het huidige jaar? Heb je een 3e variabele nodig?
Voeg bij zoveel pijlen commentaar toe als je zelf nodig vindt, om uitleg bij het programma te geven, zodat een ander ook weet wat dit programma doet.
Open zowel het console als het Variable Watch window
Run het programma stapsgewijs en volg de waarden van de variabelen in het Variable Watch window
Hoeveel geld kun je deze week nog besteden?
Maak een nieuw programma aan in Flowgorithm. Noem het oefenen_uitgaven.fprg. Declareer 2 integer variabelen, bedrag1 en bedrag2. Vraag met een Output de gebruiker om het bedrag in te geven wat aan het begin van de week in zijn portemonnee zat. Vraag daarna het bedrag in te geven wat nu in zijn portemonnee zit. Trek in de volgende output de bedragen van elkaar af en laat aan de gebruiker zien.
Zie oefenen_uitgaven.fprg voor een voorbeeld
Voeg bij 3 pijlen commentaar toe, zodat je weet wat dit programma doet.
Open zowel het console als het Variable Watch window
Run het programma stapsgewijs en volg de waarden van de variabelen in het Variable Watch window
Verdien je genoeg voor je uitgaven?
Maak een nieuw programma aan in Flowgorithm. Noem het oefenen_salaris.fprg. Declareer 2 integer variabelen, salaris en uitgaven. Laat de gebruiker zijn salaris ingeven in hele euro’s en daarna zijn uitgaven, ook in hele euro’s. Geef in de Output aan wat het verschil is. Als de uitgaven groter zijn dan het salaris, verschil is dan negatief, geef dan de tip om beter betaald werk te zoeken. (Je leert hoe je dit test in het hoofdstuk over Conditie. Voor nu geef je alleen Output, bv: “Als het verschil negatief is, zoek dan beter werk!”))
Zie oefenen_salaris.fprg voor een voorbeeld
Voeg bij zoveel pijlen commentaar toe, als je nodig vindt, om uitleg bij het programma te geven, zodat een ander ook weet wat dit programma doet.
Open zowel het console als het Variable Watch window
Run het programma stapsgewijs en volg de waarden van de variabelen in het Variable Watch window
Wat is je snelheid in meters per seconde?
Toevoeging van Yomna en Gaby
Maak een nieuw programma in Flowgorithm en noem het snelheid_berekenen.
Declareer 2 integer variabelen, de afgelegde afstand en de benodigde tijd.
Vraag de gebruiker om de afgelegde afstand in meters en de daarvoor benodigde tijd
Welke berekening moet er gedaan worden?
Voeg bij zoveel mogelijk pijlen commentaar toe. Dit laat mensen die niet veel van programmeren weten wat je allemaal aan het doen was, en wat de bedoeling is van je verhaal.
De uitwerking staat in: snelheid_berekenen.fprg
Open de console en het variable watch window
Run het programma stapsgewijs en volg de waarden van de variabelen in het variabele watch window.
Test je kennis over variabelen
Kijk hier (Quizlet) of hier (Socrative) of je voldoende weet van variabelen
Datatypes
Mogelijke datatypes
In het vorige hoofdstuk heb je kennis gemaakt met variabelen. De variabelen, die gebruikt werden, bevatten gehele getallen. Een geheel getal bij het programmeren wordt een integer genoemd.
Maar een variabele kan ook andere types gegevens bevatten zoals een stukje tekst of een reëel getal. Die kun je niet in een integer opslaan. Daar heb je andere types voor nodig. Het type gegeven, dat wordt opgeslagen, wordt datatype genoemd.
Op het moment dat je de variabele maakt, dus declareert, moet je ook bepalen wat voor soort gegeven erin opgeslagen kan worden, dus van welk datatype de variabele moet zijn.
In onderstaande tabel zie je de mogelijke datatypen, die een variabele kan krijgen en welke waarden hij dan kan bevatten:
Mogelijke datatypes in Flowgorithm
Datatype
Bevat de volgende soort gegevens
Integer
Bevat een geheel getal: positief, negatief of nul
Real
Bevat een reëel getal. Getallen hebben een punt, geen komma.
String
Bevat een stukje tekst, karakters. Hier kan niet mee gerekend worden. Een stukje tekst moet tussen aanhalingstekens geschreven worden.
Boolean
Bevat 1 van 2 mogelijke waarden: True of False
Als je meer programma´s maakt, zul je merken dat je hier vanzelf vertrouwd mee raakt.
Kleine oefening met datatypes
De nummers 1,2,3 en 6 kun je bekijken in deze video. Hier zie je ook wat voor foutmelding je krijgt als je het gereserveerde woord pi probeert te gebruiken
Maken in Flowgorithm
Kijk of je het volgende programma kunt maken in Flowgorithm. Een Real kan ingevoerd worden met een punt of een komma: Voer als graden in: 23,6 of 23.6. Flowgorithm zet de komma om naar een punt en geeft in dit geval geen foutmelding
Boolean
Een Boolean is een bijzondere variabele. Hij kan maar 2 waarden bevatten: true of false. Een Boolean wordt vaak gebruikt om een test uit te voeren.
Hieronder een voorbeeld met een Boolean. Lees deze code en ook het commentaar erbij.
Dit voorbeeld is nog niet veel. De boolean krijgt altijd de waarde True. Hieronder hetzelfde programma, maar dan geeft de gebruiker aan of het regent of niet. Open het bestand DatatypeBoolean.fprg en run het.
Operaties met booleans
Bekijk de volgende figuur met 3 tabellen. A en B zijn variabelen van het type boolean. Hier worden de operaties AND, OR en NOT op uitgevoerd. Het resultaat van deze operaties staat steeds in de 3e kolom.
Mogelijke operaties met 2 booleans
Voorbeeld boolean in Flowgorithm: A AND B
Onderstaand een programma met 2 booleans: A en B. De gebruiker wordt gevraagd een geheel getal te geven. Er worden een paar tests uitgevoerd
Boolean A: wordt True als dit getal even is en False als het getal oneven is. Dit wordt getest met de functie mod. Deze functie geeft de restwaarde. Als het getal even is, is de restwaarde nul.
Boolean B wordt True als dit getal kleiner dan 100 is en False als het getal groter dan 100 is.
In dit programma wordt alleen getest of A en B beide True zijn.
Je kunt het vinden en runnen met: DatatypeBooleanAANDB.fprg
Volgorde van booleans
Net als met vermenigvuldigen, delen en optellen/aftrekken is er ook hier een volgorde:
Allereerst wordt NOT uitgevoerd, dan AND en dan OR.
Bestudeer eerst het uitgewerkte voorbeeld en bekijk dan wat er uit de volgende statements komt: True of False. Tip: Zet haakjes om de statements die als eerste uitgevoerd worden en kijk wat je overhoudt.
Een uitgewerkt voorbeeld:
Vraag: Los het volgende statement op: False or not True and True
Antwoord:
Stap 1: Haakjes zetten. Eerst bij NOT, dan bij AND, dan bij OR.
Dit geeft: False or ((not True) and True)
Stap 2: Wat binnen de haakjes staat oplossen, in de volgorde NOT, AND, OR
Dit geeft: False or (False and True) = False or False
Stap 3: Het hele statement oplossen
Dit geeft: False or False = False
Dus in totaal: False or not True and True = False
Logische puzzels
Raymond Smullyan was een bijzonder mens. Hij was magiër, mysticus, wiskundige, Taoïst en pianist. Hij heeft de wereld voorzien van logische puzzels, zoals de reeks “The lady or the tiger”
Hieronder staan 2 puzzels uit deze reeks, kijk of je ze op kunt lossen met logisch redeneren:
Toepassen booleans in Flowgorithm
Beredeneer de uitvoer
Toepassen waarden variabelen: Swap
Als je de waarden van 2 variabelen wilt omwisselen, moet je ervoor oppassen 1 van de waarden niet kwijt te raken. Hieronder een programma met 2 variabelen: waarde1 en waarde2. Waarde1 krijgt de waarde 75, waarde2 de waarde 150. Deze waarden moeten omgewisseld worden.
Wat gaat hier mis? Probeer, voordat je verder leest, te beredeneren wat de uitvoer is, anders run je het, het staat in swap.fprg
Zelf maken: Swap
Maak een programma wat de waarden van 2 variabelen omwisselt, dus swapt. Gebruik hiervoor een extra variabele, noem deze extra.
Het begin van dit programma staat hieronder. Voeg de ontbrekende code toe en laat de waarden naar het scherm schrijven
Maak een programma dat de oppervlakte van een cirkel uitrekent en in de uitvoer toont, waarbij je de straal in laat voeren, als reëel getal in meters
Programma 4
Maak een programma dat jouw BMI uitrekent m.b.v. gewicht en lengte. Geslacht doet er even niet toe. BMI is gewicht in kilo´s gedeeld door lengte in meters in het kwadraat. Geef aan dat het aantal meters ingevoerd moet worden met een punt en geen komma.
Programma 5
Maak een programma dat jou de volgende dingen kan vertellen: (toevoeging van Renzo)
Aan de hand van je geboortejaar hoe oud je wordt in een jaar dat je zelf in kunt vullen.
Of je in het ingevulde jaar geboren bent, een kind of een volwassene bent of een volwassene wordt (Leg de grens kind/volwassene op 18 jaar).
Als je een jaar invult lager dan je geboortejaar je vertelt dat je toen nog niet geboren was.
Programma 6 (Toevoeging van David)
Eric geeft een feestje hij wil een digitale lijst maken waarin staat of zijn gasten mogen drinken of niet. Maak een programma waarbij je alleen de leeftijd hoeft in te vullen.
Er zijn altijd een paar grapjassen die rare leeftijden invullen. Afgelopen week zijn er 2 jongens geweest die 189 en 1174 als leeftijd hadden ingevuld. Maak een programma wat ervoor zorgt dat alleen geloofwaardige leeftijden kunnen worden ingevuld.
Kijk of je deze twee programma’s samen kan voegen om het voor Eric zo makkelijk mogelijk te houden.
Een variabele is een plek in het geheugen, die precies 1 waarde kan bevatten. Dat is niet altijd even handig. Het is handig als je een verzameling waarden, die bij elkaar horen, samen kunt stoppen. Zo’n verzameling bestaat en heet een array.
Een array = een gesorteerde rij variabelen.
Gesorteerd betekent hier NIET de waarden van de variabelen, maar de plek in de rij.
Je kunt een array zien als een rij deuren. De deuren zijn genummerd, zodat je weet waar je aan moet bellen. Wat er achter de deur zit, dus welke waarde op die plek opgeslagen is, weet je niet.
Achter deze deuren zit een leuke persoonlijkheidstest: Welke deur kies jij en wat zegt dat over jou en klopt het wat daar geschreven staat? Als je dat leuk vindt, klik dan hier en doe de test. Feel free to share!
Array´s - Theorie (vervolg)
Stel je voor je hebt de volgende 7 getallen: 3, 8, 1, 0, 5, -2, 32
Die kunnen we stoppen in 7 variabelen:
getal1 = 3
getal2 = 8
getal3 = 1
getal4 = 0
getal5 = 5
getal6 = -2
getal7 = 32
Er worden dan 7 plekken gereserveerd om deze waarden op te slaan.
Veel handiger is het als we ze kunnen stoppen achter de genummerde deuren. Dus in een rij variabelen, oftewel een array met 7 plekken.
Dat ziet er zo uit: rij[7]. Veel handiger en overzichtelijker!
rij[7], oftewel een array is dan een verzameling van 7 plekken voor 7 variabelen, die bij elkaar horen. De variabelen moeten van hetzelfde datatype zijn. Hier zijn het gehele getallen, integers. Maar het kunnen ook strings zijn of reële getallen.
Let op: computers beginnen te tellen bij 0. Dus met 7 plekken wordt geteld van 0 t/m6, als het ware vanaf deur 0.
Je kunt dan bv doen: Output rij[4] en de uitvoer is 5, want de waarde 5 staat in rij[4]
Samenvattend:
Array: Een gesorteerde rij variabelen
De plekken van de array zijn gesorteerd
De plekken hebben nummers
De nummers van de plekken in de array zijn oplopend
Het nummer van een plek wordt index genoemd
De eerste plek in de array is plek 0 (nul)
De opgeslagen waarden van de variabelen zijn niet automatisch gesorteerd
De waarden van de variabelen moeten van hetzelfde datatype zijn
Test je kennis over het array
Test je kennis over het array - 2
Array - Eerst droog oefenen, dan in Flowgorithm
Maak bovenstaande oefeningen in Flowgorithm en laat de waarden van de array naar de console schrijven.
Gebruik eventueel als startpunt het bestand array_1.fprg voor
Kom je er niet uit? De oefeningen staan in: array_1_1.fprg t/m array_1_5.fprg
Noot: Dit is niet handig geprogrammeerd, maar op dit moment is de FOR-loop nog niet behandeld en wordt daarom nu nog niet gebruikt
Array: Getrouwd met de FOR-loop
In programmeren is een loop, oftewel een lus, een constructie waarbinnen dezelfde code een aantal malen herhaald wordt. Dat is heel handig, want als je dezelfde code vaak uit moet schrijven, wordt je programma onleesbaar. Loops zijn belangrijke onderdelen om je programma leesbaar, efficiënt en overzichtelijk te houden.
Met bovenstaand voorbeeld heb je kennisgemaakt met het begrip array. Maar dit programma is verre van overzichtelijk. Dezelfde code, bv. output rij[x], wordt steeds herhaald.
Om handig met een array om te gaan gebruik je een loop. Er zijn 3 soorten loops en voor een array gebruiken we een FOR-loop.
Een FOR-loop gebruik je als je van tevoren precies weet hoe vaak bepaalde code herhaald moet worden. Omdat je precies weet hoeveel plekken een array heeft, is een FOR-loop heel handig om te gebruiken met een array. En dat gaan we in het volgende hoofdstuk bekijken.
FOR-loop
In programmeren is een loop (Engels: dus uitgesproken [loep]) een herhalingslus. De termen loop, lus, of herhalingslus worden door elkaar gebruikt.
In veel programma´s wordt dezelfde code vaak meerdere malen uitgevoerd. Als dat zo is, is een lus een handige constructie om te gebruiken. Een lus betekent dat op een bepaald punt gestart wordt, het beginpunt van de lus. De statements in de lus worden uitgevoerd, tot het eindpunt van de lus is bereikt. Afhankelijk van de uitkomst van de statements, wordt teruggegaan naar het beginpunt van de lus, of de lus wordt verlaten.
Er zijn verschillende soorten herhalingslussen:
FOR-loop: FOR {bepaald aantal stappen} DO {Statements}
WHILE-loop: WHILE (Conditie=True) DO {Statements}
DO-loop: DO {Statements} UNTIL (Conditie = True)
We beginnen hier met de FOR-loop.
FOR-loop in FLowgorithm
De FOR-loop is een herhalingslus, waarbij bekend is hoe vaak de statements in de loop, of lus, herhaald moeten worden. In Flowgorithm ziet een For-loop er zo uit:
Naar een FOR-loop
Bekijk de 2 onderstaande programma´s. Ze doen hetzelfde. Alleen het programma links is zonder en het programma rechts is met 1 FOR-loop gemaakt.
Hoe je het programma rechts maakt, kun je in deze video zien.
Een 2e FOR-loop
Open dan ForLoop_array_2.fprg: Hier zijn 2 FOR-loops: 1 voor de invoer en 1 voor de uitvoer
Vergelijk deze 2 programma´s, die hieronder naast elkaar staan. Welk programma vind je het handigste?
Array vullen met random getallen
We bekijken de FOR-loop aan de hand van een ander voorbeeld. In onderstaand programma wordt een array van integers gedeclareerd, met 5 plekken: rij[5]
In een lus wordt deze array gevuld met 5 random getallen. In Flowgorithm bestaat de functie random(x), die wordt hier gebruikt, met x = 100. Dat betekent dat elke plek in de array een random, dus willekeurig getal krijgt tussen 0..100.
Het groene blokje betekent dat op het moment van de screenshot die stap werd uitgevoerd.
In het Variable Watch window rechts zie je welke plekken in de array al een waarde hebben en welke nog niet. De variabele i heeft op dat moment waarde 2.
Een video hoe je dit maakt vind je in
Voor meer informatie over de functie random(x), zie hier
Zelf maken 1: random rij getallen
Bouw het programma van de vorige pagina na en run het stapsgewijs.
Doe dit als volgt:
Maak een nieuw programma en declareer een array voor Integers met 5 plekken
Declareer een variabele i, van type Integer
Doorloop met de variabele i de array in een FOR-loop
Vul plek rij[i] met een random getal: rij[i] = random(100)
Zorg dat het Variable Watch window aanstaat (vergeten waar het zit: bekijk nogmaals dit filmpje) en bekijk wanneer de variabele i en de plekken in de array een waarde krijgen.
Uitwerking kun je vinden in: ForLoop1RandomRij.fprg
Zelf maken 2: Rij getallen optellen
Gebruik het programma uit oefening 1. Zorg dat de getallen in de array bij elkaar opgeteld worden en dat het resultaat van deze optelling naar de console wordt geschreven.
Doe dit als volgt:
Bepaal hoe je het resultaat berekent als je 5 willekeurige getallen optelt.
Gebruik een extra variabele om dit resultaat in op te slaan. Noem deze bv. som
Geef deze variabele als beginwaarde 0
Bekijk hoe je voor de optelling een loop kunt gebruiken. Tip: Stap 1 is: som = som + getal1. Wat zijn de volgende stappen? (Bedenk dat het =-teken wordt gebruikt om een toekenning uit te voeren. Som wordt de waarde van variabele som + de waarde van variabele getal1)
Maak gebruik van het feit dat de getallen in het array opgeslagen zijn, waarbij elke plek in het array genummerd is, van 0..5. De getallen, die je op wilt tellen, staan in rij[0]..rij[5]
Tel in de FOR-loop bij de variabele som steeds de waarde van rij[i] op: som = som + rij[i]
Laat, als de FOR-loop klaar is, de waarde van de variabele som naar het console schrijven, met Output “De som van de getallen is: ” & som. Denk aan het &- teken om uitvoer aan elkaar te koppelen
Zie: ForLoop2_SomGetallenArray.fprg voor het eindresultaat en vergelijk het met je eigen programma
Gebruik hetzelfde programma om ook het gemiddelde te geven.
Zelf maken 3: Fibonacci-getallen
De Fibonacci getallen zijn een reeks getallen, waarbij het volgende getal ontstaat door de 2 vorige getallen op te tellen. De reeks begint bij 0 en 1. In deze oefening zet je de eerste 10 getallen in een array, door de 2 vorige getallen op te tellen en op de volgende plek te zetten
Maak een array fib van integers met 10 plekken
Maak fib[0] = 0, fib[1] = 1
Maak een variabele om de array mee door te lopen en vul de array met de eerste 10 Fibonacci-getallen. Bekijk het voorbeeld hieronder, maak het na, of gebruik ForLoop5_Fibonacci_Stap1.fprg en maak het af.
Uitwerking in: ForLoop5_Fibonacci.fprg
Zelf maken 4: Graden Kelvin, Celsius en Fahrenheit
Toevoeging van Kyle en Gijs
Er zijn drie verschillende eenheden om de temperatuur te meten, dit zijn: Fahrenheit, Celsius en Kelvin. Het doel van dit programma is dat je de verschillende soorten eenheden in een tabel laat zetten d.m.v. een for-loop. Hierbij zet je het maximaal aantal Fahrenheit op 200 en laat je elke keer een stapje van 10 Fahrenheit maken. Zorg ervoor dat boven de tabel die als output komt de volgorde staat (van eenheden) waarin de temperaturen staan
Kom je er niet helemaal uit? Volg dan dit stappenplan:
1. Maak van de verschillende eenheden een real variabele. ( Real Fahrenheit, Real Celsius en Real Kelvin)
2. Zorg ervoor dat boven de tabel die als output komt de volgorde staat (van eenheden) waarin de temperaturen staan (Fahrenheit, Celsius en Kelvin.)
3. Maak een for-loop aan.
4. Zorg dat je het aantal Fahrenheit van 0 tot 200 lopen, met stapjes van 10
5. Zet in de For-loop de berekening van het aantal Fahrenheit -> Celsius, en van Celsius -> Kelvin.
6. Als laatste zorg je dat je output weergegeven wordt als Fahrenheit = Celsius = Kelvin
Weet je niet hoe je de berekening maakt van Fahrenheit -> Celsius?
Celsius = (Fahrenheit - 32) * 5/9
Weet je niet hoe je de berekening maakt van Celsius -> Kelvin?
Kelvin = Celsius + 273.15
Uitwerking van dit programma staat in: Graden.fprg
Zelf maken 5: Kleuren mengen
Deze opdracht gaat over de kleur paars die door blauw en rood gemaakt wordt. De kleur paars wordt gemaakt door een onbekende hoeveelheid van blauw en rood, deze hoeveelheden zijn ieder maximaal 10. Zorg dat blauw en rood zo’n hoeveelheid random toegekend krijgen, gebruik hierbij een array genaamd Kleur en maak gebruik van een FOR-loop waarmee je ook de uitkomsten van deze hoeveelheden weergeeft. Laat ten slotte zien wat de uiteindelijke hoeveelheid van paars is.
Een screenshot hiervan kun je vinden in Kleurenmengen.png
Bepaal de juiste plek
Conditie
Een conditie is een voorwaarde. Je hebt er al kennis mee gemaakt met de logische puzzels in het hoofdstuk over booleans.
ALS in deze kamer een tijger zit DAN zit in de andere kamer een dame.
Als je een programma doorloopt van begin tot eind, dan komt er vaak een moment waar een keuze of een beslissing genomen moet worden. Het pad wat daarna genomen wordt is afhankelijk van de uitkomst van de keuze of beslissing.
Vaak zeg je dan ALS dit waar is DAN moet dit gebeuren
ALS de suiker op is DAN moet ik geen suiker meer eten OF ik moet naar de winkel
ALS het mooi weer is DAN zet ik de stoelen buiten
In programmeren wordt dat vertaald naar een IF-statement, zoals bv.
IF bmi-waarde > 25 THEN GeefWaarschuwingOvergewicht
IF bmi-waarde < 18,5 THEN GeefWaarschuwingOndergewicht
In Flowgorithm ziet een conditie, oftewel IF-statement er zo uit:
Maken: Minimum en maximum
We kijken naar een voorbeeld uit hetvorige hoofdstuk, waar een aantal getallen bij elkaar opgeteld werd en gaan het uitbreiden door het minimum en maximum in de rij te vinden. Hiervoor voegen we een conditie toe. Het programma dat je hiervoor als start kunt gebruiken staat in ForLoop2_SomGetallenArray.fprg
Stappenplan: Tip: teken eerst een programmadoorloop op papier, dat geeft overzicht
Open ForLoop2_SomGetallenArray.fprg en voeg 2 variabelen toe: max en min. Zet deze beide getallen op de 1e waarde uit de rij, dus rij[0]. Bedenk goed op welke plek je dit doet. rij[0] moet al wel een waarde hebben. Tip: run je programma tussendoor, zodat je fouten direct opmerkt
Doorloop de rij met een tweede FOR-loop. Als een getal groter is dan max, ken deze waarde dan toe aan max. Is er een getal kleiner dan min, ken deze waarde dan toe aan min
Laat het minimu en maximum naar het scherm schrijven en controleer of het klopt
Een uitwerking kun je vinden in: ConditieMinMax.fprg
Maken: Even of oneven
Stel je voor: Je wilt weten of een ingevoerd getal even of oneven is. Als het even is en je deelt het door 2, dan is de restwaarde 0. Is het oneven en je deelt het door 2, is de restwaarde 1. In Flowgorithm bestaat daar een kant & klare functie voor: mod of %
Bv.: 45 mod 2 = 1, want 45 is oneven. 46 mod 2 = 0, want 46 is even. De modulo-functie geeft dus de restwaarde.
Wil je weten of een getal deelbaar is door 3, dan doe je mod 3, bv. 15 mod 3 = 0. En 35 mod 3 = 2. De restwaarde kan dan 0, 1 of 2 zijn.
Bekijk eerst de volgende tabel:
Voor de Modulo-functie kun je in Flowgorithm zowel % als mod gebruiken.
Om te kijken of een variabele gelijk is aan een bepaalde waarde, Equality, kun je zowel == als = gebruiken.
Maak het programma en vergelijk het met EvenOFOneven.fprg
Voorbeelden
Bekijk onderstaande programma´s en maak ze na in Flowgorithm. Ze doen beide hetzelfde.
Zelf maken 1: BMI
Open het programma ZelfToepassenBmi.fprg of je eigen programma, waarin je de BMI-waarde uitrekende voor een gegeven gewicht en lengte. BMI = Gewicht gedeeld door lengte in het kwadraat. Voeg hieraan een waarschuwing toe: ALS de bmi > 25, geef dan een waarschuwing voor overgewicht. ALS de bmi < 18,5 geef dan een waarschuwing voor ondergewicht. Zorg dat de gebruiker zijn gegevens goed invoert, dus in meters of centimeters, afhankelijk hoe je het maakt en test of de uitvoer klopt.
Een uitwerking kun je vinden in Conditie1_BmiWaarschuwing.fprg
Zelf maken 2: Positief, negatief of nul
Maak een programma wat het volgende doet: Laat een geheel getal invoeren en controleer of het getal positief, negatief of nul is en geef adequate uitvoer.
Uitwerking in Conditie2_PosNegNul.fprg
Zelf maken 3: Grootste getal
Maak een programma dat het volgende doet: Laat 2 getallen invoeren en geef het grootste getal weer. Handel ook correct af als de getallen gelijk zijn.
Uitwerking in Conditie3_Grootste.fprg
Zelf maken 4: Som is even of oneven
Maak een programma dat het volgende doet: Maak een array van 5 integers en vul het met random getallen, zoals in een vorige oefening. Voeg 2 variabelen toe: SomOneven en SomEven. Doorloop de array met een FOR-loop en tel zowel de oneven getallen in SomOneven als de even getallen in SomEven op. Laat deze 2 variabelen naar het scherm schrijven.
Uitwerking in Conditie4_SomEvenOneven.fprg
Zelf maken 5: Minimum en maximum
Maak een programma dat een array van 5 plekken met random getallen vult. Bepaal van deze getallen het kleinste en het grootste getal en laat deze naar het scherm schrijven.
Om wat duidelijkheid te krijgen in dit algoritme:
Hieronder staat het algoritme, maar de stappen staan in de verkeerde volgorde.
Sleep de stappen in de juiste volgorde en maak daarna het programma
Uitwerking in ConditieMinMax.fprg
Zelf maken 6: Van binair naar decimaal
Maak een programma dat een binair getal als invoer vraagt, met maximaal 5 nullen en enen en zet het om naar zijn decimale equivalent
Maak eerst een stappenplan en zorg dat je het algoritme snapt
Stap 1
Ontdek hoe een decimaal getal opgebouwd is. Neem een laag getal: 13
Je werkt van rechts naar links en de exponent begint bij 0.
Het basisgetal is 10. Je krijgt dan: 13 = 3 * 100 + 1 * 101 = 3*1 + 1*10 = 13
Voor het getal 18 gaat het zo:18 = 8 *100 + 1*101 = 8 + 10 = 18
Stap 2
Zo werkt het ook met binaire getallen. Daar is het basisgetal geen 10, maar 2. Neem een binair getal: 1 0 0 1
Je werkt van rechts naar links en de exponent begint bij 0. Het basisgetal is 2.
Bedenk dat een array bij plek 0 begint. Hier kun je handig gebruik van maken als je deze oefening maakt in Flowgorithm. Een getal begint bij 20
Maak een nieuw programma aan in Flowgorithm
Maak een array van 5 plekken: Je gaat een binair getal vragen aan de gebruiker van maximaal 5 enen en nullen
Het decimale getal komt in een variabele: decimaal. Maak die en zet deze op 0
Maak om de array te doorlopen een variabele i aan
Vraag de gebruiker om een binair getal met maximaal 5 nullen en enen. Laat de gebruiker het binaire getal stapsgewijs geven van rechts naar links
Zet de nullen en enen in een array in een FOR-loop.
Test in de FOR-loop of de gebruiker een 0 of een 1 invoert. Als er een 0 ingevoerd wordt, hoog je de variabele decimaal op als volgt: decimaal = decimaal + 2i Op deze manier maak je gebruik van de genummerde plek in de array
Zie voor een voorbeeld: ForLoopBinairNaarDecimaal.fprg
Zelf maken 7: Van Celsius naar Fahrenheit
Toevoeging van Stan
Celsius naar Fahrenheit en omgekeerd
Niet overal ter wereld wordt voor temperatuur de eenheid Celsius gebruikt. In Amerika wordt bijvoorbeeld Fahrenheit gebruikt. Het doel van deze opdracht is om een temperatuur in graden Celsius of Fahrenheit (eigen keuze van de gebruiker) om te zetten naar de andere eenheid.
De formules zijn:
°C = (°F-32)*5/9
°F = (°C*1.8)+32
Uitwerking in CelsiusFahrenheit.fprg
Zelf maken 8: Kijk uit bij onweer!
Toevoeging van Stan
Onweer is gevaarlijk en je moet dus ook op tijd binnen zijn. Als je telt vanaf de flits tot aan het geluid is je afstand tot het onweer in km: tijd/3. Op 5km afstand of meer is er nog niet zo veel aan de hand. Op 3-5km afstand wordt het misschien tijd om een schuilplaats te gaan zoeken. Vanaf 3km of minder moet je zo snel mogelijk een schuilplaats hebben. Gebruik deze info om de gebruiker een tijd in te laten voeren en vervolgens een advies te geven op basis van de afstand tot het onweer.
Uitwerking in TijdOnweer.fprg
While-loop
Bij programmeren bestaan meerdere vormen van herhalingslussen. Tot nu toe is in de oefeningen de FOR-loop gebruikt. Die gebruik je als je weet hoe vaak een blok statements uitgevoerd moet worden. Niet vaker en niet minder vaak.
In dit hoofdstuk bekijken we een ander soort loop: De While-loop.
In Flowgorithm ziet een While-loop er zo uit
Verschil FOR- en WHILE-loop
De FOR-loop is heel handig als je precies weet hoe vaak een stukje code herhaald moet worden.
Aan het plaatje links zie je dat: Steeds wordt de volgende (next) stap genomen, totdat het aantal van tevoren bepaalde stappen klaar is (done).
Weet je het aantal stappen niet, of is het afhankelijk van bv. de uitkomst van een test of een keuze, dan is een FOR-loop vaak niet de meest efficiënte manier. De kans bestaat dat de code te vaak uitgevoerd wordt en dat is zonde van de rekentijd. Het programma duurt dan langer dan nodig is.
Een WHILE-loop kan dan een betere keus zijn.
Als er in een stap in een algoritme iets voorkomt als:
ZOLANG (Dit waar is) (Voer deze statements uit)
….. vertaal je dit naar:
WHILE Conditie = True {Statements}
En dit betekent: Zolang aan de conditie voldaan wordt, worden de statements uitgevoerd
Dit zie je aan het plaatje rechts: Zolang de conditie True is, worden de statements herhaald, zodra de conditie False wordt, wordt de While-loop verlaten.
Wanneer kies je voor een WHILE-loop?
De eindeloze lus
In de FOR-loop wordt de loop-variabele steeds veranderd. De programmeur hoeft daar niet aan te denken, het gebeurt vanzelf. Als je dit vergeten bent, bekijk dan dit filmpje nog een keer. De variabele i is hier de loop-variabele en die wordt binnen de FOR-loop steeds opgehoogd, totdat hij niet meer in de loop ´past´ en de loop wordt verlaten.
Een belangrijk verschil tussen de WHILE-loop en de FOR-loop is, dat in een WHILE-loop de loop-variabele veranderd moet worden door de programmeur. Als dat vergeten wordt, bestaat de kans dat het programma in een oneindige lus terecht komt.
Dit is een gevaar, dat erg bekend is in de programmeerwereld.
Nogmaals de vorm van de WHILE-loop:
WHILE Conditie = True {Statements}
Als altijd aan de conditie wordt voldaan, dus de conditie blijft eeuwig True, worden de statements eindeloos vaak uitgevoerd. Je hebt dan een eindeloze lus gemaakt en daar komt het programma niet meer uit.
Het is dus zaak binnen de WHILE-loop te zorgen dat op een gegeven moment de conditie ONWAAR wordt. Dan houdt de WHILE-loop op, de WHILE-loop wordt verlaten en het programma kan verder met de statements die na de WHILE-loop komen.
Ontdek het zelf
Ontdek de oneindige loop
Om een WHILE-loop te gebruiken, moet je dus een conditie bepalen, om de loop in te gaan en de conditie moet veranderen om de loop weer te verlaten.
Om een oneindige loop te ontdekken, kun je de volgende vragen stellen:
Verandert de loop variabele tijdens de loop? Zo nee, dan kan het programma de loop nooit verlaten
Verandert de loop variabele wel, maar niet op de goede manier?
Bekijk de afbeelding hieronder. Waar zitten in deze programma´s de oneindige loops?
Maak ze na en run ze.
Zelf maken 1: Bevolking sterft uit
Maak een programma dat tijdens een pandemie:
Het aantal dagen geeft, voordat de bevolking uitgestorven is
Als invoer wordt de grootte van de bevolking gegeven
Gegeven is verder dat het aantal mensen dat per dag ziek wordt iedere dag 2 keer zo hoog wordt.
Maak dit programma na in Flowgorithm, zorg dat het Variable window en de console zichtbaar zijn en voer als bevolking 17000000 in. Wat is de uitkomst?
Verander nu aantalzieken = 0 op de plek waar staat: aantalzieken = 1. Wat gebeurt er nu? Hoe komt dat?
Verander het aantalzieken weer terug naar 1. Wat gebeurt er als je 3000000000 invoert? (3 miljard)
De variabele aantalzieken bevat het aantal mensen, dat per dag ziek wordt. Nu willen we ook weten hoeveel mensen er in totaal ziek zijn geworden. Voeg hiervoor een nieuwe variabele toe: totaalaantalzieken. Initialiseer totaalaantalzieken op 1. Zorg dat deze variabele op de juiste plek opgehoogd wordt met het aantalzieken
Een uitwerking kun je vinden in : bevolkingsterftuit.fprg
Als je 1 miljard invoert als bevolkingsgrootte werkt het programma nog wel, 2 miljard niet. De maximale waarde van een integer is 2147483647, maar in Flowgorithm is het dus lager. Schrijf een programma dat uitzoekt hoe groot de maximale waarde van een integer is in Flowgorithm.
Uitwerking in maximumInteger.fprg
Zelf maken 3: Vind de delers van een getal
Maak een programma dat als invoer een geheel getal vraagt onder de 100 en als uitvoer alle getallen geeft waar dit getal deelbaar door is.
Bv. als de invoer 12 is, moet de uitvoer worden: 1, 2, 3, 4, 6, 12
Het is handig om van zo´n opdracht eerst een tekening te maken of stappenplan. Zo wordt het algoritme duidelijker.
Stappenplan:
Vraag om een getal
Maak een variabele deelbaarDoor en deze start bij 1 (ieder getal is deelbaar door 1)
De WHILE-loop: Hoog deelbaarDoor steeds op, totdat deelbaarDoor gelijk is aan de helft van het ingevoerde getal (in Flowgorithm bestaat de div-functie niet, dus dat moet je anders oplossen)
Binnen de WHILE-loop moet een test uitgevoerd worden: Als (getal mod deelbaarDoor = 0) laat dan de waarde van de variabele deelbaarDoor naar het scherm schrijven, want het getal is daar deelbaar door.
Een voorbeeld kun je vinden in: deelbaarDoor.fprg
Zelf maken 4: Decimaal getal omzetten naar een binair getal
Maak een programma dat een decimaal, geheel getal als invoer vraagt en zet het om naar zijn binaire equivalent.
Je hebt hiervoor 2 bewerkingen nodig: de restwaarde en een deling door 2
Dit algoritme gaat als volgt:
Neem een positief geheel getal
Zolang het getal <> 0 is, doe
Als bij het delen door 2 de restwaarde 1 is (het getal was oneven) schrijf dan een 1 op, anders (het getal was even) schrijf een 0 op
Deel het getal door 2 en ga met deze nieuwe waarde verder
Ga terug naar stap 1
Voorbeeld:
Getal = 7
7 <> 0
Restwaarde = 1 (7 is oneven): schrijf een 1 op
Deel 7 door 2: Dit wordt 3 en doorloop de stappen nogmaals, nu met 3
3 <> 0
Restwaarde = 1 (3 is oneven): Schrijf een 1 op
Deel 3 door 2: Dit wordt 1 en doorloop de stappen nogmaals, nu met 1
1 <>0
Restwaarde = 1 (1 is oneven): schrijf een 1 op
Deel 1 door 2: Dit wordt 0
Het getal is 0 geworden en de loop stopt. Je hebt nu, van rechts naar links: 111
Neem een positief geheel getal {vraag de gebruiker om een geheel positief getal}
Zolang het getal <> 0 is, doe {een while-loop, als het getal 0 is, spring dan naar stap 6}
Als bij het delen door 2 de restwaarde 1 is (het getal was oneven) schrijf dan een 1 op, anders (het getal was even) schrijf een 0 op {een if-statement: if getal mod 2 = 0, geef als uitvoer een 0; if getal mod 2 = 1, geef als uitvoer een 1}
Deel het getal door 2 en ga met deze nieuwe waarde verder { getal = getal /2 of….dit is tricky: je moet met een geheel getal verder, dus dit werkt alleen als het getal even is. Wat doe je met een oneven getal op deze plek?}
Ga terug naar stap 1
Klaar. Het binaire getal is van rechts naar links gegeven, oftewel van boven naar beneden.
Extra: Zorg voor een mooie uitvoer van links naar rechts
Voorbeeld in Flowgorithm: DecimaalNaarBinair.fprg
Zelf maken 5: Wanneer is het concert van Green Day uitverkocht?
Toevoeging van Dorien en Bridget
Stel er is een concert van Green Day op 14 augustus. Het concert is in het stadspark in Groningen. Hier zijn alleen staanplaatsen. Er is plaats voor 1000 mensen. Hoeveel mensen er het 1e uur binnenkomen, moet de gebruiker ingeven. Ieder uur daarna is het aantal binnenkomers 2 personen méér. Green Day wil graag weten over hoeveel uur alle staanplaatsen verkocht/in gebruik zijn. Maak een programma waarin Green Day kan zien hoelang dit duurt. Tip voor als je vastloopt: er zijn 1000 plaatsen beschikbaar en de mensen komen per uur binnen. Zorg ook voor adequate uitvoer.
Uitwerking: concert-opdracht.fprg
Klassiek algoritme: Binary search
Binary Search is een klassiek algoritme. Het is een spelletje. De computer neemt een random getal, bv. tussen 1 en 30. De speler gokt wat het zal zijn en krijgt iedere gok te horen of zijn gok te hoog of te laag is, of dat hij het goed gegokt heeft. De bedoeling is het getal in zo min mogelijk stappen te raden.
Maak ook hier eerst een tekening of stappenplan:
Laat het programma een random getal bepalen
Laat de gebruiker een getal invoeren
Als het getal direct geraden is, is het programma klaar
Zolang het getal nog niet geraden is doe het volgende
Is het ingegeven getal hoger of lager dan het random getal van het programma
Geef een geschikte boodschap en vraag om een volgende invoer van de gebruiker
Klaar? Het getal is geraden. Feliciteer de gebruiker
Toevoegen: Tel het aantal keren dat de gebruiker een getal moest geven
Je kunt een voorbeeld van dit programma vinden in binarySearch.fprg
Klassiek algoritme: Bubble sort
Bubble sort is een klassiek algoritme, dat een ongesorteerde rij getallen sorteert. Sorteeralgoritmes zijn heel belangrijk in de informatica. Hoe groter gegevensverzamelingen zijn, hoe meer tijd het kost om deze te sorteren. Denk aan boektitels of klantenbestanden. Hoe efficiënter het sorteren werkt, hoe minder tijd en geheugen dit kost.
Bubble sort is één van die sorteeralgoritmes. Niet het meest efficiënte, maar wel goed om mee te oefenen met programmeren.
Bekijk de volgende video´s om te ontdekken hoe dit algoritme werkt:
Om zelf te oefenen hoe dit werkt, bekijk dan eerst dit filmpje en doe dit zelf na met 10 spelkaarten. Bekijk of je met 2 of 3 personen een aanpak kunt vinden om een stapel kaarten te sorteren. Elk vervult een rol: Vergelijker, uitvoerder en teller. (met z´n 2-en? Laat dan de teller weg)
1 vergelijker: Deze krijgt 2 kaarten te zien en wijst de laagste aan
1 uitvoerder: Deze laat kaarten zien aan de uitvoerder en legt, zonder de kaarten te zien, de kaarten neer, op aanwijzing van de vergelijker. Hij kan de kaarten wel schuiven
1 teller: Deze kijkt of het goed gaat en telt het aantal malen dat de vergelijker aangeeft welke kaart lager is
Bedenk een gezamenlijke aanpak. Oefen deze om te kijken of hij goed gaat
De uitvoerder schudt de kaarten en legt ze voor zich neer, afbeelding naar beneden
Beschrijf de gevolgde aanpak en schrijf op hoeveel stappen jullie nodig hadden
Bubble sort in Flowgorithm
Om Bubble sort in Flowgorithm te maken, maak je weer eerst een stappenplan om het algoritme te ontdekken:
Zorg dat je een ongesorteerde rij hebt van gehele getallen. Dit heb je hier al gemaakt
Zorg voor een variabele i, waarmee je de array doorloopt
Nu vergelijk je getal1 en getal2 in de rij. Als getal2 groter is dan getal1, dan swap je ze. Om te swappen heb je een extra variabele nodig. Hoe je de waarden van 2 variabelen swapt heb je hier gedaan.
Dan vergelijk je getal2 en getal3 en swap je ze zonodig
Dit herhaal je, tot je de laatste 2 getallen hebt vergeleken en eventueel geswapt.
Wat weet je nu zeker?
Maar je bent nog niet klaar, dus je begint weer van voren af aan
Wat weet je zeker na 2 doorlopen?
Dit herhaal je, tot de hele rij gesorteerd is
Hoeveel vergelijkingen heb je nodig?
Wat doe je als de rij toevallig al helemaal gesorteerd is? Hoeveel vergelijkingen moet je dan maken?
Tip: Maak dit programma eerst met 2 FOR-loops, daarna met een WHILE-loop. Uitwerking met WHILE-lus: Bubblesort.fprg
Functies
Heb jij al een veterdiploma?
Stel je voor: Een robot moet leren veters strikken om de kleuterjuf te ontlasten. Hij krijgt een testprogramma om te kijken of hij alle stappen in de goede volgorde doet.
Hieronder een stukje van dit programma.
Het is te lang voor 1 pagina en je ziet dat code zich herhaalt.
Herhaling van code
Als je een lang programma hebt, kan het onoverzichtelijk worden. Ook kan het zijn dat een stuk code vaker uitgevoerd moet worden. In zulke gevallen is het handig een stuk code in een aparte functie te stoppen.
Voordelen van het gebruik van functies:
Overzichtelijkere programma’s
Een functie kan hergebruikt worden
Door een duidelijke naamgeving, waaruit blijkt wat de functie doet, wordt je programma leesbaarder
Als je ervoor zorgt dat de in- en uitvoer hetzelfde blijven, kun je je code steeds verder verfijnen
Functies in Flowgorithm
Eigenschappen van een functie in Flowgorithm:
Een functie moet een naam hebben. Met de naam wordt de functie aangeroepen
Een functie wordt aangeroepen vanuit het hoofdprogramma, de Main, of vanuit een andere functie. Dit gaat met een Call-statement, zoals je in de afbeelding hierboven kunt zien.
Met de aanroep van de functie kunnen waarden van variabelen meegegeven worden. Dit gebeurt in de functie-aanroep door middel van parameters. Hoe dat gebeurt wordt verderop uitgelegd
Een functie kan een waarde teruggeven: Een integer, een string, een boolean. Ook dat wordt verderop uitgelegd
Eenvoudige functie: Groet
Bekijk onderstaande afbeeldingen en open voor dit voorbeeld het bijbehorende bestand: functie0_groet.fprg
In het hoofdprogramma, Main, wordt de functie groet aangeroepen. In deze functie wordt als uitvoer gegeven: Hello world
Vanuit de Main wordt de functie Groet aangeroepen
De functie Groet
Bekijk dan in dit filmpje hier hoe je dit programma maakt met een functie en hier voor een voorbeeld met invoer van de gebruiker
Functie Groet met parameter
In het vorige voorbeeld werd de functie groet aangeroepen vanuit het hoofdprogramma, de Main, en werd “Hello world” naar het scherm geschreven. Nu gaan we een stap verder. We willen dat de gebruiker een tekst invoert en dat deze tekst in de functie groet naar het scherm wordt geschreven. Dit betekent dat de tekst, die de gebruiker geeft, doorgegeven moet worden aan de functie groet. Dat gebeurt doormiddel van een parameter.
Parameter
Een parameter is een speciale variabele, die in de declaratie van de functie staat. In de declaratie kunnen ook meerdere parameters staan.
Argument
Op het moment dat de functie aangeroepen wordt, krijgt de parameter zijn waarde. Deze waarde wordt argument genoemd
Functie Groet met parameter (vervolg)
Bekijk de volgende afbeeldingen. In het hoofdprogramma, de Main, wordt om input van de gebruiker gevraagd. De variabele boodschap van type String krijgt als waarde de invoer van de gebruiker. De waarde van boodschap, het argument, wordt vervolgens meegegeven tijdens de aanroep van de functie groet.
De functie groet heeft 1 parameter, de variabele tekst, van datatype String. Bij de aanroep van de functie groet krijgt de variabele tekst de meegegeven waarde vanuit het hoofdprogramma. Binnen de functie groet wordt dan de tekst naar het scherm geschreven.
Klik voor een filmpje over deze functie hier, een uitwerking van dit programma staat in: functie0_groet2.fprg
Controle tijdens het uitvoeren van een programma
Als een programma gerund wordt, heeft eerst het hoofdprogramma de controle. Zodra een functie aangeroepen wordt en uitgevoerd gaat worden, wordt de controle overgedragen aan deze functie. Als de functie klaar is, wordt de controle weer teruggegeven aan het hoofdprogramma. De controle volgt de doorloop van het programma.
Zelf maken: Veters strikken
Open het bestand VetersStrikken.fprg
Onderstaand blok wordt een aantal keren herhaald.
Stappenplan:
Sla het programma op met de naam: VetersStrikkenMetFunctie. Zo raak je de originele code niet kwijt. Je hebt nu een kopie
Maak met de functiemanager een functie, noem die Klaar en geef hem een parameter van type String: JaOfNee
Kopieer het blok wat in het hoofdprogramma herhaald wordt naar deze functie
Verander wel de variabele keuze naar JaOfNee. De variabele keuze is namelijk niet bekend in de functie Klaar
Overal waar dit blok voorkomt in het hoofdprogramma vervang je dit door een aanroep, waarbij je de waarde van de variabele keuze meegeeft als argument
Wat vaak heel handig is, is dat een functie een waarde terug kan geven. Een Integer, een Boolean, een String of een Real. Geen array, een array kan wel via een parameter meegegeven worden. We bekijken voorbeelden van functies die een waarde teruggeven.
Returnwaarde: Integer
In onderstaand hoofdprogramma, Main, krijgen 2 variabelen, getal1 en getal2, ieder een waarde, die de gebruiker invoert. In de Output wordt de functie add aangeroepen, met als argumenten de waarden van getal1 en getal2. Op het moment dat de functie add aangeroepen wordt krijgen de parameters nummer1 en nummer2, in de aanroep van de functie, de waarden van getal1 en getal2 toegekend. Binnen de functie add worden de waarden van nummer1 en nummer2 opgeteld en het resultaat van deze optelling wordt toegekend aan de variabele som. De waarde van deze variabele som wordt teruggegeven en is de returnwaarde van de functie.
Een uitwerking hiervan staat in Optellen2Getallen.fprg
Bereik van een variabele
We bekijken nogmaals dit programma
In ht hoofdprogramma, Main, worden 2 variabelen gedeclareerd, getal1 en getal2. Deze variabelen zijn alleen bekend in dit stuk programma, dus de Main. De functie add kent deze variabelen niet.
De functie add worden de variabelen nummer1 en nummer2 als parameters gedeclareerd en de returnvariabele som. Deze drie variabelen zijn op hun beurt alleen bekend in de functie add.
Bedenk, dat als de functie klaar is, de waarde van de variabele som wordt teruggegeven, niet de variabele zelf.
Returnwaarde: Boolean
In het volgende programma wordt om 2 getallen gevraagd. Dan wordt er gekeken of de som, dus de optelling, van deze 2 getallen groter is dan 50. Als dat zo is, wordt de boolean groterdan50 True. De waarde van deze boolean wordt teruggegeven.
Een uitwerking hiervan staat in: Som2GetallenMeerdan50.fprg
Returnwaarde: Real
In dit programma worden graden naar radialen omgerekend en andersom, waarbij 2pi radialen ongeveer 360 graden is.
Uitwerking in: deg2radEnrad2deg.fprg en deg2radEnrad2degVraag2.fprg
Zelf maken: Functies in Flowgorithm
Controleer eventueel hier wat de mogelijkheden zijn in Flowgorithm.
Maak programma´s die het volgende doen:
Maak het programma van de vorige pagina na en laat de gebruiker kiezen of hij een waarde van graden naar radialen wil laten omzetten of andersom
Maak een nieuw programma. Laat 2 reële getallen invoeren. Laat in een functie uitrekenen hoe vaak het 1e getal deelbaar is door het 2e getal en geef het resultaat terug
Vraag om een geheel getal en laat in een functie de som van de digits uitrekenen. Dus als de invoer 653 is, dan is de uitvoer 6+5+3=14, en 14 geeft 1+4=5
Maak een nieuw programma. Laat 2 gehele getallen invoeren. Laat in een functie uitrekenen of het 1e getal deelbaar is door het 2e getal ZONDER gebruik te maken van de operatie mod. Dit programma is te vinden in integer checker.fprg en Geert heeft hier ook een video van gemaakt.
Tip: Maak eerst een stappenplan op papier
Zelf maken: Binary search als functie
Open het programma binarySearch, dat je gemaakt hebt in het hoofdstuk over de WHILE-Loop
Bekijk onderstaand Main-programma. BinarySearch is hier een functie geworden, die vanuit het hoofdprogramma wordt aangeroepen. BinarySearch wordt aangeroepen, zolang je wilt spelen.
Bouw je eigen Binary search om zodat het een functie wordt en maak het hoofdprogramma zoals in onderstaand voorbeeld na. (Zie: binarySearchVakerSpelen.fprg)
ASCII-tabel
In deze paragraaf leer je wat de ASCII-tabel is en leer je gebruik te maken van een paar functies, die Flowgorithm biedt: toCode(i), toChar(i)
ASCII-tabel
ASCII-code is een manier om letters, cijfers, leestekens en andere toetsen, zoals ENTER intern in een computer te representeren door een getal. Intern kan een computer tenslotte alleen met 1-en en 0-en omgaan. Als je wilt dat er bv. een “A” op het scherm geschreven wordt, wordt deze “A” omgezet naar een getal. “A” wordt weergegeven door 65. Een “a” wordt weergegeven door 97.
We gaan hier 2 functies bekijken, die Flowgorithm biedt om een teken om te zetten naar zijn ASCII-waarde, of om een ASCII-waarde om te zetten naar het bijbehorende teken.
toChar(i): Deze zet een getal i om naar het bijbehorende teken uit de ASCII-tabel
toCode(i): Deze functie zet een letterteken om naar de bijbehorende ASCII-waarde
Bekijk onderstaand programma. Dit geeft de ASCII-waarden van 97..122: Precies het alfabet van kleine letters. Maak het na en bekijk de uitvoer. Zie ASCIItabel.fprg voor een uitwerking
ASCIIwaarde van een letter
Onderstaand programma geeft de ASCII-waarde van een letterteken, met de functie toCode(letter). De variabele letter wordt als parameter meegegeven aan deze functie. Zie ASCIIwaardeLetter.fprg.
Maak van dit programma een functie, die aangeroepen wordt vanuit het hoofdprogramma, waarbij je de letter meegeeft als parameter. In het hoofdprogramma geef je de gebruiker de keuze om nog een letter in te voeren, totdat hij niet meer verder wil.
Combineer de functies: geef de gebruiker de mogelijkheid te kiezen of hij een letter om wil zetten naar ASCII-waarde, of van een in te voeren ASCII-waarde het bijbehorende teken wil
Over dit lesmateriaal
Leerdoelen
Met behulp van dit lesmateriaal worden de volgende leerdoelen bereikt
Algoritmes
De leerling weet wat een algoritme is en begrijpt de samenhang met computerprogramma´s
Flowcharts
De ll kan de werking van een programma aan de hand van een flowchart, die stappen, herhaling, keuze, variabelen en functies bevat, analyseren en bij een gegeven input de output beredeneren
De ll kan eenvoudige flowcharts maken in het programma Flowgorithm met correct gebruik van variabelen, array´s, loops en functies
Datatypes
De ll kent de verschillende datatypes: Integer, string, boolean, real
De ll weet welke waarden bij welk datatype horen
Integer: Geheel getal, positief of negatief
String: tekst
Boolean: false of true
Real: reëel getal
De ll weet welk datatype een variabele moet krijgen in de context van een specifiek programma, bv.
Om het resultaat van een deling op te slaan heb je een variabele van type real nodig
Om een tekst in te kunnen voeren, heb je een variabele van type string nodig
De ll weet welke operaties uitgevoerd kunnen worden met de verschillende datatypes
De ll kent de volgorde van uitvoeren bij booleans: NOT, And, Or
Variabelen
De ll weet wat een variabele is
De ll kan een eenvoudige code lezen en de waarden van een variabele bepalen
De ll kan een eenvoudig probleem, bv het optellen van waarden omzetten naar code en op een correcte manier gebruik maken van variabelen
De ll kan eenvoudige rekensommen laten uitvoeren en daarbij gebruik maken van minimaal 3 variabelen
De ll kan de Swap-functie correct toepassen:
Arrays
De ll kan een eenvoudige code lezen en de waarden van een array bepalen
De ll kan een eenvoudig probleem omzetten naar code en op een correcte manier gebruik maken van een array
Voorbeelden van eenvoudige problemen:
Random laten vullen van een array en dit naar het scherm laten schrijven
De maximale waarde vinden in een array
De waarden in een array op laten tellen
Condities
De ll weet wat een boolean is
De ll kent de betekenis van AND, OR en NOT en weet de volgorde van uitvoeren
De ll kan een eenvoudige logische puzzel oplossen
De ll kan een eenvoudig logisch probleem omzetten naar een if-then-else statement
De ll kan Binary search omzetten naar code
Functies
De ll kan in een eenvoudig algoritme bekijken of een gedeelte van de code beter in een functie gezet kan worden
De ll kan een probleem omzetten naar code en hierbij efficiënt het gebruik van functies inzetten
De ll snapt de functie van parameters en maakt hier gebruik van
Loops
De ll kan sorteeralgoritme Bubble sort omzetten naar correcte code, gebruik makend van een loop
De ll kan 2 verschillende implementaties van Bubble sort met elkaar vergelijken en beredeneren welke het meest efficiënt is
Fouten ontdekken
De ll kent manieren om fouten te ontdekken en kan deze toepassen:
Stapsgewijs door de code heenstappen
De waarden van variabelen laten zien in het variable window
Lesmateriaal
Bij deze module horen veel uitgewerkte voorbeelden in Flowgorithm.
Je kunt dit opvragen door een mail te sturen naar: m.van.hooff@vlietlandcollege.nl
Het arrangement Programmeren met Flowgorithm is gemaakt met
Wikiwijs van
Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt,
maakt en deelt.
Auteur
Marjolein van Hooff
Je moet eerst inloggen om feedback aan de auteur te kunnen geven.
Laatst gewijzigd
2021-11-10 09:41:21
Licentie
Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:
het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
voor alle doeleinden, inclusief commerciële doeleinden.
Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:
Toelichting
Deze cursus is bedoeld om vertrouwd te raken met basisconcepten voor programmeren, zoals variabelen, datatypes, array´s, loops, condities en functies. Ook wordt een aantal klassieke algoritmes behandeld, zoals Bubble sort en Binary search. Voor dit alles wordt het programma Flowgorithm gebruikt. Hierin leer je flowcharts maken, die je vervolgens kunt runnen. Het programma is onafhankelijk van een programmeertaal, maar de flowcharts kunnen daar wel naar omgezet worden. De cursus is bedoeld voor het vak informatica in de bovenbouw Havo/Vwo.
Deze cursus is bedoeld om vertrouwd te raken met basisconcepten voor programmeren, zoals variabelen, datatypes, array´s, loops, condities en functies. Ook wordt een aantal klassieke algoritmes behandeld, zoals Bubble sort en Binary search. Voor dit alles wordt het programma Flowgorithm gebruikt. Hierin leer je flowcharts maken, die je vervolgens kunt runnen. Het programma is onafhankelijk van een programmeertaal, maar de flowcharts kunnen daar wel naar omgezet worden. De cursus is bedoeld voor het vak informatica in de bovenbouw Havo/Vwo.
