/********************************************************************
    Diferentes ejercicios que permiten ver el funcionamiento del trabajo con 
listas en Prolog. Adicionalmente se ve como se declaran algunos predicados con 
listas de distintos tipos de datos, sin necesidad de realizar modificaciones 
en la construci—n de las cl‡usulas.

              			Inteligencia Artificial
             			Gonzalo Villarreal Farah

Corre con la versi—n Turbo Prolog 2.0             			

********************************************************************/

	DOMAINS
	st = string
	i=integer       			     
	sy = symbol
	lst=st*
	ls=sy*
	li=i*
	ll=li*

	PREDICATES
	producto(li,i)
	sumar(li,i)
	pert_2(i,li,li)
	pert_2(sy,ls,ls)
	elimina_todos(i,li,li)
	lcomun(ls,ls,ls)
	lcomun(li,li,li)
	mayor(li,i)
	mayor(ls,sy)
	compara(li,li)
	compara(ls,ls)
	pertenece(i,li)
	pertenece(sy,ls)
	limpia_blanco(sy,sy,sy)
	lista_min(ls,ls)
	concatena(ls,ls,ls)
	concatena(li,li,li)
	tiene_largo(ls,i)
	tiene_largo(li,i)
	trae_hasta(sy,ls,ls,ls)

	comun(li,li,li)
	adyacentes(sy,sy,ls)       
	adyacentes(i,i,li)   
	seg(ls,ls)
	seg(li,li)
	frente(i,ls,ls)   	
	frente(i,li,li)
	invertida(ls,ls)           
	invertida(li,li)
	ultimo(i,li)
	ultimo(sy,ls)                                
	segin(li,li)
	segin(ls,ls)                    
	agrega(i,li,li)
	agrega(sy,ls,ls)
	segfin(ls,ls)     
	segfin(li,li)             
	elimina(i,li,li)   
	elimina(sy,ls,ls)
	sublista(li,li) 
	primer_elem(li,i)
	primer_elem(ls,sy)
	elimina_n(ls,i,ls)
	elimina_n(li,i,li)
	elemento_n(li,i,i)	
	elemento_n(ls,i,sy)
	elimina_t(sy,ls,ls)
	elimina_t(i,li,li)
	iguales(ls,ls)
	iguales(li,li)
	inter(ls,ls,ls)

	elimina_x(sy,ls,ls)
	compactada(ls,ls)
	positivos(li,li)
	incrementa_n(i,li,li)
	genera_inter(li,ll)

	CLAUSES

	% concatena dos listas

	concatena([],L,L):-!.
	concatena(L,[],L):-!.
	concatena([X|A],B,[X|C]):-concatena(A,B,C).

	% pasa a minusculas una lista de caracteres

	lista_min([],[]):-!.
	lista_min([A|L],[A1|La]):-upper_lower(A,A1),lista_min(L,La),!.

	% Borra los blancos de un string

	limpia_blanco("",St,St):-!.
	limpia_blanco(Str,Str1,Str2):-frontstr(1,Str,Fsr,Stf),Fsr=" ",!,
			    limpia_blanco(Stf,Str1,Str2).
	limpia_blanco(Str,Str1,Str2):-frontstr(1,Str,Fsr,Std),concat(Str1,Fsr,Stf),!,
			    limpia_blanco(Std,Stf,Str2).

	% Si pertenece a la lista lo elimina 

	pertenece(X,[X|_]):-!.
	pertenece(X,[_|Y]):-pertenece(X,Y),!.	

	% Si pertenece a la lista lo elimina 

	pert_2(_,[],[]):-!.
	pert_2(X,[X|L],L):-!.
	pert_2(X,[W|Y],[W|L]):-pert_2(X,Y,L),!.	

    
	% cuenta la cantidad de elemntos de un lista

	tiene_largo([],0):-!.
	tiene_largo([_|L],N):-!,tiene_largo(L,M),N=M+1,!.

	% trae los elementos de una lista hasta el caracter buscado, 
	% entregando la lista resultante.

	trae_hasta(S,[S|L],[],L):-!.
	trae_hasta(S,[X|L],[X|L1],Lf):-trae_hasta(S,L,L1,Lf).

	lcomun(L,L,L):-!.
	lcomun([A],L,[A]):-pertenece(A,L),!.
	lcomun([A],L,[]):-not(pertenece(A,L)),!.
	lcomun([A|La],L,[A|Lr]):-pertenece(A,L),lcomun(La,L,Lr),!.
	lcomun([_|La],L,Lr):-lcomun(La,L,Lr),!.
	
	% Obtiene el mayor elemento de una lista.
	
	mayor([A],A):-!.
	mayor([A,B|L],Ma):-A>B,!,mayor([A|L],Ma).	
	mayor([A,B|L],Ma):-A<=B,!,mayor([B|L],Ma).

	% compara dos listas
	
	compara(L,[]):-not(L=[]),fail,!.
	compara([],[]):-!.
	compara([A|L],La):-pert_2(A,La,Lb),!,compara(L,Lb),!.

	% elimina todos los elemntos igual a x en una lista.
	
	elimina_todos(_,[],[]):-!.
	elimina_todos(X,L,L2):-pert_2(X,L,L1),!,elimina_todos(X,L1,L2).
	elimina_todos(_,L,L):-!.

	% suma todos los elementos de una lista.
	
	sumar([],0):-!.
	sumar([X|L],N):-sumar(L,N1),N=X+N1.

	% obtiene el producto de los elementos de una lista.
	
	producto([],1):-!.
	producto([X|L],N):-producto(L,N1),N=X*N1.

	ultimo(X,[X]).
	ultimo(X,[_|Y]):-
			ultimo(X,Y).


	adyacentes(X,Y,[X,Y|_]).
	adyacentes(X,Y,[_|Z]):-
			adyacentes(X,Y,Z).

	frente(N,Y,Z):-
			concatena(Y,_,Z),
			tiene_largo(Y,N).

	segin(X,Y):-
		concatena(X,_,Y).

	segfin(X,Y):-
		concatena(_,X,Y).

	seg(X,Z):-
		segfin(Y,Z),
		segin(X,Y).

	invertida([],[]).
	invertida(X,[Y|Z]):-
		invertida(P,Z),
		concatena(P,[Y],X).

	agrega(X,L,[X|L]).

	elimina(X,[X|L],L).
	elimina(X,[Y|L1],[Y|L2]):-
		elimina(X,L1,L2).

	sublista(S,L):-
		concatena(_,L1,L),
		concatena(S,_,L1).

	primer_elem(L,P):-
		concatena([P],_,L).

	elemento_n([X|_],1,X).
	elemento_n([_|Y],N,E):-
		U=N-1,
		elemento_n(Y,U,E).

	elimina_n([_|Y],1,Y).
	elimina_n([X|Y],N,[X|Z]):-U=N-1,elimina_n(Y,U,Z).
	
	comun(L,L,L):-!.
	comun([],_,[]):-!.
	comun([X|L],L1,[X|L2]):-pert_2(X,L1,LA),!,comun(L,LA,L2).
	comun([_|L],L1,L2):-!,comun(L,L1,L2).


	elimina_x(_,[],[]).
	elimina_x(X,[X|Y],Z):-!,elimina_x(X,Y,Z).
	elimina_x(X,[Y|L],[Y|Z]):-elimina_x(X,L,Z).

	elimina_t(X,L,L1):-pert_2(X,L,La),!,
		       	elimina_t(X,La,L1).
	elimina_t(_,L,L).	     
	
	% Verifica si dos listas son iguales. O generar una lista igual.
        % iguales(I/O,I/O). 	      
	iguales([],[]).
	iguales([X|Y],[X|Z]):-iguales(Y,Z).
	
	%  Genera la intersecci¢n de dos listas
	% Inter(I,I,I/O).
	inter([],_,[]).
	inter([X|Y],L,[X|La]):-pertenece(X,L),elimina_x(X,L,Lc),!,inter(Y,Lc,La).
	inter([_|Y],L,La):-inter(Y,L,La).
	
	% Permite generar una lista eliminado todos los repetidos.
	% compactada(I,I/O).
	compactada([],[]).
	compactada([X|Y],[X|Z]):-elimina_x(X,Y,W),compactada(W,Z).		      
		     
	incrementa_n(_,[],[]).
	incrementa_n(N,[X|Y],[X1|Y1]):-X1=X+N,incrementa_n(N,Y,Y1).		     

	% Permite generar a partir de una lista de enteros, una segunda
	% lista con los elementos positivos de ella.   	
	positivos([],[]).
	positivos([X|Y],Z):-X<0,!,positivos(Y,Z).
	positivos([X|Y],[X|Z]):-positivos(Y,Z).
	
	% Permite generar intervalos entre una lista de enteros	
	genera_inter([X,Y],[[X,Y]]).
	genera_inter([X,Y|Z],[[X,Y]|W]):-genera_inter([Y|Z],W).