Nonogramm - Loeser

Code:

% element/2
element(E, [E|_]).
element(E, [_|R]) :- element(E,R).

% nicht_enthalten/2
nicht_enthalten(E, L) :- not(element(E,L)).

% ist_menge/1
ist_menge([]).
ist_menge([K|R]) :- ist_menge(R), nicht_enthalten(K,R).

% erstes/2
erstes([K|_], K).

ohne_kopf([_|R],R).

liste_erzeugt_x([], 0).
liste_erzeugt_x([x|R], L) :- liste_erzeugt_x(R, LR), L is LR + 1.

liste_erzeugt_o([], 0).
liste_erzeugt_o([o|R], L) :- liste_erzeugt_o(R, LR), L is LR + 1.

erlaubte_elemente(K) :-
member(K, [0,1,2,3,4,5]).

% verkettet/3
verkettet([], L, L).
verkettet([K|R], L2, [K|R2]) :- verkettet(R, L2, R2).

hintendran([],L2,L2).
hintendran([K|R1],L2,[K|R2]) :- verkettet(R1,L2,R2).

letztes([_],[]).
letztes([K|R], [K|L]) :- letztes(R,L).


kopf_entfernen([K|R],K,R).

nonogramm5([A,B,C,D,E],[F,G,H,I,J]) :-
% Nonogramm5([A,B,C,D,E],[F,G,H,I,J],LA0,LB0,LC0,...)
erlaubte_elemente(A),
liste_erzeugt_x(LA, A),
erlaubte_elemente(B),
liste_erzeugt_x(LB, B),
erlaubte_elemente(C),
liste_erzeugt_x(LC, C),
erlaubte_elemente(D),
liste_erzeugt_x(LD, D),
erlaubte_elemente(E),
liste_erzeugt_x(LE, E),
% write(LA), nl,
% write(LB), nl,
% write(LC), nl,
% write(LD), nl,
% write(LE), nl,

erlaubte_elemente(F),
liste_erzeugt_x(LF, F),
erlaubte_elemente(G),
liste_erzeugt_x(LG, G),
erlaubte_elemente(H),
liste_erzeugt_x(LH, H),
erlaubte_elemente(I),
liste_erzeugt_x(LI, I),
erlaubte_elemente(J),
liste_erzeugt_x(LJ, J),
% write(LF), nl,
% write(LG), nl,
% write(LH), nl,
% write(LI), nl,
% write(LJ), nl,

OA is 5 - A,
liste_erzeugt_o(LOA, OA),
hintendran(LA,LOA,LAR0),
% write(LAR0), nl,

OB is 5 - B,
liste_erzeugt_o(LOB, OB),
hintendran(LB,LOB,LBR0),
% write(LBR0), nl,

OC is 5 - C,
liste_erzeugt_o(LOC, OC),
hintendran(LC,LOC,LCR0),
% write(LCR0), nl,

OD is 5 - D,
liste_erzeugt_o(LOD, OD),
hintendran(LD,LOD,LDR0),
% write(LDR0), nl,

OE is 5 - E,
liste_erzeugt_o(LOE, OE),
hintendran(LE,LOE,LER0),
% write(LER0), nl,

OF is 5 - F,
liste_erzeugt_o(LOF, OF),
hintendran(LF,LOF,LFR0),
% write(LFR0), nl,

OG is 5 - G,
liste_erzeugt_o(LOG, OG),
hintendran(LG,LOG,LGR0),
% write(LGR0), nl,

OH is 5 - H,
liste_erzeugt_o(LOH, OH),
hintendran(LH,LOH,LHR0),
% write(LHR0), nl,

OI is 5 - I,
liste_erzeugt_o(LOI, OI),
hintendran(LI,LOI,LIR0),
% write(LIR0), nl,

OJ is 5 - J,
liste_erzeugt_o(LOJ, OJ),
hintendran(LJ,LOJ,LJR0),
% write(LJR0), nl,


kopf_entfernen(LAR0,A1,LAR1),
kopf_entfernen(LBR0,B1,LBR1),
kopf_entfernen(LCR0,C1,LCR1),
kopf_entfernen(LDR0,D1,LDR1),
kopf_entfernen(LER0,E1,LER1),
LFR0 == [A1,B1,C1,D1,E1],
write(LFR0), nl,

kopf_entfernen(LAR1,A2,LAR2),
kopf_entfernen(LBR1,B2,LBR2),
kopf_entfernen(LCR1,C2,LCR2),
kopf_entfernen(LDR1,D2,LDR2),
kopf_entfernen(LER1,E2,LER2),
LGR0 == [A2,B2,C2,D2,E2],
write(LGR0), nl,

kopf_entfernen(LAR2,A3,LAR3),
kopf_entfernen(LBR2,B3,LBR3),
kopf_entfernen(LCR2,C3,LCR3),
kopf_entfernen(LDR2,D3,LDR3),
kopf_entfernen(LER2,E3,LER3),
LHR0 == [A3,B3,C3,D3,E3],
write(LHR0), nl,

kopf_entfernen(LAR3,A4,LAR4),
kopf_entfernen(LBR3,B4,LBR4),
kopf_entfernen(LCR3,C4,LCR4),
kopf_entfernen(LDR3,D4,LDR4),
kopf_entfernen(LER3,E4,LER4),
LIR0 == [A4,B4,C4,D4,E4],
write(LIR0), nl,

kopf_entfernen(LAR4,A5,_),
kopf_entfernen(LBR4,B5,_),
kopf_entfernen(LCR4,C5,_),
kopf_entfernen(LDR4,D5,_),
kopf_entfernen(LER4,E5,_),
LJR0 == [A5,B5,C5,D5,E5],
write(LJR0), nl,

true.

% nonogramm5([1,1,5,4,0],[3,2,2,2,2]).