Predicados en Prolog: Listas, Árboles y Algoritmos Clásicos Explicados con Código

Clasificado en Matemáticas

Escrito el en español con un tamaño de 3,45 KB

1-aplanar([],[]). / Aplanar([Car|Cdr],[Car|X]):-atomic(Car),!,aplanar(Cdr,X).

aplanar([Car|Cdr],R):-aplanar(Car,Y), aplanar(Cdr,Z), Concar(Y,Z,R).

2-aplanar2(Lista,ListaA):-aplanardl(Lista,ListaA-[]).

aplanardl([],X-X).

aplanardl(A,[A|X]-X):-atomic(A),A\==[].

aplanardl([Caar|Cdr],CarA-X):aplanardl(Car,CarA-CdrA),aplanardl(Cdr,CdrA-X).

3-concat([],X,X).

concat([Car|Cdr],Y,[Car|R]):-concat(Cdr,Y,R).

4-conjunto([]).

conjunto([Car|Cdr]):-miembro(Car,Cdr),!,fail.

conjunto([_|Cdr]):-conjunto(Cdr).

5-cartesiano([],_,[]).

cartesiano([Car|Cdr,L,R:-pegar(Car,L,X),cartesiano(Cdr,L,Z),contact(X,Z,R).

pegar(_,[],[]):-!

pegar(X,[Car|Cdr],[[X,Car]|R]):-pegar(X,Cdr,R).

6-cart(x,y,z):-cart(x,y,z-[])

cart([],_,[]-[])

cart([Car|cdr],L,R-res):-pegar(car,L,R-Z),cart(Cdr,L,Z-Res)

pegar(_,[],[]-[]):!

pegar(x,[Car|Cdr],[[x,Car]|R]-x):-pegar(x,Cdr,R-x).

7-eliminar([],_,[])

eliminar([_|Cdr],1,Cdr).

eliminar([Car|Cdr],X,[Car|R]):-X\==1, X2 is X-1(eliminar(Cdr,X2,R).

8-enord(A,R):-enorddl(A,R-[]).

enorddl([],X-X).

enorddl([X,I,D],R-Z):-enorddl(I,R-[X|Y]),enorddl(D,Y-Z).

9-getasoc(_,[],[]).

getasoc(Llave,[[Llave,Valor ]|_],Valor):-!.

getasoc(Llave,[_|Cdr],Valor):-getasoc(Llave,Cdr,Valor).

10-insertar(X,[],[X]).

insertar(X,[Car|Cdr],[X,Car|Cdr]):-X<Car.

insertar(X,[Car|Cdr],[Car|R]):-X>=Car,insertar(X,Cdr,R).

11-inters([],_,[]).

inters([Car|Cdr],Y,[Car|R]):-miembro(Car,Y),!,inters(Cdr,Y,R).

inters([_|Cdr],Y,R):-inters(Cdr,C,D).

12-unión([],C,C).

unión([Car|Cdr],C,R):-miembro(Car,C),!,unión(Cdr,C,R).

unión([Car|Cdr],C,[Car|D]):-unión(Cdr,C,D).

13-inv(Lista,Inv):-invdl(Lista,Inv-[]).

invdl([],X-X).

invdl([Car|Cdr],R-X):-invdl(Cdr,R-[Car|X]).

14-listas(_,[],X-X,X-X):-!.

listas(X,[Car|Cdr],ma-[],[Car|me]-[]):-X>Car,!,listas(X,Cdr,ma-[],me-[]).

listas(X,[Car|Cdr],[Car|ma]-[],me-[]):-X=<Car,!,listas(X,Cdr,ma-[],me-[]).

15-miembro(X,[X|_]).

miembro(X,[_|Cdr]):-miembro(X,Cdr).

16-quicksort(L,R):-quicksortdl(L,R-[]).

quicksortdl([],X-X):-!.

quicksortdl([Car|Cdr],R-Y):-listas(Car,Cdr,ma-[],me-[]),

                                               quicksortdl(me,R-[Car|X]),

quicksortdl(ma,X-Y).

17-preord(X,R):-preorden_dl(X,R-[]).

preorden_dl([],X-X).

preorden_dl([Car|[CdrI,CdrD]],[Car|X]-Z):-preorden_dl(CdrI,X-Y),

                                                                              preorden_dl(CdrD,Y-Z).

18-posorden(Lista,ListaOrd):-posordendl(Lista,ListaOrd-[]).

posordendl([],X-X).

posordendl([X,HI,HD],T-Z):-posordendl(HI,T-Y),

                                               posordendl(HD,Y-[X|Z]).

20-hanoi(1,A,B,_,[AaB]):-!.

hanoi(N,A,B,C,Movs):-N1isN-1,hanoi(N1,A,C,B,Movs1),

                                               hanoi(N1,C,B,A,Movs2),

                                               concat(Movs1,[AaB|Movs2],Movs)

Entradas relacionadas: