Tu amigo está tratando de entrar en una bóveda que tiene un sistema de bloqueo peculiar: requiere una cierta cantidad de golpes suaves en un lugar en particular. Su amigo descubrió el número (que está en el rango de 1 ... 99999) y posee un dispositivo que produce los golpes necesarios. Sin embargo, ¡el dispositivo es un intérprete de Brainfuck! Por lo tanto, su amigo necesita alimentarlo con un programa Brainfuck, que, obviamente, debe ser lo más corto posible (la E / S del dispositivo es lenta).

¡Tu tarea es ayudarlo! Escriba un programa o una subrutina, en cualquier idioma, que acepte como entrada un número N, y genere un programa Brainfuck, que no recibe ninguna entrada y genera una cadena de caracteres ASCII imprimibles (excluyendo el carácter de espacio - códigos en el rango 33 ... 126) de longitud N.

Ejemplo: para la entrada 10, la salida podría ser

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

(¡pero estoy seguro de que se puede acortar!)

Su puntaje será la suma de las longitudes de sus resultados para los siguientes valores de N(son números aleatorios):

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

Ah, y Twitter transmitirá su código (el programa generador) a su amigo. ¡Así que asegúrate de que tenga 140 caracteres o menos!

PD: el lenguaje Brainfuck tiene muchas variantes. Supongamos que la cinta es infinita en ambas direcciones (o "circular y lo suficientemente grande"), y las celdas tienen una capacidad int de 32 bits (finita y capaz de contener números de hasta 99999). Además, sin envoltura: cuando una celda se desborda, ¡la máquina se autodestruye!

Python 2, puntuación: 1021

Me acabo de dar cuenta de que este concurso es bastante antiguo, pero aún así, dado que se me ocurrió una solución mejor que las publicadas, también lo publiqué.

Aquí hay un script python de 102 bytes que hace el trabajo:

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

La idea es utilizar la codificación de base 5 para N (la mejor base al menos para las entradas actuales, que por cierto no parecen muy "aleatorias", parece que fueron elegidas arbitrariamente por OP), y escribir un algoritmo genérico Brainfuck para decodifica un número de longitud arbitraria (el número se codifica con cada dígito aumentado en uno para detectar el final de la conversión). Elegí imprimir el carácter 35 #, el carácter 36 $es equivalente.

Puede ejecutar el siguiente script bash para obtener la puntuación:

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

Con un programa más avanzado que reemplaza la codificación con multiplicación para números pequeños y elige la mejor base para codificar cada número, puedo alcanzar 958 caracteres Brainfuck, pero Python es demasiado detallado (y soy un golfista bastante malo / flojo) en orden para obtener el convertidor en 144 bytes!

BrainF ***, puntuación: 193,313

No tiene menos de 140 caracteres (¡es 147, tan cerca!), Así que esto no puede ganar, pero pensé que era genial.

Imprime 43 signos más, luego Npuntos. No muy óptimo.

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

Si alguien puede ayudar a acortar esto, me encantaría.

J, puntaje total = 1481

(Para mi entrada anterior y explicación, verifique el historial de revisiones).

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

Esta función genera bucles BF anidados basados ​​en los dígitos de base10 del número de entrada. Verificar todas las bases razonables y elegir el código BF más pequeño mejoraría la puntuación con una pequeña cantidad.

Programas BF para el conjunto de prueba:

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

Puntaje de cálculo en el conjunto de prueba:

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

Pyth, 1702

Reconstruya números usando factores de N + x.

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

CJAM, 52 74 108 bytes, el total = 1.304 1.244 1.210

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

Un script de prueba (lento en el intérprete en línea):

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+,
>'<,']^

Sé que es malo, pero tuve ganas de escribir algo de Befunge hoy. La mejor parte de Befunge es que los programas son aún menos comprensibles que los idiomas de golf reales, especialmente cuando reutilizan el código: D

Utiliza un algoritmo similar a la respuesta CJam de Martin Büttner :

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

CJam, 40 + N, Total: 193265

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

Solo para comenzar, aquí está la solución de referencia. Genera el siguiente código:

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

donde _es Ncopias de +.

Ejecute el generador aquí.

Befunge-93 - 24 + N, total = 193009

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

Utiliza un prefijo de +++[>++++[>++++<-]<-]>>para establecer el primer índice de cinta en '0' con 24 caracteres. El programa Befunge es muy básico y produce eso junto con N '. caracteres.