Imprimez 'A' 1000 fois avec BrainFuck

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?

code-golf tips brainfuck

— Nelson G.
source

C'est un bon point de départ. Bienvenue chez Code golf! :)

— FryAmTheEggman

Je pense que vous voulez simplement utiliser une boucle imbriquée, mais je ne connais pas très bien BF. Avez-vous vu des astuces Brainfuck ? La page esolangs sur les constantes Brainfuck serait probablement une ressource utile ici.

— Jonathan Allan

Je pense que vous devriez clarifier le meilleur code BrainFuck . Êtes-vous à la recherche du plus lisible, du plus élégant, en utilisant le moins de +caractères ou simplement la plus grande concision?

— Jonathan Frech

@Jonathan Allan: Oui, c'est le but de cette question: comment utiliser une boucle imbriquée. C'est un langage fascinant proche ASM mais je ne comprends pas certains aspects

— Nelson G.

Puis-je utiliser cette variante sur BF -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Réponses:

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

— HyperNeutrino
source

cela semble supposer des cellules 8 bits, cependant ...

— John Dvorak

@JohnDvorak: La question mentionnait la définition de 255 cellules dans le cadre de la solution la plus efficace à laquelle l'OP pourrait penser. Cela semble être une indication assez claire de l'utilisation d'un habillage de cellule 8 bits.

— randomdude999

@JohnDvorak Ce que randomdude999 a dit, mais j'ai ajouté une méthode utilisant 10x10x10 au cas où les cellules seraient illimitées.

— HyperNeutrino

250 fois ....serait plus court.

— jimmy23013

@ jimmy23013 ... je ne sais pas comment je ne pensais pas à ça et j'ai encore optimisé ma solution 10x10x10 pour faire ça LOL. Merci!

— HyperNeutrino

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
]

— Josh Bacon
source

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)

— Sagittaire
source

Comment savez-vous que ce chemin est le plus court? Il est certainement plus court, mais savez-vous avec certitude que personne n'en trouvera un plus court?

— Ad Hoc Garf Hunter

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

— jimmy23013

@ SriotchilismO'Zaic ouais je ne voulais pas vraiment dire que c'était le plus court lol

— Sagittaire