Polecenia BEGIN, END, WRITE, WRITELN

Polecenia, END, WRITE, WRITELN Główna część programu (tzw. blok główny) mieści się w dwóch wyrazach. Początek programu zaznaczamy pisząc, koniec natomiast zaznaczamy słówkiem (koniecznie z kropką). Tak więc program, który nic nie robi, wygląda tak: Program się otwiera słówkiem i kończy słówkiem Taki program jest oczywiście całkowicie bezużyteczny. W takim razie trzeba go trochę wzbogacić. Zacznijmy od polecenia WRITE. Rozkazuje ono napisanie jakiegoś tekstu. Przykład tekstu wygląda tak: WRITE('Jakiś tekst niezbyt mądry'); Znasz już zatem polecenie WRITE. Na co należało by zwrócić uwagę? Między innymi na to, że tekst jak sami pewnie zauważyliście objęty jest w cudzysłowie (pojedyncze) i dodatkowo w nawiasy. Nawiasy zawsze będą istnieć przy poleceniu WRITE. Wszystko zostanie napisane co jest w nawiasie. W takim razie, po co jest cudzysłów? No więc, chodzi o to, że to co jest objęte w cudzysłowie zostanie na pewno wyświetlone na ekranie tak jak zostało to napisane. Dziwnie to brzmi, ale zobaczycie później. Komputer interpretuje to po prostu jako tekst i jeżeli chcemy coś zapisać, to zawsze w cudzysłów. I jeszcze jedno. Na końcu (za nawiasem) widnieje średnik. Zawsze trzeba go stosować na końcu polecenia. Inaczej program wskaże błędy. Potem się dowiesz, przy jakich poleceniach nie trzeba go stosować (między innymi przy poznanych już i END). OK. A teraz mała sztuczka, która pokaże wam dwa istotne fakty. Spójrzcie na poniższy program: write('wyraz numer 1'); write('wyraz numer 2'); write('wyraz numer 3); Widzimy tu program, który kolejno wypisze wyrazy. Po pierwsze - spróbujcie włączyć ten program. Na pewno zastanawiacie się, czemu nic się nie pokazało. To normalne. Komputer jest tak szybki, że zdążył pokazać te wyrazy i poleceniem END zamknął program. Zatem tak naprawdę, program zadziałał prawidłowo, ale my tego nie zauważyliśmy. Aby zobaczyć, co też komputer napisał musimy jakoś przerobić w/w kod, aby program zatrzymał się tuż przed jego końcem. Do tego służy polecenie READLN. Zastosowanie tego zostawmy sobie na później. Jak na razie będziemy stosować to tylko po to, abyśmy zobaczyli to co napisaliśmy. Tzn. zatrzymali program, aż do naciśnięcia jakiegoś klawisza. Zatem nasz program będzie wyglądał tak: write('wyraz numer 1'); write('wyraz numer 2'); write('wyraz numer 3'); I jak? Działa? Jak nie to coś pochrzaniłeś. Program powinien wyświetlić takie coś: "wyraz numer 1wyraz numer 2"...i tak dalej Zastanawiasz się pewnie dlaczego tak beznadziejnie to wygląda. Jest tak dlatego, że samo polecenie WRITE rozkazuje komputerowi napisać coś, a potem tak to zostawić. Następny zatem napis będzie zaraz po poprzednim, bez rozkazu zejścia niżej. W takim razie, powyższy program tak samo działa jak poniższy: write('wyraz numer 1wyraz numer 2wyraz numer3'); Porównajcie sobie dwa powyższe programy, a zobaczycie o co chodzi. Teraz zajmijmy się czymś bardziej skomplikowanym. Załóżmy, że chcemy, aby program obliczył proste dodawanie. Spróbujcie zrobić eksperyment i napiszcie poniższy program: write('2+3'); 1

I co się pokazało? Zamiast żądanego wyniku "5" na pewno napis "2+3", czyż nie? Zadziałało się tak dlatego, gdyż napisane było to w cudzysłowie. Komputer więc nie zwrócił uwagi, że jest to polecenie matematyczne. Po prostu napisał, to co mu kazałeś. Aby komputer wyświetlił napis "5" można albo po prostu napisać write('5'); lub coś takiego: write(2+3);. Czym się to różni? Tym, że nie ma tu cudzysłowu. Teraz już możecie śmiało wyliczać skomplikowane rzeczy. A teraz nieco z innej parafii. Jak zrobić, aby tekst schodził akapit niżej? Nic trudniejszego. Wystarczy użyć polecenia WRITELN. Używa się go tak jak polecenia WRITE. Różni się tylko tym, że schodzi na końcu o jeden wers w dół. Poprawnie napisany program i przejrzyście wyglądający ma postać taką: writeln; writeln; writeln; write('2+3='); write(2+3); Polecenie WRITELN; każe po prostu zejść linię niżej bez jakiegokolwiek tekstu. Następnie komputer napisze "2+3", po czym obliczy, że 2+3 jest 5 i napisze właśnie tą liczbę. Całość wyglądać będzie następująco: "2+3=5". Czyż PASCAL nie jest wspaniały? Kolejna sprawa to, oddzielenia. Do w/w polecenia, gdzie komputer ma wyliczyć, ile jest 2+3, nie musimy używać aż dwóch poleceń WRITE. Wystarczy jedno polecenie, a teksty te należy oddzielić przecinkiem. Zatem poniższe trzy programy, działają tak samo. Przyjrzyjcie się im: write('2+3='); write(2+3); write('2+3=',2+3); 2 write('2+3=5'); Programy te wykonują to samo chociaż ich kod jest inny. Sposobów na wykonanie tak prostego działania jest wiele. Spróbuj sam wynaleźć inny sposób. Zwróćcie uwagę na środkowy program. Został tam użyty przecinek. Można go bez problemu używać. Spójrzcie jak wygląda program bez używania przecinku i po jego użyciu: write(' tekst jakiś '); write(9-2); write(' drugi tekst '); write('10'); Był to prosty program, który wyświetli coś takiego: "tekst jakiś 7 drugi tekst 10". Spójrzcie na powyższy program i porównajcie go z programem poniżej: write(' tekst jakiś ',9-2,' drugi tekst 10'); Czyż nie jest prościej? Na tym właśnie polega stosowanie przecinka. I to byłby koniec tej lekcji. Zapraszam do następnej części. Polecenia READ, READLN, podstawy zmiennych Na poprzedniej lekcji dowiedziałeś się, że program mieści się w znacznikach i Dowiedziałeś się również, że TP można zmusić, aby coś napisał. Na tej lekcji postaramy się go zmusić, aby coś odczytał. Załóżmy, że chcemy, aby komputer wprowadził do pamięci jakieś imię. Chcemy zrobić program, który zapyta jak mamy na imię, po czym wyświetli nam napis: "Cześć (i tu imię). Miłego dnia!!!". Umiesz już napisać taki tekst, ale jak zrobić, żeby komputer wstawił do tekstu imię. Ponadto najpierw trzeba o to imię zapytać, a dopiero potem wstawić. Do tego służą tzw. zmienne. Zmienne możemy oznaczać dowolną literą lub wyrazem. Załóżmy, że zmienną, która będzie reprezentować imię użytkownika, nazwiemy po prostu "imie" (bez polskich liter). W TURBO PASCALU każdą zmienną musimy najpierw zdeklarować zanim jej użyjemy. Zmienne deklarujemy poleceniem "" i robimy to jeszcze przed programem (przed poleceniem

). Po słowie "" wypisujemy wszystkie zmienne. W naszym programie będzie tylko jedna zmienna o nazwie "imie". Po jej napisaniu trzeba jeszcze przypisać jej typ. Na razie poznasz tylko podstawowe typy zmiennych. Jak każdy wie, imię człowieka składa się z liter, więc jest to zwykły ciąg liter. Zmienna nasza będzie zatem typu STRING. Zapamiętajcie tę nazwę. Program, który zadeklaruje zmienną będzie więc wyglądał tak: imie:string; Mamy więc program, który deklaruje zmienną typu STRING (czyli ciąg znaków). Teraz (w głównym bloku programu między i END) musimy coś napisać, aby komputer spytał użytkownika jak ma na imię. Nic prostszego: imie:string; write('jak masz na imię?'); Już jesteśmy o krok dalej. Teraz musimy jakoś zatrzymać program, aby gość siedzący przed komputerem mógł napisać jak ma na imię i nacisnąć ENTER. Nic prostego. Do tego służy polecenie READ. Więc wstawmy to polecenia do naszego programu: imie:string; write('jak masz na imię?'); read(imie); Zwróćcie uwagę na konstrukcję READ. W nawiasie podajemy zmienną, do której ma być zapisana wartość z klawiatury. To znaczy, że to, co użytkownik napisze będzie liczone jako zmienna "imie". Do polecenia w nawiasie nie stosujemy cudzysłowu i pamiętamy, żeby na końcu postawić średnik. Kolejnym krokiem będzie wykombinowanie, aby program napisał ładne powitanie z imieniem. Robimy to następująco: imie:string; write('jak masz na imię?'); read(imie); write('witaj '); write(imie); write('. Życzę miłego dnia!!!'); No to po kolei. Jak już zauważyłeś aby wyświetlić zmienną wystarczy użyć zwykłego polecenia WRITE podając w nawiasie nazwę zmiennej (bez cudzysłowu). Zwróć uwagę na linię "write('. Życzę miłego dnia!!!');" Kropka przed zdaniem jest po to, aby zdanie zakończyło się po imieniu. Jest to zabieg stylistyczny i nie służy do niczego specjalnego. Wszystko razem po włączeniu powinno wyglądać tak: "Witaj Zenek. Życzę miłego dnia!!!". Już wiesz po co ta kropka? Użytkownik nie wprowadzi jej przecież, a komputer nie zna naszego języka. Spróbuj bez kropki, a zobaczysz, co to znaczy estetyka programu. Ale jest to na szczęście niezbyt duży problem. A teraz jeszcze przeróbmy nasz kod programu, aby wyglądał on ładniej i miej miejsca zajmował. Tak, więc dobry kod programu wyglądałby tak: imie:string; 3

writeln; writeln('jak masz na imię?'); writeln; read(imie); write('witaj ',imie,'. Życzę miłego dnia!!!'); W powyższym programie dodatkowo zostało dopisane zamiast WRITE, polecenie WRITELN, gdyż trzeba zauważyć, że nawet pytanie "Jak masz na imię?" musi ładnie wyglądać. Oprócz tego polecenia WRITELN; działają jak separator i nie pozwalają wszystkiego wyświetlić w jednej linii. Pokombinujcie z tymi poleceniami a zobaczycie, na czym to polega. Teraz spróbujmy wzbogacić nasz program. Załóżmy, że użytkownik wpisze jako swoje imię jakieś bzdety (na przykład 150 liter). Program zadziała, ale pomyślcie jak będzie to wyglądać. Trzeba, więc dać ograniczenie, aby użytkownik nie mógł wprowadzić zbyt wielu liter. Nie jest to specjalnie trudne. Wystarczy do typu zmiennej przypisać coś takiego: imie:string[10]; writeln; writeln('jak masz na imię?'); writeln; read(imie); write('witaj ',imie,'. Życzę miłego dnia!!!'); Jak się pewnie już domyśliłeś, zmienna ta będzie ograniczona do dziesięciu liter. Użytkownik będzie mógł wprowadzić więcej liter, ale wyświetlone zostanie tylko dziesięć. A teraz zajmijmy się liczbami. Zbudujmy prosty kalkulator, który będzie dodawał do siebie dwie liczby. Program najpierw spyta, jakie mają to być liczby, a potem je doda. Sama zasada jest podobna jak w przykładach powyżej, z tym, że zmienna będzie innego typu. Poza tym będziemy potrzebować nie jednej a dwóch zmiennych. Użytkownik przecież ma wprowadzić dwie liczby. Istnieją różne typy zmiennych oznaczające liczby. Dla początkujących użyjemy zmiennej typu LONGINT. Nie będę tłumaczył na czym ona polega, ale powiem, że mieści w sobie liczby od kilku miliardów albo nawet i więcej do minus kilku miliardów albo i nawet mniej :))) Powinna więc zadowolić każdego. Dodam jeszcze, że zapamiętuje tylko liczby całkowite, więc ułamki zostawmy sobie, na kiedy indziej. Zatem zacznijmy robić program. Poniżej znajduje się kod, który bez problemu powinieneś rozumieć: liczba1:longint; liczba2:longint; writeln; writeln('podaj pierwszą liczbę'); read(liczba1); writeln('podaj drugą liczbę'); read(liczba2); write('ich suma wynosi: ',liczba1+liczba2); Zrozumiałe? Jeżeli nie to nie wiem coś ty za jeden. Oczywiście liczby można nie tylko dodawać, ale i dzielić, odejmować, mnożyć, podnosić do kwadratu itp. ale o tym w innej części kursu. Zaraz pod słówkiem "" widzimy dwie zmienne: liczba1 i liczba2. Oba są typu LONGINT, czyli tego samego typu. Po co więc pisać dwa razy tą samą rzecz. Poprawiony program będzie więc wyglądał tak: 4

