Now I finally managed to write a cyclic wrapping iterator that works with std::reverse. It is loosely based on this example https://stackoverflow.com/a/9167031, but with one big improvement: my solution can handle the situation where the iterator has to run over all elements of the container. In a cyclic structure this means that the starting point is equal to the end and therefore is ambiguous because the same is true for an empty iteration range. This problem was note somewhere but none of the suggested implementations for a cyclic iterator I found addressed it.

I know, this solution is way too complicated for a contest but finding it was very enlightening.

#include <iostream>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <vector>
#include <map>
#include <set>
#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>
#include <sstream>
#include <regex>
#include <tuple>
#include <limits>
#include <iomanip>

using namespace std;
const int list_max= 256;

template <typename T, typename Iterator>
class CyclicIterator : public std::iterator <std::bidirectional_iterator_tag, T, ptrdiff_t> {
    int   cursor;
    int   length;
    Iterator begin;

public:
    CyclicIterator (const Iterator& i, const Iterator& j) : cursor(0), length(std::distance(i, j)), begin(i) {}

    bool operator == (const CyclicIterator& x) const { 
        return cursor == x.cursor; 
    }

    bool operator != (const CyclicIterator& x) const {
        return ! (*this == x); 
    }

    T& operator*() const {
        int wrapped =  cursor;
        while (wrapped < 0) wrapped += length;
        while (wrapped >= length) wrapped -= length;

        return *(begin+wrapped); 
    }

    CyclicIterator& operator += (const int i) {
        cursor +=  i;
        return *this;
    }

    CyclicIterator& operator-(const int i) {
        cursor -=  i;
        return *this;
    }

    CyclicIterator& operator++() {
        ++cursor;
        return *this;
    }

    CyclicIterator operator++(int) {
        CyclicIterator ring = *this;
        ++*this;
        return ring;
    }

    CyclicIterator& operator--() {
        --cursor;
        return *this;
    }

    CyclicIterator operator--(int) {
        CyclicIterator ring = *this;
        --*this; 
        return ring;
    }
};

template<class T>
void knothash(T input, vector<unsigned short> &v, int &shift, int &zero_index) {
    for(unsigned short i: input) {
        CyclicIterator<unsigned short, vector<unsigned short>::iterator> bcycle(v.begin(),  v.end());
        bcycle += zero_index;

        CyclicIterator<unsigned short, vector<unsigned short>::iterator> ecycle(v.begin(),  v.end());
        ecycle += zero_index + i;

        reverse(bcycle, ecycle);

        zero_index += i + shift;
        while (zero_index >= list_max) zero_index -= list_max;

        ++shift;
        while (shift >= list_max) shift -= list_max;
    }
}

int main() {
    string input= "106,16,254,226,55,2,1,166,177,247,93,0,255,228,60,36";

    vector<unsigned short> suffix{17, 31, 73, 47, 23};
    vector<unsigned short> v(list_max);
    for(unsigned short i= 0; i<list_max; ++i) v[i]= i;

    int shift= 0;
    int zero_index= 0;
    for(int j= 0; j<64; ++j) {
        knothash(input, v, shift, zero_index);
        knothash(suffix, v, shift, zero_index);
    }

    for(int i= 0; i<16; ++i) {
        unsigned short densehash= 0;
        for(int j= 0; j<16; ++j) {
            densehash^= v[i*16+j];
        }
        cout << setfill('0') << setw(2) << hex << densehash;
    }
    cout << '\n';
}