O Jogo do 24
Digressões com o Maple

Delfim F. M. Torres
delfim@mat.ua.pt

Março de 2004

Departamento de Matemática
Universidade de Aveiro
3810-193 Aveiro, Portugal
http://www.mat.ua.pt/delfim

Na sua versão mais simples são dados quatro números inteiros de um a nove. A tarefa consiste em formar uma expressão matemática, com valor 24, usando os quatro números dados uma e uma só vez e qualquer conjunto de operadores aritméticos +, -, *, / (e possivelmente parênteses). Por exemplo, dados os números 1, 3, 4 e 8 são possíveis quatro expressões não equivalentes com resultado 24. Se introduzirmos a notação x1=1, x2=3, x3=4, x4=8, as 4 expressões-solução são:

• x4+x3*(x1+x2) = 8+4*(1+3)
• x4/(x3/x2 - x1) = 8/(4/3 - 1)
• x3*(x1+x4-x2) = 4*(1+8-3)
• (x3+x4)*(x2-x1) = (4+8)*(3-1)

Claro que o número de soluções não varia se trocarmos a ordem com que indicamos os números: o jogo [1,3,4,8] é precisamente o mesmo que o jogo [8,4,3,1] ou qualquer uma das suas permutações!

O Maple faz parte de uma família de ambientes científicos apelidados de "Sistemas de Computação Algébrica" ( Computer Algebra Systems nos países anglo-saxónicos). Trata-se de uma ferramenta matemática muito poderosa, que permite realizar uma miríade de cálculos simbólicos e numéricos. É o laboratório de "Matemática Experimental" que tenho adoptado na disciplina de Computadores no Ensino da Matemática da licenciatura em Ensino de Matemática da Universidade de Aveiro. Depois de se iniciar uma sessão Maple, o sistema oferece-nos uma "linha de comandos":

>

O Maple encontra-se então à espera de ordens... Seguem-se algumas das minhas experiências.

Começamos por relembrar um resultado básico de combinatória.

Teorema. Se admitirmos elementos repetidos, há ${n+m-1\choose n}$ combinações de n elementos escolhidos de um conjunto de cardinalidade m.

Por exemplo, se considerarmos o conjunto dos números inteiros de um a três (m = 3), existem 15 combinações diferentes de quatro números (n = 4).

> with(combinat):

> t := (n,m) -> binomial(n+m-1,n):

> t(4,3);

É fácil, usando o Maple, enumerar todas as combinações possíveis mencionadas no Teorema. Vamos definir em Maple a função P(n,m) que, dado n e m, devolve todas as possíveis combinações.

> L := (n,m) -> [seq(op(j),j=seq([seq(i,k=1..n)],i=1..m))]:

> L(4,3);

> P := (n,m) -> choose(L(n,m),n):

> P(4,3);

> nops(P(4,3));

Com as nossas definições, é agora muito fácil gerar as 495 diferentes combinações de quatro números (n=4) de um a nove (m=9):

> t(4,9);

> P(4,9);

> nops(P(4,9));

Para obtermos todas as soluções possíveis para todas as possíveis configurações do Jogo 24 vamos formar, para cada uma das 495 combinações acima, todas as possíveis expressões aritméticas.

> tira := proc(T,L)

> local t, i, R:

> R := L:

> for t in T do

> for i to nops(R) while R[i] <> t do od:

> if i <= nops(R) then

> R := subsop(i=NULL,R)

> fi:

> od:

> return(R);

> end proc:

> tira([1,2,2],[1,2,1,2,3,1]);

> tira([3],[1,2]);

> f2 := proc(LN,LO)

> local i, j, L, o1, o2, t, z1, z2:

> L := NULL:

> for i in LO do

> for j in choose(LN,2) do

> z1 := false:

> z2 := false:

> if i <> `/` or not(simplify(j[2] = 0)) then

> o1 := simplify(apply(i,j[1],j[2])):

> else

> z1 := true:

> fi:

> if i <> `/` or not(simplify(j[1] = 0)) then

> o2 := simplify(apply(i,j[2],j[1])):

> else

> z2 := true:

> fi:

> t := tira(j,LN):

> if (z2 and not(z1)) or (simplify(o1 = o2)) then

> L := L, [[o1],t]:

> elif not(z1) and not(z2) and not(simplify(o1 = o2)) then

> L := L, [[o1],t], [[o2],t]:

> elif not(z2) then

> L := L, [[o2],t]:

> fi:

> end do:

> end do:

> return([L]);

> end proc:

> f2([x1,x2],[`+`,`-`,`*`,`/`]);

> f2([x1,x2,x3],[`+`,`-`,`*`,`/`]);

> f2([x3+x4,x1+x2],[`+`,`-`,`*`,`/`]);

> todos := proc(LP,LO)

> local i, R:

> if LP[1][2] = [] then

> R := {seq(op(LP[i][1]),i=1..nops(LP))};

> else

> R := [];

> for i in LP do

> R := [op(R),op(f2([op(i[1]),op(i[2])],LO))];

> od:

> R := todos(R,LO);

> fi:

> return(R);

> end proc:

> all := (LN,LO) -> todos(f2(LN,LO),LO):

> all([x1,x2],[`+`,`-`,`*`,`/`]);

Com 4 incógnitas existem 1170 expressões matemáticas não equivalentes (é possível formar mais expressões matemáticas com os operadores aritméticos +, -, *, /, mas essas expressões são equivalentes a umas destas 1170):

> nops(all([x1,x2,x3,x4],[`+`,`-`,`*`,`/`]));

Claro que se algumas das incógnitas forem iguais, o número de expressões matemáticas não equivalentes diminui. Se duas das incógnitas forem iguais são possíveis 609:

> nops(all([x1,x1,x2,x3],[`+`,`-`,`*`,`/`]));

Para certos valores concretos de x1 algumas das 609 possibilidades resultam equivalentes, e o número total de possibilidades diminui, enquanto para outros não:

> nops(all([1,1,x2,x3],[`+`,`-`,`*`,`/`]));

> nops(all([2,2,x2,x3],[`+`,`-`,`*`,`/`]));

> nops(all([3,3,x2,x3],[`+`,`-`,`*`,`/`]));

Já vimos que é possível obter 24 a partir de [1, 3, 4, 8]. Podemos facilmente verificar este facto:

> member(24,all([1,3,4,8],[`+`,`-`,`*`,`/`]));

A nossa função all permite-nos muito mais. Podemos obter respostas a perguntas como:

(i) Quais os inteiros positivos possíveis de serem obtidos a partir dos números 1,3,4 e 8 por intermédio das operações aritméticas +, -, * e / ?

> select(i->type(i,posint),all([1,3,4,8],[`+`,`-`,`*`,`/`]));

(ii) Quais os inteiros não positivos possíveis de serem obtidos a partir dos números 1,3,4 e 8 por intermédio das operações aritméticas +, -, * e / ?

> select(i->type(i,nonposint),all([1,3,4,8],[`+`,`-`,`*`,`/`]));

(iii) Quantos racionais positivos não inteiros, diferentes, são possíveis de serem obtidos a partir dos números 1,3,4 e 8 por intermédio das operações aritméticas

+, -, * e / ?

> nops(select(i->type(i,fraction) and i > 0,all([1,3,4,8],[`+`,`-`,`*`,`/`])));

(iv) Quantos racionais negativos não inteiros, diferentes, são possíveis de serem obtidos a partir dos números 1,3,4 e 8 por intermédio das operações aritméticas +, -, * e / ?

