Все эти занятые бобры устроили беспорядок. Они написали по всей ленте. В таком случае наш сосед перестанет одалживать нам неограниченные ленты.

Нам нужен новый способ играть в игру занятого бобра, который не разрушает каждую используемую нами ленту.

Правила

Только Brainfuck. Лента памяти неограничена в обоих направлениях. Инструкция ввода всегда будет читать , поэтому ее можно использовать для очистки значения.$0$

Ограничение в 50 байтов.

В конце выполнения память должна быть все с.$0$

Оценка - это расстояние между начальным положением указателя памяти и конечным положением - если для перемещения между ними требуется инструкций перемещения, ваш результат равен . Чем выше, тем лучше. Укажите точное значение, если можете, в противном случае предоставьте оценку.$n$$n$

пример

32 байта,$2^{255}-1$

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

объяснение

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

Начнем со списка . На каждой итерации мы используем значение слева от списка, а если , мы добавляем справа. Числа, добавленные , ниже, чем исходные , поэтому они будут уменьшаться до тех пор, пока не станут , после чего они расходуются без расширения. Таким образом, процесс заканчивается в конце концов, все с в памяти. Однако на каждом шаге количество копий этого номера удваивается. Оценка этой программы, инициализированной списком составляет .n n > 1 [ n - 1 , n - 1 ] ( n - 1 ) ( n ) 1 0 [ n ] 2 n - $[255]$$n$$n>1$$[n-1, n-1]$$(n-1)$$(n)$$1$$0$$[n]$$2^n-1$

Этот пример предназначен для демонстрации некоторых методов, используемых при создании представления. Это не конкурентоспособно для его размера.

Оценка:$A(255, 2) - 1 = (2 \uparrow^{253} 5) - 4$

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

A ( м , н ) A ( м , н $A$ вот формулировка Петера-Аккермана для функции Аккермана , в то время как в другом выражении оценки используется нотация со стрелкой вверх Кнута. 35-байтовый основной цикл [-[<+>>[-<[->+<]+>>]+<-]>[>]+[<]+<]можно использовать для вычисления , поместив на ленту значения и войдя в цикл с указателем на ячейку. После завершения цикла ненулевое содержимое ленты - это , начиная сразу справа от указателя.$A(m,n)$1 - m, m, 1 <n times>m$A(m,n)$

Я использовал следующую программу на Python для моделирования поведения программы:

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