Foi um trabalho escolar que realizei há algum tempo. Partilho para quem pretender praticar criando algo semelhante.

Objetivo:
- Definir o número de atletas e juízes que participarão no evento;
- Inserir a pontuação de cada juiz para cada atleta;
- Mostrar a nota média por aletas;
- Mostrar os atletas que têm a nota mais alta e a mais baixa;
- No total, qual a porcentagem de notas máximas (9);
- Para cada um dos atletas, mostrar o número do juiz que lhe atribuiu a melhor nota. No caso da nota mais alta de determinado atleta ser 6, por exemplo, e se essa foi dada por mais de um juiz, mostrar o número desses juízes;
- Mostrar todos os atletas e as suas pontuações.

Exemplo descritivo (com repetição do objectivo acima):

Haverá um concurso de patinagem artística onde participarão 5 concorrentes. Esses concorrentes serão avaliados por 3 juízes e a apresentação será única e sequencial. Quero um programa que me auxilie no registo das avaliações. Para isso terá de recolher o nome do atleta e a avaliação dos juízes, que também é dada em sequência.

No final quero poder consultar a nota média de cada atleta, ver quais foram as notas mais altas e as mais baixas, bem como os atletas correspondentes; Mostrar a porcentagem de notas máximas; Quais foram os juízes que atribuíram as melhores notas para cada um dos atletas. Por fim, quero ver a listagem completa, ou seja, todos os atletas e as suas pontuações. Ah! Eu pretendo utilizar essa aplicação para o mesmo evento nos anos seguintes e o número de atletas/juízes pode variar.

Não investi tempo em filtrar o que o utilizador introduz. Você poderá fazer isso para que o seu código fique completo. Por isso ao executá-lo, quando pedir um número, introduza um número e quando pedir um nome, introduza apenas letras sem caracteres especiais (inclui acentos, espaços e "ç").

Terminando este desafio eu acredito que você terá a base sólida a nível básico da linguagem e o raciocínio lógico necessário para aplicações mais avançadas.

Partilho também Workflow que certamente ajudará o pessoal a compreender todo o pensamento lógico por detrás do código.

Workflow de cada função disponível no meu flickr: https://www.flickr.com/gp/133659721@N04/P73i52

Altere o código, faça da sua maneira o que é pedido, acrescente novas funções e partilhe o código nos comentários.

Espero ter ajudado,
Lucas
tainanreis@yahoo.com

• Download 1-4.cpp
• Enviar nova versão

Esconder código-fonte

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

#define MAX 100

typedef struct {
   char nome_atleta[60];
}dados;

/*============================================*/
/*Função número dos juízes que atribuíram a melhor nota ao atleta*/
void juizes_melhor_nota_atleta(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados dados[]){
   int i_atletas, i_juizes;
   int pontuacao_mais_alta=0, numero_juiz=0;

   printf("\nNumero dos juizes que atribuiram a melhor nota dos atletas:");
   for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
      printf("\nNome: %s\n", dados[i_atletas].nome_atleta);
      for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
         if(pontuacao[i_atletas][i_juizes]>pontuacao_mais_alta){
            pontuacao_mais_alta=pontuacao[i_atletas][i_juizes];
         }
      }
      for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
         if(pontuacao[i_atletas][i_juizes]==pontuacao_mais_alta){
            printf("Juiz %d: %d\n", i_juizes+1, pontuacao[i_atletas][i_juizes]);
         }
      }
      pontuacao_mais_alta=0;
   }
   system("pause");
}
/*============================================*/
/*Função percentagem de pontuação maior ou igual a 8*/
void percentagem_maior_8(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados dados[]){
    int i_atletas, i_juizes;
    int total_notas=n_max_juizes*n_max_atletas, igual_superior_8=0;

    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
        for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
            if(pontuacao[i_atletas][i_juizes]>=8){
                igual_superior_8++;
            }
        }
    }
    printf("Percentagem: %.2f%%\n",((float)igual_superior_8/total_notas)*100);
    system("pause");
}
/*============================================*/
/*Função pior e melhor pontuação*/
void pior_melhor_pontuacao(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados dados[]){
    int i_atletas, i_juizes, i=0;
    int pontuacao_min=pontuacao[0][0], pontuacao_max=pontuacao[0][0];
    int quantos_melhores=0, quantos_piores=0;
    int posicao_melhor[n_max_atletas], posicao_pior[n_max_atletas];
    int ja_incluido;

    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
        for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
            if(pontuacao[i_atletas][i_juizes]<pontuacao_min){
                pontuacao_min=pontuacao[i_atletas][i_juizes];
            }
            if(pontuacao[i_atletas][i_juizes]>pontuacao_max){
                pontuacao_max=pontuacao[i_atletas][i_juizes];
             }
      }
    }
    
    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
        ja_incluido=0;
        for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
            if(pontuacao[i_atletas][i_juizes]==pontuacao_min){
                if(ja_incluido==0){
               posicao_pior[quantos_piores]=i_atletas;
                    quantos_piores=quantos_piores+1;
                    ja_incluido=1;
                }
            }
      }
    }
    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
        ja_incluido=0;
        for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
            if(pontuacao[i_atletas][i_juizes]==pontuacao_max){
                if(ja_incluido==0){
               posicao_melhor[quantos_melhores]=i_atletas;
                   quantos_melhores=quantos_melhores+1;
                   ja_incluido=1;
                }
            }
      }
    }  
    printf("\nAtletas com a pior pontuacao (%d):\n", pontuacao_min);
    for(i=0;i<quantos_piores;i++){
        printf("Nome: %s\n", dados[posicao_pior[i]].nome_atleta);
    }
    printf("\nAtletas com a melhor pontuacao (%d):\n", pontuacao_max);
    for(i=0;i<quantos_melhores;i++){
        printf("Nome: %s\n", dados[posicao_melhor[i]].nome_atleta);
    }

   system("pause");
}
/*============================================*/
/*Função nota média por atleta*/
void nota_media_atleta(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados dados[]){
    int i_atletas, i_juizes, media;

    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
        media=0;
      printf("\n\nNome do atleta: %s\n", dados[i_atletas].nome_atleta);
      for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
            media=media+pontuacao[i_atletas][i_juizes];
      }
        printf("Media: %.2f\n", ((float)media) /n_max_juizes);
   }
    system("pause");
}

