Materiały pomocnicze do wykładu

Transkrypt

UNIWERSYTET
RZESZOWSKI
JĘZYKI PROGRAMOWANIA
(kody źródłowe programów
omawianych w ramach wykładu)
Dr Zbigniew Gomółka
RZESZÓW 2002-3
Zakład Elektrotechniki i Informatyki
dr Z.Gomółka, e-mail [email protected]
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ęz ykó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
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
analizator składni oraz (najczęściej) generator kodu.
leksykalny,
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
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
PODSTAWOWE BLOKI PROGRAMU
BLOK
DEKLARACJI
BLOK
PROGRAMU
GŁÓWNEGO
0-4
PROCEDURA - PODPROGRAM
deklaracja
procedury
Wywołanie
procedury
0-5
UNIT - KORZYSTANIE Z BIBLIOTEK
blok deklaracji
ciała procedur
0-6
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;
Program DOBRY;
Var
Var
s:string;
s:string; {Komentarze}
b:byte;
b:byte;
Begin
ReadLn(s);
ReadLn(s);
If s='pi' Then
If s='pi' Then
Begin
For b:=1 To 10 Do
Begin
•
Begin
Begin
For b:=1 To 10 Do
Begin
WriteLn(PI);
WriteLn(PI);
WriteLn(b);
WriteLn(b);
pisownia słów kluczowych
0-7
{ Poczatek instrukcji If }
ReadLn
A := (Punkty >= 90) AND (Punkty <= 100);
B := (Punkty >= 80) AND (Punkty < 90);
C := (Punkty >= 70) AND (Punkty < 80);
WriteLn('Znak nastepny to "',SUCC(Literki),'"');
WriteLn('Program czeka na naciśnięcie Enter ...');
ReadLn(Punkty);
WriteLn('Znak poprzedni to "',PRED(Literki),'"');
Write('Prosze podac wynik testu: ');
ReadLn(Literki);
Begin
Write('Podaj znak: ');
Begin
A, B, C, D, F :BOOLEAN;
:Integer;
Punkty
Var Literki: Char;
Var
PROGRAM Punkty_I_oceny2;
PROGRAM Przed_Po;
End.
End.
WriteLn('Roznica wynosi ', ABS(x-y):2:6);
WriteLn('Wynik porownania ', Result)
WriteLn('Program czeka na nacisniecie ENTER..');
{ Koniec instrukcji If }
WriteLn('Moze kiedys bedzie lepiej. Ocena 2');
ELSE
WriteLn('Zdales, ale tylko na 3,5')
ELSE
WriteLn('Dobrze. Twoja ocena to 4')
ELSE
WriteLn('Bardzo dobrze. Masz 4,5')
ELSE
WriteLn('Doskonale. Twoja ocena to 5')
If Punkty > 89 Then
If Punkty > 79 Then
If Punkty > 69 Then
If Punkty > 59 Then
WriteLn;
Result := ABS(x - y) < blad;
ReadLn(x, y);
Write('Podaj dwie liczby rzeczywiste: ');
Begin
Result :BOOLEAN;
x, y :Real;
Var
blad = 0.0001;
Const
PROGRAM Compare2; { Porównanie wartości rzeczywistych }
End.
WriteLn('Oto wynik porównania ', Result)
nawiasy mozna pominac. }
Result := A = B;
mniej czytelnie
ReadLn(Punkty);
{ lub
Write('Prosze podac wynik testu: ');
Result := (A = B);
Begin
Var Punkty :Integer;
PROGRAM Punkty_I_oceny1;
End.
ReadLn;
ReadLn(A, B);
Write('Podaj dwie liczby calkowite: ');
Begin
Result :BOOLEAN;
Var A, B :Integer;
PROGRAM Compare1; { Przykład do wartości boolowskich }
1
WriteLn('Program czeka na Enter..');
:Integer;
Sum := Sum + Number;
ReadLn
Var
GOTo 1000
{ restart }
WriteLn('Przepraszam, powtorz..');
Begin
:= 0;
Counter := 1;
Sum
Begin
Counter, N
:Integer;
Average, Sum, Number :Real;
If Counter <= 5 Then
Var
PROGRAM Średnia2;
Counter := Counter + 1;
1000:
Counter := 0;
Begin
End.
WriteLn('Program czeka na nacisniecie Enter..');
Counter :Integer;
WriteLn;
LABEL 1000; { deklaracja etykiety }
WriteLn('Srednia liczb = ', Average:0:2);
WriteLn('Suma liczb = ', Sum:0:2);
Average := Sum / N;
PROGRAM GoToLoop(OUTPUT);
End.
ReadLn
End;
{ ----------------------- }
WriteLn('Program czeka na nacisniecie ENTER..');
ReadLn(Number);
Write('Podaj element nr',Counter,': ');
Begin
FOR Counter := 1 To N Do
ReadLn(N);
Write('Podaj liczbe elementow: ');
Sum := 0;
Begin
N, Counter
Average, Sum, Number :Real;
Var
Program Srednia_1;
End.
{ Koniec instrukcji If }
WriteLn('Podales liczbe spoza zakresu.');
ELSE
WriteLn('Moze kiedys bedzie lepiej. Ocena 2')
ELSE If F Then
WriteLn('Zdales, ale tylko na 3,5')
ELSE If D Then
WriteLn('Dobrze. Twoja ocena to 4')
ELSE If C Then
WriteLn('Bardzo dobrze. Masz 4,5')
ELSE If B Then
WriteLn('Doskonale. Twoja ocena to 5')
If A Then
{ ----------------------------- }
ReadLn
WriteLn;
F := (Punkty < 60) AND (Punkty >= 0);
WriteLn;
{ Poczatek instrukcji If }
End;
D := (Punkty >= 60) AND (Punkty < 70);
2
Var
Counter := Counter + 1
:Real;
: LiczbyArray;
{ Poczatek petli Repeat }
Write('Podaj liczbe (lub 0, aby skończyć ): ');
WriteLn('Silnia liczby ', Numer,' to ', Silnia:0:0);
Until Licznik = Numer + 1; { Koniec petli Repeat }
Licznik := Licznik + 1;
Silnia := Silnia * Licznik;
Repeat
Licznik := 1;
Silnia := 1;
Pot := Liczby[J];
Begin
{ petla wewnetrzna }
{ zamien elementy }
If Liczby[I] > Liczby[J] Then
Begin
{ petla zewnetrzna }
{ blok opcjonalny }
FOR J := I+1 To RozMac Do
Begin
FOR I := 1 To RozMac-1 Do
{ Sortuj tablice przykład prostego sortowania}
End;
ReadLn(Liczby[I])
Begin
While Numer <> 0 Do
Begin
FOR I := 1 To RozMac Do
{ Czytaj tablice }
Begin
Write('Podaj element nr', I,': ');
{ Poczatek petli While }
Liczby
I, J , Pot : Integer;
Var
ReadLn(Numer);
Write('Podaj liczbe (lub 0, aby skonczyc ): ');
Begin
Licznik, Numer :Integer;
Silnia
Var
PROGRAM Silnia;
LiczbyArray = ARRAY[Zakres] OF Integer;
Type Zakres = 1..RozMac;
Const RozMac = 6;
End.
PROGRAM Sortowanie;
ReadLn
End.
WriteLn;
WriteLn('Srednia liczb = ', Average:0:2);
Write(ORD(Month),' ')
FOR Month := Jan To Dec Do
WriteLn;
WriteLn('Suma liczb = ', Sum:0:2);
WriteLn;
Begin
Average := Sum / N;
End;
{ Koniec petli While }
Month :(Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
PROGRAM Wyliczanie;
:= Sum + Number;
Sum
End.
WriteLn('Jestem tutaj !')
End;
ReadLn(Numer)
ReadLn(Number);
Write('Podaj element nr',Counter,': ');
Begin
While Counter <= N Do
ReadLn(N);
Write('Podaj liczbe elementow: ');
3
{ koniec petli wewnetrznej }
{ koniec petli zewnetrznej }
end;
Potega:= p*Potega(p,w-1);
else
if w=1 Then Potega:= p
begin
Function Potega(p: Integer; w : Integer):Integer;
Var i, j, k : Integer;
Uses unit1;
Program Test_unita;
End.
WriteLn('X=', X, CR, LF, 'Y=', Y, CR, LF, 'Z=', Z)
RaedLn(X, Y, Z);
Write('Podaj trzy liczby: ');
Begin
X, Y, Z :Integer;
Var
CR = CHR(13);
LF = CHR(10);
CONST
PROGRAM Znaki_wyprowadzanie;
End.
ReadLn
WriteLn(Liczby[I]);
FOR I := 1 To RozMac Do
WriteLn('Posortowana tablica: ');
WriteLn; { Wyswietlanie wynikow }
End;
End
End
Liczby[I] := Pot
Liczby[J] := Liczby[I];
End.
k:= silnia(k);
test(j,k);
k:=3;
j:=2;
i:=1;
Begin
4
CONST n_max=20; (* maksymalna liczba elementow *)
TYPE Dane = ARRAY [1..n_max] OF INTEGER;
VAR n : INTEGER;
Procedure test(var liczba : Integer; numer : Integer);
Function Silnia(numer : Integer): Integer;
Implementation
END;
BEGIN
FOR i:=1 TO n DO
Writeln;
Writeln;
Write (' Odczytaj elementy tablicy w kolejnosci');
Writeln;
BEGIN
i :INTEGER; { zmienna kontrolna }
VAR
PROCEDURE Odczyt_tablicy( VAR T:Dane);
(**********************************)
END;
Readln (T[i]);
End.
Write(' element nr= ',i,', T_1[ ' , i ,' ] = ');
if numer > 0 then silnia:= numer * silnia(numer-1);
End;
BEGIN
FOR i:=1 TO n DO
Begin
if numer = 0 then silnia:= 1;
Readln (n);
WriteLn('To jest zmienna lokalna=',lokal);
Write (' Podaj elementy tablicy w kolejnosci');
Writeln;
Write (' Podaj ilosc elementow (n<=20), n= ');
WriteLn('To jest zmienna przekazana przez wartość numer=',numer);
Function Silnia(numer : Integer) : Integer;
Writeln(' Wprowadzanie danych do tablicy ');
End;
BEGIN
lokal:= 3;
VAR i :INTEGER; (* zmienna kontrolna *)
WriteLn('To jest zmienna przekazana przez nazwę liczba=',liczba);
PROCEDURE Wprowadzanie( VAR T:Dane);
numer:= numer+2;
(**********************************)
Liczba:= Liczba*2;
Begin
Var lokal : Integer;
T_1 : Dane;
USES Crt;
Interface
Procedure test(var liczba : Integer; numer : Integer);
PROGRAM Sortowanie_przez_wstawianie;
Unit unit1;
5
min:=b
i, ORZEL, RESZKA, x : INTEGER;
Tak_Nie
VAR a,b, min, mniej : LONGINT;
: CHAR;
VAR
Crt;
USES
PROGRAM Rzut_moneta;
END.
UNTIL NOT (Tak_Nie='T')
Tak_Nie:=UpCase(ReadKey)
Writeln (' Jeszcze raz ?(T)ak');
Writeln;
USES Crt;
END.
REPEAT UNTIL KeyPressed
Writeln;
Odczyt_tablicy (T_1);
Sort_wstaw (T_1);
Wprowadzanie (T_1);
ClrScr;
Writeln(' Z liczb ',a ,' i ',b ,' liczba mniejsza to ',mniej);
mniej:=Mniejsza; (*Przypisanie wyniku funkcji zmiennej *)
Writeln;
ClrScr;
PROGRAM Funkcja_minimum;
(***********************************)
END;
Writeln(' Tablica uporzadkowana');
Writeln;Writeln;
END;
T[k]:=z_p; (* wstawienie danego elementu *)
END;
k:=k-1
T[k-1]:=z_p;
T[k]:=T[k-1];
BEGIN
(* przesuniecie elementow w prawo*)
BEGIN
BEGIN
(* zapamietanie elementu do wstawienia *)
REPEAT
(*************************************)
WHILE (k>1) AND (T[k-1]> T[k]) DO
END;
z_p:=T[k];
Mniejsza:=min; (* Nadanie funkcji wartosci min *)
Else min:=a;
IF a>b THEN
UNTIL a<>b;
k:=i;
BEGIN
FOR i:=2 TO n DO
Writeln;
BEGIN
Readln (b);
(*z_p- zmienna pomocnicza do zamiany elementow *)
Writeln;
Readln (a);
Write (' Podaj liczbe naturalna b= ');
Write (' Podaj liczbe naturalna a= ');
VAR
z_p :INTEGER;
Writeln (' Podaj dwie niezerowe rozne liczby naturalne:');
PROCEDURE Sort_wstaw( VAR T:Dane);
i, k :INTEGER; (* zmienna kontrolna *)
Writeln (' Wyznaczenie liczby mniejszej ');
(***********************************)
REPEAT
BEGIN
ClrScr;
{CIAŁO GŁÓWNE PROGRAMU}
: CHAR;
FUNCTION Mniejsza:LONGINT;
Tak_Nie
END;
END;
Writeln (T[i])
Write(' element nr= ',i,', T_1[ ' ,i ,' ] = ');
6
x:=23;
RESZKA:=RESZKA+1;
FOR x:=1 TO 10 DO
Writeln;
TYPE
Tak_Nie : CHAR;
(****************************)
n,k : INTEGER;
Tab : Tablica;
VAR
ch : CHAR;
y : INTEGER;
x : INTEGER;
Tablica = ARRAY [1 .. Max_el] OF INTEGER;
CONST Max_el = 100;
VAR
f : FILE OF INTEGER;
USES Crt;
Crt;
PROGRAM Kombinacja_n_po_k;
END.
ch:=Readkey;
END;
Writeln(' ',x:2,' - ', y:2);
Read(f,y);
USES
PROGRAM Zmiana_wartosci_elementu;
END.
UNTIL NOT (Tak_Nie='T')
Tak_Nie:=UpCase(ReadKey)
Writeln (' Jeszcze raz ?(T)ak');
Writeln(' Wylosowano reszke.. ', RESZKA:2,' razy');
BEGIN
Writeln(' Po zmianie wartosci na poz. 3 ');
Writeln(' Moneta rzucano ', i,' razy ');
Writeln(' Wylosowano orla.... ', ORZEL:2 ,' razy');
Seek(f,0);
Writeln(' Losowy rzut moneta ');
Write(f,x);
Seek(f,2);
ELSE
END;
Writeln;
END;
Writeln(' ',x:2,' - ', x:2);
Write(f,x);
BEGIN
FOR x:=1 TO 10 DO
Writeln(' Poz. Wartosc ');
IF x=0 THEN ORZEL:=ORZEL+1
x:=RANDOM(2);
BEGIN
FOR i:=1 TO n DO
RESZKA:=0;
ORZEL:=0;
Writeln(' Zmiana wartosci elementu');
RANDOMIZE ;
REWRITE(f);
ASSIGN(f,'plik.dok');
BEGIN
ClrScr;
ClrScr;
n=20;
REPEAT
BEGIN
CONST
7
(* dla Kombinacja *)
Writeln;
END;
ReadLn(k);
Write(' Podaj ilosc elem. podzbioru k: ');
ReadLn(n);
Write(' Podaj ilosc elementow zbioru n: ');
Writeln;
Writeln(' Wyznaczenie wszystkich kombinacji n po k');
ClrScr;
BEGIN
WHILE n<=k DO
BEGIN
(*********************************)
END;
END
Wyswietlanie(k)
ELSE
Kombinacja(a +1, Element+1)
IF a < k THEN
Tab[a] := Element;
BEGIN
FOR Element := b to n - k + a DO
BEGIN
Element : INTEGER;
VAR
PROCEDURE Kombinacja(a, b : INTEGER);
(**********************************)
END;
Writeln;
Write(Tab[Nr_elementu] : 4);
FOR Nr_elementu := 1 TO k DO
END.
REPEAT UNTIL KeyPressed;
VAR Nr_elementu :INTEGER;
(* dla Wyswietlanie *)
Kombinacja(1,1);
Writeln;
PROCEDURE Wyswietlanie(k :INTEGER);
BEGIN
IF n >= k THEN
(**********************************)
8
Data_ur :
Procedure Inicjuj;
Procedure Inicjuj;
Procedure Drukuj;
Procedure Inicjuj;
Procedure Drukuj;
Write(' Podaj Imie: ');
Readln(Imie);
STRING [12];
Writeln;
Write(' Podaj Nazwisko: ');
Readln(Nazwisko);
Write(' Podaj Imie: ');
Readln(Imie);
Write(' Podaj Miejsce urodzenia : ');
(************************)
Procedure Osoba.Drukuj;
BEGIN
Writeln(' Drukowanie zawartosci pol obiektu');
Writeln(' Nazwisko
BEGIN
Procedure Osoba.Drukuj;
END;
Readln(Data_ur);
: ',Data_ur);
Writeln(' Data urodzenia
END;
Write(' Podaj Data urodzenia: ');
: ',Imie);
Writeln(' Miejsce urodzenia : ',Miejsce_ur);
Writeln(' Imie
Readln(Miejsce_ur);
BEGIN
Readln(Data_ur);
END;
: ',Nazwisko);
Procedure Osoba.Inicjuj;
Write(' Podaj Data urodzenia: ');
Readln(Miejsce_ur);
END;
Write(' Podaj Miejsce urodzenia : ');
STRING [20];
Stanowisko
Readln(Nazwisko);
:
Wyksztalcenie :
Kadra = OBJECT(Osoba)
END;
Procedure Drukuj;
STRING [12];
STRING [20];
Write(' Podaj Nazwisko: ');
Writeln(' Wprowadzanie danych do pol obiektu');
BEGIN
Procedure Osoba.Inicjuj;
(*************************)
END;
Miejsce_ur:
Data_ur : STRING[12];
STRING [20];
Imie :
Imie, Miejsce_ur: STRING[20];
STRING [35];
Nazwisko :
Nazwisko : STRING[35];
TYPE Osoba = OBJECT
USES Crt;
USES Crt;
TYPE Osoba = OBJECT
PROGRAM Dziedziczenie_1;
PROGRAM Tworzenie_obiektu_1;
END.
ReadKey;
Osoba_1.Drukuj;
ClrScr;
ReadKey;
Osoba_1.Inicjuj;
ClrScr;
BEGIN
(**********************)
VAR Osoba_1 : Osoba;
9
: ',Imie);
: ',Nazwisko);
Readln(Dane.Nazwisko);
Write('Podaj Imie
Readln(Dane.Imie);
Write('Podaj Plec M/K ',Licznik,'-ej osoby : ');
Readln(Dane.Plec);
Writeln;
ClrScr;
WriteLn('Obiekt po zainicjowaniu przez konstruktor:');
Writeln(' Wprowadzanie danych do pol obiektu');
Osoba_1.Inicjuj;
Kierownik_1.Inicjuj;
Writeln(' Drukowanie zawartosci pol obiektu');
END.
ReadKey;
Kierownik_1.Drukuj;
END.
END;
Write('Podaj Nazwisko ',Licznik,'-ej osoby : ');
BEGIN
Osoba_1.Drukuj;
Readln(Dane.Nr_ew);
',Licznik,'-ej osoby : ');
Write('Podaj Nr_ew
(**********************)
Writeln;
BEGIN
Kierownik_1 : Kadra;
Osoba_1
VAR
Writeln(' Stanowisko
: Osoba;
Writeln(' Dane personalne pracownikow') ;
: ',Wyksztalcenie);
: ',Stanowisko);
Writeln(' Wyksztalcenie
FOR Licznik := 1 TO 5 DO
ClrScr;
END;
BEGIN
Osoba.Drukuj;
: BYTE;
BEGIN
Licznik
: Dane_personalne;
: CHAR
(*******************)
END;
Plec
END;
Procedure Kadra.Drukuj;
Dane
VAR
Readln(Stanowisko);
Write(' Podaj Stanowisko : ');
Readln(Wyksztalcenie);
Write(' Podaj Wyksztalcenie: ');
Osoba.Inicjuj;
Nr_ew
BEGIN
: BYTE;
Procedure Kadra.Inicjuj;
: STRING[20];
Dane_personalne = RECORD
Imie
: ',Data_ur);
TYPE
USES Crt;
PROGRAM Dane_osobowe;
END;
Writeln(' Data urodzenia
Writeln(' Miejsce urodzenia : ',Miejsce_ur);
Writeln(' Imie
Writeln(' Nazwisko
10
BEGIN
TYPE
END;
END;
Write(Lista_p,Dane);
Readln(Dane.Plec);
Write('Podaj Plec M/K ',Licznik,'-ej osoby : ');
Readln(Dane.Imie);
Write('Podaj Imie
Readln(Dane.Nazwisko);
Write('Podaj Nazwisko ',Licznik,'-ej osoby : ');
Readln(Dane.Nr_ew);
Write('Podaj Nr_ew
BEGIN
END.
Odczyt;
Zapisz;
ClrScr;
BEGIN
FOR Licznik := 1 TO 5 DO
(*********************)
ClrScr;
END;
CLOSE(Lista_p);
Writeln(' Dane personalne pracownikow') ;
REWRITE(Lista_p);
ASSIGN(Lista_p,'plik_1a.dan');
BEGIN
Writeln
Write(Dane.Imie,' ');
Write(Dane.Nazwisko,' ');
Write(Dane.Plec);
Licznik
PROCEDURE Zapisz;
: Dane_personalne;
: BYTE;
Dane
Write(Dane.Nr_ew,' ');
Read(Lista_p,Dane);
BEGIN
WHILE NOT Eof(Lista_p) DO
RESET(Lista_p);
(**********************************)
: f_plik;
Lista_p
VAR
f_plik = FILE OF Dane_personalne;
END;
: CHAR
: BYTE;
ASSIGN(Lista_p,'plik_1a.dan');
Plec
Nr_ew
Writeln(' Dane personalne pracownikow');
Writeln;
: STRING[20];
Imie
Writeln;
PROCEDURE Odczyt;
USES Crt;
Dane_personalne = RECORD
END;
PROGRAM Dane_osobowe2;
CLOSE(Lista_p);
11
Write ('Podaj ',n+1,' wartosci wpolczynnika a(n) ');
Write ('- od a(0) do a(',n,'):');
tekst : STRING;
i
Writeln;
var a, b, c : macierz;
Procedure wczytaj_macierz(var m : macierz; roz : Integer);
var i, j : Integer; {Indeksy do przegladania macierzy. }
begin
USES Crt;
VAR
n, i :INTEGER;
a, x, y:REAL;
Randomize;
for j:= 1 to roz do
begin
Writeln ('Obliczenie wartosci wielomianu ');
for i:= 1 to roz do
WriteLn('Wprowadzanie element˘w macierzy: ');
y:=0;
i:=0;
ClrScr;
BEGIN
Type macierz = array[1..rozmiar,1..rozmiar] of Real;
PROGRAM Wielomian;
ClrScr;
Const rozmiar = 5;
Uses Crt;
{ Program demonstrujĄcy podstawowe operacje na macierzach. }
END.
Writeln(' Liczba malych liter ''w'' w tekscie : ',ile);
ile:=ile+1;
IF (tekst[i]='a') THEN
Program Zabawa_z_macierza;
Write ('x = ',x:5:2,', y = ',y:5:2)
ile:=0;
FOR i:=1 TO LENGTH(tekst) DO
Writeln;
Readln(tekst);
UNTIL i>n;
y:=y*x+a;
i:=i+1;
Writeln(' Wyznaczenie liczby malych liter ''a'' w tekscie');
Writeln(' Napisz tekst i nacisnij ENTER');
Readln (a);
Write ('a(',i,') = ');
REPEAT
ClrScr;
BEGIN
(*********************)
ile : INTEGER;
END.
Writeln;
VAR
Writeln;
Readln (x);
USES Crt;
: INTEGER;
Write ('Podaj wartosc x = ');
PROGRAM Obecnosc_litery_a;
Readln (n);
Write ('Podaj stopien wielomianu n = ');
Writeln;
12
o : macierz;
{ Wyzeruj elementy macierzy wynikowej. }
o[j,i]:= m[i,j];
end;
for j:= 1 to roz do
begin
end;
o[i,j]:= m[i,j]+n[i,j];
for j:= 1 to roz do
for i:= 1 to roz do
begin
Procedure dodaj_macierz(var m, n, o : macierz; roz : Integer);
end;
if i= j then WriteLn('Element m[',i,',',j,']:= ',m[i,j]:2:0);
for j:= 1 to roz do
for i:= 1 to roz do
WriteLn('Wyswietlanie przekatnych macierzy: ');
begin
{ Wyzeruj elementy macierzy wynikowej. }
temp : Real;
var i, j : Integer;
function max(m : macierz; r : Integer) : Real;
end;
end;
o[i,j]:= o[i,j] + m[i,k]*n[k,j];
for k:= 1 to roz do
begin
for j:= 1 to roz do
for i:= 1 to roz do
o[i,j]:= 0;
for j:= 1 to roz do
for i:= 1 to roz do
begin
var i, j, k : Integer; {Indeksy do przegladania macierzy. }
Procedure wyswietl_przekatna(var m : macierz; roz : Integer);
Procedure pomnoz_macierz(var m, n, o : macierz; roz : Integer);
end;
end;
end;
WriteLn;
m:= o;
begin
begin
Write( m[i,j]:2:0,' ');
for j:= 1 to roz do
for i:= 1 to roz do
o[i,j]:= 0;
for j:= 1 to roz do
for i:= 1 to roz do
begin
for i:= 1 to roz do
WriteLn('Wyswietlanie elementów macierzy: ');
begin
Procedure wyswietl_macierz(var m : macierz; roz : Integer);
end;
temp : Real;
{ReadLn(m[i,j]);}
end;
Procedure transponuj(var m : macierz; roz : Integer);
end;
WriteLn;
Write('Podaj element m[',i,',',j,']:= ',m[i,j]:2:0);
m[i,j]:= random(10);
13
{ Ciało główne programu. }
element : String[10];
i : Integer;
wsk : wskaznik_stosu;
end;
wskaznik : wskaznik_stosu;
dane : String[10];
komorka_danych = record
wskaznik_stosu = ^komorka_danych;
Dispose(w);
w:=wsk_r;
{ Demonstracja najprostszej struktury dynamicznej opartej na stosie }
wsk_r:= w^.wskaznik;
WriteLn(w^.dane);
Program Stos1;
end.
GotoXY(14,WhereY);
begin
wyswietl_przekatna(c,rozmiar);
ReadKey;
var wsk_r : wskaznik_stosu;
WriteLn('Minimum macierzy: ', min(c,rozmiar):2:0);
{ Procedura usuwajaca wierzcholek ze stosu. }
procedure ze_stosu(Var w : wskaznik_stosu);
WriteLn('Maximum macierzy: ', max(c,rozmiar):2:0);
end;
w^.wskaznik:= wsk_r;
wyswietl_macierz(c,rozmiar);
wyswietl_macierz(c,rozmiar);
w^.dane:= element;
wyswietl_macierz(b,rozmiar);
transponuj(c,rozmiar);
wsk_r:= w;
New(w);
wyswietl_macierz(a,rozmiar);
begin
var wsk_r : wskaznik_stosu;
procedure na_stos(var w : wskaznik_stosu);
var
type
Uses Crt;
elementów, z których tylko najmłodszy jest w danej chwili dostępny.}
{ Stos: to struktura danych składająca się z liniowo uporządkowanych
do nich zmiennych poprzez nazwę. }
{ W tej wersji procedury pracują w oparciu o przekazywanie
pomnoz_macierz(a,b,c,rozmiar);
dodaj_macierz(a,b,c,rozmiar);
wczytaj_macierz(b,rozmiar);
wczytaj_macierz(a,rozmiar); Delay(500);
begin
end;
min:= temp;
if m[i,j] < temp then temp:= m[i,j];
for j:= 1 to r do
for i:= 1 to r do
temp:= 0;
begin
temp : Real;
var i, j : Integer;
function min(m : macierz; r : Integer) : Real;
end;
max:= temp;
if m[i,j] > temp then temp:= m[i,j];
for j:= 1 to r do
for i:= 1 to r do
temp:= 0;
begin
14
else il_elementow:= il_elementow(wp^.wskaznik) + 1;
{ Podstawowa komórka danych. }
ReadLn(tekst);
wk^.dane:=tekst;
While wsk <> Nil do
Repeat Until KeyPressed;
do nich zmiennych poprzez nazwę. }
{ W tej wersji procedury pracują w oparciu o przekazywanie
na początku - tak samo jak w stosie. }
tylko na końcu kolejki "przed nilem", zaś usuwanie elementów tylko
{ Różni się ona od pracy stosu tym, że dołączenie elementów odbywa się
{ Program demonstrujący prace kolejki.}
Program Kolejka1;
end.
else - przesuwanie konca kolejki }
begin
if wp <> Nil then
begin
var wsk_r : wskaznik;
{ Jesli kolejka nie jest pusta to...}
procedure z_kolejki(var wp, wk : wskaznik);
end;
{ Przypadek dopisywania pierwszego el. do listy
wp:= wk else wsk_r^.wsk:= wk;
ze_stosu(wsk);
end;
if (wp = Nil) and (wsk_r = Nil) then
{ Pobieramy nastepny element danych. }
{ Pobieramy nowy wskaznik. }
Inc(i); Write(i);
wk^.wsk:= Nil;
New(wk);
WriteLn('Wyswietlam zawartosc stosu : (',il_elementow(wsk), ' element˘w)');
WriteLn('Lp. element: ');
begin
wsk_r:= wk;
begin
{ wp - wskaznik poczatka kolejki}
{ wk - wskaznik konca kolejki}
Writeln('Koniec budowania stosu');
end;
If element <> 'k' then na_stos(wsk);
ReadLn(element);
begin
While element <> 'k' do
procedure do_kolejki(var wp, wk : wskaznik);
wybor : Char;
wsk:= Nil;
i:= 0;
i, j : Integer;
tekst : String[10];
WriteLn('Podaj kolejne wyrazy do wstawienia na stos (k- kończy pracę programu)');
var pocz_kolejki, kon_kolejki, wsk_rob : wskaznik;
end;
wsk : wskaznik;
dane : String[10];
komorka = record
{ Wskaznik danych }
ClrScr;
begin
end;
if wp= Nil then il_elementow:= 0
begin
type wskaznik = ^komorka;
function il_elementow(wp : wskaznik_stosu) : Integer;
{ Funkcja zlicza rekurencyjnie kolejne elementy stosu. }
uses Crt;
end;
15
end
{ usuniety, to wpisz Nil na koncu }
else il_elementow:= il_elementow(wp^.wsk) + 1;
il_elementow(wp));
'2': z_kolejki(pocz_kolejki, kon_kolejki);
WriteLn('Lp: element:');
j:=0; { Wyzeruj licznik elementow kolejki. }
ClrScr;
begin
var j : Integer; {Licznik element˘w}
procedure wyswietl_kolejke(wp: wskaznik);
end.
end;
end;
'4': exit;
end;
'3': wyswietl_kolejke(pocz_kolejki);
if wk <> Nil then WriteLn(wk^.dane) else WriteLn;
WriteLn('4- Koniec programu');
Ostatni element : ');
'1': do_kolejki(pocz_kolejki, kon_kolejki);
case wybor of
ReadLn(wybor);
if wp <> Nil then WriteLn(wp^.dane) else WriteLn;
Pierwszy element : ');
wyswietl_menu(pocz_kolejki, kon_kolejki);
begin
ReadKey;
Write('3- Wy˜wietl kolejk©
Write('2- Usuä z kolejki
Liczba elementow listy :',
While wybor <> '4' do
kon_kolejki:=Nil;
WriteLn('1- Dopisz do kolejki
ClrScr;
begin
pocz_kolejki:=Nil;
{ Parametry zostaˆy przekazane przez wartosc }
ClrScr;
begin
end;
Write('Nacisnij dowolny klawisz...');
end;
wp:=wp^.wsk;
Writeln(j,'. ',wp^.dane); { Przegladanie kolejki aľ do koäca. }
Inc(j);
end;
ClrScr;
ReadKey;
{ Wyswietlanie menu }
procedure wyswietl_menu(wp, wk : wskaznik);
end;
if wp = Nil then il_elementow:= 0
begin
{ Funkcja zlicza rekurencyjnie elementy kolejki }
function il_elementow(wp : wskaznik) : Integer;
end;
Write('Nacisnij dowolny klawisz... ');
begin
}
wp:=wsk_r^.wsk;
if wp = Nil then wk:= Nil; { Jesli ostatni element zostal
if (j mod 23 = 0) and (j <> 0) then
begin
Write(wp^.dane);
Dispose(wp);
While wp <> Nil do
wsk_r:= wp;
16
Dec(eb);
ReadKey;
begin
end;
ReadLn(pesel);
Write('Podaj PESEL:
ReadLn(imie);
Write('Podaj Imię:
ReadLn(nazwisko);
');
');
Write('Podaj Nazwisko: ');
begin
with baza[eb] do
end;
end;
else
Inc(eb);
WriteLn('BAZA DANYCH JEST PUSTA !!!');
begin
WriteLn('Przekroczona maksymalna ilość elementów bazy !!!');
end
else
end
ClrScr;
begin
if eb+1 > MAX then
baza[i]:= baza[i+1];
for i:= temp to eb DO
begin
procedure dodaj_rekord;
ReadLn(temp);
Write('Podaj numer rekordu do usunięcia: ');
Until (temp in [1..eb]); { Czekaj na poprawny numer. }
wybor: Char;
Repeat
WriteLn;
eb : Integer; { Bieżący rekord bazy. }
baza : tab_osoby;
WriteLn(' ==============================');
osoba : osoby;
WriteLn(' W BAZIE JEST ',eb,' - REKORDÓW');
function StrComp(a, b: String) : Integer; forward;
Var
tab_osoby = array [1..MAX] of osoby;
begin
if eb > 0 then
pesel : Integer;
end;
ClrScr;
begin
i : Integer;
imie : String[15];
nazwisko : String[20];
Type osoby = record
var temp : Integer;
procedure usun_rekord;
NAZWA = 'BAZA.DAT';
end;
Const MAX = 10; { Maksymalna liczba elementów bazy. }
end;
Uses Crt;
Program Baza_danych;
17
{ Ustaw plik w pozycji do zapsiu od nowa...}
Write(plik, baza[i]);
for i:= 1 to eb do
Rewrite(plik);
Assign(plik,NAZWA); { Otwórz archiwum bazy...}
begin
i : Integer;
var plik : file of osoby;
procedure zapisz_baze;
end;
ReadKey;
end;
end;
end;
przestawil:= True;
baza[i+1]:= temp;
baza[i]:= baza[i+1];
temp:= baza[i];
begin
if StrComp(baza[i].nazwisko,baza[i+1].nazwisko) > 0 then
for i:= 1 to eb-1 do
przestawil:= False;
begin
while przestawil do
przestawil:= True;
end
begin
temp : osoby;
else WriteLn('BAZA DANYCH JEST PUSTA !!!');
end;
GoToXY(46, WhereY); WriteLn(baza[j].pesel);
i : Integer;
var przestawil : Boolean;
GoToXY(6, WhereY); Write(baza[j].nazwisko);
GoToXY(27, WhereY); Write(baza[j].imie);
procedure sortowanie_b;
Write(j,'.');
end;
end;
ReadKey;
ClrScr;
end;
Close(plik);
Inc(eb);
begin
while not EoF(plik) do
eb:= 0;
Read(plik, baza[eb+1]);
PESEL:');
{ Ustaw plik w pozycji do odczytu od poczatku...}
begin
Imie:
Reset(plik);
Assign(plik,NAZWA); { Otwórz archiwum bazy...}
if (j mod 23 = 0) and (j > 0) then
begin
for j:=1 to eb do
WriteLn('Lp: Nazwisko:
begin
if eb > 0 then
begin
var plik : file of osoby;
ClrScr;
begin
end;
procedure wczytaj_baze;
}
Close(plik);
var j: Integer;
{ Wyświetl zawartość bazy.
procedure wyswietl_baze;
18
Liczba elementow bazy :',eb);
'4': Zapisz_baze;
'3': Wyswietl_baze;
'2': Usun_rekord;
'1': Dodaj_rekord;
case wybor of
ReadLn(wybor);
wyswietl_menu;
begin
eb:= 0;
ClrScr;
begin
end;
WriteLn('6- Posortuj bazę -metoda bąbelkowa');
WriteLn('5- Wczytaj baze z pliku BAZA.DAT');
WriteLn('4- Zapisz baze do pliku BAZA.DAT');
WriteLn('3- Wyswietl baze');
WriteLn('2- Usun z bazy');
WriteLn('1- Dopisz do bazy
WriteLn(' ========================================= ');
WriteLn(' PROGRAM BAZA DANYCH - STRUKTURA TABLICA ');
ClrScr;
begin
{ Wyswietlanie menu. }
procedure wyswietl_menu;
end;
if a < b then StrComp:= -1;
if a = b then StrComp:= 0;
if a > b then StrComp:= 1;
begin
function StrComp(a, b: String) : Integer;
end.
end;
end;
'7': exit;
'6': Sortowanie_b;
'5': Wczytaj_baze;
19
wybor : Char;
wb : wskaznik; { Wskaźnik bieżącego położenia }
poczatek : wskaznik; { Wskaźnik początku }
{ Pobieramy nowy wskaznik.
}
end;
{ Koniec wstaw_na_koncu. }
else k^.wsk:= n;
if wp = Nil then wp:= n { Zapamietujemy pierwszy element. }
n^.wsk:= Nil;
n^.dane:= liczba;
New(n);
While k^.wsk <> Nil do k:=k^.wsk;
k:= wp;
begin
var n, k : wskaznik;
procedure wstaw_na_koncu(var wp : wskaznik; liczba : Integer);
function sz_element(wp : wskaznik; nr : Integer) : wskaznik; forward;
function il_elementow(wp : wskaznik) : Integer; forward;
var
end;
{ Wskaznik danych }
{ Podstawowa komórka danych. }
wsk : wskaznik;
dane : Integer;
komorka = record
type wskaznik = ^komorka;
{ Zamiana wartosci elementow 'p' i 'n'.}
wstaw_przed(wsk_r, liczba); { Wstawienie przed elementem. }
var wsk_r, temp : wskaznik;
procedure z_listy(var wp, wb : wskaznik);
end;
{ Wariant ze wstawieniem na koncu. }
if not (liczba = wsk_r^.dane) then {Jesli element nie powtórzony ..}
else
if wsk_r = Nil then wstaw_na_koncu(wp, liczba)
end;
wsk_r:=wsk_r^.wsk;
begin
While (wsk_r <> Nil) AND (liczba < wsk_r^.dane) do
ReadLn(liczba);
wsk_r:= wp;
begin
liczba : Integer;
Elementy powtarzające się nie są wstawiane.}
{ Wstawianie do listy na odpowiednie miejsce.
procedure do_listy(var wp : wskaznik);
end;
w^.dane:= liczba;
w^.wsk:= n;
end;
wsk:= w^.wsk;
{ Wstawienie po elemencie p. }
wstawic nowy element. }
dane:= w^.dane;
begin
które muszą uwzględniać istniejący porządek listy. }
uses Crt, Strings;
With n^ do
New(n);
begin
{ w wskazuje na element, przed ktory nalezy
var n : wskaznik;
procedure wstaw_przed(var w : wskaznik; liczba : Integer);
odróżnia od kolejki forma procedur dodawania i usuwania składników,
{ Lista jednokierunkowa to jedna z odmian struktury listowej, którą
miejscu można usunąć lub dołączyć składnik. }
{ Lista (liniowa) to uporządkowany zbiór składników, z którego w dowolnym
listy jednokierunkowej. }
{ Program demonstrujący działanie
Program Lista_jednokierunkowa;
20
{ Jeśli lista nie jest pusta to...}
{ Funkcja zlicza rekurencyjnie elementy listy }
end;
end;
end;
wb:= wsk_r^.wsk;
{ i przyklejam ogon listy. }
end;
WriteLn('3- Wyswietl liste');
if wp <> NIl then WriteLn(wp^.dane) else WriteLn;
{ zwalniam pamięć usuwanego elementu.. }
Write('2- Usun z listy
Poczatek listy : ');
Liczba elementow listy :',
wsk_r^.wsk:= wb^.wsk; { Rozcinam listę.. }
il_elementow(wp));
Dispose(wb);
end;
WriteLn('1- Dopisz do listy
WriteLn(' =================================== ');
wsk_r:= wsk_r^.wsk;
WriteLn(' WARIANT LISTY ZAWIERAJĄCEJ LICZBY ');
ClrScr;
begin
begin
{ w przeciwnym razie szukaj poprzednika.. }
procedure wyswietl_menu(wp : wskaznik);
end;
sz_element:= wp;
end;
Inc(i);
wp:= wp^.wsk;
begin
While wsk_r^.wsk <> wb do
begin
else
end
wp:= wb;
Dispose(wp);
wb:= wp^.wsk;
begin
if wp= wb then { Jeśli to jest pierwszy element to.. }
wsk_r:= wp;
ReadKey;
ofset: ',ofs(wb^.wsk));
while (wp^.wsk <> Nil) and (i < nr) do
'
i:= 1;
wb:= sz_element(wp,nr); { Odnajdujemy wskaznik na usuwany element. }
begin
var i : Integer;
function sz_element(wp : wskaznik; nr : Integer) : wskaznik;
end;
else il_elementow:= il_elementow(wp^.wsk) + 1;
if wp = Nil then il_elementow:= 0
begin
function il_elementow(wp : wskaznik) : Integer;
Writeln('Usuwam element nr:',nr,' ',wb^.dane,' segment: ',seg(wb^.wsk),
Until (nr in [1..il_elementow(wp)]); { Czekaj na właściwy numer. }
Read(nr);
Repeat
il_elementow(wp),')');
WriteLn('Podaj numer elementu do usunięcia z przedzialu (1 - ',
ClrScr;
begin
if wp <> Nil then
begin
nr : Integer;
21
While wp <> Nil do
ofset: ',ofs(wp^.wsk));
'1': do_listy(poczatek);
procedure dodaj_pytanie(Var wsk : wskaznik_do_pytan);
wybor : Char;
case wybor of
ReadLn(wybor);
il_pyt : Integer; {Ilosc pytan zdefiniowanych w bazie}
wsk : wskaznik_do_pytan;
pytanie : pojemnik_na_pytania;
wiedza : Real;
Var
end;
wskaznik : wskaznik_do_pytan;
pytania : dane;
pojemnik_na_pytania = record
wskaznik_do_pytan = ^pojemnik_na_pytania;
end;
nr_popr : Integer;
odp : array[1..l_odp] of String;
pyt : String;
dane = record
Type
wyswietl_menu(poczatek);
begin
poczatek:=Nil;
ClrScr;
begin
end;
ReadKey;
end;
wp:=wp^.wsk;
{ Przegladanie listy aż do końca.}
'
Writeln(j,'. ',wp^.dane,' segment: ',seg(wp^.wsk),
Inc(j);
end;
plik2 = 'config.txt';
{Plik do udoskonalania pracy programu}
plik1 = 'pytania.dat'; {Plik zawierajĄcy pytania i odpowiedzi}
ClrScr;
Const l_odp = 4;
Uses Crt;
przeprowadzanie testu i ocenianie}
{wpisywanie pytan i odpowiedzi, losowanie pytan
Program test; {Przyklad programu demonstrujacego dzialanie testu
end.
end;
end;
'4': exit;
'3': wyswietl(poczatek);
'2': z_listy(poczatek, wb);
ReadKey;
begin
if (j mod 23 = 0) and (j <> 0) then
begin
}
{ Wyzeruj licznik elementow listy. }
{ Wyświetl zawartość listy.
WriteLn('Lp: element:');
j:=0;
ClrScr;
begin
var j: Integer;
procedure wyswietl(wp : wskaznik);
22
Until (nr_popr in [1..l_odp]);
WriteLn('Podaj nowe pytanie: ');
begin
with wsk^.pytania do
New(wsk);
begin
else
{Dokladamy pierwszy element}
wsk^.wskaznik:= temp;
end;
ClrScr;
ReadKey;
begin
if (j*l_odp mod 40 = 0) then
begin
while wsk <> Nil do
23
WriteLn('======================================================================');
j:= 1;
WriteLn(' Lp: Pytania i odpowiedzi wpisane do bazy. *- odpowiedz prawidlowa');
begin
if wsk <> Nil then
ClrScr;
begin
var i, j : Integer;
{ Wyswietl zawartosc bazy pytan }
procedure wyswietl_baze_pytan(wsk : wskaznik_do_pytan);
ReadLn(nr_popr);
end;
end
wsk^.wskaznik:= Nil; {Koniec struktury pokazuje na Nil-a}
end;
end;
il_pyt:= 1;
end;
Write('Podaj numer poprawnej odpowiedzi: ', '[1..',l_odp,']:= ');
Repeat
end;
ReadLn(odp[i]);
WriteLn('Odpowiedz nr ',i,' ');
begin
for i:= 1 to l_odp do
ReadLn(pyt);
WriteLn('Podaj nowe pytanie: ');
begin
with wsk^.pytania do
il_pyt:= il_pyt+1;
New(wsk); {Utw˘rz adres wskazujĄcy na nowy pojemnik}
temp:= wsk;
Until (nr_popr in [1..l_odp]);
ReadLn(nr_popr);
begin
Write('Podaj numer poprawnej odpowiedzi: ', '[1..',l_odp,']');
if wsk <> Nil then {Jest conajmniej jeden element na stosie}
Repeat
end;
ReadLn(odp[i]);
WriteLn('Odpowiedz nr ',i,' ');
begin
for i:= 1 to l_odp do
ReadLn(pyt);
WriteLn(' ==================================================================');
WriteLn(' WPROWADZANIE KOLEJNYCH PYTAN DO PROGRAMU "TEST" -struktura stosowa');
ClrScr;
begin
pytanie : pojemnik_na_pytania;
i : Integer;
var temp : wskaznik_do_pytan;
{oraz jego odpowiedzi}
{Tutaj trafia oryginaˆ zmiennej wsk}
{ Ustaw plik w pozycji do zapisu od nowa...}
ReadLn(znak);
else
NIE: n/N ');
if (znak='t') or (znak='T') then {zastepujemy istniejacy stos}
Until (znak in ['t','T','n','N']);
Close(plik);
end
Write('TAK: t/T
Repeat
wsk:= wsk^.wskaznik;
end;
WriteLn('znajdujacych sie w pliku ', plik1,'? ');
WriteLn('Czy zastapic istniejace dane zestawem pytan ');
begin
if wsk <> Nil then
begin
znak : Char;
temp : wskaznik_do_pytan;
var plik : file of dane;
procedure wczytaj_baze(Var wsk : wskaznik_do_pytan);
end;
Write(plik, wsk^.pytania);
begin
for i:= 1 to il_pyt do
While wsk <> Nil do
Rewrite(plik);
Assign(plik,plik1); { Otworz archiwum bazy pytan...}
begin
if wsk <> Nil then
begin
i : Integer;
var plik : file of dane;
procedure zapisz_baze(wsk : wskaznik_do_pytan);
{Zwracana warto˜† funkcji}
usun_stos:= Nil; {Ten zapis musi wystĄpi† wewnĄtrz kaľdej funkcji}
end;
wsk:= temp;
end;
Dec(il_pyt);
ReadKey;
WriteLn('Brak jest pytan w bazie !!!');
temp:= wsk^.wskaznik;
Dispose(wsk);
else
while wsk<> Nil do
begin
var temp : wskaznik_do_pytan;
function usun_stos(var wsk : wskaznik_do_pytan) : wskaznik_do_pytan;
begin
{zaznaczajĄc odpowiedz poprawnĄ *}
end;
end
end;
Inc(j);
wsk:= wsk^.wskaznik;
end;
WriteLn;
if wsk^.pytania.nr_popr= i then write(' -*-');
GoToXY(27, WhereY); Write(i,'. ',wsk^.pytania.odp[i]);
ReadKey; end;
begin
WriteLn('Brak jest pytan w bazie !!!');
{Wy˜wietl tre˜† pytania}
for i:=1 to l_odp do
begin
GoToXY(6, WhereY); WriteLn(wsk^.pytania.pyt);
Write(j,'.');
24
{Jezeli zestaw nie jest pusty to zaczynamy...}
ReadKey;
end;
Close(plik);
temp3:= temp1^.wskaznik
if temp1 <> Nil then
end;
Inc(i);
end;
temp1:= temp1^.wskaznik; {kolejnych element˘w stosu}
if il_pyt = 0 then wsk^.wskaznik:= Nil else wsk^.wskaznik:= temp;
Inc(il_pyt);
{temp2 jest "wartownikiem" przy odliczaniu}
{ustaw sie na pytaniu do usuniecia}
temp2:= temp1;
begin
While i<j do
{Usuwanie ze srodka lub konca wariant trudniejszy}
Read(plik, wsk^.pytania);
New(wsk);
temp:= wsk;
i:= 1;
begin
Reset(plik);
begin
end
else
Assign(plik,plik1);
Dec(il_pyt);
wsk:= temp1;
{Wczytywanie danych gdy stos jest pusty}
else
begin
Dispose(wsk);
end
temp1:= temp1^.wskaznik; {Wystarczy pos uľy† si© tylko jednĄ zmiennĄ pomocniczĄ}
begin
if j=1 then
{zwykle usuwanie glowy stosu}
Until (j in [1..il_pyt]);
ReadLn(j); {Zabezpieczenie aby pytania pochodzi y z bieľĄcego zakresu}
Write('Podaj numer pytania do usunięcia ([1..',il_pyt,']:= ');
Repeat
WriteLn;
wyswietl_baze_pytan(wsk); {Wy˜wietlamy baz© pytaä}
end;
{wersja z tzw. wartownikiem}
{kontrolowane wyjmowanie element˘w ze stosu}
temp1:= wsk; {Zapami©tujemy wsk aby nie zgubi† gôwy stosu}
begin
if wsk<> Nil then
begin
WriteLn('Pozostawiam aktualnie wczytane dane !');
begin
else
end
Close(plik);
end;
Inc(il_pyt);
if il_pyt = 0 then wsk^.wskaznik:= Nil else wsk^.wskaznik:= temp;
Read(plik, wsk^.pytania);
New(wsk);
temp:= wsk;
begin
temp1, temp2, temp3 : wskaznik_do_pytan; {Zmienne pomocnicze umoľliwiajĄce
var i, j : Integer;
Reset(plik);
end;
procedure usun_pytanie(var wsk : wskaznik_do_pytan);
{stosem z pliku}
Assign(plik,plik1);
Usun_stos(wsk);
begin
25
end;
end;
Write(i,'.');
GoToXY(6, WhereY); WriteLn(temp1^.pytania.pyt);
WriteLn('=================================');
for i:= 1 to los do
end;
Inc(j);
WriteLn(' Wylosowano nastepujace pytania: ');
temp1:= temp1^.wskaznik;
{temp2 jest "wartownikiem"}
{ustaw sie na pytaniu do usuniecia}
ocena:= (1/los)*100; {Wyliczenie w procentach warto˜ci jednego pytania.}
temp2:= temp1;
begin
While j<wynik do
{Usuwanie ze srodka lub konca}
Until (los in [1..il_pyt]);
ReadLn(los);
Write('Podaj liczbe pytan do wylosowania z przedzialu : ', '[1..',il_pyt,']');
Repeat
j:= 1;
begin
{Losowanie numer˘w pytan w zakresie 1..il_pyt}
WriteLn('==========================================');
Randomize;
end
else
ClrScr; wiedza:= 0;
Dec(los);
Dec(il_pyt);
wsk:= temp1; {gdy wylosowano pierwsze pytanie}
Dispose(wsk); {Zwykê usuni©cie gôwy stosu}
temp1:= wsk^.wskaznik;
If (odp_u = wsk^.pytania.nr_popr) then wiedza:= wiedza+ocena;
Until (odp_u in [1..l_odp]);
ReadLn(odp_u);
Write('Podaj numer poprawnej odpowiedzi [1..',l_odp,']: ');
Repeat
WriteLn(' Losowanie pytan do przeprowadzenia testu.');
begin
if wsk<>Nil then {Jeľeli nie jest pusty moľna rozpoczĄ† losowanie}
begin
kopia, temp1, temp2, temp3 : wskaznik_do_pytan;
ocena : Real;
odp_u : Integer; {Numer odpowiedzi wybrany przez ucznia.}
los : Word;
var i,j,k,wynik : Integer;
losowania tych samych pytan. }
pytania usuwajac je z kopii stosu, aby uniknac wielokrotnego
if wsk^.pytania.nr_popr= k then write(' -*-');
WriteLn;
{ Procedura przeprowadzania testu losuje zadana ilosc razy
GoToXY(27, WhereY); Write(k,'. ',wsk^.pytania.odp[k]);
begin
for k:=1 to l_odp do {Wy˜wietl pytanie i dost©pne odpowiedzi}
GoToXY(6, WhereY); WriteLn(wsk^.pytania.pyt);
Write(i,'.');
{zwykle usuwanie glowy stosu}
{Zapami©tanie gôwy stosu}
procedure przeprowadz_test(var wsk : wskaznik_do_pytan);
end;
else; {Nic nie rob- ewentualnie informuj ľe brak jest pytaä do usuwania}
end
begin
if wynik=1 then
{ Zniszcz wskaznik do wybranego pytania}
Dispose(temp1);
Dec(il_pyt);
temp1:= wsk;
wynik:= Random(los-1)+1; {Losowanie w przedziale 1-los}
begin
temp2^.wskaznik:= temp3; { Sklej oba konce}
temp3:= Nil;
else
26
'4': zapisz_baze(wsk);
Dispose(temp1);
WriteLn('4- Zapisz pytania do pliku ',plik1);
WriteLn('3- Wyswietl wszystkie pytania');
WriteLn('2- Usun pytanie');
WriteLn('1- Dopisz pytanie Liczba pytan: ',il_pyt, ' Ocena: ',wiedza:4:0,' %');
WriteLn(' =================================================== ');
WriteLn(' PROGRAM DO PRZEPROWADZANIA TESTOW - STRUKTURA STOS ');
ClrScr;
begin
procedure wyswietl_menu;
end;
end;
ReadKey;
end;
end;
end.
end;
end;
exit;
usun_stos(wsk);
'7': begin
'6': przeprowadz_test(wsk);
Dec(los);
end;
'5': wczytaj_baze(wsk);
Dec(il_pyt);
{ Zniszcz wskaznik do wybranego pytania}
'3': wyswietl_baze_pytan(wsk);
'2': usun_pytanie(wsk);
'1': Dodaj_pytanie(wsk);
case wybor of
temp2^.wskaznik:= temp3; { Sklej oba konce}
temp3:= Nil;
else
temp3:= temp1^.wskaznik
wyswietl_menu;
ReadLn(wybor);
if temp1 <> Nil then
begin
if odp_u = temp1^.pytania.nr_popr then wiedza:= wiedza+ocena;
Until (odp_u in [1..l_odp]);
il_pyt:= 0; wsk:= Nil; {Zainicjowanie bazy pytan. }
ReadLn(odp_u);
ClrScr;
begin
end;
WriteLn('6- Przeprowadz test');
WriteLn('5- Wczytaj pytania z pliku ',plik1);
Write('Podaj numer poprawnej odpowiedzi [1..',l_odp,']:*** ');
Repeat
end;
WriteLn;
if temp1^.pytania.nr_popr= k then write(' -*-');
GoToXY(27, WhereY); Write(k,'. ',temp1^.pytania.odp[k]);
begin
for k:=1 to l_odp do {Wy˜wietl znalezione pytanie i odpowiedzi dla niego}
27

Materiały pomocnicze do wykładu

Transkrypt

Podobne dokumenty

Pierwszy program w Pascalu Kod programu

Ćwiczenie 1

Delphi to środowisko programistyczne oparte na języku Object

L3. Podstawy zapisywania programu w języku Pascal

Program obsługujący pliki elementowe

Pytania z języka Pascal.

Ćw 3. Delphi – Podprogramy (procedury i funkcje) Procedury

Delphi 1 - równanie kwadratowe

Materiały do wykładu 3