/*1 - Definir um predicado que faça a inserção de um elemento na primeira posição de uma lista */

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

/*2 - Definir um predicado que faça a inserção de um elemento na posição N da lista*/

insereN(X,1,L,[X|L]).
insereN(X,N,[C|L],[C|R]):-N1 is N-1, insereN(X,N1,L,R).
/* Lado direito é sempre estático (resposta) */


/*3 - Definir um predicado que converta todos os valores de uma lista em seus valores absolutos*/

val_absoluto_lista([],[]).
val_absoluto_lista([C|L],[A|R]) :- abs(C,A), val_absoluto_lista(L,R).


/*4 - Escreva um predicado para encontrar o maior valor da lista*/

maior_lista([R],R).
maior_lista([C|L],R) :- maior_lista(L,A), (A > C -> R = A; R = C).
/* 					    confere a calda	     compara se o maior da calda é maior que a cabeça */


/*5- Definir o predicado ultimo(Elem, Lista) que encontra o último elemento Elem de uma lista Lista. */

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


/*6 - Verificar se dois elementos são consecutivos em uma lista. */

/* consecutivos([L],N) */
/* consecutivos([C|L],N) :- consecutivos(L,A), ( N == A -> ) */

/*7 - Somar elementos de uma lista numérica*/

somar_lista([],0).
somar_lista([C|L],S) :- somar_lista(L,A), (S is A+C).

/*8 - Encontra n-ésimo elemento de uma lista*/

encontra_n([],_,_).
encontra_n([C|_],1,C).
encontra_n([_|L],N,R) :- N1 is N-1, encontra_n(L,N1,R).

/*9 - Determinar o número de elementos de uma lista*/

tamanho_lista([],0).
tamanho_lista([_|L],N) :- tamanho_lista(L,N1), N is N1+1.

/*10 - Retirar uma ocorrência de uma lista*/

remove_x1(X,[X|T], T).
remove_x1(X,[C|T], [C|T1]) :- remove_x1(X,T,T1).

/*11 - Retirar todas as ocorrências de uma lista*/

remove_x(_,[],[]).
remove_x(X,[X|T], L)      :- remove_x(X,T,L).
remove_x(X,[C|T], [C|T1]) :- X \= C, remove_x(X,T,T1).

/*12 - Substituir o elemento de uma lista por outro elemento*/

/* Na posição */
subst_n(X,1,[_|L],[X|L]).
subst_n(X,N,[C|L],[C|R]) :- N1 is N-1, subst_n(X,N1,L,R).

/* por elemento */
subst_x(_,_,[],[]).
subst_x(X,Y,[X|L],[Y|L1]) :- subst_x(X,Y,L,L1).
subst_x(X,Y,[Z|L],[Z|L1]) :- subst_x(X,Y,L,L1).

/*13 - Dividir uma lista numérica em duas sublistas <= e >*/

div_lista(_,[],[],[]).
div_lista(X,[H|T],[H|L],R) :- H =< X, div_lista(X,T,L,R).
div_lista(X,[H|T],L,[H|R]) :- H > X, div_lista(X,T,L,R).


/* Leitura e escrita */

/* write(String) */
/* read(Nome_Var) */

/* Cut '!' -> Se conseguir unificar não executa mais nada */

/*Maior*/
maior(X,Y,X) :- write('1'),X>=Y,!.
maior(X,Y,Y) :- write('2'),X<Y.

/*Fail 'fail' -> obriga a falhar (não precisa do ;)*/

/* Ex4 */
conecta(a,b).
conecta(b,c).
conecta(a,d).
conecta(d,c).
conecta(d,e).

lista(L):-findall( (X,Y),conecta(X,Y),L ).

/* Ex5 - Existe um caminho de X pra Y */

/* Caminho direto */
caminho(X,Y,[X,Y]):-conecta(X,Y).
/* X conecta com Z e Z conecta com Y chama recursivo colocando X na cabeça */
caminho(X,Y,[X|L]):-conecta(X,Z),caminho(Z,Y,L).

/* Ex6 - Alunos */

matricula(andre,pp).
matricula(andre,pi).
matricula(andre,mult).
matricula(andre,vvs).

matricula(bob,pp).
matricula(bob,paa).
matricula(bob,lp).
matricula(bob,poo).

matricula(carlos,ipo).
matricula(carlos,grafos).
matricula(carlos,mult).
matricula(carlos,bd).

matricula(dado,grafos).
matricula(dado,pp).
matricula(dado,lp).
matricula(dado,c1).

nota(andre,pp , 5).
nota(andre,pi , 5).
nota(andre,mult  , 5).
nota(andre,vvs, 5).

nota(bob,pp ,5).
nota(bob,paa,8).
nota(bob,lp ,9).
nota(bob,poo,6).

nota(carlos,ipo,9).
nota(carlos,grafos  ,4).
nota(carlos,mult  ,4).
nota(carlos,bd ,5).

nota(dado,grafos ,4).
nota(dado,pp,7).
nota(dado,lp,8).
nota(dado,c1,9).



/*disciplinas(Aluno,L):-*/
disciplinas(Aluno,L):-bagof( Materia, matricula(Aluno,Materia), L).
/*Lista de disciplinas do aluno*/

/*alunos(Disc,L):-*/
/* Lista alunos na disciplina */
alunos(Disc,L):-bagof( Aluno, matricula(Aluno,Disc),L ).


/*media_disc(Disc,M):-*/
/* Média de notas na disciplina */
media_disc(Disc,F) :- findall(N,nota(_,Disc,N),M), tamanho_lista(M,T), somar_lista(M,R), F is R/T.


/*media_aluno(Aluno,M):-*/
/* Media de notas do aluno */
media_aluno(Aluno,F) :- findall(N,nota(Aluno,_,N),M), tamanho_lista(M,T), somar_lista(M,R), F is R/T.

/*reprovados(L):-*/
/* lista de alunos reprovados em alguma disciplina. L=[(aluno,disc,nota)] */
reprovados(L) :-
	findall((Aluno,Disciplina,Nota),(nota(Aluno,Disciplina,Nota), Nota < 5),L).


/* não converte pra asc */
/* set_prolog_flag(double_quotes,chars) */






/*Gramática*/
/* set_prolog_flag(double_quotes,chars). */

reg --> ("a";"b";"c";"d"),"x". /* ax - bx - cx - ... */
bin --> ("0";"1");("0";"1"),bin.

arep --> ("";"a";arep).
brep --> ("";"b";brep).

aba --> "a",brep,"a". /* <aba> -> a {b}+ a */


ab --> "ab";("a",ab,"b"). /* <ab> -> {a}+{b}+ */

ab2 --> brep2,"a",arep2,"b".
brep2 --> "b";("b",brep2).
arep2 --> "a";("a",arep2).

/* swipl  no terminar para abrir o prolog */
/*abrir arquivo ['nome do arquivo.pl'].*/
/* para gramaticas */
/* set_prolog_flag(double_quotes,chars). para representar os caracteres como letras e nao pelo codigo ASCII das letras. */

/* Calcula MDC entre dois números inteiros.*/
mdc(X,0,Z) :- !, Z = X.
mdc(X,Y,Z) :- R is X mod Y, mdc(Y,R,Z).

/* Lista é palíndromo.*/
pali(X) :- reversa(X,X).

reversa([],[]).
reversa([X|Y],Z) :- reversa(Y,W), append(W,[X],Z).

append([],L,L).
append([X|Y],Z,[X|W]) :- append(Y,Z,W).

/* Duplica elementos da lista.  Exemplo: recebe [a,b,c] retorna [a,a,b,b,c,c].*/
duplica([],[]).
duplica([X|Y],[X,X|Z]) :- duplica(Y,Z).

/* Intervalo(i,j) que imprime os números naturais de i a j inclusive.*/
intervalo(I,J) :- I > J, !, fail.
intervalo(I,J) :- write(I), nl, I1 is I+1, intervalo(I1,J).

