├── .gitignore
└── 2024-2025
    ├── README.md
    ├── Week 01
        └── Readme.md
    ├── Week 02
        ├── Solutions
        │   └── SolutionsWeek2.cpp
        └── readme.md
    ├── Week 03
        ├── Solutions
        │   ├── Task1.cpp
        │   ├── Task2.cpp
        │   ├── Task3.cpp
        │   └── Task4.cpp
        └── readme.md
    ├── Week 04
        ├── Solutions
        │   └── Time
        │   │   ├── Time.cpp
        │   │   └── Time.h
        └── readme.md
    └── Week 05
        └── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea


--------------------------------------------------------------------------------
/2024-2025/README.md:
--------------------------------------------------------------------------------
1 | TBD


--------------------------------------------------------------------------------
/2024-2025/Week 01/Readme.md:
--------------------------------------------------------------------------------
  1 | # ООП - практикум група 1 20.02.2025
  2 | # УП - преговор 
  3 |  
  4 | * **МАСИВИ И СТРИНГОВЕ**
  5 | 
  6 | **Пример 1: Какво ще се отпечата на конзолата?**
  7 | ```c++
  8 | int main() {
  9 |     std::cout << "Hello world!" + 2;
 10 | }
 11 | ```
 12 | 
 13 | **Пример 2:Какво ще се отпечата на конзолата?**
 14 | ```c++
 15 | #include <iostream>
 16 | 
 17 | int main() {
 18 |     int arr[3] = {1, 2, 3};
 19 |     std::cout << arr[5] << std::endl;
 20 |     return 0;
 21 | }
 22 | ```
 23 | 
 24 | **Пример 3: Ще се компилира ли?**
 25 | ```c++
 26 | #include <iostream>
 27 | 
 28 | int main() {
 29 |     int arr[5];
 30 |     std::cout << arr[0] << std::endl;
 31 |     return 0;
 32 | }
 33 | ```
 34 | 
 35 | **Пример 4: Ще се компилира ли?**
 36 | 
 37 | ```c++
 38 | #include <iostream>
 39 | 
 40 | int main() {
 41 |     int arr1[3] = {1, 2, 3};
 42 |     int arr2[3];
 43 |     
 44 |     arr2 = arr1;
 45 | 
 46 |     return 0;
 47 | }
 48 | ```
 49 | 
 50 | **Пример 5: Ще се компилира ли?**
 51 | ```c++
 52 | #include <iostream>
 53 | 
 54 | int main() {
 55 |     char* str = "Hello";
 56 |     str[0] = 'h';
 57 |     std::cout << str << std::endl;
 58 |     return 0;
 59 | }
 60 | ```
 61 | 
 62 | **Пример 6: Какво ще се изведе на конзолата?**
 63 | ```c++
 64 | #include <iostream>
 65 | #include <cstring>
 66 | 
 67 | int main() {
 68 |     char* str;
 69 |     strcpy(str, "Hello");
 70 |     std::cout << str << std::endl;
 71 |     return 0;
 72 | }
 73 | ```
 74 | 
 75 | 
 76 | * **УКАЗАТЕЛИ И РЕФЕРЕНЦИИ**
 77 |  
 78 | **Пример 1: Какво ще се изведе на конзолата?**
 79 | ```c++
 80 | #include <iostream>
 81 |  
 82 | void modify(int* ptr) {
 83 |     *ptr = 20;
 84 | }
 85 |  
 86 | int main() {
 87 |     int x = 10;
 88 |     int* p = &x;
 89 |     modify(p);
 90 |     std::cout << x << std::endl;
 91 |     return 0;
 92 | }
 93 | ```
 94 |  
 95 | **Пример 2: Ще се компилира ли кодът? Ако не, защо?**
 96 |  
 97 | ```c++
 98 | #include <iostream>
 99 |  
100 | int main() {
101 |     int x = 5;
102 |     int& ref;
103 |     ref = x;
104 |  
105 |     std::cout << ref << std::endl;
106 |     return 0;
107 | }
108 | ```
109 | **Пример 3: Какво ще се изведе на конзолата?**
110 |  
111 | ```c++
112 | #include <iostream>
113 |  
114 | void func(int ref) {
115 |     ref += 5;
116 | }
117 |  
118 | int main() {
119 |     int a = 10;
120 |     func(a);
121 |     std::cout << a << std::endl;
122 |     return 0;
123 | }
124 | ```
125 |  
126 | **Пример 4: Ще се компилира ли?**
127 |  
128 | ```c++
129 | #include <iostream>
130 |  
131 | int main() {
132 |     int x = 10;
133 |     int* ptr = &x;
134 |     int& ref = *ptr;
135 |  
136 |     ref = 20;
137 |  
138 |     std::cout << x << std::endl;
139 |     return 0;
140 | }
141 | ```
142 |  
143 | **Пример 5: Какво ще се изведе на конзолата?**
144 |  
145 | ```c++
146 | #include <iostream>
147 |  
148 | void func(int* ptr) {
149 |     ptr = nullptr;
150 | }
151 |  
152 | int main() {
153 |     int x = 42;
154 |     int* p = &x;
155 |  
156 |     func(p);
157 |  
158 |     if (p) {
159 |         std::cout << *p << std::endl;
160 |     } else {
161 |         std::cout << "Pointer is null" << std::endl;
162 |     }
163 |     return 0;
164 | }
165 | ```
166 |  
167 | * **ДИНАМИЧНА ПАМЕТ**
168 |  
169 | **Пример 1: Какво ще се изведе на козолата?**
170 |  
171 | ```c++
172 | #include <iostream>
173 |  
174 | int main() {
175 |     int* p = new int(10);
176 |     std::cout << *p << std::endl;
177 |     delete p;
178 |     return 0;
179 | }
180 | ```
181 |  
182 | **Пример 2: Ще се компилира ли?**
183 |  
184 | ```c++
185 | #include <iostream>
186 |  
187 | int main() {
188 |     int* p = new int[5];
189 |     delete p;
190 |     return 0;
191 | }
192 | ```
193 |  
194 | **Пример 3: Какво ще се изведе на козолата?**
195 |  
196 | ```c++
197 | #include <iostream>
198 |  
199 | int main() {
200 |     int* p = new int(100);
201 |     delete p;
202 |     std::cout << *p << std::endl;
203 |     return 0;
204 | }
205 | ```
206 |  
207 | **Пример 4: Ще се компилира ли?**
208 |  
209 | ```c++
210 | #include <iostream>
211 |  
212 | void allocate(int*& ptr) {
213 |     ptr = new int(50);
214 | }
215 |  
216 | int main() {
217 |     int* p = nullptr;
218 |     allocate(p);
219 |     std::cout << *p << std::endl;
220 |     delete p;
221 |     return 0;
222 | }
223 | ```
224 |  
225 | **Пример 5: Ще се компилира ли?**
226 |  
227 | ```c++
228 | #include <iostream>
229 |  
230 | int* func() {
231 |     int x = 10;
232 |     return &x;
233 | }
234 |  
235 | int main() {
236 |     int* p = func();
237 |     std::cout << *p << std::endl;
238 |     return 0;
239 | }
240 | ```
241 |  
242 | **Пример 6: Какво ще се изведе на козолата?**
243 |  
244 | ```c++
245 | #include <iostream>
246 |  
247 | int main() {
248 |     int* p1 = new int(10);
249 |     int* p2 = p1;
250 |  
251 |     delete p1;
252 |     std::cout << *p2 << std::endl;
253 |     return 0;
254 | }
255 | ```
256 | 
257 | **Задача 1**
258 | 
259 | Напишете Selection Sort
260 | 
261 | Можете да видите как рабити алгиритъмът, в случай, че сте забравили, тук:
262 | https://sortvisualizer.com/selectionsort/
263 | 
264 | **Задача 2**
265 | 
266 | Напишете Merge sort
267 | 
268 | Можете да видите как рабити алгиритъмът, в случай, че сте забравили, тук:
269 | https://sortvisualizer.com/mergesort/
270 | 
271 | **Задача 3**
272 | 
273 | Да се напише рекурсивна функция, която приема "лабиринт" (булева матрици от 1ци и 0ли), за която 1цата означава стена, а 0лата път и две цели числа, които да отговарят на координати в лабиринта. Нека функцията върне дали има път от горният ляв ъгъл на матрицата до подадените координатите.
274 | 
275 | **Задача 4**
276 | 
277 | Напишете функция, която приема стринг и връща лексикографски най-малката дума.
278 | 
279 | Вход: 
280 | "Me? Why always me?
281 | 
282 | Изход: always


