Lussen en herhaalblokken: herhalende patronen maken

Een dans kan veel stappen hebben, maar maar één kort patroon. Als je dat patroon herkent, kun je veel kortere instructies geven.

Zoek dezelfde groepen

Een instructie vertelt je welke stap je moet uitvoeren. Een volgorde zet stappen achter elkaar. Een herhalend patroon heeft een groep die in dezelfde volgorde terugkomt. Herhaling betekent dat je iets opnieuw doet. Een andere naam ervoor is iteratie. In een programma herhaalt een lus instructies.

Probeer deze dans hardop te zeggen:

“Klap, klap, stamp, klap, klap, stamp, klap, klap, stamp, klap, klap, stamp.”

Begin met de kleinste groep die past: “klap, klap, stamp.” Markeer elke kopie met een streep:

“Klap, klap, stamp | klap, klap, stamp | klap, klap, stamp | klap, klap, stamp.”

Er zijn vier gelijke groepen. Elke groep heeft drie acties. Als je de aantallen per groep optelt, krijg je 12 acties:

De korte instructie is “herhaal vier keer: klap, klap, stamp.” Het aantal herhalingen telt groepen. Het telt niet alle 12 acties.

Houd de extra stappen erbij

Probeer nu “sta op, huppel, huppel, huppel, huppel, huppel, ga zitten.” Alleen “huppel” herhaalt zich. Zeg: “sta op, herhaal vijf keer: huppel, ga daarna zitten.” Je staat één keer op en gaat één keer zitten.

Het refrein van een liedje kan zich herhalen terwijl het begin en einde één keer voorkomen. Een robotroute kan “vooruit, draai naar rechts” vier keer herhalen. Met gelijke bewegingen vooruit en kwartslagen maakt die route een vierkant.

Controleer ook de laatste groep

Kijk naar “spring, klap, spring, klap, spring, stamp.” De eerste twee groepen zijn gelijk: “spring, klap.” Het einde is anders. Je kunt “spring, klap” twee keer herhalen en daarna “spring, stamp” toevoegen.

Zoek zelf een herhaling:

1. Schrijf of zeg alle stappen op volgorde.
2. Markeer de kleinste groep die zich precies herhaalt.
3. Tel de kopieën van die hele groep.
4. Laat extra stappen aan het begin of einde erbuiten.

Een herhaalblok staat om de instructies heen die je opnieuw wilt uitvoeren. Aan de vorm kun je zien welke blokken bij elkaar horen.

Volg één ronde

Een herhaalblok lijkt vaak op de letter C. Blokken passen in de opening. Het getal vertelt de computer hoe vaak hij die blokken moet uitvoeren. Een lus met een vast aantal is een tellus.

Lees dit programma vanaf de bovenkant:

zeg Klaar om te beginnen! 1 sec.
herhaal 3 keer
    start geluid trommel
    wacht 1 sec.
zeg Klaar! 1 sec.

Aan de spaties zie je welke blokken in de lus staan. Eerst zegt de sprite één keer “Klaar om te beginnen!”. Dan speelt hij een trommelgeluid en wacht hij. Dat is één hele ronde. Voor ronde twee gaat hij terug naar het eerste blok binnen de lus. Ook in ronde drie speelt hij een geluid en wacht hij. Daarna zegt hij één keer “Klaar!”.

Binnen, vóór en na

Sleep het blok “Klaar!” naar binnen, onder het wachtblok, en de sprite zegt het drie keer. De woorden blijven hetzelfde, maar de plek verandert wat er gebeurt.

Tel wat er gebeurt

Een lus met vijf rondes en een beweging van 10 stappen legt langs zijn route 50 stappen af:

Je kunt ook denken aan “vijf groepen van tien”. Drie rondes met twee trommelblokken erin maken zes trommelgeluiden. Het getal op het herhaalblok telt rondes, niet hoeveel blokken erin passen.

De volgorde is ook belangrijk. herhaal 2 keer met eerst klap en dan spring geeft “klap, spring, klap, spring.” Als je de binnenste blokken verwisselt, krijg je “spring, klap, spring, klap.” De totalen zijn gelijk, maar de dans verandert.

Zet de hele groep erin

