Prolog interativo

Numeros em Prolog

A coisa mais importante é que expressões matematicas só são calculadas em 2 contextos

• Os 2 lados de uma comparação:

X*4/Y > Z**2

• Do lado direito de um is

X is Y+2

is calcula o valor do lado direito e unifica com o lado esquerdo.

Expressões podem não dar certo em tempo de execução pois algumas variáveis podem não ter valor no momento da execução

Isso vai dar um erro

Y is X+2, X = 2

Isso vai dar algo estranho:

X = 4, Y = X+2

NAO use o = numa expressão matemática.

Isso é equivalente:

X = 2
X is 2

comparações

A > B
A >= B

A =< B

A =:= B
A =\= B

Listas

Heterogeneas, entre [ ]

[1, 2, [5,6], abobora, [] ]

Pattern matching:

[Cabeca|Resto] 
[]

[X|R] nao casa com a lista vazia

[1,2,3] = [X|R]
X = 1, R = [2,3]

Exemplo

• tamanho de uma lista

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

• com acumulador

tam(L,N) = tamx(L,N,0).
tamx([],N,Acc) :- Acc=N.
tamx([X|R],N,Acc) :- AA is Acc+1,tamx(R,N,AA).

Modo

quando vc programa tam vc assume que vc recebe a lista (+) e vai devolver o tamanho dela (-)

tam modo (+-)

Erros

tam([],0).
tam([_|R],N) :- tam(R,N), N is N+1.  <- erro

tam([_|R],N) :- tam(R,NN), N = NN+1.  <- correto

N is N+1 nunca da certo! Ou N nao tem valor, e a expressão da um erro, ou N tem valor e o lado esquerdo não unifica com o lado esquerdo

tamx([X|R],N,Acc) :- tamx(R,N,Acc+1).   <- erro

tamx([X|R],N,Acc) :-tamx(R,N,AA),  AA is Acc+1.  <- correto

Lembre-se expressões matematicas NAO sao avaliadas em passagem de parametros.

Exemplo2

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

soma([],S) :- S=0.
soma(X|R],S) :- soma(R,SS), S is SS+X.

ou

soma([],0). 
soma(X|R],S) :- soma(R,SS), S is SS+X.

exemplo3

soma dos numeros pares de uma lista somapares(+LISTA,-SOMA)

somapares([],0).
somapares([X|R),SP) :- X mod 2 == 0, somapares(R,SS),SP is SS+X.
somapares([X|R],SP) :- somapares(R,SS), SP=SS.

se X é par , ele executa a 2a regra. Se X é impar, o primeiro predicado da 2a regra falha, e o prolog executa a 3a regra.

Nao precisamos de IF/ELSE. A 2a regra testa para a condição X mod 2 == 0 e contm o THEN. A 3a regra contem o ELSE.

Outra versão

somapares([],0).
somapares([X|R),SP) :- X mod 2 == 0, somapares(R,SS),SP is SS+X.
somapares([_|R],SP) :- somapares(R,SP).

Outra versão

somapares([],0).
somapares([X|R),SP) :- somapares(R,SS),(X mod 2 == 0 , SP is SS+X ;
                                        SP=SS).

Exercícios

Da aula 1 e 2 e haskell - use acumuladores quando necessario.

o append(+,+, -)

append([],A,A).
append([X|R],A,AA) :- append(R,A,RR), AA = [X|RR].

ou 

append([X|R], A, [X|RR]) :- append(R,A,RR), 

• tamanho de uma lista

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

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

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

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

• reverte uma lista. reverte(+LISTA,-LISTAR)

• intercala 2 listas (intercala1 e intercala2)

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

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

• a lista ja esta ordenada? modo ordenada(+LISTA)

• dado n gera a lista de n a 1 range(+N,-LISTA)

• retorna o ultimo elemento de uma lista ultimo(+LISTA, -ULT)

• retorna a lista sem o utlimo elemento: semultimo(+L,-LSEMULT)

• 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 só): remove(+IT,+LISTA,-LISTASEM).

• 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 só vez): troca(+L,+VELHO,+NOVO, -LISTAtrocada)

• troca velho por novo na lista (todas vezes)

• troca velho por novo na lista n (as primeiras n vezes)