#include <iostream>

int main()
{
    auto lambdaA = [](int x) { return x + 1; };
    auto lambdaB = [](int x) { return x + 1; }; // ТОЙ САМИЙ ВИГЛЯД — але інший тип!

    // lambdaA = lambdaB; // ❌ Помилка: різні типи, хоч і однакова сигнатура

    std::cout << lambdaA(5) << '\n'; // 6
    std::cout << lambdaB(5) << '\n'; // 6

    return 0;
}

#include <iostream>
#include <functional>

int main()
{
    // Спосіб 1: auto — зберігає реальний тип, без накладних витрат (рекомендовано)
    auto addA = [](double a, double b) { return a + b; };

    // Спосіб 2: std::function — гнучко, але є накладні витрати на виклик
    std::function<double(double, double)> addB = [](double a, double b) { return a + b; };

    // Спосіб 3: вказівник на функцію — лише якщо лямбда нічого не захоплює
    double (*addC)(double, double) = [](double a, double b) { return a + b; };

    std::cout << addA(1.5, 2.5) << '\n'; // 4
    std::cout << addB(3.0, 1.0) << '\n'; // 4
    std::cout << addC(2.0, 2.0) << '\n'; // 4

    return 0;
}

#include <iostream>
#include <functional>

// Функція, що викликає fn задану кількість разів
void repeat(int count, const std::function<void(int)>& fn)
{
    for (int i = 0; i < count; ++i)
        fn(i);
}

int main()
{
    // Передаємо лямбду прямо у виклик
    repeat(4, [](int i)
    {
        std::cout << "Крок " << i << '\n';
    });

    return 0;
}

#include <iostream>

int main()
{
    // Узагальнена лямбда: auto-параметр — працює з будь-яким типом
    auto printValue = [](const auto& value)
    {
        std::cout << value << '\n';
    };

    printValue(42);       // виводить: 42       (auto деduced → int)
    printValue(3.14);     // виводить: 3.14     (auto deduced → double)
    printValue("Hello");  // виводить: Hello    (auto deduced → const char*)

    return 0;
}

#include <iostream>

int main()
{
    auto trackCalls = [](auto value)
    {
        static int callCount = 0; // окремий для кожного типу!
        std::cout << callCount++ << ": " << value << '\n';
    };

    trackCalls("hello");  // 0: hello  (екземпляр для const char*)
    trackCalls("world");  // 1: world  (той самий екземпляр)
    trackCalls(10);       // 0: 10     (новий екземпляр для int!)
    trackCalls(20);       // 1: 20     (екземпляр для int)
    trackCalls("!");      // 2: !      (знову екземпляр для const char*)

    return 0;
}

// ❌ Помилка: перший return повертає int, другий — double
auto divide = [](int x, int y, bool isInteger)
{
    if (isInteger)
        return x / y;                       // int
    else
        return static_cast<double>(x) / y;  // double ← несумісність!
};

#include <iostream>

int main()
{
    // Явно вказуємо -> double: обидва return тепер конвертуються в double
    auto divide = [](int x, int y, bool isInteger) -> double
    {
        if (isInteger)
            return x / y;                       // int → неявна конвертація в double
        else
            return static_cast<double>(x) / y;  // double
    };

    std::cout << divide(7, 2, true)  << '\n'; // 3        (цілочисельний поділ)
    std::cout << divide(7, 2, false) << '\n'; // 3.5      (дійсний поділ)

    return 0;
}

#include <iostream>
#include <functional>
#include <algorithm>

int main()
{
    int numbers[] = { 13, 90, 5, 40, 80, 99 };
    const int SIZE = 6;

    // Без STL-алгоритмів — сортуємо вручну для демонстрації
    // std::sort(numbers, numbers + SIZE, std::greater<int>{}); // за спаданням

    // Еквівалент через лямбду:
    auto greaterThan = [](int a, int b) { return a > b; };

    // Сортування методом бульбашки для демонстрації (not std::sort)
    for (int i = 0; i < SIZE - 1; ++i)
    {
        for (int j = 0; j < SIZE - i - 1; ++j)
        {
            if (!greaterThan(numbers[j], numbers[j + 1]))
                std::swap(numbers[j], numbers[j + 1]);
        }
    }

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

    return 0;
}

