Imprima 'A' 1000 vezes com BrainFuck

Qual é o melhor código do BrainFuck (em termos de tamanho do código) para imprimir 'A' 1000 vezes?

Minha abordagem é:

defina 'A' para p [0]
defina 255 para p [1] para exibir 255 'A', 3 vezes
ajuste 235 para p [1] para exibir 235 'A'

Isso não é eficaz, mas não consigo encontrar uma maneira de usar os contadores de reboque simultaneamente, como uma multiplicação

Existe uma abordagem melhor do que uma multiplicação?

Uma pergunta mais geral: existe uma regra para fazer uma multiplicação com um número grande com o menor código possível?

code-golf tips brainfuck

— Nelson G.
fonte

Este é um bom lugar para começar. Bem-vindo ao Code golf! :)

— FryAmTheEggman

Eu acho que você quer usar apenas um loop aninhado, mas não conheço muito bem o BF. Você já viu dicas do Brainfuck ? Também provavelmente a página esolangs nas constantes do Brainfuck seria um recurso útil aqui.

— Jonathan Allan

Eu acho que você deve esclarecer o melhor código do BrainFuck . Você está em busca do mais legível, mais elegante, usando a menor quantidade de +caracteres ou simplesmente a maior brevidade?

— Jonathan Frech

@ Jonathan Allan: Sim, esse é o objetivo desta pergunta: Como usar um loop aninhado. É uma fascinante ASM linguagem próxima, mas eu não compreender alguns aspectos

— Nelson G.

Eu poderia usar esta variante no BF -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Respostas:

O método que você parece estar usando atualmente é de 39 bytes:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](não incluindo a obtenção do A) ( Experimente on-line! )

(faça um loop 3 vezes, sempre que definir o contador para 255 e imprimir várias vezes, subtrair 20, subtrair 1 e imprimir várias vezes)

No entanto, é muito mais curto fazer um loop de 250 vezes e imprimir 4 vezes de cada vez (graças a jimmy23013 por otimizar isso em relação à minha solução original de loop-4 loop-250 print-1):

>------[<....>-] (16 bytes)

Se suas células não tiverem limites (presumo que sejam de 8 bits, você provavelmente não tentaria usar 255 para jogar golfe):

>>++++++++++[<++++++++++[<..........>-]>-] (42 bytes).

— HyperNeutrino
fonte

este parece assumir células de 8 bits, embora ...

— John Dvorak

@JohnDvorak: A pergunta mencionava a definição de células para 255 como parte da solução mais eficaz que o OP poderia pensar. Isso parece ser uma indicação bastante clara de (ab) usando quebra de célula de 8 bits.

— randomdude999

@JohnDvorak O que randomdude999 disse, mas adicionei um método usando 10x10x10 no caso de as células serem ilimitadas.

— HyperNeutrino 16/06/19

250 vezes ....seria mais curto.

— jimmy23013 17/07/19

@ jimmy23013 ... não tenho certeza de como eu não pensei nisso e ainda otimizei minha solução 10x10x10 para fazer isso LOL. obrigado!

— HyperNeutrino

47 bytes (sem fluxo insuficiente)

Acabei de fazer esta solução em 47 bytes. Tentei fazê-lo de uma maneira diferente da que normalmente tentaria economizar espaço manipulando contadores entre dois valores. Ele assume que A é pré-carregado em p [4].

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

Explicado

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
]

— Josh Bacon
fonte

a maneira mais curta de obter o número 65 para 'A' é >+[+[<]>>+<+]>e, em seguida, basta adicionar o HyperNeutrino's >------[<....>-]ao final disso. então o código completo se torna >+[+[<]>>+<+]>>------[<....>-](30 bytes)

— Sagitário
fonte

Como você sabe que esse caminho é o mais curto? Certamente é mais curto, mas você tem certeza de que ninguém encontrará um menor?

— Post Rock Garf Hunter

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

— jimmy23013 11/11/19

@ SriotchilismO'Zaic sim, eu realmente não queria dizer que era o mais curto lol

— Sagitário