Al fin después de tanto trabajar pudimos encontrar la solución de esta dificultad que tantos lectores de nuestra web han tenido. Si deseas compartir algo más no dudes en dejar tu comentario.
Solución:
1. Conceptos básicos
Para entender Brainfuck debes imaginar infinito array de celdas inicializadas por 0 cada.
...[0][0][0][0][0]...
Cuando se inicia el programa Brainfuck, apunta a cualquier celda.
...[0][0][*0*][0][0]...
Si mueve el puntero a la derecha > está moviendo el puntero de la celda X a la celda X + 1
...[0][0][0][*0*][0]...
Si aumenta el valor de la celda + usted obtiene:
...[0][0][0][*1*][0]...
Si vuelve a aumentar el valor de la celda + usted obtiene:
...[0][0][0][*2*][0]...
Si disminuye el valor de la celda - usted obtiene:
...[0][0][0][*1*][0]...
Si mueve el puntero hacia la izquierda < está moviendo el puntero de la celda X a la celda X-1
...[0][0][*0*][1][0]...
2. Entrada
Para leer el carácter, usa una coma. ,. Lo que hace es: Lea el carácter de la entrada estándar y escriba su código ASCII decimal en la celda real.
Eche un vistazo a la tabla ASCII. Por ejemplo, código decimal de ! es 33, tiempo a es 97.
Bueno, imaginemos que la memoria de su programa BF se ve así:
...[0][0][*0*][0][0]...
Suponiendo que la entrada estándar significa a, si usa una coma , operador, lo que hace BF es leer a código ASCII decimal 97 a la memoria:
...[0][0][*97*][0][0]...
Por lo general, quiere pensar de esa manera, sin embargo, la verdad es un poco más compleja. La verdad es que BF no lee un carácter sino un byte (cualquiera que sea ese byte). Déjame mostrarte un ejemplo:
En linux
$ printf ł
huellas dactilares:
ł
que es un carácter polaco específico. Este carácter no está codificado por codificación ASCII. En este caso es la codificación UTF-8, por lo que solía ocupar más de un byte en la memoria de la computadora. Podemos probarlo haciendo un volcado hexadecimal:
$ printf ł | hd
que muestra:
00000000 c5 82 |..|
Los ceros están compensados. 82 es primero y c5 es el segundo byte que representa ł (para que los leamos). |..| es una representación gráfica que no es posible en este caso.
Bueno, si pasas ł como entrada a su programa BF que lee un solo byte, la memoria del programa se verá así:
...[0][0][*197*][0][0]...
Por qué 197 ? Bien 197 decimal es c5 hexadecimal. ¿Te parece familiar? Por supuesto. Es el primer byte de ł !
3. Salida
Para imprimir el carácter se usa el punto . Lo que hace es: Suponiendo que tratamos el valor real de la celda como un código ASCII decimal, imprima el carácter correspondiente en la salida estándar.
Bueno, imaginemos que la memoria de su programa BF se ve así:
...[0][0][*97*][0][0]...
Si usa el operador de punto (.) Ahora, lo que hace BF es imprimir:
a
Porque a el código decimal en ASCII es 97.
Entonces, por ejemplo, un programa BF como este (97 más 2 puntos):
++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++ ..
Aumentará el valor de la celda a la que apunta hasta 97 y lo imprimirá 2 veces.
Automóvil club británico
4. Bucles
En BF, el bucle consiste en el comienzo del bucle. [ and loop end ]. Puede pensar que es como en C / C ++, donde la condición es el valor real de la celda.
Eche un vistazo al programa BF a continuación:
++[]
++ incrementa el valor real de la celda dos veces:
...[0][0][*2*][0][0]...
Y [] es como while(2) , por lo que es un bucle infinito.
Digamos que no queremos que este bucle sea infinito. Podemos hacer por ejemplo:
++[-]
Entonces, cada vez que un bucle se repite, disminuye el valor real de la celda. Una vez que el valor real de la celda es 0 termina el bucle:
...[0][0][*2*][0][0]... loop starts
...[0][0][*1*][0][0]... after first iteration
...[0][0][*0*][0][0]... after second iteration (loop ends)
Consideremos otro ejemplo de bucle finito:
++[>]
Este ejemplo muestra que no hemos terminado el ciclo en la celda en la que comenzó el ciclo:
...[0][0][*2*][0][0]... loop starts
...[0][0][2][*0*][0]... after first iteration (loop ends)
Sin embargo, es una buena práctica terminar donde comenzamos. Por qué ? Porque si el bucle termina otra celda que comenzó, no podemos asumir dónde estará el puntero de la celda. Para ser honesto, esta práctica hace que la cogida de cerebro sea menos cogida de cerebro.
Wikipedia tiene una versión comentada del código.
+++++ +++++ initialize counter (cell #0) to 10
[ use loop to set the next four cells to 70/100/30/10
> +++++ ++ add 7 to cell #1
> +++++ +++++ add 10 to cell #2
> +++ add 3 to cell #3
> + add 1 to cell #4
<<<< - decrement counter (cell #0)
]
> ++ . print 'H'
> + . print 'e'
+++++ ++ . print 'l'
. print 'l'
+++ . print 'o'
> ++ . print ' '
<< +++++ +++++ +++++ . print 'W'
> . print 'o'
+++ . print 'r'
----- - . print 'l'
----- --- . print 'd'
> + . print '!'
> . print 'n'
Para responder a sus preguntas, el , y . los caracteres se utilizan para E / S. El texto es ASCII.
El artículo de Wikipedia también continúa con más profundidad.
La primera línea se inicializa
a[0] = 10simplemente aumentando diez veces desde 0. El bucle de la línea 2 establece efectivamente los valores iniciales para el array:a[1] = 70(cerca de 72, el código ASCII para el carácter 'H'),a[2] = 100(cerca de 101 o 'e'),a[3] = 30(cerca de 32, el código del espacio) ya[4] = 10(nueva línea). El ciclo funciona agregando 7, 10, 3 y 1 a las celdasa[1],a[2],a[3]ya[4]respectivamente cada vez a través del ciclo - 10 adiciones para cada celda en total (dando
a[1]=70etc.). Una vez finalizado el ciclo,a[0]es cero.>++.luego mueve el puntero aa[1], que contiene 70, le suma dos (produciendo 72, que es el código de caracteres ASCII de una H mayúscula) y lo genera.La siguiente línea mueve el array puntero a
a[2]y le agrega uno, produciendo 101, una 'e' minúscula, que luego se imprime.Como 'l' es la séptima letra después de la 'e', a la salida 'll' se agregan otras siete (
+++++++) paraa[2]y el resultado se emite dos veces.'o' es la tercera letra después de 'l', entonces
a[2]se incrementa tres veces más y muestra el resultado.El resto del programa continúa de la misma manera. Para el espacio y las letras mayúsculas, diferentes array las celdas se seleccionan y aumentan o disminuyen según sea necesario.
Brainfuck
igual que su nombre. Utiliza solo 8 caracteres > [ . ] , - + lo que lo convierte en el mas rapido lenguaje de programación aprender pero más difícil de implementar y comprender.
… .Y hace que finalmente termines jodiendo tu cerebro.
Almacena valores en array: [72 ][101 ][108 ][111 ]
let, inicialmente puntero apuntando a la celda 1 de array:
-
>mover el puntero a la derecha en 1 -
<mover el puntero a la izquierda en 1 -
+incrementar el valor de la celda en 1 -
-incrementar el valor del elemento en 1 -
.imprimir el valor de la celda actual. -
,llevar la entrada a la celda actual. -
[ ]bucle, +++[ -] contador de 3 recuentos porque tiene 3 ′ + 'antes, y - disminuye la variable de recuento en 1 valor.
los valores almacenados en las celdas son valores ascii:
así que refiriéndome a arriba array: [72 ][101 ][108 ][108][111 ]
si coincide con los valores ascii, encontrará que es Hola escritora
¡Felicitaciones! has aprendido la sintaxis de BF
——-Algo más ———
hagamos nuestro primer programa, es decir Hola Mundo, después de lo cual podrá escribir su nombre en este idioma.
+++++ +++++[> +++++ ++ >+++++ +++++ >+++ >+ <<<-]>++.>+.+++++ ++..+++.++.+++++ +++++ +++++.>.+++.----- -.----- ---.>+.>.
rompiendo en pedazos:
+++++ +++++[> +++++ ++
>+++++ +++++
>+++
>+
<<<-]
Hace un array de 4 celdas (número de>) y establece un contador de 10 algo como: —- código de psuedo—-
array =[7,10,3,1]
i=10
while i>0:
element +=element
i-=1
porque el valor del contador se almacena en la celda 0 y> se mueve a la celda 1 actualiza su valor en + 7> se mueve a la celda 2 incrementa 10 a su valor anterior y así sucesivamente….
<<< vuelve a la celda 0 y disminuye su valor en 1
por lo tanto, después de la finalización del ciclo, tenemos array : [70,100,30,10]
>++.
se mueve al primer elemento e incrementa su valor en 2 (dos '+') y luego imprime el carácter ('.') con ese valor ascii. es decir, por ejemplo en python: chr (70 + 2) # imprime 'H'
>+.
se mueve al incremento de la 2da celda 1 a su valor 100 + 1 e imprime ('.') su valor es decir, chr (101) chr (101) # imprime 'e' ahora no hay> o último elemento = 101 por lo tanto, 101 + 7 y lo imprime dos veces (ya que hay dos '..') chr (108) #prints l dos veces se puede usar como ———¿Dónde se usa?——- Es solo un lenguaje de broma creado para desafiar a los programadores y no se usa prácticamente en ningún lado.+++++ ++..
for i in array:
for j in range(i.count(‘.’)):
print_value
valoraciones y reseñas