Buenas de nuevo,
justo coincidi con un amigo q me dedico un buen rato para explicar como va esto, asi q si entra, pues os pasteo el cursillo :P
<sheroc> 8 instrucciones
<sheroc> aver
<sheroc> tienes
<sheroc> un array ( tamaño ilimitado )
<xevian> ajam
<sheroc> aunque a nivel standard son 3000 o 30000 bytes creo
<sheroc> bien
<sheroc> pues
<sheroc> ahora
<sheroc> tienes 8 instrucciones
<xevian> sip
<sheroc> > incrementa el puntero en ese array de 0s
<sheroc> ( inicialmente el puntero empieza en una posicion - que en teoria no
sabes pero en
practica es la primera posiscion -
<sheroc> )
<sheroc> < hace lo inverso
<sheroc> tira el puntero patras
<xevian> sip
<sheroc> bien
<sheroc> + incrementa en uno el byte que esta apuntado por el puntero
<sheroc> y el - lo decrementa en uno
<sheroc> luego tienes
<sheroc> [ que lo que hace es
<sheroc> si el byte apuntado por el puntero
<sheroc> tiene valor 0
<sheroc> salta al ] que lo cierra
<sheroc> xevian
<sheroc> pues aver
<sheroc> que estos [] son lo mas chungo de pillar
<sheroc> pero es facil aun asi
<xevian> yo escuso :)
<sheroc> eshcushassh
<sheroc> xD
<sheroc> bien
<xevian> los []
<sheroc> suponte
<xevian> serian como el if, no?
<sheroc> si
<xevian> ok
<sheroc> pero aver
<sheroc> mira
<sheroc> [-]
<sheroc> eso
<sheroc> suponte que el puntero esta en la posicion 234
<sheroc> imaginate
<xevian> sip
<sheroc> ok?
<sheroc> bien
<sheroc> bien
<sheroc> el [ dice q esta a cero el byte que esta en la posicion 234
<sheroc> y si lo está, salta a una posicion mas que el ] que lo cierra
<sheroc> sorry
<xevian> ajam
<xevian> facil
<sheroc> bien
<sheroc> ese - decrementa el byte de la pos 234
<sheroc> no?
<sheroc> tonces
<sheroc> dime que haria [-]
<xevian> en q caso?
<mscorlib> [-][o]
<xevian> [ esta a cero o no?
<xevian> el [-] apuntaria donde esta ],no?
<sheroc> no
<sheroc> aver
<sheroc> [ es como if (*p==0) goto ]+1
<xevian> sip
<sheroc> donde p es la posicion actual del puntero
<xevian> sip
<sheroc> bien
<sheroc> tonces
<sheroc> supon que en la pos 234 hay un 17
<xevian> okokok
<xevian> fallo mio
<sheroc> tonces
<xevian> q habia leido q -
<xevian> decrementaba en uno la posicion del puntero
<sheroc> [-]
<xevian> no el valor al q apunta
<sheroc> hehe
<sheroc> no
<sheroc> tiene dos instrucciones mas
<xevian> tu diras :)
<sheroc> pero aun no te explicado bien las []
<xevian> amm
<xevian> ok
<sheroc> aver
<sheroc> [-]
<sheroc> eso hace que el byte apuntado por el puntero
<sheroc> se ponga a 0 fijo
<sheroc> como lo hace?
<sheroc> bien
<sheroc> hemos dicho
<sheroc> [ hace que si *p==0 entonces salta a la pos de "]"+1
<sheroc> y ahora
<sheroc> la ] hace saltar a la "[" que abrio el ambito cerrado
<sheroc> vale?
<sheroc> tonces
<sheroc> hemos dicho tb que "-" hace *p=*p-1
<sheroc> ok?
<xevian> umm
<xevian> pera q hago saltos mentales.. :P
<xevian> ummm.. el ] te vuelve al [ ?
<sheroc> sip
<sheroc> eso es
<xevian> entonces valdria
<xevian> como condicional, tmb, no?
<sheroc> si
<xevian> te vuelve a [ o a [+1 o [-1 ?
<sheroc> el [ es una if
<sheroc> o tb una while
<sheroc> o una for
<sheroc> :D
<xevian> ajam
<xevian> el ] te vuelve a [ o a [+1 o [-1 ?
<sheroc> te vuelve a "["
<sheroc> justo ahí
<xevian> okok
<xevian> i te comprueba?
<sheroc> el ] no comprueba nada
<xevian> osea, la [ hace su funcion de siempre?
<sheroc> es un GOTO
<sheroc> si
<xevian> ok
<sheroc> la [ vvuelve a hacer la misma funcion
<xevian> si era 0 o 1
<sheroc> sisi
<xevian> perfect
<xevian> sigamos
<sheroc> pero es que la ] solo salta
<xevian> :)
<sheroc> osea
<xevian> sisi
<sheroc> tu cada instruccion la tienes que mirar por separado
<sheroc> tonces
<sheroc> volvamos a nuestro ejemplo [-]
<sheroc> tenemos el puntero apuntando a la posicion 234
<xevian> sip
<sheroc> y en esa posicion hay un byte con valor 17
<aMoK> sa klase del sheroc ;)
<xevian> jeje
<sheroc> haha
<sheroc> aMoK
<xevian> buen profe :P
<sheroc> :D
<sheroc> psss
<sheroc> sin mas eh
<sheroc> no soy mu bueno
<sheroc> aver
<sheroc> tonces
<sheroc> empezamos a ejecutar el [-]
<sheroc> nos llega el [
<sheroc> miramos en pa posicion actual ( 234 )
<sheroc> y vemos que hay un 17 ( como no es un 0, no saltamos simplemente se
sigue )
<sheroc> ahora
<sheroc> nos llega el "-"
<xevian> ajam
<sheroc> verdad?
<xevian> sip
<sheroc> tonces que se hace?
<sheroc> ese 17 pasa a ser 16
<sheroc> verdad?
<xevian> sip
<sheroc> decrementamos en uno el byte que esta apuntado por el puntero
<sheroc> bien
<sheroc> tonces ahora nos llega el "]"
<xevian> y volvemos al [
<sheroc> y este simplemente salta al "["
<xevian> y asi hasta 0
<xevian> ok
<sheroc> perfecto
<sheroc> bien
<sheroc> ahora miramos en la posicion del puntero actual ( 234 )
<sheroc> y que hay?
<sheroc> un 16
<sheroc> es 0
<sheroc> no, asique nada, se sigue
<sheroc> nos llega el "-"
<xevian> vale vale
<xevian> xDD
<sheroc> ese 16 pasa a ser 15
<xevian> ya se ha hecho 0
<xevian> :P
<xevian> pasa al ]+1
<sheroc> si
<xevian> ok
<sheroc> asique que es de manera efectiva un "[-]" ?
<xevian> es buena buena
<xevian> :D
<sheroc> que es?
<xevian> pues
<xevian> en pascal un repeat until0 :P
<sheroc> si y no
<sheroc> no es un repeat
<sheroc> es un while
<xevian> while not 0
<sheroc> es un "while (*p!=0) *p=*p-1;"
<sheroc> peor a efectos reales
<sheroc> o practicos
<sheroc> es un
<sheroc> [-] es un *p=0
<xevian> sip
<sheroc> es pa poner a cero el byte apuntado por el puntero
<xevian> cierto
<sheroc> ok?
<xevian> ok
<sheroc> bien
<sheroc> suponte
<sheroc> >+++[<+++>]
<sheroc> que hace eso?
<xevian> pera q lo pienso xD
<sheroc> empezamos en la posicion XXX
<sheroc> imaginate
<sheroc> tenemos inicialmente todas las posiciones apartir de esa XXX con byt
es a 0
<sheroc> osea
<sheroc> XXX: 00 00 00 00 00
<sheroc> todos esta a cero apartir de la direccion XXX
<xevian> ok
<sheroc> bien
<sheroc> nos llega la ">"
<sheroc> asique ahora el puntero pasa a tener el valor XXX+1
<xevian> sip
<sheroc> osea avanza una posicion
<sheroc> bien
<sheroc> nos llegan tres "+"es
<sheroc> asique
<sheroc> en XXX+1 que inicialmente era 0
<sheroc> ahora
<sheroc> sera
<sheroc> ... ?
<sheroc> que sera?
<aMoK> >oOOª>
<aMoK> xDD
<sheroc> capullo
<sheroc> xD
<xevian> jaja
<xevian> pues 1
<xevian> joer
<xevian> :P
<xevian> no? xD
<sheroc> nos llegan 3 "+"es
<xevian> eso si
<xevian> pos 3
<sheroc> esso es
<sheroc> tonces
<sheroc> ahora nos llega el "["
<sheroc> no?
<sheroc> bien
<xevian> sip
<sheroc> el puntero esta apuntando a un 0 ?
<xevian> sip
<xevian> pera
<sheroc> como que sip? o_O
<xevian> nono
<xevian> es q
<xevian> se me mete en la cabeza
<xevian> q al hacer el +
<xevian> el puntero se mueve
<xevian> pero no
<xevian> :P
<xevian> ha yun 3
<xevian> :P:P
<sheroc> eeso es
<sheroc> bien
<sheroc> tonces no salta
<sheroc> luego nos viene un "<"
<sheroc> que hace ese?
<xevian> tira el punteo a XXX
<sheroc> esso es
<sheroc> y en XXX que teniamos?
<xevian> no se sabe
<xevian> no las dixo
<xevian> hs dixo apartir
<xevian> inculido XXX ?
<xevian> :P
<sheroc> si
<sheroc> incluido
<xevian> entonces 0
<sheroc> suponte que habia un 0
<sheroc> eso es
<sheroc> bien
<sheroc> tonces
<sheroc> ahora llegan 3 "+"es
<sheroc> recuerda que el programa era >+++[<+++>]
<xevian> sip
<sheroc> vale
<sheroc> tonces
<sheroc> que hacen esos tres "+"es ?
<xevian> ponen XXX a 3
<sheroc> oka
<sheroc> vale
<sheroc> ahora nos llega
<sheroc> ">"
<xevian> ummm
<xevian> este miniprogram
<sheroc> y me doy cuanta que el programa esta mal es >+++[<+++>-]
<xevian> q hace ? incrementar de 3 en 3 XXX ?
<sheroc> peor bueno
<xevian> xD
<sheroc> si
<sheroc> eso es
<sheroc> incrementa
<sheroc> 3 veces
<sheroc> la XXX
<sheroc> pero repite ese proceso 3 veces
<sheroc> asique
<xevian> el otro era bucle infinito
<xevian> si
<xevian> ok
<sheroc> pone un 3x3 = 9 en XXX
<sheroc> ok?
<xevian> sip
<sheroc> tonces
<sheroc> como ahrias por ejemplo
<sheroc> un programa
<sheroc> pa poner un
<sheroc> 25 en XXX
<sheroc> harias
<xevian> >+++++[<+++++>-]
<sheroc> esso es :D
<xevian> :P
<sheroc> bien
<sheroc> ahora
<sheroc> las dos instrucciones que quedan
<sheroc> son
<sheroc> "." y ","
<sheroc> "." saca al stdout ( escribe por pantalla si quieres ) lo que hay en
el byte apuntado por el puntero
<sheroc> y "," coge un byte de stdin y lo pone en el byte apuntado actualment
e
<xevian> sheroc: algo mas?
<sheroc> no
<sheroc> ahora coge el ejemplo que te pasteau
<sheroc> antes
<sheroc> aquel tochillo
<xevian> y si fuera a meter un caracter? solo trabaja con nums?
<sheroc> no
<sheroc> son caracteres ascii eh
<sheroc> cuidado
<sheroc> el . y la ,
<xevian> okok
<sheroc> sacan bytes
<sheroc> de la tabalk ascii
Ejercicio.
Q hace?
>+++++++[<+++++++++>-]<+++.++++++++++++++++.-----------------.++++++++.+++++.
>>++++++[<+++++>-]<++.<--------.>[-]+++[<+++++>-]<.>+++[<----->-]<---.+++++++
+.
Pues eso, espero q alguno se anime y le de caña al asunto. Si alguien se pregunta si realmente esto sirve para... os suena la makina ENIGMA de los nacis? pues fue descifrada mediante este lenguaje :D
Animo!!