ADATFELDOLGOZÁSI FELADATOK MEGOLDÁSAI

(ADATFELDOLGOZÁSI FELADATSORHOZ)

MEGÁLLAPODÁSOK

Az alábbiakban gyakorta szokatlan szintaxisú algoritmusokat is találunk; különösen, ami az

adatok megadásával kapcsolatos részleteket illeti lesz „laza”. Használjuk a típusok direkt-
szorzatát és unióját, és nem ragaszkodunk ezek szokványos reprezentációs lehet(ségéhez: a
rekordhoz ill. alternatív rekordhoz. Ezzel is az a célunk, hogy minél inkább a dolog lényegére
irányítsuk a figyelmünket, s ne ragadjunk le a nyelvek adta sokszor szükségtelen szigorúság
okozta bonyodalmaknál.
Sorozatot írunk, alatta tetsz(legesen ábrázolt elemek olyan együttesét értjük, amelyek ele-
meinek elérése szekvenciálisan történik. Tipikus példa a sorozatra az ún. Szekvenciális File,
amely az adatfeldolgozási feladatok meghatározó típusa.

1. FELADAT

Egy input szövegfájl karakterek sorozata. Írd ki a képerny(re sorokra tördelve úgy, hogy
szavakat ne törj két sorra! (Természetesen nincs sorhosszt meghaladó hosszúságú szó.)

Megoldás
Típusmegfeleltetés:
Bemenet Kimenet

Reprezentáció
Input = Sorozat(Karakter) Output = Sorozat(Sor)
Karakter = NormálJel ElválasztóJel Sor = Sorozat(Szó × Elválasztó)
[TípusInvariáns:
s:Sor | Hossz(s) sorHossz]
Szó = Sorozat(NormálJel)
Elválasztó = Sorozat(ElválasztóJel)
NormálJel = Karakter
[TípusInvariáns:
n:NormálJel | Bet"(n) SzámJegy(n) …]
ElválasztóJel = Karakter
[TípusInvariáns:
e:ElválasztóJel | ZáróJel(e) KözpontozóJel(e) …]
Ef: SorVégJel,LapVégJel X [X Input]

M#veletek
Eljárás Nyit(…x:Input,…) Eljárás Nyit(…y:Output,…)
Eljárás Olvas(…x:Input,…k:Karakter) Eljárás SorÍr(…y:Output,…s:Sor)

1
Függvény Vége?(…x:Input):Logikai Eljárás Zár(…y:Output)
Eljárás Zár(…x:Input)

Világos, hogy a típusmegfeleltetés nem végezhet( el a „natív” (Karakter Sor) elemek kö-
zött. Tehát konfliktus áll fönn. Az is nyilvánvaló, hogy ha a Szó és Elválasztó fogal-
makat a bemeneten is bevezetnénk, közelebb kerülnénk a konfliktusmentes helyzethez, hisz
ráépítve egy bemeneti sor fogalom könnyen kijöhetne. Ami már tisztán tagolási konfliktus
feloldását kívánja: valahány bemeneti ’szó+elválasztó’ párhoz hozzárendelhet( a kimeneti sor
fogalom.
Virtuális típus:

Reprezentáció
Input’ = Sorozat(Szó × Elválasztó) Output’ = Output

M#veletek
Eljárás Nyit’(…x:Input’,…) Eljárás Nyit(…y:Output’,…)
Eljárás SzóOlvas(…x:Input’, Eljárás SorÍr(…y:Output’,…s:Sor)
…szó,elv:Szöveg) Eljárás Zár(…y:Output’)
Függvény Vége?’(…x:Input’):Logikai
Eljárás Zár’(…x:Input’)

A m7veletek mellett megjelen( aposztróf utalás arra a típusra, amelyhez típushoz tartozik.
Jelenesetben az Input’-ra. Ha kimondanánk az objektum orientált programozás során nép-
szer7ségre szert tett polimorfizmus elvét, akkor persze szükségtelenné válna az „aposztró-
fozás”, hiszen a paraméter típusából kiderül, hogy mely típus azonos nev7 m7veletér(l van
éppen szó.
A m7veleteket úgy értelmezzük, hogy a megfeleltetés be- és kimenet között tökéletes legyen,
s így a Z=F(X) tétel alkalmazható legyen. Azaz az algoritmus legfels(bb szintje az alábbi
lehessen:
Változó X:Input’
Y:Output’
szó,elv,sor:Szöveg
Nyit’(X,Olvasásra); Nyit(Y,Írásra)
Ciklus amíg nem Vége?’(X)
SzóOlvas(X,szó,elv)
Feldolgozás(szó,elv,sor)
SorÍr(Y,sor)
Ciklus vége
Zár’(X); Zár(Y)
Típusfinomításhoz vegyük figyelembe, mint legjellegzetesebbet az Input’ SzóOlvas m7-
veletét! Feladata: folytatja a sorozat olvasását (építve a Karakter alapú Olvas m7veletre),
amíg NormálJel-ek jönnek, majd amíg ElválasztóJel-ek jönnek. Mivel a „kelleténél”
eggyel kés(bb derül ki, hogy mikor ér véget a szó, ill. elválasztójel-sorozat, ezért az el re-
olvasási technikát alkalmazzuk, amihez kell egy, a rutinok számára is elérhet( Karakter-
puffer. Tehát az Input’ reprezentációjához tartozik az eredeti Input mellett egy Karak-
ter-típusú adat:

2
 Típus Input’ = Input × Karakter
Megtehetnénk, hogy az új típust a két komponens alkotta rekordként írnánk le, de ez fölös-
leges leírási bonyodalmakat okozna. Figyelembe véve a szokásos nyelvi lehet(ségeinket, a
fenti rutinok paraméterezésében Input’ helyett (annak „kifejtése” gyanánt csak) Input-ot
írunk, és egy globális adatként tesszük hozzáférhet(vé (minden „érdekelt” rutin számára) a
puf-ot. Azaz a puf nem jelenik meg explicite a rutinok paraméterlistáján sem egy rekord
mez(jeként, sem direkt paraméterként.1 Végülis az Input’ ábrázolása:
Változó X:Input
puf:Karakter
… s a legjellegzetesebb SzóOlvas eljárás implementációja:
Eljárás SzóOlvas(…x:Input, …szó,elv:Szöveg):
[ef: az x-beli következ9 szó els9 jele a puf-ban]
szó:=’’
Ciklus amíg nem Vége?(x) és NormálJel(puf)
szó:+puf; Olvas(x,puf)
Ciklus vége
Elágazás
Vége?(x) és NormálJel(puf) esetén [fájlvégnél a szó vége]
szó:+puf; puf:=ÜresJel 2; elv:=’’
Vége?(x) és nem NormálJel(puf) esetén [fájlvégnél egy elválasztójel]
elv:=puf; puf:=ÜresJel
egyéb esetben [nincs még vége a fájlnak]
elv:=’’
Ciklus amíg nem Vége?(x) és nem NormálJel(puf)
elv:+puf; Olvas(x,puf)
Ciklus vége
Ha Vége?(x) és nem NormálJel(puf) akkor elv:+puf; puf:=ÜresJel
[különben normál jelre végz9dik]
Elágazás vége
Eljárás vége.
A NormálJel predikátumot definiáltnak vesszük.
A SzóOlvas ef-nek a figyelembe vételével kell az Input’ Nyit’-jét meggondolni, hiszen
a SzóOlvas els( meghívása el(tti állapotért ez az eljárás felel(s. Látható, hogy a két azonos
nev7, de más-más típushoz tartozó Nyit eljárás különböztetéséhez elkerülhetetlen már az
aposztrófozás, hiszen a fenti, paraméterezésre vonatkozó megállapodásunk miatt ebben már a
paraméterezés nem segít.3

1
Ezt nem tehetnénk meg, ha a feladatban az új típushoz több fájl is tartozna, hiszen mindegyiknek egyedileg
lenne szükség a Karakter-pufferra. Vegyük észre, ugyan ezen logika alapján a paraméterezésben további
egyszer7sítést is végrehajthatnánk, ui. az X „egyke” (egyedüli Input’ típusú) lévén, a hozzátartozó rutinok a
globálisan deklarált fájlhoz, közvetlenül is hozzáférhetnének. Ezzel a végletes leegyszer7sítéssel módszertani
okok miatt nem élünk.
2
ÜresJel, amelyt(l elvárjuk, hogy nem lehet semmilyen szöveg alapú sorozat jele.
3
Így járunk el mindig, ha nem egyértelm7, hogy az eredeti vagy a módosított reprezentációjú m7veletr(l lesz
szó.

3
 Eljárás Nyit’(…x:Input,…):
Nyit(x,…)
Ha nem Vége?(x) akkor Olvas(x,puf)
különben puf:=ÜresJel
Eljárás vége.
A Vége?’ és a Zár’ m7veletek egy az egyben megegyeznek az azonos nev7 Karakter
alapúval. A Vége?’ és a Vége? azonossága nyilvánvaló. A Zár’ és a Zár azonosságának
az a feltétele, hogy a Z=F(X) tételbeli ciklusban ne maradjon semmi még lekezeletlen (pl. a
puff-ban).
Vegyük észre azonban, hogy nem feltétlenül teljesül az a természetes elvárásunk, hogy szóval
kezd(dik a szöveg, ami viszont kell a SzóOlvas eljárás ef-nek el(szöri teljesüléséhez. El-
len(rizve a SzóOlvas eljárást azt tapasztaljuk, hogy mégis helyesen (azaz üres szó + elvá-
lasztójel kett(set visszaadva) m7ködik. Folytassuk a SorÍr m7velettel!
A paraméterlistákon az Output’-ot helyettesítjük az Output-tal. Figyeljük meg a felhasz-
nálást! Látható, hogy minden szó olvasása után némi transzformáció, majd a sor írása követ-
kezik. Nyilván ez csak úgy lehetséges, hogy a sort ténylegesen csak annak „kész”-sége esetén
írjuk, amihez a SorÍr’ eljárás számára meg kell adni a szükséges információt. (Itt ismét
aposztróffal tesszük megkülönböztethet(vé a kénytelen-kelletlen módosuló és a visszavezetés
alapjául szolgáló SorÍr eljárásokat.) Legyen a sor „üres”, ha még nincs mit kiírni, minden
egyéb esetben a benne lév( tartalmat kell megjeleníteni. Az üres kódolható az ÜresJel-lel
(nem azonos a ’’ tartalommal!). Ez által akár üres sorokat tartalmazó szöveg is feldolgoz-
hatóvá válna, de ez további vizsgálódást is igényelne, s különben is az el(feltétel ezt az esetet
kizárja.
Eljárás SorÍr’(…y:Output,…s:Sor):
Ha s ÜresJel akkor SorÍr(y,s)
Eljárás vége.
Ide illik tartalmilag leginkább az Output’ típushoz szorosan nem kapcsolódó Feldolgo-
zás eljárás. Ez tartja vissza a készül( sor tartalmát. Mivel el(re most sem lehet tudni, mikor
válik késszé: ehhez is egy pufferre (sorPuf) lesz szükség. Ez bizony –el(zetes elképzelé-
seinkkel ellentétben– az Output tényleges reprezentáció-módosítását jelenti:
Típus Output’ = Output × Szöveg
Ahogy korábban –az Input’ esetében is– eljártunk, az Output’-ot ténylegesen magával az
Output-fájllal és a sorPuf változó –globálisként való– deklarálásával reprezentáljuk.
Változó Y:Output
sorPuf:Szöveg
A Feldolgozás eljárás:
Eljárás Feldolgozás(…szó,elv:Szöveg,…s:Szöveg):
Ha Hossz(sorPuf+szó+elv)>sorHossz akkor s:=sorPuf; sorPuf:=szó+elv
különben s:=ÜresJel; sorPuf:+szó+elv
Eljárás vége.

4
Látható, hogy a pufferre, mint már értéket tartalmazóra hivatkozunk, így tehát még a ciklus
el(tt inicializálnia kell valamelyik nyitó eljárásnak. Logikusan az Output’-hoz tartozót vá-
laszthatjuk:
Eljárás Nyit’(…y:Output,…):
Nyit(y,…); sorPuf:=’’
Eljárás vége.
Belegondolva: a Zár’ („aposztrofált” Zár) m7veletnek is kell a sorPuf adat, amikor a
sorozat végére érve a ciklust elhagyjuk, de még nincs „készen” a nyomtatásra. Ekkor a Zár’
gondoskodik arról, hogy így „félkészen” megjelenjen az outputon.
Eljárás Zár’(…y:Output):
Ha sorPuf ’’ akkor SorÍr(y,sorPuf)
Zár(y)
Eljárás vége.

2. FELADAT

Egy input szövegfájl képerny( szélességnyi sorok sorozata (pl. egy sor maximum 80 karaktert
tartalmazhat). Készíts egy output szövegfájlt, amely szintén sorok sorozata, de a képerny(sor
méretét(l eltér( hosszú (pl. maximum 132 karaktert tartalmazhat), input sorok „összeolvad-
hatnak”, de el nem törhetnek!

Megoldás
Típusmegfeleltetés:
Bemenet Kimenet

Reprezentáció
Input = Sorozat(Sor) Output = Sorozat(hSor4)
Sor = Sorozat(Karakter) hSor = Sorozat(Karakter)
[TípusInvariáns: [TípusInvariáns:
s:Sor | Hossz(s) ISorH] hs:hSor | Hossz(hs) OSorH]
Ef: ISorH OSorH
[a feladat szövege szerint ISorH=80, OSorH=132]

M#veletek
Eljárás Nyit(…x:Input,…) Eljárás Nyit(…x:Output,…)
Eljárás SorOlvas(…x:Input,…s:Sor) Eljárás SorIr(…x:Output,…hs:hSor)
Függvény Vége?(…x:Input):Logikai Eljárás Zár(…x:Output)
Eljárás Zár(…x:Input)

Konfliktus feszül a kétféle sorfogalom között, ui. elképzelhet(, hogy egynél több bemeneti
sorból fog összeállni a kimeneti sorok egyike-másika.

4
hSor értsd: „hosszú sor”

5
Virtuális típus:

Reprezentáció
Input’ = Sorozat(hosszúSor) Output’ = Output
hosszúSor = Sorozat(Sor)
[TípusInvariáns:
hs:hosszúSor | Hossz(hs) OSorH]

M#veletek
Eljárás Nyit’(…x:Input’,…) uam. az Output típus m"veletei
Eljárás hosszúSorOlvas(…x:Input’,
…hs:hosszúSor)
Függvény Vége?’(…x:Input’):Logikai
Eljárás Zár’(…x:Input’)

A m7veleteket úgy értelmezzük, hogy a megfeleltetés a be- és a kimenet között tökéletes

legyen, s így a Z=F(X) tétel alkalmazható legyen. Azaz az algoritmus legfels(bb szintje az
alábbi lehessen:
Változó X:Input’
Y:Output
hos,hs:Szöveg
Nyit’(X,Olvasásra); Nyit(Y,Írásra)
Ciklus amíg nem Vége?’(X)
hosszúSorOlvas(X,hos)
SorFeldolgozás(hos,hs)
SorÍr(Y,hs)
Ciklus vége
Zár’(X); Zár(Y)
Kihasználtuk azt, hogy a Sor, hosszúSor ill. hSor típusok legtermészetesebben
Szövegként valósíthatók meg, így kezelésükhöz a Szöveg-operátorok felhasználhatók. A
SorFeldolgozás eljárás most csak „típus-konverterként” m7ködik. Ha a nyelv nem túl
„finnyáskodó”, akár egy értékadással helyettesíthet( is: hs:=hos. S(t a két „rokon” típus
(ábrázolási és) szemantikus egyezésére apellálva egyiket el is hagyhatjuk. S így egyszer7-
södik az algoritmus:
Változó X:Input’
Y:Output
hs:Szöveg
Nyit’(X,Olvasásra); Nyit(Y,Írásra)
Ciklus amíg nem Vége?’(X)
hosszúSorOlvas(X,hs)
SorÍr(Y,hs)
Ciklus vége
Zár’(X); Zár(Y)
Visszatér( gond, hogy a kimenetre együttesen küldhet( bemeneti sorok száma csak eggyel
„túlolvasva” derül ki. Vagyis megint alkalmazandó az el reolvasási technika, amihez szük-
séges egy sornyi puffer. Így a típusmódosítás már adódik:
Típus Input’ = Input × Sor

6
Jelöljük e puffert marSor-ral (értsd: „maradék sor”), és globálisan tegyük hozzáférhet(vé
az érdekelt operációk számára. Alábbiakban az operációkat részletezzük.
Változó Y:Output az Output’ és az
X:Input Input’ reprezentációja…
marSor:Szöveg
Eljárás Nyit’(…X:Input,…):
Nyit(X,…) tényleges nyitás…
Ha nem Vége?(X) akkor SorOlvas(X,marSor)5 el reolvasás a marSor-ba, ha
különben marSor:=’’ lehetséges…
Eljárás vége.
Eljárás hosszúSorOlvas(…X:Input,
…hs:hosszúSor):
[ef: marSor-ban a köv. hosszúSor els9 sora]
hs:=’’
Ciklus amíg nem Vége?(X) és a hozzáfér sorok gy!jtése,
Hossz(hs+marSor) OSorH az utolsó, már oda nem fér a
hs:+marSor; SorOlvas(X,marSor) marSor-ban várakozik a legköze-
Ciklus vége lebbi hívásig…
Ha Vége?(X) és Hossz(hs+marSor) OSorH akkor a fájl utolsó sora esetleg még
hs:+marSor; marSor:=’’ odaférne..
Elágazás vége
Eljárás vége.
Eljárás Zár’(…X:Input):
Zár(X) semmi extra a záráskor…
Eljárás vége.
Ezen a ponton már végiggondolhatjuk programunk m7ködésének helyességét úgy érezvén: a
változtatandó bemeneti típus sanszos m7veletei készen vannak. Egyetlen ponton gyanús az
összm7ködés. Mi van akkor, amikor a végén egy sornyi a bemenet marad? Mivel a ciklus-
feltétel hamissá válik, kilépünk, s a marSor-ban reked az utolsó sor. Két dolgot tehetünk.
Egyik, hogy a kimeneti oldalon módosítjuk az Output Zár m7veletét; másik, hogy meg-
akadályozzuk az „id( el(tt” történ( kilépést a feldolgozó ciklusból. Az els( megoldás nagyon
mesterkélt, hiszen semmifajta reprezentációs változás nincs, s(t egyéb helyen sem kellett
módosítani az eredeti kimeneti típuson. A másik esetén a bemeneti (tehát amúgy is
módosított) típus Vége?’ függvényét kell „csak” újrafogalmaznunk:
Függvény Vége?’(…X:Input):Logikai vége a feldolgozásnak(!), ha az
Vége?’:=Vége?(X) és marSor=’’ utolsó sort beolvastuk és maradék-
Függvény vége. talanul fel is dolgoztuk.
A módosítás indokolja, hogy a nyitással való harmóniát újraellen(rizzük. Megvizsgálandó
esetek: üres a fájl, és legalább egy sort tartalmaz. Mindkett(: OK.

5
A SorOlvas természetesen SorVégJel-ig olvas, de azt már nem teszi a sor-paraméterbe. Hasonló emlé-
keztet( megjegyzés tartozik a SorÍr m7velethez is.

7
8. FELADAT

Egy egyirányú utcában két jelz(lámpánál figyelik az áthaladó autókat (rendszám, id(, lámpa-
sorszám). Az adatok észlelési id( szerint rendezettek. N db autót figyelünk meg, ezek bizto-
san elhaladnak mindkét lámpa el(tt, egymást nem el(zik meg. Készíts egy output fájlt, amely-
ben az autók áthaladási ideje szerepel!

1. megoldás
A feladatban kétféle sorozat tagjai keverednek: az els( és a második lámpánál mért id(k soro-
zatai.
Pl.: (1,T1,1), (2,T2,1), …(i,Ti,1), (1, T1' ,2), …(j, Tj' ,2), (i+1,Ti+1,1), …(N,TN,1), (k, Tk' ,2),
…(N, TN' ,2), ahol Ti az i. autó els( lámpához tartozó idejét, a Ti' a másodikat jelöli.

Bemenet Kimenet

Reprezentáció
6
Input = Sorozat(Id9Pont ) Output = Sorozat(Id9Tartam)
Id9Pont = Autó × Mikor × Hol Id9Tartam = Autó × Mennyi
Autó = rendszám
A Mikor-t egész percekben mérve. Az áthaladási id(t percekben értve.
Hol = {1, 2} Az Id9Tartam ábrázolható rekorddal.
Az Id9Pont ábrázolható rekorddal.

Az összefonódási konfliktus „szabványos” megoldása a szétválogatásra épít, amelyben két

Segéd Autó×Mikor bázis-típusú sorozat képz(dik. Els( lépésben ezeket kell el(állítani,
majd másodjára ezek párhuzamos feldolgozása történik. Nagyvonalakban:
Változó X:Input
lámpa1,lámpa2:Segéd
Y:Output
Szétválogat(X,lámpa1,lámpa2)
PárosanFeldolgoz(lámpa1,lámpa2,Y)
A Szétválogat:
Bemenet Kimenet
Reprezentáció
Input = Sorozat(Id9Pont) Segéd12 = Segéd × Segéd
Id9Pont = Autó × Mikor × Hol Segéd = Sorozat(Id9Pont’)
… Id9Pont’ = Autó × Mikor
Az Id9Pont’ ábrázolható rekorddal:
Rekord(Autó:TAutó,Mikor:TMikor)

6
Az Id9Pont elnevezésnél tartalmilag jobb lenne pl. a Megfigyelés, de hogy nyomatékosítsuk a „transz-
formáció mikéntjét”, ti. hogy egy id(pontnak id(tartammá történ( átalakítása a cél, ezért a módszertanilag
kifejez(bbet választottuk.

8
 Eljárás Szétválogat(Változó X:Input, lámpa1,lámpa2:Segéd):
Változó a:Id9Pont
a’:Id9Pont’
Nyit(X,Olvasásra); Nyit(lámpa1,Írásra); Nyit(lámpa2,Írásra)
Ciklus amíg nem Vége?(X)
Olvas(X,a); a’.Autó:=a.Autó; a’.Mikor:=a.Mikor
Ha a.Hol=1 akkor Ír(lámpa1,a’)
különben Ír(lámpa2,a’)
Ciklus vége
Zár(X); Zár(lámpa1); Zár(lámpa2)
Eljárás vége.
A PárosanFeldolgoz:
Bemenet Kimenet

Reprezentáció
Segéd12 = Segéd × Segéd Output = Sorozat(Id9Tartam)
Segéd = Sorozat(Id9Pont’) Id9Tartam = Autó × Mennyi
… …

Arra a feltételezésre építünk, hogy nincsen el(zés és minden autó, amelyik belépett, az ki is
lép. Ekkor a segéd sorozatok azonos index7 elemei ugyanahhoz az autóhoz tartoznak. Így:
Eljárás PárosanFeldolgoz(Változó lámpa1,lámpa2:Segéd, Y:Output):
Változó a1,a2:Id9Pont’
aY:Id9Tartam
Nyit(lámpa1,Olvasásra); Nyit(lámpa2,Olvasásra); Nyit(Y,Írásra)
Ciklus amíg nem Vége?(lámpa1)
Olvas(lámpa1,a1); Olvas(lámpa2,a2)
aY.Autó:=a1.Autó; aY.Mennyi:=a2.Mikor-a1.Mikor
SorÍr(Y,aY)
Ciklus vége
Zár(lámpa1); Zár(lámpa2); Zár(Y)
Eljárás vége.

2. megoldás
Ne elégedjünk meg a fenti „sémamegoldással”, gondoljuk tovább! Ha feltehet(, hogy a párok
„nem túl távol” követik egymást a sorozatban, akkor megspórolható sok-sok elemolvasó, -író
m7velet. Ötletünk a következ(: a feldolgozandó elemek egy sorba (értsd: memóriában kezelt
FIFO-szerkezetbe) kerüljenek, ahonnan a pár megérkezésekor rögvest képezzük a kimenet
következ( elemét. Ha nem túl távol vannak a párok egymástól, akkor a memóriában csak a
közéjük ékel(dött autóészlelések kerülnek (lehet tehát memóriában tartani). Az el zés tilalma
miatt kézenfekv( a FIFO tulajdonságú sorra gondolni. A jellemz( (feldolgozás közi) állapotot
így jellemezhetjük:

9
 Bemenet Memória Kimenet

Reprezentáció
Input=Sorozat(Id9Pont) Feldolgozatlan=Sor(Id9) Output=Sorozat(Id9Tartam)
Id9Pont=Autó×Mikor×Hol Id9=Mikor Id9Tartam = Autó × Mennyi
[csak 1. lámpa id9adata …
… kell, mert el9zés, elveszés
és keletkezés nincs]

Változó X:Input
lámpa1:Feldolgozatlan
aP:Id9Pont
aS:Id9
aT:Id9Tartam
Y:Output
Üres(lámpa1); Nyit(X,Olvasásra); Nyit(Y,Írásra)
Ciklus amíg nem Vége?(X)
Olvas(X,aP)
Ha aP.Hol=1 akkor
Sorba(lámpa1,aP.Mikor)
különben [2. lámpa adatai]
Sorból(lámpa1,aS)
aT.Autó:=aP.Autó; aT.Mennyi:=aP.Mikor-aS
Ír(Y,aT)
Elágazás vége
Ciklus vége
Zár(X); Zár(Y)
Megjegyzések:
1. Kisebb-nagyobb típusmódosítás árán a Z=F(X) tétel algoritmusát ki lehet hozni a fentib(l.
A kiemelt részt tekinthetjük az elem feldolgozásának, s mint ilyent beültethetjük egy
ugyanilyen nev7 eljárásba, amely kimenetén kétféle információ jelenik meg: kész-e az
output, és ha igen, maga az output. Ezt az információt használja fel a kiíró rész (a mó-
dosított típusú Output: Ír m7velete).
2. Megfigyelhet( a bevezet( példa-adatsoron, hogy az N. autó 1. adata után már csak 2. tí-
pusú adat következhet. Ezzel némileg „id(-hatékonyítható” az algoritmus. (A módosított
algoritmusbeli változó részt alább kiemeljük.)
Változó X:Input
lámpa1:Feldolgozatlan
aP:Id9Pont
aS:Id9
aT:Id9Tartam
Y:Output
Db:Egész [a már készek száma]

10
Üres(lámpa1); Nyit(X,Olvasásra); Nyit(Y,Írásra); Db:=0
Ciklus amíg Db<N
Olvas(X,aP)
Ha aP.Hol=1 akkor
Sorba(lámpa1,aP.Mikor); Db:+1
különben [2. lámpa adatai]
Sorból(lámpa1,aS)
aT.Autó:=aP.Autó; aT.Mennyi:=aP.Mikor-aS
Ír(Y,aT)
Elágazás vége
Ciklus vége
Ciklus amíg nem Vége?(X)
Olvas(X,aP)
Sorból(lámpa1,aS)
aT.Autó:=aP.Autó; aT.Mennyi:=aP.Mikor-aS
Ír(Y,aT)
Ciklus vége
Zár(X); Zár(Y)

11