Haskell - Exercicios

import Data.Char
import Data.List

-- Ex 1

-- Escreva uma função recursiva que verifica se um dado elemento pertence à uma lista.
-- A função deve ter como argumentos uma lista e o elemento a ser procurado, e deve
--produzir como resultado um valor booleano (True/False) como no exemplo abaixo:
--      > pertence ’a’ [’b’,’c’,’a’,’d’]
--      True

pertence :: Eq l => l -> [l] -> Bool
pertence x [] = False
pertence x (h:t) = if (x == h) then True
                    else pertence x t

-- Ex 2

--Escreva uma função para calcular a média dos elementos de uma lista de números.
--Deve-se implementar duas funções recursivas, uma para obter a quantidade de ele-
--mentos e outra para obter a soma dos elementos.Finalmente, a média é calculada pela
--divisão entre a soma e a quantidade.
--      > media [4,5,2,7]
--      4.5

qtd :: [Float] -> Float
qtd [] = 0
qtd (h:t) = 1 + qtd t

soma :: [Float] -> Float
soma [] = 0
soma (h:t) = h + soma t

media :: [Float] -> Float
media l = (soma l) / (qtd l)

--  Ex 3
--  Seja a função abaixo:
--  maior [a] = a
--  maior (a:as) = if (a > (maior as)) then a else (maior as)
-- (a) Defina o tipo mais genérico para essa função;
-- (b) Reescreva essa função eliminando o comando if;
-- (c) Com base nessa função, crie uma nova função que devolva o menor elemento de
-- uma lista. Não se esqueça de definir o tipo;
-- (d) Usando as funções maior e menor, crie uma nova função que, a partir de uma
-- lista, devolve o maior e o menor elemento em uma tupla. Não se esqueça de
-- definir corretamente o tipo dessa função.

maior [h] = h
maior (h:t) = max h (maior t)

menor [h] = h
menor (h:t) = min h (menor t)

maiorMenor :: [Integer] -> (Integer,Integer)
maiorMenor l = (maior l,menor l)

-- Ex 4
-- No módulo Char encontramos a função toUpper que converte uma letra minúscula na
-- sua correspondente maiúscula1.
--  (a) Crie uma função recursiva maius que converte todas as letras de uma palavra em
-- maiúsculas;
--  (b) Usando a função isAlpha, também do módulo Char, refaça a função maius para
--descartar símbolos e números;
--  (c) Faça uma nova função que recebe uma palavra e devolve em tupla a palavra
-- original e a sua correspondente escrita em maiúscula.

-- a
maius :: [Char] -> [Char]
maius [] = []
maius (h:t) = (toUpper h) : maius t

-- b
maius2 :: [Char] -> [Char]
maius2 [] = []
maius2 (h:t) = if isAlpha h then (toUpper h) : maius2 t
                else maius2 t
-- c
letterC :: [Char] -> ([Char],[Char])
letterC l = (l,maius l)

-- Ex. 5
-- Implemente, usando recursão, as seguintes operações sobre conjuntos (listas):
--(a) pertence: define se um dado elemento pertence a um conjunto;
--(b) uniao: dados dois conjuntos, fornece a união deles;
--(c) inter: dados dois conjuntos, fornece a intersecção deles;
--(d) diff: dados dois conjuntos, fornece a diferença deles;
--(e) subCon: dados dois conjuntos, diz se o primeiro é subconjunto do segundo

-- a

-- b
concatena :: Eq t => [t] -> [t] -> [t]
concatena [] l2 = l2
concatena (x:xs) l2 = x : (concatena xs l2)

uniaoAux :: Ord t => [t] -> [t] -> [t] -> [t]
uniaoAux [] l2 l3 = (l2 ++ l3)
uniaoAux (x:xs) l2 l3 = if not(pertence x l2) then uniaoAux xs l2 (x : l3)
                        else uniaoAux xs l2 l3

uniao :: Ord t => [t] -> [t] -> [t]
uniao l1 l2 = sort (uniaoAux l1 l2 [])

-- c
interAux :: Ord t => [t] -> [t] -> [t] -> [t]
interAux [] l2 l3 = l3
interAux (x:xs) l2 l3 = if (pertence x l2) then interAux xs l2 (x : l3)
                    else interAux xs l2 l3

inter :: Ord t => [t] -> [t] -> [t]
inter l1 l2 = sort(interAux l1 l2 [])

-- d
diffAux :: Ord t => [t] -> [t] -> [t] -> [t]
diffAux [] l2 l3 = (sort l3)
diffAux (x:xs) l2 l3 = if not(pertence x l2) then diffAux xs l2 (x:l3)
                        else diffAux xs l2 l3

diff :: Ord t => [t] -> [t] -> [t]
diff l1 l2 = sort((diffAux l1 l2 []) ++ (diffAux l2 l1 []))

-- e
subCon :: Ord t => [t] -> [t] -> Bool
subCon [] l2 = True
subCon (x:xs) l2 = if (pertence x l2) then subCon xs l2
                    else False