UNIWERSYTET RZESZOWSKI

Transkrypt

1 UNIWERSYTET RZESZOWSKI JĘZYKI PROGRAMOWANIA (kody źródłowe programów omawianych w ramach wykładu) Dr Zbigniew Gomółka RZESZÓW

2 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA ZDEFINIOWANIE PODSTAWOWYCH POJĘĆ PROGRAM przepis postępowania, z góry przyswojony przez komputer plan działania. Mówiąc inaczej program jest realizacją algorytmu spełniającą wymogi komunikacji z komputerem; pisany jest w jednym z języków programowania; JĘZYK PROGRAMOWANIA zbiór zasad składni, instrukcji, dzięki którym powstaje kod źródłowy programu. Procesor jest wstanie wykonywać program jedynie w kodzie maszynowym. Jednakże tworzenie programów w tym języku jest praktycznie niemożliwe. Dlatego programista używa języka zrozumiałego dla człowieka, który następnie jest kompilowany bądź interpretowany do postaci maszynowej. Podział języków programowania strukturalne obiektowe Język wysokiego poziomu język programowania, zazwyczaj o budowie blokowej, spełniający wymagania programowania strukturalnego, lub programowania obiektowego (C i C++ Java Pascal, Matlab, Mathematica). Język niskiego poziomu język programowania, w którym środki strukturalizacji kodu są ograniczone do co najwyżej podprogramów i makroinstrukcji np. asemblery. Poziom języków programowania nie określa jego jakości, lecz rodzaj zastosowań!!! 0-1

3 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA TRANSLATOR program dokonujący przekładu tekstu wyrażonego w języku programowania na kod wynikowy. Zadaniem translatora jest wykonanie rozbioru gramatycznego przedłożonego tekstu, aby rozstrzygnąć, czy tekst jest poprawnym programem. W skład każdego translatora wchodzi analizator leksykalny, analizator składni oraz (najczęściej) generator kodu. KOMPILATOR translator języka wysokiego poziomu, którego programy wynikowe mogą być wprowadzone do pamięci i wykonane dopiero po zakończeniu tłumaczenia (w odróżnieniu od interpretatora). Programy wynikowe kompilatora mogą być przechowywane, łączone z innymi programami i wielokrotnie wykonywane znacznie szybciej niż programy interpretowane. INTERPRETER translator przekładający instrukcje programu na kod pośredni, który następnie interpretuje przy każdym ich wykonaniu. Ponieważ interpreter nie tworzy przekładu w kodzie maszynowym, lecz wykonuje instrukcje, tłumacząc je na bieżąco za każdym razem, wykonanie programu znacznie się wydłuża. Typowymi interpreterami są systemy programowania wykorzystywane do symulacji np. Matlab LINKER Program łączący (konsolidujący) biblioteki lub moduły biblioteczne z modułami programu wynikowego wyprodukowanymi przez kompilator; efektem działania konsolidatora jest kod w postaci gotowej do ładowania. produkt działania programu łączącego jest przechowywany np. w plikach exe, com, rtl, dll. KOD ŹRÓDŁOWY program komputerowy napisany w języku programowania. W tej postaci jest on zrozumiały dla programisty, bez konieczności jego uruchamiania. Kod źródłowy jest przekształcany na kod maszynowy w procesie kompilacji programu. 0-2

4 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA KOD MASZYNOWY język zrozumiały dla procesora. Program w kodzie maszynowym składa się z ciągu wartości binarnych, które oznaczają zarówno instrukcje jak i dane. Postać kodu maszynowego zależy od architektury procesora, na który dany program jest przeznaczony. Dlatego program musi zostać skompilowany na konkretnej maszynie, ewentualnie na systemie kompatybilnym z systemem docelowym. KOD WYNIKOWY (j. ang. object code), rezultat pracy translatora (np. kompilatora), nadający się do bezpośredniego wykonywania przez procesor albo wymagający dalszej obróbki (np. konsolidacji). 0-3

5 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA PODSTAWOWE BLOKI PROGRAMU BLOK DEKLARACJI BLOK PROGRAMU GŁÓWNEGO 0-4

6 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA PROCEDURA - PODPROGRAM deklaracja procedury Wywołanie procedury 0-5

7 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA UNIT - KORZYSTANIE Z BIBLIOTEK blok deklaracji ciała procedur 0-6

8 Zakład Elektrotechniki i Informatyki dr Z.Gomółka, zgomolka@atena.univ.rzeszow.pl PODSTAWY PROGRAMOWANIA PRZEJRZYSTE PROGRAMOWANIE komentarze informacje niezbędne do dalszych modyfikacji programu. wcięcia akapitowe są olbrzymim udogodnieniem dla czytającego kod źródłowy, świadczą o dobrych nawykach czytelnego i przyjaznego programowania. Program ZŁ Y; Var s:string; b:byte; Program DOBRY; Var s:string; {Komentarze} b:byte; ReadLn(s); If s='pi' Then For b:=1 To 10 Do WriteLn(PI); WriteLn(b); ReadLn(s); If s='pi' Then For b:=1 To 10 Do WriteLn(PI); WriteLn(b); pisownia słów kluczowych 0-7

9

10 PROGRAM Compare1; { Przykład do wartości boolowskich } Var A, B :Integer; Result :BOOLEAN; Write('Podaj dwie liczby calkowite: '); ReadLn(A, B); Result := (A = B); { lub mniej czytelnie Result := A = B; nawiasy mozna pominac. } WriteLn('Oto wynik porównania ', Result) End. PROGRAM Compare2; { Porównanie wartości rzeczywistych } Const blad = ; Var x, y :Real; Result :BOOLEAN; Write('Podaj dwie liczby rzeczywiste: '); ReadLn(x, y); Result := ABS(x - y) < blad; WriteLn('Roznica wynosi ', ABS(x-y):2:6); WriteLn('Wynik porownania ', Result) End. PROGRAM Przed_Po; Var Literki: Char; Write('Podaj znak: '); ReadLn(Literki); WriteLn('Znak poprzedni to "',PRED(Literki),'"'); WriteLn('Znak nastepny to "',SUCC(Literki),'"'); WriteLn('Program czeka na naciśnięcie Enter...'); ReadLn; End. PROGRAM Punkty_I_oceny1; Var Punkty :Integer; Write('Prosze podac wynik testu: '); ReadLn(Punkty); WriteLn; If Punkty > 59 Then { Poczatek instrukcji If } If Punkty > 69 Then If Punkty > 79 Then If Punkty > 89 Then WriteLn('Doskonale. Twoja ocena to 5') ELSE WriteLn('Bardzo dobrze. Masz 4,5') ELSE WriteLn('Dobrze. Twoja ocena to 4') ELSE WriteLn('Zdales, ale tylko na 3,5') ELSE WriteLn('Moze kiedys bedzie lepiej. Ocena 2'); { Koniec instrukcji If } WriteLn('Program czeka na nacisniecie ENTER..'); ReadLn End. PROGRAM Punkty_I_oceny2; Var Punkty :Integer; A, B, C, D, F :BOOLEAN; Write('Prosze podac wynik testu: '); ReadLn(Punkty); A := (Punkty >= 90) AND (Punkty <= 100); B := (Punkty >= 80) AND (Punkty < 90); C := (Punkty >= 70) AND (Punkty < 80); 1

