-
-
-
-
-
-
-
-
-
diff --git a/module1/presentation_array.md b/module1/presentation_array.md
deleted file mode 100644
index 617703c0c..000000000
--- a/module1/presentation_array.md
+++ /dev/null
@@ -1,79 +0,0 @@
-
-
-# `std::array`
-
-## Tablica o stałym rozmiarze
-
-
-
-
-
-___
-
-## Cechy `std::array`
-
-* Cache-friendly, tzn. iterując po std::array<T, N>, zostanie on cały załadowany do pamięci podręcznej procesora, co przyspieszy odczytywanie danych
-* Typ <T> może być dowolny. Zarówno typ wbudowany jak int, double, jak i własny zdefiniowany przez nas typ
-* Typ <N> oznacza rozmiar tablicy, który musi być znany już w czasie kompilacji
-* Elementy są ułożone obok siebie w pamięci, tak jak w zwykłej tablicy
-* std::array jest najprymitywniejszym wrapperem na zwykłe tablice, używanie jej jest praktycznie tak samo wydajne
-* Nie możemy dodać nowego elementu, możemy jedynie dokonać modyfikacji już istniejących pól
-* Odczyt oraz modyfikacja elementów jest bardzo szybka
-* Tak jak nie możemy dodać elementów, tak też nie możemy ich usunąć (rozmiar się nie zmienia)
-
-___
-
-## Operacje na `std::array`
-
-* dodawanie elementu: nie da się
-* modyfikowanie/dostęp do elementu: at(), operator[]
-* pierwszy/ostatni element: back(), front()
-* rozmiar/czy kontener jest pusty: size(), empty()
-* iterator początku/końca: begin(), end()
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: nie da się, jednak mamy metodę fill, którą możemy np. wyzerować wszystkie elementy
-* przygotowanie elementu do usunięcia: nie da się
-* wymazanie elementów z pamięci: nie da się
-* podmiana całego kontenera: swap()
-
-___
-
-### Przekazanie `std::array` do funkcji
-
-Ponieważ `std::array` ma 2 parametry szablonu, niektórzy mogą mieć problem przy przekazywaniu jej do funkcji, gdyż pisząc `std::array` zapominając o rozmiarze tablicy.
-
-
-```cpp
-void print(const std::array& arr) {
- for (const auto& el : arr) {
- std::cout << el << ' ';
- }
- std::cout << '\n';
-}
-
-int main() {
- std::array arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
- print(arr);
-
- return 0;
-}
-```
-
-
-___
-
-## Zadanie
-
-* Znajdź dokumentację `std::array` na [cppreference.com](https://en.cppreference.com)
-* Stwórz nowy plik cpp i napisz funkcję `main()`
-* Stwórz `std::array` o rozmiarze 10
-* Wypełnij ją wartościami 5
-* Do czwartego elementu przypisz wartość 3
-* Stwórz inną tablicę o tym samym rozmiarze
-* Podmień tablice
-* Wypisz obie tablice, każdą w osobnej linii
-
-___
-
-## Q&A
diff --git a/module1/presentation_deque.md b/module1/presentation_deque.md
deleted file mode 100644
index 79c9075d4..000000000
--- a/module1/presentation_deque.md
+++ /dev/null
@@ -1,125 +0,0 @@
-
-
-# `std::deque`
-
-## Kolejka dwustronna
-
-### deque = double ended queue
-
-
-
-
-
-___
-
-## Cechy `std::deque`
-
-* Hybryda listy oraz wektora
-* deque dzieli się na kawałki (ang. chunk), które są tablicami porozrzucanymi po pamięci
-* O wielkości takiego kawałka decyduje kompilator (nie ma jednej reguły)
-* Dodatkowo deque wyposażony jest w jeszcze jeden wektor, który przechowuje wskaźniki wskazujące początek każdego `chunka` w pamięci.
-* W ten sposób zyskujemy 2 rzeczy:
- * Dodawanie nowego elementu, jest szybsze, gdyż alokujemy zawsze pamięć dla całego `chunka` i nie będziemy przenosić elementów jak w `std::vector`, gdy zabraknie nam miejsca na alokacje dodatkowej pamięci
- * Dane załadowane z jednego `chunka` są cache-friendly
-
-___
-
-
-## Struktura `std::deque`
-
-
-
-___
-
-## Cechy `std::deque` cd.
-
-* Częściowo cache-friendly, czyli poszczególne `chunki` znajdą się w pamięci podręcznej procesora
-* Typ <T> może być dowolny. Zarówno typ wbudowany jak int, double, jak i własny zdefiniowany przez nas typ
-* Każdy `chunk` jest reprezentowany w pamięci jak tablica, natomiast same `chunki` nie sąsiadują ze sobą i są porozrzucane jak węzły listy
-* Dodanie nowego elementu jest szybkie
- * Jeżeli dany `chunk` ma jeszcze miejsce to dopisujemy go na koniec
- * Jeżeli nie, to alokowany jest nowy chunk i tam wpisywany jest nowy element
-* Usuwanie z początku i końca jest szybkie, bo powoduje jedynie przesunięcie iteratorów begin() lub end()
-* Usuwanie elementów ze środka jest kosztowne
-* Odczyt i modyfikacja jest szybka
- * Znamy rozmiar `chunka`, więc wiemy dokładnie, z którego pola w naszym wektorze pomocniczym powinniśmy odczytać adres `chunka`
- * Wiemy także, z którego pola odczytać daną, gdyż `chunk` jest ułożony jak tablica.
-
-___
-
-## Dostęp do elementu
-
-Matematycznie ujmując: jeżeli `chunk` ma 16 elementów a my chcemy dostać się do 100 elementu to:
-
-* `x = 100 / 16 -> x = 6` (ucinamy część po przecinku)
-* `y = 100 % 16 -> y = 4`
-
-Zatem wiemy, że jest to 4-ty element w 6-tym `chunku`
-
-
-Ta wiedza jest zupełnie niepotrzebna przy użytkowaniu `std::deque`. Kontener zajmuje się tym automatycznie.
-
-
-___
-
-### Operacje na `std::deque`
-
-* dodawanie elementu: push_back(), emplace_back(), push_front(), emplace_front(), insert()
-* modyfikowanie/dostęp do elementu: at(), operator[]
-* pierwszy/ostatni element: back(), front()
-* rozmiar/czy kontener jest pusty: size(), empty()
-* wyczyszczenie nieużywanej pamięci: shrink_to_fit(),
-* iterator początku/końca: begin(), end()
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: clear()
-* przygotowanie elementu do usunięcia: remove() (nie jest metodą std::deque),
-* wymazanie elementów z pamięci: erase()
-* podmiana całego kontenera: swap()
-
-___
-
-### Przykład użycia
-
-```cpp
-#include
-#include
-
-int main() {
- // Create a deque containing integers
- std::deque d = {7, 5, 16, 8};
-
- // Add an integer to the beginning and end of the deque
- d.push_front(13);
- d.push_back(25);
-
- // Iterate and print values of the deque
- for(const auto& n : d) {
- std::cout << n << ' ';
- }
- std::cout << '\n';
-}
-```
-
-Output:
-
-`13 7 5 16 8 25`
-
-___
-
-## Zadanie 6
-
-* Znajdź dokumentację `std::deque` na [cppreference.com](https://en.cppreference.com)
-* Stwórz nowy plik cpp i napisz funkcję `main()`
-* Stwórz pusty `deque`
-* Dodaj do niego 5 dowolnych wartości
-* Wyświetl deque
-* Usuń 2-gi i 4-ty element
-* Dodaj na początek i koniec wartość 30
-* Wyświetl deque
-* Dodaj na 4 pozycji liczbę 20
-* Wyświetl deque
-
-___
-
-## Q&A
diff --git a/module1/presentation_forward_list.md b/module1/presentation_forward_list.md
deleted file mode 100644
index 1a7368c62..000000000
--- a/module1/presentation_forward_list.md
+++ /dev/null
@@ -1,134 +0,0 @@
-
-
-# `std::forward_list`
-
-
-## Lista jednokierunkowa
-
-
-
-
-
-___
-
-## Cechy `std::forward_list`
-
-* Elementy porozrzucane po pamięci
-* Każdy element (węzeł -> ang. node) posiada wskaźnik na następny element
-* Typ <T> może być dowolny. Zarówno typ wbudowany jak int, double, jak i własny zdefiniowany przez nas typ.
-* Nie jest cache-friendly
-* Dodawanie nowego elementu jest proste. Program zaalokuje potrzebną pamięć dla węzła i przekaże poprzedniemu węzłowi (o ile istnieje) informacje o swoim położeniu.
-* Usuwanie elementu jest szybkie, program zwalnia pamięć zaalokowaną dla danego węzła oraz informuje o tym poprzedni węzeł, aby mógł zmienić swój wskaźnik.
-* Wyszukiwanie węzła (np. do usunięcia lub wstawienia za nim nowego elementu) jest już kosztowne, gdyż musimy się przeiterować kolejno przez wszystkie węzły, aż odnajdziemy poszukiwany (nawet, jeżeli dokładnie wiemy, że jest on np. 40-tym elementem listy)
-
-___
-
-
-### Operacje na `std::forward_list`
-
-* dodawanie elementu: push_front(), emplace_front(), insert_after(), emplace_after()
-* modyfikowanie/dostęp do elementu: należy samodzielnie odnaleźć element
-* pierwszy/ostatni element: front()
-* rozmiar/czy kontener jest pusty: nie mamy size(), dostępny jest tylko empty()
-* iterator początku/końca: begin(), end()
-* iterator wskazujący element przed begin(): before_begin()
-* stały iterator: cbegin(), cend(), cbefore_begin()
-* wyczyszczenie kontenera: clear()
-* posortowanie listy: sort()
-* odwrócenie listy: reverse()
-* usunięcie duplikatów: unique()
-* usunięcie elementów z listy: remove()
-* wymazanie elementów z pamięci: erase_after()
-* wymazanie elementów z pamięci używając <algorithm>: erase()
-* podmiana całego kontenera: swap()
-
-___
-
-## `std::forward_list::insert_after()` && `std::forward_list::before_begin()`
-
-
-Lista jednokierunkowa (ang. singly linked list) umożliwia nam wstawianie elementu za konkretnym węzłem.
-Jeżeli chcemy wstawić wartość na początku listy używając metody `insert_after`, musimy podać jej specjalny iterator `before_begin`, który wskazuje element przed pierwszym węzłem listy.
-W ten sposób, metoda `insert_after()` wstawi pożądaną przez na wartość dokładnie jako pierwszy element listy.
-
-
-```cpp
-std::forward_list list {1, 2, 3, 4, 5, 6};
-list.insert_after(list.begin(), 10);
-print(list);
-list.insert_after(list.before_begin(), 0);
-print(list);
-```
-
-
-Output:
-
-
-```cpp
-1 10 2 3 4 5 6
-0 1 10 2 3 4 5 6
-```
-
-
-___
-
-## `std::forward_list::remove()`
-
-Ponieważ lista zawiera swoją metodę `remove()`, nie musimy już korzystać z `erase()`.
-
-
-```cpp
-std::forward_list list {1, 4, 2, 4, 3, 4, 5};
-list.remove(4);
-// {1, 2, 3, 5}
-```
-
-
-___
-
-## `std::forward_list::erase_after()`
-
-
-Erase_after służy do usunięcia węzłów od miejsca za elementem wskazanym przez pierwszy iterator do momentu wskazanego przez drugi iterator (bez elementu wskazywanego przez niego).
-
-
-```cpp
-std::forward_list list {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-auto it = list.begin();
-std::advance(it, 4);
-std::cout << "it: " << *it << std::endl;
-auto it2 = list.begin();
-std::advance(it2, 7);
-std::cout << "it2: " << *it2 << std::endl;
-list.erase_after(it, it2);
-print(list);
-```
-
-
-Output:
-
-
-```cpp
-it: 5
-it2: 8
-1 2 3 4 5 8 9 10
-```
-
-
-___
-
-## Zadanie 5
-
-* Znajdź dokumentację `std::forward_list` na [cppreference.com](https://en.cppreference.com)
-* Skorzystaj z kodu z zadania z `std::list`
-* Stwórz listę jednokierunkową zawierającą elementy od 0 do 5
-* Wyświetl listę
-* Usuń 3 element z listy
-* Dodaj na początek i koniec listy wartość 10
-* Wyświetl listę
-* Dodaj na czwartej pozycji liczbę 20
-* Wyświetl listę
-
-___
-
-## Q&A
diff --git a/module1/presentation_homework.md b/module1/presentation_homework.md
deleted file mode 100644
index 03540179a..000000000
--- a/module1/presentation_homework.md
+++ /dev/null
@@ -1,156 +0,0 @@
-
-
-# STL #1
-
-## Kontenery sekwencyjne
-
-### Podsumowanie
-
-
-
-
-
-___
-
-## Co pamiętasz z dzisiaj?
-
-### Napisz na czacie jak najwięcej haseł
-
-
-1. Przypomnienie STLa
-2. Jak czytać dokumentację
-3. std::vector<T>
-4. std::list<T>
-5. std::forward_list<T>
-6. std::array<T, N>
-7. std::deque<T>
-
-___
-
-
-___
-
-## Praca domowa
-
-### Post-work
-
-Ta praca domowa może już stanowić pewne wyzwanie. Działaj dużo z dokumentacją cppreference.
-
-* Poczytaj o formacie grafiki PGM - [Wiki ENG](https://en.wikipedia.org/wiki/Netpbm#File_formats). Ta wiedza może się przydać w zadaniu 3 i 4.
-* Zadanie 1 - `removeVowels()` (5 punktów)
-* Zadanie 2 - `lengthSort()` (6 punktów)
-* Zadanie 3a - `compressGrayscale()` (7 punktów)
-* Zadanie 3b - `decompressGrayscale()` (7 punktów)
-
-#### Bonusy
-
-* 2 punkty za każde zadanie dostarczone przed 14.06.2020 (niedziela) do 23:59
-* 3 punkty za pracę w grupie dla każdej osoby z grupy. Zalecamy grupy 3 osobowe.
-
-#### [Zadania w repo](https://github.com/coders-school/stl/tree/master/module1/homework)
-
-___
-
-### Pre-work
-
-* Znajdź na [cppreference.com](https://en.cppreference.com/w/) opisy algorytmów i zapoznaj się z nimi. Popatrz też na przykłady użycia.
-* Poczytaj o złożoności obliczeniowej np. na [Samouczku programisty](https://www.samouczekprogramisty.pl/podstawy-zlozonosci-obliczeniowej/)
-* Obejrzyj i zapamiętaj jaka jest [złożoność operacji na poszczególnych kontenerach STL](https://github.com/gibsjose/cpp-cheat-sheet/blob/master/Data%20Structures%20and%20Algorithms.md)
-
-___
-
-## Zadanie 1 - `removeVowels()`
-
-Napisz funkcję `removeVowels()`, która przyjmie `std::vector` oraz usunie wszystkie samogłoski z tych wyrażeń.
-
-* Input: `{"abcde", "aabbbccabc", "qwerty"}`
-* Output: `{"bcd", "bbccbc", "qwrt"}`
-
-___
-
-## Zadanie 2 - `lengthSort()`
-
-Napisz funkcję `lengthSort()`.
-
-Ma ona przyjąć `std::forward_list` i zwrócić `std::deque`
-z posortowanymi słowami od najkrótszego do najdłuższego. Jeżeli dwa lub więcej słów ma tyle samo znaków
-posortuj je leksykograficznie.
-
-* Input: `std::forward_list{"Three", "One", "Four", "Two"}`
-* Output: `std::deque{"One", "Two", "Four", "Three"}`
-
-___
-
-
-## Zadanie 3a - `compressGrayscale()`
-
-Zadaniem będzie kompresja obrazka w odcieniach szarości o wymiarach 240x160 pikseli. Każdy piksel może mieć wartość od 0 (kolor czarny) do 255 (kolor biały). Im większa wartość tym jaśniejszy odcień piksel reprezentuje. Przykład małego obrazka o rozmiarach 6x4 piksele:
-
-
-
-```cpp
-255 255 0 255 0 255 // 0xFF 0xFF 0x00 0xFF 0x00 0xFF
-128 0 128 0 128 0 // 0x80 0x00 0x80 0x00 0x80 0x00
-64 64 64 64 64 64 // 0x40 0x40 0x40 0x40 0x40 0x40
-255 192 128 64 0 0 // 0xFF 0xB0 0x80 0x40 0x00 0x00
-```
-
-Aby otrzymać z tego plik w formacie PGM wystarczy tylko dodać mu odpowiedni nagłówek.
-
-___
-
-
-## Zadanie 3a - `compressGrayscale()` - opis
-
-Napisz funkcję `compressGrayscale()`.
-Powinna ona przyjąć jeden argument typu `std::array, 160>` określający rozkład odcieni szarości na obrazku 2D (który w dalszej części nazywać będziemy bitmapą) i zwróci `std::vector>` zawierający skompresowaną bitmapę.
-
-Kompresja powinna przebiegać w następujący sposób:
-
-* Bitmapę rysujemy od górnego lewego rogu przechodząc w prawo, następnie poziom niżej.
-* Jeżeli obok siebie występuje ten sam kolor więcej niż 1 raz, funkcja powinna wrzucić do `std::vector<>` wartość tego koloru (liczba z przedziału 0 – 255) jako pierwszy element pary oraz ilość jego powtórzeń jako drugi element pary.
-* Jeżeli obok siebie występują różne odcienie to funkcja powinna wypełnić `std::vector<> ` wartością odcienia oraz liczbą wystąpień równą 1 (w tym przypadku pogarszamy optymalizację, gdyż przechowujemy 2x tyle danych, jednak najczęściej te same kolory są położone obok siebie).
-
-___
-
-
-## Zadanie 3a - `compressGrayscale()` - przykład
-
-```cpp
-input: {{0 0 0 1 1 2 3 0 0 0},
- {0 0 4 4 4 1 1 1 1 1},
- {2 2 2 2 2 1 2 2 2 2}}
-output: {{0, 3}, {1, 2}, {2, 1}, {3, 1}, {0, 3}, {0, 2}, {4, 3}, {1, 5}, {2, 5}, {1, 1}, {2, 4}}
-```
-
-W przypadku powyższej konwersji zamiast 30 bajtów (wymiary 10x3) zużyjemy 22 (11x2). Więc skompresowaliśmy dane o 26,7%.
-
-Nie przejmujemy się na razie tym jak `uint_8` będzie zamieniany na kolor. Ważne w tym zadaniu jest, aby poćwiczyć korzystanie z kontenerów oraz wykonywania na nich różnych operacji.
-
-Chętni mogą także zrefaktoryzować (czyli napisać czytelniej, ulepszyć) testy tak, aby te skomplikowane pętle, które wypełniają tablice były uniwersalną funkcją, możliwą do wywołania w obecnie istniejących i przyszłych testach (podobnie jak funkcja `getBitmap()`).
-Po wydzieleniu i refaktoringu funkcji generującej, postarajcie się dopisać także przypadki dla 1/16, 1/32 i 1/64 mapy.
-
-___
-
-
-___
-
-## Zadanie 3b - `decompressGrayscale()`
-
-Napisz funkcję `decompressGrayscale()`, która zdekompresuje obrazek skompresowany w zadaniu 3 za pomocą funkcji `compressGrayscale()`.
-
-Jako argument funkcja `decompressGrayscale()` przyjmie `std::vector>` natomiast zwróci `std::array, 160>` i przeprowadzi operacje mające na celu rekonstrukcję pierwotnego formatu bitmapy.
-
-___
-
-## ASCII art
-
-Dla chętnych (bez punktów) polecamy także napisać sobie funkcję `printMap()`, która wyświetli mapę.
-Domyślnie `std::cout` potraktuje `uint8_t` jako `unsigned char`, dlatego też możecie sobie wypisać mapę z kodów ASCII.
-
-
-
-___
-
-Chętni mogą także zrefaktoryzować testy, tak by funkcja sprawdzająca mapę była generyczna (adekwatnie do funkcji `expectBitmap()`.
-Po refaktoringu funkcji sprawdzającej, postarajcie sie dopisać także przypadki dla 1/16, 1/32 i 1/64 mapy.
diff --git a/module1/presentation_list.md b/module1/presentation_list.md
deleted file mode 100644
index 99495d2bb..000000000
--- a/module1/presentation_list.md
+++ /dev/null
@@ -1,89 +0,0 @@
-
-
-# `std::list`
-
-## Lista dwukierunkowa
-
-
-
-
-
-___
-
-## Cechy `std::list`
-
-* Elementy porozrzucane po pamięci
-* Każdy element (węzeł, ang. node) posiada wskaźnik na poprzedni i następny element
-* Typ <T> może być dowolny. Zarówno typ wbudowany jak int, double, jak i własny zdefiniowany przez nas typ
-* Nie jest cache-friendly
-* Dodawanie nowego elementu jest proste. Program zaalokuje potrzebną pamięć dla węzła i przekaże sąsiednim węzłom (o ile istnieją) informacje o swoim położeniu
-* Usuwanie elementu jest szybkie, program zwalnia pamięć zaalokowaną dla danego węzła oraz informuje o tym sąsiednie węzły, aby mogły zmienić swoje wskaźniki
-* Wyszukiwanie węzła (np. do usunięcia lub wstawienia za nim nowego elementu) jest już kosztowne, gdyż musimy się przeiterować kolejno przez wszystkie węzły, aż odnajdziemy poszukiwany (nawet, jeżeli dokładnie wiemy, że jest on np. 40-tym elementem listy)
-
-___
-
-
-## Operacje na `std::list`
-
-* dodawanie elementu: push_back(), emplace_back(), push_front(), emplace_front(), insert()
-* modyfikowanie/dostęp do elementu: należy samodzielnie odnaleźć element
-* pierwszy/ostatni element: back(), front()
-* rozmiar/czy kontener jest pusty: size(), empty()
-* iterator początku/końca: begin(), end()
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: clear()
-* posortowanie listy: sort()
-* odwrócenie listy: reverse()
-* usunięcie duplikatów: unique()
-* usunięcie elementów z listy: remove()
-* wymazanie elementów z pamięci: erase()
-* podmiana całego kontenera: swap()
-
-___
-
-## `std::list::remove()` && `std::list::erase()`
-
-Ponieważ lista zawiera swoją metodę `remove()`, nie musimy już korzystać z `erase()`.
-
-
-```cpp
-std::list list{1, 4, 2, 4, 3, 4, 5};
-list.remove(4);
-// list {1, 2, 3, 5}
-```
-
-
-`erase()` używamy podobnie jak dla `std::vector`
-
-
-```cpp
-std::list list{1, 2, 3, 4, 5, 6, 7, 8};
-auto it = list.begin();
-std::advance(it, 3); // like on pointer ptr += 3
-list.erase(list.begin(), it);
-// list {4, 5, 6, 7, 8}
-```
-
-
-`std::advance()` służy do inkrementowania iteratorów. W naszym przypadku przesuwamy się o 3 elementy do przodu.
-
-
-___
-
-## Zadanie 4
-
-* Znajdź dokumentację `std::list` na [cppreference.com](https://en.cppreference.com)
-* Stwórz nowy plik cpp i napisz funkcję `main()`
-* Stwórz listę zawierającą elementy od 0 do 5
-* Wyświetl listę
-* Usuń trzeci element z listy
-* Dodaj na początek i koniec listy wartość 10
-* Wyświetl listę
-* Dodaj na czwartej pozycji liczbę 20
-* Przepisz listę do `std::array`
-* Wyświetl `std::array`
-
-___
-
-## Q&A
diff --git a/module1/presentation_stl.md b/module1/presentation_stl.md
deleted file mode 100644
index 9eb280525..000000000
--- a/module1/presentation_stl.md
+++ /dev/null
@@ -1,32 +0,0 @@
-
-
-# STL
-
-## Krótkie przypomnienie
-
-
-
-
-
-___
-
-## STL - Standard template library
-
-* Zawiera biblioteki dla kontenerów takich jak std:vector<T>, std::list<T>, std::map<K, V>
-* Zawiera biblioteki umożliwiające wykonywanie wielu algorytmów, takich jak std::max, std::sort
-* Jest napisana na szablonach, zatem jest uniwersalna dla wielu typów
-* Aby móc korzystać z algorytmów STL należy dołączyć do projektu bibliotekę <algorithm>
-* Istnieje też druga biblioteka <numeric>, która zawiera algorytmy numeryczne jak std::accumulate
-* Algorytmy można wykonywać na kontenerach takich jak std:vector<T>, std::list<T>, o ile spełnione są pewne warunki
-* Kontenery są zaimplementowane tak, by iterowanie po nich odbywało się poprzez iteratory
-* Iterator begin() wskazuje na początek kontenera, iterator end() na miejsce za ostatnim elementem w kontenerze
-
-___
-
-## Jak czytać dokumentację
-
-### [https://en.cppreference.com](https://en.cppreference.com)
-
-___
-
-## Q&A
diff --git a/module1/presentation_vector.md b/module1/presentation_vector.md
deleted file mode 100644
index b630d0aae..000000000
--- a/module1/presentation_vector.md
+++ /dev/null
@@ -1,231 +0,0 @@
-
-
-# `std::vector`
-
-## Tablica o dynamicznym rozmiarze
-
-
-
-
-
-___
-
-## Cechy `std::vector`
-
-* Cache-friendly, tzn. iterując po wektorze, zostanie on cały załadowany do pamięci podręcznej procesora, co przyspieszy odczytywanie danych.
-* Typ <T> może być dowolny. Zarówno typ wbudowany jak int, double, jak i własny zdefiniowany przez nas typ.
-* Elementy są ułożone obok siebie w pamięci, tak jak w zwykłej tablicy.
-* Dodawanie nowego elementu, gdy zajdzie zależność vec.size() > vec.capacity() spowoduje alokację dodatkowego miejsca w pamięci. W krytycznej sytuacji, gdy przy obecnym obszarze nie ma już miejsca na dodatkowe dane, cały wektor zostanie przeniesiony w inne miejsce w pamięci.
-* Usuwanie elementu z wektora jest szybkie, gdy usuwamy ostatni element, ale kosztowne, gdy usuwamy ze środka lub z początku.
-
-___
-
-
-## Operacje na `std::vector`
-
-* dodawanie elementu: push_back(), emplace_back(), insert()
-* modyfikowanie/dostęp do elementu: at(), operator []
-* pierwszy/ostatni element: back(), front()
-* rozmiar/czy kontener jest pusty: size(), empty()
-* zarezerwowane miejsce: capacity()
-* rezerwowanie miejsca w pamięci: reserve()
-* wyczyszczenie nieużywanej pamięci z wektora: shrink_to_fit()
-* iterator początku/końca: begin(), end()
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: clear()
-* przygotowanie elementu do usunięcia: remove() (nie jest metodą std::vector<T>)
-* wymazanie elementów z pamięci: erase()
-* podmiana całego kontenera: swap()
-
-___
-
-## Wstawianie elementów #1
-
-### `std::vector::insert()`
-
-```cpp
-iterator insert( const_iterator pos, const T& value );
-```
-
-
-W celu dodania elementu do wektora, możemy wykorzystać iterator:
-
-
-```cpp
-std::vector vec{1, 2, 3, 4};
-auto it = vec.begin();
-vec.insert(it, 20); // {20, 1, 2, 3, 4};
-```
-
-
-___
-
-## Wstawianie elementów #2
-
-### `std::vector::insert()`
-
-```cpp
-iterator insert( const_iterator pos, size_type count, const T& value );
-```
-
-
-Możemy także określić ile elementów chcemy dodać:
-
-
-```cpp
-std::vector vec{1, 2, 3, 4};
-auto it = vec.begin();
-vec.insert(it, 5, 20); // {20, 20, 20, 20, 20, 1, 2, 3, 4};
-```
-
-
-___
-
-## Wstawianie elementów #3
-
-### `std::vector::insert()`
-
-```cpp
-template< class InputIt >
-iterator insert( const_iterator pos, InputIt first, InputIt last );
-```
-
-
-Istnieje też możliwość wstawienia elementów z jednego kontenera do drugiego:
-
-
-```cpp
-std::vector vec{1, 2, 3, 4};
-std::list list{10, 20, 30, 40};
-vec.insert(vec.begin(), list.begin(), list.end());
-// vec = {10, 20, 30, 40, 1, 2, 3, 4}
-```
-
-
-___
-
-## Iterowanie od końca
-
-### `std::vector::rbegin()`, `std::vector::rend()`
-
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5, 6, 7, 8, 9};
-for (auto it = vec.crbegin() ; it != vec.crend() ; ++it) {
- // cr = (r)everse iterator to (c)onst value
- std::cout << *it << ' ';
-}
-```
-
-
-Output: `9 8 7 6 5 4 3 2 1`
-
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5, 6, 7, 8, 9};
-for (auto it = vec.rbegin() ; it != vec.rend() ; ++it) {
- *it *= 2;
-}
-for (auto it = vec.crbegin() ; it != vec.crend() ; ++it) {
- std::cout << *it << ' ';
-}
-```
-
-
-Output: `18 16 14 12 10 8 6 4 2`
-
-
-___
-
-
-## (Prawie) usuwanie 😉
-
-### `std::remove()` z nagłówka ``
-
-```cpp
-template< class ForwardIt, class T >
-ForwardIt remove( ForwardIt first, ForwardIt last, const T& value );
-```
-
-
-Ponieważ najszybciej usuwane są elementy z końca wektora, biblioteka STL umożliwia nam przygotowanie `std::vector` do usunięcia elementów poprzez przeniesienie tych poprawnych na początek kontenera.
-W wyniku tego część wartości do usunięcia jest nadpisywana wartościami z końca wektora, które nie powinny zostać usunięte.
-Dlatego na końcu wektora pozostają "śmieci", które należy wymazać (ang. erase) z pamięci.
-
-
-```cpp
-std::vector vec{1, 4, 2, 4, 3, 4, 5};
-std::remove(vec.begin(), vec.end(), 4);
-// for example: vec {1, 2, 3, 5, 3, 4, 5}
-```
-
-
-`std::remove()` zwróci nam iterator, który wskaże początek danych przeznaczonych do usunięcia.
-
-
-___
-
-## Usuwanie
-
-### `std::vector::erase()`
-
-```cpp
-template< class T, class Alloc, class U >
-constexpr typename std::vector::size_type
- erase(std::vector& c, const U& value);
-```
-
-
-Dzięki funkcji erase, możemy teraz usunąć niepotrzebne dane z kontenera:
-
-
-```cpp
-std::vector vec{1, 4, 2, 4, 3, 4, 5};
-auto it = std::remove(vec.begin(), vec.end(), 4);
-vec.erase(it, vec.end());
-// vec {1, 2, 3, 5}
-```
-
-
-Możemy też zapisać to wszystko w jednej linii (Erase-Remove Idiom)
-
-
-```cpp
-vec.erase(std::remove(vec.begin(), vec.end(), 4), vec.end());
-```
-
-
-___
-
-## Zadanie 1
-
-* [Otwórz dokumentację wektora na cppreference.com](https://en.cppreference.com/w/cpp/container/vector)
-* Stwórz nowy plik cpp i napisz funkcję `main()`
-* Stwórz wektor o wartościach { 1, 2, 4, 5, 6 }
-* Usuń pierwszą wartość
-* Dodaj wartość 5 na końcu wektora
-* Dodaj wartość 12 na początku wektora metodą `emplace`
-* Wypisz rozmiar wektora i maksymalny możliwy rozmiar
-* Wypisz zawartość wektora
-* Wyczyść wektor
-* Wypisz rozmiar wektora
-
-___
-
-## Zadanie 2
-
-* [Otwórz dokumentację wektora na cppreference.com](https://en.cppreference.com/w/cpp/container/vector)
-* Stwórz nowy plik cpp i napisz funkcję `main()`
-* Stwórz pusty wektor
-* Wypisz rozmiar i pojemność wektora
-* Zmień rozmiar wektora na 10 i wypełnij go wartościami 5
-* Wypisz rozmiar i pojemność wektora
-* Zarezerwuj pamięć na 20 elementów
-* Wypisz rozmiar i pojemność wektora
-* Zredukuj pojemność wektora metodą `shrink_to_fit()`
-* Wypisz rozmiar i pojemność wektora
-
-___
-
-## Q&A
diff --git a/module1/stl1.pdf b/module1/stl1.pdf
deleted file mode 100644
index a1a19acc9..000000000
Binary files a/module1/stl1.pdf and /dev/null differ
diff --git a/module2/homework/grayscaleImages/README.md b/module2/homework/grayscaleImages/README.md
deleted file mode 100644
index 9b0bc47ba..000000000
--- a/module2/homework/grayscaleImages/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# `compressGrayscale()` && `decompressGrayscale()`
-
-Ulepsz program `grayscaleImages` z poprzednich zajęć STL#1 (kompresja, dekompresja) obrazków, tak, aby zamiast pętli wykorzystać algorytmy. Działaj na swojej/waszej wersji implementacji tego zadania.
-
-Nie znajdziesz w repo w module2/homework/grayscaleImages żadnego kodu. Pracuj na module1/homework/grayscaleImages. Jeśli nie chcesz nadpisać PR z tamtą pracą domową to po prostu utwórz nowego brancha od tego stanu (ale nie zapomnij żeby zmergować do niego `coders/master`, aby mieć te obecne zadania). Jeśli to skomplikowane - po prostu skopiuj swój program `grayscaleImages` do katalogu module2 ;)
-
-Sugestia jak zrobić brancha pod tę pracę domową:
-
-```git
-git checkout homework1 # zakładamy, że homework1 to nazwa twojego brancha z pracą domową z STL#1
-git checkout -b homework2 # utwórz branch homework2 z obecnego stanu i przełącz się na niego
-git pull coders master # ściągnij i zintegruj zmiany z coders-school/master, aby mieć module2. Nie powinno być konfliktów
-git push origin homework2 # wyślij nowego brancha na swojego forka
-```
-
-Teraz możesz zacząć pracę (najlepiej w grupie) na branchu homework2
diff --git a/module2/homework/insensitivePalindrom/CMakeLists.txt b/module2/homework/insensitivePalindrom/CMakeLists.txt
deleted file mode 100644
index 1ec38c9a9..000000000
--- a/module2/homework/insensitivePalindrom/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Download and unpack googletest at configure time
-configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-# Prevent overriding the parent project's compiler/linker
-# settings on Windows
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-# Add googletest directly to our build. This defines
-# the gtest and gtest_main targets.
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
- ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
- EXCLUDE_FROM_ALL)
-
-# The gtest/gtest_main targets carry header search path
-# dependencies automatically when using CMake 2.8.11 or
-# later. Otherwise we have to add them here ourselves.
-if (CMAKE_VERSION VERSION_LESS 2.8.11)
- include_directories("${gtest_SOURCE_DIR}/include")
-endif()
-
-project(insensitivePalindrom)
-enable_testing()
-
-add_executable(${PROJECT_NAME}-ut test.cpp) # add your cpp file here after test.cpp
-# if this is problematic take a look into CMakeLists.txt files in other exercises
-
-add_compile_options(${PROJECT_NAME}-ut -Wall -Wextra -Wconversion -pedantic -Werror)
-
-target_link_libraries(${PROJECT_NAME}-ut gtest_main)
-add_test(NAME ${PROJECT_NAME}_test COMMAND ${PROJECT_NAME}-ut)
diff --git a/module2/homework/insensitivePalindrom/CMakeLists.txt.in b/module2/homework/insensitivePalindrom/CMakeLists.txt.in
deleted file mode 100644
index c6247af53..000000000
--- a/module2/homework/insensitivePalindrom/CMakeLists.txt.in
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
- GIT_REPOSITORY https://github.com/google/googletest.git
- GIT_TAG master
- SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
- BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- TEST_COMMAND ""
-)
diff --git a/module2/homework/transformContainers/CMakeLists.txt b/module2/homework/transformContainers/CMakeLists.txt
deleted file mode 100644
index b85d83407..000000000
--- a/module2/homework/transformContainers/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Download and unpack googletest at configure time
-configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-# Prevent overriding the parent project's compiler/linker
-# settings on Windows
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-# Add googletest directly to our build. This defines
-# the gtest and gtest_main targets.
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
- ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
- EXCLUDE_FROM_ALL)
-
-# The gtest/gtest_main targets carry header search path
-# dependencies automatically when using CMake 2.8.11 or
-# later. Otherwise we have to add them here ourselves.
-if (CMAKE_VERSION VERSION_LESS 2.8.11)
- include_directories("${gtest_SOURCE_DIR}/include")
-endif()
-
-project(transformContainers)
-enable_testing()
-
-add_executable(${PROJECT_NAME}-ut test.cpp) # add your cpp file here after test.cpp
-# if this is problematic take a look into CMakeLists.txt files in other exercises
-
-add_compile_options(${PROJECT_NAME}-ut -Wall -Wextra -Wconversion -pedantic -Werror)
-
-target_link_libraries(${PROJECT_NAME}-ut gtest_main)
-add_test(NAME ${PROJECT_NAME}_test COMMAND ${PROJECT_NAME}-ut)
diff --git a/module2/homework/transformContainers/CMakeLists.txt.in b/module2/homework/transformContainers/CMakeLists.txt.in
deleted file mode 100644
index c6247af53..000000000
--- a/module2/homework/transformContainers/CMakeLists.txt.in
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
- GIT_REPOSITORY https://github.com/google/googletest.git
- GIT_TAG master
- SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
- BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- TEST_COMMAND ""
-)
diff --git a/module2/homework/transformContainers/README.md b/module2/homework/transformContainers/README.md
deleted file mode 100644
index b749bf603..000000000
--- a/module2/homework/transformContainers/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# `transformContainers`
-
-1. Napisz funkcję `transformContainers`, która przyjmie `std::list` oraz `std::deque`
-2. Usunie duplikaty z obu kontenerów
-3. Na koniec skonwertuje to na `std::map` i ją zwróci. Użyj `std::transform`.
-
-Zajrzyj do pliku z test.cpp i na jego podstawie wywnioskuj jak się ma nazywać funkcja, którą musisz zaimplementować.
-
-Plik nagłówkowy oraz źródłowy z implementacją funkcji nazwij tak, jak Ci się wydaje, że będzie pasować :)
-
-Dodaj odpowiednie `#include` do `test.cpp`
-
-Dodaj swój plik źródłowy cpp do pliku `CMakeLists.txt`, aby również był on kompilowany. Znajdziesz tam odpowiednie sekcje pod koniec:
-
-```cmake
-add_executable(${PROJECT_NAME}-ut test.cpp) # add your cpp file here after test.cpp
-# it this is problematic take a look into CMakeLists.txt files in other exercises
-```
diff --git a/module2/homework/transformContainers/test.cpp b/module2/homework/transformContainers/test.cpp
deleted file mode 100644
index 3f6e9c0c8..000000000
--- a/module2/homework/transformContainers/test.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "gtest/gtest.h"
-
-// TODO: add proper includes
-
-TEST(transformContainerTests, ShouldReturnUniqueMap) {
- std::map expected_result{
- {1, "Ala"},
- {2, "Kot"},
- {3, "Ma"},
- {4, "Rysia"},
- {5, "Sierotka"}};
- std::list list{
- "Ala", "Kot", "Ma", "Rysia", "Ala",
- "Sierotka", "Kot", "Ma", "Ala"};
- std::deque deque{
- 1, 2, 3, 4, 5, 3, 1, 2, 3, 4,
- 5, 2, 3, 1, 1, 2, 3, 2, 1, 4};
- auto result = removeDuplicateAndTranformToMap(list, deque);
-
- ASSERT_TRUE(expected_result.size() == result.size());
- EXPECT_TRUE(std::equal(begin(result),
- end(result),
- begin(expected_result),
- [](const auto& lhs, const auto& rhs) {
- return lhs.first == rhs.first && lhs.second == rhs.second;
- }));
-}
diff --git a/module2/index.html b/module2/index.html
deleted file mode 100644
index 2f2925b2e..000000000
--- a/module2/index.html
+++ /dev/null
@@ -1,134 +0,0 @@
-
-
-
-
-
-
- STL - iteratory, funktory, lambdy, algorytmy - Coders School
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/module2/presentation_algorithms_modifying.md b/module2/presentation_algorithms_modifying.md
deleted file mode 100644
index 64de4ea89..000000000
--- a/module2/presentation_algorithms_modifying.md
+++ /dev/null
@@ -1,357 +0,0 @@
-
-
-# Algorytmy modyfikujące
-
-
-
-
-
-___
-
-## Algorytmy modyfikujące kolejność elementów
-
-Modyfikują one kontenery na których działają.
-
-Mogą:
-
-* zmieniać kolejności elementów w kontenerze
-* usuwać elementy
-* dodawać elementy
-
-Tutaj znajdziesz tylko popularne lub ciekawe użycia niektórych algorytmów. Pełna lista algorytmów dostępna jest na cppreferene.com
-
-[Algorytmy na cppreference.com](https://en.cppreference.com/w/cpp/algorithm)
-
-___
-
-## `std::copy`, `std::copy_if`
-
-```cpp
-template< class InputIt, class OutputIt >
-OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
-```
-
-```cpp
-template< class InputIt, class OutputIt, class UnaryPredicate >
-OutputIt copy_if( InputIt first, InputIt last,
- OutputIt d_first,
- UnaryPredicate pred );
-```
-
-* Podstawowa wersja `std::copy`, kopiuje podany zakres do innego zakresu. Przykładowo kopiuje elementy z wektora do listy.
-* `std::copy_if` kopiuje tylko te elementy, które spełniają podany przez nas predykat. Np. `::is_upper`, `::is::digit`.
-
-___
-
-## `std::copy`, `std::copy_if` - użycie
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5};
-std::array arr;
-std::copy(begin(vec), end(vec), begin(arr));
-print(arr);
-
-std::vector vec2(3);
-std::copy_if(begin(vec), end(vec), begin(vec2), [](auto num) {
- return num % 2 == 1;
-});
-print(vec2);
-```
-
-Output:
-
-```text
-1 2 3 4 5
-1 3 5
-```
-
-___
-
-## `std::fill`
-
-```cpp
-template< class ForwardIt, class T >
-void fill( ForwardIt first, ForwardIt last, const T& value );
-```
-
-Funkcja wypełnia podany zakres wartościami `value`
-
-```cpp
-int main() {
- std::vector v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
- std::fill(v.begin(), v.end(), -1);
- for (auto elem : v) {
- std::cout << elem << " ";
- }
- std::cout << "\n";
-}
-```
-
-Output: `-1 -1 -1 -1 -1 -1 -1 -1 -1 -1`
-
-___
-
-
-## `std::transform`
-
-Potężny algorytm, mogący zrobić dużo więcej niż się wydaje na początku :)
-
-```cpp
-template< class InputIt, class OutputIt, class UnaryOperation >
-OutputIt transform( InputIt first1, InputIt last1,
- OutputIt d_first,
- UnaryOperation unary_op );
-```
-
-```cpp
-template< class InputIt1, class InputIt2, class OutputIt, class BinaryOperation >
-OutputIt transform( InputIt1 first1, InputIt1 last1,
- InputIt2 first2,
- OutputIt d_first,
- BinaryOperation binary_op );
-```
-
-* Pierwsza wersja `std::transform` przyjmuje zakres `[first1, last1)`, oraz wykonuje na każdym elemencie operację `unary_op`, a następnie zapisuje zmodyfikowane elementy w drugim zakresie (`d_first`).
-* Druga wersja, przyjmuje 2 zakresy, pobiera z obu tych zakresów po 1 elemencie i wykonuje na nich operacje `binary_op`, następnie zapisuje wynik w 3 zakresie (`d_first`).
-
-___
-
-## `std::transform` - przykład użycia #1
-
-Konwersja jednego typu kontenera na drugi
-
-```cpp
-int main() {
- std::vector> vec {
- {0, "Zero"},
- {1, "One"},
- {2, "Two"},
- {3, "Three"},
- {4, "Four"},
- {5, "Five"}
- };
- std::vector vec2(5);
- std::transform(begin(vec), end(vec), vec2.begin(), [](const auto& pair) {
- return pair.first;
- });
- print(vec2);
- return 0;
-}
-```
-
-Output: `0 1 2 3 4 5`
-
-___
-
-## `std::transform` - przykład użycia #2
-
-Konwersja kontenera
-
-```cpp
-std::vector> vec {
- {0, "Zero"},
- {1, "One"},
- {2, "Two"},
- {3, "Three"},
- {4, "Four"},
- {5, "Five"}
-};
-std::vector vec2;
-std::transform(begin(vec),
- end(vec),
- std::back_inserter(vec2),
- [](const auto& pair){
- return pair.second + " : " + std::to_string(pair.first);
- });
-print(vec2);
-```
-
-Output: `Zero : 0, One : 1, Two : 2, Three : 3, Four : 4, Five : 5`
-
-___
-
-## `std::transform` - przykład użycia #3
-
-Zamiana znaków na małe litery
-
-```cpp
-int main() {
- std::vector vec {
- "ZeRo", "ONe", "TwO", "ThREe", "FoUr", "FiVe"
- };
- std::transform(begin(vec), end(vec), begin(vec), [](auto str) {
- std::transform(begin(str), end(str), begin(str), [](auto c) {
- return std::tolower(c);
- });
- return str;
- });
- print(vec);
-
- return 0;
-}
-```
-
-Output: `zero one two three four five`
-
-___
-
-## `std::transform` przykład użycia #4
-
-Sumowanie wartości wektora i listy:
-
-```cpp
-int main() {
- std::vector vec {1, 2, 3, 4, 5, 6, 7, 8};
- std::list list {10, 20, 30 , 40 , 50, 60, 70, 80};
- std::transform(begin(vec),
- end(vec),
- begin(list),
- begin(vec),
- [](auto first, auto second) {
- return first + second;
- });
- print(vec);
-
- return 0;
-}
-```
-
-Output: `11 22 33 44 55 66 77 88`
-
-___
-
-## `std::generate`
-
-```cpp
-template< class ForwardIt, class Generator >
-void generate( ForwardIt first, ForwardIt last, Generator g );
-```
-
-Funkcja służąca do generowania danych.
-
-```cpp
-int main() {
- std::vector vec(10);
- std::generate(begin(vec), end(vec), [i{0}]() mutable { return i++; });
- print(vec);
-
- return 0;
-}
-```
-
-Output: `0 1 2 3 4 5 6 7 8 9`
-
-___
-
-
-## `std::swap_ranges`
-
-```cpp
-template< class ForwardIt1, class ForwardIt2 >
-ForwardIt2 swap_ranges( ForwardIt1 first1, ForwardIt1 last1,
- ForwardIt2 first2 );
-```
-
-Podmienia pewien zakres danych
-
-```cpp
-int main() {
- std::vector vec {1, 2, 3, 4, 5, 6, 7, 8};
- std::list list {10, 20, 30, 40, 50, 60, 70, 80};
- std::swap_ranges(begin(vec), std::next(begin(vec), 3), std::begin(list));
- print(vec);
- print(list);
-
- return 0;
-}
-```
-
-Output:
-
-```text
-10 20 30 4 5 6 7 8
-1 2 3 40 50 60 70 80
-```
-
-___
-
-## `std::reverse`
-
-```cpp
-template< class BidirIt >
-void reverse( BidirIt first, BidirIt last );
-```
-
-Odwraca zakres
-
-```cpp
-int main() {
- std::vector vec {1, 2, 3, 4, 5, 6, 7, 8};
- std::reverse(begin(vec), end(vec));
- print(vec);
-
- return 0;
-}
-```
-
-Output: `8 7 6 5 4 3 2 1`
-
-___
-
-## `std::unique`
-
-```cpp
-template< class ForwardIt >
-ForwardIt unique( ForwardIt first, ForwardIt last );
-```
-
-Usuwa duplikaty. Ważne! Kontener musi być posortowany. Tak naprawdę ta funkcja nie usuwa duplikatów, lecz przenosi unikalne wartości na początek kontenera (nie zmieniając ich wzajemnej kolejności) oraz zwraca iterator wskazujący pierwszy element, gdzie zaczynają się duplikaty.
-
-___
-
-## `std::unique` - przykład
-
-```cpp
-int main() {
- std::vector vec {1, 2, 1, 2, 1, 2, 3, 2, 3, 1, 3, 2, 1};
- std::sort(begin(vec), end(vec));
- auto it = std::unique(begin(vec), end(vec));
- print(vec);
- vec.erase(it, end(vec));
- print(vec);
-
- return 0;
-}
-```
-
-Output:
-
-```text
-1 2 3 1 1 2 2 2 2 2 3 3 3
-1 2 3
-```
-
-___
-
-## Zadanie
-
-1. Stwórz `std::vector`
-2. Wypełnij go elementami nieparzystymi licząc od 1 do 15
-3. Odwróć kontener nie używając pętli ani `std::reverse`
-4. Przepisz `std::vector` do listy używając `std::copy`
-5. Stwórz drugi `std::vector` i wypełnij go liczbami parzystymi od 0 do 14.
-6. Znajdź sposób jak połączyć oba wektory w jeden, zawierający wartości od 0 do 15 ułożone po kolei.
-
-___
-
-## Zadanie
-
-1. Stwórz `std::list` z wartościami od 1 do 10.
-2. Utwórz `std::vector` z wartościami od 5 do 10.
-3. Przekaż odpowiednie iteratory do funkcji `std::equal`, tak by zwróciła, że oba kontenery są sobie równe.
-4. Za pomocą `std::mismatch` oraz `erase`, usuń niepasujące elementy z listy
-5. Zawołaj funkcję `std::equal` dla pełnych zakresów aby upewnić się, że są teraz identyczne.
-
-___
-
-## Q&A
diff --git a/module2/presentation_algorithms_nonmodifying.md b/module2/presentation_algorithms_nonmodifying.md
deleted file mode 100644
index 2a68e9126..000000000
--- a/module2/presentation_algorithms_nonmodifying.md
+++ /dev/null
@@ -1,248 +0,0 @@
-
-
-# Algorytmy niemodyfikujące
-
-
-
-
-
-___
-
-## Algorytmy niemodyfikujące kontenerów
-
-Nie modyfikują one kontenerów na których działają.
-
-Nie mogą:
-
-* zmieniać kolejności elementów w kontenerze
-* usuwać elementy
-* dodawać elementy
-
-Tutaj znajdziesz tylko popularne lub ciekawe użycia niektórych algorytmów. Pełna lista algorytmów dostępna jest na cppreferene.com
-
-[Algorytmy na cppreference.com](https://en.cppreference.com/w/cpp/algorithm)
-
-___
-
-## `std::find_if`
-
-```cpp
-template< class InputIt, class UnaryPredicate >
-InputIt find_if( InputIt first, InputIt last, UnaryPredicate p );
-```
-
-* Predykat = funktor, funkcja, lambda, która zwraca `bool` (`true/false`)
-* Algorytm wykorzystywany do wyszukiwania interesujących nas elementów. O tym co nas interesuje będzie decydować przekazany predykat. Jeżeli chcemy liczby podzielnie przez 3 użyjemy predykatu:
- * `[](const auto& el){ return (el % 3 == 0); }`
-* `std::find_if` różni się od `std::find` tylko tym, że zamiast poszukiwanej wartości, podajemy predykat jaki musi zostać spełniony aby uznać dany element za poszukiwana wartość.
-* Typem zwróconym przez `std::find_if` jest iterator, wskazujący na znaleziony element.
-* Jeżeli element nie został znaleziony, wartością zwróconą będzie równy `last`.
-
-___
-
-## `std::find_if` - użycie
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5, 6, 7, 8, 9};
-auto found = std::find_if(begin(vec), end(vec), [](const auto& el) {
- return el == 7;
-});
-if (found != vec.end()) {
- std::cout << *found << '\n';
-}
-```
-
-Output: `found 7`
-
-___
-
-## `std::search`
-
-```cpp
-template< class ForwardIt1, class ForwardIt2 >
-ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
- ForwardIt2 s_first, ForwardIt2 s_last );
-```
-
-* Najprostsza wersja `std::search`, przyjmuje 2 zakresy i sprawdza, czy zakres drugi `{s_first, s_last}` jest podzakresem `{first, last}`.
- * Jeżeli tak zwraca iterator wskazujący na początek tego podzakresu.
- * Jeżeli podzakres nie zostanie znaleziony, zwrócony iterator będzie równy `last`.
-* Istnieją także wersje `std::search`, przyjmujące `binary predicate` oraz typ `searcher`. Zachęcam Was do samodzielnej pracy w celu zdobycia wiedzy, jak wykorzystać te funkcję :).
-
-___
-
-## `std::search` - użycie
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5, 6, 7, 8, 9};
-std::vector vec2 {4, 5, 6};
-auto found = std::search(begin(vec), end(vec),
- begin(vec2), end(vec2));
-if (found != vec.end()) {
- std::cout << "first found element: " << *found << '\n';
-}
-```
-
-Output: `first found element: 4`
-
-___
-
-## `std::count` oraz `std::count_if`
-
-```cpp
-template< class InputIt, class T >
-typename iterator_traits::difference_type
- count( InputIt first, InputIt last, const T &value );
-```
-
-```cpp
-template< class InputIt, class UnaryPredicate >
-typename iterator_traits::difference_type
- count_if( InputIt first, InputIt last, UnaryPredicate p );
-```
-
-* `std::count` zlicza dla danego zakresu wystąpienie konkretnej wartości.
-* `std::count_if` zlicza dla danego zakresu ilość zwróconych `true` przez predykat.
-
-___
-
-## `std::count` oraz `std::count_if` - użycie
-
-```cpp
-std::vector vec {1, 2, 3, 4, 5, 1, 1, 1, 6, 7};
-
-std::cout << std::count(begin(vec), end(vec), 1) << '\n';
-
-auto counter = std::count_if(begin(vec), end(vec), [](const auto& el){
- return el % 3 == 0;
-});
-std::cout << counter << '\n';
-```
-
-Output:
-
-```text
-4
-2
-```
-
-___
-
-## `std::equal`
-
-```cpp
- template< class InputIt1, class InputIt2 >
- bool equal( InputIt1 first1, InputIt1 last1,
- InputIt2 first2 );
-```
-
-```cpp
- template< class InputIt1, class InputIt2 >
- bool equal( InputIt1 first1, InputIt1 last1,
- InputIt2 first2, InputIt2 last2 )
-```
-
-* Algorytm przyjmuje zakres pierwszego kontenera oraz początek drugiego kontenera. Funkcja będzie dokonywać
- sprawdzenia, aż nie dojdzie do końca 1 zakresu, nawet jeżeli 2 zakres jest dłuższy. Jeżeli 2 zakres jest krótszy
- to funkcja zwróci false, gdyż na pewno 1 zakres nie będzie identyczny ponieważ jest dłuższy.
-* Wersja druga algorytmu, pozwala przyjąć pełny zakres 1 i 2 kontenera i porównać te zakresy.
-
-___
-
-## `std::equal` - użycie #1
-
-```cpp
-// Missing vec1 and vec2 :D Can you think of the examples of vec1 and 2 that
-// will make the output look like below?
-std::cout << std::boolalpha << "EQUAL?: "
- << std::equal(begin(vec1), end(vec1), begin(vec2)) << '\n';
-std::cout << std::boolalpha << "EQUAL?: "
- << std::equal(begin(vec2), end(vec2), begin(vec1)) << '\n';
-std::cout << std::boolalpha << "EQUAL?: "
- << std::equal(begin(vec1), end(vec1),
- begin(vec2), std::next(vec2.begin(), 5))
- << '\n';
-```
-
-Output:
-
-```text
-EQUAL?: true
-EQUAL?: false
-EQUAL?: true
-```
-
-___
-
-## `std::equal` - użycie #2
-
-```cpp
-bool is_palindrome(const std::string& s) {
- return std::equal(s.begin(), s.begin() + s.size()/2, s.rbegin());
-}
-void test(const std::string& s) {
- std::cout << "\"" << s << "\" "
- << (is_palindrome(s) ? "is" : "is not")
- << " a palindrome\n";
-}
-int main() {
- test("radar");
- test("hello");
-}
-```
-
-Output:
-
-```text
- "radar" is a palindrome
- "hello" is not a palindrome
-```
-
-___
-
-## `std::mismatch`
-
-```cpp
-template< class InputIt1, class InputIt2 >
-std::pair
- mismatch( InputIt1 first1, InputIt1 last1,
- InputIt2 first2 );
-```
-
-```cpp
-template< class InputIt1, class InputIt2 >
-std::pair
- mismatch( InputIt1 first1, InputIt1 last1,
- InputIt2 first2, InputIt2 last2 );
-```
-
-Działa analogicznie do `std::equal`, z tym wyjątkiem, że zwraca parę iteratorów (dla pierwszego i drugiego zakresu) wskazującą początek niezgodności.
-
-___
-
-## `std::mismatch` - użycie
-
-```cpp
-std::string mirror_ends(const std::string& in) {
- return std::string(in.begin(),
- std::mismatch(in.begin(), in.end(), in.rbegin()).first);
-}
-
-int main() {
- std::cout << mirror_ends("abXYZba") << '\n'
- << mirror_ends("abca") << '\n'
- << mirror_ends("aba") << '\n';
-}
-```
-
-Output:
-
-```text
-ab
-a
-aba
-```
-
-___
-
-## Q&A
diff --git a/module2/presentation_functors.md b/module2/presentation_functors.md
deleted file mode 100644
index 6af83a6c8..000000000
--- a/module2/presentation_functors.md
+++ /dev/null
@@ -1,88 +0,0 @@
-
-
-# Funktory
-
-## Obiekty funkcyjne
-
-
-
-
-
-___
-
-
-## Czym jest funktor - obiekt funkcyjny
-
-Funktor jest to obiekt, który może zostać wywołany jak zwykła funkcja. Każda klasa oraz struktura, która posiada zdefiniowany `operator()` może pełnić rolę funktora.
-Alternatywną nazwą dla funktora jest obiekt funkcyjny.
-
-```cpp
-struct Functor {
- void operator() () {
- std::cout << "I'm a functor!\n";
- }
-};
-
-int main() {
- Functor funct;
- funct(); // obiekt nazwany (linię wyżej)
- Functor{}(); // obiekt tymczasowy
-
- return 0;
-}
-```
-
-output:
-
-```text
-I'm a functor!
-I'm a functor!
-```
-
-___
-
-## Czym jest funktor - funkcja
-
-Funkcja także jest traktowana jako funktor, ponieważ również możemy ją wywołać poprzez `()`.
-
-```cpp
-void function() {
- std::cout << "I'm a functor!\n";
-}
-
-int main() {
- function();
-
- return 0;
-}
-```
-
-output: `I'm a functor!`
-
-___
-
-## Wykorzystanie funktorów
-
-Funktory możemy wykorzystać w algorytmach STL. Przykładowo algorytm `for_each` dla każdego elementu wywołuje on przekazany funktor. Sam funktor za swój jedyny argument musi przyjmować typ elementu z zakresu, na którym pracuje.
-
-```cpp
-struct Functor {
- void operator()(int el) {
- std::cout << el << ' ';
- }
-};
-
-int main() {
- std::vector vec {1, 2, 3, 4, 5};
- std::for_each(begin(vec), end(vec), Functor{});
- std::cout << '\n';
-
- return 0;
-}
-```
-
-output: `1 2 3 4 5`
-
-___
-
-## Q&A
diff --git a/module2/presentation_homework.md b/module2/presentation_homework.md
deleted file mode 100644
index 0c86afddb..000000000
--- a/module2/presentation_homework.md
+++ /dev/null
@@ -1,92 +0,0 @@
-
-
-# STL #2
-
-## Funktory, lambdy, algorytmy
-
-### Podsumowanie
-
-
-
-
-
-___
-
-## Co było łatwe do zrozumienia?
-
-## Co chcesz powtórzyć na sesji Q&A?
-
-
-### Zapisz i wrzuć na kanał #powtórka na Discordzie :)
-
-
-___
-
-## Praca domowa
-
-### Post-work
-
-* Zadanie 1 - kontynuacja poprzedniego zadania 3 - `grayscaleImages` (6 punktów)
-* Zadanie 2 - `insensitivePalindrom` (6 punktów)
-* Zadanie 3 - `transformContainers` (6 punktów)
-
-PR zgłaszajcie również na gałąź `master` w repo `coders-school/stl`, ale dodajcie obowiązkowo w tytule `STL#2`. U was gałąź może być dowolna.
-
-#### Bonusy
-
-* 2 punkty za każde zadanie dostarczone przed 21.06.2020 (niedziela) do 23:59
-* 3 punkty za pracę w grupie dla każdej osoby z grupy. Zalecamy grupy 3 osobowe (takie jak ostatnio)
-
-#### [Zadania w repo](https://github.com/coders-school/stl/tree/master/module2/homework)
-
-___
-
-### Pre-work
-
-* Przygotuj listę pytań na sesję Q&A :)
-* Upewnij się, że działa Ci mikrofon i możesz rozmawiać na Discordzie
-* Jeśli masz wątpliwości lub niedziałające implementacje i chcesz je skonsultować - podeślij link do repo na kanale #powtórka na Discordzie.
- * Pytania możesz oznaczyć komentarzami w kodzie
- * Pytania możesz też napisać w komentarzu do PR
- * Dodatkowe pytania możesz też później zadać na żywo podczas omawiania kodu
-
-___
-
-### Zadanie 1 - `grayscaleImages` cd.
-
-Ulepsz program `grayscaleImages` z poprzednich zajęć STL#1 (kompresja, dekompresja) obrazków, tak, aby zamiast pętli wykorzystać algorytmy. Działaj na swojej/waszej wersji implementacji tego zadania.
-
-Nie znajdziesz w repo w module2/homework/grayscaleImages żadnego kodu. Pracuj na module1/homework/grayscaleImages. Jeśli nie chcesz nadpisać PR z tamtą pracą domową to po prostu utwórz nowego brancha od tego stanu (ale nie zapomnij żeby zmergować do niego `coders/master`, aby mieć te obecne zadania). Jeśli to skomplikowane - po prostu skopiuj swój program `grayscaleImages` do katalogu module2 ;)
-
-___
-
-### Zadanie 2 - `insensitivePalindrom`
-
-Napisz program, który będzie sprawdzał, czy podany ciąg wyrazów jest palindromem. Program powinien ignorować znaki specjalne jak `,.?()[]`, wielkość liter oraz białe znaki jak spacja czy znak nowej linii.
-
-Tutaj wywnioskuj po testach jak nazwać funkcję. Stwórz własne pliki źródłowe i nagłówkowe i dodaj je do CMakeLists.txt, aby się budowały. Szczegóły w README.md do tego zadania.
-
-___
-
-### Zadanie 3 - `transformContainers`
-
-1. Napisz funkcję `transformContainers`, która przyjmie `std::list` oraz `std::deque`
-2. Usunie duplikaty z obu kontenerów
-3. Na koniec skonwertuje to na `std::map` i ją zwróci. Użyj `std::transform`.
-
-Tutaj wywnioskuj po testach jak nazwać funkcję. Stwórz własne pliki źródłowe i nagłówkowe i dodaj je do CMakeLists.txt, aby się budowały. Szczegóły w README.md do tego zadania.
-
-___
-
-### Współpraca
-
-Sugestia jak zrobić brancha pod tę pracę domową:
-
-```git
-git checkout homework1 # homework1 to nazwa twojego brancha z pracą domową z STL#1
-git checkout -b homework2 # utwórz branch homework2 z obecnego stanu
-git pull coders master # ściągnij i zintegruj zmiany z coders-school/master, aby mieć module2. Nie powinno być konfliktów
-git push origin homework2 # wyślij nowego brancha na swojego forka
-```
-
-Teraz możesz zacząć pracę (najlepiej w grupie) na branchu homework2
diff --git a/module2/presentation_lambda.md b/module2/presentation_lambda.md
deleted file mode 100644
index 3d4b84fde..000000000
--- a/module2/presentation_lambda.md
+++ /dev/null
@@ -1,147 +0,0 @@
-
-
-# Wyrażenia lambda
-
-## Nowoczesne funktory
-
-
-
-
-
-___
-
-## Czym jest wyrażenie lambda?
-
-* Wprowadzone w C++11, ulepszane w C++14, C++17, C++20
-* Lambda to obiekt funkcyjny, który może zostać wywołany dla konkretnych parametrów i zwrócić wynik
-* Prosta w budowie - `[](){}`
-* Służy do zwięzłego zapisu obiektu funkcyjnego, który normalnie zająłby nam kilka razy więcej miejsca
-* Zyskujemy lepszą czytelność oraz większą swobodę w działaniu
-* Typ lambdy nazywa się domknięciem (ang. closure) i jest znany tylko kompilatorowi
-* Aby przypisać wyrażenie lambda do zmiennej musimy być ona typu auto, ponieważ tylko kompilator zna typ tego wyrażenia
-
-___
-
-## Utworzenie prostego wyrażenia lambda
-
-```cpp
-#include
-#include
-#include
-
-int main() {
- []() { std::cout << "Hello"; } // lambda printing Hello (not called)
-
- std::vector vec {1, 2, 3, 4, 5, 6, 7, 8, 9};
- vec.erase(std::remove_if(vec.begin(),
- vec.end(),
- [](int num) { return num % 2; }),
- vec.end());
-
- auto print = [](int num) { std::cout << num << ' '; };
- std::for_each(vec.begin(), vec.end(), print);
-
- return 0;
-}
-```
-
-___
-
-## Lista przechwytująca (capture list) - przykład
-
-```cpp
-int main() {
- int number = 10;
- auto add10 = [number](int num) { return num + number; };
- std::cout << add10(20) << '\n'; // 30
-
- // auto multiplyByX = [](int num) { return num * number; };
- // compilation error: number not declared
-
- return 0;
-}
-```
-
-___
-
-## Lista przechwytująca (capture list)
-
-* Kwadratowy nawias `[]` określa, jakie parametry chcemy przechwycić do naszego wyrażenia. Możemy np. chcieć przechwycić jakąś zmienną, z którą będziemy chcieli porównywać każdy element kontenera
-* Wartości możemy przechwycić przez referencję `[&value]`
-* Możemy je także przechwycić przez kopię `[value]`
-* Możemy też mieszać obie możliwości `[&by_ref, by_copy, by_copy2]`
-* Wyrażenia lambda umożliwia także przechwycenie wszystkiego, co potrzebujemy:
- * poprzez kopię `[=]`
- * poprzez referencję `[&]`
-* O ile `[=]` jest bezpieczne, to `[&]` nie zawsze jest zalecane
-
-Pytanie: kiedy [&] może byc niebezpieczne?
-
-___
-
-## Generyczne lambdy
-
-* Od C++14 możemy pisać tzw. generyczne lambdy
-* Są to lambdy wielokrotnego użytku (dla różnych typów) i używamy w nich typu `auto` jako parametru
- * `[](const auto first, const auto& second, auto third) {}`
-* Pisanie generycznych lambd jest opłacalne, ponieważ łatwo można je wielokrotnie wykorzystać
-
-```cpp
-int multiply(int first, int second) {
- return first * second;
-}
-
-int main() {
- int number = 10;
- auto multiplyByX = [&number](auto num) { return multiply(num, number); };
- std::cout << multiplyByX(20) << '\n';
-
- return 0;
-}
-```
-
-___
-
-## Typ zwracany
-
-* Nie podajemy typu zwracanego, gdyż domyślnie wyrażenie lambda dedukuje ten typ poprzez dane zawarte w jej ciele `{}`
-* Domyślnie typ zwracany przez wyrażenie lambda jest dedukowany na podstawie wyrażeń `return`
-
- ```cpp
- [i{0}](const int el){ return el + i; }; // return type is int
- ```
-
-* Jeżeli chcemy narzucić konkretny typ zwracany robimy to poprzez `->`
-
- ```cpp
- [i{0}](const auto el) -> double { return el + i; };
- ```
-
-___
-
-## Q&A
-
-### Tym razem przed zadaniami, bo temat trudny :)
-
-___
-
-## Zadanie
-
-1. Utwórz funktor sprawdzający czy podana liczba typu `int` jest podzielna przez `6`
-2. Utwórz lambdę, która przyjmie 2 argumenty typu `int` oraz zwróci ich iloczyn
-3. Utwórz lambdę, która do podanego ciągu znaków doda cudzysłów. np.
- * `krowa` -> `"krowa"`
-4. Utwórz lambdę, która wypisze ciąg znaków `*`. Przy każdym zawołaniu funkcji powinniśmy dostać ciąg dłuższy o jedną `*`. Kolejno:
- * `*`
- * `**`
- * `***`
- * itd.
-
-___
-
-## Zadanie
-
-1. Utwórz `std::vector` i wypełnij go dowolnymi wartościami
-2. Utwórz lambdę, która przechwyci ten wektor, oraz wyświetli jego zawartość
-3. Utwórz lambdę, która w swoim argumencie przyjmie `int` i go wyświetli
-4. Wykorzystaj tą lambdę w algorytmie `std::for_each()` do wyświetlenia całego kontenera
diff --git a/module2/stl2.pdf b/module2/stl2.pdf
deleted file mode 100644
index f91b215bf..000000000
Binary files a/module2/stl2.pdf and /dev/null differ
diff --git a/module3/algorithms.md b/module3/algorithms.md
deleted file mode 100644
index 40baece9a..000000000
--- a/module3/algorithms.md
+++ /dev/null
@@ -1,221 +0,0 @@
-
-
-# Algorytmy
-
-___
-
-## Typy algorytmów
-
-Podaj, jakie znasz algorytmy:
-
-* Niemodyfikujące sekwencji?
-* Modyfikujące sekwencje?
-* Partycjonujące?
-* Sortujące?
-* Przeszukujące binarnie?
-* Operujące na kopcu (ang. Heap)?
-* Min/max?
-* Porównujące?
-* Dokonujące permutacji?
-* Numeryczne?
-
-___
-
-## Quiz
-
-Korzystając z [cppreference](https://en.cppreference.com/w/) odpowiedz na pytania:
-
-* Jaką złożoność ma std::sort()?
-* Jaki algorytm użyjesz dla połączenia 2 kontenerów naprzemiennie?
-* Jaki algorytm użyjesz, aby zsumować wszystkie elementy w std::vector?
-* Jaki algorytm użyjesz, aby pomnożyć 2 kontenery ze sobą?
-* Jaki algorytm użyjesz, aby usunąć liczby parzyste?
-* Jaki algorytm użyjesz, aby wypełnić strukturę wartościami od 0 do n?
-* Jaki algorytm użyjesz, aby zawsze na 1. miejscu (0 index) znajdował się największy element?
-* Jaki algorytm użyjesz, by wyszukać czy dana liczba znajduje się w posortowanym kontenerze?
-* Jaki algorytm użyjesz, aby podzielić kontener na 2 zakresy, zawierające mniejsze i większe wartości niż 10?
-* Jaki algorytm użyjesz, aby zmienić kolejność 2 elementów w kontenerze?
-
-___
-
-## std::rotate
-
-
-
-[Link do wideo](https://youtu.be/W2tWOdzgXHA?t=560)
-
-___
-
-## Zadanie 1
-
-Napisz funkcję, która przyjmie `std::vector&`, zmienną `int value`, oraz zmienną `int new_pos`. Funkcja powinna odnaleźć `value` w `std::vector` i jeżeli ją znajdzie wstawić ją na nowe miejsce `new_pos`, odpowiednio przesuwając resztę elementów by nie zaburzyć ich sekwencji. Następnie zwróć `true`, jeżeli proces się udał, lub `false`, jeżeli nie dało się zmienić kolejności (np. nie istnieje wartość).
-
-`bool ChangePos(std::vector& vec, int value, int new_pos)`
-
-
-___
-
-## Rozwiązanie 1
-
-```C++
-bool ChangePos(std::vector& vec, int value, int new_pos) {
- if (new_pos < 0 || new_pos >= vec.size()) {
- return false;
- }
-
- auto begin = vec.begin();
- auto end = vec.end();
- auto it = std::find(begin, end, value);
- if (it == end) {
- return false;
- }
-
- auto item_pos = std::distance(begin, it);
- if (item_pos > new_pos) {
- std::rotate(begin + new_pos, begin + item_pos, begin + item_pos + 1);
- } else {
- std::rotate(begin + item_pos, begin + item_pos + 1, begin + new_pos + 1);
- }
-
- return true;
-}
-```
-
-___
-
-## std::stable_partition
-
-
-
-[Przykład wideo](https://youtu.be/W2tWOdzgXHA?t=798)
-
-___
-
-## Zadanie 2
-
-Napisz funkcję, która przyjmie dwa `std::vector` oraz zmienną `int`. Pierwszy `std::vector` zawiera kontener na którym operujemy, drugi zawiera wartości jakie chcemy przenieść, a wartość `int` to numer indexu, na który chcemy przenieść wartości.
-
-`void ChangePos(std::vector& vec, const std::vector& values, int position)`
-
-
-___
-
-
-## Rozwiązanie 2
-
-```C++
-void ChangePos(std::vector& vec, const std::vector& values, int new_pos) {
- auto pred {[&](auto& el) {
- return (std::find(values.begin(), values.end(), el) == values.end());
- }};
-
- auto middle = vec.begin() + new_pos + values.size() - 1;
- std::stable_partition(vec.begin(), middle, pred);
- std::stable_partition(middle, vec.end(), [&](auto& el){ return !pred(el); });
-}
-
-void PrintVec(const std::vector& vec) {
- for (const auto el : vec) {
- std::cout << el << ' ';
- }
- std::cout << '\n';
-}
-
-int main() {
- std::vector vec{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
- PrintVec(vec);
- ChangePos(vec, {1, 3, 9}, 4);
- PrintVec(vec);
-
- return 0;
-}
-```
-
-___
-
-## Zadanie 3
-
-Napisz funkcję Gather, która przyjmie `std::vector` oraz spowoduje, że
-wszystkie wystąpienia `*` pojawią się w środku `std::vector`.
-
-Input: `std::vector vec {'*', '@', '*', '#', '@', '^', '*', '(', ')', '*'};`
-
-
-Output: `@ # @ * * * * ^ ( )`
-
-___
-
-
-## Rozwiązanie 3
-
-```C++
-void Gather(std::vector& vec) {
- auto pred {[&](auto& el) {
- return el != '*';
- }};
-
- auto middle = vec.begin() + vec.size() / 2;
- std::stable_partition(vec.begin(), middle, pred);
- std::stable_partition(middle, vec.end(), [&](auto& el){ return !pred(el); });
-}
-
-void PrintVec(const std::vector& vec) {
- for (const auto el : vec) {
- std::cout << el << ' ';
- }
- std::cout << '\n';
-}
-
-int main() {
- std::vector vec {'*', '$', '@', '*', '#', '@', '^', '*', '(', ')', '$', '*'};
- PrintVec(vec);
- Gather(vec);
- PrintVec(vec);
-
- return 0;
-}
-```
-
-___
-
-## Zadanie 4
-
-Napisz funkcję `GetVec(size_t count)`, która zwróci `std::vector` z wartościami od `10` do `10 + n`, inkrementując je co 1. Następnie napisz drugą funkcję `int Multiply(std::vector vec)`, która zwróci wartość równą iloczynowi każdego elementu `std::vector`.
-
-Input: `GetVec(7)`
-
-
-Output: `{10, 11, 12, 13, 14, 15, 16}`
-
-
-Input: `Multiply(vec)`
-
-
-Output: `57657600`
-
-
-___
-
-## Rozwiązanie 4
-
-```C++
-std::vector GetVec(size_t count) {
- std::vector vec(count);
- std::iota(begin(vec), end(vec), 10);
- return vec;
-}
-
-int Multiply(const std::vector& vec) {
- return std::accumulate(begin(vec), end(vec), 1, std::multiplies());
-}
-
-int main() {
- std::cout << Multiply(GetVec(7)) << '\n';
-
- return 0;
-}
-```
-
-___
-
-## Q&A
diff --git a/module3/computational_complexity.md b/module3/computational_complexity.md
deleted file mode 100644
index e32044238..000000000
--- a/module3/computational_complexity.md
+++ /dev/null
@@ -1,255 +0,0 @@
-
-
-# Złożoność obliczeniowa
-
-___
-
-## Złożoność obliczeniowa
-
-
-
-___
-
-## Definicja
-
-Złożoność obliczeniowa - oszacowanie czasu wykonania algorytmu. Mierzymy liczbę operacji, następnie szukamy funkcji opisującej liczbę operacji w zależności od danych wejściowych. Notacja `O` (dużego O) jest szacowaniem z góry. Ponieważ chcemy tylko przybliżyć wartość, pomijamy wszelkiego rodzaju stałe, które nie mają znaczenia dla dużych zbiorów danych wejściowych oznaczanych jako `n`. Zatem `Ο(2n + 5)`, `Ο(2n)` i `Ο(n)` są uznawane za złożoność obliczeniową `O(n)`.
-
-___
-
-## Złożoność `O(1)`
-
-Jest to tzw. złożoność stała, która jest niezależna od liczby danych wejściowych. Przy obliczeniu sumy ciągu arytmetycznego (kod poniżej), nie iterujemy po wszystkich elementach tablicy, zatem czas wykonania jest stały i niezależny od wielkości tablicy.
-
-```C++
-int sum(std::vector vec) {
- if (vec.empty()) {
- return 0;
- }
-
- return (vec.front() + vec.back()) * vec.size() / 2;
-}
-
-int main() {
- std::cout << sum({1, 2, 3, 4, 5, 6}) << std::endl;
-
- return 0;
-}
-```
-
-
-Output: `21`
-
-
-___
-
-
-## Złożoność `O(logn)`
-
-Wyobraźmy sobie, że szukamy numeru telefonu naszego kolegi Andrzeja. Bierzemy książkę telefoniczną i otwieramy ją na środku i patrzymy, że wypada nam osoba o imieniu Kornelia. Wiemy, że Andrzej jest w pierwszej połowie książki adresowej, gdyż litera K jest dużo dalej w alfabecie niż litera A. Zatem znów otwieramy na środku pierwszej połowy i patrzymy, że widnieje tam imię Dominik. Więc powtarzamy nasze szukanie natrafiając w kolejnej części na Bartka, aż w końcu trafiamy na Andrzeja. Takie przeszukiwanie, w którym za każdym razem odrzucamy połowę zakresu jest właśnie zapisywane w notacji `O(logn)`.
-
-```C++
-std::vector vec{1, 2, 3, 4, 5, 6};
-std::cout << std::boolalpha
- << std::binary_search(begin(vec), end(vec), 2) << std::endl
- << std::binary_search(begin(vec), end(vec), 0) << std::endl;
-```
-
-
-Output:
-
-
-```C++
-true
-false
-```
-
-
-___
-
-## Złożoność `O(n)`
-
-Wyobraźmy sobie teraz sytuację, że w książce adresowej szukamy numeru Żanety. Jednak nie będziemy teraz przeszukiwać binarnie, tylko sprawdzimy ile zajmie nam to, gdy będziemy szukać osoba po osobie. Więc zaczynamy od litery A i 4 dni później znajdujemy w końcu numer Żanety 🙂. Taka złożoność, gdzie sprawdzamy po kolei każdy element jest złożonością `O(n)`.
-
-
-___
-
-
-## Złożoność `O(n)` - przykład
-
-```C++
-constexpr size_t samples = 1'000'000'000;
-constexpr size_t search_num = 987'654'321;
-std::vector vec(samples);
-std::iota(begin(vec), end(vec), 0);
-
-auto start = std::chrono::high_resolution_clock::now();
-std::binary_search(begin(vec), end(vec), search_num);
-auto stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(logn): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-
-start = std::chrono::high_resolution_clock::now();
-for (const auto el : vec) {
- if (el == search_num) {
- break;
- }
-}
-stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(n): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-```
-
-Example Output:
-
-
-```C++
-O(logn): 0 ns
-O(n): 6'949'430'300 ns
-```
-
-
-___
-
-## Złożoność `O(nlog(n))`
-
-Jest to tzw. złożoność liniowo-logarytmiczna, której czas wykonania jest wprost proporcjonalny do iloczynu danych wejściowych i ich logarytmu.
-Wyobraźmy sobie teraz sytuację: próbujemy znaleźć numer Andrzeja w książce telefonicznej, ale nasz kolega zrobił nam psikus i pozamieniał strony. Teraz musimy ją posortować, zależy nam na czasie, więc chcemy to zrobić wydajnie. Dlatego wyrywamy kolejno strony z książki telefonicznej i wstawiamy je do nowej w zgodnej kolejności. Nie dość, że musimy zrobić taką operację dla `n` stron, to jeszcze musimy wstawiać je alfabetycznie, co zajmie nam `logn` czasu. Dlatego cały proces to `nlogn`.
-
-___
-
-## Złożoność `O(nlog(n))` - przykład
-
-```C++
-constexpr size_t samples = 1'000'000'000;
-std::vector vec(samples);
-std::iota(begin(vec), end(vec), 0);
-std::random_device rd;
-std::mt19937 gen(rd());
-
-//Here our colleague mixed up phone book.
-std::shuffle(begin(vec), end(vec), gen);
-auto start = std::chrono::high_resolution_clock::now();
-std::sort(begin(vec), end(vec));
-auto stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(nlogn): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-```
-
-
-Possible output: `O(nlogn): 499'694'684'900 ns`
-
-
-Previous slides output: `O(n): 6'949'430'300 ns`
-
-
-___
-
-## Złożoność `O(n^x)`
-
-Jest to tzw. złożoność wielomianowa. Jej szczególnym i bardzo częstym przypadkiem jest złożoność kwadratowa - `O(n^2)`, której czas wykonania jest wprost proporcjonalny do kwadratu ilości danych wejściowych. Wyobraźmy sobie teraz inną sytuację. Udało nam się znaleźć numer Andrzeja i postanawiamy również zrobić psikus naszemu koledze, ale chcemy odwdzięczyć się z nawiązką. Dlatego drukujemy nową książkę telefoniczną, ale do każdego numeru dodajemy cyferkę '8' na początku numeru. Teraz nasz kolega nie dość, że musi poprawić każdą stronę `n` to jeszcze sprawdzić i poprawić każdy numer na podstawie oryginalnej książki. Taka złożoność obliczeniowa to `O(n^2)`. Przykładem złożoności `O(n^2)` jest popularne sortowanie bąbelkowe.
-
-___
-
-
-## Złożoność `O(n^2)` - przykład
-
-```C++
-constexpr size_t samples = 1'000'000;
-std::vector vec(samples);
-std::iota(begin(vec), end(vec), 0);
-auto start = std::chrono::high_resolution_clock::now();
-BubleSort(vec);
-auto stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(n^2): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-
-constexpr size_t samples2 = 10'000'000; // size is 10 times higher.
-std::vector vec2(samples2);
-std::iota(begin(vec2), end(vec2), 0);
-start = std::chrono::high_resolution_clock::noaw();
-BubleSort(vec2);
-stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(n^2): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-
-constexpr size_t samples3 = 100'000'000; // size is 100 times higher.
-std::vector vec3(samples3);
-std::iota(begin(vec3), end(vec3), 0);
-start = std::chrono::high_resolution_clock::now();
-BubleSort(vec3);
-stop = std::chrono::high_resolution_clock::now();
-std::cout << "O(n^2): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
-```
-
-
-Possible output:
-
-```C++
-O(n^2): 9'974'800 ns
-O(n^2): 83'777'600 ns
-O(n^2): 810'269'600 ns
-```
-
-
-___
-
-## Złożoność `O(x^n)`
-
-Jest to tzw. złożoność wykładnicza. Czas wykonania rośnie wykładniczo względem ilości danych wejściowych. Wyobraźmy sobie sytuację, w której nie dość, że książka zawiera błędy, które wcześniej celowo wprowadziliśmy, ale ktoś postanowił ją wydrukować w olbrzymim nakładzie i teraz musimy poprawić wszystkie książki, w których już czas poprawiania błędów wynosił `n^2`. Dla takiej kombinacji mówimy, że złożoność jest `n^n`. Czyli rośnie wykładniczo wraz ze wzrostem liczby książek (próbek). Przykładem może być algorytm przeszukiwania grafu DFS (deep-first search), jeżeli danymi wejściowymi będzie macierz. Ponieważ za każdym razem musimy przejść cały rząd, aż znajdziemy interesujący nas element, więc wykonamy `n^n` kroków. Rzadko spotykane, więc jest formą ciekawostki 🙂
-
-___
-
-## Złożoność `O(n!)`
-
-Jest to złożoność typu silnia, czas wykonania rośnie z szybkością silni względem ilości danych wejściowych. Przykładem problemu jest problem komiwojażera z grupy algorytmów grafowych. Należy znaleźć najkrótszą trasę rozpoczynając od miasta A przechodzącą jednokrotnie przez wszystkie pozostałe miasta i wracając do miasta A. Od wielu lat analitycy głowią się, jak poprawić ten algorytm. Wciąż mamy pole do popisu 🙂. Nię będę tutaj wklejał kodu, ale zainteresowanych odsyłam do wyszukania sobie algorytmu komiwojażera.
-
-___
-
-## Złożoność `O(n * n!)`
-
-Jeden z najgorszych scenariuszy jaki możemy wykonać dla algorytmu. Wyobraźmy sobie sytuację, że nasz kolega postanowił pokazać nam, że nie warto z nim zadzierać i skarży się waszemu przełożonemu, że namieszaliście w książce telefonicznej. Teraz za karę musicie napisać program do robota układającego książki na półkach waszego kolegi w kolejności alfabetycznej. Jednak Wy postanawiacie zrobić mu kolejny (najgorszy) psikus, i piszecie robota, który będzie układał książki losowo, a następnie sprawdzał, czy może udało się je ułożyć poprawnie a jak nie, to ponownie je ściągał i znów układał na nowo. W ten sposób robot będzie układał książki kilka tygodni lub miesięcy, lecz w końcu mu się to uda 🙂
-
-W ten sposób napisaliśmy idealnie nieoptymalny algorytm sortowania o złożoności `O(n * n!)`. Przykładem takiego sortowania jest bogosort.
-
-___
-
-
-## Złożoność `O(n * n!)` Przykład
-
-```C++
-std::random_device rd;
-std::mt19937 generator(rd());
-
-void BogoSort(std::vector& vec) {
- while (!std::is_sorted(vec.begin(), vec.end())) {
- std::shuffle(vec.begin(), vec.end(), generator);
- }
-}
-
-int main() {
- constexpr size_t samples = 10; // Only 10 elements! Try it for 100 :)
- std::vector vec(samples);
- std::iota(begin(vec), end(vec), 0);
- std::shuffle(vec.begin(), vec.end(), generator);
- for (int i = 0; i < 5; ++i) {
- auto start = std::chrono::high_resolution_clock::now();
- BogoSort(vec);
- auto stop = std::chrono::high_resolution_clock::now();
- std::cout << "O(n * n!): " << std::chrono::duration_cast(stop - start).count() << " ns\n";
- }
-
- return 0;
-}
-```
-
-
-Possible output:
-
-
-```C++
-O(n * n!): 35'938'300 ns
-O(n * n!): 85'772'000 ns
-O(n * n!): 899'885'600 ns
-O(n * n!): 2'603'326'600 ns
-O(n * n!): 145'608'700 ns
-```
-
-
-___
-
-## Q&A
diff --git a/module3/homework.md b/module3/homework.md
deleted file mode 100644
index 6cd7831a2..000000000
--- a/module3/homework.md
+++ /dev/null
@@ -1,94 +0,0 @@
-
-
-# Zadanie domowe
-
-___
-
-## Post-work
-
-* innerProduct (10 XP)
-* advancedCalculator (25 XP)
-
-+3 XP za dostarczenie każdego zadania przed 20.09.2020 23:59
-
-___
-
-## Zadanie 1
-
-Wykorzystując `std::inner_product`, napisz program, który obliczy średnią arytmetyczną dwóch `std::vector`.
-
-Input: `{1, 2, 3, 4}` `{1, 2, 3, 4}`
-
-
-Output: `2.5`
-
-
-___
-
-## Zadanie 1 #2
-
-Następnie wykorzystując `std::inner_product`, napisz funkcję, która obliczy odległość między 2 punktami dla n wymiarów.
-
-Metrykę euklidesową w przestrzeni definiujemy:
-
-
-`$$ {\mathbb R}^{n} $$`
-
-
-`$$ d_e(\mathbf x, \mathbf y) = \sqrt{(y_1 - x_1)^2 + \dots + (y_n - x_n)^2} $$`
-
-
-
-
-Input: `{7, 4, 3}` `{17, 6, 2}`
-
-
-Output: `10.247`
-
-
-___
-
-## Zadanie 2
-
-Napisz program `advanced_calculator`. Program ten powinien posiadać pętle główną, która będzie przyjmować dane od użytkownika. Wszystkie komendy kalkulatora powinny być przechowywane w mapie, która ma klucz `char` w postaci znaku odwołującego się do komendy (np. `+` -> dodaj , `%` -> modulo), a jej wartością powinna być funkcja `std::function<>` będąca wraperem na wyrażenia lambda dokonujące określonej kalkulacji. Program powinien także zwracać odpowiedni error code, jeżeli użytkownik poda złe dane np. dzielenie przez 0 lub spróbuje dodać `ala + 5`.
-
-Input: `5 + 5` -> operacja dodawania dwóch liczb 5 i 5 -> output: `10`.
-
-Input: `5 ^ 2` -> operacje potęgowania -> output: `25`.
-
-Input `125 $ 3` -> operacja pierwiastka (sqrt za długie), pierwiastek sześcienny z 125 -> output: `5`.
-
-___
-
-### Funkcje kalkulatora
-
-* Dodawanie, mnożenie, dzielenie, odejmowanie, (+, *, /, -),
-* Modulo (%),
-* Obliczanie silni (!),
-* Podnoszenie liczby do potęgi (^),
-* Obliczanie pierwiastka ($).
-
-___
-
-### Error code
-
-* Ok,
-* BadCharacter -> Jeżeli użytkownik poda znak inny niż liczbę.
-* BadFormat -> Jeżeli użytkownik poda zły format komendy np. + 5 4, powinno być 4 + 5.
-* DivideBy0 -> dzielenie przez 0.
-* SqrtOfNegativeNumber -> pierwiastek z liczby ujemnej.
-* ModuleOfNonIntegerValue -> Próba obliczenia % na liczbie niecałkowitej.
-
-___
-
-### Funkcja, która będzie testowana
-
-* `ErrorCode process(std::string input, double* out)`
-* Funkcja ta powinna w pętli przyjmować kolejne dane od użytkownika oraz dokonywać odpowiedniej kalkulacji.
-* Jeżeli dane są poprawne, zwróci `ErrorCode:Ok`, a w zmiennej `out` zapisze dane.
-* Jeżeli wystąpi któryś z błędów, funkcja go zwróci, a w `out` nie zapisze nic.
diff --git a/module3/homework/advanced_calculator/CMakeLists.txt b/module3/homework/advanced_calculator/CMakeLists.txt
deleted file mode 100644
index 151a74d40..000000000
--- a/module3/homework/advanced_calculator/CMakeLists.txt
+++ /dev/null
@@ -1,45 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Download and unpack googletest at configure time
-configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-# Prevent overriding the parent project's compiler/linker
-# settings on Windows
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-# Add googletest directly to our build. This defines
-# the gtest and gtest_main targets.
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
- ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
- EXCLUDE_FROM_ALL)
-
-# The gtest/gtest_main targets carry header search path
-# dependencies automatically when using CMake 2.8.11 or
-# later. Otherwise we have to add them here ourselves.
-if (CMAKE_VERSION VERSION_LESS 2.8.11)
- include_directories("${gtest_SOURCE_DIR}/include")
-endif()
-
-project(advancedCalculator)
-enable_testing()
-
-add_executable(${PROJECT_NAME} main.cpp advancedCalculator.cpp)
-add_executable(${PROJECT_NAME}-ut test.cpp advancedCalculator.cpp)
-
-target_link_libraries(${PROJECT_NAME}-ut gtest_main)
-add_test(NAME ${PROJECT_NAME}_test COMMAND ${PROJECT_NAME}-ut)
diff --git a/module3/homework/advanced_calculator/CMakeLists.txt.in b/module3/homework/advanced_calculator/CMakeLists.txt.in
deleted file mode 100644
index c6247af53..000000000
--- a/module3/homework/advanced_calculator/CMakeLists.txt.in
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
- GIT_REPOSITORY https://github.com/google/googletest.git
- GIT_TAG master
- SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
- BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- TEST_COMMAND ""
-)
diff --git a/module3/homework/advanced_calculator/README.md b/module3/homework/advanced_calculator/README.md
deleted file mode 100644
index ed7f351d9..000000000
--- a/module3/homework/advanced_calculator/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# `advancedCalculator`
-
-Napisz program advanced_calculator. Program ten powinien posiadać pętle główną, która będzie przyjmować dane od użytkownika, np. dla 5 % 3 zwrócić wynik 2. Wszystkie komendy kalkulatora powinny być przechowywane w mapie. Która jako klucz char w postaci znaku odwołującego się do komendy (np. + -> dodaj , % -> modulo) a jej wartością powinna być funkcja std::function<> będąca wraperem na wyrażenia lambda dokonujące określonej kalkulacji. Program powinien także zwracać odpowiedni error code, jeżeli użytkownik poda złe dane. Np. dzielenie przez 0 lub spróbuje dodać ala + 5. Input: 5 + 5 -> operacja dodawania dwóch liczb 5 i 5 -> output: 10. Input: 5 ^ 2 -> operacje potęgowania -> output 25. Input 125 $ 3 -> operacja pierwiastka (sqrt za długie), pierwiastek sześcienny z 125 -> output: 5.
-
-___
-
-## Funkcje kalkulatora
-
-* Dodawanie, mnożenie, dzielenie, odejmowanie, (+, *, /, -),
-* Modulo (%),
-* Obliczanie silni (!),
-* Podnoszenie liczby do potęgi (^),
-* Obliczanie pierwiastka ($).
-
-___
-
-## Error code
-
-* Ok,
-* BadCharacter -> Jeżeli użytkownik poda znak inny niż liczbę.
-* BadFormat -> Jeżeli użytkownik poda zły format komendy np. + 5 4, powinno być 4 + 5.
-* DivideBy0 -> dzielenie przez 0.
-* SqrtOfNagativeNumber -> pierwiastek z liczby ujemnej.
-* ModuleOfNonIntegerValue -> Póba obliczenia % na liczbie niecałkowitej.
-
-___
-
-## Funkcja, która będzie testowana
-
-* ErrorCode process(std::string input, double* out)
-* Funkcja ta powinna w pętli przyjmować kolejne dane od użytkownika oraz dokonywać odpowiedniej kalkulacji.
-* Jeżeli dane są poprawne, zwróci 'ErrorCode:Ok', a w zmiennej out zapisze dane.
-* Jeżeli wystąpi któryś z błędów, funkcja go zwodzi a w out nie zapisze nic.
-
-___
-
-## Add proper files
-
-Please add proper files. In CMakeLists.txt you can see which files will be compiled.
-
-```cmake
-add_executable(${PROJECT_NAME} main.cpp advancedCalculator.cpp)
-add_executable(${PROJECT_NAME}-ut test.cpp advancedCalculator.cpp)
-```
-
-You need to remember about both cpp and hpp file. Don't forget the header guard in hpp!
diff --git a/module3/homework/advanced_calculator/test.cpp b/module3/homework/advanced_calculator/test.cpp
deleted file mode 100644
index a3e0d862a..000000000
--- a/module3/homework/advanced_calculator/test.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-#include
-#include
-#include
-
-#include "advancedCalculator.hpp"
-#include "gtest/gtest.h"
-
-bool cmp(double first, double second, double epsilon = 0.5) {
- return (fabs(first - second) < epsilon);
-}
-
-TEST(advancedCalculatorTest, ShouldAdd) {
- double result = 0;
-
- ASSERT_EQ(process("5+ 11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 16));
- ASSERT_EQ(process("43.21+11.54", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 54.75));
- ASSERT_EQ(process("-54.31 + 11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -43.31));
- ASSERT_EQ(process("28.43 +-810.43", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -782));
- ASSERT_EQ(process("-11.230 + -77.321", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -88.551));
-}
-
-TEST(advancedCalculatorTest, ShouldSubstract) {
- double result = 0;
-
- ASSERT_EQ(process("5- 11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -6));
- ASSERT_EQ(process("43.21 -11.54", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 31.67));
- ASSERT_EQ(process("-54.31-11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -65.31));
- ASSERT_EQ(process("28.43 - -810.43", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 838.86));
- ASSERT_EQ(process("-11.230 --77.321", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 66.091));
-}
-
-TEST(advancedCalculatorTest, ShouldMultiply) {
- double result = 0;
-
- ASSERT_EQ(process("5 * 11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 55));
- ASSERT_EQ(process("43.21 *11.54", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 498.643));
- ASSERT_EQ(process("-54.31* 11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -597.41));
- ASSERT_EQ(process("28.43 *-810.43", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -23040.5));
- ASSERT_EQ(process("-11.230*-77.321", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 868.315));
-}
-
-TEST(advancedCalculatorTest, ShouldDivide) {
- double result = 0;
-
- ASSERT_EQ(process("5 /11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 0.454545));
- ASSERT_EQ(process("43.21/ 11.54", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 3.74437));
- ASSERT_EQ(process("-54.31/11", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -4.93727));
- ASSERT_EQ(process("28.43 /-810.43", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -0.0350801));
- ASSERT_EQ(process("-11.230/-77.321", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 0.145239));
-}
-
-TEST(advancedCalculatorTest, ShouldPower) {
- double result = 0;
-
- ASSERT_EQ(process("5 ^2", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 25));
- ASSERT_EQ(process("4.5^ 3", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 91.125));
- ASSERT_EQ(process("-5 ^3", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -125));
- ASSERT_EQ(process("24.5^-2", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 0.00166597));
- ASSERT_EQ(process("-2 ^ -10", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 0.000976562));
-}
-
-TEST(advancedCalculatorTest, ShouldCalculateRoot) {
- double result = 0;
-
- ASSERT_EQ(process("225 $3", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 6.0822));
- ASSERT_EQ(process("1024$ 2", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 32.));
- ASSERT_EQ(process("1024$4", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 5.65685));
- ASSERT_EQ(process("13.71 $-4", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 5.19686e-1));
- ASSERT_EQ(process("2.5 $ 2.5", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 1.4427));
-}
-
-TEST(advancedCalculatorTest, ShouldModulo) {
- double result = 0;
-
- ASSERT_EQ(process("225 %1000", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 225.0));
- ASSERT_EQ(process("7% 3", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 1.0));
- ASSERT_EQ(process("1024%7", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 2.0));
- ASSERT_EQ(process("1378 % 91", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 13.0));
- ASSERT_EQ(process("-2091% 67", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -14.0));
- ASSERT_EQ(process("-2091 %-67", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -14.0));
- ASSERT_EQ(process("2091%-67", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 14.0));
-}
-
-TEST(advancedCalculatorTest, ShouldFactorial) {
- double result = 0;
-
- ASSERT_EQ(process("5!", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 120));
- ASSERT_EQ(process("6.7!", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 2769.83));
- ASSERT_EQ(process("3.435!", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, 10.63327));
- ASSERT_EQ(process("-13!", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -6227020800));
- ASSERT_EQ(process("-12.4!", &result), ErrorCode::OK);
- EXPECT_TRUE(cmp(result, -1324024774.02));
-}
-
-TEST(advancedCalculatorTest, ShouldReturnBadFormat) {
- double result = 0;
-
- ASSERT_EQ(process("5,1!", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("11,3 + 12.4", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("13.4 ++ 12.43", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("13.2 + 12.3 + 13.0", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("-12.4! + 2", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("11 / 13.4+", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("+8 - 32.1", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("12 ^% 3", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("+ 3 4", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("12.4.3 + 12.3", &result), ErrorCode::BadFormat);
- ASSERT_EQ(process("123.4 ! 345", &result), ErrorCode::BadFormat);
-}
-
-TEST(advancedCalculatorTest, ShouldReturnBadCharacter) {
- double result = 0;
-
- ASSERT_EQ(process("123 #- 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123 @- 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123 &- 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123 ? 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123 \\ 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("-123 [ -123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("-123 ] 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("-98 + 12.3 =", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123 -#- 4", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("qwert + 123", &result), ErrorCode::BadCharacter);
- ASSERT_EQ(process("123,4 ; 345", &result), ErrorCode::BadCharacter);
-}
-
-TEST(advancedCalculatorTest, ShouldReturnDivideBy0) {
- double result = 0;
-
- ASSERT_EQ(process("123 / 0", &result), ErrorCode::DivideBy0);
- ASSERT_EQ(process("123 / 0.0", &result), ErrorCode::DivideBy0);
- ASSERT_EQ(process("123 / -0", &result), ErrorCode::DivideBy0);
- ASSERT_EQ(process("123 / -0.0", &result), ErrorCode::DivideBy0);
- ASSERT_EQ(process("-123 / -0.0", &result), ErrorCode::DivideBy0);
- ASSERT_EQ(process("0.0 / 0", &result), ErrorCode::DivideBy0);
-}
-
-TEST(advancedCalculatorTest, ShouldReturnModuleOfNonIntegerValue) {
- double result = 0;
-
- ASSERT_EQ(process("123 % 0.1", &result), ErrorCode::ModuleOfNonIntegerValue);
- ASSERT_EQ(process("123 % 0.0005", &result), ErrorCode::ModuleOfNonIntegerValue);
- ASSERT_EQ(process("123.1 % 0", &result), ErrorCode::ModuleOfNonIntegerValue);
- ASSERT_EQ(process("123.1 % 0.1", &result), ErrorCode::ModuleOfNonIntegerValue);
-}
-
-TEST(advancedCalculatorTest, ShouldReturnRootOfNegativeNumber) {
- double result = 0;
-
- ASSERT_EQ(process("-123 $ -1", &result), ErrorCode::SqrtOfNegativeNumber);
- ASSERT_EQ(process("-123.4 $ -1", &result), ErrorCode::SqrtOfNegativeNumber);
- ASSERT_EQ(process("-123.2 $ 1", &result), ErrorCode::SqrtOfNegativeNumber);
- ASSERT_EQ(process("-123 $ 1", &result), ErrorCode::SqrtOfNegativeNumber);
-}
diff --git a/module3/homework/inner_product/CMakeLists.txt b/module3/homework/inner_product/CMakeLists.txt
deleted file mode 100644
index a083a5811..000000000
--- a/module3/homework/inner_product/CMakeLists.txt
+++ /dev/null
@@ -1,45 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Download and unpack googletest at configure time
-configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
- RESULT_VARIABLE result
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
- message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-# Prevent overriding the parent project's compiler/linker
-# settings on Windows
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-# Add googletest directly to our build. This defines
-# the gtest and gtest_main targets.
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
- ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
- EXCLUDE_FROM_ALL)
-
-# The gtest/gtest_main targets carry header search path
-# dependencies automatically when using CMake 2.8.11 or
-# later. Otherwise we have to add them here ourselves.
-if (CMAKE_VERSION VERSION_LESS 2.8.11)
- include_directories("${gtest_SOURCE_DIR}/include")
-endif()
-
-project(arithmeticAverage)
-enable_testing()
-
-add_executable(${PROJECT_NAME} main.cpp arithmeticAverage.cpp)
-add_executable(${PROJECT_NAME}-ut test.cpp arithmeticAverage.cpp)
-
-target_link_libraries(${PROJECT_NAME}-ut gtest_main)
-add_test(NAME ${PROJECT_NAME}_test COMMAND ${PROJECT_NAME}-ut)
diff --git a/module3/homework/inner_product/CMakeLists.txt.in b/module3/homework/inner_product/CMakeLists.txt.in
deleted file mode 100644
index c6247af53..000000000
--- a/module3/homework/inner_product/CMakeLists.txt.in
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
- GIT_REPOSITORY https://github.com/google/googletest.git
- GIT_TAG master
- SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
- BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- TEST_COMMAND ""
-)
diff --git a/module3/homework/inner_product/README.md b/module3/homework/inner_product/README.md
deleted file mode 100644
index decc90732..000000000
--- a/module3/homework/inner_product/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# `ArithmeticAverage() && Distance()`
-
-Implement a `ArithmeticAverage()` function, which takes `const std::vector& first, const std::vector& second` and calculate arithemetic average.
-
-Input: `{1, 2, 3, 4}` `{1, 2, 3, 4}`
-Output: `2.5`
-
-Implement a `Distance()` function, which takes `const std::vector& first, const std::vector& second` and calculate distance between 2 points.
-
-Input: `{7, 4, 3}` `{17, 6, 2}`
-Output: `10.247`
-
-## Add proper files
-
-Please add proper files. In CMakeLists.txt you can see which files will be compiled.
-
-```cmake
-add_executable(${PROJECT_NAME} main.cpp arithmeticAverage.cpp)
-add_executable(${PROJECT_NAME}-ut test.cpp arithmeticAverage.cpp)
-```
-
-You need to remember about both cpp and hpp file. Don't forget the header guard in hpp!
diff --git a/module3/homework/inner_product/test.cpp b/module3/homework/inner_product/test.cpp
deleted file mode 100644
index fc1a574ec..000000000
--- a/module3/homework/inner_product/test.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include
-
-#include "arithmeticAverage.hpp"
-#include "gtest/gtest.h"
-
-bool cmp(double first, double second, double epsilon = 0.5) {
- return (fabs(first - second) < epsilon);
-}
-
-TEST(arithmeticAverageTest, ShouldCalculateArithmeticAverage) {
- std::vector first{-5, 4, 2, -5, 2, 4, 6, 7};
- std::vector second{3, 5, -2, 6, 7, -3, 6, 9};
- EXPECT_TRUE(cmp(ArithmeticAverage(first, second), 2.875));
- // Write more test case
-}
-
-TEST(arithmeticAverageTest, ShouldCalculateDistance) {
- std::vector first{7, 4, 3};
- std::vector second{17, 6, 2};
- EXPECT_TRUE(cmp(Distance(first, second), 10.247));
- // Write more test case
-}
\ No newline at end of file
diff --git a/module3/img/complexity.jpg b/module3/img/complexity.jpg
deleted file mode 100644
index f532a6a01..000000000
Binary files a/module3/img/complexity.jpg and /dev/null differ
diff --git a/module3/img/iterator.png b/module3/img/iterator.png
deleted file mode 100644
index 4caa9a389..000000000
Binary files a/module3/img/iterator.png and /dev/null differ
diff --git a/module3/img/iterator_categories.gif b/module3/img/iterator_categories.gif
deleted file mode 100644
index 041512818..000000000
Binary files a/module3/img/iterator_categories.gif and /dev/null differ
diff --git a/module3/img/rev_iterator.gif b/module3/img/rev_iterator.gif
deleted file mode 100644
index c346511ee..000000000
Binary files a/module3/img/rev_iterator.gif and /dev/null differ
diff --git a/module3/index.html b/module3/index.html
deleted file mode 100644
index c2a380580..000000000
--- a/module3/index.html
+++ /dev/null
@@ -1,129 +0,0 @@
-
-
-
-
-
-
- STL - złożoność obliczeniowa, iteratory i algorytmy - Coders School
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/module3/iterators.md b/module3/iterators.md
deleted file mode 100644
index 2aa915bdc..000000000
--- a/module3/iterators.md
+++ /dev/null
@@ -1,204 +0,0 @@
-
-
-# Iteratory
-
-___
-
-## Krótka powtórka #1
-
-Iterator jest to obiekt, który wskazuje na dany element w kontenerze. W zależności od typu możemy na nim wykonywać różne operacje, np: inkrementować go `operator++`, dekrementować `operator--` lub wykonywać operacje typu `it += 6`. W celu odwołania się do wskazywanego elementu przez iterator używamy `operator*` czyli dereferencji (jak na zwykłych wskaźnikach).
-
-___
-
-## Krótka powtórka #2
-
-Każdy kontener ma 2 końce. Na jeden z nich wskazuje `begin()`, a na drugi `end()`.
-
-
-
-___
-
-## Krótka powtórka #3
-
-Dla niektórych kontenerów możemy także pobrać odwrotny iterator (ang. reverse iterator) umożliwiający nam przejście wstecz przez zakres.
-
-
-
-___
-
-## Krótka powtórka #4
-
-Jeżeli nie chcemy modyfikować danych wskazywanych przez iterator zastosujemy opcję z przedrostkiem `c` pochodzącym od słowa `constant`.
-
-* cbegin()
-* cend()
-* crbegin()
-* crend()
-
-___
-
-## Hierarchia iteratorów
-
-
-
-Pytanie, co powinno się znaleźć w miejscu `forward_iterator`?
-
-
-* std::forward_list
-* std::unordered_set
-* std::unordered_map
-
-___
-
-### "Najbiedniejsze" iteratory, czyli input i output
-
-Input iterator: pochodzi np. ze strumienia `std::istream`, czyli znanego nam `std::cin`. Raz wczytane dane znikają, nie możemy ich ponownie odczytać. Mamy możliwość tylko jednorazowego przejścia przez dane. Innym słowem jak tylko odczytamy jakąś daną nasz operator od razu jest inkrementowany.
-
-```C++
-int a;
-int b;
-std::cin >> a >> b;
-```
-
-
-Output iterator: pochodzi np. ze strumienia `std::ostream`, czyli znanego nam `std::cout`. Raz wypisane dane znikają, nie możemy ich ponownie wyświetlić, musimy ponownie podać dane.
-
-
-```C++
-int a;
-int b;
-std::cin >> a >> b;
-std::cout << a << ' ' << b;
-```
-
-___
-
-### Pytanie
-
-Jakie mamy dostępne operatory dla input iterator, a jakie dla output iterator?
-
-Input iterator:
-
-
-* operator++
-* operator*
-* operator->
-* operator==
-* operator!=
-
-Output iterator:
-
-
-* operator++
-* operator*
-
-___
-
-### Forward iterator
-
-Jest to iterator, który umożliwia nam wielokrotne przejście danego zakresu w jedną stronę (w przód).
-
-```C++
-std::forward_list list {1, 2, 3, 4, 5};
-for (auto it = list.begin() ; it != list.end() ; ++it) {
- std::cout << *it << '\n';
-}
-```
-
-
-Output: `1 2 3 4 5`
-
-
-Pytanie: Jakie mamy dostępne operatory dla tego iteratora?
-
-
-* operator++
-* operator*
-* operator->
-* operator==
-* operator!=
-
-___
-
-
-### Bidirectional iterator
-
-Jest to iterator, który umożliwia nam wielokrotne przejście danego zakresu w obie strony (w przód i tył).
-
-```C++
-std::list list{1, 2, 3, 4, 5};
-for (auto it = list.begin(); it != list.end(); ++it) {
- std::cout << *it << ' ';
-}
-auto last = std::prev(list.end());
-for (auto it = last; it != std::prev(list.begin()); --it) {
- std::cout << *it << ' ';
-}
-```
-
-
-Output: `1 2 3 4 5 5 4 3 2 1`
-
-
-Pytanie: Jakie mamy dostępne operatory dla tego iteratora?
-
-
-* operator++
-* operator*
-* operator->
-* operator==
-* operator!=
-* operator--
-
-___
-
-### Random Access iterator
-
-Jest to iterator, który umożliwia nam wielokrotne przejście danego zakresu w obie strony (w przód i tył), a także dostęp do dowolnego obiektu.
-
-```C++
-std::vec vec{1, 2, 3, 4, 5};
-for (auto it = vec.begin(); it != vec.end(); ++it) {
- std::cout << *it << ' ';
-}
-auto last = std::prev(vec.end());
-for (auto it = last; it != std::prev(vec.begin()); --it) {
- std::cout << *it << ' ';
-}
-std::cout << vec[3];
-```
-
-
-Output: `1 2 3 4 5 5 4 3 2 1 3`
-
-
-___
-
-### Random Access iterator
-
-Pytanie: Jakie mamy dostępne operatory dla tego iteratora?
-
-
-* operator++
-* operator*
-* operator->
-* operator==
-* operator!=
-* operator--
-* operator<
-* operator<=
-* operator>
-* operator>=
-* operator+
-* operator-
-* operator[]
-
-___
-
-### Ciekawostka
-
-W C++ 17 wprowadzono jeszcze typ: `ContiguousIterator`. Zawiera on wszystkie cechy Random Access iterator oraz zapewnia, że wszystkie dane są ułożone w jednym miejscu w pamięci.
-
-___
-
-## Q&A
diff --git a/module3/stl3.pdf b/module3/stl3.pdf
deleted file mode 100644
index 21d0e07c1..000000000
Binary files a/module3/stl3.pdf and /dev/null differ
diff --git a/module4/associative_containers.md b/module4/associative_containers.md
deleted file mode 100644
index 31286a7a3..000000000
--- a/module4/associative_containers.md
+++ /dev/null
@@ -1,479 +0,0 @@
-
-
-# Kontenery asocjacyjne
-
-___
-
-## Posortowane
-
-* set
-* multiset
-* map
-* multimap
-
-___
-
-## Nieuporządkowane
-
-* unordered_set
-* unordered_multiset
-* unordered_map
-* unordered_multimap
-
-___
-
-## Quiz
-
-Do czego możesz użyć:
-
-* set?
-* multiset?
-* map?
-* multimap?
-* unordered_set?
-* unordered_multiset?
-* unordered_map?
-* unordered_multimap?
-
-___
-
-## Notacja dużego `O`
-
-
-
-___
-
-## Cechy `std::map` i `std::multimap` #1
-
-* Forma drzewa binarnego (red-black tree)
-* Nie jest cache friendly
-* Pozwala przechowywać parę klucz-wartość (key-value)
-* Multimapa może mieć wiele takich samych kluczy
-* Mapa ma unikatowe klucze
-* Alternatywą dla multimapy jest std::map<key, std::vector<value>>
-
-___
-
-
-## Cechy `std::map` i `std::multimap` #2
-
-Ponieważ jest ona zaimplementowana przeważnie jako red-black tree (GNU standard C++ library) to czas wstawiania, usuwania i dodawania elementu to `O(log(n)`).
-
-Zalety:
-
-
-* Szybkie wyszukiwanie elementów (kontenery sekwencyjnie O(n)),
-* Względnie szybki czas ich dodawania i usuwania np. std::vector<T> dodaje elementy w środku w czasie O(n), ale std::list<T> (jeżeli mamy podany iterator) w czasie O(1). Stąd mapa jest względnie szybka zarówno w dodawaniu jak i usuwaniu.
-* Idealna, gdy często poszukujemy danych, a rzadziej je dodajemy lub usuwamy.
-
-Jeżeli będziemy jej używać jako zwykłego kontenera, to stracimy na wydajności. Mapę należy stosować wtedy, kiedy faktycznie chcemy posiadać pary klucz-wartość i często je wyszukiwać. W innym przypadku możemy użyć `std::vector>` lub innego kontenera.
-
-
-___
-
-## Operacje na `std::map` i `std::multimap`
-
-* dodawanie elementu: insert(), emplace(), emplace_hint(). Dodatkowo mapa posiada: insert_or_assign(), try_emplace() oraz operator[] (dodająco modyfikujący)
-* modyfikowanie/dostęp do elementu: at(), operator[] (Multimapa nie posiada takich opcji)
-* pierwszy/ostatni element: Brak
-* rozmiar/czy kontener jest pusty: size(), empty()
-* wyczyszczenie nieużywanej pamięci: Brak
-* iterator początku/końca: begin(), end()
-
-
-___
-
-## Operacje na `std::map` i `std::multimap` #2
-
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: clear()
-* przygotowanie elementu do usunięcia: Brak
-* wymazanie elementów z pamięci: erase()
-* podmiana całego kontenera: swap()
-* zliczenie elementów pasujących do danego klucza: count() (dla mapy to 0 albo 1, dla multimapy od 0 do n)
-* odnalezienie elementu o podanym kluczu: find()
-
-___
-
-## Przykład użycia `emplace_hint`
-
-```cpp
-int main() {
- std::map map;
-
- auto it = map.begin();
- map.emplace_hint(it, 10, "Ten");
-
- std::cout << map[10] << '\n';
-}
-```
-
-
-Output:
-`Ten`
-
-
-Podpowiadamy mapie miejsce, gdzie powinna wstawić element, dzięki temu taka operacja będzie miała złożoność `O(1)`. Jeżeli jednak źle podpowiemy, to czas wstawienia będzie `O(log(n))`. Raczej rzadko stosowane 🙂
-
-
-___
-
-### Przykład użycia `insert_or_assign`
-
-```C++
-int main() {
- std::map map;
-
- auto it = map.begin();
- map.insert_or_assign(it, 10, "Ten");
- std::cout << map[10] << '\n';
- map.insert_or_assign(it, 10, "Dziesiec");
- std::cout << map[10] << '\n';
- map[10] = "Cent";
- std::cout << map[10] << '\n';
-}
-```
-
-
-Output:
-
-
-```C++
-Ten
-Dziesiec
-Cent
-```
-
-
-___
-
-### Przykład użycia `count`
-
-```C++
-int main() {
- std::multimap map;
-
- map.insert({5, "Five"});
- map.insert({5, "Funf"});
- map.insert({5, "Piec"});
- map.insert({5, "Cinq"});
- std::cout << map.count(5) << '\n';
-}
-```
-
-
-Output: `4`
-
-
-___
-
-### Przykład użycia `find`
-
-```C++
-int main() {
- std::multimap map;
-
- map.insert({5, "Five"});
- map.insert({5, "Funf"});
- map.insert({5, "Piec"});
- map.insert({5, "Cinq"});
- auto it = map.find(5);
-
- for (; it != map.end() ; ++it) {
- std::cout << it->first << " | " << it->second << '\n';
- }
-}
-```
-
-
-Output:
-
-
-```C++
-5 | Five
-5 | Funf
-5 | Piec
-5 | Cinq
-```
-
-
-___
-
-## Zadanie 1
-
-* Stwórz multimapę i wypełnij ją podanymi wartościami
-
-```C++
-map.insert({5, "Ala"});
-map.insert({5, "Ma"});
-map.insert({5, "Kota"});
-map.insert({5, "A"});
-map.insert({5, "Kot"});
-map.insert({5, "Ma"});
-map.insert({5, "Ale"});
-```
-
-
-* Napisz funkcję, która wyświetli słowa w mapie o liczbie znaków równej 3.
-
-___
-
-## Rozwiązanie
-
-```C++
-std::vector> result;
-std::copy_if(it,
- end(map),
- std::back_inserter(result),
- [](const auto& pair) { return pair.second.size() == 3; });
-std::for_each(begin(result),
- end(result),
- [](const auto& pair) { std::cout << pair.second << '\n'; });
-```
-
-
-___
-
-## Cechy `std::set` i `std::multiset` #1
-
-* Forma drzewa binarnego (red-black tree)
-* Nie jest cache friendly
-* Pozwala przechowywać wartości w uporządkowanej kolejności
-* Multiset może mieć wiele takich samych wartości
-* Set ma unikatowe wartości
-* Alternatywą dla multiset jest posortowany std::vector<T>
-
-___
-
-
-## Cechy `std::set` i `std::multiset` #2
-
-Ponieważ jest on zaimplementowany przeważnie jako red-black tree (GNU standard C++ library) to czas wstawiania, usuwania i dodawania elementu to `O(log(n)`).
-
-Zalety:
-
-
-* Szybkie wyszukiwanie elementów (kontenery sekwencyjnie O(n)),
-* Względnie szybki czas ich dodawania i usuwania np. std::vector<T> dodaje elementy w środku w czasie O(n), ale std::list<T> (jeżeli mamy podany iterator) w czasie O(1). Stąd set jest względnie szybki zarówno w dodawaniu jak i usuwaniu.
-* Idealny, gdy chcemy zawsze posiadać posortowane wartości.
-
-Jeżeli nie zależy nam, aby kontener był zawsze posortowany, lecz jedynie w specyficznych momentach, to może lepiej nam użyć `std::vector` i sortować go, gdy przyjdzie taka potrzeba. Jeżeli też zależy nam tylko czasami na unikatowych wartościach, to możemy wtedy użyć `std::unique()`.
-
-
-___
-
-## Operacje na `std::set` i `std::multiset`
-
-* dodawanie elementu: insert(), emplace(), emplace_hint()
-* modyfikowanie/dostęp do elementu: Brak
-* pierwszy/ostatni element: Brak
-* rozmiar/czy kontener jest pusty: size(), empty()
-* wyczyszczenie nieużywanej pamięci: Brak
-* iterator początku/końca: begin(), end()
-* odwrócony (ang. reverse) iterator: rbegin(), rend()
-
-
-___
-
-## Operacje na `std::set` i `std::multiset` #2
-
-* stały iterator: cbegin(), cend(), crbegin(), crend()
-* wyczyszczenie kontenera: clear()
-* przygotowanie elementu do usunięcia: Brak
-* wymazanie elementów z pamięci: erase()
-* podmiana całego kontenera: swap()
-* zliczenie elementów pasujących do danego klucza: count() (dla set to 0 albo 1, dla multiset od 0 do n)
-* odnalezienie elementu o podanym kluczu: find()
-
-___
-
-## Przykład użycia `std::set`
-
-```C++
-std::set set {5, 4, 3, 2, 1, 0, 6, 8, 7};
-for (const auto el : set) {
- std::cout << el << ' ';
-}
-std::cout << '\n';
-
-std::set> set2 {5, 4, 3, 2, 1, 0, 6, 8, 7};
-for (const auto el : set2) {
- std::cout << el << ' ';
-}
-std::cout << '\n';
-```
-
-
-Output:
-
-
-```C++
-0 1 2 3 4 5 6 7 8
-8 7 6 5 4 3 2 1 0
-```
-
-
-___
-
-## Przykład użycia `std::multiset`
-
-```C++
-std::multiset set {5, 4, 3, 2, 1, 0, 6, 8, 7, 1, 2, 3, 4, 5, 6};
-for (const auto el : set) {
- std::cout << el << ' ';
-}
-std::cout << '\n';
-
-std::multiset
-
-
-```cpp
-255 255 0 255 0 255 // 0xFF 0xFF 0x00 0xFF 0x00 0xFF
-128 0 128 0 128 0 // 0x80 0x00 0x80 0x00 0x80 0x00
-64 64 64 64 64 64 // 0x40 0x40 0x40 0x40 0x40 0x40
-255 192 128 64 0 0 // 0xFF 0xB0 0x80 0x40 0x00 0x00
-```
-
-Aby otrzymać z tego plik w formacie PGM wystarczy tylko dodać mu odpowiedni nagłówek.
-
-___
-
-
-## `compressGrayscale()` - opis
-
-Napisz funkcję `compressGrayscale()`.
-Powinna ona przyjąć jeden argument typu `std::array
-
-Jeśli chcesz zrobić to zadanie (nie ma za nie dodatkowych punktów, ale będzie dodatkowe osiągnięcie na platformie) to zaimplementuj zakomentowaną w main.cpp funkcję `printMap()`. Jej implementację wrzuć do pliku z funkcjami `compressGrayscale()` i `decompressGrayscale()`. Jej prawidłowa implementacja i odpalenie funkcji `main()` poprzez wywołanie `./grayscaleImages` powinna wyświetlić ninję na ekranie :)
-
-```text
- $**********$
- 488888888883
- +@DDDDDDDDDD@/
- !]=.9W]]]]]]]]]]]]]L
- 5GOQ������������W4
- !K[k�������������Y"
- !]=Z����=������p]�d"
- Wq /+e��������������d" vX
- UpH' #\��������������Y" 9�k
- )@�P #,333333333337;B1" a�Q6
- Nil #,333333333337;B1" yyk*
- -]g**,333333333337;B1=Z�sB
- ,>M6,333333333337;B1_�L+
- 
-
-
-___
-
-## Cechy `std::array
-
- 
-
-___
-
-## Cechy `std::deque
-___
-
-## Praca domowa
-
-### Post-work
-
-Ta praca domowa może już stanowić pewne wyzwanie. Działaj dużo z dokumentacją cppreference.
-
-* Poczytaj o formacie grafiki PGM - [Wiki ENG](https://en.wikipedia.org/wiki/Netpbm#File_formats). Ta wiedza może się przydać w zadaniu 3 i 4.
-* Zadanie 1 - `removeVowels()` (5 punktów)
-* Zadanie 2 - `lengthSort()` (6 punktów)
-* Zadanie 3a - `compressGrayscale()` (7 punktów)
-* Zadanie 3b - `decompressGrayscale()` (7 punktów)
-
-#### Bonusy
-
-* 2 punkty za każde zadanie dostarczone przed 14.06.2020 (niedziela) do 23:59
-* 3 punkty za pracę w grupie dla każdej osoby z grupy. Zalecamy grupy 3 osobowe.
-
-#### [Zadania w repo](https://github.com/coders-school/stl/tree/master/module1/homework)
-
-___
-
-### Pre-work
-
-* Znajdź na [cppreference.com](https://en.cppreference.com/w/) opisy algorytmów i zapoznaj się z nimi. Popatrz też na przykłady użycia.
-* Poczytaj o złożoności obliczeniowej np. na [Samouczku programisty](https://www.samouczekprogramisty.pl/podstawy-zlozonosci-obliczeniowej/)
-* Obejrzyj i zapamiętaj jaka jest [złożoność operacji na poszczególnych kontenerach STL](https://github.com/gibsjose/cpp-cheat-sheet/blob/master/Data%20Structures%20and%20Algorithms.md)
-
-___
-
-## Zadanie 1 - `removeVowels()`
-
-Napisz funkcję `removeVowels()`, która przyjmie `std::vector
-
-```cpp
-255 255 0 255 0 255 // 0xFF 0xFF 0x00 0xFF 0x00 0xFF
-128 0 128 0 128 0 // 0x80 0x00 0x80 0x00 0x80 0x00
-64 64 64 64 64 64 // 0x40 0x40 0x40 0x40 0x40 0x40
-255 192 128 64 0 0 // 0xFF 0xB0 0x80 0x40 0x00 0x00
-```
-
-Aby otrzymać z tego plik w formacie PGM wystarczy tylko dodać mu odpowiedni nagłówek.
-
-___
-
-
-## Zadanie 3a - `compressGrayscale()` - opis
-
-Napisz funkcję `compressGrayscale()`.
-Powinna ona przyjąć jeden argument typu `std::array
-
-___
-
-Chętni mogą także zrefaktoryzować testy, tak by funkcja sprawdzająca mapę była generyczna (adekwatnie do funkcji `expectBitmap()`.
-Po refaktoringu funkcji sprawdzającej, postarajcie sie dopisać także przypadki dla 1/16, 1/32 i 1/64 mapy.
diff --git a/module1/presentation_list.md b/module1/presentation_list.md
deleted file mode 100644
index 99495d2bb..000000000
--- a/module1/presentation_list.md
+++ /dev/null
@@ -1,89 +0,0 @@
-
-
-# `std::list
-
-___
-
-## Definicja
-
-Złożoność obliczeniowa - oszacowanie czasu wykonania algorytmu. Mierzymy liczbę operacji, następnie szukamy funkcji opisującej liczbę operacji w zależności od danych wejściowych. Notacja `O` (dużego O) jest szacowaniem z góry. Ponieważ chcemy tylko przybliżyć wartość, pomijamy wszelkiego rodzaju stałe, które nie mają znaczenia dla dużych zbiorów danych wejściowych oznaczanych jako `n`. Zatem `Ο(2n + 5)`, `Ο(2n)` i `Ο(n)` są uznawane za złożoność obliczeniową `O(n)`.
-
-___
-
-## Złożoność `O(1)`
-
-Jest to tzw. złożoność stała, która jest niezależna od liczby danych wejściowych. Przy obliczeniu sumy ciągu arytmetycznego (kod poniżej), nie iterujemy po wszystkich elementach tablicy, zatem czas wykonania jest stały i niezależny od wielkości tablicy.
-
-```C++
-int sum(std::vector
-
-___
-
-## Cechy `std::map