Om een vierkant te tekenen, moet de sprite elke ronde bewegen en draaien. Als alleen de beweging in herhaal 4 keer staat, beweegt hij vier keer langs één rechte lijn. Een draai onder die lus gebeurt maar één keer, aan het eind. Zet de beweging en de draai samen in de lus.

Blokken kopiëren werkt, maar een lange stapel kan lastig te controleren zijn. Met een lus heb je maar één kopie van de herhalende groep nodig.

Tel de blokken die je ziet

Om een vierkant te tekenen heb je vier kopieën van neem 100 stappen en draai ↻ 90 graden nodig. Dat zijn acht blokken in de lange stapel:

De versie met een lus heeft één herhaalblok en twee blokken erin:

herhaal 4 keer
    neem 100 stappen
    draai ↻ 90 graden

Tel elk zichtbaar blok één keer. Er zijn drie blokken, ook al worden de beweging en de draai elk vier keer uitgevoerd. Je bespaart vijf blokken:

Voor tien kopieën van “neem 10 stappen, start geluid plop” heeft de lange stapel 20 blokken nodig. Eén herhaalblok met die twee blokken erin heeft er drie nodig. Dat bespaart 17 blokken. Hoe meer kopieën, hoe meer werk een lus kan besparen.

Pas één plek aan

Wil je een groter vierkant? Pas in de lange stapel alle vier de bewegingsblokken aan. Verander in de lus de ene beweging van 100 naar 150 stappen. Elke zijde wordt langer. Wil je acht keer huppelen in plaats van vier keer? Verander het aantal herhalingen.

Een korter, duidelijker programma is efficiënter voor degene die het bouwt en leest. Met minder gekopieerde blokken zijn fouten makkelijker te herkennen. Bij één gekopieerde draai kan 80 graden staan terwijl bij de andere 90 staat. Een lus herhaalt elke keer dezelfde draai. Als die draai fout is, kun je hem op één plek verbeteren.

Controleer of het nog klopt

Uitschrijven van een lus doe je door elke actie op volgorde op te schrijven. Voor herhaal 3 keer om “vooruit, draai naar rechts” schrijf je:

“Vooruit, draai naar rechts, vooruit, draai naar rechts, vooruit, draai naar rechts.”

Vergelijk dit met de lange stapel. Controleer de acties, hun volgorde en hoe vaak ze gebeuren. Een kort programma met maar drie zijden tekent nog steeds geen vierkant.

Een actie die één keer gebeurt, heeft geen herhaalblok nodig. Als je er herhaal 1 keer omheen zet, voeg je een blok toe zonder kopieën te besparen. Commentaar, zoals “tekent één vierkant”, kan iemand helpen een lus te begrijpen. De computer negeert die opmerking.

Je kunt een sprite of schildpad laten tekenen door hem een pen te geven. Met een herhaalde beweging en draai kun je een hele vorm tekenen.

Maak je klaar om te tekenen

Wis oude lijnen. Kies een startplek en een kijkrichting. Zet de pen neer met pen neer. De pen tekent terwijl de sprite beweegt. Gebruik pen omhoog om te bewegen zonder een lijn achter te laten.

Met neem 100 stappen gaat de sprite vooruit in zijn kijkrichting. Met draai ↻ 90 graden verandert hij op zijn plaats van richting. Alleen door te draaien tekent hij geen zijde. Een kwartslag is 90 graden. Een hele draai, helemaal rond, is 360 graden.

Maak een vierkant

pen neer
herhaal 4 keer
    neem 100 stappen
    draai ↻ 90 graden

Volg de rondes met je vinger. Ronde één tekent een zijde en draait. Ronde twee tekent de volgende zijde en draait. Ronde drie tekent nog een zijde. Ronde vier tekent de laatste zijde en draait terug naar de oorspronkelijke kijkrichting. De sprite keert terug naar zijn startplek.

De vier draaien vormen samen één hele draai:

Kies de draai voor elke vorm

Een regelmatige veelhoek heeft gelijke zijden en gelijke hoeken. Herhaal één keer per zijde om één keer langs de buitenrand te gaan. Verdeel één hele draai gelijk over die zijden:

Gebruik voor een driehoek herhaal 3 keer met neem 100 stappen en draai ↻ 120 graden. De drie draaien zijn samen 360 graden.

