Existem 40 maneiras pelas quais um caminho hamiltoniano direcionado pode ser organizado em uma grade 3 × 3:

Este gráfico ( graças ao Sp3000! ) Mostra apenas os 20 caminhos não direcionados. Percorra cada linha colorida nas duas direções para os 40 caminhos direcionados.

Desafio

Usando apenas ASCII imprimível , escreva uma grade 3 x 3 de caracteres, como:

ABC
DEF
GHI

Quando cada um dos 40 caminhos direcionados é lido nesta grade como 40 programas de linha única e 9 caracteres, o objetivo é fazer com que cada programa produza um número inteiro único de 1 a 40. Fazer isso para todos os 40 caminhos parece difícil e improvável, portanto, você só precisa fazê-lo funcionar para o maior número possível de caminhos.

A submissão cujos 40 programas de caminho produzirem os números mais distintos de 1 a 40 será o vencedor. O desempatador vai para a finalização anterior.

Os programas de caminho que erro ou não produzem um número inteiro de 1 a 40 ou produzem um número inteiro que outro programa de caminho já coberto não é contado. Especificamente:

• Os programas que apresentam erros ao compilar, executar ou sair não são contados. Os avisos estão ok.
• Programas que não produzem um número inteiro de 1 a 40 ou produzem algo ligeiramente malformado, como -35ou 35 36não são contados.
• Programas que requerem entrada do usuário para produzir a saída não são contados.
• Programas que nunca terminam não são contados.
• A partir de agora , os programas que não são determinísticos não são contados.
• Caso contrário, os programas válidos que produzem um número inteiro de 1 a 40 que outro programa válido já produziu não são contados. (O primeiro programa é contado.)
• Somente os programas que geram representações inteiras de números de 1 a 40 (inclusive) são contados no total. Os números são esperados para estar no costume 1, 2, ..., 39, 40formato, a menos que não é a norma para o seu idioma. (Uma nova linha à direita na saída está correta.)
• Quais são os números de saída dos programas e em que ordem eles estão, não importa. Somente o número de números inteiros distintos de programas válidos é importante.

Todos os programas de caminho devem ser executados no mesmo idioma. No entanto, os "programas" podem de fato ser funções (sem argumentos necessários) ou comandos REPL , além de programas completos, que imprimem ou retornam seu número inteiro de destino. Você pode misturar e combinar entre funções, comandos REPL e programas completos.

Seus 9 caracteres ASCII imprimíveis não precisam ser distintos.

Exemplo

Se sua grade 3 × 3 fosse

ABC
DEF
GHI

e seus 40 programas e saídas ficaram assim

ABCFEDGHI -> 26
ABCFIHEDG -> 90
ABCFIHGDE -> 2
ABEDGHIFC -> syntax error
ADEBCFIHG -> prints 40 but then errors
ADGHEBCFI -> 6
ADGHIFCBE -> 6
ADGHIFEBC -> 6
CBADEFIHG -> runtime error
CBADGHEFI -> 3
CBADGHIFE -> 4
CFEBADGHI -> -32
CFIHEBADG -> 38.0
CFIHGDABE -> "36"
EDABCFIHG -> 33
EFCBADGHI -> no output
EHGDABCFI -> compilation error
EHIFCBADG -> 8
GDABCFEHI -> 22
GHEDABCFI -> 41
IHGDEFCBA -> 0
GDEHIFCBA -> '9'
EDGHIFCBA -> +10
CFIHGDEBA -> 11
GHIFCBEDA -> error
IFCBEHGDA -> error
EBCFIHGDA -> prints 23 but then loops infinitely
CBEFIHGDA -> randomly prints either 24 or 44
GHIFEDABC -> error
IFEHGDABC -> 30
EFIHGDABC -> 39
IHGDABEFC -> 7
GDABEHIFC -> 29
EBADGHIFC -> -1
GHIFCBADE -> 26
IHGDABCFE -> 1
IFCBADGHE -> error
GDABCFIHE -> no output
IHEFCBADG -> no output
IFCBADEHG -> "quack"

sua pontuação seria 14, porque existem 14 números inteiros distintos de 1 a 40, válidos 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignora espaços entre dígitos, para que 1 8 2, por exemplo, seja tratado como 182. O mesmo poderia funcionar para perl, substituindo os espaços por sublinhados. Não esgotei todo o espaço de pesquisa, portanto, pode haver melhores candidatos.

