Jump to content

Torneios entre equipas


Ana Silva
 Share

Recommended Posts

Ana Silva

Boa Tarde,

Eu tenho de criar um projeto com estruturas de equipas em que cada equipa vai ter um torneio com outra aleatoria e tenho de criar tabelas com as equipas e os resultados eliminando assim equipa a equipa até chegar à vencedora.

Eu para já só criei as estruturas e a inserção de jogadores e tudo mais.

Como acham que posso criar tabelas das equipas aleatorias e os seus respetivos torneios?

O meu codigo é o seguinte:

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

FILE * dados_jogador;
FILE * dados_jogo;
FILE * dados_gerais;
int n_jogos = 0;
int i;
int n_jogadores = 0;

struct dados_jogador
{
  char nome[12];
  int dia;
  int mes;
  int ano;
  float altura;
  float peso;
  int n_jogos;
};
typedef struct dados_jogador jogador;

jogador tabela[12];

jogador ler_jogador()
{
  int i;
  int num;
  jogador jogador;
  printf("Qual o numero de jogadores que deseja adicionar:");
  scanf("%d", &num);
  if(num > 0 && num <= 12){
    for(int i = 0; i < num; i++){
      printf("\nDADOS DO JOGADOR:\n");
      printf("nome:");
      scanf("%s", jogador.nome);
      printf("data de nascimento:");
      scanf("%d/%d/%d", &jogador.dia, &jogador.mes, &jogador.ano);
      if ((jogador.dia >= 01 && jogador.dia <= 30) && (jogador.mes == 04 || jogador.mes == 06 || jogador.mes == 9 || jogador.mes == 11)){
      }
      if (jogador.dia >= 01 && jogador.dia <= 31 && (jogador.mes == 01 || jogador.mes == 03 || jogador.mes == 05 || jogador.mes == 07 || jogador.mes == 8|| jogador.mes == 10 || jogador.mes == 12) && jogador.ano >= 1583){
      }
      if (jogador.dia == 29 && jogador.dia == 2 && (jogador.ano % 400 == 0 || jogador.ano % 4 == 0 && jogador.ano % 100 != 0)){
      }
      if ((jogador.dia >= 01 && jogador.dia <= 28) && (jogador.mes == 2)){
      }
      if (jogador.dia <= 00 || jogador.dia > 31){
        printf("dia invalido\n");
        ler_jogador();
      }
      if (jogador.mes <= 00 || jogador.mes > 12){
        printf("mes invalido\n");
        ler_jogador();
      }
      if (jogador.ano < 1583){
        printf("ano invalido\n");
        ler_jogador();
      }
      printf("altura:");
      scanf("%f", &jogador.altura);
      if(jogador.altura <= 0){
        ler_jogador();
      }
      printf("peso:");
      scanf("%f", &jogador.peso);
      if(jogador.peso <= 0){
        ler_jogador();
      }
      printf("numero de jogos:");
      scanf("%d", &jogador.n_jogos);
      if(jogador.n_jogos < 0){
        ler_jogador();
      }
      dados_jogador = fopen("dados_jogador.txt", "a");
      fprintf(dados_jogador, "\n%s \t\t%02d/%02d/%d\t\t%.2f\t\t%.2f\t\t%d", jogador.nome, jogador.dia, jogador.mes, jogador.ano, jogador.altura, jogador.peso, jogador.n_jogos);
      fclose(dados_jogador);
      dados_gerais = fopen("dados_gerais.dat", "ab");
      fwrite (&jogador.nome, sizeof(struct dados_jogador), 1 , dados_gerais);
      fclose(dados_gerais);
      n_jogadores++;
    }}
    printf("maximo de jogadores:12\n");
  }

  jogador consultar_jogador(){
    jogador jogador;
    int i;
    printf("numero jogadores: %d\n",n_jogadores);
    printf("Jogadores existentes:\n");
    for(i=0; i<n_jogadores; i++){
      printf("%s\n", jogador.nome);
    }
  }

  jogador eliminar_jogador() {
    jogador jogador;
    int i;
    printf("Jogadores existentes: \n");
    dados_jogador = fopen("dados_jogador.txt", "r");
    for(int i = 0; i< n_jogadores; i++){
      fscanf(dados_jogador, "%s", jogador.nome[n_jogadores]);
      fclose(dados_jogador);
    }
  }

  void procurar_jogador(){
    jogador jogador;
    char nome_jogador;
    printf("Qual o nome do jogador que procura:");
    scanf("%s", nome_jogador);
    for(int i = 0; i < n_jogadores; i++){
      if((nome_jogador,jogador.nome) == 0){
        printf("Nome: %s\nData de nascimento: %02d/%02d/%d\nAltura: %.2f\nPeso:%.2f\nNumero de jogos:%d", tabela[i].nome, tabela[i].dia, tabela[i].mes, tabela[i].ano, tabela[i].altura, tabela[i].peso, tabela[i].n_jogos);
      }}
    }
    struct dados_jogo
    {
      int dia;
      int mes;
      int ano;
      char local[50];
      char adversario[50];
      char resultado[50];
    };
    typedef struct dados_jogo jogo;

    jogo ler_jogo()
    {
      jogo jogo;
      printf("\nDADOS DO JOGO:\n");
      printf("data:");
      scanf("%d/%d/%d",&jogo.dia, &jogo.mes, &jogo.ano);
      if ((jogo.dia >= 01 && jogo.dia <= 30) && (jogo.mes == 04 || jogo.mes == 06 || jogo.mes == 9 || jogo.mes == 11)){
      }
      if (jogo.dia >= 01 && jogo.dia <= 31 && (jogo.mes == 01 || jogo.mes == 03 || jogo.mes == 05 || jogo.mes == 07 || jogo.mes == 8|| jogo.mes == 10 || jogo.mes == 12) && jogo.ano >= 1583){
      }
      if (jogo.dia == 29 && jogo.dia == 2 && (jogo.ano % 400 == 0 || jogo.ano % 4 == 0 && jogo.ano % 100 != 0)){
      }
      if ((jogo.dia >= 01 && jogo.dia <= 28) && (jogo.mes == 2)){
      }
      if (jogo.dia <= 00 || jogo.dia > 31){
        printf("dia invalido\n");
        ler_jogo();
      }
      if (jogo.mes <= 00 || jogo.mes > 12){
        printf("mes invalido\n");
        ler_jogo();
      }
      if (jogo.ano < 1583){
        printf("ano invalido\n");
        ler_jogo();
      }
      printf("local:");
      scanf("%s", jogo.local);
      printf("adversario:");
      scanf("%s", jogo.adversario);
      printf("resultado:");
      scanf("%s", jogo.resultado);
      dados_jogo = fopen("dados_jogo.txt", "a");
      fprintf(dados_jogo, "\n%02d/%02d/%d  %s  %s      %s", jogo.dia, jogo.mes, jogo.ano, jogo.local, jogo.adversario, jogo.resultado);
      fclose(dados_jogo);
    }

    int main(int argc, char *argv[])
    {
      jogador jogador[12];
      jogo jogo[100];
      char opcao;

      dados_jogador=fopen("dados_jogador.txt","r");               //para abrir os ficheiros para ler
      i=0;
      while(fscanf(dados_jogador, "%s", jogador[i].nome)!= EOF){
        i++;
        n_jogadores++;
      }
      fclose(dados_jogador);

      do{

        printf("    MENU INICIAL:\n");
        printf("Escolha uma das opcoes:\n");
        printf("1- Inserir jogador     \n");
        printf("2- Editar jogador      \n");
        printf("3- Procurar jogador    \n");
        printf("4- Eliminar jogador    \n");
        printf("5- Inserir jogo        \n");
        printf("6- Contabilizar        \n");
        printf("7- Sair do programa    \n");
        fflush(stdin);
        printf("opcao:");
        scanf("%c", &opcao);
        switch(opcao){
          case '1': ler_jogador(); break;            //escolha das opcoes e suas funcoes
          case '2': consultar_jogador(); break;
          case '3': procurar_jogador(); break;
          case '4': eliminar_jogador(); break;
          case '5': ler_jogo(); break;
          case '6': break;
          case '7': return 0;
          default: printf("Opcao invalida\n");break;
        }
      }
      while (opcao != '7');
      return 0;
    }

 

