Hay 40 formas en que se puede organizar una ruta Hamiltoniana dirigida en una cuadrícula de 3 × 3:

este gráfico (¡ gracias Sp3000! ) Muestra solo las 20 rutas no dirigidas. Atraviese cada línea de color en ambas direcciones para los 40 caminos dirigidos.

Reto

Usando solo ASCII imprimible , escriba una cuadrícula de caracteres de 3 × 3, como:

ABC
DEF
GHI

Cuando cada una de las 40 rutas dirigidas se lee de esta cuadrícula como 40 programas de una línea y 9 caracteres, el objetivo es que cada programa genere un número entero único del 1 al 40. Hacer esto para las 40 rutas parece difícil e improbable, así que solo necesitas hacer que funcione para tantos caminos como puedas.

El envío cuyos 40 programas de ruta generen los números más distintos del 1 al 40 será el ganador. Tiebreaker va a la presentación anterior.

Los programas de ruta que producen errores o no generan un número entero de 1 a 40 o generan un número entero que otro programa de ruta ya cubierto no se cuenta. Específicamente:

• Los programas que producen errores al compilar, ejecutar o salir no se cuentan. Las advertencias están bien.
• Los programas que no generan un número entero de 1 a 40 o que emiten algo ligeramente mal formado como -35o 35 36no se cuentan.
• Los programas que requieren la entrada del usuario para producir la salida no se cuentan.
• Los programas que nunca terminan no se cuentan.
• De ahora en adelante , los programas que no son deterministas no se cuentan.
• De lo contrario, no se cuentan los programas válidos que generan un número entero de 1 a 40 que otro programa válido ya ha generado. (El primer programa se contó.)
• Solo los programas que generan representaciones enteras de números del 1 al 40 (inclusive) se cuentan para su total. Se espera que los números para estar en el habitual 1, 2, ..., 39, 40formato, a menos que no es la norma para su idioma. (Una nueva línea final en la salida está bien).
• No importa qué números generan sus programas y en qué orden están. Solo importa el número de enteros distintos de los programas válidos.

Todos los programas de ruta deben ejecutarse en el mismo idioma. Sin embargo, los "programas" pueden ser funciones (sin argumentos necesarios) o comandos REPL , así como programas completos, que imprimen o devuelven su entero objetivo. Puede mezclar y combinar funciones, comandos REPL y programas completos.

Sus 9 caracteres ASCII imprimibles no necesitan ser distintos.

Ejemplo

Si tu cuadrícula de 3 × 3 fuera

ABC
DEF
GHI

y sus 40 programas y salidas se veían así

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"

su puntaje sería 14, porque hay 14 enteros distintos de 1 a 40 de salida válida, a saber 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 los espacios entre dígitos, de modo que 1 8 2, por ejemplo, se trata como 182. Lo mismo podría funcionar para Perl al reemplazar los espacios con guiones bajos. No he agotado todo el espacio de búsqueda, por lo que puede haber mejores candidatos.

Un programa puede ser alimentado a gp como gp -q -f program.gp, o interactivamente en la respuesta.

Salida

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 menos 4 valores están dentro del rango requerido, con 12 entradas duplicadas.

Actualizar

He terminado de procesar, hay seis 23 distintos, y solo uno 24 (como se lee por filas):

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]

El programa que utilicé para el crujido está debajo. PARI / GP tiene capacidades limitadas de procesamiento de cadenas, así que trata principalmente con matrices de caracteres (aka Vecsmall). Los operadores probados son +, -, *, \(div piso), %, ;(separador de expresión, esencialmente descartes todo antes de ella), y (espacio, como se describe anteriormente). El operador exponente ^también podría agregarse, pero se vuelve demasiado lento para probar exhaustivamente.

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));
        )
       )
      )
     )
    )
   )
  )
 )
})

Deadfish , 18

Este fue realmente el primer idioma que probé antes de considerar operadores infix. Lo estoy publicando ahora por la pura hilaridad de la idea de que Deadfish podría ser útil para algo.

iii
ios
sii

Para aquellos que no conocen Deadfish, ies incremental, ses cuadrado y ose emite, con el acumulador comenzando en 0 (también hay una cuarta instrucción dpara la disminución que no se usa aquí). El hecho de que no tengamos impresión automática y necesitemos usarlo oes un gran inconveniente, pero sorprendentemente a Deadfish no le va demasiado mal aquí, considerando todo. Resulta que la ubicación óptima del operador de salida está en el medio.

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 y muchos más, 22 23

6+7
*5%
6%4

Observación clave: si colorea la cuadrícula como un tablero de ajedrez, la ruta alterna los colores de la cuadrícula a medida que avanza y comienza y termina en el mismo color.

Todavía fuerza bruta para mejorar. Intentar con +*%(e incluso **para los idiomas donde ^hay exponenciación) no mostró nada mejor, desafortunadamente. También intenté incluir operadores bit a bit y solo ^(xor) pareció ayudar levemente, pero la búsqueda tardó demasiado, así que me di por vencido.

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

