Il tuo amico sta cercando di entrare in un caveau che ha un particolare sistema di chiusura: richiede un certo numero di colpi delicati in un punto particolare. Il tuo amico ha scoperto il numero (compreso nell'intervallo 1 ... 99999) e possiede un gadget che produce i colpi richiesti. Tuttavia, il gadget è un interprete Brainfuck! Quindi il tuo amico deve dargli da mangiare un programma Brainfuck, che, ovviamente, dovrebbe essere il più breve possibile (l'I / O del gadget è lento).

Il tuo compito è di aiutarlo! Scrivi un programma o una subroutine, in qualsiasi lingua, che accetta come input un numero Ne genera un programma Brainfuck, che non accetta input e genera una stringa di caratteri ASCII stampabili (escluso il carattere spaziale - codici nell'intervallo 33 ... 126) di lunghezza N.

Esempio: per l'input 10, l'output potrebbe essere

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

(ma sono sicuro che può essere abbreviato!)

Il tuo punteggio sarà la somma delle lunghezze delle tue uscite per i seguenti valori di N(sono numeri casuali):

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

Oh, e trasmetterai il tuo codice (il programma generatore) al tuo amico tramite Twitter. Quindi assicurati che contenga 140 caratteri o meno!

PS Il linguaggio Brainfuck ha molte varianti. Supponiamo che il nastro sia infinito in entrambe le direzioni (o "circolare e abbastanza grande") e che le celle abbiano una capacità int di 32 bit (finita e in grado di contenere numeri fino a 99999). Inoltre, nessun avvolgimento: quando una cella trabocca, la macchina si autodistrugge!

Python 2, punteggio: 1021

Mi sono appena reso conto che questo concorso è piuttosto vecchio ma comunque, dato che ho trovato una soluzione migliore di quelle pubblicate, l'ho pubblicato anche io.

Ecco uno script python da 102 byte che fa il lavoro:

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

L'idea è di utilizzare la codifica base 5 per N (la migliore base almeno per gli input correnti, che non sembrano molto "casuali" tra l'altro, sembra che siano stati scelti arbitrariamente da OP) e scrivere un algoritmo Brainfuck generico su decodificare un numero di lunghezza arbitraria (il numero viene codificato con ogni cifra aumentata di una per rilevare la fine della conversione). Ho scelto di stampare il carattere 35 #, il carattere 36 $è equivalente.

È possibile eseguire il seguente script bash per ottenere il punteggio:

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

Con un programma più avanzato che sostituisce la codifica con la moltiplicazione per piccoli numeri e sceglie la base migliore per codificare ciascun numero, posso raggiungere 958 caratteri Brainfuck, ma Python è fin troppo prolisso (e io sono un golfista piuttosto cattivo / pigro) in ordine per ottenere il convertitore in 144 byte!

BrainF ***, punteggio: 193.313

Non ha meno di 140 caratteri (è 147, così vicino !!), quindi questo non può vincere, ma ho pensato che fosse bello.

Stampa 43 segni più, quindi punti N. Non molto ottimale

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

Se qualcuno può aiutare ad accorciare questo mi piacerebbe.

J, Punteggio totale = 1481

(Per la mia precedente voce e spiegazione controllare la cronologia delle revisioni.)

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

Questa funzione genera loop BF nidificati in base alle cifre base10 del numero di input. Controllare tutte le basi ragionevoli e scegliere il codice BF più piccolo migliorerebbe il punteggio con una piccola quantità.

Programmi BF per il set di test:

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

Punteggio di calcolo sul set di test:

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

Pyth, 1702

Ricostruisci i numeri usando i fattori di N + x.

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

CJam, 52 74 108 byte, totale = 1304 1244 1210

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

Uno script di test (lento nell'interprete online):

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, totale = 193281

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

So che è brutto, ma mi è venuta voglia di scrivere un po 'di Befunge oggi. La parte migliore di Befunge è che i programmi sono ancora meno comprensibili delle attuali lingue di golf, specialmente quando riutilizzano il codice: D

Utilizza un algoritmo simile alla risposta CJam di Martin Büttner :

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

CJam, 40 + N, totale: 193265

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

Giusto per iniziare, ecco la soluzione di base. Genera il seguente codice:

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

dove _sono le Ncopie di +.

Esegui il generatore qui.

Befunge-93 - 24 + N, totale = 193009

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

Questo utilizza un prefisso di +++[>++++[>++++<-]<-]>>per impostare il primo indice del nastro su '0' con 24 caratteri. Il programma Befunge è molto semplice e produce questo insieme a N '.' personaggi.