Quel est le meilleur code BrainFuck (en termes de taille de code) pour imprimer 1000 fois 'A'?

Mon approche est:

• réglez 'A' sur p [0]
• régler 255 sur p [1] pour afficher 255 'A', 3 fois
• réglez 235 sur p [1] pour afficher 235 'A'

Ce n'est pas efficace mais je ne trouve pas de moyen d'utiliser simultanément les compteurs de remorquage comme une multiplication

Existe-t-il une meilleure approche qu'une multiplication?

Une question plus générale: existe-t-il une règle pour faire une multiplication avec un grand nombre avec le plus petit code possible?

La méthode que vous semblez utiliser actuellement est de 39 octets:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](hors obtention du A) ( Essayez-le en ligne! )

(boucle 3 fois, à chaque fois définissez le compteur sur 255 et imprimez ce nombre de fois, puis soustrayez 20, soustrayez 1 et imprimez ce nombre de fois)

Cependant, il est beaucoup plus court de boucler 250 fois et d'imprimer 4 fois à chaque fois (merci à jimmy23013 pour l'optimisation par rapport à ma solution originale loop-4 loop-250 print-1):

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

Si vos cellules sont illimitées (je suppose qu'elles sont 8 bits sinon vous n'essaieriez probablement pas d'utiliser 255 pour jouer au golf):

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

47 octets (pas de sous-flux)

Je viens de faire cette solution en 47 octets. J'ai essayé de le faire d'une manière différente de ce que j'essaierais normalement d'économiser de l'espace en jonglant avec les compteurs entre deux valeurs. Il suppose que A est préchargé dans p [4].

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

Expliqué

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
]

le moyen le plus court pour obtenir le nombre 65 pour «A» est >+[+[<]>>+<+]>, puis vous ajoutez simplement HyperNeutrino >------[<....>-]à la fin de cela. donc le code complet devient >+[+[<]>>+<+]>>------[<....>-](30 octets)