--------------------------------------------------------------------------------
/2024-2025/Week 02/Solutions/SolutionsWeek2.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstdint>
  3 | 
  4 | const constexpr int NAME_LEN = 17;
  5 | const constexpr int MAX_LEN = 1024;
  6 | const constexpr int MAX_STUDENTS = 1024;
  7 | const constexpr int MAX_TITLE = 50;
  8 | 
  9 | unsigned myStrlen(const char* str)
 10 | {
 11 | 	if (!str)
 12 | 		return 0;
 13 | 
 14 | 	unsigned result = 0;
 15 | 	while (*str)
 16 | 	{
 17 | 		result++;
 18 | 		str++;
 19 | 	}
 20 | 	return result;
 21 | }
 22 | void myStrcpy(const char* source, char* dest)
 23 | {
 24 | 	if (!source || !dest)
 25 | 		return;
 26 | 	while (*source)
 27 | 	{
 28 | 		*dest = *source;
 29 | 		dest++;
 30 | 		source++;
 31 | 	}
 32 | 	*dest = '\0';
 33 | }
 34 | int myStrcmp(const char* first, const char* second)
 35 | {
 36 | 	if (!first || !second)
 37 | 		return INT16_MIN;
 38 | 
 39 | 	while ((*first) && (*second) && ((*first) == (*second)))
 40 | 	{
 41 | 		first++;
 42 | 		second++;
 43 | 	}
 44 | 
 45 | 	return (*first - *second);
 46 | 
 47 | }
 48 | 
 49 | enum class Specialty
 50 | {
 51 | 	Informatics = 0,
 52 | 	InformaticSystems,
 53 | 	ComputerScience,
 54 | 	SoftwareEngineering,
 55 | 	DataAnalisys,
 56 | 	Mathematics,
 57 | 	Statistics,
 58 | 	Error
 59 | };
 60 | 
 61 | struct Student
 62 | {
 63 | 	char name[NAME_LEN];
 64 | 	char lastName[NAME_LEN];
 65 | 	unsigned fn;
 66 | 	double averageGrades;
 67 | 	Specialty spec;
 68 | };
 69 | 
 70 | void printSpecialty(const Specialty& spec)
 71 | {
 72 | 	switch (spec)
 73 | 	{
 74 | 	case Specialty::Informatics: std::cout << "Informatics"; break;
 75 | 	case Specialty::InformaticSystems: std::cout << "Informatic Systems"; break;
 76 | 	case Specialty::ComputerScience: std::cout << "Computer Science"; break;
 77 | 	case Specialty::SoftwareEngineering: std::cout << "Software Engineering"; break;
 78 | 	case Specialty::DataAnalisys: std::cout << "Data Analisys"; break;
 79 | 	case Specialty::Mathematics: std::cout << "Mathematics"; break;
 80 | 	case Specialty::Statistics: std::cout << "Statistics"; break;
 81 | 	case Specialty::Error: std::cout << "Error"; break;
 82 | 	}
 83 | }
 84 | Specialty getSpecialtyFromConsole()
 85 | {
 86 | 	char specialty[MAX_LEN];
 87 | 	std::cin.clear();
 88 | 	std::cin.getline(specialty, MAX_LEN);
 89 | 
 90 | 	if (myStrcmp(specialty, "Informatics"))
 91 | 		return Specialty::Informatics;
 92 | 	else if (myStrcmp(specialty, "Informatic Systems"))
 93 | 		return Specialty::InformaticSystems;
 94 | 	else if (myStrcmp(specialty, "Computer Science"))
 95 | 		return Specialty::ComputerScience;
 96 | 	else if (myStrcmp(specialty, "Software Engineering"))
 97 | 		return Specialty::SoftwareEngineering;
 98 | 	else if (myStrcmp(specialty, "Data Analisys"))
 99 | 		return Specialty::Mathematics;
100 | 	else if (myStrcmp(specialty, "Mathematics"))
101 | 		return Specialty::Mathematics;
102 | 	else if (myStrcmp(specialty, "Statistics"))
103 | 		return Specialty::Statistics;
104 | 	else
105 | 		return Specialty::Error;
106 | 
107 | }
108 | void printStudent(const Student& st)
109 | {
110 | 	std::cout << "Name: " << st.name << "\nLast Name: " << st.lastName << "\nFaculty Number: " << st.fn << "\nAverage Grades: " <<
111 | 		st.averageGrades << "\nSpeciality: ";
112 | 	printSpecialty(st.spec);
113 | 	std::cout << std::endl;
114 | 
115 | }
116 | 
117 | Student initStudent(const char* name, const char* lastName, unsigned fn, double avGrade, Specialty spec)
118 | {
119 | 	Student toReturn;
120 | 	if (name)
121 | 		myStrcpy(name, toReturn.name);
122 | 
123 | 	if (lastName)
124 | 		myStrcpy(lastName, toReturn.lastName);
125 | 
126 | 	if (fn >= 10000 && fn <= 99999)
127 | 		toReturn.fn = fn;
128 | 	else
129 | 		toReturn.fn = 0;
130 | 
131 | 	if (avGrade >= 2 && avGrade <= 6)
132 | 		toReturn.averageGrades = avGrade;
133 | 
134 | 	toReturn.spec = spec;
135 | 	return toReturn;
136 | }
137 | 
138 | Student initStudentFromConsole()
139 | {
140 | 	char name[NAME_LEN];
141 | 	char lastName[NAME_LEN];
142 | 	unsigned fn;
143 | 	double averagGrades;
144 | 	Specialty spec;
145 | 
146 | 	std::cin.clear();
147 | 	std::cin.getline(name, NAME_LEN);
148 | 	std::cin.getline(lastName, NAME_LEN);
149 | 	std::cin >> fn;
150 | 	std::cin >> averagGrades;
151 | 
152 | 	spec = getSpecialtyFromConsole();
153 | 	return initStudent(name, lastName, fn, averagGrades, spec);
154 | }
155 | 
156 | 
157 | struct StudentGroup {
158 | 	Student students[MAX_STUDENTS];
159 | 	int studentsCount;
160 | 	double averageGrade;
161 | };
162 | 
163 | StudentGroup initStudentGroupFromConsole() {
164 | 	int size;
165 | 	std::cin >> size;
166 | 	if (size > MAX_STUDENTS) {
167 | 		return StudentGroup{};
168 | 	}
169 | 
170 | 	StudentGroup group;
171 | 	group.studentsCount = size;
172 | 
173 | 	double totalGrade = 0;
174 | 	for (int i = 0; i < size; i++) {
175 | 		group.students[i] = initStudentFromConsole();
176 | 		totalGrade += group.students[i].averageGrades;
177 | 	}
178 | 
179 | 	group.averageGrade = totalGrade / size;
180 | 	return group;
181 | }
182 | 
183 | int getScholarshipCount(const StudentGroup& group, double minGrade) {
184 | 	int count = 0;
185 | 	for (int i = 0; i < group.studentsCount; i++) {
186 | 		if (group.students[i].averageGrades >= minGrade) {
187 | 			count++;
188 | 		}
189 | 	}
190 | 	return count;
191 | }
192 | 
193 | void swapStudents(Student& a, Student& b) {
194 | 	Student temp = a;
195 | 	a = b;
196 | 	b = temp;
197 | }
198 | 
199 | bool compareStudents(const Student& a, const Student& b) {
200 | 	if (a.averageGrades < b.averageGrades) {
201 | 		return true;
202 | 	}
203 | 	else if (a.averageGrades == b.averageGrades) {
204 | 		return a.fn > b.fn;
205 | 	}
206 | 	return false;
207 | }
208 | 
209 | void sortStudents(StudentGroup& group) {
210 | 	for (int i = 0; i < group.studentsCount; i++) {
211 | 		for (int j = i + 1; j < group.studentsCount; j++) {
212 | 			if (compareStudents(group.students[i], group.students[j])) {
213 | 				swapStudents(group.students[i], group.students[j]);
214 | 			}
215 | 		}
216 | 	}
217 | }
218 | 
219 | enum class Genre {
220 | 	Novel = 0,
221 | 	Historic,
222 | 	Poetry,
223 | 	Other
224 | };
225 | 
226 | struct Book {
227 | 	char title[MAX_TITLE];
228 | 	char author[MAX_TITLE];
229 | 	Genre genre;
230 | 	int stock;
231 | };
232 | 
233 | Book initBook(const char* title, const char* author, Genre genre, int stock) {
234 | 	Book book;
235 | 	
236 | 	if(title)
237 | 		myStrcpy(title, book.title);
238 | 	
239 | 	if(author)
240 | 		myStrcpy(author, book.author);
241 | 	
242 | 	book.genre = genre;
243 | 
244 | 	if(stock > 0)
245 | 	book.stock = stock;
246 | 
247 | 	return book;
248 | }
249 | 
250 | struct Library {
251 | 	Book books[MAX_LEN];
252 | 	int capacity = MAX_LEN;
253 | 	int size;
254 | };
255 | 
256 | void addBookToLibrary(Library& library, const Book& book) {
257 | 	if (library.size < library.capacity) {
258 | 		std::cout << "Library is full!";
259 | 		return;
260 | 	}
261 | 
262 | 	library.books[library.size++] = book;
263 | }
264 | 
265 | int searchInLibraryABookIndexByTitle(const Library& library, const char* title) {
266 | 	if (!title)
267 | 		return -1;
268 | 
269 | 	for (int i = 0; i < library.size; ++i) {
270 | 		if (!myStrcmp(title, library.books[i].title))
271 | 			return i;
272 | 	}
273 | 
274 | 	return -1;
275 | }
276 | 
277 | Book removeBookFromLibraryByTitle(Library& library, const char* title) {
278 | 	if (!title)
279 | 		return Book{};
280 | 
281 | 	int index = searchInLibraryABookIndexByTitle(library, title);
282 | 	
283 | 	if (index == -1)
284 | 		return Book{};
285 | 
286 | 	Book toReturn = library.books[index];
287 | 
288 | 	if (library.books[index].stock == 1) {
289 | 		for (int i = index; i < library.size; ++i) {
290 | 			library.books[i] = library.books[i + 1];
291 | 		}
292 | 		library.size--;
293 | 	}
294 | 	else
295 | 		library.books[index].stock--;
296 | 
297 | 	return toReturn;
298 | }
299 | 
300 | void returnABookByTitle(Library& library, const char* title) {
301 | 	if (!title)
302 | 		return;
303 | 
304 | 	int index = searchInLibraryABookIndexByTitle(library, title);
305 | 
306 | 	if (index == -1)
307 | 		return;
308 | 	else
309 | 	library.books[index].stock++;
310 | }
311 | 