> nops(select(i->type(i,fraction) and i < 0,all([1,3,4,8],[`+`,`-`,`*`,`/`])));

Ao todo é possível obterem-se 427

> 62+47+198+120;

valores diferentes a partir do quaterno [1,3,4,8] por intermédio das operações aritméticas +, -, * e /:

> numValores := L -> nops(all(L,[`+`,`-`,`*`,`/`])):

> numValores([1,3,4,8]);

Vamos definir uma função NumVal que nos permite associar a cada uma das diferentes combinações, o número de valores distintos possíveis de serem alcançados por intermédio das operações aritméticas +, -, * e /.

Antes disso introduzimos uma notação mais compacta para as combinações do Jogo 24.

> num := L -> add(j,j=seq(L[i]*10^(nops(L)-i),i=1..nops(L))):

> num([1,2,3]);

> lista := n -> [seq(iquo(irem(n,10^(length(n)-i+1)),10^(length(n)-i)),i=1..length(n))]:

> lista(123);

> ordena := LL -> [seq(lista(j),j=sort([seq(num(i),i=LL)]))]:

> ordena(P(4,3));

> NumVal := LL -> [seq([num(q),numValores(q)],q=ordena(LL))]:

> NV15 := NumVal(P(4,3));

Olhando para o resultado anterior, concluímos que de entre todas as 15 combinações diferentes de quatro números de um a três, a que conduz a um menor número de valores possíveis de serem obtidos é a combinação [1,1,1,1] (11 valores possíveis de serem obtidos por intermédio das operações +, -, *, e /); enquanto a combinação que conduz ao maior número de possibilidades é a [1,2,3,3] (139 valores possíveis). Vamos definir em Maple as funções
minimo e maximo que nos permitem determinar estas combinações (a mais estéril e a mais fecunda) no caso geral.

> minMax := proc(f,LNV)

> local i,m,R:

> m := apply(f,seq(i[2],i=LNV));

> R := NULL:

> for i in LNV do

> if i[2] = m then

> R := R,i:

> fi:

> od:

> return(R):

> end proc:

> minimo := L -> minMax(min,L):

> maximo := L -> minMax(max,L):

Como já sabemos, a combinação de quatro números de 1 a 3 que conduz a um menor número de valores possíveis é a combinação [1,1,1,1]: apenas é possível, por intermédio das quatro operações aritméticas +, -, * e / obter 11 valores diferentes:

> minimo(NV15);

Os valores possíveis de serem obtidos são:

> all(lista(1111),[`+`,`-`,`*`,`/`]);

Em particular não é possível jogar o Jogo do 24 com a configuração [1,1,1,1].

A combinação de quatro números de 1 a 3 que conduz a um maior número de valores possíveis é, como vimos, a combinação [1,2,3,3]: é possível, por intermédio das quatro operações aritméticas +, -, * e /, obter 139 valores diferentes:

> maximo(NV15);

Dos 139 valores possíveis, apenas 40 são inteiros (um dos inteiros possíveis é o 24):

> select(i->type(i,integer),all(lista(1233),[`+`,`-`,`*`,`/`]));

Vamos agora considerar todas as 495 combinações de quatro números de 1 a 9.

Nota: tempo de cálculo de aproximadamente 5 minutos...

> t := time(): NV495 := NumVal(P(4,9)); printf("%f segundos",time()-t);

290.168000 segundos

> t := time(): 100!;

0.000000 segundos

> minimo(NV495);

A combinação que conduz a mais possibilidades é a [5,6,8,9]

> maximo(NV495);

Dos 922 valores possíveis de serem obtidos a partir da combinação [5,6,8,9], 212 são inteiros:

> nops(select(i->type(i,integer),all(lista(5689),[`+`,`-`,`*`,`/`])));

Um deles é o 24:

> member(24,all(lista(5689),[`+`,`-`,`*`,`/`]));

Já a partir da combinação [1,1,1,1], como vimos, não é possível obter 24.

> member(24,all(lista(1111),[`+`,`-`,`*`,`/`]));

Vamos agora tentar dar resposta à seguinte questão:

Para quais das 495 combinações de quatro números de um a nove é realmente possível obter 24?

Melhor ainda: quais as combinações de quatro números de um a nove para as quais não é possível obter v ?
O seguinte procedimento permite-nos obter as respostas desejadas.

> falham := proc(v)

> local L495,q,R:

> L495 := ordena(P(4,9)):

> R := NULL:

> for q in L495 do

> if not(member(v,all(q,[`+`,`-`,`*`,`/`]))) then

> printf("%a\n",q):

> R := R,q:

> fi:

> od:

> return(seq(num(q),q=[R])):

> end proc:

Descobrimos que o Jogo 24 admite solução para 404 dos 495 possíveis quaternos. Os 91 quaternos que não admitem solução são (logo à cabeça aparece a caso [1,1,1,1] que já conhecíamos):

> F24 := falham(24);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 4]

[1, 1, 1, 5]

[1, 1, 1, 6]

[1, 1, 1, 7]

[1, 1, 1, 9]

[1, 1, 2, 2]

[1, 1, 2, 3]

[1, 1, 2, 4]

[1, 1, 2, 5]

[1, 1, 3, 3]

[1, 1, 5, 9]

[1, 1, 6, 7]

[1, 1, 7, 7]

[1, 1, 7, 8]

[1, 1, 7, 9]

[1, 1, 8, 9]

[1, 1, 9, 9]

[1, 2, 2, 2]

[1, 2, 2, 3]

[1, 2, 9, 9]

[1, 3, 5, 5]

[1, 4, 9, 9]

[1, 5, 5, 7]

[1, 5, 5, 8]

[1, 5, 7, 7]

[1, 6, 6, 7]

[1, 6, 7, 7]

[1, 6, 7, 8]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 8, 9, 9]

[1, 9, 9, 9]

[2, 2, 2, 2]

[2, 2, 2, 6]

[2, 2, 7, 9]

[2, 2, 9, 9]

[2, 3, 3, 4]

[2, 5, 5, 5]

[2, 5, 5, 6]

[2, 5, 9, 9]

[2, 6, 7, 7]

[2, 7, 7, 7]

[2, 7, 7, 9]

[2, 7, 9, 9]

[2, 9, 9, 9]

[3, 3, 5, 8]

[3, 4, 6, 7]

[3, 4, 8, 8]

[3, 5, 5, 5]

[3, 5, 7, 7]

[4, 4, 5, 9]

[4, 4, 6, 6]

[4, 4, 6, 7]

[4, 4, 9, 9]

[4, 7, 7, 9]

[4, 9, 9, 9]

[5, 5, 5, 7]

[5, 5, 5, 8]

[5, 5, 6, 9]

[5, 5, 7, 9]

[5, 7, 7, 7]

[5, 7, 7, 8]

[5, 7, 9, 9]

[5, 8, 9, 9]

[5, 9, 9, 9]

[6, 6, 6, 7]

[6, 6, 7, 7]

[6, 6, 7, 8]

[6, 6, 9, 9]

[6, 7, 7, 7]

[6, 7, 7, 8]

[6, 7, 7, 9]

[6, 7, 8, 8]

[6, 9, 9, 9]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 7, 9]

[7, 7, 8, 8]

[7, 7, 8, 9]

[7, 7, 9, 9]

[7, 8, 8, 8]

[7, 8, 9, 9]

[7, 9, 9, 9]

[8, 8, 8, 8]