Um programa pode ser alimentado para o gp como gp -q -f program.gp, ou interativamente, no repl.

Saída

1%1 8 2+3 -> 4
1%1 3+8 2 -> 83 # invalid
1%1 3+2 8 -> 29
1%8 2+3 1 -> 32
1 8%1 3+2 -> 7
1 2+8%1 3 -> 20
1 2+3 1%8 -> 19
1 2+3 8%1 -> 12
1%1 8 3+2 -> 3
1%1 2+8 3 -> 84 # invalid
1%1 2+3 8 -> 39
1 8%1 2+3 -> 9
1 3+8%1 2 -> 21
1 3+2 1%8 -> 18
8 1%1 3+2 -> 5
8 1%1 2+3 -> 12 # dup
8+2 1%1 3 -> 16
8+3 1%1 2 -> 15
2 1%1 8+3 -> 6
2+8 1%1 3 -> 5  # dup
3+2 8 1%1 -> 3  # dup
2 8+3 1%1 -> 28
8 2+3 1%1 -> 82 # invalid
1 3+2 8%1 -> 13
2+3 1%8 1 -> 33
3 1%8+2 1 -> 28 # dup
8%1 3+2 1 -> 29 # dup
1%8 3+2 1 -> 22
2+3 8 1%1 -> 2
3 8+2 1%1 -> 38
8 3+2 1%1 -> 83 # invalid
3+2 1%8 1 -> 24
2 1%8+3 1 -> 36
8%1 2+3 1 -> 39 # dup
2+3 1%1 8 -> 15 # dup
3+2 1%1 8 -> 6  # dup
3 1%1 2+8 -> 15 # dup
2 1%1 3+8 -> 16 # dup
3+8 1%1 2 -> 12 # dup
3 1%1 8+2 -> 15 # dup

Todos os valores, com exceção de 4, estão dentro do intervalo necessário, com 12 entradas duplicadas.

Atualizar

Eu terminei o processamento, existem seis 23s distintos e apenas um 24 (conforme lido pelas linhas):

23 1%1 6 2+3 [2, 3, 4, 5, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 22, 24, 26, 27, 32, 33, 34, 36, 37]
23 1 2%3+2*8 [2, 5, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 25, 26, 29, 31, 32, 37, 40]
23 2 3%1+8 2 [2, 4, 6, 7, 10, 11, 12, 13, 14, 15, 16, 20, 21, 23, 24, 28, 29, 30, 31, 32, 33, 34, 40]
23 4%6%5*7+6 [2, 4, 5, 6, 7, 8, 9, 12, 13, 19, 21, 23, 24, 26, 29, 31, 32, 33, 34, 37, 38, 39, 40]
23 5%6%4*7+6 [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 25, 26, 29, 31, 33, 34, 37, 38, 39, 40]
23 5%6%4*8+6 [1, 3, 5, 6, 8, 9, 10, 12, 14, 15, 18, 22, 24, 25, 27, 29, 30, 32, 34, 36, 37, 39, 40]

24 1%1 8 2+3 [2, 3, 4, 5, 6, 7, 9, 12, 13, 15, 16, 18, 19, 20, 21, 22, 24, 28, 29, 32, 33, 36, 38, 39]

O programa que eu usei para triturar está abaixo. O PARI / GP possui recursos limitados de processamento de strings; portanto, lide principalmente com matrizes de char (aka Vecsmall). Os operadores são testadas +, -, *, \(div andar), %, ;(separador de expressão, essencialmente devoluções tudo antes), e (espaço, tal como descrito acima). O operador expoente ^também pode ser adicionado, mas torna-se muito lento para testar exaustivamente.

