Question

我尝试使用Ranges-V3库将一个值容器切割成一系列范围，以便相邻范围共享边界元素。

请考虑以下事项：

magrittr

我想根据区域是否满足两个标准，将范围划分为重叠的子范围：

元素的值是否为零
或与一个或多个值为零的元素相邻

期望的输出：

using namespace ranges;

std::vector<int> v = { 1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9 };
auto myRanges = v | /* something like adjacent split */
for_each( myRanges, []( auto&& range ){ std::cout << range << std::endl;} );

我的尝试：

[1,2,3]
[3,0,4,0,5,0,6]
[6,7,8]
[8,0,0,9]

输出：

auto degenerate =
  []( auto&& arg ){
    return distance( arg ) < 2;  
  };

auto myRanges = v | view::split(0) | view::remove_if( degenerate );
for_each( myRanges, []( auto&& range ){ std::cout << range << std::endl;} );

我不知道如何

＆＃34;插入＆＃34;范围从3到6
＆＃34;附加＆＃34;范围从8到9

Answer 1

如果我正确理解您的要求，您可以使用adjacent_find：

来实现生成器

namespace detail {
    template<typename IterT, typename SentT>
    struct seg_gen_fn {
        IterT it_;
        SentT end_;
        bool parity_ = true;

        ranges::iterator_range<IterT> operator ()() {
            if (it_ == end_) {
                return {it_, it_};
            }

            auto n = ranges::adjacent_find(
                it_, end_,
                [p = std::exchange(parity_, !parity_)](auto const a, auto const b) {
                    return a && !b == p;
                }
            );
            return {
                std::exchange(it_, n),
                n != end_ ? ranges::next(std::move(n)) : std::move(n)
            };
        }
    };

    template<typename RngT>
    constexpr auto seg_gen(RngT&& rng)
     -> seg_gen_fn<ranges::iterator_t<RngT>, ranges::sentinel_t<RngT>>
    { return {ranges::begin(rng), ranges::end(rng)}; }
} // namespace detail

auto const segmented_view = [](auto&& rng) {
    return ranges::view::generate(detail::seg_gen(decltype(rng)(rng)))
         | ranges::view::take_while([](auto const& seg) { return !seg.empty(); });
};

int main() {
    auto const ns = {1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9};
    ranges::copy(segmented_view(ns), ranges::ostream_iterator<>{std::cout, "\n"});
}

的 Online Demo
_{_{不完全像人们希望的那样简洁......： - [}}

这对于一次性代码来说可能很好，但是可以做多一点工作，它可以更加可重复使用：

namespace detail { namespace tag = ranges::tag; template< typename RngT, typename PredT, typename IterT = ranges::iterator_t<RngT>, typename StateT = ranges::tagged_compressed_tuple< tag::begin(IterT), tag::end(ranges::sentinel_t<RngT>), tag::current(bool), tag::fun(ranges::semiregular_t<PredT>) > > struct seg_gen_fn : private StateT { constexpr seg_gen_fn(RngT&& rng, PredT pred) : StateT{ranges::begin(rng), ranges::end(rng), true, std::move(pred)} { } ranges::iterator_range<IterT> operator ()() { StateT& state = *this; auto& it = state.begin(); if (it == state.end()) { return {it, it}; } auto& parity = state.current(); auto n = ranges::adjacent_find( it, state.end(), [p = std::exchange(parity, !parity), &pred = state.fun()] (auto const& a, auto const& b) { return !pred(a) && pred(b) == p; } ); return { std::exchange(it, n), n != state.end() ? ranges::next(std::move(n)) : std::move(n) }; } }; template<typename RngT, typename PredT> constexpr seg_gen_fn<RngT, PredT> seg_gen(RngT&& rng, PredT pred) { return {std::forward<RngT>(rng), std::move(pred)}; } } // namespace detail auto const segmented_view = [](auto&& rng, auto pred) { return ranges::view::generate(detail::seg_gen(decltype(rng)(rng), std::move(pred))) | ranges::view::take_while([](auto const& seg) { return !seg.empty(); }); }; int main() { auto const ns = {1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9}; ranges::copy( segmented_view(ns, [](auto const n) { return n == 0; }), ranges::ostream_iterator<>{std::cout, "\n"} ); }

的 Online Demo

概念检查和预测留作练习。

将范围分割为重叠范围的范围

1 个答案: