Informacje organizacyjne

Egzamin zerowy

  1. Dn. 25 stycznia (środa) w sali wykładowej 114, bud. 21, w godz. 9:45 – 11:15 planowany jest egzamin zerowy z ZTP.
  2. Egzamin jest pisemny. Proszę zabrać ze sobą kartki papieru i długopisy oraz legitymacje studenckie. Osoby spóźnione nie zostaną wpuszczone na salę (radzę ten jeden raz przyjechać na uczelnię wcześniejszym autobusem).
  3. Szczegółowe zasady udziału są opisane na stronie www: Zasady zaliczenia wykładu, ale uwaga: (1) egzamin nie ma części praktycznej, to znaczy, nie będzie kartki z kodem programu, dla którego należy podać komunikaty wypisywane w oknie konsoli, (2) wszystkie osoby, które mają szansę na ocenę pozytywną z lab. na koniec semestru są oczekiwane na egzaminie.
  4. Ocenie podlegają prace egzaminacyjne tylko tych osób, które na koniec semestru, tj. 27 stycznia (piątek) będą miały z zajęć lab. dostateczną liczbę punktów oraz spełnią warunki gwarantujące ocenę pozytywną.
  5. Oceny pozytywne uzyskane z tego egzaminu są wpisywane do protokołu jako zdobyte w pierwszym terminie.
  6. Oceny negatywne nie są nigdzie wpisywane i są zapominane.
  7. Jeżeli będą takie osoby, które zostaną zwolnione z egzaminu za bardzo dobre wyniki lab., to proponowana im ocena zastąpi ocenę z egzaminu zerowego. Jednak decyzja o zastosowaniu w tym roku zwolnień z egzaminu za bardzo dobre wyniki jeszcze nie została podjęta.
  8. Brak zainteresowania (niedostateczna liczba studentów na sali) spowoduje odwołanie egzaminu zerowego.

Zwracam uwagę na zasadę: Na egzaminie nie wolno sięgać do telefonów komórkowych. Telefony w czasie egzaminu muszą być wyciszone i schowane np. w torbie czy plecaku. Niestosowanie się do tej zasady skutkuje natychmiastowym zakończeniem egzaminu przez studenta i opuszczeniem sali.

