Programa Gerador de Tabelas Esportivas: mudanças entre as edições

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(7 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 22: Linha 22:


===Download do programa===
===Download do programa===
O software foi desenvolvido em '''linguagem C''' para máquinas '''Linux'''. O código fonte do programa (abaixo) deve ser salvo com o nome '''tabelas.c''' e deve ser compilado com o comando:
O software foi desenvolvido em '''linguagem C'''.
  gcc -o tabelas tabelas.c
 
<!--
O '''código fonte''' do programa está organizado em três arquivos, disponibilizados abaixo:
;Versão para Windows: Arquivo [[Mídia:tabelas.exe|tabelas.exe]]
GeradorTebelas.c
-->
Copa.c
MataMata.c'''
Para gerar o '''programa executável''', os arquivos fonte devem ser compilados com o comando:
  gcc GeradorTabelas.c Copa.c MataMata.c -o GeradorTabelas


<syntaxhighlight lang="c">
<syntaxhighlight lang="c">
//Arquivo GeradorTabelas.c
//Programa Gerador de Tabelas Esportivas
//Programa Gerador de Tabelas Esportivas
//Desenvolvido por Evandro Cantú
//Desenvolvido por Evandro Cantú
//Instituto Federal do Paraná
//Instituto Federal do Paraná
//Foz do Iguaçu, outubro 2016
//Foz do Iguaçu, outubro 2016
//Contato: evandro.cantu@ifpr.edu.br
//Atualização: jun/2017
//Atualização: jun/2017


Linha 39: Linha 45:
#include <string.h>
#include <string.h>
#include <time.h>
#include <time.h>
char tabela[] = "Tabelas.txt";
FILE *arq;
//matamata: Função para determinar as partidas de uma eliminatória simples.
//          Recebe como parâmetro o número de jogadores e
//          o vetor com os jogadores
void matamata (int n, char jogadores[32][20]);
//Protótipo: Arquivo fonte MataMata.c
//copa: Função organizar a competição em grupos.
//      Recebe como parâmetros o número de grupos (g), número de
//      jogadores (n), número de classificados por grupo (nc) e
//      o vetor com os jogadores.
void copa (int r, int g, int n, int nc, char jogadores[80][20]);
//Protótipo: Arquivo fonte Copa.c


//rodizio: Função para determinar as partidas de um rodízio simples,
//rodizio: Função para determinar as partidas de um rodízio simples,
Linha 44: Linha 66:
//        Recebe como parâmetro o número de jogadores e
//        Recebe como parâmetro o número de jogadores e
//        o vetor com os jogadores
//        o vetor com os jogadores
void rodizio (int n, char jogadores[32][20])
void rodizio (int n, char jogadores[80][20])
{
  int c = 0;
  int i, j, k;
  char ultimoJogador[20] = {""};
  //SE número impar de jogadores ENTÃO adiciona um jogador vazio
  if (n % 2 == 1) {
    strcpy(jogadores[n], ultimoJogador);
    n = n + 1;
  }
  arq = fopen(tabela, "a");
  fprintf(arq, "\nPARTIDAS \nDO RODÍZIO: \n\n");
  for (k=0;k<n-1;k++)
  {
    fprintf(arq, "%sRodada: %2d\n", "",k+1);
    for (i=0;i<n/2;i++)
      if ((strcmp(jogadores[i], "") != 0) && (strcmp(jogadores[n-1-i], "") != 0))
        fprintf(arq, "%2d: %20s _ x _ %-20s\n", ++c, jogadores[i], jogadores[n-1-i]);
    //Rotaciona vetor de jogadores, menos primeira posição
    strcpy(ultimoJogador, jogadores[n-1]);
    for (j=n-1;j>0;j--)
      strcpy(jogadores[j], jogadores[j-1]);
    strcpy(jogadores[1], ultimoJogador);
  }
  fclose(arq);
}
//Ref: https://pt.wikipedia.org/wiki/Competições_de_todos_contra_todos
 
/* FUNÇÃO ANTERIOR SEM ORGANIZAR RODADAS
void rodizio (int n, char jogadores[80][20])
{
{
  char tabela[] = "Tabela.txt";
  FILE *arq; 
   int c = 0;
   int c = 0;
   int i, j;
   int i, j;
Linha 57: Linha 106:
   fclose(arq);
   fclose(arq);
}
}
 
*/
//matamata: Função para determinar as partidas de uma eliminatória simples.
//          Recebe como parâmetro o número de jogadores e
//          o vetor com os jogadores
void matamata (int n, char jogadores[32][20]);


//embaralhar: Função para embaralhar um vetor.
//embaralhar: Função para embaralhar um vetor.
//            Recebe como parâmetro o vetor com os jogadores
//            Recebe como parâmetro o vetor com os jogadores
//            a serem embaralhados e o tamanho do vetor.
//            a serem embaralhados e o tamanho do vetor.
void embaralhar(char vetor[32][20], int tamVetor)
void embaralhar(char vetor[80][20], int tamVetor)
{
{
   int i;
   int i;
Linha 79: Linha 124:
   }
   }
}
}
int main(int argc, char *argv[])
//Arquivo com jogadores pode ser fornecido como parâmetro
{
  char jogador[20];
  char jogadores[80][20];
  int n = 0;  //número de jogadores cadastrados
  int g = 0;  //número de grupos
  int nc = 2;  //Número de classificados por GRUPO
  int r;      //Número de jogadores incluídos pelo RANKING nos GRUPOS
  int i;
  char resposta;
  int tam;
  char arquivo[20];
  if (argc == 1)
  {
    printf("\nCADASTRO DE JOGADORES\n");
    printf("\nEntre com NOME DO ARQUIVO com os jogadores:\n");
    fgets(arquivo, sizeof(arquivo), stdin);
    tam = strlen(arquivo);
    if (arquivo[tam - 1] == '\n')
      arquivo[tam - 1] = '\0';
  }
  else
  {
    strcpy (arquivo, argv[1]);
  }
  FILE *arq;
  arq = fopen(arquivo, "r");
  if(arq == NULL) {
    printf("\nNao foi possivel abrir o arquivo!\n");
    printf("\nConfira se o nome do arquivo está correto, incluindo a extensão txt.\n");
    return(1);}
  else
    //Monta vetor com os jogadores
    while( (fscanf(arq,"%s\n", jogador))!=EOF )
    {
      strcpy(jogadores[n], jogador);
      n++;
    }
  fclose(arq);
  arq = fopen(tabela, "w");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n      PROGRAMA GERADOR DE TABELAS ESPORTIVAS\n");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n  Evento: _________________________________________\n");
  fprintf(arq, "\n  Local:  _________________________________________\n");
  fprintf(arq, "\n  Data:  _________________________________________\n");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  //Data e hora do sistema
  time_t mytime;
  mytime = time(NULL);
  struct tm tm = *localtime(&mytime);
  fprintf(arq, "\n      Geração das Tabelas: %d/%d/%d - %d:%d\n",
          tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min);
  fprintf(arq, "\n+----------------------------------------------------+\n");
  //Imprime jogadores cadastrados
  fprintf(arq, "\nJOGADORES CADASTRADOS:\n");
  for (i=0; i<n; i++)
  {
    printf("%2d: %-20s\n", i + 1, jogadores[i]);
    fprintf(arq, "%2d: %-20s\n", i + 1, jogadores[i]);
  }
  fclose(arq);
  //Pergunta sobre formato da competição
  do
  {
    printf("\nESCOHA FORMATO DA COMPETIÇÃO: \n");
    if (n >= 4 && n <= 80)
      printf(" (C) Copa: Grupos + Fase Final\n");
    printf(" (R) Rodízio simples\n");
      if (n <= 16 || n == 24 || n == 32)
      printf(" (E) Eliminatória simples\n");
    scanf (" %c",&resposta);
  } while (resposta != 'c' && resposta != 'C' &&
          resposta != 'r' && resposta != 'R' &&
          resposta != 'e' && resposta != 'e');
  if (resposta == 'r' || resposta == 'R')
    //Chama função rodizio
    rodizio (n, jogadores);
  if (resposta ==  'e' || resposta == 'E') {
    //Pergunta sobre formato do sorteio
    do
    {
      printf("\nESCOLHA FORMATO DO SORTEIO: \n");
      printf(" (R) Manter ordem de RANKING\n");
      printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
      scanf (" %c",&resposta);
    } while (resposta != 's' && resposta != 'S' &&
            resposta != 'r' && resposta != 'R');
    if (resposta == 's' || resposta == 'S')
      embaralhar(jogadores, n);
    //Chama função matamata
    matamata(n, jogadores);
    }
  if (resposta ==  'c' || resposta == 'C')
  {
    //Pergunta sobre número de GRUPOS
    do
    {
      printf("\n  Escolha quantos GRUPOS: \n");
      if (n >= 4 && n <= 10) {
        printf("  (2) Dois  GRUPOS (%d ", n / 2);
        if (n % 2 != 0) printf("ou %d ", n / 2 + 1);
        printf("jogadores cada)");
        if (n / 2 == 3 || (n / 2 == 4 && n % 2 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 6 && n <= 15) {
        printf("  (3) Três  GRUPOS (%d ", n / 3);
        if (n % 3 != 0) printf("ou %d ", n / 3 + 1);
        printf("jogadores cada)");
        if (n / 3 == 3 || (n / 3 == 4 && n % 3 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 8 && n <= 20) {
        printf("  (4) Quatro GRUPOS (%d ", n / 4);
        if (n % 4 != 0) printf("ou %d ", n / 4 + 1);
        printf("jogadores cada)");
        if (n / 4 == 3 || (n / 4 == 4 && n % 4 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 10 && n <= 25) {
        printf("  (5) Cinco  GRUPOS (%d ", n / 5);
        if (n % 5 != 0) printf("ou %d ", n / 5 + 1);
        printf("jogadores cada)");
        if (n / 5 == 3 || (n / 5 == 4 && n % 5 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 12 && n <= 30) {
        printf("  (6) Seis  GRUPOS (%d ", n / 6);
        if (n % 6 != 0) printf("ou %d ", n / 6 + 1);
        printf("jogadores cada)");
        if (n / 6 == 3 || (n / 6 == 4 && n % 6 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 14 && n <= 35) {
        printf("  (7) Sete  GRUPOS (%d ", n / 7);
        if (n % 7 != 0) printf("ou %d ", n / 7 + 1);
        printf("jogadores cada)");
        if (n / 7 == 3 || (n / 7 == 4 && n % 7 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 16 && n <= 40) {
        printf("  (8) Oito  GRUPOS (%d ", n / 8);
        if (n % 8 != 0) printf("ou %d ", n / 8 + 1);
        printf("jogadores cada)");
        if (n / 8 == 3 || (n / 8 == 4 && n % 8 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 24 && n <= 60) {
        printf("  (Z) Doze  GRUPOS (%d ", n / 12);
        if (n % 12 != 0) printf("ou %d ", n / 12 + 1);
        printf("jogadores cada)");
        if (n / 12 == 3 || (n / 12 == 4 && n % 12 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 32 && n <= 80) {
        printf("  (S) Dezeseis GRUPOS (%d ", n / 16);
        if (n % 16 != 0) printf("ou %d ", n / 16 + 1);
        printf("jogadores cada)");
        if (n / 16 == 3 || (n / 16 == 4 && n % 16 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      scanf (" %c",&resposta);
    } while (resposta != '2' && resposta != '3' && resposta != '4' &&
            resposta != '5' && resposta != '6' && resposta != '7' &&
            resposta != '8' && resposta != 'z' && resposta != 'Z' &&
            resposta != 's' && resposta != 'S');
    if (resposta == '2' || resposta == '3'|| resposta == '4'||
        resposta == '5' || resposta == '6')
    {
      if (resposta == '2')
        g = 2;
      if (resposta == '3')
        g = 3;
      if (resposta == '4')
        g = 4;
      if (resposta == '5')
        g = 5;
      if (resposta == '6')
        g = 6;
      if ((g == 2 && n >= 6)  || (g == 3 && n >= 9) || (g == 4 && n >= 12) ||
          (g == 5 && n >= 15) || (g == 6 && n >= 18))
        //Pergunta sobre número de classificados por GRUPO
        do
        {
          printf("\n  Escolha número de classificados por GRUPO: \n");
          printf("  (2) Dois\n");
          printf("  (3) Três\n");
          scanf (" %c",&resposta);
        } while (resposta != '2' && resposta != '3');
      if (resposta == '2')
        nc = 2;
      if (resposta == '3')
        nc = 3;
    }
    if (resposta == '7')
      g = 7;
    if (resposta == '8')
      g = 8;
    if (resposta == 'z' || resposta == 'Z')
      g = 12;
    if (resposta == 's' || resposta == 'S')
      g = 16;
    //Pergunta sobre formato do sorteio
    do
    {
      printf("\nESCOLHA O FORMATO DA MONTAGEM DOS GRUPOS: \n");
      printf(" (R) Manter ordem de RANKING para organizar GRUPOS\n");
      printf(" (1) Incluir UM  pelo RANKING e embaralhar demais\n");
      if (n / g >= 2)
        printf(" (2) Incluir DOIS pelo RANKING e embaralhar demais\n");
      if (n / g >= 3)
        printf(" (3) Incluir TRÊS pelo RANKING e embaralhar demais\n");
      printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
      scanf (" %c",&resposta);
    } while (resposta != 's' && resposta != 'S' &&
            resposta != '1' && resposta != '2' && resposta != '3' &&
            resposta != 'r' && resposta != 'R');
    if (resposta == 's' || resposta == 'S')
      r = 0;
    if (resposta == '1')
      r = 1;
    if (resposta == '2')
      r = 2;
    if (resposta == '3')
      r = 3;
    if (resposta == 'r' || resposta == 'R')
      r = 4;
  //Chama função copa
  copa(r, g, n, nc, jogadores);
  }
  arq = fopen(tabela, "a");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n Programa desenvolvido por: Evandro Cantú");
  fprintf(arq, "\n Contato: evandro.cantu@ifpr.edu.br");
  fprintf(arq, "\n Data da compilação: %s\n",__DATE__);
  fclose(arq);
  return(0);
}
</syntaxhighlight>
<syntaxhighlight lang="c">
//Arquivo Copa.c
//Programa Gerador de Tabelas Esportivas
//Função copa utilizada pelo programa principal.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
void matamata (int n, char jogadores[32][20]);
void rodizio (int n, char jogadores[80][20]);
void embaralhar(char vetor[80][20], int tamVetor);


//calExtra: Função auxiliar da função copa, permtindo verificar se
//calExtra: Função auxiliar da função copa, permtindo verificar se
Linha 94: Linha 387:


//copa: Função organizar a competição em grupos.
//copa: Função organizar a competição em grupos.
//      Recebe como parâmetros o número de grupos (g), número de
//      Recebe como parâmetros o número de jogadores a serem incluídos
//      pelo Ranking (r), o número de grupos (g), número de
//      jogadores (n), número de classificados por grupo (nc) e
//      jogadores (n), número de classificados por grupo (nc) e
//      o vetor com os jogadores.  
//      o vetor com os jogadores.  
void copa (int g, int n, int nc, char jogadores[32][20])
void copa (int r, int g, int n, int nc, char jogadores[80][20])
{
{
   char tabela[] = "Tabela.txt";
   char tabela[] = "Tabelas.txt";
   FILE *arq;
   FILE *arq;
   char grupos[8][32][20];
   char grupos[16][80][20];
  char nomeGrupo[16] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'};
   int i, j;
   int i, j;
  int c = 0;
   int div, mod;
   int div, mod;
   div = n / g; //Número mínimo de jogadores por GRUPO
   div = n / g; //Número mínimo de jogadores por GRUPO
   mod = n % g; //Jogador(es) extra para alocar em GRUPO(s)
   mod = n % g; //Jogador(es) extra para alocar em GRUPO(s)
   int ng;     //Número de jogadores além dos cabeças de GRUPO
   int ng = n; //Número de jogadores além incluídos pelo RANKING
   int extra[8];
   int extra[8];
   int offset = 0;
   int offset = 0;
   arq = fopen(tabela, "a");
   arq = fopen(tabela, "a");
   fprintf(arq, "\nCOMPETIÇÃO NO FORMATO COPA: \n");
   fprintf(arq, "\nCOMPETIÇÃO NO FORMATO COPA: \n");
   fprintf(arq, "-> %d GRUPOS\n-> %d Classificados cada GRUPO\n", g, nc);
   fprintf(arq, "-> %2d GRUPOS\n-> %2d Classificados cada GRUPO\n", g, nc);
   fprintf(arq, "\nCabeças de GRUPO e pré alocados pelo RANKING:\n");
   fprintf(arq, "\n+----------------------------------------------------+");
   for (i = 0; i < g; i++)
  fprintf(arq, "\n                TABELAS DE JOGOS: ");
  fprintf(arq, "\n+----------------------------------------------------+");
   fclose(arq);
  //Inclusão de jogadores nos GRUPOS de acordo com RANKING
  if (r >= 1)
  {
    for (i = 0; i < g; i++) //Cabeças de GRUPO
      strcpy(grupos[i][0], jogadores[i]);
    ng = n - g;  //Número total de jogadores restantes
    c = 1;     
  }
  if (r >= 2)
   {
   {
     fprintf(arq, "            Grupo %d", i+1);
     for (i = 0; i < g; i++) //Segundo integrante do GRUPO na ordem inversa
      strcpy(grupos[i][1], jogadores[2 * g - 1 - i]);
    ng = n - 2 * g; //Número total de jogadores restantes
    c = 2;     
   }
   }
   fprintf(arq, "\n");
   if ((r >= 3) && (n / g > 2))
  //Os cabeças de chave são incluídos na primeira posição de cada grupo.
  for (i = 0; i < g; i++) //Cabeça de GRUPO
   {
   {
     strcpy(grupos[i][0], jogadores[i]);
     for (i = 0; i < g; i++) //Terceiro integrante do GRUPO
     fprintf(arq, "%20s", grupos[i][0]);
      strcpy(grupos[i][2], jogadores[2 * g + i]);
     ng = n - 3 * g; //Número total de jogadores restantes
    c = 3;
   }
   }
   fprintf(arq, "\n");
   if ((r == 4) && (n / g > 3))
   //Os próximos do ranking são incluídos na segunda posição de cada grupo,
   {
  //invertendo a ordem de inclusão nos grupos.
    for (i = 0; i < g; i++) //Terceiro integrante do GRUPO
  for (i = 0; i < g; i++) //Segundo integrante do GRUPO
      strcpy(grupos[i][3], jogadores[4 * g - 1 - i]);
  {
     ng = n - 4 * g; //Número total de jogadores restantes
    strcpy(grupos[i][1], jogadores[2 * g - 1 - i]);
    c = 4;
     fprintf(arq, "%20s", grupos[i][1]);
   }
   }
  fprintf(arq, "\n");
  fclose(arq);
  ng = n - 2 * g; //Número total de jogadores além dos cabeças de GRUPO
                  //e dos próximos do RANKING
  //Retira cabeças de GRUPO e próximos do RANKING do vetor dos jogadores,
  //pois já foram incluídos nos respectivos grupos.
   for (i = 0; i < ng; i++)             
   for (i = 0; i < ng; i++)             
     strcpy(jogadores[i], jogadores[i + 2 * g]);  
     strcpy(jogadores[i], jogadores[c * g + i]); //Retira jogadores já incluídos
   embaralhar(jogadores, ng); //Embaralha restantes
   if (r != 4)
    embaralhar(jogadores, ng); //Embaralha restantes
   //Monta GRUPOS, verificado através da função callExtra se
   //Monta GRUPOS, verificado através da função callExtra se
   //há jogadores extra em um grupo, quando a divisão entre
   //há jogadores extra em um grupo, quando a divisão entre
Linha 148: Linha 452:
     extra[j] = calExtra(&mod);
     extra[j] = calExtra(&mod);
     for (i = 0; i < ng/g + extra[j]; i++)
     for (i = 0; i < ng/g + extra[j]; i++)
       //Inclui jogadores nos grupos, além do cabeça de GRUPO
       //Inclui o restante dos jogadores nos GRUPOS
       strcpy(grupos[j][i+2], jogadores[i + offset]);
       strcpy(grupos[j][i+c], jogadores[i + offset]);
     //offset marca no vetor com os jogadores a posição do próximo
     //offset marca no vetor com os jogadores a posição do próximo
     //jogador a ser incluídos no próximo GRUPO.       
     //jogador a ser incluídos no próximo GRUPO.       
     offset = offset + ng/g + extra[j];
     offset = offset + ng/g + extra[j];
     arq = fopen(tabela, "a");
     arq = fopen(tabela, "a");
     fprintf(arq, "\n+----------------------------------------------------+\n");
     fprintf(arq, "\n+------------------------------------------------+");
    fprintf(arq, "\n+-----------------------------------------------+");
     fprintf(arq, "\n| GRUPO %c : Jogadores | Vitórias | Saldo de Sets |", nomeGrupo[j]);
     fprintf(arq, "\n| GRUPO %d: Jogadores | Vitórias | Saldo de Sets |", j + 1);
     fprintf(arq, "\n+---------------------+----------+---------------+\n");
     fprintf(arq, "\n+--------------------+----------+---------------+\n");
     //Imprime os membros de cada GRUPO
     //Imprime os membros de cada GRUPO
     for (i = 0; i < n/g + extra[j]; i++)
     for (i = 0; i < n/g + extra[j]; i++)
       fprintf(arq, "|%19s |          |              |\n", grupos[j][i]);
       fprintf(arq, "|%20s |          |              |\n", grupos[j][i]);
     fprintf(arq, "+-----------------------------------------------+\n");
     fprintf(arq, "+------------------------------------------------+\n");
     fclose(arq);
     fclose(arq);
     //Chama a função rodízio para determinar as partidas do GRUPO
     //Chama a função rodízio para determinar as partidas do GRUPO
     rodizio (n/g + extra[j], grupos[j]);
     rodizio (n/g + extra[j], grupos[j]);
   }
   }
   //Sequência de vetores de stgrings que definem a ordem dos
   //Sequência de vetores de strings que definem a ordem dos confrontos
   //confrontos para as Finais, considerando o número de grupos (g) e
   //para as Finais no formato Copa, considerando o número de grupos (g)
   //o número de classificados (c) por grupo.
   //e o número de classificados (c) por grupo.
   char final2g2c[][20] = {
   char final2g2c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________",  
"1o Grupo A ________", "1o Grupo B ________",  
"2o Grupo 1 ________", "2o Grupo 2 ________"};
"2o Grupo A ________", "2o Grupo B ________"};
   char final2g3c[][20] = {
   char final2g3c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "2o Grupo 1 ________",  
"1o Grupo A ________", "1o Grupo B ________", "2o Grupo A ________",  
"2o Grupo 2 ________", "3o Grupo 1 ________", "3o Grupo 2 ________"};
"2o Grupo B ________", "3o Grupo A ________", "3o Grupo B ________"};
   char final3g2c[][20] = {
   char final3g2c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",  
"2o Grupo 2 ________", "2o Grupo 3 ________", "2o Grupo 1 ________"};
"2o Grupo B ________", "2o Grupo C ________", "2o Grupo A ________"};
   char final3g3c[][20] = {
   char final3g3c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",  
"2o Grupo 2 ________", "2o Grupo 3 ________", "2o Grupo 1 ________",  
"2o Grupo B ________", "2o Grupo C ________", "2o Grupo A ________",  
"3o Grupo 1 ________", "3o Grupo 2 ________", "3o Grupo 3 ________"};
"3o Grupo A ________", "3o Grupo B ________", "3o Grupo C ________"};
   char final4g2c[][20] = {
   char final4g2c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________", "1o Grupo 4 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________",  
"2o Grupo 2 ________", "2o Grupo 1 ________", "2o Grupo 4 ________", "2o Grupo 3 ________"};
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________"};
   char final4g3c[][20] = {
   char final4g3c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________", "1o Grupo 4 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________",  
"2o Grupo 2 ________", "2o Grupo 1 ________", "2o Grupo 4 ________", "2o Grupo 3 ________",  
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________",  
"3o Grupo 2 ________", "3o Grupo 1 ________", "3o Grupo 4 ________", "3o Grupo 3 ________"};
"3o Grupo B ________", "3o Grupo A ________", "3o Grupo D ________", "3o Grupo C ________"};
  char final5g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",
"1o Grupo D ________", "1o Grupo E ________",
"2o Grupo A ________", "2o Grupo E ________", "2o Grupo B ________",
"2o Grupo C ________", "2o Grupo D ________"};
  char final5g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",
"1o Grupo D ________", "1o Grupo E ________",
"2o Grupo A ________", "2o Grupo E ________", "2o Grupo B ________",
"2o Grupo C ________", "2o Grupo D ________",
"3o Grupo D ________", "3o Grupo A ________", "3o Grupo E ________",
"3o Grupo B ________", "3o Grupo C ________",};
   char final6g2c[][20] = {
   char final6g2c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",  
"1o Grupo 4 ________", "1o Grupo 5 ________", "1o Grupo 6 ________",  
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________",  
"2o Grupo 4 ________", "2o Grupo 3 ________", "2o Grupo 6 ________",  
"2o Grupo E ________", "2o Grupo F ________", "2o Grupo B ________",  
"2o Grupo 5 ________", "2o Grupo 1 ________", "2o Grupo 2 ________"};
"2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________"};
   char final8g2c[][20] = {
   char final6g3c[][20] = {
"1o Grupo 1 ________", "1o Grupo 2 ________", "1o Grupo 3 ________", "1o Grupo 4 ________",  
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",  
"1o Grupo 5 ________", "1o Grupo 6 ________", "1o Grupo 7 ________", "1o Grupo 8 ________",  
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________",
"2o Grupo 2 ________", "2o Grupo 1 ________", "2o Grupo 4 ________", "2o Grupo 3 ________",  
"2o Grupo E ________", "2o Grupo F ________", "2o Grupo B ________",
"2o Grupo 6 ________", "2o Grupo 5 ________", "2o Grupo 8 ________", "2o Grupo 7 ________"};
"2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________",
"3o Grupo A ________", "3o Grupo B ________", "3o Grupo C ________",
"3o Grupo D ________", "3o Grupo E ________", "3o Grupo F ________"};
  char final7g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________",
"2o Grupo B ________", "2o Grupo G ________", "2o Grupo A ________",
"2o Grupo D ________", "2o Grupo C ________", "2o Grupo F ________", "2o Grupo E ________"};
  char final8g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________",  
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________",
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________",
"2o Grupo F ________", "2o Grupo E ________", "2o Grupo H ________", "2o Grupo G ________"};
  char final12g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________",
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________",
"1o Grupo I ________", "1o Grupo J ________", "1o Grupo K ________", "1o Grupo L ________",
"2o Grupo C ________", "2o Grupo D ________", "2o Grupo E ________", "2o Grupo F ________",
"2o Grupo G ________", "2o Grupo H ________", "2o Grupo A ________", "2o Grupo B ________",
"2o Grupo J ________", "2o Grupo L ________", "2o Grupo I ________", "2o Grupo K ________"};
 
  char final16g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________",
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________",
"1o Grupo I ________", "1o Grupo J ________", "1o Grupo K ________", "1o Grupo L ________",
"1o Grupo M ________", "1o Grupo N ________", "1o Grupo O ________", "1o Grupo P ________",
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________",
"2o Grupo F ________", "2o Grupo E ________", "2o Grupo H ________", "2o Grupo G ________",  
"2o Grupo J ________", "2o Grupo I ________", "2o Grupo L ________", "2o Grupo K ________",
"2o Grupo N ________", "2o Grupo M ________", "2o Grupo P ________", "2o Grupo O ________"};
   switch (g)
   switch (g)
   {
   {
Linha 218: Linha 562:
       if (nc == 3)
       if (nc == 3)
         matamata(g * nc, final4g3c);   
         matamata(g * nc, final4g3c);   
      break;
    case 5:
      if (nc == 2)
        matamata(g * nc, final5g2c); 
      if (nc == 3)
        matamata(g * nc, final5g3c);   
       break;
       break;
     case 6:
     case 6:
       matamata(g * nc, final6g2c);   
       if (nc == 2)
        matamata(g * nc, final6g2c); 
      if (nc == 3)
        matamata(g * nc, final6g3c);   
      break;
    case 7:
      matamata(g * nc, final7g);   
       break;
       break;
     case 8:
     case 8:
       matamata(g * nc, final8g2c);   
       matamata(g * nc, final8g); 
      break;
    case 12:
      matamata(g * nc, final12g); 
      break;
    case 16:
      matamata(g * nc, final16g);   
       break;
       break;
   }
   }
}
}
</syntaxhighlight>


int main(int argc, char *argv[])
<syntaxhighlight lang="c">
//Arquivo com jogadores pode ser fornecido como parâmetro
//Arquivo MataMata.c
{
  char jogador[20];
  char jogadores[32][20];
  int n = 0;  //número de jogadores cadastrados
  int g = 0;  //número de grupos
  int nc = 2;  //Número de classificados por GRUPO
  int i;
  char resposta;
  int tam;
  char arquivo[20];
  char tabela[] = "Tabela.txt";
  if (argc == 1)
  {
    printf("\nCADASTRO DE JOGADORES\n");
    printf("\nEntre com NOME DO ARQUIVO com os jogadores:\n");
    fgets(arquivo, sizeof(arquivo), stdin);
    tam = strlen(arquivo);
    if (arquivo[tam - 1] == '\n')
      arquivo[tam - 1] = '\0';
  }
  else
  {
    strcpy (arquivo, argv[1]);
  }
  FILE *arq;
  arq = fopen(arquivo, "r");
  if(arq == NULL) {
    printf("\nNao foi possivel abrir o arquivo!\n");
    printf("\nConfira se o nome do arquivo está correto, incluindo a extensão txt.\n");
    return(1);}
  else
    //Monta vetor com os jogadores
    while( (fscanf(arq,"%s\n", jogador))!=EOF )
    {
      strcpy(jogadores[n], jogador);
      n++;
    }
  fclose(arq);


  arq = fopen(tabela, "w");
//Programa Gerador de Tabelas Esportivas
//Função matamata utilizada pelo programa principal.


  fprintf(arq, "\n+----------------------------------------------------+\n");
#include <stdio.h>
  fprintf(arq, "\n      PROGRAMA GERADOR DE TABELAS ESPORTIVAS\n");
#include <stdlib.h>
  fprintf(arq, "\n+----------------------------------------------------+\n");
#include <string.h>
  fprintf(arq, "\n            Data da Competição: %s \n", __DATE__);
#include <time.h>
  fprintf(arq, "\n+----------------------------------------------------+\n");
  //Imprime jogadores cadastrados
  fprintf(arq, "\nJOGADORES CADASTRADOS:\n");
  for (i=0; i<n; i++)
  {
    printf("%2d: %-20s\n", i + 1, jogadores[i]);
    fprintf(arq, "%2d: %-20s\n", i + 1, jogadores[i]);
  }
  fclose(arq);
  //Pergunta sobre formato do sorteio
  printf("\nESCOLHA FORMATO DO SORTEIO: \n");
  printf(" (R) Manter ordem de RANKING ou CABEÇAS DE CHAVE (embaralhando demais)\n");
  printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
  scanf (" %c",&resposta);
  while (resposta != 's' && resposta != 'S' &&
        resposta != 'r' && resposta != 'R') {
    printf("\nESCOLHA FORMATO DO SORTEIO: \n");
    printf(" (R) Manter ordem de RANKING ou CABEÇAS DE CHAVE (embaralhando demais)\n");
    printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
    scanf (" %c",&resposta);}
  if (resposta == 's' || resposta == 'S')
    embaralhar(jogadores, n);
  //Pergunta sobre formato da competição
  printf("\nESCOHA FORMATO DA COMPETIÇÃO: \n");
  if (n >= 6 && n <= 32)
    printf(" (C) Copa: Grupos + Fase Final (De 6 a 32 jogadores)\n");
  printf(" (R) Rodízio simples (Até 5 jogadores)\n");
  printf(" (E) Eliminatória simples (Até 16 jogadores)\n");
  scanf (" %c",&resposta);
  while (resposta != 'c' && resposta != 'C' &&
        resposta != 'r' && resposta != 'R' &&
        resposta != 'e' && resposta != 'e') {
    if (n >= 6 && n <= 32)
      printf(" (C) Copa: Grupos + Fase Final (De 6 a 32 jogadores)\n");
    printf(" (R) Rodízio simples (Até 5 jogadores)\n");
    printf(" (E) Eliminatória simples (Até 16 jogadores)\n"); 
    scanf (" %c",&resposta);
  }
  if (resposta == 'r' || resposta == 'R')
    //Chama função rodizio
    rodizio (n, jogadores);
  if (resposta ==  'e' || resposta == 'E')
    //Chama função matamata
    matamata(n, jogadores);
  if (resposta ==  'c' || resposta == 'C')
  {
    //Pergunta sobre número de GRUPOS
    printf("\n  Escolha quantos GRUPOS: \n");
    printf("  (2) Dois  GRUPOS (Até 10 jogadores)\n");
    printf("  (3) Três  GRUPOS (De 9 a 12 jogadores)\n");
    printf("  (4) Quatro GRUPOS (De 12 a 17 jogadores)\n");
    printf("  (6) Seis  GRUPOS (De 18 a 24 jogadores)\n");
    printf("  (8) Oito  GRUPOS (De 24 a 32 jogadores)\n");
    scanf (" %c",&resposta);
    while (resposta != '2' && resposta != '3' &&
          resposta != '4' && resposta != '6' &&
          resposta != '8') {
      printf("\n  Escolha quantos GRUPOS: \n");
      printf("  (2) Dois  GRUPOS (Até 10 jogadores)\n");
      printf("  (3) Três  GRUPOS (De 9 a 12 jogadores)\n");
      printf("  (4) Quatro GRUPOS (De 12 a 17 jogadores)\n");
      printf("  (6) Seis  GRUPOS (De 18 a 24 jogadores)\n");
      printf("  (8) Oito  GRUPOS (De 24 a 32 jogadores)\n");
      scanf (" %c",&resposta);}
    if (resposta == '2' || resposta == '3'|| resposta == '4')
    {
      if (resposta == '2')
        g = 2;
      if (resposta == '3')
        g = 3;
      if (resposta == '4')
        g = 4;
      //Pergunta sobre número de classificados por GRUPO
      printf("\n  Escolha número de classificados por GRUPO: \n");
      printf("  (2) Dois\n");
      printf("  (3) Três\n");
      scanf (" %c",&resposta);
      while (resposta != '2' && resposta != '3'){
        printf("\n  Escolha número de classificados por GRUPO: \n");
        printf("  (2) Dois\n");
        printf("  (3) Três\n");
        scanf (" %c",&resposta);}
      if (resposta == '2')
        nc = 2;
      if (resposta == '3')
        nc = 3;
    }
    if (resposta == '4')
      g = 4;
    if (resposta == '6')
      g = 6;
    if (resposta == '8')
      g = 8;
  //Chama função copa
  copa(g, n, nc, jogadores);
  }
  arq = fopen(tabela, "a");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n Programa desenvolvido por: Evandro Cantú");
  fprintf(arq, "\n Contato: evandro.cantu@ifpr.edu.br");
  fclose(arq);
  return(0);
}


//matamata: Função para determinar as partidas de uma eliminatória simples.
//matamata: Função para determinar as partidas de uma eliminatória simples.
Linha 384: Linha 607:
void matamata (int n, char jogadores[32][20])
void matamata (int n, char jogadores[32][20])
{
{
   char tabela[] = "Tabela.txt";
   char tabela[] = "Tabelas.txt";
   FILE *arq;
   FILE *arq;
   arq = fopen(tabela, "a");
   arq = fopen(tabela, "a");
Linha 704: Linha 927:
       fprintf(arq, "\n%20s          |----+","");
       fprintf(arq, "\n%20s          |----+","");
       fprintf(arq, "\n%20s ----+    |", jogadores[14]);
       fprintf(arq, "\n%20s ----+    |", jogadores[14]);
      fprintf(arq, "\n%20s    |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 18:
      //matamata 9
      fprintf(arq, "\n%22s16F  OF  QF  SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+        |----+", jogadores[15]);
      fprintf(arq, "\n%20s              |    |",""); 
      fprintf(arq, "\n%25s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%25s    |----+    |","");
      fprintf(arq, "\n%25s ----+        |----+", jogadores[7]);
      fprintf(arq, "\n%25s              |    |","");
      fprintf(arq, "\n%25s ----+        |    |", jogadores[4]);
      fprintf(arq, "\n%25s    |----+    |    |","");
      fprintf(arq, "\n%25s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%25s          |----+    |","");
      fprintf(arq, "\n%25s ----+    |        |", jogadores[12]);
      fprintf(arq, "\n%25s    |----+        |","");
      fprintf(arq, "\n%25s ----+              |", jogadores[3]);
      fprintf(arq, "\n%25s                    |-----","");
      //matamata 9
      fprintf(arq, "\n%25s ----+              |", jogadores[2]);
      fprintf(arq, "\n%25s    |----+        |",""); 
      fprintf(arq, "\n%25s ----+    |        |", jogadores[13]);
      fprintf(arq, "\n%25s          |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%25s    |----+    |    |","");
      fprintf(arq, "\n%25s ----+        |    | ", jogadores[5]);
      fprintf(arq, "\n%25s              |----+",""); 
      fprintf(arq, "\n%25s ----+        |", jogadores[6]);
      fprintf(arq, "\n%25s    |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s              |    |",""); 
      fprintf(arq, "\n%20s ----+        |----+", jogadores[14]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 24:
      //matamata 12
      fprintf(arq, "\n%18s16F      OF  QF  SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+        |----+", jogadores[15]);
      fprintf(arq, "\n%20s              |    |",""); 
      fprintf(arq, "\n%20s ----+        |    |", jogadores[8]);
      fprintf(arq, "\n%20s    |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[23]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%25s ----+        |", jogadores[7]);
      fprintf(arq, "\n%20s                    |----+",""); 
      fprintf(arq, "\n%25s ----+        |    |", jogadores[4]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[20]);
      fprintf(arq, "\n%20s    |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+        |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s              |    |    |",""); 
      fprintf(arq, "\n%20s ----+        |----+    |", jogadores[12]);
      fprintf(arq, "\n%20s    |----+    |        |","");
      fprintf(arq, "\n%20s ----+    |    |        |", jogadores[19]);
      fprintf(arq, "\n%20s          |----+        |","");
      fprintf(arq, "\n%25s ----+              |", jogadores[3]);
      fprintf(arq, "\n%20s                        |-----","");
      //matamata 12
      fprintf(arq, "\n%25s ----+              |", jogadores[2]);
      fprintf(arq, "\n%20s          |----+        |","");
      fprintf(arq, "\n%20s ----+    |    |        |", jogadores[18]);
      fprintf(arq, "\n%20s    |----+    |        |","");
      fprintf(arq, "\n%20s ----+        |----+    |", jogadores[13]);
      fprintf(arq, "\n%20s              |    |    |",""); 
      fprintf(arq, "\n%20s ----+        |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s    |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[21]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%25s ----+        |    |", jogadores[5]);
      fprintf(arq, "\n%20s                    |----+",""); 
      fprintf(arq, "\n%25s ----+        |", jogadores[6]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[22]);
      fprintf(arq, "\n%20s    |----+    |    |","");
      fprintf(arq, "\n%20s ----+        |    | ", jogadores[9]);
      fprintf(arq, "\n%20s              |    |",""); 
      fprintf(arq, "\n%20s ----+        |----+", jogadores[14]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 32:
      //matamata 16
      fprintf(arq, "\n%18s16F      OF  QF  SF    F\n","");
      fprintf(arq, "\n%20s ----+", jogadores[0]);
      fprintf(arq, "\n%20s    |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[31]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+        |", jogadores[15]);
      fprintf(arq, "\n%20s              |----+",""); 
      fprintf(arq, "\n%20s ----+        |    |", jogadores[8]);
      fprintf(arq, "\n%20s    |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[23]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |        |", jogadores[24]);
      fprintf(arq, "\n%20s    |----+        |",""); 
      fprintf(arq, "\n%20s ----+              |", jogadores[7]);
      fprintf(arq, "\n%20s                    |----+",""); 
      fprintf(arq, "\n%20s ----+              |    |", jogadores[4]);
      fprintf(arq, "\n%20s    |----+        |    |",""); 
      fprintf(arq, "\n%20s ----+    |        |    |", jogadores[27]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[20]);
      fprintf(arq, "\n%20s    |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+        |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s              |----+    |",""); 
      fprintf(arq, "\n%20s ----+        |        |", jogadores[12]);
      fprintf(arq, "\n%20s    |----+    |        |","");
      fprintf(arq, "\n%20s ----+    |    |        |", jogadores[19]);
      fprintf(arq, "\n%20s          |----+        |","");
      fprintf(arq, "\n%20s ----+    |              |", jogadores[28]);
      fprintf(arq, "\n%20s    |----+              |","");
      fprintf(arq, "\n%20s ----+                  |", jogadores[3]);
      fprintf(arq, "\n%20s                        |----+","");
      //matamata 16
      fprintf(arq, "\n%20s ----+                  |", jogadores[2]);
      fprintf(arq, "\n%20s    |----+              |","");
      fprintf(arq, "\n%20s ----+    |              |", jogadores[29]);
      fprintf(arq, "\n%20s          |----+        |","");
      fprintf(arq, "\n%20s ----+    |    |        |", jogadores[18]);
      fprintf(arq, "\n%20s    |----+    |        |","");
      fprintf(arq, "\n%20s ----+        |        |", jogadores[13]);
      fprintf(arq, "\n%20s              |----+    |",""); 
      fprintf(arq, "\n%20s ----+        |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s    |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[21]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |        |    |", jogadores[26]);
      fprintf(arq, "\n%20s    |----+        |    |",""); 
      fprintf(arq, "\n%20s ----+              |    |", jogadores[5]);
      fprintf(arq, "\n%20s                    |----+",""); 
      fprintf(arq, "\n%20s ----+              |", jogadores[6]);
      fprintf(arq, "\n%20s    |----+        |",""); 
      fprintf(arq, "\n%20s ----+    |        |", jogadores[25]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[22]);
      fprintf(arq, "\n%20s    |----+    |    |","");
      fprintf(arq, "\n%20s ----+        |    | ", jogadores[9]);
      fprintf(arq, "\n%20s              |----+",""); 
      fprintf(arq, "\n%20s ----+        |", jogadores[14]);
      fprintf(arq, "\n%20s    |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[30]);
       fprintf(arq, "\n%20s    |----+","");
       fprintf(arq, "\n%20s    |----+","");
       fprintf(arq, "\n%20s ----+\n", jogadores[1]);
       fprintf(arq, "\n%20s ----+\n", jogadores[1]);
Linha 711: Linha 1 094:
}
}
</syntaxhighlight>
</syntaxhighlight>
;Versão para Windows: Para rodar no sistema operacional Windows o código fonte deve ser compilado neste sistema. Caso prefira, pode solicitar por email o arquivo executável do programa diretamente do desenvolvedor.


----
----


[[Categoria:Atividades Esportivas]]
[[Categoria:Atividades Esportivas]]

Edição atual tal como às 16h49min de 12 de novembro de 2018

Este software permite a geração de tabelas esportivas para organizar competições em diferentes formatos, incluindo:

  • Copa (fase de grupos seguido de eliminatória simples);
  • Rodízio simples (todos contra todos);
  • Eliminatória simples (mata mata).

No formato copa o programa aceita até 80 competidores, organizados em até 16 grupos. No formato eliminatória simples o programa pode organizar confrontos com 2 a 16 jogadores ou 24 ou 32. No formato rodízio simples o programa aceita qualquer número de jogadores.

Utilização do Programa

Entrada dos jogadores
O cadastro de jogadores (ou equipes) deve ser realizado através de um arquivo de texto, um nome em cada linha. Os nomes podem ter até 20 caracteres, sem acentos ou espaços.
Caso haja um ranking dos jogadores para orientar a formação das tabelas para eliminatórias simples ou para composição de grupos no formato copa, a ordem dos jogadores no arquivo deve seguir a ordem do ranking.
Execução do programa
A execução do programa deve ser feira em um terminal de comandos, no caso do sistema Linux, passando como parâmetro o arquivo com os jogadores cadastrados.
./GeradorTabelas Jogadores.txt
No caso so sistema Windows, deve-se clicar duas vezes no programa executável e será solicitado o nome do arquivo com os jogadores.
O programa solicita ao usuário as opções quanto ao formato das competições e orienta as escolhas em função do número de competidores.
Tabelas da Competição
O programa gera como saída o arquivo Tabelas.txt, que contém os confrontos entre os jogadores.
Caso a escolha tenha sido o formato copa, o programa gera os confrontos da fase de grupos e os confrontos das partidas eliminatórias.
O arquivo Tabelas.txt pode ser editado com os resultados das competições.

Download do programa

O software foi desenvolvido em linguagem C.

O código fonte do programa está organizado em três arquivos, disponibilizados abaixo: 

GeradorTebelas.c
Copa.c
MataMata.c

Para gerar o programa executável, os arquivos fonte devem ser compilados com o comando: 

gcc GeradorTabelas.c Copa.c MataMata.c -o GeradorTabelas

//Arquivo GeradorTabelas.c

//Programa Gerador de Tabelas Esportivas
//Desenvolvido por Evandro Cantú
//Instituto Federal do Paraná
//Foz do Iguaçu, outubro 2016
//Contato: evandro.cantu@ifpr.edu.br
//Atualização: jun/2017

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

char tabela[] = "Tabelas.txt";
FILE *arq;

//matamata: Função para determinar as partidas de uma eliminatória simples.
//          Recebe como parâmetro o número de jogadores e
//          o vetor com os jogadores
void matamata (int n, char jogadores[32][20]);
//Protótipo: Arquivo fonte MataMata.c

//copa: Função organizar a competição em grupos.
//      Recebe como parâmetros o número de grupos (g), número de
//      jogadores (n), número de classificados por grupo (nc) e
//      o vetor com os jogadores. 
void copa (int r, int g, int n, int nc, char jogadores[80][20]);
//Protótipo: Arquivo fonte Copa.c

//rodizio: Função para determinar as partidas de um rodízio simples,
//         com todos jogando contra todos.
//         Recebe como parâmetro o número de jogadores e
//         o vetor com os jogadores
void rodizio (int n, char jogadores[80][20])
{
  int c = 0;
  int i, j, k;
  char ultimoJogador[20] = {""};
  //SE número impar de jogadores ENTÃO adiciona um jogador vazio
  if (n % 2 == 1) { 
     strcpy(jogadores[n], ultimoJogador);
     n = n + 1;
  }
  arq = fopen(tabela, "a");
  fprintf(arq, "\nPARTIDAS \nDO RODÍZIO: \n\n");
  for (k=0;k<n-1;k++)
  {
    fprintf(arq, "%sRodada: %2d\n", "",k+1);
    for (i=0;i<n/2;i++)
      if ((strcmp(jogadores[i], "") != 0) && (strcmp(jogadores[n-1-i], "") != 0))
        fprintf(arq, "%2d: %20s _ x _ %-20s\n", ++c, jogadores[i], jogadores[n-1-i]);
    //Rotaciona vetor de jogadores, menos primeira posição
    strcpy(ultimoJogador, jogadores[n-1]);
    for (j=n-1;j>0;j--)
      strcpy(jogadores[j], jogadores[j-1]);
    strcpy(jogadores[1], ultimoJogador);
  }
  fclose(arq);
}
//Ref: https://pt.wikipedia.org/wiki/Competições_de_todos_contra_todos

/* FUNÇÃO ANTERIOR SEM ORGANIZAR RODADAS
void rodizio (int n, char jogadores[80][20])
{
  int c = 0;
  int i, j;
  arq = fopen(tabela, "a");
  fprintf(arq, "\nPARTIDAS DO RODÍZIO: \n");
  for (i=0;i<n;i++)
    for (j=i+1;j<n;j++)
      fprintf(arq, "%2d: %20s _ x _ %-20s\n", ++c, jogadores[i], jogadores[j]);
  fclose(arq);
}
*/

//embaralhar: Função para embaralhar um vetor.
//            Recebe como parâmetro o vetor com os jogadores
//            a serem embaralhados e o tamanho do vetor.
void embaralhar(char vetor[80][20], int tamVetor)
{
  int i;
  char temp[20];
  srand(time(NULL));
  for (i = 0; i < tamVetor; i++)
  {
    int r = rand() %tamVetor;
    strcpy(temp,   vetor[i]);
    strcpy(vetor[i], vetor[r]);
    strcpy(vetor[r], temp);
  }
}

int main(int argc, char *argv[]) 
//Arquivo com jogadores pode ser fornecido como parâmetro
{
  char jogador[20];
  char jogadores[80][20];
  int n = 0;   //número de jogadores cadastrados
  int g = 0;   //número de grupos
  int nc = 2;  //Número de classificados por GRUPO
  int r;       //Número de jogadores incluídos pelo RANKING nos GRUPOS
  int i;
  char resposta;
  int tam;
  char arquivo[20];
  if (argc == 1)
  {
    printf("\nCADASTRO DE JOGADORES\n");
    printf("\nEntre com NOME DO ARQUIVO com os jogadores:\n");
    fgets(arquivo, sizeof(arquivo), stdin);
    tam = strlen(arquivo);
    if (arquivo[tam - 1] == '\n')
      arquivo[tam - 1] = '\0';
  }
  else
  {
    strcpy (arquivo, argv[1]);
  }
  FILE *arq;
  arq = fopen(arquivo, "r");
  if(arq == NULL) {
    printf("\nNao foi possivel abrir o arquivo!\n");
    printf("\nConfira se o nome do arquivo está correto, incluindo a extensão txt.\n");
    return(1);}
  else
    //Monta vetor com os jogadores
    while( (fscanf(arq,"%s\n", jogador))!=EOF )
    {
      strcpy(jogadores[n], jogador);
      n++;
    }
  fclose(arq);
  arq = fopen(tabela, "w");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n       PROGRAMA GERADOR DE TABELAS ESPORTIVAS\n");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n  Evento: _________________________________________\n");
  fprintf(arq, "\n  Local:  _________________________________________\n");
  fprintf(arq, "\n  Data:   _________________________________________\n");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  //Data e hora do sistema
  time_t mytime;
  mytime = time(NULL);
  struct tm tm = *localtime(&mytime);
  fprintf(arq, "\n      Geração das Tabelas: %d/%d/%d - %d:%d\n", 
          tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min);
  fprintf(arq, "\n+----------------------------------------------------+\n");
  //Imprime jogadores cadastrados
  fprintf(arq, "\nJOGADORES CADASTRADOS:\n");
  for (i=0; i<n; i++)
  {
    printf("%2d: %-20s\n", i + 1, jogadores[i]);
    fprintf(arq, "%2d: %-20s\n", i + 1, jogadores[i]);
  }
  fclose(arq);
  //Pergunta sobre formato da competição
  do
  {
    printf("\nESCOHA FORMATO DA COMPETIÇÃO: \n");
    if (n >= 4 && n <= 80)
      printf(" (C) Copa: Grupos + Fase Final\n");
    printf(" (R) Rodízio simples\n");
      if (n <= 16 || n == 24 || n == 32)
      printf(" (E) Eliminatória simples\n");
    scanf (" %c",&resposta);
  } while (resposta != 'c' && resposta != 'C' && 
           resposta != 'r' && resposta != 'R' &&
           resposta != 'e' && resposta != 'e');
  if (resposta == 'r' || resposta == 'R')
    //Chama função rodizio
    rodizio (n, jogadores);
  if (resposta ==  'e' || resposta == 'E') {
    //Pergunta sobre formato do sorteio
    do
    {
      printf("\nESCOLHA FORMATO DO SORTEIO: \n");
      printf(" (R) Manter ordem de RANKING\n");
      printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
      scanf (" %c",&resposta);
    } while (resposta != 's' && resposta != 'S' && 
             resposta != 'r' && resposta != 'R');
    if (resposta == 's' || resposta == 'S')
      embaralhar(jogadores, n);
    //Chama função matamata
    matamata(n, jogadores);
    }
  if (resposta ==  'c' || resposta == 'C')
  {
    //Pergunta sobre número de GRUPOS
    do
    {
      printf("\n  Escolha quantos GRUPOS: \n");
      if (n >= 4 && n <= 10) {
        printf("   (2) Dois   GRUPOS (%d ", n / 2);
        if (n % 2 != 0) printf("ou %d ", n / 2 + 1);
        printf("jogadores cada)");
        if (n / 2 == 3 || (n / 2 == 4 && n % 2 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 6 && n <= 15) {
        printf("   (3) Três   GRUPOS (%d ", n / 3);
        if (n % 3 != 0) printf("ou %d ", n / 3 + 1);
        printf("jogadores cada)");
        if (n / 3 == 3 || (n / 3 == 4 && n % 3 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 8 && n <= 20) {
        printf("   (4) Quatro GRUPOS (%d ", n / 4);
        if (n % 4 != 0) printf("ou %d ", n / 4 + 1);
        printf("jogadores cada)");
        if (n / 4 == 3 || (n / 4 == 4 && n % 4 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 10 && n <= 25) {
        printf("   (5) Cinco  GRUPOS (%d ", n / 5);
        if (n % 5 != 0) printf("ou %d ", n / 5 + 1);
        printf("jogadores cada)");
        if (n / 5 == 3 || (n / 5 == 4 && n % 5 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 12 && n <= 30) {
        printf("   (6) Seis   GRUPOS (%d ", n / 6);
        if (n % 6 != 0) printf("ou %d ", n / 6 + 1);
        printf("jogadores cada)");
        if (n / 6 == 3 || (n / 6 == 4 && n % 6 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 14 && n <= 35) {
        printf("   (7) Sete   GRUPOS (%d ", n / 7);
        if (n % 7 != 0) printf("ou %d ", n / 7 + 1);
        printf("jogadores cada)");
        if (n / 7 == 3 || (n / 7 == 4 && n % 7 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 16 && n <= 40) {
        printf("   (8) Oito   GRUPOS (%d ", n / 8);
        if (n % 8 != 0) printf("ou %d ", n / 8 + 1);
        printf("jogadores cada)");
        if (n / 8 == 3 || (n / 8 == 4 && n % 8 == 0))
          printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 24 && n <= 60) {
        printf("   (Z) Doze   GRUPOS (%d ", n / 12);
        if (n % 12 != 0) printf("ou %d ", n / 12 + 1);
        printf("jogadores cada)");
        if (n / 12 == 3 || (n / 12 == 4 && n % 12 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      if (n >= 32 && n <= 80) {
        printf("   (S) Dezeseis GRUPOS (%d ", n / 16);
        if (n % 16 != 0) printf("ou %d ", n / 16 + 1);
        printf("jogadores cada)");
        if (n / 16 == 3 || (n / 16 == 4 && n % 16 == 0))
           printf("  <- melhor escolha\n"); else printf("\n");}
      scanf (" %c",&resposta);
    } while (resposta != '2' && resposta != '3' && resposta != '4' && 
             resposta != '5' && resposta != '6' && resposta != '7' &&
             resposta != '8' && resposta != 'z' && resposta != 'Z' &&
             resposta != 's' && resposta != 'S');
    if (resposta == '2' || resposta == '3'|| resposta == '4'||
        resposta == '5' || resposta == '6')
    {
      if (resposta == '2')
        g = 2;
      if (resposta == '3')
        g = 3;
      if (resposta == '4')
        g = 4;
      if (resposta == '5')
        g = 5;
      if (resposta == '6')
        g = 6;
      if ((g == 2 && n >= 6)  || (g == 3 && n >= 9) || (g == 4 && n >= 12) ||
          (g == 5 && n >= 15) || (g == 6 && n >= 18))
        //Pergunta sobre número de classificados por GRUPO
        do
        {
          printf("\n  Escolha número de classificados por GRUPO: \n");
          printf("   (2) Dois\n");
          printf("   (3) Três\n");
          scanf (" %c",&resposta);
        } while (resposta != '2' && resposta != '3'); 
      if (resposta == '2')
        nc = 2;
      if (resposta == '3')
        nc = 3;
    }
    if (resposta == '7')
      g = 7;
    if (resposta == '8')
      g = 8;
    if (resposta == 'z' || resposta == 'Z')
      g = 12;
    if (resposta == 's' || resposta == 'S')
      g = 16;
    //Pergunta sobre formato do sorteio
    do
    {
      printf("\nESCOLHA O FORMATO DA MONTAGEM DOS GRUPOS: \n");
      printf(" (R) Manter ordem de RANKING para organizar GRUPOS\n");
      printf(" (1) Incluir UM   pelo RANKING e embaralhar demais\n");
      if (n / g >= 2)
        printf(" (2) Incluir DOIS pelo RANKING e embaralhar demais\n");
      if (n / g >= 3)
        printf(" (3) Incluir TRÊS pelo RANKING e embaralhar demais\n");
      printf(" (S) SORTEAR e embaralhar TODOS os jogadores\n");
      scanf (" %c",&resposta);
    } while (resposta != 's' && resposta != 'S' && 
             resposta != '1' && resposta != '2' && resposta != '3' &&
             resposta != 'r' && resposta != 'R');
    if (resposta == 's' || resposta == 'S') 
      r = 0;
    if (resposta == '1')
      r = 1;
    if (resposta == '2')
      r = 2;
    if (resposta == '3')
      r = 3;
    if (resposta == 'r' || resposta == 'R')
      r = 4;
   //Chama função copa
   copa(r, g, n, nc, jogadores);
  }
  arq = fopen(tabela, "a");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\n Programa desenvolvido por: Evandro Cantú");
  fprintf(arq, "\n Contato: evandro.cantu@ifpr.edu.br");
  fprintf(arq, "\n Data da compilação: %s\n",__DATE__);
  fclose(arq);
  return(0);
}

//Arquivo Copa.c

//Programa Gerador de Tabelas Esportivas
//Função copa utilizada pelo programa principal.

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

void matamata (int n, char jogadores[32][20]);
void rodizio (int n, char jogadores[80][20]);
void embaralhar(char vetor[80][20], int tamVetor);

//calExtra: Função auxiliar da função copa, permtindo verificar se
//          há jogadores extra em um grupo, quando a divisão entre
//          o número de jogadores e o número de grupos não é exata.
int calExtra (int *mod)
{
  if (*mod > 0)
  { 
    *mod = *mod - 1;
    return (1);
  }
  return (0);
}

//copa: Função organizar a competição em grupos.
//      Recebe como parâmetros o número de jogadores a serem incluídos
//      pelo Ranking (r), o número de grupos (g), número de
//      jogadores (n), número de classificados por grupo (nc) e
//      o vetor com os jogadores. 
void copa (int r, int g, int n, int nc, char jogadores[80][20])
{
  char tabela[] = "Tabelas.txt";
  FILE *arq;
  char grupos[16][80][20];
  char nomeGrupo[16] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'};
  int i, j;
  int c = 0;
  int div, mod;
  div = n / g; //Número mínimo de jogadores por GRUPO
  mod = n % g; //Jogador(es) extra para alocar em GRUPO(s)
  int ng = n;  //Número de jogadores além incluídos pelo RANKING
  int extra[8];
  int offset = 0;
  arq = fopen(tabela, "a");
  fprintf(arq, "\nCOMPETIÇÃO NO FORMATO COPA: \n");
  fprintf(arq, "-> %2d GRUPOS\n-> %2d Classificados cada GRUPO\n", g, nc);
  fprintf(arq, "\n+----------------------------------------------------+");
  fprintf(arq, "\n                 TABELAS DE JOGOS: ");
  fprintf(arq, "\n+----------------------------------------------------+");
  fclose(arq);
  //Inclusão de jogadores nos GRUPOS de acordo com RANKING
  if (r >= 1)
  {
    for (i = 0; i < g; i++) //Cabeças de GRUPO
      strcpy(grupos[i][0], jogadores[i]);
    ng = n - g;  //Número total de jogadores restantes
    c = 1;       
  }
  if (r >= 2)
  {
    for (i = 0; i < g; i++) //Segundo integrante do GRUPO na ordem inversa
      strcpy(grupos[i][1], jogadores[2 * g - 1 - i]);
    ng = n - 2 * g; //Número total de jogadores restantes
    c = 2;       
  }
  if ((r >= 3) && (n / g > 2))
  {
    for (i = 0; i < g; i++) //Terceiro integrante do GRUPO
      strcpy(grupos[i][2], jogadores[2 * g + i]);
    ng = n - 3 * g; //Número total de jogadores restantes
    c = 3;
  }
  if ((r == 4) && (n / g > 3))
  {
    for (i = 0; i < g; i++) //Terceiro integrante do GRUPO
      strcpy(grupos[i][3], jogadores[4 * g - 1 - i]);
    ng = n - 4 * g; //Número total de jogadores restantes
    c = 4;
  }
  for (i = 0; i < ng; i++)             
    strcpy(jogadores[i], jogadores[c * g + i]);  //Retira jogadores já incluídos
  if (r != 4)
    embaralhar(jogadores, ng); //Embaralha restantes
  //Monta GRUPOS, verificado através da função callExtra se
  //há jogadores extra em um grupo, quando a divisão entre
  //o número de jogadores e o número de grupos não é exata.
  for (j = 0; j < g; j++)              
  {
    extra[j] = calExtra(&mod);
    for (i = 0; i < ng/g + extra[j]; i++)
      //Inclui o restante dos jogadores nos GRUPOS
      strcpy(grupos[j][i+c], jogadores[i + offset]);
    //offset marca no vetor com os jogadores a posição do próximo
    //jogador a ser incluídos no próximo GRUPO.      
    offset = offset + ng/g + extra[j];
    arq = fopen(tabela, "a");
    fprintf(arq, "\n+------------------------------------------------+");
    fprintf(arq, "\n| GRUPO %c : Jogadores | Vitórias | Saldo de Sets |", nomeGrupo[j]);
    fprintf(arq, "\n+---------------------+----------+---------------+\n");
    //Imprime os membros de cada GRUPO
    for (i = 0; i < n/g + extra[j]; i++)
      fprintf(arq, "|%20s |          |               |\n", grupos[j][i]);
    fprintf(arq, "+------------------------------------------------+\n");
    fclose(arq);
    //Chama a função rodízio para determinar as partidas do GRUPO
    rodizio (n/g + extra[j], grupos[j]);
  }
  //Sequência de vetores de strings que definem a ordem dos confrontos
  //para as Finais no formato Copa, considerando o número de grupos (g)
  //e o número de classificados (c) por grupo.
  char final2g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", 
"2o Grupo A ________", "2o Grupo B ________"};
  char final2g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "2o Grupo A ________", 
"2o Grupo B ________", "3o Grupo A ________", "3o Grupo B ________"};
  char final3g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"2o Grupo B ________", "2o Grupo C ________", "2o Grupo A ________"};
  char final3g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"2o Grupo B ________", "2o Grupo C ________", "2o Grupo A ________", 
"3o Grupo A ________", "3o Grupo B ________", "3o Grupo C ________"};
  char final4g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________", 
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________"};
  char final4g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________", 
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________", 
"3o Grupo B ________", "3o Grupo A ________", "3o Grupo D ________", "3o Grupo C ________"};
  char final5g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"1o Grupo D ________", "1o Grupo E ________",
"2o Grupo A ________", "2o Grupo E ________", "2o Grupo B ________", 
"2o Grupo C ________", "2o Grupo D ________"};
  char final5g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"1o Grupo D ________", "1o Grupo E ________",
"2o Grupo A ________", "2o Grupo E ________", "2o Grupo B ________", 
"2o Grupo C ________", "2o Grupo D ________",
"3o Grupo D ________", "3o Grupo A ________", "3o Grupo E ________", 
"3o Grupo B ________", "3o Grupo C ________",};
  char final6g2c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________", 
"2o Grupo E ________", "2o Grupo F ________", "2o Grupo B ________", 
"2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________"};
  char final6g3c[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________", 
"2o Grupo E ________", "2o Grupo F ________", "2o Grupo B ________", 
"2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________",
"3o Grupo A ________", "3o Grupo B ________", "3o Grupo C ________", 
"3o Grupo D ________", "3o Grupo E ________", "3o Grupo F ________"};
  char final7g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", 
"1o Grupo D ________", "1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", 
"2o Grupo B ________", "2o Grupo G ________", "2o Grupo A ________", 
"2o Grupo D ________", "2o Grupo C ________", "2o Grupo F ________", "2o Grupo E ________"};
  char final8g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________", 
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________", 
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________", 
"2o Grupo F ________", "2o Grupo E ________", "2o Grupo H ________", "2o Grupo G ________"};
  char final12g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________", 
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________", 
"1o Grupo I ________", "1o Grupo J ________", "1o Grupo K ________", "1o Grupo L ________", 
"2o Grupo C ________", "2o Grupo D ________", "2o Grupo E ________", "2o Grupo F ________", 
"2o Grupo G ________", "2o Grupo H ________", "2o Grupo A ________", "2o Grupo B ________", 
"2o Grupo J ________", "2o Grupo L ________", "2o Grupo I ________", "2o Grupo K ________"};

  char final16g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________", "1o Grupo D ________", 
"1o Grupo E ________", "1o Grupo F ________", "1o Grupo G ________", "1o Grupo H ________", 
"1o Grupo I ________", "1o Grupo J ________", "1o Grupo K ________", "1o Grupo L ________", 
"1o Grupo M ________", "1o Grupo N ________", "1o Grupo O ________", "1o Grupo P ________", 
"2o Grupo B ________", "2o Grupo A ________", "2o Grupo D ________", "2o Grupo C ________", 
"2o Grupo F ________", "2o Grupo E ________", "2o Grupo H ________", "2o Grupo G ________", 
"2o Grupo J ________", "2o Grupo I ________", "2o Grupo L ________", "2o Grupo K ________",
"2o Grupo N ________", "2o Grupo M ________", "2o Grupo P ________", "2o Grupo O ________"};
  switch (g)
  {
    case 2:
      if (nc == 2)
        matamata(g * nc, final2g2c);  
      if (nc == 3)
        matamata(g * nc, final2g3c);  
      break;
    case 3:
      if (nc == 2)
        matamata(g * nc, final3g2c);  
      if (nc == 3)
        matamata(g * nc, final3g3c);  
      break;
    case 4:
      if (nc == 2)
        matamata(g * nc, final4g2c);  
      if (nc == 3)
        matamata(g * nc, final4g3c);  
      break;
    case 5:
      if (nc == 2)
        matamata(g * nc, final5g2c);  
      if (nc == 3)
        matamata(g * nc, final5g3c);    
      break;
    case 6:
      if (nc == 2)
        matamata(g * nc, final6g2c);  
      if (nc == 3)
        matamata(g * nc, final6g3c);    
      break;
    case 7:
      matamata(g * nc, final7g);  
      break;
    case 8:
      matamata(g * nc, final8g);  
      break;
    case 12:
      matamata(g * nc, final12g);  
      break;
    case 16:
      matamata(g * nc, final16g);  
      break;
  }
}

//Arquivo MataMata.c

//Programa Gerador de Tabelas Esportivas
//Função matamata utilizada pelo programa principal.

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

//matamata: Função para determinar as partidas de uma eliminatória simples.
//          Recebe como parâmetro o número de jogadores e
//          o vetor com os jogadores
void matamata (int n, char jogadores[32][20])
{
  char tabela[] = "Tabelas.txt";
  FILE *arq;
  arq = fopen(tabela, "a");
  fprintf(arq, "\n+----------------------------------------------------+\n");
  fprintf(arq, "\nPARTIDAS ELIMINATÓRIAS: \n");
  switch (n)
  {
    case 2:
      fprintf(arq, "\n%20s ----+", jogadores[0]);  
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 3:
      fprintf(arq, "\n%18sSF       F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----","");
      fprintf(arq, "\n%20s ----+    |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 4:
      fprintf(arq, "\n%20s   SF    F\n","");
      fprintf(arq, "\n%20s ----+", jogadores[0]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[3]);
      fprintf(arq, "\n%20s          |----","");
      fprintf(arq, "\n%20s ----+    |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 5:
      fprintf(arq, "\n%18sQF        SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----", jogadores[3]);
      fprintf(arq, "\n%20s               | ","");  
      fprintf(arq, "\n%25s ----+    |", jogadores[2]);
      fprintf(arq, "\n%25s     |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 6:
      fprintf(arq, "\n%18sQF        SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[3]);
      fprintf(arq, "\n%20s               |----","");
      fprintf(arq, "\n%20s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[5]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);

      break;
    case 7:
      fprintf(arq, "\n%18sQF        SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[3]);
      fprintf(arq, "\n%20s               |---","");
      fprintf(arq, "\n%20s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[5]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[6]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 8:
      fprintf(arq, "\n%20s   QF   SF    F\n","");
      fprintf(arq, "\n%20s ----+", jogadores[0]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[7]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[3]);
      fprintf(arq, "\n%20s               |----","");
      fprintf(arq, "\n%20s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[5]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[6]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 9:
      //matamata 5
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%25s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+         |----", jogadores[3]);
      fprintf(arq, "\n%25s               |","");
      //matamata 4
      fprintf(arq, "\n%25s ----+         |", jogadores[2]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |", jogadores[5]);
      fprintf(arq, "\n%25s          |----+","");
      fprintf(arq, "\n%25s ----+    |", jogadores[6]);
      fprintf(arq, "\n%25s     |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 10:
      //matamata 5
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%25s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+         |", jogadores[3]);
      fprintf(arq, "\n%25s               |----","");
      //matamata 5
      fprintf(arq, "\n%25s ----+         |", jogadores[2]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |", jogadores[5]);
      fprintf(arq, "\n%25s          |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 11:
      //matamata 5
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%25s ----+    |    |", jogadores[4]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+         |", jogadores[3]);
      fprintf(arq, "\n%25s               |----","");
      //matamata 6
      fprintf(arq, "\n%25s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 12:
      //matamata 6
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%25s ----+         |", jogadores[3]);
      fprintf(arq, "\n%20s                    |-----","");  
      //matamata 6
      fprintf(arq, "\n%25s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 13:
      //matamata 7
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[7]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[8]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |         |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+              |-----", jogadores[3]);
      fprintf(arq, "\n%20s                    |","");  
      //matamata 6
      fprintf(arq, "\n%25s ----+         |", jogadores[2]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 14:
      //matamata 7
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |         |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+              |", jogadores[3]);
      fprintf(arq, "\n%20s                    |-----","");  
      //matamata 7
      fprintf(arq, "\n%20s ----+              |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+    |         |", jogadores[13]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 15:
      //matamata 7
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[7]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |         |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+              |", jogadores[3]);
      fprintf(arq, "\n%20s                    |-----","");  
      //matamata 8
      fprintf(arq, "\n%20s ----+              |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+    |         |", jogadores[13]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[14]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 16:
      //matamata 8
      fprintf(arq, "\n%18sOF        QF   SF    F\n","");
      fprintf(arq, "\n%20s ----+", jogadores[0]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[15]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[7]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |         |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+              |", jogadores[3]);
      fprintf(arq, "\n%20s                    |-----","");  
      //matamata 8
      fprintf(arq, "\n%20s ----+              |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+    |         |", jogadores[13]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |", jogadores[6]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[14]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
    case 18:
      //matamata 9
      fprintf(arq, "\n%22s16F   OF   QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[15]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%25s ----+    |    |", jogadores[8]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+         |----+", jogadores[7]);
      fprintf(arq, "\n%25s               |    |","");
      fprintf(arq, "\n%25s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%25s     |----+    |    |","");
      fprintf(arq, "\n%25s ----+    |    |    |", jogadores[11]);
      fprintf(arq, "\n%25s          |----+    |","");
      fprintf(arq, "\n%25s ----+    |         |", jogadores[12]);
      fprintf(arq, "\n%25s     |----+         |","");
      fprintf(arq, "\n%25s ----+              |", jogadores[3]);
      fprintf(arq, "\n%25s                    |-----","");
      //matamata 9
      fprintf(arq, "\n%25s ----+              |", jogadores[2]);
      fprintf(arq, "\n%25s     |----+         |","");  
      fprintf(arq, "\n%25s ----+    |         |", jogadores[13]);
      fprintf(arq, "\n%25s          |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |    |", jogadores[10]);
      fprintf(arq, "\n%25s     |----+    |    |","");
      fprintf(arq, "\n%25s ----+         |    | ", jogadores[5]);
      fprintf(arq, "\n%25s               |----+","");  
      fprintf(arq, "\n%25s ----+         |", jogadores[6]);
      fprintf(arq, "\n%25s     |----+    |","");
      fprintf(arq, "\n%25s ----+    |    |", jogadores[9]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[14]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 24:
      //matamata 12
      fprintf(arq, "\n%18s16F       OF   QF   SF    F\n","");
      fprintf(arq, "\n%25s ----+", jogadores[0]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |----+", jogadores[15]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[23]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%25s ----+         |", jogadores[7]);
      fprintf(arq, "\n%20s                    |----+","");  
      fprintf(arq, "\n%25s ----+         |    |", jogadores[4]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[20]);
      fprintf(arq, "\n%20s     |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+         |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s               |    |    |","");  
      fprintf(arq, "\n%20s ----+         |----+    |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+    |         |","");
      fprintf(arq, "\n%20s ----+    |    |         |", jogadores[19]);
      fprintf(arq, "\n%20s          |----+         |","");
      fprintf(arq, "\n%25s ----+              |", jogadores[3]);
      fprintf(arq, "\n%20s                         |-----","");
      //matamata 12
      fprintf(arq, "\n%25s ----+              |", jogadores[2]);
      fprintf(arq, "\n%20s          |----+         |","");
      fprintf(arq, "\n%20s ----+    |    |         |", jogadores[18]);
      fprintf(arq, "\n%20s     |----+    |         |","");
      fprintf(arq, "\n%20s ----+         |----+    |", jogadores[13]);
      fprintf(arq, "\n%20s               |    |    |","");  
      fprintf(arq, "\n%20s ----+         |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[21]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%25s ----+         |    |", jogadores[5]);
      fprintf(arq, "\n%20s                    |----+","");  
      fprintf(arq, "\n%25s ----+         |", jogadores[6]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[22]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[9]);
      fprintf(arq, "\n%20s               |    |","");  
      fprintf(arq, "\n%20s ----+         |----+", jogadores[14]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%25s ----+\n", jogadores[1]);
      break;
    case 32:
      //matamata 16
      fprintf(arq, "\n%18s16F       OF   QF   SF    F\n","");
      fprintf(arq, "\n%20s ----+", jogadores[0]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[31]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[16]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+         |", jogadores[15]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |    |", jogadores[8]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[23]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |         |", jogadores[24]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+              |", jogadores[7]);
      fprintf(arq, "\n%20s                    |----+","");  
      fprintf(arq, "\n%20s ----+              |    |", jogadores[4]);
      fprintf(arq, "\n%20s     |----+         |    |","");  
      fprintf(arq, "\n%20s ----+    |         |    |", jogadores[27]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[20]);
      fprintf(arq, "\n%20s     |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+         |    |    |", jogadores[11]);
      fprintf(arq, "\n%20s               |----+    |","");  
      fprintf(arq, "\n%20s ----+         |         |", jogadores[12]);
      fprintf(arq, "\n%20s     |----+    |         |","");
      fprintf(arq, "\n%20s ----+    |    |         |", jogadores[19]);
      fprintf(arq, "\n%20s          |----+         |","");
      fprintf(arq, "\n%20s ----+    |              |", jogadores[28]);
      fprintf(arq, "\n%20s     |----+              |","");
      fprintf(arq, "\n%20s ----+                   |", jogadores[3]);
      fprintf(arq, "\n%20s                         |----+","");
      //matamata 16
      fprintf(arq, "\n%20s ----+                   |", jogadores[2]);
      fprintf(arq, "\n%20s     |----+              |","");
      fprintf(arq, "\n%20s ----+    |              |", jogadores[29]);
      fprintf(arq, "\n%20s          |----+         |","");
      fprintf(arq, "\n%20s ----+    |    |         |", jogadores[18]);
      fprintf(arq, "\n%20s     |----+    |         |","");
      fprintf(arq, "\n%20s ----+         |         |", jogadores[13]);
      fprintf(arq, "\n%20s               |----+    |","");  
      fprintf(arq, "\n%20s ----+         |    |    |", jogadores[10]);
      fprintf(arq, "\n%20s     |----+    |    |    |","");
      fprintf(arq, "\n%20s ----+    |    |    |    |", jogadores[21]);
      fprintf(arq, "\n%20s          |----+    |    |","");
      fprintf(arq, "\n%20s ----+    |         |    |", jogadores[26]);
      fprintf(arq, "\n%20s     |----+         |    |","");  
      fprintf(arq, "\n%20s ----+              |    |", jogadores[5]);
      fprintf(arq, "\n%20s                    |----+","");  
      fprintf(arq, "\n%20s ----+              |", jogadores[6]);
      fprintf(arq, "\n%20s     |----+         |","");  
      fprintf(arq, "\n%20s ----+    |         |", jogadores[25]);
      fprintf(arq, "\n%20s          |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |    |", jogadores[22]);
      fprintf(arq, "\n%20s     |----+    |    |","");
      fprintf(arq, "\n%20s ----+         |    | ", jogadores[9]);
      fprintf(arq, "\n%20s               |----+","");  
      fprintf(arq, "\n%20s ----+         |", jogadores[14]);
      fprintf(arq, "\n%20s     |----+    |","");
      fprintf(arq, "\n%20s ----+    |    |", jogadores[17]);
      fprintf(arq, "\n%20s          |----+","");
      fprintf(arq, "\n%20s ----+    |", jogadores[30]);
      fprintf(arq, "\n%20s     |----+","");
      fprintf(arq, "\n%20s ----+\n", jogadores[1]);
      break;
  }
  fclose(arq);
}
Versão para Windows
Para rodar no sistema operacional Windows o código fonte deve ser compilado neste sistema. Caso prefira, pode solicitar por email o arquivo executável do programa diretamente do desenvolvedor.
Disponível em “http://wiki.foz.ifpr.edu.br/wiki/index.php?title=Programa_Gerador_de_Tabelas_Esportivas&oldid=23564”