6 files changed, 15 insertions, 15 deletions
diff --git a/Seminar01/README.md b/Seminar01/README.md
index 79424b2..47f9f83 100644
--- a/Seminar01/README.md
+++ b/Seminar01/README.md
@@ -42,7 +42,7 @@ void redirect(int*& ptr, int& dest) {
 }
 ```
 то вече функцията върши желаната работа. Когато приемаме обект по референция **копие не се прави**. Това важи за всички типове - включително и за указателите. 
-Можем да правим указатели към всякакви типове включително и към указатели. Типът **int**** не е нищо повече от указател към указател.
+Можем да правим указатели към всякакви типове включително и към указатели. Типът **int\*\*** не е нищо повече от указател към указател.
 
 Тогава не можем ли просто да вземем указател към указателя и да го променим по този начин? 
 ```c++
@@ -63,12 +63,12 @@ int main() {
 ```
 
 Този код също върши работа. Тогава каква е разликата между указател и референция? 
-Разликата е, че указателите са по - гъвкави. Не можем да пренасочим референция. Също така не можем да имаме референция която не сочи към обект. При указателите имаме специален тип наречен nullptr, който сочи към "нищото". Често референцията е представяна като указател, който не може да се пренасочва, вика * вместо теб и винаги сочи към обект.
+Разликата е, че указателите са по - гъвкави. Не можем да пренасочим референция. Също така не можем да имаме референция която не сочи към обект. При указателите имаме специален тип наречен nullptr, който сочи към "нищото". Често референцията е представяна като указател, който не може да се пренасочва, вика \* вместо теб и винаги сочи към обект.
 
 ## const и указателите
 За *const* важи следното правило - *const* винаги модифицира това което е в негово ляво, освен когато няма нищо отляво, тогава модифицира това което е отдясно. 
 
-* const int* -> Указател, който сочи към константен *int*. Можем да пренасочваме, но не можем да променяме стойността. 
-* int const* -> Абсолютно същото.
-* int * const -> Константен указател, не можем да го пренасочваме.
-* const int* const -> Константен указател към константен *int*. Нито можем да пренасочваме нито да променяме стойността.
-\ No newline at end of file
+* const int\* -> Указател, който сочи към константен *int*. Можем да пренасочваме, но не можем да променяме стойността. 
+* int const\* -> Абсолютно същото.
+* int \* const -> Константен указател, не можем да го пренасочваме.
+* const int\* const -> Константен указател към константен *int*. Нито можем да пренасочваме нито да променяме стойността.
diff --git a/Seminar02/README.md b/Seminar02/README.md
index 97d7a86..168e452 100644
--- a/Seminar02/README.md
+++ b/Seminar02/README.md
@@ -1,10 +1,10 @@
 # Задачи за стекове 12.10.22
 
 ## Задача първа
-Имаме низ състоящ се от английски букви и символа *. Всеки път когато видим * трябва да премахнем символът отляво както и самата звезда.
+Имаме низ състоящ се от английски букви и символа \*. Всеки път когато видим \* трябва да премахнем символът отляво както и самата звезда.
 Пример:
-* aa* -> "a"
-* erase***** -> ""
+* aa\* -> "a"
+* erase\*\*\*\*\* -> ""
 * thi\*s i\*s exampl\*e -> "ths s exampe"
 
 Задачата да се реализира за линейно време с линейна памет.
diff --git a/Seminar04/README.md b/Seminar04/README.md
index efa7539..50518a3 100644
--- a/Seminar04/README.md
+++ b/Seminar04/README.md
@@ -64,7 +64,7 @@ class DynArray {
     size_t capacity = 8;
 };
 ```
-Нека в началото *capacity* да е 8. Кога ще имаме алокация? Първо, ще алокираме памет при създаването на масива. След това, когато се опитаме да добавим девети елемент ще алокираме 16 * sizeof(T) байта. След това когато се опитаме да добавим седемнадесети елемент ще алокираме 32 * sizeof(T) байта. 
+Нека в началото *capacity* да е 8. Кога ще имаме алокация? Първо, ще алокираме памет при създаването на масива. След това, когато се опитаме да добавим девети елемент ще алокираме 16 \* sizeof(T) байта. След това когато се опитаме да добавим седемнадесети елемент ще алокираме 32 \* sizeof(T) байта. 
 Тоест, когато въртя for цикъла във втория пример, всеки път когато *i = 2^k + 1* ще имам алокация на памет.
 
 Това за наше щастие има как да се оправи. Когато знаем колко елемента ще пазим в динамичния масив можем да извикаме *resize(size_t)*.
diff --git a/Seminar06/README.md b/Seminar06/README.md
index 4915dad..e333dc2 100644
--- a/Seminar06/README.md
+++ b/Seminar06/README.md
@@ -31,7 +31,7 @@ void insertSorted(std::list<T>& ll, const T& elem);
 която приема сортиран свързан списък и добавя *elem* на правилното място.
 
 ## Задача втора
-Нека имаме двусвързан списък от опашки и символи. Във всяка опашка от налачото към края е записан валиден израз в обратна полска нотация. Операторите са [+, -, *, /] а операндите за улеснение са **едноцифрени числа**.
+Нека имаме двусвързан списък от опашки и символи. Във всяка опашка от началото към края е записан валиден израз в обратна полска нотация. Операторите са [+, -, \*, /] а операндите за улеснение са **едноцифрени числа**.
 
 Да се напише функция, която приема такъв списък, изчислява стойността на всички опашки, и връща дали списъка от резултатите е симетричен спрямо средата.
 
diff --git a/Seminar08/README.md b/Seminar08/README.md
index 9948c59..64c1150 100644
--- a/Seminar08/README.md
+++ b/Seminar08/README.md
@@ -86,7 +86,7 @@ struct Tree {
 }
 ```
 
-От тук всеки указател от типа *Tree\<T>** е валидно дърво. Ако то е празно стойността му би била nullptr. Ако е непразно, данните записани във възела му достъпваме чрез data полето, а лявото и дясното поддърво достъпваме съответно чрез left и right.
+От тук всеки указател от типа *Tree\<T>\** е валидно дърво. Ако то е празно стойността му би била nullptr. Ако е непразно, данните записани във възела му достъпваме чрез data полето, а лявото и дясното поддърво достъпваме съответно чрез left и right.
 
 Дървото от пример 1, представено по този начин, би изглеждало така:
 
@@ -181,10 +181,10 @@ struct Tree {
 Да се реализира функция, която добавя елемент в двоично наредено дърво.
 
 ## Задача втора
-Да се напише функция *contains(Tree\<T>* tree, const T& elem)* която връща дали елемента се съдържа в двоично дърво. Да се реализира същата функция за двоично наредено дърво.
+Да се напише функция *contains(Tree\<T>\* tree, const T& elem)* която връща дали елемента се съдържа в двоично дърво. Да се реализира същата функция за двоично наредено дърво.
 
 ## Задача трета
-Да се напише функция *max((Tree\<T>* tree)* която връща най - големия елемент в двоично дърво. Да се реализира същата функция за двоично наредено дърво. Да се реализира функция намираща най - малкия елемент.
+Да се напише функция *max((Tree\<T>\* tree)* която връща най - големия елемент в двоично дърво. Да се реализира същата функция за двоично наредено дърво. Да се реализира функция намираща най - малкия елемент.
 
 ## Задача четвърта
 Да се реализира функция, която връща височината на двоично дърво.
diff --git a/Seminar09/README.md b/Seminar09/README.md
index 3917b0e..edcf21e 100644
--- a/Seminar09/README.md
+++ b/Seminar09/README.md
@@ -20,7 +20,7 @@ T maxElem(const Tree<T>* t) {
 Това решение работи почти винаги. Какво става ако t e nullptr? 
 
 Ако знаехме, че дървото е от тип int, лесно можехме да връщаме INT_MAX, но в случая не знаем какъв тип е скрит зад Т.
-Един от начините да се справим с този проблем е да връщаме T* вместо Т. Така, ако дървото е nullptr ние също ще връщаме nullptr. Това е валиден начин, и може би стандартния начин по който бихме подходили в С или във версиите на С++ преди С++17.
+Един от начините да се справим с този проблем е да връщаме T\* вместо Т. Така, ако дървото е nullptr ние също ще връщаме nullptr. Това е валиден начин, и може би стандартния начин по който бихме подходили в С или във версиите на С++ преди С++17.
 
 ## std::optional\<T>
 std::optional\<T> е клас който в някакъв смисъл "обвива" елемент от тип Т. Както името подсказва той или има стойност.. или няма.