perms = {[
  [1, 2, 3, 6, 5, 4, 7, 8, 9], [1, 2, 3, 6, 9, 8, 5, 4, 7], [1, 2, 3, 6, 9, 8, 7, 4, 5], [1, 2, 5, 4, 7, 8, 9, 6, 3],
  [1, 4, 5, 2, 3, 6, 9, 8, 7], [1, 4, 7, 8, 5, 2, 3, 6, 9], [1, 4, 7, 8, 9, 6, 3, 2, 5], [1, 4, 7, 8, 9, 6, 5, 2, 3],
  [3, 2, 1, 4, 5, 6, 9, 8, 7], [3, 2, 1, 4, 7, 8, 5, 6, 9], [3, 2, 1, 4, 7, 8, 9, 6, 5], [3, 6, 5, 2, 1, 4, 7, 8, 9],
  [3, 6, 9, 8, 5, 2, 1, 4, 7], [3, 6, 9, 8, 7, 4, 1, 2, 5], [5, 4, 1, 2, 3, 6, 9, 8, 7], [5, 6, 3, 2, 1, 4, 7, 8, 9],
  [5, 8, 7, 4, 1, 2, 3, 6, 9], [5, 8, 9, 6, 3, 2, 1, 4, 7], [7, 4, 1, 2, 3, 6, 5, 8, 9], [7, 8, 5, 4, 1, 2, 3, 6, 9],
  [9, 8, 7, 4, 5, 6, 3, 2, 1], [7, 4, 5, 8, 9, 6, 3, 2, 1], [5, 4, 7, 8, 9, 6, 3, 2, 1], [3, 6, 9, 8, 7, 4, 5, 2, 1],
  [7, 8, 9, 6, 3, 2, 5, 4, 1], [9, 6, 3, 2, 5, 8, 7, 4, 1], [5, 2, 3, 6, 9, 8, 7, 4, 1], [3, 2, 5, 6, 9, 8, 7, 4, 1],
  [7, 8, 9, 6, 5, 4, 1, 2, 3], [9, 6, 5, 8, 7, 4, 1, 2, 3], [5, 6, 9, 8, 7, 4, 1, 2, 3], [9, 8, 7, 4, 1, 2, 5, 6, 3],
  [7, 4, 1, 2, 5, 8, 9, 6, 3], [5, 2, 1, 4, 7, 8, 9, 6, 3], [7, 8, 9, 6, 3, 2, 1, 4, 5], [9, 8, 7, 4, 1, 2, 3, 6, 5],
  [9, 6, 3, 2, 1, 4, 7, 8, 5], [7, 4, 1, 2, 3, 6, 9, 8, 5], [9, 8, 5, 6, 3, 2, 1, 4, 7], [9, 6, 3, 2, 1, 4, 5, 8, 7]
]}

ops = Vecsmall("+-*\\%; ")

ms = 1

