NSD (Nassi-Schneidermann

NSD (Nassi-Schneidermann-diagrammen)
Werk de opdrachten in een apart Word-bestand uit en zet dit samen met de nsddiagrammen die je gemaakt hebt in je logboek.
Inleiding
Computers kunnen alleen uitvoeren wat een programmeur in een programma heeft
vastgelegd.
De instructies worden opeenvolgend uitgevoerd.
1. Bewerkingen met variabelen
In een programma kunnen getallen en teksten (strings) bewaard worden in een plek
die we variabele noemen.1
De naam van een variabele kan een letter zijn (A, B, C) of een tekenreeks. Bij echte
programma's is het vaak beter om een duidelijke naam te gebruiken (zoals
Temperatuur, Leeftijd).
Na elke opdracht staat vermeld wat de waarde van de variabele A, B en C is nadat de
instructie uitgevoerd is.
regel
1
2
3
opdracht
A=2
B=5
C=A+B
A
2
2
2
B
?
5
5
C
?
?
7
Met A=2 zorg je er voor dat het getal 2 in variabele A bewaard wordt.
Met C=A+B worden de getallen in de variabelen A en B bij elkaar geteld. De
uitkomst wordt in variabele C gezet.
De variabele waarin de uitkomst terecht komt staat altijd links van het gelijk-teken.
Rechts van het gelijk-teken staat een constant getal, of een berekening.
Opdracht 1
Bekijk het volgende eenvoudige programma. Wat moet er op de plaats van X
staan?
regel
1
2
3
opdracht
A=1
B=3
C=A+B
A
1
1
1
B
?
3
3
C
?
?
X
Bij de meeste programmeertalen kun je ook andere ‘dingen’ in variabelen bewaarden,
bijvoorbeeld teksten. Bovendien wordt er vaak onderscheid gemaakt tussen variabelen die alleen
gehele getallen kunnen onthouden en variabelen die ook kommagetallen kunnen onthouden. Als je in
een echte programmeertaal gaat programmeren is dat verschil belangrijk.
Voorlopig werken we alleen met getallen. Dat kunnen kan gehele getallen of kommagetallen zijn.
1
2. Sprongen
Er bestaan ook sprong-instructies, de processor gaat dan verder met een opdracht
ergens anders in het geheugen.
Met JUMP 3 wordt bedoeld dat de computer met de opdracht op regel 3 verder gaat.
Bekijk de volgende opdrachten. Op regel 4 staat niets vermeld bij de variabelen omdat
deze regel niet uitgevoerd wordt.
regel
1
2
3
4
5
opdracht
A=1
B=3
JUMP 5
A=6
C=A+B
A
1
1
1
B
?
3
3
C
?
?
?
1
3
4
3. De voorwaardelijke sprong: Alleen springen als...
Soms moet de computer een keuze maken, afhankelijk van een waarde gaat de
computer dan met de volgende opdracht verder, of hij springt naar een andere
instructies. Dit heet een voorwaardelijke spronginstructie.
Een voorbeeld van zo een voorwaardelijke spronginstructie is:
IF A>2 JUMP 3
Het programma springt naar regel 3 als A groter dan 2 is.
In plaats van A>2 kunnen (bijvoorbeeld) ook de volgende voorwaarden voorkomen:
A=3, B<3, A=B, etc.
In de onderstaande tabel is de schrijfwijze voor vergelijkingen opgesomd, in de
linkerkolom staat de notatie zoals je die in de wiskunde gebruikt.
Wiskunde
Basic/Pascal/Delphi
=
=
<
<
>
>
≠
<>
≤
<=
≥
>=
Bekijk weer de volgende opdrachten. Bij de derde opdracht ziet de processor dat B
gelijk aan 0 is. Hij gaat dus verder met regel 5.
regel
1
2
3
4
5
opdracht
A=1
B=0
IF B=0 JUMP 5
A=6
C=A+B
A
1
1
1
B
?
0
0
C
?
?
?
1
0
1
opdracht 2
Verander de voorwaarde in regel 3 zo, dat regel 4 wel uitgevoerd wordt.
(Je moet dus B=0 veranderen in een andere voorwaarde).
Door instructies, spronginstructies en voorwaardelijke spronginstructies te
combineren kun je herhalingen maken
In het voorbeeld hieronder kun je zien dat eerste A=3 en B=0 uitgevoerd worden.
Daarna wordt B=B+1 en A=A-1 uitgevoerd totdat A nul is. Dan pas wordt B=2*B
uitgevoerd. De asterisk (*) staat daarbij voor vermenigvuldig.
Je vindt het misschien vreemd dat in één opdracht (A=A-1) twee keer dezelfde
variabele voorkomt. Rechts van het is-teken staat wat de berekening is (A-1) en links
staat waar de uitkomst bewaard wordt (in dit geval in A).
regel
1
2
3
4
5
6
opdracht
A=3
B=0
B=B+1
A=A-1
IF A>0 JUMP 3
B=2*B
opdracht 3
Hoe vaak worden regel 3 en 4 uitgevoerd?
Het heeft bij een (voorwaardelijke) springinstructie niet zoveel zin om te springen
naar de regel die meteen na de spronginstructie staat omdat je daar vanzelf komt, ook
als je niet springt.
Bekijk het volgende programma maar eens:
1
2
ALS A=0 JUMP 2
B=6
opdracht 3b
Naar welke regel gaat het programma na regel 1 als A=0? En als A<>0?
Bekijk nogmaals dit programma:
regel
1
2
3
4
5
6
opdracht
A=3
B=0
B=B+1
A=A-1
IF A>0 JUMP 3
B=2*B
stappendiagram
Je kunt het verloop van het programma (en de inhoud van de variabelen) met een
schema zoals dat hieronder staat aangegeven. We noemen dit een stappendiagram
omdat per stap aangegeven staat welke veranderingen het programma in de variabelen
aanbrengt en hoe de computer door de programmaregels loopt.
de inhoud van de variabelen is de waarde na het uitvoeren van de instructie.
stap
1
2
3
4
5
6
7
8
9
10
11
12
regel
1
2
3
4
5
3
4
5
3
4
5
6
A
3
3
3
2
B
?
0
1
1
2
1
2
2
1
0
3
3
0
6
opdracht 3c
Waarom kunnen we de tabel na stap 12 niet meer voortzetten?
4. Halt
We introduceren nog instructie die we kunnen gebruiken om het programma
beëindigen: Halt. Na deze instructie verzet het programma geen stap meer!
Alle programma’s hierboven zouden dus met 1 extra regels moeten worden
uitgebreid!
Elementaire instructies
We noemen de instructies die je tot nu toe bent tegen gekomen elementaire
instructies:


