O primeiro for precisa fazer isso aqui:
array[0] = 1;
array[1] = 1;
array[2] = 1;
array[3] = 2;
array[4] = 2;
array[5] = 2;
array[6] = 3;
array[7] = 3;
array[8] = 3;
array[9] = 4;
array[10] = 4;
array[11] = 4;
Esse seria o array perfeito caso ao invés de sorteio você criasse os números em ordem, certo?
Veja que c é a variável que conta de 1 em 1, para cada número percorrido, e que vai ser o índice do array.
“i” é o número do jogador, ou seja, é o dado que está sendo atribuído do lado direito. j é usado apenas para repetir o valor de i em 3 posições diferentes.
Sobre a segunda parte do algoritmo. Você não conhece o algoritmo para trocar duas variáveis de valor? Costuma um dos primeiros exercícios que fazemos em programação com variáveis.
int a = 10;
int b = 20;
Como trocar o valor de a e b? Usa-se uma variável temporária:
//Guarda o valor de "a" em "temp"
int temp = a;
//Agora que o valor de "a" está guardando em temp, podemos altera-lo
a = b;
//Agora que o valor de "b" já está em a, guardamos em "b" o
// valor antigo de "a" que foi guardado em temp
b = temp;
Veja o código sem os comentários:
int temp = a; //temp recebe 10
a = b; //"a" recebe 20
b = temp; //"b" recebe o valor de temp, que é o antigo de "a", ou seja, 10
E compare com o código que postei:
int temp = array[j];
array[j] = array[i];
array[i] = temp; [/code]
O que esse código faz? Troca de lugar os valores que estão na posição i e j do array. Por exemplo, no array declarado ali em cima. Se i estiver em 0, e j for sorteado para 9 o que ele vai fazer?
[code]int temp = array[0]; //Temp recebe 1
array[0] = array[9]; //array[0] recebe 4
array[9] = temp; //array[9] recebe 1.[/code]
Portanto, o array agora está assim:
[code]array = {4,1,1,2,2,2,3,3,3,1,4,4};[/code]
Como já mexemos em array[0], vamos agora sortear quem irá trocar com array[1]. Vamos supor que se sorteie o número 5:
[code]int temp = array[1]; //temp recebe 1
int array[1] = array[5]; //array[1] recebe 2
int array[5] = temp; //arrat[5] recebe 1
E o array de jogadores agora está assim:
array = {4,2,1,2,1,2,3,3,3,1,4,4};
E o código prossegue para a posição 2 do array… e depois para a 3… e assim sucessivamente. Até ter certeza que cada casa foi sorteada pelo menos 1 vez.
Observe que como estamos só trocando os números de posição, e não sorteando os seus valores, é impossível que esse algoritmo gere mais (ou menos) do que 3 números por jogador. Por isso a analogia que se faz para esse tipo de algoritmo é como lidar com um baralho de cartas. Na primeira parte, colocamos em ordem todas as “cartas” (jogadores) que tem no nosso baralho (array). Igualzinho quando queremos conferir se o baralho que temos em casa está com todas as cartas certas. Nós organizamos o baralho por naipe e número. Em ordem mesmo, numa boa.
Na segunda parte, estamos misturando tudo, “embaralhando”. Só mexendo na ordem, sem adicionar novas cartas, e nem retirar cartas. Assim, garantimos exatamente o que você quer: exatamente 3 números por jogador, sem nada a mais, e nada a menos.
Entendeu?