Esto genera solo números válidos, pero muchos son duplicados. Los valores únicos son 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Definitivamente puede hacerlo mejor cambiando los operadores y los enteros involucrados.

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 *

Si tienes la suerte!

x;x
lxl
xnx

Dado que el desafío no requiere que el código sea determinista, solo tenemos que demostrar que es posible (incluso si es improbable) devolver 36 números y hemos terminado. Fue bueno mientras duró, supongo.

(Para aquellos que no están familiarizados con> <>, se puede encontrar una gran introducción aquí )

> <> es un lenguaje 2D basado en pila. Esto significa que las instrucciones no se ejecutan linealmente como la mayoría de los lenguajes tradicionales: ¡el flujo del programa puede ser arriba, abajo, izquierda o derecha!

Decidí usar la instrucción "x" en> <>, que cambia la dirección de los punteros de instrucción a arriba, abajo, izquierda o derecha al azar. Dado que nuestro código solo será una línea, eso significa que solo podemos ver los casos cuando va hacia la derecha o hacia la izquierda, ya que si el puntero sube o baja, simplemente volverá a presionar la instrucción "x".

La instrucción "n" muestra el número en la parte superior de la pila y lo imprime. Sin embargo, si la pila está vacía y no hay nada que resaltar, se genera un error.

La instrucción "l" simplemente empuja la longitud de la pila sobre la pila (y por suerte para nosotros, no envía un error si la pila está vacía), por ejemplo, si la pila estuviera vacía y se llamaría "l", se empujaría 0 a la pila. Si ahora volviéramos a llamar "l", entonces, dado que la pila tiene un elemento (0), empujaría 1 a la parte superior de la pila y ahora eso significaría que habría dos cosas en la pila y eso significaría que si volviéramos a llamar a "l", empujaríamos 2 a la pila, etc. De modo que podemos usar "l" para empujar un número arbitrario a la pila mediante el método mostrado anteriormente.

Los ";" La instrucción termina el programa.

La idea de usar "x" es que, por ejemplo, si solo hubiera una "x" en el código (donde A, B, C, D son algunas instrucciones):

ABCx;D

El programa ejecutaría A, luego B y luego C, y al llegar a "x" tendríamos dos posibilidades: el código continúa yendo hacia la derecha y toca ";" y sale o va a la izquierda y ejecuta C, luego B, luego A y luego D, y solo luego sale. Entonces, si nuestro código contiene una "x", el programa gana dos flujos de programa posibles de los cuales podemos elegir el programa más adecuado.

Si hay dos o más "x" es, entonces ganamos un número infinito de posibles flujos de programa.

Nuestro código tiene cinco "x" es, además cada uno de ellos está en una "celda inicial" de las rutas de Hamilton, lo que significa que cada programa comenzará con una "x", y cada programa tendrá la estructura:

xAxBxCxDx

Donde A, B, C, D pertenecen a {; , n, l, l} Esto significa que solo hay 12 programas únicos. Además, dado que siempre comenzamos con una "x", podemos ver el caso cuando el programa sale a la izquierda, por lo que los programas simétricos también pueden considerarse iguales. Hasta la simetría, solo hay 6 programas posibles diferentes. Solo 4 de ellos ocurren en los programas generados como caminos hamiltonianos:

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

Veamos el primer programa "xnxlxlx; x" si vamos directamente al primer paso, presionamos el comando de impresión que generará un error ya que no tenemos nada en la pila. Si vamos a la izquierda, presionamos el comando de finalización del programa. Por lo tanto, no podemos generar ningún número de estos programas.

El segundo programa, "xlxnxlx; x", es mucho más esperanzador, ya que al ir a la derecha al principio se pone un cero en la pila, si luego vamos a la izquierda en la próxima "x", nuestra pila gana un uno, luego yendo a la derecha nuevamente tenemos un 2 que luego podemos imprimir y continuar yendo a la derecha para finalizar el programa. Podemos observar que en realidad podemos imprimir cualquier número par , ya que en la parte "xlx" al principio podemos alcanzar un número de tamaño arbitrario yendo a la derecha, luego a la izquierda y a la derecha nuevamente una cierta cantidad de veces.

De manera similar, se puede ver que el tercer programa xnxlx; xlx puede generar cualquier número impar , yendo a la izquierda al principio y luego repitiendo la rutina "xlx" solo esta vez yendo a la izquierda, luego a la derecha y luego a la izquierda.

Y el cuarto programa es esencialmente el mismo que el segundo programa y puede generar cualquier número par .

Entonces, para los programas requeridos tenemos:

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)

Son 4 programas que no pueden generar números, 20 que pueden generar cualquier número par, 16 que pueden generar cualquier número impar. Dado que hay exactamente 20 números pares y al menos 16 números impares en el rango de 1 a 40, entonces con una cierta probabilidad existe la posibilidad de que haya 36 números diferentes en el rango de 1 a 40 producidos por este bloque de código.

GolfScript, 8

192
6#7
281

Actualmente la solución de mayor puntuación. :PAGS Fue agradable mientras duró.

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

Debajo de los programas de trabajo:

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

Los valores generados son: [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 salidas, 20 de ellas distintas (marcadas con un $ )

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