¿Cuál es el mejor código BrainFuck (en términos de tamaño del código) para imprimir 'A' 1000 veces?

Mi enfoque es:

• establezca 'A' en p [0]
• ajuste 255 a p [1] para mostrar 255 'A', 3 veces
• ajuste 235 a p [1] para mostrar 235 'A'

Esto no es efectivo pero no puedo encontrar una manera de usar contadores de remolque simultáneamente como una multiplicación

¿Hay un mejor enfoque que una multiplicación?

Una pregunta más general: ¿hay una regla para hacer una multiplicación con un número grande con el código más pequeño posible?

El método que parece estar usando actualmente es de 39 bytes:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](sin incluir obtener el A) (¡ Pruébelo en línea! )

(bucle 3 veces, cada vez configure el contador en 255 e imprima tantas veces, luego reste 20, reste 1 e imprima tantas veces)

Sin embargo, es mucho más corto hacer un bucle 250 veces e imprimir 4 veces cada vez (gracias a jimmy23013 por optimizar esto sobre mi solución original loop-4 loop-250 print-1):

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

Si sus celdas no tienen límites (supongo que son de 8 bits, de lo contrario, probablemente no intente usar 255 para jugar al golf):

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

47 bytes (sin desbordamientos)

Acabo de hacer esta solución en 47 bytes. Intenté hacerlo de una manera diferente a la que normalmente trataría de ahorrar espacio haciendo malabarismos con los contadores entre dos valores. Se supone que A está precargado en 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
]

la forma más corta de obtener el número 65 para 'A' es >+[+[<]>>+<+]>, y luego simplemente agrega HyperNeutrino's >------[<....>-]al final de eso. entonces el código completo se convierte >+[+[<]>>+<+]>>------[<....>-](30 bytes)