liczba1,liczba2:longint; writeln; writeln('podaj pierwszą liczbę'); read(liczba1); writeln('podaj drugą liczbę'); read(liczba2); write('ich suma wynosi: ',liczba1+liczba2); Widzicie jakie to proste? Zatem zmienne tego samego typu można w ten właśnie sposób oddzielić przecinkami (bez spacji). Niby to nic takiego, ale wyobraźcie sobie, że mamy 50 takich zmiennych. Zamiast do wszystkich dopisywać typ, wystarczy wypisać je po przecinku. Teraz poznamy jeszcze jedną sztuczkę. Załóżmy, że chcemy, aby jakaś zmienna miała już jakąś wartość. Na przykład do powyższego programu. Niech użytkownik nie wprowadza żadnej liczby, a program ma już zapisane w sobie ich wartości. Do tego służy instrukcja przypisania. Stosuje ją się bardzo prosto. Np. liczba1:=71; W ten sposób przypisaliśmy liczbę 71 do zmiennej "liczba1". Zwróćcie uwagę na znak przypisania. Jest to dwukropek i znak równości. Po tym wszystkim znajduje się oczywiście średnik. Zatem poniższy program nie zrobi nic innego, jak napisze liczbę 10: liczba1,liczba2:longint; liczba1:=2; liczba2:=8; write(liczba1+liczba2); Mam nadzieję, że wszyscy rozumieją, o co chodzi! Teraz nieco skomplikuję sprawę. Załóżmy, że chcemy, aby jedna zmienna była zależna od drugiej. Zróbmy pogram, który pyta użytkownika o jakąś liczbę i wyświetla ją pomnożoną przez 2. Można to zrobić w różny sposób. Spójrzcie na poniższy program. Jest to jeden ze sposobów. liczba:longint; writeln; writeln('podaj jakąś liczbę'); read(liczba); write('liczba ta pomnożona przez 2 wynosi ',liczba*2); Był to prosty sposób na pokazanie mnożenia (dokonujemy gwiazdką jakby co). Użytkownik wprowadził jakąś liczbę, a program ją wyświetlił, ale pomnożoną przez 2. A teraz spójrzcie na poniższy przykład. Działa on tak samo jak poprzedni, z tym, że jest inaczej zbudowany: liczba,iloczyn:longint; writeln; writeln('podaj jakąś liczbę'); read(liczba); iloczyn:=liczba*2; write('liczba ta pomnożona przez 2 wynosi ',iloczyn); 5

Był to nic innego jak przykład, że instrukcje przypisania można stosować nie tylko do liczb, ale i innych zmiennych, co daje nam już bardzo duże możliwości. Można przecież wykonać takie instrukcje przypisania jak: "liczba:=iloczyn*(iloczyn-1)-24" itp. O tym wszystkim dowiecie się później. Na razie najważniejsze jest, że wiecie, co to jest instrukcja przypisania i jak z niej korzystać. Teraz została jeszcze jedna sprawa. Jak przypisać do zmiennej typu STRING zwykły tekst. Nie jest to trudne. Wystarczy zastosować instrukcję przypisania, a samą wartość podać w cudzysłowie. Np: imie:='franek'; Na koniec do omówienia zostało jeszcze polecenie READLN. Oprócz tego, że używamy READLN jak dotąd do przerywania programu, służy innym celom. Cele te jednak wykraczają jak na razie w wasz zakres wiedzy, więc może innym razem. Zapraszam więc do następnej części kursu. Podstawowe polecenia modułu CRT Wypadałoby tu zacząć od wyjaśnienia słowa "moduł". Otóż w Pascalu jest pełno poleceń, a wszystkie one nie są zasługą samego Pascala. Czasami do Pascala trzeba dorzucić jakiś moduł, aby one zadziałamy. Moduł CRT jest już w Pascalu wbudowany. Jest często stosowany w najróżniejszych programach i myślę, że ma użyteczne funkcję. Wszystkie moduły (nie tylko CRT) trzeba najpierw zdeklarować zanim się ich użyje, (czyli zanim użyje się ich poleceń). Zmienne deklarowaliśmy poleceniem "", natomiast moduły deklarować będziemy za pomocą słówka "USES". Wpisujemy to jeszcze przed "" na samym początku programu. Sam moduł tak właściwie niczym nie jest - daje tylko możliwość stosowania kilku nowych poleceń. Właśnie te kilka poleceń poznasz na tej lekcji. Zatem, najprostszy program, który ma moduł CRT, wygląda tak: W ten właśnie sposób deklarujemy moduł CRT. Zwróć uwagę, że po słówku "USES" nie ma żadnego znaku. Na końcu linii pamiętamy oczywiście o średniku. Tak zdeklarowany moduł możemy wykorzystać. Najważniejsze z jego poleceń to: 1. CLRSCR; To skomplikowane polecenie jest dość użyteczne. Po prostu czyści ekran z jakiegokolwiek tekstu. Każdy tekst znajdujący się po tym poleceniu będzie wyświetlany na czystym ekranie (żadnych innych rzeczy tam nie będzie jak dotychczas). Spróbuj napisać następujące programy i zobacz sam różnice: write('jakiś tekst'); write('jakiś tekst'); Najpierw spróbuj włączyć pierwszy program, a potem drugi. Widzisz różnice? 6

2. DELAY(x); Polecenie to daje możliwość wstrzymania programu na określoną ilość czasu (przydaje się zwłaszcza w programach demonstracyjnych). Za "x" wstawiamy czas, na jaki program ma być wstrzymany (1000 to jedna sekunda). Przykład programu z zastosowaniem polecenia DELAY znajduje się poniżej: write('jakiś tekst numer 1'); delay(3500); write('jakiś tekst numer 2'); Powyższy program napisze pierwsze zdanie i po upływie trzech i pół sekundy - drugie zdanie. Nie jest to chyba zbyt skomplikowane. 3. SOUND(x); Przyszedł najwyższy czas, aby zademonstrować dźwięk. Nie będzie to dźwięk wydawany z głośników, a z tegoż urządzona, co się znajduje w środku komputera. Za "x" wstawiamy tzw. częstotliwość, tak samo jak w przypadku "DELAY". Samo polecenie "SOUND" nam nic nie da, gdyż komputer szybko odegra ten dźwięk i pojedzie dalej. Zaraz po poleceniu "SOUND" najlepiej stosować polecenie "DELAY", które zatrzyma dźwięk na określoną ilość czasu. W ten sposób możemy już grać proste melodyjki. Z osobistych doświadczeń wiem, że niektórzy nie wytrzymują dźwięku o częstotliwości 2200. Radzę popróbować. Ale najpierw przeczytajcie jeszcze poniższe polecenie. 4. NOSOUND; Służy do przerywania jakiegokolwiek dźwięku wydobywającego się ze spikera. Na końcu programu radzę to stosować, bo może okazać się, że dźwięk nie ustanie. W celu przećwiczenia tych funkcji radzę napisać następujący program: sound(2200); delay(5000); nosound; Program ten przez pięć sekund da nam bardzo denerwujący dźwięk. 5. GOTOxy(współrzędne); Załóżmy, że chcemy aby nasz tekst zaczynał się mniej więcej w środku ekranu. Stosowanie pięćdziesiąt razy polecenia "WRITELN;" a potem odmierzenie ilości spacji byłoby nieco niewygodne. Dlatego właśnie 7

powstało polecenie "GOTOxy". Polecenie to rozkazuje przejście kursora do danej pozycji. Aby wszystko ładnie wyglądało, warto by było przedtem użyć "CLRSCR". Po poleceniu "GOTOxy" podajemy w nawiasach współrzędne. Pierwsza współrzędna jest odległością w poziomie (ilość kratek od lewej strony ekranu), druga zaś jest odległością w pionie (ilość kratek od górnej części ekranu). Możemy, więc napisać poniższy program. gotoxy(30,15); write('jakiś tekst'); Powyższy tekst zaczynać się będzie w trzydziestej kolumnie i piętnastym wierszu. A teraz spróbujcie użyć ten sam program, ale bez polecenia "CLRSCR", a zobaczycie jak beznadziejnie będzie on wyglądał. 6. HALT; W zasadzie, to polecenie "HALT" nie jest w składzie modułu CRT, i działa również bez niego, jednak chciałem go teraz opisać. Nie będzie to zbyt zawiłe, gdyż polecenie to robi nic innego, jak wychodzi z programu. Jak tylko program napotka to polecenie na swojej drodze, od razu przerywa program i natychmiast z niego wychodzi. Nie muszę chyba więcej wyjaśniać. Jest oczywiście jeszcze wiele innych poleceń ze składni modułu CRT, ale staram się, aby wszystkie te polecenia były przyswajane powoli. Na razie powinieneś poćwiczyć z tym, co już umiesz. Dam ci małe zadanie domowe. Zrób program, który napisze najpierw kilka zdań, potem obliczy iloczyn dowolnych dwóch liczb wprowadzanych przez użytkownika, a na końcu wyświetli na środku ekranu napis "DOWIDZENIA!!!" przez pięć sekund. Niezłe zadanko, co? Ty już to umiesz!!! Instrukcja warunkowa IF..THEN..ELSE oraz operatory Mam nadzieję, że ukończyłeś już lekturę wszystkich poprzednich części kursu zanim zabrałeś się za bieżący. Wkraczamy, bowiem w coraz to bardziej trudne progi i niestety twoja koncentracja będzie musiała się bardziej wysilić. Ale dosyć już tego klepania, czas zaczynać. Załóżmy, że chcemy stworzyć program, który będzie pytał użytkownika o jakąś liczbę. Jest to oczywiście dla ciebie bułka z masłem, ale spróbujmy ten program rozbudować. Program ma pokazywać, czy liczba, którą wprowadził użytkownik jest większa od stu, mniejsza lub równa. Załóżmy, że użytkownik wprowadza liczbę 230. Program ma napisać, że liczba jest większa od stu. Jak użytkownik wprowadzi np. liczbę 17, to program ma napisać, że liczba jest mniejsza od stu. No i wreszcie, jak użytkownik wprowadzi 100, program napisze, że liczba, którą wprowadził użytkownik jest równa 100. Do tych zadań użyjemy jeszcze ci nieznanej instrukcji warunkowej. Zanim jednak się nią zajmiemy, napiszmy część programu, który może wyglądać tak: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); 8

Powyższy program nie powinien was dziwić - powinniście już go rozumieć. Teraz trzeba coś zrobić, aby program wykonał jedną z trzech opcji. Ma napisać, że liczba jest większa od stu albo mniejsza od stu albo równa. No to zaczynajmy. Zajmijmy się najpierw przypadkiem, gdzie liczba jest równa 100. Program będzie więc wyglądał tak: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba=100 THEN writeln('podałeś liczbę równą 100'); A teraz wyjaśnienie. Po słowie "IF" znajduje się zawsze warunek. W tym wypadku warunkiem jest przyrównanie liczby do stu. Jeżeli liczba jest równa 100, to program wykonuje to, co znajduje się po słowie "THEN". Jeżeli program stwierdzi, że nie jest to liczba 100, omija ten warunek całkowicie go ignorując. Rozumiecie? Teraz trzeba jeszcze przewidzieć dwa inne przypadki. Ktoś przecież może napisać liczbę mniejszą do sto albo większą. Cały program będzie więc wyglądał tak: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba=100 THEN writeln('podałeś liczbę równą 100'); IF liczba>100 THEN writeln('podałeś liczbę większą od 100'); IF liczba<100 THEN writeln('podałeś liczbę mniejszą od 100');> W ten prosty sposób rozważyliśmy wszystkie możliwe przypadki. Logiczne jest że zawsze wystąpi jeden z tych trzech przypadków (bo każda liczba jest albo równa 100 albo mniejsza albo większa - innej możliwości nie ma). Logiczne także jest, że nie mogą się włączyć np. dwa warunki na raz. Przecież nie istnieje taka liczba, co by np. była jednocześnie większa od stu i mniejsza. Mam nadzieję, że to rozumiecie. Jak dotąd poznaliście trzy podstawowe operatory (równe, większe i mniejsze). Wszystkie podstawowe zebrane są poniżej: = równe > większe niż < mniejsze niż >= większe lub równe <= mniejsze lub równe <> różne I wszystko jasne. A teraz kolej na następny "kwiatek" w TURBO PASCALU. Załóżmy, że chcemy zrobić instrukcję warunkową, co by sprawdzała, czy liczba, którą podał użytkownik równa jest 1000. Inne 9

przypadki nas nie interesują, i gdy liczba nie jest równa tysiąc, następuje koniec programu. Można to zrobić metodą znaną, czyli tak: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba=1000 THEN writeln('brawo! Podałeś liczbę tysiąc!'); IF liczba>1000 THEN halt; IF liczba<1000 THEN halt;> Widzimy bardzo prosty program, który zaraz się kończy, gdy liczba, którą wprowadził użytkownik nie jest równa 1000. Są tam zastosowane dwie dodatkowe instrukcje,(gdy jest większa od 1000 lub mniejsza). Można to zrobić jeszcze inaczej: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba=1000 THEN writeln('brawo! Podałeś liczbę tysiąc!'); IF liczba<>1000 THEN halt; Teraz program sprawdza, czy liczba jest różna od tysiąc a nie czy jest większa czy mniejsza. W sumie na jedno wychodzi, ale kod programu mniej zajmuje. Teraz poznasz trzeci sposób na wykonanie takiego programu. Służy do tego polecenie, "ELSE", który patrzy, czy użytkownik wprowadził inną liczbą niż przewidzianą. Spójrzcie na poniższy program: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba=1000 THEN writeln('brawo! Podałeś liczbę tysiąc!') ELSE halt; Polecenie ELSE zadziała, jeżeli użytkownik wprowadził liczbę, która nie była przewidziana przez wcześniejsze polecenie lub polecenia "IF". Zwróćcie uwagę na bardzo ważny szczegół. PRZED 10

POLECENIEM ELSE NIE MA ŚREDNIKA. Jest to bardzo ważne i nawet dobrzy programiści o tym czasami zapominają. Zastosowanie "ELSE" lepiej ukazuje ten program: liczba:longint; writeln('wprowadź jakąś liczbę od 1 do 5'); read(liczba); IF liczba=1 THEN writeln('brawo! Podałeś liczbę 1'); IF liczba=2 THEN writeln('brawo! Podałeś liczbę 2'); IF liczba=3 THEN writeln('brawo! Podałeś liczbę 3') ELSE writeln('na pewno nie podałeś liczby 1, 2 lub 3'); Przypominam jeszcze raz na brak średnika przed "ELSE" co doskonale ukazuje powyższy program. Teraz, gdy już znasz instrukcję warunkową, można przejść do bardziej skomplikowanych poleceń. Załóżmy, że program ma pytać użytkownika o dwie liczby. Najpierw program każe podać pierwszą liczbę. Potem program każe podać liczbę, która podzielona przez dwa daje liczbę pierwszą (czyli pierwsza liczba pomnożona przez dwa daje liczbę drugą). Będzie to takie zadanie dla użytkownika. Do tego musimy zastosować trochę bardziej skomplikowane obliczenia. Może tym razem od razu pokaże wam jak będzie wyglądał cały program (wierze w waszą inteligencję). liczba1,liczba2:longint; writeln('wprowadź jakąś liczbę'); read(liczba1); writeln('a teraz podaj ile to jest: pierwsza liczba pomnożona przez dwa?'); read(liczba2); IF liczba1*2=liczba2 THEN writeln('brawo! Umiesz mnożyć!!!'); IF liczba1*2<>liczba2 THEN writeln('co ty? Mnożyć nie umiesz?'); W programie tym zastosowaliśmy trochę matematyki. Program sprawdza, czy pierwsza liczba pomnożona przez dwa równa się liczbie drugiej. Jeżeli tak to program wypisuje odpowiedni tekst. Jeżeli nie to ochrzania użytkownika o nieumiejętność mnożenia. Niezłe co nie? Przyszła kolej na następną ważną rzecz. Jak pewnie zauważyłeś, wszystkie poprzednie programy z instrukcją warunkową wykorzystywały tylko jedno polecenie po słówku "THEN". A co jeśli trzeba wykonać kilka rzeczy, jeżeli dany warunek zostanie spełniony. Niech na przykład użytkownik wprowadzi jakąś liczbę. Program ma się wyłączyć, jeżeli ta liczba jest większa od 50. Jeżeli liczba jest mniejsza, to program ma napisać coś i zagrać melodię. Widzimy, że program wykonać ma dwa polecenie. Nie można tego zrobić tak: 11

liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba>50 THEN halt; IF liczba<=50 THEN writeln('brawo! Liczba jest mniejsza lub równa 50'); sound(2200); delay(3000); Jeżeli program ma grać, gdy liczba jest mniejsza lub równa 50, to powyższy program jest BŁĘDNY. Program nie wie, czy polecenie "SOUND" i następne należą do instrukcji warunkowej, czy są po prostu dalej. Prawidłowy program wyglądać będzie tak: liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba>50 THEN halt; IF liczba<=50 THEN writeln('brawo! Liczba jest mniejsza lub równa 50'); sound(2200); delay(3000); END; W w/w programie, polecenia, które mają być wykonane gdy warunek zostanie spełniony są objęte w dodatkowe bloki, czyli między słówka "" i "END;" (koniecznie END ze średnikiem). Przy bardziej skomplikowanych poleceniach trzeba uważać by się nie pogubić w tych wszystkich słówkach. Trzeba pamiętać, że każde "" trzeba zamknąć "END". Zatem ilość słówek "" jest równa ilości słówek "END". Widzicie, jakie to proste. Żeby jeszcze wam ułatwić sprawę, pokaże wam coś takiego jak wcięcia. Nie są to żadne polecenia, a sposób pisania programu, aby się w nim nie pogubić. Porównajcie powyższy program z poniższym. liczba:longint; writeln('wprowadź jakąś liczbę'); read(liczba); IF liczba>50 THEN halt; IF liczba<=50 THEN writeln('brawo! Liczba jest mniejsza lub równa 50'); sound(2200); delay(3000); 12

