Escribe el programa más corto en tu idioma favorito para interpretar un programa de brainfuck . El programa se lee desde un archivo. Entrada y salida son entrada estándar y salida estándar.
- Tamaño de celda: 8 bits sin firmar. El desbordamiento no está definido.
- Tamaño de matriz: 30000 bytes (sin círculo)
- Los comandos incorrectos no son parte de la entrada
Los comentarios comienzan con # y se extienden hasta el final de la línea. Loscomentarios son todo lo que no está en+-.,[]<>
- sin símbolo EOF
Una muy buena prueba se puede encontrar aquí . Lee un número y luego imprime los números primos hasta ese número. Para evitar la descomposición del enlace, aquí hay una copia del código:
compute prime numbers
to use type the max number then push Alt 1 0
===================================================================
======================== OUTPUT STRING ============================
===================================================================
>++++++++[<++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++.[-]
>++++++++++[<++++++++++>-]<+++++++++.[-]
>++++++++++[<++++++++++>-]<+.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++.[-]
>+++++++[<+++++++>-]<+++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
===================================================================
======================== INPUT NUMBER ============================
===================================================================
+ cont=1
[
- cont=0
>,
======SUB10======
----------
[ not 10
<+> cont=1
=====SUB38======
----------
----------
----------
--------
>
=====MUL10=======
[>+>+<<-]>>[<<+>>-]< dup
>>>+++++++++
[
<<<
[>+>+<<-]>>[<<+>>-]< dup
[<<+>>-]
>>-
]
<<<[-]<
======RMOVE1======
<
[>+<-]
]
<
]
>>[<<+>>-]<<
===================================================================
======================= PROCESS NUMBER ===========================
===================================================================
==== ==== ==== ====
numd numu teid teiu
==== ==== ==== ====
>+<-
[
>+
======DUP======
[>+>+<<-]>>[<<+>>-]<
>+<--
>>>>>>>>+<<<<<<<< isprime=1
[
>+
<-
=====DUP3=====
<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<
=====DUP2=====
>[>>+>+<<<-]>>>[<<<+>>>-]<<< <
>>>
====DIVIDES=======
[>+>+<<-]>>[<<+>>-]< DUP i=div
<<
[
>>>>>+ bool=1
<<<
[>+>+<<-]>>[<<+>>-]< DUP
[>>[-]<<-] IF i THEN bool=0
>>
[ IF i=0
<<<<
[>+>+<<-]>>[<<+>>-]< i=div
>>>
- bool=0
]
<<<
- DEC i
<<
-
]
+>>[<<[-]>>-]<<
>[-]< CLR div
=====END DIVIDES====
[>>>>>>[-]<<<<<<-] if divides then isprime=0
<<
>>[-]>[-]<<<
]
>>>>>>>>
[
-
<<<<<<<[-]<<
[>>+>+<<<-]>>>[<<<+>>>-]<<<
>>
===================================================================
======================== OUTPUT NUMBER ===========================
===================================================================
[>+<-]>
[
======DUP======
[>+>+<<-]>>[<<+>>-]<
======MOD10====
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>-] if ten=0 ten=10
<<- dec ten
<- dec num
]
+++++++++ num=9
>[<->-]< dec num by ten
=======RROT======
[>+<-]
< [>+<-]
< [>+<-]
>>>[<<<+>>>-]
<
=======DIV10========
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>>+<-] if ten=0 ten=10 inc div
<<- dec ten
<- dec num
]
>>>>[<<<<+>>>>-]<<<< copy div to num
>[-]< clear ten
=======INC1=========
<+>
]
<
[
=======MOVER=========
[>+<-]
=======ADD48========
+++++++[<+++++++>-]<->
=======PUTC=======
<.[-]>
======MOVEL2========
>[<<+>>-]<
<-
]
>++++[<++++++++>-]<.[-]
===================================================================
=========================== END FOR ===============================
===================================================================
>>>>>>>
]
<<<<<<<<
>[-]<
[-]
<<-
]
======LF========
++++++++++.[-]
@
Ejemplo de ejecución:
$ python2 bf.py PRIME.BF
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
code-golf
interpreter
brainfuck
Alexandru
fuente
fuente
,
EOF? ¿O que depende de nosotros elegir un valor al probar,
EOF? ¿O es EOF un comportamiento indefinido por completo?Respuestas:
Perl, 120
138Esto ejecuta hello.bf y primes.bf sin problemas:
Inicialización: la tabla de traducción de código de operación a Perl se almacena en
%c
. La forma legible se ve así:Paso 1: sorber la entrada del programa
$_
y transformarla en código Perl usando la tabla de traducción. Los comentarios se eliminan automáticamente (se reemplazan porundef
) en este paso.Paso 2: descomprima todas las
$b[$p]
ocurrenciasPaso 3: Inicia el programa usando
eval
.fuente
qw
sintaxis de Perl para definir%c
directamente - bueno para 7 caracteres menos (tendrá que decirprint+chr$b[$p]
yord(getc)
, sin embargo)Python (sin evaluación), 317 bytes
fuente
f(u,c,k)
while b*c[c[0]]and j<1
conwhile b*c[c[0]]*(j<1)
Código de máquina de 16 bits 8086: 168 bytes
Aquí está la versión codificada en base64 , convierta y guarde como 'bf.com' y ejecute desde el símbolo del sistema de Windows: 'bf progname'
EDITAR
Aquí hay un ensamblador (estilo A86) para crear el ejecutable (¡tuve que aplicar ingeniería inversa a esto ya que había perdido la fuente original!)
fuente
brainfuck ,
843691 bytesEditar: decidí volver a visitar esto y encontré una sorprendente cantidad de formas de jugar al golf en bytes
Esto toma la entrada en la forma
code!input
donde el!input
es opcional. También simula celdas negativas sin usar celdas negativas y puede almacenar hasta(30000-(length of code+6))/2
celdas.Pruébalo en línea!
fuente
Ruby 1.8.7,
188185149147 caracteresVersión algo legible:
Como puede ver, robé descaradamente su idea de traducir al idioma del host y luego usar eval para ejecutarlo.
fuente
>0
en lugar de probar la igualdad:!=0
. Las especificaciones dicen sin firmar, y el desbordamiento no está definido.3e4
también funcionará en lugar de30000
File.read($*.pop).bytes
->$<.bytes
debería funcionar también{?a,"foo"}
que es equivalente a{?a=>"foo"}
. Y probando aquí muestra que en realidad se puede sustituirFile.read($*.pop).bytes
con$<
y sin ningún problema. Además, alinear todo a algo asíeval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"
acorta la solución con otros pocos caracteres.Cálculo Lambda Binario 112
El programa que se muestra en el volcado hexadecimal a continuación
espera que su entrada consista en un programa Brainfuck (mirando solo los bits 0,1,4 para distinguir entre, -. + <>] [) seguido de a], seguido de la entrada para el programa Brainfuck.
Guarde el volcado hexadecimal anterior con xxd -r> bf.Blc
Tome un intérprete blc de https://tromp.github.io/cl/cl.html
Hola Mundo!
fuente
0.8.2 retina ,
386391386 bytesEl código contiene
0x00
caracteres NUL ( ) no imprimibles . Tampoco está súper golfizado todavía, porque ya es muy lento, y si lo juego más, no sé cuánto tiempo tardaría en terminar. Parece que se agotó el tiempo de espera en la muestra de búsqueda principal.Puede haber errores en el intérprete en línea o en mi programa (¿las nuevas líneas principales no se muestran en la salida?).
Toma entrada como
<code>│<input>
. No, eso no es una tubería (|
). Es el personaje de UnicodeU+2502
. El código también usa los caracteres Unicodeÿ▶◀├║
. Los caracteres Unicode se utilizan para admitir la entrada de todos los caracteres ASCII. Por lo tanto, estos caracteres deben estar separados del código por un carácter no ASCII.Pruébalo en línea
Tenga en cuenta que hay una nueva línea final allí.
Breve explicacion:
Los ceros
0x00
se usan para la cinta, que es infinita. El primer reemplazo configura el intérprete en el formulario▶<code>│<input>├<output>║▶<tape>
, donde el primero▶
es el puntero para el código, y el segundo es el puntero para la cinta.ÿ
es0xFF
(255), que se utiliza para la transliteración (utilizada para implementar+
y-
) para envolver las celdas de nuevo a cero.◀
solo se usa para facilitar la lectura (en caso de que el programa se detenga en el medio o desee ver el programa a mitad de ejecución). De lo contrario, no podría saber en qué dirección se movía el puntero.Código comentado:
Haga clic aquí para ver el código con ceros en lugar de bytes nulos. Cualquier ocurrencia de
$0
no debe ser reemplazado por nulos.Editar : ahora admite entradas vacías y suprime la nueva línea final.
Salida infinita ahora es compatible. (403 bytes)
fuente
<code>
y el<tape>
uno al lado del otro (aunque serían más caracteres) para que la transición a un intérprete SMBF fuera más fácil, si alguna vez decidiera hacer eso.TI-BASIC, 264 bytes
Debido a limitaciones en TI-BASIC, esto en realidad no califica para este desafío ya que infringe la regla 2; la RAM de la calculadora es muy limitada, y hacer algo como
30000->dim(L1
(yo uso L1 para la pila / matriz) lo obligará a lanzar unERR:MEMORY
. Como tal, la pila / matriz comienza en un tamaño de 1 y crece si el puntero apunta a un elemento más allá del final. También infringe la regla 3, porque ya infringe la regla 2, por lo que es mejor no molestarme con un límite de tamaño de celda.Probablemente todavía podría jugar golf, por cierto ... He realizado una o dos ediciones con ese fin desde la primera presentación, pero si la versión siguiente no funciona, vuelva a la edición del 6 de mayo de 2015 y utilícela. código en su lugar. Además, como realmente no hay ASCII en TI-BASIC, esto toma números de cualquier tamaño (y cualquier cosa que devuelva un número, como una variable o expresión) como entrada, y genera números a su vez.
Use SourceCoder para construirlo en un archivo .8xp y luego envíelo a su calculadora con TI-Connect o TILP o algo así, y ejecútelo incluyendo su programa brainfuck en comillas dobles seguido de dos puntos y lo que haya llamado el programa TI-BASIC. Por ejemplo, si usted lo nombró brainf, que había corrido un programa como este:
"brainfuck goes here":prgmBRAINF
. Si usted tiene una concha en su calc que intercepta otros comandos cuando se detecta laprgm
señal, sin embargo, hacer esto:"brainfuck goes here" -> press ENTER -> prgmBRAINF
.Si no tiene una manera de conectar su calculadora a su computadora y desea escribir esto en lugar de calc (no puedo imaginar por qué querría hacerlo, pero estoy divagando) tenga en cuenta que
->
es elSTO>
botón que está arriba de ON clave,~
es el símbolo negativo al lado de ENTER, y para reemplazar todas las instancias deL<number>
con el token de lista correspondiente encontrado en2ND -> <number on keypad>
Gracias a thomas-kwa (al menos, creo que ese es su nombre de usuario de Stack) por ayudarme a optimizar esto, especialmente con las instrucciones
[
y]
.fuente
Ans+S
?S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
. (a-a=0
) Y oye, no te preocupes por olvidar UNA cosa de orden de operación aquí, he visto a una gran cantidad de personas olvidar el orden de operaciones para%
(mod) en un desafío.Python
275248255Decidí probarlo.
fuente
exec t
?). Si usa la punta de S.Mark y también hace todo elfor
ciclo en una línea, puede reducir esto a 243 caracteres.[]
un programa bf válido aunque trivial. He sugerido una edición que corrige esto, pero aumenta el recuento de caracteres. Para reducir aún más el recuento de caracteres, puedefrom sys import *
y usar en'i+=1,...'.split(',')
lugar de['i+=1',...]
.+1
, pero se han sugerido muchas mejoras y no se han implementado.Haskell,
457413 caracteresEste código "compila" el programa BF en una
IO
acción de la forma en queState -> IO State
el estado es una cremallera en una cadena infinita.Triste que tuve que gastar 29 caracteres para desactivar el almacenamiento en búfer. Sin eso, funciona, pero no ve las indicaciones antes de tener que escribir input. El compilador en sí (
b
,f
yk
) se encuentra a sólo 99 caracteres, el tiempo de ejecución (#
y%
) es 216. El conductor w / estado inicial otro 32.actualización 15-02-2011: se incorporaron las sugerencias de JB, se modificó un poco el nombre y se endureció
main
fuente
IO
y los argumentos de justSystem
(-19). El problema del almacenamiento en búfer también me molesta, ya que la especificación realmente no lo menciona y la respuesta más votada ni siquiera hace E / S. Si debe conservarlo, probablemente sea más cortohFlush
después de cada escritura que cambiar el modo de almacenamiento en búfer global (-34 + 15).Transportador, 953
Este podría ser el código más hermoso que jamás haya visto:
fuente
C
284362 (de un archivo)Primes:
Compilado y ejecutado con éxito VS2008
La solución original no pudo reconocer los bucles que inicialmente se establecieron en cero. Todavía hay espacio para el golf. Pero finalmente resuelve el programa Prime Number.
Sin golf:
Pruebas:
Hola Mundo
Rot13
fuente
l
) cada vez que realiza un bucle? Creo que se supone que debes verificar la ubicación actual de la cabeza (p
).l
en el búfer ha llegado a cero y se rompe; de lo contrario, restablece la secuencia al ciclo original[
. Esto es necesario para los[
bucles anidados .break;else
porreturn;
.(c==62)?a:b
con(c-62)?b:a
.PHP 5.4,
296294273263261209191183178166 caracteres:Le di una oportunidad sin usar eval, pero finalmente tuve que usarlo
Todos los comandos están funcionando. Esto abusa mucho de las variables variables y arroja advertencias. Sin embargo, si uno cambia su php.ini a advertencias de silenciamiento (o canaliza stderr a / dev / null), esto funciona muy bien.
Verificación (es el ejemplo "Hello World!" De Wikipedia ): http://codepad.viper-7.com/O9lYjl
Sin golf,
367365335296267 caracteres:Esto debe ejecutarse a través de la línea de comando:
php bf.php hello.bf
fuente
Windows PowerShell, 204
Conversión bastante sencilla de las instrucciones y luego
Invoke-Expression
.Historia:
3e4
es más corto que30000
.switch
.Write-Host
.fuente
C, 333 caracteres
Este es mi primer intérprete BF y el primer golf que tuve que depurar.
Esto ejecuta el generador de números primos en Mac OS X / GCC, pero
#include<string.h>
puede ser necesario un adicional a un costo de 19 caracteres más si la definición implícita destrchr
no funciona en otra plataforma. Además, se suponeO_RDONLY == 0
. Aparte de eso, dejar deint
lado la declaración deM
guardar 3 caracteres, pero eso no parece ser compatible con C99. Lo mismo con la tercera*
enb()
.Esto depende de los detalles de la codificación ASCII. Los operadores Brainfuck son todos pares complementarios separados por una distancia de 2 en el espacio de código ASCII. Cada función en este programa implementa un par de operadores.
fuente
#define
tabla en lugar de la función también sería probablemente más terser. Simplemente me gusta el número 333 y la tabla: v).||
.CJam, 75 bytes
Pruébelo en línea: inversor de cadenas , Hello World .
Explicación
Toma código en la primera línea de STDIN e ingresa en todas las líneas debajo de él.
¿Qué hay de esa lista mágica?
La lista resultante es la siguiente:
Generamos los fragmentos para
+
y>
desde aquellos para-
y<
, simplemente cambiando los parentes izquierdos ("decremento" de CJam) en parens derechos ("incremento" de CJam).fuente
F #: 489 caracteres
El siguiente programa no salta a las instrucciones '[' / ']', sino que escanea el código fuente para el siguiente token coincidente. Por supuesto, esto lo hace un poco lento, pero aún puede encontrar los números primos por debajo de 100. Los tipos enteros F # no se desbordan sino que se ajustan.
Aquí está la versión corta:
Un problema desagradable fue que el programa primes.bf se ahoga en las nuevas líneas de Windows. Para ejecutarlo, tuve que guardar el número de entrada en un documento de texto con formato UNIX y alimentarlo al programa con una tubería:
Editar: ingresar Alt + 010 seguido de Enter también funciona en Windows cmd.exe
Aquí está la versión más larga:
fuente
Delphi,
397382378371366364328 caracteres¡Comete este Delphi!
Aquí el mismo código, sangrado y comentado:
Este me llevó unas horas, ya que no es el tipo de código que normalmente escribo, ¡pero disfrútalo!
Nota: La prueba principal funciona, pero no se detiene en 100, porque dice # 13 (CR) antes de # 10 (LF) ... ¿otras presentaciones también sufren este problema cuando se ejecutan en sistemas operativos CRLF?
fuente
C, 260 + 23 = 283 bytes
Creé un programa en C que se puede encontrar aquí .
Tiene que compilarse a través de
gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.c
y se puede invocar de la siguiente manera:pmmbf ",[.-]" 30000
mediante el cual el primer argumento (citado) contiene el programa bf para ejecutar, el segundo determina qué tan grande debe ser la cinta.fuente
-D"q(a,b)"="*c-a||(b);"
opción, ya que eso parece (al menos para mi comprensión limitada) ayudarlo a reducir su código.define
y la nueva línea, pero no creo que sea realmente kosher. De todos modos con las citas, comentarios, ygcc -D
no veo la ventaja en absoluto.C, 267
Ejecutar como ./a.out primes.bf
Versión sin golf:
fuente
Pitón 2, 223
Admito que reciclé un programa antiguo mío (pero tuve que cambiarlo un poco, porque la versión anterior no tenía entrada, pero la comprobación de errores ...).
Ejecuta bien la calculadora de primos.
Ahora veo que Alexandru tiene una respuesta que tiene algunas similitudes. Publicaré mi respuesta de todos modos, porque creo que hay algunas ideas nuevas.
fuente
C (gcc) Linux x86_64,
884 621 525 487 439 383 358354 bytesPruébalo en línea!
Este es un JIT que compila código BF en lenguaje máquina x86_64 en tiempo de ejecución. Este realiza una traducción recta de manera que ocurren comúnmente secuencias tales como
>>>
,<<<
,+++
y---
no se unió en instrucciones más rápidos.Versión menos golfizada:
fuente
C,
374368Lee de un archivo. Pasa la prueba PRIME.BF.
Uso: ./a.out PRIME.BF
Reformateado:
fuente
Lua, 285
Versión algo legible:
Funciona perfectamente
Lua, 478, sin cuerda de carga
Versión legible:
fuente
Brainfuck, 948 bytes
Bueno, eso tomó un tiempo. Jugué un auto-intérprete Brainfuck por ... no yo.
fuente
Retiro , 594 bytes
En resumen: Recall no tiene operadores aritméticos en un sentido clásico, solo tiene operaciones bit a bit. No puede simplemente "agregar uno", etc. La recuperación también está estrictamente basada en la pila.
Ejemplo 1: imprimir algo
Entrada:
Salida:
Ejemplo 2: números cuadrados de salida hasta 100
Entrada:
Salida:
Este ejemplo puede tardar unos minutos en ejecutarse y puede provocar el mensaje "esta pestaña está congelada". Ignora eso y espera.
fuente
OCaml (lex), 497 caracteres
OCamllex es parte de la distribución estándar de OCaml.
Guardar como b.mll y ejecutar con
No me gusta analizar a mano, así que utilicé el generador lexer provisto. A partir de los tokens leídos, componimos una función para todo el programa brainf * ck.
fuente
C # (2861 caracteres, ~ 84 líneas)
Esta no es la solución más bonita para el problema, y probablemente no sea todo ese 'Golf-ish', ya que no estaba tan preocupado por la longitud como probablemente debería haber estado. (No eliminé los comentarios ni el espacio en blanco adicional). Solo quería probar algo en un nuevo idioma, para ver si podía. Si lo volviera a hacer, abandonaría el uso de la pila para volver de ']' y solo miraría hacia atrás. Ejecutar sin argumentos de línea de comando, ejecuta el programa hello world que se proporciona en la descripción del problema. Acepta un argumento de línea de comando, el nombre de archivo del programa a ejecutar.
Editar: se eliminaron las referencias no utilizadas.
fuente
C (gcc) ,
273268 bytesPruébalo en línea!
-5 gracias a ceilingcat
Toma información de stdin.
Esto depende un poco del medio ambiente, pero es bastante consistente. Esta es efectivamente la solución de evaluación para c. Escribe un programa C apropiado en el archivo wc, lo compila y lo ejecuta como el ejecutable deseado. Por lo tanto, como efecto adicional, esto realmente compila el código bf y lo deja
a.out
como un binario. Tenga en cuenta que, según el sistema, es posible que deba modificar la última cadena. En particular, la mayoría de los compiladores de Windows C llaman al ejecutable predeterminado "a.exe". Afortunadamente, por lo que puedo decir, todos tienen la misma longitud, por lo que el bytecount es el mismo. (aunque si no tiene un cc definido, es posible que deba agregar una letra como gcc al comando de compilación, agregando 1 byte).Soy consciente de que este hilo es un poco viejo, pero todavía no vi este estilo de solución C, así que pensé en agregarlo.
fuente
[EDITAR]
C ++ 11, 355, lee del archivo:
Prueba
http://ideone.com/b7vO4
[VERSIÓN ANTIGUA]
C ++ 11, 391, para ver en ejecución: http://ideone.com/yZHVv
fuente