Múzeum - Könyvek - Hetedhét ENTRPRISE

- hogy kiknek szól ez a könyv.
Mindazoknak, akiknek van otthon ENTERPRISE számítógépük, vagy ha otthon nincs is, hozzá tudnak férni -, de nem tudnak programozni. Szeretnének megtanulni, de nincs kitől. Forduljanak bizalommal e könyvhöz! A könyv senki helyett nem tud megtanulni semmit, de segít egy kicsit játszani a géppel, és mire a játék végére érünk, már többet tudunk a programozásról is.

- hogy miről szól ez a könyv?

A könyv az ENTERPRISE számítógép BASIC nyelvét mutatja be. Ez a nyelv az egyik legjobban elterjedt nyelv a világon, sokkal többen tudnak BASIC-ül, mint magyarul. A legtöbb BASIC-ül tudó azonban nem ember, hanem számítógép. A BASIC ugyanis a számítógépek egyik nyelve.
A BASIC (ejtsd: bézik) egy angol szó; azt jelenti: alapvető. Valóban, kezdők számára ez az egyik legelterjedtebb számítógépes nyelv. Szinte minden számítógép tud BASIC-ül, így hát nekünk is érdemes megtanulni.
Mivel minden gép egy kicsit másképp beszéli ezt a nyelvet, meg kell állapodnunk abban, hogy mi a nyelvnek azt a változatát ismerjük meg, amelyiket az ENTERPRISE használ. Az ENTERPRISE rettentően sok dolgot tud csinálni. Ha mindent meg akarnánk tanulni, akkor ez a konyv tíz ilyen kötetből állna, és talán még akkor se férne bele minden. Ezért ebben a könyvben csak a legfontosabb tudnivalókkal fogunk találkozni.
Nagyon sok olyan dolog van, amit az ENTERPRISE tud, de ebben a könyvben nem szerepel. Ezeket - a felhasználói leírás segítségével - próbáljuk meg majd később megismerni. A könyv áttanulmányozása után ez már nem fog nehézséget okozni.

- hogy milyen gépre van szükségünk.
Természetesen egy ENTERPRISE számítógépre. A számítógépet kicsit ismerők rögtön megkérdezik:
angolra vagy németre?
Nálunk ugyanis kétféle ENTERPRISE számítógép volt eddig kapható. Az egyik német billentyűs - ezt onnan lehet megismerni, hogy az alsó sorban az X billentyű mellett az Y billentyű van, és a hibaüzeneteket németül írja ki -, a másik angol.
Ebben a könyvben mi mindig az angol gépre fogunk hivatkozni, ha például az egyes billentyűk elhelyezkedését ismertetjük. Természetesen annak sem kell megijedni, akinek német gépe van. Egyszerűen csak arra kell ügyelnie, hogy a gépén egyes betűk, jelek máshol találhatók meg. Szerencsére mindkét gép ugyanazt a BASIC nyelvet ismeri.
Egy apró eltérés azért még van. A német gépekhez írt programokban majd helyenként szükségünk lesz a # jelre. Ezt a jelet az angol gépek nem használják, helyette a felső sorban a szürke színű 3-as billentyű tetején lévő fontjelet kell a programokba írni. (Lásd Felhasználói leírás, 13. oldal!)

- hogyan kell olvasni ezt a könyvet.
Az első tanács, hogy amit olvasunk, azt mindig azonnal próbáljuk is ki! Ne féljünk, a gépet nem tudjuk elrontani! Legalábbis mindaddig, amíg csak a billentyűket nyomkodjuk (csavarhúzóval persze azért sikerülhet). A könyv három hét és egy plusz nap
ismeretanyagából áll. Egy hétben - nálunk is - hét nap van. Egy-egy napban pedig rettentően sok újdonság. Annyi minden új, hogy azt egy nap alatt szinte fel sem lehet fogni. Sokszor nem is sikerül. Ilyenkor semmi baj nincs, másnap kezdjük elölről a nap anyagát. Ha most sem értjük, menjünk még egy napot vissza. Ha már visszaértünk a könyv elejére, és még mindig nem értünk semmit, akkor gondolhatjuk azt, hogy rossz a könyv. A hibát ne a gépben
keressük! A számítógép szinte sosem romlik el.

- hogy minek vannak a könyvben minden nap végén feladatok.
Nem azért, mintha ezeket kötelező lenne megcsinálni. Sőt! Ha nem tetszenek nekünk, bele se kezdjünk egyikbe se, hanem találjunk ki helyettük másokat! A gyakorlást azonban ne hagyjuk ki!
Gyakorlat teszi a mestert, és ez a számítógéppel kapcsolatban még sokkal inkább igaz. Aki azt hiszi, hogy már ért valamit, próbálja ki, és rá fog jönni, hogy van még tanulni való. De a számítógépnél jobb tanítót elképzelni sem lehet, mert a gép nem fárad el, nem unja meg, és még egyest sem ad, ha rosszat csinálunk. Csak nem érti, mit akarunk tőle, ésezért üzen nekünk valamit - németül vagy angolul -, aztán megáll.

- hogy milyen programok vannak ebben a könyvben.
A könyvben rendkívül sok kis program van, de persze közelítőleg sem annyi, mint amennyit ki lehet találni. A dologban éppen az a jó, hogy mi is bármikor kitalálhatunk új programokat, és megírhatjuk őket. Roppant jó móka!
A könyvben lévő programokat mindig nekünk kell majd begépelnünk a számítógépbe. A programok listái azonban nem úgy vannak a könyvben, ahogy azokat mi begépeljük, hanem ahogy azt majd a gép utólag kiírja. A különbség az, hogy sokszor olyam dolgokat, amelyeket mi egy sorba írtunk, az ENTERPRISE két sorba rak szét. Ezt azért csinálja, mert - mint azt majd később látni is fogjuk - egyes esetekben ő szereti a sorokat egy kicsit beljebb kezdeni. Ekkor azonban már nem férnek ki a sor végén lévő szavak vagy más jelek ugyanebbe a sorba, ezért átteszi őket a következőbe. Szépen sorban haladva a könyvben - és a gyakorlásban - ezt meg fogjuk szokni, és később teljesen természetes lesz.

- hogy mire nem ad választ ez a könyv.
Akik még soha nem tanultak számítógépet programozni, óvakodjanak attól a téves elképzeléstől, hogy a programozást egyszerűen meg lehet tanulni egy könyvből. Erről szó sincs! Ha a könyvek többször ilyen vastagok lennének, akkor sem férne el beléjük minden trükk, minden lehetséges megoldás -' szerencsére. A trükkök száma ugyanis végtelen, hiszen mindenki maga találja ki magának az újabb és újabb feladatokat, és a megoldásukhoz használható fortélyokat.
Nagyon sokszor megtörténik, hogy eszünkbe jut valami ilyesmi: "Mi lenne, ha...?" Ilyenkor gyakran járunk úgy, hogy hiába keressük: a választ könyveinkben, nem találjuk, nincs. De ott van a számítógép! Az válaszol! Próbáljuk ki, amit kitaláltunk! Ha a gép elfogadja és megcsinálja, akkor jó! Ha pedig nem, akkor keressünk egy másik, megoldást! A helyes megoldásoknak nincs határa.

A programozás kicsit olyan, mint a kerékpárazás. Hiába olvasunk el róla tíz vagy száz könyvet,' biciklizni is csak akkor fogunk tudni, ha felülünk egy bringára, és nekiállunk pedálozni. És hogy mikor, merre kell fordítani a kormányt, azt mindenkinek magának kell kitalálni.
Jó kerékpározást!

A nálunk kapható személyi számítógépek között az egyik legtöbbet tudó az ENTERPRISE. (Ez a név egy angol szó, úgy kell ejteni, hogy: enterprájz, és azt jelenti: vállalkozás.) Megijedni azért nem kell, gépünk igen kezes, így megtanulni a használatát nem is olyan veszélyes vállalkozás.
A legelső, ami feltűnik, a sokféle színes billentyű. A gép sajnos nem ért a szóból, így, ha akarunk valamit tőle, akkor ezt be kell gépelnünk. Erre szolgálnak a szürke billentyűk. Mindegyiknek a tetején egy vagy két betű, illetve jel látható. Ezekkel ugyanúgy tudunk gépelni, mint az írógépen, a különbség csupán annyi, hogy hiányzik a legtöbb magyar ékezetes betű, viszont néhány új, ismeretlen jel megtalálható. Ilyen például - a német gépeken - a felső sorban a jobb oldalon a 0 billentyű melletti gomb, amelyen egy, a magyar "B" betűhöz nagyon hasonló jelet láthatunk. Ez a német "scharfes s" betű. Vigyázzunk, nehogy később összekeverjük a magyar b-vel, amely az alsó sorban középen van.
Ha véletlenül mégis hibát ejtenénk, észre fogjuk venni, hogy a gép nem érti, mit akarunk tőle, ezért megáll, és valami üzenetet ír ki nekünk a képernyőre. Ettől nem kell megijednünk. Bár a számítógép kényes jószág, nem szereti, ha vizet öntünk belé vagy ha kalapáccsal egyengetjük, de a billentyűkkel egyszerűen lehetetlen elrontani. A legrosszabb, amit elérhetünk, hogy sikerül úgy összekutyulnunk a saját programunkat, hogy kénytelenek leszünk az egészet elölről kezdeni. Ez azonban a gépet nem zavarja.
Amikor bekapcsoljuk, legelőször néhány furcsa betűt és számot ír ki a képernyő tetejére - ezalatt önmagát ellenőrzi a gép. Ha mindent rendben talál, akkor előzékenyen be is mutatkozik:

üssük le egy pillanatra valamelyik billentyűt! Azt látjuk, hogy megváltozik a kép:

A legfelső sor az ún. státusz (angolul: status, magyarul: állapot) sor, amelyben az általunk használt rendszer nevét írja ki a gép. (IS-BASIC). Az alatta lévő sorokban a gépben lévő tár méretét láthatjuk, majd a gép üzenetét (ok), amivel azt közli; hogy részéről minden rendben, ő készen áll a közös munkára. Számunkra most mindez nem túl fontos. Ami nekünk érdekes, az a kavetkező sor elején lévő villogó négyszög, melynek neve kurzor (angolul: cursor). Ez mutatja meg, hogy hova tudunk írni a képernyőre. Olyan ez, mint egy különleges írógép, amellyel nem papírra, hanem a képernyőre lehet írni. Próbáljunk ki néhányat az ismerős szürke billentyűk közül! Nyomjuk le őket egy-egy pillanatra! Azt látjuk, hogy - miközben halk kis kettyenő hang jelzi az egyes billentyűk lenyomását - a billentyűk tetején lévő betűk vagy jelek sorra megjelennek a képernyőn, ott, ahol az előbb még a kurzor volt, miközben az mindig egyet jobbra lép. Ha elérjük a képernyő szélét, a gépelés rendben folytatódik a következő sorban.
Figyeljük meg, hogy ha egy billentyűt nem csak egy pillanatig tartunk lenyomva, akkor kis idő múlva a gép automatikusan elkezdi ismételgetni a rajta lévő betűt, és mindaddig ismételgeti, amíg a billentyűt el nem engedjük.
Próbáljuk ki az alul lévő széles billentyűt is! Ez a szóköz (angolul: space, ejtsd: szpész) billentyű. Arra való, hogy a szavakat el tudjuk választani egymástól.

Mire jó alaposan kijátszottuk magunkat, az egész képernyő össze-vissza betűk kusza halmazával van tele, aminek bizony, semmi értelme. Esetleg olyan sokat gépeltünk, hogy az már ki se fért egyszerre, és a felső sorok el is tűntek.
Mielőtt. valami értelmes dolog legépelésébe kezdenénk, takarítsuk le a képernyőt. Ehhez nyomjuk le a legfelső sorban lévő kék billentyűk közül a középen lévő, FUNCTION 5 feliratot. Ekkor a következő sorban feltűnik egy pillanatra a TEXT felirat, majd az egész képernyő letör1ődik, csak a státusz sor, az ok üzenet és a kurzor marad.
A számítógépnek általában különböző parancsokkal mondjuk meg, mit is akarunk tőle. Az egyik ilyen, parancs a TEXT is. A felső sorban lévő kék billentyűkkel a leggyakrabban használt parancsokat tudjuk kiadni anélkül, hogy betűnként kéne begépelnünk őket. A billentyűk feletti cserélhető papírcsíkról le is olvasható, hogy melyikkel milyen parancs adható ki. Keressük meg az F5 billentyű felett a TEXT fel iratot!
A következő feladat amit megkísérlünk, a saját nevünk begépelése. Keressük meg az egyes betűket, és sorban üssük le! Ne feledkezzünk meg a két szó közötti szóközről sem! Ekkor valami ilyesmit láthatunk a képernyőn:

Ajjaj, nagy hibát követtünk el! Kisbetűvel írtuk a saját nevünket! No de sebaj, a számítógéppel szerencsére könnyen kijavíthatjuk, csak a kurzort kell a hibás betűre állítanunk. Ehhez a gép jobb oldalán lévő botkormányt (angol neve joystick, ejtsd: dzsojsztik) használhatjuk. A botkormánnyal ugyanúgy tudjuk mozgatni a kurzort a képernyőn, ahogy egy pilóta irányítja a repülőgépet. Amerre billentjük a botkormányt, arra lépked a kurzor. Mehetünk fölfelé, lefelé, előre, hátra vagy akár ferdén is, a kurzor szépen engedelmeskedik. Egyre azért vigyázzunk! Nem érdemes a botkormányt teljes erővel nyomnunk, ettől a kurzor nem megy gyorsabban, legfeljebb a botkormányt törhetjük le. Hasznosabb, ha csak két ujjal fogva, finoman döntjük meg egy-egy pillanatra, így pontosabban is tudjuk irányítani, mintha folyamatosan döntve tartanánk.
Álljunk tehát rá a kurzorral a nevünk elején olvasható kisbetűre. Ekkor azt látjuk, hogy hol a betű, hol meg a kurzor jelenik meg váltakozva. Most nyomjuk le a bal, illetve a jobb oldalon alul lévő két SHIFT feliratú zöld gomb közül az egyiket, és miközben nyomva tartjuk, vele együtt egy pillanatra üssük le azt a betűt, amellyel a nevünk kezdődik. Most azt látjuk, hogy a nevünk elején lévő kisbetűt felülírtuk a helyes nagybetűvel, a kurzor pedig a következő betűre ugrott. Ha tehát egy a képernyőn lévő betűt vagy jelet meg akarunk változtatni, akkor a kurzorral odalépkedve a régi jelet egyszerűen ki tudjuk cserélni.
A gépen kétoldalt lévő zöld billentyűk a gépelést, javítást könnyítik meg, vagy a szürke billentyűk jelentését módosítják. Így például, ha a SHIFT billentyű le van nyomva, és leütünk egy betűbillentyűt, akkor a megfelelő nagybetű jelenik meg a kisbetű helyett. A szám, illetve a jelbillentyűknél ilyenkor a felső jel kerül a képernyőre.
Most már tudunk betűket kicserélni (szakmai nyelven: felülírni) és nagybetűkkel is tudunk írni, javítsuk ki tehát a keresztnevünket is:

Az á betűre sajnos nem tudunk ékezetet tenni, de ezt gyorsan meg fogjuk szokni. Csak aztán nehogy végleg elfelejtsük az ékezeteket, mert a számítógépen kívüli világban még mindig nagy szükség van rájuk!
Most menjünk a kurzorral a következő sor elejére, és gépeljük be csupa nagybetűvel, hogy ENTERPRISE. Ezt persze megtehetjük úgy is, hogy a SHIFT billentyűt végig nyomva tartjuk, de van ennél kényelmesebb mód is: nyomjuk le a bal oldalon a SHIFT billentyű fölötti LOCK billentyűt, és miközben nyomva tartjuk, üssük le egy pillanatra ` SHIFT-et is. Ekkor a státusz sor elején megjelenik a SHIFT felirat - most már elengedhetjük a LOCK gombot. SHIFT üzemmódban vagyunk, ami azt jelenti` hogy minden billentyű a neki megfelelő nagybetű| írja a képernyőre. Mostantól akkor kell egy betűt SHIFT-tel együtt lenyomnunk, ha a kisbetűt szeretnénk megjeleníteni. Most már kényelmesen be tudjuk gépelni a nagybetűs feliratot, tehát valami ilyesmit kell látnunk a képernyőn:

Persze nem akarunk végleg nagybetűs (SHIFT üzemmódban maradni. A kikapcsoláshoz csak a LOCK gombot kell egy pillanatra lenyomnunk, a státus sorból eltűnik a SHIFT felirat, és ismét kisbetű üzemmódban vagyunk.
Eddig is megtörténhetett, hogy egy-egy betű rosszul ütöttünk le, és ezért az egész szót újra kellett gépelnünk. Most szándékosan csinálunk hibát, hogy megtanuljuk egyszerűen kijavítani Menjünk a kurzorral az első sorban a saját nevünk mögé, és betűről-betűre írjuk be: nagyyon okooos. Ne felejtsünk el szóközt hagyni a nevünk után! képernyőn ekkor valami ilyesminek kell lennie:

A megállapítás tökéletesen igaz, csak egy kicsit nehezen olvasható a - most az egyszer szándékos - gépelési hibák miatt. Mi a teendő? Először is szeretnénk a "nagyyon" szóból kitörölni az egyik y-t, mivel egy is elég. (Ugye?)
Menjünk hát a kurzorral a két y mögötti o betűre, majd nyomjuk le a gépen felül, jobb oldalon lév8 ERASE billentyűt egyszer. Az erase is angol szó, ejtsd: eréz, jelentése: kitöröl, kiradíroz. Ezen a billentyűn még egy kis nyilacska is jelöli, hogy eggyel balra lépteti a kurzort. Igen ám, de nemcsak a kurzort, hanem mindazt, ami a kurzortól jobbra van a sorban. A második y eltűnt; letöröltük, pontosabban felülírtuk az o betűvel. Ugye mennyivel kényelmesebb, mint újragépelni az egészet?
Ezzel a tudásunkkal már ki tudnánk javítani az "okooos" szóban lévő hibát is, hiszen a szóvégi s betűre állva ERASE-zel ki tudnánk törölni a felesleges o betűket, de mi most inkább ismerkedjünk meg egy másik billentyűvel.
Ez a billentyű a DEL; ott van mindjárt az ERASE mellett jobbról, és ez is javításra szolgál. (A teljes angol szó a delete, ami ,törlést jelent, és úgy kell ejteni, hogy: dilit.) Ezzel a billentyűvel ki tudjuk törölni azt a betűt, amelyen éppen áll a kurzor. Igen ám, de ha csak úgy simán kitöröljük, akkor üres hely keletkezhetne a szó közepén. Nem, ezt nem engedhetjük meg! A gép is inkább azt csinálja, hogy mindazt, ami a kitörölt betűtől jobbra volt, eggyel ellépteti balra, mintegy ráhúzza az üres helyre.
Próbáljuk ki! Menjünk a kurzorral az "okooos" szó k utáni első o betűjére, és üssük le a DEL billentyűt! Egy fölösleges o eltűnik, a többi pedig balra lép. Még egyszer leütve a DEL-t, helyreáll a rend, legalábbis a helyesírásban.
Tudunk tehát betűket felülírni és törö1ni, sőt, az utóbbit kétféleképpen is. Vigyázzunk azonban, a két törlés eléggé különbözik egymástól! Az ERASE a kurzortól balra lévő betűt törli, a DEL pedig a kurzor alatt lévőt, és nem a jobb oldalit Ha például most az "oko" szóban lévő k betűre állunk a kurzorral és leütjük a DEL-t, akkor nem a jobb oldali o betű tűnik el, hanem a k, és ez marad:

Igen ám, de közben elrontottuk a szót Ennek megint nincs semmi értelme! Hogyan tudnák visszatenni azt a k betűt? Az egyik megoldás persze ismét az, hogy a hiányzó k-tól kezdve újragépeljük az egész szót. Ez most nem is lenne olyan nagy munka, de ha hosszabb a sor, akkor bizony elég fárasztó. Milyen könnyű lenne kijavítani a hibát ha a két o betű közé egy üres helyet tudnánk valahogy betuszkolni. Szerencsére az ENTERPRISE ismét a segítségünkre siet. Amit most megismerünk, az az INS (insert= beszúrás, ejtése: inzert) billentyű. Ezzel egy üres helyet tudunk beszúrni a kurzor alatt lévő betű helyére. Persze az eredeti betűt sem töröljük ki, csak jobbra léptetjük, mindazzal együtt, ami tőle jobbra van.
Vigyük hát a kurzort a második o betűre, ás üssük le az INS gombot! (Ott van mindjárt a DEL mellett.) Most már kényelmesen be tudjuk szúrni a hiányzó k betűt a keletkező Üres helyre. A képernyő újra rendben van.
Ha egymás után többször ütjük le az INS-et, akkor egyszerre több szóközt is be tudunk szúrni, és több betűt, akár egészen új szavakat is el tudunk helyezni a szöveg közepén. Egy idő után azonban igen fárasztóvá válik előre megszámolni, hogy hány betűt akarunk beszúrni, azaz hogy hány üres helyet kell előtte teremtenünk. Hosszabb szövegek beszúrásakor egyszerűbb inkább az insert (beszúrás) üzemmód használata.
A gépet eddig mindig felülírás üzemmódban használtuk, azaz ha egy, a képernyőn lévő betűre vittük a kurzort, akkor ezt a betűt egy másik billentyűvel egyszerűen felül tudtuk írni. Ha insert módban gépelünk, akkor a már a képernyőn lévő betűk nem vesznek el, hanem jobbra lépnek, helyet teremtve ezzel az új betűknek. Olyan ez, mintha minden billentyű lenyomása előtt leütnénk egyszer az INS gombot is.
Alakítsuk át a szöveget a következőképpen:

Menjünk a kurzorral a "nagyon" szó elejére, nyomjuk le a gépen alul, bal oldalon lévő CTRL (control= ellenőrzés, irányítás, vezérlés; ejtsd: kontrol) gombot, és miközben nyomva tarjuk, üssük le az INS billentyűt. Ekkor átlépünk insert üzemmódba. Ezt abból is láthatjuk, hogy a kurzor megváltozik. Insert üzemmódba, a kurzor nem egy négyszög, hanem egy kis nyilacska. Most egészen nyugodtan gépeljük be a "nagyon" szót még egyszer. Látjuk, hogy az eredeti szöveg minden billentyű lenyomásakor jobbra tolódik, de nem tűnik el. Ne felejtsünk el az új szó végére szóközt tenni, különben a két "nagyon" egybeolvad. Az insert üzemmódból felülírás üzemmódba ugyanúgy tudunk visszalépni, mint ahogy beléptünk, azaz a CTRL és az INS billentyűk együttes lenyomásával.

Tegnap megtanultunk gépelni a képernyőre. Persze nemcsak mi tudunk ide írni, hanem a számítógép is. Ahhoz azonban, hogy ezt megtegye előtte meg kell neki parancsolnunk, mert ez a gép hiába ügyes és szolgálatkész, magától semmit sem csinál. Vegyünk egy általánosan használt, optimizmust sugárzó példamondatot, és írassuk ki a képernyőre. Ha a gép helyett egy barátunkat akarnánk megkérni, ilyesformán fogalmazhatnánk:
-Légy szíves, írd ki azt, hogy "ez mar döfi"
és a barátunk minden bizonnyal meg is tenné nekünk. A gépnek azonban hiába írnánk be ezt, a ugyanis magyarul nem ért, csak BASIC nyelven. Ha neki akarjuk ezt megparancsolni, akkor azt kell beírnunk:

Az idézőjelet, amelyet a szöveg elé és mögé tettünk az előbbi sorban, a kettes szám billentyűjén találjuk meg, és a SHIFT billentyűvel együtt leütve tudjuk begépelni. Ami az idézőjelek között áll, azt pontosan értjük: ez az, amit ki kell írni. De mi az, ami előtte áll? A print angol szó, ugyanúgy kell ejteni mintha magyarul volna, és azt jelenti: nyomtass! Ezzel a szóval parancsoljuk meg a gépnek, hogy kiírja azt, ami mögötte áll. Keressünk hát egy üres sort a képernyőn és íjuk be a fenti parancsot. Fontos, hogy üres sor legyen, mert különben a gép nem tudja kiválogatni a sok mindenféle közül azt, amit éppen akarunk tőle.
Most tehát begépeltük életünk első BASIC parancsát. De hiába, nem történik semmi! Persze, hiszen a gép nem tudhatja, hogy már befejeztük gépelést. Ahhoz, hogy végrehajtsa a parancsunkat, vigyük a kurzort (ha nincs már ott) abba a sorba, ahol a parancs áll , és üssük le a gép jobb oldalán lévő zöld ENTER billentyűt. Az enter is angol szó, azt jelenti : belépni, beírni, és ezzel a billentyűvel jelezzük a gépnek, ha beírtunk neki valami üzenetet. Amint lenyomtuk a gombot, az alatta lévő sorba gép engedelmesen kiírja a szöveget, majd az ok üzenetet, és újra megjelenik a kurzor.

Sikerült hát parancsolnunk, és a gép engedelmeskedett. Mi történik azonban, ha elrontjuk a gépelést? Felrobban a gép? Dehogy, dehogy! Legfeljebb nem érti meg, mit akarunk tőle, és. visszaüzen nekünk valamit. Sajnos azonban nem magyarul, hanem angolul. De azért nem kell el keseredni , elég könnyű megtalálni a hibákat. Próbaképpen töröljük ki a gép által kiírt feliratot (azaz írjuk felül csupa szóközzel), majd menjünk fel az előző parancsa és írjuk át a print kulcsszót prunt-ra! Elég csak az i betűt felülírnunk, utána rögtön nyomhatjuk az ENTER-t.

Az angol szöveg azt jelenti: nem értem". (A német gépek természetesen németül írják ki.) Valóban, a gép csak a pontosan leírt parancsokat érti meg. Erre később is figyeljünk oda, és ne lepődjünk meg, ha a gép hibát jelez. Ilyenkor olvassuk el figyelmesen a begépelt szöveget, sokszor igen könnyen megtaláljuk a hiba okát.
Most ismét menjünk az utasításunk sorára, és javítsuk ki a print szót. Próbáljuk most megváltoztatni az idézőjelek között lévő szöveget! Írjuk át "ez aztan dofi"-re! (Ehhez két üres helyet is be kell szarnunk, de mi már ugye tudjuk, hogy ezt az INS gombbal tudjuk megcsinálni.) Ha most ismét lenyomjuk az ENTER-t, ezt kapjuk:

Nocsak! Tehát a gépet nem érdekli, hogy mi van az idézőjelek között, ő betűről betűre átmásolja azt, amit mi beírtunk, és nem törődik az értelmével. Akár értelem nélküli zagyvaságokat is kiírathatunk, sőt, a BASIC parancsokat is, mert ami az idézőjeleken belül van, azt a gép el sem olvassa, csak lemásolja. Próbáljuk ki: (a felesleges betűket töröljük ki az idézőjelek közül!)

Hát ez nem egészen az, amit vártunk! Nem a gép a hibás, mi voltunk figyelmetlenek. Nem töröltük le a korábbi feliratot. A gép szépen rendben kiírta az újat, de azt nem tudhatta, hogy már van valami a képernyőn, és ezért ott is hagyta. Így lett a "print" szóból és az előzőleg kiírt "az tan" szó végéből "printtan". Ha el akarjuk kerülni ezt a hibát, akkor vagy töröljük le a korábbi felirat (esetleg az egész képernyőt), vagy tegyünk annyi szóközt az új szöveg végére, hogy az felülírja a régit.
Most már tudunk szövegeket kiíratni, de jó lenne, ha nemcsak egy sorba tudnánk. Ehhez azonban meg kell írnunk életünk első programját! Gépeljük be a következő utasításokat! (Ne feledkezzünk meg sorok elején álló számokról és a sorok vég mindig nyomjuk le az ENTER billentyűt!)

Háromszor írtuk azt, hogy print, háromszor nyomtuk le az ENTER billentyűt, és a gép mégsem írt ki semmit. Nem is tehette, hiszen ezek utasítások egy program részei, a programokat pedig gép csak külön parancsra hajtja végre. De hát honnan tudta, hogy ezek programsorok? A számokból! A sorok elején álló számok az mutatják meg, hogy egy utasítás a program hányadik sora. No de az hogy lehet, hogy egy program a harmincadik során kezdődik, a tizedik sora az utolsó, első-sora pedig egyáltalán nincs is?
Nos, a tanulság kedvéért kissé megkavartuk a dolgokat. Amikor a programsor beírása után megnyomtuk az ENTER-t, a gépnek első dolga volt megvizsgálni a sorszámot, és növekvő számsorrendbe tenni a sorokat. Nekünk éppen ezért nem kell sorrendben beírnunk őket, kezdhetjük a program írását a közepén, majd folytathatjuk az elejével de mehetünk tovább a végére is. A hiányzó sorszámok pedig a gépet egyáltalán nem zavarják, nekünk azonban így kényelmes, ugyanis ha akarjuk, utólag is be tudunk írni egy-egy új sort a régiek közé -mondjuk a 10-es után a 11-est, a 12-est ás így tovább. Csak arra kell vigyáznunk, nehogy egy korábban használt sorszámot újra beírjunk, mert akkor egyszerűen kicseréljük a régi sort az újjal, majdnem úgy, mintha a képernyőn írnánk át.
De most aztán tényleg jó lenne lefuttatni a programunkat. (A "lefuttatni" itt nem azt jelenti, hogy leküldjük a boltba tejért, hanem hogy végrehajtatjuk a géppel.) Nyomjuk le az FUNCTION 1 jelzésű kék billentyűt! Ez jelenik meg (feltéve, hogy nem rontottuk el a program gépelését):

30 print "programozni"
20 print "tudunk"
10 print "Mi mar"
START
Mi mar
tudunk
programozni
ok

A START szót az FUNCTION 1 billentyű hatására írta ki a gép. Azt már láttuk, hogy a kék színű, ún. funkcióbillentyűkkel parancsokat tudunk kiadni. Az FUNCTION 1 billentyűvel a START parancsot adtuk ki, ami a gépben lévő programot futtatja le. Persze kiadhattuk volna ezt a parancsot úgy is, hogy egy üres sorba beírjuk: start, és lenyomjuk az ENTER-t, de így egyszerűbb és gyorsabb. (Vigyázzunk, mert ha a gépben nincs program, akkor ez a parancs egészen mást csinál, ilyenkor a piros STOP billentyűvel tudunk újra munkához látni.)
Programunk tehát szépen lefutott, és kiírta a kívánt sorokat. De bizony a képernyőn annyi mindenféle van, hogy alig lehet megtalálni, mi is az, amit a program írt. Jó lenne letörölni a képernyőt, és egy tiszta lapra íratni ki a sorokat.
No, de ha letöröljük a képet, nem vész el a programunk?
Nem, a gép a program minden sorát - amint legépeltük és az ENTER billentyűvel "elküldtük" elteszi a tárjába, és akkor is megőrzi, ha a képernyőről eltűni. Takarítsuk hát le a képet (FUNCTION 5= TEXT), és újra futtassuk le a programot (FUNCTION 1= START). No, most már jól olvasható a szöveg. Persze elég unalmas lenne, ha a program minden futtatása előtt nekünk kéne letörölnünk a képernyőt. Csinálja ezt inkább maga a program! Írjuk be a következő utasítást:

Hát ez meg mi? új utasítást adunk a programhoz, amikor a program nem is látható?
Igen, ez egészen egyszerű. Hiszen a gép már eltette magának a 10-es, 20-as, 30-as sorszámú sorokat, most ezt az 5-ös sorszámú sort szépen elébük rendezi. És mi az, hogy "clear screen"? Hiszen a képernyőt a TEXT utasítással szoktuk törölni? (Amit az FUNCTION 5 billentyű lenyomásával adunk ki.)
Nos, a helyzet az, hogy a TEXT utasítás nemcsak aképernyőt törli , hanem néhány más dolgot is csinál amivel most még korai lenne foglalkoznunk. Tulajdonképpen használhatnánk azt is, de majd később meglátjuk, hagy ha csak a képernyőt akarni törölni, akkor jobb a clear screen parancs. (Ez is ugyanolyan parancs, mint a többi, tehát ha egy üres sorba beírjuk, és ENTER-rel "elküldjük", akkor szépen letörli a képet.) A clear angol szó (ejtsd: klír) azt jelenti: "tisztítsd meg", a screen (kimondva: szkrín) pedig a képernyő. Most már tehát nem kell előre kitakarítanunk a képet, el ég a programot elindítani. Próbáljuk ki!
A program tehát tényleg letörölte a képernyőt, sőt, már a START parancs sem látszik. Ez logikus, hiszen a parancsot még a program előtt adtuk ki (éppen ezzel indítottuk el a programot), tehát a többi szöveggel együtt törlődött. De hát akkor soha többé nem láthatjuk a programunkat újra? No, azért ettől nem kell megijedni! A gép bármikor szívesen kilistázza nekünk, csak utasítanunk kell rá. Erre a LIST parancs szolgál, amit ejteni "liszt"-nek kell ugyan, de a jelentése listázás. No és persze, mint a többi gyakran használt utasítást, ezt sem kell betűnként beírnunk, hanem egyetlen funkcióbillentyűvel kiadhatjuk. Ez az FUNCTION 2 billentyű. Nyomjuk meg!

LIST
5 CLEAR SCREEN
10 PRINT "Mi mar"
20 PRINT "tudunk"
30 PRINT "programozni"
ok

A programunk listája tehát bármikor kiíratható. De ez a lista már egy kicsit eltér az eredetitől. Egyrészt a gép szépen sorba rakta az utasításokat a sorszámok szerint, ezzel nekünk segít, hogy jól láthassuk, milyen sorrendben fogja végrehajtani őket. A másik különbség, hogy a BASIC, nyelv szavait nagybetűkkel írta ki, így egyszerűen meg tudjuk különböztetni őket a többi szövegtől. Ha akarjuk, a parancsokat mi is írhatjuk így, de nem kötelező. A gép számára mindegy, milyen betűket használunk, sőt, akár egy szón belül is változtathatjuk, így a következő parancsok mind helyesek:
PRINT, Print, print, PRInt
De ha ezekest a parancsokat beírjuk egy programba és azután kilistáztatjuk, akkor mindegyik print csupa nagybetűvel tűnik fel a képernyőn.
Futtassuk le még egyszer a programunkat! (FUNCTION 1) Aztán még egyszer! A szöveg jól olvasható, csak az zavaró, hogy a gép ok. üzenete teljesen egybefolyik azzal, amit mi írtunk ki. Jó lenne egy üres sort is kiírni a program végén, hogy az üzenetet elválassza. De hát hogyan? Mit kell írni a print után, hogy egy üres sort írjon ki?
A válasz rendkívül egyszerű: semmit! Ha a print utasításban semmi sincs a parancsszó (általában úgy hívjuk: kulcsszó) után, akkor a gép csak egy üres sort illeszt a szövegbe, nem ír bele semmit.Próbáljuk ki! írjuk be a következő sort (ne felejtsük el, a végén az ENTER-t):

Ha most futtatjuk le a programot, akkor már egy üres sor is van , szöveg alatt. Próbáljuk ki! Után nézzük meg a program listáját:

5 CLEAR SCREEN
10 PRINT "Mi mar"
20 PRINT "tudunk"
30 PRINT "programozni"
40 PRINT

Az úi sor tehát rendben bekerült a többi közé pontosabban után, mivel a sorsszáma nagyobb minden eddiginél.
Most azonban újabb feladat következik. Írassuk ki az előbbi szöveget, de egyetlen, sorba! Ez lenne az a nehéz feladat? Hiszen ez pofonegyszerű. Írunk: egy print utasítást, és beleírjuk az egész szöveget .
Természetesen így is lehet, de akkor újra le kel gépel ni az egészet. Van azonban ennél egyszerűbb megoldás is. Ez idáig, ha kiírtunk valamit, akkor következő print utasítás a következő sor elején folytatta az írást. Ez azonban nem mindig van így. Ha az utasítássor végére egy pontosvesszat teszünk, akkor a következő kiíró utasítás ott folytatja a kiírást, ahol ez abbahagyta. Tegyünk hát a 10-es és a 20-as sor végére egy-egy pontosvesszőt! Ne felejtsük el az ENTER-t lenyomni a megváltoztatott sorokban, különben a gép nem módosítja őket. Ha biztosak akarunk lenni abban, hogy sikerült a változtatás, listáztassuk ki ismét a programot:

5 CLEAR SCREEN
10 PRINT "Mi mar";
20 PRINT "tudunk";
30 PRINT "programozni"
40 PRINT

Hát ez bizony nem egészen az, amit vártunk. Igaz ugyan, hogy egy sorba írta a szöveget, de az olvashatatlanul egybefolyik. Mi a baj? Rendkívül egyszerű. A gép nem érti meg azt, ami az idézőjeleken belül van, csak betűről betűre átmásolja. A második kiíró utasítás pedig pontosan a parancsunknak megfelelően ott folytatta az írást, ahol az első abbahagyta, azaz a "mar" szó után rögtön folytatta a "tudunk" szóval - nem választotta el őket. Ha olvasható szöveget akarunk kapni, listáztassuk ki ismét a programot, és szúrjunk be egy-egy szóközt a "tudunk" és a "programozni" szó elé, de persze az idézőjeleken belülre:

5 CLEAR SCREEN
10 PRINT "Mi mar";
20 PRINT " tudunk";
30 PRINT " programozni"
40 PRINT

No ez már igen! Ez az, amit akartunk! Az üres print utasítás tehát nem ír ki semmit, de mint minden rendes print, amelyet nem követ pontosvessző, a következő sor elejére Viszi a kurzort, azaz sort emel. De akkor mit csinál az olyan üres print utasítás, amelynek a végér pontosvessző áll? A válasz kézenfekvő: semmit. Az ilyen utasítás olyan, mintha ott sem lenne. Írjuk be hát:

Futtassuk le a programot! Látható, hogy semmi sem változott, minden ugyanúgy íródik ki, mint eddig. Ha azonban kilistázzuk a programot, egyből feltűnik az új sor:

5 CLEAR SCREEN
10 PRINT "Mi mar";
15 PRINT ;
20 PRINT " tudunk";
30 PRINT " programozni"
40 PRINT

Ez a sor tehát végrehajtódik, de nem csinál semmit. Akkor viszont fölösleges, tehát ki kell törölni. De hogyan? Azt már tudjuk, hogy ha egy új sort olyan sorszámmal írunk be, ami már létezik a programban, akkor az új sor felülírja a régit. De mi történik akkor, ha az új sorban nincs semmi? Nos, a gép ekkor is felülírja a régi sort, de mivel az új sorban nincs semmi, a sor valójában törlődik. Írjuk hát be:

Ne felejtsük el rögtön a szám után leütni az ENTER-t, különben a gép nem törli a sort. Ha most kilistáztatjuk a programot, láthatjuk, a 15-ös sor eltűnt. Ha nem üres sort adtunk volna meg, akkor nem töröltük, hanem kicseréltük volna a sort. Ezt is kipróbálhatjuk! Gépeljük be:

5 CLEAR SCREEN
10 PRINT "Mi mar";
20 PRINT" szeretunk";
30 PRINT " programozni"
40 PRINT

A mai napon nagyon sok mindent tanultunk meg. Foglaljuk össze a legfontosabbakat!

Tegnap igen nehéz napunk volt, ma hát próbáljunk egy kicsit játszani. Persze a mi játékaink nem olyan ügyesek, mint a boltban kaphatók, de ezekről legalább elmondhatjuk, hogy mi magunk csináltuk. Kezdjük egy kis kígyóbűvöléssel! Írjuk be következő programot:

10 do
20 print"O"
30 print" O"
40 print" O"
50 print" O"
60 print" O"
70 print" O"
80 loop

Futtassuk le! A képernyőn Megindul egy kígyó fölfelé, és fut-fut végeláthatatlanul. Hogyan is van ez? Nézzük csak meg a programot! Azt látjuk, hogy a program kirajzolja a kígyó elejét. Ezt ugye a 20-as és a 70-es sor közötti rész csinálja. De miért folytatja a gép tovább?
No hát természetesen az eddig még nem ismert DO LOOP utasításoktól. Ha jobban megnézzük a képernyőn futó rajzot, könnyen észrevehetjük, hogy a futó kígyó valójában nem más, mint a 20-as és a 70-e sorok közötti programrész által kirajzolt ki "kígyódarab" egymás után újra és újra lemásolva. Lerajzolja egyszer, majd alája még egyszer, mai még egyszer, és így tovább. Azaz végrehajtja 20-as és a 70-es közötti sorokat, majd megismétli újra és újra, mindig elölről kezdve őket.
Nos, a do - loop ciklus éppen erre való! Amikor a program először odaér a do utasításhoz, nem csinál semmit, csak megjegyzi, hogy majd ide kell visszaugornia. Aztán nyugodtan megy tovább, egészen addig, amíg egy loop utasítást nem talál. Akkor megnézi, hol volt a legutóbbi do utasítás, és visszaugrik oda. Így járkál körbe- körbe egy végtelen ciklusban, éppen ezért az ilyen programszerkezetnek (azaz az utasítások ilyen elrendezésének) a neve végtelen ciklus. Egy dologra kell csak ügyelnünk, mégpedig arra, nehogy véletlenül előbb legyen a végtelen ciklus "vége", mint az "eleje", azaz nehogy a loop utasítás legyen elöl. Ha ugyanis a gép olyan loop-ot talál, amihez még nem volt do, akkor nem tudja, hova kell ugorni, és hibát jelez. Ez tehát a végtelen ciklus.
Végtelen? Akkor hát soha nem hagyja abba ezt a kacskaringózást? Hát magától nem, de azért persze mi meg tudjuk állítani. Erre való a piros STOP billentyű, amely jobb oldalt, felül található. Bármelyik programot (nemcsak a végtelen ciklusokat!) bármikor meg tudjuk állítani, csak ezt a gombot kell megnyomnunk. Nyomjuk hát meg!
A kígyó tényleg megáll, a gép kiírja, hogy hányas sorszámú utasítást hajtotta végre utoljára, amikor megnyomtuk a STOP-ot, aztán újra parancsra vár. De jó lenne, ha egy kicsit folytatná még! Semmi akadálya. Nyomjuk le a SHIFT billentyűt, és miközben nyomva tartjuk, üssük le az FUNCTION 1-et. Újra kezdjük a programot? Hiszen az FUNCTION 1 billentyű lenyomásával a START parancsot adjuk ki, az pedig elölről indítja a programot. Nem, most nem ez történik. Ha egy kék színű billentyűt (ún. funkcióbillentyűt) nem önmagában nyomunk le, hanem a SHIFT-tel együtt, akkor ugyanúgy, mint a rendes betűbillentyűknél; megváltozik az értelme. Csak itt persze nem az történik, hogy nagybetűkkel adja ki azt a parancsot, amit eddig kicsivel adott (hiszen mi tudjuk, hogy a gépnek úgyis mindegy, milyen betűkkel írunk le egy utasítást), hanem egy egészen más parancsot fog jelenteni. Az F1+SHIFT együtt, a CONTINUE parancsnak felel meg, ez a parancs pedig éppen arra való, hogy egy STOP-al megszakított programot ott folytassunk, ahol abbahagytuk. (A continue angol szó, kiejtése: kontinyjú, és azt jelenti: folytatás.) A parancsot persze(mint minden más parancsot is) nemcsak a funkcióbillentyűkkel adhatjuk ki, hanem úgy is, hogy begépeljük. Próbáljuk ki Állítsuk meg programot a STOP-pal, és írjuk be:

Amint leütjük az ENTER-t, a program szépen tovább fut. Egy dologra azonban figyelnünk kell. A csak akkor tudja folytatni a programot, ha azt közben nem változtattuk meg. Ha ugyanis néhány sort írunk be, a gép nem tudhatja, hogy most az új sorok előtt vagy után folytassa a futást. Ha tehát valami megváltozik, vagy valami olyan történik, ami a gépet zavarja akkor a gép visszaüzen:

vagy egy hasonló német szöveget. Megüzeni tehát, hogy a folytatás nem lehetséges.
Persze sokan mondhatják, hagy hiába folytatjuk ugyanonnan a programot, ha már közben telefirkáltuk a képernyőt. Ha csak azért akarjuk megállítani a programot, hogy megnézzük alaposabban, amit kiírt de nem akarunk semmit sem változtatni, akkor egyszerűbb a STOP melletti HOLD billentyűleütnünk. (A HOLD azt jelenti: felfüggesztés) Ekkor a program megáll ott, ahol éppen tart, de a kurzor nem jelenik meg képernyőn, tehát nem tudunk semmit sem változtatni. A legfelső sorban bal oldalt a gép kiírja azt, hogy HOLD, de ez most nem az égitestet jelenti, hanem, hogy a gép felfügesztette a program futását. Ha most aztán folytatni akarjuk, akkor csak a PAUSE billentyűt kell ismét lenyomnunk, és program rendben tovább fut. Próbáljuk ki!
Állítsuk meg a STOP-pal a programot, és listázz ki:

10 DO
20   PRINT "O"
30   PRINT " O"
40   PRINT " O"
50   PRINT "   O"
60   PRINT " O"
70   PRINT " O"
80 LOOP

Hát ez bizony nem pontosan olyan, mint amit mi beírtunk! Lapozzunk csak előre, ás hasonlítsuk össze! No igen, a kulcsszavakat nagybetűvel írta, és a PRINT-ek után kitett egy-egy szóközt, de hát ezt már megszoktuk. De miért tolta beljebb a PRINT-eket két-két oszloppal? Nos éppen azért, hogy jól láthassuk, melyik utasítások vannak a cikluson belül.
Hát erről a programról már minden tudunk, most ki kéne törölni és egy újat kezdeni. Kitörülni? Nem korai még? Hiszen alig néhányszor futtattuk le, és különben is, jó lenne másoknak is megmutatni. Ha most kitöröljük, akkor legközelebb újra be kell majd gépelni az egészet elölről.
Szerencsére lehet ezt másképp is csinálni! Éppen erre, a kedvenc programjaink megőrzésére szolgál a kazettás magnó. Mint tudjuk, ahány kazettás magnó, annyiféle. Mi most nem vehetjük végig az összes létező magnetofontípust, így hát csak azt írjuk le, hogy a géphez leggyakrabban használt OMEGA 8017 magnóval mi a teendő. Aki mást használ, a saját készülékének megfelelően értelmezze a szöveget.
Ez a magnó abban tér el a legtöbb asztali kismagnótól, hogy távvezérelhető. Ez azt jelenti, hogy a szalagot a számítógép automatikusan le tudja állítani, ha már befejezte a felvételt. Ehhez azonban megfelelően csatlakoztatni kell. A gép hátoldalán, szorosan egymás mellett négy apró lukat találhatunk, sorban a REM1, IN, OUT, REM2 feliratokkal megjelölve. A géphez két magnócsatlakozó-kábelt kaptunk: ezek egészen egyformák, legfeljebb a színük különbözik. Mindkét csatlakozókábel mindkét végén két-két dugó van, egy vastagabb és egy vékonyabb. Először kössük össze az egyik vastagabb dugó kábellel a gép IN feliratú kimenetét a magnón lévő IN bemenettel, majd a másik vastag dugós vezetékkel a két OUT feliratú aljzatot. (Márminthogy a számítógépen lévőt a magnetofonon lévővel.) Végül válasszuk ki az egyik vékonyabb dugós vezetéket -mindegy, hogy melyiket -, és ezzel a gép REM1 aljzatát csatlakoztassuk a magnó "REM" bemenetére.
No, most már csak egy kazettát kell betennünk a magnóba, és kezdődhet a felvétel. Tekercseljük a kazettát oda, ahova fel akarjuk venni a programot. Lenyomjuk a gyorstekercselés gombját... de nem indul.
Vajon mi miért? Áram van (a magnó csatlakozóját bedugtuk a konnektorba), kazetta van, jó gombot nyomtunk le, és mégsem tekercsel a készülék. Miért? Hát a távvezérlés miatt. Ahhoz, hogy tekercselni tudjunk, előbb ki kell kapcsolnunk a távvezérlést. De hiszen csak most dugtuk Össze, máris kezdjük szétszedni? No erre azért nincs szükség. Elég lesz szólni a gépnek, hogy most nem kell a távvezérlés. Nyomjuk le az FUNCTION 4 billentyűt! A képernyőn rögtön feltűnik a kiadott parancs:

A teljes szöveg "toggle remote control 1" lenne, ami azt jelenti: "kapcsold át az egyes távvezérlést a másik állásba", azaz ha eddig be volt kapcsolva, akkor ki, ha ki volt, akkor be. Most már tudunk tekercselni a magnón. Ha azonban odaértünk, akkor fel akarunk venni, ne felejtsük el újra átkapcsolni a távvezérlést, azaz nyomjuk le megint az F4 billentyűt!
Ahhoz, hogy felvegyünk egy programot, először a magnót kell vétel Állásba hoznunk, majd utasítanunk kell a számítógépet, hogy kezdje el felvételt. A magnón tehát nyomjuk le a lejátszás és a felvétel gombokat egyszerre. (úgy, ahogy azt a magnó gépkönyve is írja.) Most írjuk be a gépbe a következő parancsot:

A magnó elindul, pedig hozzá sem nyúltunk, a hangszóróból előbb rövidebb, aztán kicsit hosszabb ideig furcsa fütty hallatszik, aztán újra leáll a magnó, most már akár ki is kapcsolhatjuk. A felvétel kész. Amíg azonban folyt a felvétel, a felső státusz (állapot) sorban ez volt olvasható:

Hát igen, ez így egy kicsit sok egyszerre. Vegyük szépen sorjában, mi is történt. A magnó azért indult el magától, mert a számítógép felvétel előtt automatikusan elindította. Éppen ez a távirányítás lényege: nem kell nekünk indítani, leállítani a magnót, hanem ezt a gép csinálja helyettünk. A fütty, amit hallottunk, a saját programunk volt. A gép ugyanis hangokká alakította a programot, és ezeket a hangokat vette fel a kazettára. Ha akarjuk, meg is hallgathatjuk, bár sokáig nem érdemes, mert csak megfájdul tőle a fejünk.. A felirat a státusz sorban ezt jelenti: "az elso programom nevű program felvétele folyik". Tehát neve is van a programunknak? És ha szabadna kérdeznem, ki adta neki pont ezt a nevet?
Hát mi magunk! A save parancs - amit kiadtunk - ugyanis éppen, azt csinálja, hogy a gépben lévő programot azon a néven menti el a szalagra, amit mi idézőjelek között megadtunk. Bármilyen nevet adhatunk a programunknak, csak egyre kell vigyáznunk! A név nem lehet több, mint 28 betű és jel, ideértve a szóközt is. A gép a program nevét is felveszi a szalagra, a két fütty közül az első, a rövidebbik éppen ez a név volt. Persze ha utólag meghallgatnánk, elég nehezen ismernénk rá a név alapján. Nem is kell, elég, ha A gép felismeri.
A programunk tehát a szalagon van, de hogyan tudunk erről meggyőződni? Hátha rossz volt szalag, hátha nem sikerült a felvétel?
A fölvett programot természetesen ellenőrizni is tudjuk: összehasonlíthatjuk az eredetivel, amely tárban van. (A tárban van? Hiszen éppen az előbb írtuk ki a kazettára! No, attól azért még ne törlődött ki, nem kell félni.) Persze nem úgy kell összehasonlítani , hogy meghallgatjuk a kazettát, és megpróbáljuk kitalálni, vajon mit is jelentenek az egyes hangok. Az összehasonlítást is maga a gép végzi. Tekercseljük vissza a kazettát oda, ahol programunk kezdődik. (Ehhez persze ismét ki, majd utána be - kell kapcsolnunk a távvezérlést!) Hozzuk magnót lejátszás állapotba és mondjuk meg számítógépnek:, hogy kezdje meg az "elso programom" nevű program összehasonlítását. Nyomjuk tehát le a magnón a lejátszás gombot, és íjuk be a számítógépbe a következő parancsot:

A verify (ejtsd: verifáj) azt jelenti: igazolni. A magnó szépen elindul, a státusz sorban pedig feltűnik: az üzenet:

Ezt úgy kell ejteni: szörcsing és azt jelenti keresés. A számítógép tehát keresi a felvett programot a kazettán. A jobb oldalon, felül azonban egy kis zöld négyzet is látható! Ez azt jelenti, hogy a magnó nem túl hangos. Ha ez a négyzet eltűnik, és helyette egy piros jelenik meg, akkor vegyük egy kicsit lejjebb a magnón a hangerősséget, mert a gép sokallja. Kis idő múlva felhangzik a fütty, és a gép elkezdi leolvasni a felvett program nevét. (Mi már ugye tudjuk, hogy ez ott van a szalagon a program előtt.) Ha leolvasta, és egyezik azzal, amit a verify utasításban megadtunk, ki is írja:

Jelzi tehát, hogy folyik az "elo programom" nevű program betöltése. Betöltése? Hiszen mi csak össze akartuk hasonlítani a tárban lévővel! Nem kell megijedni, a gép nem tölti be a programot, csak ezt írja ki, de mi tudjuk, hogy szó sincs töltésről. (Egyáltalán, mi az hogy betöltés? Nos, betöltésnek a szalagon levű programnak a tárba való beolvasását nevezzük, de erről később még bőven szó lesz.) Felhangzik a fütty, és a gép elvégzi az összehasonlítást. Ha nem talál hibát, szépen kiírja: ok, és megállítja a magnót. Most már nyugodtak lehetünk: a programunk biztonságban megvan a szalagon.
És ha a gép hibát talál? Nos, akkor hibaüzenetet ír ki. Ilyenkor próbáljuk meg megváltoztatni a hangerőt, és végezzük el újra az ellenőrzést. Ha ez sem vezet eredményre, próbáljunk ki egy másik kazettát, hátha a szalag sérült. Vegyük fel arra is a programot, és ellenőrizzük. Ne ijedjünk meg, ha eleinte nem sikerül elsőre a felvétel, később majd belejövünk.
Gyakori eset, hogy nem a program elejére tekercseltünk, hanem egy, kicsivel hátrább. Ilyenkor a gép nem találja a program nevét, és nem állítja le a magnót. Semmi gond, egyszerűen állítsuk meg a magnetofont, tekercseljünk egy kicsit előrébb, és újra indítsuk el. (Ilyenkor nem kell a távvezérlést kikapcsolni a tekercseléshez.)
Ha már több programunk is van egy kazettán, az is előfordulhat, hogy véletlenül egy másik program elejére állunk. Ilyenkor a gép elolvassa a program nevét, de mivel nem ezt adtuk meg a verify utasításban, nem hasonlítja össze, hanem kiírja, hogy:

A found (ejts: faund) azt jelenti: "a másik program nevű programot találtam". Persze nem okvetlenül azt írja ki, hogy "másik program", hanem azt a nevet, amelyet leolvasott a szalagról. Ilyenkor a gép nem is állítja le a szalagot, hanem tovább keres. Ha már biztos, hogy nem találjuk a programunkat, akkor a STOP billentyűvel tudjuk leállítani a keresést. Ezt kell használnunk akkor is, ha a programunk neve sérült meg a szalagon és ezért nem ismeri fel a gép. (Ez nem is olyan ritka.) Ilyenkor természetesen a magnót is megállítja a számítógép. Előbb-utóbb azért bizonyára sikerrel járunk, és néhány próbálkozás után már megtanuljuk, hogyan tudunk jó felvételeket csinálni. Nemsokára már úgy fogjuk érezni, hogy ez az egész ellenőrzés teljeser fölösleges, mert úgyis minden felvételünk jó. De aztán ha mégis eltűnik egy programunk, ne szidjunk másokat - csak magunknak köszönhetjük. Most tehát már biztosak lehetünk, hogy jó a felvételünk, a tárból akár ki is törölhetjük a programot, hiszen megvan kazettán.
Kitörölni? Megint kapcsoljuk ki meg be a gépet? Nem, ennél egyszerűbb út is van. Írjuk be a következő parancsot:

A new angol szót nyú-nak kell ejteni, azt jelenti: új, és arra kéri a gépet, hogy mivel új programot akarunk kezdeni, ezért legyen szíves törölje a régit. Mindezt egyetlen szóval! Ebből is látszik, hogy a BASIC nyelv nem a sszószátyár embereknek készült. A gép persze hűségesen engedelmeskedik, és ha most kiadjuk e LIST parancsot, bizony csak a semmit írja ki.
Jó lenne kipróbálni , hogyan tudnánk újra a gépbe tölteni előző programunkat! Ennek semmi akadálya! Szinte ugyanúgy kell eljárnunk, mint az ellenőrzésnél , csak a parancsszó lesz más. Tekercseljünk tehát a programunk elejére ne felejtkezzünk meg a távvezérlés átkapcsolásáról), kapcsoljuk a magnót lejátszásra, és írjuk: be:

