std::vector<int> vec = {5, 2, 8, 1, 9};
std::deque<int> deq = {5, 2, 8, 1, 9};
std::list<int> lst = {5, 2, 8, 1, 9};

std::sort(vec.begin(), vec.end());    // O(n log n)
std::sort(deq.begin(), deq.end());    // O(n log n)
lst.sort();                           // O(n log n), власний метод list

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // Явний ітератор
    std::vector<int>::iterator it = numbers.begin();
    
    while (it != numbers.end())
    {
        std::cout << *it << ' ';  // Розіменування
        ++it;                      // Інкремент
    }
    std::cout << '\n';
    
    return 0;
}

for (int x : numbers)  // Компілятор розгортає у цикл з ітераторами
{
    std::cout << x << ' ';
}

{
    auto&& __range = numbers;
    auto __begin = __range.begin();
    auto __end = __range.end();
    
    for (; __begin != __end; ++__begin)
    {
        int x = *__begin;
        std::cout << x << ' ';
    }
}

std::vector<int> numbers = {10, 20, 30, 40, 50};

// Обхід у зворотному порядку
for (auto it = numbers.rbegin(); it != numbers.rend(); ++it)
{
    std::cout << *it << ' ';  // Виведе: 50 40 30 20 10
}

std::vector<int> numbers = {10, 20, 30};

// Константний ітератор
std::vector<int>::const_iterator it = numbers.cbegin();

std::cout << *it << '\n';  // ✅ Читання дозволене: 10

// *it = 100;  // ❌ ПОМИЛКА компіляції: присвоєння через const_iterator

std::vector<int> numbers = {10, 20, 30, 40, 50};

auto it = numbers.begin();

// Арифметика ітераторів
it = it + 2;         // Переміщення на 2 позиції вперед → вказує на 30
std::cout << *it << '\n';  // 30

it += 3;             // Переміщення ще на 3 позиції → вказує на 50 (останній)
std::cout << *it << '\n';  // 50

// Доступ за індексом
std::cout << it[-2] << '\n';  // Доступ на 2 позиції назад → 30

// Різниця ітераторів
auto distance = numbers.end() - numbers.begin();
std::cout << "Розмір: " << distance << '\n';  // 5

// Порівняння ітераторів
if (it > numbers.begin())
{
    std::cout << "it вказує на елемент після початку\n";
}

std::list<int> numbers = {10, 20, 30, 40, 50};

auto it = numbers.begin();

++it;  // Переміщення до 20
++it;  // Переміщення до 30

std::cout << *it << '\n';  // 30

--it;  // Переміщення назад до 20
std::cout << *it << '\n';  // 20

// it = it + 2;  // ❌ ПОМИЛКА: list не підтримує арифметику

auto it = numbers.begin();
std::advance(it, 3);  // Переміститься на 3 позиції (викличе ++it тричі)
std::cout << *it << '\n';  // 40

template <typename Iterator>
ReturnType algorithm(Iterator begin, Iterator end);

template <typename Iterator, typename T>
Iterator find(Iterator begin, Iterator end, const T& value);

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    auto it = std::find(numbers.begin(), numbers.end(), 30);
    
    if (it != numbers.end())
    {
        std::cout << "Знайдено: " << *it << '\n';
        std::cout << "Індекс: " << std::distance(numbers.begin(), it) << '\n';
    }
    else
    {
        std::cout << "Не знайдено\n";
    }
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

// Предикат: чи число парне?
bool isEven(int n)
{
    return n % 2 == 0;
}

int main()
{
    std::vector<int> numbers = {11, 13, 20, 25, 30};
    
    // Знайти перше парне число
    auto it = std::find_if(numbers.begin(), numbers.end(), isEven);
    
    if (it != numbers.end())
    {
        std::cout << "Перше парне: " << *it << '\n';  // 20
    }
    
    return 0;
}

auto it = std::find_if(numbers.begin(), numbers.end(), 
                       [](int n) { return n % 2 == 0; });

std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5};

// Підрахунок кількості елементів зі значенням 2
int count = std::count(numbers.begin(), numbers.end(), 2);
std::cout << "Кількість двійок: " << count << '\n';  // 3

// Підрахунок парних чисел
int evenCount = std::count_if(numbers.begin(), numbers.end(),
                               [](int n) { return n % 2 == 0; });
std::cout << "Парних чисел: " << evenCount << '\n';  // 4

template <typename InputIt, typename OutputIt, typename UnaryOp>
OutputIt transform(InputIt begin, InputIt end, OutputIt dest, UnaryOp op);

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> doubled(numbers.size());  // Резервуємо місце для результату
    
    // Подвоїти кожен елемент
    std::transform(numbers.begin(), numbers.end(), 
                   doubled.begin(),
                   [](int n) { return n * 2; });
    
    std::cout << "Подвоєні: ";
    for (int x : doubled)
    {
        std::cout << x << ' ';  // 2 4 6 8 10
    }
    std::cout << '\n';
    
    return 0;
}