--------------------------------------------------------------------------------
/2024-2025/Week 02/readme.md:
--------------------------------------------------------------------------------
  1 | # OOП - Практикум 27.02.2025 - Седмица 2
  2 | 
  3 | ## 1. Code snippets
  4 | 
  5 | Пресметнете и проверете чрез оператора `sizeof` колко е големината на следните структури, както и тяхното подравняване чрез оператора `alignof`:
  6 | 
  7 | ```c++
  8 | struct empty 
  9 | {
 10 | 
 11 | };
 12 | 
 13 | struct test1
 14 | {
 15 | 	int number;
 16 | };
 17 | 
 18 | struct test2
 19 | {
 20 | 	char symbol;
 21 | 	int number;
 22 | };
 23 | 
 24 | struct test3
 25 | {
 26 | 	char symbol;
 27 | 	short sh;
 28 | 	int number;
 29 | };
 30 | 
 31 | struct test4
 32 | {
 33 | 	char symbol1;
 34 | 	int number;
 35 | 	char symbol2;
 36 | };
 37 | 
 38 | struct student
 39 | {
 40 | 	char* name;
 41 | 	int* grades;
 42 | };
 43 | 
 44 | struct test5
 45 | {
 46 | 	char a[5];
 47 | 	int b;
 48 | 	double c;
 49 | };
 50 | 
 51 | struct test6
 52 | {
 53 | 	char a[3];
 54 | 	short b;
 55 | 	double c[4];
 56 | 	char d;
 57 | };
 58 | 
 59 | struct test7
 60 | {
 61 |     int number;
 62 |     char symbol;
 63 |     char chArr[];
 64 | };
 65 | ```
 66 | 
 67 | ```C++
 68 | struct A
 69 | {
 70 | 	double c;
 71 | 	char b; 
 72 | };
 73 | 
 74 | struct B
 75 | {
 76 | 	char c;
 77 | };
 78 | 
 79 | struct C
 80 | {
 81 | 	A obj;
 82 | 	B obj2;
 83 | };
 84 | ```
 85 | 
 86 | ```C++
 87 | struct A
 88 | {
 89 | 	double c;
 90 | 	char b;
 91 | 	int k;
 92 | 	char s;
 93 | };
 94 | 
 95 | struct B
 96 | {
 97 | 	int a;
 98 | 	char c;
 99 | 	char d;
100 | 	float f;
101 | };
102 | 
103 | struct C
104 | {
105 | 	char arr[3];
106 | 	float f;
107 | };
108 | 
109 | struct D
110 | {
111 | 	C obj1;
112 | 	A obj2;
113 | 	int i;
114 | 	char c;
115 | 	B obj3;
116 | 	bool b;
117 | 	double d;
118 | }; 
119 | ```
120 | 
121 | ## 2. Задачи за практикум
122 | 
123 | **Задача 1:** Да се създаде структура Complex, която представя комплексно число. Можете да приемете за улесниение, че параметрите на комплексното число са цели числа.
124 | 
125 | * Да се реализира функция print, която приема комплексно число и го принтира на стандартния изход във вида a + bi.
126 | * Да се реализира функция sum, която приема две комплексни числа и ги събира.
127 | * Да се реализира функция sub, която приема две комплексни числа и ги изважда.
128 | * Да се реализира функция mult, която приема две комплексни числа и ги умножава.
129 | 
130 | **Задача 2:** Да се създаде структура Rectangle, която представлява правоъгълник. Приемете, че правоъгълника се задава от две точки (долен ляв и горен десен ъгъл).
131 | * Да се реализира функция, която приема правоъгълник и връща периметъра му.
132 | * Да се реализира функция, която приема правоъгълник и връща лицето му.
133 | * Да се реализира фунцкия, която приема два правоъгълника и проверява дали първият се съдържа изцяло, отчасти или изобщо не се във втория правоъгълник.
134 | 
135 | **Задача 3:** Да се създаде структура студент. Всеки студент се определя чрез две имена с максимална дължина 16 символа всяко, петцифрен факултетен номер, среден успех и специалност, която следва (компютърни науки, информатика, софтуерно инженерство, информационни системи и т.н.) (Помислете с какъв тип да бъде зададен специалността). 
136 | 
137 | * Да се напише подходяща функция за принтиране на студента.
138 | * Да се напише initStudent(...), която приема като параметри имената, факултетния номер, средния успех и специалността на студента. Функцията трябва да върне студент с тези входни данни.
139 | * Да се напише функция, която създава студент четейки данни от конзолата. (Можете да си създадете помощни функции)
140 | 
141 | **Задача 4:** Да се създаде структура Book със следните характеристики: заглавие (до 50 символа), автор (до 50 символа), жанр и наличност.
142 | Жанровете са ограничени и могат да бъдат "Роман", "Исторически", "Поезия" и "Друг".
143 | Да се създаде структура Libary, която се описва с константен брой книги (вие изберете този брой).
144 | 
145 | Реализирайте функции за:
146 | * инициализиране на книга;
147 | * добавяне на нова книга в библиотеката (ако капацитетът е запълнен, да се изведе съобщение);
148 | * вземане на книга по подадено заглавие;
149 | * връщане на книга по подадено заглавие;
150 | * извеждане на информация за всички книги в библиотеката.
151 | 
152 | **Задача 5:** Една група се състои от краен брой студенти. Броят на студентите се задава от вас. Създайте структура, която описва група. Структурата също така трябва да пази средния успех на групата. 
153 | 
154 | * Да се напише функция, която създава група, вземайки информация от стандартния вход. Средния успех трябва да се сметне след въвеждане на информацията. 
155 | * Да се напише функция, която приема група и минимален успех за стипендия, и връща колко студента ще получават стипендия.  
156 | * Да се напише функция, която сортира групата по успех, ако два студента са с един и същ успех да се сортират по факултетен номер.  
157 | 
158 | ***Упътване:***  Приемете, че една група може да има най-много 1024 студента


