h.hofstede (h.hofstede@hogeland.nl)

While....End
       
Soms wil je dat een programma een aantal keer een lus doorloopt totdat aan een bepaalde voorwaarde is voldaan. Je weet dus nog niet van tevoren hoe vaak die lus doorlopen moet worden (zoals bij   For ...  End  wl bekend is).
In die gevallen kun je handig de instructie   PRGM   5: While ... 7: End  gebruiken.

Wat doet je rekenmachine?

Na  While  kun je een voorwaarde invoeren. (meestal uit menu   2nd   TEST  natuurlijk)

Je rekenmachine kijkt nu eerst of aan de voorwaarde is voldaan en als dat zo is gaat hij nu alle volgende programmaregels uitvoeren tot hij bij  End  komt.
Bij  End  aangekomen springt hij terug naar  While , en test opnieuw of aan de voorwaarde is voldaan. Zodra de voorwaarde niet klopt stopt de machine de lus en gaat verder na  End.
 

het "testmoment" zit bij While!

 

Je ziet dat dat weer een lus maakt.
Maar wel een  gevaarlijke lus!!!!

Zie je het gevaar????

Het zou kunnen dat tijdens deze lus NOOIT aan de voorwaarde wordt voldaan!!
Neem het volgende (belachelijke) programmaatje:
   
:  Input X
:  0 → N
:  While  N
X
:  N = N + 2
:  End
   

N wordt achtereenvolgens 2, 4, 6, 8, .....en dat stopt zodra N gelijk is aan een opgegeven getal X.

Maar als je voor X een oneven getal hebt ingevuld, dan wordt N nooit gelijk aan X. Deze lus blijft oneindig lang doorlopen. Nou ja... totdat de batterijen van de rekenmachine leeg zijn natuurlijk.

Mocht per ongeluk zoiets gebeuren, dan is er n geweldige, maar tegelijk vrij domme oplossing: 
ZET JE REKENMACHINE GEWOON UIT EN WEER AAN!
Probeer daarna de fout in je lus te achterhalen en te repareren (meer daarover in de volgende les).
Beroemd Voorbeeld:  Het 3n + 1  probleem
-  ofwel  de Hagelsteenreeks -

De hagelsteenreeks ontstaat als volgt:

   1.  Neem een willekeurig getal n
   2.  Als n even is, deel het dan door 2
   3.  Als n oneven is vermenigvuldig dan met 3 en tel er vervolgens 1 bij op
  
4.  Nu heb je een nieuw getal n en daarmee ga je weer hetzelfde doen.

Dat geeft bijvoorbeeld de reeks   12  -  6  -  3  -  10 -  5 -  16  -  8  -  4  -  2  -  1

Het  "vermoeden van Collatz"  zegt nu, dat als je maar lang genoeg doorgaat, dat je dan altijd op 1 uitkomt. 
Maar ja, het is slechts een vermoeden, en nog nooit bewezen.

Laten we een programma gaan maken.... Kijk of je het met onderstaand stroomdiagram eens bent.
   

Dat stroomdiagram klopt aardig.
 

Je zie dat even getallen steeds worden gehalveerd (rode lus) en dat oneven getallen  worden verander in 3N + 1  (blauwe lus)

Tussendoor wordt steeds de teller A van het aantal getallen bijgehouden.

Wat mist er nog?

Nou, we weten niet OF deze reeks ooit stopt, dus we moeten nog een  STOP inbouwen voor het geval dat A boven een bepaalde gekozen grens G uitkomt.

       
Dat geeft het stroomdiagram hiernaast

Nog steeds wordt in de rode lus door 2 gedeeld, maar nu wordt hij onderbroken als we de grens G hebben bereikt.
Net zoiets geldt voor de blauwe lus.

Het bijbehorende programma ziet er z uit: (het drukt ook nog de serie hagelsteen getallen af)

   
PROGRAM  HAGEL

: ClrHome
: Input"getal?", N
: Input"grens?", G
: 1 → A
: Lbl 1
: While  int(N/2) = N/2
:    A + 1 →  A
:    If A = G
:    Then
:    Disp "geen
:    Stop
:    Else
:    N/2  →  N
:    Disp N
:         If  N = 1
:         Then
:         Disp N
:         Disp"Aantal", A
:         STOP
:         End
:     End
:  End
:  3*N + 1 → N
:  Disp N
:  A + 1
A
:  If A = G
:  Then
:  Disp "geen"
:  End
:  Goto 1
       
Om even bij stil te staan
       
1. Repeat....End  is een opdracht die verdacht veel lijkt op While... End.
Direct na Repeat komt eerst een voorwaarde waaraan voldaan moet worden, en daarna kun je een serie opdrachten geven die in een lus komen, en die eindigen met End.
Elke keer wordt er bij End getest of er nog aan de voorwaarde is voldaan. Als dat zo is begint de serie opdrachten opnieuw, als dat niet zo is gaat het programma verder.  
       
 

het "testmoment" zit bij End!

       
  (Een repeat-lus wordt dus altijd minstens n keer doorlopen)
       
2. Goto
Helemaal onderaan het programma heb ik die Goto weer gebruikt. Het programma gaat bij deze opdracht rechtstreeks naar het Lbl dat achter Goto wordt genoemd. Echte programmeurs hebben trouwens nogal een hekel aan Goto. Teveel zulke springopdrachten maakt de gang van een programma onoverzichtelijk, en maakt het moeilijk fouten op te sporen als er iets mis gaat.
Bovendien:  in een While- of Repeat-lus reserveert het programma een bepaalde geheugenruimte om de voorwaarden bij te houden. Die ruimte komt weer vrij zodra lus is afgehandeld. Maar als je met een "Goto" uit de lus springt blijft die geheugenruimte bezet.
       
For...End

een fout opsporen

       
  OPGAVEN
       
1. Pas het hagelsteen programma aan om de langste hagelsteenreeks onder de 200 te vinden.
       
2. Een vader opent voor zijn pasgeboren dochtertje een bankrekening en zet daar   80,- op.
De bank geeft 4% rente per jaar, en  elk jaar stort de vader (nadat de rente is bijgeschreven) weer 80 op de rekening.
Schrijf een programma dat berekent na hoeveel jaar er voor het eerst  meer dan   5000 op de rekening zal staan.
       
3. Een Lucas-rij is afgeleid van een Fibonacci-rij.
Je begint met twee getallen en elk volgende is dan de som van de vorige twee.
Bijvoorbeeld:   2 - 6 - 8 - 14 - 22 - 36 - 58 - ....
(De Fibonacci-rij is een Lucas-rij die met 1- 1 begint)
Schrijft een programma dat van een Lucasrij berekent hoeveel getallen uit de rij tussen 5000 en 10000 liggen.
       
     
       

h.hofstede (h.hofstede@hogeland.nl)