// Подвоїти елементи у тому ж векторі
std::transform(numbers.begin(), numbers.end(),
               numbers.begin(),  // Записуємо результат у той же контейнер
               [](int n) { return n * 2; });

std::vector<std::string> words = {"hello", "world", "cpp"};

std::transform(words.begin(), words.end(), words.begin(),
               [](std::string s) {
                   std::transform(s.begin(), s.end(), s.begin(), ::toupper);
                   return s;
               });

// Результат: {"HELLO", "WORLD", "CPP"}

std::vector<int> numbers = {1, 2, 3, 4, 5};

// Вивести кожен елемент
std::for_each(numbers.begin(), numbers.end(),
              [](int n) { std::cout << n << ' '; });

std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5};

// Замінити всі 2 на 99
std::replace(numbers.begin(), numbers.end(), 2, 99);
// Результат: {1, 99, 3, 99, 4, 99, 5}

// Замінити всі парні числа на 0
std::replace_if(numbers.begin(), numbers.end(),
                [](int n) { return n % 2 == 0; },
                0);
// Результат: {1, 0, 3, 0, 0, 0, 5}

std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5};

// ❌ НЕПРАВИЛЬНО: видалення під час ітерації
for (auto it = numbers.begin(); it != numbers.end(); ++it)
{
    if (*it == 2)
    {
        numbers.erase(it);  // ❌ Інвалідує ітератор!
    }
}

for (auto it = numbers.begin(); it != numbers.end(); )
{
    if (*it == 2)
    {
        it = numbers.erase(it);  // erase() повертає новий дійсний ітератор
    }
    else
    {
        ++it;
    }
}

Початковий вектор:   [1, 2, 3, 2, 4, 2, 5]
                           ↓
Після std::remove(2): [1, 3, 4, 5, ?, ?, ?]  ← повертає ітератор на ?
                                    ↑
                                 newEnd

std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5};

// Фаза 1: std::remove переміщує елементи
auto newEnd = std::remove(numbers.begin(), numbers.end(), 2);

// Фаза 2: erase видаляє "хвіст"
numbers.erase(newEnd, numbers.end());

// Результат: {1, 3, 4, 5}

numbers.erase(std::remove(numbers.begin(), numbers.end(), 2), 
              numbers.end());

// Видалити всі парні числа
numbers.erase(std::remove_if(numbers.begin(), numbers.end(),
                              [](int n) { return n % 2 == 0; }),
              numbers.end());

template <typename RandomIt>
void sort(RandomIt begin, RandomIt end);

std::vector<int> numbers = {5, 2, 8, 1, 9, 3};

std::sort(numbers.begin(), numbers.end());
// Результат: {1, 2, 3, 5, 8, 9}

std::sort(numbers.begin(), numbers.end(), std::greater<int>());
// Результат: {9, 8, 5, 3, 2, 1}

struct Person
{
    std::string name;
    int age;
};

std::vector<Person> people = {
    {"Олександр", 25},
    {"Марія", 30},
    {"Дмитро", 22}
};

// Сортувати за віком
std::sort(people.begin(), people.end(),
          [](const Person& a, const Person& b) {
              return a.age < b.age;
          });

// Результат: Дмитро(22), Олександр(25), Марія(30)

struct Student
{
    std::string name;
    int grade;
};

std::vector<Student> students = {
    {"Анна", 85},
    {"Борис", 90},
    {"Віктор", 85},
    {"Галина", 90}
};

// Сортувати за оцінкою (stable — зберігає порядок для однакових оцінок)
std::stable_sort(students.begin(), students.end(),
                 [](const Student& a, const Student& b) {
                     return a.grade > b.grade;
                 });

// Результат: Борис(90), Галина(90), Анна(85), Віктор(85)
// Порядок всередині груп (90 та 85) збережено!

std::vector<int> numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};

// Відсортувати лише перші 3 елементи
std::partial_sort(numbers.begin(), numbers.begin() + 3, numbers.end());

// Результат: {1, 2, 3, ...решта в довільному порядку}

template <typename InputIt, typename T>
T accumulate(InputIt begin, InputIt end, T init);

#include <iostream>
#include <vector>
#include <numeric>  // accumulate знаходиться тут!

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Сума: " << sum << '\n';  // 15
    
    // Добуток (через custom операцію)
    int product = std::accumulate(numbers.begin(), numbers.end(), 1,
                                   [](int acc, int x) { return acc * x; });
    std::cout << "Добуток: " << product << '\n';  // 120
    
    return 0;
}