END; Osobiście radzę stosować wcięcia, gdyż nie macie nawet pojęcia jak może to ułatwić tworzenie programu. Kiedy już przebrnęliśmy przez podstawowe wieści, czas wreszcie zająć się "prawdziwymi" operatorami. Służą one do grupowania warunków. Załóżmy, że użytkownik ma wprowadzić liczbę od 1 do 10. Program ma pokazać, czy liczba, którą wprowadził użytkownik jest parzysta czy nie. Parzyste liczby z tego przedziału to 2, 4, 6, 8 i 10. Nieparzyste to: 1, 3, 5, 7, 9. Gdybyśmy liczyli na piechotę, program wyglądałby tak: liczba:longint writeln('wprowadź jakąś liczbę od 1 do 10'); read(liczba); IF liczba=2 THEN writeln('wprowdziłeś liczbę pażystą'); IF liczba=4 THEN writeln('wprowdziłeś liczbę pażystą'); IF liczba=6 THEN writeln('wprowdziłeś liczbę pażystą'); IF liczba=8 THEN writeln('wprowdziłeś liczbę pażystą'); IF liczba=10 THEN writeln('wprowdziłeś liczbę pażystą'); IF liczba=1 THEN writeln('wprowdziłeś liczbę niepażystą'); IF liczba=3 THEN writeln('wprowdziłeś liczbę niepażystą'); IF liczba=5 THEN writeln('wprowdziłeś liczbę niepażystą'); IF liczba=7 THEN writeln('wprowdziłeś liczbę niepażystą'); IF liczba=9 THEN writeln('wprowdziłeś liczbę niepażystą'); Trochę kosmicznie to wygląda, ale jest zrozumiałe. Program można by skrócić za pomocą operatorów. Pierwszym, jaki poznasz jest operator "OR" (alternatywa). Odpowiada polskiemu wyrazowi "lub". Doskonale nadaje się do tego programu. Spójrz na poniższy kod: liczba:longint writeln('wprowadź jakąś liczbę od 1 do 10'); read(liczba); IF (liczba=2) OR (liczba=4) OR (liczba=6) OR (liczba=8) OR (liczba=10) THEN writeln('wprowdziłeś liczbę pażystą'); IF (liczba=1) OR (liczba=3) OR (liczba=5) OR (liczba=7) OR (liczba=9) THEN writeln('wprowdziłeś liczbę niepażystą'); Program poprzedni miał taką formę:, "jeżeli liczba=2 to..., jeżeli liczba=4 to..., jeżeli liczba=6 to..." i tak dalej. Takiej formy się nie stosuje (jest poprawna, ale niewygodna). Program z operatorem ma taką postać:, "jeżeli liczba=2 lub liczba=4 lub liczb=6 lub liczba=8 lub liczba=10 to..." Chyba każdy widzi, że stosowanie operatorów jest łatwe. Pamiętać trzeba jeszcze, że jeżeli stosujemy jakikolwiek operator, to warunki muszą 13

być w NAWIASACH. Doskonale to widać na powyższym programie. To był operator alternatywy ("OR"). Teraz czas poznać operator koniunkcji ("AND"). W powyższym programie napis się wyświetlał, gdy co najmniej jeden z warunków został spełniony. Gdybyśmy zastosowali tam "AND", każdy warunek musiałby być spełniony. Odpowiada to polskiemu wyrazowi "i". Wszystko się zaraz wyjaśni na podstawie programu. Załóżmy, że chcemy zrobić program, który sprawdza, czy liczba, którą wprowadził użytkownik jest między 5 a 10. Jeżeli tak, to ukaże się napis. Jeżeli nie - program się wyłączy. Zatem: liczba:longint writeln('wprowadź jakąś liczbę'); read(liczba); IF (liczba>5) AND (liczba<10) THEN writeln('liczba ta jest w przedziale od 5 do 10');> IF (liczba>=10) OR (liczba<=5) THEN halt; Program ten wyłączy się, gdy liczba będzie większa lub równa 10 lub mniejsza/równa 5. Jeżeli jest mniejsza od dziesięciu i jednocześnie większa od 5, napis się ukaże. Poznałeś, zatem już 2 operatory (były one najważniejsze). Zajmijmy się teraz operatorem "NOT". Jest to logiczne zaprzeczenie, czyli negacja. Nie jest on zbyt szeroko stosowany w programach, mimo to warto zwrócić na niego uwagę. Operator "NOT" po prostu neguje warunek. Pokaże wam to na przykładzie. IF liczba<>10 THEN writeln('liczba ta na pewno nie jest równa 10'); Powyższy program bada, czy liczba jest różna od 10. Jeżeli tak, to napis się ukaże. To samo można zrobić za pomocą operatora "NOT" w następujący sposób: IF NOT liczba=10 THEN writeln('liczba ta na pewno nie jest równa 10'); Czyli jeżeli liczba NIE równa się 10, to... itd. Mam nadzieję, że jest to zrozumiałe. Do opisania został jeszcze jeden operator, tzw. XOR, czyli alternatywa wykluczająca. Nie musicie się go uczyć, gdyż bardzo rzadko się go stosuje, ale jeśli ktoś czuje się na siłach, zaczynajmy. Operator XOR odpowiada wyrazowi "albo" (nie mylić z "lub"). Cała instrukcja zostaje spełniona, gdy jedno z dwóch warunków jest spełnione. Natomiast, gdy oba warunki są spełnione lub niespełnione - instrukcja się nie wykonuje (albo to albo to). To był właśnie operator XOR. Omówimy go jeszcze za moment. Teraz pokaże wam, jak można "sortować" operatory, tzn. nadawać im priorytety. Wystarczy użyć zwykłych nawiasów. Jeżeli chcemy wszystko objąć w jeszcze jeden nawias, śmiało go dajemy (zwykły, a nie żaden kwadratowy - taki, w jaki objęty jest ten tekst). Przykład zastosowania nawiasów znajduje się poniżej: IF ((liczba1=10) AND (liczba2=20)) OR ((liczba1=5) AND (liczba2=15)) THEN "coś tam"... W powyższym fragmencie instrukcja po słowie "THEN" zostanie spełnione w dwóch przypadkach. Gdy liczba1=10 i liczba2=20 Gdy liczba1=5 i liczba2=15 Rozumiecie? Jak tak to dobrze. 14

To teraz jeszcze pokaże wam, jak działa XOR. Oba poniższe warunki znaczą to samo (tego rozumieć nie musicie, ale dobrze by było gdybyście chociaż zerknęli). IF liczba1=10 XOR liczba2=20 THEN "coś tam"... IF ((liczba1=10) AND (liczba2<>20)) OR ((liczba1<>10) AND (liczba2=20)) THEN "coś tam"... To był właśnie przykład na "XOR" (wcale nie musieliście tego zrozumieć). Dla podsumowania, przypomnijmy sobie wszystkie operatory. OR - alternatywa - instrukcja się wykona, gdy co najmniej jeden z warunków jest spełniony ("lub"). AND - koniukcja - instrukcja się wykona, gdy wszystkie warunki są spełnione ("i"). NOT - negacja - zaprzeczenie warunku ("nie"). XOR - alternatywa wykluczająca - instrukcja się wykona tylko wtedy, gdy jeden z dwóch warunków jest spełniony ("albo"). W ten prosty sposób skończyliśmy piątą lekcję. Zapraszam do części szóstej. Działania matematyczne Moim zdaniem dysponujesz już sporą wiedzą, aby wkroczyć w następny poziom zaawansowania. Na poprzednich lekcjach poznałeś tylko znikomą część działań matematycznych, takich jak plus (+) czy minus (-). W tej lekcji postaram się objaśnić wam jak najwięcej takich działań. Stosuje się je tak jak inne. No to zaczynajmy. + Dodawanie. Np. 3+2=5, 8+10=18, 6+2=8. - Odejmowanie. Np. 3-2=1, 8-10=-2, 6-2=4. * Mnożenie. Np. 3*2=6, 8*10=80, 6*2=12. / Dzielenie. Np. 10/5=2, 6/2=3, 2/5=2,5. To były podstawowe działania. Są jeszcze inne. Oto niektóre z nich: div Całkowita część z dzielenia. Np. 10 div 3=3, 6 div 4=1, 10 div 4=2. mod Reszta z dzielenia. Np. 5 mod 2=5, 10 mod 3=3333..., 1 mod 2=5. sqrt Pierwiastek. Np. sqrt(9)=3, sqrt(64)=8, sqrt(16)=4 sqr Kwadrat (potęga druga). Np. sqr(2)=4, sqr(3)=9, sqr(10)=100. 15

