HA_67

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <numeric>

// Простой класс для многопоточного reduce
class SimpleReducer {
public:
    // Многопоточная версия reduce
    template<typename Iterator, typename T, typename Func>
    static T reduce(Iterator first, Iterator last, T init, Func func) {
        size_t size = std::distance(first, last);

        // Если данных мало - используем обычный reduce
        if (size < 1000) {
            return std::reduce(first, last, init, func);
        }

        // Количество потоков
        size_t num_threads = std::thread::hardware_concurrency();
        if (num_threads == 0) num_threads = 4; // fallback

        // Размер части для каждого потока
        size_t chunk_size = size / num_threads;

        // Вектор для результатов от каждого потока
        std::vector<std::future<T>> futures;

        // Запускаем потоки
        Iterator current = first;
        for (size_t i = 0; i < num_threads - 1; ++i) {
            Iterator chunk_end = current + chunk_size;

            futures.push_back(std::async(std::launch::async, [=]() {
                return std::reduce(current, chunk_end, T{}, func);
            }));

            current = chunk_end;
        }

        // Последний поток обрабатывает оставшиеся элементы
        futures.push_back(std::async(std::launch::async, [=]() {
            return std::reduce(current, last, T{}, func);
        }));

        // Собираем результаты
        T result = init;
        for (auto& future : futures) {
            result = func(result, future.get());
        }

        return result;
    }
};

int main() {
    std::cout << "=== Reduce Test ===\n" << std::endl;

    // Создаем большой вектор
    std::vector<int> numbers(5000000);
    for (size_t i = 0; i < numbers.size(); ++i) {
        numbers[i] = i % 100 + 1; // числа от 1 до 100
    }

    std::cout << "Size: " << numbers.size() << " elements\n" << std::endl;

    // Тест 1: Сумма
    std::cout << "Test 1: Sum" << std::endl;

    auto start = std::chrono::high_resolution_clock::now();
    long long sum = SimpleReducer::reduce(numbers.begin(), numbers.end(), 0LL,
                                         [](long long a, int b) { return a + b; });
    auto end = std::chrono::high_resolution_clock::now();

    auto time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Result: " << sum << std::endl;

    // Тест 2: Произведение
    std::cout << "Test 2: Multiply" << std::endl;
    std::vector<int> small = {1, 2, 3, 4, 5};

    int product = SimpleReducer::reduce(small.begin(), small.end(), 1,
                                       [](int a, int b) { return a * b; });
    std::cout << "1 * 2 * 3 * 4 * 5 = " << product << std::endl;

    // Тест 3: Максимум
    std::cout << "\nTest 3: Max" << std::endl;
    int max_val = SimpleReducer::reduce(numbers.begin(), numbers.end(), 0,
                                       [](int a, int b) { return std::max(a, b); });
    std::cout << "Max: " << max_val << std::endl;

    // Простая проверка корректности
    std::cout << "\nCorrectness check:" << std::endl;
    std::vector<int> test = {10, 20, 30};
    int test_sum = SimpleReducer::reduce(test.begin(), test.end(), 0,
                                        [](int a, int b) { return a + b; });
    std::cout << "10 + 20 + 30 = " << test_sum << " (we expect 60)" << std::endl;

    return 0;
}