Operaciones con Listas en lenguaje Prolog (Invierte, Palindroma, Sublista, Ultimo)

Listas: ultimo, invierte, palindroma, busca, sublista

ultimo([],E,[E|[]]).
ultimo([H|T],E,[H|R]) :- ultimo(T,E,R).

invierte([],[]) :- !.
invierte([H|T],R) :- invierte(T,R1), ultimo(R1,H,R), !.
invierte(L,R) :- invierte(R,L) , !.

palindroma([]).
palindroma([_|[]]).
palindroma([H|T]) :- ultimo(P,H,T), palindroma(P).
%p2(T) :- invierte(T,T).

b2([],_).
b2([H|T],[H|T2]) :- b2(T,T2).
busca([],[]).
busca([H|T],[H|T2]) :- b2(T,T2),!.
busca(L,[_|T]) :- busca(L,T).

sublista([H|_],1,1,[H|[]]).
sublista([H|T],1,S,[H|T2]) :- S>1,S2 is S-1, sublista(T,1 ,S2,T2).
sublista([_|T],I,S,R ) :- I>1,I2 is I-1, sublista(T,I2,S ,R ).

Métodos de Ordenación en lenguaje Prolog

%%%%%%%%%%%%%%%%%%% 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),Bordena3(L1,L1).

Cálculos Numéricos con Listas en Lenguaje Prolog (Primos, MCD, Combinatorios, ..)

%%%%%%%%%%%%%% 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):-H1mcd([H1|T1],[H2|T2],N,M):-H2
%-----------------------------------------------------

% Ejercicio 2.14. Numeros combinatorios y triangulo de Pascal.

% a)

c(_,0,1):-!.
c(M,M,1):-!.
c(M,N,R):-M1 is M-1, N1 is N-1,c(M1,N,A),c(M1,N1,B),R is A+B.

% b)

tr([X],[X]).
tr([X,Y|L],[H|T]):-H is X+Y,tr([Y|L],T).

f(0,[1]):-!.
f(M,[1|L]):- M1 is M-1, f(M1,L1), tr(L1,L).

% Version mas eficiente porque no se repiten calculos

c2(M,N,R):-f(M,L), ele(N,L,R).
ele(0,[H|_],H).
ele(N,[_|T],X):- N>0,N1 is N-1, ele(N1,T,X).

Aplanar una lista (de listas) en Lenguaje Prolog

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).

Eliminar Elementos Repeditos de dos Listas en Lenguaje Prolog

Eliminación de elementos repetidos.

elim([],[]).
elim([H|T],S):-member(H,T),!,elim(T,S).
elim([H|T],[H|S]):-elim(T,S).

Trenzar Dos o mas Listas en Prolog

% Trenzar dos listas.

trenza([],L,L).
trenza([H|T],R,[H|S]):-trenza(R,T,S).

%----------------------------------------------------


% Trenzar varias listas.


trenza2([],[]).
trenza2([[]|T],R):-trenza2(T,R).
trenza2([[H|T]|R],[H|S]):-append(R,[T],U),trenza2(U,S).

Invertir Lista en Lenguaje Prolog

Inversion de una lista

reverse([],[]).
reverse([H|T],L):-reverse(T,S),append(S,[H],L).

% o bien mas eficiente, utilizando un parametro acumulador.

rev(L1,L2):-rev(L1,L2,[]).

rev([],L,L).
rev([H|T],L,S):-rev(T,L,[H|S]).

Sustituir un Elemento por otro En lenguaje Prolog

% 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).

Funciones Fibonacci y Cálculo de la Suma en Lenguaje Prolog

/*a) Escriba un predicado suma(N,R) que sea cierto cuando R sea la suma de los naturales desde el 1 hasta N. */

suma(1,1).
suma(N,R):- not(N=0),L is N-1,K is R-N,suma(L,K).

/*b) Escriba un predicado fibo(N,R) que sea cierto cuando R sea el enésimo elemento de la serie de Fibonacci. */

fibo(1,1).
fibo(2,1).
fibo(N,R):- not(N=0),L is N-1,H is N-2,fibo(L,T),fibo(H,S),R is T+S.

Operaciones Sobre Conjuntos en Lenguaje Prolog (Miembro, Subconjunto, Disjuntos, Interseccion, Diferencia, ...)

/* Parte a) miembro(X,L), el cual es cierto si el elemento X está en la lista L */
miembro(X,[X|_]):- !.
miembro(X,[_|Y]):- miembro(X,Y).