Poprawa jednej oceny z zajęć lab.

  1. Dn. 25 stycznia (środa) w pracowni komputerowej 119, bud. 21, w godz. 11:30 – 14:45 odbędą się zajęcia lab., na których będzie można uzyskać ocenę, która zastąpi jedną z ocen uzyskanych na zajęciach lab. w semestrze.
  2. Zajęcia lab. w dn. 25 stycznia nie są obowiązkowe. Są to zajęcia tylko dla osób, które mają powody, aby chcieć skasować jedną ze swoich ocen i zastąpić ja oceną zdobytą na tych zajęciach. Np. jeżeli ktoś ma trzy zera z zajęć, co oznacza, że otrzyma ocenę negatywną z lab., może przyjść, aby zdobyć lepszą ocenę, która zastąpi jedno z tych zer.
  3. Przed rozpoczęciem zajęć wszystkim uczestnikom kasowana jest jedna, wskazana przez nich ocena z zajęć lab. w semestrze. Jeżeli jest to ocena inna niż zero punktów, wskazane punkty są tracone bezpowrotnie.
  4. Na zajęciach będzie do zrobienia jedno zadanie, za które można zdobyć do 10 pkt. Zadanie obejmuje materiał całego semestru. Warunki realizacji są takie same jak na zajęciach w semestrze, tj. praca samodzielna bez korzystania z zasobów internetu (za wyjątkiem strony https://cplusplus.com/ oraz platformy learningowej UKSW).
  5. Zajęcia w tej sali są wspólne dla zainteresowanych z wszystkich trzech grup.

W razie niejasności proszę o pytania mailem. Pytania o warunki zwolnienia z egzaminu za bardzo dobre wyniki z lab. będą ignorowane – tak jak mówiłem, te warunki zostaną ustalone dopiero po zakończeniu semestru, kiedy będą znane wszystkie wyniki z lab.

ZTP2022: Zadania przed lab.7

Założenia

Przyjmijmy, że mamy zbiór punktów w przestrzeni n-wymiarowej, przy czym współrzędne pojedynczego punktu są reprezentowane w postaci wektora liczb rzeczywistych o długości n. Mówimy, że punkt A dominuje nad punktem B, jeżeli dla każdej współrzędnej A(i) odpowiadająca jej współrzędna B(i) jest mniejsza lub równa, oraz istnieje co najmniej jedna taka współrzędna j dla której A(j)>B(j). Można też wtedy powiedzieć, że B jest zdominowane przez A. Jeżeli natomiast dla pary punktów taki warunek nie jest spełniony, tj. ani A nie dominuje nad B, ani B nad A, wtedy uważamy punkty A i B za nieporównywalne względem siebie.

W zbiorze punktów punkt niezdominowany to taki, który może tylko dominować lub być nieporównywalnym z wszystkimi pozostałymi punktami.

Zbiór 20 punktów
Przykład: zbiór 20 punktów z zaznaczonymi na czerwono punktami niezdominowanymi
Zbiór 100 punktów
Przykład: zbiór 100 punktów z zaznaczonymi na czerwono punktami niezdominowanymi

Zadanie #1

Wygeneruj zbiór 100 losowych punktów w przestrzeni n-wymiarowej, po czym znajdź w nim zbiór punktów niezdominowanych. Algorytm znajdowania punktów niezdominowanych polega na porównaniu każdego punktu ze wszystkimi pozostałymi (nie dokonujemy porównania punktu z samym sobą). Jeżeli dla aktualnie sprawdzanego punktu z żadnego porównania nie wyniknie, że jest zdominowany, to znaczy, że jest niezdominowany. Znaleziony punkt niezdominowany należy zapisać w kontenerze pomocniczym. Na koniec sprawdzania kontener pomocniczy zawiera wyłącznie punkty niezdominowane.
Algorytm można zrealizować z pomocą dwóch kontenerów zawierających zestawy tych samych 100 punktów oraz kontenera pomocniczego, który początkowo jest pusty. Punkty z pierwszego kontenera są punktami sprawdzanymi, a punkty z drugiego – punktami z którymi dokonywane jest sprawdzenie. Do kontenera pomocniczego trafiają kopie tych punktów z kontenera pierwszego, które okazały się niezdominowane. Realizacja czynności odbywa się za pomocą dwóch pętli for – zewnętrznej (punkty z pierwszego kontenera) i wewnętrznej (punkty z drugiego kontenera).
Po zaimplementowaniu algorytmu spróbuj zaimplementować go ponownie, ale tym razem bez używania pętli for, while, repeat, natomiast stosując algorytmy STL oraz własne lub biblioteczne obiekty funkcyjne. Sprawdź, czy uzyskałeś ten sam wynik.

Zadanie #2

Wygeneruj zbiór 100 punktów losowo rozłożonych na okręgu (w przestrzeni 2-wymiarowej) o promieniu 1 (zobacz Zadania przed lab. 6: zadanie #2), po czym znajdź w nim zbiór punktów niezdominowanych. W kontenerze uporządkuj rosnąco niezdominowane punkty pod względem ich pierwszej współrzędnej. Wykorzystując algorytm adjacent_difference (slajdy 122 i 123, wykład 9) policz odległości euklidesowe miedzy sąsiednimi punktami (tj. między punktami 1 i 2, 2 i 3, 3 i 4, itd.). Uwaga: w obiekcie funkcyjnym służącym do obliczenia odległości euklidesowej miedzy dwoma punktami skorzystaj z algorytmu inner_product, tak jak to jest pokazane na slajdzie 121 wykładu 9. Policzone odległości zapisz do pomocniczego kontenera, a na koniec policz średnią odległość między punktami oraz wariancję tej odległości.
Przy pisaniu kodu programu unikaj pętli for, while, repeat, a zamiast nich stosuj algorytmy STL oraz własne lub biblioteczne obiekty funkcyjne.

Hint: Zadanie dotyczące znajdowania zbioru punktów niezdominowanych może pojawić się na lab.7. Na zajęciach można będzie wykorzystać fragmenty własnego kodu opracowanego w domu.

ZTP2022: Wykład 4 stycznia 2023

W związku z Decyzją Nr 40/2022 Prorektora ds. Studenckich i Kształcenia UKSW z 14.12.2022 r. w sprawie organizacji zajęć dydaktycznych w UKSW w okresie 2 stycznia – 5 stycznia 2023 r., wykład ZTP odbędzie się 4 stycznia zgodnie z planem w trybie zdalnym na platformie MS Teams. Aby uczestniczyć w wykładzie należy dołączyć do zespołu WM-I-S1-E3-ZTP_2022/23_Z_WYK_GR1 korzystając z kodu: xa0nijf

ZTP2022: Zadania przed lab.6

Zadania, które dotyczą zakresu materiału, jaki będzie poruszany na lab. 6. Rozwiązanie nie jest wymagane. Zadania stanowią wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie #1:

Przyjmij, że A, B, C i D reprezentują punkty w przestrzeni n-wymiarowej. Punkty te są reprezentowane w programie przez wektory współrzędnych. Wektor A zawiera dla każdej współrzędnej uzyskaną niezależnie wartość losową z generatora liczb o rozkładzie jednostajnym z przedziału [-10,10]. Wektor B zawiera wartości stałe [1,..,1].

Pobierz od użytkownika liczbę wymiarów przestrzeni n, utwórz odpowiednich rozmiarów wektory, przy czym zainicjuj też odpowiednio A i B, a następnie napisz kod wykonujący kolejno następujące obliczenia:

  1. D = A*B
  2. C = 3*B + D
  3. D = 3*(A+C)-(A*B)

gdzie operator '*’ oznacza mnożenie, przy czym kiedy argumentami są skalar i wektor, następuje przemnożenie wszystkich współrzędnych wektora przez skalar, natomiast w przypadku, kiedy argumentami są dwa wektory, jest to iloczyn Hadamarda (zobacz: https://pl.wikipedia.org/wiki/Mnożenie_macierzy). Sprawdź na danych testowych, czy obliczenia wykonują się poprawnie.

Uwaga: do zaimplementowania w/w operacji nie wykorzystuj żadnych pętli (for, while, repeat), a wyłącznie algorytmy STL i obiekty funkcyjne (własne lub biblioteczne). Jeżeli to potrzebne, rozłóż operacje na pojedyncze kroki, których wynik zapamiętuj w wektorach pomocniczych.

Zadanie #2:

W celu wygenerowania punktu na powierzchni hipersfery (zobacz: https://pl.wikipedia.org/wiki/Hipersfera) z centrum w środku układu współrzędnych należy wykonać następujące kroki:

  1. wygenerować wektor Z, którego każda współrzędna jest uzyskaną niezależnie wartością losową z generatora liczb o rozkładzie normalnym. Liczba współrzędnych wektora odpowiada liczbie wymiarów przestrzeni, w której definiowana jest hipersfera,
  2. policzyć ||Z||, tj. długość wektora Z, a następnie podzielić każdą ze współrzędnych wektora Z przez tę długość.

Nowy wektor Z reprezentuje punkt na powierzchni hipersfery o promieniu 1 z centrum w środku układu współrzędnych.

Wygeneruj wiele takich punktów dla przestrzeni 2-wymiarowej i przedstaw je w postaci graficznej. Sprawdź, czy układają się w kształt okręgu.

Uwaga: do zaimplementowania w/w operacji nie wykorzystuj żadnych pętli (for, while, repeat), a wyłącznie algorytmy STL i obiekty funkcyjne (własne lub biblioteczne). Jeżeli to potrzebne, rozłóż operacje na pojedyncze kroki, których wynik zapamiętuj w wektorach pomocniczych.

ZTP2022: Zadania przed lab.5

Zadania, które dotyczą zakresu materiału, jaki będzie poruszany na lab. 5. Rozwiązanie tych zadań nie jest wymagane. Stanowią wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie 1:

Napisz funkcję, która wczytuje macierz z pliku tekstowego zapisaną tak, że w kolejnych wierszach pliku są wartości komórek kolejnych wierszy macierzy rozdzielone spacjami, a następnie dokonuje jej transpozycji. Przyjmij, że wymiary wczytywanej macierzy są nieznane, ale że dane w pliku są na pewno poprawne (tj. wiersze przechowują tylko liczby, liczby liczb w wierszach są takie same, itp.). Do wczytania macierzy użyj kontenera typu <deque<deque<double>>. Funkcja zwraca transponowaną macierz w postaci wskaźnika do dynamicznie alokowanego kontenera typu vector<vector<double>>. Wypisz w oknie konsoli zawartość wynikowego kontenera i sprawdź, czy transpozycja została przeprowadzona poprawnie.

Zadanie 2:

Wczytaj słowa z kolejnych wierszy z pliku tekstowego do listy list, tj. kontenera typu list<list<string>>, tak aby kontener zawierał listę wierszy, gdzie każdy wiersz jest reprezentowany przez listę słów z tego wiersza. Posortuj rosnąco słowa z każdego wiersza wg zasady sortowania takiej jak w słowniku języka polskiego, a następnie scal posortowane listy słów do jednej listy wynikowej reprezentowanej przez inny kontener typu list<string>. Wypisz w oknie konsoli zawartość wynikowego kontenera w postaci kolumny i upewnij się, że sortowanie i scalanie się powiodło. Testy przeprowadź na pliku mistrz.txt

ZTP2022: Zadania przed lab.4

ZTP2022: Zadania przed lab.4

Zadanie, które dotyczy zakresu materiału, jaki będzie poruszany na lab. 4. Rozwiązanie tego zadania nie jest wymagane. Stanowi wyłącznie pomoc w przygotowaniu się do zajęć.

Zamieszczony poniżej kod programu reprezentuje przykład programowania z wykorzystaniem cech charakterystycznych. W programie wykorzystywane są dwie klasy reprezentujące dwa pojęcia:

  1. temperatura_wody – liczba rzeczywista reprezentująca temperaturę wody
  2. kostka_do_gry – liczba całkowita reprezentująca wartość, jaka może wypaść w wyniku rzutu kostką do gry.

Dla tych klas zdefiniowano ich cechy charakterystyczne. Są nimi:

  1. _jest_liczba – cecha mówiąca, czy danych obiekt reprezentuje liczbę,
  2. _jest_liczba_calkowita – cecha mówiąca, czy liczba którą reprezentuje danych obiekt, jest liczbą całkowitą,
  3. _nalezy_do_przedzialu – cecha mówiąca, czy liczba którą reprezentuje danych obiekt, należy do przedziału,
  4. _dolna_granica_przedzialu – wartość dolnej granicy przedziału, do którego mogą należeć liczby reprezentowane przez danych obiekt,
  5. _gorna_granica_przedzialu – wartość górnej granicy przedziału, do którego mogą należeć liczby reprezentowane przez danych obiekt,

Cechy charakterystyczne zostały zaimplementowane w programie. W tym celu najpierw zostały zaimplementowane dwie klasy: Bazowe_Cechy oraz Cechy: public Bazowe_Cechy tworzące pojęcie zbioru cech.

Następnie dla każdej z dwóch klas: temperatura_wody i kostka_do_gry zostały skonkretyzowane w odpowiedni sposób przypisane im klasy cech:

  1. Cechy<temperatura_wody>: public Bazowe_Cechy
  2. Cechy<kostka_do_gry>: public Bazowe_Cechy

Działanie programu polega na gromadzeniu danych liczbowych różnych typów w kontenerach, przy czym kontenery do walidacji wprowadzanych danych używają cech charakterystycznych. W tym celu zdefiniowana została klasa reprezentująca kontener SzablonStosu przystosowany do przechowywania dowolnych wartości, w tym obiektów typu temperatura_wody i kostka_do_gry. Metoda push tego kontenera przed umieszczeniem danej dokonuje jej walidacji posługując się informacjami z klasy Bazowe_Cechy.

Wykorzystanie kontenera zostało zademonstrowane w funkcji main. W kodzie main tworzone są trzy kontenery K1, K2 i K3, a następnie są wypełniane wartościami. Uwaga: kontener K1 jest zapełniany wartościami tak długo, póki wystarczy zasobów komputera (w trakcie wykonania programu warto uruchomić menedżer zadań i w sekcji wydajności obserwować, jak ubywa wolnej pamięci w miarę pracy programu).

Zadania do zrobienia przed ćwiczeniami

  1. Przenieś kod do środowiska VS C++, skompiluj i uruchom.
  2. Przeanalizuj kod, upewnij się, że rozumiesz rolę wszystkich pól i metod w klasach i potrafisz to wyjaśnić na zajęciach.
  3. Upewnij się, że potrafisz wyjaśnić, dlaczego tyle właśnie elementów zostaje umieszczonych w każdym z trzech kontenerów (a nie więcej).
  4. dodaj do kodu jeszcze jedną klasę reprezentującą pojęcie liczbowe „numer kołnierzyka koszuli” i skonkretyzuj w odpowiedni sposób odpowiadającą jej klasę cech. Następnie, jeżeli to konieczne, rozszerz kod metody push tak aby poprawnie walidował obiekty nowego typu. W funkcji main dodaj kontener K4 w którym zgromadzisz kilka obiektów nowego typu.
  5. Przygotuj się do rozwijania tego kodu dla potrzeb nowych rodzajów wartości, jakie można przechowywać w tym kontenerze.

Pliki do pobrania

Plik programu: ZPO-traits.cpp
Plik z danymi wejściowymi: qv-lab4 (po założeniu nowego projektu VC++ należy go umieścić w tym samym folderze, co plik z kodem programu).

 
/* ==========================
   (c) WMP.SNS UKSW, 2015
========================== */

#include<iostream>
#include<fstream>
#include<string>
#include<limits>
#include<exception>

using namespace std;

class _Bazowe_Cechy {
public:
	// pola statyczne stałe - dla stałych wartości całkowitych
	static const bool _jest_liczba = false;
	static const bool _nalezy_do_przedzialu = false;
	static const bool _jest_liczba_calkowita = false;
};

template<typename T>
class _Cechy : public _Bazowe_Cechy {
public:
	// metody statyczne - dla wartości innych typów niż liczby całkowite
	static const T _dolna_granica() { return T(); };
	static const T _gorna_granica() { return T(); };
};

template<typename T>
class Cechy : public _Cechy<T> {
};

class przyspieszenie {
	double a;
public:
	przyspieszenie(double acc = 0) : a(acc) {};
	double operator()() const { return a; };
	przyspieszenie& operator=(double acc) { a = acc; return *this; };
	bool operator<(const przyspieszenie& p) const { return (a < p.a); };
	friend ostream& operator<<(ostream& os, const przyspieszenie&);
};
ostream& operator<<(ostream& os, const przyspieszenie& p) { return os << p.a; };

template<>
class Cechy<przyspieszenie> : public _Cechy<przyspieszenie> {
public:
	static const bool _jest_liczba = true;
};

class temperatura_wody {
	double t;
public:
	temperatura_wody(double temp = 50) : t(temp) {};
	double operator()() const { return t; };
	temperatura_wody& operator=(double temp) { t = temp; return *this; };
	bool operator<(const temperatura_wody& tw) const { return (t < tw.t); };
	friend ostream& operator<<(ostream& os, const temperatura_wody&);
};
ostream& operator<<(ostream& os, const temperatura_wody& tw) { return os << tw.t; };

template<>
class Cechy<temperatura_wody> : public _Cechy<temperatura_wody> {
public:
	static const bool _jest_liczba = true;
	static const bool _nalezy_do_przedzialu = true;
	static const temperatura_wody _dolna_granica() { return temperatura_wody(0); };
	static const temperatura_wody _gorna_granica() { return temperatura_wody(100); };
};

class kostka_do_gry {
	int n;
public:
	kostka_do_gry(int num = 1) : n(num) {};
	int operator()() const { return n; };
	kostka_do_gry& operator=(int num) { n = num; return *this; };
	bool operator<(const kostka_do_gry& k) const { return (n < k.n); };
	friend ostream& operator<<(ostream& os, const kostka_do_gry&);
};
ostream& operator<<(ostream& os, const kostka_do_gry& k) { return os << k.n; };

template<>
class Cechy<kostka_do_gry> : public _Cechy<kostka_do_gry> {
public:
	static const bool _jest_liczba = true;
	static const bool _nalezy_do_przedzialu = true;
	static const bool _jest_liczba_calkowita = true;
	static const kostka_do_gry _dolna_granica() { return kostka_do_gry(1); };
	static const kostka_do_gry _gorna_granica() { return kostka_do_gry(6); };
};

class Przepelnienie : public exception {
	char opis[100];
public:
	Przepelnienie(const char* o) { strcpy_s(opis, o); }
	const char* what() const throw() { return opis; };
};
class BrakDanych : public exception {
	char opis[100];
public:
	BrakDanych(const char* o) { strcpy_s(opis, o); }
	const char* what() const throw() { return opis; };
};

template<typename T, int rozmiar, typename CechyT = Cechy<T>>
class SzablonStosu{
	T stos[rozmiar];
	int top;
public:
	int zajetosc() { return top; };
	SzablonStosu() : top(0) {}
	void push(const T& i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());
		stos[top++] = i;
	}
	void push(int i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());

		// walidacja wartości przekazanej do zapisu
		if (CechyT::_jest_liczba && CechyT::_jest_liczba_calkowita) {
			if (CechyT::_nalezy_do_przedzialu) {
				if (!(T(i) < CechyT::_dolna_granica()) && !(CechyT::_gorna_granica() < T(i)))
					stos[top++] = i;
			}
			else
				stos[top++] = i;
		}
	}
	void push(double i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());

		// walidacja wartości przekazanej do zapisu
		if (CechyT::_jest_liczba && !CechyT::_jest_liczba_calkowita) {
			if (CechyT::_nalezy_do_przedzialu) {
				if (!(T(i) < CechyT::_dolna_granica()) && !(CechyT::_gorna_granica() < T(i)))
					stos[top++] = i;
			}
			else
				stos[top++] = i;
		}
	}
	T pop() {
		if (top == 0)
			throw BrakDanych(typeid(stos[0]).name());

		return stos[--top];
	}
	template<typename U1, int r, typename U2>
	friend ostream& operator<<(ostream& os, const SzablonStosu<U1, r, U2>&);
};
template<typename U1, int r, typename U2>
ostream& operator<<(ostream& os, const SzablonStosu<U1, r, U2>& S)
{
	for (int i = 0; i < S.top; i++) cout << S.stos[i] << endl;
	return os;
};

