Objetivo
O objetivo deste primeiro exercício prático é revisar tópicos que já foram vistos em disciplinas anteriores e que serão essenciais para os próximos trabalhos e atividades.
Queremos que os alunos se acostumem com o uso de múltiplos arquivos .c e .h em um projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
Seu projeto deve ser capaz de receber as coordenadas de pontos do plano cartesiano, na forma (x, y). Esse conjunto de pontos descreve um caminho a ser seguido linearmente, ou seja, um ponto após outro.
Espera-se que seu programa seja capaz de calcular a distância total percorrida do primeiro ponto até o último, na ordem em que foram inseridos.
Entrada
Seu algoritmo deve receber primeiro um valor do tipo inteiro N, que representa a quantidade de pontos a serem lidos em sequência. Após isso, seu programa deve ler N pares de valores do tipo ponto flutuante na forma : X Y.
Exemplo de entrada:
3
0 0
3 0
6 4
Saída
Como saída, seu programa deve retornar um valor do tipo ponto flutuante, com precisão de duas casas decimais, que representa a distância total percorrida, passando por todos os pontos na ordem em que foram lidos.
Saída da caso acima:
8.00
Observações da implementação
Como é descrito na sessão objetivos desse documento, não queremos apenas que os alunos resolvam o problema, mas que utilizem métodos que serão comuns no decorrer da disciplina.
Devido a esse objetivo, será exigido que vocês desenvolvam seu projeto representando o objeto ponto e o objeto caminho de forma abstrata, isto é, com uma struct para cada. A memória deve ser alocada dinamicamente e ser devidamente liberada ao fim da execução.
Utilizar múltiplos arquivos .c e .h para separar a implementação e a responsabilidade dos métodos de cada objeto (ponto.c e caminho.c). Construir funções para realizar operações repetitivas, ou seja, modularizar adequadamente seu código.
Escrever um arquivo Makefile que será responsável por gerenciar a execução do projeto dentro da plataforma run.codes
Objetivo
O objetivo deste primeiro exercício prático é revisar tópicos que já foram vistos em disciplinas anteriores e que serão essenciais para os próximos trabalhos e atividades.
Queremos que os alunos se acostumem com o uso de múltiplos arquivos .c e .h em um projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
Um site de jogos eletrônicos perdeu o seu catálogo e quer refazê-lo. Você foi contratado para resolver esse problema e deve criar um programa que gerencie os jogos desse site. Isto é, permita o armazenamento e acesso às informações dos produtos e seus dados conforme o pedido do usuário.
Espera-se que seu programa seja capaz atender aos seguintes requisitos:
- Armazenar as informações de um jogo:
nome
, empresa
, ano
.
- Buscar pelos jogos lançados em um determinado
ano
.
- Buscar pelos jogos criados por uma determinada
empresa
.
Entrada
Seu algoritmo deve receber os atributos associados aos jogos, um por linha, na ordem:
- Nome
- Empresa
- Ano
Até ler a letra "F"
(maiúscula). Após a primeira letra "F"
, seu código deve esperar por um próximo caractere:
"A"
correspondendo à opção de busca por ano.
"E"
- correspondendo à opção de busca por empresa produtora
Deve continuar realizando as operações requisitadas até ler novamente a letra "F"
, marcando o fim do algoritmo.
Exemplo de entrada:
Horizon Zero Dawn
Guerrilla Games
2017
Killzone
Guerrilla Games
2004
Crash Bandicoot
Naughty Dog
1999
F
A
2004
A
2000
E
Guerrilla Games
F
Saída
Como saída, seu programa deve retornar a listagem dos nomes dos jogos pesquisados de acordo como o parâmetro determinado. Caso não haja jogos registrados que satisfaçam o critério, seu programa deve responder com "Nada encontrado"
.
Saída da caso acima:
Killzone
Nada encontrado
Horizon Zero Dawn
Killzone
Observações da implementação
Como é descrito na sessão objetivos desse documento, não queremos apenas que os alunos resolvam o problema, mas que utilizem métodos que serão comuns no decorrer da disciplina.
Devido a esse objetivo, será exigido que vocês desenvolvam seu projeto representando o objeto jogo
e o objeto catalogo
de forma abstrata, isto é, com uma struct
para cada. A memória deve ser alocada dinamicamente e ser devidamente liberada ao fim da execução.
Utilizar múltiplos arquivos .c
e .h
para separar a implementação e a responsabilidade dos métodos de cada objeto (jogo.c
e catalogo.c
). Construir funções para realizar operações repetitivas, ou seja, modularizar adequadamente seu código.
Escrever um arquivo Makefile que será responsável por gerenciar a execução do projeto dentro da plataforma run.codes.
Observações da avaliação
A avaliação do seu programa será feita além do resultado da plataforma run.codes. Portanto, ter um bom resultado com os casos de teste, não será suficiente para garantir a nota máxima e nem a aprovação do exercício.
Caso seu projeto não satisfaça os pontos exigidos nos objetivos explicitados nas observações de implementação, sua nota poderá ser reduzida ou ser desconsiderada.
Cópias de código entre alunos, acusadas pela plataforma, resultarão imediatamente em zero aos dois ou mais alunos envolvidos.
Em construção...
Trata-se de um breve relatório acerca da complexidade de alguns algoritmos. Há contagem de operações e do tempo de execução
Objetivo
O objetivo deste exercício prático é estimular os estudantes a se familiarizarem com o comportamento e a lógica associados à estrutura de dados pilha.
Queremos que os alunos se habituem com a implementação desssa estrutura e consigam entender as funções básicas, que garantem a execução adequada desse TAD, em diferentes contextos.
Para acostumar os alunos com conceitos de modularização e boas práticas de escrita de código, será exigido o uso de múltiplos arquivos .c
e .h
no projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
Sendo alunos da USP, somos fãs de jogos de cartas como truco, pôquer ...
Dentre esses jogos temos o BlackJack, famigerado 21. A dinâmica mais básica para o jogo consiste no apostador escolher cartas da pilha do baralho e somar seus valores até atingir a conta de 21, e nesse caso ganhar, ou ultrapassar e perder.
Espera-se que seu programa seja capaz atender aos seguintes requisitos:
- Ler um conjunto de 52 pares de valores (naipe, símbolo), representando as cartas, previamente embaralhadas da sua pilha.
- Retirar cartas do topo da pilha e fazer o cálculo da soma.
- Indicar se o apostador teve sorte e ganhou, ou estava em um mau dia e perdeu.
Entrada
Seu algoritmo deve receber as 52 cartas do baralho no formato: "Naipe Símbolo".
Naipes = {"Espadas", "Paus", "Ouros", "Copas"}.
Símbolos = {'1', '2', ... , 10, 'V', 'D', 'R' }.
Exemplo de entrada:
Ouros 1
Ouros 7
Espadas 5
Espadas 9
Paus 9
Paus V
Copas V
Ouros 10
Copas 3
Espadas 3
Paus 6
Ouros 9
Paus D
Copas 9
Paus 10
Espadas 6
Copas R
Espadas 2
Ouros V
Paus 8
Espadas 4
Paus 7
Ouros 2
Ouros D
Copas 2
Copas 5
Copas 6
Ouros 8
Copas 10
Ouros R
Espadas 10
Paus 4
Copas 1
Espadas D
Paus R
Ouros 5
Copas D
Espadas 7
Paus 1
Espadas R
Ouros 3
Ouros 4
Copas 4
Copas 8
Espadas 8
Ouros 6
Paus 5
Paus 2
Espadas 1
Espadas V
Copas 7
Paus 3
Saída
Como saída, seu programa deve indicar o resultado do jogo realizado.
Saída do caso acima:
Ganhou ;)
Caso o jogador perca:
Perdeu :(
Soma :: valor
Observações da implementação
Como é descrito na sessão objetivos desse documento, não queremos apenas que os alunos resolvam o problema, mas que utilizem métodos que serão comuns no decorrer da disciplina.
Devido a esse objetivo, será exigido que vocês desenvolvam seu projeto representando o objeto carta
como struct
e com a implementação do TAD pilha para construir o baralho de forma abstrata. A memória deve ser alocada dinamicamente e ser devidamente liberada ao fim da execução.
Utilizar múltiplos arquivos .c
e .h
para separar a implementação e a responsabilidade dos métodos de cada objeto. Construir funções para realizar operações repetitivas, ou seja, modularizar adequadamente seu código.
Escrever um arquivo Makefile que será responsável por gerenciar a execução do projeto dentro da plataforma run.codes
Observações da avaliação
A avaliação do seu programa será feita além do resultado da plataforma run.codes. Portanto, ter um bom resultado com os casos de teste, não será suficiente para garantir a nota máxima e nem a aprovação do exercício.
Caso seu projeto não satisfaça os pontos exigidos nos objetivos explicitados nas observações de implementação, sua nota poderá ser reduzida ou ser desconsiderada.
Cópias de código entre alunos, acusadas pela plataforma, resultarão imediatamente em zero aos dois ou mais alunos envolvidos.
Objetivo
O objetivo deste exercício prático é estimular os estudantes a se familiarizarem com o comportamento e a lógica associados à estrutura de dados lista encadeada.
Queremos que os alunos se habituem com a implementação dessa estrutura e consigam entender as funções básicas, que garantem a execução adequada desse TAD, em diferentes contextos.
Para acostumar os alunos com conceitos de modularização e boas práticas de escrita de código, será exigido o uso de múltiplos arquivos .c
e .h
no projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
Em outras disciplinas aprendemos que, comumente, valores inteiros - int - são armazenados com 4 bytes de memória, e valores decimais - double - são armazenados com 8 bytes.
Devido a essa estruturação, existe um limite físico sobre o valor que podemos registrar com essas variáveis.
- 4294967295 para um inteiro sem sinal atribuído UINT_MAX;
- 3.402823e+38 para o tipo ponto flutuante FLT_MAX;
Será que esse limite é suficiente para representar todos os fenômenos da realidade?
Existem diversos contextos, da estatísca à cosmologia, que precisam conseguir lidar com números de ordem de magnitude muito superior aos limites apresentados acima.
- O maior número primo calculado até então possuí 24.862.048 dígitos;
- O modelo do Big Bang, por exemplo, sugere que o universo tem 13,8 bilhões de anos - 4.355e+17 segundos;
- O universo observável está a 93 bilhões de anos luz, aproximadamente 8,7984793395e+23 km.
Existe uma maneira de representar esses números gigantescos por meio de uma lista encadeada. Pode-se dividir os digitos dos algarismos entre os nós da lista, caso queiramos representar os 93 bilhões de anos poderíamos fazer:
NULL <-- (930) <-- (0000) <-- (0000)
O objetivo deste exercício é desenvolver um projeto que seja capaz de realizar operações aritméticas e lógicas sobre esses números.
Entrada
Seu algoritmo deve receber como entrada um número n, que representa a quantidade de operações que serão requisitadas. Após isso ele receberá um sequência de n comandos para serem executados dentre os possíveis {soma, maior, menor, igual} acompanhados de dois números inteiros sobre os quais serão realizadas as operações
Exemplo de entrada:
12
soma 9 3
soma 225 225
soma 11123456789 11987654321
soma 101498473623545 10234586723
soma 1123456 1123459
maior -10 1
menor 012143 110
maior 1123456 -112345664
igual 123456789745 123456789745
soma 050 050
soma 2500 113567
igual 09870 098700
Saída
Como saída, seu programa deve indicar o resultado das operações.
Saída do caso acima:
Resultado :: 12
Resultado :: 450
Resultado :: 23111111110
Resultado :: 101508708210268
Resultado :: 2246915
Resultado :: False
Resultado :: False
Resultado :: True
Resultado :: True
Resultado :: 100
Resultado :: 116067
Resultado :: False
Observações da implementação
Como é descrito na sessão objetivos desse documento, não queremos apenas que os alunos resolvam o problema, mas que utilizem métodos que serão comuns no decorrer da disciplina.
Devido a esse objetivo, será exigido que vocês desenvolvam seu projeto representando o objeto big_number
como struct
e com a implementação do TAD lista para construir o baralho de forma abstrata. A memória deve ser alocada dinamicamente e ser devidamente liberada ao fim da execução. Utilizem a estrutura lista encadeada dinâmica com ligação simples.
Para cada nó da lista, representar o valor de dentro com o tipo int. Utilizar múltiplos arquivos .c
e .h
para separar a implementação e a responsabilidade dos métodos de cada objeto. Construir funções para realizar operações repetitivas, ou seja, modularizar adequadamente seu código.
Escrever um arquivo Makefile que será responsável por gerenciar a execução do projeto dentro da plataforma run.codes
Observações da avaliação
A avaliação do seu programa será feita além do resultado da plataforma run.codes. Portanto, ter um bom resultado com os casos de teste, não será suficiente para garantir a nota máxima e nem a aprovação do exercício.
Caso seu projeto não satisfaça os pontos exigidos nos objetivos explicitados nas observações de implementação, sua nota poderá ser reduzida ou ser desconsiderada.
Cópias de código entre alunos, acusadas pela plataforma, resultarão imediatamente em zero aos dois ou mais alunos envolvidos.
Objetivo
O objetivo deste exercício prático é estimular os estudantes a se familiarizarem com o comportamento e a lógica associados à estrutura de dados árvore de busca binária.
Queremos que os alunos se habituem com a implementação desssa estrutura e consigam entender as funções básicas, que garantem a execução adequada desse TAD, em diferentes contextos.
Para acostumar os alunos com conceitos de modularização e boas práticas de escrita de código, será exigido o uso de múltiplos arquivos .c
e .h
no projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
Continuando o desenvolvimento do seu projeto de sistema bancário, agora sua tarefa é lidar com a gestão de registros de clientes (inserção, remoção e busca). Lembre-se sempre do ponto principal, para garantir a satisfação de seus clientes o banco não pode deixar as pessoas zangadas esperando na hora de realizarem suas operações.
Entrada
Seu algoritmo deve receber como entrada um número n, que representa a quantidade de clientes cadastrados no nosso banco. Após isso ele receberá um sequência de n registros, representando os CPFs, Nomes, Idades e Saldos dos clientes.
O primeiro indivíduo deve ser considerado como a raiz da sua árvore, os demais cadastros serão inseridos na árvore por uma regra que no futuro facilitará a busca por pessoas:
Caso o valor numérico do CPF do novo registro de cliente seja maior que o valor do cpf da raiz, ele deve ser inserido na sua sub-árvore direita, caso contrário, sa sua sub-árvore esquerda e assim sucessivamente até encontrar a posição adequada.
Lembre que um mesmo cpf não pode estar associado a mais e uma conta dentro do banco.
Após os n valores, seu programa deve receber um char c representando uma operação que deverá ser realizada ['I'
: Inserção, 'R'
: Remoção, 'B'
: Busca]. Receberá então um cpf como parâmetro para todas as operações. Para a inserção de um novo registro, serão passadas as informações da pessoa como foi feito anteriormente na entrada.
Exemplo de entrada:
118.469.561-02,Maria Cecília Gonçalves,50,3318.74
498.228.938-76,Júlia Lorena Isadora Ribeiro,68,-20278.86
250.627.718-89,Gabriel Maite Helena Martins,41,15079.44
904.621.899-61,Lívia Isadora Santos,47,9113.10
025.801.967-06,Samuel Marques,23,-3041.86
539.696.899-02,Joaquim Samuel Sophia Jesus,0,6868.53
782.819.678-46,Gabriel Jesus,47,12237.87
370.986.568-95,Maria Júlia Moreira,60,-14561.91
550.067.540-01,Arthur Heloísa Lorena Almeida,19,-8101.50
992.090.680-84,Isaac Anthony Fernandes,50,11898.13
B
904.621.899-61
Saída
Como saída, seu programa deve apresentar os dados da conta.
Saída da caso acima:
Conta :: Lívia Isadora Santos
CPF :: 904.621.899-61
Idade :: 47
Saldo atual :: R$ 9113.10
Caso o cpf em questão não esteja mais na base de dados, deve imprimir a mensagem:
Pessoa nao encontrada.
Para os casos de Inserção, e remoção deverá novamente imprimir a árvore na lógica de preorder.
Observações da implementação
Como é descrito na sessão objetivos desse documento, não queremos apenas que os alunos resolvam o problema, mas que utilizem métodos que serão comuns no decorrer da disciplina.
Devido a esse objetivo, será exigido que vocês desenvolvam seu projeto representando ambas as entidades citadas na descrição como TADs completos e fechados sobre si mesmos, ou seja, com funções auxiliares que permitam o acesso e a manipulação de seus atributos em diferentes contextos (arquivos .c separados). Os dados devem ser armazenados como um TAD cliente e dentro de uma Árvore Binária de Busca implementada com nós de ponteiros duplos.
Para remoção, substitua o nó excluído, pelo menor entre seus maiores filhos, isto é, o nó de menor valor da sua sub-árvore direita.
A memória deve ser alocada dinamicamente e ser devidamente liberada ao fim da execução.
Utilizar múltiplos arquivos .c
e .h
para separar a implementação e a responsabilidade dos métodos de cada objeto. Construir funções para realizar operações repetitivas, ou seja, modularizar adequadamente seu código.
Escrever um arquivo Makefile que será responsável por gerenciar a execução do projeto dentro da plataforma run.codes
Observações da avaliação
A avaliação do seu programa será feita além do resultado da plataforma run.codes. Portanto, ter um bom resultado com os casos de teste, não será suficiente para garantir a nota máxima e nem a aprovação do exercício.
Caso seu projeto não satisfaça os pontos exigidos nos objetivos explicitados nas observações de implementação, sua nota poderá ser reduzida ou ser desconsiderada.
Cópias de código entre alunos, acusadas pela plataforma, resultarão imediatamente em zero aos dois ou mais alunos envolvidos.
Em construção...
Atividade extra sobre lógica de programação. Foram propostos 4 exercícios da plataforma HackerRank a fim de revisar e reforçar alguns tópicos de lógica e implementação em C.
Objetivo
O objetivo deste exercício prático é estimular os estudantes a se familiarizarem com o comportamento e a lógica associados à estrutura de dados árvore AVL.
Queremos que os alunos se habituem com a implementação desssa estrutura e consigam entender as funções básicas, que garantem a execução adequada desse TAD, em diferentes contextos.
Para acostumar os alunos com conceitos de modularização e boas práticas de escrita de código, será exigido o uso de múltiplos arquivos .c
e .h
no projeto, bem como a construção de um arquivo Makefile, responsável por gerenciar a execução do programa.
Descrição
O Programa deve rodar até receber um "F"
de entrada. Quando receber o "F"
o programa deve imprimir a árvore no formato que foi pedido e desalocar TODA a memória alocada dinamicamente.
O arquivo de entrada CSV.csv terá o seguinte formato: Nome do jogo (coluna 1), ano de lançamento (coluna 2) e produtora(coluna 3); sendo cada linha um novo jogo. TODOS os jogos do CSV devem ser adicionados a arvore AVL, antes de qualquer possível remoção.
Cada nó da arvore é uma estrutura de dados jogo
que foi definida no exercício de catálogo de jogos.Ou seja, uma estrutura com Nome, Ano, Produtora. A arvore sempre deverá ser balanceada pela data de lançamento dos jogos. Todos os nós a esquerda do nó pai terão uma data de lançamento menor que a do nó pai, enquanto todos os nó a direita uma data de lançamento maior. IMPORTANTE: caso as datas de lançamento sejam iguais o programa deve ordenar por ordem alfabética (pelo nome do jogo) crescente.
Resumindo, o programa deve sempre comparar a data de lançamento do jogo caso elas sejam iguais deve comparar o nome do jogo. Sempre colocando o menor para a esquerda e o maior para a direita.
Entrada
A primeira entrada (um inteiro) define a forma como vamos imprimir a árvore AVL no final da execução:
- Pré-ordem
- Em ordem
- Pós-ordem
Para simplificar a impressão, o programa deve imprimir apenas o Nome completo do jogo. As próximas entradas serão referentes a remoção de algum nó da arvore após TODOS os jogos serem alocados e balanceados. A remoção deve seguir a regra de substituir o nó removido, quando necessário, pelo maior nó da subárvore da esquerda.
O Usuário pode requerer a remoção de algum jogo, para isso ele irá inserir um número referente ao ano de lançamento do jogo. TODOS os jogos com essa data de lançamento devem ser excluídos. O programa deve excluir um jogo por vez e fazer o rebalanceamento Da arvore. Caso não haja nenhum jogo com essa ano o programa não fara nada.
O usuário pode pedir para remover quantos jogos quiser. O programa só deve ser finalizado quando receber o "F"
. O programa só irá imprimir a arvore após o “F” (no formato especificado no início, pré-ordem [1], em ordem [2] ou pós-ordem [3]).
Observações da avaliação
A avaliação do seu programa será feita além do resultado da plataforma run.codes. Portanto, ter um bom resultado com os casos de teste, não será suficiente para garantir a nota máxima e nem a aprovação do exercício.
Caso seu projeto não satisfaça os pontos exigidos nos objetivos explicitados nas observações de implementação, sua nota poderá ser reduzida ou ser desconsiderada.
Cópias de código entre alunos, acusadas pela plataforma, resultarão imediatamente em zero aos dois ou mais alunos envolvidos.