/*Parte b) subconjunto (L,K), el cual es válido si L es un subconjunto de K*/
subconjunto([],_).
subconjunto([A|B],K):- miembro(A,K), subconjunto(B,K).

/*Parte c) disjuntos (L,K), el cual es cierto si L y K son conjuntos disjuntos (no tienen elementos en común).*/
disjuntos([],_):- not(fail).
disjuntos([A|B],K):- not(miembro(A,K)), disjuntos(B,K).

/*Parte e) interseccion(A,B,R), el cual es válido si R es la intersección de A y B*/
interseccion([],_,[]).
interseccion([A|B],D,[A|R]):- miembro(A,D), interseccion(B,D,R).
interseccion([A|B],D,R):- not(miembro(A,D)), interseccion(B,D,R).

/*Parte d) diferencia (L,K,M), el cual es válido si M es la diferencia de L y K*/
diferencia([],_,[]).
diferencia([A|B],K,M):- miembro(A,K), diferencia(B,K,M).
diferencia([A|B],K,[A|M]):- not(miembro(A,K)), diferencia(B,K,M).

/*Ejercicio7): Defina un predicado reemplaza (L, X, Y, Z) el cuál es válido si la lista Z es igual a la lista L sustituyendo el elemento X por el elemento Y*/
reemplaza([],_,_,[]).
reemplaza([X],X,Y,[Y]).
reemplaza([A|B],A,Y,[Y|L]):- reemplaza(B,A,Y,L).
reemplaza([A|B],X,Y,[A|L]):- A\=X, reemplaza(B,X,Y,L).

/*Ejercicio8): Define un predicado borra(L, X, Z) el cual es cierto si Z es igual a la lista L tras eliminar todas las ocurrencias del elemento X*/
borra([X],X,[]).
borra([A|B],A,Z):- borra(B,A,Z).
borra([A|B],X,[A|Z]):- A\=X, borra(B,X,Z).

Longitud, Ocurrencia, Posicion y Concatenar Listas en Lenguaje Prolog

/*Ejercicio2): Defina un predicado longitud(L,N) el cual es válido si N contiene la longitud de la lista L*/
longuitud([],0).
longuitud([_|A],N):- longuitud(A,B), N is B+1.

/*Ejercicio3): Defina un predicado ocurrencia(X,L,N) el cual es válido si el elemento X aparece N veces en la lista L*/
ocurrencia(_,[],0).
ocurrencia(X,[A|C],N):- X\=A, ocurrencia(X,C,N).
ocurrencia(X,[A|C],N):- X=A, B is N-1, ocurrencia(X,C,B).

/*Ejercicio4): Defina un predicado posicion(N,L,X) el cual es válido si X es el elemento que ocupa la posición N de la lista L*/
posicion(1,[A|_],A).
posicion(N,[_|B],A):- Aux is N-1, posicion(Aux,B,A).

/*Ejercicio5): Defina un predicado concatena(L, M, N) el cuál es válido si la lista N es la concatenación de las listas L y M*/
concatena([],L,L).
concatena([_|A],M,[_|N]):- concatena(A,M,N).

Rama Familiar en Lenguaje Prolog (Hermano, Primo, Nieto..)

Dados un conjunto de hechos de la forma padre(nombre1,nombre2), donde nombre1 es el padre de nombre2:

* padre(antonio,juan).
* padre(antonio,carlos).
* padre(juan,diana).
* padre(juan,elena).
* padre(carlos,felipe).

Defina los siguientes predicados:

* hermano(X,Y) el cual es válido si X e Y son hermanos/as.
* primo(X,Y) el cual es válido si X e Y son primos.
* nieto(X,Y) el cual es válido si X es nieto/a de Y.
* descendiente(X,Y) el cual es verdadero si X es descendiente de Y.


/*A)hermano(X,Y) verdadero si X es hemano/a de Y. Hijos de igual madre y padre.*/
hermano(X,Y):-padre(A,X), padre(A,Y), not(X=Y).

/*B)primo(X,Y) verdadero si X es primo de Y.*/
primo(X,Y):-hermano(A,B), padre(A,X), padre(B,Y), not(X=Y).

/*C)nieto(X,Y) verdadero si X es nieto de Y.*/
nieto(X,Y):-padre(Y,A), padre(A,X), not(X=Y).

/*D)descendiente(X,Y) verdadero si X es descendiente de Y.*/
descendiente(X,Y):-padre(Y,X).
descendiente(X,Y):-nieto(Y,X).