Напечатайте 'A' 1000 раз с BrainFuck

Какой код BrainFuck лучше всего (с точки зрения размера кода) печатать «А» 1000 раз?

Мой подход:

установить «А» в р [0]
установите 255 в p [1] для отображения 255 'A', 3 раза
установите 235 в p [1] для отображения 235 'A'

Это не эффективно, но я не могу найти способ использовать счетчики буксировки одновременно, как умножение

Есть ли лучший подход, чем умножение?

Более общий вопрос: существует ли правило для умножения с большим числом с наименьшим возможным кодом?

code-golf tips brainfuck Нельсон Г.
источник

Это хорошее место для начала. Добро пожаловать в Код Гольф! :)

FryAmTheEggman

Я думаю, что вы хотите просто использовать вложенный цикл, но я не очень хорошо знаю BF. Вы видели советы Brainfuck ? Также вероятно, что страница esolangs по константам Brainfuck будет полезным ресурсом здесь.

Джонатан Аллан

Я думаю, вы должны уточнить лучший код BrainFuck . Вы ищете наиболее читаемый, самый элегантный, используя наименьшее количество +символов или просто краткость?

Джонатан Фрех

@Jonathan Allan: Да, в этом цель этого вопроса: как использовать вложенный цикл. Это увлекательный язык, близкий к ASM, но я не понимаю некоторые аспекты

Нельсон Дж.

Могу ли я использовать этот вариант на BF -> github.com/gergoerdi/brainfuck64

Шон Бебберс

Ответы:

Метод, который вы используете в данный момент, составляет 39 байт:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](не включая получение A) ( попробуйте онлайн! )

(3 раза, каждый раз установите счетчик на 255 и напечатайте столько раз, затем вычтите 20, вычтите 1 и напечатайте столько раз)

Тем не менее, намного короче цикл 250 раз и печать 4 раза каждый раз (спасибо jimmy23013 за оптимизацию по сравнению с моим оригинальным решением loop-4 loop-250 print-1):

>------[<....>-] (16 байт)

Если ваши клетки не ограничены (я предполагаю, что они 8-битные, в противном случае вы, вероятно, не стали бы использовать 255 для игры в гольф):

>>++++++++++[<++++++++++[<..........>-]>-] (42 байта).

HyperNeutrino
источник

это, кажется, предполагает 8-битные ячейки, хотя ...

Джон Дворжак

@JohnDvorak: В этом вопросе упоминается установка ячеек на 255 как часть наиболее эффективного решения, которое может придумать ОП. Это выглядит как довольно четкое указание на (ab) использование 8-битного переноса ячеек.

randomdude999

@JohnDvorak То, что сказал randomdude999, но я добавил метод, использующий 10x10x10 на случай, если ячейки не ограничены.

HyperNeutrino

250 раз ....будет короче.

jimmy23013

@ jimmy23013 ... не знаю, как я об этом не думал, но все же оптимизировал свое решение 10x10x10 для этого LOL. благодаря!

HyperNeutrino

47 байт (без потерь)

Я только что сделал это решение в 47 байтов. Я попытался сделать это не так, как обычно, пытаясь сэкономить место, манипулируя счетчиками между двумя значениями. Предполагается, что A предварительно загружен в p [4].

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

Разъяснения

Place 5 into p[0]
+++++
Loop 5 times to put p[1]=20, p[2]=25
[>++++>+++++<<-]>
Loop 20 times
[>
Move pointer to p[2] and loop 25 times.
Also move p[2] to p[3]

[
Increment p[3] from 0, effectively moving the value from p[2] to p[3]
>+
Print p[4]
>.
Decrement p[2]
<<-]
Shift over to p[3]
>
[
Decrement p[3]
->
Print p[4]
.<
Increment p[2]
<+>]
Move back to p[1] and decrement
<<-
Repeat until p[1] is 0
]

Джош Бэкон
источник

самый короткий способ получить число 65 для «А» - >+[+[<]>>+<+]>это просто добавить HyperNeutrino >------[<....>-]в конец этого. поэтому полный код становится >+[+[<]>>+<+]>>------[<....>-](30 байт)

Стрелец
источник

Откуда ты знаешь, что путь самый короткий? Это, конечно, короче, но знаете ли вы наверняка, что никто не найдет короче?

Ad Hoc

28:>+[+[<]>>+<+]------[>....<-]

jimmy23013

@ SriotchilismO'Zaic да, я не имел в виду, что это был самый короткий лол

Стрелец