Um probleminha de Lógica: criando um sistema de números aleatórios que se autocorrige

Num exercício de treino em programação, decidi programar um pequeno jogo da memória. Eu queria que ele tivesse quatro posições — ‘A’, ‘B’, ‘C’, ‘D’ — e que, por detrás delas, existissem dois pares de números. A posição ‘A’ poderia conter o número 2, a ‘B’ poderia conter o número 1, ‘C’ seria outro 2 e a ‘D’ outro 1, por exemplo. Foi algo bem simples, mas que envolveu algum raciocínio para resolver duas dificuldades.

A primeira era que eu desejava que esses pares de números fossem gerados aleatoriamente, ou seja, que eu mesmo não soubesse qual número estaria em cada posição.

Para tanto, fui pesquisar como o C# (a linguagem que estudo) produzia números aleatórios e acabei encontrando uma função que produzia números dentro de um intervalo o qual eu designasse. Ela poderia gerar um número aleatório entre 53 e 150, entre 10.000 e 1000.000 ou qualquer outra coisa assim. Usei essa função e fiz com que cada posição recebesse um número aleatório entre 1 e 2.

Dificuldade vencida. Ou quase.

A dificuldade seguinte surgiu de imediato. Se as posições seriam ocupadas aleatoriamente, um mesmo número não poderia se repetir mais do que duas vezes. É simples: o programa poderia fazer com que um número ocupasse três ou até quatro posições, o que impediria o surgimento de pares. Num jogo da memória com quatro posições, só duas podem ter os mesmos números, certo?

Bem, mas como resolver isso? Passei uma noite pensando na solução que vou explicar aqui, mas acho que outras seriam possíveis e eu adoraria ouvir sugestões.

A solução

1. Criei duas variáveis (espaço na memória que recebem um valor): uma para o número 1 e outra para o número 2.

2. Programei meu código de maneira que, sempre que um número aleatório fosse produzido, a variável ligada a ele receberia o valor +1. Logo, se o número 1 fosse gerado duas vezes, a variável teria o valor de +2, se fosse gerado quatro vezes, a variável teria o valor de +4 e tal. O mesmo ocorreria com o numero 2.

3. Feito isso, fiz com que a produção de números aleatórios fosse refeita (o dito “laço de repetição”) sempre que uma das duas variáveis contivesse o valor +3 ou +4.

O raciocínio foi o seguinte: sempre que um número fosse gerado e atribuído a uma das posições ‘A’, ‘B’, ‘C’ ou ‘D’, uma variável receberia o valor +1. Portanto, se esse número fosse produzido uma vez, a variável receberia +1, se fosse atribuído duas, receberia +2 e assim por diante. Contudo, se um número fosse atribuído três ou quatro vezes, o processo seria refeito… E quando isso teria fim? Simples: quando cada número fosse atribuído apenas duas vezes.

Inclusive, o mesmo raciocínio também impediria que um número fosse atribuído a uma única posição, afinal, para tanto, seria preciso que outro número fosse atribuído a três posições, o que reiniciaria o processo.

Como disse, essa foi a solução que pensei e acho que outras seriam possíveis. Além disso, se o jogo fosse maior, eu precisaria refinar mais esse raciocínio. Por ora, contudo, ele me gerou um bom aprendizado e aquela boa sensação de “puzzle resolvido”.