int main() {
	SzablonStosu<string, 5> K1;
	SzablonStosu<przyspieszenie, 10> K2;
	SzablonStosu<temperatura_wody, 10> K3;
	SzablonStosu<kostka_do_gry, 10> K4;

	// zapełnianie stosów K1, K2, K3 i K4:
	ifstream fi("qv-lab4.txt");
	string s;
	try{
		K1.push("Henryk");
		K1.push("Sienkiewicz");
		while (fi) {
			fi >> s;
			K1.push(s);
			fi.seekg(ios::beg);
			fi.clear();
			cout << '*';
		};
	}
	catch (Przepelnienie& e){
		cout << "K1 gotowy: " << e.what() << endl;
	};
	cout << "Danych na stosie K1: " << K1.zajetosc() << endl << endl;

	K2.push(przyspieszenie());
	K2.push(przyspieszenie(5.0));
	K2.push(10);	// uwaga: nie akceptujemy przyspieszenia jako liczby całkowitej
	K2.push(10.0);
	cout << K2;
	cout << "Danych na stosie K2: " << K2.zajetosc() << endl << endl;

	K3.push(temperatura_wody());
	K3.push(temperatura_wody(36.6));
	K3.push(71.2);
	K3.push(112.1); // uwaga: nie akceptujemy wartości spoza przedziału
	cout << K3;
	cout << "Danych na stosie K3: " << K3.zajetosc() << endl << endl;

	K4.push(kostka_do_gry(3));
	K4.push(kostka_do_gry());
	K4.push(6);
	K4.push(10); // uwaga: nie akceptujemy wartości spoza przedziału
	cout << K4;
	cout << "Danych na stosie K4: " << K4.zajetosc() << endl << endl;

	// opróżnianie stosów
	try{
		while (true)
			K1.pop();
	}
	catch (BrakDanych& e) {
		cout << "K1 pusty: " << e.what() << endl;
	}
	try{
		while (true)
			K2.pop();
	}
	catch (BrakDanych& e) {
		cout << "K2 pusty: " << e.what() << endl;
	}
	try{
		while (true)
			K3.pop();
	}
	catch (BrakDanych& e) {
		cout << "K3 pusty: " << e.what() << endl;
	}
	try {
		while (true)
			K4.pop();
	}
	catch (BrakDanych& e) {
		cout << "K4 pusty: " << e.what() << endl;
	}

	system("pause");
	return 0;
}

