Resolução de questões

Bons estudos à todos e ótima prova na sexta 11/10/2013

-- Resolucao da Prova

 --Dados necessarios para questao

type BancoDeDados = [Onibus]
type Onibus = (Codigo, Origem, Destino, Horario, [Passageiro])
type Codigo = Int
type Origem = String
type Destino = String
type Horario = String
type Passageiro = String

exemplo :: BancoDeDados
exemplo = [ (1, "salvador", "vitoria da conquista", "8:00", ["carlos", "maria", "rita"]),
(2, "salvador", "vitoria da conquista", "12:30", []),
(3, "vitoria da conquista", "Ilheus","9:00", ["ana", "joana", "rita"]),
(4, "salvador", "Ilheus", "22:00", ["fabio", "jose","carlos", "maria", "rita"])]

-- Questao 01
-- _ eh uma variavel anonima, utilizo quando esta variavel é irrelevante para o resultado da minha funcao
-- orig = oriigem recebida
-- ori = origem da tupla definida no BD
-- Letra a

quantOnibus :: BancoDeDados -> Origem -> Int
quantOnibus [ ]  _ = 0
quantOnibus (( cod, ori, des, hor, pas) : cauda) orig
|ori == orig = 1 + quantOnibus cauda orig
| otherwise = quantOnibus cauda orig

-- Letra b

obterHorario :: BancoDeDados -> Origem -> [Horario]
obterHorario [ ] _ = [ ]
obterHorario ((_, ori, _, hor, _) : cauda) orig
| ori == orig = hor : obterHorario cauda orig
| otherwise = obterHorario cauda orig

-- Letra c

obterHorario2 :: BancoDeDados -> Origem -> [Horario]
obterHorario2 bd orig = [ h | (_, ori, _, h, _) <- bd, ori == orig]

-- Letra d

incluir :: BancoDeDados -> Codigo -> Passageiro -> BancoDeDados
incluir [ ] _ _ = [ ]
incluir ((cod, ori, des, hor, pas) : cauda) codi pass
| cod == codi = (cod, ori, des, hor, pass: pas) : cauda
| otherwise = (cod, ori, des, hor, pas) : incluir cauda codi pass

-- Questao 02
-- Letra a
remove :: [Int] -> [Int]
remove [ ] = [ ]
remove [n] = [n]
remove (a : b : c)
| a == b = remove(b : c)
| otherwise = a : remove (b : c)

-- Letra b
intercalar :: [Int] -> [Int] -> [Int]
intercalar  [ ] lista = lista
intercalar (a : b) lista = inserir a (intercalar b lista)

inserir :: Int -> [Int] -> [Int]
inserir n [ ] = [n]
inserir n (a : b)
| n <= a = n : a : b
| otherwise = a : inserir n b

-- Outra forma para letra b da questao 02

intercalar2 :: [Int] -> [Int] -> [Int]
intercalar2 [ ] l = l
intercalar2 l [ ]  = l
intercalar2 (a:b) (c:d)
|a <= c = a : intercalar2 b (c:d)
|otherwise = c : intercalar2 (a:b) d

Com a ajuda de Jaime Freire

Mais informações »

Lista 01 - Recursão Completa

-- Bons estudos à TODOS 
-- Lista de Exercicio 01

vendas :: Int -> Int
vendas 1 = 20
vendas 2 = 32
vendas 3 = 21
vendas 4 = 60
vendas 5 = 25
vendas 6 = 12
vendas 7 = 52
vendas 8 = 28
vendas 9 = 29
vendas 10 = 40
vendas 11 = 50
vendas 12 = 33

-- Questao 01

desloca :: Int -> String -> String
desloca d palavra
        | d == 0 = palavra
        | d > 0 =  " " ++ desloca (d - 1) palavra

-- Questao 02

impAsterisco :: Int -> String
impAsterisco  qtd
        | qtd == 0 = ""
        | qtd > 0 = "*" ++ impAsterisco (qtd - 1)
       
-- Questao 03

centraliza:: String -> String
centraliza palavra = desloca (length (palavra)) palavra ++ desloca (length (palavra)) ""

-- Questao 04

tamanhoLinha :: Int
tamanhoLinha = 40

cabecalho :: String
titulo = "Relatorio de Venda de Microcomputadores"
cabecalho = impAsterisco tamanhoLinha ++ centraliza titulo ++ impAsterisco (tamanhoLinha +1) ++ "\n"

-- Questao 05

mes :: Int -> String
mes m
        | m == 00 = "Este mes nao existe."
        | m == 01 = "Janeiro"
        | m == 02 = "Fevereiro"
        | m == 03 = "Marco"
        | m == 04 = "Abril"
        | m == 05 = "Maio"
        | m == 06 = "Junho"
        | m == 07 = "Julho"
        | m == 08 = "Agosto"
        | m == 09 = "Setembro"
        | m == 10 = "Outubro"
        | m == 11 = "Novembro"
        | m == 12 = "Dezembro"
       