Edited by Ana Silva
Link to comment
Share on other sites

maluco-123

Viva,

Problema interessante,

Aqui, focando mais na parte do torneio por eliminatória, podes ver como uma árvore binária, onde a raíz (primeiro nível) é o jogo da final, o segundo nível as semi-finais, etc...

Onde cada nó poderia representar um jogo ou a equipa vencedora desse jogo.

Fiz isto como exemplo, usa memória dinâmica e recursividade. Nota que tens outras formas de implementar árvores binárias

https://gist.github.com/Wiguwbe/ca1dfe6ed3512fe48b484f24c1608331

Link to comment
Share on other sites

Ana Silva

Obrigada pela ajuda, porem existe uma forma mais facil de fazer atraves de listas ligadas?

É que eu não entendo muito bem de recursividade e achei o código bem confuso.

 

Link to comment
Share on other sites

maluco-123

Viva,

Se calhar por listas ligadas é capaz de ser ainda mais fácil,

Aí cada item na lista poderia representar uma equipa e cada par na lista um jogo (lista[0] e lista[1] seria um jogo, lista[2] e lista[3] outro).

Para jogar (simular) o torneio, a ideia seria iterar a lista, indo a cada par e remover a equipa que perdia. O torneio acaba quando já só houver uma equipa na lista.

 