abs Wartość bezwzględna. Np. abs(3)=3, abs(-3)=3, abs(-230)=230. Teorię mamy za sobą. Weźmy się za praktykę. Napiszmy program, który będzie podawał kwadrat, z liczby podanej przez użytkownika. liczba:longint; writeln('podaj jakąś liczbę'); read(liczba); writeln('kwadrat z liczby ',liczba,' wynosi ',sqr(liczba)); Może wydawać ci się to trochę skomplikowane, ale po krótkiej analizie i kilku własnych programach, wszystko zrozumiesz. Teraz zróbmy program, który będzie pytał użytkownika o dwie liczby. Po podaniu liczb, program ma mówić, czy druga liczba jest dzielnikiem pierwszej. Np. gdy użytkownik poda liczby 10 i 2, program ma napisać, że 2 jest dzielnikiem 10. No to do roboty: liczba1,liczba2:longint; writeln('podaj pierwszą liczbę'); read(liczba1); writeln('podaj drugą liczbę'); read(liczba2); IF liczba1 mod liczba2=0 THEN writeln(' Liczba ',liczba2,' jest dzielnikiem liczby ',liczba1); IF liczba1 mod liczba2<>0 THEN writeln(' Liczba ',liczba2,' nie jest dzielnikiem liczby ',liczba1); Powyższy program sprawdza, czy reszta z dzielenia jednej liczby przez drugą jest równa zero czy też nie. Można to było zrobić jeszcze w inny sposób: liczba1,liczba2:longint; writeln('podaj pierwszą liczbę'); read(liczba1); writeln('podaj drugą liczbę'); read(liczba2); IF liczba1 mod liczba2=0 THEN writeln(' Liczba ',liczba2,' jest dzielnikiem liczby ',liczba1) ELSE writeln('liczba ',liczba2,' nie jest dzielnikiem liczby ',liczba1); 16

Zamiast całej instrukcji warunkowej użyłem polecenia "ELSE". Tego typu programy są bardzo ważne i musisz je znać. Radzę je dobrze poćwiczyć, zanim dojdziesz do następnej lekcji, gdyż będą one szeroko stosowane. Praca domowa: zrób program, który pyta użytkownika o 3 liczby, a następnie sprawdza, czy liczba trzecia jest sumą dwóch pierwszych liczb. Jeżeli jest, to program ma wyświetlić dowolny komunikat i wydać jakiś dźwięk. Jeżeli nie jest - program ma się wyłączyć. POWODZENIA! Pętle REPEAT..UNTIL oraz WHILE..DO Nareszcie doszliśmy do tzw. pętli. Pętle są tak częste w programach, że nie sposób bez nich żyć. Jest ich kilka rodzajów. W tej części poznacie dwa z nich, bardzo zresztą podobne do siebie. Może zacznijmy od definicji, czym jest pętla w programie. Otóż przydaje się, gdy chcemy jakąś czynność (polecenie) wykonać określoną ilość razy. Nie będziemy oczywiście stosować metody "kopiuj / wklej" i tak np. 50 razy, gdyż jest to nieładne i czasochłonne i w ogóle tak się nie robi. Do tego są właśnie pętle. Zapętlają określony fragment kodu programu i rozkazują go wykonywać dopóki jakiś warunek zostanie spełniony. Pierwszy rodzaj pętli składa się z dwóch słów: "REPEAT" (powtarzaj) oraz "UNTIL" (dopóki). Zaraz powinno wam się wszystko w głowach rozjaśnić. Załóżmy, że chcemy, aby program napisał coś takiego: "Witam cię po raz 1, witam cię po raz 2, witam cię po raz 3, witam cię po raz 4..." i tak dalej, aż do załóżmy 100. Nie będziemy przecież pisać 100 razy tej samej kwestii metodą kopiuj/wklej. Do tego użyjemy pętli. Wprowadźmy najpierw samą pętle, a potem wyjaśnijmy. REPEAT (tu będą polecenia) UNTIL (warunek) Wszystko, co będzie między znacznikami "REPEAT" i "UNTIL" będzie się w kółko powtarzało, aż warunek będzie spełniony. My chcemy, aby program wypisał 100 razy ten sam tekst z ciągle zwiększającą się liczbą o jeden. Zatem do dzieła: licznik:longint; licznik:=0; REPEAT licznik:=licznik+1; writeln('witam cię po raz ',licznik); UNTIL licznik=100 17

A teraz wyjaśnienie. Na początku zdeklarowaliśmy zmienną o nazwie "licznik". Zaraz po "" czyścimy ładnie ekran i zerujemy licznik (przypisujemy wartość 0). Zaczynamy pętle. Od tego momentu, zatem, wszystko będzie powtarzane. Licznik przyjmuje wartość "licznik+1". Licznik miał wartość 0, zatem 0+1 jest jeden. Licznik, więc ma wartość 1. Program rozkazuje napisać tekst i wstawić wartość licznika. Pętla się kończy. Program sprawdza, czy warunek jest spełniony. Aby pętla się zakończyła, wartość licznika musi wynosić 100. Nasz licznik aktualnie ma wartość 1. Zatem warunek nie został spełniony - program wraca do słowa "REPEAT". I znowu - licznik zwiększa swoją wartość o 1, czyli ma już 2. Rozkazuje napisać tekst i wstawić licznik. Sprawdza warunek - warunek nie jest spełniony - i znowu "REPEAT" Licznik podnosi swoją wartość do 3 i tak dalej. Pętla się zakończy, aż wartość licznika będzie równa 100. Gdy pętla się zakończy, program wykonuje dalsze instrukcje (w tym wypadku jest to "READLN"). I tak oto wyjaśniłem wam działanie pętli. Jednakże jeden program to trochę mało, aby was czegoś nauczyć. Zróbmy teraz inny. Zróbmy program, który będzie kazał napisać użytkownikowi hasło. Hasło będzie cyfrowe, załóżmy, że liczba 123. Użytkownik nie będzie mógł wyjść z programu, aż napisze poprawne hasło. No to do dzieła: haslo:longint; REPEAT writeln('podaj hasło!'); read(haslo); UNTIL haslo=123; writeln('brawo! Odgadłeś hasło!'); Jak widzimy, pętla ta nie zakończy się, gdy ktoś poda nieprawidłowe hasło. I tak za każdym razem. Napis "Brawo..." wyświetli się tylko wtedy, gdy ktoś poda prawidłowe hasło. Spróbujmy teraz zrobić program z innej parafii. Naszym celem jest napisanie prostego alarmu. Program ma wytwarzać dźwięk podobny do alarmu. Dodatkowo, tak napiszemy ten program, aby alarm zapiał 10 razy. Do dzieła: ilosc,ton:longint; ilosc:=0; ton:=0; REPEAT ton:=ton+1; IF ton=1000 THEN ton:=1; ilosc:=ilosc+1; END; Sound(ton); 18

Delay(1); UNTIL ilosc=10; Nosound; Jak widzicie zdeklarowałem dwie zmienne: "ilosc" i "ton". Zmienna "ilosc" będzie nam mówiła ile razy alarm już zatrąbił. Zmienna "ton" decydować będzie to częstotliwości dźwięku. Najpierw zeruje oba zmienne. Później zaczynam pętle. Zmiennej "ton" zwiększam wartość (tak jak w poprzednich programach z pętlą). Program sprawdza, czy ta wartość równa jest sto. Na razie nie jest równa, więc program opuszcza instrukcję warunkową. Następnie przez 1/1000 sekundy wydobywa się dźwięk o częstotliwości "ton", czyli aktualnie 1. Pętla się zamyka. Następuje ponowne uruchomienie pętli, ponieważ wartość zmiennej "ilosc" nie jest równa 10. Kolejne zadania w pętli odgrywają dźwięk o coraz to wyższej częstotliwości. Daje to wrażenie alarmu. W pewnym momencie, zmienna "ton" jest już równa 1000, więc w pętli dokonuje się wstawiona tam instrukcja warunkowa. A w niej: "ton" przyjmuje wartość 1 oraz "ilosc" zwiększa swoją wartość o 1. Instrukcja warunkowa kończy się, a program odgrywa dźwięk o częstotliwości "ton", czyli znowu 1. I znowu wszystko zaczyna się, z tym, że wartość zmiennej "ilosc" jest większa. Cały proces trwa do momentu, aż zmienna "ilosc" przyjmie wartość 10. Program wtedy ucichnie dzięki poleceniu "NoSound". Skomplikowane, nieprawdaż? W praktyce usłyszysz 10 razy szybki wzrost częstotliwości. Da to efekt alarmu, zresztą - sam się przekonaj. To teraz zajmijmy się poleceniem "WHILE..DO", które jest drugą pętlą omawianą na tej lekcji. Nie różni się zbytnio od poprzedniej, natomiast jest nieco rzadziej używana. W poprzedniej pętli, zawsze to, co było ujęte w nią - wykonało się, co najmniej raz. Musi tak być, ponieważ warunek na zakończenie pętli był na jej końcu. Program działał w sposób, że najpierw wykonał pętle, a potem dopiero sprawdził, czy to jej koniec. Pętla "WHILE..DO", najpierw sprawdza warunek, a potem dopiero, (jeżeli jest on spełniony) się wykonuje. Dlatego właśnie w tej pętli zaistnieć może sytuacja, że pętla w ogóle się nie włączy, gdy warunek nie będzie spełniony. Poza tym, program działa tak: dopóki warunek jest spełniony, wykonuj..., a nie jak poprzednio: wykonuj... aż warunek zostanie spełniony. Po słowie "WHILE" zawsze jest warunek. Potem następuje słowo "DO" i wpisujemy polecenia pętli. Po słowie "DO", musimy zastosować "". Zatem wszystkie polecenia pętli muszą być ujęte w oddzielny blok. Wszystko zaraz się wyjaśni na konkretnym przykładzie (mam nadzieję). Załóżmy, że chcemy zrobić prosty program, który pyta użytkownika o jakąś liczbę. Jeżeli ta liczba jest równa 10 lub 20, program wykonuje pętle. Jeżeli nie - program się wyłącza. Pętla polega na 10 krotnym wypisaniu słowa "Podałeś liczbę 10 lub 20". Program głupi jest i nieprzydatny, ale jak do ćwiczeń, to dobry. Starymi sposobami, program ten można zrobić tak: liczba,licznik:longint; writeln('podaj jakąś liczbę'); read(liczba); IF (liczba=10) OR (liczba=20) THEN licznik:=0; REPEAT licznik:=licznik+1; writeln('podałeś liczbę 10 lub 20'); UNTIL licznik=10; writeln; END; 19

Halt; Jak widzimy program ma dwie zmienne: "liczba" i "licznik". Użytkownik wprowadza liczbę. Jeżeli nie jest równa 10 lub 20, program opuszcza instrukcję warunkową, a zarazem pętle i dochodzi do polecenia "Halt". Jeżeli liczba równa jest 10 lub 20, program wykonuje instrukcję warunkową - wypisuje 10 razy napis. A teraz powyższy program przekształćmy, tak aby można było użyć w nim pętli "WHILE..DO". Będzie on wyglądał tak: liczba,licznik:longint; writeln('podaj jakąś liczbę'); read(liczba); IF (liczba=10) OR (liczba=20) THEN licznik:=0; WHILE licznik<11 DO> licznik:=licznik+1; writeln('podałeś liczbę 10 lub 20'); END; writeln; END; Halt; Pętla sprawdza warunek, czy licznik<11. Jeżeli tak, pętla się wykonuje. Wykonuje się tak długo, aż licznik nie będzie mniejszy od 11 (czyli, aż osiągnie wartość 11). Z tego wynika, że napis wyświetli się 10 razy. Jak widzimy, łatwiej jest operować pętlą "REPEAT" niż omawianą. Ale jak to mówią: "róbta co chceta". Pamiętajcie, że w pętli "WHILE..DO" nie ma słowa "UNTIL". Do omówienia zostało jeszcze zagnieżdżanie pętli. Czy wiesz, że w pętle można wpisać jeszcze jedną pętle, a w nią następną i następną... i tak dalej. My nie będziemy zapętlali miliony razy, ale zrobimy bardzo fajny program, który nazywać się będzie "tabliczka mnożenia". Jego zadaniem będzie wypisanie mnożeń, tzn. 1*1=1, 1*2=2, 1*3=3 aż dojdzie do 10*10=100. Wszystkie działania będą linijka pod linijką. Gdybyśmy chcieli to zrobić ręcznie, musielibyśmy zająć co najmniej 100 linijek tekstu (jedną na każde działanie), np: writeln('4*3=12'); writeln('4*4=16'); writeln('4*5=20'); writeln('4*6=24'); writeln('4*7=28'); writeln('4*8=32'); writeln('4*9=36'); writeln('4*10=40'); writeln('5*1=5'); writeln('5*2=10'); writeln('5*3=15'); writeln('5*4=20'); i tak dalej... 20

Do tego celu zagnieździmy pętle. Tzn. wpiszemy drugą pętle "REPEAT" do już istniejącej. Najpierw zobaczcie na program, a potem sobie wyjaśnimy: a,b:longint; writeln(' A oto tabliczka mnożenia:'); a:=0; REPEAT a:=a+1; b:=0; REPEAT b:=b+1; writeln(a,'*',b,'=',a*b); delay(100); UNTIL b=10; UNTIL a=10; To teraz wyjaśnienie. Deklarujemy dwie zmienne: "a" i "b". Zmienna "a" będzie pierwszą liczbą, którą będziemy mnożyć, zmienna "b" natomiast - drugą. (a*b). Po napisie, zerujemy zmienną "a". Rozpoczynamy pętle ZEWNĘTRZNĄ. "a" zwiększa wartość o 1. Zerujemy "b". Zaczynamy pętle "WEWNĘTRZNĄ". "b" zwiększa wartość o 1. Program pisze: a*b=wynik. Zarówno "a" jak i "b" wynoszą 1, więc jest "1*1=1". Napis trwa 1/10 sekundy. Wartość "b" nie jest równa 10, więc pętla zaczyna się jeszcze raz. Znowu "b" zwiększa wartość, ale "a" pozostaje takie samo. Jest zatem 1*2=2. Jak zauważyliśmy, wszystko idzie dobrze. Tabliczka mnożenia idzie przez 1 do momentu, aż "b" wyniesie 10 (1*10=10). Pętla wewnętrzna się kończy. Pamiętamy jednak, że cały czas jesteśmy w pętli zewnętrznej. Pętla zewnętrzna kończy się dopiero, kiedy "a" jest równe 10. W tej chwili "a" jest równe 1, więc pętla zewnętrzna zaczyna się od początku. Wartość "b" się zeruje i zaczyna się pętla wewnętrzna. Teraz wszystko mnoży się przez "2". Zatem, w jednym poleceniu pętli zewnętrznej wykonuje się 10 razy pętla wewnętrzna. Pętla zewnętrzna wykonuje się 10 razy. Zatem końcowy napis będzie "10*10=100". Tak oto stworzyliśmy tabliczkę mnożenia dzięki podwójnej pętli (zagnieżdżeniu). Polecenie "Delay" służy tylko temu, abyśmy zdążyli tę tabliczkę zobaczyć, bo bez niego program ją wypisze w mgnieniu oka. I to tyle, jeśli chodzi o te dwie pętle. Nie zaglądaj nawet do następnej lekcji, dopóki nie zrozumiesz tej - a zwłaszcza ostatniego programu z tabliczką mnożenia. Pamiętaj, że pętle są wykorzystywane w 90% programów, więc bez nich ani rusz. Zadanie domowe: Napisz program, który pyta użytkownika o jakąś liczbę. Po wprowadzeniu liczby przez użytkownika, program ma pomnożyć ją przez wszystkie liczby od 1 do 2000 i pokazać wyniki (linijka pod linijką). Pętle goto oraz FOR..TO..DO/FOR..DOWNTO..DO W poprzednich pętlach tak naprawdę to nie wiadomo było ile razy się dana pętla wykona. Program mógł ciągnąć się w nieskończoność. Aby temu zapobiec, wymyślono pętle "FOR..TO..DO" oraz "FOR..DOWNTO..DO". Oba pętle nie różnią się zbyt od siebie. Zacznijmy może od pętli "FOR..TO..DO". Załóżmy, że chcemy zrobić program, który będzie 100 razy wypisywał imię użytkownika. Najpierw 21

