Torneios entre equipas

Ana Silva · June 22, 2021 at 01:11 PM

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;
    }

maluco-123 · June 23, 2021 at 06:20 PM

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

Ana Silva · June 23, 2021 at 11:39 PM

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.

maluco-123 · June 24, 2021 at 06:16 AM

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 June 24, 2021 at 09:40 AM by maluco-123
exemplo

Ana Silva · June 24, 2021 at 02:07 PM

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.

Ana Silva · June 28, 2021 at 07:42 PM

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;
}

maluco-123 · July 1, 2021 at 07:48 PM

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

Ana Silva · July 3, 2021 at 03:52 PM

Obrigada por tudo na mesma.

Já consegui finalizar o projeto

Sign In

Torneios entre equipas

Recommended Posts

Ana Silva

Link to comment

Share on other sites

maluco-123

Link to comment

Share on other sites

Ana Silva

Link to comment

Share on other sites

maluco-123

Link to comment

Share on other sites

Ana Silva

Link to comment

Share on other sites

Ana Silva

Link to comment

Share on other sites

maluco-123

Link to comment

Share on other sites

Ana Silva

Link to comment

Share on other sites

Create an account or sign in to comment

Create an account

Sign in

Home

Activity

Revista PROGRAMAR

Important Information