AULA 21 - Programação 1 - Engenharia

De MediaWiki do Campus São José
Ir para: navegação, pesquisa

Exercícios Adicionais de Preparação para Avaliação

EXERCÍCIO 1:

Considere que o vetor de estrutura "Jogos" representa um histórico de jogos da mega-sena. Implementar as funções indicadas abaixo. Usar funções de operação com strings da biblioteca.

#include <stdio.h>

struct tipo_local{
   char rua[30];
   int numero;
   char cidade[30];
   char estado[3]; 
};

struct tipo_jogo {
   int ganhadores_sena;
   float premio_sena;
   struct tipo_local local;
   int resultado[6];
} Jogos[5] = 
   {
{ 1, 12500.50,  {"Rua Pedro da Silva", 30, "Florianopolis", "SC"}, {1,2,3,4,5,6}},
{ 4,  1563000.00,  {"Rua Joao da Silva", 30, "Cruz Alta", "RS"},{10,20,33,44,54,6}},    
{ 3,  232000.30,  {"Rua Maria da Silva", 30, "Curitiba", "PR"}, {1,2,3,4,5,43}},
{ 2,  1300000.45,  {"Rua Jose da Silva", 30, "Tijucas", "SC"}, {1,2,3,44,5,6}},
{ 10,  1800000.60, {"Rua Ana da Silva", 30, "Itajai", "SC"}, {1,2,33,4,5,6}},
   };

/* retorna a media dos premios da sena (prêmio por por pessoa) em todos os jogos 
   que ocorreram em um dado estado*/

float media_premio_sena(char *estado)
{
}

/* retorna
   0 se NÃO existe jogo com sena  existente  no vetor passado
   1 se existe jogo com sena
*/
   
int teste_jogo_sena(int *p)
{
}

/* retorna o total de jogos na mesma cidade e estado*/
int total_jogos_mesmo_local(char estado[], char cidade[])
{
}

void main()
{
 /* testar as funções aqui */
 int vetor[6] = {8,12,23,29,56,59};

 if (teste_jogo_sena(vetor)==1) {
    printf("Este jogo consta no histórico!!\n");
 } 
 
}

Solução:

#include <stdio.h>
#include <string.h>

#define TAM_MAX 5
 
struct tipo_local{
   char rua[30];
   int numero;
   char cidade[30];
   char estado[3]; 
};
 
struct tipo_jogo {
   int ganhadores_sena;
   float premio_sena;
   struct tipo_local local;
   int resultado[6];
} Jogos[TAM_MAX] = 
   {
{ 1, 12500.50,  {"Rua Pedro da Silva", 30, "Florianopolis", "SC"}, {1,2,3,4,5,6}},
{ 4,  1563000.00,  {"Rua Joao da Silva", 30, "Cruz Alta", "RS"},{10,20,33,44,54,6}},    
{ 3,  232000.30,  {"Rua Maria da Silva", 30, "Curitiba", "PR"}, {1,2,3,4,5,43}},
{ 2,  1300000.45,  {"Rua Jose da Silva", 30, "Tijucas", "SC"}, {1,2,3,44,5,6}},
{ 10,  1800000.60, {"Rua Ana da Silva", 30, "Tijucas", "SC"}, {1,2,33,4,5,6}},
   };
 
/* retorna a media dos premios da sena (prêmio por por pessoa) em todos os jogos 
   que ocorreram em um dado estado*/
 
float media_premio_sena(char *estado)
{
  int i, cont_acertos=0;
  float soma_ac=0;
  
  for(i=0;i<TAM_MAX;i++){
     if( strcmp(estado, Jogos[i].local.estado) == 0 ) {
         soma_ac= soma_ac + Jogos[i].premio_sena;
         cont_acertos = cont_acertos + Jogos[i].ganhadores_sena;
     }
  }
  printf("Parcial de ganhadores %d em %s - Total de Premiação no Estado  %.2f\n", cont_acertos, estado, soma_ac);

  if (cont_acertos!=0)
     return soma_ac/cont_acertos;
  else
     0;
}
 
/* retorna
   0 se NÃO existe jogo com sena  existente  no vetor passado
   1 se existe jogo com sena
*/
 
int teste_jogo_sena(int *p)
{
  /* supondo que o vetor vem de forma correta (sem repetição de números e todos números válidos (1 a 60) */
  int i,j,k,ocorrencias;
  int existe_jogo =0;

  for (i=0;i<TAM_MAX;i++){ /* loop para acessar cada estrutura do vetor Jogos */
     ocorrencias=0;
     for (j=0;j<6;j++) {  /* loop para acessar cada número do vetor p[j] do vetor p */
         for (k=0;k<6;k++) { /* loop para pesquisar a existência do número p[j] no vetor resultado */ 
            if (Jogos[i].resultado[k]==p[j]) {
                ocorrencias++;
                break; /* encerrar a busca do número p[j] no vetor Jogos.resultado - o número foi encontrado*/
            }
         }
     }
     if (ocorrencias==6)
         break; /* não precisa continuar - encontramos uma ocorrência do vetor p em Jogos - note que o código poderia ser otimizado ainda mais*/ 
  }
  if (ocorrencias==6)
     return 1;
  else
     return 0;
}
 