użytkownik wprowadza imię, a potem zaczyna się pętla, która polega na 100 - krotnym wypisaniu jego imienia schodząc o linie niżej. Stosując tu znaną ci już pętle, można zrobić to w ten sposób. imie:string; ilosc:longint; writeln('jak masz na imię?'); read(imie); ilosc:=0; REPEAT ilosc:=ilosc+1; writeln(imie); UNTIL ilosc=100; Jak widzimy, pętla jest prosta i nie trzeba jej dogłębnie omawiać. Program wypisze 100 razy imię użytkownika i się wyłączy. Zatem, w pętli tej z góry ustalona jest ilość wykonania instrukcji. Wiemy, że na 100% pętla wykona się 100 razy. Nic nie jest w stanie tego zmienić. Można, zatem, aby było prościej, zastosować pętle "FOR..TO..DO". Najpierw obejrzyjcie program, a potem wyjaśnienia (program wykonuje to, co poprzedni). imie:string; ilosc:longint; writeln('jak masz na imię?'); read(imie); FOR ilosc:=1 TO 100 DO writeln(imie); END; Jak widzimy, zmienne pozostają te same, początek też ten sam. Pętla zaczyna się słówkiem "FOR". Jest to jej początek. Po tym następuje przypisanie wartości jakiejś zmiennej. Zauważmy, że przypisujemy wartość dopiero tutaj, a nie przed pętlą. Następnie widzimy słówko "TO" i wpisujemy wartość zmiennej. Wpisaliśmy 100. Ilość ta informuje już nas, że pętla wykonywać będzie się 100 razy. Było to zatem polecenie, ile razy pętla ma się wykonać. Później następuje słówko "DO" i w oddzielnych blokach "", "END" wpisujemy polecenia pętli. Najważniejsze jest, że nie wpisujemy tam już czegoś takiego: "ilosc:=ilosc+1;". Jest to zawarte po słowie "FOR". Gdy pojedyncza instrukcja pętli się zakończy, wartość zmiennej "ilosc" przyjmuje wartość +1. Dzięki temu stworzyliśmy program, który mimo, że wygląda inaczej, działa tak jak poprzedni. Stymulując język polski, będzie to wyglądało tak: Od "imie" równa się 1 do 100, rób... Pamiętać trzeba o kilku ważnych rzeczach. Instrukcje pętli wpisujemy w oddzielne bloki - wielu o tym zapomina. Jak widzimy, pętla ta może się do czegoś przydać. To w takim razie, po jakiego grzyba, wymyślono pętlę "FOR..DOWNTO..DO"??? Otóż, poprzednia pętla 22

ZWIĘKSZAŁA wartość zmiennej o 1. Natomiast pętla "FOR..DOWNTO..DO" działa identycznie, z tym, że ZMNIEJSZA wartość zmiennej o 1. Programu już myślę, że nie trzeba robić - wszyscy wiedzą, o co chodzi. Zajmijmy się czymś bardziej skomplikowanym. Na pewno pamiętacie zagnieżdżanie pętli z poprzedniej lekcji. Robiliśmy tam program "tabliczka mnożenia". Spróbujmy zrobić program ten, ale za pomocą omawianej właśnie pętli. Spójrz, jak prościej wygląda on od poprzedniej wersji. a,b:longint; FOR a:=1 TO 10 DO FOR b:=1 TO 10 DO writeln(a,'*',b,'=',a*b); END; END; Jak widzimy, do tabliczki mnożenia lepiej jest wykorzystywać pętlę "FOR..TO..DO", aniżeli pętle "REPEAT". Ponieważ czas nagli, przechodzimy szybko do drugiej pętli omawianej w tej lekcji. Jest ona najprostsza do zrozumienia. Nie przypomina, bowiem żadnego zawiłego powtarzania, a przejście z jednego miejsca programu do drugiego. Załóżmy, że chcemy, aby program w którymś tam momencie wracał do początku programu lub gdzieś w jego środek. Dla przykładu posłużymy się programem, gdzie użytkownik będzie musiał wpisać hasło (coś już takiego było zdaje się). Jeżeli nie wpisze poprawnego hasła, program powtarza zapytanie. Jeżeli wpisze, program się wyłącza. Można ten program zrobić oczywiście za pomocą innych pętli już ci znanych, ale użyjemy tu nowego polecenia "GOTO" - nie mylić z "GOTOXY". Polecenie to przenosi nas w dowolną część programu. Miejsce, gdzie przenieść ma nas to polecenie, musi być zaznaczone w kodzie programu. Poza tym, tak jak i zmienne - musi być wcześniej zdeklarowane. Miejsce takie nazywa fachowo się "kotwicą" i tak będziemy je nazywać. Deklarować kotwice najlepiej jest zaraz po zmiennych. Zmienne deklarowaliśmy poleceniem "", kotwice natomiast deklaruje się poleceniem "LABEL". W praktyce wygląda to tak: zmienna1:longint; zmienna2:string; LABEL miejsce1; (i tak dalej...) Jak widzimy, zadeklarowałem dwie zmienne (ale mniejsza z nimi) oraz kotwice o nazwie "miejsce1". Kotwice deklarujemy po słowie "LABEL" i nie wpisujemy żadnych typów (po prostu je wymieniamy po przecinku bez żadnych dwukropków). Na końcu pamiętać trzeba jednak o średniku. Teraz mamy już zadeklarowaną kotwice o nazwie "miejsce1", więc bez problemu możemy ją użyć (a raczej wstawić). Gotowy już program z hasłem, wygląda następująco: 23

haslo:longint; LABEL miejsce1; miejsce1: write('podaj poprawne hasło: '); read(haslo); IF haslo<>123456 THEN goto miejsce1; writeln('brawo! Odgadłeś hasło!'); W powyższym przykładzie kotwica o nazwie "miejsce1" znajduje się na początku programu. Kotwice mogą znajdować się również w innych miejscach. Kotwice wstawia się do programu tylko jeden raz. Wstawiamy jej nazwę i dwukropek. Później komputer czyści ekran i pyta użytkownika o hasło. Hasło jest równe 123456. Jeżeli ktoś wprowadził błędne hasło, komputer wykonuje instrukcję warunkową. W niej ma rozkaz "GOTO miejsce1", co oznacza "idź do miejsce1". Komputer nie patrząc praktycznie na dalszą część kodu, przechodzi do kotwicy tak właśnie oznaczonej. I znowu: czyści ekran, pyta urzytkow... i tak dalej. Zatem, napis z brawami nie ukaże się dopóty użytkownik wprowadzi poprawne hasło (czyli 123456). Na tym właśnie polega polecenie "GOTO". No i to by było na tyle jeśli chodzi o tą lekcję. Moim zdaniem, jeżeli przeczytałeś już wszystkie wcześniejsze lekcje i tą - jesteś na dobrej drodze, aby zostać programistą. Oczywiście, twoja wiedza jest jeszcze bardzo uboga, dlatego zapraszam do lekcji następnej. Procedury, procedury z parametrami, funkcje Doszliśmy w końcu do procedur. Do czegoż one mogą służyć? - pewnie się teraz zastanawiacie. Zaraz wam wytłumaczę. Załóżmy, że chcemy zrobić program, który będzie pytał użytkownika, czy komputer ma wyświetlić na środku ekranu napis. Jeśli użytkownik się zgodzi - napis się wyświetli. Jeżeli użytkownik się nie zgodzi - program pyta jeszcze raz. I znowu kolejny wybór. Program ten wyglądał będzie tak: wybor:longint; writeln('czy mam wyświetlić napis? - napisz 1 dla tak lub 2 dla nie'); read(wybor); IF wybor=1 THEN gotoxy(10,10); writeln('ten napis jest na środku ekranu i zniknie za 5 sekund!'); delay(5000); Halt; END; IF wybor=2 THEN 24