1ª 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: Agay Borges (abn), David Hulak (dbh), Glauco Santos (grps), Lí-via Vilaça (lcjbv), Luís Gabriel Lima (lgnfl), Pedro Melo (pam2), Thales Alex (tata), Vanessa
Gomes de Lima (vgl2), Walter Ferreira (wflf)
Engenharia da Computação: Alan Gomes (aga), Dennis Silveira (dwas), Eduardo Rocha (ejfrf), Felipe de Souza (fsa2), Gabriel Avelar (gafm), Lucas Inojosa (licf), Victor Hugo (vhca),
Wellington Oliveira (woj) CIn-UFPE – 2011.2 Disponível desde: 08/09/2011
Entrega: 21/09/2011
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 13 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.
1) Dado um conjunto de strings, implementar uma função inverteEConcatena que receba esse conjunto e inverta as letras de cada palavra bem como sua caixa (maiúsculo para minúsculo e vice-versa). Feito isso, essa mesma função deve concatenar seu nome (em maiúsculo) no início e no final da string obtida como resultado do procedimento anterior. Dica: as funções de folding e de mapeamento auxiliam bastante nessa questão, bem como as de inversão de caixa. Obs.: todas as funções usadas, mesmo havendo implementações em haskell para elas, precisam ser reescritas. Por exemplo, é necessário que seja criado um "meuMap", para evitar conflitos, que será utilizado na resolução da questão, depois deve-se utilizar também o map de haskell, e comparados os resultados com comentários no arquivo da questão.
-Exemplos:
Prelude> inverteEConcatena ["eXeMpLoUm", "eXeMpLoDoIs"] "FULANOMuOlPmExESiOdOlPmExEFULANO"
2) Determine o tipo, e comente o comportamento, de cada uma 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) map.foldr(/)
3) Considere 3 listas de tipos diferentes definidos:
- Lista de empregados: [Empregado]
* Composto por seu nome, nome do chefe atual e lista de nomes dos chefes anteriores: * type Empregado = (Nome, Nome, [Nome])
- Lista de chefes: [Chefe]
* Composto por seu nome, nome da empresa atual e lista de nomes de empresas anteriores
* type Chefe = (Nome, Nome, [Nome])
- Lista de empresas: [Empresa]
* Composta por nome e ramo de atuação * type Empresa = (Nome, Ramo)
type Nome = String type Ramo = String
Crie uma função consulta :: Ramo -> [Empregado] -> [Chefe] -> [Empresa] -> [Nome] que retorne os nomes de todos os empregados os quais já trabalharam ou trabalham para algum chefe que trabalha E já trabalhou em qualquer empresa de um determinado ramo de atuação, indicado pelo primeiro argumento da consulta (note o E, ele deve ter experiência passada em outra empresa do ramo E TAMBÉM deve estar trabalhando em outra deste mesmo ramo).
Utilize funções filter aninhadas para filtrar o resultado (possivelmente criando outras funções auxiliares para tal).
-Exemplos:
Prelude> let empregados = [("Eduardo Rocha", "Marcio Cornelio", ["Fernando Castor", "Paulo Borba"]),("Pedro Araujo", "Fernando Castor", ["Paulo
Borba"]),("Lucas Inojosa", "Ruy de Queiroz", ["Marcio Cornelio", "Fernando Castor"])]
Prelude> let chefes = [("Fernando Castor", "GVT", ["UFPE", "PriceWaterhou-seCoopers"]),("Marcio Cornelio", "Telpe", ["GVT", "UFPE"]),("Ruy de Quei-roz", "UFPE",["Stanford"])]
Prelude> let empresas = [("GVT", "Telecomunicacoes"),("UFPE", de"),("PriceWaterhouseCoopers", "Consultoria"), ("Stanford", "Universida-de"), ("Telpe", "Telecomunicaoes")]
Prelude> consulta "Telecomunicacoes" empregados chefes empresas ["Eduardo Rocha", "Lucas Inojosa"]
4) Considere o seguinte problema: Uma pessoa deseja comprar um computador novo, ela tem acesso a diversas lojas diferentes e essas oferecem uma relação custo/benefício e velocidades variadas para cada uma das peças.
Implemente uma função que vai selecionar o melhor computador dentre as opções de peças possiveis.
Detalhes da implementação :
- Um computador é sempre composto de 3 partes: Memória, Processador e Periféricos - A resposta deve conter 3 peças, uma de cada uma das partes que compõe um computador.
- A pessoa interessada em comprar pode atribuir pesos diversos (inclusive podendo atribuir pesos negativos) para a velocidade e o custo/benefício da peça, mas somente um peso para todas as peças por execução de função. Contudo, os pesos podem ser distintos para o custo/benefício e para a velocidade.
- A resposta deve deixar claro a loja dona da peça, qual o custo/benefício, a velocidade e um número de identificação para a peça.
- O número de identificação pode ser qualquer tipo desejado, mas deve ser único dentre todas as peças, inclusive peças de outras lojas.
Obs.: Considere duas peças, uma com custo/benefício igual a 3 e velocidade igual a 2 a outra com custo benefício igual a 5 e velocidade igual a 1. Caso os valores dos pesos sejam 1 para custo/benefício e 1 para velocidade, a segunda peça(1*5 + 1*1) seria melhor que a primeira(1*3 + 1*2) mas caso os valores dos pesos fossem 1 para custo/benefício e 3 para velocidade então a primeira (1*3 + 3*2) seria melhor que a primeira (1*5 + 3*1).
5) Considere uma lista de funções do tipo (Int, Int) -> Int (ou seja, funções que recebem como entrada uma dupla de números inteiros e retorna um número inteiro).
Agora defina e implemente uma função ordenar :: [(Int, Int) -> Int] -> Int -> Int -> [Int] (a qual recebe 3 argumentos como visto) que ordena a lista de funções (o primeiro dos ar-gumentos) em ordem crescente usando um algoritmo de ordenação qualquer de sua preferência e gera a mesma lista. Explicarei mais abaixo o critério de comparação das funções, de quem é maior ou menor do que quem.
O retorno deverá ser esta lista convertida para os inteiros que serão obtidos do resulta-do (passanresulta-do os argumentos, elas vão retornar um Int certo?). Os parâmetros passaresulta-dos em todas as funções da lista serão os 2 últimos argumentos da função (note o Int -> Int).
Uma função (do tipo definido lá em cima) será considerada maior do que a outra se, para dados 2 inteiros (que serão passados como entrada na tupla da função), ela retor-ne um valor maior do que a outra. ou seja, se uma função xxx para (4, 2) retorna 5 e ou-tra yyy para (4, 2) retorna 7, a segunda é maior do que a primeira. Acho que ficou claro o critério de comparação. Na função ordenar, todas as funções da lista de funções rece-berão a mesma dupla de parâmetros.
-Exemplos:
Prelude> ordenar [ (\(x,y) -> x+y) , (\(x,y) -> x*y) , (\(x,y) -> y-x) , (\ (x,y) -> 2*x+y) ] 2 3
[1, 5, 6, 7]
6) Considere a seguinte assinatura de função :
decompositor :: [(a -> b -> b)] -> a -> [(b -> b)]
Implemente a função de forma que ela receba uma lista de funções do tipo indicado e um parâmetro válido para aquelas funções e o retorno dela deve ser uma lista de funções parcialmente aplicadas.
Após implementar a função acima, implemente a seguinte função :
aplicador :: [(a -> b -> b)] -> a -> b -> [b]
Importante : A resposta para a função aplicador DEVE utilizar a função decompositor para atingir a resposta.
-Exemplos:
Prelude> aplicador [(+),(-),(*),(/)] 8 2 [10.0,6.0,16.0,4.0]
7) Um compilador é formado por um analisador léxico que lê o código-fonte e o transforma em partes chamadas Tokens, pensando nisso, defina um tipo Token com quatro construtores Num, Op e Par, que, respectivamente, representam: um número (ex.: 1,2,3..); um operador (ex.: '+', '-' , '*', '/') e os parênteses (ex.: ')', '(' ). Defina também uma função lexer :: String → [Token], que leia uma string representando uma expressão (ex.: “((1+3)+((22*32)/(221+32)))”) e retorne uma lista de tokens.
-Exemplos:
Prelude> lexer “(100-90)”
[Par '(',Num 100,Op '-',Num 90,Par ')'] Prelude> lexer “((1+2)+(23*44))”
[Par '(',Par '(',Num 1,Op '+',Num 2,Par ')',Op '+',Par '(',Num 23,Op '*',Num 44,Par ')',Par ')']
8) Depois da análise léxica, no projeto de compiladores há uma segunda fase, que consiste, basicamente, na leitura dos tokens e na criação de uma árvore, chamada análise sintática. Baseado na questão anterior, crie um tipo recursivo Tree e defina uma função parser :: [Token] → Tree que leia a saída da função lexer e gere uma arvore sintática. (obs.: para simplificar, a precedência será sempre imposta pelo uso dos parênteses, por exemplo, a entrada “(1+2*3)” não será passada, mas a entrada “(1+(2*3))”, sim.
-Exemplos:
Prelude>parser (lexer “(1+22)”)
[No (Op '+') (No (Num 1) Empty Empty) (No (Num 22) Empty Empty)]
Prelude> parser (lexer “(22*(22/44))”)
No (Op '*') (No (Num 22) Empty Empty) (No (Op '/') (No (Num 22) Empty Empty) (No (Num 44) Empty Empty))
Prelude> parser (lexer "((22+55)/(32*2))")
No (Op '/') (No (Op '+') (No (Num 22) Empty Empty) (No (Num 55) Empty Empty)) (No (Op '*') (No (Num 32) Empty Empty) (No (Num 2) Empty Empty))
Prelude> parser (lexer "(32+(43*(21/7)))")
No (Op '+') (No (Num 32) Empty Empty) (No (Op '*') (No (Num 43) Empty Empty) (No (Op '/') (No (Num 21) Empty Empty) (No (Num 7) Empty Empty)))
Equilatero (todos os lados iguais), Isoceles (dois lados iguais), Escaleno (lados dife-rentes) ou NaoEhTriangulo. Com exceção do último, cada um dos construtores desse tipo deve possuir um valor t.
Crie uma função chamada distanciaCircuncentroBaricentro :: Reta Float -> Reta Float -> Reta Float -> Resultado Float. Ela deve-se verificar se as retas formam um triângulo. Se sim, deve-se determinar qual é o seu tipo (equilátero, isósceles ou escaleno), e retornar como resposta o construtor correspondente e a distância entre o circuncentro e o baricentro desse triângulo. Caso não seja um triângulo, mostre como resultado NaoEhTriangulo. Crie ainda a função criarReta :: (t, t) -> (t, t) -> Reta t, que recebe dois dos pontos de uma reta. Ela pertencerá aos parâmetros de distanciaCircuncentroBaricentro e devem definir os valores de Reta t.
-Exemplos:
Prelude> distanciaCircuncentroBaricentro (criarReta (1,1) (4,-2)) (criar-Reta (4,-8) (8,-4)) (criar(criar-Reta (3,-2) (9,-10)))
Escaleno 1,66667
Prelude> distanciaCircuncentroBaricentro (criarReta (1,0) (5,8)) (criarRe -ta (1,-2) (4,7)) (criarRe-ta (3,4) (7,12)))
NaoEhTriangulo
10) Crie o tipo (Tree t) utilizado em sala de aula.
Faça com que ao utilizarmos a função "show" para Tree, a árvore seja sempre mostrada em pré-ordem e na formatação mostrada abaixo.
-Exemplos:
Prelude> let arvore = Node 10 (Node 2 (Node 5 NilT NilT) NilT) NilT Prelude> arvore
10,2,5
11) Crie a classe OrdTree.
A função desta classe vai ser igual à classe Ord, mas para comparar o tipo Tree.
A classe OrdTree deverá ter as funções (>), (>=), (<), (<=), (==) e (/=). Utilize uma função auxiliar valorArvore para "somar" os valores nó a nó da árvore e assim poder comparar uma árvore com a outra.
Crie uma instância de OrdTree para o tipo (Tree Int) e implemente todas as funções.
-Exemplos:
Prelude> let arvore = Node 10 (Node 2 (Node 5 NilT NilT) NilT) NilT Prelude> let arvore2 = Node 10 (Node 20 (Node 5 3 NilT) NilT) NilT Prelude> valorArvore arvore
[17]
Prelude> arvore <= arvore2 True
arestas] e instancie a classe criada anteriormente. Crie um tipo algébrico AdjMatrix que identifique uma Matriz de Adjacências de um grafo cujos nós contém valores do tipo inteiro e também instancie a classe anterior. Crie uma função raizUltimoMenorMaiorMaisLongo que recebe uma árvore cujos nós contém valores de um tipo que possam ser comparados pelos operadores relacionais básicos e transformados em String e retorna uma uma tupla (t, t, t, t, t) que contém o elemento da raiz, o último elemento em in-ordem, o menor elemento, o maior elemento, e o elemento que contenha mais caracteres (em caso de elementos com a mesma quantidade de caracteres, o menor deve ser selecionado).
13) Crie uma nova classe, que herda as classes Ord e Show. Crie as funções tamanho e exibir.
Crie também uma instância dessa classe para o tipo Tree. A função exibir retorna os elementos da Tree e a função tamanho deve mostrar a quantidade de nós.
-Exemplos:
Prelude> exibir (Node 5 (Node 2 (Node 1 NilT NilT) NilT) (Node 6 NilT (Node 7 NilT NilT))
1 2 5 6 7
Prelude> tamanho (Node 5 (Node 2 (Node 1 NilT NilT) NilT) (Node 6 NilT (Node 7 NilT NilT))
5
14) Mago é uma das classes mais populares para personagens, e por bons motivos. Graças a sua grande gama de magias, eles são um dos poucos personagens mais versáteis e poderosos do jogo. O mago é a usina de energia mágica do grupo. Ele pode aumentar as capacidades de combate do grupo, ajudar a seus companheiros a ver o perigo adiante e jogar uma bateria de assaltos mágicos nos inimigos. Dependendo se o mago é um especialista ou não, ele tem acesso a quase todo o tipo de magia arcana existente. Tudo isso graças ao seu alto nível de Inteligência. Mas também pagam um preço alto por sua capacidade de conjurar magias. Seu nível de Agilidade não é tão alto, e de Força é extremamente baixo, o que o torna extremamente vulnerável fisicamente.
Os arqueiros são exímios atiradores no uso do arco, e estão muito além das capacidades de um guerreiro especialista. Sua afinidade e dedicação a um único tipo de arma, torna possível que realizem verdadeiras proezas quando disparam suas flechas. E contrariando as expectativas, arqueiros detestam serem rotulados de meros guerreiros especialistas em arco, pois consideram a sua classe uma classe distinta e com habilidades muito superiores às habilidades de um guerreiro no uso do arco. Toda esta proeza com o arco é devido ao seu excelente nível de Agilidade, mas ainda possui níveis de Força e Inteligência um pouco abaixo (este último é menor ainda, pois não deixa de ser um guerreiro).
Implemente as classes Mago, Arqueiro e Bárbaro, como tipos algébricos que armazenem o nome do personagem e seus valores de Força, Agilidade e Inteligência em atributos de tipos que possam ser comparados pelos operadores relacionais básicos e transformados em String. Crie uma classe Ficha, com a função hierarquizarValores, que recebe o tipo que instancia a classe e retorna uma tripla. Os tipos criados anteriormente devem instanciar esta classe, de modo que a função hierarquizarValores retorne a tripla contendo como primeiro elemento o atributo primordial, o segundo elemento o atributo intermediário, e o terceiro elemento o atributo menos importante. Crie a função lutar que recebe dois valores de um tipo que seja possível fazer uma Ficha, e retorne uma String do tipo “lutadorX com Y venceu lutadorZ, que tinha W”. “lutadorX” e “lutadorZ” são os nomes dos lutadores (respectivamente, o que venceu e o que perdeu). “Y” e “W” são os valores dos atributos que decidiram a batalha. O lutador vencedor deve ser baseado no maior valor de atributo primordial, em caso de empate o segundo atributo da hierarquia deve ser levado em conta, e assim em diante; persistindo o empate até o último atributo, a String retornada deve ser “Infelizmente, lutadorX e lutadorY lutaram até a morte. Descansem em paz”
15) Faça um programa que permita ao usuário escolher dois arquivos através do console e tem como saida um arquivo contendo todas as palavras em comum nos dois arquivos. Não será permitido utilizar "do" para sequenciar operações de IO, utilize ">>" ou ">>=" apenas.
As palavras devem aparecer na sequência que elas aparecem no primeiro texto.
Palavras ja escritas não devem ser repetidas.
Não é case sensitive.
-Exemplos:
nomeDoPrimeiroArquivo nomeDoSegundoArquivo
Saida gerada com sucesso! -- Resposta do programa no console
--primeiroArquivo:
-- Esse era para ser um texto útil mas é na verdade uma porcaria. --segundoArquivo:
-- Esse outro arquivo não deveria ter nada alem da palavra texto e verdade.
--arquivoDeSaída:
Esse texto verdade
-Exemplos:
Aa= e u uo1o ok
Saida gerada com sucesso! – Resposta do programa no console
Arquivo de saida: =Aa
=aA A=a Aa= a=A aA=
eu -- há um space no início ue -- há um space no início e u
eu -- há um space no fim u e
ue -- há um space no fim
