fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define MAX 10
  6. #define MAX_PONTOS 10
  7.  
  8. typedef struct JOGADOR JOGADOR;
  9. typedef struct CAMPO CAMPO;
  10.  
  11. struct JOGADOR {
  12.     int num_jogador;
  13.     int pontos;
  14. };
  15.  
  16. struct CAMPO {
  17.     struct JOGADOR jogadores[MAX];
  18. };
  19.  
  20. /*novo jogador*/
  21. struct JOGADOR novo_jogador;
  22. /*apontador para  novo jogador*/
  23. struct JOGADOR *ptr_jogador;
  24. /*Array campo jogo e campo prolonagamento*/
  25. struct CAMPO campo[2];
  26. /*apontador para campo jogo e campo prolonagamento */
  27. struct CAMPO *ptr_campo;
  28.  
  29. /*Prototipos das funções*/
  30. void criar_jogador_no_campo0(void);
  31. void definir_vencedor_ou_empate_jogo(void);
  32. void adicionar_jogadores_empatados_campo1(int, int);
  33. void mostrar_jogadores_no_prolongamento(void);
  34.  
  35.  
  36. void criar_jogador_no_campo0(void) {
  37.  
  38.     int i, j;
  39.     //aponta para campo de jogo
  40.     ptr_campo = &campo[0];
  41.  
  42.     for (i = 0, j = 0; i < MAX; i++) {
  43.         campo[0] = *(ptr_campo);
  44.         novo_jogador.num_jogador++;
  45.         novo_jogador.pontos = 1 + rand() % MAX_PONTOS;
  46.         ptr_jogador = &novo_jogador;
  47.         campo[0].jogadores[i] = *ptr_jogador;
  48.         *(ptr_campo) = campo[0];
  49.         printf(">> Criando jogador %d com pontos %d no campo[0]...\n",
  50.                 ptr_campo->jogadores[i].num_jogador,
  51.                 ptr_campo->jogadores[i].pontos);
  52.         j++;
  53.     }
  54.  
  55.     if (j == MAX) {
  56.         definir_vencedor_ou_empate_jogo();
  57.     }
  58. }
  59.  
  60.  
  61. /*Função que determina o vencedor ou prologamento em caso de empate*/
  62. void definir_vencedor_ou_empate_jogo(void) {
  63.  
  64.     int j, k, m, t;
  65.     int contador = 0;
  66.     int max = 0;
  67.  
  68.     puts("\n Determinar o jogador vencedor ou em caso empate, irá ao prolongamento...\n");
  69.     //para todos os jogadores
  70.     for (j = 0; j < MAX; j++) {
  71.         //se o jogador listado tiver mais pontos marcados do que max
  72.         if (ptr_campo->jogadores[j].pontos > max) {
  73.             //max = pontos do jogador
  74.             max = ptr_campo->jogadores[j].pontos;
  75.             //contador será igual a um
  76.             contador = 1;
  77.             //se tiver os mesmo pontos que max
  78.         } else if (ptr_campo->jogadores[j].pontos == max) {
  79.             //incrementa o contador
  80.             contador++;
  81.         }
  82.     }//se contador for igual a um
  83.     if (contador == 1) {
  84.         //para todos os jogadores
  85.         for (k = 0; k < MAX; k++) {
  86.             //se o jogador listado tiver mais do que max pontos
  87.             if (ptr_campo->jogadores[k].pontos == max) {
  88.                 //o jogador iterado é o vencedor
  89.                 printf(">> Jogador %d é o VENCEDOR marcando %d golo(s)...\n\n",
  90.                         ptr_campo->jogadores[k].num_jogador,
  91.                         ptr_campo->jogadores[k].pontos);
  92.             }
  93.         }//caso contrário (contador diferente de um)
  94.     } else {
  95.         //iterar todos os jogadores
  96.         for (m = 0; m < MAX; m++) {
  97.             //se os pontos do jogador listado for igual a max
  98.             if (ptr_campo->jogadores[m].pontos == max) {
  99.                 //o jogador iterado faz parte do prolongamento
  100.                 printf(">> Jogador %d marcou %d golo(s) e vai para PROLONGAMENTO...\n", 
  101.                         ptr_campo->jogadores[m].num_jogador,
  102.                         ptr_campo->jogadores[m].pontos);
  103.             }
  104.         }
  105.         puts("\n\t\t--- Lista de Jogadores para Prolongamento em situação de empate ---");
  106.         //iterar todos os jogadores
  107.         for (t = 0; t < MAX; t++) {
  108.             //se os pontos do jogador listado for igual a max
  109.             if (ptr_campo->jogadores[t].pontos == max) {
  110.                 //o jogador iterado faz parte da lista de jogadores para prolongamento
  111.                 adicionar_jogadores_empatados_campo1
  112.                        (ptr_campo->jogadores[t].num_jogador, contador);
  113.             }
  114.         }
  115.     }
  116. }
  117.  
  118.  
  119.  
  120. void adicionar_jogadores_empatados_campo1(int num_jogador, int quant_jogador) {
  121.  
  122.     int j = 0;
  123.     //aponta para campo de prolongamento
  124.     //*(ptr_campo + 1) = &campo[1]; //-> dá erro
  125.  
  126.     for (int i = 0; i < MAX; i++) {
  127.         if (num_jogador == ptr_campo->jogadores[i].num_jogador) {
  128.             campo[1] = *(ptr_campo + i);
  129.             campo[1].jogadores[i / 2] = ptr_campo->jogadores[i];
  130.             *(ptr_campo + i) = campo[1];
  131.             printf("\t\t\t Jogador %d: %d golo(s)\n",
  132.                     (ptr_campo+i)->jogadores[i].num_jogador,
  133.                     (ptr_campo+i)->jogadores[i].pontos);
  134.             j++;
  135.         }
  136.     }
  137.  
  138.     if (j == quant_jogador) {
  139.         //mostra os jogadores no prolongamento
  140.         mostrar_jogadores_no_prolongamento();
  141.  
  142.  
  143.     }
  144. }
  145.  
  146. void mostrar_jogadores_no_prolongamento(void) {
  147.     printf("\n\n--- Ponteiro para Campo 1 ---");
  148.     for (int i = 0; i < MAX / 2; i++) {
  149.         //mostra os valores do novo ponteiro
  150.         printf("\nAponta para ->Jogador %d com pontos %d no campo[1]",
  151.                 (ptr_campo + i)->jogadores[i].num_jogador,
  152.                 (ptr_campo + i)->jogadores[i].pontos);
  153.     }
  154. }
  155.  
  156. int main(void) {
  157.  
  158.     criar_jogador_no_campo0();
  159.  
  160.     return 0;
  161. }
  162.  
Success #stdin #stdout 0s 2156KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
>> Criando jogador 1 com pontos 4 no campo[0]...
>> Criando jogador 2 com pontos 7 no campo[0]...
>> Criando jogador 3 com pontos 8 no campo[0]...
>> Criando jogador 4 com pontos 6 no campo[0]...
>> Criando jogador 5 com pontos 4 no campo[0]...
>> Criando jogador 6 com pontos 6 no campo[0]...
>> Criando jogador 7 com pontos 7 no campo[0]...
>> Criando jogador 8 com pontos 3 no campo[0]...
>> Criando jogador 9 com pontos 10 no campo[0]...
>> Criando jogador 10 com pontos 2 no campo[0]...

 Determinar o jogador vencedor ou em caso empate, irá ao prolongamento...

>> Jogador 9 é o VENCEDOR marcando 10 golo(s)...
https://ideone.com/Nv0Kru
language:
C99 (gcc 8.3)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!