Teste 07/08 {Resolução }

Enunciado em >>

{-
Atenção ao copy\paste uma vez que os tabs não estão atribuidos, e como se sabe o haskell é sensivel à Indentation...xD
-}

module Teste where

import IO ()

--Tipos e classes necessarias para a resolução do teste
type Filme = (Titulo,Realizador,[Actor],Genero,Ano)
type Titulo = String
type Realizador = String
type Actor = String
type Ano = Integer

type Filmes = [Filme]

data Genero = Comedia | Drama | Ficcao | Accao | Animacao | Documentario
deriving (Eq,Show)

data Avaliacao = NaoVi | Pontos Int
deriving (Ord,Eq,Show,Read)

type FilmesAval = [(Filme,[Avaliacao])]

data Abin a = Vazia | Node Int (Abin a) (Abin a)
deriving (Show,Eq,Ord)

-- Dados para testar
actores=["act1","act2","act3"]
filme1=("Resolucao do Teste de PF","Miguel Correlo",actores,Documentario,2009)
filme2=("Um","Desconhecido",actores,Comedia,2003)
filme3=("Genero = Um Quanquer","Desconhecido",actores,Documentario,2001)
filmes=[filme1,filme2,filme3]
avaliacao1= [NaoVi,Pontos 3, Pontos 4,Pontos 2, NaoVi]
avaliacao2= [NaoVi,Pontos 3, Pontos 4,Pontos 5, NaoVi, Pontos 2,Pontos 1, NaoVi]
avaliacao3= [NaoVi,Pontos 3, Pontos 4,Pontos 5, NaoVi, Pontos 2,Pontos 1, NaoVi, Pontos 2,Pontos 1, NaoVi]
filmesAvaliacao=[(filme1,avaliacao2),(filme2,avaliacao3),(filme3,avaliacao1)]
---------------------------------
--pg1
parte::Int->[Int]->([Int],[Int],[Int])
parte n [] = ([],[],[])
parte n l = ((filter (n) l)

--pg2
merge::[Float]->[Float]->[Float]
merge [] [] = []
merge [] r = r
merge l [] = l
merge (x:xs) (y:ys) | (x>y) = y:(merge (x:xs) ys)
| otherwise = x:(merge xs (y:ys))

--pg3
semMin::Abin Int->Int->(Int,Abin Int)
semMin ntree n = let arv = calcArv ntree n
;num = calcVal ntree n
in
(num,arv)
where
calcArv (Node val Vazia dir) n = Vazia
calcArv (Node val esq dir) n = (Node val (calcArv esq n) dir)
calcVal (Node val Vazia dir) n = val
calcVal (Node val esq dir ) n = calcVal esq n
-- funcoes auxiliares para teste

--lista -> arvore balanceada
toTree::[Int]->Abin Int->Abin Int
toTree [] Vazia = Vazia
toTree [] (Node n esq dir) = (Node n esq dir)
toTree (x:xs) ntree = (toTreeAux (toTree xs ntree) x)
where
toTreeAux Vazia n = (Node n Vazia Vazia)
toTreeAux (Node val esq dir) n | (n > val) = (Node val esq (toTreeAux dir n))
| (n < n ="=" valores="toTree"> Realizador -> Filmes
doRealizador l rea = (filter (\(_,r,_,_,_)->(r==rea)) l)

-- pg 4 a)
doActor :: Filmes -> Actor -> [Titulo]
doActor [] _ = []
doActor ((t,r,lactores,g,a):xs) act | (elem act lactores) = t:doActor xs act
| otherwise = doActor xs act
-- pg 4 a)
consulta :: Filmes -> Genero -> Realizador -> [(Ano, Titulo)]
consulta bd gen rea = map aux (filter (teste gen rea) bd)
where
teste :: Genero -> Realizador -> Filme -> Bool
teste g r (_,x,_,y,_) = g==y && r==x

aux::Filme->(Ano,Titulo)
aux (t,r,lac,g,a) = (a,t)

--PARTE II

