Capítulo 03 do Livro Introdução ao Haskell

Respostas do capítulo 02 do Livro Introdução ao Haskell
Autores: Stenio Longo Araújo
                 Benedito Melo Acióly

OBS: Não possui a resposta dos exercícios número 08 e 09

-- EXEMPLOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o fatorial de um número
----------------------------------------------------------------------------------------------------
fat :: Int -> Int
fat a
        | a == 0 = 1
        | a > 0 = a * fat (a - 1)
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Realizar contagem dos acessos totais até aquela semana
----------------------------------------------------------------------------------------------------
acessoTotal :: Int -> Int
acessoTotal n
        | n == 0 = numAcesso 0
        | otherwise = acessoTotal (n - 1) + numAcesso n
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Auxiliar na contagem de acessos
----------------------------------------------------------------------------------------------------
numAcesso :: Int -> Int
numAcesso n
        | n == 0 = 15
        | n == 1 = 5
        | n == 2 = 7
        | n == 3 = 18
        | n == 4 = 7
        | n == 5 = 0
        | n == 6 = 5
        | otherwise = 0
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o fatorial de um número usando casamento padrão
----------------------------------------------------------------------------------------------------
fatcp :: Int -> Int
fatcp 0 = 1
fatcp b = b * fat (b - 1)

----------------------------------------------------------------------------------------------------
-- Objetivo: Testar se um número é 0 ou não
----------------------------------------------------------------------------------------------------
ehZero :: Int -> Bool
ehZero 0 = True
ehZero _ = False

-- EXERCÍCIOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Testar eficiência do fatorial
----------------------------------------------------------------------------------------------------
fat2 :: Int -> Int
fat2 n = fatAcum 1 n

----------------------------------------------------------------------------------------------------
-- Objetivo: Auxiliar função fat2
----------------------------------------------------------------------------------------------------
fatAcum :: Int -> Int -> Int
fatAcum ac n
        | (n == 0) = ac
        | (n > 0) = fatAcum (ac * n) (n - 1)
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular potência de número
----------------------------------------------------------------------------------------------------
pot :: Int -> Int -> Int
pot l b
        | b == 0 = 1
        | b == 1 = l
        | b > 1 = l * pot l (b - 1)
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular a soma de todos os números pares num intervalo
---------------------------------------------------------------------------------------------------
somaPares :: Int -> Int
somaPares n
        | n == 0 = 0
        | n == 1 = 0
        | mod n 2 == 0 = n + (n - 2)

----------------------------------------------------------------------------------------------------
-- Objetivo: Somar naturais utilizando função sucessor
-- succ já é uma função definda no pacote da linguagem
---------------------------------------------------------------------------------------------------   
soma :: Int -> Int -> Int
soma l 0 = l
soma 0 b = b
soma l b
        | l < b = succ (soma (l - 1) b)
        | otherwise = succ (soma l (b - 1))
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Soma de fracionários
---------------------------------------------------------------------------------------------------
somaFra :: Float -> Float
somaFra l
        | l == 0 = 0
        | l == 1 = 1
        | l > 1 = 1/l + somaFra (l - 1)

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular a potência de um número diividido pelo fatorial do mesmo
---------------------------------------------------------------------------------------------------       



----------------------------------------------------------------------------------------------------
-- Objetivo: Questão anterior organizada em tabela
----------------------------------------------------------------------------------------------------


----------------------------------------------------------------------------------------------------
-- Objetivo: Algoritmo de Euclides
----------------------------------------------------------------------------------------------------   
euclides :: Int -> Int -> Int
euclides l 0 = l
euclides l b = euclides b (mod l b)

----------------------------------------------------------------------------------------------------
-- Objetivo: Realizar o somatório
----------------------------------------------------------------------------------------------------
somatorio :: Int -> Int
somatorio 1 = 1
somatorio n = (n*n) + somatorio(n-1)   

somatorio2 :: Int -> Int
somatorio2 1 = 1
somatorio2 n = fat(n) + somatorio(n-1)      

