#include <iostream>

int strLen(const char* str)
{
    int len = 0;
    while (str[len] != '\0')
        ++len;
    return len;
}

bool findFirstLonger(const char** words, int size, const std::function<bool(const char*)>& pred)
{
    for (int i = 0; i < size; ++i)
        if (pred(words[i]))
            return true;
    return false;
}

int main()
{
    const char* words[] = { "hi", "morning", "ok", "sunshine", "bye" };
    int minLength = 5; // ← ця змінна потрібна всередині лямбди

    // ❌ Спроба звернутися до minLength — помилка!
    auto isLong = [](const char* word) // [] — порожній capture, minLength невидима
    {
        return strLen(word) > minLength; // помилка компіляції: minLength not captured
    };

    return 0;
}

#include <iostream>

int strLen(const char* str)
{
    int len = 0;
    while (str[len] != '\0')
        ++len;
    return len;
}

int main()
{
    const char* words[] = { "hi", "morning", "ok", "sunshine", "bye" };
    const int SIZE = 5;
    int minLength = 5;

    // [minLength] — захоплюємо minLength за значенням
    // лямбда отримує КОПІЮ значення 5 прямо зараз
    auto isLong = [minLength](const char* word)
    {
        return strLen(word) > minLength; // використовуємо свою копію
    };

    for (int i = 0; i < SIZE; ++i)
    {
        if (isLong(words[i]))
            std::cout << words[i] << ' ';
    }
    std::cout << '\n';

    // Змінюємо оригінальну змінну — лямбда цього «не відчує»
    minLength = 10;

    std::cout << "Після зміни minLength = 10:\n";
    for (int i = 0; i < SIZE; ++i)
    {
        if (isLong(words[i]))
            std::cout << words[i] << ' ';
    }
    std::cout << '\n';

    return 0;
}

#include <iostream>

int main()
{
    int ammo = 10;

    auto shoot = [ammo]()
    {
        --ammo; // ❌ Помилка: 'ammo' is const — захоплена за значенням
        std::cout << "Pew! " << ammo << " shot(s) left.\n";
    };

    shoot();

    return 0;
}

#include <iostream>

int main()
{
    int ammo = 10;

    // mutable — дозволяємо зміну захоплених за значенням змінних
    auto shoot = [ammo]() mutable
    {
        --ammo; // ✅ Тепер можна — але змінюємо КОПІЮ, не оригінал!
        std::cout << "Pew! " << ammo << " shot(s) left.\n";
    };

    shoot(); // Pew! 9 shot(s) left.
    shoot(); // Pew! 8 shot(s) left.
    shoot(); // Pew! 7 shot(s) left.

    // ammo в main() ніяк не змінився!
    std::cout << "Original ammo: " << ammo << '\n'; // 10

    return 0;
}

#include <iostream>

int main()
{
    int ammo = 10;

    // [&ammo] — захоплюємо ammo за посиланням
    auto shoot = [&ammo]()
    {
        --ammo; // ← змінюємо оригінальну змінну з main()
        std::cout << "Pew! " << ammo << " shot(s) left.\n";
    };

    shoot(); // Pew! 9 shot(s) left.
    shoot(); // Pew! 8 shot(s) left.

    std::cout << "Remaining ammo: " << ammo << '\n'; // 8

    return 0;
}

#include <iostream>
#include <utility> // для std::swap

void bubbleSort(int* array, int size, const std::function<bool(int, int)>& compare)
{
    for (int pass = 0; pass < size - 1; ++pass)
        for (int i = 0; i < size - pass - 1; ++i)
            if (compare(array[i], array[i + 1]))
                std::swap(array[i], array[i + 1]);
}

int main()
{
    int numbers[] = { 5, 2, 8, 1, 9, 3 };
    const int SIZE = 6;

    int comparisons = 0; // зовнішній лічильник

    // Захоплюємо comparisons за посиланням — щоб рахувати з лямбди
    bubbleSort(numbers, SIZE, [&comparisons](int a, int b)
    {
        ++comparisons; // кожен виклик лямбди — це одне порівняння
        return a > b;  // сортуємо за зростанням
    });

    std::cout << "Sorted: ";
    for (int i = 0; i < SIZE; ++i)
        std::cout << numbers[i] << ' ';
    std::cout << '\n';

    std::cout << "Total comparisons: " << comparisons << '\n';

    return 0;
}

#include <iostream>

int main()
{
    int health = 100;
    int damage = 15;
    int armor = 30;

    // health і armor — за значенням (копії)
    // damage — за посиланням (оригінал)
    auto takeDamage = [health, armor, &damage]() mutable
    {
        int reduced = damage - armor; // застосовуємо зменшення через armor
        if (reduced < 0) reduced = 0;

        health -= reduced; // health — копія, зміна не впливає на оригінал
        damage += 5;       // damage — посилання, оригінал збільшується!

        std::cout << "HP: " << health
                  << ", reduced by " << reduced
                  << ", next damage: " << damage << '\n';
    };

    takeDamage();
    takeDamage();
    takeDamage();

    std::cout << "\nОригінали після викликів:\n";
    std::cout << "health = " << health << " (незмінний — захоплено за значенням)\n";
    std::cout << "damage = " << damage << " (змінився — захоплено за посиланням)\n";
    std::cout << "armor  = " << armor  << " (незмінний — захоплено за значенням)\n";

    return 0;
}

