Диапазоны в C++23 и C++26: как перестать плодить циклы и начать жить

// До C++20 это было больно
std::vector<int> result;
for (const auto& sub_vec : nested_vectors) {
    for (int val : sub_vec) {
        if (val % 2 == 0) {
            result.push_back(val * val);
        }
    }
}
 
// C++20+ с ranges
auto result = nested_vectors 
    | std::ranges::views::join 
    | std::ranges::views::filter([](int n) { return n % 2 == 0; })
    | std::ranges::views::transform([](int n) { return n * n; });

std::vector<std::vector<int>> nested{{1, 2}, {3, 4, 5}, {6, 7}};
auto joined = std::views::join(nested);
 
for (int i : joined) 
    std::println(i); // выведет 1 2 3 4 5 6 7

std::vector<std::string> words { "Hello", "World", "Coding" };
 
// вместо:
std::map<char, int> freq;
for (auto &w : words)
    for (auto &c : w)
        freq[::tolower(c)]++;
 
// с join:
std::map<char, int> freq;
for (auto &c : words | std::views::join)
    freq[::tolower(c)]++;

std::vector<std::string_view> words{
    "The", "C++", "ranges", "library"
};
 
auto words_up = words | std::views::transform([](std::string_view word) {
    std::string result(word);
    for (char& c : result) 
        c = std::toupper(static_cast<unsigned char>(c));
    return result;
});
 
auto joined = std::views::join_with(words_up, std::string_view(" "));
 
for (auto c : joined) 
    std::cout << c; // Выведет: THE C++ RANGES LIBRARY

std::string result;
for (size_t i = 0; i < words.size(); ++i) {
    result += words[i];
    if (i < words.size() - 1)
        result += " ";
}

std::vector<std::string> v1{"world", "hi"};
std::vector<std::string> v2 { "abc", "xyz" };
std::string arr[]{"one", "two", "three"};
 
auto v1_rev = v1 | std::views::reverse;
auto concat = std::views::concat(v1_rev, v2, arr);
 
concat[0] = "hello"; // доступ и модификация по индексу
 
for (auto& elem : concat)
    std::print("{} ", elem); // hello world abc xyz one two three

struct Transaction {
std::string type;
double amount;
};
 
// Банковские транзакции
std::vector<Transaction> bank_transactions{
   {"Deposit", 100.0}, 
   {"Withdraw", 50.0}, 
   {"Deposit", 200.0}
};
 
// Транзакции по кредитной карте
std::list<Transaction> credit_card_transactions{
    {"Charge", 75.0}, {"Payment", 50.0}
};
 
// Фильтруем только крупные транзакции из каждого источника
auto filtered_bank = bank_transactions 
    | std::views::filter([](const Transaction& t) {
        return t.amount >= 100.0;
    });
 
auto filtered_credit = credit_card_transactions 
    | std::views::filter([](const Transaction& t) {
        return t.amount > 60.0;
    });
 
// Объединяем отфильтрованные транзакции
auto all_transactions = std::views::concat(filtered_bank, filtered_credit);
 
// Теперь можем работать со всеми крупными транзакциями как с единым диапазоном
for (const auto& t : all_transactions)
    std::println("{} - {}$", t.type, t.amount);

// Традиционный подход
void traditional_join(const std::vector<std::vector<int>>& nested) {
    std::vector<int> result;
    for (const auto& inner : nested) {
        for (int val : inner) {
            result.push_back(val);
        }
    }
    return result;
}
 
// Подход с ranges
auto ranges_join(const std::vector<std::vector<int>>& nested) {
    return nested | std::views::join;
}

std::vector<std::vector<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
auto flattened = matrix | std::views::join;
// flattened содержит 1, 2, 3, 4, 5, 6, 7, 8, 9

std::vector<std::vector<std::vector<int>>> volume = {
    {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}},
    {{{9, 10}, {11, 12}}, {{13, 14}, {15, 16}}}
};
 
auto flattened = volume 
    | std::views::join    // Убирает первый уровень вложенности
    | std::views::join;   // Убирает второй уровень вложенности
// flattened содержит 1, 2, 3, 4, 5, 6, ..., 16

std::vector<std::vector<int>> nested = {{}, {1, 2}, {}, {3, 4}, {}};
auto joined = nested | std::views::join;
// joined содержит 1, 2, 3, 4

