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

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
                                11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
    
    // Крок 1: Фільтруємо парні
    std::vector<int> evens;
    std::copy_if(numbers.begin(), numbers.end(), 
                 std::back_inserter(evens),
                 [](int n) { return n % 2 == 0; });
    
    // Крок 2: Беремо перші 10
    if (evens.size() > 10)
        evens.resize(10);
    
    // Крок 3: Множимо на 2
    std::transform(evens.begin(), evens.end(), evens.begin(),
                   [](int n) { return n * 2; });
    
    // Крок 4: Сортуємо
    std::sort(evens.begin(), evens.end());
    
    // Виводимо
    for (int n : evens)
        std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

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

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
                                11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
    
    // Весь конвеєр в ОДНОМУ виразі
    auto result = numbers
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::take(10)
        | std::views::transform([](int n) { return n * 2; });
    
    // Матеріалізуємо у вектор та сортуємо
    std::vector<int> vec(result.begin(), result.end());
    std::ranges::sort(vec);
    
    // Виводимо
    for (int n : vec)
        std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // Класичний STL: передаємо begin() та end() окремо
    std::sort(vec.begin(), vec.end());
    
    auto it = std::find(vec.begin(), vec.end(), 3);
    
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    
    return 0;
}

#include <vector>
#include <ranges>
#include <algorithm>
#include <numeric>

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // Ranges: передаємо контейнер цілком
    std::ranges::sort(vec);
    
    auto it = std::ranges::find(vec, 3);
    
    int sum = std::ranges::fold_left(vec, 0, std::plus{});
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // Створюємо view парних чисел
    auto evens = numbers | std::views::filter([](int n) { return n % 2 == 0; });
    
    std::cout << "Evens: ";
    for (int n : evens)
        std::cout << n << " ";
    std::cout << "\n";
    
    // Змінимо вихідний вектор
    numbers.push_back(12);
    
    std::cout << "After push_back: ";
    for (int n : evens)
        std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <ranges>