--pg1 Avaliacao como instância da classe Ord, em comentario porque cria conflitos com o Preload

-- class Ord a where
-- max::a->a->a
-- instance Eq Avaliacao where
-- (Pontos a) == (Pontos b) = a == b
-- instance Ord Avaliacao where
-- (Pontos a) > (Pontos b) = a > b
-- (Pontos a) < (Pontos b) = a <>= (Pontos b) = (a > b) || (a==b)
-- (Pontos a) <= (Pontos b) = (a < a="=" b =" Pontos"> FilmesAval -> String

--pg2
grafico tit fil = let ava = snd (head (filter (\((x,_,_,_,_),y)->(x==tit)) fil))
in
trata (calcNuns (removeNao ava) 1) 1
where
trata::[Int]->Int ->String -- convert cada numero da lista em n estrela (*)
trata [] _= ""
trata l 6 = ""
trata (x:xs) n =(show n)++" " ++ newLine x ++ trata xs (n+1)

newLine ::Int-> String--recebe um Int convert em n estrilinhas
newLine 0 = "\n"
newLine n = "*"++ newLine (n-1)

calcNuns::[Avaliacao]->Int->[Int]--devolve uma lista com os repectivas classificacoes de pontos
calcNuns l 6 = []
calcNuns [] _ = []
calcNuns l n =(length ((filter (\(Pontos x)->(x==n)) l)) ) : calcNuns l (n+1)

--pg3

listaPorGeneros :: FilmesAval -> [(Genero,[(Titulo,Avaliacao)])]
listaPorGeneros l = let comedia = (calcMedia Comedia l)
;drama = (calcMedia Drama l)
;ficcao = (calcMedia Ficcao l)
;accao = (calcMedia Accao l)
;animacao= (calcMedia Animacao l)
;documentario = (calcMedia Documentario l)
in
(comedia:drama:accao:animacao:documentario:[])
where
calcMedia::Genero->FilmesAval->(Genero,[(Titulo,Avaliacao)])
calcMedia g [] = (g,[])
calcMedia g l = let genero = filter (\((_,_,_,gen,_),ava)->(g==gen)) l
in
media genero g

media::FilmesAval ->Genero-> (Genero,[(Titulo,Avaliacao)])
media [] g = (g,[])
media l gen = let nl = map (\((t,_,_,_,_),lava)->(t,lava)) l
in
(gen,auxMedia nl)

auxMedia::[(Titulo,[Avaliacao])] -> [(Titulo,Avaliacao)]
auxMedia [] = []
auxMedia [(t,[])] = [(t,NaoVi)]
auxMedia ((t, ava):xs) = (t,(cmedia ava)):auxMedia xs

cmedia::[Avaliacao]->Avaliacao
cmedia [] = Pontos 0
cmedia l= (Pontos (div ((foldr (+) 0 (toInt (removeNao l)))) (length (removeNao l))))

toInt::[Avaliacao]->[Int]
toInt [] = []
toInt l = map (\(Pontos n)->(n)) (filter (\(Pontos n)->(n > 0)) l)

removeNao::[Avaliacao]->[Avaliacao]
removeNao []=[]
removeNao (x:xs) | (x==NaoVi) = removeNao xs
| otherwise = x:removeNao xs
--pg4

avalia :: FilmesAval -> IO FilmesAval
avalia nfilmes= do {
putStr "Introduza o nome de um Filme:\n"
;ntit <- getLine ;putStr "Introduza o uma Avaliacao para esse Filme {Pontos x | NaoVi}:\n" ;nAva <- getAvaliacao ;return(addAva nfilmes ntit nAva) } addAva::FilmesAval->Titulo->Avaliacao->FilmesAval
addAva [] ti ava= []
addAva (((tit,e,r,t,y),a):xs) ti ava | (tit==ti) = ((tit,e,r,t,y),(ava:a)):xs
| otherwise = ((tit,e,r,t,y),(a)):addAva xs ti ava

getAvaliacao :: IO Avaliacao
getAvaliacao = do line <- getLine ;return (read line :: Avaliacao)