std::vector<std::vector<int>> nested = {{}, {1, 2}, {}, {3, 4}, {}};
auto joined = nested | std::views::join_with(0);
// joined содержит 1, 2, 0, 3, 4

std::vector<int> v1 = {1, 2};
std::vector<int> v2 = {};
std::vector<int> v3 = {3, 4};
auto concatenated = std::views::concat(v1, v2, v3);
// concatenated содержит 1, 2, 3, 4

std::vector<std::string> split(const std::string& text, char delimiter) {
    std::vector<std::string> result;
    std::stringstream ss(text);
    std::string item;
    while (std::getline(ss, item, delimiter)) {
        if (!item.empty()) {
            result.push_back(item);
        }
    }
    return result;
}

#include <print>
#include <ranges>
#include <string_view>
 
int main() {
    using namespace std::string_view_literals;
    
    constexpr auto text = "C++ is powerful and elegant"sv;
    
    for (auto part : std::views::split(text, ' '))
        std::print("'{}' ", std::string_view(part));
}

constexpr auto text = "C++breakisbreakpowerfulbreakandbreakelegant"sv;
 
for (auto part : std::views::split(text, "break"sv))
    std::print("'{}' ", std::string_view(part));

using Point = std::pair<int, int>;
 
std::vector<Point> path = {
    {0, 0}, {1, 1}, {-1, -1}, // маркер: {-1, -1}
    {2, 2}, {3, 3}, {-1, -1},
    {4, 4}, {5, 5}
};
 
for (auto segment : std::views::split(path, Point{-1, -1}))
    std::print("Сегмент: {}\n", segment);

Сегмент: [(0, 0), (1, 1)]
Сегмент: [(2, 2), (3, 3)]
Сегмент: [(4, 4), (5, 5)]

#include <print>
#include <ranges>
#include <vector>
 
int main() {
    std::vector<int> data{1, 2, 3, 4, 5, 6, 7, 8};
    
    for (auto chunk : data | std::views::chunk(3))
        std::print("{}\n", chunk);
}

[ 1 2 3 ]
[ 4 5 6 ]
[ 7 8 ]

#include <print>
#include <ranges>
#include <sstream>
#include <vector>
 
int main() {
    std::istringstream stream{"AB CD EF 12 34 56 78 95 FF"};
    
    auto bytes = std::ranges::istream_view<std::string>(stream);
    
    for (auto packet : bytes | std::views::chunk(4))
        std::print("Пакет: {}\n", packet);
}

Пакет: ["AB", "CD", "EF", "12"]
Пакет: ["34", "56", "78", "95"]
Пакет: ["FF"]

#include <print>
#include <ranges>
#include <vector>
 
int main() {
    std::vector<int> values{1, 3, 5, 2, 4, 6, 7, 9, 8};
    
    for (auto group : values | std::views::chunk_by([](int a, int b) {
        return (a % 2) == (b % 2); // Одинаковая четность
    })) {
        std::print("размер {}, {}\n", group.size(), group);
    }
}

размер 3, [1, 3, 5]
размер 3, [2, 4, 6]
размер 2, [7, 9]
размер 1, [8]

constexpr auto text = "C++ is powerful. Ranges are elegant. This is fun!"sv;
 
for (auto sentence : text | std::views::chunk_by([](char a, char b) {
    return a != '.' && a != '!' && a != '?';
})) {
    // Удаляем лишние пробелы и печатаем только осмысленные группы
    auto view = std::string_view(&*sentence.begin(), std::ranges::distance(sentence));
    view = view.substr(0, view.find_first_of(".!?") + 1);
    if (!view.empty() && view.size() > 1)
        std::print("Предложение: [{}]\n", view);
}

struct Trade {
    std::string symbol;
    double price;
    int volume;
    std::chrono::system_clock::time_point timestamp;
};
 
std::vector<Trade> trades = /* ... */;
 
// Группируем сделки по символу
auto trades_by_symbol = trades | std::views::chunk_by([](const Trade& a, const Trade& b) {
    return a.symbol == b.symbol;
});
 
// Обрабатываем каждую группу
for (auto group : trades_by_symbol) {
    process_symbol_group(group);
}

std::string csv_line = "field1,\"field2,with,commas\",field3";
 