11 D := (Punkty >= 60) AND (Punkty < 70); F := (Punkty < 60) AND (Punkty >= 0); WriteLn; { Poczatek instrukcji If } { } If A Then WriteLn('Doskonale. Twoja ocena to 5') ELSE If B Then WriteLn('Bardzo dobrze. Masz 4,5') ELSE If C Then WriteLn('Dobrze. Twoja ocena to 4') ELSE If D Then WriteLn('Zdales, ale tylko na 3,5') ELSE If F Then WriteLn('Moze kiedys bedzie lepiej. Ocena 2') ELSE WriteLn('Podales liczbe spoza zakresu.'); { Koniec instrukcji If } { } WriteLn('Program czeka na nacisniecie ENTER..'); ReadLn End. PROGRAM GoToLoop(OUTPUT); LABEL 1000; { deklaracja etykiety } Var Counter :Integer; Counter := 0; 1000: Counter := Counter + 1; If Counter <= 5 Then WriteLn('Przepraszam, powtorz..'); GOTo 1000 { restart } End; WriteLn; WriteLn('Program czeka na Enter..'); ReadLn End. Program Srednia_1; Var Average, Sum, Number :Real; N, Counter :Integer; Sum := 0; Write('Podaj liczbe elementow: '); ReadLn(N); FOR Counter := 1 To N Do Write('Podaj element nr',counter,': '); ReadLn(Number); Sum := Sum + Number; End; Average := Sum / N; WriteLn('Suma liczb = ', Sum:0:2); WriteLn('Srednia liczb = ', Average:0:2); WriteLn; WriteLn('Program czeka na nacisniecie Enter..'); ReadLn End. PROGRAM Średnia2; Var Average, Sum, Number :Real; Counter, N :Integer; Sum := 0; Counter := 1; 2

12 Write('Podaj liczbe elementow: '); ReadLn(N); While Counter <= N Do Write('Podaj element nr',counter,': '); ReadLn(Number); Sum := Sum + Number; Counter := Counter + 1 End; Average := Sum / N; WriteLn; WriteLn('Suma liczb = ', Sum:0:2); WriteLn('Srednia liczb = ', Average:0:2); WriteLn; WriteLn('Program czeka na nacisniecie Enter..'); ReadLn End. PROGRAM Silnia; Var Silnia :Real; Licznik, Numer :Integer; Write('Podaj liczbe (lub 0, aby skonczyc ): '); ReadLn(Numer); While Numer <> 0 Do { Poczatek petli While } Silnia := 1; Licznik := 1; Repeat { Poczatek petli Repeat } Silnia := Silnia * Licznik; Licznik := Licznik + 1; Until Licznik = Numer + 1; { Koniec petli Repeat } WriteLn('Silnia liczby ', Numer,' to ', Silnia:0:0); Write('Podaj liczbe (lub 0, aby skończyć ): '); ReadLn(Numer) End; { Koniec petli While } WriteLn('Jestem tutaj!') End. PROGRAM Wyliczanie; Var Month :(Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec); WriteLn; FOR Month := Jan To Dec Do Write(ORD(Month),' ') End. PROGRAM Sortowanie; Const RozMac = 6; Type Zakres = 1..RozMac; LiczbyArray = ARRAY[Zakres] OF Integer; Var Liczby : LiczbyArray; I, J, Pot : Integer; { Czytaj tablice } FOR I := 1 To RozMac Do Write('Podaj element nr', I,': '); ReadLn(Liczby[I]) End; { Sortuj tablice przykład prostego sortowania} FOR I := 1 To RozMac-1 Do { petla zewnetrzna } { blok opcjonalny } FOR J := I+1 To RozMac Do { petla wewnetrzna } If Liczby[I] > Liczby[J] Then { zamien elementy } Pot := Liczby[J]; 3

13 Liczby[J] := Liczby[I]; Liczby[I] := Pot End End { koniec petli wewnetrznej } End; { koniec petli zewnetrznej } WriteLn; { Wyswietlanie wynikow } WriteLn('Posortowana tablica: '); FOR I := 1 To RozMac Do WriteLn(Liczby[I]); WriteLn('Program czeka na nacisniecie Enter..'); ReadLn End. PROGRAM Znaki_wyprowadzanie; CONST LF = CHR(10); CR = CHR(13); Var X, Y, Z :Integer; Write('Podaj trzy liczby: '); RaedLn(X, Y, Z); WriteLn('X=', X, CR, LF, 'Y=', Y, CR, LF, 'Z=', Z) End. Program Test_unita; Uses unit1; Var i, j, k : Integer; Function Potega(p: Integer; w : Integer):Integer; if w=1 Then Potega:= p else Potega:= p*potega(p,w-1); i:=1; j:=2; k:=3; test(j,k); k:= silnia(k); End. 4

14 Unit unit1; Interface Procedure test(var liczba : Integer; numer : Integer); Function Silnia(numer : Integer): Integer; Implementation Procedure test(var liczba : Integer; numer : Integer); Var lokal : Integer; Liczba:= Liczba*2; numer:= numer+2; lokal:= 3; WriteLn('To jest zmienna przekazana przez nazwę liczba=',liczba); WriteLn('To jest zmienna przekazana przez wartość numer=',numer); WriteLn('To jest zmienna lokalna=',lokal); End; Function Silnia(numer : Integer) : Integer; if numer = 0 then silnia:= 1; if numer > 0 then silnia:= numer * silnia(numer-1); End; End. PROGRAM Sortowanie_przez_wstawianie; USES Crt; CONST n_max=20; (* maksymalna liczba elementow *) TYPE Dane = ARRAY [1..n_max] OF INTEGER; VAR n : INTEGER; T_1 : Dane; (**********************************) PROCEDURE Wprowadzanie( VAR T:Dane); VAR i :INTEGER; (* zmienna kontrolna *) Writeln(' Wprowadzanie danych do tablicy '); Write (' Podaj ilosc elementow (n<=20), n= '); Readln (n); Write (' Podaj elementy tablicy w kolejnosci'); FOR i:=1 TO n DO Write(' element nr= ',i,', T_1[ ', i,' ] = '); Readln (T[i]); (**********************************) PROCEDURE Odczyt_tablicy( VAR T:Dane); VAR i :INTEGER; { zmienna kontrolna } Write (' Odczytaj elementy tablicy w kolejnosci'); FOR i:=1 TO n DO 5

