%% fapte simple 
om(gica).
om(ilie).
impiedicat(gica).
traverseaza(ilie, santier). %% ilie și santier sunt constante, este un șantier anume
sapa_groapa(ilie, gica).

%% reguli
cade_in_groapa(X) :- impiedicat(X), traverseaza(X, santier).
cade_in_groapa(X) :- sapa_groapa(X, Y), X \= Y.

%% negație
bun(X) :- \+sapa_groapa(X,_).
om_bun(X) :- om(X), \+sapa_groapa(X,_).
om_bun_(X) :- \+sapa_groapa(X,_), om(X).

%% structuri (obiecte cu componente)
carte(titlu('Razboi si pace'), autor('Lev Tolstoi')).
carte(titlu('Sonata Kreutzer'), autor('Lev Tolstoi')).
carte(titlu('Magicianul'), autor('John Fowles')).
revista(titlu('National Geographic'), anul(2019), luna('septembrie')).

%% predicate de folosit în interogări
in_biblioteca(X - Y) :- carte(titlu(X), autor(Y)).
in_biblioteca(X - Y/Z) :- revista(titlu(X), anul(Z), luna(Y)).
titlu(X) :- in_biblioteca(X - _).
titlu_struct(X) :- carte(X, _) ; revista(X, _, _).
de_autor(Autor, Carte) :- in_biblioteca(Carte - Autor).


% PF: f(g(h(x)))
% PL: h(X,Y), g(Y,Z), f(Z,Res)

%% exemple pe liste
/*	
(define (num->base n b)
      (if (zero? n)
          '()
          (append (num->base (quotient n b) b)
                  (list (modulo n b)))))
*/

% num_to_base(+N, +B, -Res)
num_to_base(0, _, []).
num_to_base(N, B, Res) :- N > 0, QB is N div B, num_to_base(QB, B, Res1), MB is N mod B, append(Res1, [MB], Res).

/*
(define (all-palindromes? n Bases)
  (if (null? Bases) 
      #t            
      (and (palindrome? (num->base n (car Bases))) 
           (all-palindromes? n (cdr Bases)))))
*/

% palindrome(+L)
palindrome(L) :- reverse(L, L).

% all_palindromes(+N, +Bases)
all_palindromes(_, []).
all_palindromes(N, [B|Bases]) :- num_to_base(N, B, NB), palindrome(NB), all_palindromes(N, Bases).


/*
(define (palindromic-bases n Bases)
  (cond
    ((null? Bases) '())
    ((palindrome? (num->base n (car Bases)))
     (cons (car Bases) (palindromic-bases n (cdr Bases))))
    (else (palindromic-bases n (cdr Bases)))))
*/

% palindromic_bases(+N, +Bases, -PBases)
palindromic_bases(_, [], []).
palindromic_bases(N, [B|Bases], [B|Res]) :- num_to_base(N, B, NB), palindrome(NB), palindromic_bases(N, Bases, Res).
palindromic_bases(N, [B|Bases], Res) :- num_to_base(N, B, NB), \+palindrome(NB), palindromic_bases(N, Bases, Res).

/*
(define (palindromes-to-n n Bases)
  (cond 
    ((< n 0) '())
    ((all-palindromes? n Bases) 
     (append (palindromes-to-n (sub1 n) Bases) 
             (list n)))                        
    (else (palindromes-to-n (sub1 n) Bases))))
*/

% palindromes_to_n(+N, +Bases, -Pals)
palindromes_to_n(N, _, []) :- N < 0.
palindromes_to_n(N, Bases, Res) :- N >=0, all_palindromes(N, Bases), N1 is N-1, palindromes_to_n(N1, Bases, Res1), append(Res1, [N], Res).
palindromes_to_n(N, Bases, Res) :- N >=0, \+all_palindromes(N, Bases), N1 is N-1, palindromes_to_n(N1, Bases, Res).

%% ordinea clauzelor și premiselor
parent(george6, elizabeth2).
parent(elizabeth, elizabeth2).
parent(philip, charles).
parent(philip, anne).
parent(philip, andrew).
parent(philip, edward).
parent(elizabeth2, charles).
parent(elizabeth2, anne).
parent(elizabeth2, andrew).
parent(elizabeth2, edward).
parent(charles, william).
parent(charles, harry).
parent(william, george).
parent(william, charlotte).
parent(william, louis).

pred(Parent, Child) :- parent(Parent, Child).
pred(Pred, Succ) :- parent(Pred, Child), pred(Child, Succ).

%% clauze invers
pred1(P, S) :- parent(P, C), pred1(C, S).
pred1(P, C) :- parent(P, C).

%% premise invers
pred2(P, C) :- parent(P, C).
pred2(P, S) :- pred2(C, S), parent(P, C).

%% clauze și premise invers
pred3(P, S) :- pred3(C, S), parent(P, C).
pred3(P, C) :- parent(P, C).

factorial(0, 1).
factorial(N, F) :- 
	N > 0, 
	N1 is N-1, factorial(N1, F1), 
	F is N * F1.

factorial_1(0, 1).
factorial_1(N, F) :- 
	N > 0,
	factorial_1(N1, F1), N1 is N-1,
	F is N*F1.
	
%% eliminarea distincției dintre intrare și ieșire
elem(X, [X|_]).
elem(X, [_|Rest]) :- elem(X, Rest).
elemI(X, 0, [X|_]).
elemI(X, I, [_|Rest]) :- elemI(X, J, Rest), I is J+1.

concat([], L, L).
concat([X|Rest], L, [X|Rez]) :- concat(Rest, L, Rez).

/*
concat(X,[3,4],[1,2,3,4]).
X = [1|Rest1] si trebuie demonstrat ca concat(Rest1, [3,4], [2,3,4])
X = [1,2|Rest2] si trebuie demonstrat ca concat(Rest2, [3,4], [3,4])
Rest2 = [] => X = [1,2]
sau
X = [1,2,3|Rest3] si trebuie demonstrat ca concat(Rest3, [3,4], [4]) ... care da fail in final
*/

%% exerciții concat
elem_(X,L) :- concat(_, [X|_], L).
last_(X,L) :- concat(_, [X], L).
del22(L,Rez) :- concat([_,_|Rez], [_,_], L).
%exemplu: del22([1,2,3,4,5,6],Rez) => Rez = [3,4]

%% cut
comp(X, Y, 'LT') :- X < Y.
comp(X, Y, 'EQ') :- X =:= Y.
comp(X, Y, 'GT') :- X > Y.

comp_(X, Y, 'LT') :- X < Y, !.
comp_(X, Y, 'EQ') :- X =:= Y, !.
comp_(_, _, 'GT').

elemP(X, [X|_]) :- !.
elemP(X, [_|Rest]) :- elemP(X, Rest).

elemPP(X, [Y|Rest]) :- X = Y, ! ; elemPP(X, Rest). 

sibling(X, Y) :- parent(P, X), parent(P, Y), X \= Y.    
sibling_(X, Y) :- parent(P, X), !, parent(P, Y), X \= Y.
siblingOnce(X, Y) :- once(parent(P, X)), parent(P, Y), X \= Y.