De draai geeft aan hoeveel de sprite van richting verandert. De binnenhoek van 60 graden in een driehoek met gelijke zijden is iets anders. Als je drie keer maar 60 graden draait, teken je de helft van een zeshoek en blijft de lijn open.

Verander de grootte of vorm

Een langere beweging maakt elke zijde langer. Houd het aantal herhalingen en de draai gelijk om dezelfde vorm te houden. Verander één getal tegelijk en bekijk het resultaat.

Als je bij een vierkant het aantal herhalingen in drie verandert, ontbreekt één zijde. Als je het in acht verandert, wordt hetzelfde vierkant twee keer getekend. Een piepkleine beweging die 36 keer wordt herhaald met een draai van 10 graden maakt 36 korte zijden. Samen lijken ze bijna rond.

Met draaien naar links teken je regelmatige veelhoeken de andere kant op. Een vijfpuntige ster gebruikt vijf gelijke bewegingen en draaien van 144 graden. De draaien zijn samen 720 graden, oftewel twee hele draaien. Gebruik de regel van 360 graden om één keer langs de buitenrand van een regelmatige veelhoek te gaan.

De patrooneenheid is het deel van een patroon dat zich herhaalt. Je lus bevat die patrooneenheid. Je kunt lijnen, geluiden of gelijke sprongen op een getallenlijn herhalen.

Laat na elk streepje een tussenruimte

Begin met de kijkrichting naar rechts. Deze lus maakt een streepjeslijn:

herhaal 5 keer
    pen neer
    neem 20 stappen
    pen omhoog
    neem 20 stappen

Eén ronde tekent een streepje van 20 stappen, tilt de pen op en gaat dan 20 stappen door een tussenruimte. Elke ronde legt 40 stappen af. Vijf rondes maken vijf streepjes en leggen 200 stappen af, met de laatste tussenruimte erbij.

Zet pen neer in de lus. Als het alleen boven de lus staat, verschijnt het eerste streepje. Daarna blijft de pen door pen omhoog alle volgende rondes omhoog.

Herhaal één trede

Probeer dit met de pen neer en de kijkrichting van de sprite naar rechts:

herhaal 4 keer
    neem 30 stappen
    draai ↺ 90 graden
    neem 30 stappen
    draai ↻ 90 graden

Eén ronde gaat naar rechts, draait omhoog, beweegt omhoog en kijkt dan weer naar rechts. Door de tegengestelde draaien is de sprite klaar voor een volgende trede. Vier rondes brengen hem 120 stappen naar rechts en 120 stappen omhoog. De totale route is langer, omdat zowel de bewegingen opzij als omhoog meetellen.

Hoor de patrooneenheid

Een ritme van “trommel, trommel, bekken” heeft drie geluiden. Als je die patrooneenheid vier keer herhaalt, krijg je acht trommelgeluiden en vier bekkengeluiden. Je hoort in totaal 12 geluiden. Houd alle drie de geluidsblokken binnen de lus en houd hun volgorde aan.

Spring over een getallenlijn

Begin bij 0. Herhaal vijf keer een sprong van 3. Je landt op 3, 6, 9, 12 en 15. Dit is tellen met sprongen: elke keer hetzelfde getal optellen.

De sprongen maken vijf gelijke groepen van drie:

Als je het aantal herhalingen verandert, verandert het aantal sprongen. Als je de grootte van de sprong verandert, verandert de afstand per keer. Een lus die in elk van vier rondes twee stippen tekent, geeft vier gelijke groepen van twee stippen.

Om je eigen patroon te maken, teken of zeg je het eerst. Omcirkel de patrooneenheid en tel de kopieën. Zet de hele patrooneenheid in een herhaalblok. Voer het uit en vergelijk wat je ziet of hoort met je plan.

Een lus kan een andere lus bevatten. De binnenste lus maakt al haar rondes af telkens als de buitenste lus erbij komt.

Geef de twee lussen een naam

Een geneste lus is een lus in een andere lus. De buitenste heet de buitenste lus. De lus erin is de binnenste lus. Geneste herhaling is een andere naam voor deze opzet.

Lees dit van buiten naar binnen:

herhaal 3 keer
    herhaal 2 keer
        klap
    stamp

De buitenste lus heeft drie rondes. In elke ronde klapt de binnenste lus twee keer. Nadat die binnenste lus klaar is, stampt de sprite één keer. Dan begint de volgende buitenste ronde.

