LISTAS Uma lista é uma estrutura de dados muito comum na programação não numérica (com particular destaque na computação simbólica onde representa quase todo o tipo de estrutura)  principal estrutura de dados na linguagem Lisp (List Processing) . As listas representam árvores de parsing (léxicas), gramáticas, programas e entidades matemáticas tais como: grafos, fórmulas e funções. Programação Declarativa

Representação Notação . (adequada para representação em árvore) Tradicionalmente uma lista é representada pelo termo •(X, L) em que X é um elemento e L o resto da lista. A lista vazia denota-se por nil. Notação PROLOG Uma lista é um termo [X|L] em que X é o primeiro elemento e L é a lista resto (sub-lista). A lista vazia denota-se por []. Dizemos que X é a cabeça da lista e L é a cauda. [X|L] denota a lista (não vazia) cuja cabeça é o objecto X e a cauda é a lista L X1, X2, ..., Xn denota a lista constituída pelos objectos X1, X2, ..., Xn. Programação Declarativa

Exemplos  a   a |    1, 2, 3   1 |  2, 3   1, 2, 3   1 |  2, 3   a, b |  c    a |  b |  c    [ a | L] [ X | L] Termos equivalentes •(a, nil) [a] [a| [] ] •(a, •(b,nil)) [a,b] [a|[b] ] [a,b| [] ] •(a, •(b,X)) [a,b|X] Programação Declarativa

Listas Podemos definir lista como list([]). list([X|L]) :- list([L]). Ao contrário das linguagens funcionais, em Prolog uma lista é um objecto polimórfico. Isto é, podemos ter listas com objectos de diferentes tipos. Por exemplo: [a, 1, ana, 8.32, [a,b,c], X, ola, 6, [1, [2,3], c], fim] Programação Declarativa

Unificação de listas e correspondentes substituições Lista1 Lista2 substituição  X, Y, Z   a, 2, b  { X/a, Y/2, Z/b }  ana   X | L  { X/ana, L/ }  X, 8 | L   a, Y, b  { X/a, Y/8 L/b }  X | L   a, 10, b  { X/a, L/10,b }  X   a, 12  não unificáveis  X |  Y | Z    a, 12, b  { X/a, Y/12, Z/b }  c | L1   Y, a | L2  { L1/ a | L2, Y/c } Programação Declarativa

Alguns predicados básicos para manipular listas MEMBRO (member*) Determinar se um elemento é membro de uma lista (member). X é membro de uma lista L (member(X,L)) se X é a cabeça de L, ou X é membro da cauda de L member(X,[X|L]). member(X,[Y|L]) : member(X,L) Exemplos ?  member(b,[a,b,c]). yes ?  member(b,[a,[b,c]]). no ?  member([b,c],[a,[b,c]]). ?- member(X,[a,[b,c]]). X = a; X = [b,c]; (Construa as respectivas árvores de pesquisa) Programação Declarativa

Alguns predicados básicos para manipular listas CONCATENAÇÃO (append*) append(L,M,N) - N é a concatenação de L e M se L é vazia, N é igual a M; se L não é vazia, N é igual à lista cuja cabeça é a cabeça de L e cauda igual à concatenação da cauda de L com a lista M. append([],M,M). append([X|L],M,[X|N]) : append(L,M,N). Exemplos ? – append([a,[b,c],d],[a,[],b],L). L = [a,[b,c],d,a,[],b]; no ?  append(L1,L2,[a,b,c]). L1 = [] L2 = [a,b,c]; L1 = [a] L2 = [b,c]; L1 = [a,b] L2 = [c]; L1 = [a,b,c] L2 = []; Programação Declarativa

Alguns predicados básicos para manipular listas ADICIONAR (add) Em geral não é necessário definir um procedimento para adicionar um objecto no início (i.e. à esquerda dos restantes elementos) de uma lista. Sabemos que se X é um objecto e L uma lista, [X|L] é a lista que resulta de adicionar X a L. No caso de ser necessário é definido um procedimento (add) que é constituído pela seguinte cláusula: add(X,L,[X|L]). Exemplo ?  add([a,b],[1,2,[]],L). L = [[a,b],1,2,[]]; no Programação Declarativa

Alguns procedimentos básicos sobre listas Remover (del) del(X,L,M) - M é a lista que resulta da remoção de uma ocorrência do objecto X na lista L. M é a cauda de L, se X é a cabeça de L; M é a lista cuja cabeça é X e a cauda que resulta da remoção de X da cauda de L, se X não é a cabeça de L. del(X,[X|L],L). del(X,[Y|L],[Y|M]) : del(X,L,M). Exemplos ? – del(a,[a,b,a,a],L). L = [b,a,a]; L = [a,b,a]; no ? – del(a,L,[1,2]). L = [a,1,2]; L = [1,a,2]; L = [1,2,a]; Programação Declarativa

Alguns procedimentos básicos sobre listas SUBLISTA (sublist) S é uma sublista de L (sublist(S,L))se L pode ser decomposta nas listas L1 e L2, e L2 pode ser decomposta nas listas S e alguma L3 sublist(S,L) :- append(L1,L2,L), append(S,L3,L2). Exemplos ? – sublist([a,b],[b,c,a]). no ? – sublist(S,[a,b,c]). S = []; S = [a]; S = [a,b]; S = [a,b,c]; S = [b];  Programação Declarativa

Alguns procedimentos básicos sobre listas Permutação (permutation) L2 é uma permutação de L1 (permutation(L1,L2)) se L2 é vazia, se L1 é vazia, ou L2 é a lista que resulta de permutar a cauda de L1 e adicionar a cabeça de L1 em qualquer posição. permutation([ ],[ ]). permutation([X|L],P) : permutation(L,L1), insert(X,L1,P). Exemplo ? – permutation([a,b,c],P). P = [a,b,c]; P = [a,c,b]; P = [b,a,c]; P = [b,c,a]; P = [c,a,b]; P = [c,b,a]; no * insert(X,L1,L2) :- del(X,L2,L1). Programação Declarativa

TRADUÇÃO (EXEMPLO) Alterar uma frase da linguagem natural, representada pela lista das palavras que a constituem (mantendo a ordem original das palavras na frase), através de uma função que a cada palavra associa uma outra palavra (i.e. uma função de tradução). [you, are, a, computer] (representa a frase ) função de tradução é descrita através dos seguintes factos: change(you,i). change(are,[am, not]). change(french, german). change(do, no). change(X,X). alter([ ],[ ]). alter([H|T],[H1|T1]) : change(H,H1),alter(T,T1). ?- alter([you, are, a, computer],X). X = [i, [am, not], a, computer];  Programação Declarativa

Exercícios Defina os seguintes predicados de manipulação de listas: prefixo(L, M): que é verdadeiro se L é uma sub-lista inicial de M. Por exemplo, prefixo([a,b], [a,b,c]) é verdadeiro. sufixo(L, M): que é verdadeiro se L é uma sub-lista terminal de M. Por exemplo, sufixo([b,c], [a,b,c] é verdadeiro. sublista(L, M): que é verdadeiro se L é uma sub-lista de M. De notar que uma sub-lista necessita que os elementos sejam consecutivos, ou seja, [b,c] é uma sub-lista de [a,b,c,d] enquanto que [a,c] não é. Programação Declarativa