bewerkingen met variabelen
JUMP …


ALS … JUMP …
Halt
NSD
De structuur van een (deel van een) programma kun je in Nassi-SchneiderDiagrammen vastleggen.
Start
Het eerste symbool staat hieronder. In het vak staat een beschrijving van het
programma of de routine.
Instructie
Daarna volgen 1 of meer instructies.
Keuze
Een keuze is ook een instructie, maar die ziet er natuurlijk anders uit. In dit geval
wordt met een normale instructie een getal ingelezen. Met de functie odd(N) (odd in
Engels voor oneven) wordt gekeken of het getal N oneven is. Afhankelijk van het
resultaat wordt de juiste bewering over N gedaan.2
Soms wil je alleen in het linker- of het rechterdeel opdrachten uitvoeren. In dat geval
blijft dus één van de kolommen leeg3.
Je ziet hier dat het ‘antwoord’ van de vraag Y (Yes) of N (No) kan zijn. Bij echte
programmeertalen is het vaak beter om je af te vragen of de voorwaarde Waar (True) of Onwaar
(False).
3
In diagram wordt een lokaalcode “F005” gebruikt. Je schrijft zo een tekenreeks tussen dubbele
aanhalingstekens. Later in deze opdracht wordt er meer over tekenreeksen uitgelegd.
2
Herhalingen/Lussen
Om het meteen maar ingewikkeld te maken: er zijn drie soorten herhalingen/lussen.
while
Bij de WHILE-lus wordt eerst gekeken of aan de voorwaarde voldaan is (in dit geval
teller>0). Als dat zo is worden de opdrachten binnen de lus uitgevoerd.
Het kan dus zo zijn dat de opdrachten binnen de lus nooit uitgevoerd.
Hieronder staat van twee programmeertalen beschreven hoe je een While-lus
programmeert. We nemen aan dat er een andere stukje programma is – dat Schrijf
heet – waarmee je een getal of een tekst op het scherm kunt schrijven.
Basic
Do while teller>0
Schrijf(teller)
Teller=teller-1
Loop
Pascal/Delphi
while teller>0 do begin
Schrijf(Teller);
teller:=teller-1;
end;
Terzijde 1: Heb je de details gezien? In Basic schrijf je =. In Pascal :=. In Pascal
eindigt bijna elke regel met een puntkomma, in Basic is dat niet nodig.
Terzijde 2: In Delphi is een Begin/End nodig om aan te geven wat het blok is. Als je
dat niet doet wordt alleen Schrijf(Teller) als het blok gezien. teller:=teller-1 wordt dan
pas uitgevoerd als de lus afgebroken wordt!
Terzijde 3:Begrijp je waarom het verschil maakt als je
teller:=teller-1;
Schrijf(Teller);
In plaats van
Schrijf(Teller);
teller:=teller-1;
schrijft.
In het onderstaande voorbeeld wordt Teller>0 gebruikt.
opdracht 4
Welke getallen worden in het diagram hierboven achtereenvolgens op het
scherm geschreven?
Opdracht 5a
De eerste regel is nu 'teller=10', verander deze regel zo dat de lus nooit
uitgevoerd wordt.
Opdracht 5b
Schrijf dit programma in elementaire instructies.
Opdracht 5c
Welke getallen schrijft het programma als je de opdrachten Schrijf(teller) en
Teller=Teller-1 verwisseld.
for
Bij de FOR-lus kun je met een start- en eindgetal aangegeven voor welke waarden de
lus doorlopen moet worden.
opdracht 6a
Welke getallen worden in het diagram hierboven achtereenvolgens op het
scherm geschreven?
Opdracht 6b
Schrijf ook dit programma in elementaire instructies
Je ziet dat de getallen nu van klein naar groot geschreven worden.
IN een echte programmeertaal ziet dat er als volgt uit:
Basic
for teller = 1 to 10
schrijf(Teller)
next
Pascal/Delphi
for teller:=1 to 10 do
Schrijf(Teller);
Als je in Pascal/Delphi meer dan 1 opdracht in de lus wilt uitvoeren moet je de
opdrachten tussen begin en end zetten:
Schrijf('De eerste kwadraten zijn:');
for teller:=1 to 10 do Begin
Getal:=Teller*Teller;
Schrijf(Getal);
End;
Bij de while-lus telden we terug. Kan dat ook bij een for-lus?
In het NSD kun je dat eenvoudig oplossen door de voorwaarde te veranderen in
Teller=10 to 1.
In echte programmeertalen is er vaak nog een extra aanpassing nodig.
In Basic schrijf je step -1 achter de opdracht:
Basic
for teller = 10 to 1 step -1
schrijf(Teller)
next
In Pascal/Delphi schrijf je downto in plaats van to:
Pascal/Delphi
for teller:=10 downto 1 do
Schrijf(Teller);
repeat (ook wel repeat-until)
Bij de REPEAT-opdracht worden de opdrachten binnen de lus altijd minimaal 1 keer
uitgevoerd. De controle of de lus nog een keer doorlopen moet worden vindt pas na de
eerste doorloop plaats.
Basic
Do Until teller=0
Schrijf(teller)
Teller=teller-1
Loop
Pascal/Delphi
repeat
Schrijf(Teller);
teller:=teller-1;
until teller=0;
Het valt op dat in Basic de Until opdracht voor het blok staat dat uitgevoerd wordt,
maar in werkelijkheid vindt de controle pas achteraf plaats. Delphi is in dat opzicht
duidelijker.
opdracht 7a
Welke getallen worden in het diagram hierboven achtereenvolgens op het
scherm geschreven?
opdracht 7b
Schrijf dit programma in elementaire instructies
opdracht 8
WHILE versus UNTIL
Het zal je misschien opgevallen zijn dat de voorwaarde bij While en Until het
omgekeerde van elkaar zijn.
Kun je uitleggen waarom dat zo is?
Je kunt de ene lus dus vaak in een andere vertalen. Hieronder staat een voorbeeld.
Bekijk dit voorbeeld kritisch!
Voorbeeld
while
Teller:=4;
while teller>0 do begin
teller:=teller-1;
getal:=sqrt(teller);
schrijf(getal);
end;
for
repeat
For teller:=3 downto 0 do begin Teller:=4;
getal:=sqrt(teller);
repeat
schrijf(getal);
teller:=teller-1;
end;
getal:=sqrt(teller);
schrijf(getal);
until teller=0;
Je ziet dat bij een While en een for een begin en een end om de lus heen staat. Het
is veilig om dat steeds te doen. Bij een repeat-lus is dat niet nodig. De begin/end zit
als het ware in de repeat/until ingebouwd.
Omdat je in dit geval omlaag telt heb je een for-downto-lus. Als je omhoog telt
heb je een for-to-lus.
Je ziet dat bij een while en repeat de waarde van de teller veranderd in de regel
teller:=teller-1;. Bij een for is dat niet nodig. Het verlager van de teller zit
in downto ingebouwd.
opdracht 9
Schrijf de volgende herhaling als een For en als een Repeat-Until in Delphi:
x:=0
while x<5 Do Begin
y:=x*x;
Schrijf(y) ;
x:=x+1;
End;
Toch is er in veel gevallen wel een voorkeur voor 1 van deze drie soorten lussen.