Doorloop één buitenste ronde per rij

Tel het klappen als drie groepen van twee:

Dat is ook drie keer twee. Als je de getallen van de lussen optelt, krijg je vijf, maar dan mis je een hele groep. De binnenste lus begint in elke buitenste ronde opnieuw.

Het stampen wordt drie keer uitgevoerd. Het staat in de buitenste lus, na de binnenste lus. Het hoort niet bij de binnenste lus. Zes keer klappen en drie keer stampen zijn samen negen acties.

Volg de vormen van de blokken

Kijk in een blokkeneditor naar de twee C-vormige openingen. Kijk in geschreven code naar de spaties vóór elke regel. Het klappen staat verder naar binnen dan het stampen.

Verplaats het stampen naar binnen, naast het klappen, en de binnenste groep wordt “klap, stamp”. Die groep wordt twee keer per buitenste ronde uitgevoerd. In drie buitenste rondes krijg je nu zes keer klappen en zes keer stampen.

Bepaal of een geneste lus helpt

Twee buitenste rondes met elk drie keer klappen erin geven zes keer klappen. Eén herhaal 6 keer om klap geeft dezelfde lijst met acties. Een geneste lus is handig als je groepen binnen groepen wilt laten zien of na elke binnenste groep een andere actie wilt uitvoeren. Je kunt herhaalde acties ook direct in één lus schrijven. Kies een versie waarvan je de groepen kunt lezen en controleren.

Als je eenmaal een vorm hebt die werkt, kun je met een buitenste lus kopieën maken. Een beweging of draai tussen de kopieën verandert waar de volgende vorm komt.

Test eerst één vorm

Bouw een lus voor een vierkant met vier gelijke bewegingen en vier draaien van 90 graden. Zet de pen neer voordat je tekent. Test of de sprite terugkeert naar zijn startplek, met zijn oorspronkelijke kijkrichting.

Maak van vierkanten een bloem

pen neer
herhaal 8 keer
    herhaal 4 keer
        neem 50 stappen
        draai ↻ 90 graden
    draai ↻ 45 graden

De binnenste lus tekent één vierkant. Als die klaar is, richt de draai van 45 graden de sprite naar het volgende vierkant. Deze extra draai hoort in de buitenste lus, na de binnenste lus.

De acht kopieën hebben één gezamenlijk startpunt. Hun extra draaien vormen samen één hele draai:

De beweging in het vierkant wordt vier keer per vierkant uitgevoerd. Acht groepen van vier geven 32 bewegingen. Ook de draai van 90 graden wordt 32 keer uitgevoerd. De extra draai van 45 graden wordt maar acht keer uitgevoerd.

Als je die extra draai weghaalt, volgt elk vierkant dezelfde lijnen. Je ziet één vierkant waar acht keer overheen is getekend. Als je de draai van 45 graden houdt maar slechts zes kopieën maakt, zijn de extra draaien samen 270 graden. In het ontwerp blijft een deel van de hele draai onafgemaakt.

Zet kopieën in een rij

Begin met de kijkrichting naar rechts en de pen neer:

herhaal 3 keer
    herhaal 4 keer
        neem 40 stappen
        draai ↻ 90 graden
    pen omhoog
    neem 60 stappen
    pen neer

Bij elk vierkant keert de sprite terug naar de startplek van dat vierkant. Daarna gaat hij 60 stappen naar rechts zonder te tekenen. Elk vierkant is 40 stappen breed, dus het volgende vierkant begint na een tussenruimte van 20 stappen. Ook na het laatste vierkant maakt de sprite die beweging met de pen omhoog.

Voor kopieën rond één punt verdeel je 360 graden over de kopieën. Zes kopieën hebben daartussen een draai van 60 graden nodig. Vier vierkanten met een draai van 90 graden tussen de kopieën maken een ontwerp dat op een raam lijkt.

Tel de bespaarde blokken

Het tekendeel van de bloem gebruikt vijf zichtbare blokken: twee herhaalblokken, één beweging en twee draaien. De lange versie gebruikt acht instructies per vierkant, plus een extra draai:

Als je pen neer aan het begin meetelt, heeft de lange versie 73 blokken en de geneste versie zes.