// Обчислити суму квадратів
int sumOfSquares = std::accumulate(numbers.begin(), numbers.end(), 0,
                                    [](int acc, int x) {
                                        return acc + x * x;
                                    });
// Результат: 1 + 4 + 9 + 16 + 25 = 55

std::vector<std::string> words = {"Hello", " ", "World", "!"};

std::string sentence = std::accumulate(words.begin(), words.end(), std::string(""));
std::cout << sentence << '\n';  // "Hello World!"

std::vector<int> a = {1, 2, 3};
std::vector<int> b = {4, 5, 6};

// Скалярний добуток: 1*4 + 2*5 + 3*6 = 32
int dotProduct = std::inner_product(a.begin(), a.end(), b.begin(), 0);
std::cout << "Скалярний добуток: " << dotProduct << '\n';  // 32

[захоплення](параметри) -> тип_повернення { тіло }

// Без параметрів
auto greet = []() { std::cout << "Hello!\n"; };
greet();

// З параметрами
auto add = [](int a, int b) { return a + b; };
std::cout << add(3, 5) << '\n';  // 8

// Автоматичне виведення типу повернення
auto multiply = [](int a, int b) { return a * b; };  // Тип повернення: int

// Явне вказання типу повернення
auto divide = [](int a, int b) -> double { return static_cast<double>(a) / b; };

int threshold = 10;

std::vector<int> numbers = {5, 15, 8, 20, 3};

// Підрахувати кількість чисел більших за threshold
int count = std::count_if(numbers.begin(), numbers.end(),
                           [threshold](int n) { return n > threshold; });

std::cout << "Чисел > " << threshold << ": " << count << '\n';  // 2

int sum = 0;

std::for_each(numbers.begin(), numbers.end(),
              [&sum](int n) { sum += n; });

std::cout << "Сума: " << sum << '\n';  // 51

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
#include <sstream>
#include <cctype>

std::vector<std::string> tokenize(const std::string& text)
{
    std::vector<std::string> words;
    std::istringstream stream(text);
    std::string word;
    
    while (stream >> word)
    {
        words.push_back(word);
    }
    
    return words;
}

std::string toLower(std::string s)
{
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return s;
}

int main()
{
    std::string text = "Hello world hello programming world hello "
                      "C++ programming world hello C++ STL algorithms";
    
    // Крок 1: Розбити на слова
    std::vector<std::string> words = tokenize(text);
    
    // Крок 2: Видалити короткі слова (< 3 символи)
    words.erase(std::remove_if(words.begin(), words.end(),
                                [](const std::string& w) { return w.length() < 3; }),
                words.end());
    
    // Крок 3: Перетворити у нижній регістр
    std::transform(words.begin(), words.end(), words.begin(), toLower);
    
    // Крок 4: Підрахувати частоту
    std::unordered_map<std::string, int> freq;
    for (const auto& word : words)
    {
        ++freq[word];
    }
    
    // Крок 5: Знайти топ-5 найчастіших
    std::vector<std::pair<std::string, int>> sorted(freq.begin(), freq.end());
    
    std::partial_sort(sorted.begin(), sorted.begin() + 5, sorted.end(),
                      [](const auto& a, const auto& b) {
                          return a.second > b.second;
                      });
    
    std::cout << "Топ-5 найчастіших слів:\n";
    for (size_t i = 0; i < std::min(size_t(5), sorted.size()); ++i)
    {
        std::cout << "  " << sorted[i].first << ": " << sorted[i].second << '\n';
    }
    
    return 0;
}

// Задача: подвоїти всі парні числа та обчислити їхню суму

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int sum = 0;
for (size_t i = 0; i < numbers.size(); ++i)
{
    if (numbers[i] % 2 == 0)
    {
        numbers[i] *= 2;
        sum += numbers[i];
    }
}

std::cout << "Сума подвоєних парних: " << sum << '\n';

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// Крок 1: Подвоїти парні числа
std::transform(numbers.begin(), numbers.end(), numbers.begin(),
               [](int n) { return (n % 2 == 0) ? n * 2 : n; });

// Крок 2: Обчислити суму парних (вже подвоєних)
int sum = std::accumulate(numbers.begin(), numbers.end(), 0,
                          [](int acc, int n) {
                              return (n % 2 == 0) ? acc + n : acc;
                          });

std::cout << "Сума подвоєних парних: " << sum << '\n';

// C++20 (поза рамками цієї лекції, але для ознайомлення)
auto evenDoubled = numbers 
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * 2; });

int sum = std::accumulate(evenDoubled.begin(), evenDoubled.end(), 0);