40 números en 9 bytes

40

Hay 40 formas en que se puede organizar una ruta Hamiltoniana dirigida en una cuadrícula de 3 × 3:
los 20 caminos hamiltonianos no dirigidos de 3 & times3;  cuadrícula
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.

Pasatiempos de Calvin
fuente
14
-1, el desafío no contiene ninguna referencia a las banderas
Alex A.
@ Sp3000 ¿La disposición de la imagen está en un orden particular? (Asumo que para el desafío el orden no es importante, pero me muero de curiosidad por la imagen. Particularmente, si estos se usaron como semillas en un Sistema L para una curva espacial de Hilbert, ¿hay una codificación natural para la imagen? set?)
luser droog
@luserdroog Bueno, Sp hizo la imagen , mejor preguntarle.
Aficiones de Calvin
@luserdroog Si numera las celdas del 1 al 9, deben estar en orden lexicográfico, por ejemplo, la primera es123654789
Sp3000
@luserdroog (es decir, elegir la lexicográficamente-anterior representante de cada par de caminos dirigidos, y luego ordenar esos 20 representantes lexicográficamente.)
mathmandan

Respuestas:

27

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));
        )
       )
      )
     )
    )
   )
  )
 )
})
primo
fuente
Por desgracia, un programa Perl no genera su último valor. Una subrutina Perl sí, pero una subrutina tiene llaves. ( "La firma es parte del cuerpo de una subrutina. Normalmente, el cuerpo de una subrutina es simplemente un bloque de código entre paréntesis" ). Así que no creo que esto sea factible en Perl.
msh210
29

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
Sp3000
fuente
25

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
Sp3000
fuente
55
Siguiente tarea: escribir un programa que genere el programa con los valores más exclusivos. Entonces golf ese programa. :)
Reto Koradi
@RetoKoradi La primera parte es lo que hice. El segundo ... más tarde: P
Sp3000
@ Sp3000 Terminé la fuerza bruta de este estilo de solución. Hay 6+7*5%6%4, 6+7*4%6%5y 6+8*4%6%5(de izquierda a derecha, de arriba a abajo), y nada más.
isaacg
1
@isaacg hay más soluciones de 23 puntos si agrega algunos operadores más, como & | ^
Sparr
Solo un pensamiento aleatorio: ¿Has intentado permitir +y -en las esquinas / centro? Dado que son operadores unarios y binarios, eso debería dar como resultado todas las expresiones válidas. Es poco probable que resulte en una mejor solución, pero al menos expande el espacio de búsqueda. Hmm, en realidad, podría ser un problema porque podrías terminar con secuencias de operadores.
Reto Koradi
13

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
Fatalizar
fuente
Por cierto, ¡felicidades por golpear 1k rep! :)
Alex A.
@AlexA. Golpeando 1k en una respuesta J, después de nada más que respuestas Prolog Infiel ...
Fatalize
8
Está bien, estoy seguro de que Prolog lo entenderá.
Alex A.
3
@AlexA. Yes.
John Dvorak
@ JanDvorak ¿Estás hablando en nombre de Prolog?
Alex A.
11

> <>, 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.

cirpis
fuente
11
36 se siente terriblemente subóptimo para una respuesta que es efectivamente abuso de laguna legal
Sp3000
A veces desearía que los peces tuvieran una instrucción para "imprimir lo último en la pila y salir" que sería de gran ayuda. Sin embargo, pronto podría tener una respuesta de escapatoria completamente óptima
cirpis
Honestamente olvidé agregar una regla sobre no contar los programas no deterministas. Lo he agregado ahora. Puedes seguir con esto porque es inteligente y está bien explicado, pero no aceptaré esta respuesta.
Aficiones de Calvin
1
Claro, esta respuesta no pretendía ser una respuesta competitiva de todos modos, fue más una reacción instintiva cuando estaba leyendo este desafío y pensé en tener una respuesta de pez.
cirpis
9

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
Dennis
fuente
1
mientras duró ... durante 30 minutos ..
Optimizer
2
Lo mejor que pude encontrar para GolfScript es 0)1#2#3(4en 15. Hermosa simetría también.
primo
1
@primo: Eso es inteligente. No pensé que más comentarios mejorarían la puntuación.
Dennis
8

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]

Arnaud
fuente
¿Es este código que escribiste manualmente? ¿O enumeró y evaluó sistemáticamente las variaciones de código? Me he estado preguntando si un lenguaje con notación infija podría ser inherentemente mejor para esto, o si es posible vencer el enfoque de @ Sp3000 con un lenguaje de golf basado en stack.
Reto Koradi
@Reto Escribí un programa que probó todos los valores 0..9 para los 4 parámetros numéricos. También intenté cambiar manualmente algunos operadores. El problema con un lenguaje basado en la pila es que la mayoría de los operadores necesitan 2 parámetros en la pila, por lo tanto, tenemos muchos errores. Los idiomas infijos se benefician de la estructura de verificación descrita por Sp3000 en su publicación.
Arnaud
Sí, eso fue exactamente lo que sentí cuando vi el enfoque básico. Tener una disposición simple que garantice generar todas las expresiones válidas es una gran ventaja. La única ventaja de CJam es que tiene muchos más operadores de una letra.
Reto Koradi
5

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


fuente