#include <vector>
#include <tuple>
#include <algorithm>
 
// Функция для модификации вектора, создавая непересекающиеся интервалы
void createNonOverlappingIntervals(std::vector<std::tuple<double, double, double, double, int>>& results_out) {
    using EventTuple = std::tuple<double, double, double, double, int>;
 
    // Сортируем события по времени начала интервала
    std::sort(results_out.begin(), results_out.end(), 
              [](const EventTuple& a, const EventTuple& b) { 
                  return std::get<0>(a) < std::get<0>(b); 
              });
 
    // Если вектор пустой или содержит только одно событие, нет необходимости в обработке
    if (results_out.size() <= 1) {
        return;
    }
 
    // Создаем временный вектор для хранения результатов
    std::vector<EventTuple> processed;
    processed.push_back(results_out[0]);
 
    for (size_t i = 1; i < results_out.size(); i++) {
        EventTuple current = results_out[i];
        EventTuple& last = processed.back();
 
        double last_event_end = std::get<3>(last);
        double last_interval_end = std::get<1>(last);
 
        double current_event_start = std::get<2>(current);
 
        // Правило 2: Если текущее событие начинается до конца предыдущего события,
        // мы сохраняем только предыдущее событие
        if (current_event_start <= last_event_end) {
            continue; // Пропускаем текущее событие
        }
 
        // Правило 3: Если текущее событие начинается после конца предыдущего события,
        // но до конца предыдущего интервала
        else if (current_event_start > last_event_end && 
                current_event_start <= last_interval_end) {
            // Корректируем конец интервала предыдущего события
            std::get<1>(last) = last_event_end;
 
            // Корректируем начало интервала текущего события
            std::get<0>(current) = last_event_end;
        }
 
        // Добавляем текущее событие в результат
        processed.push_back(current);
    }
 
    // Заменяем содержимое исходного вектора обработанными событиями
    results_out = std::move(processed);
}
 
#include <iostream>
 
int main() {
    // Создаем тестовые данные
    std::vector<std::tuple<double, double, double, double, int>> test_data = {
        {1717660144617,  1717660152058,  1717660152548,  1717660158178, 1},  // interval_start, interval_end, event_start, event_end, event_id
        {1717660145858, 1717660153198,   1717660153639, 1717660158918, 2}
    };
 
    // Обрабатываем данные, модифицируя исходный вектор
    createNonOverlappingIntervals(test_data);
 
    // Вывод результата
    for (const auto& event : test_data) {
        std::cout << "Интервал: [" << std::get<0>(event) << ", " << std::get<1>(event) << "] "
                  << "Событие: [" << std::get<2>(event) << ", " << std::get<3>(event) << "] "
                  << "ID: " << std::get<4>(event) << std::endl;
    }
 
    return 0;
}

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