#include <cassert>
#include <forward_list>
#include <initializer_list>
#include <iterator>
#include <set>
#include <vector>

template <typename Value_It>
class Index_Iterator
{

    using Index_It = std::vector<std::size_t>::const_iterator;
    
public:

    using value_type      = typename Value_It::value_type;
    using reference       = typename Value_It::reference;
    using pointer         = typename Value_It::pointer;
    using difference_type = typename Value_It::difference_type;

    using iterator_category = std::forward_iterator_tag;

    reference operator*()
    {
        return *std::next(value, *index);
    }

    Index_Iterator& operator++()
    {
        ++index;
        return *this;
    }

    Index_Iterator operator++(int)
    {
        Index_Iterator tmp { *this };
        ++(*this);
        return tmp;
    }

    bool operator==(Index_Iterator const& other) const
    {
        return index == other.index && value == other.value;
    }

    bool operator!=(Index_Iterator const& other) const
    {
        return !(*this == other);
    }
        
    
private:
    
    template <typename>
    friend class Index_Range;

    Index_Iterator(Index_It index, Value_It value)
        : index { index }, value { value }
    {
    }
    
    Index_It index;
    Value_It value;
    
};

template <typename Container>
class Index_Range
{
public:

    Index_Range(Container& container, std::initializer_list<std::size_t> list)
        : indices { list.begin(), list.end() }, container { container }
    {
    }

    Index_Iterator<typename Container::iterator> begin()
    {
        return { std::begin(indices), std::begin(container) };
    }

    Index_Iterator<typename Container::iterator> end()
    {
        return { std::end(indices), std::begin(container) };
    }
    
private:

    std::vector<std::size_t> indices;
    Container& container;
    
};

template <typename Container>
Index_Range<Container> select_indices(Container& container, std::initializer_list<std::size_t> list)
{
    return { container, list };
}

int main()
{
    {
        int index { 0 };
        std::vector<int> v { 0, 1, 2, 3 };
        for (auto i : select_indices(v, { 0, 1, 2, 3 }))
        {
            assert(i == index++);
        }
    }


    {
        std::vector<double> v { 1.2, 3.45, 6.78, 9.0 };
        auto range { select_indices(v, { 0, 0, 1, 0, 2 }) };
        
        std::vector<double> result { range.begin(), range.end() };
        assert(( result == std::vector<double>{ 1.2, 1.2, 3.45, 1.2, 6.78 } ));
    }
    
    {
        std::set<std::string> v { "a", "b", "c", "d" };
        auto range { select_indices(v, { 0, 1, 1, 0 }) };
        
        std::vector<std::string> result { range.begin(), range.end() };
        assert(( result == std::vector<std::string>{ "a", "b", "b", "a" } ));
    }
    
    {
        std::forward_list<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
        auto range { select_indices(v, { 0, 2, 6, 10 }) };
        
        std::vector<int> result { range.begin(), range.end() };
        assert(( result == std::vector<int>{ 1, 3, 7, 11 } ));
    }
}