--------------------------------------------------------------------------------
/2024-2025/Week 03/Solutions/Task1.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #pragma warning(disable: 4996)
 3 | 
 4 | const constexpr unsigned NAME_LEN = 50;
 5 | 
 6 | class Teacher {
 7 | 	unsigned age;
 8 | 	unsigned experience;
 9 | 	char name[NAME_LEN];
10 | 
11 | public:
12 | 	Teacher(){
13 | 		setAge(0);
14 | 		setExperience(0);
15 | 		setName("");
16 | 	}
17 | 	Teacher(unsigned age, unsigned experience, const char* name) {
18 | 		setAge(age);
19 | 		setExperience(experience);
20 | 		setName(name);
21 | 	}
22 | 	Teacher(const Teacher& other) {
23 | 		setAge(other.getAge());
24 | 		setExperience(other.getExperience());
25 | 		setName(other.getName());
26 | 	}
27 | 
28 | 
29 | 	void setAge(unsigned age) {
30 | 		if (age > 120)
31 | 			this->age = 0;
32 | 		else
33 | 			this->age = age;
34 | 	}
35 | 	void setExperience(unsigned experience) {
36 | 		if (experience < 60)
37 | 			this->experience = experience;
38 | 		else
39 | 			this->experience = 0;
40 | 	}
41 | 	void setName(const char* name) {
42 | 		if (!name || strlen(name) >= 50)
43 | 			strcpy(this->name, "");
44 | 		else
45 | 			strcpy(this->name, name);
46 | 	}
47 | 
48 | 	int getAge() const {
49 | 		return age;
50 | 	}
51 | 	int getExperience() const {
52 | 		return experience;
53 | 	}
54 | 	const char* getName() const {
55 | 		return name;
56 | 	}
57 | };
58 | 


--------------------------------------------------------------------------------
/2024-2025/Week 03/Solutions/Task2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #pragma warning(disable: 4996)
 3 | 
 4 | const constexpr unsigned NAME_LEN = 50;
 5 | const constexpr unsigned DESCRIPTION_LEN = 1000;
 6 | const constexpr unsigned TASKS_SIZE = 10;
 7 | 
 8 | class Task {
 9 | 	int points;
10 | 	char name[NAME_LEN];
11 | 	char description[DESCRIPTION_LEN];
12 | 
13 | public:
14 | 	Task() {
15 | 		setPoints(0);
16 | 		setName("");
17 | 		setDescription("");
18 | 	}
19 | 	Task(const char* name, const char* desription, int points) {
20 | 		setName(name);
21 | 		setDescription(desription);
22 | 		setPoints(points);
23 | 	}
24 | 
25 | 	int getPoints() const {
26 | 		return points;
27 | 	}
28 | 	const char* getName() const {
29 | 		return name;
30 | 	}
31 | 	const char* getDescription() const {
32 | 		return description;
33 | 	}
34 | 
35 | 	void setDescription(const char* description) {
36 | 		if (!description)
37 | 			return;
38 | 
39 | 		std::strcpy(this->description, description);
40 | 	}
41 | 	void setName(const char* name) {
42 | 		if (!name)
43 | 			return;
44 | 
45 | 		std::strcpy(this->name, name);
46 | 	}
47 | 	void setPoints(int points) {
48 | 		this->points = points;
49 | 	}
50 | };
51 | 
52 | class Exam {
53 | 	Task tasks[TASKS_SIZE];
54 | 	int size = 0;
55 | 	int minPoints;
56 | 
57 | public:
58 | 	void addTask(const Task& task) {
59 | 		if (size >= TASKS_SIZE)
60 | 			return;
61 | 
62 | 		tasks[size++] = task;
63 | 	}
64 | 	
65 | 	void changeMin(int minPoints) {
66 | 		this->minPoints = minPoints;
67 | 	}
68 | 	void getMax() {
69 | 		int max = 0;
70 | 		
71 | 		for (int i = 0; i < size; ++i)
72 | 			max += tasks[i].getPoints();
73 | 	}
74 | };


--------------------------------------------------------------------------------
/2024-2025/Week 03/Solutions/Task3.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #pragma warning(disable: 4996)
  3 | 
  4 | const constexpr unsigned TITLE_LEN = 64;
  5 | const constexpr unsigned GAMES_CAPACITY = 100;
  6 | 
  7 | 
  8 | class Game {
  9 | 	double price;
 10 | 	char title[TITLE_LEN];
 11 | 	bool isAvailable;
 12 | 
 13 | public:
 14 | 	Game() {
 15 | 		setTitle("");
 16 | 		setPrice(0);
 17 | 		setIsAvailable(false);
 18 | 	}
 19 | 	Game(const char* title, double price, bool isAvailable) {
 20 | 		setTitle(title);
 21 | 		setPrice(price);
 22 | 		setIsAvailable(isAvailable);
 23 | 	}
 24 | 
 25 | 	const char* getTitle() const {
 26 | 		return title;
 27 | 	}
 28 | 	double getPrice() const {
 29 | 		return price;
 30 | 	}
 31 | 	bool getIsAvailable() const {
 32 | 		return isAvailable;
 33 | 	}
 34 | 
 35 | 	void setTitle(const char* title) {
 36 | 		if (!title || strlen(title) >= TITLE_LEN)
 37 | 			return;
 38 | 
 39 | 		strcpy(this->title, title);
 40 | 	}
 41 | 	void setPrice(double price) {
 42 | 		this->price = price;
 43 | 	}
 44 | 	void setIsAvailable(bool isAvailable) {
 45 | 		this->isAvailable = isAvailable;
 46 | 	}
 47 | 
 48 | 	bool isFree() const {
 49 | 		return getPrice() == 0;
 50 | 	}
 51 | 	void print() const {
 52 | 		std::cout << "Title: " << getTitle() << "\nPrice:" <<
 53 | 			getPrice() << "\nIs it available: ";
 54 | 		if (getIsAvailable())
 55 | 			std::cout << "Yes!\n";
 56 | 		else
 57 | 			std::cout << "No\n";
 58 | 	}
 59 | };
 60 | 
 61 | class GamePlatform {
 62 | 	Game games[GAMES_CAPACITY];
 63 | 	unsigned size = 0;
 64 | 
 65 | 	bool isEmpty() const {
 66 | 		return size == 0;
 67 | 	}
 68 | 
 69 | public:
 70 | 	void addGame(const Game& game) {
 71 | 		if (size >= GAMES_CAPACITY)
 72 | 			return;
 73 | 
 74 | 		games[size++] = game;
 75 | 	}
 76 | 	void removeGame(const char* title) {
 77 | 		bool found = false;
 78 | 		for (int i = 0; i < size; ++i) {
 79 | 			if (!found && !strcmp(games[i].getTitle(), title))
 80 | 				found = true;
 81 | 
 82 | 			if (found) {
 83 | 				games[i] = games[i + 1];
 84 | 			}
 85 | 		}
 86 | 		size--;
 87 | 	}
 88 | 	void printGame(unsigned index) const {
 89 | 		if (index < size)
 90 | 			games[index].print();
 91 | 	}
 92 | 	void printAllGames() const {
 93 | 		for (unsigned i = 0; i < size; ++i)
 94 | 			games[i].print();
 95 | 	}
 96 | 	void printCheapestAndMostExpensiveGames() const {
 97 | 		if (isEmpty())
 98 | 			return;
 99 | 	
100 | 		int cheap = 0, expensive = 0;
101 | 		for (unsigned i = 0; i < size; ++i) {
102 | 			if (games[i].getPrice() > games[expensive].getPrice())
103 | 				expensive = i;
104 | 			if (games[i].getPrice() < games[cheap].getPrice())
105 | 				cheap = i;
106 | 		}
107 | 
108 | 		std::cout << "The cheapest game is: ";
109 | 		games[cheap].print();
110 | 		std::cout << "The most expensive game is: ";
111 | 		games[expensive].print();
112 | 	}
113 | 	void printAllFreeGames() const {
114 | 		for (int i = 0; i < size; ++i) {
115 | 			if (games[i].isFree())
116 | 				games[i].print();
117 | 		}
118 | 	}
119 | };


--------------------------------------------------------------------------------
/2024-2025/Week 03/Solutions/Task4.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #pragma warning(disable: 4996)
  3 | 
  4 | const constexpr unsigned NAME_LEN = 50;
  5 | const constexpr unsigned PRODUCTS_CAPACITY = 100;
  6 | 
  7 | class Product {
  8 | 	double price;
  9 | 	unsigned quantity;
 10 | 	char name[NAME_LEN];
 11 | 
 12 | public:
 13 | 	Product() {
 14 | 		setPrice(0);
 15 | 		setQuantity(0);
 16 | 		setName("");
 17 | 	}
 18 | 	Product(const char* name, double price, unsigned quantity) {
 19 | 		setName(name);
 20 | 		setPrice(price);
 21 | 		setQuantity(quantity);
 22 | 	}
 23 | 
 24 | 	void setPrice(double price) {
 25 | 		this->price = price;
 26 | 	}
 27 | 	void setQuantity(unsigned quantity) {
 28 | 		this->quantity = quantity;
 29 | 	}
 30 | 	void setName(const char* name) {
 31 | 		if (!name || strlen(name) >= NAME_LEN)
 32 | 			return;
 33 | 
 34 | 		strcpy(this->name, name);
 35 | 	}
 36 | 
 37 | 	double getPrice() const {
 38 | 		return price;
 39 | 	}
 40 | 	unsigned getQuantity() const {
 41 | 		return quantity;
 42 | 	}
 43 | 	const char* getName() const {
 44 | 		return name;
 45 | 	}
 46 | 
 47 | 	void print() const {
 48 | 		std::cout << "Name: " << getName() << " Price: " << getPrice() <<
 49 | 			" Quantity: " << getQuantity() << std::endl;
 50 | 	}
 51 | };
 52 | 
 53 | 
 54 | class Store {
 55 | 	Product  products[PRODUCTS_CAPACITY];
 56 | 	unsigned size;
 57 | 
 58 | public:
 59 | 	Store() {
 60 | 		size = 0;
 61 | 	}
 62 | 
 63 | 	void addProduct(const Product& product) {
 64 | 		if (size >= PRODUCTS_CAPACITY)
 65 | 			return;
 66 | 
 67 | 		products[size++] = product;
 68 | 	}
 69 | 	void sellProduct(const char* name) {
 70 | 		bool found = 0;
 71 | 		for (unsigned i = 0; i < size; ++i) {
 72 | 			if (found && i == size - 1)
 73 | 				break;
 74 | 			else if (found) {
 75 | 				products[i] = products[i + 1];
 76 | 				continue;
 77 | 			}
 78 | 
 79 | 			if (!strcmp(products[i].getName(), name)) {
 80 | 				if (products[i].getQuantity() > 0)
 81 | 					products[i].setQuantity(products[i].getQuantity() - 1);
 82 | 				else
 83 | 					products[i] = products[i + 1];
 84 | 			}
 85 | 		}
 86 | 		size--;
 87 | 	}
 88 | 	void restock(const char* name, unsigned quantity) {
 89 | 		for (unsigned i = 0; i < size; ++i) {
 90 | 			if (!strcmp(products[i].getName(), name)) {
 91 | 				products[i].setQuantity(quantity);
 92 | 				return;
 93 | 			}
 94 | 		}
 95 | 	}
 96 | 
 97 | 	void displayProducts() const {
 98 | 		for (unsigned i = 0; i < size; ++i)
 99 | 			products[i].print();
100 | 	}
101 | 	
102 | 	
103 | };


--------------------------------------------------------------------------------
/2024-2025/Week 03/readme.md:
--------------------------------------------------------------------------------
 1 | # OOП - Практикум 6.03.2024 - Седмица 3
 2 | 
 3 | **Задача 1:**
 4 | Напишете клас teacher, който описва преподавател. Класът трябва да съдържа:
 5 | - Име (фиксирана дължина)
 6 | - Възраст
 7 | - Години стаж като преподавател
 8 | 
 9 | Създайте подходящи конструктори, get и set член функции. <br />
10 | 
11 | **Задача 2:**
12 | Ще създадем проста система за работа със задачи. Всяка задача се състои от:
13 | - Име, с фиксирана дължина.
14 | - Условие, с фиксирана дължина.
15 | - Цяло число, показващо колко точки носи задачата.
16 | 
17 | Също така всяка задача трябва да поддържа следната функционалност:
18 | - Да можем по всяко време да променяме условието на задачата.
19 | - Да можем по всяко време да променяме името на задачата.
20 | - Да можем по всяко време да променяме точките, които задачата носи.
21 | 
22 | Създайте структура моделираща изпит, която поддържа константен брой задачи
23 | и цяло число, показващо минималните точки, изискващи се за успешно вземане на
24 | изпита. Създайте също:
25 | - Функция changeMin, която подава нов минимален успех за вземане на изпита.
26 | - Функция getMax(), която извежда максималния брой точки за текущия изпит.
27 | 
28 | **Задача 3:**
29 | Имплементирайте клас Game, който съдържа следните член-данни (полета): `title`, `price`, `isAvailable`.
30 | Член-данната `title` е от тип символен низ с максимална дължина **64**.
31 | 
32 | > Бележка. В реалните софтуерни продукти не се използват floating-point числа, за да се моделират пари и други данни, изискващи прецизност. Тук го моделираме по този начин за целите на упражнението.
33 | 
34 | Нека Game да съдържа:
35 | 
36 | - Конструктор по подразбиране.
37 | - Параметризирани конструктори
38 | - Селектори (getter)
39 | - Мутатори (setter)
40 | - `isFree()` - връща информация дали играта е безплатна
41 | - `print()` - отпечатва информация за играта в подходящ формат
42 |   
43 | Проектирайте клас `GamePlatform` (платформа за игри).  
44 | Целта му е да съдържа библиотека от игри (Games).
45 | 
46 | За да работим с `GamePlatform`, се нуждаем от следните функции:
47 | 
48 | - Добавяне на игра, ако има място.
49 | - Извеждане на игра по индекс.
50 | - Извеждане на списък с всички игри в платформата.
51 | - Извеждане на най-евтината / скъпата игра в платформата.
52 | - Извеждане на всички безплатни игри.
53 | - Премахване на игра от библиотеката.
54 | 
55 | **Задача 4:**
56 | 
57 | Създайте клас Store, който управлява списък от продукти.
58 | Всеки продукт се характеризира с: има, цена и количество в наличност.
59 | Вашият клас трябва да имплементира следните функционалности: 
60 | 
61 | * addProduct(Product); - добавя продукт в магазина;
62 | * sellProduct(Product); - продава продукт, ако той е наличен;
63 | * displayProducts(); - показва всички налични продукти;
64 | * restock(Product, quantity); - зарежда определено количество от даден продукт;
65 | 
66 | Реализирайте задача спазвайки изучените до момента ООП принципи.


