Ir para o conteúdo
  • Revista PROGRAMAR: Já está disponível a edição #57 da revista programar. Faz já o download aqui!

Polmax

Texto

Mensagens Recomendadas

Polmax    0
Polmax

como faço para mostrar texto em haskell?, por exemplo mostrar isso no inicio dum modulo

***************Recursao**************

e ja que estamos eu queria uma funçao que verificasse se ha numeros repetidos numa lista,sem usar funçoes predefinidas e com recursao claro.

eu fiz isso


repetidos ::[int]->Bool
repetidos [] =False
repetidos (x:x1:xs) |(x==x1) =True
                 |otherwise =repetidos xs

Mas nao faz o que eu quero, ela faz bem se os elementos forem consecutivos por exemplo [1,1] =True ; [1,2,2]=True

(normal porque vai me comparar x com x1 que sao os dois primeiros elementos à cabeça)

eu queria que comparasse x com tudo depois comparasse o segundo elemento a cabeça com tudo e assim sucessivamente.

Outra duvida , resolvi fazer tudo no mesmo post ;)

posImpares :: [a]->[a]
posImpares []=[]
posImpares (x:xs) |mod n 2 /=0 =x:posImpares xs
                  |otherwise =posImpares xs
   where n=0

so me falta ali fazer com que o n incremente +1 mas nao sei como :X

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous

1 - putStrLn

2 - Usa a função filter em vez dessa comparação, para verificares se o elemento existe no resto da lista. Falta-te também o caso em que a lista só tem 1 elemento.

3 - Pelo que percebi isso é para devolver os elementos da lista que estão em posições ímpares. Em vez de fazeres tudo nessa função, cria uma função auxiliar que receba a lista e o n como argumentos e depois é só fazeres o que estás a fazer, só que na invocação recursiva incrementas o n.

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

1- Mas tipo tou a escrever o modulo num ficheiro .txt, ao carregar o modulo quero que aparece por exemplo "********Modulo blablabla , e mais alguma coisa que quiser escrever******" . ponho so putStrLn "Texto" no ficheiro .txt? o.o

2- Pois eu com o filter ja tinha feito , é que tenho a mania de nao usar as funçoes predefinidas, acho que é mais porque acho que assim aprendo melhor a como funcionam as coisas , nao sei é mania ;) .

3-Mas nao tou a perceber , dizes pra eu na segunda funçao incrementar o n

impAux ::Int->[a]->[a]
impAux n []=[]
impAux n (x:xs) | ?
                         | ?

que faço com a lista nessa funçao auxiliar ?

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous

1 - Não sei se dá para fazer isso, como o GHCi é um interpretador tens que invocar uma função qualquer para ele mostrar algo, por isso tinhas de ter uma função que mostrasse o texto e invocá-la.

2 - Se não quiseres usar o filter, fazes uma função auxiliar que faça a mesma verificação que ele faz, mas vai dar ao mesmo.

3 - Fazes com a lista o que queres fazer, só que agora podes incrementar o n na chamada recursiva. E essa função auxiliar é invocada pela função posImpares.

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

Desculpa tar a perguntar outra vez , tou a complicar no raciocinio :S

posImpares :: [a]->[a]
posImpares []=[]
posImpares (x:xs) =x:impAux xs
   where impAux ::Int->[a]->[a]
         impAux n []=[]
         impAux n (x:xs)|mod n 2 /0 =x:impAux xs
                        |otherwise=impAux xs

claro que esta da erro ...

Eu na função auxiliar imponho que se mod n 2/=0 então ponho aquele elemento a cabeça e repito a função, senão só repito ? ou incremento ?

e depois na função principal aplico a auxiliar ao x e ao xs?

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous

Na função principal limitas-te a invocar a função auxiliar com um valor base para o n e a lista original. Depois na auxiliar é que fazes o que estás a fazer. Só falta incrementares o n na chamada recursiva, que não estás a fazer.

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

omg tava a fazer tanta coisa mal -.-

O pior de tudo foi o que disseste, nao estava a incrementar o n... ainda tenho muito que aprender.

posImpares (x:xs) =x:(impAux 2 xs)
   where impAux ::Int->[a]->[a]
         impAux n []=[]
         impAux n (x:xs)|mod n 2 /=0 =x:impAux (n+1) xs
                        |otherwise=impAux (n+1) xs

ok só tenho uma duvida, a função já faz o que quero mas eu na função principal indico sempre que o x esta à cabeça (neste caso da jeito pk como quero posições ímpares e o x esta na posição 1 esta tudo bem) mas como faria se quisesse posições pares? (claro podia sempre mudar o valor base para 1 ou então mudar o mod n 2 /=0 para ==0 , mas como fazia pra omitir o x?)

mentira surgiu-me outra  :wallbash: (ah e obrigado por me teres ajudado ate agora :))

