Dados do Aluno Topo

• Nome: Vinicius Stein Dani
• Matrícula: 2711169

Descrição Topo

Objetivando-se o exercício da definição de funções em Haskell, fora resolvida a seguinte lista de exercícios: T1.

Resolução Topo

• 27 de Agosto de 2011 - Trabalho 1: Funções em Haskell

  Clique aqui para ver a página com os enunciados!
  Clique aqui para ver a lista de exercícios!
  
  module T1 where
  
  listaString = ["um","dois","tres"]
  listaInt = [5,2,3,1]
  
  -- (Exercicio 01) Recebe um determinado valor e retorna o valor com desconto
  comDesconto :: Float -> Float
  comDesconto valor
      | valor <   50.0                  = valor * 1.0
      | valor >=  50.0 && valor < 100.0 = valor * 0.95
      | valor >= 100.0 && valor < 300.0 = valor * 0.9
      | valor >= 300.0                  = valor * 0.85
  
  -- (Exercicio 02) Funcao que recebe uma lista de strings e gera outra lista
  -- contendo cada string numerada a partir de 1 (um)
  insereNum :: [String] -> [String]
  insereNum [] = []
  insereNum lista = myConcat [1..length lista] lista
      where
          -- Funcao auxiliar para gerar as concatenacoes devidas
          myConcat :: [Int] -> [String] -> [String]
          myConcat [] [] = []
          myConcat [] _ = []
          myConcat _ [] = []
          myConcat (x:xs) (y:ys) = (((show x) ++ " ") ++ y) : myConcat xs ys
  
  -- (Exercicio 03) Funcao que retorna "True" se a lista passada estiver
  -- em ordem crescente; ou "False", caso contrario
  crescente :: [Int] -> Bool
  crescente lista = foldr (&&) True (listaBool lista)
      where
          -- Transforma a lista de inteiros, apos devidas
          -- comparacoes, em uma lista de booleanos
          listaBool :: [Int] -> [Bool]
          listaBool [_] = []
          listaBool (x:xs) = (x < head xs) : listaBool xs
  
  -- (Exercicio 04) Funcao que recebe um inteiro e uma lista decrescente de 
  -- cedulas; o retorno deve ser uma lista com a quantidade de cedulas utilizadas
  cedulas :: Int -> [Int] -> [Int]
  cedulas _ [] = []
  cedulas i (x:xs) = helper i x 0 : cedulas (new i x) xs
      where
          helper :: Int -> Int -> Int -> Int
          helper i x cont
              | (i - x) >= 0 = helper (i - x) x (succ cont)
              | otherwise = cont
          new :: Int -> Int -> Int
          new i x
              | (i - x) >= 0 = new (i - x) x
              | otherwise = i
  
  -- (Exercicio 05) Funcao que calcula o produto vetorial de 
  -- dois vetores representados por listas de inteiros
  prodVet :: [Int] -> [Int] -> [Int]
  prodVet [] [] = []
  -- Assim:
  prodVet (x:xs) (y:ys) = x*y : prodVet xs ys
  -- Ou, com funcao de alta-ordem, assim: 
  -- prodVet x y = zipWith (*) x y
  
  -- (Exercicio 06) Fazer a funcao anterior com "zipWith"!
  -- Uso da funcao "zipWith": pode ser observado no exercicio acima
  -- Comentario: "zipWith" eh basicamente um "zip" com a qualidade
  -- de permitir realizar-se uma interacao "automatica" entre
  -- as tuplas geradas pelo "zip". Bem util :)
  -- Referencia: http://zvon.org/other/haskell/Outputprelude/zipWith_f.html
  prodVetZipWith :: [Int] -> [Int] -> [Int]
  prodVetZipWith [] [] = []
  prodVetZipWith x y = zipWith (*) x y
  
  -- (Exercicio 07) Funcao nao-recursiva (!) que recebe uma lista
  -- de bits e retorna esse numero (binario)  em decimal
  bin2dec :: [Int] -> Int
  bin2dec [] = 0
  bin2dec lista = sum $ zipWith (*) (map (2^) (reverse [0..(length lista) - 1])) lista
  
  -- (Exercicio 08) Funcao que retorna a string recebida
  -- intercalada com um caractere
  intercala :: Char -> String -> String
  intercala _ [] = []
  intercala _ [x] = [x]
  intercala c (x:xs) = x : c : intercala c xs
  
  -- (Exercicio 09) Utilizando map, zipWith e foldr1 criar uma funcao
  -- que recebe uma lista e [x1,x2,x3,...,xn] e calcule a seguinte
  -- expressao ((x1)^2)/1 + ((x2)^2)/2 + ... + ((xn)^2)/n
  serie :: [Double] -> Double
  serie lista = foldr1 (+) (zipWith (/) (map (^2) lista) [1,2..])
  
  -- (Exercicio 10) Funcao que verifica se um elemento 
  -- pertence ou nao a uma dada lista
  isElem :: Int -> [Int] -> Bool
  isElem _ [] = False
  isElem i (x:xs) 
      | i == x = True
      | otherwise = isElem i xs
  

Downloads Topo

O Arquivo Fonte deste Trabalho é distribuído sobre a GPL (faça bom proveito ;D): T1.hs (Veja "como instalar" o Haskell)