--------------------------------------------------------------------------------
/2024-2025/Week 04/Solutions/Time/Time.cpp:
--------------------------------------------------------------------------------
  1 | #include "Time.h"
  2 | 
  3 | bool Time::isHourValid(int hour) const
  4 | {
  5 |     return(hour >= 0 && hour < 12) || (hour >= 0 && hour < 24 && TimeFormat::Twenty_Four == getTimeFormat());        
  6 | }
  7 | 
  8 | bool Time::isMinutesValid(int minutes) const
  9 | {
 10 |     return minutes >= 0 && minutes < 60;
 11 | }
 12 | 
 13 | bool Time::isSecondsValid(int seconds) const
 14 | {
 15 |     return seconds >= 0 && seconds < 60;
 16 | }
 17 | 
 18 | int Time::secondsFromBeggingOfTheDay() const
 19 | {
 20 |     int toReturn = getSeconds() + 60 * getMinutes();
 21 |     if (getTimeFormat() == TimeFormat::PM)
 22 |         toReturn += 12 * 60 * 60;
 23 |     toReturn += 12 * 60 * getHour();
 24 |     return toReturn;
 25 | }
 26 | 
 27 | Time::Time(int hour, int minutes, int seconds)
 28 | {
 29 |     setHour(hour);
 30 |     setMinutes(minutes);
 31 |     setSeconds(seconds);
 32 | }
 33 | 
 34 | void Time::setHour(int hour)
 35 | {
 36 |     if (isHourValid(hour))
 37 |         this->hour = hour;
 38 |     else
 39 |         this->hour = 0;
 40 | }
 41 | 
 42 | void Time::setMinutes(int minutes)
 43 | {
 44 |     if (isMinutesValid(minutes))
 45 |         this->minutes = minutes;
 46 |     else
 47 |         this->minutes = 0;
 48 | }
 49 | 
 50 | void Time::setSeconds(int seconds)
 51 | {
 52 |     if (isSecondsValid(seconds))
 53 |         this->seconds = seconds;
 54 |     else
 55 |         this->seconds = 0;
 56 | }
 57 | 
 58 | int Time::getHour() const
 59 | {
 60 |     return hour;
 61 | }
 62 | 
 63 | int Time::getMinutes() const
 64 | {
 65 |     return minutes;
 66 | }
 67 | 
 68 | int Time::getSeconds() const
 69 | {
 70 |     return seconds;
 71 | }
 72 | 
 73 | Time::TimeFormat Time::getTimeFormat() const
 74 | {
 75 |     return timeFormat;
 76 | }
 77 | 
 78 | void Time::addSeconds(int n)
 79 | {
 80 |     int temp = getSeconds() + n;
 81 |     if (temp < 60) {
 82 |         setSeconds(temp);
 83 |         return;
 84 |     }
 85 | 
 86 |     setSeconds(temp % 60);
 87 |     int temp2 = getMinutes() + (temp / 60);
 88 |     if (temp2 < 60) {
 89 |         setMinutes(temp2);
 90 |         return;
 91 |     }
 92 | 
 93 |     int temp3 = getHour() + (temp2 / 60);
 94 |     if ((temp3 < 12) || (temp3 < 24 && getTimeFormat() == TimeFormat::Twenty_Four)) {
 95 |         setHour(temp3);
 96 |         return;
 97 |     }
 98 |     else if (getTimeFormat() == TimeFormat::Twenty_Four) {
 99 |         setHour(temp3 / 24);
100 |         return;
101 |     }
102 | 
103 |     setHour(temp3 / 12);
104 | }
105 | 
106 | void Time::removeSeconds(int n)
107 | {
108 |     int temp = getSeconds() - n;
109 |     if (temp >= 0) {
110 |         setSeconds(temp);
111 |         return;
112 |     }
113 | 
114 |     int minsToTake = std::abs((temp / 60) - 1);
115 |     if (minsToTake < getMinutes()) {
116 |         setMinutes(getMinutes() - minsToTake);
117 |         setSeconds(60 + getSeconds() + (temp % 60));
118 |         return;
119 |     }
120 | 
121 |     int hourToTake = (minsToTake / 60) + 1;
122 |     if (hourToTake > getHour()) {
123 |         setHour(0);
124 |         setMinutes(0);
125 |         setSeconds(0);
126 |         return;
127 |     }
128 | 
129 |     setHour(getHour() - hourToTake);
130 |     setMinutes(getMinutes() + 60 - minsToTake);
131 |     setSeconds(60 + getSeconds() + (temp % 60));
132 | }
133 | 
134 | void Time::switchToAM()
135 | {
136 |     if (getTimeFormat() == TimeFormat::Twenty_Four) 
137 |         setHour(getHour() - 12);
138 | 
139 |     timeFormat = TimeFormat::AM;
140 | }
141 | 
142 | void Time::switchToPM()
143 | {
144 |     if (getTimeFormat() == TimeFormat::Twenty_Four)
145 |         setHour(getHour() - 12);
146 | 
147 |     timeFormat = TimeFormat::PM;
148 | }
149 | 
150 | void Time::switchTo24()
151 | {
152 |     if (getTimeFormat() == TimeFormat::PM)
153 |         setHour(getHour() + 12);
154 |     timeFormat = TimeFormat::Twenty_Four;
155 | }
156 | 
157 | bool Time::compare(const Time& other) const
158 | {
159 |     return secondsFromBeggingOfTheDay() - other.secondsFromBeggingOfTheDay() > 0;
160 | }
161 | 
162 | int Time::remainingSecondsToNextFullHour() const
163 | {
164 |     return 60 * (60 - getMinutes()) + (60 - getSeconds());
165 | }
166 | 
167 | int Time::remainingSecondsToMidnight() const
168 | {
169 |     return 60 * 60 * 24 - secondsFromBeggingOfTheDay();
170 | }
171 | 
172 | Time Time::diff(const Time& other) const
173 | {
174 |     Time toReturn;
175 |     int diffSeconds = std::abs(secondsFromBeggingOfTheDay() - other.secondsFromBeggingOfTheDay());
176 | 
177 |     toReturn.setHour(diffSeconds / (60 * 60));
178 |     diffSeconds -= toReturn.getHour() * 60 * 60;
179 |     toReturn.setMinutes(diffSeconds / 60);
180 |     diffSeconds -= toReturn.getMinutes() * 60;
181 |     toReturn.setSeconds(diffSeconds);
182 | 
183 |     return toReturn;
184 | }
185 | 