#include <iostream>
#include <functional>

// Приймає будь-який callable bool(int) через std::function
int countIf(int* array, int size, const std::function<bool(int)>& predicate)
{
    int count = 0;

    for (int i = 0; i < size; ++i)
    {
        if (predicate(array[i])) // виклик лямбди — такий самий, як виклик функції
            ++count;
    }

    return count;
}

int main()
{
    int numbers[] = { -4, 7, 0, 12, -1, 3, 8, -9, 5, 6 };
    const int SIZE = 10;

    // Лямбда 1: парні числа
    auto isEven = [](int n)
    {
        return n % 2 == 0;
    };

    // Лямбда 2: від'ємні числа
    auto isNegative = [](int n)
    {
        return n < 0;
    };

    // Лямбда 3: у діапазоні [1, 9]
    auto isInRange = [](int n)
    {
        return n >= 1 && n <= 9;
    };

    std::cout << "Парних:       " << countIf(numbers, SIZE, isEven)    << '\n';
    std::cout << "Від'ємних:    " << countIf(numbers, SIZE, isNegative) << '\n';
    std::cout << "В діапазоні:  " << countIf(numbers, SIZE, isInRange)  << '\n';

    // Можна передати лямбду прямо у виклик:
    std::cout << "Нулів:        " << countIf(numbers, SIZE, [](int n) { return n == 0; }) << '\n';

    return 0;
}

#include <iostream>
#include <functional>

// Замінює кожен елемент результатом fn(element). In-place.
void transformArray(int* array, int size, const std::function<int(int)>& fn)
{
    for (int i = 0; i < size; ++i)
        array[i] = fn(array[i]); // Читаємо старе значення → передаємо в fn → записуємо результат
}

void printArray(int* array, int size)
{
    for (int i = 0; i < size; ++i)
        std::cout << array[i] << ' ';
    std::cout << '\n';
}

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

    std::cout << "До:        ";
    printArray(numbers, SIZE);

    // Трансформація 1: подвоїти кожен елемент
    transformArray(numbers, SIZE, [](int x)
    {
        return x * 2;
    });

    std::cout << "Подвоїти:  ";
    printArray(numbers, SIZE);

    // Трансформація 2: взяти абсолютне значення
    // abs(x): якщо x < 0 → -x, інакше → x
    transformArray(numbers, SIZE, [](int x)
    {
        return x < 0 ? -x : x;
    });

    std::cout << "Abs:       ";
    printArray(numbers, SIZE);

    // Трансформація 3: звести в квадрат
    transformArray(numbers, SIZE, [](int x)
    {
        return x * x;
    });

    std::cout << "Квадрат:   ";
    printArray(numbers, SIZE);

    return 0;
}

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

void bubbleSort(int* array, int size, const std::function<bool(int, int)>& shouldSwap)
{
    for (int pass = 0; pass < size - 1; ++pass)
    {
        for (int i = 0; i < size - pass - 1; ++i)
        {
            // Запитуємо лямбду: чи треба міняти місцями array[i] і array[i+1]?
            if (shouldSwap(array[i], array[i + 1]))
                std::swap(array[i], array[i + 1]);
        }
    }
}

void printArray(int* array, int size)
{
    for (int i = 0; i < size; ++i)
        std::cout << array[i] << ' ';
    std::cout << '\n';
}