// Это не сработает корректно из-за запятых внутри кавычек
auto simple_split = csv_line | std::views::split(',');
 
// Нужен более сложный подход
auto tokenize_csv = [](std::string_view line) {
    std::vector<std::string> result;
    bool in_quotes = false;
    std::string current_field;
    
    for (char c : line) {
        if (c == '"') {
            in_quotes = !in_quotes;
        } else if (c == ',' && !in_quotes) {
            result.push_back(current_field);
            current_field.clear();
        } else {
            current_field += c;
        }
    }
    
    if (!current_field.empty()) {
        result.push_back(current_field);
    }
    
    return result;
};

std::string utf8_text = "привет, мир!";
auto words = utf8_text | std::views::split(' ');

for (auto part : std::views::split(text, ' '))
    std::print("'{}' ", std::string_view(part));

template <typename Range>
auto regex_split(Range&& r, const std::regex& pattern) {
    return std::forward<Range>(r) | std::views::transform([&pattern](auto&& item) {
        using std::regex_token_iterator;
        using value_type = std::decay_t<decltype(item)>;
        
        if constexpr (std::is_convertible_v<value_type, std::string_view>) {
            std::string_view sv = item;
            std::string s(sv);
            return std::vector<std::string>(
                regex_token_iterator<std::string::iterator>(s.begin(), s.end(), pattern, -1),
                regex_token_iterator<std::string::iterator>()
            );
        } else {
            // Для нестроковых типов просто возвращаем исходный элемент
            return std::vector<value_type>{item};
        }
    }) | std::views::join;
}

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
auto result = numbers
 | std::views::filter([](int n) { return n % 2 == 0; })  // Только четные
 | std::views::transform([](int n) { return n * n; })    // Возведение в квадрат
 | std::views::take(3);                                 // Только первые 3 элемента
 
// result содержит {4, 16, 36}

auto expensive_op = [](int x) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Имитация тяжелой операции
    return x * 2;
};
 
auto view = numbers 
 | std::views::transform(expensive_op)
 | std::views::filter([](int n) { return n > 5; });
 
// Первый проход
for (auto val : view) {
    std::cout << val << " ";
}
 
// Второй проход
int sum = 0;
for (auto val : view) {
    sum += val;
}

auto intermediate = numbers 
 | std::views::transform(expensive_op)
 | std::ranges::to<std::vector>(); // C++23 материализация
 
auto view = intermediate | std::views::filter([](int n) { return n > 5; });
 
// Теперь expensive_op вызывается только один раз для каждого элемента

auto get_filtered() {
    std::vector<int> local_data = {1, 2, 3, 4, 5};
    return local_data | std::views::filter([](int x) { return x > 2; });
}
 
void use_filtered() {
    auto filtered = get_filtered();
    for (int x : filtered) {  // Упс! Неопределенное поведение!
        std::cout << x << " ";
    }
}

   auto get_filtered() {
       std::vector<int> local_data = {1, 2, 3, 4, 5};
       auto filtered = local_data | std::views::filter([](int x) { return x > 2; });
       return filtered | std::ranges::to<std::vector>();
   }

   auto get_filtered() {
       auto data = std::make_shared<std::vector<int>>(std::vector{1, 2, 3, 4, 5});
       return std::views::owning_view(*data) | std::views::filter([data](int x) { return x > 2; });
   }

   auto apply_filter(std::ranges::range auto& r) {
       return r | std::views::filter([](int x) { return x > 2; });
   }

std::vector<int> big_data(1'000'000);
// Заполняем данными...
 
auto result = std::ranges::sort(big_data | std::views::filter([](int x) { return x > 0; }),
                               std::execution::par); // Параллельная сортировка

auto positive = big_data 
 | std::views::filter([](int x) { return x > 0; })
 | std::ranges::to<std::vector>();
 
std::ranges::sort(positive, std::execution::par);

auto time_series = load_data();
 
// Повторяющееся преобразование
auto common_transform = std::views::transform([](auto& point) {
    return process_point(point); // Дорогая операция
});
 
// Разные фильтры с одинаковым преобразованием
auto dataset1 = time_series 
 | std::views::filter([](auto& p) { return p.region == "North"; })
 | common_transform;
 
auto dataset2 = time_series 
 | std::views::filter([](auto& p) { return p.region == "South"; })
 | common_transform;