for(c = 48, 57, {
 for(d = c, 57,
  for(f = d, 57,
   for(g = c, 57,
    for(e = 48, 57,
     print1(Strchr([c,d,e,f,g,13]));
     for(h = 1, #ops,
      for(i = 1, #ops,
       for(j = 1, #ops,
        for(k = 1, #ops,
         a = Vecsmall([c, ops[h], d, ops[i], e, ops[j], f, ops[k], g]);
         s = Set();
         for(m = 1, #perms,
          v = Strchr(vecextract(a, perms[m]));
          iferr(b = eval(v), E, b = 0);
          if(b >= 1 && b <= 40, s = setunion(s, [b]))
         );
         if(#s >= ms, ms = min(23, #s); print(#s, " ", Strchr(a), " ", s));
        )
       )
      )
     )
    )
   )
  )
 )
})

Peixe morto , 18

Este foi realmente o primeiro idioma que tentei antes de considerar os operadores de infix. Estou publicando agora pela pura hilaridade da idéia de que Deadfish poderia ser útil para alguma coisa.

iii
ios
sii

Para quem não conhece Deadfish, ié incrementado, sé quadrado e oé produzido, com o acumulador começando em 0 (também há uma quarta instrução dpara decremento não usada aqui). O fato de não termos impressão automática e precisamos usar oé uma grande desvantagem, mas surpreendentemente o Deadfish não é muito ruim aqui, considerando todas as coisas. Acontece que o posicionamento ideal do operador de saída está no meio.

iiisoisii 9
iiisiiois 11
iiisiisio 122
iioisiisi 2
iioiisiis 2
iisioiisi 5
iisiisiio 38
iisiisoii 36
iiiiosiis 4
iiiisiosi 17
iiiisiiso 324
isoiiisii 1
isiioiiis 3
isiisiiio 12
oiiiisiis 0
osiiiisii 0
oisiiiisi 0
oiisiiiis 0
siiiisoii 16
sioiiiisi 1
iisiosiii 5
sioiisiii 1
oisiisiii 0
isiisioii 10
siisiioii 6
isiioisii 3
oiisiisii 0
iiosiisii 2
siisoiiii 4
isoisiiii 1
osiisiiii 0
iisiiiosi 7
siiioiisi 3
oiiisiisi 0
siisiiiio 8
iisiiiiso 64
isiiiisio 26
siiiisiio 18
iiosiiiis 2
isiiiiois 5

Python REPL e muito mais, 22 23

6+7
*5%
6%4

Observação principal: Se você colorir a grade como um tabuleiro de damas, o caminho alterna as cores da grade à medida que avança e inicia e termina na mesma cor.

Ainda força bruta para melhor. Tentar com +*%(e mesmo **para idiomas onde a ^exponenciação) não resultou em nada melhor, infelizmente. Também tentei usar operadores bit a bit e apenas ^(xor) pareceu ajudar um pouco, mas a pesquisa estava demorando muito, então eu desisti.

6+7%5*6%4 6
6+7%4%5*6 24
6+7%4%6*5 21
6+5*6%4%7 8
6*5+7%4%6 33
6*6%5+7%4 4
6*6%4%7+5 5
6*6%4%5+7 7
7+6*5%4%6 9
7+6*6%5%4 8
7+6*6%4%5 7
7%5+6*6%4 2
7%4%5+6*6 39
7%4%6*6+5 23
5*6+7%4%6 33
5%7+6*6%4 5
5%6*6+7%4 33
5%4%7+6*6 37
6*6+7%5%4 38
6%5*6+7%4 9
4%6*5%7+6 12
6*5%4%7+6 8
5*6%4%7+6 8
7%4%6*5+6 21
6%4%7+5*6 32
4%7+5%6*6 34
5+7%4%6*6 23
7+5%4%6*6 13
6%4%5*6+7 19
4%5%6*6+7 31
5%4%6*6+7 13
4%6*6+5%7 29
6*6+5%4%7 37
5+6*6%4%7 5
6%4%7+6*5 32
4%6*6+7%5 26
4%7+6*6%5 5
6*6+7%4%5 39
4%5%7+6*6 40
4%7+6*5%6 4

J, 15

2 + 1
* 3 *
2 + 3

Isso gera apenas números válidos, mas muitos são duplicados. Os valores únicos são 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Definitivamente, você pode fazer melhor alterando operadores e números inteiros envolvidos.

2+1*3*2+3 -> 17
2+1*3+3*2 -> 11
2+1*3+2*3 -> 11
2+3*2+3*1 -> 17
2*3+1*3+2 -> 16
2*2+3+1*3 -> 16
2*2+3*1+3 -> 28
2*2+3*3+1 -> 28
1+2*3*3+2 -> 31
1+2*2+3*3 -> 23
1+2*2+3*3 -> 23
1*3+2*2+3 -> 13
1*3+3+2*2 -> 10
1*3+2*2+3 -> 13
3*2+1*3+2 -> 21
3*1+2*2+3 -> 33
3+2*2+1*3 -> 13
3+3*1+2*2 -> 18
2*2+1*3+3 -> 16
2+3*2+1*3 -> 17
3+2*3*1+2 -> 21
2*3+3*1+2 -> 24
3*2+3*1+2 -> 33
1*3+2*3+2 -> 13
2+3*1+3*2 -> 23
3*1+3+2*2 -> 24
3+1*3+2*2 -> 10
1+3*3+2*2 -> 22
2+3*3*2+1 -> 29
3*3+2*2+1 -> 27
3*3+2*2+1 -> 27
3+2*2+3*1 -> 13
2*2+3+3*1 -> 16
3+2*2+3*1 -> 13
2+3*1+2*3 -> 23
3+2*2+1*3 -> 13
3*1+2*2+3 -> 33
2*2+1*3+3 -> 16
3+3*1+2*2 -> 18
3*1+2*3+2 -> 33

> <>, 36 *

Se você tiver sorte o suficiente!

x;x
lxl
xnx

Como o desafio não exige que o código seja determinístico, precisamos apenas provar que é possível (mesmo que improvável) retornar 36 números e estamos prontos. Foi bom enquanto durou, eu acho.

(Para aqueles que não estão familiarizados com> <>, uma ótima introdução pode ser encontrada aqui )

> <> é uma linguagem 2D baseada em pilha. Isso significa que as instruções não são executadas linearmente como a maioria das linguagens tradicionais - o fluxo do programa pode ser superior, inferior, esquerdo ou direito!

Decidi usar a instrução "x" em> <>, que altera a direção dos ponteiros das instruções para cima, baixo, esquerda ou direita aleatoriamente. Como nosso código será apenas uma linha, isso significa que só podemos olhar para os casos quando ele for para a direita ou para a esquerda, pois se o ponteiro for para cima ou para baixo, ele apenas apertará a instrução "x" novamente.

A instrução "n" exibe o número na parte superior da pilha e o imprime. No entanto, se a pilha estiver vazia e não houver nada para aparecer, um erro será gerado.

A instrução "l" simplesmente empurra o comprimento da pilha para a pilha (e, para nossa sorte, ela não envia um erro se a pilha estiver vazia); portanto, por exemplo, se a pilha estiver vazia e "l" for chamado, ele colocaria 0 na pilha. Se agora chamarmos novamente "l", como a pilha possui um elemento (0), ela enviará 1 para o topo da pilha e agora isso significaria que haveria duas coisas na pilha e isso significaria que se formos chamar "l" novamente, colocaremos 2 na pilha, etc. Assim, podemos usar "l" para inserir um número arbitrário na pilha através do método mostrado anteriormente.

O ";" instrução termina o programa.

A idéia de usar "x" é que, por exemplo, se houver apenas um "x" no código (onde A, B, C, D são algumas instruções):

ABCx;D

O programa executaria A, então B e C, e, ao atingir "x", teríamos duas possibilidades: o código continuava indo para a direita e pressionava o ";" e sai ou vai para a esquerda e executa C, em seguida, B, em seguida, A, em seguida, D e só então sai. Portanto, se nosso código contiver um "x", o programa obterá dois fluxos possíveis de programas, dos quais podemos escolher o programa mais adequado.

Se houver dois ou mais "x" es, obteremos um número infinito de possíveis fluxos de programas.

Nosso código possui cinco "x" es, além disso, cada um deles está em uma "célula inicial" dos caminhos hamiltonianos, o que significa que todo programa começará com um "x" e todo programa terá a estrutura:

xAxBxCxDx

Onde A, B, C, D pertencem a {; , n, l, l} Isso significa que existem apenas 12 programas exclusivos. Além disso, como sempre começamos com um "x", podemos analisar o caso quando o programa for deixado, portanto, programas simétricos também podem ser considerados iguais. Até simetria, existem apenas 6 programas possíveis diferentes. Apenas 4 deles ocorrem nos programas gerados como caminhos hamiltonianos:

xnxlxlx;x
xlxnxlx;x
xnxlx;xlx
xlxnx;xlx

Vejamos o primeiro programa "xnxlxlx; x" se dermos certo no primeiro passo, apertarmos o comando de impressão, o que gerará um erro, pois não temos nada na pilha. Se formos para a esquerda, pressionamos o comando final do programa. Portanto, não podemos produzir nenhum número desses programas.

O segundo programa, "xlxnxlx; x", é muito mais esperançoso, pois, ao irmos para a direita no início, um zero é colocado na pilha; se formos para a esquerda no próximo "x", nossa pilha ganha um, indo para a direita novamente, temos um 2 que podemos imprimir e continuar indo para o final do programa. Podemos observar que, na verdade, podemos imprimir qualquer número par , pois na parte "xlx", no início, podemos atingir um tamanho arbitrário, indo para a direita, para a esquerda e para a direita novamente, um certo número de vezes.

Da mesma forma, pode-se ver que o terceiro programa xnxlx; xlx pode gerar qualquer número ímpar , indo para a esquerda no início e depois repetindo a rotina "xlx" somente desta vez indo para a esquerda, direita e esquerda.

E o quarto programa é essencialmente o mesmo que o segundo programa e pode gerar qualquer número par .

Portanto, para os programas necessários, temos:

x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)