15 Write(' element nr= ',i,', T_1[ ',i,' ] = '); Writeln (T[i]) (***********************************) PROCEDURE Sort_wstaw( VAR T:Dane); VAR i, k :INTEGER; (* zmienna kontrolna *) z_p :INTEGER; (*z_p- zmienna pomocnicza do zamiany elementow *) FOR i:=2 TO n DO k:=i; z_p:=t[k]; (* zapamietanie elementu do wstawienia *) WHILE (k>1) AND (T[k-1]> T[k]) DO (* przesuniecie elementow w prawo*) T[k]:=T[k-1]; T[k-1]:=z_p; k:=k-1 T[k]:=z_p; (* wstawienie danego elementu *) Writeln(' Tablica uporzadkowana'); (***********************************) PROGRAM Funkcja_minimum; USES Crt; VAR a,b, min, mniej : LONGINT; {CIAŁO GŁÓWNE PROGRAMU} Wprowadzanie (T_1); Sort_wstaw (T_1); Odczyt_tablicy (T_1); REPEAT UNTIL KeyPressed END. Tak_Nie : CHAR; FUNCTION Mniejsza:LONGINT; REPEAT Writeln (' Wyznaczenie liczby mniejszej '); Writeln (' Podaj dwie niezerowe rozne liczby naturalne:'); Write (' Podaj liczbe naturalna a= '); Readln (a); Write (' Podaj liczbe naturalna b= '); Readln (b); UNTIL a<>b; IF a>b THEN min:=b Else min:=a; Mniejsza:=min; (* Nadanie funkcji wartosci min *) (*************************************) REPEAT mniej:=mniejsza; (*Przypisanie wyniku funkcji zmiennej *) Writeln(' Z liczb ',a,' i ',b,' liczba mniejsza to ',mniej); Writeln (' Jeszcze raz?(t)ak'); Tak_Nie:=UpCase(ReadKey) UNTIL NOT (Tak_Nie='T') END. PROGRAM Rzut_moneta; USES Crt; VAR i, ORZEL, RESZKA, x : INTEGER; Tak_Nie : CHAR; 6

16 CONST n=20; REPEAT RANDOMIZE ; ORZEL:=0; RESZKA:=0; FOR i:=1 TO n DO x:=random(2); IF x=0 THEN ORZEL:=ORZEL+1 ELSE RESZKA:=RESZKA+1; Writeln(' Losowy rzut moneta '); Writeln(' Moneta rzucano ', i,' razy '); Writeln(' Wylosowano orla... ', ORZEL:2,' razy'); Writeln(' Wylosowano reszke.. ', RESZKA:2,' razy'); Writeln (' Jeszcze raz?(t)ak'); Tak_Nie:=UpCase(ReadKey) UNTIL NOT (Tak_Nie='T') END. PROGRAM Zmiana_wartosci_elementu; USES Crt; VAR f : FILE OF INTEGER; x : INTEGER; y : INTEGER; ch : CHAR; (****************************) ASSIGN(f,'plik.dok'); REWRITE(f); Writeln(' Zmiana wartosci elementu'); Writeln(' Poz. Wartosc '); FOR x:=1 TO 10 DO Write(f,x); Writeln(' ',x:2,' - ', x:2); Seek(f,2); x:=23; Write(f,x); Seek(f,0); Writeln(' Po zmianie wartosci na poz. 3 '); FOR x:=1 TO 10 DO Read(f,y); Writeln(' ',x:2,' - ', y:2); ch:=readkey; END. PROGRAM Kombinacja_n_po_k; USES Crt; CONST Max_el = 100; TYPE Tablica = ARRAY [1.. Max_el] OF INTEGER; VAR n,k : INTEGER; Tab : Tablica; Tak_Nie : CHAR; 7

17 (**********************************) PROCEDURE Wyswietlanie(k :INTEGER); VAR Nr_elementu :INTEGER; (* dla Wyswietlanie *) FOR Nr_elementu := 1 TO k DO Write(Tab[Nr_elementu] : 4); (**********************************) PROCEDURE Kombinacja(a, b : INTEGER); VAR Element : INTEGER; (* dla Kombinacja *) FOR Element := b to n - k + a DO Tab[a] := Element; IF a < k THEN Kombinacja(a +1, Element+1) ELSE Wyswietlanie(k) END (*********************************) WHILE n<=k DO Writeln(' Wyznaczenie wszystkich kombinacji n po k'); Write(' Podaj ilosc elementow zbioru n: '); ReadLn(n); Write(' Podaj ilosc elem. podzbioru k: '); ReadLn(k); IF n >= k THEN Kombinacja(1,1); REPEAT UNTIL KeyPressed; END. 8

18 PROGRAM Tworzenie_obiektu_1; USES Crt; TYPE Osoba = OBJECT Nazwisko : STRING[35]; Imie, Miejsce_ur: STRING[20]; Data_ur : STRING[12]; Procedure Inicjuj; Procedure Drukuj; (*************************) Procedure Osoba.Inicjuj; Writeln(' Wprowadzanie danych do pol obiektu'); Write(' Podaj Nazwisko: '); Readln(Nazwisko); Write(' Podaj Imie: '); Readln(Imie); Write(' Podaj Miejsce urodzenia : '); Readln(Miejsce_ur); Write(' Podaj Data urodzenia: '); Readln(Data_ur); (************************) Procedure Osoba.Drukuj; Writeln(' Drukowanie zawartosci pol obiektu'); Writeln(' Nazwisko : ',Nazwisko); Writeln(' Imie : ',Imie); Writeln(' Miejsce urodzenia : ',Miejsce_ur); Writeln(' Data urodzenia : ',Data_ur); PROGRAM Dziedziczenie_1; USES Crt; TYPE Osoba = OBJECT Nazwisko : STRING [35]; Imie : STRING [20]; Miejsce_ur: STRING [20]; Data_ur : STRING [12]; Procedure Inicjuj; Procedure Drukuj; Kadra = OBJECT(Osoba) Wyksztalcenie : STRING [12]; Stanowisko : STRING [20]; Procedure Inicjuj; Procedure Drukuj; Procedure Osoba.Inicjuj; Write(' Podaj Nazwisko: '); Readln(Nazwisko); Write(' Podaj Imie: '); Readln(Imie); Write(' Podaj Miejsce urodzenia : '); Readln(Miejsce_ur); Write(' Podaj Data urodzenia: '); Readln(Data_ur); Procedure Osoba.Drukuj; VAR Osoba_1 : Osoba; (**********************) Osoba_1.Inicjuj; ReadKey; Osoba_1.Drukuj; ReadKey; END. 9