/* Fatorial*/
fatorial(0,1).
fatorial(N,F): N>0, N1 is N-1, fatorial(N1,F1), F is N * F1.

    fatorial(X,1) :- X > 0 , X =:= 0 ; X =:= 1.
fatorial(X,R) :- X > 0 , X1 is (X-1) , fatorial(X1, R1), R is (R1*X).

/* Ordenação de uma lista com o algoritmo insertion sort*/
isort([],[]).
isort([H|T],L) :- isort(T,T1), ins(H,T1,L).
ins(X,[],[X]).
ins(X,[Y|Ys],[Y|Zs]) :- X > Y, ins(X,Ys,Zs).
ins(X,[Y|Ys],[X,Y|Ys]) :- X =< Y.

/* Apaga todas as ocorrências de um dado elemento de uma lista*/
apaga([H|T],H,L) :- apaga(T,H,L).
apaga([H|T],X,[H|L]) :- H \== X, apaga(T,X,L).
apaga([],_,[]).

/* subtermo(T1,T2) testa se T1 é subtermo de T2 */
subtermo(T1,T2) :- T1 == T2.
subtermo(S,T) :- compound(T), functor(T,F,N), subtermo(N,S,T).
subtermo(N,S,T) :- N>1, N1 is N-1, subtermo(N1,S,T).
subtermo(N,S,T) :- arg(N,T,A), subtermo(S,A).

/* mínimo */
minimo(X,Y,Y) :- X >= Y.
minimo(X,Y,X) :- X < Y.

/* progenitor */
progenitor(A,B) :- pai(A,B).
progenitor(A,B) :- mae(A,B).
avo(X,Y) :- progenitor(X,Z), progenitor(Z,Y).
progenitor(A,B) :- pai(A,B) ; mae(A,B).
tio(X,Y) :- (pai(A,Y) ; mae(A,Y)), irmao(X,A).

/* Considere o seguinte código */
amigo(ana,rui).
amigo(pedro,rui).
amigo(maria,helena).
amigo(pedro,ana).
amigo(maria,rui).
gosta(ana,cinema).
gosta(ana,pintura).
gosta(ana,ler).
gosta(rui,ler).
gosta(rui,musica).
gosta(maria,ler).
gosta(pedro,pintura).
gosta(pedro,ler).
compativeis(A,B) :- amigo(A,B), gosta(A,X), gosta(B,X).
compativeis(A,B) :- amigo(B,A), gosta(A,X), gosta(B,X).

/* findall, bagof e setof */
/*
findall(X,compativeis(ana,X),L).
L = [rui,pedro,pedro]
*/
/*
bagof(X,compativeis(ana,X),L).
 L = [rui,pedro,pedro]
*/
/*
setof(X,compativeis(ana,X),L).
 L = [pedro,rui]
*/

/* Reverter uma lista */
/* reverse([1,3,5,7,9],X). */

/* ultimo elemento de uma lista */
ultimo([Elem],Elem).
ultimo([_|Cauda],Elem) :- ultimo(Cauda,Elem).

/* soma dos elementos de uma lista */
soma([],0).
soma([Elem|Cauda],S) :- soma(Cauda,S1), S is S1+Elem.

/* n-ésimo elemento de uma lista */
n_esimo(1,Elem,[Elem|_]).
n_esimo(N,Elem,[_|Cauda]) :- n_esimo(M,Elem,Cauda), N is M+1.

/* numero de elementos de uma lista */
no_elem([],0).
no_elem([Elem|Cauda],N) :- no_elem(Cauda,N1), N is N1+1.

/* maior elemento de uma lista numerica */
max([X,Y|Cauda],Max) :- X >= Y, !, max([X|Cauda],Max).
max([X,Y|Cauda],Max) :- max([Y|Cauda],Max).

/* Usando a base ao lado, defina a regra: uma pessoa pode roubar algo se essa pessoa é um ladrão e ela gosta de um objeto.
Qual a resposta dada por Prolog à pergunta: João rouba o que? Como seria a pergunta?*/

