Pergunte ao Mago #357

Existem permut(9,3)*permut(6,3)*permut(3,3)/fact(3) = 60.480 permutações possíveis para analisar e encontrar a resposta. Devo admitir que tentei por pelo menos uma hora, por tentativa e erro, e não encontrei uma solução.

Então, escrevi um programa para percorrer todas as 362.880 maneiras possíveis de ordenar os nove dígitos e testei todas elas. A parte complicada foi percorrer todas as formas possíveis de ordenar os nove números. Veja como fazer isso, usando ordenação lexicográfica.

1. Coloque todos os nove elementos em uma matriz, organizados do menor para o maior.
2. Encontre o último elemento da matriz que seja maior que o elemento seguinte. Se nenhum for encontrado, encerre o programa.
3. Começando pelo elemento seguinte ao da etapa 2, encontre o último elemento na matriz que seja maior que o da etapa 2.
4. Troque os elementos da matriz das etapas 2 e 3.
5. Inverta a ordem dos elementos na matriz, começando pelo elemento seguinte ao da etapa 2 e seguindo até o final.
6. Voltar para a etapa 2

Seguindo esse processo, você encontrará a resposta correta seis vezes, uma vez para cada uma das seis maneiras de ordenar as três frações.

[spoiler=Código]

Escrevi o seguinte código para ordenar cada dígito de 1 a 9 em ordem lexicográfica e testar se cada um era uma solução.

vazio três_frações(vazio)
{
 int i, x_max, y_max, temp_array[100], hold, pt;
 int lex_array[] = { 1,2,3,4,5,6,7,8,9 };
 int num_elements = sizeof(lex_array) / sizeof(lex_array[0]);
 int contagem = 0;
 bool stop = falso;
 total duplo 3;
 cerr << "Número de elementos =\t" << num_elements << "\n";
 fazer
 {
  contar++;
  tot3 = (double)lex_array[0] / (double)(10 * lex_array[1] + lex_array[2]);
  tot3 += (double)lex_array[3] / (double)(10 * lex_array[4] + lex_array[5]);
  tot3 += (double)lex_array[6] / (double)(10 * lex_array[7] + lex_array[8]); 
  se (tot3 == 1.0)
  {
   cerr << count << "\t";
   cerr << lex_array[0] << "/" << lex_array[1] << lex_array[2] << " + ";
   cerr << lex_array[3] << "/" << lex_array[4] << lex_array[5] << " + ";
   cerr << lex_array[6] << "/" << lex_array[7] << lex_array[8] << "\n";
  } 
  x_max = -1;
  para (i = 0; i < (num_elementos - 1); i++)
  {
   se (lex_array[i] < lex_array[i + 1])
    x_max = i;
  }
  se (x_max >= 0)
  {
   y_max = 0;
   para (i = x_max + 1; i < num_elementos; i++)
   {
    se (lex_array[x_max] < lex_array[i])
     y_max = i;
   }
   hold = lex_array[x_max];
   lex_array[x_max] = lex_array[y_max];
   lex_array[y_max] = hold;
   se (x_max + 1 < num_elementos - 1) // inverter
   {
    para (i = x_max + 1; i < num_elementos; i++)
    {
     temp_array[i] = lex_array[i];
    }
    pt = 0;
    para (i = x_max + 1; i < num_elementos; i++)
    {
     lex_array[i] = temp_array[num_elements - 1 - pt];
     pt++;
    }
   }
  }
  outro
   parar = verdadeiro;
 } enquanto (parar == falso);
}

Seja j = volume da jarra.

Após o primeiro enchimento do jarro, restaram 10-j galões de vinho no jarro. Depois que a água substituiu o vinho, a proporção de vinho para todo o barril foi (10-j)/10.

Após a jarra retirar o vinho diluído, restaram 10 galões de vinho diluído no barril. A quantidade de vinho puro no vinho diluído pode ser expressa como:

(10-j)*((10-j)/10) = 5

(10-j)^2 = 50

j² - 20j + 100 = 50

j² - 20j + 50 = 0

j = (20 +/- sqrt(400-200))/2

j = (20 +/- 10*sqrt(2))/2

j = 10 +/- 5*sqrt(2)

O jarro não pode ser maior que o barril, portanto devemos usar o sinal negativo:

j = 10 - 5*sqrt(2) =~ aproximadamente 2,92893218813452 galões.

Para isso, precisei usar uma Cadeia de Markov. A tabela a seguir mostra a probabilidade de cada total final de acordo com a soma acumulada na coluna da esquerda. Comece com os casos óbvios para totais de 13 a 18. Em seguida, para somas acumuladas de 0 a 12, calcule a média das seis células abaixo.

As probabilidades para o estado inicial podem ser encontradas na primeira linha para uma soma de 0.