#include <iostream>

int main()
{
    int base = 10;
    int multiplier = 3;
    int offset = 7;

    // [=] — всі три змінні захоплюються за значенням автоматично
    auto calculateA = [=]()
    {
        return base * multiplier + offset; // всі три видимі
    };

    // [&] — всі три захоплюються за посиланням автоматично
    auto calculateB = [&]()
    {
        base += 1;       // змінюємо оригінали!
        multiplier += 1;
        return base * multiplier + offset;
    };

    std::cout << "A: " << calculateA() << '\n'; // 10*3+7 = 37
    std::cout << "B: " << calculateB() << '\n'; // 11*4+7 = 51  (base і multiplier змінились)
    std::cout << "base=" << base << ", multiplier=" << multiplier << '\n'; // 11, 4

    return 0;
}

int health = 100;
int armor  = 50;
int damage = 30;

// [=, &damage] — all by value, except damage — by reference
auto deal = [=, &damage]() mutable { /* ... */ };

// [&, armor] — all by reference, except armor — by value
auto deal2 = [&, armor]() { /* ... */ };

// ❌ Заборонено — дублювання: armor вже захоплено через [=]
// auto bad1 = [=, armor]() {};

// ❌ Заборонено — захоплення за замовчуванням не першим
// auto bad2 = [armor, =]() {};

// ❌ Заборонено — подвійне захоплення armor
// auto bad3 = [armor, &health, &armor]() {};

#include <iostream>

int main()
{
    int width = 6;
    int height = 7;

    // Нова змінна area, видима лише всередині лямбди.
    // Вона обчислюється ОДИН РАЗ — при визначенні лямбди.
    auto printArea = [area = width * height]()
    {
        std::cout << "Area: " << area << '\n';
    };

    // Змінюємо width і height — area всередині лямбди не зміниться!
    width = 100;
    height = 200;

    printArea(); // Area: 42 — бо 6*7=42, обчислено при визначенні

    return 0;
}

#include <iostream>

int main()
{
    int value = 5;

    // Захоплюємо value, але подвоєне — нова змінна doubleValue
    auto print = [doubleValue = value * 2]()
    {
        std::cout << "Double: " << doubleValue << '\n';
    };

    print(); // Double: 10

    return 0;
}

#include <iostream>
#include <functional>

// Функція повертає лямбду — але & захоплює локальну змінну!
std::function<void()> makePrinter()
{
    int localValue = 42; // локальна змінна — існує лише в makePrinter()

    // [&] — захоплюємо localValue за посиланням
    return [&]()
    {
        // ❌ Невизначена поведінка!
        // localValue вже знищена після повернення з makePrinter()
        std::cout << localValue << '\n';
    };
}

int main()
{
    auto printer = makePrinter(); // makePrinter() завершилась, localValue знищена
    printer(); // ❌ UB: звертаємося до неіснуючої змінної

    return 0;
}

std::function<void()> makePrinter()
{
    int localValue = 42;

    // [localValue] — копія, живе разом з лямбдою, не залежить від стеку makePrinter()
    return [localValue]()
    {
        std::cout << localValue << '\n'; // ✅ безпечно
    };
}

#include <iostream>

int main()
{
    int counter = 0;

    auto increment = [counter]() mutable
    {
        ++counter;
        std::cout << counter << '\n';
    };

    increment(); // 1  (counter лямбди: 0 → 1)

    auto copy = increment; // копіюємо лямбду — копіюється і внутрішній стан!
                           // copy.counter = 1 (поточне значення)

    increment(); // 2  (оригінал: 1 → 2)
    copy();      // 2  (копія: 1 → 2, незалежно від оригіналу!)

    return 0;
}

#include <iostream>
#include <functional>

void callThreeTimes(const std::function<void()>& fn)
{
    fn(); // std::function зберігає КОПІЮ лямбди всередині себе
    fn(); // кожен виклик — одна й та сама копія
    fn();
}

int main()
{
    int counter = 0;
    auto increment = [counter]() mutable
    {
        ++counter;
        std::cout << counter << '\n';
    };

    callThreeTimes(increment);
    // Очікуємо: 1 2 3
    // Реальність: 1 1 1 — std::function кожного разу виконує СВОЮ копію

    return 0;
}

int counter = 0;
auto increment = [&counter]() // захоплення за посиланням — не копіюється
{
    ++counter;
    std::cout << counter << '\n';
};

callThreeTimes(increment); // 1 2 3 — тепер правильно