Mierda de cerebro

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 20 de junio de 2022; las comprobaciones requieren 7 ediciones .
mierda de cerebro
clase de idioma esotérico
Apareció en 1993
Autor Müller urbano
Desarrollador Müller urbano [d]
extensión de archivo .bo.bf
Dialectos BrainSub, Brainfork, Brainloller, COW, Ook, Pbrain, Smallfuck, Spoon , LOLCODE , Whitespace , DoubleFuck , Feckfeck
sido influenciado FALSO
 Archivos multimedia en Wikimedia Commons

Brainfuck es uno de los lenguajes de programación esotéricos , inventado por Urban Müller en 1993 , conocido por su minimalismo .  El nombre del idioma se puede traducir al ruso como eliminación de cerebro , se deriva directamente de la expresión inglesa brainfuck ( cerebro -cerebro, joder - joder ), es decir, dedicarse a tonterías . El lenguaje tiene ocho comandos, cada uno de los cuales se escribe con un carácter. El código fuente de un programa Brainfuck es una secuencia de estos caracteres sin ninguna sintaxis adicional.

Uno de los motivos de Urban Muller era crear un lenguaje con el menor compilador posible. En parte se inspiró en el lenguaje FALSO , para el cual había un compilador de 1024 bytes. Hay compiladores de lenguaje Brainfuck de menos de 200 bytes [1] . La programación en el lenguaje Brainfuck es difícil de escribir, por lo que a veces se le llama el lenguaje de los masoquistas. Pero al mismo tiempo, Brainfuck es un lenguaje completamente natural, completo y simple y puede usarse para definir el concepto de computabilidad .

La máquina, controlada por los comandos Brainfuck , consta de un conjunto ordenado de celdas y un puntero a la celda actual, que se asemeja a la cinta y la cabeza de una máquina de Turing . Además, implica un dispositivo para comunicarse con el mundo exterior (ver los comandos . y , ) a través del flujo de entrada y el flujo de salida.

El lenguaje Brainfuck se puede describir usando equivalentes del lenguaje C :

