Duvida Exercicio

[programador400]

Alguém me ajuda a resolver isto:

Vamos representar um ponto por um par de números que representam as suas coordenadas no plano Cartesiano.

type Ponto = (Float,Float)

(a) Defina uma função que recebe 3 pontos que são os vértices de um triângulo e devolve um tuplo com o comprimento dos seus lados.

(b) Defina uma função que recebe 3 pontos que são os vértices de um triângulo e calcula o perimetro desse triângulo.

© Defina uma função que recebe 2 pontos que são os vértices da diagonal de um rectângulo paralelo aos eixos e constroi uma lista com os 4 pontos desse rectângulo.

[KiNgPiTo]

Vais precisar de criar uma função que calcule a distancia entre 2 pontos (http://pt.wikipedia.org/wiki/Dist%C3%A2ncia_euclidiana) e depois para a a) é retornar um tuplo chamando a função 3 vezes para cada ponto do triângulo, para a b o mesmo mas a somar, a c não percebi bem o que pede...

[programador400]

Sinceramente sou novato disto...ou melhor ainda nao tive nenhuma aula disto...mas já me consigo desenrascar qq coisa mas empanquei neste exercicio

[jpedro20]

Começa por definir a assinatura da função:

compLados :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)

depois e só calculares a distancia entre os três pontos como já te foi sugerido:

compLados a b c = (distancia a c, distancia b c, distancia a b)

Se conseguires fazer a alínea a), fazes a b) sem problemas.

Edited September 25, 2012 at 07:54 PM by jpedro20

[programador400]

Preciso de uma sugestão:

Tava a criar a funçao reverse por mim mesmo mas acho que compliquei um pouco apesar de isto funcionar perfeitamente. Se alguém tiver uma alternativa mais simples que diga. Deixo aqui o meu codigo.

Nota: O objectivo é nao recorrer a funçoes já definidas no prelude.

reverse2 :: [a] -> [a]

reverse2 x = auxiliar (length2 x) x

auxiliar :: Int -> [a] -> [a]

auxiliar 0 [] = []

auxiliar n x | n /= 0 = last2(take2 n x):(auxiliar (n-1) x)

| otherwise = []

length2 :: [a] -> Int

length2 [] = 0

length2 (x:xs) = 1 + length2 xs

take2 :: Int -> [a] -> [a]

take2 0 _ = []

take2 x (y:ys) = y:(take2 (x-1) ys)

last2 :: [a] -> a

last2 [x] = x

last2 (x:xs) = last2 xs

[pwseo]

E que tal esta?

reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

Não é uma versão optimizada, mas parece-me bastante simples e fácil de perceber. Se reparares bem, o próprio código parece ser uma tradução directa do conceito de fazer reverse.

A versão optimizada deveria ter um acumulador e fazer uso de tail recursion...

Edited September 26, 2012 at 09:59 PM by pwseo

[programador400]

E que tal esta?

reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

Não é uma versão optimizada, mas parece-me bastante simples e fácil de perceber. Se reparares bem, o próprio código parece ser uma tradução directa do conceito de fazer reverse.

A versão optimizada deveria ter um acumulador e fazer uso de tail recursion...

E que tal esta?

reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

Não é uma versão optimizada, mas parece-me bastante simples e fácil de perceber. Se reparares bem, o próprio código parece ser uma tradução directa do conceito de fazer reverse.

A versão optimizada deveria ter um acumulador e fazer uso de tail recursion...

ta mt bem pensado...thanks

[jpedro20]

reverse :: [a] -> [a]
reverse l = rev l []
    where
        rev [] a = a
        rev (x:xs) a = rev xs (x:a)

http://hackage.haskell.org/packages/archive/base/latest/doc/html/src/GHC-List.html#reverse

[pwseo]

Só falta dizer que a versão do jpedro20 é a versão optimizada que referi acima, e que todas as funções do Prelude estão disponíveis na source do próprio GHC, por isso, em caso de dúvida, podes sempre consultar a implementação de referência, tendo em conta que nem sempre estarão lá as versões mais intuitivas (por motivos de optimização, claro).