%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%% GESTION DE LISTAS %%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% append([],L,L). append([H|T],R,[H|S]):-append(T,R,S). dappend(A,B,C,D):-append(A,B,E),append(E,C,D). dappend2([],A,B,C):-append(A,B,C). dappend2([H|T],A,B,[H|C]):-dappend2(T,A,B,C). member(X,[X|_]). member(X,[_|T]):-member(X,T). member2(X,L):-append(_,[X|_],L). len([],0). len([_|T],N):-len(T,N1),N is N1+1. %---------------------------------------------------- % Ejercicio 3.6. Elementos seguidos en una lista seguidos(L,X,Y):-append(_,[X,Y|_],L). %---------------------------------------------------- % Ejercicio 6.12 (Variante). % Substring comprendido entre dos elementos sublist(L,X,Y,S):-append(_,[X|R],L),append(S,[Y|_],R). %---------------------------------------------------- % Ejercicio 3.7. Sustituir un elemento por otro. sus(_,_,[],[]). sus(X,Y,[X|T],[Y|S]):-!,sus(X,Y,T,S). sus(X,Y,[Z|T],[Z|S]):-sus(X,Y,T,S). %---------------------------------------------------- % Ejercicio 3.8. Listas con la misma longitud e38(L1,L2):-len(L1,N),len(L2,N). % o bien e382([],[]). e382([_|R],[_|S]):-e382(R,S). %---------------------------------------------------- % Ejercicio 3.9. Listas con iguales elementos en igual orden. e39(L,L). %---------------------------------------------------- % Ejercico 3.10. Listas con iguales elementos en cualquier orden. e310([],[]). e310([H|T],L):-append(L1,[H|L2],L),append(L1,L2,L3),e310(T,L3). %---------------------------------------------------- % Ejercicio 4.3. Inversion de una lista reverse([],[]). reverse([H|T],L):-reverse(T,S),append(S,[H],L). % o bien ´as efici9ente, utilizando un parametro acumulador. rev(L1,L2):-rev(L1,L2,[]). rev([],L,L). rev([H|T],L,S):-rev(T,L,[H|S]). %---------------------------------------------------- % Ejercicio 7.2. Trenzar dos listas. trenza([],L,L). trenza([H|T],R,[H|S]):-trenza(R,T,S). %---------------------------------------------------- % Ejercicio 2.15. Trenzar varias listas. trenza2([],[]). trenza2([[]|T],R):-trenza2(T,R). trenza2([[H|T]|R],[H|S]):-append(R,[T],U),trenza2(U,S). %---------------------------------------------------- % Ejerccio 2.17. Eliminación de elementos repetidos. elim([],[]). elim([H|T],S):-member(H,T),!,elim(T,S). elim([H|T],[H|S]):-elim(T,S). %----------------------------------------------------- % Ejercicio 2.19. Aplanar una lista (de listas). aplana([],[]). aplana([[H|T]|R],S):-aplana([H|T],T1),aplana(R,R1),append(T1,R1,S),!. aplana([[]|T],S):-aplana(T,S),!. aplana([H|T],[H|S]):-aplana(T,S). %----------------------------------------------------- %%%%%%%%%%%%%% CALCULOS NUMERICOS CON LISTAS %%%%%%%%%%%%%%%% % Lista de naturales lnat([0]). lnat([A,B|C]):-lnat([B|C]),A is B+1. %----------------------------------------------------- % Ejercicio 3.2. Lista infinita de a's. lia([a]). lia([a|R]):-lia(R). %----------------------------------------------------- % Ejercicio 3.3. Lista de negativos. l3([-1]). l3([A,B|C]):-l3([B|C]), A is B-1. %----------------------------------------------------- % Ejercicio 7.7. Lista de multiplos lmul(N,[N]). lmul(N,[A,B|C]):-lmul(N,[B|C]),A is B + N. %----------------------------------------------------- % Ejercicio 3.12. N-esimo numero triangular e312(N,M):-lnat([H|T]), len(T,N), sumalist([H|T],M). sumalist([],0). sumalist([H|T],N):-sumalist(T,M),N is H + M. % o bien e3122(0,0):-!. e3122(X,Y):-X1 is X-1, e3122(X1,Y1), Y is Y1+X. %----------------------------------------------------- % Ejercicio 7.8. Lista de fibonaccis lfib([1]). lfib([1,1]). lfib([A,B,C|R]):-lfib([B,C|R]), A is B+C. % Para obtener un numero de fibonacci hay dos metodos ineficientes. fib(0,1). fib(1,1). fib(N,M):-N>1,N1 is N-1, N2 is N-2, fib(N1,M1),fib(N2,M2),M is M1 + M2. % o bien fib2(N,M):-lfib([M|L]),len(L,N). % La version eficiente es fib3(N,M):-auxfib(N,M,_). auxfib(0,1,_). auxfib(1,1,1). auxfib(N,M,M1):-N1 is N-1, auxfib(N1,M1,M2), M is M1+M2. %----------------------------------------------------- %Ejercicio 3.4 . Lista de numeros Primos nat(0). nat(X):-nat(Y), X is Y +1. nodiv(_,[]). nodiv(N,[H|T]):-X is N mod H,X\==0,nodiv(N,T). sigprimo([H|T],N):-nat(R),N is H + R,nodiv(N,[H|T]),!. primos([2]). primos([A,B|T]):-primos([B|T]),sigprimo([B|T],A). % Factores Primos de un numero factores(N,L):-factores(N,[2],L). factores(N,_,[]):-(N=0;N=1;N=1.0),!. factores(N,[H|T],[H|L]):- 0 is N mod H,!,N1 is N / H,factores(N1,[H|T],L). factores(N,[H|T],L):-sigprimo([H|T],H1),factores(N,[H1,H|T],L). % maximo comun divisor de dos numeros mcd(N1,N2,N3):-factores(N1,L1),factores(N2,L2),mcd(L1,L2,N3,1). mcd([],_,N,N). mcd(_,[],N,N). mcd([H|T1],[H|T2],N,M):-M1 is M*H, mcd(T1,T2,N,M1). mcd([H1|T1],[H2|T2],N,M):-H10,N1 is N-1, ele(N1,T,X). % ---------------------------------------------------- %%%%%%%%%%%%%%%%%%% ORDENACION %%%%%%%%%%%%%%%%%%%%%% % Ordenacion por permutacion. ordena1(L,S):-permutacion(L,S),ordenada(S). permutacion([],[]). permutacion([H|T],S):-permutacion(T,T1),guarda(H,T1,S). guarda(X,L,[X|L]). guarda(X,[H|T],[H|S]):-guarda(X,T,S). ordenada([]). ordenada([_]). ordenada([A,B|T]):-A>=B,ordenada([B|T]). % ---------------------------------------------------- % Ordenacion por insercion. ordena2([],[]). ordena2([H|T],S):-ordena2(T,R),inserta(H,R,S). inserta(X,[],[X]). inserta(X,[H|T],[X,H|T]):-X>=H,!. inserta(X,[H|T],[H|S]):-inserta(X,T,S). % ---------------------------------------------------- % Ordenacion por el metodo de la burbuja. ordena3(L1,L2):-append(U,[A,B|V],L1),B