A maior rede de estudos do Brasil

Grátis
6 pág.
Exercícios Haskell

Pré-visualização | Página 1 de 1

LISTA DE EXERCÍCIOS EM HASKELL
1. Elabore uma função chamada “consumo” para calcular o valor da conta de luz a ser paga para 
um equipamento, usando a seguinte fórmula:
- consumo (Kwh) = ((potência do aparelho em Watts)x(horas de funcionamento por mês))/1000
- valor da conta em (R$) = consumo (Kwh) x valor da tarifa (ex: 0,722173)
2. Suponha que o computador não possua a operação de multiplicação. Construa a função 
“multiplica” para calcular o valor da multiplicação de dois números inteiros, m por n.
3. Elabore a função “fatorial” que recebe um número inteiro n e exibe o fatorial do número 
informado.
4. Elabore a função “ordena” que recebe 3 números inteiros e retorna os mesmos em ordem 
crescente.
5. Elabore a função “mdc” que recebe dois números inteiros X e Y e calcula o M.D.C desses 
números.
6. Elabore a função “mmc” que recebe dois números inteiros X e Y e calcula o mmc dos números. (
Você pode usar a função mdc, feita na questão anterior, para resolver este problema.)
7. Elabore a função “potencia” que recebe 2 números inteiros X e Y e calcula o resultado de X 
elevado a Y.
8. Elabore a função “primos” que recebe um número N e devolve uma lista com os fatores primos 
de N.
9. Elabore a função “maior” que recebe uma lista de números inteiros e retorna o maior número da 
lista.
10. Elabore a função “ultimo” que recebe uma lista de números inteiros e retorna o último elemento
da lista.
11. Elabore a função “semonum” que recebe uma lista de números inteiros e um número inteiro e 
retorna uma lista sem as ocorrências do número informado. (Ex: 1 [1,2,6,5,1,6,5,4] = [2,6,5,6,5,4])
12. Elabore a função “reverte” que recebe uma lista de números inteiros e inverte a ordem dos 
elementos da lista. (Não usar a função “reverse”)
13. Elabore a função “maiormenor” que recebe uma lista de números inteiros e devolve como 
resposta o maior e o menor deles. (Ex: [24,12,3] = [24,3]
14. Defina a função “produto” que recebe uma lista com números inteiros e calcula o produto dos 
números da lista.
15. Elabore uma função chamada “unicorr” que recebe uma lista de números inteiros e um número 
inteiro e verifica se existe uma única ocorrência do número na lista. (Ex: 2 [2,1,5,3,2] = False)
16. Elabore uma função chamada “uniao” que recebe duas listas de números inteiros, as listas não 
devem conter elementos repetidos, e retorna uma lista com todos os elementos das duas listas 
originais (sem repetição).
17. Elabore uma função chamada “concatena” que recebe duas listas quaisquer e retorna uma lista 
com os elemtnos da primeiroa no início e os elementos da segunda no final.
18. Elabore uma função chamada “palindroma” que recebe uma cadeia de caracteres (palavra) e 
verifica se ela é palíndroma ou não. (Ex: “ana” = True)
19. Defina a função “parimpar” que recebe uma lista de números inteiros e devolve duas novas 
listas, onde a primeira contém apenas números pares e a segunda os números impares.
20. Defina a função “repetido” que recebe uma lista de números inteiros e responde se na lista 
existe algum elemento repetido.
RESPOSTAS:
1.
consumo :: Float -> Float -> Float -> Float
consumo p h v = ((p*h) / 1000)*v
2.
multiplica :: Int -> Int -> Int
multiplica m n
 | m == 0 || n == 0 = 0
 | n > 0 = m + multiplica m(n-1)
 | n < 0 = -m + multiplica m(n+1)
3.
fatorial :: Int -> Int
fatorial n
 | n == 0 = 1
 | otherwise = fatorial(n-1)*n
4.
ordena :: Int -> Int -> Int -> (Int, Int, Int)
ordena a b c
 |a <= b && b <= c = (a, b, c)
 |a <= c && c <= b = (a, c, b)
 |b <= a && a <= c = (b, a, c)
 |b <= c && c <= a = (b, c, a)
 |c <= c && a <= b = (c, a, b)
 |otherwise = (c, b, a)
5.
mdc :: Int -> Int -> Int
mdc x 0 = x
mdc x y = mdc y (x `mod` y)
6.
mdc :: Int -> Int -> Int
mdc x 0 = x
mdc x y = mdc y (x `mod` y)
mmc :: Int -> Int -> Int
mmc a b
 | a > b = (div a (mdc a b))*b
 | a < b = (div b (mdc a b))*a
7.
potencia :: Int -> Int -> Int
potencia m n
 | n == 0 = 1
 | n == 1 = m
 | n > 0 = m * potencia m(n-1)
8.
fatores :: Int -> [Int]
fatores 0 = []
fatores n = [z | z <- [1..n], mod n z == 0]
verprimo :: Int -> Bool
verprimo 0 = False
verprimo 1 = False
verprimo i
 | fatores i == [1, i] = True
 | otherwise = False
 
primos :: Int -> [Int]
primos 0 = []
primos j = [k | k <- fatores j, verprimo k]
9.
maior :: [Int] -> Int
maior [x] = x
maior (x:xs)
 | x > maior xs = x
 | otherwise = maior xs
10.
ultimo :: [Int] -> Int
ultimo [] = 0
ultimo [x] = x
ultimo (x:xs) = ultimo xs
11. semonum :: Int -> [Int] -> [Int]
semonum n [] = []
semonum n (x:xs)
 | n == x = semonum n xs
 | otherwise = x:semonum n xs
12.
reverte :: [Int] -> [Int]
reverte [] = []
reverte (x:xs) = (reverte xs)++[x]
13.
maior :: [Int] -> [Int]
maior [x] = [x]
maior (x:xs)
 | [x] > maior xs = [x]
 | otherwise = maior xs
menor :: [Int] -> [Int]
menor [x] = [x]
menor (x:xs)
 | [x] < menor xs = [x]
 | otherwise = menor xs
 
maiormenor :: [Int] -> [Int]
maiormenor [x] = [x]
maiormenor l = (maior l)++(menor l) 
14.
produto :: [Int] -> Int
produto [l] = l
produto (x:xs)
 | x == 0 = 0
 | otherwise = (produto xs)*x
15.
cont :: Int -> [Int] -> Int
cont _ [] = 0
cont n (x:xs)
 | n == x = 1 + cont n xs
 | otherwise = cont n xs
 
unicorr :: Int -> [Int] -> Bool
unicorr _ [] = False
unicorr n (x:xs)
 | cont n xs /= 1 = True
 | otherwise = False
16.
sn :: Int -> [Int] -> [Int]
sn x [] = []
sn x (h:t)
 | x == h = sn x t
 | otherwise = h:sn x t
 
uniao :: [Int] -> [Int] -> [Int]
uniao [x] l = x:sn x l
uniao (h:t) l = h:uniao t (sn h l)
17.
concatena :: [t] -> [t] -> [t]
concatena a b = a++b
18. reverso :: String -> String
reverso [] = []
reverso (x:xs) = (reverso xs) ++ [x]
palindroma :: String -> Bool
palindroma (x:xs)
 | (x:xs) == reverso (x:xs) = True
 | otherwise = False
19.
par :: [Int] -> [Int]
par [] = []
par (x:xs)
 | mod x 2 == 0 = x:par xs
 | otherwise = par xs
 
impar :: [Int] -> [Int]
impar [] = []
impar (x:xs)
 | mod x 2 /= 0 = x:impar xs
 | otherwise = impar xs
 
parimpar :: [Int] -> ([Int],[Int])
parimpar [] = ([],[])
parimpar l = ((par l),(impar l))
20.
existe :: Int -> [Int] -> Bool
existe a [] = False
existe a (h:t)
 | a == h = True
 | otherwise = existe a t
repetido :: [Int] -> Bool
repetido [] = False
repetido (x:xs)
 | existe x xs = True
 | otherwise = repetido xs