2ª Lista de Exercícios de Paradigmas de Linguagens Computacionais Professores: Fernando Castor, Paulo Borba e Márcio Cornélio
Monitores:
Ciência da Computação: Alberto Rodrigues Costa Junior (arcj), Jéssica de Carvalho Barbalho (jcb), Luana Martins dos Santos (lms7)
Engenharia da Computação: Bruno Gomes Correia Rodrigues (bgcr), Felipe de Souza Araujo (fsa2), Jefferson Luis Alves de Medeiros (jlam)
CIn-UFPE-2012.2 Disponível desde: 19/01/2012
Entrega: 01/02/2013
A lista deverá ser respondida em dupla. A falha em entregar a lista até a data estipulada implicará na perda de 0,25 ponto na média da disciplina para os membros da dupla. Considera-se que uma lista na qual menos que 8 das respostas estão corretas não foi entregue. A entrega da lista com pelo menos 12 das questões corretamente respondidas implica em um acréscimo de 0,125 ponto na média da disciplina para os membros da dupla. Se qualquer situação de cópia de respostas for identificada, os membros de todas as duplas envolvidas perderão 0,5 ponto na média da disciplina. O mesmo vale para respostas obtidas a partir da Internet. As respostas deverão ser entregues exclusivamente em formato texto ASCII (nada de .pdf, .doc, .docx ou .odt) e deverão ser enviadas para o monitor responsável por sua dupla, sem cópia para o professor. Devem ser organizadas em arquivos separados, um por questão, entregues em um único formato compactado, ou seja, um único arquivo zipado contendo as respostas para todas as questões. Se você ainda não fez isso, vá até a página da monitoria da disciplina (http://goo.gl/BUEn4 ou http://goo.gl/IldMn) e coloque os nomes dos membros da sua dupla abaixo do nome do monitor que tem menos duplas até o momento.
1) Considere os seguintes tipos sinônimos: Lado = Float
Triangulo = (Lado, Lado, Lado)
Implemente uma função que recebe uma lista de Triangulo e retorna a soma das áreas dos respectivos triângulos. Use obrigatoriamente as funções foldr1 e map.
2) Dado as composições de funções abaixo, diga para cada uma delas, se é possível fazer a composição e o porque ( explicando o passo a passo ) e se não for possível também explique o porque (no passo a passo dizer onde deu/daria errado).
a) map.map b) foldl.foldr c) foldr.foldr.filter d) map.map.filter e) map.foldr.map
3) Cria o operador forward composition (>.>) que dado duas funções como parâmetro. Ele
compõe as respectivas funções de forma que o resultado seja igual a aplicação sucedidas dessas funções da esquerda para a direita.
(>.>)::(a->b)->(b->c)->(a->c)
4) Implemente uma função functions :: [(a -> a -> a)] -> [a] -> [(a -> a)], tal que recebe uma lista de funções binárias, uma lista de valores. O funcionamento de functions é tal que aplica cada função a um respectivo elemento da lista de valores e retorna uma lista de funções parcialmente aplicadas.
Inclua alguns exemplos de entrada e respectiva saída para functions, em comentário no arquivo de resposta.
5) Determine o tipo das funções abaixo mostrando os passos até obter o resultado. Se for preciso, identifique as classes dos parâmetros polimórficos. Caso não seja possível determinar o tipo, explique o porquê.
a) ((:).foldr.foldr) (:) b) map.map.foldr c) foldr.foldr.foldl d) foldl.foldr.foldl e) map.(foldr(/2))
6) Considere uma lista de alunos com seus nomes completos, escreva um programa que retorne a lista de nomes abreviados da seguinte forma:
abrev ["Alberto Rodrigues Pontes", "Amanda Azevedo Mendes"] >> ["A. Mendes", "A. Pontes"]
Depois de abreviados ordene a lista em ordem alfabética, utilize funções como map, fold e filter para resolver a questão.
7) Defina um tipo algébrico Temperatura com 3 construtores (Celsius, Fahrenheit e Kelvin) que terão valores (Float) representando temperaturas nas escalas indicadadas. Em seguida, crie instancias de Ord, Eq e Show para Temperatura(leve em conta que TemperaturaCelsius/5 = (TemperaturaFahrenheit-32)/9 = (TemperaturaKelvin-273)/5) depois crie uma função minMax, que recebe um lista de temperaturas e retorna uma tupla-2 em que o primeiro elemento é a menor temperatura da lista e o segundo elemento a maior.
8) A prefeitura de uma cidade quer saber quais dias de um determinado periodo a temperatura na cidade ultrapassou a média de temperatura neste mesmo período, porem o termômetro da cidade esta desregulado. Crie uma função mediaTemp que recebe uma lista de (Temperatura,Data) e uma função de correção de temperatura (Temperatura -> Temperatura) e retorna uma uma lista de (Temperatura,Data) dos dias em que temperatura ultrapassou a média.
Obs.: Crie um tipo algébrico Data(que indique dia, mês e ano); Utilize o tipo algébrico Temperatura da questão anterior;
É obrigatório que você crie suas próprias funções de alta ordem(map, filter,...).
10) a)Crie o tipo algébrico (data Arvore a) que representa uma árvore binária. b)Crie uma classe (Box b) com as seguintes definições:
mapB::(a->c)->(b a)->(b c)
que recebe uma função de conversão e converte de um Box pra outra(equivale ao map de listas).
foldPre::(a->a->a)->a->(b a)-> a
que recebe uma função de redução e reduz uma Box á um tipo a ,executando em pré-ordem (equivale ao foldl de listas).
foldPos::(a->a->a)->a->(b a)-> a
que recebe uma função de redução e reduz uma Box á um tipo a , executando em pos-ordem (equivale ao foldr de listas).
c) Implemente as seguintes instâncias : instance (Box [])
instance (Box Arvore)
instance Show a => Show (Arvore a) instance Eq a => Eq (Arvore a)
11) Nomeie o tipo Measurement, que será um Double.
Crie um tipo Sample t, que possui um atributo [t] (que chamaremos de input) e um atributo t (que chamaremos de output).
Crie um tipo Net t, que possui um atributo [[t]], um [t] e uma função [t] -> [t] -> t. Implemente as seguintes funções:
lengthDouble :: [t] -> Double
lengthDouble (x:xs) = 1 + (lengthDouble xs) lengthDouble [] = 0
tuplify :: [Sample Double] -> [Double] -> [(Double, Double)] tuplify ((Sample i o):ss) (p:ps) = (o, p):(tuplify ss ps)
tuplify [] _ = [] tuplify _ [] = []
rmse :: [Sample Double] -> [Double] -> Double rmse s p
| (length s) == (length p) = sqrt ((foldr (+) 0 (map (\(x, y) -> (x-y)**(2)) (tuplify s p))) / ((lengthDouble p)))
Crie uma classe Model (m t) com as funções: newModel :: (m t)
runModel :: (m t) -> Sample t -> t testModel :: (m t) -> [Sample t] -> [t] trainModel :: (m t) - > [Sample t] - > (m t)
Instancie esta classe para Net Double de modo que:
newModel deve gerar um novo Net Double com atributos à sua escolha;
runModel n s deve associar o input de um Sample Double, s, a um Double, tal valor será em função apenas do input desse s e do n.
testModel n s deve associar o input de cada Sample Double em s a um Double, tal valor será em função apenas do input do respectivo Sample Double e do n.
trainModel n s:
Cada n' obtém um certo rmse s (testModel n' s)
trainModel n s deve ajustar os atributos do n a fim de retornar um n' que minimize o resultado da função rmse s (testModel n' s).
Ex.:
let s = [Sample [0.14767932489451474,-0.15025906735751293,-0.1923076923076923,0.25,-0.36986301369863017,0.14653407429072796,-0.6985462892119358] 0.4482758620689655 , Sample
[-0.7805907172995781,0.544041450777202,0.46923076923076934,-0.5,0.041095890410958846,-0.21029540801403945,-0.19357306809487385] -1.0] rmse s (testModel newModel s) pode retornar 0.5524851346 enquanto
rmse s (testModel (trainModel newModel s) s) pode retornar 0.1200456739 . Brinque de criar novos modelos e instanciar a classe com eles. =D
13) Nomeie um tipo para representar um estado.
Crie um tipo ST s a, onde s normalmente será um estado e a um outro tipo, para representar um “transformador de estado”, que será uma função com um parâmetro do tipo s e um retorno do tipo (a, s).
Conselho: crie uma função runST :: (ST s a) -> (s -> (a, s)) que apenas “desencapsula” a função dentro do ST.
Instancie a classe Monad para o tipo criado, de modo que:
return deve receber um parâmetro x e retornar um ST que recebe um estado s como parâmetro e devolve a tupla (x, s);
(>>=) deve receber dois parâmetros, um processor do tipo ST s a e outro processorGenerator do tipo (a -> ST s b).
(>>=) deve retornar um ST que recebe um estado state0 como parâmetro e tem como resultado: Chamando de (out1, state1) o resultado da aplicação da função em processor sobre state0; Chamando de processor2 o resultado da aplicação de processorGenerator sobre out1; O resultado da aplicação da função em processor2 sobre state1 retorna primeiro membro da tupla retornada pela função seja utilizada.
Em outras palavras:
(processor >>= processorGenerator) s0 deve resultar em uma saída e um estado, tal saída deve ser aplicada a processorGenerator e o ST resultante deve ser aplicado àquele estado. Esta Monad obedece as três leis de Monad?
Crie uma função pseudoRandom que recebe um estado e retorne uma tupla com um inteiro pseudo-aleatório e um novo estado.
Ex.:
pseudoRandom 0 pode retornar (-34773803, 1); pseudoRandom 1 pode retornar (46883875, 2).
Utilizando pseudoRandom, crie uma função newPseudoRandom que recebe uma lista de Int e retorne um ST, que, dado um estado, adicione um novo inteiro pseudo-aleatório à cabeça da lista e altere tal estado.
Utilizando (>>=) e pseudoRandomList, crie uma função que recebe um inteiro e resulte em um ST, que, dado um estado, retorne uma lista de inteiros pseudo-aleatórios e um outro estado. Ex.: fst ((runST (pseudoRandomList 2)) 0) pode retornar [-34773803, 46883875].
15) Toninho é um cara muito esperto, cansado de ficar minimizando e maximizando o ghci na hora de corrigir algum erro nas suas questões, resolveu criar as seguintes funções para realizar pequenas alterações no código sem sair do ghci.
printFile::String->IO ()
-recebe o nome do arquivo e imprime seu conteúdo na tela. replace::String->String->String->IO()
--recebe o nome do arquivo , a string que será substituída(velha) e a string que irá substitui- a(nova). Todas ocorrência de velha no arquivo devem ser substituídas por nova(equivale ao ctrl + h no notepad);
Ele gostou tanto da sua ideia que decidiu compartilhar com seu colegas , para tal criou a função main::IO()
1-pergunta o nome do arquivo 2-imprime o conteúdo
3-pergunta a string que será substituída(velha) 4-pergunta a string que irá substituir-la(nova)
5-atualiza o arquivo(Todas ocorrências de velha no arquivo devem ser substituídas por nova) 6- imprime o arquivo
Como toninho gosta de uma gambiarra , seu código é ilegível então para fins de aprendizado você decidiu criar as mesmas funções.
(dica : se necessário utilize um arquivo temporário) -- conteúdo entrada.hs
isPrimos::Int->(Bool) isPrimos n | n<2 =False
|otherwise =all (\x-> n`mod` x /= 0) (takeWhile (floor(sqrt(toEnum n)) >= ) primos)
primos::[Int]
primos = 2:[x |x<-[3 ..],null [y| y<-[2..floor(sqrt(toEnum x))],x `mod` y ==0]] --fim do conteúdo de entrada.hs
prelude>repleace “entrada.hs” “null [y| y<-[2..floor(sqrt(toEnum x))],x `mod` y ==0]” “isPrimos x”
-- conteúdo entrada.hs isPrimos::Int->(Bool) isPrimos n | n<2 =False
|otherwise =all (\x-> n`mod` x /= 0) (takeWhile (floor(sqrt(toEnum n)) >= ) primos)
primos::[Int]