ladrao(joao).
ladrao(pedro).
gosta(maria,comida).
gosta(maria,vinho).
gosta(joao,rubi).
gosta(joao,X):- gosta(X,vinho).

roubo(X,Y):- ladrao(X), gosta(X,Y).

/*Exercício 2*/

/* progenitor(X,Y) significa que X é progenitor de Y */
progenitor(pedro, carlos).
progenitor(pedro, ana).
progenitor(carlos,antonio).
progenitor(carlos,maria).
progenitor(joana,antonio).
progenitor(joana,maria).
progenitor(joana,ana).

/* definindo alguns fatos sobre o sexo */
homem(pedro).
homem(carlos).
homem(antonio).
mulher(ana).
mulher(maria).

/* pai(X,Y) significa que X é pai de Y */
pai(X,Y):-progenitor(X,Y) , homem(X).

/* mae(X,Y) significa que X é mãe de Y */
mae(X,Y):-progenitor(X,Y), mulher(X).

irma(X,Y) :- pai(P,X), pai(P,Y), mulher(Y), X \= Y.
irma(X,Y) :- mae(P,X), mae(P,Y), mulher(Y), X \= Y.

/*Exercício 3*/
/*Para a árvore genealógica do exemplo, defina as regras:
filho, filha
avo, avó
irmão, irmã
primo, prima
tio, tia
sobrinho, sobrinha*/


filho(X,Y) :- progenitor(Y,X), homem(X).
filha(X,Y) :- progenitor(Y,X), mulher(X).
filhos(X,Y) :- progenitor(X,Y).


avo(X,Y) :- pai(P,X), pai(Y,P).
avoh(X,Y) :- mae(P,X), mae(Y,P).

irma(X,Y) :- progenitor(P,X), progenitor(P,Y), mulher(Y), X \= Y.
irmao(X,Y) :- progenitor(P,X), progenitor(P,Y), homem(Y), X \= Y.

tio(X,Y) :- progenitor(P,Y), irmao(X,P).
tia(X,Y) :- progenitor(P,Y), irma(X,P).

primo(X,Y) :- homem(X), progenitor(T,X), progenitor(P,Y), irmao(T,P) ; irma(T,P).
prima(X,Y) :- mulher(X), progenitor(T,X), progenitor(P,Y), irmao(T,P) ; irma(T,P).

sobrinho(X,Y) :- tio(Y,X) ; tia(Y,X).
sobrinha(X,Y) :- tio(Y,X) ; tia(Y,X).

casou(joao, maria, dia(5, maio, 2000)).
casou(jose,claudia, dia(11,novembro,1950)).
casou(andre, fernanda, dia(11, agosto, 1960)).
casou(adriano, claudia, dia(15, outubro, 1973)).

/*
casou(_,maria,X).
casou(andre,_, dia(_,X,_)).
casou(adriano,_,dia(_,_,X)) , casou(Y,H,dia(_,_,Z)), Z =< X.
casou(A,B,dia(_,_,X)) , X >= 1984.
casou(A,B,dia(_,_,X)) , X =< 1990, X >= 1960.
*/

/* bicharada */
canario(piupiu).
peixe(nemo).
tubarao(tutu).
vaca(mimosa).
morcego(vamp).
avestruz(xica).
salmao(alfred).
peixes(X) :- peixe(X) ; tubarao(X) ; salmao(X).
passaros(X) :- canario(X) ; avestruz(X).
mamifero(X) :- vaca(X) ; morcego(X).
animal(X) :- peixes(X) ; passaros(X) ; mamiferos(X).
delicia(X) :- salmao(X).
cor(X,Y) :- canario(X), Y = amarelo.
grande(X) :- avestruz(X).
anda(X) :- avestruz(X) ; (mamifero(X), not(morcego(X))).
alimento(X) :- vaca(X) ; delicia(X).
pele(X) :- animal(X).
nadadeira(X) :- peixes(X).
nada(X) :- peixes(X).
asas(X) :- passaros(X) , not(avestruz(X)) ; morcego(X).
voa(X) :- passaros(X) , not(avestruz(X)) ; morcego(X).
ovos(X) :- passaros(X) ; peixes(X), not(tubarao(X)).

/*Exemplo de Lista*/

lista1([[], dead(z), [2, [b,c]], [], Z, [2, [b,c]]]).

/*Cabeça e Calda*/

lista1([X|Y]).


/*Concatenação de Listas*/

conc([ ], L, L).
conc(L, [ ], L).
conc( [X | L1], L2, [X | L3]) :- conc(L1, L2, L3).

/*Definir um predicado que faça a inserção de um elemento na primeira posição de uma lista*/

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

/*Definir um predicado que converta todos os valores de uma lista em seus valores absolutos*/

labs([],[]).
labs([C|L],[Y|L1]) :- abs(C,Y), labs(L,L1).


/*Escreva um predicado para encontrar o maior valor da lista*/

maior([C] , C).
maior([C|L] , Maior) :- maior(L, C1), (C >= C1 -> Maior = C ; Maior = C1).

/*Definir o predicado ultimo(Elem, Lista) que encontra o último elemento Elem de uma lista Lista.
- O último elemento de uma lista que tem somente um
elemento é o próprio elemento
- O último elemento de uma lista que tem mais de um elemento
é o último elemento da cauda*/

ultimo( listaVazia , []).
ultimo(Resp, [Resp]).
ultimo(Resp, [H|T]) :- ultimo(Resp,T).


/*Definir um predicado que faça a inserção de um elemento na n-esima posição de uma lista*/

/*inserePosN(Elem, [], _ , [Elem]).*/
inserePosN(Elem, L , 0 , [Elem|L]).
inserePosN(Elem, [H|T], Pos, [H|Resp1]) :- Pos1 is Pos-1, inserePosN(Elem, T, Pos1, Resp1).

/* Regras Gramaticais em Prolog*/

/* cabeca --> corpo. */

reg --> ("a";"b";"c";"d"), "x".

bin --> ("0";"1") ; ("0";"1"), bin.

binfrac --> bin, (".", bin; "").

aba --> "a" , brep, "a".
brep --> ("";"b", brep).


ss --> "a" , ss , "b" ; "ab".

/* Faca um predicado que descreva a seguinte gramatica

<expr> -> <termos> {(+|-) <termo>}
<termo> -> <fator> {(*|'/') <fator>}
<fator> -> <exp> { ** <exp>}
<exp> -> '(' <expr> ')' | <id>
<id> -> A | B | C | D

*/

expr --> termo, termo1.
termo1 --> "";("+";"-"), termo, termo1.
termo --> fator, fator1.
fator1 --> ""; ("*";"/"), fator, fator1.
fator --> exp, exp1.
exp1 --> "" ; "**", exp, exp1.
exp --> "(", expr, ")" ; id.
id --> "A";"B";"C";"D".


/*Representar, em Prolog, o problema de verificar se há um caminho entre duas cidades quaisquer calculando a distância entre elas. O predicado deve retornar a lista com o caminho e a distância total percorrida*/

conecta(saocarlos,araraquara,50).
conecta(saocarlos,jau,100).
conecta(saocarlos,bauru,170).
conecta(jau,bauru,20).
conecta(bauru,araraquara,130).
conecta(bauru,ribeiraobonito,114).
conecta(ribeiraobonito,araraquara,70).


caminho(X,Y,[X,Y],Z) :- conecta(X,Y,Z).
caminho(X,Y,[X|L],D) :- conecta(X,Z,D1), caminho(Z,Y,L,D2), D is D1+D2.


menorDist(X,Y,L,D) :- setof((D1,L1),caminho(X,Y,L1,D1),[(D,L)|_]).


/*Faca um predicado que ordene uma dada lista usando o insert sort*/

menorElem([H],H).
menorElem([H|T],M) :- menorElem(T,M1), (H < M1, M = H ; M =M1).

/*
ordena([],[]).
ordena([H|T],L) :- ordena(T,L1), insere(E,L1).

insere(X, [H|T],[H|T1]) :- X > Y, insere(X,L,L1), !.
insere(X,L,[X|L]).

*/