#include <iostream>
#include <map>
#include <vector>

using namespace std;


template<class T>
class M{
public:
    T endline;
    int ruleslimit;
    int count;
    map < int, vector<T> > from;
    map < int, vector<T> > to;
    map < int, bool> term;
    vector<T> line;

    M(T e, int rl = 100) {
        endline = e;
        ruleslimit = rl;
        count = 0;
    }

        // endline - символ конца строки,

        // ruleslimit - максимальное количество правил для автомата

        // начальное состояние алгорифма - пустая строка

    bool add_rule(const T* search, const T* replace, bool isterm) {
        ruleslimit--;
        if (ruleslimit < 0) {
            return false;
        }
        vector<T> s, r;
        for (int i = 0; search[i+1] != endline; i++){
            s.push_back(search[i]);
        }
        for (int i = 0; replace[i + 1] != endline; i++){
            r.push_back(replace[i]);
        }
        count++;
        from[count] = s;
        to[count] = r;
        term[count] = isterm;
    }

        // возвращает, удалось ли добавить правило, false если лимит исчерпан

        // search - строка, которую ищут

        // replace - строка, на которую заменяют

        // isterm - является ли правило терминальным, true если является

    bool add_rule(bool isterm, ...) {
        ruleslimit--;
        if (ruleslimit < 0) {
            return false;
        }
        bool *p = &isterm;
        //p++;
        T* pp = (T*)p;
        pp++;
        vector<T> s, r;
        for (; *pp != endline; pp++) {
            s.push_back(*pp);
        }
        pp++;
        for (; *pp != endline; pp++) {
            r.push_back(*pp);
        }
        count++;
        from[count] = s;
        to[count] = r;
        term[count] = isterm;
        return true;
    }

        // isterm - является ли правило терминальным, true если является

        // … через запятую записаны элементы строк, сначала search потом replace обе

        // заканчиваются символами конца строки

    void set_state(const T* state) {
        for (T* p = (T*)state; *p != endline; p++){
            line.push_back(*p);
        }
    }
        // устанавливает текущую строку

    void set_state(T firstchar, ...) {
        T *p = &firstchar;
        for (; *(p + 1) != endline; p++){
            line.push_back(*p);
        }
    }

        // устанавливает текущую строку

    const T* get_state() const {
        T* word = new T[line.size()];
        for (int i = 0; i < line.size(); i++){
            word[i] = line[i];
        }
        return word;
    }

        // возвращает состояние алгорифма

    int run(int limit = 1000000) {
        int lim = 0;
        while (lim++ < limit) {
            bool f = false;
            for (int i = 1; i <= count; i++) {
                vector<T> m = (*from.find(i)).second;
                int n = find(line, (*from.find(i)).second);
                if ((n != -1) && !f) {
                    f = true;
                    for (int j = n; j < (*to.find(i)).second.size() + n; j++){
                        line[j] = to[i][j - n];
                    }
                    if (term[i]) {
                        return lim;
                    }
                }
            }
            if (!f) {
                return -1;
            }

        }
        return -1;
    }

        // запускает автомат, автомат должен сделать не более limit шагов

        // если на каком-то шаге не удалось применить какое-то правило, то автомат останавливается

        // функция должна возвращять номер шага, на котором остановится автомат

        // если автомат не остановился за limit шагов, то вернуть -1 (т.е. если было сделано limit замен, и

        //последнее из применённых limit правил было терминальным – возвращаем limit, иначе - 1).

    int find(vector<T> mass, vector<T> podmass) {
        int n = 0;
        bool t = false;
        for (int i = 0; i < mass.size(); i++) {
            if (mass[i] == podmass[0]) {
                t = true;
                n = i;
            }
            if (t && podmass.size() <= mass.size() - n + 1) {
                for (int j = 0; j < podmass.size(); j++) {
                    t = mass[n + j] == podmass[j];
                }
            }
            if (t) {
                return n;
            }
        }
        return -1;
    }
};

int main() {
    M<int> m(0, 9);
    m.add_rule(false, 3, 0, 4, 0);
    int *p = new int[3];
    p[0] = 2;
    p[1] = 3;
    p[2] = 0;
    m.set_state(p);
    m.run();
    for (int i = 0; i < m.line.size(); i++) {
        cout << m.line[i];
    }
    cout << " ";
    return 0;
}