int main()
{
    // Числа від 1 до 10
    for (int n : std::views::iota(1, 11))
        std::cout << n << " ";
    std::cout << "\n";
    
    // Перші 5 квадратів
    for (int n : std::views::iota(1) | std::views::take(5))
        std::cout << n * n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // Лише парні
    auto evens = numbers | std::views::filter([](int n) { return n % 2 == 0; });
    
    // Лише > 5
    auto bigNumbers = numbers | std::views::filter([](int n) { return n > 5; });
    
    // Композиція: парні ТА > 5
    auto evenAndBig = numbers 
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::filter([](int n) { return n > 5; });
    
    std::cout << "Evens: ";
    for (int n : evens) std::cout << n << " ";
    
    std::cout << "\nBig: ";
    for (int n : bigNumbers) std::cout << n << " ";
    
    std::cout << "\nEven and big: ";
    for (int n : evenAndBig) std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>
#include <string>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Множимо на 2
    auto doubled = numbers | std::views::transform([](int n) { return n * 2; });
    
    // Конвертуємо в рядки
    auto strings = numbers | std::views::transform([](int n) {
        return std::to_string(n);
    });
    
    std::cout << "Doubled: ";
    for (int n : doubled) std::cout << n << " ";
    
    std::cout << "\nStrings: ";
    for (const auto& s : strings) std::cout << s << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <ranges>

int main()
{
    auto numbers = std::views::iota(1, 21);  // 1..20
    
    // Перші 5
    auto first5 = numbers | std::views::take(5);
    
    // Пропустити перші 15
    auto last5 = numbers | std::views::drop(15);
    
    // Пропустити 5, взяти наступні 5
    auto middle = numbers | std::views::drop(5) | std::views::take(5);
    
    std::cout << "First 5: ";
    for (int n : first5) std::cout << n << " ";
    
    std::cout << "\nLast 5: ";
    for (int n : last5) std::cout << n << " ";
    
    std::cout << "\nMiddle (6-10): ";
    for (int n : middle) std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    auto reversed = numbers | std::views::reverse;
    
    std::cout << "Original: ";
    for (int n : numbers) std::cout << n << " ";
    
    std::cout << "\nReversed: ";
    for (int n : reversed) std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <map>
#include <ranges>

int main()
{
    std::map<std::string, int> scores = {
        {"Alice", 95},
        {"Bob", 87},
        {"Charlie", 92}
    };
    
    // Лише ключі
    auto names = scores | std::views::keys;
    
    // Лише значення
    auto points = scores | std::views::values;
    
    std::cout << "Names: ";
    for (const auto& name : names) std::cout << name << " ";
    
    std::cout << "\nScores: ";
    for (int score : points) std::cout << score << " ";
    std::cout << "\n";
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Два способи створення view на весь контейнер:
    auto view1 = std::views::all(numbers);
    auto view2 = std::ranges::ref_view(numbers);
    
    // Зручно для передачі в функції
    auto processRange = [](auto range) {
        for (int n : range)
            std::cout << n << " ";
        std::cout << "\n";
    };
    
    processRange(std::views::all(numbers));
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // Конвеєр обробки
    auto result = numbers
        | std::views::filter([](int n) { return n % 2 == 0; })  // Парні
        | std::views::transform([](int n) { return n * n; })    // Квадрати
        | std::views::take(3)                                     // Перші 3
        | std::views::reverse;                                    // Зворотний порядок
    
    std::cout << "Result: ";
    for (int n : result)
        std::cout << n << " ";
    std::cout << "\n";
    
    return 0;
}

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

int main()
{
    std::vector<int> numbers(1'000'000);
    std::iota(numbers.begin(), numbers.end(), 1);  // 1..1'000'000
    
    std::cout << "=== EAGER (STL) ===\n";
    {
        // Крок 1: Фільтруємо парні (створює новий вектор!)
        std::vector<int> evens;
        std::copy_if(numbers.begin(), numbers.end(),
                     std::back_inserter(evens),
                     [](int n) { return n % 2 == 0; });
        std::cout << "After filter: " << evens.size() << " elements\n";
        
        // Крок 2: Беремо перші 10 (викидаємо 499'990 елементів!)
        evens.resize(10);
        std::cout << "After take: " << evens.size() << " elements\n";
    }
    
    std::cout << "\n=== LAZY (Ranges) ===\n";
    {
        // Створюємо view (не обчислюється!)
        auto view = numbers
            | std::views::filter([](int n) { return n % 2 == 0; })
            | std::views::take(10);
        
        std::cout << "View created (no computation yet)\n";
        
        // Обчислення відбувається ТУТ
        int count = 0;
        for (int n : view)
        {
            ++count;
            // Обробляється лише 10 елементів!
        }
        std::cout << "Iterated: " << count << " elements\n";
    }
    
    return 0;
}

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

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

int main()
{
    std::vector<Person> people = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };
    
    // Сортування за віком (проєкція)
    std::ranges::sort(people, {},  // {} = std::less{}
                      &Person::age);
    
    std::cout << "Sorted by age:\n";
    for (const auto& p : people)
        std::cout << "  " << p.name << " (" << p.age << ")\n";
    
    // Пошук за ім'ям
    auto it = std::ranges::find(people, "Bob", &Person::name);
    
    if (it != people.end())
        std::cout << "\nFound: " << it->name << ", age " << it->age << "\n";
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>
#include <chrono>

using namespace std::chrono;

int main()
{
    constexpr size_t SIZE = 1'000'000;
    std::vector<int> data(SIZE);
    std::iota(data.begin(), data.end(), 1);
    
    // === STL Eager ===
    {
        auto start = high_resolution_clock::now();
        
        std::vector<int> filtered;
        std::copy_if(data.begin(), data.end(),
                     std::back_inserter(filtered),
                     [](int n) { return n % 2 == 0; });
        
        std::vector<int> transformed;
        std::transform(filtered.begin(), filtered.end(),
                       std::back_inserter(transformed),
                       [](int n) { return n * 2; });
        
        std::vector<int> result;
        std::copy_n(transformed.begin(), 100, std::back_inserter(result));
        
        auto end = high_resolution_clock::now();
        auto duration = duration_cast<microseconds>(end - start);
        
        std::cout << "STL Eager: " << duration.count() << " μs\n";
        std::cout << "  Result size: " << result.size() << "\n";
    }
    
    // === Ranges Lazy ===
    {
        auto start = high_resolution_clock::now();
        
        auto view = data
            | std::views::filter([](int n) { return n % 2 == 0; })
            | std::views::transform([](int n) { return n * 2; })
            | std::views::take(100);
        
        std::vector<int> result(view.begin(), view.end());
        
        auto end = high_resolution_clock::now();
        auto duration = duration_cast<microseconds>(end - start);
        
        std::cout << "Ranges Lazy: " << duration.count() << " μs\n";
        std::cout << "  Result size: " << result.size() << "\n";
    }
    
    return 0;
}

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

int main()
{
    std::vector<int> data = {5, 2, 8, 1, 9, 3, 7, 4, 6};
    
    // ❌ ПОВІЛЬНО: багаторазова ітерація view
    auto view = data | std::views::filter([](int n) { return n > 3; });
    
    // Кожен виклик ranges::distance проходить view заново!
    for (int i = 0; i < 1000; ++i)
    {
        auto size = std::ranges::distance(view);  // O(n) кожен раз
    }
    
    // ✅ ШВИДКО: матеріалізувати в вектор
    std::vector<int> materialized(view.begin(), view.end());
    
    // Тепер size() — O(1)
    for (int i = 0; i < 1000; ++i)
    {
        auto size = materialized.size();
    }
    
    return 0;
}

#include <vector>
#include <ranges>

auto createView()
{
    std::vector<int> local = {1, 2, 3, 4, 5};
    
    // ❌ НЕБЕЗПЕЧНО: local знищується при виході з функції
    return local | std::views::filter([](int n) { return n > 2; });
}

int main()
{
    auto view = createView();
    
    // ❌ Невизначена поведінка: view посилається на знищений вектор
    for (int n : view)
    {
        // ...
    }
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<int> data = {1, 2, 3, 4, 5};
    
    auto view = data | std::views::filter([](int n) { return n > 2; });
    
    // Ітеруємо view
    for (int n : view)
    {
        std::cout << n << " ";
        
        // ❌ НЕБЕЗПЕЧНО: модифікація під час ітерації
        if (n == 3)
            data.push_back(10);  // Може викликати реалокацію!
    }
    
    return 0;
}

#include <vector>
#include <ranges>

int main()
{
    std::vector<int> data = {1, 2, 3, 4, 5};
    
    auto view = data | std::views::filter([](int n) { return n > 2; });
    
    // ❌ Помилка компіляції: filter не підтримує random access
    // auto third = view[2];
    
    // ✅ Потрібна ітерація
    auto it = view.begin();
    std::advance(it, 2);
    auto third = *it;
    
    return 0;
}

#include <vector>
#include <ranges>

int main()
{
    auto numbers = std::views::iota(1, 11);
    
    // C++20: вручну через конструктор
    std::vector<int> vec1(numbers.begin(), numbers.end());
    
    // C++23: елегантна конвертація
    auto vec2 = numbers | std::ranges::to<std::vector>();
    
    // З трансформацією
    auto vec3 = std::views::iota(1, 11)
        | std::views::transform([](int n) { return n * n; })
        | std::ranges::to<std::vector>();
    
    return 0;
}

#include <iostream>
#include <vector>
#include <ranges>

int main()
{
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    std::vector<int> ages = {30, 25, 35};
    
    // Паралельна ітерація двох діапазонів
    for (auto [name, age] : std::views::zip(names, ages))
    {
        std::cout << name << " is " << age << " years old\n";
    }
    
    return 0;
}

#include <iostream>
#include <ranges>

int main()
{
    auto numbers = std::views::iota(1, 21);
    
    // Розбиваємо на групи по 5
    for (auto chunk : numbers | std::views::chunk(5))
    {
        std::cout << "Chunk: ";
        for (int n : chunk)
            std::cout << n << " ";
        std::cout << "\n";
    }
    
    return 0;
}