fork download

copy

#include <iostream>
using namespace std;
 
class uniq_range_combinator
{
public:
        using range_value_t = int;
        using range_t = range<range_value_t>;
 
        template <typename X>
        using list_t = std::list<X>;
 
        uniq_range_combinator() = default;
 
        template<typename FwdIt>
        list_t<std::vector<range_t>>&& operator()(FwdIt first, FwdIt last, size_t len)
        {
                len_ = len;
 
                size_t ksz = std::distance(first, last);
                std::vector<range_t> res;
                res.reserve(ksz);
 
                while(first != last)
                {
                        const range_t& el = *first++;
                        backtrack(first, last, el, 0, res);
                        res.pop_back();
                }
 
                return std::move(output_);
        }
 
private:
        template<typename FwdIt>
        void backtrack(FwdIt first, FwdIt last, const range_t& el,
                       size_t len, std::vector<range_t>& res)
        {
                res.push_back(el);
                len += el.length();
 
                if(len == len_)
                {
                        output_.push_back(res);
                        return;
                }
 
                while(first != last /* && len < len_ */)
                {
                        const range_t& next = *first++;
                        size_t nl = len + next.length();
 
                        if(el.overlap(next) or nl > len_)
                                continue;
 
                        backtrack(first, last, next, len, res);
                        res.pop_back();
                }
        }
 
private:
        list_t<std::vector<range_t>> output_;
        size_t len_;
};
 
int main() {
	// your code goes here
	return 0;
}

prog.cpp:8:25: error: ‘range’ does not name a type
         using range_t = range<range_value_t>;
                         ^~~~~
prog.cpp:11:29: error: ‘list’ in namespace ‘std’ does not name a template type
         using list_t = std::list<X>;
                             ^~~~
prog.cpp:16:9: error: ‘list_t’ does not name a type
         list_t<std::vector<range_t>>&& operator()(FwdIt first, FwdIt last, size_t len)
         ^~~~~~
prog.cpp:36:55: error: ‘range_t’ does not name a type
         void backtrack(FwdIt first, FwdIt last, const range_t& el,
                                                       ^~~~~~~
prog.cpp:37:41: error: ‘std::vector’ has not been declared
                        size_t len, std::vector<range_t>& res)
                                         ^~~~~~
prog.cpp:37:47: error: expected ‘,’ or ‘...’ before ‘<’ token
                        size_t len, std::vector<range_t>& res)
                                               ^
prog.cpp:62:9: error: ‘list_t’ does not name a type
         list_t<std::vector<range_t>> output_;
         ^~~~~~
prog.cpp: In member function ‘void uniq_range_combinator::backtrack(FwdIt, FwdIt, const int&, size_t, int)’:
prog.cpp:39:17: error: ‘res’ was not declared in this scope
                 res.push_back(el);
                 ^~~
prog.cpp:40:27: error: request for member ‘length’ in ‘el’, which is of non-class type ‘const int’
                 len += el.length();
                           ^~~~~~
prog.cpp:44:25: error: ‘output_’ was not declared in this scope
                         output_.push_back(res);
                         ^~~~~~~
prog.cpp:50:31: error: ‘range_t’ does not name a type
                         const range_t& next = *first++;
                               ^~~~~~~
prog.cpp:51:43: error: ‘std::next’ does not have class type
                         size_t nl = len + next.length();
                                           ^~~~
prog.cpp:53:31: error: request for member ‘overlap’ in ‘el’, which is of non-class type ‘const int’
                         if(el.overlap(next) or nl > len_)
                               ^~~~~~~

Standard output is empty