A load angol szó ( ejtsd: lód), azt jelenti: rakodni , tölteni , és mi most valóban betöltjük a gépbe a programunkat. A magnó elindul, és a program betöltődik. Itt ugyanazok a hibák lesnek ránk, mint az ellenőrzésnél , tehát nem is érdemes leírni ezeket még egyszer. Hibák esetén ugyanazt kell tennünk, mint ott , persze ha rossz a felvétel, akkor sajnos nem tudunk segíteni.
Van azonban valami, amit még el kell mondanunk, hiszen nemi biztos, hogy mindig tudni fogjuk, mi a pontos neve annak a programnak, amelyet be akarunk tölteni. Ilyenkor elég, ha odatekercselünk a program elejéhez és nem adunk meg semmilyen nevet, csak egy üres töltő utasítást:

Ekkor a gép az első programot tölti be, amit a szalagon talál, tehát nem ellenőrzi a nevet. Ezt a verify utasításban is megtehetjük, de akkor vigyáznunk kell, nehogy egy mási k programmal kezdjük el összehasonlítani, mert az hibát jelent.
Ha a programunkat betöltöttük, utána már egészen olyan mintha éppen most gépeltük volna be, azaz bármikor kilistáztathatjuk, lefuttathatjuk, vagy akár meg is változtathatjuk, de az eredeti változat marad nekünk a kazettán, onnan bármikor újra Betölthető. Ha akarjuk, más-más néven más programokat vagy ennek a programnak más változatait is felvehetjük kazettára, megkezdhetjük saját programkönyvtárunkkialakítását.
Ma ismét sokat haladtunk, megismerkedtünk:

A mai napon egész nap a képernyőn fogunk "bűvészkedni", de mivel minden bűvész kis trükkökkel kezdi, mi is csak fokozatosan varázsoljuk el a gépet. Az első feladatunk rendkívül egyszerű: csináljunk programot, amely letörli a képernyőt és a bal felső sarokba kiír egy X betűt. Nos, lássuk!

A 20-as sor törli a képet, a 30-as pedig kiírja az X-et. Azt viszont, hogy hová írja ki, nem mondtuk meg. Vajon mit lép erre a gép? Hova írja az X-et? Próbáljuk ki, futtassuk le a programot!
Az X tényleg ott van a bal felső sarokban! És ha újra meg újra lefuttatjuk a programot, mindig oda kerül. Az ok rendkívül egyszerű: a képernyő törlése után a kurzor mindig a bal felső sarokba kerül, ha tehát képernyőtörlés után írunk A valamit, akkor az a bal felső sarokban jelenik meg. Folytassuk egy kicsit a programot:

Ez a két sor majdnem ugyanolyan, mint az első kettő, csak a PRINT utasításban van egy szóközzel több. Futtassuk le így is a programot! Egy pillanatra feltűnik az X a bal sarokban, majd lép egyet jobbra, és ott megáll. Próbáljuk ki néhányszor, hogy megfigyelhessük! Megmozdult a betű a képernyőn? Elindult?
No nem, azért errő1 szó sincs! Csupán annyi történt, hogy először kiírtuk a bal felső sarokba, majd (az 50-es sorban, az X előtt álló szóközzel) letöröltük, és kiírtuk egyel jobbra. De a gép ezt olyan gyorsan csinálja, hogy szinte úgy tűnik, ugyanaz az X indult sétálni. Folytassuk a programot:

Most is futtassuk le! Az X most már szinte távgyalogló. Csak úgy szalad a képernyőn, bár elég hamar abbahagyja. Így bizony alig van időnk jól megnézni. Még az a szerencse, hogy akárhányszar megismétli, csak az FUNCTION 1 billentyűt kell leütnünk. De hát mi már tudjuk, hogy ha valamit újra meg újra szeretnénk megismételtetni a géppel, akkor mi a teendőnk! Tegyük be egy végtelen ciklusba! Nosza, rajta listázzuk ki a programot:

20 CLEAR SCREEN
30 PRINT"X"
40 CLEAR SCREEN
50 PRINT" X"
60 CLEAR SCREEN
70 PRINT" X"
80 CLEAR SCREEN
90 PRINT" X"

Ezt szeretnénk újra meg újra megismételni, tehát ki kell jelölnünk, hol legyen a végtelen ciklus eleje és hol a vége. Az elejének a 20-as sor előtt kellene lennie, tehát az elé kell beszarnunk a do utasítást. Mondjuk, válasszuk a 10-es sorszámot, az ugye a 20-as előtt van, tehát nekünk megfelel. Írjuk be:

Most már csak a ciklus végét kell kijelölnünk. Az eddigi utolsó sor a 90-es, tehát a 100-as sorként beírhatjuk:

10 DO
20   CLEAR SCREEN
30   PRINT"X"
40   CLEAR SCREEN
50   PRINT" X"
60   CLEAR SCREEN
70   PRINT" X"
80   CLEAR SCREEN
90   PRINT"   X"
100 LOOP

A korábbiak tehát benne vannak a ciklusban. Ezt az is mutatja, hogy két-két oszloppal beljebb írja ki őket a gép. Indítsuk el a programot! Az X szépen el lépeget egy darabig, aztán megint kezdi. A STOP-pal leállíthatjuk, és aztán a CONTINUE-val folytathatjuk, vagy a START-tal elölről kezdhetjük a lépegetést. Akinek van kedve, megpróbálhatja egy kicsit kiegészíteni is a programot. Milyen új sorokat kéne beírni ahhoz, hogy az X egyel tovább menjen? És milyeneket ahhoz, hagy ne csak oda, hanem vissza is lépegessen?
Ki-ki próbára teheti a fantáziáját, mi újat tud még kitalálni, de ha már nincs több ötletünk, akkor folytassuk a mai leckét. Ez az X igen szépen ballag nekünk, csak az a baj, hogy ott eldugva a bal felső sarokban alig lehet észrevenni. Mennyivel jobb lenne, ha a képernyő közepén járkálna! Nosza, állítsuk meg és listázzuk ki a programunkat! Egészítsük ki a következők szerint a sorokat! Ha időközben néhány új sort is beleirtunk, semmi baj, azokat ugyanúgy kell kiegészíteni, ahogy a régieket.

10 DO
20   CLEAR SCREEN
30   PRINT AT 5,10:"X"
40   CLEAR SCREEN
50   PRINT AT 5,10:" X"
60   CLEAR SCREEN
70   PRINT AT 5,10:" X"
80   CLEAR SCREEN
90   PRINT AT 5,10:"   X"
100 LOOP

Ne felejtsük el minden megváltoztatott sorban a változtatás után megnyomni az ENTER billentyűt, különben a gép nem tárolja az új sorokat, hanem a régiek maradnak meg a tárban. Listáztassuk ki a programot, és ellenőrizzük, sikerültek-e a módosítások! Ha igen, akkor indítsuk el a programot! Látható: a képernyőn most valóban középtájon vándorol a betű. A dologban persze nincs semmi titok, a gép nem a gondolatunkat találta ki, csak azt csinálja, amit megparancsoltunk neki.
A "print at" utasítás ugyanis nem oda írja ki az utána álló szöveget, ahol a kurzor éppen áll, hanem ezáltal adhatjuk meg, hogy a képernyő hányadik sorának hányadik oszlopába akarunk írni. A fenti program az 5. sor 10. oszlopába írja ki az X-et, illetve ott léptetgeti jobbra. Ha megváltoztatjuk a számokat, akkor máshova is el tudunk menni. Vigyázzunk, nehogy lelógjunk a képernyőről! A képen összesen 24 sor és 40 oszlop van, ha ennél nagyobb számot adunk meg, a gép hibát jelez. Sőt, az is előfordulhat, hogy ha nem férünk ki egy sorban, akkor a harmadik vagy negyedik X már a következő sor elején jelenik meg.
Figyeljük meg, hogy ha változtatjuk a számokat, minél lejjebb és minél inkább jobbra visszük az X-eket, annál lassabban fognak lépegetni. Ez természetes, hiszen a gépnek mindig a bal felső sarokból kell a kurzort odavinni. Minél messzebb vagyunk, ez annál hosszabb ideig tart, azaz annál több idő telik el két lépés között.
Ha már eleget játszottunk, állítsuk le a programot és tegyünk egy érdekes kísérletet. Törljük ki a clear screen utasításokat tarta1mazó sorokat. Hogyan is kell egy sort kitörölni? Emlékszünk még? Persze! Csak a sorszámát kell begépelni, és rögtön megnyomni az ENTER billentyűt. Írjuk hát be:

Most takarítsuk le a képernyőt (F5, ügye?) és indítsuk el a programot! Az X szépen fut, sőt mintha egy kicsit gyorsabb is volna. Persze, hiszen. A törlő utasítások már nincsenek benne. De egy kicsi baj mégis akad. Az utolsó X sehogy sem akar eltűnni. A gép szépen kiírja, de nem törli le. Idáig a clear screen utasítás letörölte, de most, hogy nincs ez az utasítás a programban, nincs ami eltüntesse. De hát akkor miképp lehetséges, hogy a többi mégis letörlődik? A dolog nyitja egyszerű. A korábbi X-eket az utánuk következő print utasítás törli le, pontosabban felülírja egy szóközzel, amikor ugyanott kezdi az írást, ahol az előző print, de egyel több szóközt ír ki, és csak aztán az új X-et. Az utolsó X-et viszont senki sem írja felül, mert senki sem megy tovább. Hogyan lehetne segíteni? Semmi vész, a megoldás rendkívül könnyű! Állítsuk meg a programot és írjunk az első print utasításba az X után (de persze az idézőjeleken belülre annyi szóközt, hogy majd felülírja az utolsó X-et:

No, most indítsuk el újra a programot! Most már szép rendesen fut az X, a programunk tökéletes:

10 DO
30   PRINT AT 5,10:"X   "
50   PRINT AT 5,10:" X"
70   PRINT AT 5,10:" X"
90   PRINT AT 5,10:"   X"
100 LOOP

Nem ez volt az egyetlen lehetséges mód a hiba kijavítására. A 30-as sor változtatása helyett beszúrhattunk volna egy utasítást a teljes képernyő törlésére a 20-as sorba. Állítsuk vissza a 30-as sort, és próbáljuk ki ezt a megoldást is!

Ez egy kicsit jobb is, mert ugye az egész képernyőt törli, és így nem kell néznünk mindazt a "szemetet"' ami korábbról ott maradt, de egy kicsit rosszabb is, mert lassabb. Általánosságban elmondhatjuk, hogy ha több lehetőség közül kell választanunk, akkor valószínűleg mindegyiknek lesz előnye és hátránya is.
A mai napon inkább csak játszottunk, de azért sok fontos dolgot így is megtanultunk:

Jó kísérletezgetést!

5. nap - Egyszerű, mint a kétszerkettő

Ma tényleg csupa egyszerű dologgal ismerkedünk meg, mint a kétszerkettő. Mert ugye mennyi is kétszer kettő? Négy. Ez nem vitás. És mennyi 19675+67954? Ez ugye már egy kicsit nehezebb? De nem a gépnek! Az ENTERPRISE egy szempillantás alatt megmondja a végeredményt, csak meg kell neki parancsolni. Parancsoljuk hát meg! Hiszen már mindenfélét ki tudunk íratni a képernyőre, miért pont ezt ne tudnánk? Írjuk be:

print "19675+67854"

(A "+" jelet a német gépeken az ENTER billentyű mellett találjuk, angol gépeken pedig a ":" billentyű felső részén.)
A gép erre ezt feleli:

49675+67854

Hát ez ugye nem sikerült! Azazhogy sikerült, hiszen a gép azt csinálta, amit mondtunk neki, -arról nem tehet, hagy mi nem ezt szerettük volna. Ki adtunk egy parancsot, amely elé nem írtunk sorszámot, tehát nem programsor, hanem azonnal végrehajtandó parancs. Azt mondtuk: "írd ki azt, hogy 19675+67854", és ő szépen ki is írta: "19675+678854" Csakhogy mi azt szerettük volna, ha nem a számokat írja ki, hanem az eredményt. Nos, ezek szerint máshogy kell parancsolni gépnek. Hagyjuk el az idézőjeleket, és próbálja meg anélkül:

print 19675+67854
87529

Számoljunk csak gyorsan utána! Az annyi, mint... pontosan annyi! És milyen gyorsan kiszámította a gép, csak jó parancsot kellett kiadnunk. De akkor eddig mi volt a hiba? Az idézőjelek? Hát persze! Hiszen annyiszor elmondtuk már: ami idézőjelek között áll, azt a gép el sem olvassa, csak betűről betűre átmásolja. Ha azt akarjuk, hogy valamit elolvasson (és ki is számoljon), akkor nem tehetjük idézőjelek közé! És akkor eddig miért tettünk mindent mégis oda?
Azért, mert a gép nem ért magyarul, és ha valamilyen szöveget nem idézőjelek között adunk meg, akkor azt hiszi, az is része a parancsnak, elolvassa, és megpróbálja megérteni. Persze, nem sikerül neki, hiszen csak BASIC-ül ért, így hát hibaüzenetet küld. Ezért kell mindent, ami szöveg, idézőjelek közé zárni. Ha azonban azt szeretnénk, hogy valamit számoljon ki a gép, akkor ahhoz először is el kell olvasnia a feladatot, akkor pedig nem zárhatjuk el. Jöjjön akkor egy újabb próba: mennyi a 1541-1656? Ugye fejben nem megy! Papíron is eltart egy darabig. A géppel azonban csuda gyorsan ki tudjuk számíttatni. Írjuk be (A "-" jel német gépeken a jobb oldalon alul van, angol gépeken a felső sorban a jobb oldalon.):

print 1541-1656
-115

Már itt is az eredmény! Most már azt is tudjuk, hogy a gépet a negatív számok sem hozzák zavarba, egyszerűen kiteszi az előjelet. Tudunk már összeadni és kivonni vele, de biztosan lehet mást is csinálni. Először nézzük meg a szorzást!

print 2*2

(A szorzás jele itt nem a pont, hanem német gépeken a "+" jel, angolokon pedig a ":" jel felett lévő csillag, amit a SHIFT billentyű egyidejű lenyomásával tudunk begépelni.) A gép ekkor sem hibázik:

Ugye, hogy egyszerű mint a kétszerkettő? De ha tudunk szorozni, akkor biztos tudunk osztani is, csak a jelét kell megtalálnunk. Nos, a számítógépen az osztás jele nem a kettőspont, hanem a ferde, ún. törtvonal: "/". Német gépeken ezt ott találjuk középen , felül, a 7 jelű billentyű tetején, az angolokon pedig a jobb alsó sarokban. Próbáljuk ki:

print 3/2
1.5

És máris megtanultunk még egy jelet, tizedespontot! A számítógép nem vesszővel, hanem ponttal választja el a számok egész és a tört részét. Vigyázzunk rá, hogy ne rontsuk el soha, mert a gép nem fogja megérteni!
Most már annyi mindent tudunk, hogy csak zúg tőle a fejünk: összeadni (+), kivonni (-), szorozni (*), osztani (/), és tizedes törteket írni(.) Ezeket már bonyolultabb dolgokra is használhatjuk. Számoljuk ki; hány óra van egy héten! Minden héten hét nap van, és minden nap 24 órából áll. Hetente tehát 7*24 óra telik el, az annyi mint:

print 7*24
168

És mennyi lenne, ha egy hét nyolc napból állna? Pont annyi, mintha egy napot hozzáadnánk a héthez, és ezt szoroznánk meg huszonnéggyel. Jó, jó, de hát mennyi az? Számítsuk ki:

print 7+1*24
31

No de ilyet! Ha tehát egy nappal több van egy hétben, akkor nem 168, hanem csak 31 óra lesz? Hogy megrövidült t attól az egy naptól a hét! Vagy a gép romlott el? Nem, egyik sem történt. Attól, hogy egy nappal hosszabb, egyik hét sem lehet rövidebb, és a gép is helyesen számolt. Akkor hal a hiba?
Természetesen az utasításban. A gép ugyanis nemcsak úgy össze-vissza számol! Ő pontosan eltervezi, mit fog először csinálni, mit másodiknak, és mit azután. Ha pedig nem mondjuk meg neki a helyes sorrendet, könnyen összekeverheti a dolgokat. Ő ugyanis így gondolkozik:
"Én úgy szeretek szorozni meg osztani! Olvassuk csak el ezeket a számokat! Nem találunk egy jó kis szorzást, vagy osztást?
7+1*24
Hurrá, van egy szorzás! Na ezt végezzük el gyorsan! Mi marad?
4+24
Hát ebben már nincs se szorzás, se osztás. Akkor mit csináljunk? Ha már nincs más, végezzük el az összeadásokat és kivonásokat! Mivel pedig itt egyetlen összeadás van, kezdjük és fejezzük be azzal:
31
No most aztán jól kiszámoltam magam! Ez az eredmény biztos tetszeni fog a használómnak!"
Ugye milyen jóindulatúan próbálta kiszámolni, amit kértünk tőle? És mégse sikerült, mert nekünk nem mindig felel meg az a sorrend, amelyet a gép magától használ. Akkor mit tehetünk? Jeleznünk kéne, mi az, amit előbb kéne kiszámolni, és mi az amit utóbb. A megoldás: zárójelbe kell tenni az összeadást, hogy azt végezze el először. Próbáljuk ki! (A zárójelek a 8 és a 9 jelű billentyűkön vannak, a felső sorban.)

print (7+1)*24

Számoljunk csak utána: 168+24=192. Pont jó! Nagyon fontos új dolgot is tanultunk: ha egyszerre
több műveletet végeztetünk a géppel, mindig figyeljünk oda, hogy megfelel-e az a sorrend, ahogy a gép számol (azaz, hagy először a szorzásokat és az osztásokat végzi el, balról jobbra haladva, majd az összeadásokat és a kivonásokat ugyanígy), vagy pedig más sorrendet akarunk, mert akkor azt jeleznünk kell zárójelekkel. Írjunk hát egy programot, amely kiírja, hány perc van egy "nyolcnapos hétben":

10 clear screen
20 print (7+1)*24*60

Mit is csinál ez a program? Először letörli a képernyőt, majd a bal felső sarokba - mivel a képernyő törlése után mindig oda áll a kurzor - kiírja, hogy hány perc van egy nyolcnapos hétben. (Pont hatvanszor annyi, mint ahány óra!) Futtassuk le-a programot!

11520
ok

Ez bizony szép nagy szám, csak az a baj, hogy aki nem tudja, mit csinál a program, annak halvány fogalma sem lehet arról, hogy mi is ez az eredmény. Ki kéne írni, mit számoltunk ki! Cseréljük hát ki a 20-as (Hogyan is lehet egy programsort kicserélni? Ugye csak be kell írni az újat a régi sorszámával, és az máris felülírja a régit!)

20 print "(7+1)*24*60=";(7+1)*24*60

Ugye milyen furcsa? Ugyanazt írtuk le kétszer, csak először idézőjelek közé, és egyenlőségjelet tettünk a végére (ez német gépeken ott van a felső sorban, a 0 jelű billentyű tetején, angol gépeken pedig a mellette lévő billentyűn), azután lezártuk a szöveget egy újabb idézőjellel; odaírtuk a pontosvesszőt, ami azt jelöli, hogy majd itt akarjuk folytatni az írást, de nem fejeztük be a print utasítást, hanem egyből beírtuk a számítást is!
Ezt is lehet? Bizony lehet! Ha valamit nem akarunk külön sorba írni, akkor nem kell új print utasítást kezdenünk, hanem nyugodtan folytathatjuk a pontosvessző után az előzőt. Csak egy dologra kell figyelnünk: ha a print utasítás legvégére nem teszünk pontosvesszőt, akkor a következő print utasítás új sort kezd! Futtassuk le a programot! Ezt kapjuk:

(7+1)*24*60=11520
ok

Ez igen szép, de most próbáljuk meg odaírni a végére, hogy: pontosan. Írjuk be:

30 print "pontosan"

Futtassuk le most is a programot!

(7+1)*24*60=11520
pontosan
ok

Hát ez nem egészen az, amit szerettünk volna. Mi a hiba? Nézzük meg a program listáját (F2):

10 CLEAR SCREEN
20 PRINT "(7+1)*24*60=";(7+1)*24*60
30 PRINT "pontosan"

Ott van a gond, amiről előbb beszéltünk. A 20-as sor végén nincs pontosvessző, tehát a 30-as sorban lévő print utasítás már egy új sorba ír. Menjünk oda a 20-as sor végére, tegyük ki a pontosvesszőt! Ne ijedjünk meg, hogy a "60" hirtelen átkerült a következő sorba. A gép mindig figyeli, hol a képernyő széle, és ha túl akarnánk haladni, akkor a sor végéből az utolsó szót vagy számot gyorsan átrakja a következő sor elejére, ahol már bőven van hely folytatni. Az pedig nem baj, hogy ennek a sornak az elején nincs sorszám he ugyanis az előző sorban kezdtünk el gépelni akkor az, ami a képernyőn új sorba került, a programnak még mindig ugyanahhoz a sorához tartozik. Nyomjuk le az ENTER-t, hogy meg is maradion a változtatás, aztán listáztassuk ki újra a programot, hagy lássuk, tényleg sikerült-e a javítás:

10 CLEAR SCREEN
20 PRINT "(7+1)*24*60=";(7+1)*24*60;
30 PRINT "pontosan"

Megfigyelhetjük, hogy a 20-as programsor nem fért el a képernyő egyetlen sarában, ezért egy új sorban folytatta. A folytatást pedig mindig abban az oszlopban kezdi, ahol az előző képernyősorban maga az utasítás kezdődött, jelen esetben a PRINT kulcsszónál. Ha ez a PRINT utasítás egy ciklusban lenne - ahol az utasításokat két oszloppal beljebb kezdi kilistázni a gép -, akkor a PRINT kulcsszó is beljebb kezdődne, ezért az utasításból a következő képernyősorba átcsúszó rész is beljebb lenne. A későbbi fejezetekben még találkozunk - főleg a hosszabb programoknál - olyan utasítássorokkal is, amelyek három vagy több sorban férnek csak ki listázásnál. Ne feledkezzünk meg róla, hogy a programsor begépelésénél nem kell az egyes képernyősorok végén ENTER-t nyomnunk, hanem nyugodtan írjunk tovább a programsor utasításait, azokat majd a gép tördeli szét képernyősorokra.
No. most futtassuk le a programot!

(7+1)*24*60=11520 pontosan

Így már jó!
Most már szinte mindent tudunk. Mindent? Hát azért még van hátra néhány apróság. Írjunk programot, amely kiszámolja, hogy 1974 és 1988 között hányszor volt szökőév. Ugye minden negyedik év szökőév, ilyenkor a február egy nappal hosszabb, mint máskor. Ha tehát megnézzük, hogy hány év telt el 1974 és 1988 között, azt pedig elosztjuk néggyel, akkor megkapjuk, hogy hány szökőév volt. Töröljük ki az előző programot, de ha akarjuk, vegyük fel egy kazettára. Íme az új program:

10 CLEAR SCREEN
20 PRINT " 1974 es 1988 kozott a szokoevek szama:";
30 PRINT (1988-1974)/4

Hát ez jó! Szóval volt egy fél szökőév is? No persze nem, csak hát 1988-1974=14 és 14/4 valóban 3.5, azt pedig a gép nem tudhatja, hogy ha csak félig telt el a szökőévet elválasztó négy év, akkor nem fél szökőév telt el, hanem egyenlőre egy sem, 1974 és 1988 között 3 szökőév van. Az itt a baj, hogy nem tudtuk megmondani a gépnek: minket csak az egész része érdekel az eredménynek, a törtrész nem. Szerencsére a BASIC nyelvben erre is van kulcsszó: INT.
Az eredeti angol szó az integer, amit intedzser-nek kell ejteni, és egész számot jelent. A BASIC csak az INT rövidítést használja, azt sem úgy, ahogy a kulcsszavaktól eddig megszoktuk. Ez a kulcsszó ugyanis nem önálló parancs, nem is lehet az, hiszen ha csak azt mondanánk:
INT
nem lehetni tudni, minek akarjuk az egész részét venni, és mit akarunk vele csinálni. Ezt a kulcsszót kifejezésekben, számítások során vagy akár egy print utasításban is úgy használhatjuk, mintha egy szám lenne, csak utána zárójelek között meg kell adnunk, hogy minek az egész részét jelentse. Például INT (3.5)az 3, INT (5.8) az 5, és INT (-7.11) az -8, ugyanis negatív számoknál ez a függvény nem az egész részét adja a számnak, hanem annál eggyel kevesebbet. (-7-nél a -8 eggyel kevesebb.)
Mi is ez? Függvény? Az bizony! Hiszen, az, hogy mennyit jelent, az mindig attól függ, mit írunk utána a zárójelek közé. Nem csak egyetlen számot írhatunk, hanem teljes számítást, és az INT is lehet egy számításnak része. Az pedig, hogy például az 5*INT(3.5) számításban előszar a szorzást vagy az INT kiszámítását végzi-e el a számítógép, nem lehet kérdéses, hiszen ott van a zárójel, amely jelzi, hogy a függvényt mindig előbb kell kiszámolni. Javítsuk át a program 30-as sarát:

30 PRINT INT(1988-1974/4)

Vigyázzunk, mert az INT kulcsszó után itt két zárójel kezdődik. Az egyik az INT zárójele, a másik a műveletek sorrendjét határozza meg az INT zárójelén belül.
Futtassuk le a programot:

1974 es 1988 kozott a szokoevek szama: 3
ok

Az INT tehát jól működik. Vajon az INT az egyetlen ilyen függvény? Nem, az ENTERPRISE BASIC nagyon sok hasonló függvényt használ, ezekből néhányat még ebben a könyvben megismerünk. Ha megszokjuk a függvények használatát akkor az új függvények megtanulása már rendkívül könnyű, hiszen csak azt kell megjegyeznünk, hogy az egyes függvények mit csinálnak a mögöttük lévő zárójelek közé írt értékekkel.
Ma is sokat haladtunk, hiszen megtanultunk:

Matek, matek, matek... Tegnap jól kiszámoltuk magunkat. De hát a világ nemcsak számokból áll! S vajon mit nyújt annak ez a gép, kinek szívében szerelem lángja gyúlt? Természetesen segítséget. Vajon mit tud segíteni? Ha már szívünket csordultig töltötte a szerelem, töltsük tele a képernyőt kedvesünk nevével! No ehhez kell a számítógép! Legyen hát szívunk választottja ÉVA! S hogy nevét ne felejthessük el soha, örökítsük meg egy örökké futó programban:

10 do
20 print "EVA "
30 print " EVA"
40 print " EVA"
50 print "   EVA"
60 print "    EVA"
70 print "     EVA"
80 print "      EVA"
90 print "       EVA"
100 print "       EVA"
110 print "        EVA "
120 print "       EVA "
130 print "      EVA "
140 print "     EVA "
150 print "    EVA "
160 print " EVA "
170 print " EVA "
180 loop

A program már szinte visszaköszön, ugye felismerjük: ez a kígyóztató program. Indítsuk el, s láthatjuk, a drága név mint kígyózik végig a képen. S hogy az utókor is csodálhassa szerelmünk(és türelmünk) e remekművét, vegyük is fel kazettára! Jaj, de hiába az örökéletű felvétel, ha a szerelem nem örök! Eltelik néhány hét, néhány nap (néhány óra is elég?), s szívünkben már új név honol. De a programban nem! Nosza hát, kezdjük el átjavítani a sorokat! Mindegyiknek a végéti cseréljük ki az új névre, ami legyen KATALIN.

10 DO
20   PRINT "KATALIN"
30   PRINT " KATALIN"
40   PRINT " KATALIN"
50   PRINT "   KATALIN"
60   PRINT "    KATALIN"
70   PRINT "     KATALIN"
80   PRINT"      KATALIN"
90   PRINT "       KATALIN"
100   PRINT "         KATALIN"
110   PRINT "        KATALIN "
120   PRINT "       KATALIN "
130   PRINT "      KATALIN "
140   PRINT "     KATALIN "
150   PRINT "   KATALIN "
160   PRINT " KATALIN "
170   PRINT " KATALIN "
180 LOOP

A program hosszas munka után újra kész, de sajnos mire idáig jutottunk, szívünk ismét színt váltott, s kezdődik elölről az egész névcsere. Jön ADÉK, aztán CSILLA, majd VALÉRIA, s vége hossza nincs a neveknek, s a névváltoztatásnak. De hát kinek van erre energiája? Mennyivel egyszerűbb lenne, ha volna valahol egy rejtekfiók, egy titkos kis doboz, és mi csak annyit mondanánk a gépnek: "Írd ki azt a nevet, amelyet fiókban lévő cédulán találsz!" Ha pedig változna szívünk hölgye, csak a cédulát kellene kicserélni, s máris helyes név jelenne meg a képernyőn. Szerencsére gépünk tárja tele van ilyen titkos rekeszekkel, nekünk csak használnunk kell ezeket. De ahhoz, hogy elkerüljük a rekeszek összekeveredését, mindegyiknek egy-egy nevet kell adnunk.
Jelen esetben ugyan csak egyetlen fiókot fogunk használni, de nevet ennek is adni kell. Legyen a neve: FIOK$. A név végén álló furcsa jel nem egy nyíllal átlőtt szív, bár most az is igen ide illő volna, hanem egy függőlegesen áthúzott S betű, ami más néven a "dollárjel", és kivételesen nem azt jelöli, hogy az e rekeszben elrejtett név számunkra milyen értékes, hanem hogy ebben a rekeszben szöveg van.
Kedvesünk neve a gép számára ugyanis ugyanolyan szöveg, mint a karalábé vagy a poli(vinil-klorid). S ha valamibe el akarjuk tenni, akkor jeleznünk kell, hogy ebben a dobozban nem értelmes -legalábbis a számítógép számára nem értelmes- dolog van hanem valamilyen szöveg. (Ha valaki nem tudja, mi a poli(vinil-klorid), annak eláruljuk, hogy egy igen gyakran műanyag. Ha azonban valaki azt sem tudja mi az a karalábé, azon már nem tudunk segíteni.)
Tegyük be hát a nevet a "fiókba" (A "fiok" szó után álló dollárjel a felső sorban a 4 jelű számbillentyű tetején található.)

Persze nem elég betenni, hanem szólni is kell a gépnek, hogy most már azt a szöveget írja ki a sorok végén, ami a FIOK$ nevű rekeszben van. Javítsuk ki tehát a print utasításokat úgy, hogy minden sorban csak a szóközök maradjanak meg az idézőjelek között, és írjuk minden sor végére egy-egy pontosvesszőt - jelezve, hogy közvetlenül szóközök után kell folytatni a szöveget - és írj oda, hogy mi a neve annak a változónak, amelyben a kiírandó szöveg van:

5 LET FIOK$="VALERIA"
10 DO
20   PRINT FIOK$
30   PRINT " ";FIOK$
40   PRINT " ";FIOK$
50   PRINT "   ";FIOK$
60   PRINT "    ";FIOK$
70   PRINT "     ";FIOK$
80   PRINT"      ";FIOK$
90   PRINT "       ";FIOK$
100   PRINT "         ";FIOK$
110   PRINT "        ";FIOK$
120   PRINT "       ";FIOK$
130   PRINT "      ";FIOK$
140   PRINT "     ";FIOK$
150   PRINT "   ";FIOK$
160   PRINT " ";FIOK$
170   PRINT " ";FIOK$
180 LOOP

Futtassuk le ezt a programot! A kívánt név szépen kígyózik a képernyőn. Most változtassuk meg az 5-ös sort:

Indítsuk el újra a programot: láthatjuk, hogy az új név íródik ki, és ugye milyen könnyű volt a változtatás? Ez a program igen hasznosnak tűnik. Valóban az, hiszen egy csomó dolgot megtanultunk vele. Láttuk, hogy hogyan kell egy változóba beírni egy szöveget. Változóba? Mi az a változó?
Nos, a változó nem más, mint az a "fiók", amibe bele tudtuk tenni a szükséges szöveget. A BASIC-ben ezeket a fiókokat nem azért hívjuk változónak, mert egy csélcsap ifjú szíve változását is képesek követni, hanem mert éppen az a legfőbb tulajdonságuk, hogy szövegeket tudunk beléjük tenni , és onnan később - ha kell, akár többször is - kiolvasni, majd, ha szükséges, másik szöveggel a korábbit felülírni. Tehát a változók: tartalma nem mindig ugyanaz, hanem változik - ezért is "változók".
Ezeknek a "fiókoknak" , változóknak nevük van, hogy meg tudjuk mondani mikor melyikbe akarunk valamit beírni vagy kiolvasni. A változóknak rendkívül sokféle nevet adhatunk, de azért néhány dolgot szem előtt kell tartanunk. Az egyik ilyen dolog, hogy bár a változónevekben lehetnek számjegyek, sőt egyes írásjelek is (például a pont) , de szóköz semmiképpen sem, és a legelső jelnek mindenképpen betűnek kell lenni. Egy változónak lehet az a neve, hogy "muksi11", vagy az hogy "ihaj.csujaj.638", de semmiképpen nem lehet az, hogy "1magyar", mert ez a név nem betűvel, hanem számmal kezdődik, ás nem lehet az sem, hogy "Kovacs Pista", mert, bár a Kovács Pista nagyon rendes magyar név, de a BASIC változónevekben nem lehet szóköz. Ezért aztán ezt a változót nevezzük inkább "KovacsPista"-nak vagy "Kovacs.Pista"-nak, ezek már megfelelnek. Talán furcsának tűnik, de a változónevekben a német betűk sem fordulhatnak elő , így például az ö, az ü és ö melletti, kettősponttal megjelölt a sem. Ha ezek mégis bekerülnek egy változónévbe, akkor a gép nem érti meg, és hibát jelez.
Arra is figyelnünk kell, hagy a nevek nem lehetnek: hosszabbak, mint 31 betű vagy szám, mert ez a gép rettentően csökönyös, és egyszerűen nem hajlandó több betűt megjegyezni egy változó neveként (szerencsére azért magába a változóba ennél több betűt is be tudunk tölteni) , és ha ennél hosszabb egy név, akkor a gép hibát jelez. (Vigaszul eláruljuk, hogy a Commodore 64-es összesen két betűből álló változóneveket tud kezelni.)
Javítsuk most át az 5-ös sort a következőre:

Mit csinál ez a sor? Láttuk, hogy mindig itt kellett megadnunk, milyen nevet szeretnénk kiíratni, de azt még nem néztük meg, hogy pontosa mi is történik ebben-a sorban. Nos, nagyon egyszerű! Ebben a sorban egy utasítás van, a LET utasítás. A let angol szó -ugye milyen meglepő? -és azt jelenti: "legyen a FIOK$ nevű szöveget (erre utal a név végén álló $) tartalmazó változó tartalma az idézőjelek között álló szöveg", vagyis az a szöveg, amelyet ki-ki a "sajat nevunk" helyére beírt. Ha valaki azt írta "UBUL", akkor "UBUL" lesz a változó tartalma, ha pedig azt, hogy " ", akkor szóköz , mivel a szóköz, ha idézőjelek közözz áll, akkor ugyanolyan betűnek számít, mint az "a", vagy az "x". Ha ki akarjuk írni a képernyőre azt a szöveget, amely egy változóban van, akkor a print utasítást kell használnunk. Például:

De hát hogyan lehet így kiíratni egy szöveget? Hiszen korábban azt tanultuk, hogy ha szöveget akarunk kiírni, akkor idézőjelek közé kell tennünk, itt pedig sehol egy idézőjel! Nem is lehet, hiszen ha idézőjelek közé tennénk egy változó nevét, akkor a gép ugye el sem olvasná, hanem betűről betűre átmásolná valahogy így:

Mi azonban azt szeretnénk, hogy a gép ne a változó nevét, hanem annak tartalmát írja ki. Ilyenkor elég csak a változó nevét leírnunk. Ha a gép olyan szöveget talál, ami nincs idézőjelek között, akkor azt elolvassa, és ha az egy változó neve, akkor felismeri. Ilyenkor előveszi a változó tartalmát, és azt használja tovább, azt írja ki. Mivel azonban a változónevek a gép számára értelmesek, (hiszen jelentenek valamit: egy tároló "fiókra" utalnak), ezért a listázás során ezeket is nagybetűvel írja ki. Mi persze továbbra is írhatunk kisbetűvel, a kétfajta betűt itt sem különbözteti meg, ahogy a kulcsszavaknál sem.
No, most aztán eleget töprengtünk, elő egy új programmal! Töröljük ki a régit (elszállt a szerelem?) és írjuk: be ezt:

Most futtassuk le a programot! No de ilyet? Hiszen mi azt mondtuk, először írd ki az alma$-t, s aztán a karte$-t, a képernyőn mégis az áll:

Nem a gép bolondult meg, csak már megint minden máskép van, mint ahogy azt gondoljuk. A gép először, valóban az alma$-t írta ki, pontosabban nem a változó nevét, hiszen nem tettük idézőjelek közé, hanem a tartalmát. Ha pedig elolvassuk, hogy a 10-es sorban mit töltöttünk az alma$ változóba, akkor máris rájöttünk, miért írja ki a gép azt, hogy körte.
Hogyan kerül a körte felirat mögé a dollárjel? Ez is rendkívül egyszerű! A 30-as sor végén idézőjelek közé mi magunk írtuk be, és a gép hűen ki is írta oda, ahol a kurzor állt, azaz a körte szó mögé.
Nézzük csak meg jobban azt a 10-es sort! Nem hiányzik onnan valami? Dehogynem! Hova tűnt a LET kulcsszó? Milyen utasítás akkor ez? Semmi vész, a kulcsszó nem véletlenü1 maradt le hanem hogy megmutassuk: az ENTERPRISE BASIC még abban is segít nekünk, hogy ezt az utasítás kiteszi helyettünk. Nekünk nem is kell leírnunk, ő mindig automatikusan beírja, és ha kilistázzuk a programot, már benne is lesz. Listázzuk hát ki:

10 LET ALMA$="korte"
20 LET KORTE$="alma"
30 PRINT ALMA$;"$"
40 PRINT KORTE$;"$"

Valóban, a gép beírta a hiányzó kulcsszavakat., és nagybetűre írta át az utasításokat meg a változóneveket. De hát honnan tudta, hogy ide pont a LET utasítás kell? Nos, nem tudta sehonnan, csak megpróbálkozott vele. Bár mi eddig leginkább a print utasítást használtuk, de a komolyabb programokban a LET (más néven az értékadás) utasításból van a legtöbb. (Azért értékadó utasítás a neve, mert egy változó kap értéket benne, azaz egy értéket ad egy változónak.) Mivel ebből van a legtöbb, az ENTERPRISE feltételezi, hogy ha nincs más kulcsszó egy utasítássor elején, akkor biztos ez kellett volna oda, és beírja. Ha aztán így sem sikerül értelmessé tennie a sort, akkor hibát jelez. Nekünk mégis kényelmes, hogy nem kell azt a a töméntelen LET-et mindig kiírogatnunk, a gép magától megteszi.
A változókra azt mondtuk: egyik legfontosabb tulajdonságuk az, hogy meg tudják változtatni az értéküket. Például úgy, hogy bele tudjuk tölteni egy másik változó tartalmát, vagy egy idézőjelek között álló szöveget, vagy ilyen szövegeknek és változótartalmaknak az összegét. Hogyhogy összegét? Hogyan lehet két szöveget összeadni? Hiszen azok nem számok! Valóban nem számok, ezért összeadni sem úgy kell őket, ahogyan a számokat, és ezért a művelet neve is más. Mégis látni fogjuk, hogy ez is valamiféle összeadás. Ezt a műveletet konkatenációnak nevezik, ami összefűzést jelent, és a névben benne van a jelentés is. Két szöveg összeadása nem más, mint az összefűzésük, de mivel ez, nem számok, hanem szövegek közötti művelet, ezért a jele is más: a 6 jelű billentyű tetején a felső sorban levő & jel, amelyet a SHIFT billentyű egyidejű lenyomásával tudunk elérni. Írjuk kicsit át az előző programot:

5 dollar="$"
10 alma$="korte"&dollar$
20 korte$="alma"&dollar$
30 print alma$
40 print korte$

Az 5-ös sorban a dollar$ nevű változóba töltjük a dollárjelet, majd a 10-es és a 20-as sorban egy-egy összefűzést végzünk. Először az alma$ nevű változóba töltjük a "körte" szöveg és a dollar$ nevű változó tartalmának konkatenációját, majd hasonlóan betöltjük a korte$ változóba az "alma" és a dollar$ összefűzésének eredményét. Amikor végül kiíratjuk az alma$ és a korte$ tartalmát, ugyanaz jelenik meg a képernyőn, mintha a korábbi programot hagytuk volna meg, azaz mintha a szövegek után írtuk volna a dollárjelet. Most pedig nézzünk ismét valami könnyedebbet:

Stein-Maltenak nagy, vörös és elálló
füle van. Nekem tetszik
a nagy, vörös és elálló
fül.

Ezt a csodálatos verset (Siv Widerberg Szerelem című versét) Tótfalusi István fordította le nekünk magyarra, hogy élvezni tudjuk. Az élvezetet csak fokozza, ha ki is tudjuk íratni a géppel. Persze nekikezdhetünk a dolognak úgy is, hogy leírjuk az egészet öt print utasításban, idézőjelek között, de ez nemcsak szégyenteljes megoldás egy olyan zseniális programozótól, mint amilyenek mi vagyunk, hanem roppant unalmas is. Inkább próbáljunk meg keresni a szövegben egy részletet, ami többször is el előfordul, mert a akkor azt be tudjuk tölteni egy változóba, és akkor nem kell mindig leírnunk az egészet. Ott van például az a részlet, hogy "nagy, vörös és el elálló" Ez kétszer is előfordul, tehát érdemes betölteni egy vá1tozóba. Töröljük ki a korábbi programot és írjuk be:

Ezzel megkezdtük a versíró programunkat: a 10-es sora már meg is van. Most keressünk tovább többször e1őfordu1ó részletet. Legyen ez mondjuk a "fül". A is kétszer szerepel. Nosza, írjunk egy programsort, amely betölti ezt is egy változóba:

Sajnos több lényegi egyezést nem találtunk, így megkezdhetjük a vers összeállítását. No de persze nem egyből az egészet, először csak egy-egy részét írjuk be:

40 elso.sor$=kinek$&milyen$
50 masodik.sor$=mi$&"e van."
60 harmadik.sor$="Nekem tetszik"
70 negyedik.sor$="a "&milyen$
80 otodik.sor$=mi$

90 print elso.sor$
100 print masodik.sor$
110 print harmadik.sor$
120 print negyedik.sor$
130 print otodik.sor$

A program kész, le lehet futtatni. Nosza! És valóban az történik, amire vártunk, a gép kiírja a költő sorait, melyek örök emléket állítanak Stein-Malte csodálatos füleinek.
Mi pedig a mai napon megtanultunk:

Ma egész nap csak azt fogjuk keresni, mire is jók azok a változók. Azt már láttuk, hogy ha egy szöveg
sokszor fordul elő egy programban, akkor érdemes változóba tenni, mert így csak egy helyen kell módosítanunk a programot, ha ezen a szövegrészleten változtatni akarunk. Változókat persze nemcsak erre lehet használni, hanem rendkívül sok más dologra is. Ezek közül szeretnénk megismertetni néhányat.
Nemrégiben történt, hogy két jó barátom - Pista és Feri - közösen kapott egy ENTERPRISE számítógépet. Persze egyszerre ketten nem használhatták, így elhatározták, hogy az egyik héten az egyikőjüknél lesz, a másik héten a másiknál. De ki kezdje? Ezt akár fej vagy írással is eldönthették volna, de egyiknél sem volt egy fillér sem. Mit tegyenek? Egyszer csak Pista a fejéhez kapott:
- De hisz itt van a számítógép! Döntsön ő!
- Na de Pityu, hogyan tudna dönteni egy gép? - kérdezte Feri.
- Nézd csak meg, írok egy programot! - s a következű sorokat gépelte be. Írjuk be mi is ezt a saját gépünkbe!

Pista elindította a programot. indítsuk el mi is! -Hát ez meg mire jó? - kérdezte Feri.
-Gondold csak végig, mit is csinál ez a program!
-Egyszerű. Beírja a NYERTES$ nevű változóba a te nevedet, aztán kijavítja az enyémre. De ezután rögtön visszaugrik az elejére, és megint a te nevedet írja be, majd megint az enyémet és ez így megy a végtelenségig, miközben semmit sem ír ki. Azt se lehet tudni, hogy a te vagy az én nevem van éppen a változóban.
- Hát éppen ez az! Gondolj bele, a programot bármikor megállíthatom a STOP gombbal, de előre nem tudhatom, hogy amikor megáll, ki is lesz a NYERTES$ olyan ez, mint a fej vagy írás. Elindítom a programot, és kicsit később megállítom. Ha megnézem, kinek a neve van a NYERTES$ változóban, megtudhatom, ki nyert. Biztos, hogy ezt csak a véletlen dönti el, mert hiszen senki sem látja, hogy éppen mi van a változóban, tehát nem tudhatom, mikor kellene megállítanom a programot ahhoz, hogy én nyerjek.
- Na jó, jó, de hogy a csudában tudhatjuk meg, mi
van a változóban, ha egyszer már megállítottuk a programot? Hiszen a program ilyenkor sem írja ki a változó tartalmát - húzódozott Feri.
- Semmi baj - nevetett Pista -, csak, azt kell tudni hozzá, hogy ha egy programot megállítunk, akkor a változók nem törlődnek, hiszen akkor nem tudnánk folytatni esetleg a programot a CONTINUE paranccsal. Ha egy program véget ér, vagy félbeszakítjuk a STOP-al, akkor a változókban továbbra is ott van, amit beléjük írtunk.
- Ott van bennük?
- Ott bizony, semmit sem változnak.
- De hát akkor hogyan lehet az, hogy ha egymás után lefuttatok két programot, amelyek ugyanazokat a változókat használják, akkor a második program változói soha nem keverednek össze az elsőével?
- Nincsen ebben semmi boszorkányság. A megoldás: mindössze az, hogy a START parancs hatására a gép először mindig törli a változókat, és csak azután indítja el a programot. Amikor a második programot elindítod, az első adatai kitörlődnek a tárból, így nem keveredhet a össze két program.
- Jó, jó, azt már elhiszem, hogy tényleg ott van nyertes neve a NYERTES$ változóban, de hogy fogjuk megtudni, hogy ki az?
- Egyszerűen kiíratjuk! Ne felejtsd el, hogy a print parancsot nemcsak programban használhatod, hanem azonnal végrehajtandó utasításként is! Így:

A kiírás szerint Feri a nyertes, tehát ő viheti haza az első héten a gépet. De Pista nem nagyon búslakodott:
- Na látod, még a gép is úgy érzi, hogy neked még sokat kell tanulnod. Azért ment inkább hozzád először! Bizony, ez az eset igen tanulságos, jó lesz nekünk is megtanulnunk mindazt, amit Pista mondott. Próbáljuk ki ezt a saját gépünkön is! Esetleg módosíthatjuk úgy is a programot, hogy ne Pista és Feri között sorsoljon, hanem mondjuk az ENTERPRISE és a GAZDI között.
No, de azért ez még nem minden. Miután Feri hazaért a géppel, az első dolga volt, egy BASIC könyvet, és nekiálljon megtanulni a nyelvet. De mivel egy kicsit már tudott BASIC-ül, ezért egyből a közepén nyitotta ki. Ezt a programot találta:

Be is írta a gépbe, írjuk be hát mi is! (Előtte azért ajánlatos NEW-val kitörölni a másik programot, mert különben a régi és az új program sorai jó alaposan összekeveredhetnek!) Hanem amikor Feri megpróbálta kitalálni, mit is csinál majd a program, rájött, hogy ez bizony neki túl nehéz. El is hívta Pistát, segítsen megfejteni a program titkát:
- Nézd Pista! Én már mindenféle programokat láttam, de ilyen csudabogarat még nem. Az elején úgy csinálunk, mintha egy változóba töltenénk valamit, de nem töltünk semmit. Csak tudnám, minek akkor az egész? Aztán meg azt parancsoljuk, hogy a változó legyen más, mint ami önmaga, legyen egy a betűvel több. De hát hogy lehet valami több, mint önmaga? Akkor az már nem önmaga!
- Pontosan. Fején találtad a szöget. Az a változó valóban más lesz, mint ami eddig volt. De hát azért változó a változó, hogy változzon. A 30-as sorban lévő parancs éppen azt mondja, hogy az A$ változó legyen egy a betűvel több, mint ami eddig volt. Az a fontos, hogy ne keverjük össze azt, ami eddig volt azzal, ami ezután lesz. Bármi volt is eddig az A$-ban, mostantól fogva egy a-val több lesz.
- De hát ez az utasítás egy végtelen ciklusban van! Hiába lesz egy a-val hosszabb, ha a program megint ideér, megint csak azt fogja mondani, hogy legyen eggyel hosszabb.
- No és? Hol itt a probléma? Először hozzáfűz egy a betűt, majd egy másodikat, majd egy harmadikat, és így tovább, amíg meg nem telik az A$.
- Megtelik? Mi az, hogy megtelik? Eddig erről még sohasem halottam.
- Pedig ez is logikus. Hiszen ha soha nem érne véget, akkor előbb utóbb annyi a betűt kellene az A$-ban elhelyezni, hogy akármilyen nagy is a gép tárja, akkor sem férne el. Így aztán az történik, hogy ha egy változóba túl sok betűt akarunk betenni, akkor a gép megáll, és hibát jelez.
- De eddig ezt még soha nem csinálta?
- Nem hát, hiszen ez csak nagyon sok betű betöltése esetén esik meg, minekünk pedig olyan sok betűre úgysincs szükségünk egyetlen változóban.
- Ezek szerint nem kell félnem, hogy valamelyik változóm egyszer csak megtelik, és a program megáll?
- Általában nem, csak az ilyen csalafinta programoknál fordulhat ez elő. De hát ez olyan ritka, hogy figyelnünk se kell rá.
- Most már csak azt szeretném megtudni, mi a csudának az a 10-es sor. Minek írunk az A$-ba, ha egyszer nem írunk bele semmit?
- No hát, ha olyan nagyon nem tetszik ez a sor, akkor töröld ki, és próbáld meg nélküle lefuttatni a programot!
- Meg is teszem! - azzal nekilátott.
Próbáljuk ki mi is! Töröljük ki a 10-es sort (ehhez ugye csak a számát kell Újra beírni, és lenyomni az ENTER-t), majd indítsuk el a programot:

Ez így tehát nem megy. A gép hibát jelez, és mivel program közben találta meg a hibát, ezért azt a sort is kiírta, ahol rájött a hibára. Ez persze nem azt jelenti, hogy tényleg itt van a hiba, lehetett az egy korábbi sorban is, csak idáig nem derült ki. Most viszont, a 30-as sorban valami baja van a gépnek. De vajon mi? Nem nehéz kitalálni. Amikor legelőször ér ide a program, a gép megpr6bál egy a betűt hozzátoldani az A$-hoz. De korábban egy szóval se mondtuk meg, mi van az A$-ban! A gép nem tudhatja, mi van benne, de akkor nem tud hozzáfűzni semmit. Ezért jelez hibát! Nem tudja, mi van az A$-ban, így nem tudja elvégezni a műveletet. Éppen ezért van szükség a 10-es sorra, hogy megmondja a gépnek, mi van eredetileg az A$-ban: semmi. Írjuk hát újra be a 10-es sort, és futtassuk le a programot!
Egy darabig szépen rendben íródnak ki az egyre hosszabb sorok, egészen addig, amíg el nem érik a képernyő jobb oldalát. Ettől kezdve az A$ tartalma már nem fér ki egy sorban, ezért új sorba kerül át. Ilyenkor úgy tűnik, mintha csak minden második sorba kerülne a "betűpiramis", a köztük lévő sorokat meg a betűk töltik ki. Aztán már csak minden harmadik sor változik, majd minden negyedik... És hirtelen megáll a program:

Most következett be, hogy már nem fért el a sok betű a változóba. De jó lenne, ha tudnánk, hány betű is van benne! Megtehetjük, hogy kiíratjuk és szépen megszámoljuk, csak ez kicsit fáradságos. Az lenne a jó, ha a gép számolná meg a betűket. Meg is számolja, csak persze ehhez megint meg kell ismernünk egy új dolgot, mégpedig egy új függvényt. Ez a függvény a LEN. Az eredete az angol length szó, ami hosszúságot jelent, és ezzel le is lepleztük a függvény titkát. Ez a függvény annak a szövegnek a hosszát adja meg, amit beírunk mögé a zárójelek közé.
Emlékezzünk csak az INT függvényre! Ott is zárójelek közé kellett beírni azt, amitől függött a függvény értéke, de ott egy számot (vagy egy számnak megfelelő kifejezést) kellett beírnunk. Itt nem szám, hanem szöveg áll a zárójelek között, de természetesen itt is használhatunk mindenféle csalafinta dolgot. Ha mondjuk az x$ változóban négy darab a betű van, akkor LEN(x$)=4, de LEN(x$&"a")=5 és LEN("Ubul"&x$&"Odon")=17. Ez ugye úgy jön ki, hogy csak az idézőjelek között álló betűk - hiszen azok részei a szövegnek; ami körülöttük van, az program, nem szöveg - és a változókban lévő betűk számítanak.
Ez a függvény tehát az egyik oldalán egy szöveget néz meg, a másik oldalon pedig egy számot ad ki. Vannak másfajta függvények is, amelyek például számot olvasnak be, és betűket adnak ki, de azokkal most nem foglalkozunk. Írassuk hát ki az A$ változó hosszát:

Tehát egy változóba 132 betűt tudunk beírni, utána hibát jelez a gép. Hogy is volt ez? Honnan tudjuk, hogy éppen a 132 a határ? Hát onnan, hogy amikor az a betűkből álló piramist kiíró programot futtattuk, akkor a gép éppen emiatt a túl sok betű miatt állt le. De miután leállt, a változó nem törlődött ki, abban tehát most is annyi betű van, hogy ha még egyet megpróbálnánk hozzáfűzni, a gép hibát jelezne. Ha most tehát kiíratjuk, hány betű van a változóban, akkor megkapjuk, hogy maximum hány fér bele.
Alakítsuk most át a programot, hogy ne az a betűket írja ki, hanem azt, hogy éppen hány betű van az A$-ban. Cseréljük ki a 40-es sort:

Indítsuk el a programot! Ekkor nem jelennek meg az a betűk, hanem a gép szépen sorjában elkezd számolni, egészen 132-ig, amikor újra megjelenik a hibaüzenet. Számolni most már tudunk, sőt egy szövegben a betűket megszámolni is, próbáljuk meg hát használni ezt valamire. Írjunk programot, amely megszámolja a nevünkben lévő betűket. Mielőtt beírnánk, ki kell persze törölni a régi programot. Az új program így néz ki:

10 LET NEVEM$="Pityipalko"
20 PRINT "Az en nevem ";NEVEM$
30 PRINT "A nevemben ";LEN(NEVEM$);" betu van."

Ugye nem is olyan nehéz? És attól sem kell megijednünk, hogy a 30-as sor kicsit hosszúra sikerült, hiszen tudjuk, hogy bár a gép is két sorba írja ki, de azért egynek veszi. Futtassuk le a programot!

Számoljunk csak utána... valóban, a Pityipalko tíz betűből áll. De most szúrjunk be egy szóközt a 10-es sorban a "Pityipalko" után az idézőjelek közé:

Pedig az előbb milyen szépen számolt! Hát csakugyan így megzavarja az az egy kis szóköz a gépet? Bizony! A gép nem tudja, ,hogy ami a szövegen belül, az idézőjelek között, illetve egy változóban van, az betű, számjegy, valami jel vagy épp szóköz. Neki minden ilyen dolog csak egy-egy karakter. A "karakter" itt egy speciális számítógépes szakszó, éppen az ilyen esetekben használjuk, amikor nem tudjuk, vagy nem számít, hogy egy betűnek megfelelő helyen mi is van, hanem csak az, hogy pont egy betűnyi helyet foglal el. Mindent, ami egy betűnyi helyet igényel, karakternek hívunk. A képernyőn a számítógép számára nem betűk vannak, hanem karakterek. Minden jel a képernyőn egy karakternyi helyet foglal el. A "Pityipalko " szövegben is a szöveg végén álló szóköz egy teljes karakter, tehát a karaktereket számláló LEN függvény ezt is beleszámolja a névbe, így lesz a tíz betűs Pityipalkó hossza tizenegy. Vigyázzunk erre máskor és máshol is, a szövegekben álló szóközök nem azonosak a semmivel, és a " " szöveg nem üres, hanem egy szóköz van benne. Létezik persze üres szöveg is, ez a "", amit a piramisíró programban már alkalmaztunk is.
Ma változókkal, szövegekkel foglalkoztunk. Foglaljuk össze a tanultakat!

Második hét

1. nap - Hányszor mondjam...

Ma egy programmal kezdünk:

10 clear screen
20 do
30 print at 10,10:"E"
40 print at 10,10:"EN"
50 print at 10,10:"ENT"
60 print at 10,10:"ENTE"
70 print at 10,10:"ENTER"
80 print at 10,10:"ENTERP"
90 print at 10,10:"ENTERPR"
100 print at 10,10:"ENTERPRI"
110 print at 10,10:"ENTERPRIS"
120 print at 10,10:"ENTERPRISE"
130 print at 10,10:" "
140 loop

(Ugye emlékszünk még, mi is az a PRINT AT utasítás?)
Futtassuk le a programot! Nem is csúnya. A gép szépen kiírja az ENTERPRISE feliratot, de nem egyszerre, hanem betűnként. Először csak egyet, aztán kettőt, hármat - és így tovább. Végül a 130-as sorban letörli az egészet, és kezdi elölről. Nem rossz, csak a gépelés volt egy kicsit unalmas. Minden kiíratásnál majdnem ugyanazt kellett begépelni, csak mindig egy betűvel többet. De jó lenne egy változóba beletenni! De hát nem lehet, mert akkor mindig kiírná a teljes szót. Illetve - nem is olyan biztos ez!
Próbáljuk ki a következőt! A program elején írjuk be egy változóba az egész szót, aztán minden alkalommal, amikor használjuk ezt a változót, írjuk oda mögé, hogy mettől meddig kell csak kiírni. Valahogy így:

10 clear screen
15 a$="ENTERPRISE"
20 do
30 print at 10,10:a$(1:1)
40 print at 10,10:a$(1:2)
50 print at 10,10:a$(1:3)
60 print at 10,10:a$(1:4)
70 print at 10,10:a$(1:5)
80 print at 10,10:a$(1:6)
90 print at 10,10:a$(1:7)
100 print at 10,10:a$(1:8)
110 print at 10,10:a$(1:9)
120 print at 10,i0:a$(1:10)
130 print at 10,10:" "
140 loop

És ez így működni fog? Bizony, tessék csak kipróbálni!
Ez újdolog, eddig még nem használtuk, de olyan egyszerű, hogy szinte nem is kell magyarázni. Bármilyen szöveg vagy szöveget tartalmazó változó mögé beírhatjuk zárójelek között, hogy hányadik betűtől hányadik betűig érdekel minket a szöveg. Próbáljuk ezt ki néhány közvetlen utasítással:

print "kakukmarci"(1:10)
kakukmarci
ok

Ez rendben van, hiszen a KAKUKMARCI az tíz betűből áll, és a gép ki is írta mindet. Most írassuk ki csak a szó elejét:

print "kakukmarci"(1:5)
kakuk
ok

Nocsak, hogy is van ez? Most kiírattuk a KAKUKMARCI szó első és ötödik betűje között lévő részt, azaz az első öt betűt, ami tényleg az, hogy kakuk. (Vigyázat, a kakukkmadár neve végén két k van: kakukk!) Most jöjjön a szó vége:

print "kakukmarci"(6:10)
marci
ok

Ez is szépen sikerült. Kiírattuk a hatodik és a tizedik betű közötti részt, ami marci, kis nyelvtani hibával, ugyanis a Marcit nagy betűvel szokás írni. Most az egyszer bocsássuk ezt meg, és jöjjön a szó közepe. Azt is lehet? Miért ne? Hiszen mi bármilyen számot megadhatunk, kiírathatjuk akár a harmadik és a hatodik betű közötti részt is.

print "kakukmarci"(3:6)
kukm
ok

Bármilyen számot megadhatunk? Majdnem. Illetve bármit beírhatunk, csak azt is tudnunk kell, hogy ennél az egy dolognál a gép másképpen viselkedik, mint a korábbiakban láttuk. Ha valami butaságot írunk be, akkor a gép nem hibajelzést küld, hanem valamit csinál, csak nem mindig azt, amit akartunk. Próbáljuk meg kiíratni az előbbi szót visszafelé:

print "kakukmarci"(10:1)
ok

Nem írt ki a gép semmit! Nem is írhat, hiszen a tizedik betű hátrább van, mint az első, a gép viszont visszafelé nem olvas. A két megadott szám közül a másodiknak nagyobbnak vagy legalábbis egyenlőnek kell lennie az elsővel. Egyenlő is lehet? Persze, csak akkor egyetlen betűt fogunk kiírni:

print "kakukmarci"(4:4)
u
ok

A programunkat megnézve most már értjük, miért nem írta ki a gép mindig az egész szót, amelyet a változóba töltöttünk. A dolog még mindig nem elég kényelmes, mert azért csak le kellett írnunk a PRINT utasítást tízszer. Mennyivel jobb lenne, ha a gép magától elszámolna tízig, és mindig eggyel több betűt írna ki.
Aki idáig eljutott ebben a könyvben, az már tapasztalta, hogy ha valamiről azt írjuk "milyen jó lenne, ha...", akkor ez csak arra való, hogy utána nagy boldogan bejelentsük: az ENTERPRISE meg tudja csinálni! Most sincs ez másképp. Írjuk be hát a következő programot:

10 CLEAR SCREEN
15 LET A$="ENTERPRISE"
20 DO
30   FOR N=1 TO 10
40     PRINT AT 10,10:A$(1:N)
50   NEXT N
130   PRINT AT10,10:"           "
140 LOOP

Aki ügyes, annak nem is kell minden sort begépelni hiszen ez az előző program, csak egy kicsit átalakítva. A beljebb kezdődő sorokat persze nem kötelező így begépelni: amikor kilistáztatjuk a programot akkor a gép - ugye emlékszünk - magától beljebb írja a ciklus belsejében lévő utasításokat, hogy mi könnyebben felismerjük.
Jó, jó, de hát mi az a két új sor? És miért kezdődik a közöttük lévő PRINT is két oszloppal beljebb? Talán ez is egy ciklus? Az bizony! Ez egy újfajta ciklus, a FOR-NEXT ciklus. Ahogy a végtelen ciklus. elejét a DO, a végét pedig a LOOP utasítás jelöli, ugyanúgy a FOR ciklus elején a FOR utasítás, a végén pedig a NEXT utasítás áll. A nagy különbség azonban nem ez, hanem ami a FOR után következik:

30 FOR N=1 TO 10

A FOR-NEXT ciklus ugyanis nem végtelen, azaz nem vég nélkül, megy körbe-körbe. Ez számláló ciklus. Szóról szóra lefordítva a kifejezést, magyarul nincs is értelme - csak a BASIC nyelvben ismeretes. úgy kell érteni: számolj el az N nevű változóval egytől tízig, egyesével. A gép először beleteszi az N változóba az egyet aztán folytatja a programot, egészen addig, amíg a NEXT-hez nem ér. A NEXT azt jelenti: következő, azaz a gép menjen vissza a ciklus elejére, töltse be az N változóba a következő számot, és folytassa onnan a programot. A NEXT utasítás végére nem is kéne odaírnunk, hogy az N-be kell az új értéket tölteni, hiszen ezt a FOR utasításban már úgyis megmondtuk - a gép nem is jelez hibát, ha elhagyjuk.
Töltse be az N változóba a következő számot? De hisz idáig mi csak szövegeket töltöttünk be változókba! Lehet számokat is? Igen, lehet, csak arra kell vigyáznunk, hogy azokat a változókat, amelyekben számok vannak, és nem betűk, úgy különböztetjük meg a szöveges változóktól, hogy nem teszünk a nevük végére dollár-($) jelet.
Helyes! Tehát a gép szépen elszámol tízig, és közben az N változóba sorban beírja a számokat egytől tízig egyesével. De mitől fog változni a kiírás? Nos, ha jobban megnézzük az új PRINT utasítást, akkor rögtön észrevesszük: az A változó után nem számmal adtuk meg, hogy meddig írja ki a gép az ENTERPRISE szó betűit, hanem azt mondtuk: (1:N). Tehát az első betűtől kezdve az N-edikig. Lehet ilyet csinálni?
Lehet. Ahogy korábban láttuk, mindenhova, ahova szöveget kellett írnunk, idézőjelek között írhattunk helyette szöveges változót is, és akkor a gép azt a szöveget használta, ami változóban volt ugyanúgy a számok helyett is írhat számváltozókat.
És mi van azután, hogy a gép elszámolt tízig? Számol tovább? NEM! Ez a legfontosabb, amiben a FOR-NEXT ciklus más, mint a végtelen ciklus. A FOR-NEXT ciklus csak annyiszor megy körbe, ahány számot megadtunk neki, utána véget ér, és a gép a NEXT utasítás után folytatja a programot. Nézzük csak meg a mi programunkat is! A gép elszámol tízig, és közben mindig eggyel több betűt ír ki az ENTERPRISE szóból. Ha azonban eljutott tízig, akkor a NEXT-nél nem ugrik újra vissza a FOR-hoz, hanem folytatja szépen a 130-as, 140-es sorral a programot. Azaz törli a kiírt szót, és visszamegy a végtelen ciklus elejére.
Szóval itt két ciklus van egyszerre? De hát honnan tudja a gép, hogy mikor hova kell visszaugrania? Ha megnézzük a programot úgy, ahogy a gép kilistázza, magunk is könnyen rájövünk. Hiszen Ő nekünk is jelzi, hogy az egyes ciklusoknak hol az eleje és a vége: azzal, hogy a cikluson belül lévő utasításokat - amelyek lehetnek ciklusok is - két-két oszloppal beljebb kezdi. Olyan ez, mint amikor karácsonyra kapunk egy nagy-nagy dobozt az ajándékunkkal. Kinyitjuk, és egy kicsit kisebb dobozt találunk benne. Kinyitjuk azt is, és egy még kisebbet találunk. Aztán egy még kisebbet, és így tovább, amíg a végén egy apró kis cetlire bukkanunk: KELLEMES KARÁCSONYT! Ahogy egymásba lehet rakni a a dobozokat, úgy lehet egymásba rakni a ciklusokat is.
Futtassuk hát le a programot! A gép szépen kiírja az ENTERPRISE-t, ahogy azt vártuk. Tehát elszámol tízig, aztán újra tízig, és így tovább. De Jó lenne látni is, hogyan számol! Semmi akadálya! Állítsuk meg a programot és egészítsük ki egy új sorral:

45 print at 5,10:n

Listáztassuk ki:

10 CLEAR SCREEN
15 LET A$="ENTERPRISE"
20 DO
30   FOR N=1 TO 10
40     PRINT AT 10,10:A$(1:N)
45     PRINT AT 5,10:N
50   NEXT N
130 PRINT AT 10,10:"          "
140 LOOP

Tehát most már két dolgot is kiíratunk. Az A változóból N darab betűt, és az N értékét az ötödik sorba. De hát ilyet is lehet? No hiszen, miért ne lehetne? Ha egy szöveges változó tartalmát kiírathatjuk, egy számváltozóét miért lenne tilos? Egyébként is, a gép a mi rabszolgánk, neki azt kell csinálni, amit mondunk neki. Az ő dolga, hogy engedelmeskedjék, a miénk pedig, hogy okos, de legalábbis értelmes utasításokat adjunk neki. Ennél okosabb utasítás pedig el sem képzelhető, hiszen így jól nyomon tudjuk követni, hol is jár a program.
Hát kiírni kiírja, csak éppen elolvasni nincs időnk. Ez a gép úgy kapkod, hogy majd kiesik a szemünk. Hogy lehet ezt követni? Szólni kéne neki: ha kiírta a számot, várion egy kicsit, hogy el is tudjuk olvasni. Nosza! Állítsuk meg, és írjunk be még egy új sort:

46 WAIT 1

Hát ez meg mi? A WAIT azt jelenti várj, és úgy kell ejteni: véjt. Ez is angol szó, de a BASIC-ben is használhatjuk. Arra utasítjuk a gépet vele, hogy várjon egy kicsit. Kicsit? De hát mennyi az a kicsi? Ezt adjuk meg azzal a számmal, amely a WAIT után áll. Ha egyet írunk oda, akkor egy másodpercig áll meg, ha kettőt, akkor kettőig. A legtöbb, amit megadhatunk, a 32767, de ez nem ajánlatos, mert az már több, mint kilenc óra. Ha beírnánk, a gép megállna; és kilenc órán keresztül nem csinálna semmit. (Jó tudni: ha véletlenül egyszer túl nagy számot adunk meg, akkor a STOP billentyűvel még mindig le tudjuk állítani a programot, kijavítani a WAIT utasítást, és újra kezdhető a futtatása.)
Mi most csak egy másodpercre állítjuk meg a programot, a szám elolvasásához ez is elég lesz. Futtassuk le! Ugye, most már jól látjuk, hogyan számol a gép? Csak. azt nem értjük még, miért írja a számokat az ENTERPRISE szó második betűje fölé, amikor mi azt mondtuk, hogy ezeket is a tizedik oszlopon kezdje? Nézzünk hát utána a dolognak! Állítsuk meg, és listáztassuk ki a programot! Javítsuk át a 45-ös sort a következőre:

45 PRINT AT 5,10:N*(-1)

Hogy is van ez? Megszorozzuk az N-et mínusz eggyel? De hát akkor negatív lesz az N! 'Dehogy, az N semmit sem változik. Hiszen ez nem értékadó utasítás, tehát amit itt az N értéke nem változhat. Ez kiíró utasítás, tehát amit itt kiszámolunk, az csak a képernyőre íródik ki, a változó belül nem változik.
Minek tettük a mínusz egyet zárójelbe? Ha csak annyit írnánk, hogy N*-1, akkor a gép nem tudná eldönteni, hogy ez a vonal most előjel, vagy a kivonás jele. Ha megmondjuk neki a zárójellel, akkor szépen rendben kiszámolja, hogy mennyi van a zárójelen belül (ami most mínusz egy), és aztán ezzel szorozza meg az N-et. Az eredményt pedig nem teszi el sehova, csak a képernyőre írja ki. No, futtassuk most le a programot!
Csupa negatív szám jelenik meg. De hiszen az N pozitív! Éppen azért! Hiszen a program mindig az N mínusz egyszeresét írja ki. Nem is ez a fontos, hanem az, hogy hová írja ki a számokat! Nocsak, most már valóban a tizedik oszlopon kezdődnek. Ezt volt tehát az eltolódás oka. A gép mindig kihagyja az előjel helyét, akár negatív, akár pozitív a szám. Persze ha pozitív, akkor nem kell az előjel, tehát egy üres helyet ír ki, így kerültek a számok eggyel jobbra.
Ha már megoldottuk ezt a problémát, jöhet a következő. Próbáljuk meg mindig új sorba kiíratni az egyre hosszabb szövegeket! Közben javítsuk vissza az N-et kiíró sort, hogy helyesen írja ki az N értékét. Ehhez két dolgot kell megváltoztatnunk. Állítsuk meg a programot, listáztassuk ki, és először javítsuk vissza a 45-ös sort:

45 PRINT AT 5,10:N

Most már helyesen írja ki a gép az N értékét. Most pedig a 40-es sort írjuk át:

40 PRINT AT 10+N,10:A$(1:N)

Ez most nem a tizedik sor tizedik oszlopára kezd írni, hanem a (tíz plusz N)-edik sorba, azaz először a tizenegyedikbe, aztán a tizenkettedikbe és így tovább, ahogy az N értéke változik. Futtassuk le a programot! Ez jelenik meg:

E
EN
ENT
ENTE
ENTER
ENTERP
ENTERPR
ENTERPRI
ENTERPRIS
ENTERPRISE

Miközben felül egyre számol a gép. A számolás folyik tovább, de a kép nem változik, a szöveg nem tűnik el, a gép nem ír ki semmi újat. De miért? Dehogynem ír ki! A számítógép, ahogy sorban elszámol egytől tízig, mindig kiírja a tizenegyedik, tizenkettedik stb. sorba a megfelelő szöveget, csak ezt mi nem vesszük észre, mert nem törli le a képernyőt, és így tényleg úgy tűnik, mintha nem változna semmi. De hát miért nem törli le? Hiszen mi hozzá se nyúltunk a 130-as sorban lévő törléshez, amellyel eddig eltüntettük a szót! Éppen ez a baj! A gép rendesen végrehajtja ezt az utasítást is, azaz kiír a tizedik sor tizedik oszlopától kezdve tíz szóközt. Csakhogy mi most nem oda írtuk ki a szavakat, így ezzel nem törölünk le semmit. Ha el akarjuk tűntetni a korábbi feliratokat, írjuk át a 130-as sort:

130 clear screen

No, most futtassuk le a programot! Ugye most már jól látható, ahogy újra írja a szavakat? Ez a program olyan szép, hogy bűn lenne eldobni. Vegyük fel inkább kazettára. Ez azért is hasznos lehet, mert holnap ezzel a programmal fogjuk folytatni az ismerkedést, ha tehát nem akarjuk az egészet újra begépelni, okosabb megmenteni.
Ma igazán sok újat láttunk!

Tegnapi programunk olyan jól sikerült, hogy érdemes foglalkoznunk vele még egy kicsit. Töltsük be a kazettáról:

10 CLEAR SCREEN
15 LET A$="ENTERPRISE"
20 DO
30   FOR N=1 TO 10
40     PRINT AT 10+N,10:A$(1:N)
45     PRINT AT 5,10:N
46     WAIT 1
50   NEXT N
130   CLEAR SCREEN
140 LOOP

Futtassuk le a programot! Az ENTERPRISE felirat szépen kiíródik. Persze ez a program nemcsak ezt tudja kiírni, hiszen éppen ezért használtuk a 15-ös sorban a változót. Ha ezt a sort megváltoztatjuk, a kiírt szöveg is változik. Írjuk hát át a következőre:

Az eleje nem rossz, csak minek írja ki még kétszer a végén a szöveget? Természetesen azért, mert mi a FOR-NEXT ciklusban arra utasítottuk, hogy tízszer menjen körbe. A gép tehát tízszer hajtja végre a ciklusban lévő utasításokat, és nem zavarja, hogy a változóban most nincs tíz, csak nyolc karakter. (Mert ugye a szóköz is karakter!)
Próbáljunk ki most egy másik feliratot:

Ugye a ciklus megint tízszer futott le, pedig a szöveg három betűvel hosszabb. Úgy kellene beállítani a számlálás felső határát a FOR utasításban, hogy mindig annyiszor fusson 1e a ciklus, amilyen hosszú a szöveg. De hiszen mi már tudjuk, hogyan lehet egy szöveg hosszát kiszámítani: a LEN függvénnyel! Vajon a FOR utasításba beírhatunk függvényt? Igen. A számlálás alsó és felső határát nemcsak egyetlen számmal adhatjuk meg, hanem függvényeket, kifejezéseket is beírhatunk. Próbáljuk ki:

Most futtassuk le a programot! így már valóban kiíródik minden betű. Sőt, ha más szöveget teszünk a 15-ös sorban az A$ változóba, az új szöveg is helyesen kerül ki a képernyőre. Csak arra kell vigyáznunk, hogy ha túl hosszú a szöveg, akkor a 40-es sorban lévő PRINT AT utasításban a sorszám nagyobb lesz, mint 24, és akkor a gép hibát jelez.
Meg kéne még próbálni néhány trükköt! Mi lenne, ha csak minden második sort írnánk ki? Ahhoz, hogy ezt megcsináljuk, nézzük meg, mi határozza meg, hogy a gép éppen hányadik sort írja ki?
Ha jobban belegondolunk, akkor csak az N változó -hiszen ez adja meg, hogy meddig kell kiírni a szót, és azt is, hogy melyik sorba. Ha elérnénk, hogy a FOR-NEXT ciklus ne egyesével, hanem kettesével számoljon, akkor csak minden második sor jelenne meg! De hogyan? Szerencsére a FOR utasításban arra is van mód, hogy megadjuk, mekkorákat kell lépni a ciklusban, hogy mennyit kell hozzáadni a ciklus számláló változójához. De hiszen eddig nem is írtunk ki semmit! Valóban: megtehetjük, hogy nem adunk meg lépésközt, de akkor a gép automatikusan egyesével számol. A lépésköz megadásához ismét egy angol szót használunk majd, a STEP (ejtsd: sztep) szót, amely lépést jelent. Ezt a szót biztosan mindenki hallotta már, csak nem önmagában, hanem bizonyos táncok neveként. Egészítsük ki a 30-as sort:

Ez tényleg minden második sor, méghozzá a páratlan sorok, azaz az első, a harmadik, az ötödik... De miért pont a páratlan és nem a páros sorok íródtak ki? Azért, mert a számolást egynél kezdtük. A FOR utasításban természetesen nemcsak egyet adhatunk meg kezdőértéknek. Ezt akár ki is próbálhatjuk. Állítsuk le a programot, listáztassuk ki, és, javítsuk át a 30-as sort:

Most is futtassuk le a programot! Ugye, hogy éppen az ellentétes sorok tűnnek fel? Ha már ennyi mindent tudunk, megpróbálhatnánk visszafelé is kiíratni a sorokat. Miért is ne? Hiszen ha meg tudjuk adni, hogy mennyit adjon hozzá a gép a ciklusváltozóhoz minden alkalommal, akkor megadhatunk negatív számot is. Ha pedig ilyet teszünk, akkor azzal, hogy egy nullánál kisebb számot hozzáad, valójában levon a gép a változóból. Egyre azért ügyelnünk kell. Eddig mindig a FOR kulcsszó után álló szám volt a kisebb és a TO után álló a nagyobb, hiszen egy kisebb számtól számoltunk egy nagyobbig. Ha azonban visszafelé számolunk, akkor az elöl álló szám lesz a nagyobb és a mögötte lévő a kisebb. Valahogy így:

Írjuk is ezt be a programba, és próbáljuk ki! A sorok tényleg fordított sorrendben jelennek meg, de végül mégiscsak ugyanaz a piramis tűnik fel.
Ma aztán jól megkevertük ezt a szegény programot! És még nincs vége! De mára már talán elég belőle, vegyük fel egy kazettára és tegyük el holnapra, mi pedig kezdjünk egy vadonatúj dologba. Mielőtt azonban továbbmennénk, ismerkedjünk meg egy rövid kis történettel!
A későbbi nagy matematikus, Karl Friedrich Gauss (1777-1855) már iskolás gyerek korában is igen jó eszű fiúcska volt. Egy számtanórán a tanár, akinek valami sürgős dolga akadt, nem akart az osztállyal foglalkozni, így hát kitalált egy jó nehéz feladatot, amivel úgy gondolta, el lesznek foglalva a nebulók; és amíg a gyerekek számolnak, addig ő nyugodtan csinálhat mást. A feladat így hangzott: mennyi az első száz szám összege? A tanár alaposan meglepődött, amikor a kis Gauss alig néhány perc múlva felállt, és jelezte, hogy ő már kész, szerinte az eredmény 5050.
- De hát hogyan tudtad ilyen gyorsan kiszámolni? - csodálkozott a tanító.
- Megfigyeltem - felelte Gauss -, hogy az első szám, az egyes, és az utolsó szám, a száz a száz összege pontosan százegy: 1+100=101. Ha a második számot (2) és az utolsó előttit veszem (99), az is százegy: 2+99=101. Ez így van minden ilyen számpárral, 1+100-tól egészen 50+51-ig. Mivel pedig ilyen számpárból pont 50 darab van, ezért az első száz szám öszege nem lehet más, mint 50*101=5050.
Mi most pont ugyanezt fogjuk kiszámolni, csak persze géppel, és ezért sokkal, de sokkal gyorsabban. Írjuk be a programot:

10 LET OSSZEG=0
20 CLEAR SCREEN
30 PRINT "AZ ELSO SZAZ SZAM OSSZEGE"
40 FOR SZAM=1 TO 100
50 PRINT "+";SZAM
60 LET OSSZEG=OSSZEG+SZAM
70 NEXT SZAM
80 PRINT "=";OSSZEG;

Ugye nem is olyan bonyolult? Próbáljuk is ki rögtön! A gép a képernyőn először felülre kiírja a címet ("az első száz szám összege"), majd sorban egymás alá elkezdi kiírni a számokat, ahogy összeadja őket. Végül megjelenik az eredmény, ami 5050.
Csak az a baj, hogy mire a végére ér, már rég nem látszik az eleje, az már kicsúszott a képernyőről. Hogyan tudnánk segíteni? Próbáljuk meg nem új sorba írni a számokat, hanem egybe:

A sor végére most pontosvesszőt tettünk, tehát az ezután következő PRINT ott fogja folytatni az írást, ahol ez abbahagyta. Futtassuk le a programot! Igen, igen, nem rossz, csak hát ki tudja elolvasni ezt a kavargó számözönt? Jó lenne oszlopokba rendezni őket, hogy áttekinthet8bb legyen. De hogyan? Írjunk az 50-es sor végére pontosvessző helyett egyszerűen csak egy vesszőt:

Futtassuk le így a programot! Ez az igazi! A vesszőt tehát ugyanúgy használhatjuk a PRINT utasításakban, mint a pontosvesszőt, csak kicsit más a hatása. A képernyőn 40 oszlop van, ezeket öt darab, nyolc karakter szélességű oszlopra osztottuk. Ha a PRINT utasításba vesszőt teszünk a kiírandó dolgok közé, akkor mindig a következő legközelebbi oszlop elejére ugrik a kurzor. Természetesen ha egy sor végén járunk, akkor ez az új sor eleje lesz.
És ha mi száznál szeretnénk kezdeni a számolást? Semmi akadálya, csak a 40-es sort kell átjavítani:

Ezután máris mehet a kocsi, azaz - bocsánat - a program. Az eredmény ugyanaz lesz, ami azért megnyugtató, mert tévedni emberi dolog, tehát még Gauss is elszámolhatta volna magát, de hogy egy számítógép rosszul számoljon, olyan nincs.
Most egy kicsit bonyolítsuk a dolgot! Számítsuk ki a félszámok összegét tíztől húszig! Félszámokkal is lehet ilyet csinálni? Persze! Írjuk hát át:

30 PRINT "A FELSZAMOK OSGZEGE OSSZEGE TIZTOL HUSZIG"
40 FOR SZAM=10 TO 20 STEP 0.5

Futtassuk le a programot! Az eredmény 315. Ha nem a félszámok, hanem a páros számok érdekelnek bennünket, akkor kettesével kéne számolni, de egyébként minden ugyanúgy, menne. Mi most ne is ezt próbáljuk ki, hanem egy sokkal érdekesebbet. Írassuk ki az első tíz szám összegét, de úgy, hogy az első sorba csak az elsőét, a másodikba az első kettőét és így tovább tízig. Nosza! Ehhez szinte teljesen át kell írnunk a programot: Ezért jobb, ha kitöröljük és egy újat kezdünk:

10 CLEARSCREEN
20 PRINT "OSSZEGSOROK"
30 FOR VEGE=1 TO 10
40   LET OSSZEG=0
50   PRINT "1-TOL";VEGE;"-IG=";
60   FOR SZAM=1 TO VEGE
70     LET OSSZEG=OSSZEG+SZAM
80   NEXT SZAM
90   PRINT OSSZEG
100 NEXT VEGE

Hát ez már nem is olyan egyszerű! Kezdjük elölről. A 10-es és a 20-as sor nem okoz problémát: törlik a képernyőt, és kiírják a fejlécet. A 30-as sor egy FOR-NEXT ciklus eleje, a VEGE nevű változó fog 1-től 10-ig változni. Ez a változó tartalmazza majd, hogy ebben a sorban meddig kell elszámolni. Az első sorban csak egyig, a tizedikben már ugye tízig.
A 40-es sor nullázza az OSSZEG változót, hiszen minden sor elején elölről kell kezdeni a számolást. Az 50-es sor ki is írja, hogy ezúttal mettől meddig adjuk majd össze a számokat. Ugye mindig egytő1 kezdjük, és ahogy azt az előbb mondtuk, addig
megyünk el, amennyi a VEGE változóban van.
Most jön a 60-as sor. Ez egy újabb ciklus kezdete, azaz egy kisebb doboz a nagyobbon belül. Hiszen az egyes összegeket is ciklussal kell kiszámoltatnunk. Éppen ez a ciklus végzi majd a számítást, méghozzá a 70-es sorban. A belső ciklus 1-től a VEGE változóban megadott értékig adja össze a számokat. Ez a belső ciklus a 80-as sorig tart.
Most már csak ki kell íratni az összeget; ugyanezzel a PRINT utasítással sort is emelünk a 90-es sorban. Végül a 100-as sor zárja le a külső ciklust, azaz itt ugrik vissza a gép, megnöveli a VEGE változó értékét, és új sor kiszámításába kezd.
Futtassuk le a programot! Az eredmények szépen sorban íródnak ki: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55. Ha akarnánk, számolhatnánk tovább, vagy kezdhetnénk máshol is a számolást, ehhez csak néhány számot kellene átírnunk a programban.
Ma tehát jó sokat számoltunk, és sok mindent megismertünk.

Emlékszünk még a tegnapi programunkra, amelyik fordított sorredben írta ki a megadott szöveget:

10 CLEAR SCREEN
15 LET A$="EZ MAR HOSSZU"
20 DO
30   FOR N=LEN(A$) TO 1 STEP -1
40     PRINT AT 10+N,10:A$(1:N)
45     PRINT AT 5,10:N
46     WAIT 1
50   NEXT N
130   CLEAR SCREEN
140 LOOP

Ha kazettára is felvettük, akkor töltsük be; ha nem, akkor gépeljük be újra! Szerencsére nem túl hosszú.
Ugye ez a program teljesen automatikus, nekünk csak a megfelelő szót kell beírnunk, ő Meg megszámolja, hány betű van a szóban, és annyi sort ír ki. Csak még az a baj, hogy ha meg akarjuk változtatni a szót, mindig meg kell állítanunk a programot, bele javítani a szövegébe, és újra elindítani. Mennyivel egyszerűbb volna a dolgunk, ha a program menet közben újra meg újra megkérdezné, milyen szót akarunk kiírni.
A kérés teljesíthető. Nem is túl nehéz, csak egy új utasítás kell hozzá, ez az INPUT. Eddig, ha valamit be akartunk írni egy változóba, azaz meg akartuk változtatni a változó tartalmát, akkor mindig a LET utasítást használtuk. A LET utasításnál azonban be kell írni a program szövegébe, hogy mit akarunk a változóba tölteni. Az INPUT utasításnál nem kell megmondanunk, hogy mi lesz a változó értéke, csak azt, hogy melyik változóba akarunk írni. Amikor a gép ehhez az utasításhoz ér, megáll, és megkérdezi, hogy mi is legyen akkor a változóban. Az INPUT szó maga azt jelenti: beadás, bemenet, és ez valóban a program egyik bemenete, hiszen itt mennek bele azok a dolgok, amelyeket nem írtunk eddig be a szövegbe. Olyan ez, mint egy fordított PRINT utasítás. Nem kiírja, hanem beolvassa a változók tartalmát. Használni is majdnem ugyanúgy kell. Javítsuk át a program 15-ös sorát:

Ez azt jelenti: "olvasd be az A$ vá1tozó tartalmát".
Indítsuk el a programot! A képernyő törlődik, és a bal felső sarokban megjelenik egy kérdőjel. Ez az INPUT jele, ezzel üzen, hogy szeretne valamit beolvasni. Persze a kérdőjel nem mindig a bal felső
sarokban jelenik meg, hanem ott, ahol éppen áll a kurzor. A kérdőjel mögött már ott villog a kurzor is, tehát be tudunk írni valamit. A gép azt fogja tölteni az A$ változóba, amit most beírunk. Próbaképpen írjuk be: SZOVEG, és nyomjuk le az ENTER billentyűt. A gép tehát beírja az A$ változóba azt, hogy SZOVEG, és folytatja a programot. A képernyőn mindjárt fel is tűnik a SZOVEG felirat, és ahogy azt a program idáig az EZ MAR HOSSZU felirattal tette, szépen elkezdi betűnként fogyasztani. Innentől kezdve már minden a régi, a program végtelen ciklusban fut.
Ha most megállítjuk a programot és újra elölről indítjuk, akkor újra feltűnik a kérdőjel és mi más szót is megadhatunk. Próbáljuk is ki -mondjuk írjuk be a saját nevünket. Csak arra vigyázzunk, nehogy túl hosszú legyen, mert akkor ugyanaz a hiba lép fel , mint amikor korábban a LET utasításokban túl hosszú volt a szó: a program a 24-edik soron túl próbál meg írni, amire a gép persze hibát jelez. Ha valakinek túl hosszú a neve, akkor próbálja meg rövidíteni. Tótszilvási Csalavér például használhatja a neve helyett a TóCsa rövidítést.
Mi az oka annak, hogy csak akkor tudjuk megváltoztatnia kiírandó nevet, amikor elölről kezdjük a programot? Ez talán mindig így van? Nem, nem, az ok sokkal egyszerűbb. Nézzük meg a programunk listáját! Az INPUT utasítás a végtelen cikluson kívül van, tehát csak egyetlen egyszer hajtja végre a gép, még azelőtt, hogy belépne a ciklusba. Ha mindig más nevet akarunk kiíratni, csak tegyük át máshová, és máris menni fog. Töröljük ki a 15-ös sort, és írjuk be 25-ös sorszámmal:

Most is indítsuk el a programot! A kérdőjel ugyanúgy feltűnik, mint az előbb, válaszoljunk tehát valamit. Mondjuk azt, hogy: ELSO. Amint lenyomtuk az ENTER billentyűt, a program elkezdi kiírni az egyre rövidülő sorokat, ahogy azt megszoktuk. De miután kiírta és törölte a képernyőt, nem kezdi újra, hanem megjelenik a kérdőjel, és a program megáll. Ismét az INPUT utasításhoz ért a program, és az A$ változó új értékét kérdezi Ha most valamit begépelünk akkor azt kezdi el betűzni, és ezt annyi szóval megtehetjük, ahánnyal csak akarjuk.
Ha nem írunk be semmit, csak az ENTER-t nyomjuk le, akkor az változóba üres szöveg kerül, ugyanúgy, mintha a LET A$="" utasítást adtuk volna ki. Az üres szöveg hossza 0, ezért a FOR-NEXT ciklus egyszer sem futna le, a gép pedig semmit sem írna ki, rögtön visszatérne az INPUT utasításhoz, és újabb szöveget olvasna be az A$ változóba.
Nos, most már tudjuk használni az INPUT utasítást, készítsünk hát vele valami mást. Az új program egy nyelvi játék, a beírt szó betűit fordított sorrendben írja ki. Mi ebben a játék? Ha azt akarjuk, hogy a gép által kiírt szöveg is értelmes legyen, akkor nem is olyan egyszerű megtalálni, mit írhatunk be.
Először azonban nézzük a programot:

1 PROGRAM "Fordit.bas"
10 CLEAR SCREEN
20 PRINT "FORDITVA IRO PROGRAM"
30 DO
40   PRINT
50   PRINT "A te szavad";
60   INPUT SZO$
70   PRINT "Az en szavam: ";
80   FOR MUTATO=LEN(SZO$) TO 1 STEP-1
90     PRINT SZO$(MUTATO);
100   NEXT MUTATO
110   PRINT
120 LOOP

Indítsuk el! A gép szépen megkérdezi a mi szavunkat, aztán kiírja fordítva. De hát hogyan kérdezi? Hiszen az előbb már láttuk, hogy az INPUT utasítás csak egy kérdőjelét ír ki! Nos, nagyon egyszerű. Az 50-es sorban lévő kiírás végére pontosvesszőt tettünk, tehát a kurzor ottmaradt az "A TE SZAVAD" szöveg végén. A most következő INPUT ide írja ki a kérdőjelet! Így lesz tehát a kijelentésből kérdés, és ezért ír ki épp kérdőjelet az INPUT. Ügye, milyen egyszerű?
Csak egy dolog zavaros még. Mi csinál az a PRINT utasítás a 90-es sorban? Azt értjük, hogy kiírja a SZO$ változó tartalmát, de mire jó a mögötte zárójelben levő MUTATO? Nos, ez pontosan ugyanaz a megoldás, mintha azt írtuk volna: PRINT SZO$(MUTATO:MUTATO) Ha azt látnánk, akkor tudnánk, hogy a SZO$ nevű változóból kell a MUTATO-adik betűtől a MUTATO-adik betűig terjedő részt venni, ami persze egyetlenegy betű: amelyikre a MUTATO mutat. Az ENTERPRISE BASIC megengedi, hogy ha egy szöveg egyetlen betűjére akarunk hivatkozni, akkor nem kell kétszer leírnunk a mutatót, elég egyszer is.
Így már minden-érthető. Mire jó ez a program? (Azon kívül, hogy megtanuljuk vele a mutató használatát.) Nos, kereshetünk vele például olyan szavakat, mondatokat, amelyek visszafelé olvasva is értelmesek. Próbáljuk ki például azt a szót, hogy MOZI. Már jön is a válasz: IZOM.
Tudunk e még más ilyen szavakat is találni? Ott van például a GÖRÖG vagy a KEREK. Tessék keresni, hátha találunk még!
Ha meguntuk, jöhet egy másik fejtörő program:

10 LET VEGE$="LOM"
20 DO
30   PRINT "AZ ELEJE";
40   INPUT ELEJE$
50   LET SZO$=ELEJE$&VEGE$
60   PRINT "A SZO:";SZO$
70   PRINT
80 LOOP

Ez a program egy szónak az elejét várja; ha begépeltük neki, ismét kiírja, csak hozzáilleszti a végéhez: LOM. Olyan szavaknak az elejét kell hát beírnunk neki, amelyeknek az a vége, hogy LOM. Irodalom, alkalom, alom, halom... Tessék folytatni a sort! És ha semmit nem írunk be, csak az ENTER billentyűt ütjük le? Nos, akkor a gép egy üres szöveget olvas be, és azt teszi a LOM elé, azaz semmit sem. Így aztán azt írja ki: LOM.
Ha már nincs több szavunk, menjünk tovább egy számolóprogramra:

10 CLEAR SCREEN
20 PRINT "TOSZOROZO PROGRAM"
30 LET SZ=2
40 DO
50   PRINT
60   INPUT PROMPT "A TE SZAMOD:":SZAM
70   PRINT "A SZAMOD";SZ;"SZERESE:";SZ*SZAM
80 LOOP

Ennél a programnál nem szöveget, hanem egy számot olvasunk be egy számváltozóba. Most a változó neve is az, hogy SZAM. Mivel nincs a neve végén dollárjel ($), ezért számokat tudunk tárolni benne. A számok beolvasásához az INPUT utasítást ugyanúgy tudjuk használni, mint a szövegekéhez, csak persze nem szöveges, hanem számváltozóst kell megadnunk. De mi az a PROMPT felirat? A prompt angol szó, és súgást jelent, ami az iskolában tilos ugyan, de a BASIC suliban nagyon is fontos. Azt már tapasztaltuk: az az egyetlen kis kérdőjel önmagában nem elég ahhoz, hogy tudjuk mit is kérdez tőlünk a program. Előtte mindig egy-egy PRINI utasítással írtuk ki, hogy mire kértünk választ. Szerencsére az ENTERPRISE BASIC ebben is segít nekünk. Az INPUT utasításban a PROMPT kulcsszó után megadhatunk egy szöveget, amit a gép a kérdőjel helyett kiír. Így egyetlen utasítással tudunk kérdezni, és beolvasni a választ is. Csak arra figyeljünk, hogy a kérdés és a változó neve közé még egy kettőspontot is tennünk kell!
Próbáljuk ki a programot! Ugye jól számol? Keressük meg, hol állítottuk be, hogy hányszorosát írja ki a beolvasott számnak. Változtassuk meg mondjuk ötszörösre, Figyeljük meg, hogy a kiírt szövegben is helyesen jelenik meg, hogy mivel szorzott a gép! A dolog titka mindössze annyi, hogy azt a számot, amellyel majd szorzunk, egy változóba (SZ) tettük be, és a kiíratásnál innen íratjuk ki, hogy most éppen mennyivel szoroz a program.
Ha ez a gép ilyen jól tud szorozni, igazán csinálhatnánk egy programot, ahol a szorzót és a szorzandót is így olvassa be a gép; akkor kényelmesen tudnánk szorozni. Semmi akadálya:

10 DO
20   CLEAR SCREEN
30   PRINT "SZORZO PROGRAM"
40   INPUT AT 10,10,PROMPT "SZORZO:":SZORZO
50   INPUT PROMPT"SZORZANDO:",AT 11,10:SZORZANDO
60   PRINT AT 12,10:"A SZORZAT=";SZORZO*SZORZANDO
70   WAIT 3
80 LOOP

Ebben a programban szinte mindent értünk, csak azt kéne még kideríteni, mi az az AT 10,10, meg az AT 11,10 a két INPUT utasításban? Természetesen ugyanaz, mint a PRINT utasításban: itt tudjuk megadni, hagy hol tegye fel a kérdést, hová írja ki a képernyőre. Ha jobban megnézzük, láthatjuk, hogy állhat a PROMPT előtt vagy után, de azt még elárulom, hogy ha nincs PROMPT megadva, akkor önmagában is, csak arra kell ügyelni, hogy az AT és az őt követő két szám még az elválasztó kettőspont előtt legyen, ugyanúgy, mint a PRINT-nél.
Indítsuk el a programot! A kérdéseket jól láthatóan a képernyő közepén kapjuk és ott tudunk válaszolni is. A program tökéletes, csak arra kell figyelnünk, hogy az eredmény csupán három másodpercig (ameddig a WAIT megállítja a programot) látható a képernyőn, utána eltűnik. Ha nem elég a három másodperc, állítsuk meg a programot a HOLD billentyűvel, amíg ellenőrizzük a számítást.
Ezután jöjjön egy program, amelyik kiszámítja, hogy hány éves a kapitány:

10 CLEAR SCREEN
20 INPUT PROMPT "A KAPITANY NEVE:":NEV$
30 INPUT PROMPT "AZ IDEI DATUM 19": DAT
40 INPUT PROMPT "A KAPITANY SZULETESI EVE 19":SZUL
50 PRINT NEV$;" KAPITANY ";DAT-SZUL;"EVES"

Futtassuk le a programot és írjuk be a saját nevünket, a helyes dátumot meg a születési évünket! A program kiszámítja, hány évesek vagyunk. (Idősebbek egy kicsit csalhatnak.) Egyre azonban figyelnünk kell! Ha a program számot vár, és mi betűket gépelünk be, a gép hibát jelez, mert nem tudja a megadott változóba beírni a betűket. Nagyon ügyeljünk, hogy ha számváltozóba írunk, akkor számot adjunk meg. Ha ezt betartjuk, akkor akár egyetlen INPUT utasításban több dolgot is beolvashatunk, csak arra kell figyelni, hogy pontosan abban a sorrendben írjuk be, ahogy a gép kérdezi. Próbáljuk ezt ki a kapitány programján. Töröljük a 20-as, a 30-as, a 40-es sorokat és helyettük egyetlen sort írjunk be:

Tehát egyetlen INPUT utasításba több változót is beírhatunk, ha közéjük vesszőket teszünk. De hogyan tudunk válaszolni, ha egyszerre hármat kérdeznek tőlünk? Természetesen nem egyszerre, hanem egymás után kell válaszolnunk, ugyanolyan sorrendben, ahogy a változók vannak, az egyes válaszokat pedig nem kell ENTER-rel lezárni, hanem csak egy-egy vesszővel
egymástól elválasztani. Csak akkor kell az ENTER billentyűt is leütni, ha már mind a három választ leírtuk. Próbáljuk ki! Indítsuk el a programot és írjuk be:

A kapitány kicsit már koros, a program pedig igen fürge. A mai napon igazán sokat tapasztaltunk.

A számítógéppel társalogva úgy megszoktuk a parancsolgatást, hogy talán már el is felejtettünk kérni. Pedig az udvariasság fontos dolog! De hát miért is lennénk udvariasak, ha egyszer a gép sem az? Hogy-mást se mondjak, eddig még egyszer sem köszönt, pedig ha valakivel találkozunk, akkor ugye úgy illene? A gép azonban magától nem tud köszönni, nekünk kell egy kis jólneveltséget vernünk a fejébe. Azért verni nem kell, hiszen már tudjuk, hogy őt programokkal lehet tanítani. Lássunk is mindjárt egy küszönő programot:

10 CLEAR SCREEN
20 PRINT "En vagyok az ENTERPRISE"
30 DO
40   INPUT PROMPT"Hat teged hogy hivnak?":NEV$
50   PRINT "Szervusz,";NEV$
60   PRINT
70 LOOP

Futtassuk le a programot! A program megkérdez nevünket és szépen köszön, ahogy egy jól nevelt géphez illik. Most írjuk be a nevünk helyett azt, hogy "kapitany". A gép egyből válaszol is: "Szervusz, kapitany". de kérem! Egy kapitánynak nem illik szervusszal köszönni! Egy ilyen tekintélyes úrnak egészen más jár. HA tehát valaki kapitány, AKKOR úgy kell köszönni neki: Üdvözlöm, kapitány úr!
Ezt kéne megmondani a gépnek is. Meg is mondjuk, csak persze nem magyarul, hanem BASIC-ül. A HA angolul IF, az AKKOR pedig THEN, csak ezt utóbbit körülbelül úgy kell ejteni: den.

Írjuk be a fenti sort! Az IF után persze nem szavakkal írtuk le, hogy mikor kell üdvözölni a kapitányt, hanem BASIC utasításokkal, vagyis azt írtuk, hogy IF (ha) a beolvasott NEV$ változó tartalma egyenlő a "kapitány" szöveggel, THEN (akkor) írd ki azt: Üdvözlöm, kapitány úr! Indítsuk el a programot!
Írjuk be: kapitany.
Rögtön jön is a válasz:

Ej, gépecském, gépecském, hát a kapitányt sem kell kétszer köszönteni! HA a NEV$ nem kapitány, csak AKKOR kell szervusszal köszönni. Javítsuk hát át az 50-es sort:

Hát az meg mi a manó a NEV$ és a "kapitany" között? Ez két jel egymás után írva, az egyik a "kisebb" jel (<), a másik a "nagyobb" jel (>). Igaz, egyik jel sem nagyobb, mint a másik, mindkettő pont egy-egy karakter, de mégis ez a nevük. Német gépeken a bal alsó sarokban vannak eldugva, az egyik a másik hátán, úgyhogy csak a SHIFT-tel lehet elérni. (Angol gépeken ez a két jel két egymás melletti billentyűn van, a bal oldalon alul.) Általában összehasonlításban használjuk őket: ha két dolgot össze akarunk hasonlítani, akkor ezekkel tudjuk jelölni, hogy az egyik kisebb, mint a másik, azaz BASIC-ül: EGYIK<MASIK. De hát most egyszerre van itt mind a kettő! Hát most a NEV$ kisebb vagy nagyobb, mint a "kapitany"? Se nem kisebb, se nem nagyobb, se nem egyenlő, vagyis éppen hogy NEM EGYENLő! Ha azt akarjuk jelölni, hogy két dolog nem egyenlő, akkor a kisebb meg a nagyobb jelet is beírjuk közéjük, abban a sorrendben, ahogy fent; ez pedig éppen azt jelenti a gépnek: nem egyenlőek. Az új 50-es sor magyarul tehát ennyit mond: HA a NEV$ nem egyenlő a "kapitany" szöveggel, AKKOR írd ki azt, hogy "Szervusz" és rögtön utána a NEV$ változó tartalmát! Futtassuk le a programot! Próbáljuk ki a saját nevünkkel és a "kapitany"-nyal is! Ügye most már nem köszön kétszer?
Azt most már tudjuk, hogyan köthetünk ki feltételeket, de a programot még mindig a STOP billentyűvel kell leállítanunk. Pedig igazán megtaníthatnánk, hogy ha azt mondjuk: VEGE, akkor vége. Azaz: HA a begépelt szó az, hogy VEGE, AKKOR a program álljon meg, tehát ugorjon ki a ciklusból. Semmi akadálya, írjuk csak be:

(Az EXIT szó azt jelenti: kijárat, és ez a kijárat a végtelen ciklusból, tehát oda is kell írni, hogy DO.) HA a NEV$ változó tartalma az, hogy VEGE, AKKOR a program kiugrik a DO ciklusból.
Indítsuk el a programot, és próbáljuk ki! Amíg neveket írunk be, addig rendesen köszönget. Most gépeljük be: vege. A gép ismét csak köszön: Szervusz, vege. Hol lehet a hiba? Nézzük csak meg azt a 43-as sort/ Hát persze! A vége szót nagybetűkkel írtük, ezért nem ismerte fel, amikor kisbetűkkel gépeltük be. De hiszen korábban azt mondtuk, hogy a gépnek mindegy, hogy valami kis vagy nagybetűkkel van írva? Akkor meg mi ez most?
A gépnek tényleg mindegy, hogy az utasításokat milyen betűkkel írjuk, de a szövegekre már ez nem igaz! Figyeljük csak meg, hogy a kulcsszavakat mindenütt át is írja nagybetűsekre, mert az kényelmesebb, de ami az idézőjelek között áll, az sohasem változik! "VEGE"<>"vege"!
Indítsuk el újra a programot, és most próbáljuk meg nagybetűkkel beírni: VEGE. A gép rögtön leáll, a ciklusbál sikerült kiugranunk. Csak elköszönni felejtett el a gép. Persze, hiszen meg sem mondtuk neki, hogy el is kell köszönnie. De hát hova írjuk ezt be? Írjuk be így:

Az EXIT DO utasítás ugyanis nem a program végét jelenti, csak azt, hogy ugorjunk a ciklus végét jelző LOOP utáni sorra. Ha itt már nincs semmi, akkor természetesen véget ér a program, de ha
folytatjuk, akkor rendesen fut tovább, most például kiírja majd, hogy "Hát akkor vége". Indítsuk el, és állítsuk meg a VESE szóval a programot! A gép kiírja:

Tehát a gép tényleg a LOOP utáni utasításra ugrott. De azért még lehetne egy kicsit javítani a stílusán! Ha mi köszönünk valakinek, akkor utána meg is szoktuk kérdezni, hogy hogy van. Most persze másként kell kérdeznünk egy kapitánytól, és másként a többiektől. Hát akkor még két sort be kell írnunk.

55 IF NEV$<>"kapitany" THEN PRINT "Hogy vagy?"
47 IF NEV$="kapitany" THEN PRINT "Hogy erzi magat?"

És ha még egy mondatot akarunk tanítani a gépnek, akkor még egyszer le kell írnunk az egész IF-THEN sort? Szerencsére nem, különben hamar beleunnánk. Az IF-THEN utasítással egyszerre több parancsot is kiadhatunk, csak ilyenkor blokkba kell zárnunk őket. Ilyenkor a THEN szó után nem állhat semmi sem abban a sorban, de az összes következő sor mégis úgy fog viselkedni, mintha előtte volna az egész IF feltétel. De meddig? Ettől kezdve a program összes sora csak akkor fog lefutni, ha az IF utasításban megadott feltétel teljesül?
No, erről azért szó sincs. Az IF blokk elejét egy olyan IF sor jelöli, amelyikben nincs a THEN után semmi, a végét pedig az END IF utasítás. Az END szót mindenki ismeri az amerikai és az angol filmek végéről; azt is jelenti: vége. Ha mögé írjuk az IF-et, azt jelenti: vége az IF blokknak. Írjuk hát át így a programot:

10 CLEAR SCREEN
20 PRINT "En vagyok az ENTERPRISE"
30 DO
40   INPUT PROMPT"Hat teged hogy hivnak?":NEV$
43   IF NEV$="VEGE" THEN EXIT DO
45   IF NEV="kapitany" THEN
46     PRINT "Udvozlom,kapitany ur! "
47     PRINT "Hogy erzi magat?"
48   END IF
50   IF NEV$<>"kapitany" THEN
46     PRINT "Udvozlom, kapitany úr!"
47     PRINT "Hogy erzi magot?"
50   ELSE
51     PRINT "Szervusz,";NEV$
55     PRINT "Hogy vagy?"
57   END lF
60   PRINT
70 LOOP
80 PRINT "Hat akkor vege"

Ha elindítjuk a programot, láthatjuk, hogy ugyanazt csinálja, mint az előző, csak ez ugye egyszer vizsgálja meg, mi is van a NEV$ változóban. Vigyázzunk arra, hogy ha az ELSE utasítást használni akarjuk, akkor azt mindig külön sorba kell írnunk, és az lF blokkot az END IF utasítással kell lezárnunk!
Ez a program olyan sokat tud, hagy már nincs is értelme tovább játszanunk vele, inkább kezdjünk egy újat. Vegyük fel kazettára, ha akarjuk, és utána töröljük ki. Jöhet az új feladat! Csináljunk programot, amelyik sorba rak két számot. Mindig a kisebbiket írja ki előre, a nagyobbikat másodiknak. Roppant egyszerű:

10 CLEAR SCREEN
20 PRINT "SORRENBE RAKAS"
30 INPUT PROMPT "IRD BE A SORRENDBE RAKANDOKAT!":ELSO,MASODIK
40 IF ELSO>MASODIK THEN
50   LET CSERE=ELSO
60   LET ELSO=MASODIK
70   LET MASODIK=CSERE
80 END IF
90 PRINT "AZ ELSO=";ELSO
100 PRINT "A MASODIK=";MASODIK
110 PRINT

Futtassuk is le! Vigyázzunk, mert a program két, számot vár, egymástól vesszővel elválasztva, és csak ha mind a kettőt begépeltük, akkor szabad megnyomnunk az ENTER billentyűt. A program jól működik. Futtassuk le még néhányszor más-más számokkal. Próbáljuk ki azt is, mi történik, ha az első szám után rögtön leütjük az ENTER-t. A gép újra kérdez, de mi tudjuk, hogy az első számot már megadtuk, ezért csak a másodikat kell begépelnünk. Ha ilyen jó a program, próbáljuk meg megérteni, hogyan is működik!
Az elején semmi mást nem csinál, minthogy beolvassa a két számot két változóba. Ami ez után jön, az az érdekes! Megnézi, hogy milyen sorrendben vannak a számok. Ha jó a sorrend, akkor nem csinál semmit, hiszen az IF utasításnak nincs ELSE ága. Ha azonban rossz a sorrend, azaz az ELSO változóban lévő szám nagyobb, mint a MASODIK-ban lévő, akkor kicseréli őket.
Hogyhogy kicseréli őket? Hol van itt a cserélő utasítás? Nincs, ugyanis ilyen utasítás nem létezik! Ha ki akarjuk cserélni két változó tartalmát, kénytelenek vagyunk egy harmadikat is felhasználni hozzá: Először az egyik változó tartalmát áttesszük a segédváltozónkba (CSERE=ELSO). Aztán a másik változó tartalmát betöltjük az elsőbe (ELSO=MASODIK). Ezzel az ott lévő korábbi értéket felülírtuk, azaz most mindkét eredeti változónkban a második tartalma van. De honnan tudjuk akkor, mi volt az elsőben? Éppen erre kellett a segédváltozó: abba mentettük el. Most már nyugodtan be tudjuk ezt tölteni a második változóba (MASODIK=CSERE), ezzel befejeztük a cserét!
Ügye nem is olyan bonyolult? Tessék utánagondolni, és kipróbálni! Működik. A programunk pedig olyan jól működik, hogy rögtön kedvünk kerekedne tőle nemcsak számokat, hanem szövegeket is sorba rakni. Sorba, azaz ábécérendbe. Ha lehetséges - miért ne? Igen, lehetséges, mindössze a változók nevének a végére kell egy-egy dollárjelet ($) tennünk a 30-as, a 40-es, az 50-es, a 60-as, a 70-es, a 90-es, és a 100-as sorokban, és a program máris indulhat. De hát hogyan fog működni a 40-es sorban lévő összehasonlítás?

Hogyan lehet szövegeket összehasonlítani? Pontosan az ábécésorrend alapján. A gép mindig az ábécé szerint előrébb lévő szöveget tekinti a kisebbnek amelyik. Ha a két szöveg betűről betűre megegyezik akkor persze egyen1őek. Ha azonban akár csak egy szóközben is eltérnek, akkor már nem. Akkor tehát "Ubul" nem ugyanaz, mint "Ubul "? Nem bizony! A gép ilyenkor azt tekinti kisebbnek, amelyik rövidebb?
Mi a helyzet a nagybetűkkel és a kisbetűkkel? Azok azonosak? Nem, nem, hiszen tudjuk, hogy a szövegekben ezek eltérnek egymástól. A gép úgy dolgozik, mintha minden nagybetű e1őrébb lenne az ábécében, mint a kisbetűk. Így aztán "Töhötöm" előrébb van mint "albert", mert az utóbbi nevet kisbetűvel kezdtük, és az máris nagyobb, mint a Töhötöm elején álló nagy T. Tanulság? Tessék vigyázni a helyesírásra tessék figyelni a számítógép különleges ábécésorrendjére!
Ma jó alaposam megleckéztettük a számítógépet! Megtanítottuk, hogy:

Aki gyakran ül be a moziba megnézni valami jó háborús filmet, az már szinte látja is maga előtt a főhőst, ahogy kegyetlenül töri a fejét, mert nem tudja a jelszót. Aki nem találja ki, azt az őr bizony nem engedi tovább. Jó lenne gyakorolni ezt a jelszókitalálást, csak hát hogyan? Segít a számítógép! Írjuk be a következő programot:

10 CLEAR SCREEN
20 INPUT PROMPT "UJ JELSZO:":JELEZSO$
30 DO
40   IF JELSZO$="VEGE" THEN EXIT DO
50   CLEAR SCREEN
60   PRINT "JELSZO KITALALAS"
70   DO
80     INPUT PROMPT "TIPP:":SZO$
90     IF SZO$=JELSZO$ THEN EXIT DO
100   LOOP
110   PRINT "EZ AZ!!"
120   INPUT PROMPT "UJ JELSZO:JELSZO$
130 LOOP
140 PRINT "KOSZONOM A JATEKOT"

Ha elindítjuk, a program megkérdezi a jelszót. Írjunk be valamit neki. A gép törli a képernyőt, és elkezdi kérdezgetni a tippjeinket. Ha nem a megfelelő jelszót adjuk meg, a gép nem fogadja el, új tippet kér. Ez egészen addig folyik, amíg nem sikerül kitalálnunk a jelszót. Ha sikerült, új jelszót adhatunk meg, és kezdődik elölről a játék, amíg egyszer azt nem választjuk jelszónak: VEGE. Erre a jelszóra a gép leáll.
Hogyan is működik ez a program? Első pillantásra a program két egymásba ágyazott végtelen ciklusból áll. A külső ciklus a 30-as sorban kezdődik, és a 130-as sorig tart. A belső ciklus a 70-estől a 100-as sorig tart. Ám ha jobban megnézzük, a belső ciklus nem is olyan végtelen! Ebben a ciklusban a program a tippjeinket kérdezgeti, de csak addig, MÍGNEM egyszer sikerül kitalálnunk a jelszót. Ez a ciklus igazából nem is végtelen, hiszen csak addig vár, MÍGNEM a megfelelő szót adjunk meg. Ha ez a FELTÉTEL teljesül, akkor rögtön véget is ér. Helyesebb is lenne ezt feltételes ciklusnak hívni, nem végtelennek.
De hát tudjuk, hogy a DO-LOOP ciklus eredetileg végtelen, csak az EXIT DO használatával tettük feltételessé. Ha valaki gyorsan olvassa a programot, észre sem veszi, mi itt a feltétel. Jó lenne ezt valahogy kiemelni, hogy jól látható legyen. Nos, az ENTERPRISE BASIC erre lehetőséget ad. Eddig a végtelen ciklus valahogy úgy nézett ki:

Most egy új ciklussal ismerkedünk meg, a feltételes UNTIL ciklussal. Az UNTIL angol szó, ántil-nak kell ejteni, és azt jelenti: mígnem. Az új ciklus így fest:

Csináld (DO)
amit ide írtam
ciklusban (LOOP), mígnem (UNTIL) teljesül a feltétel.

Írjunk tehát olyan ciklust, amely addig olvas, mígnem a beolvasott szó megegyezik a jelszóval!

Töröljük hát a programból a 90-es sort, helyette pedig írjuk át a 100-ast a következőre:

Próbáljuk ki! A program tökéletesen működik, és ha kilistázzuk, rögtön látszik, hogy a belső ciklus nem végtelen, hiszen ott van benne az UNTIL feltétel.
És a külső ciklus az? Dehogy, hiszen csak addig megy ez is körbe-körbe, míg azt nem adjuk meg jelszónak, hogy VEGE. Ez is egy UNTIL ciklus, csak egy kicsit más. A különbség egészen csekély, mégis megérdemli, hogy foglalkozzunk vele. Képzeljük el, mi történik, amikor elindítjuk a programot. A gép megkérdezi az új jelszót, és beolvassa. Ezután első dolga az, hogy megnézze, nem az jött-e, hogy VEGE, mert akkor vége a játéknak. Ha nem, akkor folytatódik a program, ki kell találni a szót.
Ha azonban egy ugyanolyan UNTIL ciklust próbálnánk ide is tenni, mint az e1őbbi, nagy hibát követnénk el! Gondoljunk arra, hogy az előbb látott UNTIL ciklus mindig először végrehajtotta a ciklusban lévő utasításokat, és csak azután nézte meg, kell e még egyszer elölről kezdenie. A programunk külső ciklusa viszont előbb nézi meg, hogy nem a VEGE jelszót adtuk-e meg, és ha igen, akkor bele se kezd a ciklusba! Ha rögtön a program elindítása után meggondolj magunkat, és azt a jelszót adjuk meg: VEGE, program szépen rendben véget ér. De ha átírnánk Olyan ciklusra, amely a feltételt a ciklus végén vizsgálja meg (ezért végfeltételesnek is nevezik), tehát egy UNTIL ciklusra, akkor legalább egyszer mindenképpen lefutna a ciklus, vagyis azt a jelszót is ki kéne találnunk, hogy VEGE. Ilyenkor használjuk a feltételes UNTIL ciklus másik formáját, a kezdeti-feltételes UNTIL ciklust.

Csináld (DO), mígnem (UNTIL) teljesül
a feltétel azt, amit ide írtam
ciklusban. (LOOP)

Itt már előbb nézi meg a feltételt és csak aztán lát neki a ciklusnak. Az a ciklus, amelyik addig fut, mígnem a JELSZO$ az nem lesz, hogy VEGE, a következő:

INPUT JELSZO$
DO UNTIL JELSZO$="VEGE"
ciklusban levő utasítások INPUT JELSZO$
LOOP

Nézzük meg, hogy most két külön beolvasó utasítást kellett írnunk, hiszen ahhoz, hogy a ciklus előtt meg tudjuk vizsgálni a JELSZO$ változó tartalmát, előbb valamit bele kell töltenünk. A második olvasás mindig az új jelszót tölti be a JELSZO$-ba.
Alakítsuk hát át a programunkat ilyen kezdeti-feltételes UNTIL ciklussá. Töröljük ki a 40-es sort, és helyette egészítsük ki a 30-ast a következőre:

Próbáljuk ki most így is! A program továbbra is hibátlanul működik. Most már akár versenyezni is lehetne, hogy egy-egy szót ki hányadikra talál ki. Csak az a kényelmetlen, hogy amikor végre sikerült kitalálni, akkor úgy kell egyenként összeszámolnunk, hányadik tipp volt jó. Arról nem is beszélve, hogy ha az első tippek már kicsúsztak a képernyőről, akkor nem is látjuk őket - hogyan tudnánk tehát megszámlálni? Mennyivel egyszerűbb lenne. ha a program számlálna! Semmi akadálya! Írjunk be négy új sort:

55 LET TIPPSZAM=0
75 LET TIPPSZAM=TIPPSZAM+1
76 PRINT TIPPSZAM;
115 PRINT TIPPSZAM;"-ADIKRA KITALALTAD"

Ha most is kipróbáljuk, láthatjuk, hogy a program pontosan számol. Nézzük csak végig ezeket a sorokat! Az 55-ös sor a tippeket számláló változót nullázza. Enélkül az utasítás nélkül a számlálás nem kezdődne mindig nulláról, tehát olykor hibás lenne az eredmény. A 75-ős sor mindig eggyel növeli a TIPPSZAM értékét, majd a 76-os ki is írja egy sor elejére, de a kurzort ott tartja, mert majd ide, a tippszám után kell kiírni a "TIPP:" szöveget és a tippet. Végül a 115-ös sor akkor írja ki a tippszámot, ha sikerült kitalálni a jelszót.
Most már szinte tokéletes a program, csak az a zavaró, hogy ha egy jelszót már megadtunk, akkor többé nem tudjuk megállítani a programot, és módosítani a jelszót, csak ha kitaláljuk a régit. Mennyivel jobb lenne, ha volna egy különleges tipp, amit ha beírunk, akkor a gép egyből egy új jelszót kérne be. Persze megtehetnénk, hogy beírunk egy olyan sort a belső, azaz a tippeket olvasó ciklusba, hogy:

Azt azonban most már tudjuk, hogy az EXIT DO utasítást (és FOR ciklusoknál az EXIT FOR-t) csak végszükség esetére kell fenntartanunk, mert általában a program sokkal jobban érthető, ha nem ugrálunk ki-be a ciklusokba. Valahogy azt kéne megfogalmazni, hogy a belső ciklus ne csak akkor érjen véget, ha kitaláltuk a jelszót, hanem akkor is, ha jelszónak ezt a fenti szöveget adjuk meg.

CSINÁLD azt, hogy
beolvasod a következű tippet
CIKLUSBAN mindaddig, MÍGNEM kitalálom a jelszót
VAGY új jelszót akarok megadni.

Az OR angol szó, magyarul azt jelenti: vagy. Ezt a szót akkor használjuk, ha egy feltétel több részből áll , és nekünk már az is elég, ha csak egy feltétel teljesül közülük. Ilyenkor az egyes feltétételeket az OR szóval kapcsoljuk össze, mivel mindegy, hogy az egyik VAGY (OR) a másik feltétel teljesül-e. írjuk: hát át a 100-as sort:

Most már elég csak annyit beírnunk tippnek: UJ JELSZO KELL, és máris megadhatjuk az új jelszót. Csak az a furcsa, hogy ha kipróbáljuk akkor láthatjuk: a program az új jelszó kérését ugyanúgy megünnepli, mintha tényleg kitaláltuk volna a jelszót. Persze, hiszen az "UJ JELSZO KELL" hatására a beleső ciklus véget ér, ez pedig korábban csak akkor történhetett meg, ha megfejtettük a jelszót. Mostantól fogva viszont csak akkor kell ünnepelni , HA valóban jó magoldás született. Az ünneplést tehát be kell tennünk egy feltételes (HA-IF) szerkezetbe:

Indítsuk el a programot, és próbáljunk most is új jelszót adni tippelgetés közben! Most már csal akkor gratulál a gép, ha tényleg megfejtettük az elrejtett szót.
Aki kicsit kényelmesebb, az választhat rövidebb kilépési tippet is, csak a 100-as és a 105-ös sorban kell az "UJ JELSZO KELL" szöveget valami másra kicserélni. Arra azonban vigyázzunk, hogy ha véletlenül csak egyetlen betűben is eltér a kél szöveg, akkor a program olyankor is sikeresnek fogadja el a tippelést, amikor éppen a speciális kilépési tipp segítségével jöttünk ki a belső
ciklusból. Hogyan lehetne segíteni ezen? Hogyan tudnánk garantálni, hogy a két utasításban mindig ugyanaz a szöveg legyen kilépési tippként felhasználva? Ha két dolog annyira azonos, hogy meg se lehet őket különböztetni egymástól, akkor az már nem is két dolog, hanem csak egy: egy változó! Tegyük be a kilépési tippszót egy változóba és használjuk ezt mindkét helyen. írjuk be hát a 15-os sort és javítsuk át a 100-as és 105-ös sort a következők szerint:

15 LET KIKULCS$="KIFELE"
100 LOOP UNTIL SZO$=JELSZO$ OR SZO$=KIKULCS$
105 IF SZO$<>KIKULCS$ THEN

Aki akarja, az használhatja ezt a kulcsot a külső ciklusból való kilépéshez, ekkor a 30-as sorban kell a feltételt megváltoztatni. Mi most ezzel már nem foglalkozunk, helyette nézzük még egyszer végig a programot, és próbáljuk meg minden egyes utasítását pontosan megmagyarázni! Ha ez sikerül, akkor már gyerekjáték a folytatás.

1 PROGRAM "Jelszo.bas"
15 LET KIKULCS$="UJ JELSZO KELL"
20 INPUT PROMPT "UJ JELSZO:":JELSZO$
30 DO UNTIL JELSZO$="VEGE"
50   CLEAR SCREEN
55   LET TIPPSZAM=0
60   PRINT "JELSZOKITALALAS"
70   DO
75     LET TIPPSZAM=TIPPSZAM+1
76     PRINT TIPPSZAM;
80     INPUT PROMPT " TIPP:":SZO$
100   LOOP UNTIL SZO$=JELSZO$ OR SZO$=KIKULCS$
105   IF SZO$<>KIKULCS$ THEN
110     PRINT "EZ AZ!!"
115     PRINT TIPPSZAM;"-ADIKRA KITALALTAD"
117   END IF
120   INPUT PROMPT "UJ JELSZO:":JELSZO$
130 LOOP
140 PRINT "KOSZONOM A JATEKOT!"

Búcsúzzunk el ettől a programtól, és a mai naptól is. Ma már megismertünk:

A programjainkban gyakran előfordul, hogy valamilyen kérdés jelenik meg a képernyőn, amire nekünk válaszolnunk kell. Válaszként viszont egyetlen betű is elég, nem kell egy egész szót begépelni. Nézzünk egy példát:

1 PROGRAM "Beno.bas"
10 CLEAR SCREEN
20 DO
30   PRINT
40   PRINT "Akarod latni Benot?"
50   INPUT VALASZ$
60   IF VALASZ$="i" THEN
70     PRINT "    SSS"
80     PRINT "   SSSSS"
90     PRINT " S     S"
100     PRINT " C O   O D"
110     PRINT "  I  :  I"
120     PRINT "  I  :  I"
130     PRINT " I.   .I"
140     PRINT " I ... I"
150     PRINT " I   I"
160     PRINT "    III"
170     PRINT
180     PRINT "HELLLO!!"
190   ELSE
200     PRINT "Ha nem, hat nem..."
210   END IF
220 LOOP

Indítsuk el ezt-a programot! Ha látni akarjuk Benőt, válaszoljuk i-vel, és Benő rögtön fel is tűnik. A válaszra itt elég volt egyetlen betű is, hiszen csak azt kellett eldöntenünk, hogy igen vagy nem. Ez olyan gyakori eset, hogy a BASIC nyelvben külön szó van rá, a GET.
A get magyarul azt jelenti: megkapni. Ez az utasítás - ugyanúgy, mint az INPUT - a billentyűzetről kapja meg a választ, csak az a különbség, hogy mindössze egyetlen betűt olvas be, Írjuk hát át az 50-es sort:

Most indítsuk el a programot! Ej, hát megkergült ez? Egyre csak írja ki a magáét, mintha már válaszoltunk is volna, pedig hozzá sem nyúltunk a billentyűkhöz. Ha meg lenyomjuk az i billentyűt, akkor újra meg újra kirajzolja Benőt, meg se várja, hogy megnyomjuk az ENTER-t. Éppen ez a 1egfontosabb különbség a GET és az INPUT között. Hiszen ha a GET csak abban különbözne, hogy egyetlen karaktert olvas be, akkor teljesen fölösleges volna a használata, mivel az INPUT-tal is lehet egyetlen betűt beolvasni. A GET éppen azért jó , mert az ENTER billentyűt nem kell lenyomnunk. Amikor a GET-tel kérdezünk, akkor a gép nem vár az ENTER-re, hanem megnézi, hogy valamelyik billenty0 le van-e nyomva. Ha igen, akkor billentyű betűjét beleteszi a GET után megadott változóba, ha nem, akkor nem tesz bele semmit. Pontosabban: SEMMIT tesz bele, azaz üres szöveget.
Emlékszünk még, hogy mi az az üres szöveg? Olyan valami, amiben egyetlen karakter, még szóköz sincs! Úgy lehet leírni, hogy az idézőjelek közé nem teszünk semmit: "". Ha tehát egyetlen billentyű sincs lenyomva, akkor a GET ilyen üres szöveget tesz a változóba, és a program megy tovább, nem áll meg! A mi programunk is azért bolondult meg, mert a GET állandóan ilyen üres szövegeket olvasott be, ami persze nem i volt, tehát a gép úgy vette, mintha nem akarnánk látni Benőt.
Segíteni kéne ezen valahogy! Próbáljuk mer megparancsolni a gépnek, hogy mindaddig, AMÍG a VALASZ$ üres szöveg, addig nézze meg újra és újra, nem nyomtunk-e le egy billentyűt, és csak ha lenyomtunk, akkor menjen tovább.

CSINALD
azt, hagy beírod a VALASZ$-ba
a lenyomott billentyűt"
CIKLUSBAN, AMÍG a VALASZ$=""

A WHILE angol szó, úgy kell ejteni: vájl , a jelentése pedig: AMÍG. A WHILE ciklusok nagyon hasonlóak az UNTIL ciklusokhoz, csak ezek nem addig mennek körbe-körbe, MÍGNEM a feltétel teljesül és utána véget érnek, hanem AMÍG teljesül addig fut a ciklus. Ha tehát egy UNTIL ciklusban az a feltétel, hogy EGYIK=MASIK, akkor az ennek megfelelő WHILE ciklusban éppen hogy azt kell feltételnek beírni: EGYIK<>MASIK. A kétfajta ciklussal ugyanazt tudjuk: elérni, így elegendő lenne az egyiket használni. Mégis használjuk mindkettőt, mert így sokkal jobban érthető programokat tudunk írni.
A WHILE ciklus is lehet végfeltételes vagy előfeltételes, aszerint, hogy a ciklus elejére, a DO után, vagy a ciklus végére, a LOOP-hoz írjuk a WHILE-t és a feltételt. Mi most egy végfeltételes WHILE ciklust használunk, mert nekünk először be kell olvasnunk a VALASZ$-t, és csak azután tudjuk megvizsgálni, vajon még mindig üres-e? Írjuk hát be a két új sort:

Most már bezártuk a GET utasítást ebbe a ciklusba, tehát csak akkor jön ki, ha valóban lenyomtunk valamilyen billentyűt, azaz a VALASZ$ nem üres szöveg. Próbáljuk ki a programot, ás látni fogjuk, hogy most már nem fut állandóan a képernyőn a hibás válasz, hanem a gép türelmesen vár, amíg le nem nyomunk egy billentyűt. Akkor viszont rögtön válaszol, nem vár az ENTER-re.
Csak az a furcsa, hogy bármelyik billentyű lenyomására a gép rögtön azt hiszi, neki - mondtunk valamit. Ha igennel akarunk válaszolni, leütjük az i-t, ha nemmel , akkor az n-et. Ha azonban akár csak véletlenül megérintünk egy másik billentyűt, a gép azt hiszi, mondani akartunk valamit, beolvassa és úgy értelmezi, hogy megint nemet mondtunk.
Azért hiszi ezt, mert az IF utasításban csak: azt nézi meg, vajon i betű jött-e, ha pedig nem, akkor nem vizsgálódik tovább, az összes többi betűt úgy veszi, mintha n volna. Azt kéne megmondanunk neki, hogy addig maradjon a beolvasó ciklusban, AMÍG a VALASZ$ üres, VAGY amíg a leütött billentyű nem az i ÉS nem is az n.

Az OR szócskát már ismerjük, ezzel akkor kötünk össze két feltételt, ha mindegy, hogy melyik teljesül, nekünk mindkettő jó. Az AND szócska azt jelenti: ÉS. Ezzel a szóval akkor kapcsolunk össze feltételeket, amikor csak akkor akarjuk elfogadni őket, ha mindegyik egyszerre teljesül. Azaz, ha az egyik ÉS a másik feltétel is teljesül. Írjuk át az 55-ös sort:

Most már nyugodtan próbálgathatjuk a billentyűket, a program csak az i-re és az n-re fog válaszolni. Más billentyűt lenyomva a gép ki se jön az olvasó ciklusból. Ilyenkor a VALASZ$ nem i és nem n, tehát igaz az, hogy: VALASZ<>"i" AND VALASZ$<>"n".
Az a feltétel persze most nem igaz, hogy: VALASZ$="", hiszen valamit lenyomtunk. De ez nem baj, mert a teljes ciklusfeltétel eleje és vége között az OR szócska van. Így elegendő a feltétel második felének teljesülése ahhoz, hogy az egész feltétel igazzá váljon, tehát a gép bent maradjon a ciklusban.
Hú de bonyolult! Nem is igen ajánlatos ilyen kacifántos feltételeket használni. Ezeket alig lehet elolvasni, megérteni, sőt, még programírás közben is nagyon könnyű eltéveszteni, és valami óriási galibát csinálni. Akkor aztán legény legyen a talpán, aki megtalálja a hiba okát, és ki is tudja javítani!
Ezt a programot most már jó alaposan kiveséztük. Vegyük fel egy kazettára, hogy majd később másoknak is meg tudjuk mutatni. Töröljük ki a gépből, és kezdjünk egy új programot.

10 CLEAR SCREEN
20 LET OSZLOP=1
30 LET UR$="                 "
40 DO
50   GET BILL$
60   IF BILL$="N" OR BILL$="n" AND OSZLOP>1 THEN LET OSZLOP= OSZLOP-1
70   IF BILL$="M" OR BILL$="m" AND OSZLOP<38 THEN LET OSZLOP=OSZLOP+1
80   PRINT UR$(1:OSZLOP-1);"O"
90 LOOP WHILE BILL$<>"q" AND BILL$<>"Q"

Indítsuk el a programot! Először semmi különöset nem látunk, az O-k futnak felfelé. De ha lenyomjuk az m billentyűt, rögtön más lesz a véleményünk. Az O-k elkezdenek jobbra vándorolni. Ha most az n-et nyomjuk le, akkor meg balra indulnak el. Sőt, az sem okoz gondot, ha ezeket a billentyűket a SHIFT-tel együtt nyomjuk le mert a program az n és az m betűket nagybetűként is elfogadja. Hogyan is csinálja ezt?
A gép mindig az OSZLOP változóban tárolja, hogy hányadik oszlopba kell kiírni az O-t. Az UR$ nevű változóba 37 darab szóközt tettünk (lehet többet is, de felesleges). Ha a tizedik oszlopba akarjuk kiírni az O-t, akkor először eléje kell írni kilenc szóközt, és aztán jöhet az O. Így dolgozik a 80-a sorban lévő PRINT. Ahányadik oszlopba majd az O kerül, annál eggyel kevesebb szóközt ír ki, és aztán az O-t. Az oszlop számát a 60-as és a 70-es sorban lehet megváltoztatni. Ha a leütött billentyű, N VAGY n, ÉS nem vagyunk a képernyő bal szélén, akkor az oszlopszám eggyel csökken. Ha a képernyő peremén vagyunk, akkor persze nem, hiszen így lecsúsznánk a képről, és a gép hibát jelezne. Ugyanígy az M VAGY az m hatására az oszlopszál eggyel nő.
Próbáljuk ki, hogy milyen szép kígyót tudunk rajzolni akkor, ha lassan hol jobbra, hol balra irányítjuk az O-kat. Jó, mi?
Nézzük meg a könyvben a program listáját, próbáljuk meg kitalálni, hogy melyik billentyűvel lehet a programot leállítani. Akinek sikerül, már igazi profinak gondolhatja magát (legalábbis a kígyóprogram-bűvölésben).
Egy valamit viszont most is megfigyelhettünk: ha a GET utasítással olvasunk be betűket, akkor a képernyőn ezek nem jelennek meg, tehát nem rontják el a képet. A BASIC játékprogramok általában éppen ezt az utasítást használják. Az INPUT utasítás két okból sem jó erre. Egyrészt, mert az INPUT-nál a program megáll, és nem megy tovább, amíg az ENTER billentyűt le nem nyomjuk, másrészt, mert az INPUT a képernyőre írja azt, amit begépelünk, tehát megváltoztatja a képet.
Ezek után jöhet egy újabb program. A következő feladat: el kell döntetnünk a géppel, vajon két szám szorzata kisebb-e nullánál vagy nagyobb. Ha megkérdezné tőlünk valaki, mikor lesz két szám szorzata negatív, kapásból azt válaszolnánk: akkor, ha az egyik szám kisebb, mint nulla, a másik pedig nagyobb.
"Ha az egyik szám kisebb, mint nulla."
Ez azt jelenti, hogy vagy az első kisebb' mint nulla, vagy a második, azaz:
ELSO<0 OR MASOD<0
Az, hogy a másik szám nagyobb, természetesen ugyanúgy lefordítható: vagy az első szám nagyobb nullánál, vagy a második, tehát
ELSO>0 OR MASOD>0
A teljes feltétel így hangzott:

HA az egyik szám kisebb, mint nulla
ÉS a másik szám nagyobb,
AKKOR a két szám szorzata negatív.

Ezt kicsit részletesebben felírva:
HA az első szám negatív vagy a második szám negatív
ÉS az első szám pozitív vagy a második szám pozitív
AKKOR a szorzat negatív.

Ez egy kicsit bonyolultnak tűnik, és nemcsak tűnik, hanem az is - de azért belátható, hogy hibátlan. Írjuk át BASIC-re:

10 CLEAR SCREEN
20 DO
30   INPUT PROMPT "ELSO SZAM:":ELSO
40   INPUT PROMPT "MASODIK SZAM:":MASOD
50   IF ELSO<0 OR MASOD<0 AND ELSO>0 OR MASOD>0 THEN
60     PRINT "A SZORZAT NEGATIV"
70   ELSE
80     PRINT "A SZORZAT POZITIV"
90   END IF
100   PRINT
110 LOOP

Indítsuk el a programot, és próbáljuk ki különböző számokkal. A program mindig azt írja ki: a szorzat negatív! Még két pozitív számra is! Az 1*1 a gép szerint kisebb nullánál! Na de kérem, nincs itt tévedés? Nem, a gép nem téved, csak a program hibás. No persze - várható is volt, hogy a sok AND meg OR között előbb-utóbb csak elrontunk valamit. Vajon hol a hiba? Ne keressük, a hiba nem látható, legalábbis első látásra nem. A gond ugyanaz, mint amikor azt kérdeztük, hogy mennyi 1+2*3?
Az eredmény ugyanis attól függ, hogy melyik műveletet hajtjuk végre először! Most pontosan ugyanez a hiba zavarja meg az új programunkat is:

Ebben az IF utasításban a feltétel négy összehasonlításból áll, de két OR és egy AND szócska köti össze őket egymással. Csakhogy egyáltalán nem mindegy, hogy melyiket melyikkel kötjük először! A gép itt is úgy tesz, mintha számolna. Ha nem mondjuk meg, hogy melyik műveletet csinálja először, akkor azzal kezdi, amelyiket a leginkább szeret. Ez a gép pedig nagyon szeret AND-eket csinálni. A mi bajunk éppen az, hogy azt szeretnénk: először a gép a két OR-t csinálja meg, külön-külön, és aztán ezeknek az eredményével végezze el az AND műveleteket. Ezt azonban meg kell mondani a gépnek, mégpedig pontosan ugyanúgy, ahogy a számoknál tettük: zárójelekkel.

Írjuk át az 50-es sort a fentire, és próbáljuk ki így is a programot! Most már minden tökéletes. Ma tehát megismerkedtünk:

A sok-sok kemény feladat után ma végre jöjjön egy kis pihenés. Természetesen nem a gépnek, hiszen ötletekben, feladatokban sosincs hiány, csak jó programozó kell hozzá. Most mi mégis valami mást nézünk meg: egy kicsit bonyolultabb játékprogramot, a korábbi szókitalálós program unokáját. A program természetesen futtatható, a játékszabályok rendkívül egyszerűek:
A játékot két játékos játsza felváltva, az egyik a rejtő, a másik a kitaláló. A program elején a rejtő játékos megadja a kitalálandó szót, ezalatt a másiknak illik elfordulni. Ne tessék leselkedni!
Ezután a kitalálóé a fűszerep, neki kell kitalálni az elrejtett szót. Ehhez segítségképpen betűkre is tippelhet. A gép rendesen kiírja, hogy eddig hányszor tippelt. A betűtippelés alatt azt kell érteni, hogy ha az elrejtett szóban előfordul a tippelt betű, akkor a gép kiírja valamennyi előfordulását.
Ha már elég sok látszik a szóból, megpróbálhatunk rákérdezni. A gép a rákérdezéseket is számolja. Ha sikerül kitalálnunk a szót, akkor a két játékos helyet cserél, és a játék újra kezdődik.
Rendezhetünk ebből akár házibajnokságot is, ilyenkor gondosan vezetni kell, hogy ki-ki hány betűtippel és hány rákérdezéssel találta ki az egyes szavakat. Ügyeljünk arra, hogy csak betűtippekkel nem lehet kitalálni a szút, ahhoz hogy a gép elfogadja a megoldást, rá kell kérdezni!
Íme a program:

1 PROGRAM "Szo.bas"
10 REM ************
20 REM SZOKITALALAS
30 REM ************
40 DO
50   ! SZO BEKERESE
60   ! ************
70   DO
80     CLEAR SCREEN
90     PRINT
100     PRINT " ADD MEG A KITALALANDO SZOT"
110     PRINT " MAX. 10 BETU"
120     INPUT AT 6,9,PROMPT "A SZO:":SZO$
130   LOOP WHILE(LEN(SZO$)>10) OR SZO$=""
140   ! SZO KITALALASA
150   ! **************
160   CLEAR SCREEN
170   PRINT
180   PRINT " TALALD KI A SZOT"
190   PRINT
200   PRINT " A SZO:"
210   LET RAK=0
220   LET BET=0
230   DO
240     PRINT AT 23,8:"1: BETUTIP 0: RAKERDEZES";
250     DO
260       GET BETU$
270     LOOP WHILE BETU$="" OR BETU$<>"1" AND BETU$<>"0"
280     PRINT AT 23,8:" ";
290     IF BETU$="1" THEN
300       ! BETUTIP KEZELES
310       ! ***************
320       LET BET=BET+1
330       PRINT AT 13,5:BET;
340       PRINT AT 13,8:"-IK BETUTIPP:";
350       DO
360         GET BETU$
370       LOOP WHILE BETU$=""
380       PRINT BETU$;
390       FOR I=1 TO LEN(SZO$)
400         IF BETU$=SZO$(I) THEN PRINT AT 4,16+I:BETU$;
410       NEXT
420     ELSE
430       ! RAKERDEZES KEZELESE
440       ! *******************
450       LET RAK=RAK+1
460       PRINT AT 15,3:RAK;
470       DO
480         INPUT AT 15,6,PROMPT "-IK RAKERDEZES: ":TIPP$
490       LOOP WHILE TIPP$=""
500       IF TIPP$=SZO$ THEN EXIT DO
510     END IF
520   LOOP
530   ! KITALALTA
540   ! *********
550   PRINT
560   PRINT " KITALALTAD, GRATULALOK"
570   PRINT
580   PRINT " AKARSZ UJRA JATSZANI?"
590   PRINT " (i/n)"
600   DO
610     GET BETU$
620   LOOP WHILE BETU$="" OR BETU$<>"i" AND BETU$<>"I" AND BETU$<>"n" AND BETU$<>"N"
630   IF BETU$="n" OR BETU$="N" THEN EXIT DO
640 LOOP

650 ! VEGE
660 ! ****
670 PRINT " KOSZONOM A JATEKOT"

Ejnye, hát mi az a REM az eleién? Hiszen arról volt szó, hogy ma semmi újdonság, Csupa régi, megszokott dolgot használunk. Ezt a kis csalást el lehet nézni, már csak azért is, mert a REM utasítás nem csinál semmit. A mögötte lévő szöveget a gép egészen a programsor végéig úgy tekinti, mintha nem is volna ott. Ez arra jó, hogy saját magunknak, vagy a program olvasója számára megjegyzéseket írhassunk be program szövegébe. Mivel ezt nagyon gyakran szokás alkalmazni, az ENTERPRISE ezért még azt is lehetővé teszi, hogy rövidítsük a REM kulcsszót, és helyette egyetlen felkiáltójelet használjunk, ahogy azt a program későbbi részében látni is lehet.
A felkiáltójel még arra i s alkalmas, hogy egy már megkezdett programsor végére írjunk megjegyzést, ha azt a sor többi részétől ezzel a felkiáltójellel elválasztjuk.

...hanem dallal, tánccal, rajzzal is. Elsőre mindent együtt megvalósítani kicsit túlzás lenne, ezért elégedjünk meg a rajzolással. Először rajzoljunk egyetlen pontot, hogy a feladat ne legyen túl bonyolult.
A képernyőre rajzolni azonban nem is olyan egyszerű. Azt már tudjuk, hogy a PRINT utasítás mindig karaktereket ír ki, egy karakter pedig sok kis pontocskából áll össze. Rajzolás előtt tehát szólni kell a gépnek, hogy legyen szíves, és csináljon nekünk egy kis helyet a képen belül, ahol rajzolni tudunk. Erre való a GRAPHICS parancs. A parancsot legegyszerűbben az F6 funkcióbillentyűvel adhatjuk ki. Nyomjuk hát le!
A képernyőről egyszerre minden eltűnik, a kurzor pedig majdnem az utolsó sorba ugrik le. A GRAPHICS parancs ugyanis először törli az egész képet, majd felosztja két részre. A felső húsz sorba majd rajzolni tudunk, az alsó négybe pedig továbbra is írhatunk. Olyan ez, mintha egyszerre két papírlap lenne előttünk, az egyikre írnánk, a másikra meg rajzolnánk.
Rajzoljunk hát akkor egy pontot! Erre a PLOT utasítás való. A PLOT utasításban majdnem ugyanúgy lehet megadni, hogy hova akarunk rajzolni, mint a PRlNT AT-ban, csak a sorokat és az oszlopokat kell egészen másképp számolni. Korábban az 1. sor volt a legfelső, most ez a grafikus lap legalján van. Arra is oda kell majd figyelnünk, hogy a PLOT utasításban előbb az oszlopot kell megadnunk, és csak azután a sort. A leglényegesebb különbség azonban az, hogy itt nem karaktereket rajzolunk, hanem pontokat, ezekből pedig sokkal több fér el a képernyőn. 1280 oszlopunk és 720 sorunk van, a sorszámozásuk azonban nem egytől indul, hanem nullától, így az oszlopként 0 és 1279 közötti, sorszámként pedig 0-tól 719-ig terjedő számot adhatunk meg. Rajta hát, írjuk be:

Ez most nem programsor, hanem azonnal végrehajtandó parancs, hiszen nem adtunk neki sorszámot. A gép a parancsot rögtön végre is hajtja. Ha jó alaposan megvizsgáljuk a képet, észrevehetünk egy kis pontocskát á grafikus lap bal alsó részén. (Nem egészen a bal alsó sarokban - hiszen annak a 0 sor és 0 oszlopszám felel meg -, hanem attól jobbra felfelé.)
Egy pont azonban önmagában csak egy pont, olyan kicsi, hogy észrevenni is alig lehet. Ahhoz, hagy jól látható legyen, többet kell egymás mellé rajzolnunk, mondjuk szépen sorban, hogy egy vonal legyen belőlük. Írjuk be hát a következő programot! Ne lepődjünk meg, hogy gépelés közben az első sorok eltűnnek, hiszen a szöveges lapunk csak 4 négy sorból áll, és ez bizony kevés a teljes programhoz. Az eltűnt sorokat azonban bármikor megnézhetjük, azt ugyanis már tudjuk, hogy a kurzorral felfelé lépkedve, a szöveges rész legfelső sorát elérve - ami korábban a képernyő tetején volt - a felül újra megjelennek.

Futtassuk le a programot! A gép elkezdi kirajzolni a 100. oszlopba a pontokat, alulról, a nulladik sortól kezdve fel, egészen az 500. sorig, és egy kék vonal jelenik meg.
Listáztassuk ki a programot! A látvány bizony nem túl bíztató, az első sor már is látható. Persze most még megtehetnénk, hogy felfelé lépegetve azt is visszahozzuk a képbe, de mi legyen a négy sornál hosszabb programokkal? Az lenne jó, ha az egész képernyőt vissza tudnánk kapcsolni szöveges üzemmódba. Éppen erre való a korábban is már használt TEXT parancs. Ez a parancs először - hasonlóan a GRAPHICS-hoz - törli az egészképet, majd a teljes képernyőt szöveges (text) üzemmódra kapcsolja. Idáig mi ebből csak azt a részét tudtuk, hogy törli a képernyőit, de ha lehetett, arra sem ezt használtuk, hanem a CLEAR SCREEN-t, ami tényleg nem csinál mást, mint a, teljes képernyőt letakarítja.
Adjuk ki hát a TEXT parancsot az F5 billentyűvel, és listáztassuk ki programunkat! Most már minden sor jól látható. Ha most le akarjuk futtatni a programot, előtte át kell kapcsolnunk a képet grafikus üzemmódba, különben a gép hibát jelez. A legegyszerűbb kép, amit rajzolni tudunk, a pont. Erre való a PLOT utasítás. A pontokból összerakható legegyszerűbb kép a vonal . Ennek vajon van saját utasítása?
Van is, meg nincs is. Vonalat rajzolni sokkal egyszerűbben is lehet, mint egy FOR ciklussal pontonként, de ehhez nem kell új utasítás. A PLOT utasítás erre is alkalmas. Az utasításban azonban nemcsak azt kell megmondanunk, hol kezdődjön a vonal, hanem azt is, hol legyen a vége. Ha pontosvesszővel elválasztva két pont oszlopának és sorának a számát adjuk meg, a gép rögtön össze is löti őketeegy egyenes szakasszal. Próbáljuk ki:

Ugye, ez sokkal gyorsabb? Ha akarjuk, egymás után több pontot is megadhatunk, és a gép úgy fog rajtuk végighaladni, hogy közben föl sem emeli a ceruzáját:

Ezzel szépen bekereteztük a grafikus lapunkat, most már jól látható a széle. Mit kell tenni akkor, ha fel akarjuk emelni a ceruzát? Ilyenkor pontosvessző helyett egyszerű vesszőt teszünk az egyes pontok adatai közé:

Ez az utasítás összeköti a 100,100 pontot az 1000,200 ponttal, majd felemeli a ceruzát, elviszi a 200,100 pontba, és egy vonalat húz onnan az 1100,200 pontba. Tehát ferde vonalakat is lehet rajzolni.
Azt azonban még nem tudjuk, mi történik a PLOT utasítások végén: a gép felemeli-e a ceruzát, vagy pedig vonalat húz vele a következő PLOT utasítás elején megadott ponthoz? Ezt - hasonlóan a PRINT-hez - az dönti el, mit teszünk a PLOT utasítás végére. Ha pontosvesszőt, akkor a ceruza a papíron, illetve a képernyőn marad, és a gép vonalat húz vele oda, ahova a legközelebb visszük egy PLOT utasítással. Ha azonban vesszőt, vagy semmit sem teszünk a PLOT végére, akkor a ceruza fölemelkedik, ás csak a következő PLOT utasításban tudjuk azt újra letenni. Szúrjunk be programunkba egy új sort:

Töröljük le a képernyőt (a sorszám nélkül kiadott, azaz azonnal végrehajtandó CLEAR SCREEN paranccsal) és futtassuk le a programot! Most ugye két vonalat hoz egymás mellé. Javítsuk át a 20-as sort, tegyünk a végére egy pontosvesszőt:

Most is futtassuk le a programot! (Persze előtte le kell törölni a képet.) Vastag kék csík jelenik meg a képernyőn. A gép ugyanis az azonos sorban lévő - az egymás utáni két PLOT utasításban megadott - pontokat egy-egy vonallal kötötte össze, és a sok egymás fölötti vonal egyetlen csíkká olvad össze.
Van azonban még egy apróság, amit tudnunk kell. Azt már láttuk, hogy a pontosvesszőre végződő PLOT lenyomva tartja a ceruzát, tehát a ceruza a papírt helyettesítő képernyőn marad. De van-e különbség a vesszőre végződő és a semmivel le nem zárt PLOT utasítás között? Ahhoz, hogy ezt lássuk, töröljük le a képernyőt, és adjuk ki egymás után a következű két parancsot:

Láthatjuk, hogy csak a második parancs hatására rajzolt pontot a gép. Az első parancsra tehát nem csinált semmit? Dehogynem, odavitte a ceruzát a 100,100 pontra, csak nem tette le a hegyét, így nem jelent meg semmi a képernyőn! Ha tehát vessző van a PLOT sor végén, akkor a ceruza nemcsak hogy, nem marad a papíron, de még oda sem rajzolunk, ahova a PLOT utasítás szól! (Ez természetesen nem befolyásolja azt, hogy ha idáig a papíron volt a ceruza, akkor eddig a pontig egy vonalat hozunk, csak éppen ebbe az egy pontba nem kerül semmi.) Ha viszont nincs semmi a PLOT végén, akkor egy pillanatra leteszi a ceruzát a megadott pontra, azaz otthagyja a nyomát, de utána újra felemeli. Most még talán nem jelent sokat a kettő különbsége, hiszen egy pont önmagában úgyis alig látható, de később még ez fontos lesz, ezért ne felejtsük el!
Készítsünk vonalrajzoló programot!

10 GRAPHICS
20 DO
30   INPUT PROMPT "honnan:":HOSZLOP,HSOR
40   INPUT PROMPT "hova:":VOSZLOP,VSOR
50   PLOT HOSZLOP,HSOR;VOSZLOP,VSOR
60   PRINT "rajzoljunk meg? (i/n)"
70   DO
80     GET BILL$
90   LOOP WHILE BILL$="" OR BILL$<>"i" AND BILL$<>"n"
100 LOOP WHILE BILL$="i"
110 TEXT

Ezzel a programmal vonalakat tudunk rajzoltatni, ha vesszőkkel elválasztva megadjuk neki a kezdeti és a végpontok oszlopának, illetve sorának számát. A program automatikusan átkapcsol kettéosztott, félig grafikus képernyőre, és a végén vissza, a teljes szövegesre.
Futtassuk le a programot, próbálgassuk egy kicsit a használatát! Nagyon kényelmes, csak egy dolgot `hiányolunk. Megszoktuk már, hogy minden rendes program kiírja a kép tetejére, hogy mit is csinál. Most ez nincs sehol, pedig annak is jó lenne tudni hogy mire jó, aki nem nézte meg a programot, csak használja. A képernyő tetejére írni azonban most nem olyan egyszerű, hiszen az a grafikus lapon van. A megszokott PRINT utasításunk viszont a szöveges lapra ír. Az új utasítás nem más, mint a PRINT egy újabb változata. Egészítsük ki tehát a programot a következő sorral:

Ez szinte ugyanazt csinálja, mint a PRINT AT utasítás. Az AT után megadott számok itt is a kiírandó szöveg helyét jelölik, de a £101 jelzés miatt most nem a szöveges, hanem a grafikai lapra kerül a szöveg. A felirat színe természetesen kék, hiszen a grafikus lapon a gép kék tintát használ, de ez most nem olyan nagy baj, hogy fennakadjunk rajta. Futtassuk le a programot, és nézzük meg, hogyan működik! Ha már elég sokat rajzolgattunk, kezd lassan megtelni a képernyő, és már jó lenne letakarítani. De ez nem megy másként, csak ha megállítjuk a programot - ezzel egyből törlődik a kép -, majd újra elindítjuk. Ennek egyszerűbbé tételére egészítsük ki, és írjuk át egy kicsit a programot:

...
60   PRINT "rajzoljunk meg? (i/n)"
65   PRINT "t=torles"
70   DO
80     GET BILL$
90   LOOP WHILE BILL$="" OR BILL$<>"i" AND BILL$<>"n" AND BILL$<>"t"
95   IF BILL$="t" THEN
96     CLEAR SCREEN
97     PRINT £101,AT 1,15:"vonal rajzolo"
98   END IF
100 LOOP UNTIL BILL$="n"
110 TEXT

Ne felejtsük el a 100-as és a 90-es sort átírni! Most is futtassuk le a programot! Most már elég ugye a t betűt lenyomni, és a gép törli a korábbi képet. Mivel azon rajta volt a felső sorban lévő felirat, ezért az is törlődött, de törlődött a szöveges lap is, hiszen az is része a képernyőnek. Hogyan lehetne csak az egyik lapot törölni a kettő közül? Erre új utasításaink vannak. A törlést mindig a CLEAR angol szóval kell jelezni, hiszen ez azt jelenti: TöRöLD! Az utána álló szó azonban más és más lehet. A SCREEN szó a teljes képernyőt jelenti, tehát a CLEAR SCREEN az egész képet törli. A grafikus lap neve GRAPHICS, tehát CLEAR GRAPHICS a grafikus lapot törli csak, a szöveges nem változik. Hasonlóképpen, a szöveges lap neve TEXT, ezt tehát a CLEAR TEXT utasítással lehet törölni. Próbáljuk ki, hogyan változik a program működése, ha a 96-os sorban lévő CLEAR SCREEN utasítást CLEAR GRAPHICS-ra, majd CLEAR TEXT-re cseréljük ki. Látható, hogy az elő esetben csak a rajzok törlődnek, míg a másodikban csak az alul, a szöveges lapon lévő feliratok.
Most már tudunk mindenféle pontokat és vonalakat rajzolni, próbálkozhatnánk lassan körökkel is! A körök rajzolása azonban egy kicsit másképp megy. Ha pontosak akarunk lenni, azt kell mondanunk, az ENTERPRISE nem is köröket rajzol, hanem ellipsziseket. Aki nem tudná, az ellipszis egy olyan kör, amelyiknek más a magassága és más a szélessége. Az ellipszis rajzolásához meg kell adnunk a középpontját, valamint azt, hogy mekkora legyen a sugara oldalirányban és mekkora függőlegesen. A középpontja mindig ott lesz, ahol a ceruza éppen áll, a sugarait pedig a PLOT utasításban tudjuk megadni, ha az ELLIPSE kulcsszót használjuk. Nézzünk néhány példát! Töröljük le a képernyőt, és adjuk ki a kővetkező két PLOT utasítást:

Az első PLOT - emlékezzünk, jeleztük már, hogy ez fontos! - csak a ceruzát viszi az 500,500 ponthoz, de nem rajzol semmit, még egy pontot sem! A PLOT ELLIPSE utasítás tehát az 500,500 pont köré rajzolja ki az ellipszist, méghozzá úgy, hogy oldalirányban 150, felfelé és lefelé pedig 200 lesz a sugara. A képernyőn furcsán lapított karika jelenik meg, ez az ellipszis. Ha mégis kört akarunk rajzoltatni, semmi akadálya, mindössze egy apróságot kell észrevennünk. Mégpedig azt, hogy a kör nem más, mint egy olyan ellipszis, amelynek ugyanakkora a sugara minden irányban! Tehát csak annyi a teendőnk, hogy ugyanazt a számot adjuk meg mindkét sugárnak.
Ha még nem mozdítottuk el a ceruzát, akkor az ugyanott áll, ahol a PLOT ELLIPSE előtt volt, hiszen ez az utasítás nem mozdítja, csak egy ellipszist húz köréje. Ha tehát most egy újabb PLOT' ELLIPSE utasítást adunk ki, akkor az ugyanazon pont köré fog rajzolni. Természetesen ha más számokat adunk meg, akkor egy másik ellipszist rajzol. Próbáljuk ki:

Ami most feltűnt, az már kör - már azoknál, akiknek jól van beállítva a tévéjük. Kör lett, hiszen mindkét irányban azonos, 200 a sugara. A középpontja pedig, mivel nem mozdítottuk el, az 500,500 pont.
Most már láthatjuk, mire jó az olyan PLOT, amelynek a végén vessző áll. Igaz, hogy nem rajzol ki pontot, de a ceruzát akkor is oda viszi, ahova megadjuk. No, és mi lenne, ha a PLOT 500,500 utasítás végén nem vessző állna? Nos, akkor ez a PLOT egy pontot rajzolna ide, azaz az ellipszis közepére.
Vajon mi történik, ha a PLOT ELLIPSE végére teszünk a vessző helyett pontosvesszőt, vagy semmit? Ilyenkor maga a PLOT ELLIPSE utasítás ír egy pontot az ellipszis közepébe. Próbáljuk ezt ki! Töröljük le a grafikus lapot, és adjuk ki a következő parancsot:

A képernyőn két karika jelenik meg, de csak az egyiknek van a közepén egy pont. Igen ám, de hogy is van ez, hogy mi csak úgy beleírtunk mindenféle ELLIPSE-eket egy PLOT utasítás közepébe? Nos, ebben nincs semmi titok. Ahogy a PLOT kulcsszó után egyszerre több pontot is megadhatunk, és a ceruza szépen sorba megy rajtuk, ugyanúgy a pontok rajzolása közben rajzolhatunk egy-egy ellipszist is.
Az utasítás elején az 500,500 pontba vittük a ceruzát, de nem tettük le a papírra. Ezután húztunk köré egy kört 200-as sugárral, de nem rajzoltunk a közepébe pontot, hiszen az ELLIPSE utáni két szám (a vízszintes és a függőleges sugár) után vesszőt tettünk. Most elvittük a ceruzát a 400,400 pontba - az 500,500-ból, mivel ügye még ott volt -, de még ide sem rajzoltunk pontot. A 400,400 középpontú kör közepére úgy került a pont, hogy amikor végül kirajzoltattuk a második kört (ELLIPSE 100,100), akkor nem tettünk mögéje vesszőt! Ezért aztán a gép nemcsak az ellipszist rajzolta meg, hanem a középpontját is megjelölte.
Nem is olyan egyszerű ezt a sok-sok mindent megjegyezni, de nem baj, majd idővel szépen belejövünk, és utólag már roppant kényelmesnek fog tűnni a PLOT utasítás használata, és mindaz, ami hozzá tartozik. Mára azonban ennyi már elég, foglaljuk össze, mit tanultunk!

Készítsünk egy könnyen kezelhető programot, amellyel egymást követő vonalakat tudunk rajzolni! Íme egy lehetséges megoldás:

1 PROGRAM "Rajzol.bas"
10 GRAPHICS
20 DO
30     PRINT "PONT, CERUZA FEL, TORLES, VEGE (p,f,t,v)"
40   DO
50     GET BILL$
60   LOOP WHILE BILL$<>"p" AND BILL$<>"f" AND BILL$<>"t" AND BILL$<>"v"
70   IF BILL$="t" THEN

80     CLEAR GRAPHICS
90   ELSE IF BILL$="f" THEN
100     PLOT
110     PRINT "CERUZA FELEMELVE"
120   ELSE IF BILL$="p" THEN
130     INPUT PROMPT "Oszlop,Sor:":OSZLOP,SOR
140     PLOT OSZLOP,SOR;
150   ELSE
160     EXIT DO
170   END IF
180 LOOP
190 TEXT

Hát ez bizony elég hosszadalmas, pedig ha elindítjuk a programot, láthatjuk, nem is csinál olyan sokféle dolgot. Megkérdezi, hogy mit akarunk éppen csinálni, és a leütött billentyűnek megfelelően vagy beolvassa, hogy hova kell húzni a ceruzát, vagy felemeli a hegyét - de persze csak addig, amíg arrébb visszük -, vagy éppenséggel törli a grafikus lapot.
Számunkra nem is ez érdekes, hanem az egymás után használt ELSE-IF utasítások sora. Ezekkel az utasításokkal irányítjuk a gépet a leütött billentyűnek (BILL$) megfelelő helyre, azaz vagy a törlő utasításhoz, vagy a ceruzát mozgatóhoz, vagy a ceruzát felemelőhoz és így tovább. A különböző programokban igen gyakori eset ez, amikor egy feltételtől függően vagy ezt akarjuk csinálni, vagy azt, vagy amazt. A SELECT-CASE utasítások arra valók, hagy az ilyen döntéseket egyszerűen le lehessen írni. A SELECT angol szó, a kiejtése: szelekt, és azt jelenti: kiválasztani. Ebben az utasításban fogjuk megadni, mi alapján kell kiválasztani a többféle lehetőség közül a nekünk megfelelőt. A CASE (ejtsd: kéisz) jelentésé: eset. Itt fogjuk megmondani, hogy milyen esetekben kell éppen ezt a lehetőséget, ezt az ágat választani. Szúrjuk be a 65-ös sort, és írjuk át a 70-es, a 90-es, a 120-as, a 150-es és a 170-es sort a következők szerint:

1 PROGRAM "Rajzol2.bas"
10 GRAPHICS
20 DO
30   PRINT "PONT, CERUZA FEL, TORLES, VEGE (p,f,t,v)"
40   DO
50     GET BILL$
60   LOOP WHILE BILL$<>"p" AND BILL$<>"f" AND BILL$<>"t" AND BILL$<>"v"
65   SELECT CASE BILL$
70   CASE "t"
80     CLEAR GRAPHICS
90   CASE "f"
100     PLOT
110     PRINT "CERUZA FELEMELVE"
120   CASE "p"
130     INPUT PROMPT "Oszlop,Sor:":OSZLOP,SOR
140     PLOT OSZLOP,SOR;
150   CASE ELSE
160     EXIT DO
170   END SELECT

180 LOOP
190 TEXT

Ha most lefuttatjuk a programot, láthatjuk, hogy ugyanúgy működik, mint az előző. Mik is hát ezek az új utasítások?
A SELECT CASE utasításban azt mondjuk meg, mi lesz az a változó vagy kifejezés, amelynek az értékétől függően ezt vagy azt kell csinálni. Jelen esetben a 65-ös sorban lévő SELECT CASE utasítás azt mondja, hogy a BILL$ változó tartalma szerint választjuk ki a nekünk kellő CASE ágat. Az egyes CASE utasításokban mondjuk meg, hogy melyik érték - vagy értékek - mellett kell éppen ezt az ágat választani. A 70-es sorban megadott CASE szerint például akkor kell az utána következő utasításokat végrehajtani, ha a BILL$ tartalmát. A 120-as sorban lévő CASE utáni utasításokat akkor hajtja végre a gép, ha a BILL$-ben egy p betű van. A gép ezeket az ágakat úgy járja sorba, hogy először megnézi az elsőt. Ha ez megfelel, akkor végrehajtja, és utána egyből az END SELECT utasításra ugrik, a többi CASE ágat meg sem nézi. Például írjuk a követkőket:

SELECT CASE BILL$
CASE "a"
PRINT "ez egy a betu"
CASE "a"
PRINT "ez nem b betu"
END SELECT

Így mindig csak az első ágat hajtanánk végre, azaz azt írnánk ki: ez egy a betű, pedig a második CASE ág feltétele is teljesül. Ezt azonban a gép már meg sem vizsgálná, mert amint talált egy megfelelő ágat - és az első ág itt megfelel -, csak azt csinálná meg, a többit pedig átugorná. A CASE ágak közül a legutolsó lehet mindig a CASE ELSE ág. Ez is egy ugyanolyan CASE, mint a többi, csak abban különbözik, hogy ha idáig eljutott a gép, és még egyetlen megfelelő ágat sem talált, akkor ezt hajtja végre. Ez tehát az "egyébként" ág, azaz ezt csinálja akkor, amikor a többi ág feltételei közül egy sem teljesül.
A SELECT ágak közül a legutolsó után egy END SELECT utasítás jelzi a választási lehetőségek és az utolsó CASE ág végét. A program nem rossz, de azért lehetne egy kicsit okosabb is. Jó lenne, ha köröket is tudnánk vele rajzoltatni. Miért ne? Egészítsük ki a programot a következővel:

Ezzel egy ugyanolyan CASE ágat szúrtunk be többi közé, mint az eddigiek voltak, csak ez a k betűre fog elindulni, és kört rajzol - a beolvasott sugárral - a köré a pont köré, ahol a ceruza áll. Indítsuk el a programot, és próbáljunk meg kört rajzoltatni! De hiszen ez nem csinál semmit! Ez a CASE ág talán nem jó? A hiba nem itt van, hanem még a 60-as sorban megadott LOOP utasításban. Oda ugyanis elfelejtettük beírni, hogy most már a k betű is érvényes válasz, tehát nem kell helyette egy másik betűre várni. Még egy feltételt beírni a 60-as sorba? Hiszen már így sem nagyon lehet átlátni, hogy mire is jó az a sok AND. Válasszunk más megoldást! Állítsuk meg a gépet, térjünk át szöveges képernyőre, és írjuk át a 60-as sort!

Ezek után a 40-es és a 60-as sorok közötti ciklus csak addig vár, amíg valamilyen billentyűt le nem nyomunk, és akkor azonnal folytatódik a program. Indítsuk most el a programot, és rajzoltassunk vele néhány vonalat és kört! Most már szépen működik ez is, a k billentyűvel lehet ebbe belefogni. A kiírt szövegben persze nem látjuk ezt, mert a 30-as sorban lévő PRINT utasításba elfelejtettük beírni. Ennél is nagyobb baj azonban az, hogy ha véletlenül olyan billentyűt nyomunk le, amelynek nem lenne semmi értelme, a program azonnal véget ér. Ez természetes, hiszen a 150-es sorban lévő CASE ELSE szerint minden olyan billentyűnél, amelynek nincs más jelentése, ezt kell csinálni. Ha azt akarjuk, hogy újra csak a v betűvel lehessen befejezni a rajzolást, akkor írjuk át a 150-es sort:

Most is futtassuk le a programot! Jó a felirat és jó a befejezés is, tényleg csak akkor ér véget a program, ha a v billentyűt nyomjuk le. Mi történik: azonban akkor, ha mondjuk az s billentyűt ütjük le? Ilyenkor a gép bizony hibát jelez! Hiszen ilyen ág nincs, így nem tudja, hogy mit csináljon. A korábbi CASE ELSE ág megszűnt - illetve most már CASE "v"-, újabb pedig nincs. Akkor hát írjunk egyet!

Vajon ebben az ágban mit fog csinálni a gép? Semmit! A 165 CASE ELSE és a 170 END SELECT között Ugyanis egyetlen más utasítás sincs, tehát nincs mit végrehajtani. Ez egy üres ág, csak arra jó, hogy megmondja a gépnek: ha nem érvényes billentyű jött be, akkor nem kell csinálni semmit.
Ez mér majdnem tökéletes, csak az lenne a jó, ha nemcsak: kis, hanem nagybetűkkel is ki lehetne adni a parancsokat. Azaz: he lenyomjuk a SHIFT-et és a k-t, akkor most nem csiná1 semmit sem a program, de jó lenne ha ekkor is kört rajzolna. Az egyik megoldás, hogy az összes CASE ágat leírjuk még egyszer, elejétő1 végig, de mindegyikbe a kisbetű helyett nagyot írunk, CASE "t" helyett CASE "T"-t és így tovább. Ez nemcsak unalmas, de fárasztó munka, sőt könnyű véletlenül elhibázni is. Ennél sokkal egyszerűbb lehetőséget ad az ENTERPRISE. Írjuk át a 70-es sort így:

Ehhez hasonlóan a többi CASE ág elején beírhatjuk a hiányzó nagybetűket. Az egyes CASE ágakban tehát egyszerre több értéket is megadhatunk, csak persze vesszőket kell tenni közéjük. Írjuk át tehát a 90-es, a 120-as, a 145-ös, a 150-es sorokat, és próbáljuk is ki a programot! Most már a nagybetűkkel is működik.
Ezzel ezt a programot be is fejeztük, jöhet valami más.

1 PROGRAM "Csikozo.bas"
10 GRAPHICS
20 DO
30   CLEAR GRAPHICS
40   PRINT #101,AT 1,15:"CSIKOZO"
50   INPUT PROMPT "Vonalak szama:":SZAM
60   SELECT CASE SZAM
70   CASE IS<5
80     PRINT "Ez tul keves"
90   CASE 5 TO 20
100     FOR I=1 TO SZAM
110       PLOT I*50,0;I*50+100,600
120     NEXT
130   CASE IS>20
140     PRINT "Ez tul nagy"
150   END SELECT
160   PRINT "Nyomj le egy billentyut!"
170   DO
180     GET BILL$
190   LOOP WHILE BILL$=""
200 LOOP UNTIL BILL$="v"
210 TEXT

Ezzel a programmal ferde vonalakat tudunk rajzoltatni. De hányat? Nos, ez egy SELECT-CASE sorozatban derül ki. A legelső újdonság, amit meglátunk, a 70-es sorban a CASE IS utasítás. Ezzel olyan CASE ágat kell jelölni, ahol egy összehasonlítástól függ, ez-e a megfelelő CASE ág. A 70-es sor azt mondja: ezt az ágat kell végrehajtani, ha a SZAM értéke kisebb, mint 5. Azaz ilyenkor a gép kiírja: ez túl kicsi. A 90-es sorban megadott CASE utasítás is újszerű, de nem nehéz megfejteni: ezt az ágat akkor kell választani, ha a SZAM 5 és 20 között van. Ha nagyobb, mint 20, akkor a 130-as sorban lévő CASE ág lesz igaz. Ebben a SELECT-CASE sorozatban nincs CASE ELSE ág, de nem is hiányzik, mert a SZAM minden értékénél valamelyik CASE ág megfelelő lesz. Futtassuk le, próbálgassuk ki a programot! Nézzük meg, hogy mikor melyik ágat választja ki a gép! Ne felejtsük el, hogy egy CASE utasításban egyszerre több feltétel is lehet. Például teljesen rendben lévő a következő sor:

Ez az ág akkor lesz kiválasztva, ha a megadott érték 5, vagy 8 és 23 között van, vagy nagyobb, esetleg egyenlő 130-cal.
Ma a SELECT-CASE utasítás használatát ismertük meg. Láttuk, hogy:

Ami most következik, az tényleg színes, legalább is azoknak, akiknek színes televíziójuk van. Ezidáig minden rajzunk olyan volt, mint az ég: kék. Ha házat rajzoltunk, kék volt a fala, kék a teteje. Pedig vannak más színek is!
Jó lenne néha más tintával is rajzolni egy kicsit. Ahhoz azonban, hogy be tudjuk állítani a tintánk színét, egy új utasítás kell, ez a SET. A SET (ejtsd: szet) szónak annyi jelentése van, hogy a szótárban több oldal is tele van vele, de mi csak egyetlen dologra fogjuk használni~ hogy beállítsunk vele valamit. Azt pedig, hogy mit, egy külön szóval kell megmondanunk. Ha a tinta színét akarjuk beállítani, akkor a tinta angol nevét kell megadnunk, ez az INK. SET INK annyit jelent: állítsd be a tinta színét! Milyen színűre? Ehhez még egy számot is meg kell adnunk. úgy képzeljük el, hogy egy asztalon négy tégelyünk van, sorrendben a nullás, az egyes, a kettes és a hármas. A nullásban fekete, az egyesben kék, a kettesben piros, a hármasban sárga tinta van. Ha piros tintával szeretnénk rajzolni, csak annyit kell mondanunk: SET INK 2
Ez az utasítás beállítja a tinta színét pirosra. Amit ezután rajzolunk, az mind-mind piros lesz, egészen addig, amíg valami más színt meg nem adunk. Rajzoljunk tehát egy piros házat:

Ajjaj, a vége nem sikerült! Semmi baj, könnyen kijavítjuk. Hiszen ha a vonalon egy olyan ecsetet húzunk végig, amelyen a papír színével azonos festék van, akkor egyszerűen eltüntetjük a vonalat. A papír színe most fekete, tehát ezt az utolsó rossz vonalat a következőképpen törölhetjük ki:

(A első PLOT azért kell, mert a hibás rajzoló utasítás végén felemeltük a ceruzát, tehát most rajzolás előtt le kell tennünk!) Most már meghúzhatjuk a helyes vonalat, a helyes színnel.

Nagyon szép házikó, de most nézzünk valami mást, előtte pedig töröljük le a grafikus lapot:

A kép ismét fekete. De hát miért kell a papírnak mindig feketének lenni? Miért nem lehet világos papírra sötét tintával rajzolni? Lehet! Csak persze előtte a papír színét be kell állítani, mégpedig a SET utasítással. A papír angol neve PAPER, állítsuk be hát a papír színét sárgára:

Nem történik semmi. Nem is, hiszen ha megváltoztatjuk a szivacs színét, attól még nem változik a tábla színe is, csak ha letöröljük vele a táblát. Töröljük hát le a képet:

Most jöhet a koronája! Ki látott már kék színű lombokat? Zöld tintánk pedig nincs egyik tégelyünkben sem. Semmi baj, töltsünk bele! Na de hogyan? Ezt is a SET utasítással valósíthatjuk meg. Ha egy tégely színét változtatjuk, akkor azt kell mondani: SET COLOR, utána pedig meg kell adni, hogy melyik tégelybe és milyen színt akarunk tölteni:

A GREEN (ejtsd: grín) is angol szó, annyit jelent: zöld. A színek nevei angolul a következők:

Ha valamelyik színt be akarjuk tölteni egy tégelybe, használjuk az angol nevét! Most viszont már jöhet a koronarajzolás:

Hoppá! Most meg mi történt? Hiszen mi nem törültük le a képet, a papír mégis fehérre változott! Ez bizony egy olyan dolog, amiben a gép egészen más, mint a rajzpapír. A számítógép ugyanis a hétköznapi grafikus lapon egyszerre csak négy színt tud használni - azt a négyet, amely a tégelyekben van. Ha megváltoztatjuk valamelyik tégelyben a festéket, minden, amit abból a tégelyből festettük ki, megváltoztatja a színét. Néha egészen meglepő dolgok is történhetnek emiatt, s ezek néha nagyon hasznosak lehetnek. Ha például most szeretnénk a fa törzsét kékről feketére változtatni, akkor tudnunk kell, hogy a kék festék eddig az egyes tégelyben volt. Ebbe a tégelybe fekete festéket öntve a fa törzse is rögtön feketévé változik:

A papírt, amelyet a hármas tégelyből színeztünk ki, átváltoztathatjuk pirosra:

Most már kezdenek összecsapni fejünk felett a színek, s a képernyőn látható színegyüttes nem éppen elviselhető. Mi valami szép rózsaszínre gondoltunk, és akkor megjelenik ez a jajvörös háttér. Huh! És egyáltalán! Semmilyen más színt nem használhatunk, az előbbiekben említetteken kívül?
Dehogynem! Az ENTERPRISE összesen 256 féle színt ismer, 256 különböző tubus áll rendelkezésünkre, amelyekből festékeket tölthetünk a tégelyekbe. A tubusok közül néhánynak saját neve is van, ezeket már ismerjük: RED, GREEN, BLACK, ... A legtöbbnek azonban csak száma van. Akad köztük mindenféle szín és mindenféle árnyalat, megszámozva nullától 255-ig, Az egyik rózsaszín - a többféle árnyalat közül - a 29-es. Állítsuk be ezt háttérszínnek:

Ezzel most a hármas tégelybe töltöttük a 29-es színt, azaz a papírt is átszíneztük. Honnan lehet tudni vajon, hogy melyik színnek mi a száma? Ezt bizony próbálgatással lehet csak megtalálni. A következű program az egyes színeket mutatja be szépen sorban:

10 GRAPHICS
20 SET PAPER 0
30 CLEAR SCREEN
40 FOR SZIN=0 TO 255
50   SET COLOR 0,SZIN
60   PRINT "SZINKOD:";SZIN
70   PRINT
80   PRINT "NYOMJ LE EGY BILLENTYUT"
90   DO
100     GET BILL$
110   LOOP WHILE BILL$=""
120 NEXT SZIN
130 TEXT

Ha akarunk, készíthetünk magunknak egy kis színtárat is, ahol felírjuk, hogy az egyes színeknek mi a száma. Időközben azonban előkerült egy újabb kérdés. Ha meg tudjuk változtatni a papír színét és a tintáét is, miért nem tudjuk a képernyő peremén körben húzódó keret színét is megváltoztatni? Természetesen ez is lehetséges! A keret angol neve BORDER, a színét tehát a SET BORDER utasítással tudjuk beállítani. A keretre azonban nemcsak a négy tégelyből színezhetünk, hanem a 256 szín bármelyikét megadhatjuk, ugyanúgy, mint a SET COLOR utasításban. A

pirosat. Ennek megfelelően a keret színét nem is befolyásolja, ha valamelyik tégely tartalma megváltozik. A keret színe nem függ a tégelyektől.
A grafikus lapon most már mindenféle színt tudunk használni, tudunk ezekkel a színekkel rajzolni (PLOT) és írni, (PRINT #101:), meg kellene próbálni a szöveges lapon is megváltoztatni a tinta vagy a papír színét. A szöveges lap színeit is négy tégely tárolja, de ez másik négy tégely, tehát másként is keli őket megtölteni valamilyen festékkel. A nullás tégelyt például így lehet kék festékkel megtölteni:

Ez a papír színe ebben a pillanatban a szöveges lapon. A tinta színe az egyes tégelyben van. Változtassunk meg ezt a tégelyt is:

Most már kezdjük megérteni, hogy mi á különbség. Ha a szöveges lapra vonatkozó tégelyek színét akarjuk megváltoztatni, akkor mindössze a £102: jelölést kell betennünk a SET kulcsszó után. Próbáljuk ki ezt a tintaszín állítására:

Nocsak! Mi csak a tinta színét akartuk megváltoztatni, de magától megváltozott a papír színe is. Vajon miért? A szöveges lapoknak az a fontos tulajdonságuk a grafikus lapokkal szemben, hogy a tinta színe csak 1-es vagy 3-as lehet, a papíré pedig 0-ás vagy 2-es. A párosítás még ennél is szorosabb, mivel a 0-ás papírszín és az 1-es tintaszín - és ennek megfelelően a 2-es papír és a 3-as tintaszín is - olyan szorosan összetartozik, hogy ha az egyiket beállítjuk, akkor a másik is beáll magától. Az előző utasításban mi csak a tintát állítottuk át a 3-as tégelyre, de ettől a papír színe is rögtön a 2-es tégelyben 1évő lett. Látható, hogy a 2-es tégelyben fekete, a 3-asban a piros festék van. Adjuk ki most a következő parancsot:

A nullás tégelyben kék festék van, a tinta mégis sárga lett, a papír pedig kék. A dolog egyszerű! Azt már mondtuk, hogy a szöveges lapon a tinta csak 1-es vagy 3-as lehet. Ha nullást adunk meg, akkor az ehhez tartozó ÉRVÉNYES tintaszínt, azaz az egyest állítja be a gép, ezért lett a tinta sárga. (Az egyes tégelybe mi magunk töltöttük a sárga festéket.) Ha megváltozott a tintaszín, akkor azonban hozzá párosul a papír színe is. Ha a tinta színe az egyes, akkor a papír színe nullás lesz, azaz - mivel a nullás tégelyben kék festék van - kék.
A keret színe is módosítható a szöveges lapon? Természetesen, csak persze ez a keret ugyanaz, mint ami a grafikus lap körül van, tehát a

utasítás. Hát ha már ennyi féle színünk van, jó lenne egy kicsit festegetni velük. Nyissuk meg a grafikus lapot:

Rajzoljuk fel a fát! (Figyelem! A vesszőkre, pontosvesszőre, sorvégi vesszőkre nagyon kell figyelni, mert most rendkívül fontosak.)

PLOT 400,0;400,400
PLOT 500,0;500,400
SET COLOR 2,GREEN
SET INK 2
PLOT 450,400,
PLOT ELLIPSE 150,200,

Hoppá! Hát ezt meg hogy csináltuk? PAINT (ejtsd: péint) azt jelenti: festeni. A PLOT PAINT utasítással azokat a rajzokat tudjuk kifesteni, amelyeket már korábban, PLOT és PLOT ELLIPSE utasításokkal rajzoltunk meg. A PLOT PAINT utasítás hatására a gép mindig a tinta színével fest, tehát most zölddel. A festést ott kezdi, ahol éppen a ceruza áll, és minden irányban addig fest, amíg el nem éri a kifestendő rajz peremét. Ezt onnan ismeri fel, hogy tinta színű vonalat, azaz tinta színű pontokat talál. Ha egy irányban elértük a tinta színű vonalat, akkor másik irányban folytatódik a festés, amíg az egész szükséges területet ki nem festődött.
Nagyon fontos, hogy ha az a pont, ahonnan a festést kezdenénk, maga is tinta színű, akkor a gép nem csinál semmit, mert azt hiszi, hogy már minden irányban elérte a határvonalat. Ha tehát például a PLOT ELLIPSE utasítás végéről lefelejtettük volna a vesszőt, akkor ugye ez az utasítás egy pontot tesz az ellipszis közepére, ahol a ceruza áll. Emiatt a PLOT PAINT utasításra a gép nem festene ki semmit sem, mert éppen ezen a ponton kéne kezdenie - de ez már tinta színű, tehát azt hiszi, hogy már vége is van a festésnek, és leáll. A PLOT PAINT utasítás előtt tehát ajánlatos egy üres pontra vinni a ceruzát, és a mozgató PLOT utasítás végére egy veszőt tenni; hogy ne hagyjon nyomot.
Ma annyi mindennel találkoztunk, hogy felsorolni is sok.

10 GRAPHICS
20 SET COLOR 2,GREEN
30 PLOT 400,0;400,400
40 PLOT 500,0;500,400
50 PLOT 450,400,
60 SET INK 2
70 PLOT ELLIPSE 150,200, 80 SET INK 1
90 PLOT 700,0;700,400
100 PLOT 800,0;800,400
110 PLOT 750,400,
120 SET INK 2
130 PLOT ELLIPSE
140 SET INK 1

Futtassuk le a programot! A két fa olyan szép, hogy kedvünk lenne egy harmadikat is odarajzolni - csak hát még egyszer leírni azt a sok-sok utasítást? Teljesen fölösleges. Ha többször kell ugyanazt vagy majdnem ugyanazt a dolgot csinálni, akkor ahelyett, hogy minden alkalommal újra és újra leírnánk az egészet, egyszerűbb egy dobozba, egy blokkba beletenni ezeket az utasításokat, és valahányszor csak szükséges, egyszerűen annyit mondani: csináld azt, ami a dobozban van. Ez a bűvös doboz, ez az utasításblokk a DEF blokk. Írjuk át az előző programot DEF blokk segítségével:

1 PROGRAM "Fa.bas"
10 GRAPHICS
20 SET COLOR 2,GREEN
30 DEF FARAJZ
40 PLOT OSZL,0;OSZL,400

50   PLOT OSZL+100,0;OSZL+100,400
60   PLOT OSZL+50,400,
70   SET INK 2
80   PLOT ELLIPSE 150,200,
90   SET INK 1
100 END DEF
110 LET OSZL=400
120 CALL FARAJZ
130 LET OSZL=700
140 CALL FARAJZ

Mit is csináltunk? A 40-es és 90-es sorok közötti utasításokat bezártuk egy DEF blokkba. A blokk a 30-as sorban lévő DEF utasítással kezdődik, ez egyben azt is megmondja, hogy ennek a blokknak a neve FARAJZ lesz. A blokk végét a 100-as sorban az END DEF jelzi. Mit csinál a gép, amikor végrehajtja ezt a programot? A legelején természetesen beállítja a grafikus lapot, és betölti a kettes tégelyt zöld festékkel. És utána? A legfontosabb dolog most következik. Ha csak az utasítások sorrendjét nézzük a listában, azt hihetnénk, a gép most szépen elkezdi végrehajtani a DEF blokkban lévő utasításokat. De nem! A DEF utasítás hatására ugyanis megjegyzi a blokk nevét és azt, hagy hol kezdődik, DE NEM HAJTJA VÉGRE! A DEF blokkokat a program egészen egyszerűen átugorja, meg sem nézi, hogy mi van bennük!
Mire jó hát akkor ez az egész? Csak nyugalom! Az, hogy elsőre átugorja a blokkot, nem jelenti azt, hogy később sem tér oda vissza. A program a 110-es sor utasításán folytatódik, betölti az OSZL változóba a 400-at, és most jön a 120-as sorban lévő CALL. Mi az a CALL? Maga a szó - amit egyébként kól-nak kell ejteni - azt jelenti: hívd. A CALL utasítás szorosan összetartozik a megfelelő DEF blokkal. A DEF szócska az angol define (ejtsd: difájn) rövidítése, ami meghatározást jelent. A DEF utasítás utáni blokkban határozzuk ugyanis hogy mik lesznek a végrehajtandó utasítások, de egyelőre nem hajtjuk őket végre, csak leírjuk.
A CALL utasítás éppen azt csinálja, hogy odaugrik a DEF blokk elejére, végrehajtja a benne megadott utasításokat, majd visszatér, és a CALL utáni utasítással folytatódik a program. Ezt úgy szokták mondani, hogy a CALL utasítás meghívja a megadott DEF blokkot, ezért is CALL az utasítás neve. A 120-as sorban megadott CALL utasítás hatására tehát a program a 30-as sorra ugrik, végrehajtja a blokkon belüli utasításokat, és visszatér. Mi van a blokkban? Ha végignézzük, akkor azt látjuk, hogy ez a blokk egy fát rajzol, mégpedig abban az oszlopban kezdve, amelynek a számát az OSZL változó tartalmazza. Az OSZL változó nagyon fontos ebben a blokkban. Ez mondja, hogy végül is hova kell rajzolni a fát. Enélkül a blokk le sem tudna futni. Azokat az adatokat, változókat, amelyek a blokk működését irányítják, a blokk paramétereinek hívjuk. A FARAJZ blokknak egyetlen paramétere van, ez az változó. Mielőtt meghívnánk a blokkot, mindig meg kell mondanunk, hogy mi legyen a paraméter értéke, azaz a gép hova rajzolja ki a fát. A mi programunkban először a 400. oszloptól kezdve rajzoltatjuk ki a fát, majd a 130-as sorban megadott utasításban átállítjuk a paramétert a 700. oszlopra, és oda is rajzoltatunk egy fát. Akárhány fát rajzoltathatunk, mindegyikhez mindössze két utasítás kell. Az elsővel megadjuk, hogy melyik oszlopon kezdjük a rajzolást (LET OSZL= 400), a másodikkal pedig meghívjuk a fát rajzoló blokkot (CALL FARAJZ).
Ha most e mellé a két fa mellé szeretnénk még kettőt rajzolni, semmi akadálya, csak az alábbi sorokat írjuk a programhoz:

Ha most is lefuttatjuk a programot, akkor már négy fa jelenik meg.
A bemutatott programban szereplő DEF blokk nem ellenőrzi, hogy a paramétere megfelel-e, azaz megadhatunk neki paraméterként 3000-t vagy -10-et is, ő nem veszi észre, csak a gép jelez majd hibát, mivel a képernyőn kívülre próbálunk rajzolni. Ezen segít a következő utasítás:

Az EXIT DEF utasítással a DEF blokk végrehajtását tudjuk félbeszakítani, és visszatérni a blokkot hívó CALL utasításhoz. A DEF blokkokat, mivel a program feladatának egy részét önállóan oldják meg, részprogramoknak, alprogramoknak, vagy angol nevük nyomán szubrutinoknak hívják. Mostantól fogva mi is így nevezzük majd őket. Ezekkel a szubrutinokkal játszani is lehet. Írjuk be a programba például a következűket:

A 104-es lévő END utasítás nem egy blokk végét jelzi önmagában álló END ugyanis a program véget mutatja. A szóval már valószínűleg mindenki találkozott angol vagy amerikai filmek végén, azt jelenti: vége. Általában az END után szoktuk: megadni a BASIC-ben azt, hogy minek van vége, ha azonban nem írunk semmit, akkor ez a program végét jelenti. Ezt az END-et azért írtuk ide, mert az utána következő utasításokat teljesen felesleges végrehajtani, minket most csak az érdekel, mit csinál az előtte lévő FOR ciklus. Ez a ciklus egymás után sorban rajzoltatja ki a fákat, szorosan egymás mellé, a képernyőn el sem lehet őket választani.
Indítsuk el a programot! A sűrűn egymás mellett álló fák úgy összefolynak, hogy csak egy mozgó csövet látunk balról megjelenni.
Gyakori probléma, hogy a billentyűk figyelését végző ciklus sokszor négy-öt helyen is használja a program, és nekünk mindannyiszor le kell írnunk. Tegyük inkább egy szubrutinba! A következő program csak akkor áll le, ha csupa nagybetűkkel a VEGE szót gépeljük be.

10 DEF BILLBE
20   DO
30     GET BILL$
40   LOOP WHILE BILL$=""
50 END DEF
60 DO
70   CALL BILLBE
80   IF BILL$="V" THEN
90     CALL BILLBE
100     IF BILL$="E" THEN
110       CALL BILLBE
120       IF BILL$="G" THEN
130         CALL BILLBE
140         IF BILL$="E" THEN
150           EXIT DO
160         END IF
170       END IF
180     END IF
190   END IF
200 LOOP

Indítsuk el a programot! Ameddig nem nyomunk le, semmit, addig nincs is baj, de az elő, billentyű, lenyomására a gép azonnal hibát jelez. Vajon miért? A dolog nyitja a szubrutinok paramétereiben rejlik. Amikor a program elindul, a BILLBE szubrutint természetesen átugorja, és a 60-as sorban megadott DO utasítással kezdi végrehajtani a parancsokat. Rögtön a következő, a 70-es sorban ott egy CALL utasítás, amellyel a BILLBE szubrutint hívjuk meg. A gép, mielőtt elindítaná a rutint, megnézi, milyen változókat használtunk eddig, azaz mik lehetnek ennek a szubrutinnak a paraméterei. Egyetlen ilyet sem talál. Megkezdi a szubrutin végrehajtását, de a 30-as sorban talál egy változónevet: BILL$. Vajon mit csinál? Hiszen ilyen változó eddig nem volt.
Nos, a legegyszerűbb megoldást választja, azaz létrehoz magának egy ilyen nevű változót. Igen ám, de ő gondosan ügyel, nehogy a szubrutinon belüli dolgok összekeveredjenek a kívül levőkkel, ezért ezt a változót úgy hozza létre, hogy megjegyzi: csak a szubrutinon belül létezik. Ez a szubrutin belső változója!
Ha a szubrutin befejeződik, az ilyen belső változókat a gép azonnal elfelejti, mivel ezek csak a szubrutinon belül használatosak. A rutin tehát beolvassa a lenyomott billentyűt egy BILL$ nevű változóba, de ezt a változót, ahogy véget ért a szubrutin, azon nyomban ki is törli. Amikor tehát a 70-es sorban meghívott szubrutin visszatér, és a 80-as sorban a BILL$ vált tartalmát megpróbálja összehasonlítani a v-vel, akkor észreveszi, hogy itt, kívül a szubrutinon nincs is olyan változó, amelynek a neve BILL$, természetesen hibát jelez.
A hiba oka tehát az, hogy a gép nem ismerte fel: a BILL$ változót a szubrutinon kívül is használjuk, ezért belső változóként hozta létre, a szubrutin befejezésekor automatikusan törölte, így aztán, amikor ki akartuk olvasni a tartalmát, hibát jelzett. Mit lehet tenni? A probléma elég gyakori ahhoz, hogy a BASIC nyelvben erre is legyen segítség. A módszer rendkívül egyszerű. Mielőtt meghívnánk a szubrutint, meg kell mondani a gépnek, hogy bár eddig nem használtuk a BILL$ változót, de majd fogjuk, és ezért ne belső, hanem külső változóként kezelje, azaz a szubrutinon kívül is vegye létezőnek.
Erre a célra két utasítás szolgál, a STRING és a NUMERIC. A STRING azt jelenti: füzér, és a szöveges változókat szokás így nevezni. Ezzel a szöveg típusú változókat hozzuk létre. A NUMERIC jelentése: szám jellegű, ezzel tehát a számokat tartalmazó változókat jelöljük ki.
Általános szokás, és hasznos is tartanunk magunkat hozzá, hogy a különböző szubrutinok paraméterváltozóit, a külső változókat a program legelején hozzuk létre, így biztos, hogy mielőtt bármelyik szubrutint megkezdenénk, már létrejöttek a megfelelő külső változók, és nem lesz keveredés. Írjuk hát be a program elé:

Ezzel létrehoztunk egy BILL$ nevű szöveges változót. Amikor tehát a gép megkezdi végrehajtani a szubrutint, már létezik ilyen, tehát nem hoz létre egy másikat belső változóként.
Nézzük a következű programot!

10 DEF KORBEO
20   INPUT PROMPT "OSZLOP:":OSZLOP
30   INPUT PROMPT "SOR:":SOR
40   INPUT PROMPT "SUGAR:":SUGAR
50 END DEF
60 DEF KORRAJZ
70   PLOT OSZLOP,SOR
80   PLOT SUGAR,SUGAR
90 END DEF
100 GRAPHICS
110 DO
120   CALL KORBEO
130   CALL KORRAJZ
140 LOOP

Természetesen most csak a példa kedvéért írtuk be az utasításokat két szubrutinba. Ha azonban feledékenyek vagyunk, akkor az ilyen szubrutinba pakolás könnyen hibához is vezethet. Indítsuk el a programot! A gép rendesen beolvassa az adatokat, de utána az első PLOT utasításra hibát jelez. Ennek ugyanaz az oka, ami az előző programnál volt. A KORBEO rutin a saját belső változóiba olvasta be a megrajzolandó kör oszlopszámát, sorszámát és sugarát, ezek a változok pedig a szubrutin végén elvesztek. A KORRAJZ rutin a saját belső változóiból próbálja kiolvasni az adatokat, de ott nincs semmi, ezért hibát jelez. A változókat tehát külső változóként előre létre kell hozni! Írjuk be:

Most már működni fog a program, vidáman rajzolja a köröket.
Foglaljuk össze új ismereteinket!

Mi is az a teknőc? A Révai lexikon nyomán: "A teknősök a csúszómászók rendjébe tartoznak. Valamennyi teknősféle négylábú, és legfőbb jellemvonása, hogy széles és rövid törzsét páncél övezi, úgy, hogy csak a fej, a láb és a farok látszik ki alóla. A teknősök lomha, lassú állatok. Értelmi képességeik igen alacsony szintűek."
A mi teknősünk nem csúszómászó, hanem robot. A hasán alul kis tollhegy van, s amerre jár - ha leengedi ezt a tollat-, nyomot hagy maga után. A teknőc tehát rajzeszköz. Az ötlet, hogy egy teknőcöt kéne a számítógéppel vezérelni, és rajzoltatni vele, Amerikában született, a hatvanas évek végén, amikor Seymour Papert irányításával megkezdték a LOGO nyelv kifejlesztését, kifejezetten gyermekek számára. Ebben a nyelvben úgy lehet rajzolni, hogy a képernyőn mozgó képzeletbeli teknőcnek kell parancsokat adni.

Menj előre tíz lépést!
Fordulj balra 25 fokkal!
Indulj el hátrafelé két lépést!

Az ötletes megoldás olyan jól bevált, olyan kényelmes és egyszerű, hogy azóta sok más számítógépes nyelvben is helyet kapott. A sok közül az egyik az ENTERPRISE BASIC, amelyet mi használunk. A mi teknősünk ott van mindig a grafikus lapon, eddig is ő mozgatta a ceruzát, csak nem tudtunk róla. Mostantól fogva azonban egyenesen neki parancsolunk. Parancsolni, természetesen, csak BASIC-ül lehet neki, mert más nyelvet nem ért. S mivel ugyanazt a ceruzát mozgatja, amelyet eddig is használtunk a PLOT utasításokban, ezért ő is a PLOT utasításokat fogja végrehajtani. Van azonban néhány olyan PLOT utasítás, amellyel eddig még nem találkoztunk.
A legegyszerűbb ezek közül a PLOT FORWARD. A forward (ejtsd: fóvörd) azt jelenti: előre, és valóban, a kis teknőc annyi képpontot lép ettől előre, amennyit megadunk. A FORWARD párja a BACK (ejtése: bek), ami éppen az ellenkező irányt jelenti, azaz: hátra. A kis teknőc persze nem mászkálhat mindig csak előre-hátra, néha el is kell fordulnia. Erre való a PLOT RIGHT és a PLOT LEFT utasítás. Az első jobbra, a második pedig balra fordítja el teknőcünket akkora szöggel, amekkorát megadunk. A right (kiejtve: rájt) azt jelenti: jobbra, párja a left pedig: balra. (Ezt úgy kell ejtenünk, ahogy írjuk.)
Azt már tudjuk, hogy az előre-hátra mozgásnál meg kell adnunk, hányat lépjen a teknőc, de vajon az elfordulásoknál hogyan adható meg, hogy mennyire forduljon jobbra vagy balra? Nos, az elfordulás szögét mi mindig fokokban fogjuk beírni, de ezt meg kell mondani a számítógépnek is, hogy tudjon róla. A legelső teknőc-parancs előtt ezért azt kell mondanunk:

Ez magyarra fordítva annyit tesz: mostantól fogva az elfordulásokat szögben mérve fogom megadni. Már szó volt arról, hogy ez a kis teknőc, miközben mászkál a képernyőn, fel tudja emelni a ceruzáját, és le is tudja engedni! Ezt hogyan mondjuk meg neki? Természetesen úgy, ahogy azt eddig is tettük, csak nem tudtuk, hogy a teknőnek szól. Az üres PLOT felemeli, a pontosvesszőre végződő PLOT; leengedi a ceruzát.
Nézzünk hát először egy egyszerű kis programot:

10 OPTION ANGLE DEGREES
20 CLEAR GRAPHICS
30 PLOT 600,350;
40 DO
50 PLOT FORWARD 100;RIGHT 150;
60 LOOP

Futtassuk le a programot! Ugye szép? Most próbáljuk ki úgy, hogy nem 150, hanem 155 fokot adunk meg! Próbálgassuk más szögekkel és más lépéshosszakkal is! Ugye jó játék? Ha valami változatosságot akarunk, egészítsük ki a programot:

Nézzük meg, mit csinál most a teknőc? Az egyetlen gond, hogy mindig más irányba kezdi el a rajzolást. Hogyan lehetne megadni az irányát? Természetesen fokokban, ehhez a PLOT ANGLE utasítást használjuk. Az ANGLE (ejtsd: engl) szöget jelent, jelen esetben azt, hogy a teknőcünk a vízszintesen jobbra mutató nyílhoz képest mekkora szögben induljon el balra. A PLOT ANGLE 90; után egyenesen felfelé mutat az előre irány, a PLOT ANGLE 270; után pedig éppen ellenkezőleg, lefelé. Írjuk hát át a 30-as sort:

Mostantól fogva már mindig felfelé indul el a teknőc. Próbáljuk is ki!
Foglaljuk hát össze, mit tudunk a PLOT utasításról!

Harsona harsan, legalábbis ha megfújják. A gépet azonban hiába fújjuk, nem szól. Ha hangot akarunk hallani, mást kell tennünk. Mondjuk meg neki, mit akarunk: HANGOT. A hang angolul SOUND (ejtsd: szaund), gépeljük tehát be:

A hangszóróból rövid dudaszó hangzik, aztán újra csend. A legfontosabb azonban már megvan, megismertük a SOUND parancsot, amellyel éneklésre tudjuk bírni a gépet. Éneklésre? Kicsit unalmas lenne az a dal, amely csak egyetlen hangból- állna, még ha azt többször játsszuk is le. Ha más hangot szeretnénk hallani, meg kéne mondanunk, hogy. milyen magasan szóljon. A hangmagasság angol neve PITCH. Írjuk be a következő parancsot:

Amit most hallunk, az már egészen más. Ez nem duda, ez egy kis síp. A hatvanas szám éppen azt mondja meg, hogy milyen magas legyen a hang. Ha a SOUND utasításba nem írunk PITCH részt, akkor a 37-es hang, a normál C szólal meg. Ha egy félhanggal magasabbat szeretnénk, akkor 38-at kell megadnunk, ha még eggyel magasabbat, akkor 39-et. A hangok tehát félhangonként emelkednek egyesével. Ez egy magas hang:

Ha azonban zenélni akarunk, nem elég a hangok magasságát megmondanunk, hanem a hosszát is Jelölnünk ke1l. Az időtartamot az angolban a DURATION (kiejtése: durésön) szó jelöli, a mi BASIC-ül tudó gépünk is ezt használja. Próbáljuk ki:

Ez sokkal rövidebb volt, mint az eddigi hangok. A hang hosszát a másodperc ötvened-részében kell megadnunk, a

pedig négy másodperces D. A következő program egy rövid dallamot játszik le:

10 SOUND DURATION 10,PITCH 37
20 SOUND DURATION 10,PITCH 41
30 SOUND DURATION 10,PITCH 44
40 SOUND DURATION 10,PITCH 49

Csak az a baj, hogy túlságosan hangosan szól, a hangszóró nem is bírja, torz zaj hallatszik. Csökkenteni kéne a hangerőt. De hogyan? Természetesen erre is van utasítás, csak nem olyan egyszerű, mint az eddigiek. Az ENTERPRISE valójában sztereó hangot állít elő, azaz olyat, amelyben a bal és a jobb oldalról más-más erővel szólal meg a hang. Mivel azonban a gépen csak egyetlen hangszóró van, ezért mindkét oldal ezen szólal meg. Ha sztereóban szeretnénk hallgatni, akkor szerezzünk valahonnan egy kis fejhallgatót, és dugjuk be a hátoldalon lévő OUT feliratú aljzatba, ahová eddig a magnót kötöttük.
Ha most játszatunk le egy hangot, akkor az tényleg mindkét oldalról szól. Egyelőre azonban mindkét oldalról ugyanakkora hangerővel, méghozzá a lehető leghangosabban. Ha meg akarjuk változtatni, meg kell adnunk, melyik oldalról milyen hangos legyen. A bal oldal neve - ahogy azt láttuk már a teknőcnél is - LEFT, a jobb oldalé RIGHT. A hangerőt 0 és 255 közötti számmal kell megadnunk, tehát

csak balról. Ha nem fejhallgatóval hallgatjuk, akkor a hangszórón egyszerre mindkét oldal szólal meg, tehát a két oldal hangereje összeadódik. Ilyenkor tehát teljesen mindegy, hogy melyiket választjuk az előzőek közül, mindkettő 255-ös hangerővel szól a hangszóróban. A következő ugyancsak:

mivel 128+127=255.
Ha nem mondjuk meg, hogy mi legyen a hangerő, akkor mindkét oldal 255-ös erővel szól, a SOUND utasítás tehát 255+255=510-es hangerővel hallható. Ez pedig egyes hangoknál már több, mint amit a hangszóró elbír, ilyenkor lesz a hang zajos, torz. Írjuk hát át a programot:

10 SOUND DURATION 10,PITCH 37,LEFT 0
20 SOUND DURATION 10,PITCH 41,LEFT 0
30 SOUND DURATION 10,PITCH 44,LEFT 0
40 SOUND DURATION 10,PITCH 49,LEFT 0

Aki fejhallgatón hallgatja, annak csak a jobb oldalról szólalnak meg a hangok, hiszen a bal oldalt elnémítottuk, a hangszórón keresztül viszont pont jó. Most aztán jöhet a zenélés. Írjunk programot, amely eljátssza a boci-boci tarkát! Hány hang is az?
24!
Az nagyon sok. Huszonnégyszer leírni egy teljes SOUND utasítást, megadva a hangmagasságot, hosszt és hangerőt is - ez több, mint unalmas. Mindegyik utasítás így nézne ki (csak a számok változnának):

Mennyivel egyszerűbb lenne külön leírni csak a számokat, és külön azt, hogy mit kell csinálni az adatokkal. Erre van is lehetőség. Az adatok neve angolul DATA, ezeket tehát a DATA utasításba tudjuk beleírni. Az adatokat azután a READ utasítással lehet egy változóba beolvasni, ugyanúgy, mintha a billentyűket olvasnánk egy INPUT-tal. Írják be a következő programot:

1 PROGRAM "Zene.bas"
10 FOR HANG=1 TO 27
20 READ MAGASSAG,HOSSZ
30 SOUND PITCH MAGASSAG,DURATION HOSSZ,LEFT 128,RIGHT 128

40 NEXT
50 DATA 37,10,41,10,37,10,41,10
60 DATA 44,20,0,1,44,20
70 DATA 37,10,41,10,37,10,41,10
80 DATA 44,20,0,1,44,20
90 DATA 49,10,48,10,46,10,44,10
100 DATA 42,20,46,20
110 DATA 44,10,42,10,41,10,39,10
120 DATA 37,20,0,1,37,20

A program elején egy ciklus van. A ciklusban huszonhétszer olvassuk be a hang magasságát és hosszát, megszólaltatjuk a hangot, majd vesszük a következőt. A READ utasítás szépen sorban halad az egyes DATA utasításokon, sorra olvassa ki belőlük az adatokat. Először mindig a magasságot, aztán, az időtartamot.
Hasznos megfigyelnünk néhány dolgot. A DATA utasításoknak nem kell a program elején lenniük, lehetnek a végén vagy akár a közepén is. Sőt, akár azt is megtehetjük, hogy nem egymás után tesszük őket, hanem néhányat az elejére, egyeseket meg a közepére vagy a végére. A DATA utasításokat a gép mindig átugorja, hiszen azokban nincs mit végrehajtani, csak adatokat tárolnak. A READ utasítás a legelső DATA elején kezdi az olvasást, és sorban olvassa ki az egymás után következd adatokat. Ha a DATA végére ért, akkor a következőn folytatja. Bár most nem kellett, de a programban lehet egyszerre több READ parancs is ezek mindig ott fogják folytatni a DATA-k olvasását, ahol az előző abbahagyta.
Futtassuk le a programot!
Most futtassuk le még egyszer, de közben figyeljük meg, hogy mikor tűnik fel az "ok" üzenet és a kurzor! Hiszen még végére sem ért a zenének, és máris úgy csinál, mintha befejezte volna! Vajon miért? A megoldás elég meglepő. A program a SOUND utasításoknál sohasem várja meg, amíg valóban véget ér a hang, hanem csak utasítja a gépet, hogy szólaltassa meg a hangot, és továbbhalad. Ahogy egyre újabb és újabb hangokat kell lejátszania, a gép egyre inkább lemarad, a program már régen véget ért, amikor a zenének is vége szakad. A gép azonban egyetlen hangot sem felejt el, végig lejátssza a dallamot.
Szépen szól a zene, legalábbis akkor, ha nem rontottuk el az adatok másolását. Jó lenne ezt többször is meghallgatni. Tegyük hát be egy ciklusba! Írjuk be a következő két sort:

Indítsuk el a programot!
Na de kérem! Mi a baj? A hibaüzenet azt jelenti, hogy a program az adatok végére ért, és mégis újra megpróbált újabb adatot beolvasni. Persze, hiszen a legelő, alkalommal az összes DATA utasítást végigolvasta, a 120-as DATA sornak is végére ért, most már nem tud honnan olvasni. Amikor újra kezdi a programot, hibát jelez. Hogyan lehetne ezt kijavítani? Talán tegyük be a DATA utasításokat is a ciklusba? Az semmire sem jó, hiszen ezeket a gép úgysem hajtja végre, tehát nem számít az sem, hogy a cikluson belül vagy kívül vannak-e. Azt kéne megmondani a gépnek, hogy az 50-es sor DATA utasításánál folytassa az adatok olvasását. Erre való a RESTORE utasítás:

Indítsuk el a programot!
Most már szépen ismételgeti a dalt. A RESTORE utasítással tehát bármikor megmondhatjuk, hogy melyik DATA utasításnál kell folytatni az olvasást. Ez nemcsak akkor lehetséges, ha az adatok végére értünk, hanem máskor is.
Állítsuk le a programot a STOP billentyű lenyomásával! De hisz ez még szól! Semmi baj, mi már tudjuk: csak annyi történik, hogy a gép még lejátssza azokat a hangokat, amelyeket a program már beolvasott, de eddig még nem szólaltak meg. Amint a végükre ér, rendben elnémul. Most írjuk be a következő sorokat:

Az első RESTORE a 130-as programsorra állítja azt a mutatót, amellyel a gép a következő olvasandó DATA sort jelzi. A 42-es sorban lévő READ beolvassa a 130-as DATA sorból a szöveget, a 43-as sorban megadott PRINT kiírja, majd a 44-es sorban lévő RESTORE ismét a hangok elejére állítja a DATA mutatót. A 130-as sor DATA utasításában a szöveget természetesen idézőjelek közé kellett zárni. Futtassuk le a programot! A program nemcsak zenél, de ír is, sőt, mivel a zenénél egy kicsit lemarad a gép, ezért még előbb írja ki a szöveget, minthogy befejezte volna a zenét. Az egyetlen problémánk, hogy ha nem nézünk a képernyőre, csak a zenét hallgatjuk, akkor könnyen észrevehetjük: a dal vége és a következő lejátszás eleje teljesen összefolyik. Hogyan lehetne egy kis szünetet teremteni közöttük?
Mi jellemző a szünetre? Az, hogy egyik oldalról sem szól semmi, azaz mindkét oldal hangereje 0. Egészítsük hát ki a programot a következő sorral:

Indítsuk el a programot! Most már jól lehet hallani, hol van az egyik dal vége, és hol kezdődik a másik. Ma is sok új dolgot láttunk.

Ezek a tömbök nincsenek éppen aranyból, mégis aranyat érnek. Róluk azonban egy kicsit később lesz szó. Először készítsünk egy programot, amely beolvas tíz hangot, pontosabban tíz számot, melyek egy-egy hang magasságát adják meg, aztán szépen egymás után lejátssza a hangokat. Nézzük, hogyan lehet egy hangot beolvasni:

Ha most egymás után írunk tíz INPUT utasítást, melyek beolvassák az egyes hangmagasságokat egy-egy változóba, aztán írunk tíz SOUND parancsot, melyek megszólaltatják őket, akkor kész a program. Mit tegyünk akkor, ha nem tíz, hanem húsz vagy száz hangot szeretnénk megszólaltatni? Ennyi utasítást leírni nem volna kellemes időtöltés. Hol itt a gond - kérdezhetjük -, hiszen mi már ismerjük a ciklusokat. Ha ugyanazt egymás után többször kell megcsinálni, akkor bele kell tenni az utasításokat egy FOR ciklusba és annyiszor menni körbe, ahányszor csak szükséges. Igen ám, de most nekünk nem ugyanabba a változóba kell tízszer beolvasnunk, hanem mindig másikba! Mi lenne, ha megsorszámoznánk a változókat és a ciklusváltozót felhasználnánk arra, hogy mindig megmondja, most éppen hányadik változóba akarunk olvasni?
Ennek semmi akadálya! Amit kitaláltunk, nem más, mint a számítástechnikában TÖMB-nek nevezett dolog. Azt még látni fogjuk, hogy csakugyan aranyat ér. Nézzük hát a programot:

10 NUMERIC HANGOK(1 TO 10)
20 FOR SORSZAM=1 TO 10
30   PRINT "AZ";SORSZAM;"-IK HANG:";
40   INPUT PROMPT "":HANGOK(SORSZAM)
50 NEXT SORSZAM
60 FOR SORSZAM=1 TO 10
70   SOUND PITCH HANGOK(SORSZAM)
80 NEXT SORSZAM

Az első sor mindjárt valami új. A NUMERIC utasítással ugyan már találkoztunk, de akkor arra használtuk, hogy a külső változókat jó előre létrehoztuk, nehogy később, ha keresi őket a gép, ne találja. Most is létrehozunk vele valamit, de ez nem egyetlen változó, hanem egy egész változótömb. A tömb egyes elemeire mindig úgy tudunk majd hivatkozni, hogy megmondjuk, melyik tömbből való ás utána zárójelek között azt, hogy mi az elem sorszáma. Jó példa erre a 40-es sor második fele. A HANGOK tömb egy-egy elemét olvassuk itt be, de azt, hogy hányadikat, mindig a SORSZAM nevű változó tartalma mondja majd meg.
Mindig előre meg kell mondanunk, hogy egy tömbnek hány eleme van, pontosabban, hogy a sorszámok mettől meddig terjednek. Éppen erre használjuk a NUMERIC utasítást. Ezzel az utasítással olyan tömböket hozunk létre, melyek elemeiben számokat tudunk tárolni. A NUMERIC utasításban a tömb neve után, zárójelek között mindig meg kell mondanunk azt is, hogy az egyes elemek mettől meddig sorszámozódnak. Persze lehet a sorszám negatív is, csak az a fontos, hogy az első mindig kisebb legyen, mint a második. A

tehát helyes utasítás, egy olyan tömböt hoz létre, melynek 37 eleme van, mindegyikben egy-egy számot lehet tárolni, a sorszámozás pedig -20-tól indul, +16-ig tart, tehát nulladik eleme is van.
Programunkban most már minden világos és érthető, futtassuk hát le!
A program kérdez is, dalol is, csak az a baj, hogy egyetlen dallamot beolvas, azt egyszer lejátssza, és utána rögtön el is felejti. Olyan program kéne, amely egyszerre több dallamot is képes tárolni, és ha akarjuk, bármelyiket lejátsza, akár többször is. Az első gondolatunk az, hogy megadunk egy SELECT CASE utasítást, melynek minden ágában egy-egy tömböt olvasunk be vagy szólaltatunk meg. De hát ahány dallam, annyiszor kellene leírni az egész beolvasást, ami nagyon hosszadalmas volna. Jó lenne egy beolvasó szubrutint készíteni, és mindig csak azt meghívni az egyes CASE ágakban. Igen ám, de honnan tudja a szubrutin, hogy neki melyik tömbbe kell beolvasni? Talán ha megadnánk neki egy változóban, hogy mi a neve a tömbnek! Ez nem rossz ötlet, csak sajnos a gép ilyet nem tud. Tud helyette azonban valami mást!
Adjunk az egyes tömböknek egy-egy sorszámot -valahogy úgy, mintha a tömbökből csinálnánk tömböt- és mindig mondjuk meg, hogy most éppen hányadik tömböt akarjuk használni. Nézzük a programot:

1 PROGRAM "Zenegep.bas"
10 NUMERIC HANGOK(1 TO 10,1 TO 5)
20 NUMERIC TOMBSZAM
30 REM *** BEOLVASO RUTIN ***
40 DEF BEOLV
50   FOR SORSZAM=1 TO 10
60     PRINT "A";TOMBSZAM;"-IK DALLAM";SORSZAM;"-IK HANGJA:";
70     INPUT HANGOK(SORSZAM,TOMBSZAM)
80   NEXT
90 END DEF
100 REM *** DALOLO RUTIN ***
110 DEF DALOLO
120   FOR SORSZAM=1 TO 10
130     SOUND PITCH HANGOK(SORSZAM,TOMBSZAM)
140   NEXT
150 END DEF
160 REM *** FOPROGRAM ***
170 DO
180   PRINT "BEIRAS, VISSZAHALGATAS (b/v)"
190   DO
200     GET BILL$
210   LOOP WHILE BILL$<>"b" AND BILL$<>"v"
220   INPUT PROMPT "HANYADIKAT?:":TOMBSZAM
230   IF BILL$="b" THEN
240     CALL BEOLV
250   ELSE
260     CALL DALOLO
270   END IF
280 LOOP

A program négy részből áll. Az első két sorban változókat hozunk létre. Először egy tömbökből álló tömböt. Az ilyen tömböket úgy kell elképzelni, mintha kis dobozokból - a tömb elemeiből - oszlopokat raknánk össze, majd ezeket egymás mellé téve egy egész tömböt. Ha valamit be akarunk tenni vagy ki akarunk venni az egyik dobozból, mindig meg kell mondanunk, hogy hányadik oszlop hányadik sorában van az a doboz, amelyikre szükségünk van. A NUMERIC utasításban, amikor létrehozzuk a tömböt, meg kell mondanunk, hogy mettől meddig fogjuk számozni az oszlopokat és a sorokat. A második NUMERIC utasítás célja egészen más. Ezt arra használjuk, hogy egy külső változót, a TOMBSZAM-ot létrehozzuk, mert azt több rutin is használni fogja.
Ezután a programban két szubrutint írunk le, ezek mindig a TOMBSZAM változó által meghatározott sorszámú tömböt töltik fel, illetve szólaltatják meg. Ilyenkor valójában az történik, hogy a HANGOK nevű kétdimenziós tömbnek azt az oszlopát használják, amelyiknek az indexe a TOMBSZAM változóban van.
Most két új szót használtunk, amiket természetesen meg is kell magyaráznunk. Nos, a tömböket, aszerint, hogy csak egyetlen sorszám kell egy-egy elemük kiválasztásához, vagy sor- és oszlopszámot is meg kell adni, egy- vagy kétdimenziós tömböknek nevezzük. Ez sokkal egyszerűbb, mint állandóan sorokról és oszlopokról szólni. Ha viszont nincsenek sem sorok, sem oszlopok, csak egy- vagy kétdimenziós tömbök, akkor nem lehetnek sor- és oszlopszámok sem. Éppen ezért azt a számot, amellyel meghatározzuk, hogy melyik elemre van szükségünk, indexnek hívjuk; ha kétdimenziós a tömb, akkor pedig első, illetve második indexnek.
A BEOLV és a DALOLO rutinok egy külső változóban kapják meg a HANGOK tömb második indexét, és az első index szerint mennek végig a tömb egy részletén, feltöltik vagy megszólaltatják az elemeit. Azt, hogy mi legyen a második index - amit itt a TOMBSZAM változó tartalmaz - a főprogram határozza meg. Először eldönti, hogy beolvasni vagy megszólaltatni kell-e hangokat, majd beolvassa a második indexet. Beállítja a TOMBSZAM változót, és ezután hívja meg a BEOLV vagy DALOLO rutint. A rutinok most már tudják, hogy melyik oszlopot, azaz melyik dallamot kell beolvasni vagy eldalolni, hiszen ezt jelöli a TOMBSZAM-ban tárolt index.
Futtassuk le a programot, és írjunk bele néhány dallamot, majd hallgassuk is vissza őket! Vigyázzunk, mert ha visszahallgatáskor olyan dallam számát adjuk meg, amelyik még nem létezik, akkor a gép hibát jelez és a program megáll!
Csak számváltozókból lehet tömböket csinálni? Dehogy! A következő program tíz szót olvas be, és fordított sorrendben írja vissza őket:

10 STRING *10 SZO$(1 TO 10)
20 FOR I=1 TO 10
30 INPUT SZO$(I)
40 NEXT I
50 FOR I=10 TO 1 STEP -1
60 PRINT SZO$(I)
70 NEXT I

A legfontosabb újdonság a STRING utasításban látható csillag és az utána álló szám. Ez mire jó? Nos, ezzel a számmal adhatjuk meg, hogy az ebben a STRING utasításban létrehozott szövegváltozókban legföljebb hány karakter férhet el. A legnagyobb megadható hossz 254 karakter, ennél többet beírva a gép hibát jelez.
És ha nem adjuk meg ezt a számot? Nos, akkor - ugyanúgy, mint azoknál a szövegváltozóknál, amelyeket nem STRING utasítással hozunk létre, hanem maguktól keletkeznek - 132 karakternek megfelelő méretű változó jön létre. Ha egyszerre ilyen sok betű férhet egy változóba, akkor minek ennél kevesebbet megadni? Éppen azért, mert az olyan változó, az olyan doboz, amelybe sok betű fér, maga is sok helyet foglal, tehát ilyen nagy dobozokból jóval kevesebb fér el a gépben. Ha úgyis tudjuk, hány karaktert akarunk betenni, akkor sokkal jobb, ha ezt meg is mondjuk a gépnek. A STRING utasítást ezért sokszor arra is használjuk, hogy nem tömböket, hanem egyszerű változókat hozunk létre, de megadjuk a hosszukat is:

A SZOVEG nevű változóba legfeljebb 50 karakter tehető; ha ennél többet írunk be, akkor az hibát okoz. Futtassuk le a programot!
Adjunk meg tíz, egyenként maximum tíz karakteres szót! Láthatjuk, hogy a gép szépen fordított sorrendben írja ki őket. Most megint indítsuk el a programot! Adjunk meg egy tíz karakternél hosszabb szót is! Figyeljük meg az eredményt! A gép hibát jelez, a program leáll. Tehát a szövegváltozók hosszára mindig ügyelnünk kell.
Alakítsuk át a programot úgy, hogy csak a szavak első öt betűjét írja ki, amikor fordított sorrendben ír! Ehhez a 60-as sort kell módosítanunk:

Hogy is van ez? Arra emlékszünk még - aki pedig nem, az lapozzon vissza, és nézzen utána -: a szövegek egy-egy
betűjét vagy részletét úgy tudtuk megadni, hogy a szöveg vagy a változó mögé zárójelek közé beírtuk, hogy mettől meddig van. szükségünk a szövegre. Ez természetesen szövegtömbökre is igaz, csak arra kell figyelnünk, hogy előbb mindig a tömb indexét - vagy indexeit, ha kétdimenziós tömbről van szó - adjuk meg, és csak azután a szövegkivágást.
Ma is sok új ismeretet szereztünk.

Mármint micsoda függ és mitől? A függvény értéke - hiszen éppen ezért FÜGGVÉNY - függ a bemenete értékétől. Bemenet? Függvényérték? Függvény? De hát mik ezek?
Nos, a függvények az ENTERPRISE talán leghasznosabb segítségei nekünk, akár számolni akarunk, akár szövegeket használni. Közülük kettőt már ismerünk is: a LEN és az INT függvényt. A LEN függvény egy szöveg hosszát adja meg. Úgy használjuk, mintha változó volna, csakhogy a neve után mindig megadunk egy szöveget - vagy szöveges változót -, és a LEN éppen annyi lesz, amennyi a szöveg hossza. Ha például azt írjuk:

akkor az A változóba 7 kerül, mert a LEN függvény bemenetén lévő szöveg hossza hét. Most már azt is tudjuk, hogy a függvények bemenete az a valami, amitől a függvény értéke függ. Azt is láttuk, hogy a függvény bemenetét mindig zárójelek között, a függvény neve után kell megadnunk.
Egy másik ismert függvényünk az INT. Ennek egy szám a bemenete, a függvény értéke pedig a szám egész része lesz. Az INT(15.3876895) tehát 15.
Nagyon sok más függvény is rendelkezésünkre áll, de persze mindegyiket nem tudjuk felsorolni. Ha valakit érdekel, akkor a Referencia Kézikönyvben találja meg őket.
Mi most előszar azt a függvényt nézzük meg, amelyikkel a gépen lévő kis botkormányt tudjuk használni. A botkormány angol neve joystick, ezért a függvény neve JOY. Ennek a függvénynek van egy bemenete is, egy szám. Ez a szám fogja megmondani a gépnek, hogy melyik botkormányt akarjuk használni. Hogyhogy melyiket? Hiszen a gépen csak egy van! No igen, de még további kettőt lehet csatlakoztatni, csak azokat persze külön kell a boltban megvennünk. Ha ilyet veszünk, ne felejtsük el a külső botkormány csatlakoztatására való kis dugót is megvenni. A legjobb, ha abban az üzletben vásárolunk, ahol gépet is vettük, mert ott rögtön meg is mutatják, hogyan kell összerakni.
A JOY függvénynek tehát egy számmal meg kell mondanunk, hogy melyik botkormány érdekel minket. Ha ez a szám 0, akkor a beépített, ha 1, akkor a CONTROL 1, ha pedig 2, akkor a CONTOL 2 feliratú csatlakozóhoz kapcsolt botkormányt jelöljük ki. A függvény értéke egy szám. Ha például jobbra döntjük a botkormányt, akkor a JOY(0) értéke 1 lesz. Ha balra, akkor 2, ha lefelé, akkor 4, ha meg felfelé, akkor 8. A külső botkormányokon külső tűzgomb is szokott lenni, ezt a beépített botkormánynál a szóközbillentyű helyettesíti, Ha ezt lenyomjuk, a JOY értéke 16 lesz. No, írjunk akkor egy programot, amely aszerint énekel magasabban vagy mélyebben, hogy felfelé vagy lefelé állítjuk ,a botkormányt. Íme:

10 LET H=37
20 DO
30   LET A=JOY(0)
40   SELECT CASE A
50   CASE 8
60     LET H=H+l
70   CASE 4
80     LET H=H-1
90   CASE ELSE
100   END SELECT
110   SOUND PITCH H,DURATION 2,LEFT 100,RIGHT 100
120 LOOP

(Figyeljük meg, hogy bár a CASE ELSE ágban nincs semmi, mégis írtunk ilyen ágat, mert különben lettek volna olyan esetek, amikor a gép nem tudta volna eldönteni, hogy melyik ágat válassza. Például, ha a botkormányt jobbra döntjük, akkor a JOY értéke 1, ilyen ág viszont nincs, tehát a gép hibát jelezne.) Indítsuk el a programot! Ha most előre- vagy hátra döntjük a beépített botkormányt, a gép egyre mélyebben vagy magasabban sípol. Ha azonban ferdén döntjük a botkormányt, vagy lenyomva tartjuk a szóközbillentyűt - azaz a tűzgombot -, akkor hiába nyomjuk a botkormányt, a hang nem változik. Miért?
Ilyenkor ugyanis a JOY függvény összeadja a számokat. Ha ferdén jobbra, felfelé döntjük a botkormányt, akkor jobbra(=1) + felfelé(=8), azaz 9 lesz a JOY értéke. Ha balra lefelé döntjük, és a tűzgombot is lenyomjuk, akkor balra(2) + lefelé(4) + tűzgomb(16) =22 lesz a JOY értéke. És ha nem csinálunk semmit? Akkor a JOY függvényérték nullával egyenlő.
Egy dolog azonban még zavar minket. Valahányszor hozzányúlunk a botkormányhoz, a gép mindig egy rövidet pittyeg, ugyanúgy, mint amikor a billentyűket nyomjuk le. Ez a billentyűhang, ezt használja a beépített botkormány is. Ha azonban nincs szükségünk rá, akkor a billentyűhangot ki is tudjuk kapcsolni. Állítsuk le a programot, és üssük le az F7 jelű kék funkcióbillentyűt! Ezzel kiadtuk a

parancsot, amely kikapcsolja a pittyegést. Mostantól fogva a billentyűk sem pittyegnek, egészen addig, amíg a CLICK-et újra be nem kapcsoljuk. Ehhez csak az F7 billentyűt kell újra lenyomnunk, a TOGGLE utasítás ugyanis, oda-vissza kapcsolgatja azt, amit megadtunk mögötte. A billentyűk angol neve key a billentyű hangjáé pedig click. Toggle key click (ejtsd: togl kíj klikk) tehát azt jelenti: "kapcsold át a billentyűhangot". Hallgattassuk el hát a billentyűket, és így is indítsuk el a programot! Ügye sokkal jobb?

Jöjjön most egy újabb függvény, a véletlenszám-generátor. Ez a függvény nem függ semmitől. Akkor mire jó? Nos, igen gyakran éppen azt szeretnénk, hogy a gép egy olyan számot gondoljon, amelyről előre nem tudjuk, hogy pontosan mennyi. A véletlen angolul random, tehát a véletlenszám-generáló függvény neve RND. Az RND függvény értéke mindig egy szám lesz 0 és 1 között, de hogy mennyi, azt sohasem tudhatjuk előre. Egy biztos: nulla és egy között van, lehet nulla, de nem lehet egy. A legkisebb értéke tehát 0, a legnagyobb 0.99999...
Mire jó mindez? Ha például kockadobást játszunk, akkor minden dobásnál egy számot várunk, de előre sosem tudjuk, hogy mennyi lesz az a szám. A következő program véletlen számokat ír ki, valahányszor csak leütünk egy billentyűt:

10 DO
20   PRINT "MEHET?"
30   DO
40     GET BILL$
50   LOOP WHILE BILL$=""
60   PRINT RND
70 LOOP

A 60-as sorban a PRINT az RND függvény értékét írja ki, ami persze mindig más és más, ahányszor csak megkérdezzük. Éppen ettől véletlenszám-generátor a neve. A számok azonban mind nulla és egy között lesznek, pedig a kockán a legnagyobb szám a hatos. Nosza, írjuk át a 60-as sort:

Most már a sorra jövő számok jóval nagyobbak, csak még az a baj, hogy nem egészek. A kockán nincsenek törtszámok, itt meg csupa hosszú törtet kapunk. A megoldás kulcsa a már jel ismert INT függvény. Vegyük a véletlenszámok egész részét, és meg is oldottuk a problémát:

Ez már majdnem olyan, mint a kocka, csak az a baj, hogy néha nullát is dob, viszont sohasem dob hatost. Persze, hiszen az RND értéke nulla és egy között van, és lehet nulla, de soha nem lesz egy. Ha megszorozzuk hattal, akkor egy olyan számot kapunk, ami nulla és hat között van, lehet nulla, de nem lehet hat. Ha most ennek vesszük az egész részét, akkor minden olyan számból, ami nulla és egy közé esik, nulla lesz, minden öt és hat közé esőből pedig öt. Mit lehetne tenni? A megoldás egyszerű, hozzá kell adni az eredményhez mindig egyet. Így a nullából egy lesz, az ötből pedig hat:

Most már tökéletes a program. Az, hogy az RND-t megszorozzuk egy számmal és aztán az egész részét vesszük, olyan gyakori, hogy külön függvény is van rá. A neve ennek is RND, csak ennek van egy bemenete is, ugyanis meg kell adnunk, hogy mennyivel szorozza az RND-t. Az RND(6) tehát pontosan ugyanazokat a számokat adja, mint az INT(RND*6). Használjuk ezt fel és újra írjuk át a programot:

Az új program is tökéletes. Játszani tehát már tudunk a véletlenszámokkal, most próbáljunk meg egy kicsit számolni is! Számtanóra következik, de persze ez is csak játék. A következő program szorozni tanít:

10 CLEAR SCREEN
20 DO
30   LET SZORZO=RND(10)+1
40   LET SZORZANDO=RND(10)+1
50   DO
60     PRINT "SZERINTED MENNYI ";
70     PRINT SZORZO;"*";SZORZANDO
80     INPUT SZORZAT
90     IF SZORZAT=SZORZO*SZORZANDO THEN
100       PRTNT "JOL SZAMOLTAL!"
110       EXIT DO
120     ELSE
130       PRINT "NA PROBALD CSAK UJRA!"
140     END IF
150   LOOP
160 LOOP

(Figyeljük meg, hogy az EXIT DO utasítás mindig csak a legbelső DO ciklusból ugrik ki, tehát a 110-es sornál nem a program végére, hanem a belső DO ciklus vége utáni, azaz a 160-as sorra ugrunk.) Indítsuk el a programot! A program felad nekünk egy szorzást, megkérdezi az eredményt, és persze csak a helyes választ fogadja el. Jó számolást!
Ma két új függvénnyel találkoztunk.

BLACK	- fekete
BLUE	- kék
CYAN	- türkizkék
GREEN	- zöld
MAGENTA	- bíborvörös
RED	- piros
WHITE	- fehér
YELLOW	- sárga