São 4 programas que não podem emitir números, 20 que podem gerar qualquer número par, 16 que podem gerar qualquer número ímpar. Como existem exatamente 20 números pares e pelo menos 16 números ímpares no intervalo de 1 a 40, com uma certa probabilidade, existe a possibilidade de haver 36 números diferentes no intervalo de 1 a 40 emitidos por esse bloco de código.

GolfScript, 8

192
6#7
281

Atualmente, a solução com maior pontuação. : P Foi legal enquanto durou.

Programas

1927#6281 1927
192718#62 192718
19271826# 19271826
19#628172 19
16#927182 16
1628#9271 1628
16281729# 16281729
162817#92 162817
2916#7182 2916
291628#71 291628
29162817# 29162817
27#916281 27
2718#9162 2718
27182619# 27182619
#61927182 
#72916281 
#82619271 
#81729162 
261927#81 261927
28#619271 28
1826#7291 1826
26#817291 26
#62817291 
271826#91 271826
281729#61 281729
1729#8261 1729
#92718261 
29#718261 29
2817#6192 2817
17#826192 17
#71826192 
182619#72 182619
2619#8172 2619
#91628172 
28172916# 28172916
18261927# 18261927
17291628# 17291628
26192718# 26192718
18#729162 18
172916#82 172916