[8, 8, 8, 9]

[8, 8, 9, 9]

[8, 9, 9, 9]

[9, 9, 9, 9]

> nops([F24]);

Das 91 configurações para as quais não existe solução para o Jogo 24, apenas duas possuem os quatro algarismos diferentes:

> select(i->nops({op(lista(i))})=4,[F24]);

Vamos guardar, de modo ordenado, numa lista de nome PC , todas as 404 Possíveis Configurações para o Jogo do 24.

> PC := [seq(lista(j),j=sort(tira([F24],[seq(num(i),i=P(4,9))])))];

> nops(PC);

A função tau(n) , disponível em Maple no package de teoria de números numtheory , devolve o número de divisores positivos de n.

> with(numtheory):

> tau(24);

Se quisermos saber quais são os 8 divisores positivos de 24, podemos recorrer à função Maple divisors .

> divisors(24);

O número 24 não foi escolhido, com toda a certeza, ao acaso por Robert Sun. Existirão outras possibilidades interessantes? O número 24 é o menor inteiro positivo no intervalo [1,35] a ter o maior número de divisores.

> seq(tau(i),i=1..36);

A quantidade de divisores não é, no entanto, o único ingrediente a ter em conta. O menor inteiro positivo, de entre todos os inteiros positivos com menos de 3 dígitos, com o maior número de divisores positivos é o 60 (tem 12 divisores positivos):

> LD := seq(tau(i),i=1..99):

> max(LD);

> member(12,[LD],'p'):

> p;

No entanto para o "Jogo do 60" existem muito menos configurações admissíveis do que para o Jogo do 24: o número de configurações admissíveis é de
495 - 219 = 276, contra as 404 possíveis no Jogo 24.

> F60 := falham(60):

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 4]

[1, 1, 1, 5]

[1, 1, 1, 6]

[1, 1, 1, 7]

[1, 1, 1, 8]

[1, 1, 1, 9]

[1, 1, 2, 2]

[1, 1, 2, 3]

[1, 1, 2, 4]

[1, 1, 2, 5]

[1, 1, 2, 6]

[1, 1, 2, 7]

[1, 1, 2, 8]

[1, 1, 2, 9]

[1, 1, 3, 3]

[1, 1, 3, 4]

[1, 1, 3, 5]

[1, 1, 3, 6]

[1, 1, 3, 7]

[1, 1, 3, 8]

[1, 1, 3, 9]

[1, 1, 4, 4]

[1, 1, 4, 5]

[1, 1, 4, 6]

[1, 1, 4, 7]

[1, 1, 4, 8]

[1, 1, 4, 9]

[1, 1, 5, 5]

[1, 1, 5, 7]

[1, 1, 5, 8]

[1, 1, 6, 6]

[1, 1, 6, 7]

[1, 1, 7, 7]

[1, 1, 7, 8]

[1, 1, 8, 8]

[1, 1, 8, 9]

[1, 1, 9, 9]

[1, 2, 2, 2]

[1, 2, 2, 3]

[1, 2, 2, 4]

[1, 2, 2, 5]

[1, 2, 2, 6]

[1, 2, 2, 7]

[1, 2, 2, 8]

[1, 2, 2, 9]

[1, 2, 3, 3]

[1, 2, 3, 4]

[1, 2, 3, 5]

[1, 2, 3, 6]

[1, 2, 3, 7]

[1, 2, 3, 8]

[1, 2, 4, 4]

[1, 2, 7, 7]

[1, 2, 9, 9]

[1, 3, 3, 3]

[1, 3, 3, 4]

[1, 3, 3, 8]

[1, 3, 4, 7]

[1, 3, 4, 8]

[1, 4, 4, 6]

[1, 4, 4, 7]

[1, 4, 4, 9]

[1, 4, 5, 5]

[1, 4, 9, 9]

[1, 5, 5, 9]

[1, 5, 6, 8]

[1, 5, 7, 7]

[1, 5, 7, 9]

[1, 5, 8, 9]

[1, 5, 9, 9]

[1, 6, 6, 7]

[1, 6, 7, 7]

[1, 6, 7, 8]

[1, 6, 8, 8]

[1, 6, 8, 9]

[1, 6, 9, 9]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 7, 7, 9]

[1, 7, 8, 8]

[1, 7, 8, 9]

[1, 7, 9, 9]

[1, 8, 8, 8]

[1, 8, 8, 9]

[1, 8, 9, 9]

[1, 9, 9, 9]

[2, 2, 2, 2]

[2, 2, 2, 3]

[2, 2, 2, 4]

[2, 2, 2, 5]

[2, 2, 2, 6]

[2, 2, 2, 7]

[2, 2, 2, 8]

[2, 2, 2, 9]

[2, 2, 3, 3]

[2, 2, 3, 4]

[2, 2, 3, 7]

[2, 2, 4, 4]

[2, 2, 4, 9]

[2, 2, 5, 6]

[2, 2, 5, 9]

[2, 2, 6, 8]

[2, 2, 7, 7]

[2, 2, 7, 9]

[2, 2, 8, 9]

[2, 2, 9, 9]

[2, 3, 3, 3]

[2, 3, 4, 4]

[2, 3, 4, 5]

[2, 3, 8, 8]

[2, 4, 4, 4]

[2, 4, 5, 7]

[2, 4, 5, 9]

[2, 4, 7, 7]

[2, 4, 7, 9]

[2, 4, 9, 9]

[2, 5, 5, 6]

[2, 5, 6, 6]

[2, 5, 7, 8]

[2, 5, 8, 9]

[2, 5, 9, 9]

[2, 6, 7, 7]

[2, 6, 9, 9]

[2, 7, 7, 7]

[2, 7, 7, 8]

[2, 7, 8, 9]

[2, 7, 9, 9]

[2, 8, 8, 9]

[2, 8, 9, 9]

[2, 9, 9, 9]

[3, 3, 3, 3]

[3, 3, 3, 4]

[3, 3, 3, 6]

[3, 3, 3, 8]

[3, 3, 3, 9]

[3, 3, 4, 5]

[3, 3, 4, 7]

[3, 3, 5, 8]

[3, 3, 5, 9]

[3, 3, 6, 8]

[3, 3, 7, 7]

[3, 3, 7, 8]

[3, 3, 8, 8]

[3, 3, 9, 9]

[3, 4, 4, 5]

[3, 4, 4, 7]

[3, 4, 7, 7]

[3, 5, 5, 7]

[3, 5, 6, 7]

[3, 5, 7, 7]

[3, 5, 8, 8]

[3, 5, 8, 9]

[3, 6, 6, 9]

[3, 7, 7, 7]

[3, 7, 8, 9]

[3, 8, 8, 8]

[3, 8, 8, 9]

[3, 9, 9, 9]

[4, 4, 4, 6]

[4, 4, 4, 9]

[4, 4, 5, 8]

[4, 4, 6, 7]

[4, 4, 9, 9]

[4, 5, 5, 6]

[4, 5, 6, 7]

[4, 5, 7, 7]

[4, 5, 7, 8]

[4, 5, 8, 9]

[4, 5, 9, 9]

[4, 6, 7, 9]

[4, 6, 9, 9]

[4, 7, 8, 9]

[4, 7, 9, 9]

[4, 8, 9, 9]

[4, 9, 9, 9]

[5, 5, 5, 5]

[5, 5, 5, 9]

[5, 5, 6, 8]

[5, 5, 7, 7]

[5, 5, 7, 8]

[5, 5, 7, 9]

