Katharsis's devblog

Facta, non verba!

Katharsis — Tue, 16 Feb 2010 01:08:24 +0000

Filozoficzny bit.

Ktoś kiedyś powiedział, że “życie jest sztuką priorytetów”. Kierując się tą myślą zauważyłem, że hierarchia ważności, to nic innego jak struktura o cechach obiektywnego doboru tego, na czym nam najbardziej zależy. Wdrażając taką postawę można wyraźniej zarysować kontury przyszłości, nadając kierunek i sens temu co robimy oraz skuteczniej realizować wytyczone zadania.

Zastosowałem tą metodę półtora roku temu, decydując się na “pełnoetatowy” rozwój projektu PPCG. Dzięki polityce małych kroczków i pracy zespołowej zrealizowaliśmy większość wspólnie ustalonych celów. Efekt był na tyle zadowalający, że pojawiły się kolejne pomysły i propozycje związane z naszą dotychczasową działalnością. Niestety, ostatnio życie zaczęło narzucać zupełnie inny bieg zdarzeń – odbiegający od “Wielkiego Planu” – coraz częściej skupiając moją uwagę i czas na innych zadaniach. Powrócił drażliwy dla mnie temat studiów, który okazał się “złem ostatecznym”, na szczęście tylko w teorii. W praktyce bowiem, przy odpowiednim nakładzie pracy przekonałem się, iż studia mogą dać wiele satysfakcji i nieocenionej wiedzy. Zaangażowałem się do tego stopnia, że moja obecność przy projekcie PPCG spadła ze sporadycznej do równej zeru. W efekcie większość zaplanowanych, tegorocznych zadań nie miała okazji ujrzeć światła dziennego, a społeczność zaczęła wątpić w ich realizację. Niewątpliwie jest to moja wina i zamierzam to naprawić.

Właściwa technika jest kluczem do sukcesu.

W związku z decyzją zacząłem zastanawiać się, czy jestem w stanie pogodzić ze sobą dwa równie istotne priorytety. Ważnym jest wypracowanie kompromisu między owocnym rozwojem projektu oraz pomyślnym postępem spraw na uczelni. Zacząłem od dogłębnej analizy źródła wcześniejszych problemów z zaangażowaniem mojej osoby w progres dotyczący PPCG. Niewłaściwa umiejętność gospodarowania czasem i częsta utrata motywacji to kwestie personalne, które wziąłem na warsztat. Projekt również wymaga przeprowadzenia “dogłębnej restrukturyzacji”. Przede wszystkim usprawnić należy sprawy związane z administracją projektu, przydzielić nowe zadania dla sprecyzowanego i oficjalnie działającego zespołu oraz wyselekcjonować i udostępnić materiały dydaktyczne. W tym wszystkim uwzględniony zostanie głos społeczności, dlatego też zależy mi na uzyskaniu jej zaangażowania i pełnego zaufania. Jak tego dokonać?

Faza pierwsza – punkt zaczepienia.

Projekt PPCG obchodził niedawno swoje trzecie urodziny, osiągając pewną dojrzałość. W związku z czym, nadszedł czas podsumowań w postaci raportu, który posłuży mi do skutecznej analizy naszej działalności. W ten sposób zdecydowanie prościej jest ustalić braki związane z funkcjonowaniem projektu, w tym osiągnięcia, porażki oraz skutki jakie ze sobą niosą. W raporcie znajdą się wnioski ze statystyk Google Analytics, IRC’a i forum, które posłużą do precyzyjnego określenia zapotrzebowania społeczności i kierunku, w którym to wszystko zmierza. Warto będzie zamieścić w nim bazę kontaktów wszystkich osób, firm i instytucji związanych z PPCG, włącznie z programem partnerskim/sponsorskim obejmującym daną współpracę. Z góry zapewniam, iż ze względu na troskę o dane personalne osób w to zaangażowanych, raport zostanie udostępniony do wglądu jedynie dla wybranej grupy figurantów.

Faza druga – team play.

To ludzie budują społeczność, stając się jej najważniejszym organem. Dlatego też, na podstawie planowanego bilansu, rozpocznę od przywrócenia kontaktów z dotychczasowymi współtwórcami PPCG. Podejmę próbę utworzenia i przygotowania kompletnego zespołu, działającego w ściśle zorganizowanej strukturze i o bardziej formalnym charakterze. Wspólnymi siłami ustalimy szczegółowy harmonogram działań wraz z strategią wykonania poszczególnych zadań. Z pewnością dołożę wszelkich starań do nawiązania bliższej współpracy z Python Software Foundation, której to owocem, miejmy nadzieje, będzie zmiana domeny projektu czy innych prywatnych zasobów, z których aktualnie korzystamy. Bardzo zależy mi na sukcesywnym przebiegu całej akcji, dlatego też z pewnością wykorzystam wszystkie dostępne środki, by przekonać Community do dalszego rozwoju projektu PPCG.

… a na zakończenie.

Zyskać utracone zaufanie nie jest łatwo. Mam wielką nadzieję, że w najbliższym czasie, przy odpowiedniej dawce inicjatywy i pracowitości, uda mi się zrealizować wytyczone cele. Wydaje się, że w ciągu tych kilku miesięcy nieobecności i stagnacji, udało mi się dojrzeć do przeprowadzenia kilku mini-rewolucji dotyczących oblicza polskiej społeczności Python’a. Nadszedł najwyższy czas na zmiany!

Informacji o postępie prac oczekujcie na moim blogu i oficjalnej stronie PPCG.

Trzymajcie kciuki i niech Moc będzie z Wami!

Laborki z Pascala – Lista 8 i 9

Katharsis — Mon, 11 Jan 2010 21:13:53 +0000

Do Waszej dyspozycji udostępniam dziś dwie ostatnie, najbardziej pracochłonne listy: 8 i 9. Zadania poświęcone są przede wszystkim tematyce zmiennych rekordów i plikom, będących przykładem zmiennych złożonych.

Laboratorium 8

Zadanie 1

Przeanalizowałem :).

Zadanie 2

PROGRAM lista8_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	ZBIOR_PKT = ARRAY OF RECORD
					a, b : INTEGER;
				END;
 
VAR
	punkt : ZBIOR_PKT;
	x, y, ilosc, X1, Y1, X2, Y2 : INTEGER;
	wynik, max : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj ilość punktów: ');
	READLN(ilosc);
 
	WRITELN;
 
	SETLENGTH(punkt, ilosc);
 
	max := 0;
 
	FOR x := 0 TO (ilosc - 1) DO
		BEGIN
			WITH punkt[x] DO
				BEGIN
					WRITE('Podaj współrzędne punktu ', x + 1, ': ');
					READLN(a, b);
				END;
		END;
 
	FOR x := 0 TO (ilosc - 1) DO
		BEGIN
				FOR y := 0 TO (ilosc - 1) DO
					BEGIN
						WITH punkt[y] DO
							BEGIN
								wynik := SQRT(SQR(punkt[x].a - a) + SQR(punkt[x].b - b));
 
								IF wynik > max THEN
									BEGIN
										max := wynik;
										X1 := punkt[x].a;
										Y1 := punkt[x].b;
										X2 := a;
										Y2 := b;
									END
 
								ELSE
									CONTINUE;
							END;
					END;
		END;
 
	WRITELN;
 
	WRITELN('Punkty: (', X1, ', ', Y1, ') i (', X2, ', ', Y2, '), Odległość: ', max:0:2);
 
	REPEAT UNTIL KEYPRESSED;
END.

Zgodnie z treścią zadania, współrzędne podanych punktów dodaję do tablicy rekordów. Następnie wyliczam odległości pomiędzy wszystkimi punktami z wzoru na odległość euklidesową i wyznaczam maksymalną wartość, która jest rozwiązaniem problemu.

Zadanie 3

PROGRAM lista8_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	rok, miesiac, dzien : INTEGER;
 
	FUNCTION UstalDzien(rok, miesiac, dzien : INTEGER) : STRING;
		VAR
			M, C, D, N : INTEGER;
 
		CONST
			dni : ARRAY[0..6] OF STRING = ('Niedziela', 'Poniedziałek', 'Wtorek', 'Środa', 'Czwartek', 'Piątek', 'Sobota');
 
		BEGIN
			M := 1 + ((miesiac + 9) MOD 12);
 
			IF M > 10 THEN
				rok := rok - 1;
 
			C := rok DIV 100;
			D := rok MOD 100;
			N := ((((13 * M) - 1) DIV 5) + D + (D DIV 4) + (C DIV 4) + (5 * C) + dzien) MOD 7;
 
			UstalDzien:= dni[N];
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj datę (YYYY MM DD): ');
	READLN(rok, miesiac, dzien);
 
	WRITELN;
 
	WRITELN('Jest to: ', UstalDzien(rok, miesiac, dzien));
 
	REPEAT UNTIL KEYPRESSED;
END.

Sposobów na określenie dnia tygodnia na podstawie podanej daty jest kilka. Do tego zadania wykorzystałem jeden z nich, czyli wieczny kalendarz.

Zadanie 4

PROGRAM lista8_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	DATA = RECORD
				dzien, miesiac, rok : STRING;
			END;
 
	UCZEN = ARRAY[1..5] OF RECORD
				imie, nazwisko : STRING;
				dataur : DATA;
			END;
 
VAR
	info : UCZEN;
	wybor : INTEGER;
 
	PROCEDURE UzupelnijBaze;
		VAR
			x : INTEGER;
 
		BEGIN
			FOR x := 1 TO 5 DO
				BEGIN
					WITH info[x], dataur DO
						BEGIN
							WRITELN;
 
							WRITELN('Uzupełnij formularz - Osoba nr', x, ':');
 
							WRITELN;
 
							WRITE('Imię: ');
							READLN(imie);
 
							WRITE('Nazwisko: ');
							READLN(nazwisko);
 
							WRITE('Dzień urodzin: ');
							READLN(dzien);
 
							WRITE('Miesiąc urodzin: ');
							READLN(miesiac);
 
							WRITE('Rok urodzin: ');
							READLN(rok);
						END;
				END;
 
			READLN;
			CLRSCR;
		END;
 
	PROCEDURE WyswietlBaze;
		VAR
			x : INTEGER;
 
		BEGIN
			WRITELN;
 
			FOR x := 1 TO 5 DO
				BEGIN
					WITH info[x], dataur DO
						WRITELN('NR', x, ': ', imie, ' ', nazwisko, ' :: ', dzien, '-', miesiac, '-', rok);
				END;
 
			READLN;
			CLRSCR;
		END;
 
	PROCEDURE SzukajNazwiskiem;
		VAR
			x : INTEGER;
			nazw : STRING;
 
		BEGIN
			WRITELN;
 
			WRITE('Wpisz szukane nazwisko: ');
			READLN(nazw);
 
			WRITELN;
 
			FOR x := 1 TO 5 DO
				BEGIN
					WITH info[x] DO
						BEGIN
							IF nazw = nazwisko THEN
								WRITELN('- ', imie, ' ', nazwisko)
 
							ELSE
								CONTINUE;
						END;
				END;
 
			READLN;
			CLRSCR;
		END;
 
	PROCEDURE SzukajData;
		VAR
			x : INTEGER;
			rokur : STRING;
 
		BEGIN
			WRITELN;
 
			WRITE('Wpisz rok urodzenia: ');
			READLN(rokur);
 
			WRITELN;
 
			FOR x := 1 TO 5 DO
				BEGIN
					WITH info[x], dataur DO
						BEGIN
							IF rokur = rok THEN
								WRITELN('- ', imie, ' ', nazwisko)
 
							ELSE
								CONTINUE;
						END;
				END;
 
			READLN;
			CLRSCR;
		END;
 
BEGIN
	WHILE TRUE DO
		BEGIN
			CLRSCR;
 
			WRITELN('1. Uzupełnij bazę');
			WRITELN('2. Wyświetl bazę');
			WRITELN('3. Szukaj względem nazwiska');
			WRITELN('4. Szukaj względem roku urodzenia');
 
			WRITELN;
 
			WRITE('Wybór: ');
			READLN(wybor);
 
			CASE wybor OF
				1 : UzupelnijBaze;
				2 : WyswietlBaze;
				3 : SzukajNazwiskiem;
				4 : SzukajData;
 
			ELSE
				EXIT;
 
			END;
		END;
END.

W zadaniu tym należy skorzystać z rekordów zagnieżdżonych, czyli pól adresowych, będących rekordami umieszczonymi wewnątrz głównego rekordu. Należy zwrócić uwagę na to, w jakiej kolejności definiowane są poszczególne (zależne od siebie) rekordy! Zwróćcie uwagę na to, że skorzystałem z instrukcji WITH, w celu pominięcia nazwy rekordów przed nazwali pól. Całe zadanie dotyczy zdefiniowanych procedur, których rolę realizują założenia wytyczone w treści.

Zadanie 5

PROGRAM lista8_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	KLASA = ARRAY[1..36] OF RECORD
				imie, nazwisko : STRING;
			END;
 
	TABLICA = ARRAY[1..36] OF INTEGER;
 
