Votre ami essaie de s'introduire dans un coffre-fort doté d'un système de verrouillage particulier: il nécessite un certain nombre de coups légers à un endroit particulier. Votre ami a découvert le numéro (qui est compris entre 1 et 99999) et possède un gadget qui produit les coups nécessaires. Cependant, le gadget est un interprète Brainfuck! Votre ami doit donc lui fournir un programme Brainfuck, qui, évidemment, devrait être aussi court que possible (les E / S du gadget sont lentes).

Votre tâche est de l'aider! Écrivez un programme ou un sous-programme, dans n'importe quelle langue, qui accepte comme entrée un nombre Net génère un programme Brainfuck, qui ne prend aucune entrée et génère une chaîne de caractères ASCII imprimables (à l'exclusion du caractère espace - codes dans la plage 33 ... 126) de longueur N.

Exemple: pour l'entrée 10, la sortie peut être

+++++++++++++++++++++++++++++++++..........

(mais je suis sûr qu'il peut être raccourci!)

Votre score sera la somme des longueurs de vos sorties pour les valeurs suivantes de N(ce sont des nombres aléatoires):

55
68
15
28
841
838
522
846
4898
9004
9363
3810
13230
67175
37231
44701

Oh, et vous transmettrez votre code (le programme générateur) à votre ami par Twitter. Assurez-vous donc que c'est 140 caractères ou moins!

PS Le langage Brainfuck a de nombreuses variantes. Supposons que la bande soit infinie dans les deux sens (ou "circulaire et assez grande"), et que les cellules ont une capacité int de 32 bits (finies et capables de contenir des nombres jusqu'à 99999). De plus, pas d'emballage: quand une cellule déborde, la machine s'autodétruit!

Python 2, score: 1021

Je viens de réaliser que ce concours est assez ancien mais quand même, étant donné que j'ai trouvé une meilleure solution que celles publiées, je l'ai aussi publiée.

Voici un script python de 102 octets qui fait le travail:

n=input()
s='>'
while n:
    s+='>'+'+'*(n%5+1);n/=5
print s+'[->[-<+++++>]<<]<+++++++[>+++++<-]>>[-<.>]'

L'idée est d'utiliser le codage base 5 pour N (meilleure base au moins pour les entrées actuelles, qui ne semblent pas très "aléatoires" d'ailleurs, semble avoir été arbitrairement choisies par OP), et d'écrire un algorithme générique Brainfuck pour décoder un nombre de longueur arbitraire (le nombre est codé avec chaque chiffre augmenté d'un pour détecter la fin de la conversion). J'ai choisi d'imprimer le caractère 35 #, le caractère 36 $est équivalent.

Vous pouvez exécuter le script bash suivant pour obtenir le score:

i=0
while read p; do
  i=$((i+`echo $p | python convert.py | wc -m`))
done
echo $i

Avec un programme plus avancé qui remplace l'encodage par la multiplication pour les petits nombres et choisit la meilleure base pour encoder chaque nombre, je peux atteindre 958 caractères Brainfuck, mais Python est beaucoup trop verbeux (et je suis un golfeur assez mauvais / paresseux) dans l'ordre pour obtenir le convertisseur en 144 octets!

BrainF ***, score: 193,313

Ce n'est pas moins de 140 caractères (c'est 147, si près !!), donc cela ne peut pas gagner, mais je pensais que c'était cool.

Imprime 43 signes plus, puis les Npoints. Pas très optimal.

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

Si quelqu'un peut aider à raccourcir cela, je l'adorerais.

J, score total = 1481

(Pour mon entrée précédente et explication, consultez l'historique des révisions.)

f10=.('>++++++++++<';'')rplc~;@([:(<@('+++++[>+++++++<-]>>+',;@((<'[>++++++++++')#~#)),[<@(']',~'<-','<.>'#~],[,])"0 #-i.@# )10#.inv])

Cette fonction génère des boucles BF imbriquées sur la base des chiffres de base10 du numéro d'entrée. Vérifier toutes les bases raisonnables et choisir le plus petit code BF améliorerait le score avec un petit montant.

Programmes BF pour l'ensemble de test:

   f10 every 55 68 15 28 841 838 522 846 4898 9004 9363 3810 13230 67175 37231 44701
+++++[>+++++++<-]>>+[>++++++++++[-<<.....>>]<-<.....>]                                                                                     
+++++[>+++++++<-]>>+[>++++++++++[-<<......>>]<-<........>]                                                                                 
+++++[>+++++++<-]>>+[>++++++++++[-<<.>>]<-<.....>]                                                                                         
+++++[>+++++++<-]>>+[>++++++++++[-<<..>>]<-<........>]                                                                                     
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<....>>]<-<.>]                                                             
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<...>>]<-<........>]                                                       
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<.....>>>]<-<<..>>]<-<..>]                                                                 
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<....>>]<-<......>]                                                        
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<....>>>>]<-<<<........>>>]<-<<.........>>]<-<........>]                      
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<.........>>>>]<-<<<>>>]<-<<>>]<-<....>]                                      
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<.........>>>>]<-<<<...>>>]<-<<......>>]<-<...>]                              
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<...>>>>]<-<<<........>>>]<-<<.>>]<-<>]                                       
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<.>>>>>]<-<<<<...>>>>]<-<<<..>>>]<-<<...>>]<-<>]                 
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<......>>>>>]<-<<<<.......>>>>]<-<<<.>>>]<-<<.......>>]<-<.....>]
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<...>>>>>]<-<<<<.......>>>>]<-<<<..>>>]<-<<...>>]<-<.>]          
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<....>>>>>]<-<<<<....>>>>]<-<<<.......>>>]<-<<>>]<-<.>]          

