Was ist der beste BrainFuck-Code (in Bezug auf die Codegröße), um 1000-mal 'A' zu drucken?

Mein Ansatz ist:

• setze 'A' auf p [0]
• Stellen Sie 255 auf p [1], um 255 'A' dreimal anzuzeigen
• Stellen Sie 235 auf p [1], um 235 'A' anzuzeigen.

Dies ist nicht effektiv, aber ich kann keinen Weg finden, Schleppzähler gleichzeitig wie eine Multiplikation zu verwenden

Gibt es einen besseren Ansatz als eine Multiplikation?

Eine allgemeinere Frage: Gibt es eine Regel, um eine Multiplikation mit einer großen Zahl mit dem kleinstmöglichen Code durchzuführen?

Die Methode, die Sie derzeit zu verwenden scheinen, ist 39 Byte:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](ohne das zu bekommen A) ( Try It Online! )

(3-mal schleifen, jedes Mal den Zähler auf 255 setzen und so oft drucken, dann 20 subtrahieren, 1 subtrahieren und so oft drucken)

Es ist jedoch viel kürzer, 250-mal zu schleifen und jedes Mal 4-mal zu drucken (danke an jimmy23013 für die Optimierung gegenüber meiner ursprünglichen Loop-4-Loop-250-Print-1-Lösung):

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

Wenn Ihre Zellen unbegrenzt sind (ich gehe davon aus, dass sie 8-Bit sind, sonst würden Sie wahrscheinlich nicht versuchen, 255 zum Golfen zu verwenden):

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

47 Bytes (keine Unterläufe)

Ich habe diese Lösung gerade in 47 Bytes gemacht. Ich habe versucht, es anders zu machen, als ich normalerweise versuchen würde, Platz zu sparen, indem ich Zähler zwischen zwei Werten jongliere. Es wird angenommen, dass A in p [4] vorgeladen ist.

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

Erklärt

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
]

Der kürzeste Weg, um die Nummer 65 für 'A' zu erhalten, ist >+[+[<]>>+<+]>, und >------[<....>-]am Ende fügen Sie einfach HyperNeutrino hinzu . so wird der vollständige Code >+[+[<]>>+<+]>>------[<....>-](30 Bytes)