Se quiseres como exemplo https://gist.github.com/Wiguwbe/935e0fb3723c9100cdbf81ec44d1a299

Edited by maluco-123
exemplo
Link to comment
Share on other sites

Ana Silva

Sim, penso que será mais facil irei tentar fazer dessa maneira e qualquer duvida que tenha ponho aqui.

Mais uma vez, muito obrigada pela ajuda.

Link to comment
Share on other sites

Ana Silva

Já atualizei o código e notei que eu quero que o utilizador escolha os valores dos golos e não que seja aleatoriamente como posso fazer isso?

O meu codigo está assim neste momento:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define NUM_EQUIPAS 8
#define L_ALLOC (struct jogo*)malloc(sizeof(struct jogo))

int n_jogadores = 0;
int n_jogos = 0;

struct equipas {
	char *nome;
};
typedef struct equipas equipa;

struct jogo {
	equipa *equipa;
	struct jogo *next;
};

static int escolhido = 0;
static equipa equipas[] = {
	{"Equipa A"},
	{"Equipa B"},
	{"Equipa C"},
	{"Equipa D"},
	{"Equipa E"},
	{"Equipa F"},
	{"Equipa G"},
	{"Equipa H"}
};

struct jogo * sorteio(void)
{
	// gera 8 items na lista com as equipas
	struct jogo *head = L_ALLOC;
	struct jogo *atual = head;
	struct jogo *bak;
	if(head==NULL) {
		fprintf(stderr, "memoria ultrapassada\n");
		exit(1);
	}

	srand(time(NULL));


  	int escolha, bit, teste;
  	for(int i=0; i < NUM_EQUIPAS; i++) {
  		while(1) {
  			escolha = rand() % 8;
  			bit = 1 << escolha;
  			teste = escolhido ^ bit;
  			if(teste > escolhido) {
  				escolhido = teste;
  				break;
  			}
  		}
  		atual->equipa = equipas + escolha;
  		atual->next = L_ALLOC;
  		if(atual->next == NULL) {
  			fprintf(stderr, "memoria rebentada\n");
  			exit(1);
  		}
  		bak = atual;
  		atual = atual->next;
  	}

    // remover ultima
    free(atual);
    bak->next = NULL;