CJam, 14

3(4
;];
0)1

Abaixo os programas de trabalho:

3(4;];0)1 = 11
3(4;1)0;] = 22
3(];0)1;4 = 14
3;0)](4;1 = 11
3;0)1;4(] = 13
3;0)1;](4 = 14
4(3;];1)0 = 20
4(3;0)];1 = 1
4(3;0)1;] = 31
4;1)](3;0 = 20
4;1)0;3(] = 22
0;3(4;])1 = 21
0)];3(4;1 = 21
1)0;];4(3 = 33
4;1)0;](3 = 23
0)1;4(];3 = 3
1;4(])0;3 = 33
4(];1)0;3 = 23
0)1;];3(4 = 24
1)0;3(];4 = 4
0;3(])1;4 = 24
0)1;4(3;] = 13
1)0;3(4;] = 22
1;4(3;0)] = 31
0;3(4;1)] = 22
1)];4(3;0 = 30
1;4(3;])0 = 30

Os valores gerados são: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]

dc (20)

2+3
*p+
4+5

ABCFEDGHI -> 2+3+p*4+5 -> 5     $ **
ABCFIHEDG -> 2+3+5+p*4 -> 10    $ **
ABCFIHGDE -> 2+3+5+4*p -> 40    $ **
ABEDGHIFC -> 2+p*4+5+3 -> 2     $ **
ADEBCFIHG -> 2*p+3+5+4 -> 2       **
ADGHEBCFI -> 2*4+p+3+5 -> 6     $ **
ADGHIFCBE -> 2*4+5+3+p -> 14    $ **
ADGHIFEBC -> 2*4+5+p+3 -> 11    $ **
CBADEFIHG -> 3+2*p+5+4 -> 6       **
CBADGHEFI -> 3+2*4+p+5 -> 10      **
CBADGHIFE -> 3+2*4+5+p -> 15    $ **
CFEBADGHI -> 3+p+2*4+5 -> 3     $ **
CFIHEBADG -> 3+5+p+2*4 -> 8     $ **
CFIHGDABE -> 3+5+4*2+p -> 34    $ **
EDABCFIHG -> p*2+3+5+4 -> 
EFCBADGHI -> p+3+2*4+5 -> 
EHGDABCFI -> p+4*2+3+5 -> 
EHIFCBADG -> p+5+3+2*4 -> 
GDABCFEHI -> 4*2+3+p+5 -> 9     $ **
GHEDABCFI -> 4+p*2+3+5 -> 4     $ **
IHGDEFCBA -> 5+4*p+3+2 -> 20    $ **
GDEHIFCBA -> 4*p+5+3+2 -> 4       **
EDGHIFCBA -> p*4+5+3+2 -> 
CFIHGDEBA -> 3+5+4*p+2 -> 32    $ **
GHIFCBEDA -> 4+5+3+p*2 -> 12    $ **
IFCBEHGDA -> 5+3+p+4*2 -> 8       **
EBCFIHGDA -> p+3+5+4*2 -> 
CBEFIHGDA -> 3+p+5+4*2 -> 3       **
GHIFEDABC -> 4+5+p*2+3 -> 9       **
IFEHGDABC -> 5+p+4*2+3 -> 5       **
EFIHGDABC -> p+5+4*2+3 -> 
IHGDABEFC -> 5+4*2+p+3 -> 22    $ **
GDABEHIFC -> 4*2+p+5+3 -> 6       **
EBADGHIFC -> p+2*4+5+3 -> 
GHIFCBADE -> 4+5+3+2*p -> 24    $ **
IHGDABCFE -> 5+4*2+3+p -> 25    $ **
IFCBADGHE -> 5+3+2*4+p -> 20      **
GDABCFIHE -> 4*2+3+5+p -> 14      **
IHEFCBADG -> 5+p+3+2*4 -> 5       **
IFCBADEHG -> 5+3+2*p+4 -> 16    $ **

32 saídas, 20 delas distintas (marcadas com a $)

2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 14, 15, 16, 20, 22, 24, 25, 32, 34, 40