Home > Free Pascal, UwB > Laborki z Pascala – Lista 6

Laborki z Pascala – Lista 6

Grudzień 6th, 2009 Katharsis Zostaw komentarz Idź do komentarzy

Udostępniam rozwiązania Listy 6!

Laboratorium 6

Zadanie 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

PROGRAM lista6_zad1(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE WypelnijTablice(a, b : INTEGER);
		VAR
			tablica : ARRAY OF INTEGER;
			x : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			FOR x := 0 TO (a - 1) DO
				tablica[x] := RANDOM(b) + 1;
 
			FOR x := 0 TO (a - 1) DO
				WRITE(tablica[x], ' ');
		END;
 
BEGIN
	CLRSCR;
 
	WypelnijTablice(10, 20);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele procedury WypelnijTablice. Ilość liczb oraz ich zakres podaje użytkownik w postaci parametrów aktualnych. W treści zadania nie zostało sprecyzowane, czy algorytm losowania ma eliminować duplikaty, dlatego też przedstawiłem go w najprostszej postaci.

Zadanie 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

PROGRAM lista6_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION PoliczSrednia(a, b : INTEGER) : REAL;
		VAR
			tablica : ARRAY OF INTEGER;
			x, wynik : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			wynik := 0;
 
			FOR x := 0 TO (a - 1) DO
				BEGIN
					tablica[x] := RANDOM(b) + 1;
					wynik := wynik + tablica[x];
				END;
 
			PoliczSrednia := wynik / a;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN(PoliczSrednia(10, 20):0:1);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele funkcji PoliczSrednia, po czym obliczam średnią z tych liczb.

Zadanie 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

PROGRAM lista6_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION PoliczSume(a, b : INTEGER) : REAL;
		VAR
			tablica : ARRAY OF INTEGER;
			x, wynik : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			wynik := 0;
 
			FOR x := 0 TO (a - 1) DO
				BEGIN
					tablica[x] := RANDOM(b) + 1;
					wynik := wynik + tablica[x];
				END;
 
			PoliczSume := wynik;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN(PoliczSume(10, 20):0:1);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele funkcji PoliczSume, po czym obliczam sumę wszystkich liczb.

Zadanie 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

PROGRAM lista6_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE WyznaczMax(a, b : INTEGER);
		VAR
			tablica : ARRAY OF INTEGER;
			x, max, pozycja: INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			max := 0;
 
			FOR x := 0 TO (a - 1) DO
				BEGIN
					tablica[x] := RANDOM(b) + 1;
 
					IF tablica[x] > max THEN
						BEGIN
							max := tablica[x];
							pozycja := x + 1;
						END
 
					ELSE
						CONTINUE;
				END;
 
			WRITELN(max, ', ', pozycja);
		END;
 
BEGIN
	CLRSCR;
 
	WyznaczMax(10, 20);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele procedury WyznaczMax. Następnie, na podstawie porównania wyznaczam maksymalną liczbę wraz z jej pozycją w ciągu.

Zadanie 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

PROGRAM lista6_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION OdszukajElement(a, b, c : INTEGER) : INTEGER;
		VAR
			tablica : ARRAY OF INTEGER;
			x : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, b);
			RANDOMIZE;
 
			FOR x := 0 TO (b - 1) DO
				BEGIN
					tablica[x] := RANDOM(c) + 1;
 
					IF a = tablica[x] THEN
						BEGIN
							OdszukajElement := x + 1;
							EXIT;
						END
 
					ELSE
						CONTINUE;
				END;
 
			OdszukajElement := -1;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN(OdszukajElement(5, 10, 20));
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele funkcji OdszukajElement. Następnie, każdą z tych liczb porównuję z liczbą podaną przez użytkownika, zwracając ustaloną w treści zadania wartość. W sytuacji kiedy liczby są sobie równe, zwracam pozycję liczby, w przeciwnym wypadku (brak szukanego elementu) -1. W związku z tym, że w (Free) Pascalu zwracanie danych przez funkcję wcale nie kończy jej działania, wykorzystałem instrukcję EXIT, która “wychodzi” z funkcji i wraca do głównego ciała programu.