/* retorna o total de jogos na mesma cidade e estado */
int total_jogos_mesmo_local(char estado[], char cidade[])
{
  int i, contador_jogos=0;

  for (i=0;i<TAM_MAX;i++){ /* loop para acessar cada estrutura do vetor Jogos */
     if (strcmp(estado, Jogos[i].local.estado) ==0 && strcmp(cidade, Jogos[i].local.cidade)==0) {
         contador_jogos++;
     }
  }
  return contador_jogos;
}
 
void main()
{
 /* testar as funções aqui */
 int vetor1[6] = {8,12,23,29,56,59};
 int vetor2[6] = {1,2,33,4,5,6};

 if (teste_jogo_sena(vetor1)==1)
    printf("O jogo do vetor 1 consta no histórico!!\n");
 else
    printf("O jogo do vetor 1 não consta do histórico!!\n");

 if (teste_jogo_sena(vetor2)==1)
    printf("O jogo do vetor 2 consta no histórico!!\n");
 else
    printf("O jogo do vetor 2 não consta do histórico!!\n");

 /* teste da função media_premio_sena() */
 printf("Estado %s Média %.2f\n", "SC", media_premio_sena("SC"));
 printf("Estado %s Média %.2f\n", "PR", media_premio_sena("PR")); 

 /* teste da função  total_jogos_mesmo_local */

 printf("Total de Jogos em Tijucas - SC = %d\n",total_jogos_mesmo_local("SC", "Tijucas"));
 
}

EXERCÌCIO 2

Considere o mesmo exercício 2. Faça uma modificação para fornecer o vetor a ser testado com teste_jogo_sena na linha de comando. O vetor a ser repassado para a função deve ser alocado dinamicamente.

mega_sena 1 20 33 4 5 6

Solução

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define TAM_MAX 5
 
struct tipo_local{
   char rua[30];
   int numero;
   char cidade[30];
   char estado[3]; 
};
 
struct tipo_jogo {
   int ganhadores_sena;
   float premio_sena;
   struct tipo_local local;
   int resultado[6];
} Jogos[TAM_MAX] = 
   {
{ 1, 12500.50,  {"Rua Pedro da Silva", 30, "Florianopolis", "SC"}, {1,2,3,4,5,6}},
{ 4,  1563000.00,  {"Rua Joao da Silva", 30, "Cruz Alta", "RS"},{10,20,33,44,54,6}},    
{ 3,  232000.30,  {"Rua Maria da Silva", 30, "Curitiba", "PR"}, {1,2,3,4,5,43}},
{ 2,  1300000.45,  {"Rua Jose da Silva", 30, "Tijucas", "SC"}, {1,2,3,44,5,6}},
{ 10,  1800000.60, {"Rua Ana da Silva", 30, "Tijucas", "SC"}, {1,2,33,4,5,6}},
   };
 
/* retorna a media dos premios da sena (prêmio por por pessoa) em todos os jogos 
   que ocorreram em um dado estado*/
 
float media_premio_sena(char *estado)
{
  int i, cont_acertos=0;
  float soma_ac=0;
  
  for(i=0;i<TAM_MAX;i++){
     if( strcmp(estado, Jogos[i].local.estado) == 0 ) {
         soma_ac= soma_ac + Jogos[i].premio_sena;
         cont_acertos = cont_acertos + Jogos[i].ganhadores_sena;
     }
  }
  printf("Parcial de ganhadores %d em %s - Total de Premiação no Estado  %.2f\n", cont_acertos, estado, soma_ac);

  if (cont_acertos!=0)
     return soma_ac/cont_acertos;
  else
     0;
}
 
/* retorna
   0 se NÃO existe jogo com sena  existente  no vetor passado
   1 se existe jogo com sena
*/
 
int teste_jogo_sena(int *p)
{
  /* supondo que o vetor vem de forma correta (sem repetição de números e todos números válidos (1 a 60) */
  int i,j,k,ocorrencias;
  int existe_jogo =0;

  for (i=0;i<TAM_MAX;i++){ /* loop para acessar cada estrutura do vetor Jogos */
     ocorrencias=0;
     for (j=0;j<6;j++) {  /* loop para acessar cada número do vetor p[j] do vetor p */
         for (k=0;k<6;k++) { /* loop para pesquisar a existência do número p[j] no vetor resultado */ 
            if (Jogos[i].resultado[k]==p[j]) {
                ocorrencias++;
                break; /* encerrar a busca do número p[j] no vetor Jogos.resultado - o número foi encontrado*/
            }
         }
     }
     if (ocorrencias==6)
         break; /* não precisa continuar - encontramos uma ocorrência do vetor p em Jogos - note que o código poderia ser otimizado ainda mais*/ 
  }
  if (ocorrencias==6)
     return 1;
  else
     return 0;
}
 
