Todos esos castores ocupados hicieron un desastre. Escribieron por toda la cinta. A este ritmo, nuestro vecino dejará de prestarnos cintas ilimitadas.

Necesitamos una nueva forma de jugar al ocupado juego de castores, uno que no arruine todas las cintas que usamos.

Las normas

Brainfuck solo. La cinta de memoria no tiene límites en ambos sentidos. La instrucción de entrada siempre leerá , por lo que puede usarse para borrar un valor.$0$

Límite de origen de 50 bytes.

Al final de la ejecución, la memoria debe ser todo s.$0$

El puntaje es la distancia entre la ubicación inicial y la ubicación final del puntero de memoria: si se necesitan instrucciones de movimiento para ir entre ellos, su puntaje es$n$ . Más alto es mejor. Proporcione un valor exacto si puede, de lo contrario proporcione una estimación.$n$

Ejemplo

32 bytes, $2^{255}-1$

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

Explicación

-                                Initialize the list to [255].
 [                             ] Repeat as long as the list is not empty.
 [-                            ] Decrement the left end. We need to shrink the numbers so it ends eventually.
 [ [                         ] ] Skip if 0 already.
 [ [[>]                      ] ] Move to the cell past the right end.
 [ [   +                     ] ] Make this cell 1.
 [ [    >                    ] ] Go right again.
 [ [     +                   ] ] Make this cell 1. We've now appended [1, 1].
 [ [      [<]>               ] ] Go back to the first nonzero cell on the left.
 [ [          -              ] ] And decrement it.
 [ [           [            ]] ] We will need to transfer the rest of the number from the left to the right, so keep looping.
 [ [           [[>]<        ]] ] Go to the last nonzero cell on the right.
 [ [           [    +<+     ]] ] Increment this and the one on the left. These are the cells we appended earlier. We transfer to them.
 [ [           [       [<]> ]] ] Go back to the first nonzero cell on the left, which we are transferring from.
 [ [           [           -]] ] Decrement here on the left to balance out the incrementing on the right.
 [                            >] We end the iteration on a now empty cell. Move right, the new left end is there.

Comenzamos con la lista . En cada iteración, consumimos el valor n a la izquierda de la lista, y si n > 1 , agregamos [ n - 1 , n - 1 ] a la derecha. Los números agregados ( n - 1 ) son más bajos que el original ( n ) , por lo que se harán más pequeños hasta que sean 1 , momento en el que se consumen sin expandirse. Por lo tanto, el proceso termina eventualmente, con todos$[255]$$n$$n>1$$[n-1, n-1]$$(n-1)$$(n)$$1$$0$s en la memoria. Sin embargo, en cada paso, el número de copias del número se duplica. El puntaje de este programa inicializado con la lista es 2 n - $[n]$$2^n-1$ .

Este ejemplo pretende mostrar algunas de las técnicas utilizadas en la creación de un envío. No es competitivo por su tamaño.

$A(255, 2) - 1 = (2 \uparrow^{253} 5) - 4$

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

$A$[-[<+>>[-<[->+<]+>>]+<-]>[>]+[<]+<]$A(m,n)$1 - m, m, 1 <n times>m$A(m,n)$ , comenzando inmediatamente a la derecha del puntero.

Usé el siguiente programa de Python para modelar el comportamiento del programa:

def a(M, N):
    assert M > 0
    m = [-M + 1, M]
    n = N
    while m[-1]:
        while m[-1] > 1:
            m[-1] -= 1
            m[-2] += 1
            while n:
                m.insert(-1, 1)
                n -= 1
            n = 1
        n += 2
        m.pop()
    return n