Ainda a existência de elementos de uma lista noutra lista

[AprendizZ 0]

Desculpem-me abrir outro tópico, mas afinal li mal o enunciado e afinal as ajudas só me ajudaram um pouco.

Afinal o que pretendo é: uma função que dadas duas listas, a 1ª é uma sequência de números únicos, a 2ª

a lista que vai ser comparada, verifica se a 2ª tem todos os números da 1ª (não pode faltar um) e se só tem

números dessa mesma 1ª (confundi?).

Eis uns exemplos: funcao [1,2,3] [1,2,3,1,2,3,3,2,1] ou funcao [1,2,3] [3,2,1] dá True, funcao [1,2,3] [1,5,6,7] ou

funcao [1,2,3] [4..10] dá False.

Ainda tentei seguir uma das ajudas dadas no post anterior:

procurA2 [] (_) = False
procurA2 (x:xs) ys = elem x ys && procurA xs ys

mas dá-me sempre False.

Agradeço desde já toda a paciência e muito obrigado.

[Rui Carlos 345]

Pois dá sempre False, porque é também esse valor que estás a devolver no caso de paragem. E como tens uma conjunção (&&), basta uma das chamadas recursivas devolver False, para o resultado final ser também False.

Adicionalmente, qual deve ser o resultado de procurA2 [] x? Qualquer que seja o valor de x, x contém todos os elementos da primeira lista (nenhum), logo o resultado devia ser True e não False.

[AprendizZ 0]

Obrigado Rui Carlos, já encontrei uma solução.

Para futuras ajudas, deixo aqui a minha solução a este problema:

-- compara duas listas, se os valores da 1ª estao na 2ª e vice-versa
compAra :: [int] -> [int] -> Bool
compAra [] (_) = False
compAra [x] ys = elem x ys
compAra (x:xs) ys = elem x ys && compAra xs ys

testCompara :: [int] -> [int] -> Bool
testCompara xs ys = compAra xs ys && compAra ys xs

É uma solução atabalhoada (reflexo da minha inexperiência em haskell)

mas deixo-a aqui, não para cópia, mas para ajudar outros a fazer melhor.

Abraço.

[kurayama 0]

Não percebi bem se é isto que queres, mas deixo outra sugestão

import List
compara a b = length ( (nb\\a) ++ (a\\nb) ) == 0
                where nb = nub b

[Rui Carlos 345]

Do meu ponto de vista, a solução original deveria ter sido corrigida trocando o resultado do caso de paragem. Não faz sentido devolveres False quando a primeira lista está vazia.

[kurayama 0]

O Rui Carlos tem razão, muda isso e tira o caso do meio(só um elemento) que passa a ser inútil.

Para o caso da lista vazia, regra geral quando é 'and' (&&) deve ser True, e quando é 'or' (||) deve ser False.

Isto é uma opinião pessoal, mas tenta compactar as funções, fica mais bonito afinal programar é uma arte..

compAra :: [int] -> [int] -> Bool
compAra xs ys = foldr (&&) True (map (\x -> elem x ys) xs)