auto cached_data = time_series
 | std::views::transform([](auto& point) {
     static std::map<decltype(point.id), decltype(process_point(point))> cache;
     auto it = cache.find(point.id);
     if (it != cache.end())
         return it->second;
     auto result = process_point(point);
     cache[point.id] = result;
     return result;
 })
 | std::ranges::to<std::vector>();
 
// Теперь используем кэшированные данные
auto dataset1 = cached_data | std::views::filter([](auto& p) { return p.region == "North"; });
auto dataset2 = cached_data | std::views::filter([](auto& p) { return p.region == "South"; });

cppcoro::generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield b;
        auto next = a + b;
        a = b;
        b = next;
    }
}
 
void use_fibonacci() {
    auto fib = fibonacci()
     | std::views::take(10)  // Первые 10 чисел Фибоначчи
     | std::views::transform([](int x) { return x * x; });
     
    for (auto val : fib) {
        std::cout << val << " ";
    }
}

// Генератор событий
cppcoro::generator<Event> event_stream() {
    while (true) {
        auto event = wait_for_next_event(); // Блокирующий вызов, ожидающий событие
        co_yield event;
    }
}
 
// Использование с ranges
auto important_events = event_stream()
    | std::views::filter([](const Event& e) { return e.priority > 5; })
    | std::views::take_while([](const Event& e) { return !e.is_shutdown_signal; });
 
for (const auto& event : important_events) {
    handle_important_event(event);
}

template <std::ranges::input_range R>
requires std::ranges::view<R> && std::is_arithmetic_v<std::ranges::range_value_t<R>>
class offset_view : public std::ranges::view_interface<offset_view<R>> {
private:
    R base_ = {};
    std::ranges::range_value_t<R> offset_ = 0;
    
    template <bool Const>
    class iterator {
        // ... детали реализации итератора
    };
 
public:
    offset_view() = default;
    
    offset_view(R base, std::ranges::range_value_t<R> offset)
        : base_(std::move(base)), offset_(offset) {}
    
    auto begin() { return iterator<false>(std::ranges::begin(base_), offset_); }
    auto end() { return sentinel<false>(std::ranges::end(base_)); }
    
    // ... остальные методы
};
 
// Шаблон конвейерного адаптера
inline constexpr auto offset(auto&& value) {
    return std::views::view_closure(
        [value = std::forward<decltype(value)>(value)](auto&& r) {
            return offset_view(std::forward<decltype(r)>(r), value);
        });
}

std::vector<int> nums = {1, 2, 3, 4, 5};
auto result = nums | std::views::filter([](int x) { return x % 2 == 1; })
                   | offset(10)
                   | std::views::transform([](int x) { return x * 2; });
// result содержит {22, 26, 30}

template <typename T>
auto debug_view(std::string_view label = "Debug") {
    return std::views::transform([label](T&& item) {
        std::cerr << label << ": " << item << '\n';
        return std::forward<T>(item);
    });
}

auto result = numbers
    | std::views::filter([](int n) { return n % 2 == 0; })
    | debug_view<int>("After filter")
    | std::views::transform([](int n) { return n * n; })
    | debug_view<int>("After transform");

std::ifstream log_file("server.log");
std::string line;
std::vector<std::string> error_requests;
 
// Традиционный подход
while (std::getline(log_file, line)) {
    if (line.find("HTTP 404") != std::string::npos) {
        std::stringstream ss(line);
        std::string timestamp, ip, method, url, status, size;
        ss >> timestamp >> ip >> method >> url >> status >> size;
        error_requests.push_back(url);
    }
}
 
// Подход с ranges (C++23)
auto error_lines = std::ranges::istream_view<std::string>(log_file)
    | std::views::filter([](const std::string& line) { 
        return line.find("HTTP 404") != std::string::npos; 
    });
 
auto parsed_errors = error_lines 
    | std::views::transform([](const std::string& line) {
        std::stringstream ss(line);
        std::string timestamp, ip, method, url, status, size;
        ss >> timestamp >> ip >> method >> url >> status >> size;
        return url;
    });
 
auto result = parsed_errors | std::ranges::to<std::vector>();

struct Record {
    std::string name;
    int age;
    std::string city;
};
 