a minha função repetidos, depois de ter deixado mesmo com o filter porque não valia mesmo a pena fazer uma função nova, ficou assim

repetidos ::[int]->Bool
repetidos [] =False
repetidos [x]=False
repetidos (x:xs) |(filter (==x) xs)/=([]) =True
                 |otherwise =repetidos xs

agora eu tentei fazer o mesmo aqui

turmaV ::[Aluno]->Bool
turmaV []=False
turmaV [nu,no,p1,p2] =True
turmaV ((nu,no,p1,p2):xs)| (filter (==nu) xs)/=[] &&((p1>=0) && (p1<=12)) && ((p2>=0) && (p2<=8)) = True
                         |otherwise = turmaV xs

é para ver se a turma é valida, só que neste caso eu estou a fazer filter com nu que é um inteiro numa lista de (nu,no,p1,p2)

como faço para só comparar com o nu da lista?

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous

Como vejo que não entendeste completamente por palavras, deixo aqui a resolução da 1ª:

posImpares l = posImparesAux 0 l
        where posImparesAux _ [] = []
              posImparesAux n (x:xs) | mod n 2 /= 0 = x:(posImparesAux (n+1) xs)
                                     | otherwise = posImparesAux (n+1) xs

Na 2 lembrei-me de uma forma mais fácil de implementar, sem usar o filter:

repetidos [] = False
repetidos [x] = False
repetidos (x:xs) = elem x xs || repetidos xs

Talvez consigas adaptar a esse caso.

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous

Depende do que tu consideras uma posição par. Eu estou a considerar que uma lista começa no índice 0, por isso a minha função faz o esperado.

> posImpares [1,2,3,4,5]
[2,4]

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

Ah pois tem lógica.

Não consigo pelo seguinte

eu so quero comparar o nu com os outros nu da calda

mas se digo elem nu xs dá-me erro pk xs é (nu,no,p1,p2)

se digo elem (nu,no,p1,p2) xs só devolve true se todos forem iguais.

o problema é o mesmo que com o filter , não sei comparar só uma parte :/

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

Ao estou a conseguir fazer mesmo com uma função auxiliar :/

Podes me dar um exemplo qualquer de uma função (com ou sem função auxiliar) que tenha uma lista com tuplos de mais de 2 elementos (a,b,c) ou (a,b,c,d) etc em que tu compares um desses elementos com a calda ? 

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Baderous    31
Baderous
comp :: [(Int,Int,String)] -> Bool
comp [] = False
comp [x] = False
comp ((a,b,c):(d,e,f):xs) = (b==e && c==f) || comp ((a,b,c):xs)

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Polmax    0
Polmax

Obrigado :O

Vou colocar aqui como ficou a minha ,para o caso de alguem ter duvidas em algo parecido :P (é basicamente o exemplo que me deste, só pus mais uma condição para que compare todos elementos e não só o primeiro com a calda)

turmaV ::[Aluno]->Bool
turmaV []=False
turmaV [x] =True
turmaV l |compararN l ==True =False
               |otherwise =True
                                           
  where compararN :: [Aluno]->Bool
             compararN []=False
             compararN [x]=False
             compararN ((nu,no,p1,p2):(nu1,no1,p11,p21):xs) = (nu==nu1)||((p1<8)&&(p1+p2<9.5))||compararN ((nu,no,p1,p2):xs)||compararN ((nu1,no1,p11,p21):xs)

Ja é hora de fechar o post antes que fique demasiado grande  :confused: .

Obrigado mais uma vez pela ajuda .

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
Betovsky    2
Betovsky

posImpares (x:xs) =x:(impAux 2 xs)
   where impAux ::Int->[a]->[a]
         impAux n []=[]
         impAux n (x:xs)|mod n 2 /=0 =x:impAux (n+1) xs
                        |otherwise=impAux (n+1) xs

Já agora para evitar o uso do mod, uma outra solução possível, que é até bastante interessante na minha opinião, seria:

posImpares [] = []
posImpares [x] = [x]
posImpares (x:_:xs) = x : posImpares xs

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
trincheiro2499    0
trincheiro2499

Se quiseres dividir tudo tambem da assim:

turmaV :: Turma -> Bool
turmaV []= True
turmaV t = (notas t) && (numdif t)

notas :: Turma -> Bool
notas []= True
notas ((num,nome,p1,p2):xs) = (p1>=0) && (p1<=12) && (p2>=0) && (p2<=8) && notas xs

numdif :: Turma -> Bool
numdif []=True
numdif (x:xs) = numaux x xs &&  numdif xs

numaux :: Aluno -> Turma -> Bool
numaux _ [] = True
numaux (num1,nome1,p11,p21) ((num2,nome2,p12,p22):xs) = (num1/=num2) &&  numaux (num1,nome1,p11,p21) xs

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora


×

Aviso Sobre Cookies

Ao usar este site você aceita a nossa Política de Privacidade