ZTP2022: Zadania przed lab.3

Zadanie, które dotyczy zakresu materiału, jaki będzie poruszany na lab. 3. Rozwiązanie nie jest wymagane. Zadanie stanowi wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie:

Zaprojektuj szablon kontenera typu stos posiadający zagnieżdżoną klasę reprezentującą iteratory stosu. Następnie utwórz w funkcji main obiekt reprezentujący stos do przechowywania zmiennych typu double i umieść w nim za pomocą metody push dowolną liczbę (nie większą od 100) wartości losowych rzeczywistych z przedziału 〈0, 10).

Napisz szablony trzech funkcji, które jako argument wejściowy przyjmują parę iteratorów stosu identyfikujących przedział danych z kontenera (tak jak na slajdzie 150, wykład 3), i które dla liczb w tym przedziale znajdują lub obliczają i zwracają:

  1. wartość minimalną/maksymalną,
  2. medianę,
  3. wartość średnią.

Przyjmij, że typ danych przechowywanych w kontenerze zawsze pozwala na wszystkie standardowe operacje arytmetyczne i logiczne (posiada odpowiednie operatory). Uwaga: funkcje nie otrzymują w argumentach wywołania referencji ani wskaźnika do obiektu kontenera, a jedynie iteratory wskazujące na poprawny przedział danych w nim zawartych.
Zademonstruj poprawne działanie tych szablonów funkcji wywołując je w funkcji main dla przykładowych danych zapisanych w kontenerze. Na początku na potrzeby testów poprawności spreparuj dane testowe w kontenerze tak, aby łatwo było w pamięci policzyć wynik i potwierdzić poprawność działania szablonów funkcji.


