Programa Gerador de Tabelas Esportivas
De Wiki Cursos IFPR Foz
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 MataMata.c Copa.c
Para gerar o programa executável, os arquivos fonte devem ser compilados com o comando:
gcc GeradorTabelas.c MataMata.c Copa.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
//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')
{
if (resposta == '2')
g = 2;
if (resposta == '3')
g = 3;
if (resposta == '4')
g = 4;
if ((g == 2 && n >= 6) || (g == 3 && n >= 9) || (g == 4 && n >= 12))
//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 == '4')
g = 4;
if (resposta == '5')
g = 5;
if (resposta == '6')
g = 6;
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 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>
void imprimeF (int p, char jogador[20]);
void imprimeSF (int f, int sf, char jogador[20]);
void imprimeQF (int f, int sf, int qf, char jogador[20]);
void imprimeOF (int f, int sf, int qf, int of, char jogador[20]);
void matamata2 (int n, char jogadores[32][20]);
//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%39sF\n","");
fclose(arq);
imprimeF(0, jogadores[0]);
imprimeF(1, jogadores[1]);
break;
case 3:
fprintf(arq, "\n%33sSF F\n","");
fclose(arq);
imprimeF(0, jogadores[0]);
imprimeSF(1, 0, jogadores[2]);
imprimeSF(1, 1, jogadores[1]);
break;
case 4:
fprintf(arq, "\n%33sSF F\n","");
fclose(arq);
imprimeSF(0, 0, jogadores[0]);
imprimeSF(0, 1, jogadores[3]);
imprimeSF(1, 0, jogadores[2]);
imprimeSF(1, 1, jogadores[1]);
break;
case 5:
fprintf(arq, "\n%28sQF SF F\n","");
fclose(arq);
imprimeSF(0, 0, jogadores[0]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeSF(1, 0, jogadores[2]);
imprimeSF(1, 1, jogadores[1]);
break;
case 6:
fprintf(arq, "\n%28sQF SF F\n","");
fclose(arq);
imprimeSF(0, 0, jogadores[0]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeQF(1, 0, 1, jogadores[5]);
imprimeSF(1, 1, jogadores[1]);
break;
case 7:
fprintf(arq, "\n%28sQF SF F\n","");
fclose(arq);
imprimeSF(0, 0, jogadores[0]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeQF(1, 0, 1, jogadores[5]);
imprimeQF(1, 1, 0, jogadores[6]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 8:
fprintf(arq, "\n%28sQF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeQF(0, 0, 1, jogadores[7]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeQF(1, 0, 1, jogadores[5]);
imprimeQF(1, 1, 0, jogadores[6]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 9:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeQF(1, 0, 1, jogadores[5]);
imprimeQF(1, 1, 0, jogadores[6]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 10:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeQF(1, 0, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 11:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeQF(0, 1, 0, jogadores[4]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 12:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeOF(0, 1, 0, 0, jogadores[4]);
imprimeOF(0, 1, 0, 1, jogadores[11]);
imprimeQF(0, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 13:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeOF(0, 1, 0, 0, jogadores[4]);
imprimeOF(0, 1, 0, 1, jogadores[11]);
imprimeOF(0, 1, 1, 0, jogadores[12]);
imprimeOF(0, 1, 1, 1, jogadores[3]);
imprimeQF(1, 0, 0, jogadores[2]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 14:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeOF(0, 1, 0, 0, jogadores[4]);
imprimeOF(0, 1, 0, 1, jogadores[11]);
imprimeOF(0, 1, 1, 0, jogadores[12]);
imprimeOF(0, 1, 1, 1, jogadores[3]);
imprimeOF(1, 0, 0, 0, jogadores[2]);
imprimeOF(1, 0, 0, 1, jogadores[13]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 15:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeOF(0, 1, 0, 0, jogadores[4]);
imprimeOF(0, 1, 0, 1, jogadores[11]);
imprimeOF(0, 1, 1, 0, jogadores[12]);
imprimeOF(0, 1, 1, 1, jogadores[3]);
imprimeOF(1, 0, 0, 0, jogadores[2]);
imprimeOF(1, 0, 0, 1, jogadores[13]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeOF(1, 1, 1, 0, jogadores[14]);
imprimeOF(1, 1, 1, 1, jogadores[1]);
break;
case 16:
fprintf(arq, "\n%23sOF QF SF F\n","");
fclose(arq);
imprimeOF(0, 0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 0, 1, jogadores[15]);
imprimeOF(0, 0, 1, 0, jogadores[8]);
imprimeOF(0, 0, 1, 1, jogadores[7]);
imprimeOF(0, 1, 0, 0, jogadores[4]);
imprimeOF(0, 1, 0, 1, jogadores[11]);
imprimeOF(0, 1, 1, 0, jogadores[12]);
imprimeOF(0, 1, 1, 1, jogadores[3]);
imprimeOF(1, 0, 0, 0, jogadores[2]);
imprimeOF(1, 0, 0, 1, jogadores[13]);
imprimeOF(1, 0, 1, 0, jogadores[10]);
imprimeOF(1, 0, 1, 1, jogadores[5]);
imprimeOF(1, 1, 0, 0, jogadores[6]);
imprimeOF(1, 1, 0, 1, jogadores[9]);
imprimeOF(1, 1, 1, 0, jogadores[14]);
imprimeOF(1, 1, 1, 1, jogadores[1]);
break;
case 24:
//Eliminatória 12
fprintf(arq, "\n%23s16F OF QF SF\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 1, 0, jogadores[16]);
imprimeOF(0, 0, 1, 1, jogadores[15]);
imprimeOF(0, 1, 0, 0, jogadores[8]);
imprimeOF(0, 1, 0, 1, jogadores[23]);
imprimeQF(0, 1, 1, jogadores[7]);
imprimeQF(1, 0, 0, jogadores[4]);
imprimeOF(1, 0, 1, 0, jogadores[20]);
imprimeOF(1, 0, 1, 1, jogadores[11]);
imprimeOF(1, 1, 0, 0, jogadores[12]);
imprimeOF(1, 1, 0, 1, jogadores[19]);
imprimeQF(1, 1, 1, jogadores[3]);
//Eliminatória 12
fprintf(arq, "\n\n\n%23s16F OF QF SF\n","");
fclose(arq);
imprimeQF(0, 0, 0, jogadores[2]);
imprimeOF(0, 0, 1, 0, jogadores[18]);
imprimeOF(0, 0, 1, 1, jogadores[13]);
imprimeOF(0, 1, 0, 0, jogadores[10]);
imprimeOF(0, 1, 0, 1, jogadores[21]);
imprimeQF(0, 1, 1, jogadores[5]);
imprimeQF(1, 0, 0, jogadores[6]);
imprimeOF(1, 0, 1, 0, jogadores[22]);
imprimeOF(1, 0, 1, 1, jogadores[9]);
imprimeOF(1, 1, 0, 0, jogadores[14]);
imprimeOF(1, 1, 0, 1, jogadores[17]);
imprimeQF(1, 1, 1, jogadores[1]);
break;
case 32:
//Eliminatória 16
fprintf(arq, "\n\n\n%23s16F OF QF SF\n","");
fclose(arq);
imprimeOF(0, 0, 0, 0, jogadores[0]);
imprimeOF(0, 0, 0, 1, jogadores[31]);
imprimeOF(0, 0, 1, 0, jogadores[16]);
imprimeOF(0, 0, 1, 1, jogadores[15]);
imprimeOF(0, 1, 0, 0, jogadores[8]);
imprimeOF(0, 1, 0, 1, jogadores[23]);
imprimeOF(0, 1, 1, 0, jogadores[24]);
imprimeOF(0, 1, 1, 1, jogadores[7]);
imprimeOF(1, 0, 0, 0, jogadores[4]);
imprimeOF(1, 0, 0, 1, jogadores[27]);
imprimeOF(1, 0, 1, 0, jogadores[20]);
imprimeOF(1, 0, 1, 1, jogadores[11]);
imprimeOF(1, 1, 0, 0, jogadores[12]);
imprimeOF(1, 1, 0, 1, jogadores[19]);
imprimeOF(1, 1, 1, 0, jogadores[28]);
imprimeOF(1, 1, 1, 1, jogadores[3]);
//Eliminatória 16
fprintf(arq, "\n\n\n%23s16F OF QF SF\n","");
fclose(arq);
imprimeOF(0, 0, 0, 0, jogadores[2]);
imprimeOF(0, 0, 0, 1, jogadores[29]);
imprimeOF(0, 0, 1, 0, jogadores[18]);
imprimeOF(0, 0, 1, 1, jogadores[13]);
imprimeOF(0, 1, 0, 0, jogadores[10]);
imprimeOF(0, 1, 0, 1, jogadores[21]);
imprimeOF(0, 1, 1, 0, jogadores[26]);
imprimeOF(0, 1, 1, 1, jogadores[5]);
imprimeOF(1, 0, 0, 0, jogadores[6]);
imprimeOF(1, 0, 0, 1, jogadores[25]);
imprimeOF(1, 0, 1, 0, jogadores[22]);
imprimeOF(1, 0, 1, 1, jogadores[9]);
imprimeOF(1, 1, 0, 0, jogadores[14]);
imprimeOF(1, 1, 0, 1, jogadores[17]);
imprimeOF(1, 1, 1, 0, jogadores[30]);
imprimeOF(1, 1, 1, 1, jogadores[1]);
break;
}
}
void imprimeF (int f, char jogador[20])
{
char tabela[] = "Tabelas.txt";
FILE *arq;
arq = fopen(tabela, "a");
fprintf(arq, "\n%40s --+", jogador); //Jogador
if (f == 0)
fprintf(arq, "\n%40s |----+",""); //Ligação meio tabela
fclose(arq);
}
void imprimeSF (int f, int sf, char jogador[20])
{
char tabela[] = "Tabelas.txt";
FILE *arq;
arq = fopen(tabela, "a");
if (f == 1 && sf == 1)
fprintf(arq, "\n%35s |----+",""); //Ligação adversário
fprintf(arq, "\n%35s --+", jogador); //Jogador
if ((f == 0 && sf == 1) || (f == 1 && sf == 0))
fprintf(arq, " |"); //Completa final
if (f == 0 && sf == 0)
fprintf(arq, "\n%35s |----+",""); //Ligação adversário
if (f == 0 && sf == 1)
fprintf(arq, "\n%40s |----+",""); //Ligação meio tabela
fclose(arq);
}
void imprimeQF (int f, int sf, int qf, char jogador[20])
{
char tabela[] = "Tabelas.txt";
FILE *arq;
arq = fopen(tabela, "a");
if (f == 1 && sf == 1 && qf == 0)
fprintf(arq, "\n%35s |----+",""); //Ligação meio da semifinal
fprintf(arq, "\n%30s --+", jogador); //Jogador
if ((f == 0 && sf == 0 && qf == 1) || (f == 1 && sf == 1 && qf == 0))
fprintf(arq, " |"); //Completa semifinal
if ((f == 0 && sf == 1 && qf == 0) || (f == 1 && sf == 0 && qf == 1))
fprintf(arq, " | |"); //Completa semifinal e final
if ((f == 0 && sf == 1 && qf == 1) || (f == 1 && sf == 0 && qf == 0))
fprintf(arq, " |"); //Completa final
if (qf == 0) {
fprintf(arq, "\n%30s |----+",""); //Ligação adversário
if ((f == 0 && sf == 1) || (f == 1 && sf == 0))
fprintf(arq, " |");} //Completa final
if (f == 0 && sf == 0 && qf == 1)
fprintf(arq, "\n%35s |----+",""); //Ligação meio semifinal
if (f == 0 && sf == 1 && qf == 1)
fprintf(arq, "\n%40s |----+",""); //Ligação meio tabela
fclose(arq);
}
void imprimeOF (int f, int sf, int qf, int of, char jogador[20])
{
char tabela[] = "Tabelas.txt";
FILE *arq;
arq = fopen(tabela, "a");
if (f == 1 && sf == 1 && qf == 0 && of == 0)
fprintf(arq, "\n%35s |----+",""); //Ligação meio semifinal
fprintf(arq, "\n%25s --+", jogador); //Jogador
if ((f == 0 && sf == 0 && qf == 0 && of == 1) || (f == 1 && sf == 1 && qf == 1 && of == 0))
fprintf(arq, " |"); //Completa quartafinal
if ((f == 0 && sf == 0 && qf == 1 && of == 0) || (f == 1 && sf == 1 && qf == 0 && of == 1))
fprintf(arq, " | |"); //Completa quarta e semifinal
if ((f == 0 && sf == 0 && qf == 1 && of == 1) || (f == 1 && sf == 1 && qf == 0 && of == 0))
fprintf(arq, " |"); //Completa semifinal
if ((f == 0 && sf == 1 && qf == 0 && of == 0) || (f == 1 && sf == 0 && qf == 1 && of == 1))
fprintf(arq, " | |"); //Completa semi e final
if ((f == 0 && sf == 1 && qf == 0 && of == 1) || (f == 1 && sf == 0 && qf == 1 && of == 0))
fprintf(arq, " | | |"); //Completa quarta, semi e final
if ((f == 0 && sf == 1 && qf == 1 && of == 0) || (f == 1 && sf == 0 && qf == 0 && of == 1))
fprintf(arq, " | |"); //Completa quarta e final
if ((f == 0 && sf == 1 && qf == 1 && of == 1) || (f == 1 && sf == 0 && qf == 0 && of == 0))
fprintf(arq, " |"); //Completa final
if (of == 0) {
fprintf(arq, "\n%25s |----+",""); //Ligação adversário
if ((f == 0 && sf == 0 && qf == 1) || (f == 1 && sf == 1 && qf == 0))
fprintf(arq, " |"); //Completa semifinal
if ((f == 0 && sf == 1 && qf == 0) || (f == 1 && sf == 0 && qf == 1))
fprintf(arq, " | |"); //Completa semi e final
if ((f == 0 && sf == 1 && qf == 1) || (f == 1 && sf == 0 && qf == 0))
fprintf(arq, " |");} //Completa final
if (f == 0 && sf == 0 && qf == 1 && of == 1)
fprintf(arq, "\n%35s |----+",""); //Ligação meio semifinal
if ((f == 1 && sf == 1 && qf == 0 && of == 1) || (f == 0 && sf == 0 && qf == 0 && of == 1))
fprintf(arq, "\n%30s |----+",""); //Ligação meio quartafinal
if ((f == 0 && sf == 1 && qf == 0 && of == 1) || (f == 1 && sf == 0 && qf == 0 && of == 1))
fprintf(arq, "\n%30s |----+ |",""); //Ligação meio quartafinal e completa final
if (f == 0 && sf == 1 && qf == 1 && of == 1)
fprintf(arq, "\n%40s |----+",""); //Ligação meio tabela
fclose(arq);
}
//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 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 final5g[][20] = {
"1o Grupo A ________", "1o Grupo B ________", "1o Grupo C ________",
"1o Grupo D ________", "1o Grupo E ________",
"2o Grupo E ________", "2o Grupo A ________", "2o Grupo B ________",
"2o Grupo C ________", "2o Grupo D ________"};
char final6g[][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 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:
matamata(g * nc, final5g);
break;
case 6:
matamata(g * nc, final6g);
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;
}
}