[5, 5, 8, 8]

[5, 5, 9, 9]

[5, 6, 6, 7]

[5, 6, 8, 8]

[5, 7, 7, 7]

[5, 7, 7, 8]

[5, 7, 7, 9]

[5, 7, 8, 8]

[5, 7, 9, 9]

[5, 8, 8, 8]

[5, 8, 9, 9]

[5, 9, 9, 9]

[6, 6, 6, 6]

[6, 6, 6, 7]

[6, 6, 7, 7]

[6, 6, 7, 8]

[6, 7, 7, 7]

[6, 7, 7, 8]

[6, 7, 8, 8]

[6, 8, 8, 8]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 7, 9]

[7, 7, 8, 8]

[7, 7, 8, 9]

[7, 7, 9, 9]

[7, 8, 8, 8]

[7, 8, 8, 9]

[7, 8, 9, 9]

[7, 9, 9, 9]

[8, 8, 8, 8]

[8, 8, 8, 9]

[8, 8, 9, 9]

[8, 9, 9, 9]

[9, 9, 9, 9]

> nops([F60]);

Um jogo interessante, que vou propor como alternativa a próxima vez que for desafiado por pequerruchos bem treinados no Jogo do 24, é o Jogo do 6 ;-)
O Jogo do 6 admite solução para 469 dos 495 possíveis quaternos: mais 65 hipóteses de jogo do que no conhecido Jogo do 24. Os 26 quaternos para os quais não existe solução são:

> F6 := falham(6);

[1, 1, 1, 1]

[1, 1, 7, 9]

[1, 1, 8, 8]

[1, 1, 8, 9]

[1, 1, 9, 9]

[1, 5, 5, 9]

[1, 6, 6, 9]

[1, 9, 9, 9]

[3, 5, 8, 8]

[3, 6, 6, 7]

[4, 4, 9, 9]

[4, 5, 9, 9]

[4, 6, 6, 7]

[4, 7, 7, 8]

[5, 5, 9, 9]

[5, 6, 6, 8]

[5, 6, 6, 9]

[5, 7, 8, 8]

[6, 7, 8, 9]

[7, 7, 7, 9]

[7, 7, 8, 8]

[7, 7, 9, 9]

[7, 8, 9, 9]

[8, 8, 8, 9]

[8, 8, 9, 9]

[9, 9, 9, 9]

> nops([F6]);

Notamos, no entanto, que dos 26 quaternos que não admitem solução para o Jogo do 6, exactamente metade deles admite solução para o Jogo do 24. As 13 combinações que não admitem solução para o Jogo do 6, mas admitem solução para o Jogo do 24, são:

> tira([F24],[F6]);

Vejamos mais alguns valores além do 6 que conduzem a jogos com um número de configurações admissíveis maior que no Jogo 24.

> F8 := falham(8);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 4, 7]

[1, 1, 4, 9]

[1, 1, 5, 7]

[1, 1, 6, 6]

[1, 1, 6, 9]

[1, 3, 7, 7]

[1, 3, 7, 8]

[1, 3, 8, 9]

[1, 3, 9, 9]

[1, 5, 5, 5]

[1, 5, 8, 8]

[1, 5, 8, 9]

[1, 5, 9, 9]

[3, 5, 6, 8]

[3, 7, 7, 7]

[3, 7, 8, 8]

[3, 8, 8, 9]

[3, 9, 9, 9]

[4, 5, 5, 9]

[4, 6, 7, 7]

[4, 7, 7, 9]

[4, 7, 8, 8]

[4, 7, 9, 9]

[4, 8, 8, 9]

[5, 5, 5, 5]

[5, 5, 6, 6]

[5, 5, 7, 7]

[5, 6, 6, 6]

[5, 6, 7, 8]

[5, 7, 7, 7]

[5, 7, 8, 9]

[5, 8, 8, 9]

[5, 9, 9, 9]

[6, 6, 7, 7]

[6, 6, 7, 9]

[6, 6, 9, 9]

[6, 7, 9, 9]

[6, 8, 8, 9]

> nops([F8]);

> F12 := falham(12);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 8]

[1, 1, 2, 2]

[1, 1, 7, 8]

[1, 1, 7, 9]

[1, 1, 8, 9]

[1, 1, 9, 9]

[1, 4, 5, 5]

[1, 5, 5, 5]

[1, 5, 5, 9]

[1, 5, 7, 8]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 7, 8, 8]

[1, 8, 8, 8]

[1, 8, 8, 9]

[1, 8, 9, 9]

[1, 9, 9, 9]

[2, 2, 9, 9]

[3, 5, 5, 7]

[3, 7, 7, 7]

[4, 5, 5, 5]

[4, 5, 7, 7]

[4, 5, 9, 9]

[5, 5, 5, 5]

[5, 5, 5, 9]

[5, 5, 6, 9]

[5, 5, 7, 7]

[5, 5, 7, 8]

[5, 5, 8, 8]

[5, 5, 9, 9]

[5, 7, 7, 9]

[5, 9, 9, 9]

[6, 7, 7, 9]

[6, 8, 8, 9]

[6, 8, 9, 9]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 8, 8]

[7, 7, 8, 9]

[7, 7, 9, 9]

[7, 8, 8, 8]

[7, 8, 9, 9]

[7, 9, 9, 9]

[8, 8, 8, 8]

[8, 8, 8, 9]

[8, 8, 9, 9]

[8, 9, 9, 9]

[9, 9, 9, 9]

> nops([F12]);

> F18 := falham(18);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 4]

[1, 1, 1, 5]

[1, 1, 1, 7]

[1, 1, 2, 2]

[1, 1, 2, 3]

[1, 1, 2, 4]

[1, 1, 4, 8]

[1, 1, 5, 5]

[1, 1, 5, 7]

[1, 1, 5, 9]

[1, 1, 6, 7]

[1, 1, 6, 8]

[1, 1, 6, 9]

[1, 1, 7, 7]

[1, 1, 7, 8]

[1, 2, 2, 2]

[1, 2, 7, 7]

[1, 3, 4, 8]

[1, 3, 5, 5]

[1, 3, 5, 7]

[1, 4, 4, 4]

[1, 4, 4, 5]

[1, 4, 4, 7]

[1, 4, 4, 8]

[1, 4, 5, 5]

[1, 5, 5, 5]

[1, 5, 8, 8]

[1, 6, 7, 7]

[1, 6, 7, 8]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 7, 8, 8]

[1, 8, 8, 8]

[2, 2, 2, 2]

[2, 2, 7, 9]

[2, 5, 5, 7]

[2, 7, 7, 7]

[2, 7, 9, 9]

[3, 3, 4, 4]

[3, 3, 7, 8]

[3, 3, 8, 8]

[3, 4, 4, 4]

[3, 4, 5, 8]

[3, 4, 7, 8]

[3, 8, 8, 8]

[4, 4, 4, 4]

[4, 4, 4, 5]

[4, 4, 4, 7]

[4, 4, 5, 9]

[4, 4, 7, 7]

[4, 4, 8, 8]

[4, 5, 5, 5]

[4, 5, 5, 8]

[4, 5, 5, 9]

[4, 5, 7, 8]

[4, 7, 7, 7]

[4, 7, 8, 8]

[4, 8, 9, 9]

[5, 5, 5, 5]

[5, 5, 5, 6]

[5, 5, 5, 8]

[5, 5, 6, 6]

[5, 5, 6, 8]

[5, 5, 6, 9]