int main()
{
    int numbersA[] = { 64, 34, 25, 12, 22, 11, 90 };
    int numbersB[] = { 64, 34, 25, 12, 22, 11, 90 }; // копія для другого сортування
    const int SIZE = 7;

    // Лямбда 1: за зростанням — міняти, якщо лівий БІЛЬШИЙ за правий
    bubbleSort(numbersA, SIZE, [](int a, int b)
    {
        return a > b; // a зліва, b справа; якщо a > b — вони в неправильному порядку
    });

    std::cout << "За зростанням: ";
    printArray(numbersA, SIZE);

    // Лямбда 2: за спаданням — міняти, якщо лівий МЕНШИЙ за правий
    bubbleSort(numbersB, SIZE, [](int a, int b)
    {
        return a < b; // якщо a < b — для спадного порядку вони стоять неправильно
    });

    std::cout << "За спаданням:  ";
    printArray(numbersB, SIZE);

    return 0;
}

#include <iostream>
#include <functional>

// Знаходить "крайній" елемент масиву згідно з критерієм isBetter.
// isBetter(candidate, current) → true, якщо candidate є "кращим" за current
int findExtreme(int* array, int size, const std::function<bool(int, int)>& isBetter)
{
    int extreme = array[0]; // починаємо з першого елемента як поточного "чемпіона"

    for (int i = 1; i < size; ++i) // перебираємо решту, починаючи з другого
    {
        // Якщо поточний елемент "кращий" за досі знайдений — оновлюємо
        if (isBetter(array[i], extreme))
            extreme = array[i];
    }

    return extreme;
}

int main()
{
    int numbers[] = { 3, -7, 14, 0, -2, 11, 8 };
    const int SIZE = 7;

    // Лямбда для мінімуму: candidate є "кращим", якщо він менший
    auto isSmaller = [](int candidate, int current)
    {
        return candidate < current;
    };

    // Лямбда для максимуму: candidate є "кращим", якщо він більший
    auto isLarger = [](int candidate, int current)
    {
        return candidate > current;
    };

    // Лямбда для "найближчого до нуля":
    // candidate є "кращим", якщо його абсолютне значення менше
    auto isCloserToZero = [](int candidate, int current)
    {
        int absCand = candidate < 0 ? -candidate : candidate;
        int absCurr = current < 0  ? -current  : current;
        return absCand < absCurr;
    };

    std::cout << "Мінімум:          " << findExtreme(numbers, SIZE, isSmaller)      << '\n';
    std::cout << "Максимум:         " << findExtreme(numbers, SIZE, isLarger)        << '\n';
    std::cout << "Ближче до нуля:   " << findExtreme(numbers, SIZE, isCloserToZero) << '\n';

    return 0;
}

#include <iostream>
#include <functional>

// Перевіряє число за набором правил. Якщо хоч одне порушене — повертає false.
bool validate(int value, const std::function<bool(int)>* rules, int ruleCount)
{
    for (int i = 0; i < ruleCount; ++i)
    {
        if (!rules[i](value)) // якщо i-те правило повернуло false
        {
            std::cout << "  Правило #" << i + 1 << " порушено!\n";
            return false;     // зупиняємось при першому порушенні
        }
    }

    return true; // усі правила дотримані
}

int main()
{
    // Масив правил-лямбд — кожна перевіряє одну умову
    std::function<bool(int)> rules[] =
    {
        // Правило 1: не від'ємне
        [](int n)
        {
            return n >= 0;
        },

        // Правило 2: менше 100
        [](int n)
        {
            return n < 100;
        },

        // Правило 3: парне
        [](int n)
        {
            return n % 2 == 0;
        },

        // Правило 4: не кратне 7
        [](int n)
        {
            return n % 7 != 0;
        }
    };

    const int RULE_COUNT = 4;

    int testValues[] = { 42, -5, 56, 100, 14 };

    for (int i = 0; i < 5; ++i)
    {
        std::cout << "Перевірка " << testValues[i] << ":\n";

        if (validate(testValues[i], rules, RULE_COUNT))
            std::cout << "  ✅ Валідне\n";
        else
            std::cout << "  ❌ Невалідне\n";
    }

    return 0;
}