19 Writeln(' Nazwisko : ',Nazwisko); Writeln(' Imie : ',Imie); Writeln(' Miejsce urodzenia : ',Miejsce_ur); Writeln(' Data urodzenia : ',Data_ur); Procedure Kadra.Inicjuj; Osoba.Inicjuj; Write(' Podaj Wyksztalcenie: '); Readln(Wyksztalcenie); Write(' Podaj Stanowisko : '); Readln(Stanowisko); Procedure Kadra.Drukuj; Osoba.Drukuj; Writeln(' Wyksztalcenie : ',Wyksztalcenie); Writeln(' Stanowisko : ',Stanowisko); VAR Osoba_1 : Osoba; Kierownik_1 : Kadra; (**********************) WriteLn('Obiekt po zainicjowaniu przez konstruktor:'); Writeln(' Wprowadzanie danych do pol obiektu'); Osoba_1.Inicjuj; Kierownik_1.Inicjuj; Writeln(' Drukowanie zawartosci pol obiektu'); Osoba_1.Drukuj; Kierownik_1.Drukuj; ReadKey; END. PROGRAM Dane_osobowe; USES Crt; TYPE Dane_personalne = RECORD Imie : STRING[20]; Nazwisko : STRING[30]; Nr_ew : BYTE; Plec : CHAR VAR Dane : Dane_personalne; Licznik : BYTE; (*******************) Writeln(' Dane personalne pracownikow') ; FOR Licznik := 1 TO 5 DO Write('Podaj Nr_ew ',Licznik,'-ej osoby : '); Readln(Dane.Nr_ew); Write('Podaj Nazwisko ',Licznik,'-ej osoby : '); Readln(Dane.Nazwisko); Write('Podaj Imie ',Licznik,'-ej osoby : '); Readln(Dane.Imie); Write('Podaj Plec M/K ',Licznik,'-ej osoby : '); Readln(Dane.Plec); END. 10

20 PROGRAM Dane_osobowe2; USES Crt; TYPE Dane_personalne = RECORD Imie : STRING[20]; Nazwisko : STRING[30]; Nr_ew : BYTE; Plec : CHAR f_plik = FILE OF Dane_personalne; VAR Lista_p : f_plik; Dane : Dane_personalne; Licznik : BYTE; (**********************************) PROCEDURE Zapisz; ASSIGN(Lista_p,'plik_1a.dan'); REWRITE(Lista_p); Writeln(' Dane personalne pracownikow') ; FOR Licznik := 1 TO 5 DO Write('Podaj Nr_ew ',Licznik,'-ej osoby : '); Readln(Dane.Nr_ew); Write('Podaj Nazwisko ',Licznik,'-ej osoby : '); Readln(Dane.Nazwisko); Write('Podaj Imie ',Licznik,'-ej osoby : '); Readln(Dane.Imie); Write('Podaj Plec M/K ',Licznik,'-ej osoby : '); Readln(Dane.Plec); Write(Lista_p,Dane); CLOSE(Lista_p); PROCEDURE Odczyt; Writeln(' Dane personalne pracownikow'); ASSIGN(Lista_p,'plik_1a.dan'); RESET(Lista_p); WHILE NOT Eof(Lista_p) DO Read(Lista_p,Dane); Write(Dane.Nr_ew,' '); Write(Dane.Nazwisko,' '); Write(Dane.Imie,' '); Write(Dane.Plec); Writeln CLOSE(Lista_p); (*********************) Zapisz; Odczyt; REPEAT UNTIL KeyPressed END. 11

21 PROGRAM Obecnosc_litery_a; USES Crt; VAR tekst : STRING; i : INTEGER; ile : INTEGER; (*********************) Writeln(' Wyznaczenie liczby malych liter ''a'' w tekscie'); Writeln(' Napisz tekst i nacisnij ENTER'); Readln(tekst); ile:=0; FOR i:=1 TO LENGTH(tekst) DO IF (tekst[i]='a') THEN ile:=ile+1; Writeln(' Liczba malych liter ''w'' w tekscie : ',ile); REPEAT UNTIL KeyPressed END. PROGRAM Wielomian; USES Crt; VAR n, i :INTEGER; a, x, y:real; i:=0; y:=0; Writeln ('Obliczenie wartosci wielomianu '); Write ('Podaj stopien wielomianu n = '); Readln (n); Write ('Podaj wartosc x = '); Readln (x); Write ('Podaj ',n+1,' wartosci wpolczynnika a(n) '); Write ('- od a(0) do a(',n,'):'); REPEAT Write ('a(',i,') = '); Readln (a); y:=y*x+a; i:=i+1; UNTIL i>n; END. Write ('x = ',x:5:2,', y = ',y:5:2) Program Zabawa_z_macierza; Uses Crt; { Program demonstrujący podstawowe operacje na macierzach. } Const rozmiar = 5; Type macierz = array[1..rozmiar,1..rozmiar] of Real; var a, b, c : macierz; Procedure wczytaj_macierz(var m : macierz; roz : Integer); var i, j : Integer; {Indeksy do przegladania macierzy. } Randomize; WriteLn('Wprowadzanie element w macierzy: '); for i:= 1 to roz do for j:= 1 to roz do 12

22 m[i,j]:= random(10); Write('Podaj element m[',i,',',j,']:= ',m[i,j]:2:0); WriteLn; {ReadLn(m[i,j]);} Procedure wyswietl_macierz(var m : macierz; roz : Integer); var i, j : Integer; {Indeksy do przegladania macierzy. } WriteLn('Wyswietlanie elementów macierzy: '); for i:= 1 to roz do for j:= 1 to roz do Write( m[i,j]:2:0,' '); WriteLn; Procedure wyswietl_przekatna(var m : macierz; roz : Integer); var i, j : Integer; {Indeksy do przegladania macierzy. } WriteLn('Wyswietlanie przekatnych macierzy: '); for i:= 1 to roz do for j:= 1 to roz do if i= j then WriteLn('Element m[',i,',',j,']:= ',m[i,j]:2:0); Procedure dodaj_macierz(var m, n, o : macierz; roz : Integer); var i, j : Integer; {Indeksy do przegladania macierzy. } for i:= 1 to roz do for j:= 1 to roz do o[i,j]:= m[i,j]+n[i,j]; Procedure transponuj(var m : macierz; roz : Integer); var i, j : Integer; {Indeksy do przegladania macierzy. } temp : Real; o : macierz; for i:= 1 to roz do for j:= 1 to roz do o[i,j]:= 0; { Wyzeruj elementy macierzy wynikowej. } for i:= 1 to roz do for j:= 1 to roz do o[j,i]:= m[i,j]; m:= o; Procedure pomnoz_macierz(var m, n, o : macierz; roz : Integer); var i, j, k : Integer; {Indeksy do przegladania macierzy. } for i:= 1 to roz do for j:= 1 to roz do o[i,j]:= 0; { Wyzeruj elementy macierzy wynikowej. } for i:= 1 to roz do for j:= 1 to roz do for k:= 1 to roz do o[i,j]:= o[i,j] + m[i,k]*n[k,j]; function max(m : macierz; r : Integer) : Real; var i, j : Integer; temp : Real; 13