VAR
	uczen : KLASA;
	ludzie : TABLICA;
	x : INTEGER;
 
	FUNCTION LosowanieBezPowtorzen : TABLICA;
		VAR
			losy : TABLICA;
			x, temp : INTEGER;
 
		BEGIN
			RANDOMIZE;
 
			FOR x := 1 TO 36 DO
				losy[x] := 0;
 
			FOR x := 1 TO 36 DO
				BEGIN
					REPEAT
						temp := RANDOM(36) + 1;
 
					UNTIL
						losy[temp] = 0;
 
					ludzie[x] := temp;         
					losy[temp] := 1;       
				END;
 
			LosowanieBezPowtorzen := ludzie;
		END;
 
BEGIN
	CLRSCR;
 
	FOR x := 1 TO 36 DO
		BEGIN
			WITH uczen[x] DO
				BEGIN
					WRITE('Imię i nazwisko ucznia: ');
					READLN(imie, nazwisko);
				END;
		END;
 
	ludzie := LosowanieBezPowtorzen;
 
	WRITELN;
 
	WRITELN('Wyniki losowania: ');
 
	WRITELN;
 
	FOR x := 1 TO 36 DO
		BEGIN
			IF (x MOD 2 = 0) THEN
				BEGIN
					WITH uczen[ludzie[x]] DO
						WRITELN(imie, ' ', nazwisko);
				END
 
			ELSE
				WITH uczen[ludzie[x]] DO
						WRITE('Para: ', imie, ' ', nazwisko, 'oraz ');
		END;
 
	REPEAT UNTIL KEYPRESSED;
END.

W celu wylosowania nazwisk uczniów i stworzenia par odbywających dyżury, napisałem funkcję LosowanieBezPowtorzen, która generuje tablicę liczb (z uwzględnionym przedziałem), pozbawioną duplikatów. Tablica posłuży mi jako indeks, za pomocą którego odwołam się do tablicy rekordów przechowującej dane wszystkich uczniów.

Zadanie 6

PROGRAM lista8_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
CONST
	rozmiar = 3;
 
TYPE
	COMPLEX = ARRAY OF ARRAY OF RECORD
					re, im : REAL;
			  END;
 
VAR
	zespolona : COMPLEX;
	x, y : INTEGER;
 
BEGIN
	CLRSCR;
 
	SETLENGTH(zespolona, rozmiar, rozmiar);
 
	FOR x := 0 TO (rozmiar - 1) DO
		BEGIN
			FOR y := 0 TO (rozmiar - 1) DO
				BEGIN
					WITH zespolona[x][y] DO
						BEGIN
							WRITE('Podaj Re i Im: ');
							READLN(re, im);
						END;
				END;
		END;
 
	WRITELN;
 
	FOR x := 0 TO (rozmiar - 1) DO
		BEGIN
			FOR y := 0 TO (rozmiar - 1) DO
				BEGIN
					WITH zespolona[x][y] DO
						WRITELN('z = ', re:0:0, ' i', im:0:0);
				END;
		END;
 
	REPEAT UNTIL KEYPRESSED;
END.

Wartość stałej nadaje rozmiar macierzy (NxN), przechowującej nowo zdefiniowany typ, jakim są liczby zespolone (COMPLEX). Tablica rekordów zostanie uzupełniona polami przechowującymi część rzeczywistą i urojoną podanych liczb.

Laboratorium 9

Zadanie 1