----------------------------------------------------------------------------------------------------
-- Objetivo: Realizar a tabuada
----------------------------------------------------------------------------------------------------
tabuada :: Int -> String
tabuada l = valoresImpressos l 10

valoresImpressos :: Int -> Int -> String
valoresImpressos l 1 = resultadoFinal l 1
valoresImpressos l b= valoresImpressos l (b-1) ++ resultadoFinal l b 

resultadoFinal :: Int -> Int -> String
resultadoFinal l i = show(l) ++ "X" ++ show (i) ++ " = " ++show (l*i)    ++ "\n"        

Ótimos Estudos

Mais informações »

Capítulo 02 do Livro Introdução ao Haskell

Respostas do capítulo 02 do Livro Introdução ao Haskell
Autores: Stenio Longo Araújo
                 Benedito Melo Acióly

import Data.Char
-- EXEMPLOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular a função nAnd 
----------------------------------------------------------------------------------------------------
nAnd :: Bool -> Bool -> Bool
nAnd p q = not (p && q)

----------------------------------------------------------------------------------------------------
-- Objetivo:
-- Verificar se um caracter é MAIÚSCULO;
-- Verificar se um caracter é minúsculo.

-- letra para teste entre ' '
----------------------------------------------------------------------------------------------------
ehMaiuscula :: Char -> Bool
ehMaiuscula ch = ('A' <= ch) && (ch <= 'Z')

ehMinuscula :: Char -> Bool
ehMinuscula ch = ('a' <= ch) && (ch <= 'z')

----------------------------------------------------------------------------------------------------
-- Objetivo: Concatenar três strings
-- palavras para teste entre " "
----------------------------------------------------------------------------------------------------
linhas :: String -> String -> String -> String
linhas s1 s2 s3 = s1 ++ s2 ++ s3

----------------------------------------------------------------------------------------------------
-- EXERCÍCIOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Operação nOr, que retorna false se dois valores forem false
----------------------------------------------------------------------------------------------------
nOr :: Bool -> Bool -> Bool
nOr p q = not (p || q)

----------------------------------------------------------------------------------------------------
-- Objetivo: Comparar se três inteiros são diferentes entre si
----------------------------------------------------------------------------------------------------
tresDiferentes :: Int -> Int -> Int -> Bool
tresDiferentes a b c
        | a /= b && b /= c && a /= c = True
        | otherwise = False
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular àrea de um triângulo
----------------------------------------------------------------------------------------------------
areaT :: Float -> Float -> Float
areaT base altura = ((base * altura) / 2)

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular àrea de um círculo
----------------------------------------------------------------------------------------------------
areaC :: Float -> Float
areaC raio = (3.14 * (raio * raio))

----------------------------------------------------------------------------------------------------
-- Objetivo: Converter uma temperatura Farenheit para Centígrados
----------------------------------------------------------------------------------------------------
converteT :: Float -> Float
converteT temperatura = (5 / 9) * (temperatura - 32)

----------------------------------------------------------------------------------------------------
-- Objetivo: Converter Maiúscula para Minúscula
----------------------------------------------------------------------------------------------------
paraMinuscula :: Char -> Char
paraMinuscula a = chr (ord a + 32)

----------------------------------------------------------------------------------------------------
-- Objetivo: Converter Minúscula para Maiúscula
----------------------------------------------------------------------------------------------------
paraMaiuscula :: Char -> Char
paraMaiuscula a = chr (ord a - 32)

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular média de um aluno
----------------------------------------------------------------------------------------------------
calculaMedia :: Float -> Float -> Float -> Float
calculaMedia a b c = (a + b + c) / 3

