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?

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

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
]

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)