% 8. Se da o lista de numere intregi. Se cere sa se
% elimine secventele de lungime maxima formata doar
% din elemente pare.

%trace

domains
    elem = integer
    list = elem *
predicates
    elimPos(list, list, integer, integer, integer) %(i, i, o, i)
    /*elimPos(l1, l2, p1, p2, n) - elimina din l1,
      din pozitia p1 pana la p2 => rezultat in l2
    */

    elim(list, list, list) % (i, i, o)
    /* elim(l1, l2, r) - elimina din l1, toate
       pozitiile din lista de pozitii l2
       => rezultat in r
    */

    count(list, list, integer) %(i, o, i)
    /* count(L1, L2, N) - numara toate subsirurile
       de elemente consecutive pare din L1,
       => adauga pozitiile lor in L2
    */

    par(integer)
    impar(integer)
    maxPos(list, integer, integer)
    remForMax(list, list, integer)
    run(list, list)
    runMe(list, list)
    updatePos(integer, list, list)
clauses

    run(X,R) :- runMe(X,R).
    runMe(X, R) :-
        count([1|X], ListPos, 1),
        maxPos(ListPos, 0, PMax),
        remForMax(ListPos, [H1,H2|ListMax], PMax),
        updatePos(PMax, ListMax, UpdatedListM),
        elim([1|X], [H1,H2|UpdatedListM], [_|R]).


    updatePos(_, [], []).
    updatePos(N, [H1,H2|T], [H1u,H2u|R]) :-
        H1u = H1 - N,
        H2u = H2 - N,
        Nu =  N * 2,
        updatePos(Nu, T, R).


    par(X) :- X mod 2 = 0.
    impar(X) :- X mod 2 = 1.


    maxPos([], X, X).
    maxPos([H1, H2|T], Mi, Mf) :-
        D = H2 - H1 + 1,
        D > Mi, !,
        maxPos(T, D, Mf).
    maxPos([_,_|T], Mi, Mf) :-
        maxPos(T, Mi, Mf).


    remForMax([], [], _).
    remForMax([H1, H2|T], [H1,H2|R], M) :-
        M = H2 - H1 + 1,
        remForMax(T, R, M).
    remForMax([H1, H2|T], R, M) :-
        M <> H2 - H1 + 1,
        remForMax(T, R, M).


    count([], [], _).
    count([H1, H2|T], [N1|R], N) :-
        impar(H1),
        par(H2),
        N1=N+1, !,
        count([H2|T], R, N1).

    count([H1, H2|T], R, N) :-
        impar(H1),
        impar(H2),
        N1=N+1, !,
        count([H2|T], R, N1).

    count([H1,H2|T], [N|R], N) :-
        par(H1),
        impar(H2),
        N1=N+1,
        count([H2|T], R, N1).

    count([H1,H2|T], R, N ) :-
        par(H1),
        par(H2),
        N1 = N + 1,
        count([H2|T], R, N1).
    count([H], [N], N) :-
        par(H), !.
    count([_], [], _).



    elimPos([], [], _, _, _).
    elimPos([H|T] , [H|X], P1, P2, N) :-   % n < p1
        N<P1,
        N1=N+1,
        !,
        elimPos(T, X, P1, P2, N1).
    elimPos([_|T] , X, P1, P2, N) :-  % p1 <= n <= p2
        N>=P1,
        N<=P2,
        N1=N+1,
        !,
        elimPos(T , X, P1, P2, N1).
    elimPos([H|T] , [H|X], P1, P2, N) :- % n>p2
        N>P2,
        N1=N+1,
        !,
        elimPos(T , X, P1, P2, N1).

    elim(L,[],L).
    elim(L, [P1, P2 | T], R) :-
        elimPos(L, Ri, P1, P2, 1),
        !,
        elim(Ri, T, R).