[5, 5, 7, 7]

[5, 5, 7, 9]

[5, 5, 8, 8]

[5, 6, 7, 7]

[5, 7, 7, 7]

[5, 7, 7, 8]

[5, 8, 8, 8]

[5, 8, 8, 9]

[6, 6, 6, 6]

[6, 6, 6, 7]

[6, 6, 7, 7]

[6, 6, 7, 8]

[6, 6, 8, 8]

[6, 7, 7, 7]

[6, 7, 7, 8]

[6, 7, 7, 9]

[6, 7, 8, 8]

[6, 8, 8, 9]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 8, 8]

[7, 8, 8, 8]

[8, 8, 8, 8]

> nops([F18]);

Os jogos do 8, do 12 e do 18 são também jogos interessantes a considerar.

O 30 tem o mesmo número de divisores que 24 (ambos têm 8 divisores positivos), enquanto 36 é o menor natural com um número de divisores superior ao de 24 (tem, como vimos, 9 divisores positivos). O facto de estarmos a considerar apenas configurações formadas por números de um a nove, faz com que estes casos sejam menos interessantes (o número de configurações admissíveis é menor, em ambos os casos, do que no Jogo do 24):

> F30 := falham(30);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 4]

[1, 1, 1, 5]

[1, 1, 1, 6]

[1, 1, 1, 7]

[1, 1, 1, 8]

[1, 1, 1, 9]

[1, 1, 2, 2]

[1, 1, 2, 3]

[1, 1, 2, 4]

[1, 1, 2, 5]

[1, 1, 2, 6]

[1, 1, 2, 7]

[1, 1, 2, 8]

[1, 1, 3, 3]

[1, 1, 3, 4]

[1, 1, 3, 7]

[1, 1, 4, 4]

[1, 1, 5, 9]

[1, 1, 6, 8]

[1, 1, 7, 7]

[1, 1, 7, 9]

[1, 1, 8, 8]

[1, 1, 8, 9]

[1, 1, 9, 9]

[1, 2, 2, 2]

[1, 2, 2, 3]

[1, 2, 2, 4]

[1, 2, 2, 9]

[1, 2, 3, 3]

[1, 2, 8, 9]

[1, 2, 9, 9]

[1, 3, 4, 4]

[1, 3, 5, 7]

[1, 3, 7, 7]

[1, 3, 8, 8]

[1, 4, 4, 4]

[1, 4, 4, 5]

[1, 4, 4, 7]

[1, 4, 4, 9]

[1, 4, 5, 8]

[1, 4, 7, 7]

[1, 4, 7, 8]

[1, 4, 8, 8]

[1, 4, 8, 9]

[1, 4, 9, 9]

[1, 5, 5, 9]

[1, 5, 6, 8]

[1, 5, 7, 7]

[1, 5, 7, 8]

[1, 5, 7, 9]

[1, 5, 8, 8]

[1, 5, 9, 9]

[1, 6, 6, 8]

[1, 6, 6, 9]

[1, 6, 7, 7]

[1, 6, 7, 8]

[1, 6, 7, 9]

[1, 6, 8, 8]

[1, 6, 8, 9]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 7, 7, 9]

[1, 7, 8, 8]

[1, 7, 8, 9]

[1, 7, 9, 9]

[1, 8, 8, 8]

[1, 8, 8, 9]

[1, 8, 9, 9]

[1, 9, 9, 9]

[2, 2, 2, 2]

[2, 2, 2, 3]

[2, 2, 2, 4]

[2, 2, 2, 6]

[2, 2, 2, 9]

[2, 2, 3, 5]

[2, 2, 4, 8]

[2, 2, 9, 9]

[2, 3, 5, 8]

[2, 4, 5, 9]

[2, 4, 7, 9]

[2, 4, 9, 9]

[2, 5, 9, 9]

[2, 6, 7, 7]

[2, 6, 7, 8]

[2, 7, 7, 7]

[2, 7, 8, 9]

[2, 7, 9, 9]

[2, 8, 8, 8]

[2, 8, 8, 9]

[2, 8, 9, 9]

[2, 9, 9, 9]

[3, 3, 4, 4]

[3, 3, 7, 7]

[3, 3, 7, 8]

[3, 3, 8, 8]

[3, 4, 4, 4]

[3, 4, 4, 5]

[3, 4, 4, 7]

[3, 4, 4, 8]

[3, 4, 7, 8]

[3, 4, 8, 9]

[3, 5, 5, 5]

[3, 5, 6, 6]

[3, 5, 7, 7]

[3, 5, 8, 8]

[3, 6, 7, 7]

[3, 7, 7, 7]

[3, 7, 7, 8]

[3, 7, 8, 8]

[3, 8, 8, 8]

[4, 4, 4, 4]

[4, 4, 4, 5]

[4, 4, 4, 7]

[4, 4, 4, 8]

[4, 4, 4, 9]

[4, 4, 7, 9]

[4, 4, 8, 9]

[4, 4, 9, 9]

[4, 5, 6, 7]

[4, 5, 8, 9]

[4, 5, 9, 9]

[4, 6, 7, 9]

[4, 7, 7, 7]

[4, 7, 7, 8]

[4, 7, 9, 9]

[4, 8, 8, 8]

[4, 8, 8, 9]

[4, 9, 9, 9]

[5, 5, 5, 9]

[5, 5, 6, 8]

[5, 5, 7, 9]

[5, 6, 6, 8]

[5, 7, 7, 9]

[5, 8, 8, 8]

[5, 8, 9, 9]

[5, 9, 9, 9]

[6, 6, 6, 8]

[6, 6, 6, 9]

[6, 6, 7, 9]

[6, 7, 7, 7]

[6, 7, 7, 8]

[6, 8, 8, 9]

[6, 9, 9, 9]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 9, 9]

[7, 8, 8, 8]

[7, 8, 8, 9]

[7, 8, 9, 9]

[7, 9, 9, 9]

[8, 8, 8, 8]

[8, 8, 8, 9]

[8, 8, 9, 9]

[8, 9, 9, 9]

[9, 9, 9, 9]

> nops([F30]);

> F36 := falham(36);

[1, 1, 1, 1]

[1, 1, 1, 2]

[1, 1, 1, 3]

[1, 1, 1, 4]

[1, 1, 1, 5]

[1, 1, 1, 6]

[1, 1, 1, 7]

[1, 1, 1, 8]

[1, 1, 1, 9]

[1, 1, 2, 2]

[1, 1, 2, 3]

[1, 1, 2, 4]

[1, 1, 2, 5]

[1, 1, 2, 6]

[1, 1, 2, 7]

[1, 1, 2, 8]

[1, 1, 3, 3]

[1, 1, 3, 4]

[1, 1, 3, 5]

[1, 1, 3, 7]

[1, 1, 4, 4]

[1, 1, 4, 5]

[1, 1, 7, 8]

[1, 1, 7, 9]

[1, 1, 8, 8]

[1, 2, 2, 2]

[1, 2, 2, 3]

[1, 2, 2, 4]

[1, 2, 2, 5]

[1, 2, 2, 7]

[1, 2, 3, 3]

[1, 2, 3, 8]

[1, 3, 5, 5]

[1, 3, 7, 7]

[1, 3, 8, 8]

[1, 4, 5, 6]

[1, 4, 6, 7]

[1, 5, 5, 5]

[1, 5, 5, 9]

[1, 5, 6, 8]

[1, 5, 6, 9]

[1, 5, 7, 9]

