Debería escribir un programa de Brainfuck (BF) de 100 bytes de longitud.

Un personaje se eliminará de todas las formas posibles de los 100 nuevos programas resultantes (99 bytes de longitud). Por ejemplo, para el programa de ++.>.las 5 subprogramas son +.>., +.>., ++>., ++..y ++.>.

Su puntaje será el número de resultados únicos que generan los 100 programas. Mayor puntaje es mejor.

Detalles

• Sus programas finalizarán después de generar el primer carácter.
• Los programas no válidos o que no terminan y los programas que generan salidas vacías no se cuentan para la puntuación.
• Las celdas BF son envolturas de 8 bits. (255 + 1 = 0, 0-1 = 255)
• Su programa no recibe ninguna entrada. Si usa ,en el código, establece la celda actual en 0.
• No hay celdas en el lado izquierdo de la posición inicial. Por ejemplo, <.no es válido pero .<es válido ya que la ejecución finaliza en .. La cinta no tiene límites en la otra dirección.
• Los programas con corchetes desequilibrados ( [y ]) no son válidos.
• Su programa original puede tener menos de 100 bytes, ya que es fácil extenderlo a 100 bytes sin cambiar la puntuación.
• Su programa original no tiene que ser un código BF válido.

Puede usar este programa python3 (enlace ideone) para determinar el puntaje de su respuesta. (Para programas de larga ejecución, es posible que deba modificar la maxstepvariable).

Ejemplo

(Para simplificar, este programa es más corto que 100 bytes).

Solution: ++,+[-]+><.-,-.

Score: 3

Explanation:

Subprogram     => Output