23 temp:= 0; for i:= 1 to r do for j:= 1 to r do if m[i,j] > temp then temp:= m[i,j]; max:= temp; function min(m : macierz; r : Integer) : Real; var i, j : Integer; temp : Real; temp:= 0; for i:= 1 to r do for j:= 1 to r do if m[i,j] < temp then temp:= m[i,j]; min:= temp; { Ciało główne programu. } wczytaj_macierz(a,rozmiar); Delay(500); wczytaj_macierz(b,rozmiar); dodaj_macierz(a,b,c,rozmiar); pomnoz_macierz(a,b,c,rozmiar); wyswietl_macierz(a,rozmiar); wyswietl_macierz(b,rozmiar); wyswietl_macierz(c,rozmiar); transponuj(c,rozmiar); wyswietl_macierz(c,rozmiar); WriteLn('Maximum macierzy: ', max(c,rozmiar):2:0); WriteLn('Minimum macierzy: ', min(c,rozmiar):2:0); wyswietl_przekatna(c,rozmiar); ReadKey; end. Program Stos1; { Demonstracja najprostszej struktury dynamicznej opartej na stosie } { W tej wersji procedury pracują w oparciu o przekazywanie do nich zmiennych poprzez nazwę. } { Stos: to struktura danych składająca się z liniowo uporządkowanych elementów, z których tylko najmłodszy jest w danej chwili dostępny.} Uses Crt; type wskaznik_stosu = ^komorka_danych; komorka_danych = record dane : String[10]; wskaznik : wskaznik_stosu; var wsk : wskaznik_stosu; i : Integer; element : String[10]; procedure na_stos(var w : wskaznik_stosu); var wsk_r : wskaznik_stosu; wsk_r:= w; New(w); w^.dane:= element; w^.wskaznik:= wsk_r; procedure ze_stosu(var w : wskaznik_stosu); { Procedura usuwajaca wierzcholek ze stosu. } var wsk_r : wskaznik_stosu; GotoXY(14,WhereY); WriteLn(w^.dane); wsk_r:= w^.wskaznik; Dispose(w); w:=wsk_r; 14

24 function il_elementow(wp : wskaznik_stosu) : Integer; { Funkcja zlicza rekurencyjnie kolejne elementy stosu. } if wp= Nil then il_elementow:= 0 else il_elementow:= il_elementow(wp^.wskaznik) + 1; WriteLn('Podaj kolejne wyrazy do wstawienia na stos (k- kończy pracę programu)'); wsk:= Nil; i:= 0; While element <> 'k' do ReadLn(element); If element <> 'k' then na_stos(wsk); Writeln('Koniec budowania stosu'); WriteLn('Wyswietlam zawartosc stosu : (',il_elementow(wsk), ' element w)'); WriteLn('Lp. element: '); While wsk <> Nil do Inc(i); Write(i); ze_stosu(wsk); Repeat Until KeyPressed; end. Program Kolejka1; { Program demonstrujący prace kolejki.} { Różni się ona od pracy stosu tym, że dołączenie elementów odbywa się tylko na końcu kolejki "przed nilem", zaś usuwanie elementów tylko na początku - tak samo jak w stosie. } { W tej wersji procedury pracują w oparciu o przekazywanie do nich zmiennych poprzez nazwę. } uses Crt; type wskaznik = ^komorka; { Wskaznik danych } komorka = record { Podstawowa komórka danych. } dane : String[10]; wsk : wskaznik; var pocz_kolejki, kon_kolejki, wsk_rob : wskaznik; i, j : Integer; tekst : String[10]; wybor : Char; procedure do_kolejki(var wp, wk : wskaznik); { wk - wskaznik konca kolejki} { wp - wskaznik poczatka kolejki} var wsk_r : wskaznik; wsk_r:= wk; New(wk); { Pobieramy nowy wskaznik. } ReadLn(tekst); { Pobieramy nastepny element danych. } wk^.dane:=tekst; wk^.wsk:= Nil; if (wp = Nil) and (wsk_r = Nil) then wp:= wk else wsk_r^.wsk:= wk; { Przypadek dopisywania pierwszego el. do listy else - przesuwanie konca kolejki } procedure z_kolejki(var wp, wk : wskaznik); var wsk_r : wskaznik; if wp <> Nil then { Jesli kolejka nie jest pusta to...} 15

25 wsk_r:= wp; Write(wp^.dane); Dispose(wp); wp:=wsk_r^.wsk; if wp = Nil then wk:= Nil; { Jesli ostatni element zostal } end { usuniety, to wpisz Nil na koncu } function il_elementow(wp : wskaznik) : Integer; { Funkcja zlicza rekurencyjnie elementy kolejki } if wp = Nil then il_elementow:= 0 else il_elementow:= il_elementow(wp^.wsk) + 1; procedure wyswietl_menu(wp, wk : wskaznik); { Wyswietlanie menu } { Parametry zostaˆy przekazane przez wartosc } WriteLn('1- Dopisz do kolejki Liczba elementow listy :', il_elementow(wp)); Write('2- Usuä z kolejki Pierwszy element : '); if wp <> Nil then WriteLn(wp^.dane) else WriteLn; Write('3- Wy wietl kolejk Ostatni element : '); if wk <> Nil then WriteLn(wk^.dane) else WriteLn; WriteLn('4- Koniec programu'); procedure wyswietl_kolejke(wp: wskaznik); var j : Integer; {Licznik element w} j:=0; { Wyzeruj licznik elementow kolejki. } WriteLn('Lp: element:'); While wp <> Nil do if (j mod 23 = 0) and (j <> 0) then Write('Nacisnij dowolny klawisz... '); ReadKey; Inc(j); Writeln(j,'. ',wp^.dane); { Przegladanie kolejki aľ do koäca. } wp:=wp^.wsk; Write('Nacisnij dowolny klawisz...'); ReadKey; pocz_kolejki:=nil; kon_kolejki:=nil; While wybor <> '4' do wyswietl_menu(pocz_kolejki, kon_kolejki); ReadLn(wybor); case wybor of '1': do_kolejki(pocz_kolejki, kon_kolejki); '2': z_kolejki(pocz_kolejki, kon_kolejki); '3': wyswietl_kolejke(pocz_kolejki); '4': exit; end. 16

26 Program Baza_danych; Uses Crt; Const MAX = 10; { Maksymalna liczba elementów bazy. } NAZWA = 'BAZA.DAT'; Type osoby = record nazwisko : String[20]; imie : String[15]; pesel : Integer; tab_osoby = array [1..MAX] of osoby; Var osoba : osoby; eb : Integer; { Bieżący rekord bazy. } baza : tab_osoby; wybor: Char; function StrComp(a, b: String) : Integer; forward; procedure dodaj_rekord; if eb+1 > MAX then WriteLn('Przekroczona maksymalna ilość elementów bazy!!!'); end else Inc(eb); with baza[eb] do Write('Podaj Nazwisko: '); ReadLn(nazwisko); Write('Podaj Imię: '); ReadLn(imie); Write('Podaj PESEL: '); ReadLn(pesel); procedure usun_rekord; var temp : Integer; i : Integer; if eb > 0 then WriteLn(' W BAZIE JEST ',eb,' - REKORDÓW'); WriteLn(' =============================='); WriteLn; Repeat Write('Podaj numer rekordu do usunięcia: '); ReadLn(temp); Until (temp in [1..eb]); { Czekaj na poprawny numer. } for i:= temp to eb DO baza[i]:= baza[i+1]; Dec(eb); end else WriteLn('BAZA DANYCH JEST PUSTA!!!'); Write('Nacisnij dowolny klawisz...'); ReadKey; 17