[1, 5, 8, 8]

[1, 6, 6, 9]

[1, 6, 7, 8]

[1, 6, 7, 9]

[1, 6, 8, 8]

[1, 7, 7, 7]

[1, 7, 7, 8]

[1, 7, 7, 9]

[1, 7, 8, 8]

[1, 7, 9, 9]

[1, 8, 8, 8]

[1, 8, 8, 9]

[1, 8, 9, 9]

[1, 9, 9, 9]

[2, 2, 2, 2]

[2, 2, 2, 3]

[2, 2, 2, 4]

[2, 2, 2, 5]

[2, 2, 2, 9]

[2, 2, 5, 5]

[2, 2, 7, 7]

[2, 3, 4, 7]

[2, 3, 5, 8]

[2, 4, 5, 5]

[2, 5, 5, 5]

[2, 5, 5, 6]

[2, 5, 7, 7]

[2, 6, 7, 7]

[2, 7, 7, 7]

[2, 7, 7, 9]

[2, 7, 8, 9]

[3, 3, 5, 5]

[3, 3, 6, 8]

[3, 3, 7, 7]

[3, 3, 8, 8]

[3, 4, 7, 7]

[3, 4, 9, 9]

[3, 5, 5, 5]

[3, 5, 5, 7]

[3, 5, 6, 6]

[3, 5, 7, 7]

[3, 5, 8, 8]

[3, 6, 6, 7]

[3, 6, 7, 8]

[3, 6, 8, 8]

[3, 7, 7, 7]

[3, 7, 8, 8]

[3, 8, 8, 8]

[4, 4, 6, 9]

[4, 4, 7, 7]

[4, 4, 7, 9]

[4, 4, 9, 9]

[4, 5, 5, 5]

[4, 5, 9, 9]

[4, 6, 7, 7]

[4, 7, 7, 7]

[5, 5, 5, 5]

[5, 5, 5, 8]

[5, 5, 6, 8]

[5, 5, 7, 7]

[5, 5, 7, 9]

[5, 5, 8, 8]

[5, 8, 8, 8]

[6, 6, 7, 9]

[6, 7, 7, 9]

[6, 8, 8, 8]

[7, 7, 7, 7]

[7, 7, 7, 8]

[7, 7, 7, 9]

[7, 7, 8, 8]

[7, 7, 8, 9]

[7, 7, 9, 9]

[7, 8, 8, 8]

[7, 8, 8, 9]

[8, 8, 8, 8]

[8, 8, 8, 9]

[8, 8, 9, 9]

[8, 9, 9, 9]

> nops([F36]);

O nosso objectivo será agora o de definir em Maple a função jogo24 que, dados 4 números, nos devolva todas as soluções do Jogo 24 para essa combinação.

Vê-se facilmente que muitas expressões associadas a uma dada combinação correspondem, na verdade, ao mesmo método de solução.
Vejamos, a título ilustrativo, o exemplo dado no início deste trabalho: [1, 3, 4, 8]. O programa disponibilizado em
www.wxs.nl/~edejong/24-game dá-nos 12 soluções! A saber:

24-Game Oplossingen
1348 : ((1+3)*4)+8 = 24
1348 : ((1+8)-3)*4 = 24
1348 : ((1-3)+8)*4 = 24
1348 : ((3+1)*4)+8 = 24
1348 : ((8+1)-3)*4 = 24
1348 : ((8-3)+1)*4 = 24
1348 : (4+8)*(3-1) = 24
1348 : (8+4)*(3-1) = 24
1348 : 4*(1-(3-8)) = 24
1348 : 4*(8-(3-1)) = 24
1348 : 8+(4*(1+3)) = 24
1348 : 8+(4*(3+1)) = 24

Muitas delas são repetidas... Para a combinação [1, 3, 4, 8] apenas existem, na verdade, como já vimos, quatro soluções verdadeiramente distintas.

O programa "24-Game Oplossingen" parece dar muitas soluções, mas na verdade não as descobre todas! Apenas indica 3 das 4 possíveis: podemos agrupar as 12 soluções acima em três grupos, de tal modo que as fórmulas associadas ao primeiro grupo são todas elas equivalentes à expressão
x4+x3*(x1+x2) ; as do segundo grupo a
x3*(x1+x4-x2) ; e as do último grupo a
(x3+x4)*(x2-x1) ; com x1=1, x2=3, x3=4,x4=8:

• ((1+3)*4)+8 = ((3+1)*4)+8 = 8+(4*(1+3)) = 8+(4*(3+1))
• ((1+8)-3)*4 = ((1-3)+8)*4 = ((8+1)-3)*4 = ((8-3)+1)*4 = 4*(1-(3-8)) = 4*(8-(3-1))
• (4+8)*(3-1) = (8+4)*(3-1)

O "24-Game Oplossingen" deixa de fora a solução x4/(x3/x2 - x1) = 8/(4/3 - 1) . Poderíamos pensar que este programa apenas considera soluções que envolvam inteiros. Isso não é, no entanto, verdade, como rapidamente se confirma, por exemplo, com a combinação [1,4,5,6]:

24-Game Oplossingen
1456 : 4/(1-(5/6)) = 24

Também aqui existe uma solução que não é descoberta pelo "24-Game Oplossingen":
6/((5/4)-1)
Nós estamos interessados em obter, apenas, as soluções estruturalmente diferentes. Como explicado por Xu X.J. em
http://eppe.tamu.edu/~xuxj/prog/download/24game.htm
eliminar os casos duplicados não é uma tarefa fácil. Xu X.J. desenvolveu, no ano 2000, um programa para o Jogo do 24, disponibilizando o seu código fonte em C e o respectivo executável, que faz alguma eliminação, usando para isso uma representação das expressões em árvore. A eliminação não é, no entanto, completa e o autor apresenta, inclusive, alguns exemplos em que o seu método de eliminação não funciona bem. Para a combinação [1, 3, 4, 8] este programa dá-nos 8 soluções:

Please input 4 integer numbers: 1 3 4 8
((1+3)*4)+8
((1-3)+8)*4
(1-(3-8))*4
((1+8)-3)*4
(1+(8-3))*4
(3-1)*(4+8)
4*(8-(3-1))
8/((4/3)-1)
total 8 solutions
Nós só estamos interessados em obter as 4 soluções verdadeiramente diferentes (que provêm de expressões matemáticas não equivalentes):
(4+8)*(3-1)
4*(1+8-3)
8+4*(1+3)
8/(4/3-1)
O Maple, com as suas capacidades simbólicas, permite-nos verificar facilmente a igualdade de expressões matemáticas que, sendo equivalentes, estão escritas de forma diferente.

O Maple permite-nos abordar o problema de uma maneira alternativa, na nossa opinião mais simples, elegante e com algumas vantagens.
A nossa definição em Maple do jogo24 é feita de modo incremental. Começamos por introduzir primeiro algumas funções auxiliares. O modus operandi destas funções auxiliares é explicado por intermédio de alguns exemplos.

> afecta := (LN,LX) -> {seq(LX[i]=LN[i],i=1..nops(LN))}:

> afecta([1,2,3],[x1,x2,x3]);

> afecta([4,4,7,8],[x1,x1,x2,x3]);

> divisaoZero := proc(e,a)

> local d, D, flag:

> flag := false:

> D := [seq(denom(j),j=select(i->denom(i)<>1,[op(e)]))];

> for d in D while not flag do

> if simplify(subs(a,d) = 0) then

> flag := true

> fi:

> od:

