Projecto de prolog

[Yuliya]

Boa tarde Pessoal,

Queria pedir a vossa ajuda a implementar uma coisa do genero:

inserenovazio([1,2,_,4,_,6,7,_],[3,5,8],L)

e o L deve ser:

L=[1,2,3,4,5,6,7,8].

Nota: o conteúdo do projecto não é numérico, dei só um exemplo.

Alguém pode dar-me dicas? Estou a fazer um projecto de faculdade e está a ser dificil. Ando a varrer internet, mas só encontro as listas desorganizadas, permutações e assim.

Cumprimentos

Yuliya

[HappyHippyHippo]

esse tipo de predicado é um bocado "não convencional" ... mas é possível se e só se os elementos da segunda lista não existam na primeira e os elementos estiverem ordenados, isto porque caso contrário, é impossivel inferir que um valor da primeira lista não esteja definido.

é este o caso, se sim já tenho o código e poderei te direccionar como deves pensar para resolver o problema.

Edited May 14, 2014 at 05:19 PM by HappyHippyHippo

[Yuliya]

Desde já obrigada pela resposta. 😉

Em relação ao código:

"elementos da segunda lista não existam na primeira"- está garantido.

"os elementos estiverem ordenados"- a ordem dos elementos na segunda lista não importa.

inserenovazio([1,2,_,4,_,6,7,_],[3,5,8],L)

Tanto pode ficar

L=[1,2,3,4,5,6,7,8].

como

L=[1,2,5,4,8,6,7,3]

ou

L=[1,2,8,4,3,6,7,5]

Os da primeira lista é que devem ficar nos mesmos lugares.

Podia indicar-me as pistas então?

Cumprimentos

Yuliya

[HappyHippyHippo]

a solução é composta por 4 predicados :

2 para determinar os diferentes tipos de condição de paragem da criação da árvore de resultados

2 para determinar as diferentes situações que podem ocorrer na criação válida da árvore de resultados:

- ou o "header" da primeira lista não se encontra na segunda lista

- ou o "header" da primeira lista é igual ao "header" da segunda lista

Edited May 14, 2014 at 07:41 PM by HappyHippyHippo

[Yuliya]

A condição de paragem é a primeira combinação possível, desde que todas as posições da primeira lista estiverem preenchidas(ou a segunda lista estiver vazia).

Confirma-me só, os últimos dois predicados são exclusivamente para garantir que não ha elementos repetidos?

[HappyHippyHippo]

esse tipo de predicado é um bocado "não convencional" ... mas é possível se e só se os elementos da segunda lista não existam na primeira e os elementos estiverem ordenados, isto porque caso contrário, é impossivel inferir que um valor da primeira lista não esteja definido.

é este o caso, se sim já tenho o código e poderei te direccionar como deves pensar para resolver o problema.

vou-me auto corrigir aqui, alterei o meu código para ser possível atribuir valores a elementos de uma lista parcialmente atribuida, mesmo não ordenada, com qualquer combinaçáo de valores repetidos e sem restrição no número de elementos na lista de valores a serem atribuidos.

por outras palavras, é exactamente o que uma função com o nome "insere_no_vazio" deveria fazer.

em relação à tuas dúvidas, só posso dizer duas coisas :

- esqueçe a programação imperativa, isto é completamente diferente !!!

- pensa mais em funções recursivas

[HappyHippyHippo]

bem, acho que passou tempo sufeciente para poder apresentar a solução :

/*
>> olist/3

usado para atribuir valores a uma lista parcialmente atribuida

 exemplos:
  >> ter números insuficiente de valores a serem atribuídos
  ?- olist([1, _, _], [5], L).
  L = [1, 5, _G1234].

  >> ter demasiado números de valores a serem atribuídos
  ?- olist([1, _], [5, 3], L).
  L = [1, 5].

  >> ter o número exacto de números a serem atribuídos
  ?- olist([1, _, _, 3], [5, 3], L).
  L = [1, 5, 3, 3].
*/

/*
se as listas forem compostas pelos mesmos elementos

caso exemplo :
  olist([X, Y], [1, 2], [1, 2]).
*/
olist(L, L, L) :- !.

/*
se a lista de elementos a inserir for vazia, então a terceira lista será
igual à primeira

caso exemplo :
  olist([1, 2], [], [1, 2]).
*/
olist(L, [], L) :- !.

/*
se o primeiro elemento da primeira lista ainda não tiver sido atribuido
então o prodicado sucede se os primeiros elementos das duas primeiras
listas forem iguais, o primeiro elemento da terceira lista é o mesmo
elemento que estes dois e o resto das três listas tambem sucedem na
recursividade

caso exemplo :
  olist([X, 2], [1], [1, 2]).
*/
olist([H1|T1], [H2|T2], [H2|T3]) :- var(H1),
                                   H1 = H2,
                                   olist(T1, T2, T3),
                                   !.

/*
em último caso, o primeiro elemento da primeira lista já foi atribuido
tendo o mesmo valor que o primeiro elemento da terceira lista e o resto
dessas listas tambêm sucedem na recursividade com a segunda lista intacta.

caso exemplo :
  olist([1, X, 3], [2], [1, 2, 3]).
*/
olist([H|T1], L, [H|T2]) :- \+ var(H),
                           olist(T1, L, T2).