Exercício 1 - Linguagens de Programação 2022 2

Classificado como Público Neste VPL vocês implementarão um Tipo Abstrato de Dados (TAD) usando structs. Este TAD representa números complexos. A descrição dos dados e dos métodos associados a este TAD encontram-se no arquivo complexo.h Qualquer código que opere sobre este TAD deve incluir este arquivo Exercício 1: Implemente, no arquivo main.cpp, o TAD Complexo. Uma vez que você tem o número complexo, implemente a função de computar as raízes, https://wikiciencias.casadasciencias.org/wiki/index.php/Ra%C3%ADzes_de_n%C3%BAmeros_compl exos #include <iostream> #include <cmath> #include <utility> using namespace std; // Tipo abastrato de dados que representa uma número complexo. class Complexo { // Atributos. private: double real; double imag; // Métodos. public: double modulo() { } Complexo conjugado() { } Classificado como Público Complexo inverso() { } Complexo soma(Complexo y) { } Complexo subtrair(Complexo y) { } Complexo multiplicar(Complexo y) { } Complexo dividir(Complexo y) { } }; pair<Complexo, Complexo> raizes(double a, double b, double c) { } int main () { cout << "Digite os coeficientes da equação f(x) = ax^2 + bx + c:" << endl; double a, b, c; cin >> a >> b >> c; auto r = raizes(a, b, c); cout << "(" << r.first.real << ", " << r.first.imag << ") " << "(" << r.second.real << ", " << r.second.imag << ")" << endl; return 0; } ------------------------------------------------------------------------------------------------------------------------------------- std::string nome Neste exercício estaremos simulando um escalonador de processos, ou seja, o subsistema de um SO que escolhe qual processo será executado pela CPU. Para isso, deve-se implementar uma Fila de Prioridades básica, utilizando o std::vector. Classificado como Público Você deverá implementar dois TADs: Processo e ListaProcessos. Cada TAD deve seguir as especificações abaixo: • Processo: 1. Atributos: int id, std::string nome, int prioridade; 2. Processo(int id, std::string nome, int prioridade): Método construtor para a inicialização dos atributos. 3. void imprimir_dados(): Método que faz a impressão dos atributos no seguinte formato: "id nome prioridade", com uma quebra de linha ao final. • ListaProcessos: 2. void adicionar_processo(Processo proc): Método que recebe um Processo e o adiciona na lista de maneira ORDENADA considerando a prioridade informada. A ordenação da prioridade deve ser DECRESCENTE, ou seja, do maior para o menor. Logo, um processo de prioridade 5 deve aparecer antes na lista que um processo com prioridade 1. Em caso de prioridades iguais, a ordem de inserção deve ser respeitada. Dica: A função insert da classe vector pode te ajudar a inserir um elemento na posição correta. 3. Processo remover_processo_maior_prioridade(): remove da lista o processos de maior prioridade, para facilitar, o primeiro do vetor. Você deve retornar o processo removido. Dica: A função at da classe vector pode te ajudar acessar uma posição específica do vetor, e a função erase da classe vector pode te ajudar a remover um elemento do vetor. 4. Processo remover_processo_menor_prioridade(): remove da lista o processo de menor prioridade, para facilitar, o último elemento do vetor (não precisa respeitar a ordem de inserção). Você deve retornar o processo removido. Dica: A função back() pode te ajudar acessar o último elemento de um vetor, e a função pop_back() pode te ajudar a remover o último elemento de um vetor. 5. Processo remover_processo_por_id(int id): remove da lista um processo de acordo com o id e retorna o processo removido. Considere que o id sempre será válido, isto é, ele sempre existirá na lista quando a função for chamada. Classificado como Público 6. void imprimir_lista(): imprime a situação atual da lista, ou seja, percorre toda a lista (do início para o final) e chama o método 'imprimir_dados()' de cada processo. Você é livre para adicionar nos TADs quaisquer outros atributos ou métodos auxiliares que julgar necessário. Por fim, no arquivo main.cpp você deve implementar toda a parte de entrada/saída que será responsável por manipular os seguintes comandos: • 'a id nome prioridade': comando para adicionar um novo processo na lista de acordo com os parâmetros passados. Você pode assumir que o nome sempre será uma única palavra. • 'm': comando para remover o processo de MAIOR prioridade da lista. • 'n': comando para remover o processo de MENOR prioridade da lista. • 'r id': comando para remover um processo da lista de acordo com o ID informado. • 'p': comando para imprimir a lista. • 'b': deve chamar a função 'avaliacao_basica()' implementada no arquivo "avaliacao_basica_escalonador.hpp" (já incluído no main.cpp). Essa função faz uma avaliação do código (não apenas dos resultados). Para ilustrar, abaixo é apresentado um exemplo de entrada/saída: input= a 1 Proc1 1 a 2 Proc2 1 a 3 Proc3 3 p output = 3 Proc3 3 1 Proc1 1 2 Proc2 1 Atenção: Lembre-se de fazer a correta modularização utilizando os arquivos .hpp e .cpp. Dica 1: O código da avaliação básica pode ser copiado aqui, caso você queira depurar algo localmente. Classificado como Público Dica 2: Você pode usar o código fornecido no exercício anterior e o da avaliação básica para lhe ajudar a fazer toda a parte de entrada/saída. Referências: https://www.cplusplus.com/reference/vector/vector/insert/ https://www.cplusplus.com/doc/tutorial/dynamic/ https://www.cplusplus.com/doc/tutorial/structures/ https://www.cplusplus.com/articles/LACRko23/ ------------------------------------------------------------------------------------------------------------------------- O objetivo desse exercício é praticar o uso de diferentes estruturas da STL. Para ajudar os alunos a encontrarem onde ocorrerão suas aulas, você deverá desenvolver um programa que será responsável por manipular um quadro de alocação de salas. Esse quadro demandará a implementação de três TADs: Alocacao, Disciplina e QuadroAlocacao. Cada TAD deve seguir as especificações abaixo: Classificado como Público • Alocacao: 7. Atributos: dia, horario, sala (todos do tipo string). 8. Alocacao(string dia, string horario, string sala): Método construtor para a inicialização dos atributos. 9. void imprimir_dados(): faz a impressão dos atributos no seguinte formato: "dia horario sala", com uma quebra de linha ao final. • Disciplina: 10. Atributos: codigo e nome (ambos do tipo string), e alocacao (que guarda uma coleção de elementos do tipo Alocacao, você deve escolher a estrutura que julgar mais adequada para usar). 11. Disciplina(string codigo, string nome): método construtor para a inicialização dos atributos. 12. void inserir_alocacao(string dia, string horario, string sala): cria uma nova alocação para a disciplina a partir dos dados informados e insere na coleção. 13. void remover_alocacao(string horario): remove uma alocação da coleção. Para facilitar, vamos assumir que existe apenas uma única alocação em cada horário. 14. void imprimir_alocacao(): imprime todas as alocações para a disciplina. Cada alocação deve ser impressa em uma linha separada e seguindo o formato "codigo nome dia horario sala". Além disso, a alocação deve ser impressa ordenada de acordo com o horário. • QuadroAlocacao: 15. Atributos: crie um atributo para guardar as alocações de todas as disciplinas. Você deve escolher a estrutura que julgar mais adequada para usar (dica: um map é bem útil!). 16. void inserir_alocacao(string codigo, string nome, string dia, string horario, string sala): cria uma nova alocação para uma determinada disciplina de acordo com os parâmetros informados. Todas as disciplinas possuem códigos Classificado como Público diferentes, ou seja, únicos. 17. remover_alocacao_disciplina(string codigo, string horario): remove a alocação em um determinado horário para a disciplina com o código informado. Lembrando que os horários de alocação são únicos em cada disciplina. 18. vector<Disciplina> recuperar_disciplinas_mais_ofertadas(): recupera todas as disciplinas que possuem o maior número de alocações. 19. imprimir_alocacao_completa(): imprime todo o quadro de alocação. As disciplinas devem estar ordenadas pelo código, e as alocações pelo horário da oferta. Você é livre para adicionar nos TADs quaisquer outros atributos ou métodos auxiliares que julgar necessário. Por fim, no arquivo main.cpp você deve implementar toda a parte de entrada/saída que será responsável por manipular os seguintes comandos: • 'a codigo nome dia horario sala': comando para adicionar uma nova alocacao no quadro de acordo com os parâmetros passados. Você pode assumir que as informações *não* possuem espaço, ou seja, são palavras únicas. • 'm': comando para recuperar as disciplinas mais ofertas. Sempre que esse comando for chamado além de recuperar as disciplinas, a alocação de cada uma também deve ser impressa. • 'r codigo horario': remove uma alocação do quadro de acordo com o código da disciplina e horário informados. • 'p': comando para imprimir a alocação completa. • 'b': deve chamar a função 'avaliacao_basica()' implementada no arquivo "avaliacao_basica_alocacao.hpp" (já incluído no main.cpp). Essa função faz uma avaliação do código (não apenas dos resultados). Para ilustrar, abaixo é apresentado um exemplo de entrada/saída: Classificado como Público input= a MAT333 CAL1 Seg-Qua 19:00-20:40 2003 a MAT111 GAAL Ter-Qui 07:30-09:10 3015 a MAT111 GAAL Ter-Qui 14:55-16:35 3015 a DCC123 PDS2 Ter-Qui 14:55-16:35 3040 p m output = DCC123 PDS2 Ter-Qui 14:55-16:35 3040 MAT111 GAAL Ter-Qui 07:30-09:10 3015 MAT111 GAAL Ter-Qui 14:55-16:35 3015 MAT333 CAL1 Seg-Qua 19:00-20:40 2003 MAT111 GAAL Ter-Qui 07:30-09:10 3015 MAT111 GAAL Ter-Qui 14:55-16:35 3015 Nesse exemplo, as quatro primeiras linhas da saída representam a chamada de 'imprimir_alocacao_completa()' (comando 'p') e as duas últimas linhas a disciplina mais ofertada e suas alocações (comando 'm'). Atenção: Lembre-se de fazer a correta modularização utilizando os arquivos .hpp e .cpp. Dica 1: O código da avaliação básica pode ser copiado aqui, caso você queira depurar algo localmente. Dica 2: Você pode usar os códigos dos exercícios anteriores e o da avaliação básica para lhe ajudar a fazer toda a parte de entrada/saída. Referências: https://www.cplusplus.com/doc/tutorial/structures/ https://www.cplusplus.com/reference/stl/ Classificado como Público --------------------------------------------------------------------------------------------------------------------------------- Neste exercício você deverá fazer dois TADs para um jogo de batalha espacial. Utilizando Structs, você deve criar os seguintes TADs: Ponto2D e Nave. Cada TAD deve seguir as especificações abaixo: • Ponto2D tem dois membros: (i) x, do tipo double, e (ii) y, do tipo double. • Essa classe deve possuir um construtor que recebe x e y, ambos do tipo double, e inicializa os membros correspondentes com os valores recebidos. • Também deve possuir um construtor default, que inicializa x e y com zero. A classe deve possuir o seguinte método: 20. double calcular_distancia(Ponto2D ponto): calcula a distância euclidiana para outro ponto no plano. • Nave tem três membros: (i) posicao do tipo Ponto2D, (ii) forca do tipo double, e (iii) energia do tipo double. • Toda instância deve começar com o valor de energia igual a 100, independente do construtor utilizado. Classificado como Público • A classe deve possuir um construtor que recebe posicao e forca e inicializa os membros correspondentes com os valores recebidos. Caso o parâmetro forca não seja informado, ele deve ter um valor padrão 1. • A classe também deve possuir um construtor default, que inicializa posicao com seu construtor padrão, forca com 1, e energia com 100. Você deve implementar os seguintes métodos nesse TAD: 21. void mover(double dx, double dy): atualiza a posição da nave nos eixos x e y somando valores dx e dy, respectivamente. 22. double calcular_distancia(Nave nave): calcula e retorna a distância euclidiana para outra nave qualquer passada como parâmetro. 23. int determinar_indice_nave_mais_proxima(Nave naves[], int n): recebe um array de naves e um parâmetro que informa a quantidade de elementos nesse array. Determina qual a nave mais próxima e retorna o índice que essa nave ocupa no array. Assuma que duas naves não ocupam o mesmo espaço, então se achar uma nave com distância igual a zero, essa nave é você mesmo, e não a nave mais próxima. 24. void atacar(Nave naves[], int n): ataca a nave mais próxima. A nave que sofre o ataque tem o seu valor de energia reduzido por uma quantidade de dano. O valor do dano a ser reduzido é dado pela seguinte equação: , onde distancia é distância para a nave, e forca é a força da nave que faz o ataque. o O máximo de dano (limite) que uma nave pode fazer em outra é 30. o Se após um ataque, a nave atacada tiver energia menor/igual a 50 deve ser impressa a mensagem "Energia baixa!". 25. void imprimir_status(): imprime a situação atual da nave no seguinte formato "x y energia". OBS1: Nesse exercício você não precisa implementar a função main! O objetivo é simular o caso em que você está implementando um TAD que será utilizado por outra pessoa (que conhece apenas o contrato). Dessa forma, a leitura dos dados de entrada e jogadas já estão implementadas, e você deve apenas implementar os TADs (Ponto2D e Nave). Você é livre para implementar quaisquer outros métodos auxiliares nos TADs que julgar necessário. OBS2: Deve-se conseguir criar variáveis do tipo Ponto2D e Nave sem passar nenhum valor para o construtor. Para isso, você pode criar um construtor default ou utilizar valores padrões no construtor Classificado como Público com parâmetros mencionado acima (veja o último link nas referências abaixo). Lembre-se que uma TAD pode ter vários construtores diferentes. Pergunta frequente: Por que não preciso retornar nada na função atacar? Como a função main vai saber que alterei os valores de energia das naves? Resposta: Lembre-se de que quando recebemos arrays como parâmetros de funções (por exemplo, na função atacar), eles são uma referência do array original*, e não uma cópia. Por isso, se em algum momento da função nós alterarmos os valores de um elemento do array, todos os lugares que têm acesso ao array verão a mudança. E é por isso que não precisamos retornar nada na função atacar. Quando a função alterar os valores de energia das naves, a função main verá essa mudança imediatamente, pois também tem acesso ao array sendo alterado. * Essa não é a terminologia mais correta, mas a explicação completa só pode ser entendida depois da aula de ponteiros. Para ilustrar, abaixo é apresentado um exemplo de entrada/saída: input= 3 -1.0 0.0 1.0 0.0 0.0 1.0 1.0 0.0 1.0 s a 0 s output = -1.00 0.00 100.00 0.00 0.00 100.00 1.00 0.00 100.00 -1.00 0.00 100.00 0.00 0.00 70.00 1.00 0.00 100.00 Nesse caso, o comando 's' é usado para imprimir o status atual de todas as naves, e o comando 'a' faz um ataque considerando a nave informada. Atenção: Lembre-se de fazer a correta modularização utilizando os arquivos .hpp e .cpp. Dica: Você pode copiar o arquivo main.cpp aqui para testar localmente e ver como todo o setup inicial é feito (entrada/saída, jogadas, etc). Referências: https://www.cplusplus.com/doc/tutorial/dynamic/ https://www.cplusplus.com/doc/tutorial/structures/ https://en.cppreference.com/w/cpp/language/default_arguments ------------------------------------------------------------------------------------------------------------------------------------- Classificado como Público O objetivo desse VPL é praticar a manipulação de dados em memória, especialmente considerando o uso de ponteiros. Nesse exercício, você não deve incluir nenhuma biblioteca além de iostream. Então você não pode usar vector, por exemplo Para isso, você deve escrever as instruções necessárias para cada um dos itens listados nos comentários do código inicial fornecido. Todas as impressões específicas de uma instrução devem ser feitas na mesma linha, utilizando um espaço em branco (" ") caso mais de um elemento seja impresso. Ao final de cada instrução que realiza alguma impressão você deve fazer uma quebra de linha (endl). ATENÇÃO: quando vários elementos são impressos na mesma linha, o último elemento não deve ser seguido de espaço, apenas da quebra de linha! Referências: https://www.cplusplus.com/doc/tutorial/pointers/ https://www.cplusplus.com/doc/tutorial/dynamic/ int main(){ // 1) Declare uma variável do tipo inteiro e atribua o valor '10' // 2) Declare um ponteiro para inteiros e inicialize com valor nulo // 3) Declare um vetor de inteiros e inicialize com valores de 9 a 0 (nessa ordem) // 4) Imprima o ENDEREÇO da variável declarada em (1) // 5) Imprima o VALOR da variável declarada em (1) // 6) Imprima o ENDEREÇO da variável declarada em (2) Classificado como Público // 7) Imprima o VALOR da variável declarada em (2) // 8) Imprima o ENDEREÇO da variável declarada em (3) // 9) Imprima o ENDEREÇO da primeira posição da variável declarada em (3) // 10) Imprima o VALOR da primeira posição da variável declarada em (3) // 11) Atribua o ENDEREÇO da variável declarada em (1) à variável declarada em (2) // 12) Imprima o VALOR da variável declarada em (2) // 13) Imprima o VALOR guardado no ENDEREÇO apontado por (2) // 14) Imprima o resultado da comparação do ENDEREÇO de (1) e do VALOR de (2) // 15) Coloque o VALOR '5' no ENDEREÇO apontado por (2) // 16) Imprima o VALOR da variável declarada em (1) Classificado como Público // 17) Atribua o ENDEREÇO apontado pela variável (3) à variável declarada em (2) // 18) Imprima o VALOR da variável declarada em (2) // 19) Imprima o VALOR guardado no ENDEREÇO apontado por (2) // 20) Atribua o ENDEREÇO da primeira posição de (3) à variável declarada em (2) // 21) Imprima o VALOR da variável declarada em (2) // 22) Imprima o VALOR guardado no ENDEREÇO apontado por (2) // 23) Multiplique todos os valores do vetor declarado em (3) por '10', porém manipulando apenas a variável (2) // 24) Imprima os elementos de (3) a partir variável do vetor utilizando a notação [] (colchetes) // 25) Imprima os elementos de (3) a partir variável do vetor utilizando a notação ponteiro/deslocamento // 26) Imprima os elementos de (3) utilizando a variável (2) e a notação ponteiro/deslocamento Classificado como Público // 27) Atribua o ENDEREÇO da quinta posição de (3) à variável declarada em (2) // 28) Imprima o VALOR da variável declarada em (2) // 29) Imprima o VALOR guardado no ENDEREÇO apontado por (2) // 30) Imprima o VALOR guardado no: ENDEREÇO do ponteiro (2) decrementado de 4 // 31) Declare um ponteiro para ponteiro e o inicialize com o ENDEREÇO da variável (2) // 32) Imprima o VALOR da variável declarada em (31) // 33) Imprima o ENDEREÇO da variável declarada em (31) // 34) Imprima o VALOR guardado no ENDEREÇO apontado por (31) // 35) Imprima o VALOR guardado no ENDEREÇO do ponteiro apontado por (31) return 0; } Classificado como Público ------------------------------------------------------------------------------------------------------------------------------------- Você possui um programa bem simples, estruturado de acordo com a hierarquia de diretórios abaixo. . programa ├── Makefile ├── build/ │ └── [arquivos.o] ├── include/ │ └── Pessoa.hpp │ └── Funcionario.hpp │ └── Professor.hpp └── src/ │ └── entidades/ │ └── Pessoa.cpp │ └── Funcionario.cpp │ └── Professor.cpp │ └── main.cpp O seu objetivo é unicamente escrever um arquivo Makefile para esse programa, seguindo as seguintes orientações: • Todas as entidades e o arquivo main devem ser compilados individualmente e os arquivos *.o resultantes devem ser salvos no diretório /build/ • Em seguida, os arquivos compilados devem ser linkados em um executável resultante chamado vpl_execution, que deve ser salvo no diretório raiz da aplicação. Você pode copiar o arquivo zipado do projeto aqui para poder fazer o desenvolvimento localmente. ------------------------------------------------------------------------------------------------------------------------------------- Neste VPL, você vai terminar de implementar um programa que lê, da entrada padrão, uma lista de nomes e idades. Ao final, ele imprime somente os nomes (um por linha) ordenados pela idade (da maior para a menor). Você pode assumir que cada nome tem apenas uma palavra. Se dois nomes têm a mesma prioridade, aquele digitado primeiro tem prioridade sobre o outro. Este programa já está implementado no arquivo main.cpp, mostrado a seguir. Resta a você implementar (no arquivo fila_de_prioridade.cpp) a classe FilaDePrioridade definida no arquivo fila_de_prioridade.h. Você não pode, em Classificado como Público hipótese alguma, alterar a interface pública desta classe, sob pena de inviabilizar a compilação do arquivo main.cpp (ou qualquer outro arquivo hipotético que utilize esta classe). Entretanto, você pode alterar os dados privados, além de incluir quaisquer bibliotecas que julgar necessárias ou implementar funções auxiliares no arquivo fila_de_prioridade.cpp. Exemplo de entrada/saída: input = João 26 Marcos 54 Maria 35 Ana 65 Bia 35 output = Ana Marcos Maria Bia João Classificado como Público