Als je een hele reeks gehele getallen 1-voor-1 wilt doorlopen kies je een FORloop.
Als het blok zeker 1 keer doorlopen moet worden kies je een UNTIL-loop.
Als je vooraf wil bepalen of de lus wel/niet doorlopen moet worden kies je een
WHILE-loop.
Extra voorbeeld 1
Hier volgt nog een extra voorbeeld over lussen.
Stel, je wilt alle getallen van StartGetal tot EindGetal bij elkaar tellen. Als het
StartGetal 3 is en het eindgetal 5, tel je dus de getallen 3, 4 en 5 bij elkaar.
Je kunt dat op de volgende manier doen:
-
-
Lees het startGetal in
Lees het Eindgetal in
Maak een variabele Som nul, hiermee ga je later de getallen bij elkaar tellen
Doorloop nu een lus waarmee je de getallen van StartGetal tot en met
Eindgetal bij Som telt. In Som staat dus steeds de som van de getallen die je
tot dusver bij elkaar geteld hebt.
Op het eind toon je de totale Som.
Het valt op dat je de variabele Getal niet hoeft op te hogen met 1.
Je kunt deze lus ook met een While schijven:
De variabele Teller heeft dezelfde functie als de variabele getal in het programma met
de FOR-lus. Aan het begin van de lus wordt gecontroleerd of Teller<=EindGetal is.
Aan het eind van de lus wordt Teller met 1 opgehoogd.
Nu maken we hetzelfde programma nog eens met een repeat-until-lus.
Terzijde
We zijn er bij dit programma vanuitgegaan dat de gebruiker voor het startGetal een
kleiner getal invoerde als voor het eindGetal.
Als beide getallen gelijk zijn werkt het programma ook nog, maar als het eindGetal
kleiner is dan het startGetal werkt het programma niet meer.
We kunnen natuurlijk een controle inbouwen: als EindGetal<StartGetal worden de
twee getallen verwisseld. Maar hoe verwissel je twee getallen?
Poging 1
Stel A=5 en B=3. Kun je deze waarden verwisselen met de opdrachten A=B en B=A?
A
5
3
3
A=B
B=A
B
3
3
3
Je ziet dat je na de opdracht A=B de waarde van A overschrijft met 3. Je bent het
getal 5 dus kwijt!
Dat brengt ons op het idee om de waarde van A even in een tijdelijke variabele weg te
zetten:
C=A
A=B
B=C
A
5
5
3
3
B
3
3
3
5
C
?
5
5
5
Op deze manier kunnen we de waarde van A en B dus verwisselen.
Je kunt deze controle in alle drie de programma’s verwerken. Als voorbeeld staat
hieronder het programma met de while.
Extra voorbeeld 2
Er komen natuurlijk ook andere lussen in programma’s voor, waarbij niet steeds 1 bij
een teller geteld wordt.
Een voorbeeld is het 3*n+1 probleem. Meer hierover kun je vinden op:
http://acm.uva.es/p/v1/100.html
De berekening bij dit probleem gaat als volgt:
-
neem een getal n
we stoppen als n=1
als n oneven is berekenen we n=3*n+1, anders n=n/2
Verwerk dit algoritme als oefening in een NSD. De uitwerking staat aan het einde van
deze opdrachten.
NSD’s zelf maken
Op de website vind je het programma NSD. Pak het zip-bestand in een mapje uit en
start het programma (nsd.exe).
Maak een nieuw NSD aan met de meeste linkse knop in de taakbalk.
We gaan een programma maken dat opeenvolgende getallen bij elkaar telt. Je bent het
eerder tegengekomen als extra voorbeeld bij de lussen. Je moet het NSD nu zelf
maken.
Geef het programma de naam SOM.
Je NSD ziet er dan zo uit.
We gaan nu een statement toevoegen. Klik op de bovenste knop in de lijst met NSDelementen en sleep met de muis tot de plek onder Som rood oplicht.
Geef de volgende beschrijving van de eerste instructie.
Opdracht 10
Maak nu zelf het NSD op de onderstaande manier na. Bewaar je NSD onder de
naam Som.nsd en zet het bij de uitwerking van deze opdracht op je logboek.
opdracht 11
Een wielrenner trekt afhankelijk van de temperatuur een bepaald tenue aan.
Hij draagt altijd een korte broek, sokken, een bril en een helm.
Als de temperatuur 25 graden of hoger is, draagt hij verder een shirt met korte
mouwen. Beneden 25 graden draagt hij onder zijn shirt met korte mouwen een
termo-shirt. Bij 15 graden of lager draagt hij over dit alles een jasje met lange
mouwen. Als de temperatuur onder de 10 graden zakt trekt hij een extra lange
broek aan. Als het niet droog en/of kouder dan 5 graden is, trekt hij bovendien
nog overschoenen aan.
De korte broek heeft helpen4 die over het termo-schirt heen moeten, maar onder
het shirt met de korte mouwen of het jasje gedragen worden.
Het termo-shirt wordt onder het shirt met korte mouwen gedragen.
Het jasje wordt over de shirt gedragen.
De lange broek wordt over de kort broek gedragen.
Verwerk deze gegevens in een kloppend NSD en bewaar dit onder de naam
fietsen.nsd (Het programma NSD is al meer dan 10 jaar oud en kan niet met
bestandsnamen van meer dan 8 tekens omgaan).
Het valt je wellicht tegen dat er zoveel beschreven wordt in deze opdracht.
Vooral de laatste voorschriften/omschrijvingen kunnen natuurlijk weggelaten
worden als je uit gaat van ‘gezond verstand’. Het probleem is natuurlijk dat
‘gezond verstand’ geen exacte omschrijving is van hoe de wielrenner zijn tenue
draagt.
Het is in de informatica (maar ook bij andere wetenschappen als wiskunde) vaak
pure noodzaak om exact en volledig te zijn.
Ga er bij de volgende opdrachten vanuit dat je:
 een getal in de variabele X kunt inlezen (=invoeren met het toetsenbord) met
