Brainfuck es un lenguaje de programación esotérico creado en 1993 por Urban Müller. [1]
Paradigma | esotérico , imperativo , estructurado |
---|---|
Diseñada por | Urban Müller |
Apareció por primera vez | Septiembre de 1993 |
Disciplina de mecanografía | sin tipo |
Extensiones de nombre de archivo | .b, .bf |
Influenciado por | |
P ′ ′ , FALSO | |
Influenciado | |
Malbolge |
Notable por su minimalismo extremo, el lenguaje consta de solo ocho comandos simples, un puntero de datos y un puntero de instrucción . Si bien está completamente Turing completo , no está diseñado para un uso práctico, sino para desafiar y divertir a los programadores . Brainfuck simplemente requiere que uno rompa los comandos en pasos microscópicos.
El nombre del idioma es una referencia al término de jerga brainfuck , que se refiere a cosas tan complicadas o inusuales que exceden los límites de la comprensión de uno.
Historia
En 1992, Urban Müller, un estudiante de física suizo, se hizo cargo de un pequeño archivo en línea para el software Amiga . [2] El archivo se hizo más popular y pronto se reflejó en todo el mundo. Hoy en día, es el archivo Amiga más grande del mundo, conocido como Aminet .
Müller diseñó Brainfuck con el objetivo de implementar el compilador más pequeño posible , [3] inspirado en el compilador de 1024 bytes para el lenguaje de programación FALSE . [4] El compilador original de Müller se implementó en lenguaje de máquina y se compiló en un binario con un tamaño de 296 bytes. Subió el primer compilador Brainfuck a Aminet en 1993. El programa venía con un archivo "Readme", que describía brevemente el lenguaje, y desafiaba al lector "¿Quién puede programar algo útil con él? :) ". Müller también incluyó un intérprete y algunos ejemplos bastante elaborados. Una segunda versión del compilador utilizó solo 240 bytes. [5]
A medida que Aminet creció, el compilador se hizo popular entre la comunidad de Amiga y, con el tiempo, se implementó para otras plataformas.
P ′ ′: el "lenguaje de los padres" formal de Brainfuck
Excepto por sus dos comandos de E / S, Brainfuck es una variación menor del lenguaje de programación formal P ′ ′ creado por Corrado Böhm en 1964, que a su vez se basa explícitamente en la máquina de Turing . De hecho, el uso de seis símbolos equivalentes a los comandos Brainfuck respectivos +
, -
, <
, >
, [
, ]
, Böhm proporcionado un programa explícito para cada una de las funciones básicas que juntos sirven para calcular cualquier función computable . Así que los primeros programas de "Brainfuck" aparecen en el artículo de Böhm de 1964, y fueron suficientes para demostrar que Turing estaba completo.
The Infinite Abacus: el lenguaje de los "abuelos" de Brainfuck
Joachim Lambek introdujo una versión con direccionamiento de memoria explícito sin pila y un salto condicional en 1961 con el nombre de Infinite Abacus, [6] que consta de un número infinito de celdas y dos instrucciones:
X+
(incremento de celda X)X- else jump T
(disminuya X si es positivo, de lo contrario, salte a T)
Demuestra que Infinite Abacus puede calcular cualquier función recursiva computable programando el conjunto de Kleene de funciones básicas recursivas μ .
Su máquina fue simulada por la máquina de Melzac [7] que modela el cálculo mediante aritmética (en lugar de lógica binaria) imitando a un operador humano moviendo guijarros en un ábaco, de ahí el requisito de que todos los números deben ser positivos. Melzac, cuya computadora con un conjunto de instrucciones es equivalente a un ábaco infinito, ofrece programas para multiplicación, mcd, n- ésimo número primo, representación en base b, ordenación por magnitud, y muestra cómo simular una máquina de Turing arbitraria.
Diseño de lenguaje
El idioma consta de ocho comandos , que se enumeran a continuación. Un programa de Brainfuck es una secuencia de estos comandos, posiblemente intercalados con otros caracteres (que se ignoran). Los comandos se ejecutan secuencialmente, con algunas excepciones: un puntero de instrucción comienza en el primer comando, y cada comando al que apunta se ejecuta, después de lo cual normalmente avanza al siguiente comando. El programa termina cuando el puntero de la instrucción pasa del último comando.
El lenguaje Brainfuck utiliza un modelo de máquina simple que consta del programa y el puntero de instrucción, así como una matriz unidimensional de al menos 30.000 celdas de bytes inicializadas a cero; un puntero de datos móvil (inicializado para apuntar al byte más a la izquierda de la matriz); y dos flujos de bytes para entrada y salida (la mayoría de las veces se conectan a un teclado y un monitor respectivamente, y utilizan la codificación de caracteres ASCII ).
Comandos
Los ocho comandos de idioma constan cada uno de un solo carácter:
Personaje | Significado |
---|---|
> | incremente el puntero de datos (para apuntar a la siguiente celda a la derecha). |
< | disminuir el puntero de datos (para apuntar a la siguiente celda a la izquierda). |
+ | incrementar (incrementar en uno) el byte en el puntero de datos. |
- | disminuir (disminuir en uno) el byte en el puntero de datos. |
. | salida del byte en el puntero de datos. |
, | aceptar un byte de entrada, almacenando su valor en el byte en el puntero de datos. |
[ | si el byte en el puntero de datos es cero, entonces en vez de mover el puntero de instrucción que llegue el siguiente comando, saltar que avance a la orden después de que el juego ] de comandos. |
] | si el byte en el puntero de datos es distinto de cero, entonces en lugar de mover el puntero de instrucción hacia adelante al siguiente comando, salte de nuevo al comando después del comando coincidente [ . |
(Alternativamente, el ]
comando puede traducirse como un salto incondicional al[
comando correspondiente , o viceversa; los programas se comportarán igual pero se ejecutarán más lentamente, debido a una doble búsqueda innecesaria).
[
y ]
coinciden como suelen hacerlo los paréntesis: cada uno [
coincide exactamente con uno ]
y viceversa, el [
viene primero, y no puede haber ningún emparejamiento [
o ]
entre los dos.
Los programas Brainfuck se pueden traducir a C usando las siguientes sustituciones, asumiendo que ptr
es de tipo char*
y se ha inicializado para apuntar a una matriz de bytes con cero:
comando Brainfuck | Equivalente de C |
---|---|
(Inicio del programa) | char array[30000] = {0}; char *ptr = array; |
> | ++ptr; |
< | --ptr; |
+ | ++*ptr; |
- | --*ptr; |
. | putchar(*ptr); |
, | *ptr = getchar(); |
[ | while (*ptr) { |
] | } |
Como sugiere el nombre, los programas Brainfuck tienden a ser difíciles de comprender. Esto se debe en parte a que cualquier tarea levemente compleja requiere una larga secuencia de comandos y en parte a que el texto del programa no da indicaciones directas del estado del programa . Estos, así como la ineficiencia de Brainfuck y sus capacidades limitadas de entrada / salida, son algunas de las razones por las que no se utiliza para programación seria. No obstante, como cualquier lenguaje completo de Turing, Brainfuck es teóricamente capaz de calcular cualquier función computable o simular cualquier otro modelo computacional, si se le da acceso a una cantidad ilimitada de memoria. [8] Se ha escrito una variedad de programas Brainfuck. [9] Aunque los programas Brainfuck, especialmente los complicados, son difíciles de escribir, es bastante trivial escribir un intérprete para Brainfuck en un lenguaje más típico como C debido a su simplicidad. Incluso existen intérpretes Brainfuck escritos en el propio idioma Brainfuck. [10] [11]
Brainfuck es un ejemplo del llamado tarpit de Turing : se puede usar para escribir cualquier programa, pero no es práctico hacerlo, porque Brainfuck proporciona tan poca abstracción que los programas se vuelven muy largos y / o complicados.
Ejemplos de
Sumando dos valores
Como primer ejemplo simple, el siguiente fragmento de código agregará el valor de la celda actual a la celda siguiente: Cada vez que se ejecuta el ciclo, la celda actual se reduce, el puntero de datos se mueve hacia la derecha, la celda siguiente se incrementa y el puntero de datos vuelve a moverse a la izquierda. Esta secuencia se repite hasta que la celda inicial es 0.
[ - > + < ]
Esto se puede incorporar en un programa de adición simple de la siguiente manera:
++ Celda c0 = 2 > +++++ Celda c1 = 5 [ Inicie sus bucles con su puntero de celda en el contador de bucle (c1 en nuestro caso) < + Suma 1 a c0 > - Resta 1 de c1 ] Termina tus bucles con el puntero de celda en el contador de bucle En este punto, nuestro programa ha agregado 5 a 2 dejando 7 en c0 y 0 en c1, pero no podemos enviar este valor al terminal ya que no está codificado en ASCII .Para mostrar el carácter ASCII "7" debemos sumar 48 al valor 7 .Usamos un ciclo para calcular 48 = 6 * 8 .++++ ++++ c1 = 8 y este será nuestro contador de bucle nuevamente [ < +++ +++ Suma 6 a c0 > - Resta 1 de c1 ] < . ¡Imprima c0 que tiene el valor 55 que se traduce en "7"!
¡Hola Mundo!
El siguiente programa imprime "¡Hola mundo!" y una nueva línea a la pantalla:
[ Este programa imprime "¡Hola mundo!" y una nueva línea a la pantalla , su longitud es de 106 caracteres de comando activos . [ No es el más corto . ] Este bucle es un "bucle de comentario inicial" , una forma sencilla de agregar un comentario a un programa BF para que no tenga que preocuparse por ningún carácter de comando . Los caracteres " . " , " , " , " + " , " - " , " < " y " > " simplemente se ignoran , los caracteres " [ " y " ] " solo deben equilibrarse . Este bucle y los comandos que contiene se ignoran porque la celda actual tiene un valor predeterminado de 0; el valor 0 hace que se omita este bucle .]++++++++ Establecer celda n. ° 0 en 8 [ > ++++ Agregar 4 a la celda # 1; esto siempre establecerá la celda # 1 en 4 [ ya que la celda será borrada por el ciclo > ++ Agregar 2 a la celda # 2 > +++ Agregar 3 a la celda # 3 > +++ Agregar 3 a la celda # 4 > + Agregue 1 a la celda # 5 <<<< - Disminuya el contador de bucle en la celda # 1 ] Bucle hasta que la celda # 1 sea cero; el número de iteraciones es 4 > + Suma 1 a la celda n. ° 2 > + Suma 1 a la celda n. ° 3 > - Resta 1 de la celda n. ° 4 >> + Suma 1 a la celda n. ° 6 [ < ] Vuelve a la primera celda cero que encuentres ; esta será la celda # 1 que fue borrada por el ciclo anterior < - Disminuir el contador de ciclo en la celda # 0 ] Loop hasta que la celda # 0 sea cero; el número de iteraciones es 8 El resultado de esto es: Número de celda: 0 1 2 3 4 5 6 Contenido: 0 0 72104 88 32 8 Puntero: ^>> . La celda # 2 tiene el valor 72 que es 'H' > --- . Reste 3 de la celda n. ° 3 para obtener 101, que es 'e' +++++++ .. +++ . Lo mismo ocurre con 'llo' de la celda n. ° 3 >> . La celda # 5 es 32 para el espacio < - . Reste 1 de la celda n. ° 4 para obtener 87 para obtener una 'W' < . La celda n. ° 3 se estableció en 'o' desde el final de 'Hola' +++ . ------ . -------- . Celda # 3 para 'rl' y 'd' >> + . Agregar 1 a la celda # 5 nos da un signo de exclamación > ++ . Y finalmente una nueva línea de Cell # 6
Para "legibilidad", este código se ha distribuido en muchas líneas y se han agregado espacios en blanco y comentarios. Brainfuck ignora todos los caracteres excepto los ocho comandos, +-<>[],.
por lo que no se necesita una sintaxis especial para los comentarios (siempre que los comentarios no contengan los caracteres del comando). El código también podría haberse escrito como:
++++++++ [ > ++++ [ > ++ > +++ > +++ > + <<<< - ] > + > + > - >> + [ < ] < - ] > > . > --- . +++++++ .. +++ . >> . < - . < . +++ . ------ . -------- . >> + . > ++ .
ROT13
Este programa cifra su entrada con el cifrado ROT13 . Para hacer esto, debe asignar los caracteres AM ( ASCII 65-77) a NZ (78-90) y viceversa. También debe mapear am (97-109) a nz (110-122) y viceversa. Debe mapear todos los demás personajes a sí mismos; lee los caracteres uno a la vez y genera sus equivalentes cifrados hasta que lee un EOF (aquí se supone que se representa como -1 o "sin cambios"), momento en el que el programa termina.
El enfoque básico utilizado es el siguiente. Llamar al carácter de entrada x , dividir x -1 entre 32, manteniendo el cociente y el resto. A menos que el cociente sea 2 o 3, simplemente genere x , habiendo guardado una copia durante la división. Si el cociente es 2 o 3, divida el resto (( x -1) módulo 32) por 13; si el cociente aquí es 0, salida x +13; si es 1, salida x -13; si 2, salida x .
En cuanto el algoritmo de división, al dividir y por z para obtener un cociente q y resto r , hay un bucle exterior que establece q y r primero al cociente y el resto de 1 / z , a continuación, a los de 2 / z , y así en; después de que ha ejecutado Y veces, esto termina bucle externo, dejando q y r conjunto para el cociente y el resto de y / z . (El dividendo y se usa como un contador decreciente que controla cuántas veces se ejecuta este ciclo). Dentro del ciclo, hay un código para incrementar r y disminuir y , lo cual suele ser suficiente; sin embargo, cada z ésima vez a través del bucle exterior, es necesario poner a cero r e incrementar q . Esto se hace con un contador decreciente establecido en el divisor z ; cada vez que pasa por el bucle exterior, este contador disminuye y, cuando llega a cero, se rellena moviendo el valor de r de nuevo a él.
- , + [ Leer el primer carácter y comenzar el ciclo de lectura del carácter externo - [ Saltar hacia adelante si el carácter es 0 >> ++++ [ > ++++++++ < - ] Configurar el divisor (32) para el ciclo de división ( DISEÑO DE LA MEMORIA: dividendo copiar resto divisor cociente cero cero) < + < - [ Configurar dividendo (x menos 1) e ingresar bucle de división > + > + > - [ >>> ] Aumentar copia y resto / reducir divisor / Caso normal: saltar hacia adelante < [[ > + < - ] >> + > ] Caso especial: mover el resto hacia atrás al divisor y aumentar el cociente <<<<< - Disminuir dividendo ] Finalizar ciclo de división ] >>> [ - ] + Finalizar ciclo de salto; cero ex divisor y reutilizar el espacio para una bandera > - [ - [ < - > +++ [ - ]]] < [ Cero esa bandera a menos que el cociente sea 2 o 3; cociente cero; marca de verificación ++++++++++++ < [ Si marca, entonces configure el divisor (13) para el ciclo de la segunda división (DISEÑO DE LA MEMORIA: cero copia dividendo divisor resto cociente cero cero) > - [ > + >> ] Reducir divisor; Caso normal: aumentar el resto > [ + [ < + > - ] > + >> ] Caso especial: aumentar el resto / moverlo de regreso al divisor / aumentar el cociente <<<<< - Disminuir el dividendo ] Finalizar el ciclo de división >> [ < + > - ] Agregue el resto al divisor para obtener un 13 útil > [ Saltar hacia adelante si el cociente era 0 - [ Disminuir el cociente y saltar hacia adelante si el cociente era 1 - << [ - ] >> Cociente cero y divisor si el cociente era 2 ] < < [ << - >> - ] >> Cero divisor y reste 13 de la copia si el cociente era 1 ] << [ << + >> - ] Cero divisor y sume 13 para copiar si el cociente era 0 ] Fin del ciclo de salto externo ( saltar a aquí si ((carácter menos 1) / 32) no era 2 o 3) < [ - ] Borrar el resto de la primera división si se omitió la segunda división < . [ - ] Salida del carácter ROT13ed de la copia y borrarlo < - , + Leer el siguiente carácter ] Finalizar el ciclo de lectura de caracteres
Problemas de portabilidad
En parte porque Urban Müller no escribió una especificación completa del lenguaje, los muchos intérpretes y compiladores de brainfuck posteriores han implementado dialectos de brainfuck ligeramente diferentes.
Tamaño de la celda
En la distribución clásica, las celdas tienen un tamaño de 8 bits (las celdas son bytes) y este sigue siendo el tamaño más común. Sin embargo, para leer datos no textuales, un programa de brainfuck puede necesitar distinguir una condición de fin de archivo de cualquier valor de byte posible; por tanto, también se han utilizado celdas de 16 bits. Algunas implementaciones han utilizado celdas de 32 bits, celdas de 64 bits o celdas bignum con un rango prácticamente ilimitado, pero es probable que los programas que usan este rango adicional sean lentos, ya que almacenar el valor en una celda requiere el tiempo como el valor de una celda solo se puede cambiar aumentando y disminuyendo.
En todas estas variantes, los comandos ,
y .
aún leen y escriben datos en bytes. En la mayoría de ellos, las celdas se envuelven, es decir, incrementar una celda que tiene su valor máximo (con el +
comando) la llevará a su valor mínimo y viceversa. Las excepciones son implementaciones que están lejos del hardware subyacente, implementaciones que usan bignums e implementaciones que intentan imponer la portabilidad.
Por lo general, es fácil escribir programas geniales que nunca provoquen un ajuste o desbordamiento de enteros y, por lo tanto, no dependan del tamaño de la celda. Por lo general, esto significa evitar el incremento de +255 (envolvente de 8 bits sin signo) o evitar sobrepasar los límites de [-128, +127] (envolvente de 8 bits con signo) (dado que no hay operadores de comparación, un programa no puede distinguir entre un la celda de tamaño de bit fijo en complemento a dos con signo y sin signo y la negatividad de los números es una cuestión de interpretación). Para obtener más detalles sobre el envolvente de enteros, consulte el artículo Desbordamiento de enteros .
Tamaño de la matriz
En la distribución clásica, la matriz tiene 30.000 celdas y el puntero comienza en la celda más a la izquierda. Se necesitan aún más celdas para almacenar cosas como el número millonésimo de Fibonacci , y la forma más fácil de completar el lenguaje de Turing es hacer que la matriz sea ilimitada a la derecha.
Algunas implementaciones [12] también extienden la matriz a la izquierda; esta es una característica poco común y, por lo tanto, los programas portátiles de Brainfuck no dependen de ella.
Cuando el puntero se mueve fuera de los límites de la matriz, algunas implementaciones darán un mensaje de error, algunas intentarán extender la matriz dinámicamente, otras no lo notarán y producirán un comportamiento indefinido , y algunas moverán el puntero al extremo opuesto de la matriz. Están involucradas algunas compensaciones: expandir la matriz dinámicamente hacia la derecha es el enfoque más fácil de usar y es bueno para los programas que consumen mucha memoria, pero conlleva una penalización de velocidad. Si se utiliza una matriz de tamaño fijo, es útil hacerla muy grande o, mejor aún, dejar que el usuario establezca el tamaño. Dar un mensaje de error por violaciones de límites es muy útil para la depuración, pero incluso eso conlleva una penalización de velocidad a menos que pueda ser manejado por las protecciones de memoria del sistema operativo.
Código de fin de línea
Los diferentes sistemas operativos (y a veces diferentes entornos de programación) utilizan versiones sutilmente diferentes de ASCII. La diferencia más importante está en el código utilizado para el final de una línea de texto. MS-DOS y Microsoft Windows utilizan un CRLF , es decir, un 13 seguido de un 10, en la mayoría de los contextos. UNIX y sus descendientes (incluidos GNU / Linux y Mac OSX) y Amigas usan solo 10, y las Mac antiguas usan solo 13. Sería difícil si los programas de mierda tuvieran que reescribirse para diferentes sistemas operativos. Sin embargo, fue fácil crear un estándar unificado. El compilador de Urban Müller y sus programas de ejemplo utilizan 10, tanto en la entrada como en la salida; lo mismo ocurre con la gran mayoría de los programas de cogida cerebral existentes; y 10 también es más conveniente de usar que CRLF. Por lo tanto, las implementaciones de brainfuck deberían asegurarse de que los programas de brainfuck que asumen newline = 10 se ejecuten correctamente; muchos lo hacen, pero otros no.
Esta suposición también es coherente con la mayoría del código de muestra del mundo para C y otros lenguajes, ya que utilizan "\ n", o 10, para sus nuevas líneas. En los sistemas que usan terminaciones de línea CRLF, la biblioteca estándar de C reasigna de forma transparente "\ n" a "\ r \ n" en la salida y "\ r \ n" a "\ n" en la entrada para secuencias no abiertas en modo binario.
Comportamiento al final del archivo
El comportamiento del ,
comando cuando se encuentra una condición de fin de archivo varía. Algunas implementaciones establecen la celda en el puntero en 0, algunas la configuran en la constante C EOF (en la práctica, esto suele ser -1), algunas dejan el valor de la celda sin cambios. No existe un consenso real; Los argumentos para los tres comportamientos son los siguientes.
Establecer la celda en 0 evita el uso de números negativos y hace que sea un poco más conciso escribir un bucle que lea caracteres hasta que se produzca EOF. Esta es una extensión de lenguaje ideada por Panu Kalliokoski.
Establecer la celda en -1 permite distinguir EOF de cualquier valor de byte (si las celdas son más grandes que bytes), que es necesario para leer datos no textuales; también, es el comportamiento de la traducción C de ,
dado en el archivo Léame de Müller. Sin embargo, no es obvio que esas traducciones de C deban tomarse como normativas.
Dejar el valor de la celda sin cambios es el comportamiento del compilador de cerebro de Urban Müller. Este comportamiento puede coexistir fácilmente con cualquiera de los otros; por ejemplo, un programa que asume EOF = 0 puede establecer la celda en 0 antes de cada ,
comando, y luego funcionará correctamente en implementaciones que hagan EOF = 0 o EOF = "sin cambios". Es tan fácil adaptarse al comportamiento de "no cambiar" que cualquier programador de cerebro loco interesado en la portabilidad debería hacerlo.
Implementaciones
Tyler Holewinski desarrolló un marco de software basado en .NET , BrainF.NET , que de forma predeterminada ejecuta brainfuck, pero también puede extender el lenguaje con nuevos comandos o modificar el comportamiento de los existentes. BrainF.NET permite así el desarrollo de software como un IDE.
Aunque es trivial hacer un intérprete ingenuo de Brainfuck, escribir un compilador o intérprete optimizador se convierte en un desafío y una diversión al igual que escribir programas en Brainfuck en sí: para producir resultados razonablemente rápidos, el compilador necesita reconstruir las instrucciones fragmentarias forzadas por el idioma. Las posibles optimizaciones van desde optimizaciones simples de mirilla de longitud de ejecución en comandos repetidos y patrones de bucle comunes [-]
, hasta otras más complicadas, como eliminación de código muerto y plegado constante . [13]
Además de la optimización, también se han escrito otros tipos de intérpretes de brainfuck inusuales. Varios compiladores de brainfuck se han hecho con un tamaño inferior a 200 bytes, uno solo tiene 100 bytes en código de máquina x86. [14]
Derivados
Mucha gente ha creado equivalentes de brainfuck (lenguajes con comandos que se asignan directamente a brainfuck) o derivados de brainfuck (lenguajes que amplían su comportamiento o alteran su semántica).
Algunos ejemplos:
- Pi , que mapea el cerebro de los errores en los dígitos individuales de Pi . [15]
- VerboseFuck , que parece un lenguaje de programación tradicional, solo lo que aparece como parámetros o expresiones son en realidad partes de comandos más largos que no se pueden modificar. [dieciséis]
- DerpPlusPlus , en el que los comandos se reemplazan con palabras como 'HERP', 'DERP', 'GIGITY', etc. [17]
- ¡Ook! , que asigna los ocho comandos de Brainfuck a combinaciones de dos palabras de "Ook.", "Ook?" y "Ook!", diseñado en broma para ser "escribible y legible por orangutanes" según su creador, una referencia a la Bibliotecario orangután en las novelas de Terry Pratchett . [18] [19]
- Ternario , similar en concepto a Ook! sino que consiste en permutaciones de los caracteres ASCII 0, 1 y 2. [20]
- BodyFuck , una implementación de BrainFuck basada en un sistema controlado por gestos para que los movimientos del programador sean capturados por una cámara de video y convertidos en los 8 personajes posibles. [21]
- OooWee , los comandos son variaciones de OooWee (por ejemplo, ooo, ooe, wee, etc.). Inspirado en el personaje de Rick y Morty Mr. PoopyButthole. [22]
- Yo uso Arch por cierto , que mapea el brainfuck en las palabras que se encuentran en la frase "Yo uso Arch por cierto". Inspirado en una frase acuñada por la comunidad Arch Linux . [23]
- Brainfunk , asigna el brainfuck a muestras de voz, que se utilizan en una pista de baile, cuyas palabras codifican un programa de brainfuck. [24]
Ver también
- JSFuck : un lenguaje de programación JavaScript esotérico con un conjunto de caracteres muy limitado
Referencias
- ↑ Pascua, Brandee (2 de abril de 2020). "Totalmente humano, totalmente máquina: retórica de la descorporización digital en la programación". Revisión de la retórica . 39 (2): 202–215. doi : 10.1080 / 07350198.2020.1727096 . ISSN 0735-0198 .
- ^ "Aminet alcanza 5000 archivos" . Urban Müller. 1993-09-24 . Consultado el 3 de mayo de 2015 .
- ^ "El lenguaje de programación Brainfuck" . Muppetlabs.com . Consultado el 30 de octubre de 2013 .
- ^ "Wiki de Wouter: lenguaje falso" . Strlen.com. 2013-08-03 . Consultado el 30 de octubre de 2013 .
- ^ "dev / lang / brainfuck-2.lha" . Aminet. Archivado desde el original el 6 de noviembre de 2005 . Consultado el 30 de octubre de 2013 .
- ^ J. Lambek (1961). "Cómo programar un ábaco infinito" . Boletín matemático canadiense . Archivado desde el original el 15 de septiembre de 2018 . Consultado el 15 de septiembre de 2018 .
- ^ ZA Melzak (1961). "Un enfoque aritmético informal a la computabilidad y la computación" . Boletín matemático canadiense . Archivado desde el original el 15 de septiembre de 2018 . Consultado el 15 de septiembre de 2018 .
- ^ "BF es Turing completo" . Iwriteiam.nl . Consultado el 30 de octubre de 2013 .
- ^ "Índice de / brainfuck / bf-source / prog" . Esoteric.sange.fi. 2002-01-22 . Consultado el 30 de octubre de 2013 .
- ^ "Intérprete BF escrito en BF" . Iwriteiam.nl . Consultado el 30 de octubre de 2013 .
- ^ "intérprete de mierda de cerebro" . Daniel B. Cristofani.
- ^ Bolognani, Andrea. "Carne de res -" . Kiyuko.org . Consultado el 30 de octubre de 2013 .
- ^ Hughes, Wilfred (5 de agosto de 2020). "Wilfred / bfc: un compilador de brainfuck de grado industrial" . GitHub .
- ^ "Brainfuck en 100 Bytes!" . github.com . Consultado el 22 de marzo de 2016 .
- ^ "Pi - Esolang" . esolangs.org . Consultado el 19 de marzo de 2019 .
- ^ "VerboseFuck - Esolang" . esolangs.org . Consultado el 11 de septiembre de 2019 .
- ^ "TheRaz / DerpPlusPlus" . Github.com . Consultado el 8 de abril de 2015 .
- ^ Morgan-Mar, David (21 de marzo de 2009). "¡Ook!" . Lenguajes de programación esotéricos de DM . Consultado el 28 de junio de 2014 .
- ^ Paloque-Bergès, Camille (2009). Poétique des codes sur le réseau informatique (en francés). París: Éditions des archive contemporaines . pag. 73. ISBN 978-2-914610-70-4.
- ^ "Lenguaje de programación ternario" . Lenguaje de programación ternario . Consultado el 14 de junio de 2015 .
- ^ Hanselmann, Nik. "No hay hardware" . Consultado el 2 de febrero de 2016 .
- ^ "omkarjc27 / OooWee" . Github.com . Consultado el 19 de enero de 2019 .
- ^ "OverMighty / Yo uso Arch por cierto" . Github.com . Consultado el 3 de febrero de 2021 .
- ^ brainfunk (get with the program) , consultado el 16 de marzo de 2021
enlaces externos
- Brainfuck en Curlie
- Intérprete Brainfuck online en JavaScript con colección de programas
- Brainfuck IDE : un entorno de desarrollo genial con depurador interactivo
- Generador de Brainfuck - Un generador de texto a Brainfuck
- Colección Brainfuck de intérpretes y guiones
- Brainfuck al compilador COBOL, C, ASM, PL / 1, ...
- Brainfuck Assembler traduce el código ensamblador x86 (conjunto reducido) en código Brainfuck
- Zona de juegos Brainfuck en tio.run