    return head;
    }

    static void _pl(struct jogo *l) {
    	// for debug, print list
    	struct jogo *p = l;
    	printf("---\n");
    	while(p) {
    		printf("%p (%p), %s\n ", p, p->next, p->equipa->nome);
    		p = p->next;
    	}
    }

    equipa * jogar_torneio(struct jogo *torneio)
    {
    	struct jogo *a, *b;
    	int cestos_a, cestos_b;
    	int ronda = 0;

    	// enquanto houver um `next`, a lista tem mais do que 1 equipa
    	while(torneio->next != NULL) {
    		//_pl(torneio);

    		// primeira equipa
    		a = torneio;

    		while(a != NULL) {
    			// equipa a seguir (par)
    			b = a->next;
    			do {
    				cestos_a = rand() % 4;
    				cestos_b = rand() % 4;
    			} while(cestos_a == cestos_b);

    			// imprime o jogo
    			for(int i=0;i<ronda;i++) {
    				putchar('\t');
    			}
    			printf("%s %d - %d %s\n",a->equipa->nome,cestos_a,cestos_b,b->equipa->nome);

    			// remove-se sempre o `b`, para facilitar a vida
    			// mantém-se o vencedor no `a`

    			if(cestos_b > cestos_a) {
    				// troca os lados
    				a->equipa = b->equipa;
    			}
    			a->next = b->next;
    			free(b);

    			// proxima iteracao, com o `b` já removido, o "salto" é só de 1 (next)
    			a = a->next;
    		}

    		ronda++;
    	}

    	return torneio->equipa;
    }

struct dados_jogador{
  char nome[10];
  char equipa[1];
  int dia;
  int mes;
  int ano;
  float altura;
  float peso;
  int numJogos;
};
typedef struct dados_jogador jogador;

struct dados_jogo{
  char equipa[1];
  int pontos;
  int dia;
  int mes;
  int ano;
  int horas;
  int minutos;
  char resultado[3];
};
typedef struct dados_jogo jogo;

void ler_jogador(jogador lista_jogadores[])
{
  FILE *dados_jogador;
  dados_jogador=fopen("dados_jogador.txt","r");               //para abrir os ficheiros para ler
	int i=0;
	while(fscanf(dados_jogador, "%s", &lista_jogadores[i].nome)!= EOF){
		n_jogadores++;
		i++;
	}
	fclose(dados_jogador);
  printf("n: %d\n",n_jogadores);
  if(n_jogadores < 20){
      printf("\nDADOS DO JOGADOR:\n");
      printf("nome:");
      scanf("%s", lista_jogadores[n_jogadores].nome);
      printf("equipa:");
      scanf("%s", lista_jogadores[n_jogadores].equipa);
      printf("data de nascimento:");
      scanf("%d/%d/%d", &lista_jogadores[n_jogadores].dia, &lista_jogadores[n_jogadores].mes, &lista_jogadores[n_jogadores].ano);
      if ((lista_jogadores[n_jogadores].dia >= 01 && lista_jogadores[n_jogadores].dia <= 30) && (lista_jogadores[n_jogadores].mes == 04 || lista_jogadores[n_jogadores].mes == 06 || lista_jogadores[n_jogadores].mes == 9 || lista_jogadores[n_jogadores].mes == 11)){
      }
      if (lista_jogadores[n_jogadores].dia >= 01 && lista_jogadores[n_jogadores].dia <= 31 && (lista_jogadores[n_jogadores].mes == 01 || lista_jogadores[n_jogadores].mes == 03 || lista_jogadores[n_jogadores].mes == 05 || lista_jogadores[n_jogadores].mes == 07 || lista_jogadores[n_jogadores].mes == 8|| lista_jogadores[n_jogadores].mes == 10 || lista_jogadores[n_jogadores].mes == 12) && lista_jogadores[n_jogadores].ano >= 1583){
      }
      if (lista_jogadores[n_jogadores].dia == 29 && lista_jogadores[n_jogadores].dia == 2 && (lista_jogadores[n_jogadores].ano % 400 == 0 || lista_jogadores[n_jogadores].ano % 4 == 0 && lista_jogadores[n_jogadores].ano % 100 != 0)){
      }
      if ((lista_jogadores[n_jogadores].dia >= 01 && lista_jogadores[n_jogadores].dia <= 28) && (lista_jogadores[n_jogadores].mes == 2)){
      }
      if (lista_jogadores[n_jogadores].dia <= 00 || lista_jogadores[n_jogadores].dia > 31){
        printf("dia invalido\n");
        ler_jogador(lista_jogadores);
      }
      if (lista_jogadores[n_jogadores].mes <= 00 || lista_jogadores[n_jogadores].mes > 12){
        printf("mes invalido\n");
        ler_jogador(lista_jogadores);
      }
      if (lista_jogadores[n_jogadores].ano < 1583){
        printf("ano invalido\n");
        ler_jogador(lista_jogadores);
      }
      printf("altura:");
      scanf("%f", &lista_jogadores[n_jogadores].altura);
      if(lista_jogadores[n_jogadores].altura <= 0){
        ler_jogador(lista_jogadores);
      }
      printf("peso:");
      scanf("%f", &lista_jogadores[n_jogadores].peso);
      if(lista_jogadores[n_jogadores].peso <= 0){
        ler_jogador(lista_jogadores);
      }
      printf("numero de jogos:");
      scanf("%d", &lista_jogadores[n_jogadores].numJogos);
      if(lista_jogadores[n_jogadores].numJogos < 0){
        ler_jogador(lista_jogadores);
      }
      for(int i=0;i<=n_jogadores;i++){
      FILE *dados_jogador;
      dados_jogador = fopen("dados_jogador.txt", "a");
      fprintf(dados_jogador, "\n%s \t\t%s\t\t%02d/%02d/%d\t\t%.2f\t\t%.2f\t\t%d", lista_jogadores[i].nome, lista_jogadores[i].equipa, lista_jogadores[i].dia, lista_jogadores[i].mes, lista_jogadores[i].ano, lista_jogadores[i].altura, lista_jogadores[i].peso, lista_jogadores[i].numJogos);
      fclose(dados_jogador);
    }
      FILE *dados_gerais;
      dados_gerais = fopen("dados_gerais.txt", "ab");
      fwrite (&lista_jogadores[n_jogadores].nome, sizeof(struct dados_jogador), 1 , dados_gerais);
      fclose(dados_gerais);
      n_jogadores++;
      printf("numero de jogadores: %d\n",n_jogadores);
    if(n_jogadores > 12){
    printf("maximo de jogadores atingido:12\n");
  }
}
}

