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

predicatesdiv_3(integer*,integer)clausesdiv_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

Predicatesp(integer*,integer*,integer*)clausesp([],[],[]):-!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 imparepredicatesp(integer*,integer*,integer*)clausesp([],[],[]):-!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

predicatesp(integer*,integer*,integer*)lungMult3(integer*)clauseslungMult3([]):-!.lungMult3([X,Y,Z|R]):-lungMult3(R) sau [_,_,_|R]

Sa se scrie un program care ar calcula cite numere impare sunt intr-o lista data

Predicatesp(integer*,integer)clausesp([],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).