Sommige taken hebben een einde. Andere blijven doorgaan zolang je programma aanstaat. Kies een lus die past bij wat je wilt laten gebeuren.

Met of zonder aantal?

Een lus die zich steeds herhaalt, heet ook een oneindige lus. Hij herhaalt de blokken erin zonder vanzelf te stoppen. Je kunt het programma stoppen met de stopknop.

Een molen kan met deze lus blijven draaien:

herhaal
    draai ↻ 5 graden

Voor precies één hele draai gebruik je 72 herhalingen van die draai. De draaien zijn samen 360 graden. Na de laatste draai stopt de tellus.

Zet de eerste stappen vooraan

Een oneindige lus bereikt nooit een einde. Blokken eronder in hetzelfde script kunnen niet beginnen. Veel blokkeneditors geven het blok een platte onderkant, zodat je er geen ander blok onder kunt vastmaken.

Als een ventilator “Ik begin!” moet zeggen voordat hij draait, zet je dat bericht boven de oneindige lus. Als hij een vast aantal keren moet draaien en dan “Klaar!” moet zeggen, gebruik je een tellus.

Als je een oneindige lus gebruikt om een vierkant te tekenen, blijft die over dezelfde vier zijden heen tekenen. Het script gaat nooit verder met het volgende deel. Gebruik vier herhalingen als het tekenen na één vierkant moet stoppen.

Andere scripts kunnen nog steeds draaien

Een script is een stapel instructies die aan elkaar vastzitten. Een oneindige lus houdt zijn eigen stapel bezig. Een andere stapel met een eigen startblok kan tegelijk worden uitgevoerd. Een spel kan in het ene script muziek blijven afspelen terwijl een ander script een personage laat bewegen.

Een geplande oneindige lus is handig. Het wordt een programmeerfout als de eindeloze herhaling verhindert dat het programma de gewenste taak uitvoert.

Een sprite kan van plaatje veranderen terwijl hij beweegt. Door die kleine veranderingen te herhalen kun je een vogel laten fladderen of een personage laten lopen.

Plaatjes worden beweging

Animatie laat plaatjes na elkaar zien, zodat iets lijkt te bewegen. De uiterlijken van een sprite zijn zijn verschillende plaatjes. Geef een vogel één uiterlijk met de vleugels omhoog en een ander met de vleugels omlaag.

herhaal
    volgende uiterlijk
    wacht 0,2 sec.

volgende uiterlijk schakelt naar het volgende plaatje. Na het laatste uiterlijk gaat het terug naar het eerste. Door de korte wachttijd kun je elk plaatje zien. De twee plaatjes van de vogel blijven elkaar afwisselen tot je het programma stopt.

Wacht binnen de lus

Een computer voert blokken heel snel uit. Zonder pauze kunnen veranderingen van uiterlijk te snel gaan om te volgen. Een wachttijd boven een lus zorgt alleen vóór de animatie voor een pauze. Een wachttijd onder een lus met een vast aantal herhalingen zorgt alleen erna voor een pauze. Zet de wachttijd binnen de lus, zodat die na elke verandering gebeurt.

Een langere wachttijd vertraagt de veranderingen. Een kortere wachttijd versnelt ze. Probeer alleen die wachttijd te veranderen en bekijk het verschil.

Beweeg met kleine stappen

herhaal 10 keer
    neem 10 stappen
    wacht 0,1 sec.

Tien kleine bewegingen leggen samen 100 stappen af. De tien wachttijden zijn samen één seconde, dus de beweging duurt ongeveer een seconde. Met één keer neem 100 stappen springt de sprite er meteen naartoe.

Zet voor een lopend personage een kleine beweging, volgende uiterlijk en een korte wachttijd in de lus. Grotere bewegingen leggen elke ronde meer afstand af; kleinere bewegingen minder. Houd bij het vergelijken de wachttijd gelijk. Een ingebouwd blok voor terugkaatsen aan de rand kan het personage laten omkeren bij de schermrand als je het in de lus zet.

Bedenk wat er gebeurt

Een storyboard bestaat uit een paar snelle tekeningen van je animatie. Schets het begin, een herhalend deel en een einde. Geef aan welke plaatjes blijven terugkomen.

