Genere un programa Brainf_ck que genere una cadena de longitud determinada

11

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!

anatolyg
fuente
2
"los siguientes valores de N (son números aleatorios)" me recordaron a xkcd.com/221
cirpis
Solo como referencia, el carácter de espacio (código de carácter 32) generalmente se incluye en el rango ASCII imprimible. Sin embargo, realmente no hace la diferencia para el desafío, ya que ha definido el rango explícitamente.
Martin Ender
3
¿Podemos suponer que las células en brainfuck son enteros de ancho arbitrario? Si no, ¿cómo y cuándo se envuelven?
orlp
1
Sería bueno suponer que al menos puede contener 67175 + unos pocos.
orlp
@anatolyg Me di cuenta de eso más tarde. Lo siento.
Esolanging Fruit

Respuestas:

3

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!

rixm
fuente
Esta es una gran idea! Tal vez lo usaré una vez para mejorar esta respuesta (escribió un script en Python para obtener una puntuación inferior a 950, pero no conozco ningún lenguaje de golf que lo haga lo suficientemente corto).
anatolyg
8

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.

mdc32
fuente
Supongo que con Brainfuck sería suficiente hacer una "subrutina" que recibe su entrada en la cinta, sin necesidad de leer desde el "dispositivo de entrada estándar".
anatolyg
@anatolyg Eso lo hace mucho más fácil, probablemente unos 80 o 90 caracteres. ¿Debo cambiarlo?
mdc32
5

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
randomra
fuente
3

Pyth, 1702

Reconstruya números usando factores de N + x.

+holN+]++">>"*"+"Q"<<"mjk(">>"j">"m*"+"kP+Qd"<[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>"*"-"d"<<")50"++++++[>++++++<-]>>[<.>-]"
orlp
fuente
Para 2esto salidas ++. ahora que no imprime nada en BF.
randomra
@randomra Buena captura, esto sucedió durante la actualización, lo arreglaré, dame algunos.
orlp
@randomra Debería arreglarse, hacer que la puntuación sea un poco más alta (por supuesto).
orlp
3

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,
jimmy23013
fuente
No vi la parte sobre la autodestrucción. Pero nunca se desbordará de todos modos.
jimmy23013
¿Como funciona?
anatolyg
@anatolyg La primera versión simplemente genera el número en la base 5. Las versiones posteriores agregaron un caso especial para los primeros dos dígitos y también usaron decremento.
jimmy23013
@ user23013 Oh, lo siento, no he visto los cambios en las especificaciones. (
Actualicé
2

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)>+++++++++++++++++++++++++++++++++<[->.<]
PurkkaKoodari
fuente
1

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

Martin Ender
fuente
1

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.

objeto
fuente
Ahora que veo esto, no sé por qué estaba pensando que mi ciclo sería mejor ...
Martin Ender