#include <iterator>
#include <vector>
#include <iostream>

using namespace std;


class SequenceIterator;


class Sequence
{
private:
    vector<int> seq;
    vector<int> sum;
    int k, count;
    friend class SequenceIterator;
public:
    Sequence(int k){ this->k = k; count = 0; }

    void add(int x)
    {

        if (count > k)
        {
            count = 0;
            sum.resize(sum.size()+1);
            sum[sum.size()-1] = 0;
        }
        sum[sum.size()-1] += x;
        //if (x.size() != N) throw "incorrect dimencity";
        /*if (seq.empty())
        {
            seq.emplace_back(x);
            return;
        }
        else
        {
            seq.emplace_back(x);
            int s = 0;
            for (int i = 0; i < k; i++)
                s += seq[i];
            sum.emplace_back(s);
        }*/
    }

    SequenceIterator begin();
    SequenceIterator end();

    int& operator[] (int n)
    {
        return seq[n];
    }

    const int& operator[] (int n) const
    {
        return seq[n];
    }
};


class SequenceIterator:
        public iterator<
                bidirectional_iterator_tag,
                int,
                ptrdiff_t,
                Sequence*,
                Sequence
        >
{
private:
    Sequence *s;
    bool is_default;
    int ind;

    bool is_end() const {
        return ind >= s->seq.size();
    }

public:
    SequenceIterator(): is_default(true) {}
    SequenceIterator(Sequence &obj): SequenceIterator(obj, 0) {};
    SequenceIterator(Sequence &obj, int ind): s(&obj), ind(ind), is_default(false) {}

    bool operator== (const SequenceIterator &other) const
    {
        return (is_default && other.is_default) ||
               (is_default && other.is_end()) ||
               (is_end() && other.is_default) ||
               (s == other.s && ind == other.ind);
    }

    bool operator!= (const SequenceIterator &other) const
    {
        return !(*this == other);
    }

    const int operator* ()
    {
        if (is_default) throw "not initialized iterator";
        return s->sum[ind];
    }

    SequenceIterator& operator++()
    {
        if (is_default) throw "not initialized iterator";
        ind++;
        return *this;
    }

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

    SequenceIterator& operator--()
    {
        if (is_default) throw "not initialized iterator";
        ind--;
        return *this;
    }

    SequenceIterator operator--(int)
    {
        SequenceIterator tmp(*this);
        ind--;
        return tmp;
    }
};


SequenceIterator Sequence::begin()
{
    return SequenceIterator(*this);
}

SequenceIterator Sequence::end()
{
    return SequenceIterator(*this, this->sum.size());
}


int main()
{
    Sequence a(3);
    for (int i = 0; i < 20; i++)
    {
        a.add(i);
    }
    for (auto x : a)
    {
        std::cout << x << " ";
    }

}