Aula 12

Da aula 1 e 2 - use acumuladores quando necessario.

• tamanho de uma lista
• soma dos elementos de uma lista soma(+LISTA,-SOMA)

soma([],0).
soma([X|R],N) :- soma(R,NN), N is NN+1.

• soma dos números pares de uma lista somap(+LISTA,-SOMA)

somap([],0).
somap([X|R],N) :- X mod 2 == 0, somap(R,NN), N is NN+X.
somap([X|R],N) :- somap(R,N). 

• soma dos elementos nas posições pares da lista ( o primeiro elemento esta na posicao 1) somapares(+LISTA,-SOMA)

somapares([],0).
somapares([_],0).
somapares([A,B|R],S) :- somapares(R,SS), S is SS+B.

• existe item na lista elem(+IT,+LISTA)

elem(X,[X|_]).
elem(IT,[_,R]) :- elem(IT,R).

• posição do item na lista: 1 se é o primeiro, falha se nao esta na lista pos(+IT,+LISTA,-POS)

pos(IT,L,P) :- pos(IT,L,P,1).
pos(IT,[X|_],P,N) :- X=IT,P=N.
pos(IT, [_|R],P,N) :- NN is N+1, pos(IT,R,P,NN)

ou

pos(IT,[IT|_],P,P).
pos(IT, [_|R],P,N) :- NN is N+1, pos(IT,R,P,NN)

• conta quantas vezes o item aparece na lista (0 se nenhuma) conta(+IT,+LISTA,-CONTA)

conta(_,[],0).
conta(X,[X|R],N) :- conta(X,R,NN), N is NN+1.
conta(X,[_|R],N) :- conta(X,R,N). 

• maior elemento de uma lista - maior(+LISTA,-MAX)

# codigo exponencial 
# eu preciso de um 1F-then-else para fazer o codigo linear
# ou um acumulador 

maior([X],X).
maior([X|R],M) :- maior(R,MM), X>MM, M=X.
maior([_|R],M) :- maior(R,M).

Com acumulador

maior([X|R],M) :- maior(R,M,X).
maior([],M,M).
maior([X|R],M,Acc) :- X > Acc, maior(R,M,X).
maior([X|R],M,Acc) :- maior(R,M,Acc).

• reverte uma lista -

rev([X|R],B) :- rev(R,B,[X]).
rev([],A,A).
rev([X|R],B,A) :- rev(R,B,[X|A]).

• intercala 2 listas (intercala1 e intercala2)

intercala1([1,2,3], [4,5,6,7,8], X).
 X =  [1,4,2,5,3,6]

intercala1([],_,[]).
intercala1(_,[],[]).
intercala1([A|RA],[B|RB],[A,B|RR] ) :- intercala1(RA,RB,RR).

intercala2([1,2,3], [4,5,6,7,8], Y),
 Y =   [1,4,2,5,3,6,7,8]

• a lista ja esta ordenada?

ordenada([]).
ordenada([_]).
ordenada([A,B|R]):- A =< B, ordenda([B|R]).

• dado n gera a lista de 1 a n

gera(N,L) :- gera(N,L,1).
gera(N,[],N).
gera(N,L,X) :- XX is X+1, gera(N,LL,XX), L = [X|LL].

• retorna o ultimo elemento de uma lista

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

• retorna a lista sem o ultimo elemento

semult(L,LS) :- rev(L,[_|LL]),rev(LL,LS).

• shift right

shiftr([1,2,3,4],X)
 X = [4,1,2,3]

• shiftr n lista (shift right n vezes)
• shift left
• shift left n vezes

• remove item da lista (1 vez so)

• remove item da lista (todas as vezes)

• remove item da lista n (as primeiras n vezes)

• remove item da lista (a ultima vez que ele aparece) **
• troca velho por novo na lista (1 so vez)
• troca velho por novo na lista (todas vezes)
• troca velho por novo na lista n (as primeiras n vezes)

Not

\+ (predicado)

OR

A ; B 

IF then else como OR

(teste, then);else

maximo([X],X).
maximo([X|R],M) :- maximo(R,MM), (MM > X, M = MM) ; M = X.

teste -> then ; else

maximo([X],X).
maximo([X|R],M) :- maximo(R,MM), (MM > X ->  M = MM ; M = X).

p :- teste, then.
p :- else.