tut5.pl

cone([o,o,o], 0).
cone(R, 1) :- select(x, R, [o,o]).
cone(R, 2) :- select(o, R, [x,x]).
cone([x,x,x], 3).

match([_,_], []).
match([A,B,C|R], [M|RM]) :- cone([A,B,C],M), match([B,C|R], RM).

miny(Pocty, Miny) :- same_length(Pocty, Miny), append([[o],Miny,[o]], MinyLong), match(MinyLong, Pocty).


table([1000-[m],900-[c,m],500-[d],400-[c,d],100-[c],90-[x,c],50-[l],40-[x,l],10-[x],9-[i,x],5-[v],4-[i,v],1-[i]]).

add([V-Rep|Rest], N, R) :-
    N >= V, N2 is N - V,
    add([V-Rep|Rest], N2, R2),
    append(Rep, R2, R).
add([V-_|Rest], N, R) :-
    N > 0, N < V,
    add(Rest, N, R).
add(_, 0, []).

roman(N, R) :- between(0, 3999, N), table(T), add(T, N, R).

% algebrogram
%   D O N A L D
% + G E R A L D
%   -----------
%   R O B E R T
%
%   5 2 6 4 8 5
% + 1 9 7 4 8 5
%   -----------
%   7 2 3 9 7 0
%
% soucet([D,O,N,A,L,D],[G,E,R,A,L,D],[R,O,B,E,R,T]).
all_dif([]).
all_dif([X|Xs]) :- maplist(dif(X), Xs), all_dif(Xs).

add_one(X, Y, R, CIn, COut) :-
    between(0, 9, X),
    between(0, 9, Y),
    Total is X + Y + CIn,
    R is Total mod 10,
    COut is Total div 10.

soucet(A, B, C) :-
    append([A, B, C], All),
    sort(All, Vars),
    all_dif(Vars),
    maplist(reverse, [A, B, C], [RA, RB, RC]),
    foldl(add_one, RA, RB, RC, 0, 0).


% state(Time, Left, Pos, Right)
initial(state(0, [ciri, geralt, triss, vesemir], left, [])).

final(state(Time, [], right, People)) :-
    Time =< 17,
    sort(People, [ciri, geralt, triss, vesemir]).

time(vesemir, 10).
time(geralt, 5).
time(triss, 2).
time(ciri, 1).

move(From1, To1, Time, From2, To2) :-
    select(First, From1, Rem1),
    (Who = [First], From2 = Rem1; select(Second, Rem1, From2), First @< Second, Who = [First, Second]),
    maplist(time, Who, Times),
    max_list(Times, Time),
    append(Who, To1, Unsorted),
    sort(Unsorted, To2). % to reduce duplicate states

opposite(left, right).
opposite(right, left).

next(state(T1, L1, P1, R1), state(T2, L2, P2, R2)) :-
    (P1 = left, move(L1, R1, Time, L2, R2); P1 = right, move(R1, L1, Time, R2, L2)),
    opposite(P1, P2),
    T2 is T1 + Time,
    T2 =< 17.

bfs(Start,Goal,Path):- bfs1([[Start]],Goal,Path).

add_head(Xs, X, [X|Xs]).

bfs1([Xs|_], Goal, Path):- Xs=[S|_], call(Goal, S), reverse(Xs, Path).
bfs1([[X|Xs]|Xss], Goal, Path):-
    findall(XNext, next(X, XNext), Neigh),
    subtract(Neigh, [X|Xs], NewNeigh),
    maplist(add_head([X|Xs]), NewNeigh, NewPaths),
    append(Xss, NewPaths, NewQueue),!,
    bfs1(NewQueue, Goal, Path).



:- op(550, xfx, ekv).
:- op(500, xfy, imp).
:- op(450, xfy, or).
:- op(400, xfy, and).
:- op(350,  fx, non).

% Do prefixové notace můžeme převést pomocí predikátu display/1
%
% display(1+2*3).
% +(1,*(2,3))
% true.

% Korektně zadaná formule.
correct(X) :- ground(X), correct_(X).

correct_(X) :- atom(X).
correct_(F ekv G) :- correct_(F), correct_(G).
correct_(F imp G) :- correct_(F), correct_(G).
correct_(F or  G) :- correct_(F), correct_(G).
correct_(F and G) :- correct_(F), correct_(G).
correct_(  non G) :-              correct_(G).

% Chceme zjistit, jestli je daná formule F splnitelná.
%
% Idea:

sat(F) :-
  correct(F),
  vars(F, Vars),
  genModel(Vars, Model),
  eval(F, Model, true).

% Kde vars najde všechny proměnné, genModel na základě těchto proměnných
% (nedeterministicky) vytvoří model a pak jen zkusíme, jestli je F
% pravdivá v tomto modelu.

% Slévání seznamů, které vyhazuje duplikátní prvky.
mergeU(XS, [], XS) :- !.
mergeU([], YS, YS) :- !.
mergeU([X|XS], [Y|YS], R) :-
  ( X @< Y -> mergeU(XS, [Y|YS], S), R = [X|S]
  ; X == Y -> mergeU(XS, YS, S), R = [X|S]  % Takto vypadá "else-if" v Prologu.
  ; mergeU([X|XS], YS, S), R = [Y|S]
  ).

vars(X, [X]) :- atom(X).
vars(non F, R) :- vars(F, R).
vars(F, RR) :-
  F =.. [H, L, R],  % Lze splnit pouze pokud F byl (binární) složený term. Viz níže.
  member(H, [ekv, imp, or, and]),  % H je hlava složeného termu F.
  vars(L, R1),  % L je první argument.
  vars(R, R2),  % R je druhý argument.
  mergeU(R1, R2, RR).