Equipo Brainfuck C equivalente Descripción del equipo
Inicio del programa int i = 0;
char arr[30000];
memset(arr, 0, sizeof(arr));		 la memoria se asigna para 30,000 celdas con cero valores iniciales
> i++; pasar a la siguiente celda
< i--; pasar a la celda anterior
+ arr[i]++; aumentar el valor en la celda actual en 1
- arr[i]--; disminuir el valor en la celda actual en 1
. putchar(arr[i]); imprimir el valor de la celda actual
, arr[i] = getchar(); ingrese un valor desde afuera y guárdelo en la celda actual
[ while(arr[i]){ si el valor de la celda actual es cero, avance en el texto del programa hasta el carácter que sigue al ] correspondiente (incluido el anidamiento)
] } si el valor de la celda actual no es cero, retroceda en el texto del programa hasta el carácter [ (teniendo en cuenta el anidamiento)

A pesar de la primitividad externa, Brainfuck con un conjunto infinito de celdas tiene la integridad de Turing y, por lo tanto, no es inferior a los lenguajes "reales" como C , Pascal o Java en términos de potencial .

Brainfuck es adecuado para experimentos en programación genética debido a la simplicidad de la sintaxis y, en consecuencia, la generación de código fuente.

En el Brainfuck "clásico" descrito por Muller, el tamaño de celda es de un byte, el número de celdas es de 30 000. En el estado inicial, el puntero está en la posición más a la izquierda y todas las celdas se llenan con ceros. Los valores de celda aumentan o disminuyen módulo 256. La entrada/salida también se produce byte a byte, teniendo en cuenta la codificación ASCII (es decir, como resultado de la operación de entrada ( , ), el carácter 1 se escribirá en la celda actual como el número 0x31 (49), y la operación de salida ( . ) realizada en una celda que contiene 0x41 (65) imprimirá la A latina ). En otras variantes de idioma, el tamaño y el número de celdas pueden ser diferentes (más grandes). Hay versiones donde el valor de las celdas no es entero (coma flotante).

Ejemplo de programa

Brainfuck programa paso a paso que imprime Hello World! » con un salto de línea (en forma de código ASCII - 72 101 108 108 111 32 87 111 114 108 100 33 10): ++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++ . ++++++++++++++++++ ++++++++++++++ . +++++++ .. +++ . -------------------- -------------------------------------------------- -- --------------- . ++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++ . ++++++++++++++++++++++ ++++++ . +++ . ------ . -------- . ------------------ -------------------------------------------------- -- ---- . ---------------------- .

Total de 389 declaraciones y 1 celda de memoria utilizada. El programa optimizado es notablemente más corto: solo 111 declaraciones, pero 5 celdas de memoria. La primera celda se usa como contador de bucle para 10 iteraciones, las siguientes celdas contienen los números 7, 10, 3 y 1 , aumentados por este bucle a 70, 100, 30 y 10 , la suma se produce antes de imprimir, la segunda palabra es construido a partir de los restos del primero:

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

Analizando el programa:

El ciclo de rellenar los números principales
++++++++++ asignando a la celda 0 el valor 10
[ repita los comandos descritos por este paréntesis hasta que el valor de la celda actual 0 no sea igual a cero
>+++++++ incremento de celda 1 por 7
>++++++++++ incremento de celda 2 por 10
>+++ incremento de celda 3 por 3
>+ incremento de celda 4 por 1
<<<<- decremento de celda 0 por 1
] comprobando si la celda 0 es cero
Salida de la primera palabra
>++. en la celda 1 , sumando 2 a 70 e imprimiendo el código ASCII 72, es decir las letras " H ".
>+. en la celda 2 sumar 1 a 100 = 101, imprimir la letra " e "
+++++++.. en la misma celda sumando 7 a 101 = 108, imprimiendo " l " dos veces
+++. en la misma celda sumando 3 a 108 = 111, imprimiendo " o "
>++. en la celda 3 suma 2 a 30 = 32, imprime un espacio
Salida de segunda palabra con reutilización de celda
<<+++++++++++++++. en la celda 1 agregue 15 a 72 = 87, escriba " W "
>. la celda 2 ya tiene 111, inmediatamente escribe " o "
+++. en la misma celda sumando 3 a 111 = 114, imprimiendo " r "
------. en la misma celda, restar 6 de 114 = 108, imprimir " l "
--------. en la misma celda, restar 8 de 108 = 100, imprimir " d "
>+. en la celda 3 agregue 1 a 32 = 33, imprima " ! »
>. la celda 4 ya tiene 10, imprima inmediatamente el salto de línea

Intérprete Brainfuck

perl

Un ejemplo de un intérprete de Brainfuck escrito en Perl :

#!/usr/bin/perl abrir F , cambiar ; @code = grep { /[+-\.,\[\]><]/ } split '' , <F> ; for ( my $_ = 0 ; $_ < @code ; ++ $_ ) { ++ $cpu [ $i ] if $code [ $_ ] eq '+' ; -- $cpu [ $i ] if $código [ $_ ] eq '-' ; -- $i si $código [ $_ ] eq '<' ; ++ $i si $código [ $_ ] eq '>' ; print chr $cpu [ $i ] if $código [ $_ ] eq '.' ; $cpu [ $i ] = ord <STDIN> if $código [ $_ ] eq ',' ; if ( $código [ $_ ] eq '[' ) { if ( ! $cpu [ $i ]) { ++ $brc ; while ( $brc ) { ++ $_ ; ++ $brc if $código [ $_ ] eq '[' ; -- $brc if $código [ $_ ] eq ']' ; } } más { siguiente ; } } elsif ( $código [ $_ ] eq ']' ) { if ( ! $cpu [ $i ]) { siguiente ; } else { ++ $brc if $código [ $_ ] eq ']' ; while ( $brc ) { -- $_ ; -- $brc if $código [ $_ ] eq '[' ; ++ $brc if $código [ $_ ] eq ']' ; } -- $_ ; } } }

C++

Un ejemplo de un intérprete de Brainfuck escrito en C++ :

#incluir <iostream> #incluir <fstream> #incluir <vector> #include <iterador> int principal ( int argc , char ** argv ) { std :: archivo fstream ( argv [ 1 ], std :: ios :: in ); std :: istreambuf_iterator < char > fstart ( archivo ), defender ; std :: vector < char > itape ( fstart , fend ); archivo _ cerrar (); std :: vector < char > mtape ( 30000 , 0 ); std :: vector < char >:: iterador m = mtape . comenzar (); std :: vector < char >:: iterador i = itape . comenzar (); int b = 0 ; for (; i != itape . end (); ++ i ) { cambiar ( * i ){ caso '>' : if ( ++ m == mcinta . end ()) { cinta m retroceso ( 0 ); m = -mcinta ._ _ fin (); } romper ; caso '<' : - m ; romper ; caso '+' : +**** m ; romper ; caso '-' : --* m ; romper ; caso '.' : std :: cout << * m ; romper ; case ',' : std :: cin >> * m ; romper ; caso '[' : si ( * m ) continuar ; ++ b ; mientras ( b ) cambiar ( *++ i ){ caso '[' : ++ b ; romper ; caso ']' : - b ; romper ; } romper ; caso ']' : si ( !* m ) continuar ; ++ b ; mientras ( b ) cambiar ( *-- i ){ caso '[' : -- b ; romper ; caso ']' : ++ b ; romper ; } --yo ; _ romper ; } } }

Programación Brainfuck

Todos los principiantes en programación Brainfuck inmediatamente se encuentran con los siguientes problemas:

Estos problemas se pueden resolver.

Denote por @(k) el desplazamiento de k celdas hacia la derecha si k>0, y hacia la izquierda si k<0 En consecuencia, @(k) = >… k veces …> o <… -k veces …<
cero(): poner a cero la celda actual: [-] = [+]
add(k): sumando el valor de la celda n (actual) al valor de la celda n+k: [ - @(k) + @(-k) ] en este caso, el valor de la celda n se pierde (se pone a cero).
mov(k): copiando el valor de la celda n (actual) a la celda n+k con la pérdida (puesta a cero) del valor de la celda n: @(k) cero() @(-k) sumar(k) = @(k) [-] @(-k) [ - @(k) + @(-k) ]
copy(k,t): copia el valor de la celda n (actual) a la celda n+k utilizando una celda intermedia n + k + t, por lo que el valor de la celda n no se pierde (guarda). @(k) cero() @(t) cero() @(-kt) [ - @(k) + @(t) + @(-kt) ] @(k+t) mov(-kt) = @(k) [-] @(t) [-] @(-kt) [ — @(k) + @(t) + @(-kt) ] @(k+t) [ — @(-kt) + @(k+t) ]
ifelse(t): si la celda actual>0 entonces es verdadero si la celda actual = 0, entonces la condición es falsa Número de celda auxiliar relativo a t: @(t)[-]+@(-t) establece el indicador 1 para el caso contrario [ aquí las acciones de ramificación son verdaderas @(t)[-]@(-t) establece el indicador 0 para el caso contrario [-] salida de bucle ] @(t) [@(-t) aquí las acciones de ramificación son falsas @(t)[-] salida del bucle ] @(-t-1)

Brainfuck casi nunca se usa para programación práctica (con la excepción del trabajo de entusiastas individuales), y se usa principalmente para acertijos y problemas de competencia.

Lenguajes basados ​​en Brainfuck

Notas: 1. Especialmente para la funcionalidad del comando mOO, los códigos internos de sus comandos [2] se introducen en el lenguaje COW , en la tabla se indican en una columna separada. 2. La ausencia de un equipo se señala como ausente .

mierda de cerebro ¡OK! VACA código de vaca Descripción
] ¿OK? ¡OK! mugir 0 fin de ciclo
< ¿OK? ESTÁ BIEN. mugir una celda anterior
> ESTÁ BIEN. ¿OK? mugir 2 siguiente celda
os. os. mugir 3 Ejecute el valor en la celda actual como un comando con el código correspondiente del rango 0 - 11; el código 3 provoca un bucle
os. os. Mugir cuatro Si el valor de la celda actual es cero, ingréselo desde el teclado; si el valor de la celda actual no es cero, muéstrelo en la pantalla
- ¡OK! ¡OK! Mugir 5 El valor de la celda actual se reduce en 1
+ ESTÁ BIEN. ESTÁ BIEN. Mugir 6 El valor de la celda actual se incrementa en 1
[ ¡OK! ¿OK? mes 7 Inicio de bucle (COW tiene una función: se omite el primer comando del bucle)
[-] os. OOO ocho Restablece el valor en la celda actual
os. os. MMM 9 Si el registro está vacío, copie el valor de la celda actual en él; de lo contrario, copie el contenido del registro en la celda y borre el registro.
. ¡OK! ESTÁ BIEN. OM diez Mostrar el valor de la celda actual
, ESTÁ BIEN. ¡OK! oom once Consultar el valor de la celda actual

Véase también

Dialectos y realizaciones

Otra descripción de los muchos dialectos de este idioma se puede encontrar en la enciclopedia wiki de idiomas esotéricos [3]

Otros implementadores abstractos y sistemas informáticos formales

Notas

  1. ↑ Por ejemplo, código fuente del compilador de 166 bytes (enlace no disponible) . Fecha de acceso: 18 de agosto de 2010. Archivado desde el original el 19 de agosto de 2010. 
  2. ↑ COW - un dialecto del lenguaje de programación Brainfuck - Enciclopedia de lenguajes de programación . Consultado el 11 de diciembre de 2020. Archivado desde el original el 5 de mayo de 2021.
  3. ↑ Categoría: Brainfuck_derivatives Archivado el 14 de abril de 2012 en Wayback Machine , esolangs.org

Enlaces


 Lenguajes de programación