--------------------------------------------------------------------------------
/2024-2025/Week 04/Solutions/Time/Time.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <iostream>
 3 | class Time
 4 | {
 5 | public:
 6 | 	enum class TimeFormat
 7 | 	{
 8 | 		AM,
 9 | 		PM,
10 | 		Twenty_Four,
11 | 	};
12 | 
13 | private:
14 | 	int hour = 0;
15 | 	int minutes = 0;
16 | 	int seconds = 0;
17 | 	TimeFormat timeFormat = TimeFormat::Twenty_Four;
18 | 
19 | 	bool isHourValid(int hour) const;
20 | 	bool isMinutesValid(int minutes) const;
21 | 	bool isSecondsValid(int seconds) const;
22 | public:
23 | 	Time() = default;
24 | 	Time(int hour, int minutes, int seconds);
25 | 
26 | 	void setHour(int hour);
27 | 	void setMinutes(int minutes);
28 | 	void setSeconds(int seconds);
29 | 	
30 | 	int getHour() const;
31 | 	int getMinutes() const;
32 | 	int getSeconds() const;
33 | 	TimeFormat getTimeFormat() const;
34 | 
35 | 	void addSeconds(int n);
36 | 	void removeSeconds(int n);
37 | 	void switchToAM();
38 | 	void switchToPM();
39 | 	void switchTo24();
40 | 
41 | 	bool compare(const Time& other) const;
42 | 	int remainingSecondsToNextFullHour() const;
43 | 	int remainingSecondsToMidnight() const;
44 | 	Time diff(const Time& other) const;
45 | 	int secondsFromBeggingOfTheDay() const;
46 | };
47 | 
48 | 


--------------------------------------------------------------------------------
/2024-2025/Week 04/readme.md:
--------------------------------------------------------------------------------
 1 | # ООП - практикум 13.03.2025 - Седмица 4
 2 | 
 3 | **Задача 1.**
 4 | 
 5 | Реализирайте клас **Time** за работа с време. Класът трябва да има три член-данни:
 6 | 
 7 | * час (int)
 8 | * минути (int)
 9 | * секунди (int)
10 | 
11 | Класът трябва да предоставя следните **функционалности**:
12 | 
13 | * Конструктор по подразбиране, който задава времето на 00:00:00.
14 | * Конструктор, който приема като аргументи час, минути и секунди и ги задава като стойности.
15 |     Ако подадените стойности са извън допустимите граници (например 25 часа или 90 минути), да се зададат като 00:00:00.
16 | * Метод за добавяне на секунди – приема цяло число n и увеличава времето с n секунди. Ако при това увеличаване се премине към следваща минута или час, времето трябва да се коригира съответно.
17 | * Метод за изваждане на секунди – приема цяло число n и намалява времето с n секунди, като при достигане на 00:00:00 се връща към предишен час/минута, ако е необходимо.
18 | * Метод за връщане на времето в 12-часов формат – връща текущото време във формат hh:mm:ss AM/PM.
19 | * Метод за проверка дали времето е сутрин или вечер – връща "AM" ако времето е в интервала [00:00 - 11:59] и "PM" ако е в [12:00 - 23:59].
20 | * Метод за сравнение на две времена – приема друг обект от тип Time и връща истина, ако текущото време е след подаденото.
21 | * Метод, който връща оставащите секунди до следващия час – изчислява колко секунди остават до пълния следващ час.
22 | * Метод, който връща оставащото време до полунощ – изчислява колко часа, минути и секунди остават до 00:00:00.
23 | * Метод, който връща разликата между две времена – приема друг обект от тип Time и връща разликата между текущото и подаденото време във формат hh:mm:ss.
24 | 
25 | **Задача 2.**
26 | 
27 | **Система за управление на метрото – Софийска община**
28 | 
29 | Софийска община желае да създаде система за дигитално управление на метрото. Системата трябва да съдържа следните компоненти:
30 | 
31 | Клас **Train**
32 | Класът представлява влак в метрото и съдържа следните член-данни:
33 | 
34 | * марка – марката на влака.
35 | * модел – моделът на влака.
36 | * идентификационен номер – уникален идентификатор на влака.
37 | * брой вагони – броят на вагоните във влака.
38 | * маршрут – списък от спирки, които влакът обслужва.
39 |     Всяка спирка е символен низ с дължина до 32 символа.
40 |     Всеки маршрут съдържа до 16 спирки.
41 | * Текуща спирка – спирката, на която в момента се намира влакът.
42 | * Посока на движение – булева променлива, указваща посоката на движение (напред или назад по маршрута).
43 | 
44 | *Основни методи* на Train
45 | 
46 | * Редактиране на маршрут – метод за промяна на маршрута на влака.
47 | * Принтиране на маршрут – метод, който извежда маршрута в следния формат:
48 | 
49 | „Младост 1 -> Мусагеница -> Г.М. Димитров -> …“
50 | * Преместване на следваща спирка – метод, който премества влака на следващата спирка в маршрута му.
51 | * Обръщане на посоката – метод за промяна на посоката на движение на влака.
52 | 
53 | Клас **Underground**
54 | Класът представлява цялата мрежа на метрото и съдържа следните член-данни:
55 | 
56 | * масив от влакове – списък от влакове, които в момента се движат в метрото (до 64 влака).
57 | * брой пътници – общият брой пътници в метрото.
58 | * множество от спирки – списък от всички възможни спирки в метрото (до 16×64 спирки).
59 | 
60 | *Основни методи* на Underground
61 | * Добавяне на влак – метод за добавяне на нов влак към метрото. При добавяне трябва да се проверят следните условия:
62 | * Да няма друг влак на същата начална спирка.
63 | * Да не се надвиши максималният брой влакове в метрото.
64 |     Ако маршрутът на влака е нов, неговите спирки се добавят към списъка от спирки.
65 | * Премахване на влак – метод за премахване на влак от метрото.
66 | * Преместване на конкретен влак напред – метод, който премества даден влак на следващата спирка от маршрута му.
67 | * Преместване на всички влакове напред – метод, който премества всички влакове напред по маршрутите им.
68 |     Ако даден влак достигне последната спирка в маршрута си, той обръща посоката си и се премества с една спирка в обратна посока.
69 | 


