Algoritomo de la regla 110 en JAVA

Por peticion de unos compa~eros esta vez publico el codigo de la regla 110, en JAVA.

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package fractal;



public class automata {

    

    public static char convert(String d){

    char r='x';

        if(d.equals("000")) r = '0';

    else if(d.equals("001")) r = '1';

    else if(d.equals("010")) r = '1';

    else if(d.equals("011")) r = '1';

    else if(d.equals("100")) r = '0';

    else if(d.equals("101")) r = '1';

    else if(d.equals("110")) r = '1';

    else if(d.equals("111")) r = '0';

    return r; }



    public static void main(String arg[])

    {

    String SRED = "\u001B[37m";

    String ERED = "\u001B[31m";

        int t,index,aux1,aux2,aux3;

 String cad = "10010100101001010101010101010101010101010101000010100101010010001001001011011100101000";



 //cad = raw_input(">> ")

t =cad.length();

index = t-1;

//print "longitud : ",t

String r = "";

for (int j=0;j<40;j++){

    aux1 = index;

 // este debe ser longitud -1 , al iniciar

    aux2 = index -index; // este debe ser 0 al iniciar

    aux3 = index - (index-1); // este debe ser 1 al iniciar

    int cnt = 1;

    r="";

    char[] cadx=cad.toCharArray();

    for (int i=0;i<cad.length();i++){

        if (aux3==t){

           aux3=0;}

        char l = cadx[aux1];

        char m = cadx[aux2];

        char n = cadx[aux3];

    //System.out.println(aux1+"-"+aux2+"-"+""+aux3);

        String n1 = l+""+m+""+n;

        if (cnt==1){

            aux1 = 0;

            aux2 = 1;

            aux3 = 2; }

        else {

            aux1 = aux1 +1;

            aux2 = aux2 +1;

            aux3 = aux3 +1; }

        cnt = cnt+1;

//        System.out.println(n1 + " - - " + convert(n1) );

        r += ""+convert(n1);

    }

    

    cad = r;

    for(char c:r.toCharArray()) {

    if(c=='0'){

        System.out.print(SRED+""+"█"+ERED);

    }

    else {

        System.out.print("█");

    }

}

    System.out.println("");

    //System.out.println(r);

}   





//print r

   }    

}

Funciona de la misma forma que el algoritmo anterior solo que este esta en java, hay ciertas caracteristicas muy diferentes de python, como son la declaracion de variables y la sintaxis de los for, pero la estructura del algoritmo es la misma.

Algoritmo de la regla 110 ITSC

Bueno este es el codigo del algoritmo de la regla 110 expuesta en la clase de graficacion 6A del ITSC, el codigo a continuacion es codigo python, pero obivamente muy facil de pasar a otro lenguaje de programacion como java.

el codigo es el siguiente :

def convert(d):
    if(d=="000"): r = '0';
    elif(d=="001"): r = '1';
    elif(d=="010"): r = '1';
    elif(d=="011"): r = '1';
    elif(d=="100"): r = '0';
    elif(d=="101"): r = '1';
    elif(d=="110"): r = '1';
    elif(d=="111"): r = '0';
    return r;
print convert("001")

#cad = "101011100101000"
cad = raw_input(">> ")
t =len(cad)
index = t-1
print "longitud : ",t
r = ""
for j in range(40):
    aux1 = index # este debe ser longitud -1 , al iniciar
    aux2 = index -index # este debe ser 0 al iniciar
    aux3 = index - (index-1) # este debe ser 1 al iniciar
    cnt = 1
    r=""
    for i in range(t):
        if aux3==t:
           aux3=0
        l = cad[aux1]
        m = cad[aux2]
        n = cad[aux3]
    
        n1 = l+m+n
        if cnt==1:
            aux1 = 0
            aux2 = 1
            aux3 = 2
        else :
            aux1 = aux1 +1
            aux2 = aux2 +1
            aux3 = aux3 +1
        cnt = cnt+1
        r += convert(n1)
    cad = r
    print r

Cabe destacar varias cosas de este algoritmo.

1.- la funcion convert recive como parametro los 3 valores binarios que se leen de la cadena inicia, y como resultado dan un solo caracter sea 0 o 1, dependiendo de los 3 valores.

2.- el for de recorrido de la cadena binaria revisa de (len a len-1) contando los valores de 3 en tres empezando con (len 0 1) , (0 1 2), (1 2 3) hasta (3 len-2 len-1).

3.- hay un for principal que revisa la cadena inicial, y convierte la cadena inicial procesada en la siguiente cadena a procesar.