Score de calcul sur l'ensemble de test:

   +/#@> f10 each 55 68 15 28 841 838 522 846 4898 9004 9363 3810 13230 67175 37231 44701
1481

Pyth, 1702

Reconstruisez des nombres en utilisant des facteurs de N + x.

+holN+]++">>"*"+"Q"<<"mjk(">>"j">"m*"+"kP+Qd"<[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>"*"-"d"<<")50"++++++[>++++++<-]>>[<.>-]"

CJAM, 52 74 108 octets, total = 1304 1244 1210

ri5b_,1>{(_3<{\(@5*+}*\+}*W%)\{T+_2>:T5*-_0>"-+"=\z*}%\T+'+*a+W%{"[->+++++<]>"\}*">x[>x<-]<[->>.<<]"'x/'+6**

Un script de test (lent dans l'interpréteur en ligne):

q~]
{
_[0:T;
5b_,1>{(_3<{\(@5*+}*\+}*W%)\{T+_2>:T5*-_0>"-+"=\z*}%\T+'+*a+W%{"[->+++++<]>"\}*">x[>x<-]<[->>.<<]"'x/'+6**
]s
_[L:RL@0\
"-+><.]"['('){+\_{)}0?@\}{@\+\_{)}0?}{R1$c+:R;}]:`"]a"{{_aa+1$4G#%{:~~1}{;0}?}g}`+a+er:~:~
];R,@=!"Error."N+*o
}%s,

Befunge-98, N + 41, total = 193281

&>'+\:v
v^-1,\_
' >1-:v
>v^,+'_
,'    :
>ff3++^
>2f*+v
^>/9+:,
>'>,61v
, v*6+<
^/2,:<@
v >+2+,
>'<,']^

Je sais que c'est mauvais, mais j'avais envie d'écrire du Befunge aujourd'hui. La meilleure partie de Befunge est que les programmes sont encore moins compréhensibles que les langues de golf réelles, surtout lorsqu'ils réutilisent le code: D

Utilise un algorithme similaire à la réponse CJam de Martin Büttner :

(N +'s)>+++++++++++++++++++++++++++++++++<[->.<]

CJam, 40 + N, Total: 193265

'+33*'>'+l~*"[<.>-]"

Pour commencer, voici la solution de base. Il génère le code suivant:

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

où se _trouve des Ncopies de +.

Exécutez le générateur ici.

Befunge-93 - 24 + N, total = 193009

&>">>]-<]-<++++>[++++>[+++"v
v  ,,,,,,,,,,,,,,,,,,,,,,, <
>:v
,v_@
"1
.-
"
^<

Cela utilise un préfixe de +++[>++++[>++++<-]<-]>>pour définir le premier index de bande sur «0» avec 24 caractères. Le programme Befunge est très basique et génère cela avec N '.' personnages.