Kies een oneindige lus voor een vogel die het hele spel door fladdert. Kies een vast aantal herhalingen voor een bal die tien kleine bewegingen rolt en dan stopt. Een storyboard helpt je een lus te kiezen voordat je blokken gaat slepen.

Je kunt een programma lezen als een reeks aanwijzingen. Voorspellen betekent dat je vertelt wat het gaat doen voordat je op start drukt.

Doorloop vanaf de bovenkant

Lees eerst de blokken aan het begin. Zoek het aantal herhalingen van de lus of zie dat die zich steeds herhaalt. Doorloop de blokken in de lus één keer op volgorde. Tel daarna alle rondes en neem eventuele blokken na een vast aantal herhalingen mee.

Probeer dit programma:

zeg Luister! 1 sec.
herhaal 3 keer
    start geluid bel
herhaal 5 keer
    start geluid houtblok

De lussen staan na elkaar. De sprite zegt één keer “Luister!”, speelt drie belgeluiden en daarna vijf houtblokgeluiden. De tweede lus begint als de eerste klaar is. Er zijn in totaal acht geluiden.

Schrijf zo nodig elke actie op

Door uitschrijven maak je de herhalingen zichtbaar. Voor herhaal 2 keer om neem 15 stappen en zeg Hallo! schrijf je:

“Neem 15 stappen, zeg Hallo!, neem 15 stappen, zeg Hallo!”

Tel nu twee bewegingen en twee berichten. De totale afgelegde afstand is 30 stappen. Houd elke actie op haar plek in de lijst; niet alle bewegingen gebeuren vóór alle berichten.

Schrijf bij geneste lussen één buitenste ronde per rij. Als elke rij drie bewegingen en één draai heeft, geven twee buitenste rondes zes bewegingen en twee draaien. Vermenigvuldig het aantal bewegingen met de lengte van elke beweging om de afstand langs de hele route te vinden.

Voorspel ook een verandering

Als je het aantal herhalingen van een vierkant van vier in acht verandert, blijven de beweging en de draai hetzelfde. Acht kwartslagen vormen samen twee hele draaien. De sprite tekent hetzelfde vierkant twee keer. Het eindplaatje kan het extra werk verbergen.

Schrijf een voorspelling op voordat je het programma uitvoert. Let daarna op de acties en op het eindplaatje. Als ze afwijken van je voorspelling, controleer dan zowel de code als je telling. In beide kan een fout zitten.

Een programmeerfout laat je programma iets doen wat je niet wilde. Debuggen betekent de fout opsporen en verhelpen. Door goed te kijken krijg je aanwijzingen over welk blok je moet veranderen.

Vergelijk het plan en het resultaat

Vertel eerst wat er moet gebeuren. Voer het programma uit en beschrijf wat er echt gebeurt. Zoek de eerste plek waar die twee verhalen verschillen.

Een lus die een zeshoek moet tekenen, luidt:

herhaal 5 keer
    neem 60 stappen
    draai ↻ 60 graden

Hij tekent vijf zijden en laat een opening. De draai klopt voor een zeshoek, maar er moeten zes zijden zijn. Verander alleen herhaal 5 keer in herhaal 6 keer. De zes draaien zijn samen 360 graden. Voer het opnieuw uit om te controleren of de lijn sluit.

Zoek het blok bij de aanwijzing

Oude lijnen kunnen je nieuwe tekening ook verbergen. Wis het scherm aan het begin, zet de sprite daarna op zijn startplek en geef hem zijn oorspronkelijke kijkrichting.

Vertraag de lus

Voeg tijdens het testen wacht 0,5 sec. toe in een lus. Tel de rondes hardop terwijl je kijkt. Je merkt misschien dat een draai één keer aan het eind gebeurt terwijl die elke ronde moet gebeuren. Verwijder de extra wachttijd voor het testen als je de programmeerfout hebt gevonden.

Test één verandering tegelijk

Verander één blok of getal en voer het programma opnieuw uit. Als je het aantal, de draai en de beweging allemaal tegelijk verandert, is het lastig te zien welke verandering hielp.

Als de verbetering werkt, probeer je een andere startplek met genoeg ruimte. Probeer ook een grotere vorm. Zet de start terug en wis oude lijnen bij elke test. Controleer de lengtes van de zijden, de draaien en het einde, zodat de verbetering ook na je eerste poging werkt.