TRABALHO DE PROG - EXERCÍCIO 1

Program Educacao_Fisica;
Type
Taluno = Record
nome: string;
habil: integer;
end;
Var n, t, i, k, nivelador, local: integer;
media: array[1..4] of real;
tamanhotime: array [1..4] of integer;
dados, ordem: array[1..20] of Taluno;
time: array[1..4,1..20] of Taluno;

Begin
{Coleta de dados}
write ('Informe a quantidade de alunos [máximo 20]: ');
readln (n);
write ('Informe a quantidade de times [máximo 4]: ');
readln (t);
writeln ('');
for i := 1 to n do
Begin
write ('Informe o nome do ', i, 'º aluno: ');
readln (dados[i].nome);
write ('Informe a habilidade do ', i, 'º aluno [de 1 a
100]: ');
readln (dados[i].habil);
writeln ('');
end;
// Aqui, a variável "n" coleta a quantidade de alunos, "t" coleta a
quantidade de times e os vetores de "dados" coletam as informações
como nome e habilidade (1 - 100). Esses dados permanecerão durante
todo o programa.

{Ordenação dos nomes por habilidade}

for i := 1 to n do
Begin
nivelador := -2;
local := 0;
for k := 1 to n do
Begin
if (dados[k].habil > nivelador) then
 Begin
nivelador := dados[k].habil;
local := k;
end;
if (k = n) then
Begin
dados[local].habil := -1;
end;
end;
ordem[i].habil := nivelador;
ordem[i].nome := dados[local].nome;
end;
// Nesta etapa, um nivelador vai auxiliar a ordenação dos dados. No
começo do primeiro laço, ele é definido como "-2" para poder ser
diferenciado dos dados contidos dentro do vetor (valor estipulado
por ser menor que 0). Um valor também é adotado para a variável
"local" que, por definir a posição do elemento do vetor nesse
processo, começa em 0.
// No laço interno, quando o valor de habilidade é maior que o
nivelador, no caso -2 (qualquer valor de habilidade), ele é
armazenado como o novo nivelador e a posição que ele se encontra
dentro do vetor é armazenada em "local". A partir disso, o laço
continua rodando e definindo sempre qual é o maior valor do vetor em
relação ao elemento anterior (novo nivelador). Quando o laço chega
ao fim, ele já coletou o maior valor e, para não conflitar com as
próximas coletas de maiores valores, ele transforma o maior valor em
"-1", ou seja, esse valor não fará mais parte da próxima análise do
segundo maior valor e assim por diante.
// Por fim, no final do laço interno ele armazena o maior valor de
habilidade e seu respectivo nome em um novo vetor "ordem" de acordo
com a variável "local". E recomeça o ciclo para encontrar todos os
outros maiores valores na sequência.

{Distribuição dos times por inserção na matriz principal}

nivelador := 0;
for i := 1 to n do
Begin
for k := 1 to t do
Begin
nivelador := nivelador + 1;
time[k,i].nome := ordem[nivelador].nome;
time[k,i].habil := ordem[nivelador].habil;
end;
end;
// Aqui iremos definir os time. Para isso, usaremos uma matriz 4x20
onde as colunas representam os 4 times possíveis e as linhas
representam o máximo de alunos a ser armazenados em um time.
// Os laços distribuem da seguinte maneira: os alunos com maiores
valores de habilidade são distribuídos na primeira linha, ou seja,
um em cada time dependendo do valor de "t". Em seguida, o laço
interno finaliza e o segundo laço distribui os novos maiores valores
de habilidade na segunda linha e assim por diante.
// Isso é possível pois há um nivelador que aumenta 1 unidade a cada
novo ciclo do laço interno, fazendo com que sejam armazendas a
primeira habilidade maior na primeira casa da matriz, a segunda
maior habilidade na segunda casa da matriz e assim por diante.

{Cálculo do tamanho do time}

for i := 1 to t do
Begin
tamanhotime[i] := 0;
for k := 1 to n do
Begin
if (time[i,k].habil <> 0) then
Begin
tamanhotime[i] := tamanhotime[i] + 1;
end;
end;
end;
// Após definidos os times, utilizaremos desta etapa para calcular o
tamanho deles.
// Aqui, todas as casas diferentes de zero (dados não preenchidos)
são ignoradas e ele só realiza uma operação simples de soma com as
células da coluna (time) que foram devidamente preenchidas.

{Cálculo da média}
for i := 1 to t do
Begin
media[i] := 0;
for k := 1 to n do
Begin
if (time[i,k].habil <> 0) then
Begin
media[i] := media[i] + time[i,k].habil;
end;
end;
media[i] := media[i] / tamanhotime[i];
end;
// Para calcularmos a média de habilidades de um time, nós,
primeiramente, definimos ela como 0 para depois ir acrescentando os
valores de habilidades de acordo com a coluna da matriz.
// No final do laço mais externo, a variável "media" divide todas as
somas que foram calculadas na coluna pelo tamanho do time
anteriormente calculado, para depois voltar ao começo do laço e
prosseguir calculando a média da próxima coluna (próximo time).

{Saída dos dados}

for i := 1 to t do
Begin
writeln ('Time ', i, ' [Habilidade Média: ', media[i]:0:2,
']');
for k := 1 to n do
Begin
if (time[i,k].habil <> 0) then
Begin
writeln (time[i,k].nome);
end;
end;
writeln (' ');
end;
// Para encerrar, dois laços de repetição são utilizados para
apresentar o resultado da distribuição dos times.
// Existe uma condicional para que os valores da matriz que
correspondem à 0 não sejam apresentados.
end.