----------------------------------------------------------------------------------------------------
-- Objetivo: Definir a posição do ponto no eixo cartesiano
----------------------------------------------------------------------------------------------------
cartesiano :: Float -> Float -> String
cartesiano x y
        | x > 0 && y > 0 = "Primeiro Quadrante"
        | x < 0 && y > 0 = "Segundo Quadrante"
        | x < 0 && y < 0 = "Terceiro Quadrante"
        | x > 0 && y < 0 = "Quarto Quadrante"
        | otherwise = "Os pontos nao esta em nenhum dos quadrantes pois eh o ponto 0."
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Definir a unidade de um número
----------------------------------------------------------------------------------------------------
unidade :: Int -> Int
unidade a
        | a < 10 = a
        | otherwise = mod a 10
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Definir a dezena de um número
----------------------------------------------------------------------------------------------------
dezena :: Int -> Int
dezena a
        | a < 100 = a
        | otherwise = mod a 100
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Definir a centena de um número
----------------------------------------------------------------------------------------------------
centena :: Int -> Int
centena a
        | a < 1000 = a
        | otherwise = mod a 1000
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Somar algarismos
----------------------------------------------------------------------------------------------------
somaAl :: Int -> Int
somaAl a
        | a < 10 = a
        | a >= 10 && a < 100 = (mod a 10) + (div a 10)
        | a >= 100 && a < 1000 = (mod a 10) + (mod (div a 10) 10) + (div a 100)
        | otherwise = error " Numero deve ser menor que 1000."
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Soma lados dos triângulos
----------------------------------------------------------------------------------------------------
somaTri :: Int -> Int -> Int -> String
somaTri a b c
        | a == b && a == c = "Triangulo Equilatero"
        | a /= b && a /= c && b /= c = "Triangulo Escaleno"
        | otherwise = "Triangulo Isosceles"
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Verificar se um número é par
----------------------------------------------------------------------------------------------------
ehPar :: Int -> Bool
ehPar a
        | mod a 2 == 0 =  True
        | otherwise = False
        

Mais informações »

Capítulo 01 do Livro Introdução ao Haskell

Respostas do capítulo 01 do Livro Introdução ao Haskell
Autores: Stenio Longo Araújo
                 Benedito Melo Acióly

-- EXEMPLOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o quadrado de um número
-- Arquivo: Primeiro.hs
----------------------------------------------------------------------------------------------------
quadrado :: Int -> Int
quadrado numero = numero * numero

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o maior de dois inteiros
----------------------------------------------------------------------------------------------------
maior :: Int -> Int -> Int
maior a b  
        | a >= b = a
        | b > a = b
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o maior de dois inteiros
-- Versão 2
----------------------------------------------------------------------------------------------------
maior2 :: Int -> Int -> Int
maior2 a b
        | a >= b = a
        | otherwise = b
       
----------------------------------------------------------------------------------------------------
-- EXERCÍCIOS
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o cubo de um número
----------------------------------------------------------------------------------------------------
cubo :: Int -> Int
cubo numero = numero * numero * numero

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o cubo de um número a partir da função quadrado
----------------------------------------------------------------------------------------------------
cubo2 :: Int -> Int
cubo2 numero = quadrado numero * numero

----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o menor de dois inteiros
----------------------------------------------------------------------------------------------------
menor :: Int -> Int -> Int
menor a b
        | a <= b = a
        | b < a = b
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o menor de dois inteiros
-- Versão 2
----------------------------------------------------------------------------------------------------
menor2 :: Int -> Int -> Int
menor2 a b
        | a <= b = a
        | otherwise = b
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o maior de três inteiros
-- Versão 3
----------------------------------------------------------------------------------------------------
maior3 :: Int -> Int -> Int -> Int
maior3 a b c
        | a >= b && a >= c = a
        | b >= a && b >= c = b
        | otherwise = c
       
----------------------------------------------------------------------------------------------------
-- Objetivo: Calcular o maior de três inteiros a partir da função maior
-- Versão 4
----------------------------------------------------------------------------------------------------
maior4 :: Int -> Int -> Int -> Int
maior4 a b c = maior a (maior b c)

----------------------------------------------------------------------------------------------------
-- Objetivo: Inverter o sinal de um número inteiro
----------------------------------------------------------------------------------------------------   
negar :: Int -> Int
negar numero = numero * (-1)

Mais informações »

Reativação em prol dos estudos de HASKELL

Galerinha, por perceber que na internet algumas coisas de haskell é difícil encontrar, estou reativando este blog.
Vou postando as atividades que vou conseguindo fazer, conforme meus estudos na matéria.

Mais informações »