std::vector<Record> parse_csv(const std::string& file_path) {
    std::ifstream file(file_path);
    std::string header;
    std::getline(file, header); // Пропускаем заголовок
    
    auto lines = std::ranges::istream_view<std::string>(file);
    
    auto records = lines 
        | std::views::transform([](const std::string& line) {
            auto parts = line | std::views::split(',')
                | std::views::transform([](auto&& part) {
                    return std::string(part.begin(), part.end());
                })
                | std::ranges::to<std::vector>();
            
            return Record{
                parts[0],
                std::stoi(parts[1]),
                parts[2]
            };
        })
        | std::views::filter([](const Record& r) { return r.age > 0; }) // Валидация
        | std::ranges::to<std::vector>();
    
    return records;
}

using Pixel = std::array<uint8_t, 3>; // RGB
using Image = std::vector<Pixel>;
 
Image blur_image(const Image& image, int width, int height, int kernel_size) {
    auto get_pixel = [&](int x, int y) -> const Pixel& {
        x = std::clamp(x, 0, width - 1);
        y = std::clamp(y, 0, height - 1);
        return image[y * width + x];
    };
    
    auto pixel_indices = std::views::iota(0, width * height);
    
    auto blurred_pixels = pixel_indices
        | std::views::transform([&](int idx) {
            int x = idx % width;
            int y = idx / width;
            
            std::array<double, 3> sum = {0, 0, 0};
            int count = 0;
            
            auto offsets = std::views::iota(-kernel_size/2, kernel_size/2 + 1);
            auto neighbor_pixels = std::views::cartesian_product(offsets, offsets)
                | std::views::transform([&](auto&& p) {
                    auto [dx, dy] = p;
                    return get_pixel(x + dx, y + dy);
                });
            
            for (const auto& p : neighbor_pixels) {
                sum[0] += p[0];
                sum[1] += p[1];
                sum[2] += p[2];
                count++;
            }
            
            return Pixel{
                static_cast<uint8_t>(sum[0] / count),
                static_cast<uint8_t>(sum[1] / count),
                static_cast<uint8_t>(sum[2] / count)
            };
        })
        | std::ranges::to<Image>();
    
    return blurred_pixels;
}

std::vector<double> calculate_moving_average(const std::vector<double>& prices, int window) {
    return std::views::iota(0, static_cast<int>(prices.size() - window + 1))
        | std::views::transform([&](int start) {
            auto window_view = prices 
                | std::views::drop(start) 
                | std::views::take(window);
            
            double sum = 0.0;
            int count = 0;
            for (double price : window_view) {
                sum += price;
                count++;
            }
            
            return sum / count;
        })
        | std::ranges::to<std::vector>();
}

enum class TokenType { 
    LeftBrace, RightBrace, LeftBracket, RightBracket, 
    Colon, Comma, String, Number, True, False, Null 
};
 
struct Token {
    TokenType type;
    std::string value;
};
 
std::vector<Token> tokenize_json(std::string_view json) {
    auto is_whitespace = [](char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; };
    
    // Пропускаем пробелы
    auto non_whitespace = json | std::views::filter([&](char c) { return !is_whitespace(c); });
    
    std::vector<Token> tokens;
    
    auto it = non_whitespace.begin();
    auto end = non_whitespace.end();
    
    while (it != end) {
        char c = *it++;
        
        switch (c) {
            case '{': tokens.push_back({TokenType::LeftBrace, "{"}); break;
            case '}': tokens.push_back({TokenType::RightBrace, "}"}); break;
            case '[': tokens.push_back({TokenType::LeftBracket, "["}); break;
            case ']': tokens.push_back({TokenType::RightBracket, "]"}); break;
            case ':': tokens.push_back({TokenType::Colon, ":"}); break;
            case ',': tokens.push_back({TokenType::Comma, ","}); break;
            
            case '"': {
                // Строки обрабатываем отдельно
                auto start = it;
                while (it != end && *it != '"') ++it;
                tokens.push_back({TokenType::String, std::string(start, it)});
                if (it != end) ++it; // Пропускаем закрывающую кавычку
                break;
            }
            
            default:
                // Числа и ключевые слова требуют более сложной обработки...
                // (упрощено для примера)
                if (std::isdigit(c) || c == '-') {
                    auto start = it - 1;
                    while (it != end && (std::isdigit(*it) || *it == '.')) ++it;
                    tokens.push_back({TokenType::Number, std::string(start, it)});
                }
                break;
        }
    }
    
    return tokens;
}

