feat!: Update dunbar after inline brace character swap

Commit: 88a5b49611a0a4d1eb47ba86b9123159443ce4cb (patch)
Author: Syndamia <kamen@syndamia.com> 2025-12-23 22:54:20 +0200
Committer: Syndamia <kamen@syndamia.com> 2025-12-23 22:54:20 +0200
Files: 22ce3c36887f506898cc7636a80abf245ae240e7 /src/teaching
Parent: 0be8d4b427a0f0944552769edc9a080dbaf79cee (diff)
65 files changed, 1554 insertions, 1230 deletions
diff --git a/src/teaching/index.du b/src/teaching/index.du
index 8622894..8c4d12f 100644
--- a/src/teaching/index.du
+++ b/src/teaching/index.du
@@ -4,7 +4,7 @@ This is a list of all the subjects I've taught professionally.
 
 \n
 
-#### *[2025 - 2026]*
+#### [*2025 - 2026*]
 
 :defs
 ; [$bg] 2025-2026 &emsp; [url /teaching/upp-2025 3107 Увод в програмирането - практикум, КН, 5 група]
@@ -14,7 +14,7 @@ This is a list of all the subjects I've taught professionally.
 : Преподавател в частна академия по Nix към [url https://blocksense.network blocksense.network]
 
 
-#### *[2023 - 2024]*
+#### [*2023 - 2024*]
 
 :defs
 ; [$bg] 2023-2024 &emsp; [url /teaching/oop-2023 З520 Обектно-ориентрано програмиране - практикум, КН, 8 група]
diff --git a/src/teaching/oop-2023/index.du b/src/teaching/oop-2023/index.du
index 5641c13..1cd59f5 100644
--- a/src/teaching/oop-2023/index.du
+++ b/src/teaching/oop-2023/index.du
@@ -2,11 +2,11 @@
 
 Материали на проведените през 2023/2024 практикуми по Обектно-ориентирано програмиране на Компютърни науки (2 поток), 8 група.
 
-=[Зала:]= ФМИ 120 ||
-=[Време:]= 13:15 - 15:00 ||
-=[Ден:]= Четвъртък
+[=Зала:=] ФМИ 120 ||
+[=Време:=] 13:15 - 15:00 ||
+[=Ден:=] Четвъртък
 \n
-=[Директни връзки:]=
+[=Директни връзки:=]
 [url ../upp-2023/week1/welcome.html?a#section-4 Контакт с мен] |
 [url https://github.com/Syndamia/oop-2023-solutions Решения на задачи] |
 [url https://github.com/Aleksis99/Object-Oriented-Programming_FMI_2023-2024 Материали от семинари] |
@@ -59,7 +59,7 @@
 
 |: 11
 |: 09.05.2024
-|: [url ./week11/ Задачи] \|\| [url https://github.com/Syndamia/oop-2023-solutions/tree/main/week11 Решения] \|\| [url https://classroom.github.com/a/oYQehcnN GitHub classroom] =[Това упражнение е от 11:15 до 13:15]=
+|: [url ./week11/ Задачи] \|\| [url https://github.com/Syndamia/oop-2023-solutions/tree/main/week11 Решения] \|\| [url https://classroom.github.com/a/oYQehcnN GitHub classroom] [=Това упражнение е от 11:15 до 13:15=]
 
 |: 12
 |: 09.05.2024
@@ -75,7 +75,7 @@
 
 |: 15
 |: 30.05.2024
-|: [url ./week15/ Задачи] <!-- \|\| [url https://github.com/Syndamia/oop-2023-solutions/tree/main/week12 Решения] --> \|\| [url https://classroom.github.com/a/z2QadyEE GitHub classroom] =[Това упражнение е от 11:15 до 13:15]=
+|: [url ./week15/ Задачи] <!-- \|\| [url https://github.com/Syndamia/oop-2023-solutions/tree/main/week12 Решения] --> \|\| [url https://classroom.github.com/a/z2QadyEE GitHub classroom] [=Това упражнение е от 11:15 до 13:15=]
 
 |: 16
 |: 06.06.2024
diff --git a/src/teaching/oop-2023/week1/good-software.du b/src/teaching/oop-2023/week1/good-software.du
index 94bf593..3f8fd9a 100644
--- a/src/teaching/oop-2023/week1/good-software.du
+++ b/src/teaching/oop-2023/week1/good-software.du
@@ -54,7 +54,7 @@
 
 :middle_slide
 
-Труден за четене код *[(забелязвате ли грешките?)]*:
+Труден за четене код [*(забелязвате ли грешките?)*]:
 
 .font22
 ```
@@ -84,7 +84,7 @@ if (board[a][b][i] == ' ') {
 
 :middle_slide
 
-По-лесен за четене код *[(а сега виждат ли се по-лесно?)]*:
+По-лесен за четене код [*(а сега виждат ли се по-лесно?)*]:
 
 :font18
 :code
@@ -120,7 +120,7 @@ for (int i = 0; i < layers; i++)
 
 
 
-Би трябвало да е малко по-лесно, в последния `[if]` имаме "e=[n]=ptyRow", което е печатната грешка, `[!=]` което трябва да бъде `[==]` и липсва въвеждането на `[b]` след първия `[if]`.
+Би трябвало да е малко по-лесно, в последния [`if`] имаме "e[=n=]ptyRow", което е печатната грешка, [`!=`] което трябва да бъде [`==`] и липсва въвеждането на [`b`] след първия [`if`].
 
 Примерът не е перфектен, но илюстрира какво се опитвам да кажа: формата на код е от огромно значение, обръщайте ѝ внимание.
 
@@ -139,11 +139,11 @@ for (int i = 0; i < layers; i++)
 [$br1]
 
 .bulleted
-- `[doX()]` е по-лошо от `[do(X)]`
+- [`doX()`] е по-лошо от [`do(X)`]
   .unordered
-  - можем да преизползваме `[do()]` за неща, различни от `[X]`
-  - един път разбрано, всяка употреба на `[do()]` също е разбрана; този стил кара `[do()]` да бъде по-обща функция, което я прави по-лесна за разбиране
-  - модификация на `[do(X)]` се свежда до заменяне на `[do()]` с `[doOther()]` или до заменяне на `[X]` с `[Y]`; променяме "инструкцията" или променяме данната
+  - можем да преизползваме [`do()`] за неща, различни от [`X`]
+  - един път разбрано, всяка употреба на [`do()`] също е разбрана; този стил кара [`do()`] да бъде по-обща функция, което я прави по-лесна за разбиране
+  - модификация на [`do(X)`] се свежда до заменяне на [`do()`] с [`doOther()`] или до заменяне на [`X`] с [`Y`]; променяме "инструкцията" или променяме данната
 
 
 Нека сега разгледаме няколко примера, първият е много груб и елементарен, но служи за добро начало:
@@ -175,7 +175,7 @@ int fib5()                      │ int fib(int n)
 
 :slide
 
-Лошо - `[doX()]` в тялото на функцията
+Лошо - [`doX()`] в тялото на функцията
 
 ```cpp
 void tryTakeTile(char** board, int rows, int cols,
@@ -201,16 +201,16 @@ void tryTakeTile(char** board, int rows, int cols,
 
 Повечето предадени работи са имплементирали функционалността по точно този начин.
 Замислете се обаче, какво става ако сменим типа данна, тоест ако дъската е триизмерна?
-Тогава трябва да добавим още една `[int]` променлива, още едно условие в `[if]`, трябва да я добавим при трите индексирания на `[board]`.
+Тогава трябва да добавим още една [`int`] променлива, още едно условие в [`if`], трябва да я добавим при трите индексирания на [`board`].
 
-Какво става ако променим самата структура от данни за `[emptyRow]` (за сега сте учили само масиви, но скоро ще видите, че има и други начини да съхраняваш редица информация), тогава ще трябва да пренапишем целия цикъл.
+Какво става ако променим самата структура от данни за [`emptyRow`] (за сега сте учили само масиви, но скоро ще видите, че има и други начини да съхраняваш редица информация), тогава ще трябва да пренапишем целия цикъл.
 
 Тоест, ако променим нещо, трябва да пренапишем значителни части от самия код, и като разширим това върху 10-20 функции, изведнъж малка промяна става голяма.
 Нека сега да пренапишем функцията, използвайки колкото се може повече абстракция.
 
 :middle_slide
 
-Добро - `[do(X)]`
+Добро - [`do(X)`]
 
 :code_cpp
 bool tryReadCoordinates(int& x, int& y) {
@@ -233,9 +233,9 @@ void tryTakeTile(char** board, int rows, int cols,
 
 
 
-Искаме трето измерение на `[board]`?
-Няма проблем, написали сме нова `[tryReadCoordinates]`, която приема три променливи, и в `[tryTakeTile]` добавяме една декларация и обновяваме двете индексирания на `[board]`.
-Ако `[emptyRow]` стане друг тип данна, просто променяме функцията да бъде `[appendToOtherDataType]` и сме готови.
+Искаме трето измерение на [`board`]?
+Няма проблем, написали сме нова [`tryReadCoordinates`], която приема три променливи, и в [`tryTakeTile`] добавяме една декларация и обновяваме двете индексирания на [`board`].
+Ако [`emptyRow`] стане друг тип данна, просто променяме функцията да бъде [`appendToOtherDataType`] и сме готови.
 
 И ако тази промяна трябва да се направи в много функции, даже бихме могли да употребяваме функционалност на самия текстов редактор да търси и заменя срещания на един низ с друг.
 
@@ -244,7 +244,7 @@ void tryTakeTile(char** board, int rows, int cols,
 
 :slide
 
-Лошо - всички цикли са `[doX()]`
+Лошо - всички цикли са [`doX()`]
 
 ```cpp
 void generateLayer(char** layer, int rows, int cols,
@@ -272,15 +272,15 @@ void generateLayer(char** layer, int rows, int cols,
 Този сегмент е по-интересен за променяне от преди, понеже за да го направим хубаво трябва да променим самата ни логика.
 Запълването със шпации е ясно, обаче случайното поставяне на плочки не е.
 
-Ако имаме функция `[placeRandomЕлемент]` която само поставя една плочка в слоя, пак ще имаме вложени цикли, трябва да има начин да останем с един цикъл.
-Ако направим `[placeRandomElementNTimes]`, тогава пък абстрахираната функция става твърде специфична и вече имаме `[doX()]` при самата нея.
+Ако имаме функция [`placeRandomЕлемент`] която само поставя една плочка в слоя, пак ще имаме вложени цикли, трябва да има начин да останем с един цикъл.
+Ако направим [`placeRandomElementNTimes`], тогава пък абстрахираната функция става твърде специфична и вече имаме [`doX()`] при самата нея.
 
 Чрез функционално програмиране този проблем може да се разреши лесно, обаче вие ще го учите следващия семестър.
 С достатъчно размишления, може да стигнем до следния вариант: вместо всяка плочка да я поставяме на случайна позиция, защо не поставим всички плочки една след друга и не разбъркаме слоя?
 
 :middle_slide
 
-Добро - `[do(X)]`
+Добро - [`do(X)`]
 
 ```cpp
 void generateLayer(char** layer, int rows, int cols,
@@ -296,7 +296,7 @@ void generateLayer(char** layer, int rows, int cols,
     shuffleMatrix(layer, rows, cols);
 }
 
-=[Бонус:]= работи по-коректно от преди
+[=Бонус:=] работи по-коректно от преди
 
 
 В предходния вариант, ако примерно цялата е пълна освен една клетка, и трябва да поставим една финална плочка, тогава трябва да чакаме докато случайните стойности се напаснат точно с координатите на тази една клетка.
@@ -304,14 +304,14 @@ void generateLayer(char** layer, int rows, int cols,
 Даже, този проблем става все по-тегав с времето: с всяка запълнена клетка, шанса случайните стойности да ударят на заети координати се увеличава.
 
 Докато тук, нямаме този проблем, отнема някакво консистентно предопределено време да разбъркаме матрицата.
-Как имплементираме `[shuffleMatrix]` си има и своите тънкости, но най-елементарния начин е просто да направим сортираш алгоритъм, при който вместо да сравним две стойности, използваме случайна стойност, която определя дали ще разменим плочките.
+Как имплементираме [`shuffleMatrix`] си има и своите тънкости, но най-елементарния начин е просто да направим сортираш алгоритъм, при който вместо да сравним две стойности, използваме случайна стойност, която определя дали ще разменим плочките.
 
 Друго хубаво нещо на решения с абстракция, е един лек лавинен ефект, където веднъж като почнем да мислим за абстракции, намираме къде да ги ползваме навсякъде.
 Да разгледаме същата функция, обаче при D подточка.
 
 :middle_slide
 
-Решения със слоеве правят същото. Лошо - `[doX()]` при циклите:
+Решения със слоеве правят същото. Лошо - [`doX()`] при циклите:
 
 ```cpp
 void generate(char*** board, int rows, int cols, int layers,
@@ -325,13 +325,13 @@ void generate(char*** board, int rows, int cols, int layers,
 }
 
 
-Без абстракция отново ще пренапишем голяма част от `[generate]` функцията, за да се побере на слайда съм оставил само "най-сложната" промяна - случайните стойности.
-Пак, имаше решения на подточката, без преизползване на `[generate]` за един слой.
-Айде да разгледаме решението, заедно с абстрахираната `[generate]`.
+Без абстракция отново ще пренапишем голяма част от [`generate`] функцията, за да се побере на слайда съм оставил само "най-сложната" промяна - случайните стойности.
+Пак, имаше решения на подточката, без преизползване на [`generate`] за един слой.
+Айде да разгледаме решението, заедно с абстрахираната [`generate`].
 
 :slide
 
-Добро - `[do(X)]`
+Добро - [`do(X)`]
 
 ```cpp
 void generateLayer(char** layer, int rows, int cols,
@@ -357,14 +357,14 @@ void generate(char*** board, int rows, int cols, int layers,
 Супер елементарно, има-няма 5-6 реда код промяна, при генериране за всеки слой, просто извикваме функцията за генериране върху един слой, за всеки слой.
 А в самата функция само премахваме броя вмъкнати плочки от сумата на даден тип.
 
-Наблюдателните са забелязали, че в "ръчното" решение слоевете са третия индекс, тоест имаме `[board[x][y][layer]]`, докато в това решение е първия, тоест `[board[layer][x][y]]`.
+Наблюдателните са забелязали, че в "ръчното" решение слоевете са третия индекс, тоест имаме [`board[x][y][layer]`], докато в това решение е първия, тоест [`board[layer][x][y]`].
 Разликата е значителна, но от гледна точка на код, особено когато използваме абстракция, промяната е лесна.
 
 Иначе, в момента се намираме в много добра позиция, без абстракция как правим рестартирането на играта?
 По условие броя и типовете плочки трябва да се запазят, но позиции не.
 Истината е, че става малко тромаво: цикълът за намираме на позиции се преизползва, и броя плочки трябва да се запази.
 
-Обаче, сега това става с едно `[shuffleMatrix]`, не е нужно нищо специално да правим!
+Обаче, сега това става с едно [`shuffleMatrix`], не е нужно нищо специално да правим!
 
 :middle_slide35
 
@@ -372,7 +372,7 @@ void generate(char*** board, int rows, int cols, int layers,
 
 .unordered
 - Целта на коментарите е да направи разбиране и модификация на код по-лесни.
-- В повечето случаи, коментарът трябва да ни дава *[нова]* информация или да *[свърже]* парчета информация
+- В повечето случаи, коментарът трябва да ни дава [*нова*] информация или да [*свърже*] парчета информация
 
 
 Да разгледаме следния пример.
@@ -401,7 +401,7 @@ for (int i = 0; i < rows; i++) {
 }
 
 
-При добрия вариант, получаваме нова информация, че това запълване се случва понеже ще подаваме към някаква си `[functionX]`, и че евентуално може да има други функции, при които празни клетки може да не се обозначават с `['\0']`.
+При добрия вариант, получаваме нова информация, че това запълване се случва понеже ще подаваме към някаква си [`functionX`], и че евентуално може да има други функции, при които празни клетки може да не се обозначават с [`'\0'`].
 В лошия можем да стигнем до същото заключение като погледнем самия код.
 
 :comment
@@ -424,7 +424,7 @@ for (int i = 0; i < rows; i++) {
 
 
 
-Умението да разрешиш един проблем *[не те]* прави добър програмист, да го разрешиш по четим, разширяем, лесен, ефикасен, ... начин *[те]* прави добър програмист.
+Умението да разрешиш един проблем [*не те*] прави добър програмист, да го разрешиш по четим, разширяем, лесен, ефикасен, ... начин [*те*] прави добър програмист.
 
 :slide35
 
diff --git a/src/teaching/oop-2023/week1/index.du b/src/teaching/oop-2023/week1/index.du
index b6d678b..f229343 100644
--- a/src/teaching/oop-2023/week1/index.du
+++ b/src/teaching/oop-2023/week1/index.du
@@ -11,7 +11,7 @@ GitHub classroom: [url https://classroom.github.com/a/UPJOzHty classroom.github.
 Имплементирайте низ чрез структура.
 В структурата трябва да запазвате указател към низа и неговата дължина.
 
-Имплементирайте функция `[concatString]`, която приема две структури от този тип и връща низ, пак в същата структура, който е конкатенация (слепване) на първите два низа.
+Имплементирайте функция [`concatString`], която приема две структури от този тип и връща низ, пак в същата структура, който е конкатенация (слепване) на първите два низа.
 
 .question Има ли значение дали типовете на аргументите, или на върнатата стойност, са референции или указатели (или нито едното)?
 
@@ -26,9 +26,9 @@ GitHub classroom: [url https://classroom.github.com/a/UPJOzHty classroom.github.
 
 Заделянето на динамична памет е бавна операция, затова винаги ще заделяме повече клетки, отколкото са ни нужни.
 
-Имплементирайте функция `[resize]`, която удвоява размера на масива (нека първоначалния размер на масива е 2), на подадена стойност от тип вашата структура.
+Имплементирайте функция [`resize`], която удвоява размера на масива (нека първоначалния размер на масива е 2), на подадена стойност от тип вашата структура.
 
-Имплементирайте функция `[addToEnd]`, която приема (инстанция на) структурата ви и вмъква елемент в първата незаета позиция.
+Имплементирайте функция [`addToEnd`], която приема (инстанция на) структурата ви и вмъква елемент в първата незаета позиция.
 
 В самия код тествайте функциите (не е нужен потребителски вход).
 
@@ -41,11 +41,11 @@ GitHub classroom: [url https://classroom.github.com/a/UPJOzHty classroom.github.
 Всички типове данни са целочислени.
 
 От входа получавате N, броя пакети, които трябва да запазите, и след това 5N на брой целочислени стойности.
-Накрая получавате буква: `[t]`, `[p]`, `[h]`, `[e]`, всяка съответства на някоя отделна стойност от датчиците.
+Накрая получавате буква: [`t`], [`p`], [`h`], [`e`], всяка съответства на някоя отделна стойност от датчиците.
 
 Трябва да изкарате на екрана всичките стойности от пакетите, подредени в нарастващ ред на времето, като всички след първата са разликите им спрямо първата.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -81,11 +81,11 @@ p
 От входа получавате N, това определя броя полети, които трябва да се добавят в системата.
 Всеки полет е редица от 5 стойности, в реда в който са дефинирани.
 
-*[Напомням, че това е нагласено да ползвате `[std::cin]` вместо ръчно да обработвате целия ред.]*
+[*Напомням, че това е нагласено да ползвате [`std::cin`] вместо ръчно да обработвате целия ред.*]
 
 Изкарайте началните и крайните градове, както и цената на полетите, подредени в нарастващ ред на час на излитане.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -119,7 +119,7 @@ Paris NewYork 500
 Прикачване между полети е позволено, така че под "вариант" трябва да изкарате всичките полети, които са решение.
 За един полет е нужно да изкарате само началния град, крайния град, час на излитане и цена, като градовете трябва да са подредени в нарастващ ред на часа на излитане.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -148,7 +148,7 @@ Sofia NewYork 0610 800
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise5.cpp Решение]
 
-Имате система за потребители, всеки потребител си има име и приятели (един приятел е =[указател към потребител]=).
+Имате система за потребители, всеки потребител си има име и приятели (един приятел е [=указател към потребител=]).
 
 В началото се въвежда N, това е броят потребители в системата.
 За един потребител, първо се въвежда на нов ред името му, след това броя на неговите приятели и накрая, на отделни редове, имената на всички тези приятели.
@@ -156,7 +156,7 @@ Sofia NewYork 0610 800
 Накрая получавате едно име, това е началния потребител.
 Трябва да намерите, започвайки от него, с колко други потребителя има някаква приятелска връзка (директна, приятел на приятел, приятел на приятел на приятел, ...).
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/oop-2023/week1/organization.du b/src/teaching/oop-2023/week1/organization.du
index 40abea9..3732566 100644
--- a/src/teaching/oop-2023/week1/organization.du
+++ b/src/teaching/oop-2023/week1/organization.du
@@ -39,9 +39,9 @@
 :middle_slide35
 
 :unordered
-- Зачитат се =[единствено нещата, качени в GitHub classroom, качени в срок]=
+- Зачитат се [=единствено нещата, качени в GitHub classroom, качени в срок=]
   .unordered
-  - До =[15]= минути след края на часа
+  - До [=15=] минути след края на часа
 
 - Както преди, не е нужно да присъствате, за да качвате решения
 - Ако случайно някой не знае как се ползва:
diff --git a/src/teaching/oop-2023/week10/index.du b/src/teaching/oop-2023/week10/index.du
index dfff7fc..d36406b 100644
--- a/src/teaching/oop-2023/week10/index.du
+++ b/src/teaching/oop-2023/week10/index.du
@@ -12,7 +12,7 @@ GitHub classroom: [url https://classroom.github.com/a/PbkITWhF classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise01 Решение]
 
-Реализирайте шаблонен клас `[Array]`, който запазва динамично-заделен и оразмеряем масив от елементи с подаден тип.
+Реализирайте шаблонен клас [`Array`], който запазва динамично-заделен и оразмеряем масив от елементи с подаден тип.
 Имплементирайте голяма четворка.
 
 ### Задача 2 - Оператори
@@ -32,7 +32,7 @@ GitHub classroom: [url https://classroom.github.com/a/PbkITWhF classroom.github.
 
 Имплементирайте функция, която приема име на текстов файл и изкарва на екрана първия ред от него.
 Ако файлът не може да бъде отворен, хвърлете грешка - низ.
-Ако във файлът няма други редове (няма знакът `['\\n']`), тогава хвърлете грешка число - размерът на файла.
+Ако във файлът няма други редове (няма знакът [`'\\n'`]), тогава хвърлете грешка число - размерът на файла.
 
 В главната функция, приемете името на файла от потребителския вход и извикайте функцията.
 Ако файлът не може да бъде отворен, тогава изкарайте хвърлената грешка на терминала и приключете програмата (успешно).
@@ -44,69 +44,69 @@ GitHub classroom: [url https://classroom.github.com/a/PbkITWhF classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise04 Решение]
 
-Реализирайте клас `[Time24]`, който запазва час и минути (в 24-часов формат) в две отделни целичислени член-данни.
-Имплементирайте член-функция `[Print24]`, която изкарва часа на екрана в 24-часов формат.
+Реализирайте клас [`Time24`], който запазва час и минути (в 24-часов формат) в две отделни целичислени член-данни.
+Имплементирайте член-функция [`Print24`], която изкарва часа на екрана в 24-часов формат.
 Нека конструкторът му приема две целочислени променливи, една за часа и втора за минутите.
 
-Реализирайте негов наследник `[Time12]`, който имплементира метод `[Print12]`, принтиращ часа в 12-часов формат.
+Реализирайте негов наследник [`Time12`], който имплементира метод [`Print12`], принтиращ часа в 12-часов формат.
 Имплементирайте и негов конструктор, който приема две целочислени променливи (една за часа и една за минутите), заедно с булева променлива описваща дали часа е следобеден или не.
 
 ### Задача 5
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise05 Решение]
 
-Реализирайте клас `[FN]`, който запазва факултетен номер като неотрицателно цяло число от 5 цифри.
-Реализирайте негов наследник `[ModernFN]`, който запазва и начален (префиксен) низ, състоящ се от цифра, две букви и още две цифри.
+Реализирайте клас [`FN`], който запазва факултетен номер като неотрицателно цяло число от 5 цифри.
+Реализирайте негов наследник [`ModernFN`], който запазва и начален (префиксен) низ, състоящ се от цифра, две букви и още две цифри.
 
-Имплементирайте конструктори, като този на `[FN]` приема число, докато този на `[ModernFN]` приема низ, състоящ се от целия факултетен номер (и трябва да конвертирате последните 5 цифри към число).
-Имплементирайте метод `[PrintOldFN]` на класа `[FN]` и метод `[PrintNewFN]` на класа `[ModernFN]`, които изкарват целия факултетен номер на съответния клас.
+Имплементирайте конструктори, като този на [`FN`] приема число, докато този на [`ModernFN`] приема низ, състоящ се от целия факултетен номер (и трябва да конвертирате последните 5 цифри към число).
+Имплементирайте метод [`PrintOldFN`] на класа [`FN`] и метод [`PrintNewFN`] на класа [`ModernFN`], които изкарват целия факултетен номер на съответния клас.
 
 ### Задача 6
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise06 Решение]
 
-Реализирайте клас `[Grade]`, който запазва оценка (от 2 до 6) като неотрицателна целочислена член-данна.
-Реализирайте и негов наследник `[GradeWithName]`, който запазва и името на оценката като низ с произволна дължина.
+Реализирайте клас [`Grade`], който запазва оценка (от 2 до 6) като неотрицателна целочислена член-данна.
+Реализирайте и негов наследник [`GradeWithName`], който запазва и името на оценката като низ с произволна дължина.
 
-Конструктора на `[Grade]` приема само числовата стойност, докато този на наследника приема и името на оценката.
-Имплементирайте голяма петица на `[GradeWithName]`.
+Конструктора на [`Grade`] приема само числовата стойност, докато този на наследника приема и името на оценката.
+Имплементирайте голяма петица на [`GradeWithName`].
 
 ### Задача 7
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise07 Решение]
 
-Реализирайте клас `[String]`, който запазва низ с произволна дължина.
-Имплементирайте голяма петица и член-функция `[At]`, която приема индекс и връща референция към буквата на този индекс (при невалиден индекс хвърляте грешка).
+Реализирайте клас [`String`], който запазва низ с произволна дължина.
+Имплементирайте голяма петица и член-функция [`At`], която приема индекс и връща референция към буквата на този индекс (при невалиден индекс хвърляте грешка).
 
-Реализирайте негов наследник `[FileString]`, който запазва и името на текстов файл като низ с произволна дължина.
+Реализирайте негов наследник [`FileString`], който запазва и името на текстов файл като низ с произволна дължина.
 Ако е нужно, имплементирайте голяма петица.
 
-Самия низ в `[FileString]` е първия низ (начало първата буква и край `['\\n']`) от файла с подадено име.
+Самия низ в [`FileString`] е първия низ (начало първата буква и край [`'\\n'`]) от файла с подадено име.
 
-Имплементирайте метод `[ChangeAt]`, който приема индекс и нова буква, променя буквата на дадения индекс с подадената и обновява файла със запазеното име.
+Имплементирайте метод [`ChangeAt`], който приема индекс и нова буква, променя буквата на дадения индекс с подадената и обновява файла със запазеното име.
 
 ### Задача 8
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise08 Решение]
 
-Реализирайте клас `[User]`, който запава име и парола като два низа с произволна дължина.
-Реализирайте негов наследник `[Moderator]`, който запазва и подпис, който също е низ с произволна дължина.
-Реализирайте наследник `[Administrator]` на `[Moderator]`, който запазва и оразмеряващ се масив от цели числа.
+Реализирайте клас [`User`], който запава име и парола като два низа с произволна дължина.
+Реализирайте негов наследник [`Moderator`], който запазва и подпис, който също е низ с произволна дължина.
+Реализирайте наследник [`Administrator`] на [`Moderator`], който запазва и оразмеряващ се масив от цели числа.
 
 Идеята е, че всяко действие от модератор или администратор се "подписва" публично (за да се знае, че той го е направил, дори да си смени името), а за администратор допълнително пазим масив от идентификатори на форуми, които администрира.
 
 За всеки клас имплементирайте голяма петица и гетъри и сетъри за името и паролата, когато е нужно.
-За `[Moderator]` имплементирайте гетър за подписа, но без сетър.
-За `[Administrator]` имплементирайте методи за добавяне и премахване на идентификатор на форум.
+За [`Moderator`] имплементирайте гетър за подписа, но без сетър.
+За [`Administrator`] имплементирайте методи за добавяне и премахване на идентификатор на форум.
 
 ### Задача 9
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise09 Решение]
 
-Реализирайте клас `[CommunicationPacket]`, който запазва начален и краен адрес като две неотрицателни цели числа, заедно с трето число за размера на данните.
+Реализирайте клас [`CommunicationPacket`], който запазва начален и краен адрес като две неотрицателни цели числа, заедно с трето число за размера на данните.
 В този клас никога няма данни, затова размера винаги е нула.
 
-Реализирайте негови наследници `[StringPacket]` и `[IntPacket]`, където първия запазва и низ с произволна дължина (и дължината му е размера на данните) докато втория запазва и едно цяло число (и размера на `[int]` е размера на данните).
+Реализирайте негови наследници [`StringPacket`] и [`IntPacket`], където първия запазва и низ с произволна дължина (и дължината му е размера на данните) докато втория запазва и едно цяло число (и размера на [`int`] е размера на данните).
 
 Размерът не се подава на конструктори, а се изчислява в конструктори.
 Имплементирайте голяма петица и конструктори с нужните параметри.
@@ -115,12 +115,12 @@ GitHub classroom: [url https://classroom.github.com/a/PbkITWhF classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week10/Exercise10 Решение]
 
-Реализирайте клас `[String]`, който запазва низ с произволна дължина, и имплементира оператори ==, !=, + (който връща нов низ с конкатенацията на двата низа).
+Реализирайте клас [`String`], който запазва низ с произволна дължина, и имплементира оператори ==, !=, + (който връща нов низ с конкатенацията на двата низа).
 
-Реализирайте негов наследник `[ModifiableString]`, който имплементира оператор[] &#20;(връщащ референция към буквата на дадения индекс) и оператор+=.
+Реализирайте негов наследник [`ModifiableString`], който имплементира оператор[] &#20;(връщащ референция към буквата на дадения индекс) и оператор+=.
 
-Реализирайте наследник на `[ModifiableString]`, `[ShowableString]`, който имплементира оператори << и >>.
-Реализирайте наследник на `[ModifiableString]`, `[SaveableString]`, който имплементира методи write и read, приемащи име на двоичен файл и записващи или четещи низа от този файл.
+Реализирайте наследник на [`ModifiableString`], [`ShowableString`], който имплементира оператори << и >>.
+Реализирайте наследник на [`ModifiableString`], [`SaveableString`], който имплементира методи write и read, приемащи име на двоичен файл и записващи или четещи низа от този файл.
 
 За всички класове имплементирайте голяма петица, когато е нужно.
 
@@ -128,23 +128,23 @@ GitHub classroom: [url https://classroom.github.com/a/PbkITWhF classroom.github.
 
 ### Задача 11
 
-Реализирайте шаблонен клас `[Array]`, който запазва оразмеряем масив с елементи от подаден тип.
-Имплементирайте оператор== и оператор!=, заедно с метод `[isEmpty]`.
+Реализирайте шаблонен клас [`Array`], който запазва оразмеряем масив с елементи от подаден тип.
+Имплементирайте оператор== и оператор!=, заедно с метод [`isEmpty`].
 Концептуално идеята е, че този масив не може да се променя след като му се въведат стойностите от конструктора.
 
-Реализирайте негов наследник `[PrintableArray]`, който имплементира оператори << и >>.
-Реализирайте наследник `[SaveableArray]` на `[Array]`, който имплементира методи write и read, приемащи име на файл и булева стойност дали е двоичен или не, и съответно прочитат или запазват елементите от този масив във файла.
+Реализирайте негов наследник [`PrintableArray`], който имплементира оператори << и >>.
+Реализирайте наследник [`SaveableArray`] на [`Array`], който имплементира методи write и read, приемащи име на файл и булева стойност дали е двоичен или не, и съответно прочитат или запазват елементите от този масив във файла.
 
-Реализирайте трети наследник, `[ModifiableArray]`, на `[Array]`, в който са имплементирани член-функции:
+Реализирайте трети наследник, [`ModifiableArray`], на [`Array`], в който са имплементирани член-функции:
 
 .unordered
-- `[push]`, която приема елемент и го вмъква в (десния) края на масива
-- `[pop]`, който премахва елемент от (десния) края на масива
-- `[last]`, който връща последния елемент от масива
+- [`push`], която приема елемент и го вмъква в (десния) края на масива
+- [`pop`], който премахва елемент от (десния) края на масива
+- [`last`], който връща последния елемент от масива
 
 Може да се налага масива да се оразмерява.
 Като подсказка, имплементирайте си метод, наличен за класа и наследници, който вмъква елемент на произволен индекс.
 
-Реализирайте наследник `[IndexableArray]` на `[ModifiableArray]`, който имплементира оператор[].
+Реализирайте наследник [`IndexableArray`] на [`ModifiableArray`], който имплементира оператор[].
 Ако индекса е след края, тогава "вмъквате" елементи по подразбиране между края и подадения индекс, и връщате елемента от сега новия край.
-Реализирайте наследник `[FrontableArray]` на `[ModifiableArray]`, който имплементира методи `[pushf]` и `[popf]`, които работят като `[push]` и `[pop]`, но с елемента в началото на масива (първия елемент).
+Реализирайте наследник [`FrontableArray`] на [`ModifiableArray`], който имплементира методи [`pushf`] и [`popf`], които работят като [`push`] и [`pop`], но с елемента в началото на масива (първия елемент).
diff --git a/src/teaching/oop-2023/week11/index.du b/src/teaching/oop-2023/week11/index.du
index 5fd580b..295c2de 100644
--- a/src/teaching/oop-2023/week11/index.du
+++ b/src/teaching/oop-2023/week11/index.du
@@ -8,7 +8,7 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .warn Моля, не отделяйте на преговорните задачи повече от 30мин
 
-.important Всеки бащин клас, във всички случаи, трябва да има виртуален деструктор (`[virtual ~ClassName();]`).
+.important Всеки бащин клас, във всички случаи, трябва да има виртуален деструктор ([`virtual ~ClassName();`]).
 
 ### Задача 1 - Шаблони и оператори
 
@@ -17,21 +17,21 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 Реализирайте шаблонен клас множество, който запазва фиксиран брой елементи от подаден тип.
 Реализирайте голяма петица и оператори:
 .bulleted
-- `[+]`, `[+=]` които действат като обединение
-- `[*]`, `[*=]` които действат като сечение
-- `[-]`, `[-=]` които действат като допълнение
+- [`+`], [`+=`] които действат като обединение
+- [`*`], [`*=`] които действат като сечение
+- [`-`], [`-=`] които действат като допълнение
 
 ### Задача 2 - Наследяване
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week11/Exercise02 Решение]
 
-Реализирайте клас `[Employee]`, съхраняващ име на човек, позиция и департамент като низове със съответно дължина 512, 128 и 64, заедно със заплата като число с плаваща запетая.
+Реализирайте клас [`Employee`], съхраняващ име на човек, позиция и департамент като низове със съответно дължина 512, 128 и 64, заедно със заплата като число с плаваща запетая.
 
-Реализирайте негов наследник `[Manager]`, който допълнително пази масив с фиксиран размер от Employee.
+Реализирайте негов наследник [`Manager`], който допълнително пази масив с фиксиран размер от Employee.
 
-Реализирайте наследника на `[Employee]`, `[Developer]`, който допълнително пази брой проекти върху който работи.
+Реализирайте наследника на [`Employee`], [`Developer`], който допълнително пази брой проекти върху който работи.
 
-Наследниците не могат да достъпят заплатата, но трябва да могат да достъпят другите данни на `[Employee]`.
+Наследниците не могат да достъпят заплатата, но трябва да могат да достъпят другите данни на [`Employee`].
 
 ## Лесни
 
@@ -41,17 +41,17 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Динамично свързване, Inherit 3
 
-Реализирайте клас `[Electronics]`, който съдържа модел (низ с максимална дължина от 255 знака), `[needsVolts]` и `[needsAmps]` (стойности с плаваща запетая).
+Реализирайте клас [`Electronics`], който съдържа модел (низ с максимална дължина от 255 знака), [`needsVolts`] и [`needsAmps`] (стойности с плаваща запетая).
 
 Имплементирайте негови наследници:
 .bulleted
-- `[Laptop]`, който допълнително съхранява размер на екрана като число с плаваща запетая
-- `[WashingMachine]`, който допълнително запазва максимално тегло на прането, като цяло неотрицателно число
-- `[Camera]`, която допълнително запазва резолюция като число с плаваща запетая (в мегапиксели)
+- [`Laptop`], който допълнително съхранява размер на екрана като число с плаваща запетая
+- [`WashingMachine`], който допълнително запазва максимално тегло на прането, като цяло неотрицателно число
+- [`Camera`], която допълнително запазва резолюция като число с плаваща запетая (в мегапиксели)
 
-За всеки клас реализирайте член-функция `[Print]`, която изкарва всички данни на екрана.
+За всеки клас реализирайте член-функция [`Print`], която изкарва всички данни на екрана.
 
-&:question Чрез статично или динамично свързване сте имплементирали `[Print]`? Каква е разликата?
+&:question Чрез статично или динамично свързване сте имплементирали [`Print`]? Каква е разликата?
 
 ### Задача 4
 
@@ -59,19 +59,19 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Dynamic linking, Inherit 2
 
-Реализирайте клас `[String]`, който запазва динамично-заделен масив.
+Реализирайте клас [`String`], който запазва динамично-заделен масив.
 
-Имплементирайте негов наследник `[Name]`, който допълнително запазва число: номер на името (първо име, бащино име (второ име), фамилия (трето име)).
+Имплементирайте негов наследник [`Name`], който допълнително запазва число: номер на името (първо име, бащино име (второ име), фамилия (трето име)).
 
-Имплементирайте втори наследник на `[String]`, `[Street]`, който запазва и число: номер на улицата.
+Имплементирайте втори наследник на [`String`], [`Street`], който запазва и число: номер на улицата.
 
-Във всеки клас имплементирайте голяма петица, член-функция `[Length]`, като:
+Във всеки клас имплементирайте голяма петица, член-функция [`Length`], като:
 .bulleted
-- в `[String]` връща дължината на низа,
-- в `[Name]` връща дължината на името умножена по номера си и
-- в `[Street]` връща дължината на името на улицата плюс броя цифри в номера на улицата.
+- в [`String`] връща дължината на низа,
+- в [`Name`] връща дължината на името умножена по номера си и
+- в [`Street`] връща дължината на името на улицата плюс броя цифри в номера на улицата.
 
-Самият низ в `[String]` =[не]= може да се достъпва от наследниците.
+Самият низ в [`String`] [=не=] може да се достъпва от наследниците.
 
 ### Задача 5
 
@@ -79,8 +79,8 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Templates 1 type
 
-Реализирайте шаблонен клас `[Counted]`, който запазва елемент от подаден тип и неговата бройка (цяло неотрицателно число).
-Имплементирайте оператори `[++]`, `[--]`, `[+=]`, `[-=]`, които променят бройката, както и гетъри за елемента и бройката.
+Реализирайте шаблонен клас [`Counted`], който запазва елемент от подаден тип и неговата бройка (цяло неотрицателно число).
+Имплементирайте оператори [`++`], [`--`], [`+=`], [`-=`], които променят бройката, както и гетъри за елемента и бройката.
 
 ### Задача 6
 
@@ -88,14 +88,14 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Templates 2 types
 
-Реализирайте шаблонен клас `[TwoArray]`, който запазва два динамично-заделени масива с подадени типове.
+Реализирайте шаблонен клас [`TwoArray`], който запазва два динамично-заделени масива с подадени типове.
 Масивите не могат да се оразмеряват и имат еднаква дължина.
 
 Имплементирайте:
 .bulleted
 - голяма петица,
-- оператор `[[]]`, който по подаден индекс връща елемент от първия масив, и
-- оператор `[()]`, който по подаден индекс връща елемент от втория масив.
+- оператор [`[]`], който по подаден индекс връща елемент от първия масив, и
+- оператор [`()`], който по подаден индекс връща елемент от втория масив.
 
 ### Задача 7
 
@@ -103,29 +103,29 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Abstract class
 
-Реализирайте абстрактен клас `[DynamicArray]`, който задължава наследниците да имплементират оператор `[[]]` и оператор `[+=]`.
+Реализирайте абстрактен клас [`DynamicArray`], който задължава наследниците да имплементират оператор [`[]`] и оператор [`+=`].
 
 Реализирайте негови наследници:
 
 :unordered
-- `[Numbers]`, който "имплементира" динамично-заделен масив от цели числа, като
+- [`Numbers`], който "имплементира" динамично-заделен масив от цели числа, като
 
   .bulleted
-  - оператор `[[]]` връща първия елемент, по-малък от подадения индекс. Ако няма такъв, връщате първия елемент.
-  - оператор `[+=]` вмъква елементите в началото на масива
+  - оператор [`[]`] връща първия елемент, по-малък от подадения индекс. Ако няма такъв, връщате първия елемент.
+  - оператор [`+=`] вмъква елементите в началото на масива
 
-- `[String]`, който "имплементира" динамично-заделен масив от букви, като
+- [`String`], който "имплементира" динамично-заделен масив от букви, като
 
   .bulleted
-  - оператор `[[]]` връща индекс на брой (първата, втората, ...) главна буква в низа. Ако няма такава, тогава връща последната буква.
-  - оператор `[+=]` вмъква елементите в края на масива
+  - оператор [`[]`] връща индекс на брой (първата, втората, ...) главна буква в низа. Ако няма такава, тогава връща последната буква.
+  - оператор [`+=`] вмъква елементите в края на масива
 
 
 Имплементирайте голяма петица.
 
 .question Къде ще имплементирате динамичния масив и голямата петица?
 
-.question Можем ли да използваме оператор `[+=]` в полиморфна йерархия?
+.question Можем ли да използваме оператор [`+=`] в полиморфна йерархия?
 
 ### Задача 8
 
@@ -133,33 +133,33 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 .comment Abstract class
 
-Имплементирайте абстрактен клас `[Message]`, който съдържа динамично-заделен низ (текстово съобщение, което се показва на екрана) и задължава наследниците да имплементират:
+Имплементирайте абстрактен клас [`Message`], който съдържа динамично-заделен низ (текстово съобщение, което се показва на екрана) и задължава наследниците да имплементират:
 .unordered
-- метод `[size]`, който връща общия размер на всички данни в байтове.
+- метод [`size`], който връща общия размер на всички данни в байтове.
 
-Реализирайте негов наследник `[Link]` (хипервръзка), който запазва и втори динамично-заделен низ, запазващ адресът към който линкът сочи.
+Реализирайте негов наследник [`Link`] (хипервръзка), който запазва и втори динамично-заделен низ, запазващ адресът към който линкът сочи.
 
-Реализирайте втори негов наследник `[Location]`, чието текстово съдържание е адрес, и който допълнително запазва две стойности с плаваща запетая: една за географска ширина и втора за географска дължина.
+Реализирайте втори негов наследник [`Location`], чието текстово съдържание е адрес, и който допълнително запазва две стойности с плаваща запетая: една за географска ширина и втора за географска дължина.
 
-За всички класове реализирайте член-функция `[Length]`, която връща размера на =[текстовото съобщение]= и оператор `[<<]`.
+За всички класове реализирайте член-функция [`Length`], която връща размера на [=текстовото съобщение=] и оператор [`<<`].
 
-.question Има ли разлика между оператор `[<<]` на трите класа?
+.question Има ли разлика между оператор [`<<`] на трите класа?
 
 ### Задача 9
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week11/Exercise09 Решение]
 
-Реализирайте абстрактен шаблонен клас `[MixedArray]`, който съхранява алтерниращи елементи от два типа.
+Реализирайте абстрактен шаблонен клас [`MixedArray`], който съхранява алтерниращи елементи от два типа.
 Тоест, на индекс 0 имаме елемент от първия тип, на индекс 1 от втория, на индекс 2 от първи и так. нат.
 
-Елементите не е нужно да могат да се конвертират помежду си (тоест не може да използвате полиморфен контейнер), затова се достъпват с член функция `[At]`, приемаща индекс и референции към указатели към всеки тип.
-При подаден индекс, на единия указател се записва адресът на съответната стойност, а на другия `[nullptr]`.
+Елементите не е нужно да могат да се конвертират помежду си (тоест не може да използвате полиморфен контейнер), затова се достъпват с член функция [`At`], приемаща индекс и референции към указатели към всеки тип.
+При подаден индекс, на единия указател се записва адресът на съответната стойност, а на другия [`nullptr`].
 
-Също имплементира голяма петица и задължава наследниците да имплементират оператори `[+=]`, върщащи указател.
+Също имплементира голяма петица и задължава наследниците да имплементират оператори [`+=`], върщащи указател.
 
-Реализирайте негов наследник `[DirectConcat]`, който реализира `[+=]` като директно слепване (конкатениране).
+Реализирайте негов наследник [`DirectConcat`], който реализира [`+=`] като директно слепване (конкатениране).
 
-Реализирайте втори негов наследник, `[MixedConcat]`, който реализир `[+=]` като алтернира елемент от първия масив с елемент от втория.
+Реализирайте втори негов наследник, [`MixedConcat`], който реализир [`+=`] като алтернира елемент от първия масив с елемент от втория.
 
 ## Трудни
 
@@ -183,7 +183,7 @@ GitHub classroom: [url https://classroom.github.com/a/oYQehcnN classroom.github.
 
 Имплементирайте клас Document, който запазва масив от Node-ове и за който са имплементирани:
 .bulleted
-- методи save и load, които запазват и четат цялото съдържание на документа в =[текстов]= файл с произволен формат.
+- методи save и load, които запазват и четат цялото съдържание на документа в [=текстов=] файл с произволен формат.
 
 ### Задача 11
 
diff --git a/src/teaching/oop-2023/week12/index.du b/src/teaching/oop-2023/week12/index.du
index b0384e5..537e03b 100644
--- a/src/teaching/oop-2023/week12/index.du
+++ b/src/teaching/oop-2023/week12/index.du
@@ -10,46 +10,46 @@ GitHub classroom: [url https://classroom.github.com/a/o7hNz1pr classroom.github.
 
 .comment Multiple inheritance
 
-Реализирайте клас `[Publication]`, който пази:
+Реализирайте клас [`Publication`], който пази:
 
 .bulleted
 - низ от максимална дължина 1023, съхраняващ автори и
 - втори низ с максимална дължина от 255, съхраняващ име на (научно) списание.
 
-Реализирайте клас `[TextDocument]`, който пази неоразмеряем низ с текстово съдържание и неговия размер.
+Реализирайте клас [`TextDocument`], който пази неоразмеряем низ с текстово съдържание и неговия размер.
 
-Реализирайте наследник на двата класа `[ScientificPaper]`, който допълнително пази и низ от максимално 511 знака, съдържащ име на научна дисциплина.
+Реализирайте наследник на двата класа [`ScientificPaper`], който допълнително пази и низ от максимално 511 знака, съдържащ име на научна дисциплина.
 За всички класове реазлизирайте оператор <<.
 
 ### Задача 2
 
-*[Не говорим за нея, условието беше толкова сбъркано, че се наложи да я сваля]*
+[*Не говорим за нея, условието беше толкова сбъркано, че се наложи да я сваля*]
 
 ### Задача 3
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week12/Exercise3 Решение]
 
-Реализирайте абстрактен клас `[MobileDevice]`, който запазва:
+Реализирайте абстрактен клас [`MobileDevice`], който запазва:
 .bulleted
 - телефонен номер като цяло неотрицателно число и
 - масив с максимална дължина от 511 знака за текстово съобщение.
 
 Допълнително нека:
 .bulleted
-- класът да задължава имплементацията на метод `[Show]`,
-- да има член-функция `[CanAccept]`, която по подадено "хиперсъобщение" връща дали неговия номер съвпада с този на класа.\n
+- класът да задължава имплементацията на метод [`Show`],
+- да има член-функция [`CanAccept`], която по подадено "хиперсъобщение" връща дали неговия номер съвпада с този на класа.\n
   Под "хиперсъобщение" имаме предвид низ, който започва с телефонния номер, след това има шпация и след това е самото съобщение.
-- да има член-функция `[Accept]`, която по подадено "хиперсъобщение" запазва текстовото съобщение.
+- да има член-функция [`Accept`], която по подадено "хиперсъобщение" запазва текстовото съобщение.
   Ако номерът не съответства тогава хвърля грешка.
 
-Реализирайте негов наследник `[Telephone]`, за който `[Show]` изкарва съобщението на екрана.
+Реализирайте негов наследник [`Telephone`], за който [`Show`] изкарва съобщението на екрана.
 
 'footnote pager От времето без мобилни телефони, хората са си купували пейджъри, които ти пращат нотификация ако някой ти звънне и не вдигнеш. Пейджърите са "заключени" за определени региони, тоест някой ти се обажда, не вдигаш, и всички телекомуникционни кули в региона изпращат съобщение "на теб ти звънна този", и пейджъра като засече сигнала ти писука. Мисля че също можеш да пращаш кратки съобщения. Не е било хич сигурна система, все още се ползва от болници в някои държави.
 
-Реализирайте втори негов наследник `[Pager]` [$pager], който съхранява име на файл (като динамично-заделен низ) и `[Show]` изкарва съобщението в съответния файл.
+Реализирайте втори негов наследник [`Pager`] [$pager], който съхранява име на файл (като динамично-заделен низ) и [`Show`] изкарва съобщението в съответния файл.
 Разбира се, имплементирайте голяма петица.
 
-Реализирайте клас `[TelecommunicationCompany]`, който съхранява динамично-заделен и оразмеряем масив от (указатели към) `[MobileDevice]`.
+Реализирайте клас [`TelecommunicationCompany`], който съхранява динамично-заделен и оразмеряем масив от (указатели към) [`MobileDevice`].
 Имплементирайте всичко от голяма петица.
 
 ### Задача 4
@@ -58,40 +58,40 @@ GitHub classroom: [url https://classroom.github.com/a/o7hNz1pr classroom.github.
 
 .comment Multiple inheritance with mixed class types, polymorphic container, and copying
 
-Реализирайте клас `[Employee]`, който запазва:
+Реализирайте клас [`Employee`], който запазва:
 .bulleted
 - заплата като число с плаваща запетая и
 - производителост също като число с плаваща запетая.
 
 Производителността е множител на заплатата, тоест ако има производителност 0.5 значи работи като човек на който му плащат с половината заплата.
 
-Реализирайте абстрактен клас `[Person]`, който запазва: 
+Реализирайте абстрактен клас [`Person`], който запазва: 
 .bulleted
 - име като низ с произволна дължина и
 - възраст като цяло неотрицателно число
 
-Допълнително задължава реализацията на член-функция `[Workload]`, връщаща стойност с плаваща запетая.
+Допълнително задължава реализацията на член-функция [`Workload`], връщаща стойност с плаваща запетая.
 Разбира се имплементирайте голяма петица.
 
-Реализирайте наследник на двата класа на име `[Developer]`, който допълнително запазва:
+Реализирайте наследник на двата класа на име [`Developer`], който допълнително запазва:
 .bulleted
 - цяло неотрицателно число - брой проекти в които участва, и
 - второ което е брой проекти на които ще се пуска нова версия.
 
-Реализирайте оператори `[++]` и `[--]`, като префиксните променят броя проекти на които ще се пуска нова версия, докато постфиксните променя броя проекти в които участва.\n
-За него `[Workload]` се определя като 1.1 по всеки проект и допълнително по 2.3 за всеки проект на който ще се пуска нова версия.
+Реализирайте оператори [`++`] и [`--`], като префиксните променят броя проекти на които ще се пуска нова версия, докато постфиксните променя броя проекти в които участва.\n
+За него [`Workload`] се определя като 1.1 по всеки проект и допълнително по 2.3 за всеки проект на който ще се пуска нова версия.
 
-Реализирайте наследник на двата класа на име `[Manager]`, който допълнително запазва динамично-заделен и оразмеряем масив от `[Person]`, които менижира.
+Реализирайте наследник на двата класа на име [`Manager`], който допълнително запазва динамично-заделен и оразмеряем масив от [`Person`], които менижира.
 
 Имплементирайте голяма петица и:
 .bulleted
-- оператори `[==]` и `[!=]`, сравняващи хора по име
-- член-функция `[StartManaging]`, която приема `[Person]` и го запазва, и
-- член-функция `[StopManaging]`, която приема `[Person]` и го премахва от масива ако съществува в него.
+- оператори [`==`] и [`!=`], сравняващи хора по име
+- член-функция [`StartManaging`], която приема [`Person`] и го запазва, и
+- член-функция [`StopManaging`], която приема [`Person`] и го премахва от масива ако съществува в него.
 
-`[Workload]` се определя като 0.6 на човек който менижира.
+[`Workload`] се определя като 0.6 на човек който менижира.
 
-Финално реализирайте клас `[Company]`, който запазва масив от 128 указателя `[Person]` в компанията.
+Финално реализирайте клас [`Company`], който запазва масив от 128 указателя [`Person`] в компанията.
 Имплементирайте негова член-функция:
 .bulleted
-- `[PaymentDifference]`, която връща с колко платената заплата на всички служители се отличава с тази според тяхната производителност
+- [`PaymentDifference`], която връща с колко платената заплата на всички служители се отличава с тази според тяхната производителност
diff --git a/src/teaching/oop-2023/week13/index.du b/src/teaching/oop-2023/week13/index.du
index 936f34b..5bd0904 100644
--- a/src/teaching/oop-2023/week13/index.du
+++ b/src/teaching/oop-2023/week13/index.du
@@ -12,13 +12,13 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week13/Exercise1 Решение]
 
-Реализирайте клас `[String]`, който запазва динамичен низ с фиксиран размер.
+Реализирайте клас [`String`], който запазва динамичен низ с фиксиран размер.
 
-Реализирайте клас `[IndexArray]`, който запазва динамичен масив с фиксиран размер от цели числа - индекси.
+Реализирайте клас [`IndexArray`], който запазва динамичен масив с фиксиран размер от цели числа - индекси.
 
-.warn =[Не]= правете общ родител, който имплементира динамичен масив!
+.warn [=Не=] правете общ родител, който имплементира динамичен масив!
 
-Реализирайте наследник на двата класа, `[WordsString]`, при който индексите определят началото на всяка дума от запазения низ.
+Реализирайте наследник на двата класа, [`WordsString`], при който индексите определят началото на всяка дума от запазения низ.
 Индексите се дефинират при конструктора.
 
 ## Лесни
@@ -29,20 +29,20 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 
 .comment Диамант
 
-Реализирайте шаблонен клас `[Container]`, който съхранява масив с фиксиран размер от елементи с подаден тип.
-=[Не]= трябва да реализирате нищо повече от задължителните компоненти (голяма петица).
+Реализирайте шаблонен клас [`Container`], който съхранява масив с фиксиран размер от елементи с подаден тип.
+[=Не=] трябва да реализирате нищо повече от задължителните компоненти (голяма петица).
 
-Реализирайте негов наследник `[Indexable]`, който реализира оператор[].
+Реализирайте негов наследник [`Indexable`], който реализира оператор[].
 
-Реализирайте втори негов наследник `[Resizeable]`, който реализира член-функция `[InsertAt]`, приемаща елемент и индекс, и която вмъква елемента на даден индекс.
+Реализирайте втори негов наследник [`Resizeable`], който реализира член-функция [`InsertAt`], приемаща елемент и индекс, и която вмъква елемента на даден индекс.
 Разбира се, може да се наложи оразмеряване на масива.
 
-Реализирайте наследник `[Vector]` на `[Indexable]` и `[Resizeable]`, който реализира оператор[] и член-функции:
+Реализирайте наследник [`Vector`] на [`Indexable`] и [`Resizeable`], който реализира оператор[] и член-функции:
 .bulleted
-- `[pop_back]`, премахваща последния елемент
-- `[pop_front]`, премахваща първия елемент
-- `[push_back]`, приемаща елемент който се вкарва в края на масив
-- `[push_front]`, приемаща елемент който се вкарва в началото на масив
+- [`pop_back`], премахваща последния елемент
+- [`pop_front`], премахваща първия елемент
+- [`push_back`], приемаща елемент който се вкарва в края на масив
+- [`push_front`], приемаща елемент който се вкарва в началото на масив
 
 .important Не забравяйте за диамантния проблем!
 
@@ -52,29 +52,29 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 
 .comment Диамант
 
-Реализирайте клас `[User]`, който запазва потребителско име и парола като низове с произволна дължина, заедно с булев флаг `[banned]`, определящ дали акаунтът може да прави действия.
+Реализирайте клас [`User`], който запазва потребителско име и парола като низове с произволна дължина, заедно с булев флаг [`banned`], определящ дали акаунтът може да прави действия.
 Потребителско име не може да съдържа шпации.
 
-Реализирайте клас `[Thread]`, който запазва масив с произволна дължина, от низове с произволна дължина.
+Реализирайте клас [`Thread`], който запазва масив с произволна дължина, от низове с произволна дължина.
 Имплементирайте член-функция:
 
 .bulleted
-- `[PostMessage]`, която приема потребител и негово съобщение и добавя съобщението с потребителското име като един низ.
-  Ако потребителя е `[banned]`, тогава хвърлете грешка.
+- [`PostMessage`], която приема потребител и негово съобщение и добавя съобщението с потребителското име като един низ.
+  Ако потребителя е [`banned`], тогава хвърлете грешка.
 
-Реализирайте наследник `[ThreadModerator]` на `[User]`, който може да променя `[Thread]` обекти, без да се нуждае от публични член-функции в `[Thread]`.
+Реализирайте наследник [`ThreadModerator`] на [`User`], който може да променя [`Thread`] обекти, без да се нуждае от публични член-функции в [`Thread`].
 Имплементирайте методи:
 .bulleted
-- `[RemoveMessage]`, който приема `[Thread]` и индекс на съобщение и премахва съответното съобщение
-- `[RemoveByUser]`, който приема `[Thread]` и потребител, и премахва всички съобщения, направени от дадения потребител
+- [`RemoveMessage`], който приема [`Thread`] и индекс на съобщение и премахва съответното съобщение
+- [`RemoveByUser`], който приема [`Thread`] и потребител, и премахва всички съобщения, направени от дадения потребител
 
-Реализирайте наследник `[UserModerator]` на `[User]`, който може да променя `[User]` обекти, без да се нуждае от публични член-функции в `[User]`.
+Реализирайте наследник [`UserModerator`] на [`User`], който може да променя [`User`] обекти, без да се нуждае от публични член-функции в [`User`].
 Имплементирайте методите:
 .bulleted
-- `[BanUser]`, който приема потребител и вдига `[banned]` флага
-- `[UnbanUser]`, който приема потребител и сваля `[banned]` флага
+- [`BanUser`], който приема потребител и вдига [`banned`] флага
+- [`UnbanUser`], който приема потребител и сваля [`banned`] флага
 
-Реализирайте наследник `[Administrator]` на `[ThreadModerator]` и `[UserModerator]`, който може да прави всичко, което и родителите могат.
+Реализирайте наследник [`Administrator`] на [`ThreadModerator`] и [`UserModerator`], който може да прави всичко, което и родителите могат.
 
 .important Не забравяйте за диамантния проблем!
 
@@ -82,7 +82,7 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 
 ### Задача 4
 
-Реализирайте абстрактен клас `[ShopLocation]`, който съхранява член-данни:
+Реализирайте абстрактен клас [`ShopLocation`], който съхранява член-данни:
 .bulleted
 - адрес като низ с максимална дължина от 511 знака.
   Всеки адрес съдържа произволни символи и задължително завършва на число, определящо неговия район.
@@ -90,24 +90,24 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 
 Имплементирате методи:
 .bulleted
-- `[IsOpen]`, който връща по подаден час дали локацията е отворена
-- `[InCenter]`, който връща дали локацията се намира в центъра на града.
+- [`IsOpen`], който връща по подаден час дали локацията е отворена
+- [`InCenter`], който връща дали локацията се намира в центъра на града.
   Всички адреси с регион, по-малък от 11, се намират в центъра.
 
-Реализирайте шаблонен клас `[Inventory]`, който съхранява =[фиксиран]= брой елементи и техните неотрицателни бройки (количества).
+Реализирайте шаблонен клас [`Inventory`], който съхранява [=фиксиран=] брой елементи и техните неотрицателни бройки (количества).
 Имплементирайте член-функции:
 .bulleted
 - оператор[], който връща елемент на дадения индекс
 - оператор(), който връща бройка на елемент на дадения индекс
-- `[Stock]`, приемащ индекс на елемент и бройка (положителна/отрицателна) с която бройката на дадения елемент се променя.
+- [`Stock`], приемащ индекс на елемент и бройка (положителна/отрицателна) с която бройката на дадения елемент се променя.
   Бройката може да бъде най-малко 0.
-- `[List]`, който връща всички елементи и техните индекси
+- [`List`], който връща всички елементи и техните индекси
 
-Реализирайте абстрактен шаблонен наследник `[DeliverableInventory]` на `[Inventory]`, който е инвентар с максимум 2048 елемента и допълнително задължава имплементацията на:
+Реализирайте абстрактен шаблонен наследник [`DeliverableInventory`] на [`Inventory`], който е инвентар с максимум 2048 елемента и допълнително задължава имплементацията на:
 .bulleted
-- `[ShippingDelay]`, който приема адрес и връща времето в което ще може да се достави обекта
+- [`ShippingDelay`], който приема адрес и връща времето в което ще може да се достави обекта
 
-Реализирайте наследник на `[DeliverableInventory]`, склад `[Warehouse]`, който допълнително запазва разстояние от града в километри и имплементира `[ShippingDelay]` по следната логика:
+Реализирайте наследник на [`DeliverableInventory`], склад [`Warehouse`], който допълнително запазва разстояние от града в километри и имплементира [`ShippingDelay`] по следната логика:
 .bulleted
 - доставки в центъра отнемат един ден + регионът в който се доставя
 - доставки извън центъра отнемат толкова време, колкото е нужно да се стигне до града ако пътува с 80 километра в час + времето което ще отнеме да се измине номер на региона на брой километри при скорост от 20 километра в час
@@ -115,27 +115,27 @@ GitHub classroom: [url https://classroom.github.com/a/GvV1wrC1 classroom.github.
 Доставка не може да се случи преди 9 сутринта и след 18 вечерта.
 Ако попадне в този диапазон, тогава се отлага за най-скорошния следващ възможен час.
 
-Реализирайте шаблонен наследник магазин `[Shop]` на `[ShopLocation]` и `[Inventory]`, който е инвентар с максимум 256 елемента, запазващ:
+Реализирайте шаблонен наследник магазин [`Shop`] на [`ShopLocation`] и [`Inventory`], който е инвентар с максимум 256 елемента, запазващ:
 .bulleted
-- =[оразмеряем]= масив от низове с произволен размер, всеки низ който е "отчет на продажба"
+- [=оразмеряем=] масив от низове с произволен размер, всеки низ който е "отчет на продажба"
 - общо бройка продажби
 
 и който имплементира методи:
 .bulleted
-- `[SellItems]`, който приема масив от идентификатори на обекти, намалява бройката на всеки от тях и създава нов отчет.
+- [`SellItems`], който приема масив от идентификатори на обекти, намалява бройката на всеки от тях и създава нов отчет.
   Отчета е в произволен формат, но трябва да съдържа идентификаторите и бройките на всеки обект.
   Ако за някой обект няма достатъчно бройки или изобщо не се пази, хвърлете грешка.
 
-Реализирайте шаблонен клас `[WebStore]`, който запазва оразмеряеми масиви от `[Shop]` и `[Warehouse]`.
+Реализирайте шаблонен клас [`WebStore`], който запазва оразмеряеми масиви от [`Shop`] и [`Warehouse`].
 Имплементирайте:
 .bulleted
 - оператор<<, който изкарва всички уникални (unique) обекти от всички магазини и складове, с индекс до тях
-- `[GetEstimate]`, който приема индекс на уникален обект от всички магазини и складове, сегашно време и адрес, и изкарва на екрана всички магазини които са отворени в дадения час и кое е най-скорошното време в което може обектът да се достави от склад.
+- [`GetEstimate`], който приема индекс на уникален обект от всички магазини и складове, сегашно време и адрес, и изкарва на екрана всички магазини които са отворени в дадения час и кое е най-скорошното време в което може обектът да се достави от склад.
   Ако няма отворени магазини, ако няма магазин с наличност и так. нат. изкарайте съответно съобщение.
 
-Последно реализирайте клас `[Book]`, който запазва заглавие на книга и име на автор като низове с максимална дължина от 127 знака.
+Последно реализирайте клас [`Book`], който запазва заглавие на книга и име на автор като низове с максимална дължина от 127 знака.
 Имплементирайте оператор<<, който изкарва съответната книга в произволен формат.
 
-В главната функция реализирайте `[WebStore]` от книги, заедно с набор от книги, магазини и складове по ваш избор.
+В главната функция реализирайте [`WebStore`] от книги, заедно с набор от книги, магазини и складове по ваш избор.
 Нека в началото на програмата да приемате от потребителя сегашното време и адрес, след това изкарайте на екрана всички ункални книги с индекси.
 Накрая потребителя може да въведе индекс на книга и да получи информация кои отворени сега магазини имат съответната книга и кога най-скоро може да бъде доставена от склад.
diff --git a/src/teaching/oop-2023/week14/index.du b/src/teaching/oop-2023/week14/index.du
index 761edd5..d9c827a 100644
--- a/src/teaching/oop-2023/week14/index.du
+++ b/src/teaching/oop-2023/week14/index.du
@@ -37,7 +37,7 @@ GitHub classroom: [url https://classroom.github.com/a/K0XomKEP classroom.github.
 
 и имплементира метод:
 .bulleted
-- `[NewSemester]`, който приема учебна година и тип, и връща нов обект от семестър с попълнени данни
+- [`NewSemester`], който приема учебна година и тип, и връща нов обект от семестър с попълнени данни
 
 Имаме потребители, като всеки си има роля, определяща неговите способности в системата.
 Ролята може да бъде студент, преподавател или администратор, като при конкретизиране в условието на някои от тях трябва да се извършат съответните проверки.
diff --git a/src/teaching/oop-2023/week15/index.du b/src/teaching/oop-2023/week15/index.du
index 7bf678f..55ee303 100644
--- a/src/teaching/oop-2023/week15/index.du
+++ b/src/teaching/oop-2023/week15/index.du
@@ -19,7 +19,7 @@ GitHub classroom: [url https://classroom.github.com/a/z2QadyEE classroom.github.
 - линк (хипервръзка) като текст и (уеб) адрес
 - време: дата и час
 
-Всеки тип трябва да имплементира `[Print]` член-функция, която изкарва текстово съдържание на съобщението.
+Всеки тип трябва да имплементира [`Print`] член-функция, която изкарва текстово съдържание на съобщението.
 За текстово съобщение това е самия текст, за локация това е низ във формата "[ДЪРЖАВА] ГРАД(ОБЛАСТ) УЛИЦА NoНОМЕР НА УЛИЦА", за линк е самия текст и за време е "ЧАС:МИНУТИ ДЕН.МЕСЕЦ.ГОДИНА".
 
 Реализирайте потребители, като за всеки потребител имаме потребителско име и парола.
diff --git a/src/teaching/oop-2023/week16/index.du b/src/teaching/oop-2023/week16/index.du
index da0c1d6..604c746 100644
--- a/src/teaching/oop-2023/week16/index.du
+++ b/src/teaching/oop-2023/week16/index.du
@@ -13,7 +13,7 @@ GitHub classroom: [url https://classroom.github.com/a/BWjw2dUC classroom.github.
 Разбира се, отдолу няма истински файлове които се запазват в харддиск (примерно), просто ОС превежда всички тези операции върху файлове със съответни действия към устройството.
 
 Реализирайте подобна система.
-Първо трябва ни обща схема за файлове, за всеки файл имаме `[Read]` и `[Write]` методи, и пазим името на файла.
+Първо трябва ни обща схема за файлове, за всеки файл имаме [`Read`] и [`Write`] методи, и пазим името на файла.
 
 За всяко устройство само по себе си знаем, че трябва да използваме определен драйвър (по име) и че то има малко информация за себе си: марка като низ и модел като цяло число.
 По-конкретно разглежаме два основни типа устройства: индексируемо и поточно (streamable).
diff --git a/src/teaching/oop-2023/week2/index.du b/src/teaching/oop-2023/week2/index.du
index 2a71e0e..ade800c 100644
--- a/src/teaching/oop-2023/week2/index.du
+++ b/src/teaching/oop-2023/week2/index.du
@@ -23,7 +23,7 @@ GitHub classroom: [url https://classroom.github.com/a/3qPsfyyI classroom.github.
 
 За всеки играч трябва съответно да изкарате общия брой X-ове или броя O-та в цялата дъска, както и дължината на най-дългата последователност от Х-ове или О-та в един реда на дъската (примерно за първия играч, търсим реда с най-много последователни X-ове, и изкарваме тяхната бройка).
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -50,40 +50,40 @@ BoburaBG: Total - 12, Longest - 3
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week02/Exercise0.cpp#L3-L83 Решение]
 
-.important Решете подточката =[без]= структури, тоест без знания по ООП
+.important Решете подточката [=без=] структури, тоест без знания по ООП
 
-Имплементирайте =[функция]= `[boardCounts]`, която приема дъската и връща по някакъв начин нужните бройки: общ брой X-ове, общ брой O-та, брой X-ове в най-дългата последователност от X-ове в ред, брой O-та в най-дългата последователност от O-та в ред.
+Имплементирайте [=функция=] [`boardCounts`], която приема дъската и връща по някакъв начин нужните бройки: общ брой X-ове, общ брой O-та, брой X-ове в най-дългата последователност от X-ове в ред, брой O-та в най-дългата последователност от O-та в ред.
 
-След това имплементирайте фукция `[printResult]`, която приема имената на двата играча, както и бройките, върнати от `[boardCounts]`, и изкарва на екрана съобщенията във формата от примера.
+След това имплементирайте фукция [`printResult`], която приема имената на двата играча, както и бройките, върнати от [`boardCounts`], и изкарва на екрана съобщенията във формата от примера.
 
 ### б) структура за board
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week02/Exercise0.cpp#L85-L166 Решение]
 
 "Слепете" в една съвкупност (структура) указателя към самата дъска за морски шах, както и нейния размер N.
-Нека името на структурата да бъде `[GameBoard]`.
+Нека името на структурата да бъде [`GameBoard`].
 
-Обновете `[boardCounts]`, така че вместо да приема дъската и размера ѝ чрез две променливи, да ги приема чрез една променлива от тип `[GameBoard]`.
+Обновете [`boardCounts`], така че вместо да приема дъската и размера ѝ чрез две променливи, да ги приема чрез една променлива от тип [`GameBoard`].
 
 ### в) структура за числата
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week02/Exercise0.cpp#L168-L255 Решение]
 
-"Слепете" в една съвкупност (структура) на име `[BoardCounts]` четирите променливи, които `[boardCounts]` връща.
+"Слепете" в една съвкупност (структура) на име [`BoardCounts`] четирите променливи, които [`boardCounts`] връща.
 
-Обновете `[boardCounts]` да връща една стойност от тип `[BoardCounts]`, вместо да връща четирите бройки като отделни числа.
-Обновете `[printResult]` да приема стойност от тип `[BoardCounts]`, вместо да приема четирите бройки като отделни числа.
+Обновете [`boardCounts`] да връща една стойност от тип [`BoardCounts`], вместо да връща четирите бройки като отделни числа.
+Обновете [`printResult`] да приема стойност от тип [`BoardCounts`], вместо да приема четирите бройки като отделни числа.
 
 ### г) структура за цялата игра
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week02/Exercise0.cpp#L257-L300 Решение]
 
-Сега "слепете" предходните две структури, заедно с имената на нашите играчи, в една голяма обща структура за цялата игра на име `[Game]`.
-Тоест, всичките ни данни: дъската, бройките и имената на играчите, да се намират в `[Game]`.
+Сега "слепете" предходните две структури, заедно с имената на нашите играчи, в една голяма обща структура за цялата игра на име [`Game`].
+Тоест, всичките ни данни: дъската, бройките и имената на играчите, да се намират в [`Game`].
 
-.important Искам да *[композирате]*, тоест искам да използвате `[GameBoard]` и `[BoardCounts]` структурите в `[Game]` структурата.
+.important Искам да [*композирате*], тоест искам да използвате [`GameBoard`] и [`BoardCounts`] структурите в [`Game`] структурата.
 
-Обновете `[boardCounts]` и `[printResult]`, така че да използват тази структура.
+Обновете [`boardCounts`] и [`printResult`], така че да използват тази структура.
 
 ## Задача 1 - Основи от материала
 
@@ -91,9 +91,9 @@ BoburaBG: Total - 12, Longest - 3
 
 Работите върху система за инвентар на книжарница.
 
-.warn Не е задължително, но е препоръчително да си направите и една структура `[String]` с конструктор и деструктор
+.warn Не е задължително, но е препоръчително да си направите и една структура [`String`] с конструктор и деструктор
 
-Създайте структура `[Book]` със скрити (private) данни за:
+Създайте структура [`Book`] със скрити (private) данни за:
 .bulleted
 - заглавие, като един низ
 - автори, като масив от низове
@@ -108,28 +108,28 @@ Set-ърите трябва да записват стойности в данн
 - годината на публикация не може да надвишава 2024, не може да е по-малка от -2100 (2100 п.н.е.) и не може да бъде нула
 - цената не може да е отрицателна
 
-Всеки от мутаторите трябва да връща булева стойност, `[true]` ако проверките са изпълнени (и запазването на данни е извършено) и `[false]` ако съответната проверка не е изпълнена (и няма промяна в данните).
+Всеки от мутаторите трябва да връща булева стойност, [`true`] ако проверките са изпълнени (и запазването на данни е извършено) и [`false`] ако съответната проверка не е изпълнена (и няма промяна в данните).
 Създайте съответните конструктори и деструктори.
 
-След това направете структура `[Library]`, която държи масив от книги и бройката за всяка книга (отново като скрити данни).
+След това направете структура [`Library`], която държи масив от книги и бройката за всяка книга (отново като скрити данни).
 Най-лесния вариант е да имате втори масив, като за всеки индекс в масива с книги, на същия индекс в масива за бройки се намира съответната бройка.
-Можете и да го направите чрез структура `[Pair]` и да имате един масив.
+Можете и да го направите чрез структура [`Pair`] и да имате един масив.
 
-Като публични методи на `[Library]` имплементирайте `[AddBook]`, която вмъква нова книга в масива, и `[RemoveBook]` която съответно "премахва" книга по заглавие и година.
-Допълнително направете член-функция `[StockBook]`, която приема заглавие на книга, годината ѝ, и цяло число с което наличната бройка се увеличава.
-Аналогично направете и `[SellBook]`.
+Като публични методи на [`Library`] имплементирайте [`AddBook`], която вмъква нова книга в масива, и [`RemoveBook`] която съответно "премахва" книга по заглавие и година.
+Допълнително направете член-функция [`StockBook`], която приема заглавие на книга, годината ѝ, и цяло число с което наличната бройка се увеличава.
+Аналогично направете и [`SellBook`].
 За всики тези методи трябва да имате съответните проверки:
 .bulleted
-- ако напълно идентична книга вече съществува, `[AddBook]` не трябва да я добавя на ново
-- `[RemoveBook]` не трябва да "гърми" ако книгата не съществува
-- бройката на добавени/продадени книги, подадени на `[SellBook]` и `[StockBook]`, трябва да бъдат положителни, както и книгите да съществуват
+- ако напълно идентична книга вече съществува, [`AddBook`] не трябва да я добавя на ново
+- [`RemoveBook`] не трябва да "гърми" ако книгата не съществува
+- бройката на добавени/продадени книги, подадени на [`SellBook`] и [`StockBook`], трябва да бъдат положителни, както и книгите да съществуват
 
-Аналогично като при `[Book]`, тези функции трябва да връщат булева стойност, дали проверките са изпълнени.
+Аналогично като при [`Book`], тези функции трябва да връщат булева стойност, дали проверките са изпълнени.
 Не забравяйте за конструктор и деструктор!
 
 .question Можете ли да си улесните работата, ако използвате скрити член-функции?
 
-Не е нужно да правите потребителски вход/изход, но тествайте ръчно кода си в `[main]`.
+Не е нужно да правите потребителски вход/изход, но тествайте ръчно кода си в [`main`].
 
 ## Задача 2
 
@@ -138,26 +138,26 @@ Set-ърите трябва да записват стойности в данн
 Работите върху система за Excel-ски таблици.
 Една клетка може да съдържа някаква числена стойност, или проста формула която определя тази стойност.
 
-Създайте структура `[Cell]`, която запазва (скрито) целочислена стойност, знак, който определя опреацията във формулата, и два указателя на `[Cell]` към двете страни на оператора.
-Оператора (знака) може да бъде `[+]`, `[-]`, `[*]` или `[/]`.
+Създайте структура [`Cell`], която запазва (скрито) целочислена стойност, знак, който определя опреацията във формулата, и два указателя на [`Cell`] към двете страни на оператора.
+Оператора (знака) може да бъде [`+`], [`-`], [`*`] или [`/`].
 
 Идеята е, че ако клетката само запазва стойност, тогава оператора ще бъде нещо празно (терминираща нула например).
 Обаче ако се определя от формула, тогава оператора и указателите също ще са попълнени, а запазената стойност ще действа като кеш, тоест вместо всеки път да преизчисляваме стойността когато я искаме, преизчислили сме я веднъж и я запазваме.
 
-За тази цел имплементирайте публична член-функция `[evaluate]`, ако не е запазена формула, тя не прави нищо, ако е, прави съответното изчисление и запазва резултата.
-Разбира се, направете и мутатори `[setValue]` и `[setFormula]`, със съответните проверки.
+За тази цел имплементирайте публична член-функция [`evaluate`], ако не е запазена формула, тя не прави нищо, ако е, прави съответното изчисление и запазва резултата.
+Разбира се, направете и мутатори [`setValue`] и [`setFormula`], със съответните проверки.
 Не забравяйте за конструктор и деструктор.
 
-Сега направете структура `[Table]`, която пази (скрито) двумерен масив от клетки.
-Имплементирайте селектор `[getCell]`, който връща указател на клетка по координати и мутатор `[setCell]`, който приема клетка и координати в масива.
+Сега направете структура [`Table`], която пази (скрито) двумерен масив от клетки.
+Имплементирайте селектор [`getCell`], който връща указател на клетка по координати и мутатор [`setCell`], който приема клетка и координати в масива.
 
 .question Какъв ще е типа на подадената клетка и стойностите в масива?
 
-Направете метод `[updateCell]`, чрез която стойностите на клетка по координати могат да бъдат променени, и след това всички клетки в таблицата се преизчисляват.
+Направете метод [`updateCell`], чрез която стойностите на клетка по координати могат да бъдат променени, и след това всички клетки в таблицата се преизчисляват.
 
-Последно, имплементирайте и член-функция `[printTable]`, която изкарва на екрана цялата таблица, като клетката на индекси 0,0 се намира в горния ляв ъгъл, всички клетки са разделени с `[|]`.
+Последно, имплементирайте и член-функция [`printTable`], която изкарва на екрана цялата таблица, като клетката на индекси 0,0 се намира в горния ляв ъгъл, всички клетки са разделени с [`|`].
 
-Не е нужно да правите потребителски вход/изход, но тествайте ръчно кода си в `[main]`.
+Не е нужно да правите потребителски вход/изход, но тествайте ръчно кода си в [`main`].
 
 ## Задача 3
 
@@ -185,7 +185,7 @@ Set-ърите трябва да записват стойности в данн
 Ако една кола успешно "излиза" от участака на магистралата, тоест тя се опитва да се придвижи някъде след края ѝ, зачитаме че успешно е минала пътя и спираме да я разглеждаме.
 
 Сами определете как ще изглеждат структурите за колата и магистралата, както и нужните методи.
-Имайте предвид, че трябва цялата логика да присъства в тези структури, тоест в `[main]` трябва да присъства само някакъв инициализиращ код.
+Имайте предвид, че трябва цялата логика да присъства в тези структури, тоест в [`main`] трябва да присъства само някакъв инициализиращ код.
 
 .important Не е позволено магистралата да бъде двумерна матрица, координатите на всяка кола се пазят в самата кола.
 
@@ -207,7 +207,7 @@ Set-ърите трябва да записват стойности в данн
 Типовете на материалите са отделни стойности от идентификационните номера, тоест като е подаден материал, той се превръща в крайния тип, и трябва да намерите на кой материал точва число е началния тип.
 
 Всички тези данни трябва да са скрити, трябва за съответните структури да присъстват конструктори и деструктори.
-Допълнително при машините трябва да има член-функция `[convertMaterial]`, която получава идентификационен номер на материал и бройка, и връща колко от резултатния материал е успяла да създаде (спрямо ефикасността, закръглена надолу, и дали се нуждае от ремонт по средата на работата).
+Допълнително при машините трябва да има член-функция [`convertMaterial`], която получава идентификационен номер на материал и бройка, и връща колко от резултатния материал е успяла да създаде (спрямо ефикасността, закръглена надолу, и дали се нуждае от ремонт по средата на работата).
 
 Ще получите данни за всички материали и машини, както и задачи, тоест идентификационни номера на начален и краен материал, както и бройката на началния материал.
 Трябва да намерите редицата от машини, които ще създадат възможно най-много краен материал.
diff --git a/src/teaching/oop-2023/week3/index.du b/src/teaching/oop-2023/week3/index.du
index 44d23f7..9617d36 100644
--- a/src/teaching/oop-2023/week3/index.du
+++ b/src/teaching/oop-2023/week3/index.du
@@ -10,7 +10,7 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week03/Exercise1.cpp Решение]
 
-Имплементирайте структура `[Lightbulb]`, която запазва идентифициращите данни за една крушка:
+Имплементирайте структура [`Lightbulb`], която запазва идентифициращите данни за една крушка:
 .bulleted
 - диаметър и дължина: и двете са целочислени стойности
 - тип: низ с максимална дължина от 100 знака
@@ -20,7 +20,7 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week03/Exercise2.cpp Решение]
 
-Имплементирайте структура `[Alarm]`, която съдържа следните =[скрити]= данни:
+Имплементирайте структура [`Alarm`], която съдържа следните [=скрити=] данни:
 .bulleted
 - име на модел: низ с максимална дължина от 1024 знака
 - пин код: целочислено число
@@ -40,23 +40,23 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week03/Exercise3.cpp Решение]
 
-Имплементирайте структура `[Person]`, която запазва двете имена на човек, възраст като целочислено число и неговия имейл.
+Имплементирайте структура [`Person`], която запазва двете имена на човек, възраст като целочислено число и неговия имейл.
 Имената и имейла са низвое с произволна дължина.
 
-Направете конструктор, който приема възрастта и тези три низа, и =[копира]= стойностите им в динамичната памет.
+Направете конструктор, който приема възрастта и тези три низа, и [=копира=] стойностите им в динамичната памет.
 Също напишете и деструктор, който коректно трие нужните данни.
 
 ### Задача 4 - Динамично-заделени структури в други структури
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week03/Exercise4.cpp Решение]
 
-Имплементирайте структура `[Bus]`, която публично запазва капацитета хора и километража на един автобус.
+Имплементирайте структура [`Bus`], която публично запазва капацитета хора и километража на един автобус.
 
-Имплементирайте структура `[BusWarehouse]`, която запазва динамично-заделен масив от автобуси.
-В конструктора се въвежда максималния брой автобуси, който може един `[BusWarehouse]` да съдържа.
+Имплементирайте структура [`BusWarehouse`], която запазва динамично-заделен масив от автобуси.
+В конструктора се въвежда максималния брой автобуси, който може един [`BusWarehouse`] да съдържа.
 
 Имплементирайте конструктор, който само инициализира нужните данни, и деструктор който трие каквото трябва.
-Имплементирайте член-функция `[AddBus]`, която добавя автобус в инстанция на `[BusWarehouse]`, ако има място за него.
+Имплементирайте член-функция [`AddBus`], която добавя автобус в инстанция на [`BusWarehouse`], ако има място за него.
 
 ## Лесни задачи
 
@@ -64,14 +64,14 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week03/Exercise5.cpp Решение]
 
-Имплементирайте структура `[Car]`, всяка кола пази скрито своя модел като низ с произволна дължина, брой врати и брой седалки като целочислени числа.
+Имплементирайте структура [`Car`], всяка кола пази скрито своя модел като низ с произволна дължина, брой врати и брой седалки като целочислени числа.
 Направете съответните get-ъри, set-ъри, конструктор и деструктор.
 
-Имплементирайте структура `[TrafficJam]`, която пази произволно дълга редица коли в задръстване.
-Направете и член-функция `[AddCar]`, която вмъква кола в края на редицата.
+Имплементирайте структура [`TrafficJam`], която пази произволно дълга редица коли в задръстване.
+Направете и член-функция [`AddCar`], която вмъква кола в края на редицата.
 Тази функция може да се извиква произволен брой пъти, затова имплементирайте и оразмеряване на вътрешната редица.
 
-`[TrafficJam]` трябва да има конструктор, деструктор и тази член-функция.
+[`TrafficJam`] трябва да има конструктор, деструктор и тази член-функция.
 
 ### Задача 6
 
@@ -79,9 +79,9 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 
 Ще работите с N-мерна шахматна дъска.
 
-Направете структура `[ChessPiece]`, която запазва цвета и типа на фигурата от шах, като първото е целочислена стойност, второто е буква.
+Направете структура [`ChessPiece`], която запазва цвета и типа на фигурата от шах, като първото е целочислена стойност, второто е буква.
 
-Направете структура `[ChessBoard]`, която по подадено N в конструктора създава шахматна дъска с размер NxN с =[указатели]= към съответните фигури на дъската.
+Направете структура [`ChessBoard`], която по подадено N в конструктора създава шахматна дъска с размер NxN с [=указатели=] към съответните фигури на дъската.
 Разбира се, някои от тези указатели трябва да сочат към някакви създадени шахматни фигури.
 
 При създаване на дъската, трябва да подредите фигурите.
@@ -103,10 +103,10 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 Имате затворени интервали от целочислени числа.
 Разглеждаме смесване на интервали:
 .bulleted
-- смеската на допиращи се интервали е тяхното слепване, тоест смеската на `[[0, 3]]` и `[[3, 5]]` е `[[0, 5]]`
-- смеската на препокриващи се интервали е тяхното обединение, тоест смеската на `[[0, 5]]` и `[[3, 8]]` е `[[0, 8]]`
+- смеската на допиращи се интервали е тяхното слепване, тоест смеската на [`[0, 3]`] и [`[3, 5]`] е [`[0, 5]`]
+- смеската на препокриващи се интервали е тяхното обединение, тоест смеската на [`[0, 5]`] и [`[3, 8]`] е [`[0, 8]`]
 
-В противен случай не можем да смесим интервалите (примерно не можем да смесим `[[0, 3]]` и `[[4, 8]]`).
+В противен случай не можем да смесим интервалите (примерно не можем да смесим [`[0, 3]`] и [`[4, 8]`]).
 
 Започвайки от някакво множество с интервали, смесете колкото се може повече от тях и изкарайте всичките резултатни интервали, които не могат повече да се смесят.
 Използвайте структури и член-функции.
@@ -125,7 +125,7 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 Градът трябва да пази всички отделни сгради, като допълнително за всяка жилищна трябва да съхранява общата бройка жители, a за всяка търговска - общата бройка отворени магазини.
 Освен това трябва да се съхрани и нещо като карта на всичките сгради: допускаме Старозагоско/Манхатънско подреждане на сградите, тоест всички сгради се намират върху някаква "решетка".
 
-.question Познавате ли структурата `[Pair]`?
+.question Познавате ли структурата [`Pair`]?
 
 Имплементирайте възможност за построяване и събаряне на сгради.
 Направете нужните проверки на всички данни: цената да не е отрицателна, бройката жители да не надвишава капацитета на сградата и так. нат.
@@ -153,22 +153,22 @@ GitHub classroom: [url https://classroom.github.com/a/KPMqXsFp classroom.github.
 Винаги започваме с една празна начална директория.
 
 Двете функции, за създаване и изтриване, трябва да приемат масив от низове, който определя път от директории към желания файл, започвайки от началния файл.
-Тоест, ако бяха подадени низовете `[Documents]`, `[Personal]`, `[Health]`, `[receipt.txt]`, тогава от началния файл намираме името `[Documents]` и "влизаме" в директорията със съответния идентификационен номер, в нея намираме името `[Personal]` и так. нат.
+Тоест, ако бяха подадени низовете [`Documents`], [`Personal`], [`Health`], [`receipt.txt`], тогава от началния файл намираме името [`Documents`] и "влизаме" в директорията със съответния идентификационен номер, в нея намираме името [`Personal`] и так. нат.
 
 ### Задача 10
 
-Намираме се в равнината, при която всички (двуизмерни) координати са =[целочислени]=.
+Намираме се в равнината, при която всички (двуизмерни) координати са [=целочислени=].
 
 В нея имаме стъклени панели (прави отсечки), дефинирани с координатите на двете им крайни точки.
 Допълнително всеки панел си има свой цвят (като проценти, между 0 и 1, от цветовете червено, зелено и синьо) и прозрачност (като процент, между 0 и 1).
 
 Също имаме и един лъч, той се характеризира с началния си координат и единичен двуизмерен вектор, определящ неговата посока на движение.
-Този лъч не се пречупва и винаги се движи напред (преместването на лъча се извършва чрез `[позиция = позиция + посока]`).
+Този лъч не се пречупва и винаги се движи напред (преместването на лъча се извършва чрез [`позиция = позиция + посока`]).
 
 Чрез този лъч трябва да изкарате композитния цвят, след като лъча е минал през всички стъклени панели пред него.
 Нека също композитния цвят винаги да има 100% прозрачност.
 
-Примерно, ако лъча премине през един панел с цветови проценти `[0,1,0]` и прозрачност `[0.5]` и още един панел с цветови проценти `[0,1,1]` и прозрачност `[0.5]`, тогава композитния цвят е `[0,1,0.5]`.
+Примерно, ако лъча премине през един панел с цветови проценти [`0,1,0`] и прозрачност [`0.5`] и още един панел с цветови проценти [`0,1,1`] и прозрачност [`0.5`], тогава композитния цвят е [`0,1,0.5`].
 
 .question Колко структури ще ви трябват?
 
diff --git a/src/teaching/oop-2023/week4/index.du b/src/teaching/oop-2023/week4/index.du
index a6e02b9..3b2c19f 100644
--- a/src/teaching/oop-2023/week4/index.du
+++ b/src/teaching/oop-2023/week4/index.du
@@ -10,7 +10,7 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week04/Exercise1.cpp Решение]
 
-Имплементирайте структура `[Smartphone]`, която запазва =[скрито]=:
+Имплементирайте структура [`Smartphone`], която запазва [=скрито=]:
 .bulleted
 - марка, низ с максимална дължина от 128 знака
 - модел, низ с максимална дължина от 512 знака
@@ -29,9 +29,9 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week04/Exercise2.cpp Решение]
 
-Имплементирайте структура `[Bee]`, която запазва възрастта на пчела чрез число с плаваща запетая и типа пчела с буква.
+Имплементирайте структура [`Bee`], която запазва възрастта на пчела чрез число с плаваща запетая и типа пчела с буква.
 
-Имплементирайте структура `[BeeHive]`, която запазва динамично-заделен масив с всички реещи се пчели и друг динамично-заделен масив с всички яйца в кошера.
+Имплементирайте структура [`BeeHive`], която запазва динамично-заделен масив с всички реещи се пчели и друг динамично-заделен масив с всички яйца в кошера.
 Размерите на двата масива се подават на конструктора.
 Имплементирайте нужните конструктор и деструктор.
 
@@ -41,12 +41,12 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week04/Exercise3.cpp Решение]
 
-Имплементирайте структура `[Paper]`, която запазва своето текстово съдържание като низ от максимум 1024 знака и положително цяло число, определящо номера на страницата.
+Имплементирайте структура [`Paper`], която запазва своето текстово съдържание като низ от максимум 1024 знака и положително цяло число, определящо номера на страницата.
 
-От входа получавате на един ред цялото текстото съдържание за един обект от тип `[Paper]` и на следващия ред - бройките копия `[N]` на дадения обект.
+От входа получавате на един ред цялото текстото съдържание за един обект от тип [`Paper`] и на следващия ред - бройките копия [`N`] на дадения обект.
 
-Създайте `[Paper]` обект със съответното съдържание и номер на страницата `[1]`.
-Създайте динамично-заделен масив от `[Paper]` с размер `[N]`, като първия му елемент е новосъздадения обект, докато останалите са =[копия]= на първия обект.
+Създайте [`Paper`] обект със съответното съдържание и номер на страницата [`1`].
+Създайте динамично-заделен масив от [`Paper`] с размер [`N`], като първия му елемент е новосъздадения обект, докато останалите са [=копия=] на първия обект.
 
 При всяко копие, трябва да увеличите номера на страницата.
 Имплементирейте логиката чрез копиращ конструктор.
@@ -55,31 +55,31 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week04/Exercise4.cpp Решение]
 
-Създайте структура `[DynamicString]`, чиито конструктор приема низ с терминираща нула, заделя точно толкова динамична памет, колкото е нужно да се запази целия низ и копира буквите на низа в тази памет.
+Създайте структура [`DynamicString`], чиито конструктор приема низ с терминираща нула, заделя точно толкова динамична памет, колкото е нужно да се запази целия низ и копира буквите на низа в тази памет.
 Имплементирайте оператор равно.
 
-.question Какви данни трябва `[DynamicString]` да запазва скрито?
+.question Какви данни трябва [`DynamicString`] да запазва скрито?
 
 :question
-Какво трябва оператор равно да направи, ако записваме в `[DynamicString]` с вече заделена памет?\n
+Какво трябва оператор равно да направи, ако записваме в [`DynamicString`] с вече заделена памет?\n
 
 Тоест ако имахме:\n
-`[DynamicString s1("Hello"); DynamicString s2("World"); s2 = s1;]`
+[`DynamicString s1("Hello"); DynamicString s2("World"); s2 = s1;`]
 
 
 ### Задача 5
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week04/Exercise5.cpp Решение]
 
-Имплементирайте структура `[TVProgram]`, която запазва името на предаването като низ от максимум 1024 знака, начало на излъчване и край на излъчване като неотрицателни целочислени числа (като примерно 1347 е един часа и 47 минути следобед).
+Имплементирайте структура [`TVProgram`], която запазва името на предаването като низ от максимум 1024 знака, начало на излъчване и край на излъчване като неотрицателни целочислени числа (като примерно 1347 е един часа и 47 минути следобед).
 Имплементирайте конструктор, деструктор, оператор равно и копиращ конструктор.
 
-Имплементирайте структура `[TVChannel]`, която запазва динамично заделен масив от `[TVProgram]`, размера на динамично заделената памет и броя "ненулеви" елементи (програми, добавени с `[AddProgram]`).
+Имплементирайте структура [`TVChannel`], която запазва динамично заделен масив от [`TVProgram`], размера на динамично заделената памет и броя "ненулеви" елементи (програми, добавени с [`AddProgram`]).
 
-Имплементирайте нейн метод `[AddProgram]`, който приема `[TVProgram]` =[по копие]= и го вмъква на последната свободна позиция в масива.
+Имплементирайте нейн метод [`AddProgram`], който приема [`TVProgram`] [=по копие=] и го вмъква на последната свободна позиция в масива.
 Ако масива е пълен, трябва да го "оразмерите" (да направите нов, по-голям масив, да копирате данните от стария в новия, да изтриете стария и да обновите указателя да сочи към новия).
 
-.question Кога използвате копиращия конструктор на `[TVProgram]` и кога използвате оператор равно?
+.question Кога използвате копиращия конструктор на [`TVProgram`] и кога използвате оператор равно?
 
 ## Трудни задачи
 
@@ -94,7 +94,7 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 [image ./img/Rotation_matrix.png]
 
-Ъгълът на въртене &theta;, спрямо разстоянието до една звезда, се определя чрез [url https://en.wikipedia.org/wiki/Inverse-square_law закона на обратните квадрати], тоест в зависимост от разстоянието `[d]` между центъра на звездата и центъра на планетата, то истинският ъгъл на завъртане е &theta; = &theta;<sub>max</sub> * 1 / d^2.
+Ъгълът на въртене &theta;, спрямо разстоянието до една звезда, се определя чрез [url https://en.wikipedia.org/wiki/Inverse-square_law закона на обратните квадрати], тоест в зависимост от разстоянието [`d`] между центъра на звездата и центъра на планетата, то истинският ъгъл на завъртане е &theta; = &theta;<sub>max</sub> * 1 / d^2.
 
 Допълнително, ако имаме повече от една звезда, тогава ще използваме &theta;' = max(&theta;<sub>i</sub> - average(&theta;<sub>1</sub>, ..., &theta;<sub>n</sub>)), където &theta;<sub>i</sub> е намереният ъгъл &theta; за i-тата звезда и имаме n на брой звезди.
 
@@ -105,11 +105,11 @@ GitHub classroom: [url https://classroom.github.com/a/qa_FfWeG classroom.github.
 
 Имплементирайте структури:
 .bulleted
-- `[Matrix2x2]` и `[Matrix2x1]`, чиито стойности са числа с плаваща запетая, и с член функции за събиране и умножение (не оператор+, оператор\*)
-- `[Coordinate]`, която запазва (=[не наследява]=) точките в пространството като `[Matrix2x1]` и имплементира събиране, умножение и разстояние между координати и матрици
-- `[Star]`, запазваща координатата на своя център (`[Matrix2x1]`) и ъгълът &theta;<sub>max</sub> като число с плаваща запетая.
+- [`Matrix2x2`] и [`Matrix2x1`], чиито стойности са числа с плаваща запетая, и с член функции за събиране и умножение (не оператор+, оператор\*)
+- [`Coordinate`], която запазва ([=не наследява=]) точките в пространството като [`Matrix2x1`] и имплементира събиране, умножение и разстояние между координати и матрици
+- [`Star`], запазваща координатата на своя център ([`Matrix2x1`]) и ъгълът &theta;<sub>max</sub> като число с плаваща запетая.
   Имплементирайте и метод, който приема планета и връща ъгълът &theta;.
-- `[Planet]`, запазваща своите координати (`[Matrix2x1]`) и изминалото време (тоест колко пъти се е движела от началото на симулацията).
-  Имплементирайте метод `[OrbitPlanet]`, която приема планета и ъгъл &theta;', и се завърта около нея.
-- `[Universe]`, запазваща всички звездите и планетата.
-  Имплементирайте метод `[FullOrbit]`, която връща звездата около която планетата е успяла да извърши пълна ротация и времето за което това се е случило.
+- [`Planet`], запазваща своите координати ([`Matrix2x1`]) и изминалото време (тоест колко пъти се е движела от началото на симулацията).
+  Имплементирайте метод [`OrbitPlanet`], която приема планета и ъгъл &theta;', и се завърта около нея.
+- [`Universe`], запазваща всички звездите и планетата.
+  Имплементирайте метод [`FullOrbit`], която връща звездата около която планетата е успяла да извърши пълна ротация и времето за което това се е случило.
diff --git a/src/teaching/oop-2023/week5/index.du b/src/teaching/oop-2023/week5/index.du
index f159418..265e4f7 100644
--- a/src/teaching/oop-2023/week5/index.du
+++ b/src/teaching/oop-2023/week5/index.du
@@ -14,7 +14,7 @@ GitHub classroom: [url https://classroom.github.com/a/42ZZ56Mg classroom.github.
 Една болница има максимален капацититет на болни, които може да държи (максимален брой легла за тях).
 
 Конструктора за болницата приема максималния капацитет, като структурата за болницата пази всичките си пациенти.
-Имплементирайте методи `[AddPatient]`, който добавя нов пациент и `[RemovePatient]`, който го премахва от болницата.
+Имплементирайте методи [`AddPatient`], който добавя нов пациент и [`RemovePatient`], който го премахва от болницата.
 
 Не е нужно данните за пациентите да са скрити, но данните в болницата трябва да са.
 
@@ -22,10 +22,10 @@ GitHub classroom: [url https://classroom.github.com/a/42ZZ56Mg classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week05/Exercise2.cpp Решение]
 
-Имплементирайте структура `[FloatArray]`, която запазва динамично-заделен масив от `[float]` стойности.
+Имплементирайте структура [`FloatArray`], която запазва динамично-заделен масив от [`float`] стойности.
 Размерът на масива се подава в конструктора.
 
-Имплементирайте копиращ конструктор, оператор= и get-ър/set-ър за елемент на индекс `[i]`.
+Имплементирайте копиращ конструктор, оператор= и get-ър/set-ър за елемент на индекс [`i`].
 
 ## Лесни задачи
 
@@ -67,8 +67,8 @@ GitHub classroom: [url https://classroom.github.com/a/42ZZ56Mg classroom.github.
 В началото винаги започва празен.
 Имплементирайте голяма четворка.
 
-Имплементирайте метод `[InsertPerson]`, който вмъква ново име в указателя, като вмъкването запазва сортировка по азбучен ред.
-Тоест ако указателя беше `[{ "Atanas", "Yavor" }]`, тогава след вмъкване на `[Boris]` ще имаме `[{ "Atanas", "Boris", "Yavor" }]`.
+Имплементирайте метод [`InsertPerson`], който вмъква ново име в указателя, като вмъкването запазва сортировка по азбучен ред.
+Тоест ако указателя беше [`{ "Atanas", "Yavor" }`], тогава след вмъкване на [`Boris`] ще имаме [`{ "Atanas", "Boris", "Yavor" }`].
 
 .important Имплементирайте вмъкване, запазващо "сортираност" без функция за сортиране!
 
@@ -77,15 +77,15 @@ GitHub classroom: [url https://classroom.github.com/a/42ZZ56Mg classroom.github.
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week05/Exercise7.cpp Решение]
 
 Имплементирайте структура водомер, която скрито запазва отчетеното количество вода (double).
-Има =[единствено]= конструктор по подразбиране, при който отчетеното количество е нула, метод `[AddWater]`, който увеличава брояча с подаденото количество вода и метод `[Print]`, който изкарва стойността на брояча на екрана.
+Има [=единствено=] конструктор по подразбиране, при който отчетеното количество е нула, метод [`AddWater`], който увеличава брояча с подаденото количество вода и метод [`Print`], който изкарва стойността на брояча на екрана.
 Имплементирайте голяма четворка (когато е нужно).
 
 Имплементирайте структура сграда, която има инсталирани подаден брой водомери.
 
-Имплементирайте метод `[SimulateDay]`, който "симулира" ден в сградата - към всички датчици се добавят между 0 и 0.42 вода (разглеждаме само числа с максимум 3 цифри след запетаята).
+Имплементирайте метод [`SimulateDay`], който "симулира" ден в сградата - към всички датчици се добавят между 0 и 0.42 вода (разглеждаме само числа с максимум 3 цифри след запетаята).
 Количеството е случайно за всеки ден.
 
-Имплементирайте метод `[SimulateMonth]`, който "симулира" 30 дена в сградата, като на всеки 5 дена се прави "отчет" - всичките водомери се =[копират]= и запазват във вътрешен масив.
+Имплементирайте метод [`SimulateMonth`], който "симулира" 30 дена в сградата, като на всеки 5 дена се прави "отчет" - всичките водомери се [=копират=] и запазват във вътрешен масив.
 На края на месеца изкарайте на екрана, на един ред, всичките водомери от първите дни (първи ден на първи отчет, първи ден на втори отчет, ...), вторите дни, ...
 
 ### 8 задача
@@ -93,15 +93,15 @@ GitHub classroom: [url https://classroom.github.com/a/42ZZ56Mg classroom.github.
 Една интернет заявка се характеризира с тип (низ от максимум 4 знака), версия на протокола (положително число с плаваща запетая) и идентификатор (буква).
 Нека тези данни да са скрити, като единствено могат да се set-нат от конструктора (тоест няма set-ъри, но има get-ъри) и е имлементирана голяма четворка (когато е нужно).
 
-Интернет сървър обработва интернет заявки, като всяка получена заявка я запазва в нормалните логове (динамично-заделен масив със заявки) =[и]= в логовете за грешки (друг динамично-заделен масив със заявки).
+Интернет сървър обработва интернет заявки, като всяка получена заявка я запазва в нормалните логове (динамично-заделен масив със заявки) [=и=] в логовете за грешки (друг динамично-заделен масив със заявки).
 
-Разглеждаме четири типа заявки: `[GET]`, `[HEAD]`, `[POST]` и `[PUT]`.
+Разглеждаме четири типа заявки: [`GET`], [`HEAD`], [`POST`] и [`PUT`].
 За всяка сървърът съдържа динамично-заделен масив от низове.
 Имплементирайте методи за добавяне на низ към всеки тип.
 Ако съответния масив от низове е пълен, тогава трябва да го уголемите.
 
-Имплементирайте метод `[HandleRequest]`, който приема интернет заявка =[по копие]=, запазва я в нормалните логове и връща първия низ от масива на съответния тип, който започва с идентификатор-буквата.
-Ако такъв низ не съществува, тогава връща низа "Bad request" и добавя заявката =[и]= в логовете за грешки.
+Имплементирайте метод [`HandleRequest`], който приема интернет заявка [=по копие=], запазва я в нормалните логове и връща първия низ от масива на съответния тип, който започва с идентификатор-буквата.
+Ако такъв низ не съществува, тогава връща низа "Bad request" и добавя заявката [=и=] в логовете за грешки.
 
 Размерите на логовете се подават на конструктора.
 По принцип добавяте нови заявки в края на лога.
diff --git a/src/teaching/oop-2023/week6/index.du b/src/teaching/oop-2023/week6/index.du
index 9a2947e..2662f2c 100644
--- a/src/teaching/oop-2023/week6/index.du
+++ b/src/teaching/oop-2023/week6/index.du
@@ -12,7 +12,7 @@ GitHub classroom: [url https://classroom.github.com/a/rzSTn5pu classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week06/Exercise01.cpp Решение]
 
-Имплементирайте структура `[WoodenPlank]`, която скрито запазва ширина, дължина и височина на дъската (целочислено), цената ѝ (число с плаваща запетая) и типа дърво (низ с максимум 1024 знака).
+Имплементирайте структура [`WoodenPlank`], която скрито запазва ширина, дължина и височина на дъската (целочислено), цената ѝ (число с плаваща запетая) и типа дърво (низ с максимум 1024 знака).
 
 Имплементирайте get-ъри, set-ъри, копиращ конструктор, оператор=
 
@@ -20,7 +20,7 @@ GitHub classroom: [url https://classroom.github.com/a/rzSTn5pu classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week06/Exercise02.cpp Решение]
 
-Имплементирайте структура `[DynamicString]`, която скрито запазва указател към низ (в динамичната памет) и неговия размер.
+Имплементирайте структура [`DynamicString`], която скрито запазва указател към низ (в динамичната памет) и неговия размер.
 
 Имплементирайте голяма четворка.
 
@@ -40,7 +40,7 @@ GitHub classroom: [url https://classroom.github.com/a/rzSTn5pu classroom.github.
 Имплементирайте програма, която приема име на файл от стандартния вход.
 Изкарайте последния ред от файла.
 
-Редовете са разделени със знака `[\\n]`.
+Редовете са разделени със знака [`\\n`].
 
 ### 5 задача
 
@@ -68,7 +68,7 @@ GitHub classroom: [url https://classroom.github.com/a/rzSTn5pu classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week06/Exercise08.cpp Решение]
 
-Имплементирайте структура `[FileBuffer]`, която в конструктора си приема име на файл, отваря го и запазва (копира) цялото му съдържание в динамичната памет (с указател член-данна).
+Имплементирайте структура [`FileBuffer`], която в конструктора си приема име на файл, отваря го и запазва (копира) цялото му съдържание в динамичната памет (с указател член-данна).
 
 .question Кога трябва да затворим файла?
 
@@ -78,27 +78,27 @@ GitHub classroom: [url https://classroom.github.com/a/rzSTn5pu classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week06/Exercise09.cpp Решение]
 
-Имплементирайте структура `[Person]`, която приема име на човек (низ с максимална дължина от 1024 знака) и неговата възраст (целочислена стойност).
-Имплементирайте методи `[Save]` и `[Load]`, които съответно запазват/прочитат данните в (двоичен) файл с подадено име.
+Имплементирайте структура [`Person`], която приема име на човек (низ с максимална дължина от 1024 знака) и неговата възраст (целочислена стойност).
+Имплементирайте методи [`Save`] и [`Load`], които съответно запазват/прочитат данните в (двоичен) файл с подадено име.
 
 ## Трудни задачи
 
 ### 10 задача
 
-Имплементирайте структура `[Table]`, която запазва произволен брой колони и редове с низови стойности.
+Имплементирайте структура [`Table`], която запазва произволен брой колони и редове с низови стойности.
 Броя редове/колони може да се уразмерява по време на изпълнение.
 Имплементирайте голяма четворка.
 
-Имплементирайте методи `[AddRow]` и `[AddColumn]`, които вмъкват подадените стойности като нов ред/колона на дадения индекс.
-Аналогично имплементирайте методи `[RemoveRow]` и `[RemoveColumn]`.
-=[Чрез всички тези]= имплементирайте метода `[ModifyValue]`, който променя стойността на клетката на дадените индекси.
+Имплементирайте методи [`AddRow`] и [`AddColumn`], които вмъкват подадените стойности като нов ред/колона на дадения индекс.
+Аналогично имплементирайте методи [`RemoveRow`] и [`RemoveColumn`].
+[=Чрез всички тези=] имплементирайте метода [`ModifyValue`], който променя стойността на клетката на дадените индекси.
 
-Имплементирайте методи `[Save]` и `[Load]`, които запазват/зреждат таблицата в/от файл с подадено име, в текстовия CSV формат (всеки ред в таблицата е ред във файла, всички стойности в реда от таблицата са разделени със запетая в реда във файла).
+Имплементирайте методи [`Save`] и [`Load`], които запазват/зреждат таблицата в/от файл с подадено име, в текстовия CSV формат (всеки ред в таблицата е ред във файла, всички стойности в реда от таблицата са разделени със запетая в реда във файла).
 
 ### 11 задача
 
-Имплементирайте структура `[City]`, която запазва името на даден град (низ с максимална дължина от 1024 знака) и масив от указатели към други градове, които са негови съседи.
-Имплементирайте методи `[AddNeighbour]` и `[RemoveNeighbour]` (броя съседи може да се променя), както и голяма четворка.
+Имплементирайте структура [`City`], която запазва името на даден град (низ с максимална дължина от 1024 знака) и масив от указатели към други градове, които са негови съседи.
+Имплементирайте методи [`AddNeighbour`] и [`RemoveNeighbour`] (броя съседи може да се променя), както и голяма четворка.
 
-Имплементирайте методи `[Save]` и `[Load]`, които запазват/зреждат всичките достижими градове от сегашния в/от (бинарен) файл с подадено име.
+Имплементирайте методи [`Save`] и [`Load`], които запазват/зреждат всичките достижими градове от сегашния в/от (бинарен) файл с подадено име.
 Подсказвам, че не можете да запазите указателите ей-така.
diff --git a/src/teaching/oop-2023/week7/index.du b/src/teaching/oop-2023/week7/index.du
index 04800db..e3b1044 100644
--- a/src/teaching/oop-2023/week7/index.du
+++ b/src/teaching/oop-2023/week7/index.du
@@ -12,7 +12,7 @@ GitHub classroom: [url https://classroom.github.com/a/vvZENbkX classroom.github.
 
 Една съставка е композирана от низ (с максимална дължина от 511 знака) определящ името ѝ и грамаж (число с плаваща запетая).
 
-Създайте клас `[Recipe]`, към който могат да се прибавят и премахват произволен брой съставки.
+Създайте клас [`Recipe`], към който могат да се прибавят и премахват произволен брой съставки.
 Имплементирайте голяма петица (голяма четворка плюс move семантики) за него.
 
 ### Задача 2 - Работа с файлове
@@ -28,19 +28,19 @@ GitHub classroom: [url https://classroom.github.com/a/vvZENbkX classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week07/Exercise3.cpp Решение]
 
-Имплементирайте клас `[Thermometer]`, който запазва максималната и минималната възможна температура за измерване, както и сегашната температура, всичките които са цели неотрицателни числа.
+Имплементирайте клас [`Thermometer`], който запазва максималната и минималната възможна температура за измерване, както и сегашната температура, всичките които са цели неотрицателни числа.
 
-Имплементирайте методи `[SaveText]` и `[LoadText]`, които съответно записват и четат (тоест член-данните стават равни на тези от файла) данните си в/от =[текстови]= файл с подадено име.
-Аналогично имплементирайте `[SaveBinary]` и `[LoadBinary]`, които работят с =[двоични]= файлове.
+Имплементирайте методи [`SaveText`] и [`LoadText`], които съответно записват и четат (тоест член-данните стават равни на тези от файла) данните си в/от [=текстови=] файл с подадено име.
+Аналогично имплементирайте [`SaveBinary`] и [`LoadBinary`], които работят с [=двоични=] файлове.
 
 ### Задача 4
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week07/Exercise4.cpp Решение]
 
-Имплементирайте клас `[Street]`, който запазва скрито името на улицата като низ с произволна дължина и номер като цяло число.
+Имплементирайте клас [`Street`], който запазва скрито името на улицата като низ с произволна дължина и номер като цяло число.
 Имплементирайте голяма петица.
 
-Имплементирайте методите `[SaveText]`, `[LoadText]`, `[SaveBinary]`, `[LoadBinary]`.
+Имплементирайте методите [`SaveText`], [`LoadText`], [`SaveBinary`], [`LoadBinary`].
 
 ### Задача 5
 
@@ -54,15 +54,15 @@ GitHub classroom: [url https://classroom.github.com/a/vvZENbkX classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week07/Exercise6.cpp Решение]
 
-Имплементирайте клас `[Matrix]`, който запазва стойностите на матрица 2 на 2.
+Имплементирайте клас [`Matrix`], който запазва стойностите на матрица 2 на 2.
 Предефинирайте операторите за инкрементиране, декрементиране, събиране, изваждане, умножение и вход/изход от/към поток.
 
 Имплементирайте четирите функции за записване и четене от файлове.
 
 ### Задача 7
 
-Имплементирайте клас `[Paragraph]`, който съдържа текст с много редове в него.
-Текстът се запазва като низ с произволна дължина, а редовете се разделят със знака `['\\n']`.
+Имплементирайте клас [`Paragraph`], който съдържа текст с много редове в него.
+Текстът се запазва като низ с произволна дължина, а редовете се разделят със знака [`'\\n'`].
 
 Имплементирайте голяма петица.
 Имплементирайте четирите функции за записване и четене от файлове.
@@ -73,7 +73,7 @@ GitHub classroom: [url https://classroom.github.com/a/vvZENbkX classroom.github.
 
 ### Задача 8
 
-Имплементирайте клас `[MatrixNМ]`, който запазва стойностите на матрица с N реда и M колони (подадени на конструктор).
+Имплементирайте клас [`MatrixNМ`], който запазва стойностите на матрица с N реда и M колони (подадени на конструктор).
 
 Имплементирайте голяма петица.
 Имплементирайте четирите функции за записване и четене от файлове.
diff --git a/src/teaching/oop-2023/week8/index.du b/src/teaching/oop-2023/week8/index.du
index 6d48934..4e2270d 100644
--- a/src/teaching/oop-2023/week8/index.du
+++ b/src/teaching/oop-2023/week8/index.du
@@ -10,7 +10,7 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise1.cpp Решение]
 
-Имплементирайте клас `[StreetList]`, който запазва имената на улици (низове с произволна дължина) в динамичен масив.
+Имплементирайте клас [`StreetList`], който запазва имената на улици (низове с произволна дължина) в динамичен масив.
 Може да се добавят нови имена в края на списъка, като съответния (вътрешен) масив трябва да се уголеми.
 
 Имплементирайте голяма петица за класа.
@@ -19,11 +19,11 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise2.cpp Решение]
 
-Имплементирайте клас `[Person]`, който запазва трите имена (низове с произволна дължина) и идентификационния номер (цяло неотрицателно число) на човек.
+Имплементирайте клас [`Person`], който запазва трите имена (низове с произволна дължина) и идентификационния номер (цяло неотрицателно число) на човек.
 Имплементирайте голяма петица.
 
-Имплементирайте методи `[SaveText]` и `[LoadText]`, които съответно записват и четат (тоест член-данните стават равни на тези от файла) данните си в/от =[текстови]= файл с подадено име.
-Аналогично имплементирайте `[SaveBinary]` и `[LoadBinary]`, които работят с =[двоични]= файлове.
+Имплементирайте методи [`SaveText`] и [`LoadText`], които съответно записват и четат (тоест член-данните стават равни на тези от файла) данните си в/от [=текстови=] файл с подадено име.
+Аналогично имплементирайте [`SaveBinary`] и [`LoadBinary`], които работят с [=двоични=] файлове.
 
 ## Лесни
 
@@ -31,13 +31,13 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise3.hpp Решение]
 
-Имплементирайте шаблонната структура `[Pair]`, която приема два типа и запазва по една стойност от всеки тип.
+Имплементирайте шаблонната структура [`Pair`], която приема два типа и запазва по една стойност от всеки тип.
 
 ### Задача 4
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise4.cpp Решение]
 
-Имплементирайте клас `[FloatArray]`, който съдържа списък с числа с плаваща запетая.
+Имплементирайте клас [`FloatArray`], който съдържа списък с числа с плаваща запетая.
 Може да добавяте нови числа в края на този списък.
 Имплементирйате голяма петица.
 
@@ -55,14 +55,14 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise5.hpp Решение]
 
-Имплементирайте класът и неговите оператори от предходната задача като темплейтен (шаблонен) клас с име `[DynamicArray]`.
+Имплементирайте класът и неговите оператори от предходната задача като темплейтен (шаблонен) клас с име [`DynamicArray`].
 Очевидно шаблонния тип определя типа на списъка с елементи.
 
 ### Задача 6
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise6.cpp Решение]
 
-Имплементирайте клас `[NumberInput]`, който запазва целочислена стойност.
+Имплементирайте клас [`NumberInput`], който запазва целочислена стойност.
 В конструктора се подава минимална и максимална възможна стойност, след това (все още в конструктора) се изкарва на екрана съответно съобщение и се приема потребителски вход.
 Ако той не е валиден или е извън подадения обхват, трябва да хвърлите грешка.
 
@@ -74,24 +74,24 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week08/Exercise7.cpp Решение]
 
-Имплементирайте клас `[UserError]`, чиято употреба е да се хвърля като грешка.
+Имплементирайте клас [`UserError`], чиято употреба е да се хвърля като грешка.
 За тази цел нека да запазва два низа, които се приемат в конструктора: името на клас и името на член-данната.
 
 Имплементирайте голяма петица и оператор<<, който изкарва съобщение с информация за класа и член-данната в подадения поток.
-Следете бройката на създадени `[UserError]` инстанции в самия клас (статична променлива) и имплементирате нужната (статична) член-функция, която връща този брой.
+Следете бройката на създадени [`UserError`] инстанции в самия клас (статична променлива) и имплементирате нужната (статична) член-функция, която връща този брой.
 
 Преобразувайте последната задача, така че да хвърля грешка от този клас.
-В края на програмата изкарайте колко грешки са се хвърлили =[използвайки статичните членове на UserError]=.
+В края на програмата изкарайте колко грешки са се хвърлили [=използвайки статичните членове на UserError=].
 
 ## Трудни задачи
 
 ### Задача 8
 
-Имплементирайте шаблонен клас `[UserInput]`, който запазва стойност от подадения тип.
+Имплементирайте шаблонен клас [`UserInput`], който запазва стойност от подадения тип.
 Ако типа е указател, тогава заделяте динамична памет за един такъв елемент.
 За проверка на типа използвайте [url https://en.cppreference.com/w/cpp/language/partial_specialization partial template specialization].
 
-В шаблона (`[template <...>]`) се приема указател към валидираща функция, която приема стойността от съответния тип и връща булева стойност.
+В шаблона ([`template <...>`]) се приема указател към валидираща функция, която приема стойността от съответния тип и връща булева стойност.
 В конструктора се приема от входа нужната стойност и ако стойността е неуспешно приета или валидиращата функция върне false, тогава хвърляте грешка.
 Ако типа е указател, не забравяйте да освободите паметта.
 
@@ -101,7 +101,7 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 
 .important В тази задача се изикват помощни класове, прочетете цялото условие преди имплементиране!
 
-Имплементирайте шаблонен клас `[Dictionary]`, който запазва два динамично-заделени масива: първия е със стойност от подадения тип, втория е с низове.
+Имплементирайте шаблонен клас [`Dictionary`], който запазва два динамично-заделени масива: първия е със стойност от подадения тип, втория е с низове.
 Низовете ще се използват за индексиране, вместо числа.
 Разбира се, очаквайте да може да се уразмерява.
 Имплементирайте голяма петица.
@@ -109,12 +109,12 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
 Имплементирайте оператор:
 
 :bulleted
-- <<=, който вмъква всички стойности от десния `[Dictionary]` в левия
+- <<=, който вмъква всички стойности от десния [`Dictionary`] в левия
 - [], който приема низ и връща референция "към" стойността.
   Ако няма записана стойност на съответния индекс, тогава връщате референция в която може да се запише стойност.
 - [], който приема число, което се конвертира до низ и работи както предходния оператор
 - [], който приема низове (или числа), разделени със запетая и връща "масив" само с тези стойности
-- delete, който приема стойност, върната от оператор[] и "премахва" съответната стойност от `[Dictionary]`
+- delete, който приема стойност, върната от оператор[] и "премахва" съответната стойност от [`Dictionary`]
 - префиксен++, префиксен+ и префиксен-, които ще се използват за итериране.
   .bulleted
   - ++ връща инкрементира индекса на сегашната стойност.
@@ -124,7 +124,7 @@ GitHub classroom: [url https://classroom.github.com/a/7d0MBjcK classroom.github.
   - + връща референция към стойността на сегашния индекс
   - - връща сегашния (низов) индекс
 
-- ->, такъв че можем да правим `[a->(&func1)->(&func2)]` и `[a->[&func3]->[&func4]]`.\n
+- ->, такъв че можем да правим [`a->(&func1)->(&func2)`] и [`a->[&func3]->[&func4]`].\n
   Върху всяка двойка индекс-стойност се прилагат &func1 и &func2 (приемат индекс и стойност като параметри), които връщат нова стойност, заместваща сегашната.\n
   &func3, &func4 аналогично приемат индекс и стойност, но връщат нов индекс.
 
diff --git a/src/teaching/oop-2023/week9/index.du b/src/teaching/oop-2023/week9/index.du
index 56ac747..ac7892b 100644
--- a/src/teaching/oop-2023/week9/index.du
+++ b/src/teaching/oop-2023/week9/index.du
@@ -22,10 +22,10 @@ GitHub classroom: [url https://classroom.github.com/a/wlL1oUg2 classroom.github.
 .solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week09/Exercise2 Решение]
 
 Реализирайте клас Date, който съдържа номера на деня, месеца и годината в три отделни целочислени член-данни.
-Имплементирайте член-методи `[storeText]`, `[storeBinary]`, които съответно запазват данните в текстов файл (във формата "YEAR MONTH DAY") и в двоичен файл с подадени имена.
-Аналогично имплементирайте `[loadText]` и `[loadBinary]`, които презаписват член-данните с тези от подадените (имена на) файлове.
+Имплементирайте член-методи [`storeText`], [`storeBinary`], които съответно запазват данните в текстов файл (във формата "YEAR MONTH DAY") и в двоичен файл с подадени имена.
+Аналогично имплементирайте [`loadText`] и [`loadBinary`], които презаписват член-данните с тези от подадените (имена на) файлове.
 
-В главната функция създайте 5 дати, запазете всяка в =[един и същ текстов файл]=, след това прочетете датите в =[нови]= 5 променливи и изкарайте датите в обратен ред.
+В главната функция създайте 5 дати, запазете всяка в [=един и същ текстов файл=], след това прочетете датите в [=нови=] 5 променливи и изкарайте датите в обратен ред.
 
 ## Лесни
 
@@ -45,10 +45,10 @@ GitHub classroom: [url https://classroom.github.com/a/wlL1oUg2 classroom.github.
 Имплементирайте методите:
 .bulleted
 - от голямата петица
-- `[TransferNextRegion]`, който променя сегашната локация на следващата по ред в текстовия файл (чието име е подадено в конструктор).
+- [`TransferNextRegion`], който променя сегашната локация на следващата по ред в текстовия файл (чието име е подадено в конструктор).
   Ако няма следващо по ред, тогава локацията да си остане същата и да се хвърли грешка.
   Ако се срещнат проблеми с файла, хвърлете грешка.
-- `[SwitchRailLine]`, който приема идентификационен номер на релсовата линия и име на текстов файл, и променя вътрешните стойности.
+- [`SwitchRailLine`], който приема идентификационен номер на релсовата линия и име на текстов файл, и променя вътрешните стойности.
   Съответно локацията трябва да бъде първата в подадения файл.
   Ако се срещнат проблеми с файла, хвърлете грешка.
 
@@ -59,19 +59,19 @@ GitHub classroom: [url https://classroom.github.com/a/wlL1oUg2 classroom.github.
 
 За този клас имплементирайте методите:
 .bulleted
-- `[HaveCollided]`, който приема индекс на два влака и връща дали са се блъснали.
+- [`HaveCollided`], който приема индекс на два влака и връща дали са се блъснали.
   Това се случва ако в една и съща релсова линия и един и същи регион, когато регионът не е последния възможен.
-- `[RunTrains]`, който придвижва напред всички влакове, докато не стигнат финалната си възможна дестинация.
+- [`RunTrains`], който придвижва напред всички влакове, докато не стигнат финалната си възможна дестинация.
   Влакове които са се ударили не се придвижват напред.
   Връщате броя ударили се влакове.
 
 Да се имплементира главна функция, в която приемате име на двоичен файл от потребителя.
 В този файл имате някакъв брой редици с идентификационен номер на релсова линия, брой локации върху съответната линия и всички локации като нормални низове, разделени с нови редове.
 
-Допълнително в главната функция приемайте от потребителя влаковете, като имената на текстовите файлове се избират от програмата (=[НЕ]= от потребителя) според идентификационния номер на релсовата линия и информацията във файла с редиците.
-=[Не може да променяте Train класа!]=
+Допълнително в главната функция приемайте от потребителя влаковете, като имената на текстовите файлове се избират от програмата ([=НЕ=] от потребителя) според идентификационния номер на релсовата линия и информацията във файла с редиците.
+[=Не може да променяте Train класа!=]
 
-Последно в главната функция създайте обект от тип TrainNetwork и изкарайте резултата от `[RunTrains]` на екрана.
+Последно в главната функция създайте обект от тип TrainNetwork и изкарайте резултата от [`RunTrains`] на екрана.
 
 ## Трудни
 
@@ -87,11 +87,11 @@ GitHub classroom: [url https://classroom.github.com/a/wlL1oUg2 classroom.github.
 Имплементирайте методи:
 .bulleted
 - от голямата петица
-- `[AddPassenger]`, който добавя нов човек на дадения индекс на седалка
-- `[RemovePassenger]`, който премахва човека от дадения индекс
-- `[TotalHunger]`, който връща общото количество гладност в колата
-- `[StoreData]`, който запазва всички данни от колата в =[двоичен]= файл с подадено име
-- `[LoadData]`, който презаписва всички данни с тези от подадения по име =[двоичен]= файл
+- [`AddPassenger`], който добавя нов човек на дадения индекс на седалка
+- [`RemovePassenger`], който премахва човека от дадения индекс
+- [`TotalHunger`], който връща общото количество гладност в колата
+- [`StoreData`], който запазва всички данни от колата в [=двоичен=] файл с подадено име
+- [`LoadData`], който презаписва всички данни с тези от подадения по име [=двоичен=] файл
 
 Реализирайте клас DriveThrough, в който се запазват:
 .bulleted
@@ -101,14 +101,14 @@ GitHub classroom: [url https://classroom.github.com/a/wlL1oUg2 classroom.github.
 Имплементирайте методи:
 .bulleted
 - от голяма петица
-- `[QueueUp]`, който приема кола и я вкарва в края на опашката.
+- [`QueueUp`], който приема кола и я вкарва в края на опашката.
   Разбира се, масивът се уголемява ако е нужно.
-- `[Serve]`, който изпълнява поръчката на най-предната кола в опашката.
+- [`Serve`], който изпълнява поръчката на най-предната кола в опашката.
   За единица глад, ресторанта може да сготви достатъчно храна (за да нахрани клиента с "единица" храна) за единици време между половината от дължината на името на ресторанта и три пъти дължината на името на ресторанта време.\n
   Максималното възможно количество време за изпълнение на поръчката варира и според броя коли в опашка: ако са под 6 на брой, тогава тогава се увеличава с 10%, а ако са над 10 тогава се намалява с по 5% за всяка кола след десетата.
-- `[EfficiencyService]`, който изпълнява поръчките на всички коли в опашката и връща средно колко време е отнело на поръчка.
-- `[StoreData]`, който запазва всички данни в =[текстов]= файл с подадено име
-- `[LoadData]`, който презаписва всички данни с тези от подадения по име =[текстов]= файл
+- [`EfficiencyService`], който изпълнява поръчките на всички коли в опашката и връща средно колко време е отнело на поръчка.
+- [`StoreData`], който запазва всички данни в [=текстов=] файл с подадено име
+- [`LoadData`], който презаписва всички данни с тези от подадения по име [=текстов=] файл
 
 Имплементирайте главна функция, в която от потребителския вход приемате име на текстов файл.
-Създайте обект от тип DriveThrough, който да запълни своите стойности с тези от подадения файл и изкарайте на екрана стойността от `[EfficiencyService]`.
+Създайте обект от тип DriveThrough, който да запълни своите стойности с тези от подадения файл и изкарайте на екрана стойността от [`EfficiencyService`].
diff --git a/src/teaching/upp-2023/additional1/index.du b/src/teaching/upp-2023/additional1/index.du
index 70cc715..0356403 100644
--- a/src/teaching/upp-2023/additional1/index.du
+++ b/src/teaching/upp-2023/additional1/index.du
@@ -10,8 +10,8 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 ## Задача - База гаднни
 
-.warn =[Нямате]= право да използвате каквито и да е функции, които вие не сте написали, както и неизучаван материал като двуизмерни масиви или динамична памет.
-=[Не]= употребявайте търсачки, ако ви трябва информация за нещо, ще може да си я изкарате с една проста тестова програма или калкулатор.
+.warn [=Нямате=] право да използвате каквито и да е функции, които вие не сте написали, както и неизучаван материал като двуизмерни масиви или динамична памет.
+[=Не=] употребявайте търсачки, ако ви трябва информация за нещо, ще може да си я изкарате с една проста тестова програма или калкулатор.
 
 \n
 
@@ -41,7 +41,7 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 Стойностите от таблица А са винаги ограничени отгоре с най-големия брой битове, които комфортно може да поберем в 7 цифри.
 Тоест 9999999 не е валидна стойност от таблица А, докато 8388608 e.
 
-.question Колко най-много *[битове]* можем със сигурност да поберем в 7 цифри?
+.question Колко най-много [*битове*] можем със сигурност да поберем в 7 цифри?
 
 Понеже редовете са от 1 до 9, ако в таблица А имаме ред 0 правим нещо специално, но това ще видите в бъдеще.
 
@@ -51,13 +51,13 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 Преди да започнем, трябва да имплементираме функция, която разделя дадения ред от таблица А на трите му компонента (ред, тип и стойност):
 
-`[getRow]` - приема ред от таблица А и указатели към променливи за ред, тип и стойност; не връща нищо\n
+[`getRow`] - приема ред от таблица А и указатели към променливи за ред, тип и стойност; не връща нищо\n
 В подадените указатели пази съответните стойности от реда
 
 .question Защо приемаме указатели към променливи? Каква е "сигнатурата" на функцията?
 
 \n
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Извикване
@@ -82,11 +82,11 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 Имплементирайте функция:
 
-`[parseNumber]` - приема стойност от таблица А и ред от таблица Б; връща полученото число от тези стойности
+[`parseNumber`] - приема стойност от таблица А и ред от таблица Б; връща полученото число от тези стойности
 
 \n
-=[Примери:]=
-*[Възможно е отклонението на последния пример да бъде повече от 2 единици]*
+[=Примери:=]
+[*Възможно е отклонението на последния пример да бъде повече от 2 единици*]
 
 :table_2
 |= Извикване
@@ -137,7 +137,7 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 |: 11010
 |: 26
-|: *[шпация]*
+|: [*шпация*]
 
 |: 11011
 |: 27
@@ -160,20 +160,20 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 |: !
 
 
-Тоест ако в нашия тип данни запазваме само 10 бита, тогава числото "2" ще бъде `[0000000010]` и имаме низа "AC".
+Тоест ако в нашия тип данни запазваме само 10 бита, тогава числото "2" ще бъде [`0000000010`] и имаме низа "AC".
 Игнорирайте старшите битове, които остават като "остатък" (по-малко от 5 бита ширина).
 
 .question Колко бита наистина запазваме в нашия тип данни? Колко бита ще трябва да игнорираме? Колко най-много букви може да поберем?
 
 Имплементирайте функция:
 
-`[decodeNumberText]` - приема ред от таблица Б и указател към "низ"; не връща нищо\n
+[`decodeNumberText`] - приема ред от таблица Б и указател към "низ"; не връща нищо\n
 Записва декодиран текстът от реда в указателя
 
 .question Нарочно има кавички около думата "низ", какъв трябва наистина да е типа на указателя?
 
 \n
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Извикване
@@ -192,7 +192,7 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 ### г) числов текст (част две)
 
 Дотук добре, обаче не сме свършили съвсем.
-От гледна точка на сигурност, искаме дори някой да получи достъп до таблица Б, да не може да разбере текста дори след като е използвал `[decodeNumberText]`.
+От гледна точка на сигурност, искаме дори някой да получи достъп до таблица Б, да не може да разбере текста дори след като е използвал [`decodeNumberText`].
 
 Ще използваме [url https://en.wikipedia.org/wiki/Caesar_cipher шифъра на Цезар]: един много прост шифър, където отместваме позицията на всяка буква с няколко места "напред".
 Тоест, при отместаване 3, буквата A става D, B става E, и так. нат.
@@ -205,11 +205,11 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 Промененте функцията:
 
-`[decodeNumberText]` - приема ред от таблица Б, стойност от таблица А и указател към "низ"; не връща нищо\n
+[`decodeNumberText`] - приема ред от таблица Б, стойност от таблица А и указател към "низ"; не връща нищо\n
 След като декодира текста от реда от Б, дешифрира го със стойността от таблица А
 
 \n
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Извикване
@@ -246,11 +246,11 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 Имплементирайте функцията:
 
-`[decodeArray]` - приема ред от таблица Б и указател към масив; не връща нищо\n
+[`decodeArray`] - приема ред от таблица Б и указател към масив; не връща нищо\n
 Декодира елементите от реда и ги запазва в указателя
 
 \n
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Извикване
@@ -267,19 +267,19 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 В старшите 20 бита от стойността в таблица А ще пазим общо 5 възможни валидни стойности, а в останалите (младши) 3 бита ще пазим индекс към тези стойности, който индекс (започвайки от 1) определя стойността по подразбиране.
 
-Пример: ако имаме побитово `[1111100000100011101101010101]`, тогава:
+Пример: ако имаме побитово [`1111100000100011101101010101`], тогава:
 .bulleted
-- валидните числа са `[11111, 00000, 10001, 11011 и 01010]`
-- числото по подразбиране е 5-тото (`[101 = 5]`), което е числото `[01010]`
-- ако от реда в Б изкараме `[11011]`, тогава го запазваме, обаче ако изкараме примерно `[11000]` тогава го превръщаме в стойността по подразбиране, а именно `[01010]`
+- валидните числа са [`11111, 00000, 10001, 11011 и 01010`]
+- числото по подразбиране е 5-тото ([`101 = 5`]), което е числото [`01010`]
+- ако от реда в Б изкараме [`11011`], тогава го запазваме, обаче ако изкараме примерно [`11000`] тогава го превръщаме в стойността по подразбиране, а именно [`01010`]
 
 Разширете функцията:
 
-`[decodeArray]` - приема стойност от таблица А, ред от таблица Б и указател към масив; не връща нищо\n
+[`decodeArray`] - приема стойност от таблица А, ред от таблица Б и указател към масив; не връща нищо\n
 Декодира елементите от реда, като всички невалидни стойност се превръщат в стойността по подразбиране, и ги запазва в указателя
 
 \n
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Извикване
@@ -306,15 +306,15 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 .comment                   000    001    010    011    100    101
 
 :bulleted
-- Kриптографски ред е `[00000, 10101, 11011, 10001, 01101, 10100]`
+- Kриптографски ред е [`00000, 10101, 11011, 10001, 01101, 10100`]
   .bulleted
   - Индексираме от 0 до 5, което побитово е от 000 до 101
 
-- Стойност в таблицата А е `[011001000001101101]`
+- Стойност в таблицата А е [`011001000001101101`]
   .bulleted
-  - Разделяйки го на индекси, това са `[011, 001, 000, 001, 101, 101]`
+  - Разделяйки го на индекси, това са [`011, 001, 000, 001, 101, 101`]
 
-- Слепвайки от криптографския ред на тези индекси получаваме `[100011010100000101011010010100]`
+- Слепвайки от криптографския ред на тези индекси получаваме [`100011010100000101011010010100`]
 
 
 Във вашата програма ще се наложи да направите още една променлива, в която пазите криптографския ред.
@@ -326,10 +326,10 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 Напишете функция:
 
-`[decompress]` - приема стойност от таблица А, криптографски ред, указател за запазване на декомпресираната стойност от таблица А и указател за запазване на декомпресирания ред от таблица Б; не връща нищо
+[`decompress`] - приема стойност от таблица А, криптографски ред, указател за запазване на декомпресираната стойност от таблица А и указател за запазване на декомпресирания ред от таблица Б; не връща нищо
 
 \n
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Извикване
@@ -352,22 +352,22 @@ GitHub classroom: [url https://classroom.github.com/a/nlFuKALw classroom.github.
 
 След това получавате команди (знак):
 .bulleted
-- `[g X]`: изкарвате на екрана стойността в базата данни, започвайки с ред X от таблица А
-- `[i]`: Връщате информация за базата данни
-- `[q]`: спиране на програмата
+- [`g X`]: изкарвате на екрана стойността в базата данни, започвайки с ред X от таблица А
+- [`i`]: Връщате информация за базата данни
+- [`q`]: спиране на програмата
 
 ### й) заявки
 
 .bulleted
-- `[t X]`: връщате броя и след това всички редове от таблица А с тип X
-- `[r X]`: връщате броя и всички редове от таблица А, които използват реда Х\n
+- [`t X`]: връщате броя и след това всички редове от таблица А с тип X
+- [`r X`]: връщате броя и всички редове от таблица А, които използват реда Х\n
   Ако реда е 0, тогава трябва да върнете и размера на криптографския ред
 
 ### к) презаписване в базата данни
 
 .bulleted
-- `[w T R V]`: запазвате (презаписвате) стойност V в таблица Т (може да бъде `[A]` или `[B]`) на ред R
-- `[s T V]`: запазвате стойност V от тип Т в базата данни\n
+- [`w T R V`]: запазвате (презаписвате) стойност V в таблица Т (може да бъде [`A`] или [`B`]) на ред R
+- [`s T V`]: запазвате стойност V от тип Т в базата данни\n
   Пробвате се да я запазите, използвайки и двете таблици, но ако Б вече е запълнена, добавяте я като компресирана стойност в таблица А.
   Ако и А е запълнена, изкарвате съобщение за запълнена база данни и не запазвате стойността.
 
diff --git a/src/teaching/upp-2023/additional2/index.du b/src/teaching/upp-2023/additional2/index.du
index d562120..953288a 100644
--- a/src/teaching/upp-2023/additional2/index.du
+++ b/src/teaching/upp-2023/additional2/index.du
@@ -12,7 +12,7 @@ GitHub classroom: [url https://classroom.github.com/a/CrerXpf6 classroom.github.
 
 Ще направим един прост текстов редактор.
 От входа ще получавате редове текст, в общия случай редовете ще бъдат някакво текстово съдъражение, което ще трябва да запазите в паметта.
-Определени редове ще имат команди, чрез които ще *[редактирате]* вече въведения текст.
+Определени редове ще имат команди, чрез които ще [*редактирате*] вече въведения текст.
 
 Задачата е сравнително голяма, затова е разделена на подточки, като всяка надгражда предходната.
 
@@ -26,10 +26,10 @@ GitHub classroom: [url https://classroom.github.com/a/CrerXpf6 classroom.github.
 Използвайте многомерен масив за запазване на редовете, вместо всичко да се запазва в един голям низ.
 Това е нужно за бъдещи подточки.
 
-*[Само за тестване]*, набързо имплементирайте проверка, ако първата буква от реда е `[Q]`, тогава програмата да спре да приема вход, да изкара въведения текст до сега и да приключи.
+[*Само за тестване*], набързо имплементирайте проверка, ако първата буква от реда е [`Q`], тогава програмата да спре да приема вход, да изкара въведения текст до сега и да приключи.
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -44,7 +44,7 @@ est. It was a high bank, and he paused to breathe at the top.
 
 ### б) функция за извеждане на команди
 
-Команда е един ред текст, като първата буква, различна от шпация, е `[:]`.
+Команда е един ред текст, като първата буква, различна от шпация, е [`:`].
 След нея има нула или повече шпации и още една буква, тази буква определя коя команда искаме да използваме.
 В зависимост от командата, може да имаме параметри, поставени след буквата за командата.
 Параметрите не съдържат шпации и параметрите са разделени помежду си с поне една шпация.
@@ -55,7 +55,7 @@ est. It was a high bank, and he paused to breathe at the top.
 
 Командите не се запазват като част от текста.
 
-Имплементирайте функция `[extractCommand]`, която приема низ.
+Имплементирайте функция [`extractCommand`], която приема низ.
 Ако низът е команда, тогава връща масив от низове, първия от които съдържа буквата, определяща командата, докато останалите низове са параметрите.
 Ако низът не е команда, тогава връща празен масив.
 
@@ -65,11 +65,11 @@ est. It was a high bank, and he paused to breathe at the top.
 
 .question Как ще върнем масив? Нужно ли е да връщаме бройката елементи?
 
-*[Само за тестване]*, след всеки въведен ред, ако е команда, изкарайте извлечените стойности от `[extractCommand]`, със запетайки след всяка.
-Като при [url #section подточка a)], ако редът започва с `[Q]`, спирате приемане на вход и изкарвате запазения текст.
+[*Само за тестване*], след всеки въведен ред, ако е команда, изкарайте извлечените стойности от [`extractCommand`], със запетайки след всяка.
+Като при [url #section подточка a)], ако редът започва с [`Q`], спирате приемане на вход и изкарвате запазения текст.
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -94,10 +94,10 @@ est. It was a high bank, and he paused to breathe at the top.
 
 ### в) команда print
 
-Имплементирайте функция `[print]`, която приема масив, съдържащ целия запазен текст, и го изкарва на екрана, като преди всеки ред изкарва неговия номер (първи ред има номер 1, втори има номер 2, так. нат.) с =[вмъкнати водещи нули]= (така че всяко число да бъде съставено от един и същ брой знаци).
+Имплементирайте функция [`print`], която приема масив, съдържащ целия запазен текст, и го изкарва на екрана, като преди всеки ред изкарва неговия номер (първи ред има номер 1, втори има номер 2, так. нат.) с [=вмъкнати водещи нули=] (така че всяко число да бъде съставено от един и същ брой знаци).
 Ако текстът е празен, не изкарва нищо.
 
-Тоест, ако сме въвели текст от 7 реда, `[print]` ще изкара:
+Тоест, ако сме въвели текст от 7 реда, [`print`] ще изкара:
 
 ```terminal
 1 First line
@@ -130,16 +130,16 @@ est. It was a high bank, and he paused to breathe at the top.
 ...
 130 Last line
 
-Командата, която използва тази функция, се определя с главната буква `[P]` и няма параметри.
+Командата, която използва тази функция, се определя с главната буква [`P`] и няма параметри.
 
-За всички команди (за момента само `[P]`):
+За всички команди (за момента само [`P`]):
 .bulleted
 - Обновете програмата, така че при валидна команда, да изпълни съответната и функция и да продължи изпълнение.
 - Ако срещнете недефинирана команда, трябва да изкарате на екрана "; Not an editor command" и изпълнението на програмата да продължи.
 - Ако срещнете допълнителни/излишни параметри, трябва да изкарате "; Excess parameters", но функцията да се изпълни с коректния брой параметри.
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -164,11 +164,11 @@ est. It was a high bank, and he paused to breathe at the top.
 
 ### г) команда quit
 
-Вече може да премахнете временната функционалност, където ако реда започва с `[Q]` програмата спира и изкарва целия текст.
-Добавете командата `[Q]`, която изкарва на екрана целия текст (без номера на редове) и спира програмата.
+Вече може да премахнете временната функционалност, където ако реда започва с [`Q`] програмата спира и изкарва целия текст.
+Добавете командата [`Q`], която изкарва на екрана целия текст (без номера на редове) и спира програмата.
 
-=[Примери:]=
-*[Смесен вход/изход]*
+[=Примери:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -187,14 +187,14 @@ the man turned aside from the main Yukon trail. He climbed the high
 
 ### д) команда delete
 
-Имплементирайте функцията `[deleteRow]`, която получава целия текст, въведен до сега, и номер на реда (редовете се индексират от 1 до N).
+Имплементирайте функцията [`deleteRow`], която получава целия текст, въведен до сега, и номер на реда (редовете се индексират от 1 до N).
 Тя променя текста, като премахва реда на дадения номер.
 
-.important Не забравяйте да промените размера на масива с низове! Не е решение просто да промените указателя към дадения ред на `[nullptr]`, не искаме да използваме излишна памет.
+.important Не забравяйте да промените размера на масива с низове! Не е решение просто да промените указателя към дадения ред на [`nullptr`], не искаме да използваме излишна памет.
 
 .question Какъв ще бъде типа на аргумента, който приема целия текст?
 
-Добавете командата `[D]`, която приема един параметър - цяло положително число, и го прилага върху функцията `[deleteRow]`.
+Добавете командата [`D`], която приема един параметър - цяло положително число, и го прилага върху функцията [`deleteRow`].
 Ако номера на реда е невалиден, трябва да изкарате съобщение "; Invalid row number".
 
 Имплементирайте следните функционалности за всички команди:
@@ -203,8 +203,8 @@ the man turned aside from the main Yukon trail. He climbed the high
 - Ако даден параметър на команда е от невалиден тип (подадени букви, когато се иска число, примерно), изкарайте "; Invalid parameter type".
   Единствените типове на параметри са цели числа и произволни низове (без шпации).
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 dAY HAD DAWNED COLD AND GRAY WHEN
@@ -240,16 +240,16 @@ earth-bank where a little-traveled trail led east through the pine for-
 
 ### e) команда insert
 
-Имплементирайте функция `[insertRow]`, която приема целия текст, низ и номер на реда.
-Функцията вмъква низа в целия текст като ред =[над]= този на подадения номер.
+Имплементирайте функция [`insertRow`], която приема целия текст, низ и номер на реда.
+Функцията вмъква низа в целия текст като ред [=над=] този на подадения номер.
 Ако номерът е над броя въведени редове до сега, редът се вмъква като последен.
 
-Добавете команда `[O]`, която приема един параметър - неотрицателен ред.
-Следващия написан ред ще се вмъкне преди реда на дадения номер, използвайки функцията `[insertRow]`.
+Добавете команда [`O`], която приема един параметър - неотрицателен ред.
+Следващия написан ред ще се вмъкне преди реда на дадения номер, използвайки функцията [`insertRow`].
 Ако номера е невалиден изкарва "; Invalid row number".
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 the man turned aside from the main Yukon trail. He climbed the high
@@ -285,19 +285,19 @@ He excused
 
 ### ж) команда join
 
-Имплементирайте функция `[joinRows]`, която приема текстът, въведен до сега, и номер на ред N.
+Имплементирайте функция [`joinRows`], която приема текстът, въведен до сега, и номер на ред N.
 Функцията вмъква текста от ред N+1 в края на ред N, като ги разделя с една шпация.
 Ред N+1 се изтрива.
 Ако N е 0 или номера на последния ред, не прави нищо.
 
-.important Не забравяйте да промените размера на масива с низове! Не е решение просто да промените указателя към дадения ред на `[nullptr]`, не искаме да използваме излишна памет.
+.important Не забравяйте да промените размера на масива с низове! Не е решение просто да промените указателя към дадения ред на [`nullptr`], не искаме да използваме излишна памет.
 
-Добавете команда `[J]`, която приема номер на ред - положително число.
-Следващия ред ще се вмъкне в края на сегашния, с една шпация между тях, използвайки функцията `[joinRows]`.
+Добавете команда [`J`], която приема номер на ред - положително число.
+Следващия ред ще се вмъкне в края на сегашния, с една шпация между тях, използвайки функцията [`joinRows`].
 При подаден невалиден ред изкарвате "; Invalid row number".
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED
@@ -328,16 +328,16 @@ the man turned aside from the main Yukon trail. He climbed the high
 
 ### з) команда word info
 
-Имплементирайте функция `[wordOccurrences]`, която приема целия текст и дума (низ без шпации).
+Имплементирайте функция [`wordOccurrences`], която приема целия текст и дума (низ без шпации).
 Тя изкарва на екрана броя на срещания на дадената дума в целия текст, като изхода е във формата "; N occurrences" (където N е броя на срещания).
 
-*[Подсказвам, че за следващата подточка ще е полезно ако първо имплементирате функция, която връща броя срещания на дума в един ред.]*
+[*Подсказвам, че за следващата подточка ще е полезно ако първо имплементирате функция, която връща броя срещания на дума в един ред.*]
 
-Добавете команда `[n]`, която приема един аргумент - низ беш шпации.
-Използвайки `[wordOccurrences]` изкарва броя срещания на дадена дума в целия текст.
+Добавете команда [`n`], която приема един аргумент - низ беш шпации.
+Използвайки [`wordOccurrences`] изкарва броя срещания на дадена дума в целия текст.
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -360,13 +360,13 @@ est. It was a high bank, and he paused to breathe at the top.
 
 ### и) команда word substitute
 
-Имплементирайте функция `[substituteWord]`, която приема целия текст и две думи (низове без шпации).
+Имплементирайте функция [`substituteWord`], която приема целия текст и две думи (низове без шпации).
 В текстът, всяко срещане на първата дума е заменено с втората дума.
 
 .question Какво ще стане с размера на един ред, ако някоя дума/някои думи трябва да се заменят?
 
-Добавете команда `[s]`, която приема две думи - низове без шпации.
-Използвайки функцията `[substituteWord]` замества всяко срещане на първата дума с втората.
+Добавете команда [`s`], която приема две думи - низове без шпации.
+Използвайки функцията [`substituteWord`] замества всяко срещане на първата дума с втората.
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
@@ -397,21 +397,21 @@ est. It was a high bank, and he paused to breathe at the top.
 
 ### й) команда word delete
 
-Имплементирайте функция `[deleteWord]`, която приема целия текст и дума (низ без шпации).
-В текстът, всяко срещане на думата, заедно с *[излишните]* шпации около нея, са премахнати.
+Имплементирайте функция [`deleteWord`], която приема целия текст и дума (низ без шпации).
+В текстът, всяко срещане на думата, заедно с [*излишните*] шпации около нея, са премахнати.
 Ето в кои случаи шпации са излишни (където "WORD" е подадената дума, която ще изтрием, а "\_" е някаква буква, която не е шпация):
 .bulleted
-- `[WORD _]` (WORD е в началото на реда или има знаци преди нея) - шпацията след думата е излишна, трябва да стане `[_]`.
-  Отбелязвам, че шпациите в ляво се запазват: `[   WORD _]` става `[   _]`.
-- `[_ WORD]` (WORD е в края на реда или има знаци след нея) - шпацията преди думата е излишна, трябва да стане `[_]`.
-- `[_ WORD _]` - шпацията, която следва думата, е излишна, тоест трябва да стане `[_ _]`.
-  Трябва да отбележа, че шпациите в ляво се запазват така както са: `[_   WORD _]` става `[_   _]`.
+- [`WORD _`] (WORD е в началото на реда или има знаци преди нея) - шпацията след думата е излишна, трябва да стане [`_`].
+  Отбелязвам, че шпациите в ляво се запазват: [`   WORD _`] става [`   _`].
+- [`_ WORD`] (WORD е в края на реда или има знаци след нея) - шпацията преди думата е излишна, трябва да стане [`_`].
+- [`_ WORD _`] - шпацията, която следва думата, е излишна, тоест трябва да стане [`_ _`].
+  Трябва да отбележа, че шпациите в ляво се запазват така както са: [`_   WORD _`] става [`_   _`].
 
 Във всичките случаи, като имам предвид "шпацията е излишна", означава че тази шпация, заедно с всички съседни.
-Тоест, `[WORD    _]` трябва да стане `[_]`, а не `[  _]`.
+Тоест, [`WORD    _`] трябва да стане [`_`], а не [`  _`].
 
-Добавете команда `[d]`, която приема един параметър - дума, низ без шпации.
-Използвайки функцията `[deleteWord]` премахва самата дума и излишните шпации.
+Добавете команда [`d`], която приема един параметър - дума, низ без шпации.
+Използвайки функцията [`deleteWord`] премахва самата дума и излишните шпации.
 
 ```terminal
 DAY HAD DAWNED COLD AND GRAY WHEN
diff --git a/src/teaching/upp-2023/index.du b/src/teaching/upp-2023/index.du
index a868af4..50ced66 100644
--- a/src/teaching/upp-2023/index.du
+++ b/src/teaching/upp-2023/index.du
@@ -6,11 +6,11 @@
 От сега нататък ще може да продължите да предавате решения след крайния срок в classroom.
 Не мога да гарантирам кога ще погледна предадени решения след срока, но ще ги погледна!
 
-=[Зала:]= ФМИ 309 ||
-=[Време:]= 10:15 - 12:00 ||
-=[Ден:]= Петък
+[=Зала:=] ФМИ 309 ||
+[=Време:=] 10:15 - 12:00 ||
+[=Ден:=] Петък
 \n
-=[Директни връзки:]=
+[=Директни връзки:=]
 [url ./week1/welcome.html?a#section-4 Контакт с мен] |
 [url https://github.com/Syndamia/upp-2023-solutions Решения на задачи] |
 [url https://github.com/ivanahristova/introduction-to-programming-2023-2024 Материали от семинари] |
diff --git a/src/teaching/upp-2023/week1/index.du b/src/teaching/upp-2023/week1/index.du
index 926d021..e41a297 100644
--- a/src/teaching/upp-2023/week1/index.du
+++ b/src/teaching/upp-2023/week1/index.du
@@ -18,7 +18,7 @@ GitHub classroom: [url https://classroom.github.com/a/W7hZDMgC classroom.github.
 
 Във входа получавате цифра, трябва да върнете нейната числена стойност, умножена по две.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -31,7 +31,7 @@ GitHub classroom: [url https://classroom.github.com/a/W7hZDMgC classroom.github.
 |: 16
 
 
-=[Упътване:]=
+[=Упътване:=]
 Цифрата е просто знак, и за да извършите коректно умножението трябва да превърнете знака в число.
 
 ### 3 задача - От Фаренхайт в Целзий
@@ -43,7 +43,7 @@ GitHub classroom: [url https://classroom.github.com/a/W7hZDMgC classroom.github.
 ```
 C = (F - 32) * 5/9
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week1/setup.du b/src/teaching/upp-2023/week1/setup.du
index 9865737..6b22df6 100644
--- a/src/teaching/upp-2023/week1/setup.du
+++ b/src/teaching/upp-2023/week1/setup.du
@@ -34,16 +34,16 @@
 
 .p
 git е програма (система) за [url https://en.wikipedia.org/wiki/Distributed_version_control контрол на версиите].
-В един проект, git пази =[списък от всички commit-и]=.
-Един commit в себе си =[съдържа какви са точно промените]=, кой ги е направил, кога са направени, защо са направени и так. нат.
-Този списък, заедно с още неща за които не е нужно да мислите, се нарича =[repository]=.
+В един проект, git пази [=списък от всички commit-и=].
+Един commit в себе си [=съдържа какви са точно промените=], кой ги е направил, кога са направени, защо са направени и так. нат.
+Този списък, заедно с още неща за които не е нужно да мислите, се нарича [=repository=].
 
 .p
-Обаче, =[commit-ове не се правят автоматично]=, не е като историята с промени в един Word файл.
-=[Commit се прави от разработчика]=, и то за предпочитане на всеки няколко (свързани) промени.
+Обаче, [=commit-ове не се правят автоматично=], не е като историята с промени в един Word файл.
+[=Commit се прави от разработчика=], и то за предпочитане на всеки няколко (свързани) промени.
 
 .p
-Така, когато смесваме кода от многото разработчици, ще можем да засечем =[какви точно са различията]= между работата на двама човека.\n
+Така, когато смесваме кода от многото разработчици, ще можем да засечем [=какви точно са различията=] между работата на двама човека.\n
 Често промените не си "противоречат" и могат да бъдат смесени директно, понякога се налага ръчно да решим какво точно да се случи с тези парчета код.
 
 
@@ -111,7 +111,7 @@ git е програма (система) за [url https://en.wikipedia.org/wiki
 За всеки практикум ще ви направя линк, чрез който след малко кликане ще се създаде ново лично repository за всеки от вас.
 
 .p
-До 12:20 трябва да сте качили работата си =[по време]= на упражнението в това repository.
+До 12:20 трябва да сте качили работата си [=по време=] на упражнението в това repository.
 GitHub предоставя лесни начини да правите промени по файлове директно чрез браузъра, така че за незаинтересуваните, може да го ползвате като усложнен Google Drive.
 
 .p
@@ -198,14 +198,14 @@ GitHub предоставя лесни начини да правите пром
 [$br2]
 
 .p
-=[Кодът е чисто и просто текст]=, компилаторът е специалната програма, която превръща този текст в нещо, което може компютъра да изпълни.
+[=Кодът е чисто и просто текст=], компилаторът е специалната програма, която превръща този текст в нещо, което може компютъра да изпълни.
 
 .p
-За писане и редактиране на текст ползваме =[текстови редактори]=.
+За писане и редактиране на текст ползваме [=текстови редактори=].
 Програмистите са искали да улеснят работата си, затова модерните текстови редактори поддържат много помощни функционалности: показване на грешки на точния ред, автоматично форматиране, ...
 
 .p
-За някои и това не е било достатъчно удобно, затова са създадени =[Integrated Development Environment]= (IDE), програми които съдържат в себе си всичко нужно за разработка на код.
+За някои и това не е било достатъчно удобно, затова са създадени [=Integrated Development Environment=] (IDE), програми които съдържат в себе си всичко нужно за разработка на код.
 Тоест, те са текстови редактори, но "вградено" могат да компилират код, да менижират сегашното repository, ...
 
 
@@ -356,7 +356,7 @@ GitHub предоставя лесни начини да правите пром
 В Solution Explorer имате всички файлове от проекта (Visual Studio позволява да групирате няколко проекта в едно, наречено Solution, не е нужно да се занимавате).
 
 .p
-Тук =[единственото важно за вас се намира в папката "Source Files"]=.
+Тук [=единственото важно за вас се намира в папката "Source Files"=].
 В нея ще се намира вашия код, всичко останало са допълнителни неща, които са релевантни за по-големи проекти.
 
 
@@ -430,9 +430,9 @@ Visual Studio предоставя много функционалности, к
 Най-елементарния начин: копирате всичко, след това отивате на вашето GitHub repository, кликвате "Add", после "Create new file".
 
 .p
-Отгоре на "Name your file..." пишете някакво име, което =[моля да завърша на `[.cpp]`!]=
+Отгоре на "Name your file..." пишете някакво име, което [=моля да завърша на [`.cpp`]!=]
 Това показва, че файла съдържа код на C++.
-Също, когато решавате много задачи и създавате много такива файлове, =[напомням че имената на файловете трябва да са различни.]=
+Също, когато решавате много задачи и създавате много такива файлове, [=напомням че имената на файловете трябва да са различни.=]
 
 .p
 В "Enter file contents here" пействате копирания код.
diff --git a/src/teaching/upp-2023/week1/welcome.du b/src/teaching/upp-2023/week1/welcome.du
index e1690a2..6821e67 100644
--- a/src/teaching/upp-2023/week1/welcome.du
+++ b/src/teaching/upp-2023/week1/welcome.du
@@ -93,7 +93,7 @@
 - Имейл:
   .bulleted
   - <a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#107;&#97;&#109;&#101;&#110;&#46;&#100;&#46;&#109;&#108;&#97;&#100;&#101;&#110;&#111;&#118;&#64;&#112;&#114;&#111;&#116;&#111;&#110;&#109;&#97;&#105;&#108;&#46;&#99;&#111;&#109;">&#107;&#97;&#109;&#101;&#110;&#46;&#100;&#46;&#109;&#108;&#97;&#100;&#101;&#110;&#111;&#118;&#64;&#112;&#114;&#111;&#116;&#111;&#110;&#109;&#97;&#105;&#108;&#46;&#99;&#111;&#109;</a> <a class="borderless" href="/files/publickey-&#107;&#97;&#109;&#101;&#110;&#46;&#100;&#46;&#109;&#108;&#97;&#100;&#101;&#110;&#111;&#118;&#64;&#112;&#114;&#111;&#116;&#111;&#110;&#109;&#97;&#105;&#108;&#46;&#99;&#111;&#109;-62ca52e87475c874b9e6ebf3c4c9f716b6ce4c9d.asc"><img class="borderless unzoomable" src="/img/pgpkey.gif" alt="PGP key"></a>
-  - <a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;">&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;</a> <a class="borderless" href="/files/publickey-&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;-0x354C5F95.asc"><img class="borderless unzoomable" src="/img/pgpkey.gif" alt="PGP key"></a> =[(гледайте си спама!)]=
+  - <a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;">&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;</a> <a class="borderless" href="/files/publickey-&#107;&#097;&#109;&#101;&#110;&#064;&#115;&#121;&#110;&#100;&#097;&#109;&#105;&#097;&#046;&#099;&#111;&#109;-0x354C5F95.asc"><img class="borderless unzoomable" src="/img/pgpkey.gif" alt="PGP key"></a> [=(гледайте си спама!)=]
   - [url mailto:kdmladenov@uni-sofia.bg kdmladenov@uni-sofia.bg]
 
 
@@ -112,7 +112,7 @@
 - Ще гледам винаги да има задачи с връзка към реален софтуер.
   За любителите, където е възможно, ще добавям външни препратки.
 
-- Давам ви *[много]* повече задачи, отколкото очаквам да решите на живо!\n
+- Давам ви [*много*] повече задачи, отколкото очаквам да решите на живо!\n
   Хубаво е да имате с какво още да се упражните след практикума, 2 часа писане на код седмично е малко!
 
 - Ще качвам решения на задачите, заедно с подробно коментари върху тях, тук: [url https://github.com/Syndamia/upp-2023-solutions github.com/Syndamia/upp-2023-solutions].
@@ -163,11 +163,11 @@
 
 :font35
 :unordered
-- =[НЕ плагиатствайте!]=
-  =[НЕ си качвайте решенията на контролни или домашни онлайн!]=
+- [=НЕ плагиатствайте!=]
+  [=НЕ си качвайте решенията на контролни или домашни онлайн!=]
   Формално плагиатството е незаконно, ако някой Ви направи доклад, възможно е да бъдете изключени.
 
-- =[Следвайте материала, който ви се преподава!]=
+- [=Следвайте материала, който ви се преподава!=]
   За хората с опит, ще дойде време когато ще искате да приложите лични знания и практики.
   Ако не е казано някъде, не го правите и не го обмисляте!
 
@@ -189,7 +189,7 @@
 
 :font22
 Ще си позволя едно отклонение.\n
-Искам да обясня как =[аз лично]= виждам\n
+Искам да обясня как [=аз лично=] виждам\n
 математиката в компютърния свят.
 
 
@@ -239,7 +239,7 @@
 :column
 
 :unordered
-- =[Булева алгебра]=: как работим с истина/лъжа, с 0/1
+- [=Булева алгебра=]: как работим с истина/лъжа, с 0/1
 
   .bulleted
   - Доказана е [url https://en.wikipedia.org/wiki/A_Symbolic_Analysis_of_Relay_and_Switching_Circuits еквивалентност между ел. вериги и булевата алгебра].
@@ -256,7 +256,7 @@
 [$br1]
 
 :unordered
-- =[Теория на множествата]=: множество е някаква съвкупност от обекти
+- [=Теория на множествата=]: множество е някаква съвкупност от обекти
 
   .bulleted
   'footnote importance-of-sets [url https://math.stackexchange.com/a/536172 https://math.stackexchange.com/a/536172]
@@ -266,7 +266,7 @@
 [$br2]
 
 'footnote importance-of-combinatorics [url https://math.stackexchange.com/questions/2146051/where-do-combinatorics-play-a-role-in-computer-science https://math.stackexchange.com/questions/2146051/where-do-combinatorics-play-a-role-in-computer-science]
-- =[Комбинаторика]= [$importance-of-combinatorics]: изследва бройки на неща
+- [=Комбинаторика=] [$importance-of-combinatorics]: изследва бройки на неща
 
   .bulleted
   - Често се ползва за анализ и дизайн на алгоритми и структури от данни
@@ -282,7 +282,7 @@
 [$br5]
 
 :unordered
-- =[Теория на графите]=: граф е съвкупност от някакви обекти и връзки между тях.
+- [=Теория на графите=]: граф е съвкупност от някакви обекти и връзки между тях.
   .bulleted
   - Позволява моделиране на много естествени структури: интернет мрежите, географски карти (места и пътищата между тях), йерархии, биологически мрежи и так. нат.
   - Използва се във важни структури от данни като [url https://en.wikipedia.org/wiki/Heap_%28data_structure%29 heap] (и интересната [url https://www.youtube.com/watch?v=6JxvKfSV9Ns fibonacci heap]) и [url https://en.wikipedia.org/wiki/Trie trie]
@@ -356,7 +356,7 @@
 - ...
 
 .p
-Математиката е =[неразделима]= част от софтуера!\n
+Математиката е [=неразделима=] част от софтуера!\n
 Друг е въпросът дали на вас лично ще ви се налага да я използвате...
 
 
@@ -372,7 +372,7 @@
 .p
 
 .bulleted
-- Най-великият труд на тази дисциплина е постигнат чрез =[синхрон]= между тези три предмета
+- Най-великият труд на тази дисциплина е постигнат чрез [=синхрон=] между тези три предмета
 
 :centered
 :width60%
diff --git a/src/teaching/upp-2023/week10/index.du b/src/teaching/upp-2023/week10/index.du
index 3c4f8de..746cacd 100644
--- a/src/teaching/upp-2023/week10/index.du
+++ b/src/teaching/upp-2023/week10/index.du
@@ -4,16 +4,16 @@
 
 GitHub classroom: [url https://classroom.github.com/a/EJcTQRz4 classroom.github.com/a/EJcTQRz4]
 
-.important Във всички задачи =[трябва]= да използвате рекурсия!
+.important Във всички задачи [=трябва=] да използвате рекурсия!
 
 ## Задача 1
 
-Най-големия общ делител на числата `[a]` и `[b]` е най-голямото, число което ги дели без остатък.
-Евклидовият алгоритъм се базира на факта, че за две положителни числа `[a]` и `[b]`, като `[a > b]`, НОД на `[a]` и `[b]` е същия като НОД на `[a - b]` и `[b]` и когато `[a = b]`, тогава НОД на `[a]` и `[b]` е тяхната стойност.
+Най-големия общ делител на числата [`a`] и [`b`] е най-голямото, число което ги дели без остатък.
+Евклидовият алгоритъм се базира на факта, че за две положителни числа [`a`] и [`b`], като [`a > b`], НОД на [`a`] и [`b`] е същия като НОД на [`a - b`] и [`b`] и когато [`a = b`], тогава НОД на [`a`] и [`b`] е тяхната стойност.
 
-От входа получавате две цели положителни числа и трябва да изкарате техния НОД, чрез алгоритъма на Евклид =[имплементиран с рекурсия]=.
+От входа получавате две цели положителни числа и трябва да изкарате техния НОД, чрез алгоритъма на Евклид [=имплементиран с рекурсия=].
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -28,7 +28,7 @@ GitHub classroom: [url https://classroom.github.com/a/EJcTQRz4 classroom.github.
 
 ## Задача 2
 
-От входа получавате неотрицателно число `[N]`, което ще бъде някое число на Фибоначи.
+От входа получавате неотрицателно число [`N`], което ще бъде някое число на Фибоначи.
 Трябва да върнете кое по ред е, като 0 е нулевото, 1 е първото, 2 е третото, 3 е четвъртото и так. нат.
 Напомням, че математически фибоначи се дефинира така:
 
@@ -43,7 +43,7 @@ F_{n-1} + F_{n-2} & \text{иначе} \\
 
 [image ./img/fib.png F(0) = 0; F(1) = 1; F(n) = F(n-1) + F(n-2)]
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -70,9 +70,9 @@ F_{n-1} + F_{n-2} & \text{иначе} \\
 
 ## Задача 3
 
-От входа получавате положително число `[N]`, трябва да изкарате на екрана "рисунка", показваща формата на пясъчен часовник с височина `[2N]` (вижте примерите).
+От входа получавате положително число [`N`], трябва да изкарате на екрана "рисунка", показваща формата на пясъчен часовник с височина [`2N`] (вижте примерите).
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -119,10 +119,10 @@ F_{n-1} + F_{n-2} & \text{иначе} \\
 
 ## Задача 4
 
-От входа получавате число `[N]`, след това тябва да изкарате на нови редове, в нарастващ ред, всички двоични числа, които могат да се представят с `[N]`-бита.
-Вкарвате и водещи нули, тоест всяко число е съставено от точно `[N]` букви (`[N]` нули и единици).
+От входа получавате число [`N`], след това тябва да изкарате на нови редове, в нарастващ ред, всички двоични числа, които могат да се представят с [`N`]-бита.
+Вкарвате и водещи нули, тоест всяко число е съставено от точно [`N`] букви ([`N`] нули и единици).
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -159,11 +159,11 @@ F_{n-1} + F_{n-2} & \text{иначе} \\
 ```
 0000
 0001
-*[...]*
+[*...*]
 0111
 1000
 1001
-*[...]*
+[*...*]
 1101
 1110
 1111
@@ -171,12 +171,12 @@ F_{n-1} + F_{n-2} & \text{иначе} \\
 
 ## Задача 5
 
-Получавате един ред от терминала, в който ще имате скоби, знакът `[+]` и `[*]`, шпации и числа.
-Това е прост математически израз, трябва да изкарате резултата след неговото пресмятане, като винаги около `[число + число]` и `[число * число]` има скоби (тоест не е нужно да се притеснявате от приоритет и асоциативност).
+Получавате един ред от терминала, в който ще имате скоби, знакът [`+`] и [`*`], шпации и числа.
+Това е прост математически израз, трябва да изкарате резултата след неговото пресмятане, като винаги около [`число + число`] и [`число * число`] има скоби (тоест не е нужно да се притеснявате от приоритет и асоциативност).
 
-За удобство спокойно може да ползвате `[atoi]` за конверитране на числовите части от низа в числа.
+За удобство спокойно може да ползвате [`atoi`] за конверитране на числовите части от низа в числа.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week11/index.du b/src/teaching/upp-2023/week11/index.du
index e8ef6bd..b0f5be1 100644
--- a/src/teaching/upp-2023/week11/index.du
+++ b/src/teaching/upp-2023/week11/index.du
@@ -4,7 +4,7 @@
 
 GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.com/a/cZRnZj9y]
 
-.important Във всички задачи =[трябва]= да използвате рекурсия!
+.important Във всички задачи [=трябва=] да използвате рекурсия!
 
 .warn Някои задачи се повтарят с тези от миналия път, ако преди не сте ги решили, сега ги решете
 
@@ -16,13 +16,13 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 ## Задача 1
 
-От входа получавате неотрицателно число `[N]`, което ще бъде някое число на Фибоначи.
+От входа получавате неотрицателно число [`N`], което ще бъде някое число на Фибоначи.
 Трябва да върнете кое по ред е, като 0 е нулевото, 1 е първото, 2 е третото, 3 е четвъртото и так. нат.
 
 Напомням, че нормално Фибоначи се дефинира като редица, която започва с числата 0 и 1, и всяко следващо е сумата на предходните две.
-Тоест, нулевото число е 0, първото 1, второто е `[0 + 1 = 1]` (понеже 1 се повтаря, зачитаме го за първото число), третото е `[1 + 1 = 2]`, четвъртото е `[1 + 2 = 3]` и так. нат.
+Тоест, нулевото число е 0, първото 1, второто е [`0 + 1 = 1`] (понеже 1 се повтаря, зачитаме го за първото число), третото е [`1 + 1 = 2`], четвъртото е [`1 + 2 = 3`] и так. нат.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -49,13 +49,13 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 ## Задача 2
 
-От входа получавате положително число `[N]`, трябва да изкарате на екрана "рисунка" на триъгълници.
+От входа получавате положително число [`N`], трябва да изкарате на екрана "рисунка" на триъгълници.
 
 ### a) горен триъгълник
 
-Рисунката е един правоъгълен равнобедрен триъгълник от знака `[+]`, като `[N]` определя размера на равнобедрените страни (вижте примерите).
+Рисунката е един правоъгълен равнобедрен триъгълник от знака [`+`], като [`N`] определя размера на равнобедрените страни (вижте примерите).
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -89,9 +89,9 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 ### б) долен триъгълник
 
-Подобно на предходната подточка, обаче обърнат по хоризонтала, и със знака `[#]`.
+Подобно на предходната подточка, обаче обърнат по хоризонтала, и със знака [`#`].
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -127,10 +127,10 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 ### в) пълен триъгълник
 
-=[Използвайки само една рекурсивна функция,]= сега трябва да изкарате първо горния триъгълник и след това долния.
+[=Използвайки само една рекурсивна функция,=] сега трябва да изкарате първо горния триъгълник и след това долния.
 Ако просто извикате предходните две функции една след друга, задачата се обезсмисля.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -185,9 +185,9 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 Разбира се, от входа получавате две числа, съответно умножението и сбора на възрастите им.
 Трябва на екрана да изкарате три числа - възрастите на трите деца.
 
-=[Подсказка:]= най-лесното решение е да пробвате всички възможни възрасти, като избягвате техни пермутации
+[=Подсказка:=] най-лесното решение е да пробвате всички възможни възрасти, като избягвате техни пермутации
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -205,10 +205,10 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 ## Задача 4
 
-От входа получавате число `[N]`, след това трябва да изкарате на нови редове, в нарастващ ред, всички двоични числа, които могат да се представят с `[N]`-бита.
-Вкарвате и водещи нули, тоест всяко число е съставено от точно `[N]` букви (`[N]` нули и единици).
+От входа получавате число [`N`], след това трябва да изкарате на нови редове, в нарастващ ред, всички двоични числа, които могат да се представят с [`N`]-бита.
+Вкарвате и водещи нули, тоест всяко число е съставено от точно [`N`] букви ([`N`] нули и единици).
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -245,11 +245,11 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 ```
 0000
 0001
-*[...]*
+[*...*]
 0111
 1000
 1001
-*[...]*
+[*...*]
 1101
 1110
 1111
@@ -264,7 +264,7 @@ GitHub classroom: [url https://classroom.github.com/a/cZRnZj9y classroom.github.
 
 От входа получавате дъската, като с -1 обозначаваме празна клетка.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week12/index.du b/src/teaching/upp-2023/week12/index.du
index 4596fda..3fa25ff 100644
--- a/src/teaching/upp-2023/week12/index.du
+++ b/src/teaching/upp-2023/week12/index.du
@@ -4,7 +4,7 @@
 
 GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.com/a/KEDSxDjl]
 
-.important Във всички задачи =[трябва]= да използвате рекурсия!
+.important Във всички задачи [=трябва=] да използвате рекурсия!
 
 ## Алтернативни задачи
 
@@ -21,7 +21,7 @@ GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.
 Накрая получавате максималната обща тежест за раницата.
 Трябва да изкарате на екрана максималната възможна обща ценност.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -66,7 +66,7 @@ GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.
 
 Получавате N и M, съответно броя редове и колони в дъска.
 Всяка клетка от дъската е пълна или празна.
-След това получавате NxM на брой символа за всяка клетка, като `[-]` означава празна клетка, докато `[#]` означава пълна.
+След това получавате NxM на брой символа за всяка клетка, като [`-`] означава празна клетка, докато [`#`] означава пълна.
 Накрая получавате две числа - координати (започващи от нула, като 0,0 е горния-ляв ъгъл) в дъската.
 
 От подадените координати трябва да запълните "фигурата" в която се намира (фигурата която огражда) дадената плочка.
@@ -76,7 +76,7 @@ GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.
 
 [image https://upload.wikimedia.org/wikipedia/commons/7/7e/Recursive_Flood_Fill_4_%28aka%29.gif]
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -114,7 +114,7 @@ GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.
 Напишете програма, която намира броя на възможните такива поставяния на цариците.
 От входа не получавате нищо.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -124,43 +124,43 @@ GitHub classroom: [url https://classroom.github.com/a/KEDSxDjl classroom.github.
 |: 92
 
 
-=[Бонус:]= направете програмата да изкарва всяко решение
+[=Бонус:=] направете програмата да изкарва всяко решение
 
 ## Задача 4
 
 .comment https://mathcenter.oxford.emory.edu/site/cs171/probSetUsingStacks/
 
-Нормално ние представяме математически операции чрез "инфиксен" запис, тоест операторът е по средата, между нещата върху които работи (пример: `[1 + 2]`).
-Обаче, това не е задължително, по обратната полска нотация винаги слагаме оператът след нещата върху които работи (пример: `[1 2 +]`).
+Нормално ние представяме математически операции чрез "инфиксен" запис, тоест операторът е по средата, между нещата върху които работи (пример: [`1 + 2`]).
+Обаче, това не е задължително, по обратната полска нотация винаги слагаме оператът след нещата върху които работи (пример: [`1 2 +`]).
 
 Бонусът на това, е че не ни трябва скобуване и ред на операциите.
-В инфиксния израз `[(2 + 3) * (2 ^^ 2)]`, без скобите, сбора ще се извърши след умножението и степенуването ще се извърши след умножението.
-Обаче, ако искаме да изразим това в обратен полски запис, просто правим `[2 3 + 2 2 ^^ *]`.
-А ако искаме оригиналното действие, без скоби, записваме `[2 3 2 * 2 ^^ +]`.
+В инфиксния израз [`(2 + 3) * (2 ^^ 2)`], без скобите, сбора ще се извърши след умножението и степенуването ще се извърши след умножението.
+Обаче, ако искаме да изразим това в обратен полски запис, просто правим [`2 3 + 2 2 ^^ *`].
+А ако искаме оригиналното действие, без скоби, записваме [`2 3 2 * 2 ^^ +`].
 
 Ако изглежда объркващо, идеята е че всеки оператор работи върху предходните две стойности, изчисляваме изразите от ляво надясно и заместваме веднага.
-Тоест, при последния пример, пропускаме първите три числа, стигаме до `[*]`, умножаваме последните две и заместваме трите неща (`[3 2 *]`) с резултата, следователно имаме `[2 6 2 ^^ +]`, пропускаме две, стигаме до `[^^]` и так.нат.
+Тоест, при последния пример, пропускаме първите три числа, стигаме до [`*`], умножаваме последните две и заместваме трите неща ([`3 2 *`]) с резултата, следователно имаме [`2 6 2 ^^ +`], пропускаме две, стигаме до [`^^`] и так.нат.
 
-Направете програма, която чисто рекурсивно изчислиява изрази в обратен полски запис, който поддържа цели числа и операциите събиране, умножение, деление, изваждане и степенуване (за степенуване ще използваме знакът `[^]`).
+Направете програма, която чисто рекурсивно изчислиява изрази в обратен полски запис, който поддържа цели числа и операциите събиране, умножение, деление, изваждане и степенуване (за степенуване ще използваме знакът [`^`]).
 
 .important Обаче, за едно извикване на рекурсивната функция, може да пазите само един елемент на израза (число или оператор)!
 
-Изразът винаги завършва на знака `[$]`.
+Изразът винаги завършва на знака [`$`].
 
 :warn
 .p
-Относно вход/изход, понеже няма как да знаем дали i-тата стойност е число или знак (операция), трябва да използваме функцията `[std::cin.fail()]`, която връща булева стойност, която ни казва дали записването на входа е било успешно.
+Относно вход/изход, понеже няма как да знаем дали i-тата стойност е число или знак (операция), трябва да използваме функцията [`std::cin.fail()`], която връща булева стойност, която ни казва дали записването на входа е било успешно.
 
 .p
-Тоест, може винаги да запазвате входа в целочислен тип, когато стигнете до знак `[std::cin.fail()]` ще върне `[true]`.
-След това трябва да "забравите" за грешката чрез `[std::cin.clear()]` и може втори път да запазите входа (провалените данни ще се препрочетат) в променлива от знаков тип.
+Тоест, може винаги да запазвате входа в целочислен тип, когато стигнете до знак [`std::cin.fail()`] ще върне [`true`].
+След това трябва да "забравите" за грешката чрез [`std::cin.clear()`] и може втори път да запазите входа (провалените данни ще се препрочетат) в променлива от знаков тип.
 
 .p
-Но това поражда друг проблем, понеже записваме в целочислен тип, когато въведем `[+]` или `[-]`, `[std::cin]` ще очаква това да е водещ знак на число, и ще продължи да чака входа докато не въведем друг знак, тоест `[+]` и `[-]` ще бъдат пропуснати.
-Като компромисен вариант, просто пред тях винаги ще слагаме `[']` и в кода ще го пропускаме.
+Но това поражда друг проблем, понеже записваме в целочислен тип, когато въведем [`+`] или [`-`], [`std::cin`] ще очаква това да е водещ знак на число, и ще продължи да чака входа докато не въведем друг знак, тоест [`+`] и [`-`] ще бъдат пропуснати.
+Като компромисен вариант, просто пред тях винаги ще слагаме [`'`] и в кода ще го пропускаме.
 
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week13/index.du b/src/teaching/upp-2023/week13/index.du
index b312d9e..c12c546 100644
--- a/src/teaching/upp-2023/week13/index.du
+++ b/src/teaching/upp-2023/week13/index.du
@@ -20,7 +20,7 @@ GitHub classroom: [url https://classroom.github.com/a/bgiFD6SB classroom.github.
 Всяка дума е на нов ред и е съставена от малки латински букви.
 Ако има няколко думи с еднаква "близкост", изкарайте последната от тях.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -59,12 +59,12 @@ mask
 Редовете са разбъркани, изкарайте първо име и фамилия на хората с най-много продадени продукти.
 Ако има няколко хора, които са продали най-много продукти, изкарайте имената им в азбучен ред, първо по фамилия, после по име.
 
-Използвайте =[само една функция за сортиране!]=
+Използвайте [=само една функция за сортиране!=]
 Като подсказка, използвайте указатели към функции за да променяте как тя работи.
 
 .question Какво свойство трябва да е изпълнено за сортиращата функция?
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -121,7 +121,7 @@ A .
 
 Изкарайте на конзолата всички обвити изречения в матрицата (редът им няма значение).
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -198,7 +198,7 @@ Big   jumper.
 
 ## 4 задача
 
-В префиксния (или полския) запис слагаме оператора за смятане пред (в ляво от) елементите върху които работи (нормален запис - `[1 + 2]`, полски запис - `[+ 1 2]`).
+В префиксния (или полския) запис слагаме оператора за смятане пред (в ляво от) елементите върху които работи (нормален запис - [`1 + 2`], полски запис - [`+ 1 2`]).
 Ще разглеждаме "многоредови" изрази в полски запис, тоест изрази в които има няколко реда от целочислени стойности, така че трябва да се изчислят няколко израза с еднаква "форма", но различни стойности.
 
 Един такъв израз изглежда така:
@@ -209,7 +209,7 @@ Big   jumper.
   5 6 .
 
 Точката на края на последния ред задава край на израза.
-В този пример ще изчислим `[1 + 2]`, `[3 + 4]` и `[5 + 6]`, тоест ще "върне" три стойности: 3, 7 и 11.
+В този пример ще изчислим [`1 + 2`], [`3 + 4`] и [`5 + 6`], тоест ще "върне" три стойности: 3, 7 и 11.
 Всяка колона в израза е от един и същи "тип", тоест в една колона винаги ще има числова стойност или някакъв знак.
 С изключение на точката, всеки знак може да се постави на произволен ред (обаче в една колона не може да има повече от един знак).
 
@@ -220,10 +220,10 @@ Big   jumper.
 + 3   4   7 7
   5   6 * 8 9 .
 
-Това ще изчисли `[1 + (2 - 2 * 63)]`, `[3 + (4 - 7* 7)]` и `[5 + (6 - 8 * 9)]`.
+Това ще изчисли [`1 + (2 - 2 * 63)`], [`3 + (4 - 7* 7)`] и [`5 + (6 - 8 * 9)`].
 Израза би направил същото нещо ако примерно всички знаци бяха на първия ред или на последния.
 
-От входа получавате няколко такива израза, докато не получите знака `[$]`.
+От входа получавате няколко такива израза, докато не получите знака [`$`].
 
 Може да достъпвате стойност от предходни изрази чрез синтаксиса "ИНДЕКС.ИНДЕКС", където индексите са от 0, първия определя номера на израза, докато втория определя коя стойност искаме.
 Примерно:
@@ -240,7 +240,7 @@ Big   jumper.
 
 .warn Погледнете пояснението за вход/изход от [url ../week12/#4 последната задача от миналия път].
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week14/index.du b/src/teaching/upp-2023/week14/index.du
index a73e18f..a0f9906 100644
--- a/src/teaching/upp-2023/week14/index.du
+++ b/src/teaching/upp-2023/week14/index.du
@@ -163,7 +163,7 @@ But you have only X people to tend the fields. Now then,
 След това избирате друго произволно число между 1 и 6.
 Ако числото е по-голямо от 1, тогава плъховете ще изядат по толкова голяма дроб бушели жито от резерва (при числото 5, плъховете изяждат 1/5; тук бушелите жито се смятат преди жътва).
 
-Сега населението расте, броя хора които са "дошли" в града се определя по формулата `[R * (20* АКРИ ЗЕМЯ + БУШЕЛИ ЖИТО) / БРОЙ ХОРА / 100 + 1]`, където R е цяло число между 1 и 6.
+Сега населението расте, броя хора които са "дошли" в града се определя по формулата [`R * (20* АКРИ ЗЕМЯ + БУШЕЛИ ЖИТО) / БРОЙ ХОРА / 100 + 1`], където R е цяло число между 1 и 6.
 Бушелите жито се смятат след жътва.
 
 Предпоследно, определя се колко хора са умрели от глад, като всеки човек консумира 20 бушели жито.
diff --git a/src/teaching/upp-2023/week2/index.du b/src/teaching/upp-2023/week2/index.du
index 5319d74..645f1c6 100644
--- a/src/teaching/upp-2023/week2/index.du
+++ b/src/teaching/upp-2023/week2/index.du
@@ -6,13 +6,13 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 Решения: [url https://github.com/Syndamia/upp-2023-solutions/tree/main/week02 GitHub]
 
-## =[Важни бележки]=
+## [=Важни бележки=]
 
 .numbered
-1. Не е добре да ползвате `[using namespace std;]`
-2. Единствената библиотека, която (поне за сега) може да ползвате е `[iostream]`
-3. За хората с текстови редактори и `[gcc]`, моля да погледнете в Moodle и да използвате предоставените флагове, най-важния от които е `[-std=c++17]`
-3. Като си качвате решенията в GitHub classroom, за предпочитане е имената на файловете да свършват на `[.cpp]`.
+1. Не е добре да ползвате [`using namespace std;`]
+2. Единствената библиотека, която (поне за сега) може да ползвате е [`iostream`]
+3. За хората с текстови редактори и [`gcc`], моля да погледнете в Moodle и да използвате предоставените флагове, най-важния от които е [`-std=c++17`]
+3. Като си качвате решенията в GitHub classroom, за предпочитане е имената на файловете да свършват на [`.cpp`].
    Отново, не е задължително, но ми улеснява живота.
 
 ## Тема: конвертиране
@@ -21,23 +21,23 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 ### Задача 1 - Конвертирания от int
 
-Получавате целочислено число (тип `[int]`), след това, за всеки тип от следния списък, трябва да изкарате на нов ред текст във формата "Със/без загуба тип стойност":
+Получавате целочислено число (тип [`int`]), след това, за всеки тип от следния списък, трябва да изкарате на нов ред текст във формата "Със/без загуба тип стойност":
 
 .bulleted
-- `[bool]`
-- `[long long int]`
-- `[unsigned int]`
-- `[char]`
-- `[short int]`
-- `[double]`
-- `[long int]`
-- `[unsigned char]`
+- [`bool`]
+- [`long long int`]
+- [`unsigned int`]
+- [`char`]
+- [`short int`]
+- [`double`]
+- [`long int`]
+- [`unsigned char`]
 
 Целта е да напишете един низ, който съдържа "Със/без загуба тип", и след това да изкарате (конвертираната) стойност.
 Не се иска да правите код, който намира тази информация автоматично, всичко това просто си го напишете ръчно (hardcoded).
 
-=[Пример]=
-&emsp; *[Нарочно са показани само първите два реда от изхода]*
+[=Пример=]
+&emsp; [*Нарочно са показани само първите два реда от изхода*]
 
 :table_2
 |= Вход
@@ -55,7 +55,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 Получавате положително цяло число, от него трябва да "запазите" само първите (най-десните) 6 бита и да изкарате получилото се число.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -70,11 +70,11 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 ### Задача 3 - Деление и умножение
 
-Получавате положително цяло число `[а]`, трябва да изкарате две числа (разделени с празно пространство):\n
-`[a]` (целочислено) разделено на 16 и `[а]` умножено по 8.
-=[Трябва да използвате побитови оператори за това!]=
+Получавате положително цяло число [`а`], трябва да изкарате две числа (разделени с празно пространство):\n
+[`a`] (целочислено) разделено на 16 и [`а`] умножено по 8.
+[=Трябва да използвате побитови оператори за това!=]
 
-=[Пример]=
+[=Пример=]
 
 :table_2
 |= Вход
@@ -105,11 +105,11 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 ```
 128 128 128 128
 
-И накрая изкарания резултат трябва да бъде `[128.128.128.128]`
+И накрая изкарания резултат трябва да бъде [`128.128.128.128`]
 
 На входа получавате цяло положително число, трябва да изкарате на екрана как би изглеждало с това представяне, с точките между осморки битове.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -131,12 +131,12 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 ### Задача 5 - Дели ли се
 
-От входа получавате две числа: `[а]` и `[n]`.
-Трябва да върнете 0 ако `[a]` не се дели на `[n]` без остатък, и 1 иначе.
+От входа получавате две числа: [`а`] и [`n`].
+Трябва да върнете 0 ако [`a`] не се дели на [`n`] без остатък, и 1 иначе.
 
-=[Упътване:]= Булевата стойност `[false]` се изкарва като 0, а `[true]` се изкарва като 1, от `[std::cout]`
+[=Упътване:=] Булевата стойност [`false`] се изкарва като 0, а [`true`] се изкарва като 1, от [`std::cout`]
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -154,7 +154,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 Получавате от входа буква, трябва да върнете 0 ако буквата не е цифра и 1 ако е.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -178,7 +178,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 На входа получавате три целочислени, трябва да ги изкарате в нарастващ ред.
 
-=[Пример]=
+[=Пример=]
 
 :table_2
 |= Вход
@@ -192,9 +192,9 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 От входа получавате число от 1 до 12: номера на месеца.
 Трябва да изкарате името на месеца, където 1 съответства на "January", 2 на "February" и так. нат.
-Моля използвате `[switch]` конструкция.
+Моля използвате [`switch`] конструкция.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -213,7 +213,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 Искате да платите използвайки само монети, като целта е да използвате възможно най-големите стойности на монети, възможно най-много (тоест ситуацията в която трябва да носите един милион монети по една стотинка не трябва да е възможност).
 Изкарайте двойки "монета бройка", като работите с монети от по 50 стотинки, 20 стотинки, 10 стотинки, 5 стотинки, 1 стотинка.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -238,7 +238,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 Спрямо техните стойности, трябва да върнете "Turn right" ако самолетът е в ляво от пистата (ако XXX е по-голямо от YYY) и "Turn left" ако самолетът е в дясно.
 Допълнително, понеже не е нужно самолетът да се намира перфектно в средата на пистата, зачитаме че ако разликата между двата интензитета е по-малка от 4, тогава самолетът е правилно подравнен и връщаме "Follow heading".
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -256,12 +256,12 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 
 ### Задача 11 - GPS
 
-*[В тази задача има много "теория", иначе самия код е малък и лесен.]*
+[*В тази задача има много "теория", иначе самия код е малък и лесен.*]
 
 Кондензирайки възможно най-много, ще обясня как работи GPS.
 На земята имаме специални методи, чрез които можем да определим позицията на всеки сателит, обаче обратното, определянето на позицията чрез сателит, става с помощта на супер прецизни часовници и малко математика.
 
-Понеже радио комуникацията е със скоростта на светлината, можем лесно да определим разстояния между сателит и дадена точка, считайки колко време е отнело на сателита да върне отговор (припомням формулата `[s = v * t]`, или `[разстояние = скорост * време]`).
+Понеже радио комуникацията е със скоростта на светлината, можем лесно да определим разстояния между сателит и дадена точка, считайки колко време е отнело на сателита да върне отговор (припомням формулата [`s = v * t`], или [`разстояние = скорост * време`]).
 
 Обаче, така получаваме само разстоянието, това не е достатъчно за да определим точната позиция, понеже има много възможни точки на земята, които да са на това разстояние.
 Решението на проблема, е че просто вземаш разстоянието от няколко сателита, твоята позиция се намира в общата точка между всички възможни области.
@@ -287,7 +287,7 @@ GitHub classroom: [url https://classroom.github.com/a/Bi5dhwW7 classroom.github.
 Накрая получавате още две числа, пак координата и време, но за втория сателит.
 Изкарайте къде се намираме ние, като нека скоростта на светлината да бъде 29 метра в милисекунда.
 
-=[Пример]=
+[=Пример=]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week2/revision.du b/src/teaching/upp-2023/week2/revision.du
index be27064..f2d771d 100644
--- a/src/teaching/upp-2023/week2/revision.du
+++ b/src/teaching/upp-2023/week2/revision.du
@@ -55,15 +55,15 @@
 
 .p Първо ще ги погледнем чисто теоретично.
 
-.p =[Внимавайте, те са различни от логическите оператори!]=
+.p [=Внимавайте, те са различни от логическите оператори!=]
 
-.p =[Означавам побитовите числа с водеща буква "b"!]=
-Тоест, числото `[b1001]` е двоичното число `[1001]`, което е десетичното число `[9]`.
+.p [=Означавам побитовите числа с водеща буква "b"!=]
+Тоест, числото [`b1001`] е двоичното число [`1001`], което е десетичното число [`9`].
 
 [$br3]
 
 :unordered
-- Отрицание/негация, `[~]`: обръща 0 в 1 и 1 в 0
+- Отрицание/негация, [`~`]: обръща 0 в 1 и 1 в 0
 
   ```
   ~ b0010 = b1101
@@ -72,19 +72,19 @@
 
 :slide
 :unordered
-- Побитово "и", `[&]`: за два бита, ако и двете са 1, връща 1, иначе връща 0
+- Побитово "и", [`&`]: за два бита, ако и двете са 1, връща 1, иначе връща 0
 
   ```
   3 & 5 = 1
   b0011 & b0101 = b0001
 
-- Побитово "или", `[|]`: за два бита, ако и двете са 0, връща 0, иначе връща 1
+- Побитово "или", [`|`]: за два бита, ако и двете са 0, връща 0, иначе връща 1
 
   ```
   3 | 5 = 7
   b0011 | b0101 = b0111
 
-- Изключващо "или", `[^]`: ако само един от двата бита е 1, връща 1, иначе връща 0
+- Изключващо "или", [`^`]: ако само един от двата бита е 1, връща 1, иначе връща 0
 
   ```
   3 ^ 5 = 6
@@ -94,7 +94,7 @@
 
 :middle_slide27
 :unordered
-- Побитово отместване на ляво, `[<<]`: отмества всеки бит с n позиции на ляво\n
+- Побитово отместване на ляво, [`<<`]: отмества всеки бит с n позиции на ляво\n
   Винаги "запълва" с нули (няма разлика между логическо и аритметично ляво отместване)
 
   ```
@@ -103,7 +103,7 @@
 
   (приемаме, че типа данни съхранява само 4 бита данни)
 
-- Побитово отместване на дясно, `[>>]`: отмества всеки бит с n позиции на дясно\n
+- Побитово отместване на дясно, [`>>`]: отмества всеки бит с n позиции на дясно\n
   При аритметичното отместване, дупките се запълват с предходната стойност на старшия бит\n
   При логическото отместване, винаги запълваме с 0\n
   В C++ има един оператор, дали е аритметическо или логическо се определя от типа
@@ -149,7 +149,7 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 [$br4]
 
 :unordered
-- `[!]`: обръща `[true]` във `[false]` и обратно
+- [`!`]: обръща [`true`] във [`false`] и обратно
 
    ```cpp
    ! true  // false
@@ -159,14 +159,14 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 
 :middle_slide
 :unordered
-- `[&&]`: "логическо и", ако и двете стойности са `[true]`, тогава и резултатът е `[true]`
+- [`&&`]: "логическо и", ако и двете стойности са [`true`], тогава и резултатът е [`true`]
 
   ```cpp
   true  && true  // true
   false && true  // false
   false && false // false
 
-- `[||]`: "логическо или", само ако и двете са `[false]`, тогава е `[false]`
+- [`||`]: "логическо или", само ако и двете са [`false`], тогава е [`false`]
 
   ```cpp
   true  || true  // true
@@ -180,7 +180,7 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 ## Условни конструкции
 
 :unordered
-- `[if]`: приема булева стойност, ако е `[true]`, изпълнява кода в къдравите скоби, ако е `[false]` ги пропуска
+- [`if`]: приема булева стойност, ако е [`true`], изпълнява кода в къдравите скоби, ако е [`false`] ги пропуска
 
   ```cpp
   if (expression) {
@@ -188,9 +188,9 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
   }
   dootherthing;
 
-  `[expression]` се конвертира към типа `[bool]`\n
+  [`expression`] се конвертира към типа [`bool`]\n
 
-  Ако в къдравите скоби имаме един израз (тоест е само един ред код, завършващ на `[;]`) можем да ги пропуснем.
+  Ако в къдравите скоби имаме един израз (тоест е само един ред код, завършващ на [`;`]) можем да ги пропуснем.
 
   ```cpp
   if (expression) dosomething;
@@ -200,7 +200,7 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 
 :middle_slide25
 :unordered
-- `[if-else]`: работи като `[if]`, обаче след къдравите скоби добавяме `[else { ... }]`.
+- [`if-else`]: работи като [`if`], обаче след къдравите скоби добавяме [`else { ... }`].
 
   ```cpp
   if (expression) {
@@ -212,10 +212,10 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
   dootherthing;
 
   .p
-  Ако `[expression]` е истина, `[dothing1]` се изпълнява и `[dothing2]` се пропуска изцяло.
-  Аналогично, ако `[expression]` е лъжа, `[dothing1]` се изпуска и `[dothing2]` се изпълнява.
+  Ако [`expression`] е истина, [`dothing1`] се изпълнява и [`dothing2`] се пропуска изцяло.
+  Аналогично, ако [`expression`] е лъжа, [`dothing1`] се изпуска и [`dothing2`] се изпълнява.
 
-  .p Както с `[if]`, ако `[dothing2]` е само един израз, можем да пропуснем къдравите скоби
+  .p Както с [`if`], ако [`dothing2`] е само един израз, можем да пропуснем къдравите скоби
 
   ```cpp
   if (expression) {
@@ -258,8 +258,8 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 
 :slide
 :unordered
-- `[expression]` винаги се конвертира до тип `[bool]` (ако е нужно)\n
-  =[Никога не правете такива неща:]=
+- [`expression`] винаги се конвертира до тип [`bool`] (ако е нужно)\n
+  [=Никога не правете такива неща:=]
 
   ```cpp
   bool a;
@@ -270,14 +270,14 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
   bool a = false;
   if (expression) a = true;
 
-  Просто правите `[bool a = expression;]`
+  Просто правите [`bool a = expression;`]
 
   ```cpp
   bool a;
   if (expression) a = false;
   else a = true;
 
-  Просто правите `[bool a = ! expression;]`
+  Просто правите [`bool a = ! expression;`]
 
 
 
@@ -288,7 +288,7 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
   ```cpp
   (expression) ? valueA : valueB
 
-  Ако `[expression]` е истина, връща се `[valueA]`, иначе се връща `[valueB]`
+  Ако [`expression`] е истина, връща се [`valueA`], иначе се връща [`valueB`]
 
   ```cpp
   int grade;
@@ -306,7 +306,7 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
 
 :middle_slide27
 :unordered
-- `[switch]`: приема стойност и изпълнява случая, при който стойността съвпада с определената
+- [`switch`]: приема стойност и изпълнява случая, при който стойността съвпада с определената
 
   ```cpp
   switch (value) {
@@ -323,10 +323,10 @@ int r5 = (unsigned int)-b >> 1; // 2147483645
   else if (value == valueC) doSomething3;
 
   .p
-  `[otherwise]` е като `[else]`, това е случая когато не съвпада с никоя стойност.
+  [`otherwise`] е като [`else`], това е случая когато не съвпада с никоя стойност.
   Може да бъде изпуснат.
 
-  .p Без `[break]` изпълнението продължава към следващия `[case]`
+  .p Без [`break`] изпълнението продължава към следващия [`case`]
 
 
 
diff --git a/src/teaching/upp-2023/week3/index.du b/src/teaching/upp-2023/week3/index.du
index 202da69..1b0f213 100644
--- a/src/teaching/upp-2023/week3/index.du
+++ b/src/teaching/upp-2023/week3/index.du
@@ -10,9 +10,9 @@ GitHub classroom: [url https://classroom.github.com/a/JgMSXuCf classroom.github.
 
 ### Задача 1 - Степенуване
 
-Получавате цяло число `[x]` и цяло положително число `[n]`, трябва да върнете `[x]` на степен `[n]`-та.
+Получавате цяло число [`x`] и цяло положително число [`n`], трябва да върнете [`x`] на степен [`n`]-та.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -30,11 +30,11 @@ GitHub classroom: [url https://classroom.github.com/a/JgMSXuCf classroom.github.
 
 ### Задача 2 - Progress bar
 
-Получавате цяло число `[x]`, което е по-голямо или равно на 1, и на всеки ред трябва да изкарате един "progress bar", чиято дължина се увеличава с всеки изминал ред.
-На практика, този "progress bar" трябва да бъде една права, съставена от знакът `[#]`, която трябва с всеки изминал ред да се удължава с един знак.
-В началото прогресът е 1 и продължава до `[x]` включително.
+Получавате цяло число [`x`], което е по-голямо или равно на 1, и на всеки ред трябва да изкарате един "progress bar", чиято дължина се увеличава с всеки изминал ред.
+На практика, този "progress bar" трябва да бъде една права, съставена от знакът [`#`], която трябва с всеки изминал ред да се удължава с един знак.
+В началото прогресът е 1 и продължава до [`x`] включително.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -59,10 +59,10 @@ GitHub classroom: [url https://classroom.github.com/a/JgMSXuCf classroom.github.
 
 #### Бонус
 
-Направете дължината на този progress bar фиксирана на 10 знака, и въведеното `[x]` да определя след колко реда трябва да запълним progress bar-а.
+Направете дължината на този progress bar фиксирана на 10 знака, и въведеното [`x`] да определя след колко реда трябва да запълним progress bar-а.
 Този път, прогресът започва от 0.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -92,7 +92,7 @@ GitHub classroom: [url https://classroom.github.com/a/JgMSXuCf classroom.github.
 #
 ##
 ###
-*[...]*
+[*...*]
 
 |: 20
 |:
@@ -102,16 +102,16 @@ GitHub classroom: [url https://classroom.github.com/a/JgMSXuCf classroom.github.
 ##
 ##
 ###
-*[...]*
+[*...*]
 
 
 ### Задача 3 - Endless program with an end
 
 От входа получавате букви, не се знае колко.
 На нов ред, за всяка буква, трябва да върнете "letter" ако е латинска буква, "digit" ако е цифра и "other" ако не е нито едно от двете.
-Обаче, буквата `[^]` има специално значение, когато я получим трябва програмата да свърши изпълнение.
+Обаче, буквата [`^`] има специално значение, когато я получим трябва програмата да свърши изпълнение.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -128,13 +128,13 @@ letter
 
 ### Задача 4 - Premature end
 
-Ще получите максимум 10 цели числа, трябва (целочислено) да разделите числото `[65536]` на всяко от въведените числа.
+Ще получите максимум 10 цели числа, трябва (целочислено) да разделите числото [`65536`] на всяко от въведените числа.
 Но, когато получите числото 0, веднага трябва да спрете вземане на числа от входа.
 Финално, изкарайте резултата от всички тези деления.
 
-=[Упътване:]= Използвайте `[break]`.
+[=Упътване:=] Използвайте [`break`].
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -156,17 +156,17 @@ letter
 Получавате букви, незнайно колко.
 Трябва да броите колко от тях са малки букви, колко са главни и колко са цифри.
 
-В момента в който получите `[$]` трябва да спрете приемане на букви и да изкарате
+В момента в който получите [`$`] трябва да спрете приемане на букви и да изкарате
 
 ```
 Lowercase: X Uppercase: Y Digit: Z
 
 където X, Y и Z са съответните бройки.
-Обаче, ако получите буква, която не е малка, главна, цифра или `[$]`, трябва моментално да спрете изпълнението на програмата, без да отпечатвате нищо.
+Обаче, ако получите буква, която не е малка, главна, цифра или [`$`], трябва моментално да спрете изпълнението на програмата, без да отпечатвате нищо.
 
-=[Упътване:]= Използвайте `[return]`.
+[=Упътване:=] Използвайте [`return`].
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -184,21 +184,21 @@ Lowercase: X Uppercase: Y Digit: Z
 От входа получавате букви, това ще са "команди", като при всяка буква трябва да направите различно действие:
 
 .bulleted
-- `[s]`: след като я получите, трябва да вземете цяло число от входа и да го запазите (първоначалната стойност на числото е 15)
-- `[l]`: трябва побитово да отместите наляво запазеното число с един бит
-- `[r]`: трябва побитово да отместите надясно запазеното число с един бит
-- `[q]`: трябва да запазите сегашното число на втора степен
-- `[c]`: трябва да запазите сегашното число на трета степен
-- `[m]`: трябва да запазите сегашното число минус 351
-- `[p]`: трябва да запазите сегашното число плюс 94
-- `[&]`: прекратявате програмата
+- [`s`]: след като я получите, трябва да вземете цяло число от входа и да го запазите (първоначалната стойност на числото е 15)
+- [`l`]: трябва побитово да отместите наляво запазеното число с един бит
+- [`r`]: трябва побитово да отместите надясно запазеното число с един бит
+- [`q`]: трябва да запазите сегашното число на втора степен
+- [`c`]: трябва да запазите сегашното число на трета степен
+- [`m`]: трябва да запазите сегашното число минус 351
+- [`p`]: трябва да запазите сегашното число плюс 94
+- [`&`]: прекратявате програмата
 
 След всяка операция трябва да изкарате сегашната стойност на числото.
-Обаче, ако се въведе буква, за която няма дефинирана операция (не е команда) трябва да изкарате "Invalid command!" и да =[не]= изкарвате сегашната стойност на числото.
+Обаче, ако се въведе буква, за която няма дефинирана операция (не е команда) трябва да изкарате "Invalid command!" и да [=не=] изкарвате сегашната стойност на числото.
 
-=[Упътване:]= Използвайте `[switch]`, `[default]` и `[continue]`.
+[=Упътване:=] Използвайте [`switch`], [`default`] и [`continue`].
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -232,9 +232,9 @@ Invalid command!
 
 Първоначалната стойност на числото е 3.14159 и трябва в началото да изкарате "Positive".
 
-=[Упътване:]= Използвайте `[do-while]`.
+[=Упътване:=] Използвайте [`do-while`].
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -255,21 +255,21 @@ Negative
 Получавате букви (команди), като на всяка трябва да извършите някакво действие:
 
 :bulleted
-- `[t]` - увеличавате минутите с единица (не забравяйте, че ако времето е било "0:59", трябва да стане "1:00") и изкарвате сегашното време
-- `[c]` - в зависимост от предишни натискания, прави различни неща:
+- [`t`] - увеличавате минутите с единица (не забравяйте, че ако времето е било "0:59", трябва да стане "1:00") и изкарвате сегашното време
+- [`c`] - в зависимост от предишни натискания, прави различни неща:
    .bulleted
    - ако преди не е натиснат, влизаме в режим на промяна на часовете, от входа приемаме число което ще бъде новия час и изкарваме сегашното време
    - ако вече е натиснат, влизаме в режим на минутите, от входа приемаме число, което ще бъде новата стойност на минутите и изкарваме сегашното време
    - ако вече два пъти е бил натиснат, излизаме от режима
-   - ако сме в някой от първите два режима и получим `[t]` преди да излезем, не увеличаваме минутите
+   - ако сме в някой от първите два режима и получим [`t`] преди да излезем, не увеличаваме минутите
 
-- `[f]` - променяме изкараното време от 12 часов формат на 24 часов и обратно, като първоначално започваме с 24 часов, и изкарваме сегашното време
+- [`f`] - променяме изкараното време от 12 часов формат на 24 часов и обратно, като първоначално започваме с 24 часов, и изкарваме сегашното време
   .bulleted
-  - При 24 часов формат изкарваме "XX:YY", където `[XX]` е часа и `[YY]` са минутите
+  - При 24 часов формат изкарваме "XX:YY", където [`XX`] е часа и [`YY`] са минутите
   - При 12 часов формат е почти същото "XX:YY ZM" където ZM е PM или AM
 
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -293,9 +293,9 @@ Negative
 ```
 10 PRINT CHR$(205.5+RND(1));:GOTO 10
 
-Задачата е да я пресъздадем, тоест на 20 реда трябва да има по 20 букви, като всяка буква е, на случаен принцип, `[/]` или `[\\]` .
+Задачата е да я пресъздадем, тоест на 20 реда трябва да има по 20 букви, като всяка буква е, на случаен принцип, [`/`] или [`\\`] .
 
-=[Упътване:]= Формално никога не се преподават или изискват случайни стойности, затова ги показвам сега:
+[=Упътване:=] Формално никога не се преподават или изискват случайни стойности, затова ги показвам сега:
 
 Най-отгоре на сорс-файла добавете нужната библиотека:
 
@@ -303,21 +303,21 @@ Negative
 #include <stdlib.h>
 #include <ctime>
 
-След това, в `[main]`, преди да използвате случайни стойности, трябва да "инициализираме системата":
+След това, в [`main`], преди да използвате случайни стойности, трябва да "инициализираме системата":
 
 ```cpp
 srand(time(NULL));
 
-С функцията `[rand()]` получавате случайна положителна стойност, може да я ограничите до две стойности с модулно деление, `[rand() % 2]`.
+С функцията [`rand()`] получавате случайна положителна стойност, може да я ограничите до две стойности с модулно деление, [`rand() % 2`].
 
-=[Примерен изход]= *[Нямаме вход, вашия изход няма да изглежда напълно еднакъв]*
+[=Примерен изход=] [*Нямаме вход, вашия изход няма да изглежда напълно еднакъв*]
 
 ```
 'include ./example_maze.txt
 
 ### Задача 10 - Елка
 
-*[Решението на тази задача е по-дълго!]*
+[*Решението на тази задача е по-дълго!*]
 
 Сега имплементирате кода на една елка.
 Елката запазва две числа, първото е "сегашното" число с което правим нормалните операции и "виждаме" на екрана, и второто е отделна памет, в която можем да добавяме и изваждаме числа.
@@ -328,14 +328,14 @@ srand(time(NULL));
 Буквата е команда, като може да бъде +,-,\*,/, които са обикновените операции с които променяме сегашното число, докато:
 
 .bulleted
-- `[a]` - добавя сегашното число в отделната памет
-- `[s]` - изважда сегашното число от тази памет
-- `[c]` - занулява сегашното число
-- `[m]` - занулява числото в отделната памет
+- [`a`] - добавя сегашното число в отделната памет
+- [`s`] - изважда сегашното число от тази памет
+- [`c`] - занулява сегашното число
+- [`m`] - занулява числото в отделната памет
 
-След `[a]`, `[s]` и `[m]` трябва да изкарате числото в отделната памет, докато след всички други команди трябва да изкарате сегашното число.
+След [`a`], [`s`] и [`m`] трябва да изкарате числото в отделната памет, докато след всички други команди трябва да изкарате сегашното число.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -363,7 +363,7 @@ srand(time(NULL));
 ```
 int parseSensor(int s) { return ((((s=(s>>1)&(~0xF617A100))<0x54)?s|0xF01:s&0xCBFF)>>2)-21; }
 
-Все още не сме учили функции, затова просто пльоснете горното нещо във вашия сорс код, *[над]* `[int main()]` и *[в]* `[main]` може да я използвате чрез `[parseSensor(inputValue)]`.
+Все още не сме учили функции, затова просто пльоснете горното нещо във вашия сорс код, [*над*] [`int main()`] и [*в*] [`main`] може да я използвате чрез [`parseSensor(inputValue)`].
 
 Вашата задача е при определени градуси да връщате съобщение на екрана:
 
@@ -376,7 +376,7 @@ int parseSensor(int s) { return ((((s=(s>>1)&(~0xF617A100))<0x54)?s|0xF01:s&0xCB
 
 Обаче, това не е всичко.
 Поглеждате функцията на вашия колега и не сте уверени в нея, обаче нямате документацията за обработка на входа.
-Единственото нещо, което знаете, е че стойностите от функцията не трябва да са извън обхвата -20 и 40, затова използвайте `[assert]` и проверете/тествайте дали това винаги е вярно.
+Единственото нещо, което знаете, е че стойностите от функцията не трябва да са извън обхвата -20 и 40, затова използвайте [`assert`] и проверете/тествайте дали това винаги е вярно.
 
 Ето стойности с които може да тествате:
 
@@ -391,7 +391,7 @@ int parseSensor(int s) { return ((((s=(s>>1)&(~0xF617A100))<0x54)?s|0xF01:s&0xCB
 
 На кои стойности функцията на колегата не работи?
 
-=[Примери]= *[Входът е различен от горепосочените стойности (и при него функцията работи коректно)]*
+[=Примери=] [*Входът е различен от горепосочените стойности (и при него функцията работи коректно)*]
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2023/week3/revision.du b/src/teaching/upp-2023/week3/revision.du
index 876ed77..bcbdafa 100644
--- a/src/teaching/upp-2023/week3/revision.du
+++ b/src/teaching/upp-2023/week3/revision.du
@@ -20,7 +20,7 @@
   bool b;
   if (condition) b = true;
 
-  Грешно е, понеже `[condition]` сам по себе си е от тип bool, с този `[if]` буквално не правите нищо.
+  Грешно е, понеже [`condition`] сам по себе си е от тип bool, с този [`if`] буквално не правите нищо.
   Правилния вариант е:
 
   ```cpp
@@ -48,7 +48,7 @@
 
   .p
   Всяка буква действително съответства на определено число, дефинирано от ASCII стандарта.
-  Наистина '0' е 48 и '9' е 57, обаче от вас =[не]= се очаква да помните ASCII таблицата!
+  Наистина '0' е 48 и '9' е 57, обаче от вас [=не=] се очаква да помните ASCII таблицата!
   Също, ако не знаеш наизуст кои буква са тези числа, този израз е много неясен.
 
   .p
@@ -67,7 +67,7 @@
 
 .p
 Получи се малко разногласие между това, което Ивана ви е казала и това което аз ви казах.
-В края на деня, =[конвертиране от int към unsigned int не губи информация!]=
+В края на деня, [=конвертиране от int към unsigned int не губи информация!=]
 
 .p
 Цитирайки 4то издание на "The C++ Programming Language" глава 10.5:
@@ -88,7 +88,7 @@ A conversion is value-preserving if you can convert a value and then convert the
 
 .p
 Как бихме ги използвали, за да представим отрицателните числа?
-Най-лесния начин е да погледнем най-левия (старшия) бит, ако е 0 значи е положително, ако е 1 значи е отрицателно, тоест `[010]` е 2, докато `[110]` е -2.
+Най-лесния начин е да погледнем най-левия (старшия) бит, ако е 0 значи е положително, ако е 1 значи е отрицателно, тоест [`010`] е 2, докато [`110`] е -2.
 Ако разпишем всичките ни числа:
 
 ```
@@ -178,14 +178,14 @@ A conversion is value-preserving if you can convert a value and then convert the
 Още от много старите "калкулатори" ([url https://en.wikipedia.org/wiki/Adding_machine сумиращи машини]), изваждането се е свеждало до събиране на положително и отрицателно число.
 
 .p
-И това е причината защо `[~ 2]` връща `[-3]`:
+И това е причината защо [`~ 2`] връща [`-3`]:
 
 ```
 ~ 00000000000000000000000000000010
 ──────────────────────────────────
   11111111111111111111111111111101
 
-И затова при `[>>]` със знаков тип имаме аритметическо отместване:
+И затова при [`>>`] със знаков тип имаме аритметическо отместване:
 
 ```
 11111111111111111111111111111101 >> 1
@@ -200,14 +200,14 @@ A conversion is value-preserving if you can convert a value and then convert the
 [$br4]
 
 :unordered
-- `[while]` цикъл
+- [`while`] цикъл
 
   ```cpp
   while (условие) {
       тяло
   }
 
-  "условие" е булева стойност, като ако е `[false]` цикъла спира, докато ако е `[true]` "тяло" се изпълнява и после пак се проверява условие
+  "условие" е булева стойност, като ако е [`false`] цикъла спира, докато ако е [`true`] "тяло" се изпълнява и после пак се проверява условие
 
 
 
@@ -236,7 +236,7 @@ A conversion is value-preserving if you can convert a value and then convert the
 
 :slide
 :unordered
-- `[do-while]` цикъл, като `[while]`, но "тяло" се изпълнява поне един път
+- [`do-while`] цикъл, като [`while`], но "тяло" се изпълнява поне един път
 
   ```cpp
   do {
@@ -263,7 +263,7 @@ A conversion is value-preserving if you can convert a value and then convert the
 
 :middle_slide
 :unordered
-- `[for]` цикъл
+- [`for`] цикъл
 
   ```cpp
   for (инициализация; условие; инкрементация) {
@@ -271,7 +271,7 @@ A conversion is value-preserving if you can convert a value and then convert the
   }
 
   "инициализация" се изпълнява само веднъж, преди всичко останало в цикъла\n
-  "условие" се изпълнява преди всяка итерация, като ако е `[false]` цикъла спира, докато ако е `[true]` продължава\n
+  "условие" се изпълнява преди всяка итерация, като ако е [`false`] цикъла спира, докато ако е [`true`] продължава\n
   "инкрементация" се изпълнява след края на всяка итерация
 
 
@@ -305,7 +305,7 @@ A conversion is value-preserving if you can convert a value and then convert the
 
 :middle_slide
 :unordered
-- или използвайки `[while]` цикъл:
+- или използвайки [`while`] цикъл:
 
   ```cpp
   инициализация
@@ -323,15 +323,15 @@ A conversion is value-preserving if you can convert a value and then convert the
 [$br3]
 
 :unordered
-- `[break]`: моментално прекратява изпълнението на цикъла
+- [`break`]: моментално прекратява изпълнението на цикъла
 
-  .p При `[for]` цикли инкрементацията не се изпълнява след `[break]`
+  .p При [`for`] цикли инкрементацията не се изпълнява след [`break`]
 
 [$br2]
 
-- `[continue]`: продължи след края на сегашната итерация; тоест изпълнението на тяло се прекратява и започваме нова итерация
+- [`continue`]: продължи след края на сегашната итерация; тоест изпълнението на тяло се прекратява и започваме нова итерация
 
-  .p При `[for]` цикли директно отива на инкрементация
+  .p При [`for`] цикли директно отива на инкрементация
 
 
 
@@ -349,7 +349,7 @@ A conversion is value-preserving if you can convert a value and then convert the
 assert(condition);
 
 .p
-Ако `[condition]` е `[true]`, нищо не се случва, обаче ако е `[false]` програмата моментално прекратява изпълнение.
+Ако [`condition`] е [`true`], нищо не се случва, обаче ако е [`false`] програмата моментално прекратява изпълнение.
 
 .p
-Използва се повече като програмистки уред, тоест ако програмата спре заради `[assert]`, това е защото има някаква програмистка грешка.
+Използва се повече като програмистки уред, тоест ако програмата спре заради [`assert`], това е защото има някаква програмистка грешка.
diff --git a/src/teaching/upp-2023/week4/index.du b/src/teaching/upp-2023/week4/index.du
index 9f60ea6..425ffbd 100644
--- a/src/teaching/upp-2023/week4/index.du
+++ b/src/teaching/upp-2023/week4/index.du
@@ -6,7 +6,7 @@ GitHub classroom: [url https://classroom.github.com/a/jqKaO1ny classroom.github.
 
 ## Задача 1 - Числен редактор
 
-Получавате число `[N]`, което ще е в обхвата от 1 до 10000000000000000000.
+Получавате число [`N`], което ще е в обхвата от 1 до 10000000000000000000.
 Вашата програма трябва да поддържа няколко операции върху това число, включително копиране на редица от цифри в него и поставянето им в друга част на числото.
 Подробните операции ще получите по-късно, и не е нужно да валидирате вход или дали след дадена операция числото се побира в типа данни.
 
@@ -16,7 +16,7 @@ GitHub classroom: [url https://classroom.github.com/a/jqKaO1ny classroom.github.
 Всичките операции трябва да бъдат отделени във функции.
 Затова, и за улеснение, задачата е разделена на стъпки:
 
-=[ВАЖНО:]= В решението =[НЕ]= може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
+[=ВАЖНО:=] В решението [=НЕ=] може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
 
 ### Подточка а) Примитивните функции
 
@@ -25,67 +25,67 @@ GitHub classroom: [url https://classroom.github.com/a/jqKaO1ny classroom.github.
 Имплементирайте функциите:
 
 :unordered
-- `[get]`, която приема число, начален индекс и краен индекс (в този ред)\n
+- [`get`], която приема число, начален индекс и краен индекс (в този ред)\n
   Тя връща подчислото, което започва от началния и завършва в крайния индекс.
 
-  .p Пример: `[get(481395, 2, 4)]` връща `[813]`
+  .p Пример: [`get(481395, 2, 4)`] връща [`813`]
 
-- `[remove]`, която приема число, начален индекс и дължина (в този ред)\n
+- [`remove`], която приема число, начален индекс и дължина (в този ред)\n
   Връща числото, без "дължина" на брой цифри от началния индекс
 
-  .p Пример: `[remove(481395, 3, 3)]` връща `[485]`
+  .p Пример: [`remove(481395, 3, 3)`] връща [`485`]
 
-- `[insert]`, която приема число, начален индекс, дължина и число за вмъкване\n
+- [`insert`], която приема число, начален индекс, дължина и число за вмъкване\n
   Връща числото, като на началния индекс намираме началото на вмъкнатото число с дължина "дължина"\n
   Ефектът, е че числото се вмъква на дадения индекс, обаче избутва цифрите в ляво от него, вместо тези от дясно.
 
-  .p Пример: `[insert(495, 2, 4, 1001)]` връща `[4100195]`
+  .p Пример: [`insert(495, 2, 4, 1001)`] връща [`4100195`]
 
 
 ### Подточка б) Композитните функции
 
 Сега е време да имплементираме съществената логика в задачата.
-Използвайки =[само]= примитивните функции, имплементирайте функциите:
+Използвайки [=само=] примитивните функции, имплементирайте функциите:
 
 :unordered
-- `[copy]`, която приема число, начален индекс, дължина и втори начален индекс\n
+- [`copy`], която приема число, начален индекс, дължина и втори начален индекс\n
   Връща числото, като от втория начален индекс, следващите "дължина" на брой цифри съвпадат с "дължина" на брой цифри от първия начален индекс
 
-  .p Пример: `[copy(481395, 3, 4, 2)]` връща `[4139581395]`
+  .p Пример: [`copy(481395, 3, 4, 2)`] връща [`4139581395`]
 
-- `[cut]`, която приема число, начален индекс, дължина и втори начален индекс\n
+- [`cut`], която приема число, начален индекс, дължина и втори начален индекс\n
   Връща числото, като "дължина" на брой цифри от (стария) начален индекс са преместени във втория начален индекс
 
-  .p Пример: `[cut(481395, 3, 4, 2)]` връща `[413958]`
+  .p Пример: [`cut(481395, 3, 4, 2)`] връща [`413958`]
 
-- `[replace]`, която приема число, начален индекс, дължина и число за замяна\n
+- [`replace`], която приема число, начален индекс, дължина и число за замяна\n
   Връща числото, като "дължина" на брой цифри от начален индекс са заменени с числото за замяна\n
-  Заменените цифри и числото за замяна =[може да имат различни дължини]=!
+  Заменените цифри и числото за замяна [=може да имат различни дължини=]!
 
-  .p Пример: `[replace(481395, 4, 2, 705)]` връща `[4817055]`
+  .p Пример: [`replace(481395, 4, 2, 705)`] връща [`4817055`]
 
-- `[prepend]`, която приема две числа\n
+- [`prepend`], която приема две числа\n
   Връща долепени второто и първото число
 
-  .p Пример: `[prepend(395, 81)]` връща `[81395]`
+  .p Пример: [`prepend(395, 81)`] връща [`81395`]
 
-- `[append]`, която приема две числа\n
+- [`append`], която приема две числа\n
   Връща долепени първото и второто число
 
-  .p Пример: `[append(395, 81)]` връща `[39581]`
+  .p Пример: [`append(395, 81)`] връща [`39581`]
 
 
 ### Подточка в) Вход и изход
 
 Последно, време е да имплементираме интерфейса на програмата.
-Както вече казахме, първия вход е числото `[N]` с което ще извършим операция.
+Както вече казахме, първия вход е числото [`N`] с което ще извършим операция.
 
-След това приемаме буква, която определя нашата (композитна) функция, като за всички функции използваме първата буква в името им, освен за `[cut]`, за която използваме `[x]`.
-Тоест, `[c]` означава, че ще "copy"-ваме, `[p]` че ще "prepend"-ваме, `[x]` че ще "cut"-ваме и так. нат.
+След това приемаме буква, която определя нашата (композитна) функция, като за всички функции използваме първата буква в името им, освен за [`cut`], за която използваме [`x`].
+Тоест, [`c`] означава, че ще "copy"-ваме, [`p`] че ще "prepend"-ваме, [`x`] че ще "cut"-ваме и так. нат.
 
 След като въведем буква, трябва да приемем съответния за дадената функция брой аргументи и да изкараме на екрана резултата от функцията.
 
-=[Примери]=
+[=Примери=]
 
 :table_2
 |= Вход
@@ -111,7 +111,7 @@ GitHub classroom: [url https://classroom.github.com/a/jqKaO1ny classroom.github.
 Числото с коефициенти е между 1 и 10000000000000000000.
 
 Пример: първото число е 13, a второто е 3052.
-Побитово `[13 = 1101]`, тоест ще имаме
+Побитово [`13 = 1101`], тоест ще имаме
 
 ```
 x³ * 1 + x² * 1 + x¹ * 0 + x⁰ * 1
@@ -121,15 +121,15 @@ x³ * 1 + x² * 1 + x¹ * 0 + x⁰ * 1
 ```
 3 * x³* 1 + 0 * x² * 1 + 5 * x¹ * 0 + 2 * x⁰ * 1
 
-Финално, нашия полином, кодиран от числата 13 и 3052 е `[3x³ + 2]`.
+Финално, нашия полином, кодиран от числата 13 и 3052 е [`3x³ + 2`].
 
 От входа получавате два полинома, трябва да ги умножите и да изкарате получилия се полином (пак във формата с две числа).
 
-=[ВАЖНО:]= В решението =[НЕ]= може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
+[=ВАЖНО:=] В решението [=НЕ=] може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
 
 ## Задача 3 - Дъската на Зар
 
-*[Името си го измислих, няма връзка с нещо :)]*
+[*Името си го измислих, няма връзка с нещо :)*]
 
 Дъската на Зар е една много проста игра.
 Имаме два играча, които играят върху квадратна дъска, като на всяка "клетка" има цифра (0 до 9).
@@ -171,11 +171,11 @@ V
 Накрая на играта, трябва да сравните точките на първия и втория играч и да изкарате кой е победил (или дали никой не е).
 
 Един ред може да се представи като цяло число и обработваме ред по ред, без да се връщаме назад.
-Тоест, първо от входа получавате число `[N]`, което е размера на дъската.
-След това ще получавате `[N]` числа, всяко с `[N]` цифри в десетичния си запис, като след получаване на едно число изпълнявате ходовете на всички играчи.
+Тоест, първо от входа получавате число [`N`], което е размера на дъската.
+След това ще получавате [`N`] числа, всяко с [`N`] цифри в десетичния си запис, като след получаване на едно число изпълнявате ходовете на всички играчи.
 
-=[ВАЖНО:]= В решението =[НЕ]= може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
+[=ВАЖНО:=] В решението [=НЕ=] може да изполвате масиви, вектори, ..., както и каквито и да е функции, които не сте написали вие!
 
-=[Упътване:]=
+[=Упътване:=]
 Лесно се получава, ако занулим цифрите които първия играч е посетил.
 Още по-лесно става ако използвате функции от първата задача.
diff --git a/src/teaching/upp-2023/week4/revision.du b/src/teaching/upp-2023/week4/revision.du
index 558739f..622df06 100644
--- a/src/teaching/upp-2023/week4/revision.du
+++ b/src/teaching/upp-2023/week4/revision.du
@@ -20,9 +20,9 @@
 
 - Ще изисквам добър стил при писане на код
   .bulleted
-  - Това означава добре подравнен код, празни символи около оператори =[и]= свестни имена на променливи
+  - Това означава добре подравнен код, празни символи около оператори [=и=] свестни имена на променливи
   - Името на променлива не трябва да бъде 150 знака, но трябва да е разбираемо какво съдържа
-  - =[Без шльокавица!]=
+  - [=Без шльокавица!=]
 
 - Преговорът ще бъде за вас да си го четете (освен ако не трябва да преподам нещо ново)
 - Ще може да предавате задания след срока!\n
@@ -30,7 +30,7 @@
 
 
 
-*[Нещата за 2s compliment се намират и в [url ../week3/revision.html?a преговора на миналата седмица], ама го написах след като свърши часа, затова го копирам и тук.]*
+[*Нещата за 2s compliment се намират и в [url ../week3/revision.html?a преговора на миналата седмица], ама го написах след като свърши часа, затова го копирам и тук.*]
 
 :slide
 
@@ -42,7 +42,7 @@
 
 .p
 Как бихме ги използвали, за да представим отрицателните числа?
-Най-лесния начин е да погледнем най-левия (старшия) бит, ако е 0 значи е положително, ако е 1 значи е отрицателно, тоест `[010]` е 2, докато `[110]` е -2.
+Най-лесния начин е да погледнем най-левия (старшия) бит, ако е 0 значи е положително, ако е 1 значи е отрицателно, тоест [`010`] е 2, докато [`110`] е -2.
 Ако разпишем всичките ни числа:
 
 ```
@@ -137,14 +137,14 @@
 Още от много старите "калкулатори" ([url https://en.wikipedia.org/wiki/Adding_machine сумиращи машини]), изваждането се е свеждало до събиране на положително и отрицателно число.
 
 .p
-И това е причината защо `[~ 2]` връща `[-3]`:
+И това е причината защо [`~ 2`] връща [`-3`]:
 
 ```
 ~ 00000000000000000000000000000010
 ──────────────────────────────────
   11111111111111111111111111111101
 
-И затова при `[>>]` със знаков тип имаме аритметическо отместване:
+И затова при [`>>`] със знаков тип имаме аритметическо отместване:
 
 ```
 11111111111111111111111111111101 >> 1
@@ -162,13 +162,13 @@
     тяло
 }
 
-Като `[<АРГУМЕНТИ>]` са двойки от типа `[ТИП ИМЕ]`, разделени със запетаи.
-Един вид, аргументите са променливи към `[тяло]`, които задаваме извън функцията.
+Като [`<АРГУМЕНТИ>`] са двойки от типа [`ТИП ИМЕ`], разделени със запетаи.
+Един вид, аргументите са променливи към [`тяло`], които задаваме извън функцията.
 
-Извикваме функция чрез `[име(<СТОЙНОСТИ>)]`, като `[<СТОЙНОСТИ>]` са разделени със запетая и всяка съответства на поредния тип в аргументите на функцията.
-Там, където пишем `[име(<СТОЙНОСТИ>)]` се "замества" с върнатата стойност от функцията.
+Извикваме функция чрез [`име(<СТОЙНОСТИ>)`], като [`<СТОЙНОСТИ>`] са разделени със запетая и всяка съответства на поредния тип в аргументите на функцията.
+Там, където пишем [`име(<СТОЙНОСТИ>)`] се "замества" с върнатата стойност от функцията.
 
-Връщаме стойност като напишем във функцията `[return СТОЙНОСТ;]`.
+Връщаме стойност като напишем във функцията [`return СТОЙНОСТ;`].
 
 Една функция трябва да бъде декларирана преди да бъде използвана, тоест кода
 
diff --git a/src/teaching/upp-2023/week5/index.du b/src/teaching/upp-2023/week5/index.du
index 010c352..2673077 100644
--- a/src/teaching/upp-2023/week5/index.du
+++ b/src/teaching/upp-2023/week5/index.du
@@ -10,9 +10,9 @@ GitHub classroom: [url https://classroom.github.com/a/3KoIQ71H classroom.github.
 Направете функция, която получава два двуизмерни координата, покомпонентно ги сумира и връща резултатните координати.
 Няма как функцията да върне две стойности, затова добаваете оше два аргумента, които да са указатели към променливи в които да запазим сумираните координати.
 
-От входа получавате два координата, след това връщате тяхната покомпонентна сума =[използвайки функцията]=.
+От входа получавате два координата, след това връщате тяхната покомпонентна сума [=използвайки функцията=].
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -28,12 +28,12 @@ GitHub classroom: [url https://classroom.github.com/a/3KoIQ71H classroom.github.
 Трябва да поддържате операциите събиране и изваждане между две такива числа.
 
 Първо ще получите 30 цифри, които отговарят на първото числа, после още 30 цифри, които отговарят на втрото число и накрая ще получите знак.
-Ако знака е `[+]`, трябва да ги съберете и да изкарате резултата на екрана.
-Ако знака е `[-]`, трябва да ги извадите и да изкарате резултата на екрана.
+Ако знака е [`+`], трябва да ги съберете и да изкарате резултата на екрана.
+Ако знака е [`-`], трябва да ги извадите и да изкарате резултата на екрана.
 
 При изкарване трябва да следвате "нормалните" правила: цифрите са долепени и водещите нули не се пишат.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -76,18 +76,18 @@ GitHub classroom: [url https://classroom.github.com/a/3KoIQ71H classroom.github.
 
 Получавате редица цифри.
 Ако имаме поне 3 повтарящи се цифри една след друга, можем да ги премахнем.
-Тоест редицата `[0 3 1 2 2 2 4 7]` може да стане `[0 3 1 4 7]`.
+Тоест редицата [`0 3 1 2 2 2 4 7`] може да стане [`0 3 1 4 7`].
 След едно премахване, трябва да можем после да премахнем новопоявило се премахване.
-Тоест редицата `[5 1 3 3 3 3 1 1 1 9 2]` първо става `[5 1 1 1 1 9 2]` и след това `[5 9 2]`.
+Тоест редицата [`5 1 3 3 3 3 1 1 1 9 2`] първо става [`5 1 1 1 1 9 2`] и след това [`5 9 2`].
 
 Не е нужно да гледате напред за възможно най-много премахване.
-Тоест в случая `[8 1 3 4 4 4 5 5 5 5 4 4]` не се очаква да предвидите, че ако първо премахнете 5-те, после ще може да премахнете всички 4ки.
+Тоест в случая [`8 1 3 4 4 4 5 5 5 5 4 4`] не се очаква да предвидите, че ако първо премахнете 5-те, после ще може да премахнете всички 4ки.
 Премахвате първата валидна повтаряща се редица, връщате се малко назад, поглеждате дали някоя нова редица не се е появила, премахвате нея или отивате на следващата.
 
-От входа първо получавате броя `[N]` на цифрите в редицата, като `[N]` е между 1 и 40.
-След това получавате `[N]` на брой цифри и накрая връщате редицата с премахнати повтаряния.
+От входа първо получавате броя [`N`] на цифрите в редицата, като [`N`] е между 1 и 40.
+След това получавате [`N`] на брой цифри и накрая връщате редицата с премахнати повтаряния.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -112,15 +112,15 @@ GitHub classroom: [url https://classroom.github.com/a/3KoIQ71H classroom.github.
 
 Получавате редица числа.
 Всяко число е индекс към друго число в редицата (индексите започва от 0).
-Започвайки от всяка цифра, проследяваме всички "скоци", тоест ако имаме `[1 3 0 2]` и започваме от индекс 0, тогава от него скачаме на индекс 1, от него на индекс 3, от него на индекс 2 и от него се връщаме в индекс 0.
-Докато прескачаме не може да посетим вече посетен индекс, тоест ако имаме `[1 3 0 1]`, от 0 отиваме в 1, от 1 в 3 и от 3 в 1, обаче вече сме посетили индекс 1, така че спираме да скачаме.
+Започвайки от всяка цифра, проследяваме всички "скоци", тоест ако имаме [`1 3 0 2`] и започваме от индекс 0, тогава от него скачаме на индекс 1, от него на индекс 3, от него на индекс 2 и от него се връщаме в индекс 0.
+Докато прескачаме не може да посетим вече посетен индекс, тоест ако имаме [`1 3 0 1`], от 0 отиваме в 1, от 1 в 3 и от 3 в 1, обаче вече сме посетили индекс 1, така че спираме да скачаме.
 
 Търси се колко най-много скока можем да направим, започайки от който и да е индекс.
 Ако има няколко индекса с максималния брой скоци, връщаме само първия.
 
-Получавате от входа брой `[N]` на числата (индексите), като `[N]` е между 1 и 30, след това получавате толкова на брой числа (между 0 и N-1) и накрая връщате при кой начален индекс имаме най-много скока и колко са тези скоци.
+Получавате от входа брой [`N`] на числата (индексите), като [`N`] е между 1 и 30, след това получавате толкова на брой числа (между 0 и N-1) и накрая връщате при кой начален индекс имаме най-много скока и колко са тези скоци.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -166,9 +166,9 @@ sim картите са типове smart-card, това означава че
 ### а) валидационни функции
 
 .bulleted
-- `[isUnblockCode]`, приема буква и връща дали е отблокиращ код\n
+- [`isUnblockCode`], приема буква и връща дали е отблокиращ код\n
   Само главни, малки и цифри са валидни отблокиращи кодове
-- `[isPhoneNumber]`, приема число (10 цифрено) и поглежда най-левите 3 цифри\n
+- [`isPhoneNumber`], приема число (10 цифрено) и поглежда най-левите 3 цифри\n
   Те трябва да са валиден код на държава.
   Нужно е да приемате поне кодовете за България (359) и за Франция (033).
   Ако искате може и други да приемате, пълен списък има [url https://en.wikipedia.org/wiki/List_of_country_calling_codes#Alphabetical_order тук].
@@ -179,20 +179,20 @@ sim картите са типове smart-card, това означава че
 Ако отблокиращия е в невалиден формат, връщате съответно съобщение за грешка и спирате програмата.
 
 След това получавате команди, всяка команда се определя с букви и още някакви стойности.
-=[Всяка команда трябва да бъде изкарана в отделна функция!]=
+[=Всяка команда трябва да бъде изкарана в отделна функция!=]
 
 .bulleted
-- `[v]` - пробвате се да се "логнете" в сим картата.
+- [`v`] - пробвате се да се "логнете" в сим картата.
   След буквата получавате и едно число, което е въведения ПИН код.
   Ако е правилен, следващите 5 команди, които изискват упълномощение могат да се изпълнят.
   След 5те команди, упълномощението се "премахва" и трябва пак да се въведе ПИН код при упълномощени команди.
   Ако е грешен, общо има 3 опита, и след тях картата се блокира.
-- `[u]` - отпблокиране на блокирана карта.
+- [`u`] - отпблокиране на блокирана карта.
   След буквата получавате отблокиращ код и нов ПИН код.
   Ако отблокиращия код е в грешен формат или е грешната стойност, премахваме един опит.
   При 10 неуспешни опита, изкарвате съобщение, че картата е перманентно блокирана и спирате програмата.
   Ако е успешно отблокирана, тогава променяте ПИН кода и сте се "логнали" автоматично.
-- `[i]` - връща информация за СИМ картата, това са общо броя команди които са изпълнявани до сега
+- [`i`] - връща информация за СИМ картата, това са общо броя команди които са изпълнявани до сега
 
 ### в) команди с упълномощение
 
@@ -202,15 +202,15 @@ sim картите са типове smart-card, това означава че
 Ако някоя търсена стойност е невалидна или не съществува, връщате съответната грешка.
 
 .bulleted
-- `[c]` - променя ПИН код.
+- [`c`] - променя ПИН код.
   Получавате нов ПИН код и го променяте.
-- `[a]` - добавя контакт в паметта, общо може да имаме 10 контакта.
+- [`a`] - добавя контакт в паметта, общо може да имаме 10 контакта.
   Всеки контакт се определя с буква, неговото "име", и 10-цифрен мобилен номер.
   Приема допълнително неговото име и тел. номер.
   Добавяме контакта в първото незаето място, а ако всички са заети, връщаме съобщение с грешка.
-- `[r]` - приема и още една буква (име), връща телефонния номер на съответния контакт.
+- [`r`] - приема и още една буква (име), връща телефонния номер на съответния контакт.
   Ако той не съществува или телефонния номер е невалиден, връщаме съответно съобщение с грешка.
-- `[d]` - приема и още една буква (име), изтрива съответния контакт.
+- [`d`] - приема и още една буква (име), изтрива съответния контакт.
   Ако той не съществува, връщаме съответно съобщение с грешка.
-- `[o]` - променя контакт, приема допълнително две имена на контакти и телефонен номер.
+- [`o`] - променя контакт, приема допълнително две имена на контакти и телефонен номер.
   Променя контакта с първото име, като второто име и тел. номер стават новите му стойности.
diff --git a/src/teaching/upp-2023/week5/revision.du b/src/teaching/upp-2023/week5/revision.du
index 017b2a1..37c7c8d 100644
--- a/src/teaching/upp-2023/week5/revision.du
+++ b/src/teaching/upp-2023/week5/revision.du
@@ -6,22 +6,22 @@
 За да можем да определим къде дадено нещо е запазено, всяка клетка в паметта си има "адрес".
 Адресът е едно цяло положително число.
 
-Можем да вземем адреса на дадена променлива с оператора `[&]`:
+Можем да вземем адреса на дадена променлива с оператора [`&`]:
 
 ```cpp
 double a = 3.14159;
 std::cout << (&a) << std::endl;
 
-Tази програма ще върне адресът на променлива `[a]`.
+Tази програма ще върне адресът на променлива [`a`].
 
 След като имаме адрес, бихме искали да работим със стойността на този адрес.
-Това го правим с дерефериращия оператор `[*]`:
+Това го правим с дерефериращия оператор [`*`]:
 
 ```cpp
 double a = 3.14159;
 std::cout << (*(&a)) << std::endl;
 
-Тази програма връща стойността на адреса на променлива `[a]`.
+Тази програма връща стойността на адреса на променлива [`a`].
 
 Променливи, които съдържат адреси се наричат указатели.
 Синтаксисът на един указател е:
@@ -55,13 +55,13 @@ double *pointer2 = &a;
 <ТИП> <ИМЕ>[N] = { <СТОЙНОСТ> }; // дефинира всички N елементи със <СТОЙНОСТ>
 <ТИП> <ИМЕ>[N] = { <СТОЙНОСТ 1>, <СТОЙНОСТ 2>, ..., <СТОЙНОСТ M> }; // където M <= N
 
-Самото `[<ИМЕ>]` е указател, така че може да достъпваме стойности чрез указателна аритметика:
+Самото [`<ИМЕ>`] е указател, така че може да достъпваме стойности чрез указателна аритметика:
 
 ```cpp
 int arr[2] = { 83, 18 };
 std::cout << (*(arr + 1)) << std::endl;
 
-Връща втория елемент, `[18]`.
+Връща втория елемент, [`18`].
 
 Или чрез по-приятния синтаксис с квадратни скоби:
 
@@ -69,7 +69,7 @@ std::cout << (*(arr + 1)) << std::endl;
 int arr[2] = { 83, 18 };
 std::cout << (arr[1]) << std::endl;
 
-Двете неща са еквивалентни, тоест `[name[x]]` е еквивалентно на `[*(name + x)]`.
+Двете неща са еквивалентни, тоест [`name[x]`] е еквивалентно на [`*(name + x)`].
 
 Когато един масив съдържа букви, наричаме го "низ" (string).
-За да не трябва да следим дължината на един низ в друга променлива и да трябва да я подаваме, винаги завършваме нашия низ на "терминаращата нула" - `['\0']`.
+За да не трябва да следим дължината на един низ в друга променлива и да трябва да я подаваме, винаги завършваме нашия низ на "терминаращата нула" - [`'\0'`].
diff --git a/src/teaching/upp-2023/week6/index.du b/src/teaching/upp-2023/week6/index.du
index a09e7d6..f9ff0b1 100644
--- a/src/teaching/upp-2023/week6/index.du
+++ b/src/teaching/upp-2023/week6/index.du
@@ -12,7 +12,7 @@ GitHub classroom: [url https://classroom.github.com/a/BBLlWMOy classroom.github.
 
 N и M са между 1 и 60.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -42,14 +42,14 @@ N и M са между 1 и 60.
 
 Разглеждаме числатата от 0 до N.
 За всяко число знаем колко интервала го включват (покриват).
-Тоест в `[0 1 1 0]` означава, че 0 интервала "покриват" числото 0, един интервал покрива числото 1, един интервал покрива числото 2 и 0 покриват числото 3.
+Тоест в [`0 1 1 0`] означава, че 0 интервала "покриват" числото 0, един интервал покрива числото 1, един интервал покрива числото 2 и 0 покриват числото 3.
 
 Търси се колко различни интервала имаме.
 Не различаваме между два долепени интервала и един дълъг интервал.
 
 От входа получаввате N (от 1 до 30), и след това N на брой числа: броя покриващи интервали за всички числа от 0 до N-1.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -95,13 +95,13 @@ N и M са между 1 и 60.
 
 В случай, че игралното поле се запълни и никой не е спечелил, след последното му изкарване трябва да върнете "Draw!" и да спрете програмата.
 
-=[Пример:]=
-*[Смесен вход/изход, вход е означен с "$ " преди него]*
+[=Пример:=]
+[*Смесен вход/изход, вход е означен с "$ " преди него*]
 
 ```
 'include ./ex3-io.txt
 
-=[Бонус:]= направете го да работи с NxN брой клетки, като N е число между 1 и 50.
+[=Бонус:=] направете го да работи с NxN брой клетки, като N е число между 1 и 50.
 
 ## Задача 4
 
@@ -114,15 +114,15 @@ N и M са между 1 и 60.
 Редуват се първия и втория играч, като всеки въвежда две числа - координати в шоколада (между 1 и N за реда и 1 и M за колоната).
 Когато някой изяде парчето в горния ляв ъгъл, програмата изкарва "PLAYER wins!" (PLAYER е 1 или 2) и спира изпълнение.
 
-=[Пример]=
-*[Смесен вход/изход, вход е означен с "$ " преди него]*
+[=Пример=]
+[*Смесен вход/изход, вход е означен с "$ " преди него*]
 
 ```
 'include ex4-io.txt
 
 ## Задача 5
 
-=[Тази задача е много трудна, proceed with caution!]=
+[=Тази задача е много трудна, proceed with caution!=]
 
 Ще имплементираме програма, която "симулира" един елементарен компютър.
 Компютъра ни, като всеки друг, работи само и единствено с цели неотрицателни числа.
@@ -133,34 +133,34 @@ N и M са между 1 и 60.
 Започваме изпълнение от началото на паметта, след като изпълним една инструкция, изпълняваме тази директно до нея, и така докато не стигнем инструкцията "EXT".
 В такъв случай, изкарваме стойността в регистър B и спираме програмата.
 
-Това са командите, описани във формата "D - `[A B C]`", като D е число, съответстващо на инструкцията с име `[A]` (името го използваме за нас, в кода то не присъства) и аргументи след името `[B]` и `[C]`.
-`[MEMORY]` е число, съответстващо на индекс (адрес) в паметта на компютъра (между 0 и 127), а `[VALUE]` е произволна числова стойност.
+Това са командите, описани във формата "D - [`A B C`]", като D е число, съответстващо на инструкцията с име [`A`] (името го използваме за нас, в кода то не присъства) и аргументи след името [`B`] и [`C`].
+[`MEMORY`] е число, съответстващо на индекс (адрес) в паметта на компютъра (между 0 и 127), а [`VALUE`] е произволна числова стойност.
 
 :unordered
-- 0 - `[EXT]` - край на изпълнението на програмата в симулирания компютър
+- 0 - [`EXT`] - край на изпълнението на програмата в симулирания компютър
 
-- 1 - `[INC MEMORY]` - инкрементира стойността на индекс `[MEMORY]`\n
-  Пример: `[0 2]` - инкрементира стойността на индекс 2
+- 1 - [`INC MEMORY`] - инкрементира стойността на индекс [`MEMORY`]\n
+  Пример: [`0 2`] - инкрементира стойността на индекс 2
 
-- 2 - `[RIN VALUE MEMORY]` - инкрементира стойността на индекс `[VALUE + MEMORY]`\n
-  Пример: `[1 3 6]` - инкрементира стойността на адрес `[3 + 6 = 9]`
+- 2 - [`RIN VALUE MEMORY`] - инкрементира стойността на индекс [`VALUE + MEMORY`]\n
+  Пример: [`1 3 6`] - инкрементира стойността на адрес [`3 + 6 = 9`]
 
-- 3 - `[DEC MEMORY]` - декрементира стойността на индекс `[MEMORY]`
+- 3 - [`DEC MEMORY`] - декрементира стойността на индекс [`MEMORY`]
 
-- 4 - `[RDE VALUE MEMORY]` - декрементира стойността на индекс `[VALUE + MEMORY]`
+- 4 - [`RDE VALUE MEMORY`] - декрементира стойността на индекс [`VALUE + MEMORY`]
 
-- 5 - `[STA MEMORY]` - запазва стойността на индекс `[MEMORY]` в регистъра А\n
-  Пример: `[4 19]` - запазва стойността на индекс 19 в регистъра А
+- 5 - [`STA MEMORY`] - запазва стойността на индекс [`MEMORY`] в регистъра А\n
+  Пример: [`4 19`] - запазва стойността на индекс 19 в регистъра А
 
-- 6 - `[RST VALUE MEMORY]` - запазва стойността на адрес `[VALUE + MEMORY]` в регистър А\n
-  Пример: `[5 2 14]` - запазва стойността на индекс `[2 + 14 = 16]` в регистър А
+- 6 - [`RST VALUE MEMORY`] - запазва стойността на адрес [`VALUE + MEMORY`] в регистър А\n
+  Пример: [`5 2 14`] - запазва стойността на индекс [`2 + 14 = 16`] в регистър А
 
-- 7 - `[STB MEMORY]` - запазва стойността на индекс `[MEMORY]` в регистъра B
+- 7 - [`STB MEMORY`] - запазва стойността на индекс [`MEMORY`] в регистъра B
 
-- 8 - `[BEQ MEMORY]` - продължава изпълнение от индекс `[MEMORY]`, ако стойността в регистъра А е нула\n
-  Пример: `[7 8]` - продължава изпълнение от индекс 8, ако стойността в регистър А е нула
+- 8 - [`BEQ MEMORY`] - продължава изпълнение от индекс [`MEMORY`], ако стойността в регистъра А е нула\n
+  Пример: [`7 8`] - продължава изпълнение от индекс 8, ако стойността в регистър А е нула
 
-- 9 - `[BNE MEMORY]` - продължава изпълнение от индекс `[MEMORY]`, ако стойността в регистъра А не е нула
+- 9 - [`BNE MEMORY`] - продължава изпълнение от индекс [`MEMORY`], ако стойността в регистъра А не е нула
 
 
 В началото получавате N, това са броя числа, които съставят цялата програма.
@@ -169,9 +169,9 @@ N и M са между 1 и 60.
 Ако по време на изпълнение стигнете до инструкция, която не е дефинирана, изкарвате "Error: undefined instruction!" и спирате програмата.
 Ако някой аргумент е индекс в паметта, обаче стойността му е извън обхвата на паметта, изкарвате "Error: invalid memory address!" и спирате програмата.
 
-Ако няма грешка и програмата успешно стигне до `[EXT]` инструкция, както беше казано, изкарваме на екрана стойността в регистъра B.
+Ако няма грешка и програмата успешно стигне до [`EXT`] инструкция, както беше казано, изкарваме на екрана стойността в регистъра B.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -192,7 +192,7 @@ N и M са между 1 и 60.
 
 .question Какво прави последната програма?
 
-=[Бонус:]= направете програми за симулаторния компютър, които
+[=Бонус:=] направете програми за симулаторния компютър, които
 .ordered
 1. умножават числата 87401 и 37
 2. намира сумата на числата 87, 305, 2, 612, 222
diff --git a/src/teaching/upp-2023/week7/index.du b/src/teaching/upp-2023/week7/index.du
index e582368..e8173b9 100644
--- a/src/teaching/upp-2023/week7/index.du
+++ b/src/teaching/upp-2023/week7/index.du
@@ -6,17 +6,17 @@ GitHub classroom: [url https://classroom.github.com/a/m5M2_CWD classroom.github.
 
 ## Задача 1
 
-*[Това е почти същата задача като през [url ../week5/#1 седмица 5]]*
+[*Това е почти същата задача като през [url ../week5/#1 седмица 5]*]
 
 Дефинираме двуизмерен координат като две числа с плаваща запетая.
 Направете функция, която получава два двуизмерни координата, покомпонентно ги сумира и връща резултатните координати.
 Няма как функцията да върне две стойности, затова добаваете още два аргумента, които да са указатели към променливи в които да запазим сумираните координати.
 
-.warn =[Трябва]= да използвате референции вместо указатели!
+.warn [=Трябва=] да използвате референции вместо указатели!
 
-От входа получавате два координата, след това връщате тяхната покомпонентна сума =[използвайки функцията]=.
+От входа получавате два координата, след това връщате тяхната покомпонентна сума [=използвайки функцията=].
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -28,19 +28,19 @@ GitHub classroom: [url https://classroom.github.com/a/m5M2_CWD classroom.github.
 
 ## Задача 2
 
-Един магазин продава три продукта, които ще бележим с `[a]`, `[b]` и `[c]`.
+Един магазин продава три продукта, които ще бележим с [`a`], [`b`] и [`c`].
 Правим инвентарна система за тези продукти, като за всеки от тях пазим неговата бройка в склада.
 В началото имаме 0 от всеки продукт.
 
-Получавате букви, докато не стигнете до буквата `[$]`.
-Ако буквата е `[a]`, `[b]` или `[c]`, тогава този продукт става "сегашния" продукт.
-Ако буквата е `[S]`, тогава намаляте бройката на сегашния продукт с 1, а ако е `[R]` - увеличаваме с 10.
+Получавате букви, докато не стигнете до буквата [`$`].
+Ако буквата е [`a`], [`b`] или [`c`], тогава този продукт става "сегашния" продукт.
+Ако буквата е [`S`], тогава намаляте бройката на сегашния продукт с 1, а ако е [`R`] - увеличаваме с 10.
 
-.warn =[НЕ]= може да използвате масиви! =[Трябва]= действията на `[S]` и `[R]` да се изкарат във функции!
+.warn [=НЕ=] може да използвате масиви! [=Трябва=] действията на [`S`] и [`R`] да се изкарат във функции!
 
-Когато получите `[$]`, изкарвате броя на всеки продукт и спирате програмата.
+Когато получите [`$`], изкарвате броя на всеки продукт и спирате програмата.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -52,19 +52,19 @@ GitHub classroom: [url https://classroom.github.com/a/m5M2_CWD classroom.github.
 
 ## Задача 3
 
-В началото получавате буква - тя съответства на дадена =[функция]=, след това получавате 5 числа с плаваща запетая.
+В началото получавате буква - тя съответства на дадена [=функция=], след това получавате 5 числа с плаваща запетая.
 След всяко въведено трябва да изкарате резултата от съответната функция при подадено входното число.
 
-.warn =[Трябва]= да използвате указател към функция!
+.warn [=Трябва=] да използвате указател към функция!
 
 Буквите съответстват на следните функции:
 .bulleted
-- `[a]` - модул на стойност
-- `[s]` - стойност на втора степен
-- `[h]` - занулена частта след запетаята
-- `[f]` - занулена частта преди (в ляво от) запетаята
+- [`a`] - модул на стойност
+- [`s`] - стойност на втора степен
+- [`h`] - занулена частта след запетаята
+- [`f`] - занулена частта преди (в ляво от) запетаята
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -95,22 +95,22 @@ GitHub classroom: [url https://classroom.github.com/a/m5M2_CWD classroom.github.
 ```
 N. [C] TASK
 
-Където `[N]` е нейния номер (индекс), `[C]` е шпация или буквата "x" (шпация когато не е изпълнена, и "х" когато е), `[TASK]` е самия низ на задачата.
+Където [`N`] е нейния номер (индекс), [`C`] е шпация или буквата "x" (шпация когато не е изпълнена, и "х" когато е), [`TASK`] е самия низ на задачата.
 
-Програмата получава букви, докато не получи буквата `[$]`.
+Програмата получава букви, докато не получи буквата [`$`].
 Всяка буква определя някакво действие:
 .bulleted
-- при `[p]` изкарваме на екрана всички задачи
-- при `[d]` изкарваме на екрана всички завършени задачи
-- при `[t]` изкарваме на екрана всички незавършени задачи
-- след `[a]` въвеждаме нова (незавършена) задача на последния свободен индекс\n
+- при [`p`] изкарваме на екрана всички задачи
+- при [`d`] изкарваме на екрана всички завършени задачи
+- при [`t`] изкарваме на екрана всички незавършени задачи
+- след [`a`] въвеждаме нова (незавършена) задача на последния свободен индекс\n
   Ако вече пазим 64 задачи, трябва да изкараме грешка на екрана и да продължим с програмата.
-- след `[c]` въвеждаме номер на задача и обръщаме нейната изпълненост: ако е изпълнена, става неизпълнена, и ако е неизпълнена, става изпълнена
+- след [`c`] въвеждаме номер на задача и обръщаме нейната изпълненост: ако е изпълнена, става неизпълнена, и ако е неизпълнена, става изпълнена
 
 В началото на програмата нямаме никакви задачи.
 
-=[Пример:]=
-*[Смесен вход/изход, изход е отбелязан с "> ". Забележете, че има шпации в края на низове за задачи.]*
+[=Пример:=]
+[*Смесен вход/изход, изход е отбелязан с "> ". Забележете, че има шпации в края на низове за задачи.*]
 
 ```
 'include ex4-io.txt
@@ -124,17 +124,17 @@ N. [C] TASK
 След това получавате произволен брой команди - букви с възможна последователност от стойности.
 Трябва да имплементирате следните команди:
 .bulleted
-- `[s]` - изкарвате изображението на екрана
-- `[r]` - завъртате изображението по часовниковата стрелка с 90 градуса
-- `[l]` - завъртате изображението обратно на часовниковата стрелка с 90 градуса
-- `[h]` - обръщате изображението по хоризонтала (първи и последен ред се разменят, след това втори и предпоследен и так. нат.)
-- `[v]` - обръщате изображението по вертикалата (първа и последна колона се разменят, след това втора и предпоследна и так. нат.)
-- `[f]` - след този знак получавате още 4 стойности - това са два координата върху изображението, и трябва да запълните с бяло правоъгълна област с горен ляв ъгъл в първата точка и с долен десен ъгъл във втората точка.
+- [`s`] - изкарвате изображението на екрана
+- [`r`] - завъртате изображението по часовниковата стрелка с 90 градуса
+- [`l`] - завъртате изображението обратно на часовниковата стрелка с 90 градуса
+- [`h`] - обръщате изображението по хоризонтала (първи и последен ред се разменят, след това втори и предпоследен и так. нат.)
+- [`v`] - обръщате изображението по вертикалата (първа и последна колона се разменят, след това втора и предпоследна и так. нат.)
+- [`f`] - след този знак получавате още 4 стойности - това са два координата върху изображението, и трябва да запълните с бяло правоъгълна област с горен ляв ъгъл в първата точка и с долен десен ъгъл във втората точка.
   В един координат първо посочваме реда и след това колоната, като координатите започват от 0, от горния ляв ъгъл.
-- `[c]` - почти същото като `[f]`, обаче запълвате с черно, не с бяло
+- [`c`] - почти същото като [`f`], обаче запълвате с черно, не с бяло
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```
 'include ex5-io.txt
@@ -145,7 +145,7 @@ N. [C] TASK
 Задачата изглежда сложна, но не е толкова зле.
 
 За нашите цели, един "елементарен едноклетъчен автомат" е просто един голям булев масив.
-Ще наричаме стойност `[true]` жива и стойност `[false]` мъртва.
+Ще наричаме стойност [`true`] жива и стойност [`false`] мъртва.
 За всяка клетка в масива имаме правила, в зависимост от стойностите на клетката в ляво и в дясно променяме сегашната клетка.
 Направили сме една "генерация" след като обиколим всички клетки един път (от ляво на дясно) и обновим техните стойности.
 
diff --git a/src/teaching/upp-2023/week8/index.du b/src/teaching/upp-2023/week8/index.du
index 1268477..83e9a76 100644
--- a/src/teaching/upp-2023/week8/index.du
+++ b/src/teaching/upp-2023/week8/index.du
@@ -4,7 +4,7 @@
 
 GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.com/a/Big7FRUG]
 
-.warn =[Трябва]= да използвате възможно най-малко памет във всички задачи!
+.warn [=Трябва=] да използвате възможно най-малко памет във всички задачи!
 
 ## Задача 1
 
@@ -15,7 +15,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 Броим позициите на числата от 1, тоест в "8 5 9 7", 8 е на позиция 1, 5 е на позиция 2, 9 е на позиция 3 и 7 е на позиция 4.
 "Всяко второ число" са числата 5 и 7, докато "всяко трето" е само числото 9.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -43,7 +43,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 
 След ротацията трябва да изкарате числата на екрана.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -64,7 +64,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 Получавате цяло положително число N и след това получавате всички коефициенти в матрица NxN.
 Трябва да изкарате редицата числа, получена чрез умножаване на първия ред по всяка колона от същата матрица.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -100,7 +100,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 Накрая трябва да изкарате получената редица стойности.
 При изкарване трябва да пропуснете незапълнени клетки.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -120,7 +120,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 
 Получавате цели числа от входа, докато не получите числото 0.
 Представете си една права "по средата" на масива, вмъквате първото число в ляво от правата, второто в дясно, после пак в ляво и четвъртото в дясно и так. нат.
-Пример: ако са въведени числата "1 2 3 4", и си представяме правата `[|]`, при първото число правим `[1|]`, при второто `[1|2]`, при третото `[1 3|2]` и при четвъртото `[1 3|4 2]`, тоест финалната редица е "1 3 4 2".
+Пример: ако са въведени числата "1 2 3 4", и си представяме правата [`|`], при първото число правим [`1|`], при второто [`1|2`], при третото [`1 3|2`] и при четвъртото [`1 3|4 2`], тоест финалната редица е "1 3 4 2".
 
 Друг начин по който да го разберем, е че първото число е на първа позиция, второто число е на последната, третото число е на втора позиция, четвъртото е на предпоследна и так. нат.
 Обаче ние не знаем финалния размер на масива, затова се нуждаем от логиката с чертата.
@@ -130,7 +130,7 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 Напомням, че тази права само си я представяте.
 В началото масива е с размер 2.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -155,19 +155,19 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 
 Самите команди (знаци), които съставят една brainfuck програма са:
 .bulleted
-- `[>]`: сегашната клетка (къде се намирате в паметта на "машината") става тази в дясно
-- `[<]`: сегашната клетка става тази в ляво
-- `[+]`: инкрементира стойността в сегашната клетка с едно
-- `[-]`: декрементира стойността в сегашната клетка с едно
-- `[.]`: изкарва стойността в сегашната клетка (като число)
-- `[,]`: приема от входа едно число и го записва в сегашната клетка
-- `[[]`: ако стойността в сегашната клетка е 0, тогава програмата "скача" напред към знака след съответната `[]]`
-- `[]]`: ако стойността в сегашната клетка не е 0, тогава програмата "скача" назад към знака след съответната `[[]`
+- [`>`]: сегашната клетка (къде се намирате в паметта на "машината") става тази в дясно
+- [`<`]: сегашната клетка става тази в ляво
+- [`+`]: инкрементира стойността в сегашната клетка с едно
+- [`-`]: декрементира стойността в сегашната клетка с едно
+- [`.`]: изкарва стойността в сегашната клетка (като число)
+- [`,`]: приема от входа едно число и го записва в сегашната клетка
+- [`[`]: ако стойността в сегашната клетка е 0, тогава програмата "скача" напред към знака след съответната [`]`]
+- [`]`]: ако стойността в сегашната клетка не е 0, тогава програмата "скача" назад към знака след съответната [`[`]
 
-От входа ще получавате редица знаци, които ще съставят вашата brainfuck програма, като при знака `[$]` входът спира и трябва да започнете изпълнение на brainfuck кода.
+От входа ще получавате редица знаци, които ще съставят вашата brainfuck програма, като при знака [`$`] входът спира и трябва да започнете изпълнение на brainfuck кода.
 Не знаете колко памет на "машината" ще ви трябва, затова бъдете готови да я разширявате при нужда.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -224,4 +224,4 @@ GitHub classroom: [url https://classroom.github.com/a/Big7FRUG classroom.github.
 Всеки допълнителен телепортер, извън първоначалния с който спирате играта, ви носи още 50 точки.
 
 На всеки ход трябва да изкарате броя точки живот на играча, броя точки живот които меча му отнема, сегашната стая в която се намира, левите 5 стаи и десните 5 стаи.
-Една стая е изобразена със знака `[?]` ако не е посетена, `[ ]` ако е празна, `[c]` ако има съкровище, `[m]` ако има чудовище и `[t]` ако има тунел.
+Една стая е изобразена със знака [`?`] ако не е посетена, [` `] ако е празна, [`c`] ако има съкровище, [`m`] ако има чудовище и [`t`] ако има тунел.
diff --git a/src/teaching/upp-2023/week9/index.du b/src/teaching/upp-2023/week9/index.du
index 77cf2aa..9e93216 100644
--- a/src/teaching/upp-2023/week9/index.du
+++ b/src/teaching/upp-2023/week9/index.du
@@ -11,7 +11,7 @@ GitHub classroom: [url https://classroom.github.com/a/lGXxCRZO classroom.github.
 Получавате от входа два низа.
 Трябва да изкарате на екрана низ, при който има знакът "\_" на индексите, където буквите между двата низа се различават, и съответната буква, когато не се различават.
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -35,7 +35,7 @@ A__D__
 
 .important Трябва да използвате динамична памет
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -65,7 +65,7 @@ KLMNABC
 От входа получаввате един низ, трябва да изкарате броя думи в него.
 Думите се разделят с една или повече шпации, като знаци (точка, запетая, удивителна, ...) не са думи.
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -96,7 +96,7 @@ This , is ,      a , sentence    .!
 Тя позволява да погледнеш стойностите в клетки от паметта, да запишеш стойности и да стартираш програми.
 
 Игнорирайки последната му възможност, нека да го имплементираме.
-За нашите цели, паметта на компютъра е просто един масив, които ще расте =[когато е нужно]=.
+За нашите цели, паметта на компютъра е просто един масив, които ще расте [=когато е нужно=].
 Ще адресираме (индексираме) стойностите от масива с числа от 16-тична бройна система.
 
 Когато въведем низ във формата:
@@ -121,7 +121,7 @@ This , is ,      a , sentence    .!
 - "адрес: стойност ...", като предходното, обаче може да определим стойностите на сегашната и на следващите клетки (пак изкарваме във формата "X: V ...")
 
 
-=[Примери:]=
+[=Примери:=]
 
 :table_2
 |= Вход
@@ -188,7 +188,7 @@ This , is ,      a , sentence    .!
 Трябва да имплементирате програма, която получава перфо карти в стандартния IBM формат: 12 реда и 80 колони и изкарва съответния ред, който е закодиран.
 
 Тоест, от входа получавате 12 низа, всеки низ е с дължина 80, и са съставени от 0 и 1.\n
-Стойностите =[по колони]=:
+Стойностите [=по колони=]:
 
 .bulleted
 - от "100000000000" до "000000000001" (със само една 1ца) съответстват на знаците "&", "-", "0", "1", ... "9".
@@ -196,7 +196,7 @@ This , is ,      a , sentence    .!
 - от "010100000000" до "010000000001" (с две 1ци, едната която е винаги втората) съответстват на знаците от "J" до "R".
 - от "001100000000" до "001000000001" (с две 1ци, едната която е винаги третата) съответстват на знаците "/", "S", ... "Z".
 
-=[Пример:]=
+[=Пример:=]
 
 :table_2
 |= Вход
@@ -232,21 +232,21 @@ This , is ,      a , sentence    .!
 - ако не е някой от горните знаци, тогава искаме сегашната буква да бъде равна на тази в израза
 
 :unordered
-1. Какво описва регулярният израз `[aa*bcd]`?
+1. Какво описва регулярният израз [`aa*bcd`]?
 
    .p
-   Първата буква от нашия низ трябва да бъде `[а]`.
-   След това имаме `[a*]`, след тази първа буква може да имаме 0 или повече `[a]`-та.
-   Тоест втората буква може да бъде `[a]` или `[b]`, ако е `[a]`, третата буква може да бъде `[a]` или `[b]`, обаче ако втората буква е `[b]`, тогава продължаваме напред и останалите букви трябва да са `[bcd]`.
+   Първата буква от нашия низ трябва да бъде [`а`].
+   След това имаме [`a*`], след тази първа буква може да имаме 0 или повече [`a`]-та.
+   Тоест втората буква може да бъде [`a`] или [`b`], ако е [`a`], третата буква може да бъде [`a`] или [`b`], обаче ако втората буква е [`b`], тогава продължаваме напред и останалите букви трябва да са [`bcd`].
 
    .p
-   Тоест, този регулярен израз приема низове, които започват с `[a]`, след това имат 0 или повече `[a]`-та и завършват на `[bcd]`.
+   Тоест, този регулярен израз приема низове, които започват с [`a`], след това имат 0 или повече [`a`]-та и завършват на [`bcd`].
    Следните низове ще бъдат приети: "abcd", "aabcd", "aaabcd", "aaaabcd" и так. нат.
 
-2. Какво описва регулярният израз `[b*cd?]`?
+2. Какво описва регулярният израз [`b*cd?`]?
 
    .p
-   В началото имаме `[b]` нула или повече пъти, след това имаме `[c]` и накрая имаме нула или едно `[d]`.
+   В началото имаме [`b`] нула или повече пъти, след това имаме [`c`] и накрая имаме нула или едно [`d`].
    Следните низове ще бъдат приети: "c", "bc", "bbc", "bbbc", ..., "cd", "bcd", "bbcd", ...
 
 
@@ -257,8 +257,8 @@ This , is ,      a , sentence    .!
 В противен случай изкарвате "No match".
 Ако регулярния израз е в грешен формат (срещнете "?" или "\*" като първи знак), трябва да изкарате "Bad regex".
 
-=[Пример:]=
-*[Смесен вход/изход]*
+[=Пример:=]
+[*Смесен вход/изход*]
 
 ```
 'include ./ex6-io.txt
diff --git a/src/teaching/upp-2025/cpp-pitfalls/index.du b/src/teaching/upp-2025/cpp-pitfalls/index.du
index 3f04b01..8a6936b 100644
--- a/src/teaching/upp-2025/cpp-pitfalls/index.du
+++ b/src/teaching/upp-2025/cpp-pitfalls/index.du
@@ -54,12 +54,12 @@ if (condition)
 else
     myvar = false;
 
-Стойността на `[condition]` е булева сама по себе си, добрата практика е директно да запишем стойността:
+Стойността на [`condition`] е булева сама по себе си, добрата практика е директно да запишем стойността:
 
 ```c++
 myvar = condition;
 
-Като `[condition]` е какъвто и да е булев израз.
+Като [`condition`] е какъвто и да е булев израз.
 
 [$br2]
 
@@ -73,7 +73,7 @@ bool f() {
         return false;
 }
 
-Коректното е просто да върнем `[condition]`, тя е булева:
+Коректното е просто да върнем [`condition`], тя е булева:
 
 ```c++
 bool f() {
@@ -146,8 +146,8 @@ std::cout << ((double)x / y); // едното вече е с плаваща за
 ```c++
 a || b || c || d
 
-Ако `[a]` е истина, тогава другите няма да се изпълнят, защото тяхната стойност не е от значение, общия израз ще си остане истина.
-Аналогично, ако `[a]` е лъжа, но `[b]` е истина, тогава `[c]` и `[d]` няма да се изпълнят.
+Ако [`a`] е истина, тогава другите няма да се изпълнят, защото тяхната стойност не е от значение, общия израз ще си остане истина.
+Аналогично, ако [`a`] е лъжа, но [`b`] е истина, тогава [`c`] и [`d`] няма да се изпълнят.
 
 [$br2]
 
@@ -155,7 +155,7 @@ a || b || c || d
 a && b && c && d
 
 Напълно еквивалентно работи и "или".
-Ако `[a]` е лъжа, тогава другите няма да се изпълнят, защото общия израз ще си остане лъжа.
+Ако [`a`] е лъжа, тогава другите няма да се изпълнят, защото общия израз ще си остане лъжа.
 
 [$br2]
 
@@ -169,14 +169,14 @@ if (condition1 && ((myvar += 5) == 8))
 ```c++
 if (condition1 && f())
 
-И в двата случая, ако `[condition1]` е лъжа, тогава присвояването и извикването на функцията няма да се изпълнят.
+И в двата случая, ако [`condition1`] е лъжа, тогава присвояването и извикването на функцията няма да се изпълнят.
 
 Дали това е желан ефект или не зависи от кода.
 
 ## Undefined behaviour
 
 C++ наследява идеята от C, че някои неща в стандарта на езика не са дефинирани.
-Тоест, какво ще се случи зависи от имплементацията на компилатора (това което превръща кода в `[.exe]`) и често се срещат разлики.
+Тоест, какво ще се случи зависи от имплементацията на компилатора (това което превръща кода в [`.exe`]) и често се срещат разлики.
 
 ### Приоритет на скоби спрямо аритметични оператори
 
@@ -190,14 +190,14 @@ C++ наследява идеята от C, че някои неща в стан
 int x = 9;
 int y = (x += 5) * (x += 1) * (x -= 8);
 
-Има два начина да се изчисли стойността на `[y]`:
+Има два начина да се изчисли стойността на [`y`]:
 
 :ordered
 1. Първо изчисляваме всички изрази в скобите и след това изпълняваме умноженията.
 
    .p
-   Тоест, първо правим `[x += 5]`, после `[x += 1]` и след това `[x -= 8]`.
-   Това променя стойността на `[x]` на 7 и стойността на `[y]` се свежда до `[x * x * x = 343]`
+   Тоест, първо правим [`x += 5`], после [`x += 1`] и след това [`x -= 8`].
+   Това променя стойността на [`x`] на 7 и стойността на [`y`] се свежда до [`x * x * x = 343`]
 
 2. Първо изчисляваме умноженията.
    Това означава, че първо "слагаме" скоби около умноженията; израза се изпълнява все едно е:
@@ -206,17 +206,17 @@ int y = (x += 5) * (x += 1) * (x -= 8);
 ((x += 5) * (x += 1)) * (x -= 8)
 
    .p
-   *[(Умножението е ляво асоциативно)]*
+   [*(Умножението е ляво асоциативно)*]
 
    .p
-   Тоест, първо правим `[x += 5]` и след това `[x += 1]`.
-   Стойността на `[x]` е 15 и в големите скоби изчисляваме `[x * x = 225]`.
+   Тоест, първо правим [`x += 5`] и след това [`x += 1`].
+   Стойността на [`x`] е 15 и в големите скоби изчисляваме [`x * x = 225`].
    Сега израза се свежда до:
 
    ```c++
 225 * (x -= 8)
 
-   Изпълнява се `[x -= 8]`, `[x]` става 7, и `[y]` се свежда до `[225 * 7 = 1575]`.
+   Изпълнява се [`x -= 8`], [`x`] става 7, и [`y`] се свежда до [`225 * 7 = 1575`].
 
 
 Първия метод се изпълнява от компилатора на Visual Studio, втория метод от gcc (много популярен C++ компилатор под Linux/MacOS).
@@ -224,7 +224,7 @@ int y = (x += 5) * (x += 1) * (x -= 8);
 ## Масиви и матрици
 
 .important
-Всички неща, които важат за статично-заделени масиви (`[int arr[5];]`), важат и за статично-заделени матрици (`[int mat[5][6];]`)!
+Всички неща, които важат за статично-заделени масиви ([`int arr[5];`]), важат и за статично-заделени матрици ([`int mat[5][6];`])!
 
 ### Връщане на масиви
 
@@ -252,11 +252,11 @@ int main() {
     } // b се освобождава
 }
 
-Като цяло, няма особено значение дали говорим за къдравите скоби на функция, на `[if]`, на цикъл, ...
+Като цяло, няма особено значение дали говорим за къдравите скоби на функция, на [`if`], на цикъл, ...
 
 [$br2]
 
-Затова следното е =[грешно]=:
+Затова следното е [=грешно=]:
 
 ```c++
 int* f() {
@@ -264,18 +264,18 @@ int* f() {
     return arr;
 }
 
-`[arr]` е адрес в паметта (индекс, позиция, ..., която посочва клетка в паметта), някакво число.
+[`arr`] е адрес в паметта (индекс, позиция, ..., която посочва клетка в паметта), някакво число.
 
-След като функцията свърши изпълнение и се върне стойността, ще сме "стигнали" къдравата скоба и `[arr]` ще бъде освободено.
+След като функцията свърши изпълнение и се върне стойността, ще сме "стигнали" къдравата скоба и [`arr`] ще бъде освободено.
 Може да зачитате, че стойностите се унищожават в този момент.
 
 Обаче, адреса сам по себе си е число, което си се връща и ние можем да работим с него както си искаме.
 
-Тоест, =[C++ няма да ни се скара, че използваме масив, въпреки че той е, на практика, унищожен!]=
+Тоест, [=C++ няма да ни се скара, че използваме масив, въпреки че той е, на практика, унищожен!=]
 
 [$br2]
 
-Ако искаме действително да върнем масив от стойности, трябва да го създадем в =[обхвата в който функцията се извиква и да го подадем като аргумент.]=
+Ако искаме действително да върнем масив от стойности, трябва да го създадем в [=обхвата в който функцията се извиква и да го подадем като аргумент.=]
 Например:
 
 ```c++
@@ -303,7 +303,7 @@ int arr1[3] = { 1, 2, 3 };
 ```c++
 int arr2[3] = { 0 };
 
-Обаче, ако примерно се опитаме да напълним масива с единици, тогава следното =[няма]= да проработи:
+Обаче, ако примерно се опитаме да напълним масива с единици, тогава следното [=няма=] да проработи:
 
 ```c++
 int arr3[3] = { 1 };
@@ -312,10 +312,10 @@ int arr3[3] = { 1 };
 
 Инициализацията чрез къдрави скоби работи по следния начин: всички елементи в масива се попълват спрямо подадените елементи в къдравите скоби.
 
-=[Ако в къдравите скоби има по-малко елементи отколкото е голям масива, останалите елементи се попълват с нули!]=
+[=Ако в къдравите скоби има по-малко елементи отколкото е голям масива, останалите елементи се попълват с нули!=]
 
-Тоест, в `[arr2]` ние попъляваме първия елемент да е нула, и останалите стават нули по подразбиране.
-В `[arr3]` попълваме първия елемент да е единица и останалите стават нули по подразбиране.
+Тоест, в [`arr2`] ние попъляваме първия елемент да е нула, и останалите стават нули по подразбиране.
+В [`arr3`] попълваме първия елемент да е единица и останалите стават нули по подразбиране.
 
 Това навява на мисълта, дали не можем в C++ да пропуснем записването на първия елемент, когато искаме всичко да е нула?
 Можем!
@@ -334,33 +334,33 @@ for (int i = 0; i < 3; i++)
 
 ### Масиви с неконстантен размер
 
-=[Не]= позволяваме в този курс да правите такива неща:
+[=Не=] позволяваме в този курс да правите такива неща:
 
 ```c++
 int size;
 std::cin >> size;
 int arr[size];
 
-Въпреки че това *[може]* да се компилира и да работи.
+Въпреки че това [*може*] да се компилира и да работи.
 
 Причината е защото този тип масиви се наричат [url https://en.wikipedia.org/wiki/Variable-length_array VLA].
-И в =[C++ VLA-ове не са позволени!]=
+И в [=C++ VLA-ове не са позволени!=]
 
 Въпреки това, много компилатори ги поддържат, главно защото много C++ компилатори са и C компилатори (и VLA-ове са позволени в C).
 
-=[Единствения]= коректен метод да създадем масив, чиито размер не знаем предварително, е чрез динамича памет.
+[=Единствения=] коректен метод да създадем масив, чиито размер не знаем предварително, е чрез динамича памет.
 
 ### Тип на матрици (int[7][3] vs int(*)[3] vs int**)
 
 ```c++
 int mat[7][3];
 
-Какъв е типа на `[mat]`?
+Какъв е типа на [`mat`]?
 
-От една страна е `[int[7][3]]`.
-Но какъв е типа като указател, тоест когато няма въведени редове =[и]= колони?
+От една страна е [`int[7][3]`].
+Но какъв е типа като указател, тоест когато няма въведени редове [=и=] колони?
 
-Отговорите са два: `[int(*)[3]]` и `[int*]`.
+Отговорите са два: [`int(*)[3]`] и [`int*`].
 Ето защо.
 
 [$br2]
@@ -371,29 +371,29 @@ int mat[7][3];
 ```c++
 int arr[14];
 
-Тогава в паметта се *[използва]* (заделя) =[последователност]= от клетки, която побира 14 `[int]` стойности.
+Тогава в паметта се [*използва*] (заделя) [=последователност=] от клетки, която побира 14 [`int`] стойности.
 
-Също да си припомним, че `[arr]` е указател към първата от тези клетки.
+Също да си припомним, че [`arr`] е указател към първата от тези клетки.
 
-На кратко, това означава че `[arr]` е адрес (индекс, позиция, ..., число което посочва в коя клетка на паметта се намираме).
+На кратко, това означава че [`arr`] е адрес (индекс, позиция, ..., число което посочва в коя клетка на паметта се намираме).
 
 Финално припомняме, че индексирането в масив е същото като отместване на адреса.
-Т.е. `[arr[6]]` е еквивалентно на `[*(arr + 6)]`.
+Т.е. [`arr[6]`] е еквивалентно на [`*(arr + 6)`].
 
-На кратко, ние преместваме нашия адрес (индекс в паметта) напред с 6 позиции и с `[*]` дереферираме (прочитаме стойността на подадения адрес).
+На кратко, ние преместваме нашия адрес (индекс в паметта) напред с 6 позиции и с [`*`] дереферираме (прочитаме стойността на подадения адрес).
 
-Това означава, че =[всички елементи в масива е нужно да бъдат поставени последователно в паметта]=.
+Това означава, че [=всички елементи в масива е нужно да бъдат поставени последователно в паметта=].
 
 [$br2]
 
-Двумерните масиви =[работят по същия начин!]=
+Двумерните масиви [=работят по същия начин!=]
 
-В декларацията на `[mat]`, в паметта се заделя последователност от клетки в паметта, равна на размера на матрицата.
-Тоест `[7 * 3 = 21]` =[последователни]= *[позиции]* в паметта.
+В декларацията на [`mat`], в паметта се заделя последователност от клетки в паметта, равна на размера на матрицата.
+Тоест [`7 * 3 = 21`] [=последователни=] [*позиции*] в паметта.
 
-Тогава, `[mat[2][1]]` на какво е еквивалентно?
+Тогава, [`mat[2][1]`] на какво е еквивалентно?
 
-Отговорът е `[*(mat + 2 * 7 + 1)]`.
+Отговорът е [`*(mat + 2 * 7 + 1)`].
 
 Нашата таблица е разположена като последователност от клетки, където първо имаме клетките от първи ред, след това от втория ред и так. нат.
 
@@ -411,21 +411,21 @@ int nums[3][2] = {
 ```
 8 92 20 50 7 45
 
-Как извеждаме елемента `[nums[2][1]]`?
-Това е последната стойност в матрицата, `[45]`.
+Как извеждаме елемента [`nums[2][1]`]?
+Това е последната стойност в матрицата, [`45`].
 
 Щом искаме трети ред (втори по индекс), значи трябва да пропуснем първите два реда.
-Това са общо 4 числа, как го сметнахме? `[Два реда * брой колони на ред = 2 * 2]`.
+Това са общо 4 числа, как го сметнахме? [`Два реда * брой колони на ред = 2 * 2`].
 Сега сме на последния ред, искаме втория елемент (първи по индекс), значи отиваме на следващия елемент.
 
-Така показахме, че `[nums[2][1]]` е еквивалентно на `[*(nums + 2 * 2 + 1)]`.
+Така показахме, че [`nums[2][1]`] е еквивалентно на [`*(nums + 2 * 2 + 1)`].
 
 [$br2]
 
-Това трябва да поражда въпрос: не можем ли да използваме `[nums]` като едномерен масив и да напишем `[nums[2 * 2 + 1]]`?
+Това трябва да поражда въпрос: не можем ли да използваме [`nums`] като едномерен масив и да напишем [`nums[2 * 2 + 1]`]?
 
 Можем!
-Затова е смислено да преобразуваме `[int[3][2]]` към `[int*]`.
+Затова е смислено да преобразуваме [`int[3][2]`] към [`int*`].
 
 Единствения проблем, е че употребата става неприятна.
 Например:
@@ -440,7 +440,7 @@ void f(int* matrix) {
 [$br2]
 
 Забелязваме, че ако C++ знае броя колони, би трябвало да може да направи сам тази сметка с пропускането на редове.
-От там се поражда `[int(*)[2]]` като смислено преобразуване на `[int[3][2]]`.
+От там се поражда [`int(*)[2]`] като смислено преобразуване на [`int[3][2]`].
 
 Това е най-обикновен указател, обаче му даваме броя колони (и с това, подсказваме че ще работим с матрица).
 С такъв тип указател можем да използваме синтаксиса с двете квадратни скоби.
@@ -458,12 +458,12 @@ void g(int (*matrix)[2]) {
 Очевиден проблем, е че броя колони трябва да бъде константен (зададен в типа), ако искаме да ползваме двата чифта квадратни скоби.
 
 Няма ли начин да ги използваме с неконстантен брой колони?
-Отговорът е =[не!]=
+Отговорът е [=не!=]
 
-Изкушаващо е да използваме `[int**]`, но този тип обозначава нещо друго: указател към указател.
+Изкушаващо е да използваме [`int**`], но този тип обозначава нещо друго: указател към указател.
 
-Ако имаме `[int** x]`, то тогава `[x[2][1]]` =[няма]= да бъде еквивалентно на `[*(x + 2 * колони + 1)]`!
-Ще бъде еквивалентно на `[*(*(x + 2) + 1)]`!
+Ако имаме [`int** x`], то тогава [`x[2][1]`] [=няма=] да бъде еквивалентно на [`*(x + 2 * колони + 1)`]!
+Ще бъде еквивалентно на [`*(*(x + 2) + 1)`]!
 
 Това защо е така ще разберем когато учим динамична памет.
 Тогава, матриците ни няма да бъдат последователност от елементи, ами ще бъдат последователност от (указатели към) масиви.
diff --git a/src/teaching/upp-2025/ideas.du b/src/teaching/upp-2025/ideas.du
new file mode 100644
index 0000000..7453dcf
--- /dev/null
+++ b/src/teaching/upp-2025/ideas.du
@@ -0,0 +1,324 @@
+
++ "Симулация" на FNAF3 използвайки графа на ходене на Springtrap
++ Solver на шифъра на Цезар, използвайки подадена ключова дума
++ PID controller?
++ Смарт пойнтъри
++ Слайдър, получаваш начална позиция и много отмествания, накрая връщаш в коя позиция е финално
++ GitHub-стип генератор на профилно изображение: използвайки ascii
++ https://rosettacode.org/wiki/Kernighans_large_earthquake_problem
+
+Въведение, променливи
+
+ГОТОВО
+
+Оператори, условни оператори
++ Четно, нечетно
++ Аритметична прогресия - подават се три числа, връща се дали са в аритметична прогресия
++ Условен полином - подава се степен (0, 1, 2), подават се a, b, c, x, y и се смята стойността
++ Деление и умножение на две без оператор *, /
++ Логическа операция върху много двойки битове (в две числа)
++ Връщане на бит по позиция
+
++ DYMO rotation calculator
++ Timestamp convertion
++ Collision detection
+  Получавате точките на два правоъгълника в равнинатата
+  Трябва да върнете дали се пресичат или не
+
++ Парсване на data frame/CAN frame с фиксиран размер
+  https://en.wikipedia.org/wiki/ISO_15765-2
+
+Условни конструкции
++ UTF-8 type?
+
+Цикли
++ Степенуване
++ Геометрична прогресия по подадени параметри
++ Фибоначи
++ Брояч на букви (главни, малки, цифри)
++ Сума на числа докато не получи нула
++ Ред на тейлър на синус с подадена дължина
++ Метод на Херон за коренуване
++ Полином н-та степен, дали е корен
+
++ Интерполация между координати
++ Имплементация на Luhn алгоритъма
++ Имплементация на готината проверка за просто число
++ IPv4 checksum https://en.wikipedia.org/wiki/Internet_checksum
++ Tic-tac-toe статистика: да се разиграят всички възможни игри и да се върне кои от тях са успешни и кои не
++ Дали число е перфектно
++ Дали е число на армстронг
++ Ред на тейлър за логаритъм
+
+
++ Brainfuck interpreter
+
+Функции
++ Получвате цяло положително число.
+  Трябва да върнете неговото наименование на английски.
++ Операции върху 3 числа, изведени във функции и избор по "име"
++ Идентификационна система, приема много числа (за даден човек), трябва да напишат обща функция за вход на число с проверка за валидност
++ Полином от произволна степен
+
++ DVD logo bounce simulation
+  Получават размер на екрана, позиция на логото и посока (диагонална)
+  Логото се движи с дискретни координати в екрана
+  Ако стигне стена, той се удря и продължава в посока на 90 градуса
+  Връщат се броя позиции които логото ще смени преди да удари ъгъла
+
++ Текстов редактор
++ ASCII image editor?
+
+Указатели
++ N на брой числа
++ Числа докато не се получи 0
++ Умножение на матрици
++ Гаусова елиминация
+  https://en.wikipedia.org/wiki/Gaussian_elimination
+
++ BMP header parser https://en.wikipedia.org/wiki/BMP_file_format
++ Получавате N на брой числа (байтове?)
+  Тези байтове съдържат данни.
+  Данните са низове или таблици.
+  Първия байт съдържа индекса към "първата" таблица.
+  В нея се съдържат началните адреси на всички данни.
+  Адресът на таблица първо съдържа размер на данни, после брой колони и накрая данните.
+  Низът съдържа букви които са null-terminated.
+
++
+
+Масиви
++ Sakmoto's day of week method
+  https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto's_methods
+
+
++ Memory manager
+  Получава редица request-и за "заделяне" и "освобождаване" на памет в масив
+  Трябва да може да реорганизира паметта.
+  Получава и заявки за стойности в паметта.
+
+Матрици
++ Conway's game of life
++ https://rosettacode.org/wiki/Knight%27s_tour
+
+Референции
+
+Низове
++ Имплементация на FNV алгоритъма
++ Имплементация на XOR шифър https://en.wikipedia.org/wiki/XOR_cipher
++ https://en.wikipedia.org/wiki/Levenshtein_distance
++ https://rosettacode.org/wiki/Pangram_checker
++ Solver на Viginere шифъра, използвайки index of coincidence и brute force
+  https://www.cipherchallenge.org/wp-content/uploads/2020/12/Five-ways-to-crack-a-Vigenere-cipher.pdf
++ https://rosettacode.org/wiki/Jewels_and_stones
++ https://rosettacode.org/wiki/Jaro_similarity
++ https://rosettacode.org/wiki/Factorize_string_into_Lyndon_words
+
++ printf стил функционалност: с низ за шаблон и аргументи
+
+Рекурсия
++ flood fill
++ 8 queens
++ https://rosettacode.org/wiki/Flatten_a_list
++ https://rosettacode.org/wiki/Arithmetic-geometric_mean
++ sudoku
++ all tic-tac-toe games
+
++ Детерминанта чрез адюнгирани количества
+  https://en.wikipedia.org/wiki/Determinant#Laplace_expansion
+
+
+Сортиране
++ https://en.wikipedia.org/wiki/Five-number_summary
+
+
+
+
+
+
+
+
+
+### 2 задача - Делено на 7
+
+Във входа получавате цяло число.
+Трябва да върнете (изкарате на екрана) стойността на числото делено на 7 (закръглено надолу).
+
+[=Примери:=]
+
+:table_2
+|= Вход
+|= Изход
+
+|: 49
+|: 7
+
+|: 34
+|: 4
+
+
+### 3 задача - От Инчове в Сантиметри
+
+Във входа получавате цяло число: дължина в инчове.
+Трябва да върнете размера в сантиметри по формулата (закръглено надолу):
+
+[image ./cm-inch-formula Сантиметри = 50 / 127 * Инчове]
+
+[=Примери:=]
+
+:table_2
+|= Вход
+|= Изход
+
+|: 7
+|: 17
+
+|: 42
+|: 106
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+A register - always reset to 0 when started
+B register - always reset to 0 when started
+
+INPUT1 - input values
+INPUT2 - input values
+
+ASUM <value>        - A += Value
+ASUBTRACT <value>   - A -= Value
+ASHOW               - show A on the big screen
+
+BSUM <value>        - B += Value
+BSUBTRACT <value>   - B -= Value
+GOTOBZ <row>        - jump to <row> addr when B == 0
+GOTOBN <row>        - jump to <row> addr when B != 0
+
+starts on row 1, works downwards
+if it sees an empty cell, stops running
+
+5:
+	ASUM
+	5
+	ASHOW
+
+2+2:
+	ASUM
+	2
+	ASUM
+	2
+	ASHOW
+
+8+INPUT1:
+	ASUM
+	8
+	ASUM
+	INPUT1
+	ASHOW
+
+INPUT1 * 2:
+	ASUM
+	INPUT1
+	ASUM
+	INPUT1
+	ASHOW
+
+INPUT1==5:
+	BSUM
+	5
+	BSUBTRACT
+	INPUT1
+	GOTOBZ
+	+3
+	ASHOW
+	
+	ASUM
+	1
+	ASHOW
+
+if INPUT1 == 0 then INPUT2 * 2 else INPUT2 - 100:
+	BSUM
+	INPUT1
+	JUMPBZ
+	+?
+	ASUM
+	INPUT2
+	ASUBTRACT
+	100
+	ASHOW
+	
+	ASUM
+	INPUT2
+	ASUM
+	INPUT2
+	ASHOW
+
+INPUT1 == 5 || INPUT2 == 5:
+	BSUM
+	5
+	BSUBTRACT
+	INPUT1
+	GOTOBZ
+	+9
+	BSUM
+	INPUT1
+	BSUBTRACT
+	INPUT2
+	GOTOBZ
+	+3
+	ASHOW
+	
+	ASUM
+	1
+	ASHOW
+
+INPUT1 == 5 && INPUT2 == 5: TODO
+
+INPUT1 * INPUT2:
+	BSUM
+	INPUT2
+	JUMPBZ
+	+7
+	ASUM
+	INPUT1
+	BSUBTRACT
+	1
+	JUMPBZ
+	-5
+	SHOWA
+
+INPUT1 ^^ 3:
+	BSUM
+	INPUT1
+	ASUM
+	INPUT1
+	BSUBTRACT
+	1
+	JUMPBN
+	-?
+	
+	BSUM
+	INPUT1
+	JUMPBZ
+	+?
+	ASUM
+	INPUT1
+	BSUBTRACT
+	1
+	JUMPBN
+	-?
+
+
+---
diff --git a/src/teaching/upp-2025/index.du b/src/teaching/upp-2025/index.du
index 610316d..e41a422 100644
--- a/src/teaching/upp-2025/index.du
+++ b/src/teaching/upp-2025/index.du
@@ -2,17 +2,17 @@
 
 Материали на проведените през 2024/2025 практикуми по Увод в програмирането на Компютърни науки (2 поток), 5 група.
 
-=[Зала:]=  ФМИ 107       [$dbarsep]
-=[Време:]= 16:00 - 18:00 [$dbarsep]
-=[Ден:]=   Четвъртък
+[=Зала:=]  ФМИ 107       [$dbarsep]
+[=Време:=] 16:00 - 18:00 [$dbarsep]
+[=Ден:=]   Четвъртък
 
-=[Директни връзки:]=
+[=Директни връзки:=]
 [url ./week01/introduction.html?a#section-3 Контакт с мен]
 | [url https://github.com/Syndamia/upp-2025-solutions Решения на задачи]
 | [url https://github.com/18ivan18/IntroductionToProgramming2025 Материали от семинари]
 | [url https://learn.fmi.uni-sofia.bg/course/view.php?id=11601 Курс в мудъл]
 
-=[Допълнителни ресурси:]=
+[=Допълнителни ресурси:=]
 [url ./cpp-pitfalls Капани в C++]
 
 :table_3
@@ -42,7 +42,7 @@
 
 |: 2
 |: 09.10.2025
-|: Програмистко мислене *[(много експериментално)]*
+|: Програмистко мислене [*(много експериментално)*]
 
 |:
 |:
diff --git a/src/teaching/upp-2025/week01/concepts.du b/src/teaching/upp-2025/week01/concepts.du
index 53cad37..242e635 100644
--- a/src/teaching/upp-2025/week01/concepts.du
+++ b/src/teaching/upp-2025/week01/concepts.du
@@ -34,21 +34,21 @@
 - В древността (около 1940те) програмистите са ръчно са размествали жички за да работят с компютъра
 - Електротехниката се развива и това "разместване" се случва без нуждата от промяна в електрическата схема
 - На хората им омръзва от писането на числа, изобретяват програмните езици
-- Това е (=[неформатиран]=) текст, като комбинации от знаци се свеждат до съответните цифри
+- Това е ([=неформатиран=]) текст, като комбинации от знаци се свеждат до съответните цифри
   .unordered
   - Например, нека числото 200 да обозначава\n
-    "добавяне на единица към *[(регистър)]* Y"
-  - С програмен език текста `[INY]` или `[++Y]` се свежда до числото 200
+    "добавяне на единица към [*(регистър)*] Y"
+  - С програмен език текста [`INY`] или [`++Y`] се свежда до числото 200
 
 
 :middle_slide35
 
 .unordered
-- Програмите които превръщат този текст в числа се наричат =[компилатори]=.
-  Самия процес - =[компилиране]=.
+- Програмите които превръщат този текст в числа се наричат [=компилатори=].
+  Самия процес - [=компилиране=].
 - Разногласия по какъв текст какво трябва да значи още текат, затова имаме различни (програмни) езици
 - Допълнително, хората правят комбинации от знаци, които се превеждат до много числа по сложни начини
-- Така се зараждат =[парадигмите]=
+- Така се зараждат [=парадигмите=]
 
 
 :slide35
@@ -68,18 +68,18 @@
 
 .unordered
 - [url https://git-scm.com/ git] е програма, която пази такива разклонени редици от промени върху файловете в директории
-- Всяка промяна се нарича "=[commit]="
-- Различните разклонения се наричат "=[branch]="-ове
+- Всяка промяна се нарича "[=commit=]"
+- Различните разклонения се наричат "[=branch=]"-ове
 - Всеки "commit" трябва да има автор и описание, тоест commit-ове не се правят автоматично!
 - Създаването/изтриването на файлове с/без съдържание също се включва в commit-ите
-- Папка (и всички под-папки в нея) в която git следи за промени се нарича "=[repository]=" (хранилище)
+- Папка (и всички под-папки в нея) в която git следи за промени се нарича "[=repository=]" (хранилище)
 
 
 :slide35
 
 .unordered
 - Понякога искаме да споделим нашите промени и да смесим чужди промени при нас\n
-  *[(примерно няколко програмиста паралелно правят модификации по един и същ код)]*
+  [*(примерно няколко програмиста паралелно правят модификации по един и същ код)*]
 - Можем да използваме Google Drive/Dropbox/... и ръчно да смесваме, но става сложно и тромаво
 - Сайтове като [url https://github.com GitHub] са специализирани за работа с repository-та.
   Предоставят:
@@ -103,9 +103,9 @@
 [$br1]
 
 .unordered
-- Чрез [url https://classroom.github.com GitHub Classroom] ще създавам =[задания с ограничен срок]= (края на съответното упражнение)
+- Чрез [url https://classroom.github.com GitHub Classroom] ще създавам [=задания с ограничен срок=] (края на съответното упражнение)
 - Когато вие приемете заданието, автоматично се създава git repository към което имате (ограничен) достъп
-- Преди срока трябва да добавите commit с вашата работа по време на упражнението, =[колкото и малко да е!]=
+- Преди срока трябва да добавите commit с вашата работа по време на упражнението, [=колкото и малко да е!=]
 - Добавя се един автоматичен "pull request" в който ще пиша отзивите.
 
 
diff --git a/src/teaching/upp-2025/week01/github_classroom.du b/src/teaching/upp-2025/week01/github_classroom.du
index 216a09d..fbce90d 100644
--- a/src/teaching/upp-2025/week01/github_classroom.du
+++ b/src/teaching/upp-2025/week01/github_classroom.du
@@ -69,7 +69,7 @@
 При приемане на заданието се генерира repository.
 
 .p
-Трябва да сте качили работата си =[по време]= на упражнението (или малко след това) в това repository.
+Трябва да сте качили работата си [=по време=] на упражнението (или малко след това) в това repository.
 GitHub предоставя лесни начини да правите промени по файлове директно чрез браузъра, така че за незаинтересуваните, може да го ползвате като усложнен Google Drive.
 
 .p
@@ -160,9 +160,9 @@ GitHub предоставя лесни начини да правите пром
 Най-елементарния начин: копирате всичко, след това отивате на вашето GitHub repository, кликвате "Add", после "Create new file".
 
 .p
-Отгоре на "Name your file..." пишете някакво име, което =[моля да завърша на `[.cpp]`!]=
+Отгоре на "Name your file..." пишете някакво име, което [=моля да завърша на [`.cpp`]!=]
 Това показва, че файла съдържа код на C++.
-Също, когато решавате много задачи и създавате много такива файлове, =[напомням че имената на файловете трябва да са различни.]=
+Също, когато решавате много задачи и създавате много такива файлове, [=напомням че имената на файловете трябва да са различни.=]
 
 .p
 В "Enter file contents here" пействате копирания код.
diff --git a/src/teaching/upp-2025/week01/index.du b/src/teaching/upp-2025/week01/index.du
index 4cb0503..f3a5364 100644
--- a/src/teaching/upp-2025/week01/index.du
+++ b/src/teaching/upp-2025/week01/index.du
@@ -17,7 +17,7 @@ GitHub Classroom: [url https://classroom.github.com/a/-1l498jX]
 Ако използвате Visual Studio, проектът по подразбиране трябва да съдържа програмата за "Hello, World!".
 Нужно е единствено да я компилирате и пуснете, както са инструкциите в [url ./visual_studio.du#section-6 презентацията "Visual Studio"].
 
-Ако използвате друга среда/редактор, създайте `[C++]` файл със следното съдържание:
+Ако използвате друга среда/редактор, създайте [`C++`] файл със следното съдържание:
 
 ```c++
 'include ./helloworld.cpp
@@ -36,7 +36,7 @@ GitHub Classroom: [url https://classroom.github.com/a/-1l498jX]
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week01 Решение]
 
-Създайте =[ZIP архив]= който съдържа вашия `[.cpp]` файл (съдържащ "Hello, World!" програмата).
+Създайте [=ZIP архив=] който съдържа вашия [`.cpp`] файл (съдържащ "Hello, World!" програмата).
 Качете архива във вашето repository към заданието най-отгоре на страницата.
 
 Инструкции за създаване на ZIP архив [url ./zip.html тук].
diff --git a/src/teaching/upp-2025/week01/introduction.du b/src/teaching/upp-2025/week01/introduction.du
index a1eb3d7..1e077c5 100644
--- a/src/teaching/upp-2025/week01/introduction.du
+++ b/src/teaching/upp-2025/week01/introduction.du
@@ -89,9 +89,9 @@
 [$br3]
 
 .unordered
-- =[Лекции]= - теория и формалности зад нещата
-- =[Семинари]= (семинарни упражнения) - как теоретичните неща се реализират
-- =[Практикуми]= (практически упражнения) - реализиране на нещата от вас
+- [=Лекции=] - теория и формалности зад нещата
+- [=Семинари=] (семинарни упражнения) - как теоретичните неща се реализират
+- [=Практикуми=] (практически упражнения) - реализиране на нещата от вас
 
 
 :slide35
@@ -113,9 +113,9 @@
 [$br4]
 
 .unordered
-- Ще работим изцяло с езика `[C++]`
+- Ще работим изцяло с езика [`C++`]
 - Ще разглеждаме общи концепции: оператори, цикли, функции, масиви, низове
-- И някои по-специални понятия: =[указатели]=, =[рекурсия]=
+- И някои по-специални понятия: [=указатели=], [=рекурсия=]
 
 
 :slide35
@@ -133,9 +133,9 @@
 ### За хората без опит
 
 .unordered
-- Материалът е =[много]= и бързо напредваме.
+- Материалът е [=много=] и бързо напредваме.
   Няма да имаме време всичко да изговорим.
-- Допълнителна самоподготовка е =[нужна]= и едва ли ще можете да се справите без нея.
+- Допълнителна самоподготовка е [=нужна=] и едва ли ще можете да се справите без нея.
 
 
 :slide35
@@ -145,10 +145,10 @@
 [$br3]
 
 .unordered
-- =[Не се отпускайте!]=
-- `[C++]` е език на ниско ниво, има безброй много детайли които може да ви спънат.
+- [=Не се отпускайте!=]
+- [`C++`] е език на ниско ниво, има безброй много детайли които може да ви спънат.
 - Ние имаме специфични изисквания за писане на код.\n
-  =[Ако не ги спазвате, дори решението да работи, може да получите слаба оценка!]=
+  [=Ако не ги спазвате, дори решението да работи, може да получите слаба оценка!=]
 
 
 :slide35
@@ -159,14 +159,14 @@
 
 .unordered
 - В училище (разкрито) преписването води до двойка и потенциално обаждане към родителите.
-- Във ФМИ при установено плагиатството, =[в срок от една година]=, студента *[може]* да бъде =[изключен от университета без възможност да се запише обратно]=.
+- Във ФМИ при установено плагиатството, [=в срок от една година=], студента [*може*] да бъде [=изключен от университета без възможност да се запише обратно=].
 - По-добре си изкарайте двойката, ще ви дадем достатъчно шансове да си минете курса.
 
 
 :middle_slide35
 :centered
 
-.p *[Пък и може би не си заслужава...]*
+.p [*Пък и може би не си заслужава...*]
 
 <iframe width="480" height="360" src="https://www.youtube.com/embed/hMloyp6NI4E">
 </iframe>
@@ -188,7 +188,7 @@
 - В началото на часа давам задачи, вие ги решавате.
 - Всички текстови редактори/IDE-та са позволени.
 - До края на часа трябва да предадете написаното от вас в [url ./github_classroom.html#-github-classroom-1 GitHub Classroom]
-- Ще връщам обратна връзка към предаденото, *[моля да я четете!]*
+- Ще връщам обратна връзка към предаденото, [*моля да я четете!*]
 
 
 :slide
@@ -203,7 +203,7 @@
 ; За самоподготовка
 : По-сложни задачи, които ще описват възможни проблеми от реалния свят
 ; За любознателните
-: 1-2 сложни задачи, чиято цел е да се реализира *[реалистичен]* използваем софтуерен компонент
+: 1-2 сложни задачи, чиято цел е да се реализира [*реалистичен*] използваем софтуерен компонент
 
 
 :middle_slide35
@@ -223,7 +223,7 @@
 .unordered
 - Ще чуете и други мнения от екипа по тематa
 - Анализ на генериран изход от ИИ ще бъде разглеждан в курса
-- На практикумите ви е позволено да го ползвате, =[но]= не го окуражавам
+- На практикумите ви е позволено да го ползвате, [=но=] не го окуражавам
 
 
 :slide35
@@ -232,9 +232,9 @@
 
 .p Различни умения са:
 .numbered
-1. да =[напишеш сам]= код от нулата
-2. да =[четеш]= код и разбереш какво прави
-3. да =[модифицираш/допълниш]= вече написан код
+1. да [=напишеш сам=] код от нулата
+2. да [=четеш=] код и разбереш какво прави
+3. да [=модифицираш/допълниш=] вече написан код
 
 .unordered
 - Чрез ИИ избягвате да правите първото.
diff --git a/src/teaching/upp-2025/week01/visual_studio.du b/src/teaching/upp-2025/week01/visual_studio.du
index a6735fb..cf7a9d4 100644
--- a/src/teaching/upp-2025/week01/visual_studio.du
+++ b/src/teaching/upp-2025/week01/visual_studio.du
@@ -19,14 +19,14 @@
 [$br2]
 
 .p
-=[Кодът е чисто и просто текст]=, компилаторът е специалната програма, която превръща този текст в нещо, което може компютъра да изпълни.
+[=Кодът е чисто и просто текст=], компилаторът е специалната програма, която превръща този текст в нещо, което може компютъра да изпълни.
 
 .p
-За писане и редактиране на текст ползваме =[текстови редактори]=.
+За писане и редактиране на текст ползваме [=текстови редактори=].
 Програмистите са искали да улеснят работата си, затова модерните текстови редактори поддържат много помощни функционалности: показване на грешки на точния ред, автоматично форматиране, ...
 
 .p
-За някои и това не е било достатъчно удобно, затова са създадени =[Integrated Development Environment]= (IDE), програми които съдържат в себе си всичко нужно за разработка на код.
+За някои и това не е било достатъчно удобно, затова са създадени [=Integrated Development Environment=] (IDE), програми които съдържат в себе си всичко нужно за разработка на код.
 Тоест, те са текстови редактори, но "вградено" могат да компилират код, да менажират сегашното repository, ...
 
 
@@ -179,7 +179,7 @@ Visual Studio е вече инсталирано там.
 В Solution Explorer имате всички файлове от проекта (Visual Studio позволява да групирате няколко проекта в едно, наречено Solution, не е нужно да се занимавате).
 
 .p
-Тук =[единственото важно за вас се намира в папката "Source Files"]=.
+Тук [=единственото важно за вас се намира в папката "Source Files"=].
 В нея ще се намира вашия код, всичко останало са допълнителни неща, които са релевантни за по-големи проекти.
 
 
diff --git a/src/teaching/upp-2025/week01/zip.du b/src/teaching/upp-2025/week01/zip.du
index 57457a8..d81320a 100644
--- a/src/teaching/upp-2025/week01/zip.du
+++ b/src/teaching/upp-2025/week01/zip.du
@@ -26,7 +26,7 @@
 [$br4]
 
 :unordered
-- Под Windows 11 с *[новото]* меню което излиза при натискане на десен бутон, можете директно да архивирате селектираните файлове
+- Под Windows 11 с [*новото*] меню което излиза при натискане на десен бутон, можете директно да архивирате селектираните файлове
 - Тоест, процедурата е
   .numbered
   1. Селекция на файловете за архивиране
@@ -60,11 +60,11 @@
 
 .ordered
 1. Селектирате файловете които искате да архивирате
-2. Десен бутон *[(под Windows 11 трябва да натиснете "Show more options")]*
+2. Десен бутон [*(под Windows 11 трябва да натиснете "Show more options")*]
 3. Задържате курсора върху "7-Zip"
-4. Избирате `[Add to "SOMETHING.=[zip]="]`, където `[SOMETHING]` ще е името на папката в която се намирате.
+4. Избирате [`Add to "SOMETHING.[=zip=]"`], където [`SOMETHING`] ще е името на папката в която се намирате.
    Това директно създава архив с името на текущата папка.
-5. Алтернативно избирате `[Add to archive...]`.
+5. Алтернативно избирате [`Add to archive...`].
    От там се отваря прозорец с настройки, най-важно под "Archive format" да изберете ZIP.
    Другите неща не е нужно да променяте.
 
@@ -87,14 +87,14 @@
 
 .p
 .font20
-*[Ползваш Linux и се нуждаеш от туториал? Слабо.]*
+[*Ползваш Linux и се нуждаеш от туториал? Слабо.*]
 
 [$br5]
 
 ### Чрез командния ред
 
 .ordered
-1. Инсталираш `[zip]` командата (пакета почти винаги също се казва `[zip]`)
+1. Инсталираш [`zip`] командата (пакета почти винаги също се казва [`zip`])
 2. Извикваш команда във следната форма:
 ```bash
 zip archive.zip file1 file2 ...
diff --git a/src/teaching/upp-2025/week02/index.du b/src/teaching/upp-2025/week02/index.du
index b014ef9..d1be61f 100644
--- a/src/teaching/upp-2025/week02/index.du
+++ b/src/teaching/upp-2025/week02/index.du
@@ -20,66 +20,66 @@ GitHub Classroom: [url https://classroom.github.com/a/DRjtkc6f]
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение02.csv Решение]
 
-Покажете сумата на `[INPUT1]` и 8 в "popup".
+Покажете сумата на [`INPUT1`] и 8 в "popup".
 
 ## Задача 3
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение03.csv Решение]
 
-Покажете числото `[INPUT1]` в "popup", но с обърнат знак.
+Покажете числото [`INPUT1`] в "popup", но с обърнат знак.
 
 ## Задача 4
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение04.csv Решение]
 
-Покажете `[INPUT1]` умножено по две в "popup".
+Покажете [`INPUT1`] умножено по две в "popup".
 
 ## Задача 5
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение05.csv Решение]
 
-Ако `[INPUT1]` е равно на 10, покажете в "popup" стойността 1.
+Ако [`INPUT1`] е равно на 10, покажете в "popup" стойността 1.
 Иначе, покажете стойността 0.
 
 ## Задача 6
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение06.csv Решение]
 
-Покажете в "popup" числото 1 ако `[INPUT1]` =[или]= `[INPUT2]` е равно на 5.
+Покажете в "popup" числото 1 ако [`INPUT1`] [=или=] [`INPUT2`] е равно на 5.
 Иначе покажете 0.
 
 ## Задача 7
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение07.csv Решение]
 
-Покажете в "popup" числото 1 ако `[INPUT1]` =[и]= `[INPUT2]` са равни на 5.
+Покажете в "popup" числото 1 ако [`INPUT1`] [=и=] [`INPUT2`] са равни на 5.
 Иначе покажете 0.
 
 ## Задача 8
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение08.csv Решение]
 
-Покажете в "popup" умножението на `[INPUT1]` и `[INPUT2]`.
-Допускаме, че `[INPUT2]` е неотрицателно цяло число.
+Покажете в "popup" умножението на [`INPUT1`] и [`INPUT2`].
+Допускаме, че [`INPUT2`] е неотрицателно цяло число.
 
 ## Задача 9
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение09.csv Решение]
 
-Нека `[INPUT1]` да обозначава разликата на аритметична прогресия (разликата между два съседни елементa) и `[INPUT2]` да обозначава индекса на елемент в тази прогресия.
+Нека [`INPUT1`] да обозначава разликата на аритметична прогресия (разликата между два съседни елементa) и [`INPUT2`] да обозначава индекса на елемент в тази прогресия.
 
-Покажаете в "popup" числото на `[INPUT2]` позиция от аритметичната прогресия.
+Покажаете в "popup" числото на [`INPUT2`] позиция от аритметичната прогресия.
 Нека първия елемент винаги е 0 и неговия индекс е 1.
 
-Допускаме, че `[INPUT2]` е неотрицателно цяло число.
+Допускаме, че [`INPUT2`] е неотрицателно цяло число.
 
 ## Задача 10
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week02/Решение10.csv Решение]
 
 .note
-=[(11.09.2025)]= Вече в условието и `[INPUT1]` е неотрицателно, иначе решението става твърде голямо.
+[=(11.09.2025)=] Вече в условието и [`INPUT1`] е неотрицателно, иначе решението става твърде голямо.
 
-Покажете в "popup" делението на `[INPUT1]` и `[INPUT2]`, закръглено нагоре.
-Допускаме, че `[INPUT1]` и `[INPUT2]` са неотрицателни цели числа.
+Покажете в "popup" делението на [`INPUT1`] и [`INPUT2`], закръглено нагоре.
+Допускаме, че [`INPUT1`] и [`INPUT2`] са неотрицателни цели числа.
 Може да зачитате, че резултата при деление на 0 е 0.
diff --git a/src/teaching/upp-2025/week02/machine.du b/src/teaching/upp-2025/week02/machine.du
index 089bf0a..6c63d22 100644
--- a/src/teaching/upp-2025/week02/machine.du
+++ b/src/teaching/upp-2025/week02/machine.du
@@ -8,7 +8,7 @@
 В тази таблица може да редактирате клетките на колона A и тези срещу INPUT1 и INPUT2.
 
 При изпълнение, всяка клетка в A се обикаля отгоре-надолу (показано с жълто).
-Ако срещне =[команда]= тогава потенциално прочита и долната клетка, и извършва някакво действие.
+Ако срещне [=команда=] тогава потенциално прочита и долната клетка, и извършва някакво действие.
 
 Повече подробности в [url ./machine_manual.html упътването].
 Списък от налични команди [url #section-1 в дъното на страницата].
@@ -19,25 +19,25 @@
 ## Команди
 
 :defs
-; `[ASUM]`
-: Прави `[A = A + <числото в долната клетка>]`
+; [`ASUM`]
+: Прави [`A = A + <числото в долната клетка>`]
 
-; `[ASUBTRACT]`
-: Прави `[A = A - <числото в долната клетка>]`
+; [`ASUBTRACT`]
+: Прави [`A = A - <числото в долната клетка>`]
 
-; `[ASHOW]`
-: Показва стойността на `[A]` като pop-up.
+; [`ASHOW`]
+: Показва стойността на [`A`] като pop-up.
 
-; `[BSUM]`
-: Прави `[B = B + <числото в долната клетка>]`
+; [`BSUM`]
+: Прави [`B = B + <числото в долната клетка>`]
 
-; `[BSUBTRACT]`
-: Прави `[B = B - <числото в долната клетка>]`
+; [`BSUBTRACT`]
+: Прави [`B = B - <числото в долната клетка>`]
 
-; `[GOTOBZ]`
-: Ако `[B]` =[е]= 0, тогава отива на реда, посочен от следващата клетка.
+; [`GOTOBZ`]
+: Ако [`B`] [=е=] 0, тогава отива на реда, посочен от следващата клетка.
   Иначе продължава нататък.
 
-; `[GOTOBN]`
-: Ако `[B]` =[е по-голямо или равно на]= 0, тогава отива на реда, посочен от следващата клетка.
+; [`GOTOBN`]
+: Ако [`B`] [=е по-голямо или равно на=] 0, тогава отива на реда, посочен от следващата клетка.
   Иначе продължава нататък.
diff --git a/src/teaching/upp-2025/week02/machine_manual.du b/src/teaching/upp-2025/week02/machine_manual.du
index acf5559..7090a12 100644
--- a/src/teaching/upp-2025/week02/machine_manual.du
+++ b/src/teaching/upp-2025/week02/machine_manual.du
@@ -18,8 +18,8 @@
 - Целта е да разиграем мисленето за програмиране
 - Без да пишем истински код
 - "Машинната таблица" е специална таблица, която създадох за този практикум\n
-  *[(щеше да е на Excel ама...)]*
-- Тя симулира действието на един =[много]= прост компютър
+  [*(щеше да е на Excel ама...)*]
+- Тя симулира действието на един [=много=] прост компютър
 
 
 :slide35
@@ -37,7 +37,7 @@
 
 .centered
 .font18
-*[(По принцип ще спре при първия празен ред)]*
+[*(По принцип ще спре при първия празен ред)*]
 
 .centered
 .p
@@ -48,7 +48,7 @@
 
 .centered
 .p
-Продължава да обикаля клетки, докато не срещне =[празна клетка]= или не свършат всички клетки
+Продължава да обикаля клетки, докато не срещне [=празна клетка=] или не свършат всички клетки
 
 .centered
 .p
@@ -58,17 +58,17 @@
 :middle_slide35
 
 .unordered
-- Във всяка една клетка може да срещне =[команда]= или =[число]=
+- Във всяка една клетка може да срещне [=команда=] или [=число=]
 - Очаква последователност от команди в колона A
-- След =[някои]= команди, може да се срещне и число
+- След [=някои=] команди, може да се срещне и число
 - Стойности могат да се въвеждат в колоната A
 - Клетките "A" и "B" стават 0 при изпълнение
-- Всяка команда работи със стойността на клетката "A" =[или]= "B"
+- Всяка команда работи със стойността на клетката "A" [=или=] "B"
 
 
 :middle_slide35
 
-## Командата `[ASHOW]`
+## Командата [`ASHOW`]
 
 .p
 Показва стойността на клетката A като popup
@@ -79,7 +79,7 @@
 
 :middle_slide35
 
-## Командата `[ASUM]`
+## Командата [`ASUM`]
 
 .p
 Поглежда числото в долната клетка и го сумира към клетката "А".
@@ -101,10 +101,10 @@
 
 :middle_slide35
 
-## Командата `[ASUBTRACT]`
+## Командата [`ASUBTRACT`]
 
 .p
-Като `[ASUM]`, но изважда вместо да събере.
+Като [`ASUM`], но изважда вместо да събере.
 
 .p
 [image ./img/table_asubtract.gif]
@@ -143,29 +143,29 @@
 
 :middle_slide35
 
-## Командата `[BSUM]`
+## Командата [`BSUM`]
 
 .p
-Същото като `[ASUM]`, но с клетка "B".
+Същото като [`ASUM`], но с клетка "B".
 
-## Командата `[BSUBTRACT]`
+## Командата [`BSUBTRACT`]
 
 .p
-Същото като `[ASUBTRACT]`, но с клетка "B".
+Същото като [`ASUBTRACT`], но с клетка "B".
 
 [$br1]
 
 .p
-=[Нямаме `[BSHOW]`!]=
+[=Нямаме [`BSHOW`]!=]
 Но имаме други специални команди.
 
 
 :middle_slide35
 
-## Командата `[GOTOBZ]`
+## Командата [`GOTOBZ`]
 
 .p
-=[Ако]= клетка "B" е равна на 0, тогава прочита следващата клетка и отива на посочения ред.
+[=Ако=] клетка "B" е равна на 0, тогава прочита следващата клетка и отива на посочения ред.
 
 .p
 [image ./img/table_gotobz.gif]
@@ -174,7 +174,7 @@
 :middle_slide
 
 .p
-=[Иначе]= продължава напред
+[=Иначе=] продължава напред
 
 .p
 [image ./img/table_gotobz_false.gif]
@@ -182,17 +182,17 @@
 
 :middle_slide35
 
-## Командата `[GOTOBN]`
+## Командата [`GOTOBN`]
 
 .p
-Същата като `[GOTOBZ]`, обаче отива на посочения ред когато "B" е =[по-голямо или равно]= на 0 (неотрицателно).
+Същата като [`GOTOBZ`], обаче отива на посочения ред когато "B" е [=по-голямо или равно=] на 0 (неотрицателно).
 
 
 :middle_slide35
 
 .unordered
 - Употребата на останалите бутони трябва да е явна.
-- "Запази" запазва =[само]= колона A!
+- "Запази" запазва [=само=] колона A!
 
 
 :middle_slide35
diff --git a/src/teaching/upp-2025/week03/index.du b/src/teaching/upp-2025/week03/index.du
index c1001af..6eeb8f4 100644
--- a/src/teaching/upp-2025/week03/index.du
+++ b/src/teaching/upp-2025/week03/index.du
@@ -78,10 +78,10 @@ GitHub Classroom: [url https://classroom.github.com/a/UMc2WhVX]
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week03/Exercise05.cpp Решение]
 
-Получавате десетично число: сума в =[левове]=.
-Трябва да върнете същата сума в =[евро]=, като `[1 &euro; = 1.95583 лв]`.
+Получавате десетично число: сума в [=левове=].
+Трябва да върнете същата сума в [=евро=], като [`1 &euro; = 1.95583 лв`].
 
-*[Поради прецизност при такива числа, вашите изходи може с много малко да се различават.]*
+[*Поради прецизност при такива числа, вашите изходи може с много малко да се различават.*]
 
 :table_2
 |= Вход
@@ -141,7 +141,7 @@ GitHub Classroom: [url https://classroom.github.com/a/UMc2WhVX]
 .bulleted
 - средно аритметично,
 - сума,
-- сума от вида `[1/<първо число> + 1/<второ число> + ...]`,
+- сума от вида [`1/<първо число> + 1/<второ число> + ...`],
 - умножение.
 
 :table_2
@@ -162,11 +162,11 @@ GitHub Classroom: [url https://classroom.github.com/a/UMc2WhVX]
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week03/Exercise08.cpp Решение]
 
-Получавате 5 реални числа: коефициентите на полином от трета степен `[a]` (`[a]` различно от 0), `[b]`, `[c]`, `[d]` и потенциален негов корен `[x]`.
+Получавате 5 реални числа: коефициентите на полином от трета степен [`a`] ([`a`] различно от 0), [`b`], [`c`], [`d`] и потенциален негов корен [`x`].
 
-Трябва да върнете 1 ако `[x]` е корен на уравнението и 0 ако не е.
+Трябва да върнете 1 ако [`x`] е корен на уравнението и 0 ако не е.
 
-Припомняме, че `[x]` е корен на кубично уравнение, когато:
+Припомняме, че [`x`] е корен на кубично уравнение, когато:
 
 [image ./img/cubic.png]
 
@@ -271,14 +271,14 @@ GitHub Classroom: [url https://classroom.github.com/a/UMc2WhVX]
 
 От входа ще получите два ъгъла в радиани, &alpha; и &beta;, чиято сума е между 0 и &pi;/2 (включително).
 
-Използвайки =[единствено]= апроксимацията на Бхаскара 1ви, пресметнете `[tg(&alpha; + &beta;)]`.\n
-=[Не може да използвате коренуване!]=
+Използвайки [=единствено=] апроксимацията на Бхаскара 1ви, пресметнете [`tg(&alpha; + &beta;)`].\n
+[=Не може да използвате коренуване!=]
 
 За константата &pi;, използвайте поне 5 цифри след десетичната запетая.
 
 .text
 <details>
-<summary>*[Подсказка]*</summary>
+<summary>[*Подсказка*]</summary>
 Използвайте факта, че [url https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Shifts_and_periodicity може да представите косинус чрез отместване на синус].
 </details>
 
@@ -404,7 +404,7 @@ pi / 8 = 0.392698
 Примерно, числото 2148271109 в двоичната бройна система е 10000000000011000000010000000101, което се разделя на подчислата 10000000, 00001100, 00000100 и 00000101 (128, 12, 4 и 5).
 
 Получавате две 32-битови цели неотрицателни числа.
-Сумирайте =[съответните]= подчисла в двете числа и изкарайте резултаното "надчисло".
+Сумирайте [=съответните=] подчисла в двете числа и изкарайте резултаното "надчисло".
 
 :table_2
 |= Вход
@@ -474,7 +474,7 @@ pi / 8 = 0.392698
 
 ### Задача 15
 
-В модерния интернет, всяко устройство се обозначава с *[уникален]* адрес.
+В модерния интернет, всяко устройство се обозначава с [*уникален*] адрес.
 Това е 32-битово цяло неотрицателно число.
 
 За човешко удобоство, това число се представя чрез "dot-decimal notation": всеки 8 бита се представят като десетично число и тези 4 числа се слепват с точки между тях.
diff --git a/src/teaching/upp-2025/week04/index.du b/src/teaching/upp-2025/week04/index.du
index e803f2e..8b138fa 100644
--- a/src/teaching/upp-2025/week04/index.du
+++ b/src/teaching/upp-2025/week04/index.du
@@ -9,7 +9,7 @@ GitHub Classroom: [url https://classroom.github.com/a/rOzekyCs]
 
 :important
 .p
-При `[if]`-ове =[ще]= вземаме точки за изрази от типа:
+При [`if`]-ове [=ще=] вземаме точки за изрази от типа:
 
 ```c++
 if (condition)
@@ -122,11 +122,11 @@ else
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week04/Exercise04.cpp Решение]
 
-От входа получавате реални коефициенти на квадратно уравнение: `[a]`, `[b]` и `[c]`.
+От входа получавате реални коефициенти на квадратно уравнение: [`a`], [`b`] и [`c`].
 Трябва да изкарате корените на уравнението, като:
 .bulleted
 - ако има два корена, изкарвате и двата,
-- ако има един корен, изкарвате =[само]= него,
+- ако има един корен, изкарвате [=само=] него,
 - ако няма реални корени, изкарвате "No real roots".
 
 :table_2
@@ -149,11 +149,11 @@ else
 
 От входа получавате буква, съответстваща на операция върху числа:
 .bulleted
-- `[_]` за закръгляне надолу на число
-- `[+]` за събиране на две числа
-- `[*]` за умножение на две числа
-- `[x]` за умножение на три числа
-- `[.]` за умножение на четири числа
+- [`_`] за закръгляне надолу на число
+- [`+`] за събиране на две числа
+- [`*`] за умножение на две числа
+- [`x`] за умножение на три числа
+- [`.`] за умножение на четири числа
 
 След тази буква ще получите съответния брой реални числа и трябва да изкарате резултата от операцията.
 
@@ -184,9 +184,9 @@ else
 От входа получавате число, което определя фигура.
 Това число може да бъде:
 .bulleted
-- `[1]` за окръжност,
-- `[2]` за правоъгълник и
-- `[3]` за триъгълник.
+- [`1`] за окръжност,
+- [`2`] за правоъгълник и
+- [`3`] за триъгълник.
 
 Спрямо типа фигура, ще приемете различен брой реални числа:
 .bulleted
@@ -218,7 +218,7 @@ else
 От входа получавате цяло число.
 Изкарайте за него таблицата на умножение от 1 до 10 включително.
 
-=[Използвайте цикъл!]=
+[=Използвайте цикъл!=]
 
 :table_2
 |= Вход
@@ -257,8 +257,8 @@ else
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week04/Exercise08.cpp Решение]
 
-От входа получавате две цели положителни числа, `[a]` и `[x]`.
-Пресметнете `[a]` на степен `[x]`.
+От входа получавате две цели положителни числа, [`a`] и [`x`].
+Пресметнете [`a`] на степен [`x`].
 
 :table_2
 |= Вход
@@ -282,7 +282,7 @@ else
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week04/Exercise09.cpp Решение]
 
 От входа получавате цяло положително число.
-Трябва =[поотделно]= да сумирате всички четни и нечетни числа от 1 до подаденото число, включително.
+Трябва [=поотделно=] да сумирате всички четни и нечетни числа от 1 до подаденото число, включително.
 Накрая изкарайте двете суми.
 
 :table_2
@@ -350,12 +350,12 @@ else
 
 От входа получавате знак.
 
-Ако този знак е аритметична операция (`[+]`, `[-]`, `[*]`, `[/]`), тогава ще получите две цели числа.
+Ако този знак е аритметична операция ([`+`], [`-`], [`*`], [`/`]), тогава ще получите две цели числа.
 Трябва да пресметнете резултата на операцията върху тези числа, да го изкарате и пак да очаквате знак.
 
 Ако този знак е точка, тогава спирате програмата.
 
-*[При вас вход и изход ще са смесени.]*
+[*При вас вход и изход ще са смесени.*]
 
 :table_2
 |= Вход
@@ -542,7 +542,7 @@ else
 Ако е по-голямо, трябва да върнете "Lower".
 Ако бъде познато, трябва да върнете "You guessed it!" и да спрете програмата.
 
-*[В следните примери числото е 1337. Вашия вход и изход ще бъдат смесени.]*
+[*В следните примери числото е 1337. Вашия вход и изход ще бъдат смесени.*]
 
 :table_2
 |= Вход
@@ -613,7 +613,7 @@ You guessed it!
 От входа получавате реално ненулево "целево" число и реално "обсег" число (в проценти).
 След това получавате редица реални ненулеви числа.
 
-Продължавате да приемате реални числа, докато сумата на всички числа в редицата не е поне с "обсег" процента *[близкост]* до целевото число.
+Продължавате да приемате реални числа, докато сумата на всички числа в редицата не е поне с "обсег" процента [*близкост*] до целевото число.
 Накрая на програмата изкарайте тази сума.
 
 Формулата за процентова разлика между числа а и b е:
diff --git a/src/teaching/upp-2025/week05/index.du b/src/teaching/upp-2025/week05/index.du
index a0bfe7f..f19ff04 100644
--- a/src/teaching/upp-2025/week05/index.du
+++ b/src/teaching/upp-2025/week05/index.du
@@ -78,7 +78,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 Трябва да върнете [url https://en.wikipedia.org/wiki/Factorial#Definition факториел] от първото число, който факториел е повдигнат на степен второто число.
 
 Факториел на едно (неотрицателно цяло) число е умножението на всички цели числа от 1 до самото число включително.
-Примерно, факториел от 5 е `[1 * 2 * 3 * 4 * 5 = 120]`.
+Примерно, факториел от 5 е [`1 * 2 * 3 * 4 * 5 = 120`].
 
 :table_2
 |= Вход
@@ -134,7 +134,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 Последователност от числа, която съдържа еднакви числа, също се зачита за сортирана в нарастващ ред.
 
 .note
-=[(01.11.2025)]= Поправен е изхода в първия пример, от 6 на 8.
+[=(01.11.2025)=] Поправен е изхода в първия пример, от 6 на 8.
 
 :table_2
 |= Вход
@@ -206,7 +206,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week05/Exercise08.cpp Решение]
 
 От входа получавате две редици от по 10 реални числа (т.е. първите 10 числа са от първата редица, и вторите 10 числа образуват втората редица).
-След това получавате знак - аритметича операция (`[+]`, `[-]`, `[*]`, `[/]`).
+След това получавате знак - аритметича операция ([`+`], [`-`], [`*`], [`/`]).
 
 Трябва да изпълните операцията върху всяка съответна двойка числа от двете редици и да върнете резултатите.
 
@@ -293,7 +293,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 .numbered
 1. От ляво на дясно, трябва да умножите всяка цифра със съответната си "тежест": 8, 6, 4, 2, 3, 5, 9, 7
 2. Сумирате умножените цифри
-3. Пресмятате контролната цифра по формулата: `[11 - <сума> mod 11]`, където
+3. Пресмятате контролната цифра по формулата: [`11 - <сума> mod 11`], където
    ако резултата е 10, цифрата е 0 и ако резултата е 11, цифрата е 5.
 
 :table_2
@@ -331,10 +331,10 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 
 От входа получавате цяло неотрицателно число.
 
-Изкарвате [url https://en.wikipedia.org/wiki/Lucas_number числото на Лукас] след толкова на брой позиции и ако числото =[не]= е било 0, приемаме ново число и повтаряте логиката.
+Изкарвате [url https://en.wikipedia.org/wiki/Lucas_number числото на Лукас] след толкова на брой позиции и ако числото [=не=] е било 0, приемаме ново число и повтаряте логиката.
 
-Тоест, ако първото число е n, тогава връщате `[n]`-тото число на Лукас.\n
-Ако второто число е m, тогава връщате `[n + m]`-тото число на Лукас.
+Тоест, ако първото число е n, тогава връщате [`n`]-тото число на Лукас.\n
+Ако второто число е m, тогава връщате [`n + m`]-тото число на Лукас.
 И така нататък.
 
 Числата на Лукас се определят по следния начин:
@@ -342,9 +342,9 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 [image ./img/lucas_def.png]
 
 .note
-=[(01.11.2025)]= Входа на последния пример е поправен.
+[=(01.11.2025)=] Входа на последния пример е поправен.
 
-*[Вашия вход и изход може да са смесени!]*
+[*Вашия вход и изход може да са смесени!*]
 
 :table_2
 |= Вход
@@ -384,7 +384,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 Ако се поражда цикъл (посетим някое число повече от един път), тогава трябва да изкарате "Infinity".
 
 .note
-=[(01.11.2025)]= Входа на първия пример е поправен.
+[=(01.11.2025)=] Входа на първия пример е поправен.
 
 :table_2
 |= Вход
@@ -549,7 +549,7 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week05/Exercise18.cpp Решение]
 
 .note
-=[(01.11.2025)]= Поправени бройката на входните цели числа и втория пример.
+[=(01.11.2025)=] Поправени бройката на входните цели числа и втория пример.
 
 От входа получавате 7 цели числа.
 
@@ -607,15 +607,15 @@ GitHub Classroom: [url https://classroom.github.com/a/6oPRMxJx]
 1. Най-дясната цифра е "цифра за проверка", тя трябва да бъде изкарана за после.
 2. Започвайки от най-дясната цифра (от останалите цифри, т.е. втората най-дясна в числото),
    трябва да умножите всяка втора цифра по две.
-   Ако цифрата стане по-голяма от 9, трябва да *[извадите]* 9.
+   Ако цифрата стане по-голяма от 9, трябва да [*извадите*] 9.
 3. Сумирате всички цифри (всички умножени и неумножени).
-4. Проверявате дали цифрата за проверка е равна на `[(10 - (сумa mod 10)) mod 10]`
+4. Проверявате дали цифрата за проверка е равна на [`(10 - (сумa mod 10)) mod 10`]
 
 Този алгоритъм се използва главно в проверката на номера на дебитни/кредитни карти.
 Главната цел е да се засекат някои механични грешки при въвеждане на номера.
 
 .note
-=[(01.11.2025)]= Поправен е входа на третия пример.
+[=(01.11.2025)=] Поправен е входа на третия пример.
 
 :table_2
 |= Вход
@@ -651,7 +651,7 @@ n-тото число на Каталан се дефинира по следн�
 
 [image ./img/catalan_def.png]
 
-Където `[x!]` е [url https://en.wikipedia.org/wiki/Factorial#Definition факториел] от x.
+Където [`x!`] е [url https://en.wikipedia.org/wiki/Factorial#Definition факториел] от x.
 Припомняме, че факториел на едно число е умножението на всички цели числа от 1 до самото число включително.
 
 :table_2
diff --git a/src/teaching/upp-2025/week06/index.du b/src/teaching/upp-2025/week06/index.du
index d6c4b18..a1660f8 100644
--- a/src/teaching/upp-2025/week06/index.du
+++ b/src/teaching/upp-2025/week06/index.du
@@ -19,7 +19,7 @@ GitHub Classroom: [url https://classroom.github.com/a/JSB1UK_f]
 What is the smallest positive integer whose square ends in the digits 269,696?
 
 Според него това число е 99736 (чиито квадрат е 9947269696).
-Напишете програма, която =[намира]= най-малкото число, отговарящо на въпроса.
+Напишете програма, която [=намира=] най-малкото число, отговарящо на въпроса.
 
 :table_2
 |= Вход
@@ -116,7 +116,7 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 [image ./img/rectangle_and_line.png]
 
 изкарайте дали точката е в защрихованата област или не.
-Областта =[не]= включва правата и правоъгълника!
+Областта [=не=] включва правата и правоъгълника!
 
 Зачитайте, че черните прави отбелязват главните оси, а разстоянията между съседни сиви оси е единица.
 
@@ -238,7 +238,7 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 [image ./img/two_circles.png]
 
 изкарайте дали точката е в защрихованата област или не.
-Областта =[не]= включва самите окръжности!
+Областта [=не=] включва самите окръжности!
 
 Зачитайте, че черните прави отбелязват главните оси, а разстоянията между съседни сиви оси е единица.
 
@@ -317,7 +317,7 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 От входа получавате четири трицифрени цели неотрицателн числа.
 Трябва да върнете най-голямото възможно цяло число, което се получава след "слепване" на тези числа.
 
-*[Не е нужно да използвате сортиращ алгоритъм!]*
+[*Не е нужно да използвате сортиращ алгоритъм!*]
 
 :table_2
 |= Вход
@@ -342,7 +342,7 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 
 [image ./img/triangle_and_circle.png]
 
-Областта =[не]= включва правата и правоъгълника!
+Областта [=не=] включва правата и правоъгълника!
 
 Зачитайте, че черните прави отбелязват главните оси, а разстоянията между съседни сиви оси е единица.
 
@@ -544,10 +544,10 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week06/Exercise17.cpp Решение]
 
-От входа получавате две естествени числа, `[a]` и `[b]`.
-Трябва да върнете дали `[a]` е [url https://en.wikipedia.org/wiki/Unitary_divisor унитарен делител] на `[b]`.
+От входа получавате две естествени числа, [`a`] и [`b`].
+Трябва да върнете дали [`a`] е [url https://en.wikipedia.org/wiki/Unitary_divisor унитарен делител] на [`b`].
 
-Това е изпълнено, когато `[a]` е делител на `[b]` и най-големия общ делител на `[a]` и `[b / a]` е 1.
+Това е изпълнено, когато [`a`] е делител на [`b`] и най-големия общ делител на [`a`] и [`b / a`] е 1.
 
 :table_2
 |= Вход
@@ -574,7 +574,7 @@ What is the smallest positive integer whose square ends in the digits 269,696?
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week06/Exercise18.cpp Решение]
 
 От входа получавате 10 реални числа.
-Трябва да върнете най-голямата възможна сума, получена чрез събиране на колкото и дълга =[последователна]= редица от елементи.
+Трябва да върнете най-голямата възможна сума, получена чрез събиране на колкото и дълга [=последователна=] редица от елементи.
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2025/week07/index.du b/src/teaching/upp-2025/week07/index.du
index b23dcd5..3f671b0 100644
--- a/src/teaching/upp-2025/week07/index.du
+++ b/src/teaching/upp-2025/week07/index.du
@@ -9,7 +9,7 @@ GitHub Classroom: [url https://classroom.github.com/a/clYBilXQ]
 
 :important
 
-.p Както при `[if]`-ове, следното е лоша практика и ще се вземат точки:
+.p Както при [`if`]-ове, следното е лоша практика и ще се вземат точки:
 
 ```c++
 bool f() {
@@ -22,7 +22,7 @@ bool f() {
 
 :important
 
-.p Следното е =[грешно]= и ще се вземат точки:
+.p Следното е [=грешно=] и ще се вземат точки:
 
 ```c++
 int* f() {
@@ -44,7 +44,7 @@ int* f() {
 bool evenAndPositive(int x);
 
 От входа получавате цяло число.
-Използвайки `[evenAndPositive]`, върнете дали е четно и положително.
+Използвайки [`evenAndPositive`], върнете дали е четно и положително.
 
 :table_2
 |= Вход
@@ -64,7 +64,7 @@ bool evenAndPositive(int x);
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise02.cpp Решение]
 
-Напишете функция, която приема цяло неотрицателно число `[n]` и връща n-тото число на фибоначи.
+Напишете функция, която приема цяло неотрицателно число [`n`] и връща n-тото число на фибоначи.
 Припомняме, че нулевото число на фибоначи е 0, първото число е 1 и всяко следващо е сумата на предходните две.
 
 Нека вашата функция да следва декларацията:
@@ -73,7 +73,7 @@ bool evenAndPositive(int x);
 unsigned int fib(unsigned int n);
 
 От входа получавате цяло неотрицателно число.
-Използвайки `[fib]`, трябва да изкарате n-тото число на фибоначи.
+Използвайки [`fib`], трябва да изкарате n-тото число на фибоначи.
 
 :table_2
 |= Вход
@@ -109,10 +109,10 @@ unsigned int fib(unsigned int n);
 double average(int numbers[15]);
 
 От входа получавате 15 цели числа.
-Използвайки `[average]`, трябва да изкарате средното аритметично на всички тях.
+Използвайки [`average`], трябва да изкарате средното аритметично на всички тях.
 
 .note
-*[(14.11.2025)]* Оправен изхода на втори пример.
+[*(14.11.2025)*] Оправен изхода на втори пример.
 
 :table_2
 |= Вход
@@ -132,7 +132,7 @@ double average(int numbers[15]);
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise04.cpp Решение]
 
-Напишете функция, която приема число с плаваща запетая и *[връща]* две числа:
+Напишете функция, която приема число с плаваща запетая и [*връща*] две числа:
 .numbered
 1. числото, разделено на половина и
 2. числото, закръглено надолу към най-близкото цяло число.
@@ -143,7 +143,7 @@ double average(int numbers[15]);
 void calc(float number, double &half, int* integer);
 
 От входа получавате число с плаваща запетая.
-Използвайки `[calc]`, трябва да изкарате двете *[върнати]* стойности.
+Използвайки [`calc`], трябва да изкарате двете [*върнати*] стойности.
 
 :table_2
 |= Вход
@@ -160,13 +160,13 @@ void calc(float number, double &half, int* integer);
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise05.cpp Решение]
 
-Напишете функция `[maxElem]`, която приема масив от числа с плаваща запетая и негов размер =[поотделно]=!
+Напишете функция [`maxElem`], която приема масив от числа с плаваща запетая и негов размер [=поотделно=]!
 Това означава, че на функцията може да ѝ бъде подаден масив с 10, 15, 2 или ... елемента.
 
 Нека вашата функция да върне най-големия елемент в масива.
 
 От входа получавате една редица от 5 реални числа и втора редица от 7 реални числа.
-Използвайки `[maxElem]`, върнете най-големия елемент в първата и във втората редица.
+Използвайки [`maxElem`], върнете най-големия елемент в първата и във втората редица.
 
 :table_2
 |= Вход
@@ -191,14 +191,14 @@ void calc(float number, double &half, int* integer);
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise06.cpp Решение]
 
-Напишете функция, която приема масив с произволна дължина (масива и размера се подават поотделно), съствен от цели числа, и *[върнете]* най-големия и най-малкия му елемент.
+Напишете функция, която приема масив с произволна дължина (масива и размера се подават поотделно), съствен от цели числа, и [*върнете*] най-големия и най-малкия му елемент.
 Нека вашата функция да следва декларацията:
 
 ```c++
 void minmaxElems(int* arr, unsigned size, int* min, int* max);
 
 От входа получавате две редици от по 10 и 8 цели числа съответно.
-Използвайки `[minmaxElems]`, върнете най-големия и най-малкия елемент на всяка редица.
+Използвайки [`minmaxElems`], върнете най-големия и най-малкия елемент на всяка редица.
 
 :table_2
 |= Вход
@@ -236,12 +236,12 @@ void minmaxElems(int* arr, unsigned size, int* min, int* max);
 unsigned sumElems(int* arr, unsigned size);
 
 От входа получавате 11 цели числа.
-Трябва да върнете първата последователност от 3 елемента, чиято сума е 0, използвайки `[sumElems]`.
+Трябва да върнете първата последователност от 3 елемента, чиято сума е 0, използвайки [`sumElems`].
 
 Ако няма такава, не изкарвайте нищо.
 
 .note
-*[(14.11.2025)]* Оправен изхода на трети пример.
+[*(14.11.2025)*] Оправен изхода на трети пример.
 
 :table_2
 |= Вход
@@ -264,11 +264,11 @@ unsigned sumElems(int* arr, unsigned size);
 Напишете функция, която приема масив с произволен размер, съставен от цели неотрицателни числа, и неотрицателно число: ротация.
 Трябва да завъртите елементите в масива с ротация на брой позиции на дясно.
 
-Тоест, ако масива е `[1 2 3 4]`, тогава след ротация с една позиция, масива ще е `[4 1 2 3]`.
-Ако имахме две ротации, тогава щяхме да получим `[3 4 1 2]`.
+Тоест, ако масива е [`1 2 3 4`], тогава след ротация с една позиция, масива ще е [`4 1 2 3`].
+Ако имахме две ротации, тогава щяхме да получим [`3 4 1 2`].
 
 Не модифицирайте оригиналния масив!
-Трябва да *[върнете]* друг масив със завъртяните елементи.
+Трябва да [*върнете*] друг масив със завъртяните елементи.
 
 От входа получавате две редици от по 6 и 7 цели числа.
 След всяка редица получавате ротация.
@@ -304,10 +304,10 @@ unsigned sumElems(int* arr, unsigned size);
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise09.cpp Решение]
 
 .note
-*[(14.11.2025)]* Оправена декларацията на функцията, примери и добавено упътване.
+[*(14.11.2025)*] Оправена декларацията на функцията, примери и добавено упътване.
 
 .warn
-НЕ може да използвате "вградената" функция `[pow]`!
+НЕ може да използвате "вградената" функция [`pow`]!
 
 Напишете функция, която приема число с плаваща запетая и цяло неотрицателно число, и връща първото число на степен второто.
 Нека вашата функция да следва декларацията:
@@ -319,13 +319,13 @@ double topower(double x, unsigned int a);
 Първите 10 са коефициентите в полином от 10та степен.
 11тото е потенциален корен.
 
-Трябва да върнете дали 11тото действително е корен на уравнението, използвайки `[topower]`.
+Трябва да върнете дали 11тото действително е корен на уравнението, използвайки [`topower`].
 
-Припомняме, че едно число `[x]` е корен на полином от 10та степен, когато:
+Припомняме, че едно число [`x`] е корен на полином от 10та степен, когато:
 
 [image ./img/polynomial.png]
 
-=[Упътване:]=
+[=Упътване:=]
 За някои примери, прецизността на въведения корен не е достатъчна.
 Може да приемете, че ако (абсолютната стойност на) сумата е по-малка от 0.0001, то сумата на практика е 0.
 
@@ -371,10 +371,10 @@ double topower(double x, unsigned int a);
 unsigned int countSameElementsOnSameIndecies(int* arr1, unsigned int size1, int* arr2, unsigned int size2);
 
 От входа получавате две редици от по 10 и 15 цели числа.
-Трябва да върнете бройката на съвпадащи стойности на съвпадащи индекси, използвайки `[countSameElementsOnSameIndecies]`.
+Трябва да върнете бройката на съвпадащи стойности на съвпадащи индекси, използвайки [`countSameElementsOnSameIndecies`].
 
 .note
-*[14.11.2025]* Оправен вход на последния пример.
+[*14.11.2025*] Оправен вход на последния пример.
 
 :table_2
 |= Вход
@@ -470,7 +470,7 @@ unsigned int countSameElementsOnSameIndecies(int* arr1, unsigned int size1, int*
 От входа получавате 12 букви и трябва да върнете дали целия масив образува последователността "буква, цифра, буква, цифра, буква, цифрва, ...", използвайки вашата функция.
 
 .note
-*[(14.11.2025)]* Оправен трети пример.
+[*(14.11.2025)*] Оправен трети пример.
 
 :table_2
 |= Вход
@@ -490,15 +490,15 @@ unsigned int countSameElementsOnSameIndecies(int* arr1, unsigned int size1, int*
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise14.cpp Решение]
 
-Напишете функция, която получава масив от 10 реални числа и *[връща]* масив от 5 реални числа.
+Напишете функция, която получава масив от 10 реални числа и [*връща*] масив от 5 реални числа.
 Резултатния масив се формира по следния начин:
 .numbered
-1. Първия елемент на *[върнатия]* масив е разликата на втория от първия елемент на входния (получения) масив.
-2. Втория елемент на *[върнатия]* масив е разликата на четвъртия от третия елемент на входния масив.
+1. Първия елемент на [*върнатия*] масив е разликата на втория от първия елемент на входния (получения) масив.
+2. Втория елемент на [*върнатия*] масив е разликата на четвъртия от третия елемент на входния масив.
 3. И така нататък.
 
 От входа получавате масив с 10 елемента.
-Трябва да *[върнете]* резултатния 5-елементен масив от вашата функция.
+Трябва да [*върнете*] резултатния 5-елементен масив от вашата функция.
 
 :table_2
 |= Вход
@@ -532,7 +532,7 @@ unsigned int countSameElementsOnSameIndecies(int* arr1, unsigned int size1, int*
 Допуснете, че винаги ще срещнете целевото число.
 Използвайте вашите функции.
 .note
-*[(14.11.2025)]* Оправени входове на първите два примера.
+[*(14.11.2025)*] Оправени входове на първите два примера.
 
 :table_2
 |= Вход
diff --git a/src/teaching/upp-2025/week08/index.du b/src/teaching/upp-2025/week08/index.du
index 9fd0260..4b75284 100644
--- a/src/teaching/upp-2025/week08/index.du
+++ b/src/teaching/upp-2025/week08/index.du
@@ -14,7 +14,7 @@ GitHub Classroom: [url https://classroom.github.com/a/rhpKbNmH]
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week08/Exercise01.cpp Решение]
 
 От входа получавате матрица 5 на 5 от цели числа.
-Трябва да върнете дали е разредена матрица: дали има *[повече]* нули отколкото други числа.
+Трябва да върнете дали е разредена матрица: дали има [*повече*] нули отколкото други числа.
 
 :table_2
 |= Вход
@@ -100,12 +100,12 @@ Sparse
 Тоест, всички елементи от горния ляв ъгъл, надолу и надясно колкото е размера на втората матрица.
 
 От входа получавате матрица 6 на 6 от реални числа.
-След това получавате 4 неотрицателни числа: първите две са координат в матрицата (където горния ляв ъгъл е `[(0, 0)]`), вторите две са нейни размери.
+След това получавате 4 неотрицателни числа: първите две са координат в матрицата (където горния ляв ъгъл е [`(0, 0)`]), вторите две са нейни размери.
 
-Използвайки вашата функция, трябва да изкарате подматрицата с начало подадения координат и размери подадените размери =[използвайки]= вашата функция.
+Използвайки вашата функция, трябва да изкарате подматрицата с начало подадения координат и размери подадените размери [=използвайки=] вашата функция.
 
 .note
-=[(23.11.2025)]= Опростени някои примери.
+[=(23.11.2025)=] Опростени някои примери.
 
 :table_2
 |= Вход
@@ -189,12 +189,12 @@ City Bloxx е известна мобилна игра за строене на
 
 Нека да разгледаме следните правила за сгради (в самата игра има някои разлики):
 .numbered
-1. *[Жилищните сгради]* може да се поставят навсякъде.
-2. *[Търговските сгради]* трябва да бъдат поставени до поне една жилищна сграда.
-3. *[Офис сградите]* трябва да бъдат поставени до поне една жилищна и една търговска.
-4. *[Луксозните сгради]* трябва да бъдат поставени до поне една жилищна, една търговска и една офис сграда.
+1. [*Жилищните сгради*] може да се поставят навсякъде.
+2. [*Търговските сгради*] трябва да бъдат поставени до поне една жилищна сграда.
+3. [*Офис сградите*] трябва да бъдат поставени до поне една жилищна и една търговска.
+4. [*Луксозните сгради*] трябва да бъдат поставени до поне една жилищна, една търговска и една офис сграда.
 
-Сгради са съседни само по вертикал и хоризонтал, =[не]= по диагонал.
+Сгради са съседни само по вертикал и хоризонтал, [=не=] по диагонал.
 
 От входа получавате масив 5 на 5 с цели числа, където с 1 до 4 се обозначават сградите, от жилищни до луксозни.
 Изкарайте дали подредбата на сградите е позволена (следва горните правила).
@@ -302,7 +302,7 @@ City Bloxx е известна мобилна игра за строене на
 
 Трябва да размените двете колони, използвайки вашата функция, и да изкарате резултата.
 
-*[Вашия изход не е нужно да бъде подравнен.]*
+[*Вашия изход не е нужно да бъде подравнен.*]
 
 :table_2
 |= Вход
@@ -353,10 +353,10 @@ City Bloxx е известна мобилна игра за строене на
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week08/Exercise07.cpp Решение]
 
 От входа получавате матрица от букви 3 на 3.
-Тя определя шаблон, където буквата `[*]` означава, че всяка стойност е позволена.
+Тя определя шаблон, където буквата [`*`] означава, че всяка стойност е позволена.
 
 След това от входа получавате матрица 6 на 6, съствена от букви.
-Трябва да намерите всички срещания на шаблона в тази матрица, като =[срещанията може да се застъпват!]=
+Трябва да намерите всички срещания на шаблона в тази матрица, като [=срещанията може да се застъпват!=]
 
 :table_2
 |= Вход
@@ -427,7 +427,7 @@ City Bloxx е известна мобилна игра за строене на
 Пресметнете умножението на матриците (ред по стълб) и изкарайте резултата.
 
 .note
-=[(23.11.2025)]= Оправен входа на втория пример.
+[=(23.11.2025)=] Оправен входа на втория пример.
 
 :table_2
 |= Вход
@@ -469,9 +469,9 @@ City Bloxx е известна мобилна игра за строене на
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week08/Exercise09.cpp Решение]
 
 При изграждането на устройства като клавиатури, често се използва "бутонна матрица".
-Няма да навлизаме в електрониката, но идеята е че когато натиснеш бутон, съответната колона =[и]= ред са "свързани"/активни.
+Няма да навлизаме в електрониката, но идеята е че когато натиснеш бутон, съответната колона [=и=] ред са "свързани"/активни.
 
-=[Тоест, когато активни ред и колона се пресичат, тогава съответния бутон е натиснат.]=
+[=Тоест, когато активни ред и колона се пресичат, тогава съответния бутон е натиснат.=]
 
 Това означава, че се нуждаем да погледнем само състоянията на всеки ред и колона, и ще знаем всички натиснати бутони (вместо да поглеждаме всеки бутон поотделно).
 
@@ -484,7 +484,7 @@ City Bloxx е известна мобилна игра за строене на
 От входа първо получавате 4 булеви стойности: дали реда е активен (отгоре надолу).
 След това получавате още 3 булеви стойности: дали колоната е активна (отляво надясно).
 
-Изкарайте кои бутони са натиснати, използвайки цифровите знаци, звезда (`[*]`) и диез (`[#]`).
+Изкарайте кои бутони са натиснати, използвайки цифровите знаци, звезда ([`*`]) и диез ([`#`]).
 Ако няма натиснати, изкарайте съответно съобщение.
 
 :table_2
@@ -523,26 +523,26 @@ City Bloxx е известна мобилна игра за строене на
 
 [image https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif]
 
-=[Генерирайте]= и изкарайте триъгълника на паскал в матрица 11 на 11, където двете страни на триъгълника са първата колона и главния диагонал.
+[=Генерирайте=] и изкарайте триъгълника на паскал в матрица 11 на 11, където двете страни на триъгълника са първата колона и главния диагонал.
 
 Нека стойностите извън триъгълника да са нули.
 
-=[Изход:]= *[(не е нужно да бъде подравнен)]*
+[=Изход:=] [*(не е нужно да бъде подравнен)*]
 
 .comment https://www.fcfung2000.com/ufcfiles/ufcmatrk.htm
 
 ```
-=[1]=  0  0   0   0   0   0   0  0  0  0
-=[1]=  =[1]=  0   0   0   0   0   0  0  0  0
-=[1]=  2  =[1]=   0   0   0   0   0  0  0  0
-=[1]=  3  3   =[1]=   0   0   0   0  0  0  0
-=[1]=  4  6   4   =[1]=   0   0   0  0  0  0
-=[1]=  5 10  10   5   =[1]=   0   0  0  0  0
-=[1]=  6 15  20  15   6   =[1]=   0  0  0  0
-=[1]=  7 21  35  35  21   7   =[1]=  0  0  0
-=[1]=  8 28  56  70  56  28   8  =[1]=  0  0
-=[1]=  9 36  84 126 126  84  36  9  =[1]=  0
-=[1]= 10 45 120 210 252 210 120 45 10  =[1]=
+[=1=]  0  0   0   0   0   0   0  0  0  0
+[=1=]  [=1=]  0   0   0   0   0   0  0  0  0
+[=1=]  2  [=1=]   0   0   0   0   0  0  0  0
+[=1=]  3  3   [=1=]   0   0   0   0  0  0  0
+[=1=]  4  6   4   [=1=]   0   0   0  0  0  0
+[=1=]  5 10  10   5   [=1=]   0   0  0  0  0
+[=1=]  6 15  20  15   6   [=1=]   0  0  0  0
+[=1=]  7 21  35  35  21   7   [=1=]  0  0  0
+[=1=]  8 28  56  70  56  28   8  [=1=]  0  0
+[=1=]  9 36  84 126 126  84  36  9  [=1=]  0
+[=1=] 10 45 120 210 252 210 120 45 10  [=1=]
 
 ### Задача 11
 
@@ -559,9 +559,9 @@ City Bloxx е известна мобилна игра за строене на
 Не добавяйте към средното аритметично несъществуващи клетки (напр. клетката в горния ляв ъгъл няма клетки над или в ляво от себе си).
 
 .note
-=[(23.11.2025)]= Добавени още примери.
+[=(23.11.2025)=] Добавени още примери.
 
-*[(Вашия изход не е нужно да бъде подравнен.)]*
+[*(Вашия изход не е нужно да бъде подравнен.)*]
 
 :table_2
 |= Вход
@@ -655,7 +655,7 @@ City Bloxx е известна мобилна игра за строене на
 
 От входа получавате два реални координата, между (0,0) и (10,10).
 
-Трябва да върнете матрица 10 на 10 от знаци, която се съставя единствено от шпации (spaces) и хиксове (`[x]`).
+Трябва да върнете матрица 10 на 10 от знаци, която се съставя единствено от шпации (spaces) и хиксове ([`x`]).
 Зачитаме, че координатите директно съответстват на матрицата, като (0,0) се намира в горния ляв ъгъл и (10,10) в долния десен.
 
 В тази матрица, по подразбиране стоят само шпации.
@@ -667,7 +667,7 @@ City Bloxx е известна мобилна игра за строене на
 Тази операция се нарича интерполация.
 
 .note
-=[(23.11.2025)]= Добавени още примери.
+[=(23.11.2025)=] Добавени още примери.
 
 :table_2
 |= Вход
@@ -867,7 +867,7 @@ City Bloxx е известна мобилна игра за строене на
 Ако не можете, не записвайте нищо във върнатата.
 
 От входа получавате матрица 4 на 8, съставена от цели числа.
-=[Използвайки вашата функция]=, завъртете матрицата и изкарайте резултата.
+[=Използвайки вашата функция=], завъртете матрицата и изкарайте резултата.
 
 :table_2
 |= Вход
@@ -1022,7 +1022,7 @@ City Bloxx е известна мобилна игра за строене на
 
 ### Задача 20
 
-=[Генерирайте]= и изкарайте [url https://en.wikipedia.org/wiki/Bell_triangle триъгълника на Бел] в долния ляв ъгъл на матрица 11 на 11.
+[=Генерирайте=] и изкарайте [url https://en.wikipedia.org/wiki/Bell_triangle триъгълника на Бел] в долния ляв ъгъл на матрица 11 на 11.
 Това означава, че страните на триъгълника включват първата колона и главния диагонал.
 
 .bulleted
@@ -1039,7 +1039,7 @@ City Bloxx е известна мобилна игра за строене на
 
 Тази задача е подобна на [url #-10 Задача 10].
 
-=[Изход:]= *[(не е нужно да бъде подравнен)]*
+[=Изход:=] [*(не е нужно да бъде подравнен)*]
 
 .comment https://oeis.org/A011971
 
@@ -1108,9 +1108,9 @@ https://www.apcomputersciencetutoring.com/2d-array-practice-exercises/#grow-meth
 
 Трябва да изкарате матрица със знаци 9 на 9, в която е попълнено изображението спрямо режима.
 .numbered
-1. =[Режим 1]= обозначава повтаряне, където изображението се повтаря последователно
-2. =[Режим 2]= обозначава "border", където изображението се слага в центъра и останалта част се попълва със знак диес `[#]`.
-3. =[Режим 3]= обозначава "clamp", изображението се слага в центъра и останалата част се попълва като се повтаря последната буква. Тоест, дясното 3 на 3 се попълва с повторение на десния знак.
+1. [=Режим 1=] обозначава повтаряне, където изображението се повтаря последователно
+2. [=Режим 2=] обозначава "border", където изображението се слага в центъра и останалта част се попълва със знак диес [`#`].
+3. [=Режим 3=] обозначава "clamp", изображението се слага в центъра и останалата част се попълва като се повтаря последната буква. Тоест, дясното 3 на 3 се попълва с повторение на десния знак.
 
 :table_2
 |= Вход
@@ -1181,7 +1181,7 @@ f f f g g g h h h
 
 Зачитайте, че 0 винаги е в центъра на спиралата и се въртите първо с една позиция разстояние, после с две и так. нат.
 
-*[(Вашия изход не е нужно да бъде подравнен.)]*
+[*(Вашия изход не е нужно да бъде подравнен.)*]
 
 :table_2
 |= Вход
@@ -1222,15 +1222,15 @@ f f f g g g h h h
 Реализирайте матричен калкулатор.
 От входа получавате матрица 4 на 4 с реални числа и след това получавате редица операции.
 
-Всяка операция започва с буква, като буквата `[$]` сигнализира край на програмата.
+Всяка операция започва с буква, като буквата [`$`] сигнализира край на програмата.
 След всеки знак има няколко аргумента, т.е. допълнителни стойности които трябва да се въведат, преди операцията да се изпълни.
 
 .bulleted
-- Операцията `[*]` обозначава умножение на ред, и след знака има цяло неотрицателно число за индекс на ред и след него е реално число (коефициент с който да умножим реда).
-- Операцията `[+]` обозначава сума на редове, след знака се очакват два неотрицателни индекса на редове, първия ред се сумира в втория
-- Операцията `[^]` обозначава размяна на редове, след знака се очакват два неотрицателни индекса на редове и стойностите им се разменят.
+- Операцията [`*`] обозначава умножение на ред, и след знака има цяло неотрицателно число за индекс на ред и след него е реално число (коефициент с който да умножим реда).
+- Операцията [`+`] обозначава сума на редове, след знака се очакват два неотрицателни индекса на редове, първия ред се сумира в втория
+- Операцията [`^`] обозначава размяна на редове, след знака се очакват два неотрицателни индекса на редове и стойностите им се разменят.
 
-След всяка операция (освен `[$]`) трябва да изкарате състоянието на матрицата.
+След всяка операция (освен [`$`]) трябва да изкарате състоянието на матрицата.
 
 ### Задача 25
 
@@ -1239,7 +1239,7 @@ f f f g g g h h h
 От входа получавате матрица 10 на 10 с булеви стойности.
 След това получавате неотрицателно число: брой генерации (ходове).
 
-Всяка клетка наричаме жива или мъртва (съответно на `[true]` или `[false]`).
+Всяка клетка наричаме жива или мъртва (съответно на [`true`] или [`false`]).
 В една генерация (ход) на играта, всяка клетка променя своя статус (стойност) по следните правила:
 .bulleted
 - всяка жива клетка с по-малко от два живи съседа (вертикално, хоризонтално и диагонално) умира
diff --git a/src/teaching/upp-2025/week09/index.du b/src/teaching/upp-2025/week09/index.du
index b204cd8..55febbf 100644
--- a/src/teaching/upp-2025/week09/index.du
+++ b/src/teaching/upp-2025/week09/index.du
@@ -30,9 +30,9 @@ GitHub Classroom: [url https://classroom.github.com/a/ZYFDdLi4]
 Всеки хигрометър измерва процента влажност.
 В условието не са дадени подробности относно формата на тази стойност, затова ще използваме тип с плаваща запетая, който ще покрие всички реални стойности.
 
-Ще изведем в глобална константа `[SIZE]` размера на едно измерение на матрицата, и самата матрица ще съдържа влажността в стойности от тип `[double]`.
+Ще изведем в глобална константа [`SIZE`] размера на едно измерение на матрицата, и самата матрица ще съдържа влажността в стойности от тип [`double`].
 
-За намиране на средната влажност в града, ще изградим функцията `[average]`, която изглежда по следния начин:
+За намиране на средната влажност в града, ще изградим функцията [`average`], която изглежда по следния начин:
 
 ```c++
 double average(const double hygrometers[SIZE][SIZE]);
@@ -41,7 +41,7 @@ double average(const double hygrometers[SIZE][SIZE]);
 Реализацията изисква линейно итериране през цялата матрица, като се пази сума на всички елементи.
 Върнатата стойност е сумата, разделена на броя хигрометри.
 
-За намиране на най-влажен и най-сух квадрант ще реализираме функцията `[quadrantHumidity]`, чиято декларация е:
+За намиране на най-влажен и най-сух квадрант ще реализираме функцията [`quadrantHumidity`], чиято декларация е:
 
 ```c++
 double quadrantHumidity(const double hygrometers[SIZE][SIZE], unsigned startRow, unsigned startCol);
@@ -49,16 +49,16 @@ double quadrantHumidity(const double hygrometers[SIZE][SIZE], unsigned startRow,
 Функцията приема матрицата с влажности и начални индекси по ред и колона на съответния квадрант.
 Знаем, че един квадрант ще бъде една четвърт от размера на матрицата (половината височина и ширина), затова не е нужно той да бъде подаден.
 
-В имплементацията, ще итерираме през матрицата, като започнем от началните редове и колона, и обиколим точно `[SIZE / 2]` реда и колони.
+В имплементацията, ще итерираме през матрицата, като започнем от началните редове и колона, и обиколим точно [`SIZE / 2`] реда и колони.
 Ще пазим сума на всички елементи и накрая ще разделим на броя елементи, т.е. ще върнем средната стойност на влажност в квадранта.
 
 В заглавната функция ще дефинираме матрицата и ще попълним входните влажности.
-След това ще изкараме стойността, върната от извикване на `[average]`.
+След това ще изкараме стойността, върната от извикване на [`average`].
 
 За сух и влажен квадрант, ще създадем две променливи за най-голяма и най-малка стойност.
-След това ще извикваме `[quadrantHumidity]`, като ще запазим върната стойност като най-голяма и най-малка спрямо текущите стойности.
+След това ще извикваме [`quadrantHumidity`], като ще запазим върната стойност като най-голяма и най-малка спрямо текущите стойности.
 
-Началните ред и колона ще подаваме с вложен цикъл, който ще итерира колоните и редовете от най-първите (на индекси 0,0) и ще увеличава всеки индекс с размера на страната на квадрант (`[SIZE / 2]`).
+Началните ред и колона ще подаваме с вложен цикъл, който ще итерира колоните и редовете от най-първите (на индекси 0,0) и ще увеличава всеки индекс с размера на страната на квадрант ([`SIZE / 2`]).
 
 След цикъла и всички извиквания ще имаме стойностите в нашите променливи и ще ги изкараме.
 
diff --git a/src/teaching/upp-2025/week10/index.du b/src/teaching/upp-2025/week10/index.du
index 34c4370..5ec2926 100644
--- a/src/teaching/upp-2025/week10/index.du
+++ b/src/teaching/upp-2025/week10/index.du
@@ -6,7 +6,7 @@
 [$pagenav]
 
 .important
-Едно от най-важните неща: =[всяка динамично-заделена памет трябва да се освободи преди края на програмата!]=
+Едно от най-важните неща: [=всяка динамично-заделена памет трябва да се освободи преди края на програмата!=]
 
 GitHub Classroom: [url https://classroom.github.com/a/kDfmWmy7]
 
@@ -37,7 +37,7 @@ GitHub Classroom: [url https://classroom.github.com/a/kDfmWmy7]
 
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise02.cpp Решение]
 
-Реализирайте функцията `[average]`, която приема масив, съставен от цели числа, с произволен размер, и връща средното аритметично на всички тези числа.
+Реализирайте функцията [`average`], която приема масив, съставен от цели числа, с произволен размер, и връща средното аритметично на всички тези числа.
 
 От входа ще получите размер n и след това 2n на брой цели числа.
 Използвайки вашата функция, трябва да върнете средното аритметично на тези числа.
@@ -55,7 +55,7 @@ GitHub Classroom: [url https://classroom.github.com/a/kDfmWmy7]
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise03.cpp Решение]
 
 От входа получавате размерите на матрица, съставена от неотрицателни целочислени стойности, и след това всички стойности в самата матрица.
-=[В паметта]= обърнете реда на редовете и изкарайте резултата.
+[=В паметта=] обърнете реда на редовете и изкарайте резултата.
 
 .question
 Може ли да се направи по по-прост начин, отколкото ако матрицата беше статично-заделена?
@@ -132,9 +132,9 @@ Cannot multiply!
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise05.cpp Решение]
 
 .note
-*[(07.12.2025)]* Оправено условие и пример
+[*(07.12.2025)*] Оправено условие и пример
 
-Реализирайте функция `[largest]`, която приема матрица, съставена от цели числа, с произволни размери, и връща най-големия елемент в нея.
+Реализирайте функция [`largest`], която приема матрица, съставена от цели числа, с произволни размери, и връща най-големия елемент в нея.
 
 От входа получавате две числа, размери на матрица, и след това всички елементи в матрицата.
 Използвайки вашата функция, върнете най-голямото число.
@@ -190,7 +190,7 @@ Cannot multiply!
 След това получавате координат в дъската, трябва да върнете дали змията някога е посетила тази клетка.
 
 .note
-*[(07.12.2025)]* Разменени ред и колона в примерите
+[*(07.12.2025)*] Разменени ред и колона в примерите
 
 :table_2
 |= Вход
@@ -286,7 +286,7 @@ Cannot multiply!
 Трябва да върнете елементите по контура (краищата) на часовника, следвайки горното правило.
 
 .note
-*[(07.12.2025)]* Поправен примера с четния размер
+[*(07.12.2025)*] Поправен примера с четния размер
 
 :table_2
 |= Вход
@@ -336,7 +336,7 @@ Cannot multiply!
 Трябва да върнете дали числото е корен на съответния полином.
 
 .note
-*[(07.12.2025)]* Поправени примерите с първа степен полином
+[*(07.12.2025)*] Поправени примерите с първа степен полином
 
 :table_2
 |= Вход
@@ -400,24 +400,24 @@ Cannot multiply!
 След това влизате в "потребителски интерфейс", където от входа получавате буква, обозначаваща команда върху дневника.
 Командите са:
 .bulleted
-- `[e]` обозначава край на програмата
-- `[m]`, получавате индекс на ден и трябва да върнете максималната продажба в този ден
-- `[M]`, трябва да върнете индекса на най-печелившия ден
+- [`e`] обозначава край на програмата
+- [`m`], получавате индекс на ден и трябва да върнете максималната продажба в този ден
+- [`M`], трябва да върнете индекса на най-печелившия ден
 
-=[Пример:]= *[(вход и изход са смесени, изходът е удебелен)]*
+[=Пример:=] [*(вход и изход са смесени, изходът е удебелен)*]
 ```
 3
 4 0.5 100 19.99 7
 0
 2 500 8
 m 0
-=[100]=
+[=100=]
 m 1
-=[0]=
+[=0=]
 m 2
-=[500]=
+[=500=]
 M
-=[2]=
+[=2=]
 e
 
 ### Задача 14
diff --git a/src/teaching/upp-2025/week11/index.du b/src/teaching/upp-2025/week11/index.du
index 17bbd52..a381246 100644
--- a/src/teaching/upp-2025/week11/index.du
+++ b/src/teaching/upp-2025/week11/index.du
@@ -27,7 +27,7 @@ GitHub Classroom: [url https://classroom.github.com/a/z_C3UMi8]
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week11/Exercise01.cpp Решение]
 
 От входа получавате 20 буквен низ: име.
-Трябва да изкарате съобщението "Hello *[[име]]*!"
+Трябва да изкарате съобщението "Hello [*[име]*]!"
 
 :table_2
 |= Вход
@@ -69,19 +69,19 @@ GitHub Classroom: [url https://classroom.github.com/a/z_C3UMi8]
 Изключвайте крайната точка в бройката на полетата.
 
 .note
-*[(14.12.2025)]* Добавени точки в края на изреченията.
+[*(14.12.2025)*] Добавени точки в края на изреченията.
 
 :table_2
 |= Вход
 |= Изход
 
-|: `[first second  third    fourth.]`
+|: [`first second  third    fourth.`]
 |: 4
 
-|: `[I'm glad you're here.]`
+|: [`I'm glad you're here.`]
 |: 4
 
-|: `[  a   b  c    d   8 k *    * .]`
+|: [`  a   b  c    d   8 k *    * .`]
 |: 8
 
 
@@ -144,12 +144,12 @@ trail led eastward through the fat spruce timberland.\n
 .solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week11/Exercise06.cpp Решение]
 
 От входа получавате ред, обозначаващ число в 16-тича бройна система.
-Тоест, реда започва с `[0x]` и останалото са 16-тични цифри.
+Тоест, реда започва с [`0x`] и останалото са 16-тични цифри.
 
-Трябва да изкарате стойността на числото в 10-тична бройна система, =[като направите конвертирането ръчно!]=
-Тоест =[не е позволено да използвате функционалност от стандартната библиотека!]=
+Трябва да изкарате стойността на числото в 10-тична бройна система, [=като направите конвертирането ръчно!=]
+Тоест [=не е позволено да използвате функционалност от стандартната библиотека!=]
 
-Приемете, че буквите A-F са главни и че няма да имате водещи нули (напр. `[0x0001]`).
+Приемете, че буквите A-F са главни и че няма да имате водещи нули (напр. [`0x0001`]).
 
 :table_2
 |= Вход
@@ -315,7 +315,7 @@ Buffalo  Buffalo    Buffalo
 Накрая тряба да върнете оценката на паролата.
 
 .note
-*[(14.12.2025)]* Оправени оценки в примерите
+[*(14.12.2025)*] Оправени оценки в примерите
 
 :table_2
 |= Вход
@@ -352,22 +352,22 @@ Buffalo  Buffalo    Buffalo
 Използвайки 32-битовите offset basis (2166136261) и FNV простото число (16777619), изкарайте хешираната стойност на подадения ред текст.
 
 .note
-*[(14.12.2025)]* Поправен хеш на последния пример.
+[*(14.12.2025)*] Поправен хеш на последния пример.
 
 :table_2
 |= Вход
 |= Изход
 
-|: `[Hello World]`
+|: [`Hello World`]
 |: 310551791
 
-|: `[Nothing]`
+|: [`Nothing`]
 |: 383317984
 
-|: `[!]`
+|: [`!`]
 |: 84696382
 
-|: `[The most effective debugging tool is still careful thought, coupled with judiciously placed print statements.]`
+|: [`The most effective debugging tool is still careful thought, coupled with judiciously placed print statements.`]
 |: 2408366471
 
 
diff --git a/src/teaching/upp-2025/week12/index.du b/src/teaching/upp-2025/week12/index.du
index 1fd2428..5fc86b8 100644
--- a/src/teaching/upp-2025/week12/index.du
+++ b/src/teaching/upp-2025/week12/index.du
@@ -113,12 +113,12 @@ day.
 
 Трябва да разположите двете полета в колоните така, че разстоянието между полетата и разтоянията между всяко поле и краищата са еднакви.
 
-С други думи, ако сме получили `[Hello]`, `[World]` и 25 колони, трябва да изкараме следния низ (където `[|]` обграждат всичките колони):
+С други думи, ако сме получили [`Hello`], [`World`] и 25 колони, трябва да изкараме следния низ (където [`|`] обграждат всичките колони):
 
 ```
 |     Hello     World     |
 
-Разстоянието между `[|]` и `[H]` е същото като между `[o]` и `[W]`, и между `[d]` и `[|]`, а иммено 5 шпации.
+Разстоянието между [`|`] и [`H`] е същото като между [`o`] и [`W`], и между [`d`] и [`|`], а иммено 5 шпации.
 
 Когато разстоянията не могат да са точни, трябва или средното да е по-късото, или и двата края да са по-къси.
 Ако буквите в думите са повече от броя колоните, тогава изкарайте думите слепени.
@@ -166,12 +166,12 @@ Lorem ipsum
 Трябва да върнете типа на полето, спрямо тези правила:
 
 .ordered
-1. =[Тип "integer":]= може да започне с `[+]` или `[-]` и всички останали букви са цифри
-2. =[Тип "float":]= може да започне с `[+]` или `[-]` и след това съдържа цифри и точка, която точка трябва да се намира между цифри (т.е. не е преди или след всички цифри)
-3. =[Тип "word":]= ако съдържа само латински букви (главни или малки)
-4. =[Тип "time":]= може да започне или завърши с "AM" или "PM", след това (допускайки че е започва с низа) съдържа 1-2 цифри (часа), които са между 0 и 24 вкл., знака двоеточие `[:]` и накрая завършва на две цифри (минутите), които са между 0 и 59 вкл.
-5. =[Тип "percentage":]= започва с поне една цифра, като след първите цифри може да има точка и още цифри, и накрая завършва на знака `[%]`
-6. =[Тип "other"]=, когато не можем да го свържем с никое от горните правила
+1. [=Тип "integer":=] може да започне с [`+`] или [`-`] и всички останали букви са цифри
+2. [=Тип "float":=] може да започне с [`+`] или [`-`] и след това съдържа цифри и точка, която точка трябва да се намира между цифри (т.е. не е преди или след всички цифри)
+3. [=Тип "word":=] ако съдържа само латински букви (главни или малки)
+4. [=Тип "time":=] може да започне или завърши с "AM" или "PM", след това (допускайки че е започва с низа) съдържа 1-2 цифри (часа), които са между 0 и 24 вкл., знака двоеточие [`:`] и накрая завършва на две цифри (минутите), които са между 0 и 59 вкл.
+5. [=Тип "percentage":=] започва с поне една цифра, като след първите цифри може да има точка и още цифри, и накрая завършва на знака [`%`]
+6. [=Тип "other"=], когато не можем да го свържем с никое от горните правила
 
 :table_2
 |= Вход
@@ -324,17 +324,17 @@ Mo Tu We Th Fr Sa Su
 Обсега за един ред е една от 3 типа стойности:
 .numbered
 1. цяло число (последователност от цифри), която определя реда в текущия текст
-2. `[.]`, което обозначава текущия ред
-3. `[$]`, което обозначава последния ред във файла
+2. [`.`], което обозначава текущия ред
+3. [`$`], което обозначава последния ред във файла
 
-Ако въведем =[само]= обсег за един ред, то това обновява текущия ред.
+Ако въведем [=само=] обсег за един ред, то това обновява текущия ред.
 
-Имаме и обсег за няколко реда, който е във формата `[начало,край]`.
-`[начало]` и `[край]` са в същия формат като обсега за един ред.
+Имаме и обсег за няколко реда, който е във формата [`начало,край`].
+[`начало`] и [`край`] са в същия формат като обсега за един ред.
 Тоест, това са два обсега за един ред, слепени със запетая.
 
-`[начало]` може да бъде пропуснато, в който случай по подразбиране е 1 (първия ред).
-`[край]` може да бъде пропуснато, в който случай по подразбиране е `[$]` (последния ред).
+[`начало`] може да бъде пропуснато, в който случай по подразбиране е 1 (първия ред).
+[`край`] може да бъде пропуснато, в който случай по подразбиране е [`$`] (последния ред).
 
 Трябва да върнете съобщение за грешка, ако е подаден невалиден обсег за текущия текст.
 
@@ -344,19 +344,19 @@ Mo Tu We Th Fr Sa Su
 Това са всички команди:
 
 .numbered
-1. `[p]` - изкарва редовете в обсега
-2. `[n]` - изкарва редовете в обсега, като преди всеки е поставен неговия номер на реда
-3. `[d]` - изтрива редовете в обсега
-4. `[а]` - добавя текст =[след]= всеки ред в обсега
-5. `[i]` - добавя текст =[преди]= всеки ред в обсега
-6. `[q]` - прекратява програмата
+1. [`p`] - изкарва редовете в обсега
+2. [`n`] - изкарва редовете в обсега, като преди всеки е поставен неговия номер на реда
+3. [`d`] - изтрива редовете в обсега
+4. [`а`] - добавя текст [=след=] всеки ред в обсега
+5. [`i`] - добавя текст [=преди=] всеки ред в обсега
+6. [`q`] - прекратява програмата
 
-Буквите, след командите `[a]` и `[i]` са текста, който трябва да бъде вмъкнат.
+Буквите, след командите [`a`] и [`i`] са текста, който трябва да бъде вмъкнат.
 Може да се вмъкне само по един ред текст.
 
-След въвеждане на ред чрез `[a]` или `[i]`, текущия ред автоматично се обновява на ново-добавения ред.
+След въвеждане на ред чрез [`a`] или [`i`], текущия ред автоматично се обновява на ново-добавения ред.
 
-След изтриване на ред чрез `[d]`, трябва да обновите текущия ред, само когато има смисъл.
+След изтриване на ред чрез [`d`], трябва да обновите текущия ред, само когато има смисъл.
 Например, ако текущия ред е 10 и изтриете ред 20, няма нужда от промяна.
 Ако текущия ред е 10 и изтриете редове 2 и 3, тогава текущия ред трябва да се намали с броя изтрите редове, а имменно, с 2, от 10 на 8.
 
@@ -365,7 +365,7 @@ Mo Tu We Th Fr Sa Su
 Вход и изход не са смесени.
 Наклонения текст е допълнителен коментар на това, което се случва (тоест, вие не трябва да го подавате на вашата програма).
 
-=[Вход 1:]=
+[=Вход 1:=]
 ```
 aThe man looked along the way he had come.
 aThe Yukon lay a mile wide and hidden under three feet of ice.
@@ -373,7 +373,7 @@ aOn top of this ice were as many feet of snow. It was all pure white.
 ,p
 q
 
-=[Изход 1:]=
+[=Изход 1:=]
 ```
 The man looked along the way he had come.
 The Yukon lay a mile wide and hidden under three feet of ice.
@@ -381,7 +381,7 @@ On top of this ice were as many feet of snow. It was all pure white.
 
 [$br1]
 
-=[Вход 2:]=
+[=Вход 2:=]
 ```
 aThe Yukon lay a mile wide and hidden under three feet of ice.
 iThe man looked along the way he had come.
@@ -394,23 +394,23 @@ p
 ,p
 q
 
-=[Изход 2:]=
+[=Изход 2:=]
 ```
-*[Изход от ",2n"]*
+[*Изход от ",2n"*]
 1    The man looked along the way he had come.
 2    The Yukon lay a mile wide and hidden under three feet of ice.
-*[Изход от първото "p"]*
+[*Изход от първото "p"*]
 On top of this ice were as many feet of snow. It was all pure white.
-*[Изход от второто "p"]*
+[*Изход от второто "p"*]
 The Yukon lay a mile wide and hidden under three feet of ice.
-*[Изход от ",p"]*\n
+[*Изход от ",p"*]\n
 The man looked along the way he had come.\n
 The Yukon lay a mile wide and hidden under three feet of ice.\n
 On top of this ice were as many feet of snow. It was all pure white.
 
 [$br1]
 
-=[Вход 3:]=
+[=Вход 3:=]
 ```
 aNorth and south, as far as his eye could see,
 ait was unbroken white.
@@ -429,29 +429,29 @@ icurved from the pine-covered
 ,p
 q
 
-=[Изход 3:]=
+[=Изход 3:=]
 
 .note
-=[(23.12.2025)]= Поправен този изход
+[=(23.12.2025)=] Поправен този изход
 
 ```
-*[Изход от "3,5p"]*
+[*Изход от "3,5p"*]
 The one thing that relieved
 the whiteness was a thin dark line that
 cruved from the pine-covered
-*[Изход от ",n"]*
+[*Изход от ",n"*]
 1    North and south, as far as his eye could see,
 2    it was unbroken white.
 3    The one thing that relieved
 4    the whiteness was a thin dark line that
 5    island to the south.
-*[Изход от ".,$p"]*
+[*Изход от ".,$p"*]
 curved from the pine-covered
 the whiteness was a thin dark line that
 island to the south.
-*[Изход от ".n"]*
+[*Изход от ".n"*]
 3    curved from the pine-covered
-*[Изход от ",p"]*
+[*Изход от ",p"*]
 The one thing that relieved
 the whiteness was a thin dark line that
 curved from the pine-covered
Commit	88a5b49611a0a4d1eb47ba86b9123159443ce4cb (patch)
Author	Syndamia <kamen@syndamia.com>	2025-12-23 22:54:20 +0200
Committer	Syndamia <kamen@syndamia.com>	2025-12-23 22:54:20 +0200
Files	22ce3c36887f506898cc7636a80abf245ae240e7 /src/teaching
	syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.tar syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.tar.gz syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.zip
Parent	0be8d4b427a0f0944552769edc9a080dbaf79cee (diff)