:- dynamic posx/2, sizeX/1, sizeY/1.


/* 1 */

numofp(X1, Y1, X1, Y1, XS, YS, 1)
	:-	XS > 1, YS > 1,
		retractall(sizeX(_)), retractall(sizeY(_)), assert(sizeX(XS)), assert(sizeY(YS)),
		testX(X1),
		testY(Y1),
		!.
numofp(X1, Y1, X2, Y2, XS, YS, NUM)
	:-	XS > 1, YS > 1,
		retractall(sizeX(_)), retractall(sizeY(_)), assert(sizeX(XS)), assert(sizeY(YS)),
		testX(X1), testX(X2),
		testY(Y1), testY(Y2),
		retractall(posx(_, _)),
		setof(RR, search(X1, Y1, X1, Y1, RR), RES),
		fltr(RES, (X2:Y2), RX), length(RX, NUM).


search(X, Y, X, Y, [(X:Y)])
	:-	posx(_, _), !.
search(X1, Y1, X2, Y2, [(X1:Y1)|P])
	:-	assert(posx(X1, Y1)),
		move(X1, Y1, XN, YN),
		(not(posx(XN, YN)); (X2 = XN, Y2 = YN)),
		search(XN, YN, X2, Y2, P).
search(X1, Y1, _, _, _)
	:-	posx(X1, Y1),
		retract(posx(X1, Y1)),
		!, fail.

fltr([L|LS], V, [L|LX]) :- member(V,L), !, fltr(LS, V, LX).
fltr([_|LS], V, LX) :- fltr(LS, V, LX).
fltr([], _, []).

move(X, Y, NX, NY) :-
	NX is X + 1,
	NY is Y + 2,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X - 1,
	NY is Y + 2,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X + 1,
	NY is Y - 2,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X - 1,
	NY is Y - 2,
	testX(NX),
	testY(NY).

move(X, Y, NX, NY) :-
	NX is X + 2,
	NY is Y + 1,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X - 2,
	NY is Y + 1,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X + 2,
	NY is Y - 1,
	testX(NX),
	testY(NY).
move(X, Y, NX, NY) :-
	NX is X - 2,
	NY is Y - 1,
	testX(NX),
	testY(NY).

testX(X) :- sizeX(XX), X >= 1, X =< XX.
testY(Y) :- sizeY(YY), Y >= 1, Y =< YY.

/* 2 */
mapst(Map, Key, Value) :- nonvar(Map), var(Value), nonvar(Key), Get =.. [Map, Key, Value], call(Get).
mapst(Map, Key, Value) :- nonvar(Map), nonvar(Value), nonvar(Key), insrt(Map, Key, Value).
mapst(Map, Key, Value) :- nonvar(Map), nonvar(Value), var(Key), Get =.. [Map, K, Value], setof(K, Get, Key).

insrt(Map, Key, _) :- Test =.. [Map, Key, _], call(Test), !, fail.
insrt(Map, Key, Val) :- Asrt =.. [Map, Key, Val], assert(Asrt).

/* !!!!!!!!!!!!! NNEEEEE!!!! !!!!!!!!!!!!!! */
/* 2 BRUTUS chyby !!!!!!!!!!! */

mapstx(Map, _, _) :- var(Map), !, fail.
mapstx(_, Key, Value) :- var(Key), var(Value), !, fail.
mapstx(Map, Key, Value) :- var(Value), P =.. [Map, Key, Value], call(P).
mapstx(Map, Key, Value) :- var(Key), P =.. [Map, K, Value], setof(K, P, Key).
mapstx(Map, Key, Value) :- P =.. [Map, Key, Value], call(P), !, fail.
mapstx(Map, Key, Value) :- P =.. [Map, Key, Value], assert(P).


/* 3 */

sbstr([], []).
sbstr(Str, SStr) :- appnd(_, SStr, L), appnd(L, _ ,Str).

appnd([], L2, L2).
appnd([H|T], L2, [H|AP]) :- appnd(T,L2,AP).


/* 3 alternativa */

sbstr2([], []).
sbstr2([_|_], []).
sbstr2([H|T1], [H|T2]) :- prfx(T1, T2).
sbstr2([_|T], X) :- sbstr2(T, X).

prfx(_, []).
prfx([H|T1], [H|T2]) :- prfx(T1,T2).


/* !!!!!!!!!!!!! NNEEEEE!!!! !!!!!!!!!!!!!! */
/* zkuste varianty pro sbstrx([1,2,3],X). */

sbstrx(Str, Sub) :- sstr(Str, Sub, Sub).

sstr([H1|T1], [H2|T2], S) :- (H1 = H2 -> sstr(T1, T2, S); sstr(T1, S, S)).
sstr(_, [], _).

/* ---------------------- Goedel ----------------------- */
/*

MODULE PRIME.
IMPORT Integers.

PREDICATE Prime : Integer.

Prime(prime) <- ~ SOME [x] (x > 1 & x < prime & prime Mod x = 0).

*/
/* ---------------------- Goedel ----------------------- */

/* EOF */