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