Ihr Freund versucht, in ein Gewölbe einzubrechen, das über ein besonderes Schließsystem verfügt: Es erfordert eine bestimmte Anzahl sanfter Schläge an einer bestimmten Stelle. Ihr Freund hat die Nummer entdeckt (die im Bereich von 1 ... 99999 liegt) und besitzt ein Gerät, das die erforderlichen Klopfen erzeugt. Das Gadget ist jedoch ein Brainfuck-Dolmetscher! Ihr Freund muss ihm also ein Brainfuck-Programm geben, das natürlich so kurz wie möglich sein sollte (die E / A des Gadgets ist langsam).

Ihre Aufgabe ist es, ihm zu helfen! Schreiben Sie ein Programm oder eine Unterroutine in einer beliebigen Sprache, die eine Zahl als Eingabe akzeptiert Nund ein Brainfuck-Programm ausgibt, das keine Eingabe akzeptiert und eine Zeichenfolge druckbarer ASCII-Zeichen ausgibt (mit Ausnahme der Leerzeichen - Codes im Bereich 33 ... 126) der Länge N.

Beispiel: Für die Eingabe 10könnte die Ausgabe sein

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

(aber ich bin sicher, dass es verkürzt werden kann!)

Ihre Punktzahl ist die Summe der Längen Ihrer Ausgaben für die folgenden Werte von N(es handelt sich um Zufallszahlen):

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

Oh, und Sie werden Ihren Code (das Generatorprogramm) per Twitter an Ihren Freund senden. Stellen Sie also sicher, dass es maximal 140 Zeichen sind !

PS Die Brainfuck-Sprache hat viele Varianten. Nehmen wir an, das Band ist in beide Richtungen unendlich (oder "kreisförmig und groß genug") und die Zellen haben eine 32-Bit-Int-Kapazität (endlich und in der Lage, Zahlen bis zu 99999 aufzunehmen). Auch kein Wrapping: Wenn eine Zelle überläuft, zerstört sich die Maschine selbst!

Python 2, Punktzahl: 1021

Ich habe gerade festgestellt, dass dieser Wettbewerb ziemlich alt ist, aber da ich eine bessere Lösung als die veröffentlichten gefunden habe, habe ich ihn auch veröffentlicht.

Hier ist ein 102-Byte-Python-Skript, das die Aufgabe erfüllt:

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

Die Idee ist, die Basis-5-Codierung für N zu verwenden (beste Basis zumindest für die aktuellen Eingaben, die übrigens nicht sehr "zufällig" erscheinen, wie sie von OP willkürlich ausgewählt wurden) und einen generischen Brainfuck-Algorithmus zu schreiben Dekodieren Sie eine Zahl beliebiger Länge (die Zahl wird mit jeder um eins erhöhten Ziffer codiert, um das Ende der Konvertierung zu erkennen). Ich habe Zeichen 35 gedruckt #, Zeichen 36 $ist gleichwertig.

Sie können das folgende Bash-Skript ausführen, um die Punktzahl zu erhalten:

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

Mit einem fortgeschritteneren Programm, das die Codierung durch Multiplikation für kleine Zahlen ersetzt und die beste Basis für die Codierung jeder Zahl auswählt, kann ich 958 Brainfuck-Zeichen erreichen, aber Python ist viel zu ausführlich (und ich bin ein ziemlich schlechter / fauler Golfer) um den Konverter in 144 Bytes zu bekommen!

BrainF ***, Punktzahl: 193.313

Es ist nicht unter 140 Zeichen (es ist 147, so nah !!), also kann das nicht gewinnen, aber ich fand es cool.

Druckt 43 Pluszeichen und dann NPunkte. Nicht sehr optimal.

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

Wenn jemand helfen kann, dies zu verkürzen, würde ich es lieben.

J, Gesamtpunktzahl = 1481

(Für meinen vorherigen Eintrag und meine Erklärung überprüfen Sie den Revisionsverlauf.)

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

Diese Funktion generiert verschachtelte BF-Schleifen basierend auf den base10-Ziffern der Eingangsnummer. Das Überprüfen aller vernünftigen Grundlagen und das Auswählen des kleinsten BF-Codes würde die Punktzahl mit einem kleinen Betrag verbessern.

BF-Programme für den Testsatz:

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

Berechnungsergebnis auf dem Testsatz:

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

Pyth, 1702

Rekonstruieren Sie Zahlen mit den Faktoren N + x.

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

CJam, 52 74 108 Bytes, gesamt = 1304 1244 1210

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

Ein Testskript (langsam im Online-Interpreter):

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

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

Ich weiß, dass es schlecht ist, aber ich wollte heute Befunge schreiben. Das Beste an Befunge ist, dass die Programme noch weniger verständlich sind als die eigentlichen Golfsprachen, insbesondere wenn sie Code wiederverwenden: D.

Verwendet einen ähnlichen Algorithmus wie Martin Büttners CJam-Antwort :

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

CJam, 40 + N, Gesamt: 193265

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

Um dies zu beginnen, finden Sie hier die Basislösung. Es wird der folgende Code generiert:

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

Wo _sind NKopien von +.

Lassen Sie den Generator hier laufen.

Befunge-93 - 24 + N, insgesamt = 193009

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

Hierbei wird das Präfix von verwendet +++[>++++[>++++<-]<-]>>, um den ersten Bandindex mit 24 Zeichen auf '0' zu setzen. Das Befunge-Programm ist sehr einfach und gibt dies zusammen mit N 'aus.' Zeichen.