de opdracht Lees(X).
 de variabele X op het scherm kunt schrijven met de opdracht Schrijf(X)
 Twee variabelen of getallen kun je vermenigvuldigen met het
vermenigvuldigingsteken *
 de wortel kun je berekenen met de opdracht sqrt (van square root).
Bijvoorbeeld: a=sqrt(4)
 van een kommagetal kun je een geheel getal maken door alles achter de
komma weg te laten met de opdracht Int(). Bijvoorbeeld A=Int(2.3)=2. Je kunt
die natuurlijk ook met variabelen doen: A=Int(B)
 En willekeurig getal kun je laten kiezen met de opdracht Rand(). Dit komt van
het Engelse woord random wat willekeurig betekend).
Let op de haakjes achter Rand!5
 Je kunt een programma tussentijds beëindigen met de opdracht Exit.
4
Helpen zijn van die dingen die aan een broek vast zitten en over de schouders gedragen
worden.
5
Bij echte programmeertalen zet de opdracht A=Rand() in A een kommagetal, bijvoorbeeld
A=0.03022003.
Als je met rand een willekeurige geheel getal wilt maken moet je Int() gebruiken. Bijvoorbeeld
A=Int(10*Rand())
opdracht 12
Maak een NSD waarin je een programma beschrijft dat twee getallen inleest en
het product van die twee getallen op het scherm schrijft.
Bewaar dit NSD onder de naam product.nsd.
opdracht 13
Maak een NSD waarin je een programma beschrijft dat de wortel van een
ingelezen getal berekend en op het scherm schrijft.
Bewaar dit NSD onder de naam wortel.nsd.
Opdracht 14
Maak een NSD van een programma dat van een ingelezen getal bepaald of het
gelijk is aan een eerder gekozen willekeurig geheel getal.
Bewaar dit NSD onder de naam gokken.nsd.
Opdracht 15
Maak een NSD waarin je een programma beschrijft waarmee iemand zijn
leeftijd kan invoeren. Als de ingevoerde leeftijd lager is dan dan jouw eigen
leeftijd, schrijft jouw programma “je bent jonger”. Als de ingevoerde leeftijd
hoger is schrijf het “Je bent ouder”, anders “we zijn even oud”.
Bewaar dit NSD onder de naam leeftijd.nsd.
opdracht 16
Maak een NSD voor het berekenen van de oplossingen van een kwadratische
vergelijking door middel van de abc-formule. De kwadratische vergelijking is
2
van de vorm ax bxc0.
Lees eerst a, b en c in. Bereken daarna de discriminant D.
Afhankelijk van de waarde van D zijn er 0, 1 of 2 snijpunten
Bewaar je NSD onder de naam abc.nsd.
Opdracht 17a
Wat schrijft het volgende programma op het scherm?
Opdracht 17b
Maak een NSD voor een programma dat alle kwadraten tussen twee ingelezen
getallen op het scherm schrijft, de twee grenswaarden tellen mee.
Als de ingelezen getallen 1 en 10 zijn, worden de getallen 1, 4 en 9 op het
scherm geschreven omdat dit de enige kwadraten, die niet kleine dan 1 of groter
dan 10 zijn.
Bewaar je NSD onder de naam kwadraat.nsd.
Strings
Een string is een tekenreeks. Voorbeelden zijn: “A”, “Brood”.
Ook cijfers of andere tekens kun je in een string opnemen: “[email protected]”,
“4HA”, “123”.
Je ziet dus dat 123 als getal is op te slaan (je kunt er dan mee rekenen), maar ook als
tekenreeks. In het laatste geval zijn het dus drie tekens '1', '2' en '3' die je achterelkaar
plakt.
Je kunt strings ook achteraf achterelkaar plekken met de opdracht +. Bij strings
betekent + dus niet optellen, maar achterelkaar plakken.
Zet het teken 'A' in de string S
S=”A”
Zet het woord “Brood” in de string S
S=”Brood”
Zet 'niets' in S (je niet dit een lege string) S=””
Plak twee strings achterelkaar
S=”Hallo ” + “wereld”
Je kunt strings ook met elkaar vergelijken. In Basic en Delphi ziet dat er als volgt uit:
Basic
If s=”A” Then
Schrijf(“De eerste letter van het alfabet”)
Delphi
If s='A' Then
Schrijf('De eerste letter van het alfabet');
Het enige echte verschil is dat in Basic een dubbel aanhalingsteken gebruikt wordt en
in Pascal/Delphi een enkel aanhalingsteken.
Je kunt ook controleren of een string voor of na een andere string in het woordenboek
zou komen te staan.
Basic
S=”Aap”
If S<”Brood” Then
Schrijf(“Aap staat voor Brood in het woordenboek”)
Else
Schrijf(“In dit geval wordt deze regel niet uitgevoerd”)
Endif
A<B
A voor B in het woordenboek
A=B
A en B gelijk
A>B
A na B in het woordenboek
Je kunt zo'n vergelijking tussen twee variabelen maken:
Basic
C=”IJ”
A=”H”+C
B=”Z”+C
If A<B Then Schrijf(A+”staat voor ”+B+” in het woordenboek)
Zie de noot onderaan deze bladzijde6
Opdracht 18
In je boek staat op bladzijde 46 een stroomdiagram voor de conversie van een
getal van het decimale naar de binaire talstelsel. Maak een NSD dat hetzelfde
algoritme beschrijft als het stroomdiagram.
Hint 1: Gebruik de functie Odd() die eerder in deze opdracht al gebruikt werd.
Hint 2: Je moet iets vooraan schrijven. Dat is iets anders dan de gewone schrijf
opdracht Schrijf(). Je kunt dat oplossen door de tekensreeks die je op het scherm
wilt schrijven in het geheugen opbouwt. Je hebt bij deze opdracht dus een
geheugenplek nodig waarin je geen getallen, maar zogenaamde strings bewaard.
Bewaar je NSD onder de naam binair.nsd
Opdracht 19 (moeilijk!)
Maak een NSD van een programma dat van een ingelezen getal bepaald of het
een priemgetal is. Een priemgetal is een getal dat alleen deelbaar is door 1 en
zichzelf.
Je mag bij deze opdracht ook de waarden True en False aan een variabele
toekennen. Bijvoorbeeld:
RoodIsEenKleur=True
WitIsEenDag=False
Soms schrijven we strings (Bijvoorbeeld Schrijf(“Hallo”)) en soms getallen (Schijf(123). In
echte programmeertalen is er een duidelijk verschil. Het getal 123 moet namelijk eerst worden omgezet
in de string “123”. Dat gebeurt in Basic met de functie Str (Je schrijft dan Schrijf(Str(123)) en in
Delphi met IntToStr (Schrijf(IntToStr(123))
6
Hint: Als een getal D een deler van G is moet de uitkomst van de deling ene
geheel getal zijn. Een getal is een geheel getal als X-int(X)=0. Bijvoorbeeld:
X=2.3, 2.3-int(2.3)=2.3-2=0.3
Bewaar je NSD onder de naam priem.nsd.
Extra opdrachten
3*n+1
Deze opdracht is alleen met een while-lus te maken.
Bij een for-lus moet je weten hoe vaak de lus doorlopen moet worden en dat weet je
hier niet.
Antwoorden
opdracht 1
4
opdracht 2
Bijvoorbeeld B<>0, B>0, B<0, B>2
Onjuist is bijvoorbeeld: B<2, B>-2,
opdracht 3
Drie keer (nl. voor A=3, A=2 en A=1, daarna is A=0 en wordt de lus afgebroken).
opdracht 3b
In beide gevallen naar regel 2. De spronginstructie is dus totaal overbodig.
opdracht 3c
We zijn bij de laatste instructie aangeland. Het programma is dus klaar.
opdracht 4a
10,9,8,7,6,5,4,3,2,1
opdracht 5
Teller=0
opdracht 5b
In dit stappendiagram gebruiken we ALS teller>0.
1
2
3
4
5
6
Teller=10
ALS Teller>0 JUMP 4
Halt
Schrijf(Teller)
Teller=Teller-1
JUMP 2
Je kunt de opdracht Schrijf() niet meteen op regel 3 schrijven. In het onderstaande
voorbeeld is dat wel gedaan.
1
2
3
4
5
Teller=10
ALS Teller>0 JUMP 3
Schrijf(Teller)
Teller=Teller-1
JUMP 2
Als je de lus wel meteen na ALS Teller wilt laten beginnen moet je Als Teller<=0
gebruiken.
1
2
3
4
5
6
opdracht 6a
1,2,3,4,5,6,7,8,9,10
Teller=10
ALS Teller<=0 JUMP 6
Schrijf(Teller)
Teller=Teller-1
JUMP 2
Halt
opdracht 6b
1
2
3
4
5
Teller=1
Schrijf(Teller)
Teller=Teller+1
ALS Teller<=10 JUMP 2
Halt
opdracht 7a
10,9,8,7,6,5,4,3,2,1
opdracht 7b
1
2
3
4
5
Teller=10
Schrijf(Teller)
Teller=Teller-1
ALS Teller>0 JUMP 2
Halt
opdracht 8
Bij een while bepaald de voorwaarde of je de lus (nog) een keer gaat uitvoeren. Bij
een repeat bepaald de voorwaarde of je het herhalen van de lus gaat afbreken.
opdracht 9
while
for
repeat
x:=0
while x<5 Do Begin
y:=x*x;
Schrijf(y);
x:=x+1;
End;
For x:=0 to 4 do begin
y:=x*x;
schrijf(y);
end;
x:=0;
Repeat
y:=x*x;
schrijf(y);
x:=x+1;
until x>4;
opdracht 10
nsd bijvoegen
opdracht 11
nsd bijvoegen
opdracht 12
opdracht 13
opdracht 14
opdracht 15
opdracht 16
opdracht 17
Hieronder staan drie mogelijke oplossingen
Bij het linker diagram:
Lees de start- en eindwaarde in.
Bewerken van al deze getallen de wortel, zet die in Y.
Als Y=Int(Y) is Y een geheel getal (Je mag ook zeggen Y-Int(Y)=0).
In dat geval schrijven we het getal op het scherm.
Bij het middelste diagram:
Van het start- en eindgetal wordt de wortel berekend. Hiervan wordt de gehele waarde
genomen.
Dus als de getallen 1 en 10 zijn wordt 1 en 3.1 berekenend. Dat wordt 1 en 3.
Van deze drie getallen wordt het kwadraat berekend: 1, 4 en 9.
Bij het rechter diagram:
Er zit een probleempje in dit NSD: als het startgetal 2 is, is de wortel 1.4 en dat wordt
1 als je de gehele waarde hier van neemt. De berekening begint dus bij 1, terwijl het 2
moet zijn.
In het derde NSD is dat opgelost. Bij het eindgetal doet zich dat probleem overigens
niet voor!
Opdracht 18
opdracht 19
of (Dit programma kijk meteen ook of Getal>2 is!)