PROGRAM lista9_zad1(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	BYTEFILE = FILE OF BYTE;
 
VAR
	plik : BYTEFILE;
	x, ilosc, liczba : INTEGER;
 
BEGIN
	CLRSCR;
	RANDOMIZE;
 
	ASSIGN(plik, 'zad1.txt');
	REWRITE(plik);
 
	ilosc := RANDOM(801) + 200;
 
	FOR x := 1 TO ilosc DO
		BEGIN
			liczba := RANDOM(101) + 100;
			WRITE(plik, liczba);
		END;
 
	CLOSE(plik);	
 
	REPEAT UNTIL KEYPRESSED;
END.

Zadanie jest dobrym przykładem sposobu definiowania i korzystania z pliku nietekstowego (w formacie binarnym). Plik ten składa się z losowej ilości liczb o przypadkowych wartościach, ograniczonych przedziałami. Posłuży nam do wykonania pozostałych zadań tej listy.

Zadanie 2a

PROGRAM lista9_zad2a(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	BYTEFILE = FILE OF BYTE;
 
VAR
	plik, plik2 : BYTEFILE;
	temp : BYTE;
 
BEGIN
	CLRSCR;
 
	ASSIGN(plik, 'zad1.txt');
	RESET(plik);
 
	ASSIGN(plik2, 'zad2a.txt');
	REWRITE(plik2);
 
	WHILE NOT EOF(plik) DO
		BEGIN
			READ(plik, temp);
 
			IF (temp MOD 2 = 0) THEN
				WRITE(plik2, temp)
 
			ELSE
				CONTINUE;
		END;
 
	CLOSE(plik2);
	CLOSE(plik);
 
	REPEAT UNTIL KEYPRESSED;
END.

Bazując na pliku z Zadania 1, znajduję wszystkie liczby parzyste. Następnie umieszczam je w pliku docelowym. W tym celu analizuję cały plik źródłowy wykorzystując funkcję EOF.

Zadanie 2b

PROGRAM lista9_zad2b(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	BYTEFILE = FILE OF BYTE;
	BYTEARRAY = ARRAY OF BYTE;
 
	STATS = ARRAY OF RECORD
				cyfra, ile : INTEGER;
			END;
 
VAR
	plik : BYTEFILE;
	tablica : BYTEARRAY;
	statystyka : STATS;
	temp : BYTE;
	x, y, ilosc : INTEGER;
 
BEGIN
	CLRSCR;
 
	ilosc := 0;
 
	ASSIGN(plik, 'zad1.txt');
	RESET(plik);
 
	WHILE NOT EOF(plik) DO
		BEGIN
			SETLENGTH(tablica, ilosc + 1);
			SETLENGTH(statystyka, ilosc + 1);
 
			READ(plik, temp);
			tablica[ilosc] := temp;
 
			ilosc := ilosc + 1;
		END;	
 
	CLOSE(plik);
 
	FOR x := 0 TO (ilosc - 1) DO
		BEGIN
			statystyka[x].ile := 0;
			statystyka[x].cyfra := tablica[x];
 
			FOR y := 0 TO (ilosc - 1) DO
				BEGIN
					IF tablica[x] = tablica[y] THEN
						statystyka[x].ile := statystyka[x].ile + 1
 
					ELSE
						CONTINUE;
				END;
		END;
 
	ASSIGN(plik, 'zad2b.txt');
	REWRITE(plik);
 
	FOR x := 0 TO (ilosc - 1) DO
		BEGIN
			IF statystyka[x].ile = 1 THEN
				WRITE(plik, statystyka[x].cyfra)
 
			ELSE
				CONTINUE;
		END;
 
	CLOSE(plik);
 
	REPEAT UNTIL KEYPRESSED;
END.

Bazując na pliku z Zadania 1, wyodrębniam liczby, które w całym ciągu pojawiły się jeden raz. Aby tego dokonać tworzę statystykę (tablicę rekordów), która dla każdej analizowanej liczby przypisuje ilość jej wystąpień. Następnie do pliku docelowego trafiają liczby, których to wystąpienie w ciągu równe jest 1. Warto szczególną uwagę zwrócić na budowę pierwszej pętli WHILE, odpowiedzialnej za jednoczesne ustalenie ilości liczb w ciągu, jak i dynamiczny przyrost wielkości obu tablic.

Zadanie 3

PROGRAM lista9_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	BYTEFILE = FILE OF BYTE;
	BYTEARRAY = ARRAY OF BYTE;
 
VAR
	plik : BYTEFILE;
	tablica : BYTEARRAY;
	temp : BYTE;
	x, ilosc : INTEGER;
 
	FUNCTION SortujTablice(tablica : BYTEARRAY) : BYTEARRAY;
		VAR
			x, y, liczba : INTEGER;
 
		BEGIN
			FOR x := 0 TO (ilosc - 2) DO
				BEGIN
					FOR y := (ilosc - 1) DOWNTO (x + 1) DO
						BEGIN
							IF tablica[y - 1] > tablica[y] THEN
								BEGIN
									liczba := tablica[y];
									tablica[y] := tablica[y - 1];
									tablica[y - 1] := liczba;
								END
 
							ELSE
								CONTINUE;
						END;
				END;
 
			SortujTablice := tablica;
		END;
 
BEGIN
	CLRSCR;
 
	ilosc := 0;
 
	ASSIGN(plik, 'zad1.txt');
	RESET(plik);
 
	WHILE NOT EOF(plik) DO
		BEGIN
			SETLENGTH(tablica, ilosc + 1);
 
			READ(plik, temp);
			tablica[ilosc] := temp;
 
			ilosc := ilosc + 1;
		END;
 
	CLOSE(plik);
 
	tablica := SortujTablice(tablica);
 
	ASSIGN(plik, 'zad1.txt');
	REWRITE(plik);
 
	FOR x := 0 TO (ilosc - 1) DO
		WRITE(plik, tablica[x]);
 
	CLOSE(plik);
 
	REPEAT UNTIL KEYPRESSED;
END.

Bazując na pliku z Zadania 1, sortuję cały ciąg liczb, bez tworzenia pliku pomocniczego. W tym celu stworzyłem tablicę dynamiczną zawierającą dane liczby, którą to “przepuściłem” przez funkcję SortujTablice. Następnie wynik nadpisałem na plik źródłowy.

Zadanie 4

PROGRAM lista9_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	LINEARRAY = ARRAY OF STRING;
 
VAR
	plik : TEXT;
	x, ilosc, dlugosc : INTEGER;
	liczba, temp : STRING;
	tablica : LINEARRAY;
 
BEGIN
	CLRSCR;
 
	ilosc := 0;
 
	ASSIGN(plik, 'zad4.txt');
	RESET(plik);
 
	WHILE NOT EOF(plik) DO
		BEGIN
			SETLENGTH(tablica, ilosc + 1);
 
			READLN(plik, temp);
			tablica[ilosc] := temp;
 
			ilosc := ilosc + 1;
		END;
 
	CLOSE(plik);
 
	ASSIGN(plik, 'zad4.txt');
	REWRITE(plik);	
 
	FOR x := 0 TO (ilosc - 1) DO
		BEGIN
			STR(x + 1, liczba);
			dlugosc := LENGTH(liczba);
 
			IF dlugosc = 1 THEN
				WRITE(plik, CONCAT('000', liczba, tablica[x]))
 
			ELSE IF dlugosc = 2 THEN
				WRITE(plik, CONCAT('00', liczba, tablica[x]))
 
			ELSE IF dlugosc = 3 THEN
				WRITE(plik, CONCAT('0', liczba, tablica[x]))
 
			ELSE
				WRITE(plik, CONCAT(liczba, tablica[x]));
 
			IF x = (ilosc - 1) THEN
				WRITE(plik)
 
			ELSE
				WRITELN(plik);
		END;
 
	CLOSE(plik);
 
	REPEAT UNTIL KEYPRESSED;
END.

W celu prawidłowego uruchomienia tego programu, należy wcześniej przygotować plik tekstowy zad4.txt (z zawartością). Każdej linii pliku zostaje przyporządkowany numer wiersza, który powinien zajmować (zawsze) 4 pozycje.

Zadanie 5

PROGRAM lista9_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
TYPE
	MACIERZ = ARRAY OF ARRAY OF INTEGER;
 
VAR
	plik, plik2 : TEXT;
	x, y, wiersze, kolumny, a, b : INTEGER;
	znak : CHAR;
	tablica : MACIERZ;
 
BEGIN
	CLRSCR;
 
	ASSIGN(plik, 'zad5.txt');
	RESET(plik);
 
	wiersze := 0;
	kolumny := 0;
 
	WHILE NOT EOF(plik) DO
		BEGIN
			WHILE NOT EOLN(plik) DO
				BEGIN
					READ(plik, znak);
 
					IF znak IN ['0'..'9'] THEN
						kolumny := kolumny + 1
 
					ELSE
						CONTINUE;
				END;
 
			READLN(plik);
			wiersze := wiersze + 1;
		END;
 
	CLOSE(plik);
 
	kolumny := ROUND(kolumny / wiersze) - 1;
 
	a := 0;
	b := 0;
 
	SETLENGTH(tablica, wiersze, kolumny);
 
	ASSIGN(plik, 'zad5.txt');
	RESET(plik);
 
	ASSIGN(plik2, 'zad5-trans.txt');
	REWRITE(plik2);
 
	FOR y := 0 TO (kolumny - 1) DO
		BEGIN
			FOR x := 0 TO (wiersze - 1) DO
				BEGIN
					WHILE NOT EOF(plik) DO
						BEGIN
							WHILE NOT EOLN(plik) DO
								BEGIN
									READ(plik, tablica[a, b]);
									b := b + 1;
								END;
 
							READLN(plik);
 
							b := 0;
							a := a + 1;
						END;	
 
					IF x = (wiersze - 1) THEN
						WRITE(plik2, tablica[x][y])
 
					ELSE
						WRITE(plik2, tablica[x][y], ' ');
				END;
 
			IF y = (kolumny - 1) THEN
				WRITE(plik2)
 
			ELSE
				WRITELN(plik2);
		END;
 
	CLOSE(plik2);
	CLOSE(plik);
 
	REPEAT UNTIL KEYPRESSED;
END.

W celu prawidłowego uruchomienia tego programu, należy wcześniej przygotować plik tekstowy zad5.txt, z zawartością macierzy (NxM). Program dokona przestawienia macierzy, a wynik zapisze w pliku docelowym.

Zadanie 6

PROGRAM lista9_zad6(INPUT, OUTPUT);
 
USES
	CRT, DOS, SYSUTILS;
 
CONST
	baza = 'zad6.txt';
 
TYPE
	OSOBA = RECORD
				imie, nazwisko : STRING[25];
				dzien, miesiac : BYTE;
				rok : INTEGER;
			END;
 
VAR
	plik : TEXT;
	wybor : CHAR;
 
	PROCEDURE SprBaza;
		BEGIN
			IF FSEARCH(baza, '') = '' THEN
				BEGIN
					ASSIGN(plik, baza);
					REWRITE(plik);
					CLOSE(plik);
				END;
		END;
 
	PROCEDURE DodajOsobe;
		VAR
			nowy : OSOBA;
			d, m, r : STRING;
 
		BEGIN
			ASSIGN(plik, baza);
			APPEND(plik);
 
			WITH nowy DO
				BEGIN
					WRITELN;
 
					WRITE('Podaj imię i nazwisko: ');
					READLN(imie, nazwisko);
 
					WRITE('Podaj datę urodzenia (DD MM RRRR): ');
					READLN(dzien, miesiac, rok);
 
					STR(dzien, d);
					STR(miesiac, m);
					STR(rok, r);
 
					IF LENGTH(d) = 1 THEN
						d := '0' + d;
 
					IF LENGTH(m) = 1 THEN
						m := '0' + m;
 
					WRITELN(plik, CONCAT(imie, nazwisko, ' ', d, '-', m, '-', r));
				END;
 
			CLOSE(plik);
 
			READLN;
			CLRSCR;
		END;
 
	PROCEDURE WyswietlPelnoletnich;
		VAR
			linia, data : STRING;
			akt_d, akt_m, akt_r, d, m, r : INTEGER;
 
		BEGIN
			WRITELN;
 
			ASSIGN(plik, baza);
			RESET(plik);
 
			WHILE NOT EOF(plik) DO
				BEGIN
					READLN(plik, linia);
 
					data := DATETOSTR(Date);
 
					VAL(COPY(linia, LENGTH(linia) - 9, 2), d);
					VAL(COPY(linia, LENGTH(linia) - 6, 2), m);
					VAL(COPY(linia, LENGTH(linia) - 3, 4), r);
					VAL(COPY(data, 9, 2), akt_d);
					VAL(COPY(data, 6, 2), akt_m);
					VAL(COPY(data, 1, 4), akt_r);
 
					IF (akt_r - r) > 18 THEN
						WRITELN('- ', linia)
 
					ELSE IF (akt_r - r) = 18 THEN
						BEGIN
							IF (akt_m - m) > 0 THEN
								WRITELN('- ', linia)
 
							ELSE IF (akt_m - m) = 0 THEN
								BEGIN
									IF (akt_d - d) >= 0 THEN
										WRITELN('- ', linia);
								END;
						END;
 
				END;
 
			CLOSE(plik);
 
			READLN;
			CLRSCR;
		END;
 
	PROCEDURE WyswietlWzgledemDaty;
		VAR
			linia : STRING;
			ust_d, ust_m, ust_r, d, m, r : INTEGER;
 
		BEGIN
			WRITELN;
 
			WRITE('Podaj datę (DD MM RRRR): ');
			READLN(ust_d, ust_m, ust_r);
 
			WRITELN;
 
			ASSIGN(plik, baza);
			RESET(plik);
 
			WHILE NOT EOF(plik) DO
				BEGIN
					READLN(plik, linia);
 
					VAL(COPY(linia, LENGTH(linia) - 9, 2), d);
					VAL(COPY(linia, LENGTH(linia) - 6, 2), m);
					VAL(COPY(linia, LENGTH(linia) - 3, 4), r);
 
					IF (ust_r - r) < 0 THEN
						WRITELN('- ', linia)
 
					ELSE IF (ust_r - r) = 0 THEN
						BEGIN
							IF (ust_m - m) < 0 THEN
								WRITELN('- ', linia)
 
							ELSE IF (ust_m - m) = 0 THEN
								BEGIN
									IF (ust_d - d) < 0 THEN
										WRITELN('- ', linia);
								END;
						END;
 
				END;
 
			CLOSE(plik);
 
			READLN;
			CLRSCR;
		END;
 
BEGIN
	CLRSCR;
 
	WHILE TRUE DO
		BEGIN
			SprBaza;
 
			WRITELN('1. Dodaj nową osobę');
			WRITELN('2. Wyświetl osoby pełnoletnie');
			WRITELN('3. Wyświetl osoby później urodzone');
 
			WRITELN;
 
			WRITE('Wybór: ');
			READLN(wybor);
 
			CASE wybor OF
				'1' : DodajOsobe;
				'2' : WyswietlPelnoletnich;
				'3' : WyswietlWzgledemDaty;
 
			ELSE
				EXIT;
 
			END;
		END;
END.

Na podstawie ustalonego już typu – OSOBA, należy wykonać sprawnie działającą bazę danych. Na początku każdego uruchomienia programu sprawdzam, czy w obrębie aplikacji nie znajduje się już plik tekstowy, przechowujący dane tych osób. Dokonuję tego przy pomocy funkcji FSEARCH, z modułu DOS. Brak pliku spowoduje utworzenie nowej bazy. Dodawanie osób odbywa się przy pomocy procedury DodajOsobe ściśle powiązanej z typem OSOBA. WyswietlPelnoletnich, to kolejna procedura naszego menu, która na podstawie dogłębnej analizy daty urodzenia każdej z osób oraz aktualnej daty, wyznacza tylko te, które ukończyły 18 lat. Dzisiejszą datę ustala funkcja DATETOSTR(Date), z modułu SYSUTILS. WyswietlWzgledemDaty, działa podobnie do powyższej procedury. Algorytm postępowania jest analogiczny, zmieniają się tylko warunki logiczne.

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

Laborki z Pascala – Lista 7

Katharsis — Sun, 03 Jan 2010 21:47:40 +0000

Z dużym poślizgiem, ale są! W dzisiejszej notce udostępniam rozwiązania zadań z Listy 7.

Laboratorium 7

Zadanie 1

PROGRAM lista7_zad1(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	wymiar, x, y : INTEGER;
	macierz : ARRAY OF ARRAY OF INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj wymiar miacierzy: ');
	READLN(wymiar);
 
	SETLENGTH(macierz, wymiar, wymiar);
 
	WRITELN;
 
	FOR x := 0 TO (wymiar - 1) DO
		BEGIN
			FOR y := 0  TO (wymiar - 1) DO
				BEGIN
					macierz[x][y] := (x + 1) * (y + 1);
					WRITE(macierz[x][y]:4);
				END;
 
			WRITELN;
		END;
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypełniam iloczynem liczb macierz, o podanym przez użytkownika rozmiarze. Aby zachować dynamikę rozwiązania, korzystam ze znanego już typu danych, jakim są tablice dynamiczne.

Zadanie 2

PROGRAM lista7_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	n, m, przedzial, x, y, min, suma : INTEGER;
	macierz : ARRAY OF ARRAY OF INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj wymiary macierzy NxM: ');
	READLN(n, m);
 
	WRITE('Podaj końcowy przedział liczb losowych: ');
	READLN(przedzial);
 
	SETLENGTH(macierz, n, m);
	RANDOMIZE;
 
	WRITELN;
 
	FOR x := 0 TO (n - 1) DO
		BEGIN
			FOR y := 0  TO (m - 1) DO
				BEGIN
					macierz[x][y] := RANDOM(przedzial) + 1;
					WRITE(macierz[x][y]:4);
				END;
 
			WRITELN;
		END;
 
	suma := 0;
 
	FOR y := 0 TO (m - 1) DO
		BEGIN
			min := przedzial + 1;
 
			FOR x := 0 TO (n - 1) DO
				BEGIN
					IF macierz[x][y] < min THEN
						min := macierz[x][y]
 
					ELSE
						CONTINUE;
				END;
 
			suma := suma + min;
		END;
 
	WRITELN;
 
	WRITELN('Wynik: ', suma);
 
	REPEAT UNTIL KEYPRESSED;
END.

Zadanie podobne do powyższego, z tym, że tutaj elementami macierzy są liczy losowe. Dalsza część programu odpowiedzialna jest za znalezienie najmniejszych elementów w poszczególnych kolumnach naszej macierzy, a nastepnie podliczenie sumy wszystkich wyników.

Zadanie 3

PROGRAM lista7_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
	x : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	FOR x := LENGTH(lancuch) DOWNTO 1 DO
		WRITE(lancuch[x]);
 
	REPEAT UNTIL KEYPRESSED;
END.

Wypisuję podany łańcuch znaków w odwrotnej kolejności.

Zadanie 4

PROGRAM lista7_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	FUNCTION ZmienZnak(str : STRING; pre, pos : CHAR) : STRING;
		VAR
			x : INTEGER;
 
		BEGIN
			FOR x := 1 TO LENGTH(lancuch) DO
				BEGIN
					IF lancuch[x] = pre THEN
						lancuch[x] := pos
 
					ELSE
						CONTINUE;
				END;
 
			ZmienZnak := lancuch;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', ZmienZnak(lancuch, ' ', '_'));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji ZmienZnak zmieniam wszystkie wystąpienia znaku spacji na znak podkreślenia w podanym przez użytkownika łańcuchu znaków.

Zadanie 5

PROGRAM lista7_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
	znak : CHAR;
 
	FUNCTION ZliczZnak(str : STRING; zn : CHAR) : INTEGER;
		VAR
			x, ilosc : INTEGER;
 
		BEGIN
			ilosc := 0;
 
			FOR x := 1 TO LENGTH(lancuch) DO
				BEGIN
					IF lancuch[x] = zn THEN
						ilosc := ilosc + 1
 
					ELSE
						CONTINUE;
				END;
 
			ZliczZnak := ilosc;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITE('Szukany znak: ');
	READLN(znak);
 
	WRITELN;
 
	WRITELN('Wynik: ', ZliczZnak(lancuch, znak));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji ZliczZnak zliczam ilość wystąpień danego znaku w podanym przez użytkownika łańcuchu znaków.

Zadanie 6

PROGRAM lista7_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	FUNCTION UsunZnak(str : STRING; zn : CHAR) : STRING;
		VAR
			x, ilosc, index : INTEGER;
 
		BEGIN
			ilosc := 0;
 
			FOR x := 1 TO LENGTH(str) DO
				BEGIN
					IF str[x] = zn THEN
						ilosc := ilosc + 1
 
					ELSE
						CONTINUE;
				END;
 
			FOR x := 1 TO ilosc DO
				BEGIN
					index := POS(zn, str);
					DELETE(str, index, 1);
				END;
 
			UsunZnak := str;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', UsunZnak(lancuch, ' '));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji UsunZnak usuwam wszystkie wystąpienia znaku spacji w podanym przez użytkownika łańcuchu znaków.

Zadanie 7

PROGRAM lista7_zad7(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	FUNCTION ZliczWyrazy(str : STRING) : INTEGER;
		VAR
			x, ilosc : INTEGER;
			zbior : SET OF CHAR;
 
		BEGIN
			zbior := ['A'..'Z', 'a'..'z'];
			ilosc := 0;
 
			FOR x := 1 TO LENGTH(lancuch) DO
				BEGIN
					IF NOT (lancuch[x] IN zbior) AND (lancuch[x + 1] IN zbior) AND (x + 1 < = LENGTH(lancuch)) THEN
						ilosc := ilosc + 1
 
					ELSE
						CONTINUE;
				END;
 
			IF NOT (lancuch[1] IN zbior) THEN
				ilosc := ilosc - 1
 
			ELSE IF LENGTH(lancuch) = 0 THEN
				ilosc := ilosc - 1
 
			ELSE
				ilosc := ilosc;
 
			ZliczWyrazy := ilosc + 1;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', ZliczWyrazy(lancuch));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji ZliczWyrazy wyznaczam ilość wyrazów w łańcuchu znaków podanym przez użytkownika. W tym celu należy cały łańcuch przeanalizować względem zbioru dużych i małych liter.

Zadanie 8

PROGRAM lista7_zad8(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	PROCEDURE RozdzielWyrazy(str : STRING);
		VAR
			x : INTEGER;
			zbior : SET OF CHAR;
 
		BEGIN
			zbior := ['A'..'Z', 'a'..'z'];
 
			FOR x := 1 TO LENGTH(lancuch) DO
				BEGIN
					IF lancuch[x] IN zbior THEN
						WRITE(lancuch[x])
 
					ELSE IF (lancuch[x - 1] IN zbior) AND NOT (lancuch[x] IN zbior) THEN
						WRITELN
 
					ELSE
						CONTINUE;
				END;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	RozdzielWyrazy(lancuch);
 
	REPEAT UNTIL KEYPRESSED;
END.

Procedura RozdzielWyrazy ma za zadanie wypisać każde sowo w odzielnym wierszu, bez względu na budowę wprowadzonego wczęsniej łańcucha znaków

Zadanie 9

PROGRAM lista7_zad9(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	FUNCTION MaxWyraz(str : STRING) : STRING;
		VAR
			x, licznik, max, index : INTEGER;
			zbior : SET OF CHAR;
 
		BEGIN
			licznik := 0;
			max := 0;
			zbior := ['A'..'Z', 'a'..'z'];
 
			FOR x := 1 TO LENGTH(str) DO
				BEGIN
					IF NOT (str[x] in zbior) THEN
						licznik := 0
 
					ELSE
						BEGIN
							licznik := licznik + 1;
 
							IF max < licznik THEN
								BEGIN
									max := licznik;
									index := x;
								END
 
							ELSE
								CONTINUE;
						END;
				END;
 
			MaxWyraz := COPY(str, (index - max + 1), max);
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', MaxWyraz(lancuch));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji MaxWyraz wyznaczam najdłuższy wyraz w podanym przez użytkownika łańcuchu znaków. Algorytm zlicza tylko i wyłącznie znaki będące dużymi i małymi literami, wyznaczając w późniejszym etapie maksymalną wartość. W międzyczasie ustalamy położenie wyrazu w całym łańcuchu i przy pomocy funkcji COPY wyciągamy właściwy fragment.

Zadanie 10

PROGRAM lista7_zad10(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch : STRING;
 
	FUNCTION DuplikujWyraz(str : STRING) : STRING;
		VAR
			x : INTEGER;
			duplistr : STRING;
 
		BEGIN
			FOR x := 1 TO LENGTH(str) DO
				duplistr := duplistr + str[x] + str[x];
 
			DuplikujWyraz := duplistr;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj łańcuch znaków: ');
	READLN(lancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', DuplikujWyraz(lancuch));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji DuplikujWyraz podwajam wystąpienie każdego znaku w podanym przez użytkownika wyrazie.

Zadanie 11

PROGRAM lista7_zad11(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch, sublancuch : STRING;
 
	FUNCTION UsunSubLancuch(str, substr : STRING) : STRING;	
		VAR
			index, dlugosc : INTEGER;
 
		BEGIN
			index := POS(substr, str);
			dlugosc := LENGTH(substr);
 
			DELETE(str, index, dlugosc);
 
			IF index > 0 THEN
				UsunSubLancuch := UsunSubLancuch(str, substr)
 
			ELSE
				UsunSubLancuch := str;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj łańcuch znaków: ');
	READLN(lancuch);
 
	WRITE('Podaj podłańcuch znaków: ');
	READLN(sublancuch);
 
	WRITELN;
 
	WRITELN('Wynik: ', UsunSubLancuch(lancuch, sublancuch));
 
	REPEAT UNTIL KEYPRESSED;
END.

Przy pomocy funkcji UsunSubLancuch usuwam wszystkie wystąpienia danego podłańcucha w głównym łańcuchu znaków. Tym razem postanowiłem nie korzystać z pętli w celu analizy obu stringów, a oddać tą część pracy w ręce gotowych funkcji: POS, DELETE czy LENGTH.

Zadanie 12

PROGRAM lista7_zad12(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	lancuch, sublancuch, zastepczy : STRING;
 
	FUNCTION ZamienWyrazy(str, substr, exstr : STRING) : STRING;
		VAR
			x, index, dlugosc : INTEGER;
			newstr : STRING;
 
		BEGIN
			index := POS(substr, str);
			newstr := str;
 
			IF index = 0 THEN
				ZamienWyrazy := newstr
 
			ELSE
				BEGIN
					dlugosc := LENGTH(substr) + index - 1;
					newstr := CONCAT(COPY(str, 1, index - 1), exstr, COPY(str, dlugosc + 1, LENGTH(str) - index));
 
					ZamienWyrazy := ZamienWyrazy(newstr, substr, exstr);
				END;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Wpisz łańcuch znaków: ');
	READLN(lancuch);
 
	WRITE('Podaj szukany podłańcuch znaków: ');
	READLN(sublancuch);
 
	WRITE('Podaj zastępczy łańcuch znaków: ');
	READLN(zastepczy);
 
	WRITELN;
 
	WRITELN('Wynik: ', ZamienWyrazy(lancuch, sublancuch, zastepczy));
 
	REPEAT UNTIL KEYPRESSED;
END.

Zadanie podobne do powyższego, z tym że tutaj dokonujemy zamiany we wszystkich miejscach szukanego podłańcucha na nowy ciąg znaków (o nie znanym rozmiarze). Cały "pic" polega na umiejętnym wykorzystaniu wspomnianych już funkcji operujących na stringach: String handling i rekurencji.

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

Laborki z Pascala – Lista 6

Katharsis — Sun, 06 Dec 2009 11:41:27 +0000

Udostępniam rozwiązania Listy 6!

Laboratorium 6

Zadanie 1

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

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

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

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

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

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

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

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

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

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.

Laborki z Pascala – Lista 5

Katharsis — Sun, 29 Nov 2009 13:29:57 +0000

Kolejne rozwiązania już dostępne – tym razem Lista 5 – wykorzystujące pojęcie rekurencji.

Laboratorium 5

Zadanie 1

PROGRAM lista5_zad1(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	wybor : CHAR;
	liczba : INTEGER;
 
	FUNCTION SilniaIteracyjnie(x : INTEGER) : EXTENDED;
		VAR
			wynik : EXTENDED;
			licznik : INTEGER;
 
		BEGIN
			wynik := 1;
 
			IF (x = 0) OR (x = 1) THEN
				SilniaIteracyjnie := 1
 
			ELSE
				BEGIN
					FOR licznik := x DOWNTO 1 DO
						wynik := wynik * licznik;
 
					SilniaIteracyjnie := wynik;
				END;
		END;
 
	FUNCTION SilniaRekurencyjnie(x : INTEGER) : EXTENDED;
		BEGIN
			IF (x = 0) OR (x = 1) THEN
				SilniaRekurencyjnie := 1
 
			ELSE
				SilniaRekurencyjnie := SilniaRekurencyjnie(x - 1) * x;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN('Jaki sposób liczenia silnii wybierasz:');
	WRITELN('  a) Iteracyjnie');
	WRITELN('  b) Rekurencyjnie');
 
	GOTOXY(4, 5);
	WRITELN('Wybór: [ ]');
	GOTOXY(12, 5);
	wybor := READKEY;
	WRITE(wybor);
 
	GOTOXY(4, 7);
 
	IF (wybor = 'a') OR (wybor = 'A') THEN
		BEGIN
			WRITE('Podaj liczbę: ');
			READLN(liczba);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', SilniaIteracyjnie(liczba):0:0)
		END
 
	ELSE IF (wybor = 'b') OR (wybor = 'B') THEN
		BEGIN
			WRITE('Podaj liczbę: ');
			READLN(liczba);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', SilniaRekurencyjnie(liczba):0:0)
		END
 
	ELSE
		WRITELN('Błędny wybór!');
 
	REPEAT UNTIL Keypressed;
END.

Obliczam silnię z podanej przez użytkownika liczby, wykorzystując do tego jedną z wybranych funkcji. Pierwsza (SilniaIteracyjnie), to zwykła iteracja pętli FOR. Druga możliwość (SilniaRekurencyjnie) oblicza wynik z wykorzystaniem rekurencji.

Zadanie 2

PROGRAM lista5_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	wybor : CHAR;
	a1, q, n : INTEGER;
 
	FUNCTION Iter(x, y, z : INTEGER) : EXTENDED;
		VAR
			wynik, licznik : INTEGER;
 
		BEGIN
			wynik := 1;
 
			FOR licznik := z - 1 DOWNTO 1 DO
				wynik := wynik * y;
 
			Iter := x * wynik;
		END;
 
	FUNCTION Rek(x, y, z : INTEGER) : EXTENDED;
		BEGIN
			IF z = 1 THEN
				Rek := x
 
			ELSE
				Rek := y * Rek(x, y, z - 1);
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN('Jaki sposób liczenia n-tego wyrazu ciągu geo. wybierasz:');
	WRITELN('  a) Iteracyjnie');
	WRITELN('  b) Rekurencyjnie');
 
	GOTOXY(4, 5);
	WRITELN('Wybór: [ ]');
	GOTOXY(12, 5);
	wybor := READKEY;
	WRITE(wybor);
 
	GOTOXY(4, 7);
 
	IF (wybor = 'a') OR (wybor = 'A') THEN
		BEGIN
			WRITE('Podaj a1, q oraz n: ');
			READLN(a1, q, n);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', Iter(a1, q, n):0:0)
		END
 
	ELSE IF (wybor = 'b') OR (wybor = 'B') THEN
		BEGIN
			WRITE('Podaj a1, q oraz n: ');
			READLN(a1, q, n);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', Rek(a1, q, n):0:0)
		END
 
	ELSE
		WRITELN('Błędny wybór!');
 
	REPEAT UNTIL Keypressed;
END.

Obliczam dowolny wyraz ciągu geometrycznego, który wyraża się bardzo prostym wzorem. Mimo to, ze względu na “walory edukacyjne”, wykonuję to przy pomocy dwóch funkcji: Rek (rekurencyjnie) i Iter (iteracyjnie).

Zadanie 3

PROGRAM lista5_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b : INTEGER;
	wybor : CHAR;
 
	FUNCTION NWDbezR(x, y : INTEGER): INTEGER;
		VAR
			temp : INTEGER;
 
		BEGIN
		  REPEAT
			temp := x MOD y;
			x := y;
			y := temp;
		  UNTIL y = 0;
 
		  NWDbezR := x;
		END;
 
	FUNCTION NWDzR(x, y : INTEGER): INTEGER;
		BEGIN
			IF y = 0 THEN
				NWDzR := x
 
			ELSE
				NWDzR := NWDzR(y, x MOD y);
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN('Jaki sposób liczenia NWD wybierasz:');
	WRITELN('  a) Bez użycia rekurencji');
	WRITELN('  b) Rekurencyjnie');
 
	GOTOXY(4, 5);
	WRITELN('Wybór: [ ]');
	GOTOXY(12, 5);
	wybor := READKEY;
	WRITE(wybor);
 
	GOTOXY(4, 7);
 
	IF (wybor = 'a') OR (wybor = 'A') THEN
		BEGIN
			WRITE('Podaj a i b: ');
			READLN(a, b);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', NWDbezR(a, b))
		END
 
	ELSE IF (wybor = 'b') OR (wybor = 'B') THEN
		BEGIN
			WRITE('Podaj a i b: ');
			READLN(a, b);
 
			GOTOXY(4, 9);
			WRITELN('Wynik: ', NWDzR(a, b))
		END
 
	ELSE
		WRITELN('Błędny wybór!');
 
	REPEAT UNTIL Keypressed;
END.

Skoro mowa o rekurencji, nie może zabraknąć zadania z NWD. Zrozumienie działania algorytmu to podstawa do jego poprawnej implementacji.

Zadanie 4

PROGRAM lista5_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION Piramida(x : INTEGER) : INTEGER;
		VAR
			licznik, temp : INTEGER;
 
		BEGIN
			temp := x - 1;
 
			IF temp = -1 THEN
				Piramida := 1
 
			ELSE
				BEGIN
					FOR licznik := x DOWNTO 1 DO
						WRITE('*');
 
					WRITELN;
 
					Piramida := Piramida(temp);
				END;
		END;
 
BEGIN
	CLRSCR;
 
	Piramida(5);
 
	REPEAT UNTIL Keypressed;
END.

Funkcja Piramida odpowiedzialna jest za wypisywanie ciągu znaków, składającego się z malejącej ilości gwiazdek. Ilość ta maleje za każdym (rekurencyjnym) wywołaniem funkcji, dzięki czemu osiągamy zamierzony cel.

Zadanie 5

PROGRAM lista5_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION G(x, y : INTEGER) : REAL;
		BEGIN
			WRITELN('a = ', x, ', b = ', y);
 
			IF (x = 0) OR (y < = 1) THEN
				G := 69
 
			ELSE IF (x + y) > 6 THEN
				G := G(x - 1, y) * G(x, y - 1)
 
			ELSE
				G := G(1, x - 1);
		END;
 
BEGIN
	CLRSCR;
 
	G(3, 5);
 
	REPEAT UNTIL Keypressed;	
END.

Badam działanie funkcji G i generuję drzewo wywołań, w zależności od podanych parametrów (3, 5).

Zadanie 6

PROGRAM lista5_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	n : INTEGER;
 
	FUNCTION OkreslTo(x : INTEGER) : EXTENDED;
		BEGIN
			IF x = 0 THEN
				BEGIN
					OkreslTo := 0;
					WRITELN('a', x, ' = ', Okreslto:0:0);
				END
 
			ElSE IF x = 1 THEN
				BEGIN
					OkreslTo := 1;
					WRITELN('a', x, ' = ', Okreslto:0:0);
				END
 
			ELSE IF x < = 5 THEN
				BEGIN
					OkreslTo := SQR(OkreslTo(x - 2)) - 1;
					WRITELN('a', x, ' = ', Okreslto:0:0);
				END
 
			ELSE
				BEGIN
					OkreslTo := (3 * OkreslTo(x - 3)) - OkreslTo(x - 1);
					WRITELN('a', x, ' = ', Okreslto:0:0);
				END;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj n: ');
	READLN(n);
 
	WRITELN;
 
	OkreslTo(n);
 
	REPEAT UNTIL Keypressed;
END.

Zdecydowanie to zadanie przystworzyło najwięcej problemów. Implementacja algorytmu nie była tak prosta, jak się na początku wydawało. Kluczem do rozwiązania tego zadania jest właściwe ustalenie warunków zachowania ciągu i deklaracja początkowych jego wyrazów. Naszym zadaniem było sprawdzić 8-smy wyraz tego ciągu, który przy moich założeniach równy jest -2.

Zadanie 7

To zadanie nie wymaga kodu do ustalenia prawidłowego rozwiązania, ponieważ podlega tylko i wyłącznie analizie. Podając argumenty tylko parzyste, spowodujemy największą ilość wywołań funkcji, o której mowa jest w treści zadania.

Zadanie 8

PROGRAM lista5_zad8(INPUT, OUTPUT);
 
USES
	CRT;
 
	PROCEDURE ZrobTo(x : INTEGER);
		BEGIN
			IF x > 0 THEN
				BEGIN
					WRITE('$');
					ZrobTo(x - 1);
				END
 
			ELSE
				WRITELN;
		END;
 
BEGIN
	CLRSCR;
 
	ZrobTo(0);
	ZrobTo(88);
 
	REPEAT UNTIL Keypressed;
END.

Badam działanie funkcji ZrobTo, która generuje ciąg znaków, składający się z dolara i nowej linii. W przypadku parametru 0, funkcja wygeneruje tylko pustą linię. Parametr 88, uruchomi rekurencyjne działanie funkcji, co spowoduje zwrot ciągu znaków o tej samej długości i pustą linię.

Zadanie 9

PROGRAM lista5_zad9(INPUT, OUTPUT);
 
USES
	CRT;
 
	FUNCTION Zagadka(x, y : INTEGER) : INTEGER;
		BEGIN
			IF x = 0 THEN
				Zagadka := y
 
			ELSE
				Zagadka := Zagadka(x - 1, y) + 1;
		END;	
 
	FUNCTION Zagadkowa(x, y : INTEGER) : INTEGER;
		BEGIN
			IF y = 0 THEN
				Zagadkowa := x
 
			ELSE
				Zagadkowa := Zagadkowa(x - 1, y) + 1;
		END;
 
BEGIN
	CLRSCR;
 
	WRITELN(Zagadka(5, 8));
	WRITELN(Zagadkowa(5, 8));
 
	REPEAT UNTIL Keypressed;
END.

Badam działanie funkcji Zagadka i Zagadkowa, w zależności od tych samych wartości parametrów. W przypadku Zagadka, funkcja wykonuje się rekurencyjnie, zwracając sumę dwóch liczb. Zagadkowa to zmodyfikowana funkcja Zagadka, która zwraca "fatalny błąd": Range check error. Wyrażenie w ciele funkcji po pewnym czasie przekracza określony zakres liczbowy (nieprawidłowo określony warunek), przez co program się wysypuje.

Zadanie 10

PROGRAM lista5_zad10(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	k, n : INTEGER;
 
	PROCEDURE GenerujSume(a, b : INTEGER);
		VAR
			tablica : ARRAY OF ARRAY OF REAL;
			x, y: INTEGER;
 
		BEGIN	
			a := a + 1;
			b := b + 1;
 
			SETLENGTH(tablica, a, b);
 
			WRITELN;
 
			FOR x := 0 TO a - 1 DO
				FOR y := 0 TO b - 1 DO
					BEGIN
						IF y = 0 THEN
							tablica[x][y] := 0
 
						ELSE IF (y > 0) AND (x = 0) THEN
							tablica[x][y] := x + y
 
						ELSE
							tablica[x][y] := tablica[x - 1][y] + tablica[x][y - 1];
					END;
 
			FOR x := 0 TO a - 1 DO
				BEGIN
					FOR y := 0 TO b - 1 DO
						WRITE(tablica[x][y]:5:0);
 
					WRITELN;
				END;	
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj k i n: ');
	READLN(k, n);
 
	GenerujSume(k, n);
 
	REPEAT UNTIL Keypressed;
END.

Procedura GenerujSume, jest odpowiedzialna za wygenerowanie tabelki, zwierającej sumę wartości umieszczonych z lewej i górnej strony. Do rozwiązania tego zadania wykorzystałem tablice dynamiczne. Takie podejście zapewnia nam elastyczny sposób przechowywania pewnej ilości danych, dlatego też deklarując taką tablicę początkowo nie podajemy zakresu indeksów. Ilość elementów określamy dopiero w czasie działania programu. W tym celu korzystam z funkcji SETLENGTH. Uwaga! W tablicach dynamicznych indeksy rozpoczynają się od 0, a kończą na (mniejszej o 1) liczbie komórek tablicy. Nie musimy się również martwić o naszą pamięć, bo jeśli tablica została utworzona w procedurze lub funkcji, to jest automatycznie usuwana z pamięci po zakończeniu jej działania.

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

Laborki z Pascala – Lista 4

Katharsis — Tue, 24 Nov 2009 19:40:53 +0000

Udostępniam rozwiązania zadań z Listy 4.

Laboratorium 4

Zadanie 1

PROGRAM lista4_zad1(OUTPUT);
 
USES
	CRT;
 
VAR
	k : REAL;
	x, y, z : INTEGER;
 
BEGIN
	CLRSCR;
 
	k := 1.5;
	x := 5;
	y := 6;
	z := 3;
 
	WRITELN('x + y + z = ', x + y + z);
	WRITELN('x + y * z = ', x + y * z);
	WRITELN('x * (y + z) = ', x * (y + z));
	WRITELN('x + y - z = ', x + y - z);
	WRITELN('y / z = ', (y / z):2:2);
	WRITELN('x + y / z = ', (x + y / z):2:2);
 
	WRITELN;
 
	WRITELN('y DIV 1 = ', (y DIV 1));
	WRITELN('y DIV 2 = ', (y DIV 2));
	WRITELN('y DIV 3 = ', (y DIV 3));
	WRITELN('y DIV 4 = ', (y DIV 4));
	WRITELN('y DIV 5 = ', (y DIV 5));
	WRITELN('y DIV 6 = ', (y DIV 6));
	WRITELN('y DIV 7 = ', (y DIV 7));
 
	WRITELN;
 
	WRITELN('z MOD 1 = ', (z MOD 1));
	WRITELN('z MOD 2 = ', (z MOD 2));
	WRITELN('z MOD 3 = ', (z MOD 3));
	WRITELN('z MOD 4 = ', (z MOD 4));
	WRITELN('z MOD 5 = ', (z MOD 5));
	WRITELN('z MOD 6 = ', (z MOD 6));
 
	WRITELN;
 
	WRITELN('k * y = ', (k * y):2:2);
END.

Wykonujemy podstawowe działania arytmetyczne (w tym DIV i MOD), badając ich zachowanie względem ustalonych liczb.

Zadanie 2

PROGRAM lista4_zad2(OUTPUT);
 
USES
	CRT;
 
BEGIN
	CLRSCR;
 
	WRITELN('ROUND(3.4) = ', ROUND(3.4));
	WRITELN('ROUND(3.7) = ', ROUND(3.7));
 
	WRITELN;
 
	WRITELN('TRUNC(3.4) = ', TRUNC(3.4));
	WRITELN('TRUNC(3.7) = ', TRUNC(3.7));
 
	WRITELN;
 
	WRITELN('INT(3.4) = ', INT(3.4):2:2);
	WRITELN('INT(3.7) = ', INT(3.7):2:2);
 
	WRITELN;
 
	WRITELN('FRAC(3.4) = ', FRAC(3.4):2:2);
	WRITELN('FRAC(3.7) = ', FRAC(3.7):2:2);
END.

Badamy działanie 4 wbudowanych funkcji konwersji: ROUND, TRUNC, INT i FRAC.

Zadanie 3

PROGRAM lista4_zad3(OUTPUT);
 
USES
	CRT, MATH;
 
BEGIN
	CLRSCR;
 
	WRITELN('SIN(PI / 2) = ', SIN(PI /2):2:1);
 
	WRITELN;
 
	WRITELN('SQRT(16) = ', SQRT(16):2:1);
 
	WRITELN;
 
	WRITELN('POWER(2, 3) = ', POWER(2, 3):2:1);
	WRITELN('POWER(125, 1/3) = ', POWER(125, 1/3):2:1);
	WRITELN('POWER(16, 1/4) = ', POWER(16, 1/4):2:1);
 
	WRITELN;
 
	WRITELN('ABS(-16.2) = ', ABS(-16.2):2:1);
END.

Badamy działanie 4 funkcji matematycznych, dostępnych w bibliotece standardowej i module MATH: SIN, SQRT, POWER i ABS.

Zadanie 4

PROGRAM lista4_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczby a i b: ');
	READLN(a, b);
 
	WRITELN;
 
	IF b = 0 THEN
		WRITELN('Nie dzielimy przez zero!')
 
	ELSE
		WRITELN('Iloraz liczb: ', (a / b):0:2);
END.

Badamy iloraz wprowadzonych liczb, pamiętając o zabezpieczeniu sytuacji dzielenia przez zero.

Zadanie 5

PROGRAM lista4_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczbę a: ');
	READLN(a);
 
	WRITELN;
 
	IF (a MOD 2) = 0 THEN
		WRITELN('Jest to liczba parzysta.')
 
	ELSE
		WRITELN('Nie jest to liczba parzysta.');
END.

Badamy parzystość (i nieparzystość) wprowadzonej liczby całkowitej, korzystając z MOD.

Zadanie 6

PROGRAM lista4_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	liczba : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczbę rzeczywistą: ');
	READLN(liczba);
 
	IF liczba > 0 THEN
		WRITELN('Liczba jest większa od zera.')
 
	ELSE IF liczba = 0 THEN
		WRITELN('Liczba jest równa zero!')
 
	ELSE
		WRITELN('Liczba jest mniejsza od zera.');
END.

Sprawdzamy, czy wprowadzona liczba rzeczywista jest większa, mniejsza bądź równa zero.

Zadanie 7

PROGRAM lista4_zad7(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b, c, delta, x0, x1, x2: REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj współczynniki a, b i c równania: ');
	READLN(a, b, c);
 
	WRITELN;
 
	delta := SQR(b) - 4 * a * c;
 
	IF delta < 0 THEN
		WRITELN('Pierwiastki rzeczywiste nie istnieją!')
 
	ELSE IF delta = 0 THEN
		BEGIN
			x0 := -b / (2 * a);
			WRITELN('x0 = ', x0:0:2);
		END
 
	ELSE
		BEGIN
			x1 := (-b + SQRT(delta)) / (2 * a);
			x2 := (-b - SQRT(delta)) / (2 * a);
			WRITELN('x1 = ', x1:0:2, ', x2 = ', x2:0:2);
		END;
END.

Obliczamy miejsca zerowe (dla liczb rzeczywistych) funkcji kwadratowej, analizując wartość delty. Ilość argumentów zależna jest od wartości delty.

Zadanie 8

PROGRAM lista4_zad8(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	licznik, liczba : BYTE;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczbę naturalną: ');
	READLN(liczba);
 
	WRITELN;
 
	FOR licznik := liczba TO (liczba + 10) DO
		WRITELN(licznik);
END.

Wypisujemy 10 kolejnych liczb naturalnych, ale od liczby, którą wprowadzi użytkownik.

Zadanie 9

PROGRAM lista4_zad9(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	licznik : BYTE;
 
BEGIN
	CLRSCR;
 
	FOR licznik := 10 DOWNTO 1 DO
		WRITELN(licznik);
END.

Wypisujemy (malejąco) 10 kolejnych liczb naturalnych, począwszy od liczby 10. W zadaniu tym wykorzystałem wyrażenie DOWNTO, dzięki któremu taki sposób działania pętli jest możliwy.

Zadanie 10

PROGRAM lista4_zad10(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	ciag1, ciag2 : STRING;
 
	PROCEDURE Polacz(x, y : STRING);
		BEGIN
			WRITELN;
			WRITELN(x, ' ', y);
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj pierwszy ciąg znaków: ');
	READLN(ciag1);
 
	WRITE('Podaj drugi ciąg znaków: ');
	READLN(ciag2);
 
	Polacz(ciag1, ciag2);
END.

Program pobiera od użytkownika dwa ciągi znaków. Następnie przekazuje zmienne do procedury Polacz, która to dokonuje konkatenacji i wypisuje wynik jej działania.

Zadanie 11

PROGRAM lista4_zad11(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	ciag1, ciag2, wynik : STRING;
 
	PROCEDURE Polacz(x, y : STRING; VAR z : STRING);
		BEGIN
			WRITELN;
			z := x + ' ' + y;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj pierwszy ciąg znaków: ');
	READLN(ciag1);
 
	WRITE('Podaj drugi ciąg znaków: ');
	READLN(ciag2);
 
	Polacz(ciag1, ciag2, wynik);
 
	WRITELN(wynik);
END.

Zmodyfikowana wersja Zadania 10. Tym razem procedura zwraca wynik do głównego ciała programu - przy pomocy parametru zmiennego.

Zadanie 12

PROGRAM lista4_zad12(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b : REAL;
 
	PROCEDURE Sprawdz(x, y : REAL);
		BEGIN
			WRITELN;
 
			IF x > y THEN	
				WRITELN(x:0:2, ' > ', y:0:2)
 
			ELSE IF x < y THEN
				WRITELN(x:0:2, ' < ', y:0:2)
 
			ELSE
				WRITELN(x:0:2, ' = ', y:0:2);
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczby rzeczywiste a i b: ');
	READLN(a, b);
 
	Sprawdz(a, b);
END.

Program pobiera od użytkownika dwie liczby rzeczywiste. Następnie przekazuje zmienne do procedury Sprawdz, która to w zależności od wartości ich porównania wypisuje stosowany komunikat.

Zadanie 13

PROGRAM lista4_zad13(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	liczba : REAL;
 
	FUNCTION Pierw(a : REAL) : REAL;
		BEGIN
			WRITELN;
 
			IF a > 0 THEN
				Pierw := SQRT(a)
 
			ELSE
				Pierw := -1;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj liczbę rzeczywistą: ');
	READLN(liczba);
 
	IF Pierw(liczba) = -1 THEN
		WRITELN('Tylko liczby dodatnie!')
 
	ELSE
		WRITELN('Pierwiastek z tej liczby to: ', pierw(liczba):0:2);
END.

Program pobiera od użytkownika liczbę rzeczywistą. Następnie przekazuje tą zmienną do funkcji Pierw, która to oblicza jej pierwiastek kwadratowy. W sytuacji gdy podana liczba jest ujemna, funkcja zwraca wartość -1, a główne ciało programu reaguje na to właściwym komunikatem. W pozostałych przypadkach dochodzi do obliczenia wartości.

Zadanie 14

PROGRAM lista4_zad14(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	ciag : STRING;
 
	FUNCTION LiczZnak(a : STRING; b : CHAR) : INTEGER;
		VAR
			licznik, ilosc : INTEGER;
 
		BEGIN
			ilosc := 0;
 
			FOR licznik := 1 TO LENGTH(a) DO
				BEGIN
					IF a[licznik] = b THEN
						ilosc := ilosc + 1;
				END;
 
			LiczZnak := ilosc;
		END;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj ciąg znaków: ');
	READLN(ciag);
 
	WRITELN;
 
	WRITELN('Ilość dla ''o'': ', LiczZnak(ciag, 'o'));
	WRITELN('Ilość dla ''n'': ', LiczZnak(ciag, 'n'));
	WRITELN('Ilość dla ''t'': ', LiczZnak(ciag, 't'));
END.

Program pobiera od użytkownika ciąg znaków. Następnie przekazuje zmienną do funkcji LiczZnak, której zadaniem jest zliczyć ilość wystąpień znaków: o, n oraz t w tym ciągu. Do obliczenia długości ciągu wykorzystałem wbudowaną funkcję LENGTH.

Zadanie 15

PROGRAM lista4_zad15(INPUT, OUTPUT);
 
USES
	CRT;
 
CONST
	PIN = '1234';
 
VAR
	walidacja, weryfikacja : BOOLEAN;
	wybor : CHAR;
	kwota : INTEGER;
 
	{ PROCEDURY :: SprPin, Menu, Saldo }
	PROCEDURE SprPin(VAR wynik : BOOLEAN);
		VAR
			iterator : INTEGER;
			znak : CHAR;
			temp : STRING;
 
		BEGIN
			TEXTCOLOR(LightGreen);
			GOTOXY(37, 6);
			WRITELN('-- PIN --');
			GOTOXY(23, 7);
			WRITELN('______________________________________');
 
			TEXTCOLOR(White);
			GOTOXY(33, 9);
			WRITE('Podaj PIN: ');
 
			temp := '';
 
			FOR iterator := 1 TO 4 DO
				BEGIN
					znak := READKEY;
					WRITE('*');
					temp := temp + znak;
				END;
 
			IF temp = PIN THEN
				wynik := TRUE
 
			ELSE
				wynik := FALSE;
		END;
 
	PROCEDURE Menu(warunek, wynik : BOOLEAN; VAR wybor : CHAR);
		BEGIN
			CLRSCR;
 
			IF wynik = FALSE THEN
				BEGIN
					TEXTCOLOR(LightGreen);
					GOTOXY(37, 6);
					WRITELN('-- PIN --');
					GOTOXY(23, 7);
					WRITELN('______________________________________');
 
					GOTOXY(36, 9);
					TEXTCOLOR(Yellow);
					WRITELN('Błędny PIN!');
					DELAY(2000);
				END
 
			ELSE
				BEGIN
					TEXTCOLOR(LightGreen);
					GOTOXY(37, 6);
					WRITELN('-- MENU --');
					GOTOXY(23, 7);
					WRITELN('______________________________________');
 
					TEXTCOLOR(White);
					GOTOXY(33, 9);
					WRITELN('1. Wpłata');
					GOTOXY(33, 10);
					WRITELN('2. Wypłata');
					GOTOXY(33, 11);
					WRITELN('3. Sprawdź saldo');
					GOTOXY(33, 12);
					WRITELN('4. Exit');
 
					GOTOXY(33, 15);
					WRITE('Wybór: [');
					GOTOXY(42, 15);
					WRITE(']');
 
					IF warunek = TRUE THEN
						BEGIN
							GOTOXY(41, 15);
							wybor := READKEY;
							WRITE(wybor);
						END
 
					ELSE
						WRITELN;
				END;
		END;
 
	PROCEDURE Saldo(kasa : INTEGER);
		BEGIN
			CLRSCR;
 
			TEXTCOLOR(LightGreen);
			GOTOXY(36, 6);
			WRITELN('-- SALDO --');
			GOTOXY(23, 7);
			WRITELN('______________________________________');
 
			TEXTCOLOR(White);
			GOTOXY(35, 9);
			WRITELN('SALDO: ', kasa, 'zł');
 
			DELAY(2000);
 
			Menu(TRUE, TRUE, wybor);
		END;
 
	{ FUNKCJE :: Wplata, Wyplata }
	FUNCTION Wplata(kasa : INTEGER) : INTEGER;
		VAR
			wpl : CHAR;
 
		BEGIN
			CLRSCR;
 
			TEXTCOLOR(LightGreen);
			GOTOXY(36, 6);
			WRITELN('-- WPŁATA --');
			GOTOXY(23, 7);
			WRITELN('______________________________________');
 
			TEXTCOLOR(White);
			GOTOXY(33, 9);
			WRITELN('Możliwości wpłaty:');
			GOTOXY(34, 10);
			WRITELN('a) 50zł');
			GOTOXY(34, 11);
			WRITELN('b) 100zł');
			GOTOXY(34, 12);
			WRITELN('c) 200zł');
			GOTOXY(34, 14);
			WRITELN('d) Wróć do MENU');
 
			GOTOXY(33, 16);
			WRITELN('Twój wybór: [');
			GOTOXY(47, 16);
			WRITELN(']');
			GOTOXY(46, 16);
			wpl := READKEY;
			WRITE(wpl);
 
			IF (wpl = 'a') OR (wpl = 'A') THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('WPŁACONO: 50zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wplata := kasa + 50;
				END
 
			ELSE IF (wpl = 'b') OR (wpl = 'B') THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('WPŁACONO: 100zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wplata := kasa + 100;
				END
 
			ELSE IF (wpl = 'c') OR (wpl = 'C') THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('WPŁACONO: 200zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wplata := kasa + 200;
				END
 
			ELSE IF (wpl = 'd') OR (wpl = 'D') THEN
				BEGIN
					Menu(TRUE, TRUE, wybor);
					Wplata := kasa;
				END
 
			ELSE
				BEGIN
					CLRSCR;
 
					TEXTCOLOR(LightGreen);
					GOTOXY(36, 6);
					WRITELN('-- WPŁATA --');
					GOTOXY(23, 7);
					WRITELN('______________________________________');
 
					GOTOXY(36, 9);
					TEXTCOLOR(Yellow);
					WRITELN('Błędny wybór!');
					DELAY(2000);
 
					weryfikacja := FALSE;
				END;
		END;
 
	FUNCTION Wyplata(kasa : INTEGER) : INTEGER;
		VAR
			wyp : CHAR;
 
		BEGIN
			CLRSCR;
 
			TEXTCOLOR(LightGreen);
			GOTOXY(36, 6);
			WRITELN('-- WYPŁATA --');
			GOTOXY(23, 7);
			WRITELN('______________________________________');
 
			TEXTCOLOR(White);
			GOTOXY(33, 9);
			WRITELN('Możliwość wypłaty:');
			GOTOXY(34, 10);
			WRITELN('a) 50zł');
			GOTOXY(34, 11);
			WRITELN('b) 100zł');
			GOTOXY(34, 12);
			WRITELN('c) 200zł');
			GOTOXY(34, 14);
			WRITELN('d) Wróć do MENU');
 
			GOTOXY(33, 16);
			WRITELN('Twój wybór: [');
			GOTOXY(47, 16);
			WRITELN(']');
			GOTOXY(46, 16);
			wyp := READKEY;
			WRITE(wyp);
 
			IF ((wyp = 'a') OR (wyp = 'A')) AND (kasa >= 50) THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('POBRANO: 50zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wyplata := kasa - 50;
				END
 
			ELSE IF ((wyp = 'b') OR (wyp = 'B')) AND (kasa >= 100) THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('POBRANO: 100zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wyplata := kasa - 100;
				END
 
			ELSE IF ((wyp = 'c') OR (wyp = 'C')) AND (kasa >= 200) THEN
				BEGIN
					GOTOXY(33, 19);
					TEXTCOLOR(Cyan);
					WRITELN('POBRANO: 200zł');
					DELAY(2000);
 
					Menu(TRUE, TRUE, wybor);
 
					Wyplata := kasa - 200;
				END
 
			ELSE IF (wyp = 'd') OR (wyp = 'D') THEN
				BEGIN
					Menu(TRUE, TRUE, wybor);
					Wyplata := kasa;
				END
 
			ELSE
				BEGIN
					CLRSCR;
 
					TEXTCOLOR(LightGreen);
					GOTOXY(36, 6);
					WRITELN('-- WYPŁATA --');
					GOTOXY(23, 7);
					WRITELN('______________________________________');
 
					GOTOXY(33, 9);
					TEXTCOLOR(Yellow);
 
					IF (kasa < 50) OR (kasa < 100) OR (kasa < 200) THEN
						BEGIN
							GOTOXY(32, 9);
							WRITELN('Brak środków na koncie!');
							DELAY(2000);
 
							Wyplata := kasa;
							Menu(TRUE, TRUE, wybor);
						END
 
					ELSE
						BEGIN
							GOTOXY(36, 9);
							WRITELN('Błędny wybór!');
							DELAY(2000);
 
							weryfikacja := FALSE;
						END;
				END;
		END;
 
BEGIN
	CLRSCR;
 
	SprPin(walidacja);
	Menu(TRUE, walidacja, wybor);
 
	kwota := 1000;
	weryfikacja := TRUE;
 
	WHILE (weryfikacja = TRUE) AND (walidacja = TRUE) DO
		BEGIN
			CASE wybor OF
				'1' : kwota := Wplata(kwota);
				'2' : kwota := Wyplata(kwota);
				'3' : Saldo(kwota);
				'4' : EXIT;
 
			ELSE
				BEGIN
					CLRSCR;
 
					TEXTCOLOR(LightGreen);
					GOTOXY(37, 6);
					WRITELN('-- MENU --');
					GOTOXY(23, 7);
					WRITELN('______________________________________');
 
					GOTOXY(36, 9);
					TEXTCOLOR(Yellow);
					WRITELN('Błędny wybór!');
					DELAY(2000);
 
					weryfikacja := FALSE;
				END;
			END;
		END;
END.

Wypasione zadanie, symulujące działanie bankomatu. Program można zdecydowanie okroić, pozbywając się takich "dodatków" jak zmiana pozycji na ekranie GOTOXY, zmiana koloru TEXTCOLOR czy opóźnienie czasowe DELAY. Głównym założeniem tego zadania jest umiejętne operowanie pamięcią (tymczasową) w programie. Należy również zabezpieczyć właściwie sytuację, w której użytkownik chce wypłacić kwotę większą od tej zgromadzonej na koncie.

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

RuPy 2009 – agenda (???)

Katharsis — Wed, 04 Nov 2009 01:53:06 +0000

Już za kilka dni odbędzie się, z niecierpliwością oczekiwana konferencja RuPy 2009! Organizatorzy dopracowują ostatnie szczegóły, a wszystko po to aby pewną stopą stanąć na wysokości zadania!

Ostatnie 3 tygodnie to dla nas prawdziwy sprawdzian cierpliwości, dyspozycyjności i pracy zespołowej. Jak pokazuje praktyka, zapał to nie wszystko! Czasami trzeba mieć też jaja ze stali… W dzisiejszym poście chciałbym przede wszystkim poruszyć temat agendy oraz konkursu, w którym do wygrania były darmowe wejściówki na konferencję, a także podzielić się wizją własnego konkursu, który zamierzam zrealizować w ciągu pierwszego dnia imprezy. Dorzucę do tego kilka kwestii organizacyjnych.

Tegoroczna agenda należy do najbardziej interesujących, a zarazem “upchanych agend” z jakimi RuPy miał do czynienia. Ma to swoje dobre i złe strony, o czym świadczą komentarze na IRCu czy mikroblogach. Spora ilość wystąpień daje uczestnikowi możliwość elastycznej budowy ścieżki, po której będzie się poruszał w czasie imprezy. Staraliśmy się tak dobierać do siebie talki, aby trudność wyboru prelekcji w czasie trwania obu sesji zmniejszyć do minimum. Z pewnością zauważyliście też, że osierociliśmy wystąpienia o tematyce nieściśle związanej z konkretną technologią. Do takich talków należą głównie keynotey invited speakerów.

W tym momencie chciałbym dodać, iż agenda nadal jest modyfikowana, a jej ostateczną formę każdy z nas pozna dzień przed RuPy. Dzieje się to głównie z powodu trudności i problemów osobistych, jakich masowo zaczęli doznawać nasi prelegenci. Do speakerów “stojących pod znakiem zapytania” należą: Olszówka, Franz, Borges i Rudolph. Pomimo naszych wysyłanych e-maili i prób nawiązania telefonicznego kontaktu, nie udało się ostatecznie ustalić czy ich prelekcje są zaklepane. Z pewnością rozczarowania nie ukrywają chłopaki od Rubyiego, a to z powodu nagłej decyzji Obiego Fernandeza, który nie wystąpi na tegorocznym RuPy. W zamian za to pojawi się jego kolega Durran Jordan. Tą sprawę badamy od wczoraj. Stosowny e-mail został już wysłany, dlatego też nadal mamy nadzieję, że Obie jednak powróci do pierwotnej decyzji i wystąpi na polskich ziemiach.

Wspólnie z DEVELOPERS WORLD, miesiąc temu ogłosiliśmy konkurs, w którym nagrodą były dwie darmowe wejściówki na konferencję RuPy! Nie wiem, może zawinił słaby marketing, może pytania były za trudne, ale frekwencja nie wywarła na mnie większego wrażenia. Spodziewałem się bitwy i chyba się przeliczyłem :). Odpowiedzi, jakie zostały nadesłane były prawidłowe, aczkolwiek zróżnicowane. Selekcji dokonaliśmy na zasadzie wyboru najbardziej trafnych i precyzyjnych zgłoszeń, a następnie metodą losowania. Dziękuję chłopakom z PPCG: pigmejowi i salmonowi, za pomoc w analizie odpowiedzi! Zwycięzcami konkursu zostali: Maciej Dziardziel i Damian Nowak. Gratulujemy!

W tym roku będziemy nagradzać uczestników konferencji koszulkami RuPy 2009 i prenumeratami magazynu Linux+ (niestety, bida w budżecie piszczy – nie wszyscy wyjadą w czarnym i pachnącym T-shirtcie). Tak, więc zdradzam sposoby na to, jak takie gadżety pozyskać! Metodą będzie “na pitchera”, nagrodzimy za ciekawe lighting talki. Jednakże wpadła mi do głowy również inna koncepcja. Każdy z Was, podczas rejestracji otrzyma papierową wersję agendy RuPy 2009, kupony na wyżywienie (lunch/obiad) i browar w Mood Cafe. Dodatkowo, na każdej z nich będzie wydrukowany kod, który weźmie udział w grupowym losowaniu gadżetów. W ciągu pierwszego dnia, na oczach uczestników wylosujemy ponad 50 kodów, których właściciele będą mogli zgłosić się do organizatorów po odbiór własnej koszulki (dysponujemy rozmiarami: M/L/XL). Dodam, że cały mechanizm będzie działać w Pythonie :)!

Warto wspomnieć też o tym, że ilość miejsc dla uczestników RuPy 2009, w sektorze VIP klubu Mood Cafe, jest ograniczona (tylko dla 100 osób)! Dlatego proponuję szybkim krokiem podążać w stronę klubu i pamiętać by zabrać ze sobą identyfikatory! Pozostałe osoby również mają możliwość zabawy w klubie, w sektorze ogólnodostępnym. Jeżeli mogę coś zasugerować, bilard + butelka dobrego Whisky w gronie znajomych też świetnie się sprawdza (pozdrawiam Honze i kolegów z PPCG :) ).

Jest to ostatnia notka o charakterze stricte organizacyjnym. Na RuPy 2009 będę brał udział głównie jako uczestnik (obserwator). Ma to związek z zadaniem, którego celem jest wyłapać niedociągnięcia w organizacji, a zarazem w pełni obiektywnie umożliwić mi podsumowanie imprezy. Mam nadzieję, że raport, który złożę zaraz po konferencji okaże się skuteczny i doda swoje dwa grosze do kolejnej edycji RuPy.

Więcej informacji jak zwykle na stronie konferencji: RuPy 2009. Zachęcam również do śledzenia mojego, Jakuba Nowaka i konferencyjnego Twittera!

Bezpiecznej drogi i do zobaczenia w Poznaniu!

Laborki z Pascala – Lista 2 i 3

Katharsis — Sun, 01 Nov 2009 10:30:22 +0000

Wpadł mi do głowy pewien pomysł na to, aby regularnie udostępniać rozwiązania zadań (włącznie z krótką analizą problemu) z Podstaw Programowania. Chciałbym w ten sposób zachęcić Was do prezentacji własnego kodu, a przede wszystkim zarazić bakcylem programowania.

W związku z tym, dzisiaj przerobimy listę 2 i 3.

Laboratorium 2

Zadanie 1

PROGRAM lista1_zad1(OUTPUT);
 
USES
	CRT;
 
BEGIN
	CLRSCR;
 
	WRITELN('                                    ,.,  ');
	WRITELN(' /"""\      /"""\       /"""\      /"""\ ');
	WRITELN(' |o o|      |0 0|       |o o|      |@ @| ');
	WRITELN(' \ - /      \ U /       \ ~ /      \ = / ');
	WRITELN('  |_|        |_|         |_|        |_|  ');
	WRITELN('normalny  szczęśliwy  zakochany  po sesji');
END.

To zadanie chyba nie wymaga szczególnego komentarza.

Zadanie 2

PROGRAM lista1_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj dwie liczby rzeczywiste: ');
	READ(a, b);
 
	WRITELN;
 
	WRITELN('Suma: ', (a + b):2:2);
	WRITELN('Różnica: ', (a - b):2:2);
	WRITELN('Iloczyn: ', (a * b):2:2);
 
	IF b = 0 THEN
		WRITELN('Nie dzielimy przez zero!')
 
	ELSE
		WRITELN('Iloraz: ', (a / b):2:2);
END.

Wczytujemy przy pomocy instrukcji READ (oddzielając spacją) dwie liczby rzeczywiste. Następnie, wykonujemy kolejno wyrażenia: sumy, różnicy, iloczynu oraz ilorazu dla tych liczb, uwzględniając sytuację, w której dzielnik jest zerem. Wyniki formatujemy, zaokrąglając do dwóch miejsc po przecinku.

Zadanie 3

PROGRAM lista1_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	tempC : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj temperaturę (w Celsjuszach): ');
	READ(tempC);
 
	WRITELN;
 
	WRITELN('Temperatura (w Farenheitach): ', ((1.8 * tempC) + 32):2:1);
END.

Wczytujemy przy pomocy instrukcji READ liczbę rzeczywistą – temperaturę wyrażoną w Celsjuszach – którą to w instrukcji WRITELN konwertujemy (przy pomocy wzoru) i przedstawiamy jako wynik, zaokrąglony do jednego miejsca po przecinku.

Zadanie 4 (a)

PROGRAM lista1_zad4_a(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	argm, war : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź argument funkcji: ');
	READ(argm);
 
	IF argm < -1 THEN
		war := 3 * argm
 
	ELSE IF (argm >= -1) AND (argm < 1) THEN
		war := 2 * argm
 
	ELSE
		war := argm;
 
	WRITELN('Wartość funkcji: ', war);
END.

Wczytujemy przy pomocy instrukcji READ liczbę całkowitą – argument naszej funkcji. W zależności od jej wartości, sprawdzanej w instrukcji warunkowej IF – ELSE IF – ELSE, wzór funkcji liniowej przybiera różne postacie. Na koniec wyprowadzamy wartość funkcji jako wynik działania.

Zadanie 4 (b)

PROGRAM lista1_zad4_b(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	argm, war : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź argument funkcji: ');
	READ(argm);
 
	IF argm < -5 THEN
		war := -argm
 
	ELSE IF (argm >= -5) AND (argm < 5) THEN
		war := 0
 
	ELSE
		war := argm;
 
	WRITELN('Wartość funkcji: ', war);
END.

Zadanie analogiczne do podpunktu (a). Zmieniły się tylko przedziały w instrukcji warunkowej.

Zadanie 5

PROGRAM lista1_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Wprowadź współczynniki a i b: ');
	READ(a, b);
 
	WRITELN;
 
	IF b = 0 THEN
		WRITELN('Nie dzielimy przez zero!')
 
	ELSE
		WRITELN('Miejsce zerowe funkcji: ', (-b / a):2:1);
END.

Wczytujemy przy pomocy instrukcji READ (oddzielając spacją) dwie liczby rzeczywiste - współczynniki a i b naszej funkcji. Następnie, sprawdzamy czy przypadkiem b nie jest równe zeru. Jeżeli nie, obliczamy miejsce zerowe i wyprowadzamy wynik.

Zadanie 6

PROGRAM lista1_zad6(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	a, b, c: INTEGER;
	p : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Podaj długości boków a, b i c: ');
	READ(a, b, c);
 
	WRITELN;
 
	IF (a < b + c) AND (b < a + c) AND (c < b + a) THEN
		BEGIN
			p := (a + b + c) / 2;
			WRITELN('Pole trójkąta: ', SQRT(p * (p - a) * (p - b) * (p - c)):2:2);
		END
 
	ELSE
		WRITELN('Nie policzę tego!');
END.

Wczytujemy przy pomocy instrukcji READ (oddzielając spacją) trzy liczby całkowite - boki trójkąta: a, b i c. Następnie sprawdzamy ich wartości względem warunku istnienia trójkąta (dowolnego). Jeżeli z podanych wartości możemy zbudować figurę, korzystamy ze wzoru Herona. Pierwiastek obliczamy przy pomocy funkcji wbudowanej SQRT.

Laboratorium 3

Zadanie 1

PROGRAM lista2_zad1(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x, ilosc : BYTE;
	liczba : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Ile liczb wprowadzisz: ');
	READ(ilosc);
 
	x := 0;
 
	WRITELN;
 
	WHILE x < ilosc DO
		BEGIN
			x := x + 1;
 
			WRITE('Podaj liczbę: ');
			READ(liczba);
 
			WRITELN('Wynik: ', x, ' ', liczba:2:2, ' ', (liczba * liczba):2:2, ' ', (liczba * liczba * liczba):2:2);
			WRITELN
		END;
END.

Wczytujemy przy pomocy instrukcji READ liczbę naturalną - odgrywającą rolę górnej granicy ilości obrotów pętli (inkrementacja). Następnie, w ciele pętli pytamy użytkownika o liczbę rzeczywistą, na podstawie której mamy wykonać operacje. Wyprowadzamy jej pozycję w ciągu, liczbę i jej kwadrat oraz sześcian, formatując wyniki wyrażeń do dwóch miejsc po przecinku.

Zadanie 2

PROGRAM lista2_zad2(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	liczba : INTEGER;
	licznik : BYTE;
	x : BOOLEAN;
 
BEGIN
	CLRSCR;
 
	x := TRUE;
	licznik := 0;
 
	WHILE x = TRUE DO
		BEGIN
			WRITE('Podaj liczbę: ');
			READ(liczba);
 
			licznik := licznik + 1;
 
			IF liczba = 0 THEN
				x := FALSE
 
			ELSE
				WRITELN('Wynik: ', licznik, ' ', liczba, ' ', liczba * liczba, ' ', liczba * liczba * liczba);
 
			WRITELN;
		END;
END.

W przypadku tego zadania, nie ustalamy odgórnie długości ciągu na podstawie wartości jaką początkowo wprowadza użytkownik. Umożliwiamy mu wykonywanie obliczeń (na liczbach całkowitych), dopóty dopóki nie poda liczby 0, która to przerywa działanie pętli. Warto też uwzględnić, że podczas przerwania pętli program nie wykona obliczeń dla wartości 0. Działanie pętli WHILE .. DO w tym przykładzie bazuje na typie danych BOOLEAN.

Zadanie 3

PROGRAM lista2_zad3(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	liczba : EXTENDED;
	licznik : BYTE;
	x : BOOLEAN;
 
BEGIN
	CLRSCR;
 
	x := TRUE;
	licznik := 0;
 
	WHILE x = TRUE DO
		BEGIN
			WRITE('Podaj liczbę: ');
			READ(liczba);
 
			licznik := licznik + 1;
 
			IF liczba = 10000 THEN
				BEGIN
					WRITELN('Wynik: ', licznik, ' ', liczba:1:0, ' ', (liczba * liczba):1:0, ' ', (liczba * liczba * liczba):1:0);
					x := FALSE;
				END
 
			ELSE
				WRITELN('Wynik: ', licznik, ' ', liczba:1:0, ' ', (liczba * liczba):1:0, ' ', (liczba * liczba * liczba):1:0);
 
			WRITELN;
		END;
END.

To zadanie jest niemalże identyczne jak powyższe, z tym że tutaj operujemy na bardzo dużym przedziale liczb EXTENDED. Dlatego, że działanie pętli zakończy się w momencie jak użytkownik poda liczbę 10000, dla której to musimy wykonać obliczenia (kwadrat i sześcian tej liczby) i dopiero wtedy zakończyć działanie programu.

Zadanie 4

PROGRAM lista2_zad4(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x : BOOLEAN;
	znak : CHAR;
	licznik : BYTE;
 
BEGIN
	CLRSCR;
 
	x := TRUE;
	licznik := 0;
 
	WHILE x = TRUE DO
		BEGIN
			WRITE('Podaj znak: ');
			READLN(znak);
 
			licznik := licznik + 1;
 
			IF znak = '*' THEN
				BEGIN
					WRITELN;
					WRITELN('Ilość znaków w ciągu: ', licznik - 1);
					x := FALSE;
				END;
 
			WRITELN;
		END;
END.

Wczytujemy od użytkownika ciąg znaków, do momentu aż zostanie wprowadzona *, która powoduje zakończenie działania pętli oraz wypisanie łącznej sumy wprowadzonych znaków (nie uwzględniając gwiazdki).

Zadanie 5

PROGRAM lista2_zad5(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	ilosc, licznik, pozycja : BYTE;
	liczba, max : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Ile liczb chcesz wprowadzić: ');
	READ(ilosc);
 
	licznik := 0;
	max := 0;
 
	WRITELN;
 
	WHILE licznik < ilosc DO
		BEGIN
			licznik := licznik + 1;
 
			WRITE('Podaj liczbę: ');
			READ(liczba);
 
			IF liczba > max THEN
				BEGIN
					max := liczba;
					pozycja := licznik;
				END;
 
			WRITELN;
		END;
 
	WRITELN('Liczba: ', max, ', Numer w ciągu: ', pozycja);
END.

Wczytujemy od użytkownika liczbę, która będzie odgrywać rolę górnej granicy ilości obrotów pętli. W ciele tej pętli, pobieramy ciąg liczb, na podstawie którego, wyznaczamy maksymalną wartość oraz jej pozycję w tym ciągu. Wykonujemy to przy pomocy zmiennej pomocniczej max (zerowanej w głównym ciele programu), która za każdym obrotem pętli jest porównywana z nowo wprowadzoną liczbą. Jeżeli warunek nierówności jest spełniony, dla zmiennej max przypisywana jest nowa wartość i zapamiętywana jej pozycja.

Zadanie 6 (a)

PROGRAM lista2_zad6_a(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x, y, war, r, ilosc : INTEGER;
 
BEGIN
	CLRSCR;
 
	WRITE('Ilość punktów do sprawdzenia: ');
	READ(ilosc);
 
	WRITE('Podaj promień okręgu: ');
	READ(r);
 
	r := r * r;
 
	WHILE ilosc > 0 DO
		BEGIN
			WRITELN;
 
			WRITE('Podaj współrzędne x i y punktu: ');
			READ(x, y);
 
			ilosc := ilosc - 1;			
			war := (x * x) + (y * y);
 
			WRITELN;
 
			IF war = r THEN
				WRITELN('Punkt: (', x, ', ', y, ') leży na obręczy okręgu')
 
			ELSE IF war < r THEN
				WRITELN('Punkt: (', x, ', ', y, ') leży wewnątrz okręgu')
 
			ELSE
				WRITELN('Punkt: (', x, ', ', y, ') leży na zewnątrz okręgu');
		END;
END.

W celu sprawdzenia czy dany punkt leży nad, pod lub na obręczy okręgu (o środku (0, 0)), musimy zastosować nierówności (i porównanie) pomiędzy kwadratem promienia okręgu, a sumą kwadratów współrzędnych tego punktu. Wynik końcowy zależny jest od wyniku instrukcji warunkowej.

Zadanie 6 (b)

PROGRAM lista2_zad6_b(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	ilosc : INTEGER;
	F, x, y : REAL;
 
BEGIN
	CLRSCR;
 
	WRITE('Ilość punktów do sprawdzenia: ');
	READ(ilosc);
 
	WRITE('Podaj wartość funkcji: ');
	READ(F);
 
	WHILE ilosc > 0 DO
		BEGIN
			WRITELN;
 
			WRITE('Podaj współrzędne x i y punktu: ');
			READ(x, y);
 
			ilosc := ilosc - 1;
 
			WRITELN;
 
			IF F = y THEN
				WRITELN('Punkt: (', x:2:1, ', ', y:2:1, ') leży na prostej')
 
			ELSE IF F < y THEN
				WRITELN('Punkt: (', x:2:1, ', ', y:2:1, ') leży nad prostą')
 
			ELSE
				WRITELN('Punkt: (', x:2:1, ', ', y:2:1, ') leży pod prostą');
		END;
END.

Ten kod jest bardzo podobny do rozwiązania powyższego zadania, z tym że, tutaj sprawdzamy pozycję punktu względem prostej (stałej). Wystarczy tylko sprawdzić nierówności w instrukcji warunkowej, pomiędzy wartością prostej, a wartością podanego punktu. Dodatkowo, tutaj operujemy na liczbach rzeczywistych.

Zadanie 7 (a)

PROGRAM lista2_zad7_a(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x : BYTE;
	y : EXTENDED;
 
BEGIN
	CLRSCR;
 
	WRITE('Policzę silnię z liczby: ');
	READ(x);
 
	y := 1;
	y := y * x;
 
	WHILE x > 1 DO
		BEGIN
			x := x - 1;
			y := y * x;
		END;
 
	WRITELN;
 
	WRITELN('Wynik: ', y:2:2);
END.

Wprowadzamy wartość liczby naturalnej, na podstawie której liczona jest silnia. Zazwyczaj algorytm silni bazuje na rekurencji, jednak na tym poziomie wiedzy, musimy zbudować go przy użyciu samej pętli. Pomysł jaki należało wykorzystać w przypadku pętli WHILE .. DO polega na tym, by przy każdym jej obrocie zmniejszać liczbę wejściową o jeden (dekrementacja) i w takiej postaci wymnażać z iloczynem wszystkich, kolejnych liczb dodatnich.

Zadanie 7 (b)

PROGRAM lista2_zad7_b(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x, i: BYTE;
	y : EXTENDED;
 
BEGIN
	CLRSCR;
 
	WRITE('Policzę silnię z liczby: ');
	READ(x);
 
	y := 1;
 
	FOR i := 1 TO x DO
		y := y * i;
 
	WRITELN;
 
	WRITELN('Wynik: ', y:2:2);
END.

Rozwiązanie bazujące na pętli FOR .. TO .. DO wydaje się być prostsze do zrozumienia i szybsze do zaimplementowania. Dla określonego przedziału wykonujemy mnożenie kolejnych liczb z tego przedziału, w efekcie końcowym otrzymując wynik.

Zadanie 7 (c)

PROGRAM lista2_zad7_c(INPUT, OUTPUT);
 
USES
	CRT;
 
VAR
	x, i : BYTE;
	y : EXTENDED;
 
BEGIN
	CLRSCR;
 
	WRITE('Policzę silnię z liczby: ');
	READ(x);
 
	y := 1;
	i := 1;
 
	REPEAT
		y := y * i;
		i := i + 1;
 
	UNTIL
		i > x;
 
	WRITELN;
 
	WRITELN('Wynik: ', y:2:2);
END.

Ostatnie rozwiązanie wykorzystuje instrukcję REPEAT .. UNTIL. Koncepcja jest podobna do przykładu (a), jednak w tym wypadku najpierw wykonujemy iloczyn liczb, stosujemy inkrementację, a następnie sprawdzamy warunek pętli.

Rozwiązania z listy 4 pojawią się w najbliższy wtorek.

RuPy 2009 – powiew nadziei i wszystko się klei

Katharsis — Wed, 07 Oct 2009 09:42:14 +0000

Dużo dobrego dzieje się w organizacji tegorocznej edycji konferencji RuPy. Dowodzi tego kolejna notka, optymistycznie zapowiadająca to listopadowe wydarzenie.

Wielokrotnie wspominałem o kryzysie jaki dotknął RuPy 2009. Jak się okazuje, nic nie trwa wiecznie, a cierpliwość się opłaca. Do grona sponsorów imprezy dołączyły dwie kolejne firmy: NG Logic i Lunar Logic Polska. Co więcej prowadzimy aktualnie negocjację z innymi firmami i fundacjami, wykazującymi chęci zaangażowania się w promocję i pomoc finansową dla konferencji.

Idąc tropem pozytywnych wiadomości: jest już pełna lista prelegentów! Dokładnie 20 talków (tyle co przewidywaliśmy) zostanie wygłoszonych na tegorocznym RuPy. Warto też w tym miejscu zasygnalizować, że spora ich część zostanie poprowadzona przez znane nam postacie ze świata Pythona, Rubiego czy innych nowoczesnych technologii. Bardzo pocieszającym faktem jest to, że prawie połowę z tych prelekcji poprowadzą Polacy! Jest to dla nas miłe zaskoczenie, ponieważ początkowo obawialiśmy się małego zaangażowania rodaków w tym wydaniu imprezy.

Skuteczny marketing, rzetelność Partnerów Medialnych oraz interesująca lista talków przekładają się na ilość zarejestrowanych osób. Mogę zdradzić, że w tym momencie pojawi się już ponad 150 uczestników imprezy, a ugościć jesteśmy w stanie jeszcze drugie tyle!

A teraz niespodzianka, którą celowo zostawiłem na deser. Wiadomo, że w PPCG są osoby, które od początku działalności w projekcie, wykazują się ponad przeciętnym zaangażowaniem, wiedzą i czasem, budując to Polskie Community Pythona. W związku z tym postanowiłem z pośród najbardziej widocznych postaci, wybrać trzy, które otrzymają darmowe wejścia (z wyżywieniem i zestawem gadżetów) na RuPy 2009. Są to mianowicie:

Jędrzej “Pigmej” Nowak
Zaprojektował system do zarządzania treścią dla portalu PPCG: Pigmej CMS, który od ponad roku służy nam jako część platformy projektu. Jędrzej planuje wydanie jego kolejnej wersji, jako system w pełni otwarty. Jest również jednym z developerów bota IRCowego: Konfident, ułatwiającego nam komunikację pomiędzy trzema głównymi częściami projektu. Włożył duży wkład w pozyskanie głównego sponsora dla projektu PPCG – firmę DMTEC.

Marek “red_ag” Skiba
Administrator głównego serwera PPCG (również Forum). Jest odpowiedzialny za wszelkie migracje, integracje oraz konfiguracje systemów, skryptów sieciowych, tworzenie backupów i zadań, które powodują, że platforma projektu nigdy jeszcze tak skutecznie nie funkcjonowała. Marek jest głównym pomysłodawcą serwera Jabbera w domenie python.org.pl. Pozyskał również pierwszego sponsora, oferującego hosting – firmę Maxnet.

Piotr “Husio” Husiatyński
Główny developer jednego z pierwszych edycji Konfidenta. Jest najbardziej skutecznie udzielającą się osobą na Forum projektu. Posiada duży wkład w kształt PPCG, często dzieląc się słusznymi uwagami i sugestiami, dot. spraw technicznych i organizacyjnych projektu. Piotr prowadzi również Wiki Pythona, które z biegiem czasu z pewnością przerodzi się w bogate i różnorodne źródło wiedzy.

W gronie naszej paczki, jest jeszcze kilka osób, które równie skutecznie angażują się w rozwój i przyszłość tego projektu. Gdybym tylko posiadał większe możliwości oraz środki, z pewnością lista osób wyszczególnionych byłaby dłuższa.

Uwaga! W najbliższym czasie zorganizujemy wspólnie z JAVA exPress konkurs teoretyczno-programistyczny, na którym to spośród osób przechodzących do głównego etapu, wylosujemy dwie, które otrzymają wejściówki na RuPy 2009 :)! Niestety nic więcej na ten temat powiedzieć nie mogę, jak tylko życzyć powodzenia.

Więcej informacji jak zwyklę dostepnych będzie na stronie konferencji: RuPy 2009.

RuPy 2009 – nastąpiło otwarcie rejestracji

Katharsis — Tue, 22 Sep 2009 22:41:55 +0000

Wszystko zaczyna nabierać pozytywnych wibracji, a struktura konferencji wyrazistych kształtów. Otóż kilka dni temu ruszyliśmy z rejestracją! Do dnia 6 listopada każdy z Was ma możliwość zgłoszenia swojego uczestnictwa na tegoroczną edycję RuPy, przy pomocy tego formularza.

Chciałbym zwrócić uwagę na 3 rzeczy związane z powyższym. Pierwsza to cena konferencji, która z biegiem kolejnych tygodni wzrasta! Dlatego też sugeruję by rejestracji dokonywać jak najszybciej, również z powodu ograniczonej ilości miejsc (nieoficjalnie 300). Druga, to często pomijana informacja, którą chcę podkreślić – rezerwacja miejsca jest równoznaczna z datą, w której dokonujemy wpłaty. I rzecz ostatnia dotyczy waluty, w jakiej wykonujemy przelew. Uczestnicy z Polski mają możliwość transferowania w polskich złotych, a w pozostałych przypadkach jest to Euro.

Co więcej znane jest już dokładne miejsce, w którym odbędzie się impreza. W związku z tym, że tegoroczny kapitał imprezy nie jest wystarczający do wynajmu np. kina Apollo, zdecydowaliśmy się na ponowną współpracę z władzami Uniwersytetu im. Adama Mickiewicza w Poznaniu, na Wydziale Matematyki i Informatyki. Konferencja odbędzie się dokładnie w tym samym miejscu, co zeszłoroczne edycję. Będziemy mieli do dyspozycji dwie aule (ponad 200 i 100 osobowe), gdzie odbędą się wszystkie prelekcje.

Na zakończenie mogę dodać, że strona jest sukcesywnie aktualizowana. Dlatego też zainteresowanych kwestią zakwaterowania czy dojazdu, zapraszam do działu LOCATION. W niektórych hotelach będą przewidziane rabaty dla uczestników konferencji RuPy 2009.

Więcej informacji na stronie RuPy 2009.