struct JsonValue {
    enum class Type { Null, Boolean, Number, String, Array, Object };
    
    Type type;
    std::variant<std::nullptr_t, bool, double, std::string, 
                 std::vector<JsonValue>, std::map<std::string, JsonValue>> value;
    
    // Вспомогательные методы доступа
    bool is_null() const { return type == Type::Null; }
    bool is_boolean() const { return type == Type::Boolean; }
    // ... и так далее
};
 
JsonValue parse_json_tokens(const std::vector<Token>& tokens) {
    size_t pos = 0;
    
    std::function<JsonValue()> parse_value = [&]() -> JsonValue {
        if (pos >= tokens.size()) throw std::runtime_error("Unexpected end of input");
        
        const Token& token = tokens[pos++];
        
        switch (token.type) {
            case TokenType::LeftBrace: {
                // Объект
                std::map<std::string, JsonValue> obj;
                
                if (pos < tokens.size() && tokens[pos].type == TokenType::RightBrace) {
                    pos++; // Пустой объект
                } else {
                    while (true) {
                        // Ключ должен быть строкой
                        if (tokens[pos].type != TokenType::String)
                            throw std::runtime_error("Expected string key");
                        
                        std::string key = tokens[pos++].value;
                        
                        // За ключом должно идти двоеточие
                        if (pos >= tokens.size() || tokens[pos++].type != TokenType::Colon)
                            throw std::runtime_error("Expected colon after key");
                        
                        // Разбираем значение
                        obj[key] = parse_value();
                        
                        // После пары может быть запятая или закрывающая скобка
                        if (pos >= tokens.size())
                            throw std::runtime_error("Unexpected end of object");
                        
                        if (tokens[pos].type == TokenType::RightBrace) {
                            pos++;
                            break;
                        }
                        
                        if (tokens[pos].type != TokenType::Comma)
                            throw std::runtime_error("Expected comma or closing brace");
                        
                        pos++; // Пропускаем запятую
                    }
                }
                
                return {JsonValue::Type::Object, std::move(obj)};
            }
            
            // Аналогично для массивов, строк, чисел и т.д...
            // (код упрощен для примера)
        }
        
        throw std::runtime_error("Unknown token type");
    };
    
    return parse_value();
}

struct Sale {
    std::string product;
    double amount;
    std::chrono::year_month date;
};
 
auto generate_monthly_report(const std::vector<Sale>& sales) {
    // Группируем продажи по месяцам
    auto sales_by_month = sales 
        | std::views::chunk_by([](const Sale& a, const Sale& b) {
            return a.date == b.date;
        });
    
    // Преобразуем каждую группу в сводку
    return sales_by_month
        | std::views::transform([](const auto& month_sales) {
            auto first_sale = *month_sales.begin();
            auto total = std::accumulate(month_sales.begin(), month_sales.end(), 0.0,
                [](double sum, const Sale& sale) { return sum + sale.amount; });
            
            return std::make_pair(first_sale.date, total);
        })
        | std::ranges::to<std::map>();
}

struct SensorReading {
    int sensor_id;
    double value;
    std::chrono::system_clock::time_point timestamp;
};
 
void process_sensor_stream(std::istream& data_stream) {
    auto readings = std::ranges::istream_view<SensorReading>(data_stream);
    
    // Группируем показания по ID датчика
    auto by_sensor = readings
        | std::views::chunk_by([](const auto& a, const auto& b) {
            return a.sensor_id == b.sensor_id;
        });
    
    // Для каждой группы показаний одного датчика
    for (auto sensor_group : by_sensor) {
        // Рассчитываем скользящее среднее
        auto moving_avg = sensor_group
            | std::views::adjacent<3>  // Берем группы по 3 показания
            | std::views::transform([](const auto& window) {
                double sum = 0.0;
                for (const auto& reading : window) {
                    sum += reading.value;
                }
                return sum / window.size();
            });
        
        // Проверяем на выбросы (упрощено)
        for (auto [reading, avg] : std::views::zip(sensor_group, moving_avg)) {
            if (std::abs(reading.value - avg) > threshold) {
                report_anomaly(reading);
            }
        }
    }
}