-- Questao 06

impBranco :: Int -> String
impBranco  qtd
        | qtd == 0 = ""
        | qtd > 0 = " " ++ impBranco (qtd - 1)
       
-- Questao 07

impMes :: Int -> String
impMes mesp = desloca 6 (mes mesp) ++ impBranco (tamanhoLinha - length(mes mesp)) ++ show (vendas mesp) ++ "\n"

-- Questao 08

impMeses :: Int -> String
impMeses 1 = impMes 1 ++ "\n"
impMeses messp = impMeses (messp - 1) ++ impMes messp ++  "\n"  

-- Questao 09

somaVendas :: Int -> Int
somaVendas 1 = vendas 1
somaVendas v = somaVendas (v - 1) +  vendas v

-- Questao 10

impSoma :: Int -> String
impSoma sv = impAsterisco tamanhoLinha ++ "\n" ++ desloca 6 ("Total de Vendas: ") ++ show (somaVendas sv) ++ "\n"

-- Questao 11

maiorVenda :: Int -> Int
maiorVenda 1 = vendas 1
maiorVenda maior = maiorVendaAux (vendas maior) (maiorVenda (maior - 1))

maiorVendaAux :: Int  -> Int -> Int
maiorVendaAux v1 v2
        | v1 >= v2 = v1
        | otherwise = v2

-- Questao 12
       
impMaior :: Int -> String
impMaior mv = desloca 5 (" Maior Venda no Periodo: ") ++ show (maiorVenda mv)   

impVendaZerada :: Int -> String
impVendaZerada vz = desloca 6 ("Vendas Zeradas: ") ++ show (vendasZeradas vz) ++ "\n"

vendasZeradas :: Int -> Int
vendasZeradas 0 = 0
vendasZeradas vmes =  testa0 (vmes) + vendasZeradas (vmes - 1)

testa0 :: Int -> Int
testa0  vmz
        | vendas vmz == 0 = 1
        | otherwise = 0

-- Questao 13

geraGraf :: Int -> String
geraGraf 1 = "\n" ++ desloca 6 ("Grafico de Vendas: ") ++ "\n"  ++ "\t" ++ impAsterisco (vendas 1) ++ "\n"
geraGraf astGraf = geraGraf (astGraf - 1) ++ "\t" ++ impAsterisco (vendas astGraf) ++ "\n"

-- Questao 14

relatorio :: Int -> IO( )
relatorio n = putStr (cabecalho ++ impMeses n ++
                                        impSoma n ++ impVendaZerada n ++  impMaior n ++ geraGraf n)

Mais informações »

Listas em Haskell

Resolução da Lista 02

-- Funcao base para as questoes
nove,cinco,um,dois,tres,quatro,seis,sete,oito,zero :: [Int]
zero  = [4,1,2,1,2,1,4]
um = [0,2,1,2,1,2,1,2,1,2,1]
dois = [3,2,5,2,3]
tres = [3,2,4,2,4]
quatro = [1,1,2,1,4,2,1,2,1]
cinco = [4,2,3,2,4]
seis = [4,2,4,1,4]
sete = [3,2,1,2,1,2,1,2,1]
oito = [4,1,5,1,4]
nove = [4,1,4,2,1,2,1]

--Questao 01
-- recebe um dos numeros por extenso e devolve a lista considerando que posicao 0 quantidade de asteriscos, porsicao 1 espacos e vai alternando entre asterisco e espacos
toString :: [Int] -> String
toString [ ] = [ ] -- nao necessita
toString [n] = impAsterisco n
toString (a : b : c) = impAsterisco a ++ impEspaco b ++ toString c -- c eh cauda, b eh segundo elemento e a eh o primeiro elemento

-- auxilia na impressao dos asteriscos
impAsterisco :: Int -> String
impAsterisco  0 = [ ]
impAsterisco qtd = "*" ++ impAsterisco (qtd - 1)

-- auxilia nos espacos
impEspaco :: Int -> String
impEspaco 0 = [ ]
impEspaco qtd = ' ' : impEspaco (qtd - 1) --aspas simples porque eh para concatenar com uma lista

-- Questao 02

type Linha = String

toLinhas :: String -> [Linha]
toLinhas [ ] = [ ]
toLinhas (a : b : c : d) = ([a] ++ [b] ++ [c] ) : toLinhas d -- a, b e c representa cada elemento ou seja cada "*" e d eh o resto dos astericos e espacos

--para testar coloque no terminal toLinhas (toString nove) nove pode ser qualquer um dos outros numeros de zer - nove

-- Questao 03
--imprime os \n a cada tres caracteres