> if not(flag) and whattype(e) = `^` and subs(a,op(2,e)) < 0 and subs(a,op(1,e)) = 0 then

> flag := true:

> fi:

> return(flag);

> end proc:

> divisaoZero(x1*x2/x3,{x1=1,x2=2,x3=3});

> divisaoZero(x1/(x2-x3),{x1=1,x2=2,x3=2});

> divisaoZero((x1-x2)^(-1),{x1=2,x2=2});

> variaveis := proc(LN)

> local i, j, p,LX:

> LX := []:

> j := 0:

> for i to nops(LN) do

> if member(LN[i],LN[1..i-1],'p') then

> LX := [op(LX), LX[p]]:

> else

> j := j + 1:

> LX := [op(LX), x||j]:

> fi:

> od:

> return(LX);

> end proc:

> variaveis([1,4,6,9]);

> variaveis([1,2,1,4]);

> variaveis([8,8,4,4]);

Com a ajuda das funções afecta , divisaoZero e variaveis , que acabámos de definir, estamos agora em condições de implementar o tão almejado jogo24 .

> jogo := proc(LN,LO,v)

> local LX, CE, e, a, i:

> LX := variaveis(LN);

> CE := todos(f2(LX,LO),LO);

> a := afecta(LN,LX);

> i := 0;

> printf("-------------\n");

> printf("%a = %a\n",LX,LN);

> for e in CE do

> if not(divisaoZero(e,a)) and subs(a,e) = v then

> i := i + 1:

> printf("Solucao %a: %a\n",i,e);

> fi:

> od:

> end proc:

> jogo24 := L -> jogo(L,[`+`,`-`,`*`,`/`],24):

Para obtermos todas as soluções para todas as possíveis configurações do Jogo 24, basta agora executar o seguinte comando:

> for c in PC do jogo24(c) od;

-------------

[x1, x1, x1, x2] = [1, 1, 1, 8]

Solucao 1: 3*x1*x2

-------------

[x1, x1, x2, x3] = [1, 1, 2, 6]

Solucao 1: (2*x1+x2)*x3

Solucao 2: 2*x1*x2*x3

-------------

[x1, x1, x2, x3] = [1, 1, 2, 7]

Solucao 1: (x1+x2)*(x1+x3)

-------------

[x1, x1, x2, x3] = [1, 1, 2, 8]

Solucao 1: x1*(x2+1)*x3

Solucao 2: (x1+x2)*x1*x3

Solucao 3: (x1^2+x2)/x1*x3

Solucao 4: (x1^2+x2)*x3

Solucao 5: (x2+1)*x3

Solucao 6: (x1+x2)*x3/x1

-------------

[x1, x1, x2, x3] = [1, 1, 2, 9]

Solucao 1: -(x1+x2)*(x1-x3)

-------------

[x1, x1, x2, x3] = [1, 1, 3, 4]

Solucao 1: 2*x1*x2*x3

-------------

[x1, x1, x2, x3] = [1, 1, 3, 5]

Solucao 1: (x1+x2)*(x1+x3)

-------------

[x1, x1, x2, x3] = [1, 1, 3, 6]

Solucao 1: (x1+x2)*x1*x3

Solucao 2: x1*(x2+1)*x3

Solucao 3: (x2+1)*x3

Solucao 4: (x1^2+x2)*x3

Solucao 5: (x1+x2)*x3/x1

Solucao 6: (2*x1+x3)*x2

Solucao 7: (x1^2+x2)/x1*x3

-------------

[x1, x1, x2, x3] = [1, 1, 3, 7]

Solucao 1: (x3+1)*x2

Solucao 2: (x1^2+x3)/x1*x2

Solucao 3: (x1+x3)*x2/x1

Solucao 4: x1*(x1+x3)*x2

Solucao 5: x1*(x3+1)*x2

Solucao 6: -(x1+x2)*(x1-x3)

Solucao 7: (x1^2+x3)*x2

-------------

[x1, x1, x2, x3] = [1, 1, 3, 8]

Solucao 1: x2*x3

Solucao 2: x1^2*x2*x3

Solucao 3: x2*x3/x1^2

-------------

[x1, x1, x2, x3] = [1, 1, 3, 9]

Solucao 1: -x1*(x1-x3)*x2

Solucao 2: -(x1-x3)*x2/x1

Solucao 3: x1*(x3-1)*x2

Solucao 4: -(x1^2-x3)*x2

Solucao 5: 2*x1*(x2+x3)

Solucao 6: (x3-1)*x2

Solucao 7: -(x1^2-x3)/x1*x2

-------------

[x1, x1, x2, x2] = [1, 1, 4, 4]

Solucao 1: (2*x1+x2)*x2

-------------

[x1, x1, x2, x3] = [1, 1, 4, 5]

Solucao 1: (1+x3)*x2

Solucao 2: x1*(x1+x3)*x2

Solucao 3: x1*x3+x2*x3-x1

Solucao 4: (x1+x3)*x2/x1

Solucao 5: x1*(1+x3)*x2

Solucao 6: (x1^2+x3)*x2

Solucao 7: (x1^2+x3)/x1*x2

-------------

[x1, x1, x2, x3] = [1, 1, 4, 6]

Solucao 1: x2*x3/x1^2

Solucao 2: x1^2*x3*x2

Solucao 3: x2*x3

-------------

[x1, x1, x2, x3] = [1, 1, 4, 7]

Solucao 1: -(x1^2-x3)/x1*x2

Solucao 2: -(x1^2-x3)*x2

Solucao 3: -(x1+x3)*(x1-x2)

Solucao 4: (x3-1)*x2

Solucao 5: -(x1-x3)*x1*x2

Solucao 6: -(x1-x3)*x2/x1

Solucao 7: x1*(x3-1)*x2

-------------

[x1, x1, x2, x3] = [1, 1, 4, 8]

Solucao 1: -(x1^2-x2)/x1*x3

Solucao 2: 2*x1*(x2+x3)

Solucao 3: (x2-1)*x3

Solucao 4: -(2*x1-x3)*x2

Solucao 5: -x1*(x1-x2)*x3

Solucao 6: -(x1^2-x2)*x3

Solucao 7: -(x1-x2)*x3/x1

Solucao 8: x1*(x2-1)*x3

-------------

[x1, x1, x2, x3] = [1, 1, 4, 9]

Solucao 1: (x1-x3)*(x1-x2)

-------------

[x1, x1, x2, x2] = [1, 1, 5, 5]

Solucao 1: -(x1^2-x2^2)/x1

Solucao 2: x1*x2^2-x1

Solucao 3: -(x1+x2)*(x1-x2)

Solucao 4: -(x1-x2^2)*x1

Solucao 5: -(x1-x2^2)/x1

Solucao 6: -1+x2^2

Solucao 7: x2^2-x1^2

-------------

[x1, x1, x2, x3] = [1, 1, 5, 6]

Solucao 1: -(x1^2-x2)/x1*x3

Solucao 2: -x1*(x1-x2)*x3

Solucao 3: -(x1-x2)*x3/x1

Solucao 4: x1*(-1+x2)*x3

Solucao 5: -x1*x2+x2*x3-x1

Solucao 6: -(x1^2-x2)*x3

Solucao 7: (-1+x2)*x3

-------------

[x1, x1, x2, x3] = [1, 1, 5, 7]

Solucao 1: (x1-x3)*(x1-x2)

Solucao 2: 2*(x2+x3)*x1

-------------