Zadanie 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

PROGRAM lista6_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE WyswietlTablice(a, b : INTEGER);
		VAR
			tablica : ARRAY OF INTEGER;
			x : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			FOR x := 0 TO (a - 1) DO
				tablica[x] := RANDOM(b) + 1;
 
			FOR x := (a - 1) DOWNTO 0 DO
				WRITE(tablica[x], ' ');
		END;
 
BEGIN
	CLRSCR;
 
	WyswietlTablice(10, 20);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele procedury WyswietlTablice, po czym wyświetlam jej elementy w odwrotnej kolejności.

Zadanie 7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

PROGRAM lista6_zad7(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION ZliczParzyste(a, b : INTEGER) : INTEGER;
		VAR
			tablica : ARRAY OF INTEGER;
			x, ilosc : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			ilosc := 0;
 
			FOR x := 0 TO (a - 1) DO
				BEGIN
					tablica[x] := RANDOM(b) + 1;
 
					IF (tablica[x] MOD 2) = 0 THEN
						ilosc := ilosc + 1
 
					ELSE
						CONTINUE;
				END;
 
			ZliczParzyste := ilosc;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN(ZliczParzyste(10, 20));
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele funkcji ZliczParzyste. Następnie, na podstawie dzielenia modulo i zwracanej wartości zliczam ilość elementów parzystych w tablicy.

Zadanie 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

PROGRAM lista6_zad8(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE SortujTablice(a, b : INTEGER);
		VAR
			tablica : ARRAY OF INTEGER;
			x, y, temp : INTEGER;
 
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			FOR x := 0 TO (a - 1) DO
				tablica[x] := RANDOM(b) + 1;
 
			FOR x := 0 TO (a - 2) DO
				BEGIN
					FOR y := (a - 1) DOWNTO (x + 1) DO
						BEGIN
							IF tablica[y - 1] > tablica[y] THEN
								BEGIN
									temp := tablica[y];
									tablica[y] := tablica[y - 1];
									tablica[y - 1] := temp;
								END
 
							ELSE
								CONTINUE;
						END;
				END;
 
			FOR x := 0 TO (a - 1) DO
				WRITE(tablica[x], ' ');
		END;
 
BEGIN
	CLRSCR;
 
	SortujTablice(10, 20);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam tablicę (dynamiczną) losowymi liczbami całkowitymi, zadeklarowaną w ciele procedury SortujTablice. Następnie, sortuję elementy tablicy, wykorzystując algorytm sortowania bąbelkowego.

Zadanie 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

PROGRAM lista6_zad9(INPUT, OUTPUT);
 
USES
	CRT;
 
CONST
	LINIA = CHR(13) + CHR(10);
	rozmiar = 10;
	przedzial = 20;
 
VAR
	x : INTEGER;
	tablica : ARRAY OF INTEGER;
	wybor : CHAR;
 
	// Wybór 1 :: WypelnijTablice
	PROCEDURE WypelnijTablice(a, b : INTEGER);
		BEGIN
			SETLENGTH(tablica, a);
			RANDOMIZE;
 
			FOR x := 0 TO (a - 1) DO
				tablica[x] := RANDOM(b) + 1;
 
			TEXTCOLOR(WHITE);
			WRITE(LINIA, 'Wynik: ');
 
			FOR x := 0 TO (a - 1) DO
				WRITE(tablica[x], ' ');
 
			READLN;
		END;
 
	// Wybór 2 :: WyznaczMax
	PROCEDURE WyznaczMax(a, b : INTEGER);
		VAR
			max, pozycja: INTEGER;
 
		BEGIN
			max := 0;
 
			FOR x := 0 TO (a - 1) DO
				BEGIN
					IF tablica[x] > max THEN
						BEGIN
							max := tablica[x];
							pozycja := x + 1;
						END
 
					ELSE
						CONTINUE;
				END;
 
			TEXTCOLOR(WHITE);
			WRITELN(LINIA, 'Wynik: ', max, ', ', pozycja);
 
			READLN;
		END;
 
	// Wybór 3 :: WyswietlTablice
	PROCEDURE WyswietlTablice(a, b : INTEGER);
		BEGIN
			TEXTCOLOR(WHITE);
			WRITE(LINIA, 'Wynik: ');
 
			FOR x := (a - 1) DOWNTO 0 DO
				WRITE(tablica[x], ' ');
 
			READLN;
		END;
 
	// Wybór 4 :: SortujTablice
	PROCEDURE SortujTablice(a, b : INTEGER);
		VAR
			y, temp : INTEGER;
 
		BEGIN
			FOR x := 0 TO (a - 2) DO
				BEGIN
					FOR y := (a - 1) DOWNTO (x + 1) DO
						BEGIN
							IF tablica[y - 1] > tablica[y] THEN
								BEGIN
									temp := tablica[y];
									tablica[y] := tablica[y - 1];
									tablica[y - 1] := temp;
								END
 
							ELSE
								CONTINUE;
						END;
				END;
 
			TEXTCOLOR(WHITE);
			WRITE(LINIA, 'Wynik: ');
 
			FOR x := 0 TO (a - 1) DO
				WRITE(tablica[x], ' ');
 
			READLN;
		END;
 
BEGIN
	WHILE TRUE DO
		BEGIN
			CLRSCR;
 
			TEXTCOLOR(YELLOW);
			WRITELN('1) Wypełnij tablicę losowanymi liczbami', LINIA);
			WRITELN('2) Znajdź wartość i pozycję maksymalnej liczby', LINIA);
			WRITELN('3) Wypisz (w odwrotnej kolejności) wszystkie liczby', LINIA);
			WRITELN('4) Posortuj liczby', LINIA);
			WRITELN('5) EXIT', LINIA);
 
			WRITE('Wybór: ');
			READLN(wybor);
 
			CASE wybor OF
				'1' : WypelnijTablice(rozmiar, przedzial);
				'2' : WyznaczMax(rozmiar, przedzial);
				'3' : WyswietlTablice(rozmiar, przedzial);
				'4' : SortujTablice(rozmiar, przedzial);
				'5' : EXIT;
 
			ELSE
				EXIT;
 
			END;
		END;
END.

Zadanie ma na celu przetestować działanie tej samej tablicy (dynamicznej) względem powyższych procedur. Wiąże się to z tym, że deklaracji tablicy należy dokonać w głównym bloku deklaracyjnym zmiennych.

Zadanie 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

PROGRAM lista6_zad10(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE GenerujTabliczke;
		VAR
			tablica : ARRAY [1..10, 1..10] OF INTEGER;
			x, y: INTEGER;
 
		BEGIN	
 
			FOR x := 1 TO 10 DO
				BEGIN
					FOR y := 1 TO 10 DO
						tablica[x][y] := x * y;
				END;
 
			FOR x := 1 TO 10 DO
				BEGIN
					WRITELN;
 
					FOR y := 1 TO 10 DO
						WRITE(tablica[x][y]:7);
 
					WRITELN;
				END;
 
		END;
 
BEGIN
	CLRSCR;
 
	GenerujTabliczke;
 
	REPEAT UNTIL Keypressed;
END.

Generuję w dwuwymiarowej tablicy (statycznej) tabliczkę mnożenia (10 x 10), a następnie wyświetlam jej wynik na ekranie.

Wszystkie zadania z tej lekcji można pobrać: tutaj.

Categories: Free Pascal, UwB Tags:
  1. N.
    Grudzień 23rd, 2009 at 00:43 | #1
    Odpowiedz | Cytuj

    Dzięki Tobie proste jak Żaba :).

  1. Brak jeszcze trackbacków
Kod (wymagane)