--------------------------------------------------------------------------------
/2024-2025/Week 05/README.md:
--------------------------------------------------------------------------------
  1 | # OOП - Практикум 20.03.2024 - Седмица 4
  2 | 
  3 | ## Задачи върху обикновени файлове
  4 | 
  5 | **Задача 1:**
  6 | 
  7 | Реализирайте функция, която приема отворен поток и връща размера на отворения файл в константно време.
  8 | 
  9 | **Задача 2:**
 10 | 
 11 | От стандартния вход се прочитат три числа. Запишете във файл "result.txt"сумата и произведението им. <br />
 12 | Направете функция, която извежда на стандартния изход разликата на сумата и произведението, прочетени от файла "result.txt". <br />
 13 | _Забележка:_ Коректността на данните във файла, който четете, е гарантирана. <br />
 14 | 
 15 | **Задача 3.** 
 16 | 
 17 | Да се напише програма, която чете матрица от текстов файл от вида : 3,3,3|1,1,3|3,3,1, чете друга матрица в същия формат от втория файл и записва произведението им в нов файл.
 18 | 
 19 | Примерен вход:
 20 | 
 21 | Файл fst.txt:
 22 | ```c++
 23 | 1,2,3|3,2,1|1,2,3
 24 | ```
 25 | 
 26 | файл snd.txt:
 27 | ```c++
 28 | 4,5,6|6,5,4|4,6,5
 29 | ```
 30 | 
 31 | 
 32 | Примерен изход:
 33 | файл result.txt:
 34 | ```c++
 35 | 28,33,29|28,31,31|28,33,29
 36 | ```
 37 | 
 38 | **Задача 4.**	
 39 | 
 40 | Да се напишат функции, които запазват и зареждат данните за студентите в една група, като всеки студент се характеризира с:
 41 | * две имена с максимална дължина 16 символа всяко;
 42 | * петцифрен факултетен номер;
 43 | * среден успех и цвят на косата (кафява, черна, руса, червена или бяла). 
 44 | 
 45 | Файлът може да съдържа максимално 1024 студента. Файлът трябва да бъде с разширение .csv
 46 | 
 47 | **Задача 5:**
 48 | 
 49 | Да се напише функция, която приема поток към текстов файл и структура, която съдържа два масива от символи ( **key и value** (всеки с максимален размер от 32 символа)). Функцията трябва да смени всяко срещане на **key** c **value** в текстовия файл. <br />
 50 | Новия тескт да се запише в друг текстов файл. <br />
 51 | Да се напише втора функция, която приема текстов файл и множество от двойки **key и value** и заменя всеки **key** в текстовия файл със съответния му **value**. <br />
 52 | _Забележка:_ Приемете, че данните са валидни и няма нито един key да е същия, като някое value на друга двойка
 53 | 
 54 | **Задача 6:**
 55 | 
 56 | Да се създаде структура pair, която представя наредена двойка от естествени числа. <br />
 57 | Да се създаде структура, която представя релация. В релацията има най-много 25 наредени двойки и структурата пази текущия си размер. <br />
 58 | Да се създаде функция writeRelationToFile(...), която записва релацията във файл с име "relation.txt"и readRelationFromFile(...), която чете релацията от файла. <br />
 59 | Следните функции ще ви бъдат полезни: <br />
 60 | 
 61 | - createPair()
 62 | - initPair()
 63 | - readPairFromFile()
 64 | - writePairToFile()
 65 | - addPairToRelation()
 66 | 
 67 | Помислете какво трябва да приемат и връщат горните функции.  
 68 | Напишете проста програма, която демонстрира работата на написаната от вас програма.
 69 | 
 70 | **Задача 7:**
 71 | 
 72 | Реализирайте структура User, която да съдържа:
 73 | * име; 
 74 | * имейл;
 75 | * парола.
 76 | 
 77 | Всяко поле е с максимална дължина 128 символа. Създайте възможност за записване и четене на потребител в текстов файл. <br />
 78 | 
 79 | Реализирайте клас System, който има масив от User-и. Системата поддържа максимално 100 потребителя. Създайте методи за запазване и прочитане на обект от тип System от файл. <br />
 80 | 
 81 | **Задача 8:**
 82 | 
 83 | Напишете програма, която управлява списък с книги. Всяка книга трябва да съдържа следните данни:
 84 | * Заглавие (64 символа)
 85 | * Автор (64 символа)
 86 | * Година на издаване
 87 | * Цена ( > 1 && < 100)
 88 | 
 89 | Програмата трябва да:
 90 | * Прочита списък с книги от файл books.csv
 91 | * Позволява на потребител да добавя нови книги
 92 | * Записва новите книги обратно във файла
 93 | * Извежда списъка с книги на екрана
 94 | 
 95 | Примерно съдържание на файла books.csv: 
 96 | ```
 97 | Origin,Dan Brown,2017,29.99
 98 | Dune,Frank Herbert,1965,21.89
 99 | A Murder Is Announced,Agatha Christie,1950,18.99
100 | Billy Summers,Stephen King,2021,23.45
101 | ```
102 | 
103 | **Задача 9:**
104 | 
105 | Напишете програма, която взема две версии на един файл (нова и стара) и записва в трети файл всички разлики между двата файла. <br />
106 | 
107 | Третия файл трябва да е във вида:
108 | 
109 | ```
110 | еднакъв ред
111 | - стар ред
112 | + нов ред
113 | ```
114 | 
115 | Примерен вход:
116 | 
117 | file1:
118 | 
119 | ```
120 | Water. Earth. Fire. Air.
121 | Long ago, the four nations lived together in harmony.
122 | Then everything changed when the Fire Nation attacked.
123 | Only the Avatar, master of all four elements, could stop them,
124 | ```
125 | 
126 | file2:
127 | 
128 | ```
129 | Water. Earth. Fire. Air.
130 | Long ago, the five nations lived together in harmony.
131 | Then everything changed when the Water Nation attacked.
132 | Only the Avatar, master of all four elements, could stop them,
133 | but when the world needed him most, he vanished.
134 | ```
135 | 
136 | Примерен изход:
137 | 
138 | ```
139 | Water. Earth. Fire. Air.
140 | - Long ago, the four nations lived together in harmony.
141 | + Long ago, the five nations lived together in harmony.
142 | - Then everything changed when the Fire Nation attacked.
143 | + Then everything changed when the Water Nation attacked.
144 | Only the Avatar, master of all four elements, could stop them,
145 | + but when the world needed him most, he vanished.
146 | ```
147 | 
148 | ## Задачи върху Двоични Файлове
149 | 
150 | **Задача 1.** 
151 | 
152 | Да се напише структура, която съхранява информация за доставка на пица. Да се създаде масив от доставки - списък с поръчки. Една поръчка съдържа име на клиента (до 50 символа), телефонен номер (до 20 символа), адрес на потребителя(до 100 символа), общата стойност на доставката, броят пици и масив от пици. Структурата на пицата трябва да съдъжа типа на пицата { Маргарита, калцоне, бурата и каквато още пожелаете}, размер на пицата {S,M,L}, цена на пицата. Да се имплементират функции, които позволяват съхраняването и изчитането на информацията за поръчките от двоичен файл. Да се сортират поръчките в масива по адрес на доставка и да се запише в нов двоичен файл.
153 | 
154 | Разгледайте съдържанието на този файл като използвате за целта подходящ Hex Editor: https://en.wikipedia.org/wiki/Hex_editor
155 | 
156 | **Задача 2.**	
157 | 
158 | След като Пенчо успешно завърши първи курс на ФМИ, той беше готов да започне работа. Но понеже работодателите, търсещи неговите невероятни умения, бяха повече от очакваното, той реши да изтрие имейла си и да направи собствена система, чрез която да получава покани за работа.
159 | 
160 | Създайте структура, описваща обява за работа. Структурата трябва да съдържа:
161 | 
162 |     1) Име на фирмата. То трябва да е с максимална дължина от 25 символа.
163 |     2) Брой на програмистите, с които той ще работи в екип.
164 |     3) Брой на дните платен отпуск през годината.
165 |     4) Сума, която ще му бъде изплатена след успешно завършване на проекта  (от тип long long)
166 | 
167 | Създайте функция, която прочита n на брой заявки от стандартния вход.
168 | Заявките се запазват в двоичен файл, като ако във файла вече има информация,тя не се изтрива.
169 | 
170 | Създайте функция void filterOffers(const char* filePath, long long minSalary), която приема адрес на файл, от който четем заявките. Извежда на стандартния изход всички обяви за работа, които предлагат поне толкова пари, колкото са подадени като аргумент.
171 | 
172 | Създайте функция, bool existOffer(const char* filePath, const char* name),
173 | която проверява дали дадена фирма е пратила покана за работа.
174 | 
175 | *Бонус №1: Създайте void perfectOffer(const char* filePath, int maxCoworkers, int minVacancyDays, int minSalary), която извежда във файл всички обяви, които отговарят точно на изискванията на Пенчо.
176 | 
177 | *Бонус №2: Създайте система, която работи чрез следните заявки:
178 | 
179 |     a <оферта> - добавя оферта за работа
180 | 
181 |     i - показва всички оферти
182 | 
183 |     s <име на фирма> - връща дали фирмата съществува
184 | 
185 |     f <число> - извежда всички обяви, за които заплатата е по - висока от числото
186 |     q - изход от системата


--------------------------------------------------------------------------------