/* retorna o total de jogos na mesma cidade e estado */
int total_jogos_mesmo_local(char estado[], char cidade[])
{
  int i, contador_jogos=0;

  for (i=0;i<TAM_MAX;i++){ /* loop para acessar cada estrutura do vetor Jogos */
     if (strcmp(estado, Jogos[i].local.estado) ==0 && strcmp(cidade, Jogos[i].local.cidade)==0) {
         contador_jogos++;
     }
  }
  return contador_jogos;
}
 
void main(int argc, char *argv[])
{
 /* testar as funções aqui */

 int i, *p_vetor;

 /* omitido o teste de argc por simplicidade - admitido que não haverá erro na passagem de parâmetros */
 if ((p_vetor=(int *) malloc (6*sizeof(int)))==NULL)
      exit(1); /* não conseguiu alocar ... */

 for (i=0;i<6;i++) { 
    p_vetor[i] = atoi(argv[i+1]);  /* notar que começa em i+1 pois a string apontada por argv na posição 0 é o nome do arquivo executável */
    printf("valor armazenado %d \n", p_vetor[i]);
 }

 if (teste_jogo_sena(p_vetor)==1)
    printf("O jogo do vetor passado consta no histórico!!\n");
 else
    printf("O jogo do vetor passado NÂO consta do histórico!!\n");

 
}

Listas Ligadas

Por vezes não se conhece o tamanho dos dados que se vai manipular e o uso de uma lista pode ser conveniente para armazená-los. Um sistema de estoque de produtos, por exemplo, poderia ser armazenado na forma de uma lista. O exercício a seguir explora esta estrutura.

Exercício de lista ligada


#include <stdlib.h>
#include <stdio.h>

/*========================*/
/** OPERAÇÔES COM LISTA LIGADA ******/
/*========================*/

/*
   tipos e variáveis globais
*/

struct TProduto{
   int codigo;
  struct TProduto *next;
} *head, *tail;


/*
   adiciona item a cabeça da lista
   retorna 0 se tudo ok e -1 se erro
*/
int add_nodo_head(int codigo)
{

}

/*
   adiciona item ao final  lista
   retorna 0 se tudo ok e -1 se erro
*/
int add_nodo_tail(int codigo)
{
   struct TProduto *p =  malloc (sizeof(struct TProduto));
   if (!p)
        return -1;

   p->codigo = codigo;
   p->next = NULL;

   if (tail==NULL) {
      /* lista vazia */
      tail = head = p;
   }else {
     /*lista não vazia */
       tail->next = p;
       tail = p;
   }
   return 0;
}

/*
   imprimir lista 
*/

void print_list()
{

}
 
main()
{
  int i;

  head = tail = NULL;
  print_list ();
  for (i=0;i<5;i++)
     add_nodo_tail(i);

  print_list ();
}


Exercício 1

No exercício anterior:

  • Implementar a função add_node_head()
  • Implementar a função print_list()
  • Implementar a função delete_node(int codigo)

Exercício 2

Considere um sistema de estoque de uma livraria representado por uma tabela conforme abaixo. Elabore as funções para adicionar, remover e listar um livro na/da tabela. Considere que uma entrada livre possui o ponteiro titulo igual a NULL.

#include <stdio.h>
#define TAM 10
 
 
struct tLivro {
  char *titulo;
  char *autor;
  char *isbn;
  float *preco;
  int  estoque;
};
 
 
typedef struct tLivro TLivro;
 
TLivro Livros[10]; /* iniciar a tabela com NULL */
 
 
 
TLivro *retornar_entrada_livre()
{
}
 
int adicionar_livro()
{
 char aux_isbn[20];
 TLivro *p;

 /* Ler ISBN */
 if(verificar_livro_existe(aux_isbn)==1)
    return 0;
 if((p=retornar_entrada_livre())==NULL)
    return -1;
 
 /* Ler os dados do livro pelo teclado e colocar na estrutura 
    apontada por p*/
 
}
 
/* retorna 0 se removido com sucesso e -1 caso contrário */
int remover_livro(char *isbn)
{
}
 
void imprimir_dados_livro(char *isbn)
{
}
 
main()
{
 /* testar as funções aqui */
}

Exercício 3

Refazer o exercício anterior usando filas.

Exercício 5

Seja a seguinte estrutura:

struct tipo_carro {
   char *marca;
   char *modelo;
   int  potencia;
};

typedef tipo_carro tcarro;


Implpementar as funções abaixo:

/* cria dinamicamente uma estrutura,
   preenche os dados dos campos
   e retorna um ponteiro para a estrutura criada
   Retorna NULL caso não consiga alocar área
 */
tcarro *ler_carro()
{
}

/*
  recebe dois ponteiros para estruturas do tipo carro e
  retorna -1 caso pelo menos um dos ponteiros seja NULL,
  retorna 0 se os modelos forem iguais
  e retorna 1 se os modelos forem diferentes */
int compara_modeloa(tcarro *p1, tcarro *p2)
{
}

/* libera a área da estrutura passada como parâmetro */
void deleta_estrutura(tcarro *p)
{
}

main()
{
  /*testar as funções aqui */
  /* criar dois carros */
  /* comparar o modelo dos dois carros. Testar o retorno */
  /* liberar a área das estruturas */
}