[x1, x1, x2, x3] = [1, 1, 5, 8]

Solucao 1: -(2*x1-x2)*x3

-------------

[x1, x1, x2, x2] = [1, 1, 6, 6]

Solucao 1: -(2*x1-x2)*x2

Solucao 2: 4*x1*x2

-------------

[x1, x1, x2, x3] = [1, 1, 6, 8]

Solucao 1: 1/2*x2*x3/x1

-------------

[x1, x1, x2, x3] = [1, 1, 6, 9]

Solucao 1: 2*x1*x3+x2

-------------

[x1, x1, x2, x2] = [1, 1, 8, 8]

Solucao 1: 2*x1*x2+x2

-------------

[x1, x2, x2, x3] = [1, 2, 2, 4]

Solucao 1: (x1+x2)*x3*x2

-------------

[x1, x2, x2, x3] = [1, 2, 2, 5]

Solucao 1: (x1+x3)*x2^2

Solucao 2: 2*(x1+x3)*x2

-------------

[x1, x2, x2, x3] = [1, 2, 2, 6]

Solucao 1: (x1+x2)*(x2+x3)

Solucao 2: x2^2*x3/x1

Solucao 3: x2^2*x1*x3

Solucao 4: x2*(x1+1)/x1*x3

Solucao 5: 2*x1*x2*x3

Solucao 6: 2*x2*x3/x1

Solucao 7: x3*x2*(x1+1)

-------------

[x1, x2, x2, x3] = [1, 2, 2, 7]

Solucao 1: -2*(x1-x3)*x2

Solucao 2: -(x1-x3)*x2^2

-------------

[x1, x2, x2, x3] = [1, 2, 2, 8]

Solucao 1: -(x1-2*x2)*x3

Solucao 2: -(x1-x2^2)*x3

-------------

[x1, x2, x2, x3] = [1, 2, 2, 9]

Solucao 1: (x2+x3+x1)*x2

-------------

[x1, x2, x3, x3] = [1, 2, 3, 3]

Solucao 1: (x1+x3)*x3*x2

-------------

[x1, x2, x3, x4] = [1, 2, 3, 4]

Solucao 1: (x1+x3)*(x2+x4)

Solucao 2: x2*x3*x4/x1

Solucao 3: x1*x2*x4*x3

Solucao 4: (x2+x3+x1)*x4

-------------

[x1, x2, x3, x4] = [1, 2, 3, 5]

Solucao 1: (x4-x1)*x3*x2

Solucao 2: x2*x4+x3*x4-x1

Solucao 3: (x1+x2+x4)*x3

Solucao 4: (x1+x2)*(x3+x4)

-------------

[x1, x2, x3, x4] = [1, 2, 3, 6]

Solucao 1: (x1*x4+x2)/x1*x3

Solucao 2: -x4*(x1-x2-x3)

Solucao 3: (x1*x2+x4)*x3

Solucao 4: (x1*x2+x4)/x1*x3

Solucao 5: x1*(x2+x4)*x3

Solucao 6: -(x1-x3)*x4*x2

Solucao 7: (x2+x4)*x3/x1

Solucao 8: (x1*x4+x2)*x3

-------------

[x1, x2, x3, x4] = [1, 2, 3, 7]

Solucao 1: x3*x4+x1+x2

Solucao 2: (x2+x4-x1)*x3

Solucao 3: x1*x4+x2*x4+x3

-------------

[x1, x2, x3, x4] = [1, 2, 3, 8]

Solucao 1: x4/(x1*x3-x2)*x3

Solucao 2: -(x1-x2)*x4*x3

Solucao 3: (x4+x1+x3)*x2

Solucao 4: -x3*x4/(x1-x2)

Solucao 5: (x1+x3)*(x4-x2)

-------------

[x1, x2, x3, x4] = [1, 2, 3, 9]

Solucao 1: x1*(x3+x4)*x2

Solucao 2: (x1*x3+x4)/x1*x2

Solucao 3: (x1*x4+x3)/x1*x2

Solucao 4: (x3+x4)*x2/x1

Solucao 5: (x1+x4-x2)*x3

Solucao 6: (x1*x4+x3)*x2

Solucao 7: (x1*x3+x4)*x2

Solucao 8: x1*x4+x2*x4-x3

Solucao 9: x3*x4-x1-x2

-------------

[x1, x2, x3, x3] = [1, 2, 4, 4]

Solucao 1: (x2+x3)*x3/x1

Solucao 2: 2*(x1+x2)*x3

Solucao 3: (x1*x2+x3)/x1*x3

Solucao 4: (x1*x3+x2)/x1*x3

Solucao 5: (x1*x2+x3)*x3

Solucao 6: (x1*x3+x2)*x3

Solucao 7: (x2+x3)*x1*x3

Solucao 8: -(x1-x3)*x3*x2

-------------

[x1, x2, x3, x4] = [1, 2, 4, 5]

Solucao 1: (x2+x3)*(x4-x1)

Solucao 2: (x2+x4-x1)*x3

-------------

[x1, x2, x3, x4] = [1, 2, 4, 6]

Solucao 1: -(x1-x2)*x4*x3

Solucao 2: -x3*x4/(x1-x2)

Solucao 3: -(x1-x3)*(x2+x4)

-------------

[x1, x2, x3, x4] = [1, 2, 4, 7]

Solucao 1: (x4+x1+x3)*x2

Solucao 2: (x1+x4-x2)*x3

-------------

[x1, x2, x3, x4] = [1, 2, 4, 8]

Solucao 1: (x1+x3-x2)*x4

Solucao 2: (x4-x2)*x1*x3

Solucao 3: (x1*x3+x4)/x1*x2

Solucao 4: (x4-x2)*x3/x1

Solucao 5: (x4-x1*x2)/x1*x3

Solucao 6: (x1*x3+x4)*x2

Solucao 7: x4*(x1*x2+x3)/x2

Solucao 8: (x1*x4+x3)/x1*x2

Solucao 9: (x4-x1*x2)*x3

Solucao 10: (x1*x4+x3)*x2

Solucao 11: (x1*x4-x2)/x1*x3

Solucao 12: (x3+x4)*x2/x1

Solucao 13: x1*(x3+x4)*x2

Solucao 14: (x1*x4-x2)*x3

-------------

[x1, x2, x3, x4] = [1, 2, 4, 9]

Solucao 1: (x3+x4-x1)*x2

Solucao 2: x1*x2+x2*x4+x3

Solucao 3: (x4-x1-x2)*x3

-------------

[x1, x2, x3, x3] = [1, 2, 5, 5]

Solucao 1: x1-x2+x3^2

-------------

[x1, x2, x3, x4] = [1, 2, 5, 6]

Solucao 1: (x4+x1+x3)*x2

Solucao 2: (x1+x3)*(x4-x2)

Solucao 3: (x1+x3-x2)*x4

-------------

[x1, x2, x3, x4] = [1, 2, 5, 7]

Solucao 1: (x3+x4)*x2/x1

Solucao 2: (x3-x2)*(x1+x4)

Solucao 3: (x3+x4)*x1*x2

Solucao 4: -x1+x3*x4-x2*x3

Solucao 5: (x1*x4+x3)*x2

Solucao 6: (x1*x4+x3)/x1*x2

Solucao 7: (x1*x3+x4)/x1*x2

Solucao 8: (x1*x3+x4)*x2

-------------

[x1, x2, x3, x4] = [1, 2, 5, 8]

Solucao 1: -(x1-x3)*(x4-x2)