+,+[-]+><.-,-. => 1
+,+[-]+><.-,-. => 1
+++[-]+><.-,-. => 1
++,[-]+><.-,-. => 1
++,+-]+><.-,-. => None
++,+[]+><.-,-. => None
++,+[-+><.-,-. => None
++,+[-]><.-,-. => 0
++,+[-]+<.-,-. => None
++,+[-]+>.-,-. => 0
++,+[-]+><-,-. => 255
++,+[-]+><.,-. => 1
++,+[-]+><.--. => 1
++,+[-]+><.-,. => 1
++,+[-]+><.-,- => 1

Unique outputs are [0, 1, 255]    
Score is 3 for ++,+[-]+><.-,-. (length = 15)

En caso de empate, el ganador es el que tiene el código más corto. (Su programa puede tener menos de 100 bytes como se indica en la sección Detalles). Si los códigos tienen la misma longitud, el ganador es el cartel anterior.

Bonus puzzle: sin la restricción en negrita, ¿puedes encontrar un programa con puntaje 100?

Puntuación: 35 41 69 78 79 83

(Elimine la nueva línea).

-->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>-
>+>->+>->+>->+>->+>->+>->+>->+>++[>[-<+++>]<<++]>.

Pruébalo en línea!

No estoy seguro exactamente por qué funciona ...

Puntuación: 79

X->>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>
+>+>+>+>+>+>+>+>+>+>+>+[>[-<+>>+<]+>[-<+>]<<<+]>>.

Pruébalo en línea!

Se suponía que debía sumar 2 * mem [i] * i y agregar el número de celdas (+ const) donde las direcciones se cuentan de derecha a izquierda. El multiplicador 2 y el número de celdas pueden hacer que eliminar + y> tengan una paridad diferente.

De hecho, funcionó así en la versión de 69 puntos. Pero la última versión rompió eso y obtuvo algo más por coincidencia. Calcula la suma (mem [i] * i + i + 1) y eliminar + y> hace casi lo mismo, excepto por la suma (i) que tiene una diferencia del número de celdas, que también es el número de resultados diferentes para eliminar + y>.

Por el bono:

+. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +.

Puntuación: 37 43

+>-,->,+-><->-[>---+-+<[--->>+><,+>>>++<><<<+<[>--]]><><+-+>+<<+<><+++<[[<[---->-<-]>++>],>,]<,]<+-.

EDITAR: ahora mi programa permite algunos corchetes. No voy a ganar ningún premio con eso, pero eso es lo que obtengo por hacer que algunos RNG pesados ​​hagan el trabajo ocupado por mí.

Esto fue generado por un programa que escribí en C.

Para cada Ncarácter eliminado, aquí están las salidas:

N = 0 => 158
N = 1 => 158
N = 2 => 158
N = 3 => 187
N = 4 => 129
N = 5 => 100
N = 6 => 158
N = 7 => 13
N = 8 => 1
N = 9 => 211
N = 10 => 129
N = 11 => 1
N = 12 => 57
N = 13 => 255
N = 14 => Mismatched Braces
N = 15 => 59
N = 16 => 11
N = 17 => 11
N = 18 => 11
N = 19 => 117
N = 20 => 11
N = 21 => 117
N = 22 => 166
N = 23 => Mismatched Braces
N = 24 => 206
N = 25 => 206
N = 26 => 206
N = 27 => 147
N = 28 => 147
N = 29 => 158
N = 30 => 148
N = 31 => 188
N = 32 => 51
N = 33 => 17
N = 34 => 84
N = 35 => 84
N = 36 => 84
N = 37 => 158
N = 38 => 158
N = 39 => 94
N = 40 => 46
N = 41 => 94
N = 42 => 94
N = 43 => 94
N = 44 => 17
N = 45 => 196
N = 46 => Mismatched Braces
N = 47 => 149
N = 48 => No Termination
N = 49 => No Termination
N = 50 => Mismatched Braces
N = 51 => Mismatched Braces
N = 52 => 45
N = 53 => 77
N = 54 => 45
N = 55 => 77
N = 56 => 50
N = 57 => 209
N = 58 => 50
N = 59 => 251
N = 60 => 249
N = 61 => 99
N = 62 => 99
N = 63 => 117
N = 64 => 89
N = 65 => 207
N = 66 => 89
N = 67 => 115
N = 68 => 115
N = 69 => 115
N = 70 => 95
N = 71 => Mismatched Braces
N = 72 => Mismatched Braces
N = 73 => 104
N = 74 => Mismatched Braces
N = 75 => No Termination
N = 76 => No Termination
N = 77 => No Termination
N = 78 => No Termination
N = 79 => Left Overflow
N = 80 => 3
N = 81 => 2
N = 82 => No Termination
N = 83 => Mismatched Braces
N = 84 => No Termination
N = 85 => 133
N = 86 => 133
N = 87 => 0
N = 88 => Mismatched Braces
N = 89 => 158
N = 90 => 0
N = 91 => 4
N = 92 => Mismatched Braces
N = 93 => 0
N = 94 => 158
N = 95 => Mismatched Braces
N = 96 => 0
N = 97 => 157
N = 98 => 159
N = 99 => None

Hay un total de 37 salidas únicas, que son (en orden numérico):

0, 1, 2, 3, 4, 11, 13, 17, 45, 46, 50, 51, 57, 59, 77, 84, 89, 94, 95, 99,
100, 104, 115, 117, 129, 133, 147, 148, 149, 157, 158, 159, 166, 187, 188, 
196, 206, 207, 209, 211, 249, 251, 255

Estoy 90% 100% seguro de que esta solución no es óptima , pero estoy probando que puede ser extremadamente difícil . Hay algunas cosas que están claras. No tener .símbolos hasta el último carácter parece ser el camino a seguir , y los corchetes ( []) parecen ser bastante inútiles . Pensé un poco aquí, lo que me gustaría resumir:

Sea Lla longitud del código en bytes (en el desafío 100) y nel número de salidas únicas de los subprogramas.

Para L=3, hay varias soluciones óptimas de la forma +-., donde n=2(en este caso, las salidas son 1 y 255 para +.y -., respectivamente.) Esto pone la mejor relación para L = 3at n/L = 66.67%. Tenga en cuenta que esta proporción no puede ser superada por al menos L<10.

Para L=10, las soluciones son lo suficientemente simples como para aplicar fuerza bruta. Aquí están todas las mejores soluciones, en n = 6:

++>-->+<+. => 6
++>-->+<+. => 6
+++>->+<+. => 6
--->->+<+. => 6
++>---><+. => 6
+++>--><+. => 6
-->++>-<-. => 6
+++>+>-<-. => 6
--->+>-<-. => 6
-->+++><-. => 6
--->++><-. => 6

Lo que produce una relación de puntuación de n/L = 60%.

Como L->infinity, está claro que la relación debe acercarse a 0, ya que solo hay 255 posibles salidas para un potencial infinito L.

Sin embargo, la relación NO disminuye uniformemente. No es posible construir una solución para n=6, L=9, por lo que la mejor relación posible para L=9es 5/9 = 55.56% < 60%.

Esto plantea la pregunta, ¿qué tan rápido y en qué materia desciende la relación? Para L = 100, y en 10^9 checks/second, tomaría varios órdenes de magnitud más tiempo que la vida del universo para imponer una solución óptima. ¿Hay una manera elegante de hacer esto? Dudo mucho que se ha reducido a 37%para L = 100.

La proporción en realidad aumenta, hasta L=100. Ver otras respuestas para confirmar.

Me encantaría escuchar sus evaluaciones de lo anterior. Yo podría estar era atrozmente mal, después de todo.