Exercício de Lista em prolog.

lista.pro

/* 01 =====================
* Predicado: primeiro(L,P)
* Definição: L é uma lista e P é o primeiro dado de L.
*/

primeiro([P|_],P).

/* 02 ====================
* Predicado: segundo(L,S)
* Definição: L é uma lista e S é o segundo dado de L. 
*/

segundo([_,S|_],S).

/* 03 ===================
* Predicado: ultimo(L,U)
* Definição: L é uma lista e U é o último dado de L.
*/

ultimo([U],U).
ultimo([_,S | R], U) :- ultimo([S|R],U).

/* 04 ======================
* Predicado: penultimo(L,P)
* Definição: L é uma lista e P é o penúltimo de L.
*/

penultimo([Pe,_], Pe).
penultimo([_,S,T|R],Pe) :- penultimo([S,T|R],Pe).

/* 05 ====================
* Predicado: tamanho(L,T)
* Definição: L é uma lista e T é o número de dados de L.
*/

tamanho([],0).
tamanho([_|R],T) :- tamanho([R],TR),
T is TR + 1.

/* 06 =====================
* Predicado: pertence(D,L)
* Definição: L é uma lista e D é um dos dados de L
*/
pertence(D,[D | _]).
pertence(D,[P|T]) :- D \= P, pertence(D,T). 

/* 07 ========================
* Predicado: posicao(D,L,Pos)
* Definição: L é uma lista e Pos é a posição (iniciando com 1) 
* do dado D na lista L. Pos = 0 caso dado não esteja em L.
*/

posicao(D,[],0).
posicao(D,[P|_],1) :- D = P.
posicao(D,[P|T],Pos) :- D \= P, posicao(D,T,PosAux),
Pos is PosAux + 1.


/* 08 ==============================
* Predicado: removidoPrimeiro(L,LR)
* Definição: L é uma lista e LR é uma lista com os mesmos dados de L 
* menos o primeiro.
*/

removidoPrimeiro([P|H],H). 

/* 09 ============================
* Predicado: removidoUltimo(L,LR)
* Definição: L é uma lista e LR é uma lista com os mesmos dados de L
* menos o último.
*/

removidoUltimo([U],[]).
removidoUltimo([P|T1], [P|T2]) :- removidoUltimo(T1,T2).


/* 10 =================================
* Predicado: substituidoUltimo(D,L,LM)
* Definição: L é uma lista e LM é uma lista com os mesmos dados de L 
* com exceção do último que é D.
*/

substituiUltimo(D,[U],[D]).
substituiUltimo(D,[P|T1], [P|T2]) :- substituiUltimo(D,T1,T2).

/* 11 ==================================
* Predicado: inseridoNoInicio(D, L, LM)
* Definição: D é um dado, L é uma lista e LM é a lista L mais o dado D no início.
*/

inseridoNoInicio(D,L,[D|L]).

/* 12 =================================
* Predicado: inseridoNoFinal(D, L, LM)
* Definição: D é um dado, L é uma lista e LM é a lista L mais o dado D no final.
*/
inseridoNoFinal(D,[],[D]).
inseridoNoFinal(D,[P|T],[P|T2]) :- inseridoNoFinal(D,T,T2).

/* 13 ====================================
* Predicado: inseridoNaPos(D, Pos, L, LM)
* Definição: D é um dado, Pos é a posição onde D deve ser inserido na lista L 
* e LM é a lista L mais o dado D na posição Pos.
*/

inseridoNaPos(D,1, L,[D|L]).
inseridoNaPos(D,Pos,[P|T],[P|T2]) :- inseridoNaPos(D,PosAux,T,T2),
Pos is PosAux + 1.


/* 14 =====================================
* Predicado: removidoDaPos(L, Pos, D, LM)
* Definição: L é uma lista, Pos é a posição do dado a ser removido, 
* D é o dado removido e LM é a lista L sem o dado removido.
*/

removidoDaPos(P,1,[P|R],R).
removidoDaPos(D,Pos,[P|T1],[P|T2]) :- Pos > 1, removidoDaPos(D,PosAux,T1,T2),
Pos is PosAux + 1.

/* 15 =====================================
* Predicado: substituidoDoInicio(D, L, LM)
* Definição: D é um dado, L é uma lista e LM é a lista L com D no lugar do primeiro dado de L.
*/
 
substituiDoInicio(D,[P|T],[D|T]).
 
/* 16 =======================================
 
* Predicado: substituidoDaPos(D, Pos, L, LM)
* Definição: D é um dado, Pos é a posição do dado a ser substituído,
* L é uma lista e LM é a lista L com D no lugar do dado de L que está na posição Pos.
*/
 
substituiDaPos(D,1,[P|T],[D|T]).
substituiDaPos(D,Pos,[P|T],[P|T2]) :- D \= P, substituiDaPos(D,PosAux,T,T2),
Pos is PosAux + 1.
 
/* 17 ========================
* Predicado: invertida(L, LM)
* Definição: L é uma lista e LM é a lista L com os dados
* invertidos (o primeriro de L será o último de LM,
* o segundo de L será o penúltimo de LM e assim por diante).
*/
 
 
/* 18 =============================
* Predicado: temOcorrencias(D,L,O)
* Definição: D é um dado, L é uma lista e O é um número que indica quantas
* vezes D aparece na lista L.
*/

temOcorrencias(D,[],0).
temOcorrencias(D,[D|R],O) :- temOcorrencias(D,R,OAux), O is OAux + 1.
temOcorrencias(D,[P|R],O) :- temOcorrencias(D,R,O).
 
/* 19 ==============================
* Predicado: semOcorrencias(D,L,LM)
* Definição: D é um dado, L é uma lista e LM é a lista L sem a
* presença do dado D. A ordem dos dados em LM tem que ser a mesma de L.
*/

semOcorrencias(_,[],[]).
semOcorrencias(D,[D|T],LM) :- semOcorrencias(D,T,LM).
semOcorrencias(D,[P|T1],[P|T2]) :- D \= P, semOcorrencias(D,T1,T2).

/* 20 ================================
* Predicado: concatenadas(L1, L2, LC)
* Definição: L1 e L2 são listas e LC é a lista contendo todos os dados de L1
* seguidos de todos os dados de L2.
*/

concatenadas([],[],[]).
concatenadas([],[P|T],[P|T2]) :- concatenadas([],T,T2).
concatenadas([P|T],L2,[P|T2]) :- concatenadas(T,L2,T2).

 
/* 21 ====================
* Predicado: ehMaior(L,M)
* Definição: L é uma lista de números e M é o maior dos números.
*/

ehMaior([],M).
ehMaior([P|T],M) :- P > M, ehMaior(T,P).
ehMaior([P|T],M) :- P < M, ehMaior(T,M).
 
/* 22 ===============================
* Predicado: primeiroEUltimo(L, LPU)
* Definição: L é uma lista e LPU é uma lista contendo o primeiro
* e o último dados de L.
*/

primeiroEUltimo([P,U],[P,U]).
primeiroEUltimo([P,_,T|R],LPU) :- primeiroEUltimo([P,T|R],LPU). 
 
/* 23 ======================
* Predicado: nivelada(L,LN)
* Definição: L é uma lista que pode conter outras listas e LN é uma lista
* formada pelos dados de L com uma diferença: quando um dado de L for uma lista
* então os dados desta lista são incluídos na lista LN.
 
Exemplo: ? nivelada([a,b, [c, d], e], LN).
LN = [a, b, c, d, e]
*/
 
/* 24 ========================
* Predicado: invertida2(L,LI)
* Definição: L é uma lista e LI é uma lista formada pelos membros de L só
* que na ordem inversa. A implementação não deve usar o predicado concatenadas.
*/
 
/* 25 ======================
* Predicado: impares(L, LI)
* Definição: L é uma lista e LI é uma lista que contém os dados de L nas posições
* ímpares.
*/

impares([P],[P]).
impares([P,U],[P]).
impares([P,_,T|R],[P|Resto]) :- impares([T|R],Resto).
 
/* 26 ==================================
* Predicado: maioresQue(L1, Limite, L2)
* Definição: L1 é uma lista de números, L2 é uma lista que contém dados de L1
* que são maiores que Limite.
*/

maioresQue([],Limite,[]).
maioresQue([P|R],Limite,[P|R2]) :- P > Limite, maioresQue(R,Limite,R2).
maioresQue([P|R],Limite,[P2|R2]) :- P =< Limite, maioresQue(R,Limite, [P2|R2]).

/* 27 ===========================
* Predicado: monteLista(D, C, L)
* Definição: L é uma lista formada por C dados iguais a D.
*/

/*Corrigir 
monteLista(D,1,L).
monteLista(D,C,L) :- monteLista(D,CAux,[D|L]), C is CAux + 1.
monteLista(D,C,[]) :- monteLista(D,CAux,[D]), C is CAux + 1.
*/

Erro no exercício 7.