27 procedure wyswietl_baze; { Wyświetl zawartość bazy. } var j: Integer; if eb > 0 then WriteLn('Lp: Nazwisko: Imie: PESEL:'); for j:=1 to eb do if (j mod 23 = 0) and (j > 0) then Write('Nacisnij dowolny klawisz... '); ReadKey; Write(j,'.'); GoToXY(6, WhereY); Write(baza[j].nazwisko); GoToXY(27, WhereY); Write(baza[j].imie); GoToXY(46, WhereY); WriteLn(baza[j].pesel); end else WriteLn('BAZA DANYCH JEST PUSTA!!!'); Write('Nacisnij dowolny klawisz...'); ReadKey; procedure zapisz_baze; var plik : file of osoby; i : Integer; Assign(plik,NAZWA); { Otwórz archiwum bazy...} Rewrite(plik); { Ustaw plik w pozycji do zapsiu od nowa...} for i:= 1 to eb do Write(plik, baza[i]); Close(plik); procedure wczytaj_baze; var plik : file of osoby; Assign(plik,NAZWA); { Otwórz archiwum bazy...} Reset(plik); { Ustaw plik w pozycji do odczytu od poczatku...} eb:= 0; while not EoF(plik) do Read(plik, baza[eb+1]); Inc(eb); Close(plik); procedure sortowanie_b; var przestawil : Boolean; i : Integer; temp : osoby; przestawil:= True; while przestawil do przestawil:= False; for i:= 1 to eb-1 do if StrComp(baza[i].nazwisko,baza[i+1].nazwisko) > 0 then temp:= baza[i]; baza[i]:= baza[i+1]; baza[i+1]:= temp; przestawil:= True; 18

28 function StrComp(a, b: String) : Integer; if a > b then StrComp:= 1; if a = b then StrComp:= 0; if a < b then StrComp:= -1; procedure wyswietl_menu; { Wyswietlanie menu. } WriteLn(' PROGRAM BAZA DANYCH - STRUKTURA TABLICA '); WriteLn(' ========================================= '); WriteLn('1- Dopisz do bazy Liczba elementow bazy :',eb); WriteLn('2- Usun z bazy'); WriteLn('3- Wyswietl baze'); WriteLn('4- Zapisz baze do pliku BAZA.DAT'); WriteLn('5- Wczytaj baze z pliku BAZA.DAT'); WriteLn('6- Posortuj bazę -metoda bąbelkowa'); WriteLn('7- Koniec programu'); eb:= 0; While wybor <> '7' do wyswietl_menu; ReadLn(wybor); case wybor of '1': Dodaj_rekord; '2': Usun_rekord; '3': Wyswietl_baze; '4': Zapisz_baze; '5': Wczytaj_baze; '6': Sortowanie_b; '7': exit; end. 19

29 Program Lista_jednokierunkowa; { Program demonstrujący działanie listy jednokierunkowej. } { Lista (liniowa) to uporządkowany zbiór składników, z którego w dowolnym miejscu można usunąć lub dołączyć składnik. } { Lista jednokierunkowa to jedna z odmian struktury listowej, którą odróżnia od kolejki forma procedur dodawania i usuwania składników, które muszą uwzględniać istniejący porządek listy. } uses Crt, Strings; type wskaznik = ^komorka; { Wskaznik danych } komorka = record { Podstawowa komórka danych. } dane : Integer; wsk : wskaznik; var poczatek : wskaznik; { Wskaźnik początku } wb : wskaznik; { Wskaźnik bieżącego położenia } wybor : Char; function il_elementow(wp : wskaznik) : Integer; forward; function sz_element(wp : wskaznik; nr : Integer) : wskaznik; forward; procedure wstaw_na_koncu(var wp : wskaznik; liczba : Integer); var n, k : wskaznik; k:= wp; While k^.wsk <> Nil do k:=k^.wsk; New(n); { Pobieramy nowy wskaznik. } n^.dane:= liczba; n^.wsk:= Nil; if wp = Nil then wp:= n { Zapamietujemy pierwszy element. } else k^.wsk:= n; { Koniec wstaw_na_koncu. } procedure wstaw_przed(var w : wskaznik; liczba : Integer); var n : wskaznik; { w wskazuje na element, przed ktory nalezy wstawic nowy element. } New(n); With n^ do dane:= w^.dane; wsk:= w^.wsk; w^.wsk:= n; { Wstawienie po elemencie p. } w^.dane:= liczba; { Zamiana wartosci elementow 'p' i 'n'.} procedure do_listy(var wp : wskaznik); { Wstawianie do listy na odpowiednie miejsce. Elementy powtarzające się nie są wstawiane.} var wsk_r : wskaznik; liczba : Integer; wsk_r:= wp; ReadLn(liczba); While (wsk_r <> Nil) AND (liczba < wsk_r^.dane) do wsk_r:=wsk_r^.wsk; if wsk_r = Nil then wstaw_na_koncu(wp, liczba) else { Wariant ze wstawieniem na koncu. } if not (liczba = wsk_r^.dane) then {Jesli element nie powtórzony..} wstaw_przed(wsk_r, liczba); { Wstawienie przed elementem. } procedure z_listy(var wp, wb : wskaznik); var wsk_r, temp : wskaznik; 20

30 nr : Integer; if wp <> Nil then { Jeśli lista nie jest pusta to...} WriteLn('Podaj numer elementu do usunięcia z przedzialu (1 - ', Repeat il_elementow(wp),')'); Read(nr); Until (nr in [1..il_elementow(wp)]); { Czekaj na właściwy numer. } wb:= sz_element(wp,nr); { Odnajdujemy wskaznik na usuwany element. } Writeln('Usuwam element nr:',nr,' ',wb^.dane,' segment: ',seg(wb^.wsk), ' ofset: ',ofs(wb^.wsk)); ReadKey; wsk_r:= wp; if wp= wb then { Jeśli to jest pierwszy element to.. } wb:= wp^.wsk; Dispose(wp); wp:= wb; end else { w przeciwnym razie szukaj poprzednika.. } While wsk_r^.wsk <> wb do wsk_r:= wsk_r^.wsk; wsk_r^.wsk:= wb^.wsk; { Rozcinam listę.. } Dispose(wb); { zwalniam pamięć usuwanego elementu.. } wb:= wsk_r^.wsk; { i przyklejam ogon listy. } function il_elementow(wp : wskaznik) : Integer; { Funkcja zlicza rekurencyjnie elementy listy } if wp = Nil then il_elementow:= 0 else il_elementow:= il_elementow(wp^.wsk) + 1; function sz_element(wp : wskaznik; nr : Integer) : wskaznik; var i : Integer; i:= 1; while (wp^.wsk <> Nil) and (i < nr) do wp:= wp^.wsk; Inc(i); sz_element:= wp; procedure wyswietl_menu(wp : wskaznik); { Wyswietlanie menu. } WriteLn(' WARIANT LISTY ZAWIERAJĄCEJ LICZBY '); WriteLn(' =================================== '); WriteLn('1- Dopisz do listy Liczba elementow listy :', il_elementow(wp)); Write('2- Usun z listy Poczatek listy : '); if wp <> NIl then WriteLn(wp^.dane) else WriteLn; WriteLn('3- Wyswietl liste'); WriteLn('4- Koniec programu'); 21

