Concatenarea a 2 liste

Append
Regula: 1).append([],L,L):-!. daca lista este vida rezultatul este a 2-a lista
2). Append([E|L1],L2,[E|R]):-append(L1,L2,R)
Prima regula specifica faptul ca o lista vida concatenata la o lista este ea
insasi. Aceasta regula este conditia de finalizare a recursiei.
A 2-a regula extrage cite un element din prima lista si il trece la lista
rezultat. Alipirea lui E la R nu are loc pina cind R nu va fi concretizat. Deci
initial elementul E se pune in stiva si se preia atunci cind R va fi concretizat
de catre prima regula.
Goal: append([a,b,c],L,[a,b,c,d,e,f]) -> L=[d,e,f]
Aflarea ultimului element din lista:
ultim_el(X,[R]): X=R.
ultim_el(X,[_|Y]): ultim_el(X,Y).

goal: ultim_el(X,[a,b,c,d]);
ultim_el(_,b,c,d)
ultim_el(_c,d)
ultim_el(_,d) ->R=d
Eliminarea unui element din lista:
del(X,[X|L],L): !.
del(X,[Y|L],[Y|L1]): del(X,L,L1).
elim_el(X,[],[]):-!
elim_el(X,[X|L],R):-elim_el(X,L,R)
elim_el(X,[Y|L],[Y|R]):-X<>Y,elim_el(X,L,R)

Aflarea elementului maximal din lista

maximum([X|L],M): max_el(L,X,M).
max_el([X|L],Y,M): X<=Y,max_el(L,Y,M).
max_el([X|L],Y,M): X>Y,max_el(L,X,M).
max_el([ ],M,M).
Toate elementele unei liste daca sint mai mari decit 5 sa se scada 5,
celelalte sa ramina neschimbate
P5([],[]).
p5([X|L1],[Y|L2]):-X>5,Y=X-5,p5(L1,L2).
p5([X|L1],[X|L2]):-X<=5,p5(L1,L2)
Goal: p5([6,3,8,-3,5,9],R) -> R=[1,3,3,-3,5,4]
Sa se inverseze primul element cu al 2-lea, al 3-lea cu al 4-lea, in caz
cind lista este impara elementul de pe ultima pozitie sa ramina
neschimbat

P([],[]):-!.
P([X],[X]):-!.
P([X,Y|L1],[Y,X|L2]):-P(L1,L2)
Sa se mareasca(inmultire) elementele listei cu 2 daca este integer,
daca este symbol sa se dubleze (aa,bb,cc)
P([],[]).
P([X|L1],[Y|L2]):-Y=X*2,P(L1,L2)
dublu([],[]).
dublu([X|L1],[X,X|L2]):-dublu(L1,L2)
Sa se mareasca elementele listei cu o unitate
P([],[]).
P([X|L1],[Y|L2]):-Y=X+1,P(L1,L2)

17.03.2016
Sa se scrie un predicat care ar calcula numarul elementelor
divizibile cu 3 dintr-o lista data
predicates
div_3(integer*,integer)
clauses
div_3([],0):-!
div_3([X|L],R):-X mod 3=0,div_3(L,N1),R=N1+1.
div_3([X|L],R):-X mod 3<>0,div_3(L,R).
Sa se scrie un predicat ce ar calcula suma numerelor divizibile cu 5
dintr-o lista data
p5([],0):-!.
p5([X|L],R):-X mod 5=0,p5(L,N1),R=N1+X.
p5([X|L],R):-X mod 5<>0,p5(L,R).
Sa se scrie un predicat ce ar calcula suma nr pare dintr-o lista data
suma([],0):-!.
suma([X|L],R):-X mod 2=0,suma(L,N1),R=N1+X.
suma([X|L],R):-X mod 2<>0,suma(L,R).
Sa se scrie un predicat ce ar calcula suma nr impare dintr-o lista
data
suma([],0):-!.
suma([X|L],R):-X mod 2=1,suma(L,N1),R=N1+X.
suma([X|L],R):-X mod 2=0,suma(L,R).
Sa se scrie predicatul ce ar adauga elementele negative intr-o lista

suma([],[]):-!.
suma([X|L],[X|R]):-X<0,suma(L,R).
suma([X|L],R):-X>=0,suma(L,R).
Sa se scrie un predicat ce ar elimina elementele listei divizibile la 5
elim([],[]):-!.
elim([X|L],[X|R]):-X mod 5<>0,elim(L,R).
elim([X|L],R):-X mod 5=0,elim(L,R).

Sa se scrie un predicat ce ar separa o lista in 2 liste, in una sa fie

cele pare, in cealalta cele impare
Predicates
p(integer*,integer*,integer*)
clauses
p([],[],[]):-!
p([X|L],[X|R1],R2):-X mod 2=1,p(L,R1,R2)
p([X|L],R1,[X|R2]):-X mod 2=0,p(L,R1,R2)
Sa se scrie un predicat ce ar separa o lista in 2 liste, in prima sa fie
elementele de pe locurile pare, iar in a doua elementele de pe
locurile impare
predicates
p(integer*,integer*,integer*)
clauses
p([],[],[]):-!
p([X,Y|L],[X|R1],[Y|R2]):-p(L,R1,R2)
p([X],[X],0):-!
Sa se scrie un predicat care este adevarat daca lungimea listei L
este multiplul lui 3
predicates
p(integer*,integer*,integer*)
lungMult3(integer*)
clauses
lungMult3([]):-!.
lungMult3([X,Y,Z|R]):-lungMult3(R) sau [_,_,_|R]
Sa se scrie un program care ar calcula cite numere impare sunt intro lista data
Predicates
p(integer*,integer)
clauses
p([],0):-!.
p([X|L],R):-X mod 3=1,p(L,N1),R=N1+1.
p([X|L],R):-X mod 3=0,p(L,R).