#include <functional>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <numeric>
#include <cstdint>
#include <thread>
#include <chrono>
#include <deque>
#include <array>
using namespace std::chrono_literals;


namespace std {
template<typename Type, size_t size>
std::ostream& operator<<(std::ostream& out, const std::array<Type, size>& collection) {
    out << '[';
    std::copy(collection.begin(), collection.end(), std::ostream_iterator<Type>{ out, " "});
    out << ']';
    return out;
}


template<typename Type>
std::ostream& operator<<(std::ostream& out, const std::deque<Type>& collection) {
    out << '[';
    std::copy(collection.begin(), collection.end(), std::ostream_iterator<Type>{ out, " "});
    out << ']';
    return out;
}
}

// Опрос
std::array<uint16_t, 12> get_sensor_info() {
    std::array<uint16_t, 12> result{};
    std::generate(result.begin(), result.end(), rand);
    std::this_thread::sleep_for(0.1s);
    return result;
}


int main() {
    // std::array<std::deque<uint16_t>, 12> snapshots{};
    // for(const auto start_time = std::chrono::steady_clock::now(); std::chrono::steady_clock::now() - start_time < 1s;) {
    //     auto snapshot = get_sensor_info();
    //     for(auto index = 0; index < 12; ++index) {
    //         snapshots[index].push_back(snapshot[index]);
    //     }
    // }
    // std::copy(snapshots.begin(), snapshots.end(), std::ostream_iterator<std::deque<uint16_t>>{ std::cout, "\n" });


    // std::cout << "Average on 2: " << std::accumulate(snapshots[2].begin(), snapshots[2].end(), double{ 0.0 }, std::plus<>{}) / snapshots.size() << std::endl;

    // ===========================================================================================

    // std::deque<std::array<uint16_t, 12>> snapshots{};
    // for(const auto start_time = std::chrono::steady_clock::now(); std::chrono::steady_clock::now() - start_time < 1s;) {
    //     snapshots.push_back(get_sensor_info());
    // }
    // std::copy(snapshots.begin(), snapshots.end(), std::ostream_iterator<std::array<uint16_t, 12>>{ std::cout, "\n" });

    // std::cout << "Average on 2: " << std::accumulate(snapshots.begin(), snapshots.end(), double{ 0.0 }, [](double sum, const std::array<uint16_t, 12>& snapshot)->double {
    //     return sum + snapshot[2];
    // }) / snapshots.size() << std::endl;
}