Hint: aby wygenerować wartość losową z przedziału 〈0, 1) można np. użyć funkcji:
//generates a psuedo-random double between 0.0 and 0.999...
double randdouble() {
return rand()/(double(RAND_MAX)+1);
}

ZTP2022: Zadanie przed lab.2

Zadania, które dotyczą zakresu materiału, jaki będzie poruszany na lab. 2. Rozwiązanie tych zadań nie jest wymagane. Stanowią wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie #1:

W kolejnych wierszach pewnego pliku znajdują się wyrażenia arytmetyczne zapisane w odwrotnej notacji polskiej (ale bez wykorzystania nawiasów). Napisz program, który będzie odczytywał wiersz i obliczał wartość, a jeżeli w wyrażeniu jest błąd składni, to rzucał wyjątek. Wyjątek zostaje przechwycony na końcu programu i obsłużony w postaci wyświetlenia komunikatu o rodzaju błędu. Dostosuj wartość wyjątku do rodzaju błędu.

Zadanie #2:

Napisz grę, która będzie losowała dowolne litery z alfabetu i wyświetlała je na ekranie, a zadaniem gracza jest podać szybko kod ascii odpowiadający danej literze. Fragment programu odpowiedzialny za zadawanie pytań i sprawdzanie odpowiedzi użytkownika jest zamknięty w funkcji, która zwraca liczbę całkowitą – sumaryczną liczbę sekund, jakiej użytkownik potrzebował, żeby udzielać odpowiedzi na serię pytań. Może zdarzyć się, że użytkownik poda niewłaściwy kod ascii, ale to nie powoduje przerwania gry. Dopiero w przypadku popełnienia przez użytkownika drugiej pomyłki zamiast kolejnego pytania rzucany jest wyjątek, który jest przechwycony dopiero w funkcji main. W ramach obsługi wyjątku użytkownik dostaje pytanie, czy chce spróbować jeszcze raz i jeżeli tak – funkcja zadająca pytania jest ponownie wywoływana.

