Verificar se 3 números constituem triângulo

[pr0zin 0]

Bons dias, eu tenho uma duvida num exercicio(estou a iniciar a programaçao em haskell)

O que eu pretendia era verificar se 3 numeros constituem um triangulo.

em C isto era muito facil, mas em haskell eu nao sei muito bem como isto funciona.

Podem me ajudar/corrigir?

Bool :: triangulo a b c = if ((a + b) > c) || (a + c) > b) || (b + c) > a)) return True; else return False;

Editado 23 de Fevereiro de 2013 por Baderous

[brunoais 67]

Podem me ajudar/corrigir?

Bool :: triangulo a b c = if ((a + b) > c) || (a + c) > b) || (b + c) > a)) return True; else return False;

Acho que seria algo mais... (não testado)

triangulo a b c = if ((a + b) > c) || (a + c) > b) || (b + c) > a)) then True else False

[pr0zin 0]

ja consegui resolver!

triangulo :: Int -> Int -> Int -> Bool
triangulo a b c = if(a + b)>c then True
                   else if(a + c)>b then True
                   else if(b + c)>a then True
                   else False

obrigado

Editado 23 de Fevereiro de 2013 por thoga31
GeSHi

[thoga31 610]

Atenção! Convém referir isto: o return do Haskell não tem o mesmo significado que o return de outras LP's, como C! O return do Haskell é utilizado para outros fins totalmente distintos.

Para este caso, eu recomendo o uso de guards, fica muito mais legível

triangulo :: (Num a, Ord a) => a -> a -> a -> Bool
triangulo a b c | (a + b) > c = True
               | (a + c) > b = True
               | (b + c) > a = True
               | otherwise   = False

Também alterei o tipo de dados de entrada de modo à função ter um alcance a mais tipos de dados, neste caso que são numéricos e "comparáveis pela ordem".

Agora uma outra questão: isto é suposto fornecer 3 números e verificar se eles constituem os lados de um triângulo? É que se for isso, estas condições são insuficientes.

Cumprimentos.

[pwseo 231]

Se calhar para quem está a começar é melhor utilizar tipos de dados concretos (ex.: Integer), porque nem sempre estamos completamente a par de todas as type classes necessárias para o que queremos fazer. Uma boa solução é deixar o Haskell inferir o tipo de dados e depois usarmos isso como base para uma assinatura mais específica.

A tua solução falha porque estás a utilizar o operador ou (||) em vez do e (&&).

Aqui ficam soluções com piada (sem corrigir directamente o código do OP):

import Data.List (permutations)

-- 'dt' vem de "desigualdade triangular"
dt a b c = and $ map (\[a,b,c] -> a + b > c) (permutations [a,b,c])

-- outra solução, sem 'permutations'
dt a b c = and [ a + b > c, a + c > b, b + c > a ]

Em ambos os casos, o tipo de dados inferido pelo compilador é dt :: (Num a, Ord a) => a -> a -> a -> Bool, mas poderíamos utilizar uma assinatura mais específica como dt :: Int -> Int -> Int -> Bool ou então dt :: Integer -> Integer -> Integer -> Bool.

A vantagem de utilizar a assinatura geral (ou deixar o compilador inferir o tipo de dados) é que podemos utilizar a função com outros tipos de dados, como já foi referido pelo thoga31.

Editado 23 de Fevereiro de 2013 por pwseo