31 procedure wyswietl(wp : wskaznik); { Wyświetl zawartość listy. } var j: Integer; j:=0; { Wyzeruj licznik elementow listy. } WriteLn('Lp: element:'); While wp <> Nil do if (j mod 23 = 0) and (j <> 0) then Write('Nacisnij dowolny klawisz... '); ReadKey; Inc(j); Writeln(j,'. ',wp^.dane,' segment: ',seg(wp^.wsk), ' ofset: ',ofs(wp^.wsk)); { Przegladanie listy aż do końca.} wp:=wp^.wsk; Write('Nacisnij dowolny klawisz...'); ReadKey; poczatek:=nil; While wybor <> '4' do wyswietl_menu(poczatek); ReadLn(wybor); case wybor of '1': do_listy(poczatek); '2': z_listy(poczatek, wb); '3': wyswietl(poczatek); '4': exit; end. Program test; {Przyklad programu demonstrujacego dzialanie testu {wpisywanie pytan i odpowiedzi, losowanie pytan przeprowadzanie testu i ocenianie} Uses Crt; Const l_odp = 4; plik1 = 'pytania.dat'; {Plik zawierający pytania i odpowiedzi} plik2 = 'config.txt'; {Plik do udoskonalania pracy programu} Type dane = record pyt : String; odp : array[1..l_odp] of String; nr_popr : Integer; wskaznik_do_pytan = ^pojemnik_na_pytania; pojemnik_na_pytania = record pytania : dane; wskaznik : wskaznik_do_pytan; Var pytanie : pojemnik_na_pytania; wsk : wskaznik_do_pytan; il_pyt : Integer; {Ilosc pytan zdefiniowanych w bazie} wiedza : Real; wybor : Char; procedure dodaj_pytanie(var wsk : wskaznik_do_pytan); 22

32 var temp : wskaznik_do_pytan; i : Integer; pytanie : pojemnik_na_pytania; WriteLn(' WPROWADZANIE KOLEJNYCH PYTAN DO PROGRAMU "TEST" -struktura stosowa'); WriteLn(' =================================================================='); if wsk <> Nil then {Jest conajmniej jeden element na stosie} temp:= wsk; New(wsk); {Utw rz adres wskazujący na nowy pojemnik} il_pyt:= il_pyt+1; with wsk^.pytania do WriteLn('Podaj nowe pytanie: '); ReadLn(pyt); for i:= 1 to l_odp do WriteLn('Odpowiedz nr ',i,' '); ReadLn(odp[i]); Repeat Write('Podaj numer poprawnej odpowiedzi: ', '[1..',l_odp,']:= '); ReadLn(nr_popr); Until (nr_popr in [1..l_odp]); wsk^.wskaznik:= temp; end else New(wsk); {Dokladamy pierwszy element} with wsk^.pytania do WriteLn('Podaj nowe pytanie: '); ReadLn(pyt); for i:= 1 to l_odp do WriteLn('Odpowiedz nr ',i,' '); ReadLn(odp[i]); Repeat Write('Podaj numer poprawnej odpowiedzi: ', '[1..',l_odp,']'); ReadLn(nr_popr); Until (nr_popr in [1..l_odp]); il_pyt:= 1; wsk^.wskaznik:= Nil; {Koniec struktury pokazuje na Nil-a} procedure wyswietl_baze_pytan(wsk : wskaznik_do_pytan); { Wyswietl zawartosc bazy pytan } var i, j : Integer; if wsk <> Nil then j:= 1; WriteLn(' Lp: Pytania i odpowiedzi wpisane do bazy. *- odpowiedz prawidlowa'); WriteLn('======================================================================'); while wsk <> Nil do if (j*l_odp mod 40 = 0) then Write('Nacisnij dowolny klawisz... '); ReadKey; 23

33 Write(j,'.'); GoToXY(6, WhereY); WriteLn(wsk^.pytania.pyt); for i:=1 to l_odp do {Wy wietl tre pytania} {oraz jego odpowiedzi} GoToXY(27, WhereY); Write(i,'. ',wsk^.pytania.odp[i]); if wsk^.pytania.nr_popr= i then write(' -*-'); WriteLn; {zaznaczając odpowiedz poprawną *} wsk:= wsk^.wskaznik; Inc(j); end else WriteLn('Brak jest pytan w bazie!!!'); Write('Nacisnij dowolny klawisz...'); ReadKey; procedure zapisz_baze(wsk : wskaznik_do_pytan); var plik : file of dane; i : Integer; if wsk <> Nil then Assign(plik,plik1); { Otworz archiwum bazy pytan...} Rewrite(plik); { Ustaw plik w pozycji do zapisu od nowa...} While wsk <> Nil do for i:= 1 to il_pyt do Write(plik, wsk^.pytania); wsk:= wsk^.wskaznik; Close(plik); end else WriteLn('Brak jest pytan w bazie!!!'); Write('Nacisnij dowolny klawisz...'); ReadKey; {Tutaj trafia oryginaˆ zmiennej wsk} function usun_stos(var wsk : wskaznik_do_pytan) : wskaznik_do_pytan; var temp : wskaznik_do_pytan; {Zwracana warto funkcji} while wsk<> Nil do temp:= wsk^.wskaznik; Dispose(wsk); Dec(il_pyt); wsk:= temp; usun_stos:= Nil; {Ten zapis musi wystąpi wewnątrz kaľdej funkcji} procedure wczytaj_baze(var wsk : wskaznik_do_pytan); var plik : file of dane; temp : wskaznik_do_pytan; znak : Char; if wsk <> Nil then WriteLn('Czy zastapic istniejace dane zestawem pytan '); WriteLn('znajdujacych sie w pliku ', plik1,'? '); Repeat Write('TAK: t/t NIE: n/n '); ReadLn(znak); Until (znak in ['t','t','n','n']); if (znak='t') or (znak='t') then {zastepujemy istniejacy stos} 24

34 {stosem z pliku} Usun_stos(wsk); Assign(plik,plik1); Reset(plik); while not EoF(plik) do temp:= wsk; New(wsk); Read(plik, wsk^.pytania); if il_pyt = 0 then wsk^.wskaznik:= Nil else wsk^.wskaznik:= temp; Inc(il_pyt); Close(plik); end else WriteLn('Pozostawiam aktualnie wczytane dane!'); Write('Nacisnij dowolny klawisz...'); ReadKey; end else {Wczytywanie danych gdy stos jest pusty} Assign(plik,plik1); Reset(plik); while not EoF(plik) do temp:= wsk; New(wsk); Read(plik, wsk^.pytania); if il_pyt = 0 then wsk^.wskaznik:= Nil else wsk^.wskaznik:= temp; Inc(il_pyt); Close(plik); procedure usun_pytanie(var wsk : wskaznik_do_pytan); var i, j : Integer; temp1, temp2, temp3 : wskaznik_do_pytan; {Zmienne pomocnicze umoľliwiające {kontrolowane wyjmowanie element w ze stosu} {wersja z tzw. wartownikiem} if wsk<> Nil then {Jezeli zestaw nie jest pusty to zaczynamy...} temp1:= wsk; {Zapami tujemy wsk aby nie zgubi gˆowy stosu} wyswietl_baze_pytan(wsk); {Wy wietlamy baz pytaä} WriteLn; Repeat Write('Podaj numer pytania do usunięcia ([1..',il_pyt,']:= '); ReadLn(j); {Zabezpieczenie aby pytania pochodziy z bieľącego zakresu} Until (j in [1..il_pyt]); if j=1 then {zwykle usuwanie glowy stosu} temp1:= temp1^.wskaznik; {Wystarczy posuľy si tylko jedną zmienną pomocniczą} Dispose(wsk); wsk:= temp1; Dec(il_pyt); end else {Usuwanie ze srodka lub konca wariant trudniejszy} i:= 1; While i<j do {ustaw sie na pytaniu do usuniecia} temp2:= temp1; {temp2 jest "wartownikiem" przy odliczaniu} temp1:= temp1^.wskaznik; {kolejnych element w stosu} Inc(i); if temp1 <> Nil then temp3:= temp1^.wskaznik 25

35 else temp3:= Nil; temp2^.wskaznik:= temp3; { Sklej oba konce} Dispose(temp1); { Zniszcz wskaznik do wybranego pytania} Dec(il_pyt); end else; {Nic nie rob- ewentualnie informuj ľe brak jest pytaä do usuwania} procedure przeprowadz_test(var wsk : wskaznik_do_pytan); { Procedura przeprowadzania testu losuje zadana ilosc razy pytania usuwajac je z kopii stosu, aby uniknac wielokrotnego losowania tych samych pytan. } var i,j,k,wynik : Integer; los : Word; odp_u : Integer; {Numer odpowiedzi wybrany przez ucznia.} ocena : Real; kopia, temp1, temp2, temp3 : wskaznik_do_pytan; if wsk<>nil then {Jeľeli nie jest pusty moľna rozpoczą losowanie} wiedza:= 0; WriteLn(' Losowanie pytan do przeprowadzenia testu.'); WriteLn('=========================================='); Randomize; {Losowanie numer w pytan w zakresie 1..il_pyt} Repeat Write('Podaj liczbe pytan do wylosowania z przedzialu : ', '[1..',il_pyt,']'); ReadLn(los); Until (los in [1..il_pyt]); ocena:= (1/los)*100; {Wyliczenie w procentach warto ci jednego pytania.} WriteLn(' Wylosowano nastepujace pytania: '); WriteLn('================================='); for i:= 1 to los do wynik:= Random(los-1)+1; {Losowanie w przedziale 1-los} temp1:= wsk; {Zapami tanie gˆowy stosu} if wynik=1 then {zwykle usuwanie glowy stosu} Write(i,'.'); GoToXY(6, WhereY); WriteLn(wsk^.pytania.pyt); for k:=1 to l_odp do {Wy wietl pytanie i dost pne odpowiedzi} GoToXY(27, WhereY); Write(k,'. ',wsk^.pytania.odp[k]); if wsk^.pytania.nr_popr= k then write(' -*-'); WriteLn; Repeat Write('Podaj numer poprawnej odpowiedzi [1..',l_odp,']: '); ReadLn(odp_u); Until (odp_u in [1..l_odp]); If (odp_u = wsk^.pytania.nr_popr) then wiedza:= wiedza+ocena; temp1:= wsk^.wskaznik; Dispose(wsk); {Zwykˆe usuni cie gˆowy stosu} wsk:= temp1; {gdy wylosowano pierwsze pytanie} Dec(il_pyt); Dec(los); end else {Usuwanie ze srodka lub konca} j:= 1; While j<wynik do {ustaw sie na pytaniu do usuniecia} temp2:= temp1; {temp2 jest "wartownikiem"} temp1:= temp1^.wskaznik; Inc(j); Write(i,'.'); GoToXY(6, WhereY); WriteLn(temp1^.pytania.pyt); 26

36 for k:=1 to l_odp do {Wy wietl znalezione pytanie i odpowiedzi dla niego} GoToXY(27, WhereY); Write(k,'. ',temp1^.pytania.odp[k]); if temp1^.pytania.nr_popr= k then write(' -*-'); WriteLn; Repeat Write('Podaj numer poprawnej odpowiedzi [1..',l_odp,']:*** '); ReadLn(odp_u); Until (odp_u in [1..l_odp]); if odp_u = temp1^.pytania.nr_popr then wiedza:= wiedza+ocena; if temp1 <> Nil then temp3:= temp1^.wskaznik else temp3:= Nil; temp2^.wskaznik:= temp3; { Sklej oba konce} Dispose(temp1); { Zniszcz wskaznik do wybranego pytania} Dec(il_pyt); Dec(los); ReadKey; procedure wyswietl_menu; { Wyswietlanie menu. } WriteLn(' PROGRAM DO PRZEPROWADZANIA TESTOW - STRUKTURA STOS '); WriteLn(' =================================================== '); WriteLn('1- Dopisz pytanie Liczba pytan: ',il_pyt, ' Ocena: ',wiedza:4:0,' %'); WriteLn('2- Usun pytanie'); WriteLn('3- Wyswietl wszystkie pytania'); WriteLn('4- Zapisz pytania do pliku ',plik1); WriteLn('5- Wczytaj pytania z pliku ',plik1); WriteLn('6- Przeprowadz test'); WriteLn('7- Koniec programu'); il_pyt:= 0; wsk:= Nil; {Zainicjowanie bazy pytan. } While wybor <> '7' do wyswietl_menu; ReadLn(wybor); case wybor of '1': Dodaj_pytanie(wsk); '2': usun_pytanie(wsk); '3': wyswietl_baze_pytan(wsk); '4': zapisz_baze(wsk); '5': wczytaj_baze(wsk); '6': przeprowadz_test(wsk); '7': usun_stos(wsk); exit; end. 27