/*============================================*/
/*Função ver todos*/
void teste_ver_todos(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados dados[]){
    int i_atletas, i_juizes;

    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
      printf("\n\nNome do atleta: %s", dados[i_atletas].nome_atleta);
      for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
         printf("\nNota do juiz [%d]: %d", i_juizes+1, pontuacao[i_atletas][i_juizes]);
      }
   }
    printf("\n");
    system("pause");
}

/*============================================*/
/*Função Inserir*/
void inserir(int n_max_atletas, int n_max_juizes, int pontuacao[][MAX], dados inserir[]){
   int i_atletas, i_juizes;
   int valor_inserido;

    for(i_atletas=0; i_atletas<n_max_atletas; i_atletas++){
      printf("\nNome do atleta: \n> ");
      scanf("%s", inserir[i_atletas].nome_atleta);
      for(i_juizes=0; i_juizes<n_max_juizes; i_juizes++){
         
         printf("\nNota do juiz [%d]: ", i_juizes+1);
         scanf("%d", &valor_inserido);
         if(valor_inserido>=0 && valor_inserido<=9){
            pontuacao[i_atletas][i_juizes]=valor_inserido;
         }else{
            printf("\n\nIntroduza um valor entre 0 e 9!\n\n");
            i_juizes--;
         }
      }
   }
}


/*============================================*/
/*Função principal*/
main(){
   int n_max_atletas, n_max_juizes, opcao_menu=0, pontuacao[MAX][MAX];
   dados dados[MAX];
   printf("Insira o numero de atletas:\n> ");
   scanf("%d", &n_max_atletas);
   printf("Insira o numero de juizes:\n> ");
   scanf("%d", &n_max_juizes);

   while(opcao_menu!=7){
      system("cls");
      printf(   
            "Escola uma opcao:\n"
            "1\t-\tInserir\n"
            "2\t-\tNota media por atleta\n"
            "3\t-\tPior e melhor pontuacao\n"
            "4\t-\tPercentagem de pontuacoes iguais ou superiores a 8\n"
            "5\t-\tNumero dos juizes que atribuiram melhor nota por atleta\n"
            "6\t-\tMostrar todos os atletas e pontos\n\n"
            "7\t-\tSair\n>"
      );
      scanf("%d", &opcao_menu);

      switch(opcao_menu){
         case 1:
            inserir(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 2:
            nota_media_atleta(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 3:
            pior_melhor_pontuacao(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 4:
            percentagem_maior_8(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 5:
            juizes_melhor_nota_atleta(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 6:
            teste_ver_todos(n_max_atletas, n_max_juizes, pontuacao, dados);
         break;
         case 7:
            exit(0);
         break;
         default:
            printf("\nEscolheu uma opcao nao valida!");
            system("PAUSE");
      }
   }
}

Conversor de escalas

Gauss Seidel

Sequência de Fibonacci

Convolução 1D

Função split em C

Nenhum comentário foi encontrado.