showLinhas :: [Linha] -> String
showLinhas [n] = n
showLinhas (a : b) = a ++ "\n" ++ showLinhas b ++ "\n"

-- Questao 04
-- recebe duas listas que podem ser numeros e concatena numa so lista

juntaLinhas :: [Linha] -> [Linha] -> [Linha]   
juntaLinhas [ ] [ ] = [ ]
juntaLinhas (a1 : b1) (a2 : b2) = (a1 ++ " " ++ a2) : juntaLinhas b1 b2

-- Questao 05
-- [ ] !! int  concatena com a lista com o int
-- recebe numeros de ate tres digitos

toLcd :: Int -> String
toLcd n = showLinhas (toLcd2 n)

toLcd1 :: Int -> IO( )
toLcd1 n = putStr (showLinhas (toLcd2 n))

toLcd2 :: Int -> [Linha]
toLcd2 n
        | n <= 9 = toLcdAux n
        | n <= 99 = juntaLinhas (toLcd2 (div n 10)) (toLcd2 (mod n 10))
        | n <= 999 = juntaLinhas (toLcd2 (div n 100)) (toLcd2 (mod n 100))
        | otherwise = error "Garotinho so eh permitido numeros de tres digitos"

toLcdAux :: Int -> [Linha]
toLcdAux n = toLinhas (toString (numeros !! n))       
       
numeros :: [[Int]]
numeros = [zero,um,dois,tres,quatro,cinco,seis,sete,oito,nove]

-- Questao 06

--toCompact :: String -> [Int]
--toCompact numero

Pelo monitor Jaime Freire

Falta a questão 06 que ainda tentarei fazer.

Mais informações »

Lista 01 - Recursão

Alguns exercícios de recursão

-- Lista de Exercicio 01

vendas :: Int -> Int
vendas 1 = 20
vendas 2 = 32
vendas 3 = 21
vendas 4 = 60
vendas 5 = 25
vendas 6 = 12
vendas 7 = 52
vendas 8 = 28
vendas 9 = 29
vendas 10 = 40
vendas 11 = 50
vendas 12 = 33

-- Questao 01

desloca :: Int -> String -> String
desloca d palavra
        | d == 0 = palavra
        | d > 0 =  " " ++ desloca (d - 1) palavra

-- Questao 02

impAsterisco :: Int -> String
impAsterisco  qtd
        | qtd == 0 = ""
        | qtd > 0 = "*" ++ impAsterisco (qtd - 1)
       
-- Questao 03

centraliza:: String -> String
centraliza palavra = desloca (length (palavra)) palavra ++ desloca (length (palavra)) ""

-- Questao 04

tamanhoLinha :: Int
tamanhoLinha = 40

cabecalho :: String
titulo = "Relatorio de Venda de Microcomputadores"
cabecalho = impAsterisco tamanhoLinha ++ centraliza titulo ++ impAsterisco (tamanhoLinha +1) ++ "\n"

-- Questao 05

mes :: Int -> String
mes m
        | m == 00 = "Este mes nao existe."
        | m == 01 = "Janeiro"
        | m == 02 = "Fevereiro"
        | m == 03 = "Marco"
        | m == 04 = "Abril"
        | m == 05 = "Maio"
        | m == 06 = "Junho"
        | m == 07 = "Julho"
        | m == 08 = "Agosto"
        | m == 09 = "Setembro"
        | m == 10 = "Outubro"
        | m == 11 = "Novembro"
        | m == 12 = "Dezembro"
       
-- Questao 06

impBranco :: Int -> String
impBranco  qtd
        | qtd == 0 = ""
        | qtd > 0 = " " ++ impBranco (qtd - 1)
       
-- Questao 07

impMes :: Int -> String
impMes mesp = desloca 6 (mes mesp) ++ impBranco (tamanhoLinha - length(mes mesp)) ++ show (vendas mesp) ++ "\n"

-- Questao 08

impMeses :: Int -> String
impMeses 1 = impMes 1 ++ "\n"
impMeses messp = impMeses (messp - 1) ++ impMes messp ++  "\n"  

-- Questao 09

somaVendas :: Int -> Int
somaVendas 1 = vendas 1
somaVendas v = somaVendas (v - 1) +  vendas v

-- Questao 10

impSoma :: Int -> String
impSoma sv = impAsterisco tamanhoLinha ++ "\n" ++ desloca 6 ("Total de Vendas: ") ++ show (somaVendas sv) ++ "\n"

-- Questao 11

maiorVenda :: Int -> Int
maiorVenda 1 = vendas 1
maiorVenda maior = maiorVendaAux (vendas maior) (maiorVenda (maior - 1))

maiorVendaAux :: Int -> Int
maiorVenda v1 v2
        a >= b = a
        otherwise = b
       
Falta as útimas questões logo logo postarei aqui.

Mais informações »

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 »