Zadanie #3:

Język „Markdown” jest jednym z najprostszych języków znaczników, mimo to jednak znajduje wiele zastosowań, m.in. w plikach readme. W tym języku można formatować tekst, który później zostanie odpowiednio zwizualizowany w oknie przeglądarki.

W języku „Markdown” wskazywanie czcionek, które mają być użyte w poszczególnych fragmentach dokumentu, odbywa się wg następującej składni: najpierw znak otwierający formatowanie, np. _, *, __, ** lub `, potem tekst podlegający formatowaniu, a na koniec ten sam znak, ale tym razem oznaczający koniec formatowanego fragmentu tekstu. Przykłady: _italic_, *italic*, __bold__, **bold**, `monospace`.

Napisz parser, który będzie sprawdzał poprawność formatowania czcionek w tekście zawartym w pliku. Przyjmij, że poprawne formatowanie wymaga, aby liczba znaków otwierających i zamykających była sobie równa, oraz aby formatowane obszary nie przecinały się ani nie zagnieżdżały. W przypadku wykrycia błędu składni rzucany jest wyjątek, który zostanie przechwycony na końcu programu i obsłużony w postaci wyświetlenia komunikatu o błędzie. Dostosuj wartość wyjątku do rodzaju błędu.

ZTP2022: Wskazówki przed lab. 1

Zasady ogólne

Zasady wykonywania i oceniania programów na stacjonarnych zajęciach lab.:

  • Każdy uczestnik wykonuje na komputerze w pracowni dwa zadania w środowisku MS Visual Studio: podstawowe (pierwszego poziomu) za 6 pkt. i dodatkowe (drugiego poziomu) za 4 pkt.
  • Zadań nie wolno realizować na własnym laptopie.
  • Dopiero kiedy prowadzący odbierze i pozytywnie oceni zadanie podstawowe, można zacząć rozwiązywać zadanie dodatkowe (dodatkowe bywa łatwiejsze).
  • Studenci mogą realizować swoje zadania tylko na zajęciach – nie ma możliwości kończenia programu poza pracownią i przesyłania go do oceny w godzinach wieczornych czy następnego dnia.
  • Studenci obowiązkowo uploadują do moodle rozwiązane zadania I i II poziomu w trakcie zajęć. Rozwiązania uploadowane po zajęciach nie będą oceniane.

Pełny opis zasad został zamieszczony w moodle.

Rozwiązania będą weryfikowane za pomocą oprogramowania antyplagiatowego MOSS (tak samo jak w ubiegłym semestrze), dlatego oceny wystawione na zajęciach mogą jeszcze być korygowane na podstawie wyników raportu MOSS (zbytnie podobieństwo kodu powoduje obniżenie oceny u wszystkich wskazanych w raporcie, tj. bez ustalania, kto był rzeczywistym autorem, a kto popełnił plagiat).

Porady przed lab. 1

Ponieważ plan ułożony jest tak, że pierwsze zajęcia laboratoryjne odbywają się tuż po pierwszym wykładzie w semestrze, zadania realizowane na tych zajęciach będą dotyczyły materiału z ostatnich wykładów Programowania Obiektowego z poprzedniego semestru. Dlatego proszę Państwa o przejrzenie materiału z poprzedniego semestru, a zwłaszcza przypomnienie sobie i dopracowanie rozwiązań zadania z lab. 14, ponieważ może pojawić się zadanie, w którym trzeba będzie rozbudować kod tego rozwiązania.

PO2022: Wyniki egzaminu, termin 2, z dn. 21.09

Wiersze zawierają: cztery ostatnie cyfry z nr indeksu, liczbę punktów za część teoretyczną, liczbę punktów za część praktyczną, całkowitą liczbę zdobytych punktów i ocenę.

  1. **0759   11.5   0   11.5   2
  2. **0807   6   0   6   2
  3. **0809   0   0   0   2 *
  4. **0851   15.5   0   15.5   2
  5. **0855   13   16   29   4
  6. **0856   0   0   0   2
  7. **6360   14   0   14   2
  8. **7384   13.5   1   14.5   2
  9. **7490   19   2   21   3
  10. **7621   7.5   3   10.5   2
  11. **7690   14   11   25   3.5
  12. **8980   10   3   13   2
  13. **9050   2.5   1   3.5   2
  14. **9065   13   0   13   2
  15. **9170   17.5   16   33.5   4.5
  16. **9172   8.5   6   14.5   2
  17. **9179   7.5   0   7.5   2
  18. **9226   15   16   31   4
  19. **9229   0   0   0   2 *
  20. **9232   21   1   22   3
  21. **9242   10   2   12   2
  22. **9244   20.5   3   23.5   3
  23. **9246   13.5   2   15.5   2
  24. **9261   8.5   1   9.5   2
  25. **9263   14.5   0   14.5   2
  26. **9268   4   0   4   2
  27. **9271   11   0   11   2
  28. **9273   10.5   0   10.5   2
  29. **9274   16   12   28   4
  30. **9306   23.5   2   25.5   3.5

* – ocena negatywna z powodu naruszenia reguł zachowania się podczas egzaminu.

30 września (piątek) w godz. od 12:30 do 13:30 w pok. 1247 bud. 12 możliwe będzie obejrzenie prac egzaminacyjnych z egzaminu PO.