For loop-parameteren godtar verdier. Matriser
Generelt sett vil vi i dag lære mer om hver av syklusene i Pascal og se hvordan de er definert. Vi ordner det mens loop med forutsetning, for loop med parameter Og gjenta - til løkke med postcondition.
1. Sløyfe med en parameter i Pascal - FOR
FOR-løkken setter en viss betingelse som programmet vil fungere under før det kjøres. La oss si at vi må gå i løkke 5 (eller n) ganger, så kan dette enkelt gjøres ved å bruke denne løkken. FOR-løkken har et karakteristisk trekk - en teller, som vanligvis er betegnet med bokstaven i eller j.
Utseendet til en løkke med en parameter i Pascal:
for i:= 1 til n gjør // tilordne i først til en, deretter til to, tre, ..., n
Etter 1. passering tildeler vi 1 til variabelen i, etter den andre tildeler vi 2, og så videre til vi når n. til - dette er opp til.. i stigende rekkefølge, det er også ned til - opp til.. i synkende rekkefølge.
Blokk - syklusdiagram med parameter:
2. Sløyfe med forutsetning i Pascal - MENS
En sløyfeoperatør med en forutsetning utfører handlinger et ukjent antall ganger. Sløyfen avsluttes hvis et logisk uttrykk eller resultatet viser seg å være usant. Siden gyldigheten til det logiske uttrykket kontrolleres i begynnelsen, kan det hende at løkkens kropp ikke utføres en gang.
Løkkestruktur med forutsetning:
Mens du begynner slutt;
Et logisk uttrykk hvis sannhet kontrolleres i begynnelsen av utførelsen av den sykliske operatoren;
Eventuelle kjørbare språksetninger.
Rekkefølge for løkkeutførelse:
Mens betingelsen er sann, utføres løkkens kropp. Så snart tilstanden blir falsk, stopper utførelsen av sløyfen.
Blokkdiagram over en syklus med en forutsetning:
Merk: rektangulære blokker viser enhver handling som utføres i løkken eller etter den (løkketrinn), mens ovale blokker viser begynnelsen eller slutten av hele programmet eller deler av det. Hovedrollen i dette blokkdiagrammet spilles av dens sentrale del.
Eksempel:
Oppgave: regn ut summen av serien 1+1,5+2+2,5+3+3,5+ .. + 30
program eksempel-mens;
Var sum:real; n:ekte; BEGIN sum:=0; n:=1; mens n
3. Løkke med postcondition - Gjenta - til.
Denne operatøren ligner på sløyfeoperatøren med en forutsetning, men skiller seg fra den ved at tilstanden kontrolleres etter at sløyfens kropp (handlinger) er utført. Dette sikrer at det utføres minst én gang, i motsetning til tidligere analyserte løkker.
Vær oppmerksom på at denne sløyfeoperatøren forutsetter at det er flere setninger i løkkens kropp, det vil si at flere handlinger kan utføres, så start- og slutttjenesteordene er ikke nødvendig.
Sekvensen av operatører som er inkludert i løkkens kropp, utføres én gang, hvoretter betingelsen skrevet etter tjenesteordet Til, blir sjekket. Hvis betingelsen ikke er oppfylt, avsluttes sløyfen. Ellers gjentas løkkens kropp igjen, hvoretter tilstanden kontrolleres igjen.
Blokkdiagram av en syklus med en postbetingelse:
Opptaksformat, syklusstruktur:
GJENTA TIL;
Eksempel:
Programtest2; Var b:Ekte; Begynn b:=100; Gjenta b:=b/2; Inntil b
Konklusjoner:
1. En sløyfe med en parameter bruker en variabel kalt en sløyfeparameter eller teller. Før sløyfen utføres, settes parameteren (telleren) til startverdien. Etter å ha fullført et loop-trinn, økes parameterverdien med én. Sløyfen fortsetter til parameteren når sin endelige verdi, som er indikert etter til (ned til).
2. Forutsetningssløyfen kjører til utførelsesbetingelsen blir falsk og fortsetter hvis betingelsen er sann.
3. Sløyfen med en postbetingelse utføres til betingelsen blir sann, hvis betingelsen er usann, fortsetter loopen.
Mål: gi konseptet sykluser med en parameter, blokkskjemaer som viser slike sykluser. Lær å tegne blokkskjemaer og programmer med løkker ved å bruke spesifikke eksempler; gi en idé om forskjellene mellom løkker med en forutsetning, en postbetingelse og en løkke med en parameter; lære hvordan du bruker forskjellige løkker i ett program hvis programmet inneholder flere løkker; skriv inn og utfør programmer ved hjelp av BPW- eller Turbo Pascal-kompilatorer.
1. Operatør løkke for ... å ... gjøre ...Noen ganger vet du på forhånd hvor mange ganger loopen skal utføres. For problemer av denne typen har Pascal-språket operatører løkker med parametere
.
Formatet for opptak av slike operatører er som følger:
til<syklus par.> := <Opprinnelig verdi> til<endelig verdi.> gjøre <operatør>.
Her til, til, gjøre- reserverte ord (for, å, utføre);
<damp. syklus> - loop parameter - en variabel av typen heltall (mer presist, hvilken som helst ordinær type);
<begynnelse verdi.> - startverdi - et tall eller uttrykk av samme type;
<lure. verdi.> - sluttverdi - et tall eller uttrykk av samme type;
<operatør> er en vilkårlig Pascal-operatør.
Hvis det er flere operatører, så som i operatøren samtidig som... gjør ..., operatørbraketter brukes: begynne ... slutt.
For eksempel er følgende sløyfeoperatøroppføringer mulige:
til i:=a til b gjøre s1;
til j:=a til b begynne s1; s2; ..., sn slutt; eller
til k:=p til m gjøre
begynne
s1;
s2;
...
sn
slutt;
Her er s1, s2, s3, ... sn sløyfeoperatorer.
Når du utfører uttalelsen til først blir uttrykket evaluert<Opprinnelig verdi.> og tilordne verdien til loop-variabelen
<syklus par.> := <begynnelse verdi.>.
Etter dette gjentar de syklisk:
1) sjekke tilstanden<syklus par.> <lure. verdi.>; hvis vilkåret ikke er oppfylt, operatøren til fullfører arbeidet;
2) utførelse av erklæringen<operatør> eller operatorer s1; s2; s3; ...sn;
3) loop variabel<damp. syklus> øker med én.
Vi må umiddelbart merke det at det er umulig å sette et annet loop-trinn enn 1 i denne setningen.
Grafisk fremstilling av sykluser til vil være slik (se fig. 33):
Ris. 33
Her: i er en løkkevariabel; n er dens begynnelsesverdi; k er dens endelige verdi. Syklusens kropp består av en operatør eller flere operatører: s1; s2; ... sn;, som er tegnet i et rektangel.
For å illustrere operatørens arbeid til La oss vurdere et eksempel som allerede har blitt tradisjonelt når vi studerer arbeidet til denne operatøren.
Eksempel 1. Lag et program for å beregne faktoren til tallet n, dvs. n!.
La oss huske fra matematikken at faktoren til tallet n er lik produktet av tallene fra 1 til n.
For eksempel:
Z Merk . I matematikk er det akseptert: 0! = 1.
Blokkdiagram
Ris. 34
Program
Program Problem1; (Beregner faktorialet til n!)
bruker WinCrt;
var
n, f, i: longint;
begynne
f:= 1;
hvis n<> 0 deretter til i:= 1 til n gjøre f:= f*i;
slutt.
Variabel n - for et tall som er angitt av brukeren, hvis faktor må finnes; f er variabelen som vil inneholde " akkumulere" Verdien av faktoren til tallet n; i er en løkkevariabel.
Startverdien til variabelen f:= 1 er satt.
Så begynner syklusen. Variabelen i tildeles startverdien 1; den sammenlignes med den siste - n (1<= n), Hvis tilstanden er sann, Deretter operatøren utføres (det er bare én i dette programmet): f:= f*i, 1*1=1; verdien av løkkevariabelen økes med 1, dvs. den blir lik: i:= i + 1, 1 + 1 = 2 og løkken gjentas.
Når verdien av i vil bli lik n, Deretter sløyfen vil kjøre en siste gang fordi den neste verdien av i vil være n + 1, som er større enn den endelige verdien av n, betingelse Jeg<= n - falsk, løkken utføres ikke.
2. Sløyfeoperatør for ... ned til ... gjøre ...
Det er en annen form for løkkeoperatøren til:
til<par.syklus.> := <begynnelse zn.> ned til <lure. zn.> gjøre <operatør>.
Erstatter et reservert ord til på ned til betyr at loop parameter trinn er (-1).
Parameterverdien endres fra en større verdi til en mindre, dvs.
<begynnelse verdi.> <lure. verdi.>.
Et program for å beregne faktoren til et tall kan skrives ved hjelp av denne sløyfeoperatoren.
Program
Program Problem1a;
bruker WinCrt;
var
n, i, f: longint;
begynne
write("Skriv inn et naturlig tall"); readln(n);
f:= 1;
hvis n<> 0 deretter til i:=n ned til 1 gjøre f:= f*i;
writeln("Faktualiseringen av ", n, " er ", f)
slutt.
1. Endre programmet slik at det ikke viser en tabell med kvadrater av tall fra 1 til n, men kvadratet av bare ett tall n, angitt av brukeren.
2. Endre og utvide programmet slik at det gir verdien av kvadratet av tallet og de oddetallene hvis sum er lik.
3 . Fortsetter temaet å heve naturlige tall til potenser, uten multiplikasjonsoperasjoner, la oss vurdere to flere interessante eksempler. I den første av dem må vi kombinere, " investere"to sykluser inn i hverandre til, og i den andre, sykluser til Og gjenta.
Eksempel 3. Terningen til ethvert naturlig tall n er lik summen av n oddetall som følger i rekkefølge tallene hvis sum var kuben til det forrige tallet n - 1:
13 = 1
23 = 3 + 5
33 = 7 + 9 + 11
43 = 13 + 15 + 17 + 19
. . . . . . . . . . . . . . . . . . . . . .
Basert på denne egenskapen, lag et program som lar deg skrive ut en tabell med kuber av naturlige tall.
Her trengs det allerede to sykluser. Den ene er ekstern
, i henhold til antall oddetall, som er lik tallet som blir kubert, for eksempel for 43 bør denne løkken utføres 4 ganger. I samme syklus, etter å ha beregnet summen, vil det være nødvendig å vise verdien på skjermen sammen med tallet som er kubert.
Den andre er intern
, som summerer oddetallene og " utvikle"krever oddetall for summering.
Blokkdiagram
Ris. 36
Program
Program Problem 3; (Kuber av naturlige tall fra 1 til n)
bruker WinCrt;
var
i, j, n, s, k: longint;
begynne
writeln("Skriv inn det naturlige tallet som skal nås");
write("skriv ut kuber av tall"); readln(n);
writeln("Tallkubene er som følger:");
k:= 1;
til i:= 1 til n gjøre
begynne
s:= 0;
til j:= 1 til Jeg gjøre
begynne
s:= s + k;
k:= k + 2
slutt;
writeln("Terningen av tallet ", i, " er lik ", s)
slutt
slutt.
La oss se på hvordan dette programmet fungerer
Variablene i og j er nødvendig som variabler for de første - ytre og andre - indre løkkene. Variabelen k er for oddetall, og s er for summen av tall. Typen av disse variablene er satt til heltall, men longint, siden det kan være ganske store heltall større enn 32767.
Programmet begynner med en forespørsel om at brukeren, ved å bruke skrive- og skriveoperatorene, legger inn et naturlig tall, før det er nødvendig å lage en tabell med kuber av tall. Denne verdien legges deretter inn i datamaskinens minne ved hjelp av readln-setningen og tilordnes til variabelen n.
Meldingen " Terningene av tall er som følger". Det er gitt før starten av løkkene av åpenbare grunner. Det kan ikke gis i løkker - det vil bli gjentatt flere ganger. På slutten av løkkene vil det også bli skrevet nedenfor, etter at tallene selv er skrevet ut Variabelen k er tildelt den første oddeverdien 1.
Den ytre løkken begynner basert på antall tall, fra 1 til n. Det er flere utsagn i løkken, så " åpen" operatørparentes: - begynne...
Før starten av den indre sløyfen tilbakestilles variabelen s - summen - til null. Dessuten vil en slik tilbakestilling skje hver gang utvendig
løkke, før du utfører den indre løkken.
Den indre løkken går fra 1 til i. Hvorfor? Sløyfen beregner summen og øker oddetall k med 2, dvs. " blir produsert" neste oddetall.
Legge merke til!
Variabelen k er ikke tildelt før starten av hver indre sløyfe 1. Hvorfor?
Den neste skriveerklæringen inne i den ytre løkken skriver ut informasjon til skjermen. Hvorfor er den plassert i den ytre løkken?
Eksempel 4. Fra matematikken er det kjent at hver naturlig potens av tallet n er summen av n påfølgende oddetall. Skriv et program som, for enhver potens av et naturlig tall n, vil finne en sekvens av oddetall hvis sum er lik denne potensen.
For eksempel, for 53 vil det produsere tallsekvensen: 21, 23, 25, 27, 29.
Programmeringsplan
1. La oss bestemme formålet med å lage programmet: det er nødvendig forestilling
, som egentlig er enhver naturlig potens av et naturlig tall Kan
representere det som en sum av påfølgende oddetall.
Og hvis dette er tilfelle, må vi absolutt vite verdien av potensen til n med eksponent k.
Dette kan gjøres med en enkel sløyfe:
s:= 1;
til i:= 1 til k gjøre s:= s*n;
Verdien av graden vil bli akkumulert i variabelen s for dette, er dens opprinnelige verdi satt til 1.
I en sløyfe multipliseres verdien av variabelen s sekvensielt k ganger med potensen av n. Etter å ha utført løkken, vil variabelen s motta verdien av potensen til n med eksponent k.
2. Hele det haster med spørsmålet ligger i det faktum at det første oddetall er ukjent, hvorfra summeringen av påfølgende oddetall må begynne.
For dette trenger du prøve
legg til oddetall først fra 1 og utover (tallet deres er kjent - n);
1 + 3 + 5 + 7 + 9 ...,
og kontroller deretter resultatet oppnådd ved å sammenligne det med verdien av graden s. Hvis likheten er sann, avslutt sløyfen og vis de resulterende oddetallene på skjermen hvis likheten ikke er sann, må du starte summeringen fra det neste oddetall - 3: 3 + 5 + 7 + 9. .. etc.
Denne prosessen er lettere å organisere ved hjelp av en løkke gjenta. Variabelen j, som vil spesifisere de innledende oddetallene, må settes til startverdien 1 før starten av loopen.
Generelt syn på en slik syklus:
j:= 1;
gjenta
. . . . . .
j:=j+2
før...= s;
3. Det gjenstår å tenke på hvordan man beregner summene av påfølgende oddetall. Vi har allerede møtt dette spørsmålet, og vi vet at for dette må vi lage en syklus fra 1 til n, der denne mengden må akkumuleres i en av variablene, si m, og den andre variabelen må " utvikle" neste oddetall.
Denne syklusen kan skrives slik:
p:= j; m:= 0;
til i:= 1 til n gjøre
begynne
m:= m + p;
p:= p+2
slutt;
Merk!
Variabel p, hver syklus gjenta, (eksternt til den gitte), vil motta en ny startverdi av oddetall, og variabelen m - for summen må tilbakestilles før hver ny summering for en annen sekvens av oddetall.
4. Til slutt, når sekvensen av oddetall er funnet, må den vises på skjermen. For å gjøre dette må vi arrangere en annen løkke fra 1 til n, der vi vil gi ut verdiene til disse oddetallene. For det første odde tallet i sekvensen må vi ta verdien j, men siden den allerede har økt med 2, bør vi trekke 2 fra j.
j:= j - 2;
til i:= 1 til n gjøre
begynne
skriv(j, " ");
j:=j+2
slutt
Blokkdiagram
Ris
. 37
Program
Program Problem4;
bruker WinCrt;
var
n, i, k, j, m, s, p: longint;
begynne
write("Skriv inn et naturlig tall - grunnen av potensen "); readln(n);
write("Skriv inn et naturlig tall - eksponent "); readln(k);
s:= 1; j:= 1;
til i:= 1 til k gjøre s:= s*n;
gjenta
p:= j;
m:= 0;
til i:= 1 til n gjøre
begynne
m:= m + p;
p:= p+2
slutt;
j:=j+2
før m=s;
write("Kraft med base", n);
writeln(" og eksponent ", k, " dvs. ", s);
writeln("lik summen av følgende oddetall");
j:= j - 2;
til i:=1 til n gjøre
begynne
skriv(j, " ");
j:=j+2
slutt
slutt.
For bedre å forstå funksjonen, ta strøm 25 og sjekk hvordan programsetningene vil bli utført sekvensielt.
1 . Kjør dette programmet på datamaskiner.
2
. Lag et flytskjema og et program som avgjør om et verk kan
a) tre; b) fire påfølgende naturlige tall er lik en potens av et naturlig tall (kvadrat, terning, etc.)?
4. Ulike oppgaver
Eksempel 5. Skriv ut alle firesifrede tall hvis desimalnotasjon ikke har to identiske sifre.
Kommentar . Før du begynner å lage et flytskjema for denne oppgaven, bør du vite hvordan løkker i løkker er avbildet for løkker med parametere. Den generelle konstruksjonen av to nestede løkker med parametere vil være slik:
Ris. 38
Ideen oppstår umiddelbart om å lage et program i henhold til følgende skjema:
organisere syklus etter antall tusener, t fra 1 til 9, og deretter internt sykluser: etter antall hundrevis, s fra 0 til 9; etter antall tiere, d fra 0 til 9; etter antall enheter, e fra 0 til 9; tilstandssjekk: Hvis tallene er forskjellige Deretter vise et firesifret tall som består av dem på skjermen.
Blokkdiagram
Ris. 39
Program
Program Problem5; (Første metode)
bruker WinCrt;
var
t, s, d, e: heltall;
begynne
til t:= 1 til 9 gjøre
til s:= 0 til 9 gjøre
til d:= 0 til 9 gjøre
til e:= 0 til 9 gjøre
hvis(t<>s) og(t<>d) og(t<>e) og(s<>d) og
(s<>e) og(d<>e)
deretter skriv(t*1000 + s*100 + d*10 + e, " ")
slutt.
Det er tydelig at dette programmet ble implementert irrasjonelt. I den utføres alle sykluser fullstendig.
Programmet kan forbedres på denne måten. Når hundrer-syklusen er utført, må den neste ti-syklusen startes, Hvis
hundresifferet s er ikke lik tusensifferet t, ellers, ellers
, må syklusen av hundrer fortsettes, dvs. ta neste siffer av hundre.
For tiersifferet, sett også betingelsen om at neste enhetsløkke skal utføres, Hvis
titallet d er ikke lik hundre- og tusensifrene, ellers ellers
, må du gå videre til neste ti-siffer.
Og så, " innsiden" syklus av enheter, er det nok å skrive betingelsen, Hvis
enhetssifre e er ikke lik titallet d, hundrevis s og tusenvis t, da er det firesifrede nummeret ønsket og det vises på skjermen.
Blokkdiagram
Ris . 40
Program
Program Oppgave5a; (andre metode)
bruker WinCrt;
var
t, s, d, e: heltall;
begynne
writeln("Alle firesifrede tall fra forskjellige sifre");
til t:= 1 til 9 gjøre
til s:= 0 til 9 gjør hvis s<>t deretter
til d:= 0 til 9 gjør hvis(d<>s) og(d<>t) deretter
til e:= 0 til 9 gjøre
hvis(e<>d) og(e<>s) og(e<>t)
deretter skriv((((t*10 + s)*10 + d)*10) + e, " ")
slutt.
Oppgave 4
1. Legg til og endre dette programmet slik at det ikke bare viser de forskjellige firesifrede tallene, men også deres nummer.
2. Når du multipliserte et firesifret tall som består av forskjellige sifre med 9, produserte produktet et tall som skilte seg fra multiplikaanden bare ved at det var en null mellom sifrene på tusener og hundre. Finn multiplikanet. Lag et flytskjema og program.
Eksempel 6. Tripler av naturlige tall a, b, c, som tilfredsstiller likheten: - kalles pytagoreiske tall.
For eksempel er 3, 4 og 5 Pythagoras tall fordi
Skriv et program for å finne og skrive ut alle Pythagoras tall som ikke overstiger 20.
Matematikken bak dette spørsmålet er enkel. For tallene a, b og c er de mulige verdiene naturlige tall fra 1 til 20.
Startverdien til a er én, a = 1. Vi vil se gjennom alle mulige verdier av b fra 1 til 20, samt verdier av c fra 1 til 20 og sjekke likheten a a + b b = c c . Når likestillingen er oppfylt, viser du verdiene til a, b og c.
Deretter må du ta verdien a = 2 og sjekke verdiene til b fra 2 til 20. Hvorfor ikke fra 1, men fra 2? Ja, fordi settet med to tall fra 1 og 2 allerede har blitt vurdert med verdiene a = 1 og b = 2, for ikke å gjenta verdiene til a og b, dvs. for å unngå utseendet til to identiske tallpar, bør verdiene til b begynne å vises eller til verdien en eller fra en til 20.
I denne forbindelse er det flere mulige måter å organisere løkker for variablene a og b.
1. metode:
til a:= 1 til 20 gjøre
til b:=a til 20 gjøre
2. metode:
til a:= 20 ned til 1 gjøre
til b:= 1 til en gjøre
3. metode:
til a:= 1 til 20 gjøre
til b:= 1 til en gjøre
Det er lett å se at med hver av disse metodene vil ikke tallpar gjentas. Sjekk det ut selv.
For verdier av c er vi pålagt å sjekke alle naturlige tall fra 1 til 20 for hvert tallpar a og b. Så løkken for c bør være slik: til c:= 1 til 20 gjøre
Blokkdiagram
Ris . 41
Program
Program Problem6;
bruker WinCrt;
var
a, b, c: heltall;
begynne
writeln("Trippel av pythagoras tall fra intervallet ");
til a:= 1 til 20 gjøre
til b:= 1 til en gjøre
til c:= 1 til 20 gjøre
hvis a*a + b*b = c*c deretter writeln(a, "", b, "", c)
slutt.
1. Lag et blokkdiagram og et program som finner alle løsninger på likningen der n er et gitt tall, fra intervallet .
2. Finn alle naturlige x fra intervallet der uttrykket er kvadratet av et naturlig tall.
Eksempel 7. På hvor mange måter kan et gitt naturlig tall n representeres som summen av to kuber av naturlige tall:
Omorganisering av vilkårene gir ingen ny metode. Operasjonen med å heve til styrken 1/3 kan ikke brukes.
Følgende enkle idé for å lage et program oppstår umiddelbart.
Organiser to løkker, den ene er en ytre løkke med variabel i fra 1 til n, og den andre er en indre løkke i j, også fra 1 til n.
Essensen av programmet vil være som følger:
den første verdien av i er 1, den multipliseres tre ganger med seg selv (dette erstatter å heve til 3. potens);
deretter " beveger seg" alle verdier av j fra 1 til n, som hver også multipliseres tre ganger med seg selv og legges til verdien i i i, dvs. i kubert;
videre sjekkes denne summen for å se om den er lik verdien n, hvis likheten er sann, så økes telleren, som åpenbart er definert i programmet, med 1, og verdiene til i og j kan vises på skjermen;
sløyfen gjennom i fortsetter, i tar på seg den andre verdien - 2, og den indre sløyfen gjennom j fra 1 til n begynner å kjøre igjen, og så videre.
Hvis vi lager et program i henhold til denne planen, vil det ha to betydelige ulemper:
1) mye ubrukelig arbeid blir gjort - begge løkkene er organisert fra 1 til n, og det er mange unødvendige blant dem (det er nok å ta verdier fra 1 til terningroten av n);
2) programmet vil produsere verdier som oppnås ved å omorganisere begrepene, for eksempel: 2 2 2 + 3 3 3 = 35 og 3 3 3 + 2 2 2 = 35, noe som er uakseptabelt i henhold til forholdene til problemet . Hvordan eliminere disse manglene?
Vi kan eliminere den første ulempen hvis vi først finner ut hvor mange verdier for hvert av tallene som må vurderes for at ulikheten skal holde
For å gjøre dette kan du organisere en løkke med en forutsetning, en løkke " Ha det
", for å inkludere en teller - k, som vil telle hvor mange ganger en slik sløyfe vil bli utført.
Dette kan gjøres slik:
k:= 0; i:= 1;
samtidig som i*i*i + 1<= n gjøre
begynne
k:= k + 1;
i:= i + 1
slutt;
Nå kan du redusere antall sykluser for " fag" tall og organiser dem fra 1 til k, fordi for verdier av i større enn k, selv for den minste verdien av j (j:= 2) ulikheten i i i + 1<=n не выполняется.
For å eliminere den andre ulempen, det vil si for ikke å produsere alternativer med omorganisering av vilkår, kan du gjøre dette:
ordne den ytre løkken for i av det første tallet fra k til 1, og lag den indre løkken for det andre tallet for j fra 1 til i. Du får denne delen av programmet:
p:= 0;
til i:=k ned til 1 gjøre
til j:= 1 til Jeg gjøre
hvis i*i*i + j*j*j = n
deretter
begynne
p:= p + 1;
slutt;
Se nøye på denne delen av programmet og tenk på hvorfor vi i dette tilfellet unngår å gjenta alternativer og ekskluderer tilfeller av omorganisering av vilkår?
Venstre Vakker fullføre programmet. Tross alt, veldig ofte vil det være tilfeller der et tall ikke kan representeres i det hele tatt som summen av kubene av to tall. Denne omstendigheten må også tas i betraktning.
For å gjøre dette, etter å ha utført alle løkkene, vil vi introdusere en betinget operatør der, avhengig av verdiene til telleren p, vil de tilsvarende meldingene bli utstedt.
Hvis
p = 0, Deretter
vise en melding om at tallet ikke kan representeres som summen av kubene av to tall, og ellers, viser en melding om antall måter.
Denne delen av programmet kan kjøres slik:
hvis p = 0
deretter
begynne
slutt
ellers
Blokkdiagram
Ris
. 42
Program
Program Problem7;
bruker WinCrt;
var
i, j, n, k, p: longint;
begynne
write("Skriv inn et naturlig tall"); readln(n);
k:= 0; i:= 1;
samtidig som i*i*i + 1<= n gjøre
begynne
k:= k + 1; i:= i + 1
slutt;
p:= 0;
til i:=k ned til 1 gjøre
til j:= 1 til Jeg gjøre
hvis i*i*i + j*j*j=n
deretter
begynne
p:= p + 1;
writeln(i, "*", i, "*", i, "+", j, "*", j, "*", j, "=", n)
slutt;
hvis p = 0
deretter
begynne
write("Tallet", n, " kan ikke representeres som ");
writeln("summen av terninger av to tall")
slutt
ellers writeln("Antall måter er ", p)
slutt.
En annen løsning på dette problemet
Program Oppgave 7b;
bruker WinCrt;
merkelapp 1, 2;
var
i, j, m, k, n: longint;
begynne
write("Skriv inn et naturlig tall"); readln(n);
m:= 0; i:= 1; j:= 1;
samtidig som j*j*j + 1< n gjøre j:= j + 1;
gjenta
k:= i*i*i + j*j*j;
hvis k = n deretter m: = m + 1;
hvis k<= n deretter i:= i + 1;
hvis k >= n deretter j:= j - 1;
før i > j;
hvis m = 0 så gå 1;
write("Tallet ",n," kan representeres som en sum");
writeln(" kuber av to tall ",m," måter"); gå til 2;
1: write("Dette tallet kan ikke representeres");
writeln("summen av terninger av to tall");
2: slutt.
Naturlig n er gitt. Kan n representeres som summen av tre kvadrater av naturlige tall? Hvis mulig, angi alle trippel x, y, z slike naturlige tall at Omorganisering av leddene ikke gir en ny metode. Lag et flytskjema og program.
5. Skriv Konvertering
Eksempel 8. Et tosifret desimaltall lagt til et tall skrevet med de samme sifrene, men i omvendt rekkefølge, gir en komplett firkant. Finn alle slike tall.
La det ønskede tosifrede tallet = a 10 + b, så blir tallet skrevet i de samme tallene, men i omvendt rekkefølge = b 10 + a, for eksempel 12 og 21, 13 og 31 osv.
Summen av disse tallene skal gi et komplett kvadrat, dvs. det nøyaktige kvadratet av heltall. Hvordan kan jeg sjekke dette?
Kontrollen kan gjøres slik: ta kvadratroten av det resulterende beløpet; avrund deretter resultatet til et helt tall, og multipliser deretter det resulterende resultatet med seg selv, hvis summen av disse tallene igjen oppnås, betyr det at det er et nøyaktig eller perfekt kvadrat.
For eksempel, 12 + 21=33, ta kvadratroten av 33, det er lik 5,74...; runde blir det 6; gang 6 med seg selv og få 36.
Vi fikk ikke det opprinnelige resultatet, noe som betyr at summen av 33 ikke er et eksakt kvadrat.
Et eksempel til slik at du forstår ideen om løsningen. La det tosifrede tallet være 29, så er tallet skrevet med de samme sifrene, men i omvendt rekkefølge er 92, totalt gir de 121. Vi tar kvadratroten av 121 og får 11. Multipliserer 11 med seg selv, får vi igjen 121. Vi konkluderer med at vi har fått et nøyaktig kvadrat, som betyr at det tosifrede tallet 29 er det ønskede.
For å skrive et program som bruker dette prinsippet, må du ta kvadratroten av summen, noe som kan gjøres ved å bruke standard sqrt(x)-funksjonen. Resultatet av sqrt(x)-funksjonen er et reelt tall, det må avrundes eller forkastes, og vi vet ikke hvordan vi gjør dette.
Men enda viktigere er det at hvis kvadratroten i settet med heltall tas i sin helhet, som for 121 (det er lik 11), vil vi i settet med reelle tall strengt tatt ikke få tallet 11, men resultatet vil være veldig nær 11 og etter å ha multiplisert med seg selv vil det fortsatt ikke gi 121, dvs. behovet oppstår konvertere
reell verdi til heltall.
Så vi har to oppgaver: 1) finne ut hvordan man runder tall og; 2) etablere hvordan du konverterer en reell type til et heltall.
For dette formålet har Pascal standardfunksjoner rund(x) og trunc(x)
Standard funksjoner rund Og trunc er ment å erstatte verdier av en reell type med verdier av en heltallstype.
Funksjon rund(x) runder av det reelle tallet x til et heltall - verdien er det nærmeste heltall:
rund(4.2) = 4, rund(4.7) = 5, rund(4.5)=5,
rund(-4.2) = -4, rund(-4.7) = -5, rund(-4.5) = -5.
Funksjon trunc(x) forkaster (uten å avrunde) brøkdelen av det reelle tallet x:
trunc(1.2) = 1, trunc(5.8) = 5, trunc(-1.2) = -1,
trunc(-5.8) = -5, trunc(-6.7) = -6, trunc(8,9) = 8
Avrundingsfunksjonene er relatert slik:
trunc(x + 0,5) = rund(x), Hvis
x 0,
trunc(x - 0,5) = rund(x), Hvis
x< 0.
Så du kan bruke en av disse funksjonene i programmet. Hvilken? Tenk selv og prøv å bruke funksjonen i programmet først trunc, og deretter erstatte den med rund og sammenligne resultatene.
- For hvilken naturverdi av a vil tallet a2 + a + 1589 være et perfekt kvadrat?
- Finn et perfekt tall av formen 16p.
- Finn to tall hvis summen av kvadratene deres er 468 og summen av deres felles største divisor og minste multiplum er 42.
For loop-setningen implementerer den algoritmiske strukturen løkke med parameter(eller en løkke med en teller). For-løkken brukes når i et program, før du utfører løkkeinstruksjonene, antall trinn i denne løkken blir kjent (eller forhåndsbestemt). I et blokkdiagram er for-setningen representert som følger:
Syntaks:
for ( initialisering; betingelse; modifikasjon) (Instruksjoner for løkkekropp; )
Hvis det er én instruksjon i hoveddelen av løkken, kan ( ) utelates. Løkkeparametervariabelen (teller) kan være av hvilken som helst numerisk type. Dette gjør C++ for loop like allsidig som en while-løkke. Modifikasjonsdelen bruker oftest en postfix eller prefiks inkrement (eller dekrement) operasjon, men ethvert tilordningsuttrykk som endrer verdien til en loop parameter kan brukes. Syklusen fungerer slik:
- I begynnelsen er tellervariabelen beskrevet og initialisert
- Deretter kontrollerer du betingelsen: hvis uttrykket har en verdi ekte, vil iterasjon forekomme
- Etter å ha utført instruksjonene til løkkelegemet, endres tellerverdien
Merk: I C++ er det en regel å lage deklarasjonen av tellervariabelen i loophodet. Men dette er ikke nødvendig, spesielt hvis du planlegger å initialisere flere variabler i initialiseringsdelen som implementert i program 9.2. Bruk av en tellervariabeldeklarasjon i en loop-header resulterer imidlertid i en lokal variabeldeklarasjon som blir ødelagt automatisk når loopen avsluttes. Derfor, med mindre det er absolutt nødvendig, bør du ikke definere en tellervariabel utenfor en for-løkke.
Mens for-løkken kjører, anbefales det ikke å endre operandene i løkkehodeuttrykkene - dette vil føre til alle slags feil! Men verdiene til variabler (eller konstanter), inkludert foranderlige verdier (teller), kan brukes. La oss se på et klassisk eksempel.
Program 9.1 Gitt et naturlig tall N. Skriv ut alle divisorer av dette tallet.
#inkludere
Bruke fortsette-setningen i en for-løkke
Når du bruker fortsette-setningen i en for-løkke, må du ta hensyn til særegenhetene ved hvordan denne løkken fungerer:
- Uttalelser etter fortsett vil bli hoppet over
- Deretter endres telleren
- Gå til neste iterasjon (ellers kontroller tilstanden)
La oss vise dette med et eksempel: int main() ( for (int i = 1; i< 20; i++) { if (i % 2 == 0) continue; cout << i << " "; } 1 3 5 7 9 11 13 15 17 19
Merk. Merk: Selv om utdata av tall etter tilstand hoppes over, økes telleren. Dette eksemplet er kun for illustrative formål. Dette er ikke måten å programmere en loop på! Dette problemet løses bedre som følger:
Int main() ( for (int i = 1; i< 20; i += 2) cout << i << " ";
Flere uttrykk i initialiserings- og modifikasjonsdelen
Som vi bemerket tidligere, må lederen av for-uttalelsen ha tre seksjoner. Uttrykk i disse seksjonene kan utelates, men ";" kan ikke utelates. . Til slutt kan man bare forlate; . Overskrift i skjemaet:
For (;;) ( ... )
er overskriften til en "uendelig" løkke. (Utgangen fra sløyfen må programmeres inne i sløyfen.)
C++ støtter flere uttrykk i initialiserings- og modifikasjonsdelene av hodet til en for-setning. I dette tilfellet må betingelsen for å fortsette syklusen være en!
For eksempel. Problemstilling: Regn ut faktoren til et tall som ikke overstiger 20.
Program 9.2
#inkludere
Merk: Merk at utgangsstrømmen på linje 12 ikke er en del av sløyfen! (På slutten av tittelen - ;). Dermed har denne løkken en tom instruksjon i brødteksten, og alle uttrykk blir evaluert i overskriften. Program 9.2 beregner riktig faktoren til et tall fra 0 til 20.
rekkeviddebasert for loop
For å iterere gjennom elementene i en matrise eller beholder, må du utføre samme type handlinger og bruke tungvint kode. For å forenkle arbeid med beholdere i C++, er det en spesiell form for for-løkken - rekkeviddebasert for (løkke for rekkeviddebasert eller rekkevidde for).
Syntaks:
for ( kunngjøring : sekvensnavn) loop_statement
Bruk av rekkeviddebasert for å bruke en C-matrise som eksempel:
Program 9.3
#inkludere
For at array-elementer skal endres, må variabelen s være en referansevariabel (som i eksemplet ovenfor). Hvis variabelen ikke er en referanse, vil dataene bli kopiert. For automatisk å utlede typen bruker denne sløyfen autospesifikasjonen. områdebasert for har en begrensning når du arbeider med dynamiske matriser: den støtter ikke endring av størrelsen på matrisen, siden den inneholder en fast peker til slutten av matrisen. Når du arbeider med arrays som har en fast størrelse, er range for et utmerket og trygt alternativ til vanlig for .
Nestet for løkker
Akkurat som andre loop-setninger, støtter for en nestet loop-struktur. Å bruke nestet for loops for å organisere input og output fra todimensjonale arrays er mye mer kompakt enn å bruke en while-løkke.
Men når du løser problemer med å krysse slike matriser, er det nødvendig å unngå å bruke den betingede if-setningen. Ofte kan oppgaven implementeres mer rasjonelt ved å manipulere indeksene (løkkevariablene i og j). Det vil si å gjøre endringen i en indeks avhengig av verdien til en annen. La oss se på to eksempler.
Program 9.4 Gitt en kvadratisk matrise av størrelse n, hvis elementer er lik 0. Fyll elementene som ligger under og på hoveddiagonalen med enere.
#inkludere
Program 9.5 Skriv et program for å fylle en matrise med tall fra Pascals trekant og skriv ut denne matrisen. Pascals trekant ser slik ut: 
I denne trekanten er det en på toppen og på sidene (i program 9.5 er trekanten "lagt på siden" - sidene av trekanten er: den første kolonnen og hoveddiagonalen). Hvert tall er lik summen av de to tallene over det. Trekantens rader er symmetriske om den vertikale aksen og inneholder binomiale koeffisienter.
#inkludere
Spørsmål
- Kan for loop instruksjonen i et program erstattes av en while loop instruksjon? Kan dette alltid gjøres?
- Når er det mer praktisk å bruke for-setningen for å organisere looper? samtidig som?
- Er følgende uttrykk mulige i hodet av en for-setning: a) for (;a > b && !(a % 2);) b) for (a > b;;) c) for (;;i = 0) d) for ( ;i = 0;) e) for (;;i++, --b) f) for (--i;;) g) for (b = 0; b != a;) ?
- Variabel i er en parameter for den ytre sløyfen, og j er en parameter for den nestede sløyfen. Vil variabel j være tilgjengelig i den ytre sløyfen? jeg i en nestet løkke?
Lærebok
Hjemmelekser
- Bak 29. Skriv et program som legger inn naturlige tall en Og b, og displayet viser alle primtall i området fra en før b(algoritme idé Program 8.5)
- Bak 30. Et tall kalles perfekt hvis det er lik summen av alle dets divisorer som er mindre enn seg selv (for eksempel tallet 6 = 1 + 2 + 3). Skriv et program som legger inn et naturlig tall N og bestemmer om N er et perfekt tall.
- Skriv et program som viser en kvadratisk talltabell av størrelse n x n, med følgende form for n = 10: 1 * * * * * * * * * * 2 * * * * * * * * * 3 * * * * * * * * * * 4 * * * * * * * * * * 5 * * * * * * * * * * 6 * * * * * * * * * * 7 * * * * * * * * * * 8 * * * * * * * * * * 9 * * * * * * * * * * * 10
Litteratur
- Lafore R. Objektorientert programmering i C++ (4. utgave). Peter: 2004
- Prata, Stephen. C++ programmeringsspråk. Forelesninger og øvinger, 6. utg.: Trans. fra engelsk - M.: LLC "I.D. William", 2012
- Lippman B. Stanley, Josie Lajoie, Barbara E. Mu. C++ programmeringsspråk. Grunnkurs. Ed. 5. M: LLC "Jeg. D. Williams", 2014
- Elline A. C++. Fra lamer til programmerer. St. Petersburg: Peter, 2015
- Shildt G. C++: Grunnkurs, 3. utg. M.: Williams, 2010
Loops opptar en spesiell plass i Turbo Pascal. De begynner å studere dem umiddelbart etter å ha mestret ferdighetene til input og output av informasjon på skjermen. Tross alt kommer de fleste problemene ned på det faktum at løkker med en parameter og andre konstruksjoner bidrar til å lette skrivingen og funksjonen til en bestemt programblokk.
Typer av sykluser
Det er tre typer totalt:
- med parameteren
- med en forutsetning,
- med en postcondition.
Løkker med en parameter, ellers heter de For ... å ... gjøre eller For ... ned til .... gjør, gjenta en bestemt sekvens av handlinger mange ganger. I prinsippet brukes andre varianter til samme formål, bare i for-løkken er antall trinn kjent på forhånd.
I de to andre konstruksjonene (While og Repeat) er antall iterasjoner i utgangspunktet ukjent. Derfor, når du studerer oppgaven, er det allerede nødvendig å forstå hvilken syklus som skal brukes.
Grunnleggende definisjoner om emnet
Sløyfer med parametere er gjentatte iterasjoner. Telleren er hovedindikatoren ved hjelp av hvilken et gitt design utføres. Grensene for intervallet viser innenfor hvilke grenser visse iterasjoner vil bli utført. Forresten, det er slett ikke nødvendig at startverdien er lik 1. Brukeren setter uavhengig begge grensene for intervallet. Broppen til løkken er et sett med kommandoer der antall repetisjoner allerede er bestemt.
Konseptet med "løkker med parametere" betyr at i dette designet kontrolleres en tilstand, hvoretter et sett med iterasjoner utføres. Telleren øker (eller minker) og alt gjentas. Hoveddelen av loopen vil bli utført så lenge betingelsen er sann.
For ... å ... gjøre: driftsalgoritme, syntaks
Som allerede nevnt, brukes løkker med en parameter i oppgaver som spesifiserer "intervallet" for å arbeide. Så dette kan være en rekke tall, ukedager, linjer i et dikt, etc.
Det er 2 typer design: for å øke telleren og for å redusere den. Den første konstruksjonen vil bli skrevet som følger:
til opprinnelig variabel := grense 1 til grense 2 gjøre
løkkekropp;
Her: ref. variabel erklært av brukeren i begynnelsen av et program eller en blokk; kantlinje 1 og kantlinje 2- innledende og endelig verdi av intervallet; V kropp syklus en rekke handlinger er foreskrevet som må utføres av programmet. Det må huskes at hvis hoveddelen av løkken bare inneholder 1 kommando, kan operatørparentesene begynne...slutt utelates. I denne versjonen av designet, telleren, nemlig<исх.переменная>, vil øke i trinn på 1.
til opprinnelig variabel:= grense 1 ned til grense 2 gjøre
løkkekropp;
Her er ref. variabelen vil avta i trinn på 1.
Sløyfeoperasjonsdiagrammet med For... to... do-parameteren vil se slik ut:
- Verdien av intervallets øvre grense settes, dvs. grense 2.
- Kildevariabel parameterverdien er tildelt grense 1.
- Tilstanden blir sjekket: opprinnelig variabel ≤ grense 2.
- Etter å ha mottatt resultatet ekte (ekte) løkkens kropp utføres.
- Telleren økes med trinn lik 1.
- Trinn 3-5 utføres nøyaktig til betingelsen er sann: opprinnelig variabel > grense 2. Så snart dette skjer, går sløyfen ut og kontrollen overføres til kommandoen etter denne konstruksjonen.
I For... downto... do er driftsalgoritmen lik den ovenfor, med unntak av noen punkter:
- I 3. ledd er vilkåret kontrollert: opprinnelig variabel ≥ grense 2.
- I den femte linjen i algoritmen reduseres telleren med 1.
- I 6. ledd vil kommando 3-5 utføres inntil betingelsen er oppfylt: opprinnelig variabel< граница 2.
Alt annet er likt i begge driftsalgoritmene.
Blokkdiagram av en syklus med en parameter
Sykluser med en parameter har følgende blokkskjema (selv om det allerede er presentert ovenfor). En forenklet organisering av designet er også vist her.
Grunnleggende krav til en syklus med en parameter
Sløyfer med parametere krever visse typer forhold.
- Teller- og spenngrensene (dvs. kildevariabel, grense 1 og grense 2) må være av samme datatype. Hvis det bare er kompatibilitet mellom start- og sluttverdiene til segmentet og kildevariabelen, kan programmet oppføre seg feil fordi grensene vil bli konvertert til datatypen til kildeparameteren.
- Datatypen som parameterverdiene må tilhøre må være heltall. Det anbefales sterkt å ikke bruke den ekte typen.
- Det er ikke tilrådelig å tvinge verdien av den opprinnelige variabelparameteren i sløyfens kropp. Ellers vil brukeren ha problemer med å spore opp mulige feil som kan dukke opp.
- I motsetning til andre typer løkker, i For ... to ... do eller For ... downto ... kan ikke trinnet endres med en annen parameter enn 1.
Turbo Pascal: hvordan bryte ut av en loop
Det er ofte problemer der looping oppstår, det vil si at tilstanden som kontrolleres alltid er sann. Break-prosedyren hjelper til med å bryte ut av løkker med en precondition, postcondition og parameter. Det vil si at arbeidet deres avsluttes før tidsplanen.
Sløyfer med pascal-parametere (hvor programmeringen forutsetter den "evige" sannheten om tilstanden) kan stoppes ved å bruke Fortsett. Her er arbeidet organisert som følger: den nåværende iterasjonen avslutter utførelsen før tidsplanen, kontrollen overføres til neste kommando, men uten å gå ut av loopen.
Utgangsprosedyren er nødvendig for å fullføre arbeidet med en bestemt blokk i programkoden. Det kalles inne i en prosedyre (funksjon), og i samme øyeblikk stopper utførelsen av dette "stykket" umiddelbart. Hvis Exit er i hovedblokken til programmet, avslutter det arbeidet.
Stopp-prosedyren reduserer driftsprinsippet til følgende: programmet avsluttes fullstendig.
Eksempler på oppgaver med løsninger
Det vil være nyttig for brukeren, etter å ha studert emnet "Loops with parameters in Pascal," å først studere eksemplene og deretter trene på å skrive kode på egenhånd. Enkle oppgaver hjelper den fremtidige programmereren med å lære teori i praksis, og deretter bruke den. På emnet "Sløyfer med en parameter" kan eksempler på problemer med løsninger finnes enkle og komplekse. Her er 3 oppgaver som forklarer algoritmene og gir forklaringer og kommentarer for hver løsning.
Oppgave 1
Gitt en todimensjonal rekke naturlige tall i området , valgt tilfeldig. Finn tallet på alle tosifrede tall der summen av sifre er et multiplum av 2.
Algoritme for handlinger:
- Lag en todimensjonal matrise.
- Sjekk hvert nummer for å se om det oppfyller følgende betingelser:
a) hvis 9< Х < 100, то разделить его нацело на 10 посредством div;
b) velg det andre sifferet i et tall ved å dele via mod;
c) legg til de uthevede tallene;
d) del den gitte mengden med 2 ved å bruke mod;
e) hvis resultatet er 0, økes telleren med 1.
Oppgave 2
Gitt en endimensjonal rekke av heltallselementer. Finn antall positive tall.
Algoritme for handlinger:
- Lag en rekke heltallselementer laget av randomize.
- I en løkke med en parameter, sett inn en IF som vil sjekke det gitte elementet for samsvar med betingelsen: X>0.
- Hvis betingelsen er oppfylt, økes telleren med 1.
- Etter syklusen skal den resulterende tellerverdien vises.
Data gitt i parentes () er kommentarer. I linje 11 kan du vise matrisen på skjermen på to måter: la et mellomrom mellom tallene eller allokere et visst antall celler for hvert element (i dette tilfellet er det 5).
I linje 12 kan tellervariabelen også økes på to måter: enten ved å legge til 1 til forrige verdi, eller ved å bruke standard Inc-funksjonen.
Oppgave 3
Gitt en kvadratisk matrise. Finn antall positive elementer plassert på hoveddiagonalen.
Forklaringer:
I en rekke tall strekker hoveddiagonalen seg fra øvre venstre hjørne til nedre høyre. Dets særegne er det faktum at rad- og kolonneindeksene faller sammen. Derfor er det nok å organisere 1 løkke for å bevege seg gjennom linjene uten å telle opp de gjenværende elementene.
Algoritme for handlinger:
- Lag en firkantet matrise.
- Tilordne verdien "0" til variabelen som er ansvarlig for å telle positive elementer.
- Lag en syklus for å lage en firkantet matrise.
- Organiser en sløyfe for å sjekke tilstanden: hvis tallet på hoveddiagonalen er >0, økes telleren med 1.
- Etter at løkken er avsluttet, viser du verdien til variabelen som lagrer antall positive elementer.
Konfrontasjon mellom to programmeringsspråk: C og Turbo Pascal
Som regel kan en programmerer med respekt for seg selv flere språk. Det kan for eksempel være C++, Turbo Pascal, Delphi, Java osv. Motsetningen mellom de to kom tydelig til uttrykk tilbake på 80-tallet. (C og turbo pascal). På slutten av det tjuende århundre ble den samme kampen observert mellom C++ og Java.
I det virtuelle rommet, blant tre dusin programmeringsspråk, kan man skille mellom tre av de lyseste parene, hvis konfrontasjon overrasket de største hjernene i cyberspace: ALGOL-60 og Fortran, Pascal og C, Java og C++. Selvfølgelig er disse følelsene subjektive, men på et eller annet tidspunkt var en av paret lederen. Dette ble forklart av kravene til industrien og behovet for et bestemt programvareprodukt. På 70-tallet Fortran "styrte verden", på 80-tallet - Turbo Pascal, på 90-tallet - C++. Selvfølgelig, ingen av dem "døde". Snarere har de forvandlet seg til avanserte programvareprodukter.
Når du lærer programmeringsspråk, kan du legge merke til at noen emner har lignende syntaks. Dermed ligner løkker med en parameter i C lignende konstruksjoner i Pascal, med unntak av noen punkter.
Det er interessant at utviklerne av Turbo Pascal (Old World) brukte resultatene av utviklingen til amerikanske forskere, mens de i den nye verden aktivt brukte resultatene av forskning fra europeiske spesialister. I Europa tar utviklere mer til orde for renheten og kompaktheten til programmeringsspråk, mens amerikanske sinn er mer tilbøyelige til å bruke nymotens trender innen koding.
I de fleste programmer er det behov for å gjentatte ganger utføre en bestemt setning (eller blokk med setninger). Sløyfeoperatører kan brukes til å organisere denne typen konstruksjon. Pascal-programmeringsspråket bruker følgende typer loop-operatorer: for, while, repeat (PascalABC.NET bruker også foreach loop-operatoren).
Blokken med setninger som må utføres gjentatte ganger kalles løkkens kropp.
for operatør i Pascal
Hvis antall kroppsrepetisjoner syklus er kjent på forhånd, så brukes den for loop statement, som også ofte kalles sløyfeoperatøren med en parameter.
For-setningen består av to deler: loop-kroppen og overskriften, som er ment å beskrive start- og sluttverdiene til loop-parameteren, samt muligheten for å endre den.
Avhengig av endringsretningen for loop-parameteren (økende - til eller avtagende - ned til) i Pascal-språket, kan for loop-operatoren skrives i en av to former:
- for parameter := start_value til end_value do
- operatør;
- for parameter := start_verdi ned til sluttverdi do
- operatør;
Sløyfeparametervariabelen kan være en hvilken som helst ordinaltype. I dette tilfellet må start- og sluttverdiene være av en type som er kompatibel med typen parametervariabel.
La oss se på hvordan for-løkken fungerer.
Før du utfører en loop-setning, beregnes startverdien tilordnet parametervariabelen og sluttverdien. Deretter utføres følgende operasjoner syklisk:
- Gjeldende verdi av parameteren sammenlignes med sluttverdien.
- Hvis betingelsesparameteren con_value er sann, blir sløyfens kropp utført, ellers fullfører for-setningen arbeidet sitt og kontrollen overføres til operatøren som følger løkken.
OBS: På Pascal-språket endres loop-parameteren, uavhengig av om den øker eller reduseres, med én hver gang.
Oppgave. Vis en liste over kvadrater med heltall fra 10 til 1.
Løsning. I det oppgitte problemet synker syklusparameteren.
(Programkodefragment)
- for i:= 10 ned til 1 do
- writeln(i:2, " ", i * i);
OBS: hvis det er nødvendig å bruke mer enn én operatør i sløyfens kropp, brukes en sammensatt operatør (operatørparentes begynner og slutter ).
Eksempel 2. Søkerens karakterer på fire eksamener er kjent. Bestem hvor mange poeng han fikk.
Oppgave. Søkerens karakterer på fire eksamener er kjent. Bestem hvor mange poeng han fikk.
Løsning. Vi vil bruke en loop-operator med parametere i programmet, siden antall repetisjoner av de utførte handlingene er kjent (søkeren fikk nøyaktig fire karakterer)
(Programkodefragment)
- s:= 0;
- for i:= 1 til 4 do
- begynne
- readln(merke);
- s:= s + mark;
- skriveln(er);