/*  void escreve_jogadores(jogador lista_jogadores[]){

    for(int i=0;i < n_jogadores ;i++) {
      printf("\nDADOS DO JOGADOR:\n");
      printf("nome: %s\n", lista_jogadores[i].nome);
      printf("equipa: %s\n", lista_jogadores[i].equipa);
      printf("data de nascimento: %d/%d/%d\n", lista_jogadores[i].dia, lista_jogadores[i].mes, lista_jogadores[i].ano);
      printf("altura: %.f\n",lista_jogadores[i].altura);
      printf("peso: %.f\n",lista_jogadores[i].peso);
      printf("numero de jogos: %d\n",lista_jogadores[i].numJogos);
    }
  }
*/
int main(int argc, char *argv[])
{
struct jogo *torneio = sorteio();
equipa *vencedora = jogar_torneio(torneio);
jogador equipas[8];
jogador lista_jogadores[12];
jogo jogos[7];
char opcao;
do{

  printf("    MENU INICIAL:\n");
  printf("Escolha uma das opcoes:\n");
  printf("1- Inserir jogador     \n");
  printf("2- Editar jogador      \n");
  printf("3- Procurar jogador    \n");
  printf("4- Eliminar jogador    \n");
  printf("5- Torneio             \n");
  printf("6- Contabilizar        \n");
  printf("7- Sair do programa    \n");
  fflush(stdin);
  printf("opcao:");
  scanf("%c", &opcao);
  switch(opcao){
    case '1': ler_jogador(lista_jogadores); break;            //escolha das opcoes e suas funcoes
    case '2': //escreve_jogadores(lista_jogadores); break;
    case '3': break;
    case '4': break;
    case '5': printf("vencedora: %s\n", vencedora->nome); break;
    case '6': break;
    case '7': return 0;
    default: printf("Opcao invalida\n");break;
}
}
while (opcao != '7');
return 0;
}

 

Link to comment
Share on other sites

maluco-123

Viva, peço desculpa não tenho estado atento aqui ao fórum,

Para ser o utilizador a decidir os cestos, naquele do...while dentro do jogar_torneio, em vez de atribuires o rand()%4 ao cestos_a e cestos_b, pedes ao utilizador um valor

Sugeria uma função separada para pedir os valores dos cestos, individualmente para cada lado ou para o jogo em si

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.