hdfull fix aadecode

[robalo]

El problema de java está en pasar una expresión contenida en una cadena a una expresión; "-~0", "-~-~1", "-~3" (1, 3, 4).
Si introduces las expresiones como tal en una variable Integer las resuelve perfectamente:

int n = -~0; // = 1
int n = -~-~1; // = 3
etc.

Integer.parseInt() no nos vale, necesitamos algo que le pase la expresión sin más a Integer que él sí las entiende.

[tormund]

¿Integer.valueOf()? Con este método haces un cast a int.

[robalo]

A ti te funciona?, a mi no.

Estas cosas me matan, int n = 3^3^3 es válido y por lo que he podido ver no hay nada en Integer que acepte este formato y lo que es es peor "3*3" por ejemplo.

Para poder evaluar la expresión anterior sin usar ScriptEngine solo se me ocurre descomponerla pero podríamos acabar cortándonos la venas

int n = Integer.parseInt("3") ^ Integer.parseInt("3") ^ Integer.parseInt("3");

lo que se podría traducir a algo parecido a

Código: Seleccionar todo

	String p(String s){
		String[] l = {};
		if(s.startsWith("-~")) l = s.split("-~");
		else l = s.split("\\^");

		Integer ret = 0;
		if(s.startsWith("-~")){
			if(l.length>2) ret = -~-~ Integer.parseInt(l[2]);
			else ret = -~ Integer.parseInt(l[1]);
		}
		else if(l.length==1) ret = Integer.parseInt(s);
		else{
			for(int i=0;i<l.length;i++){
				ret = ret ^ Integer.parseInt(l[i]);
			}
		}
		return ret.toString();
	}

que con las expresiones que nos solemos encontrar

Código: Seleccionar todo

		System.out.println("\"0^3^3\" = " + p("0^3^3")); // 0
		System.out.println("  \"-~0\" = " + p("-~0"));   // 1
		System.out.println("    \"1\" = " + p("1"));     // 1
		System.out.println("\"-~-~0\" = " + p("-~-~0")); // 2
		System.out.println("  \"-~1\" = " + p("-~1"));   // 2
		System.out.println("\"-~-~1\" = " + p("-~-~1")); // 3
		System.out.println("\"3^3^3\" = " + p("3^3^3")); // 3
		System.out.println("  \"-~3\" = " + p("-~3"));   // 4
		System.out.println("    \"4\" = " + p("4"));     // 4

nos delvolvería

Código: Seleccionar todo

"0^3^3" = 0
  "-~0" = 1
    "1" = 1
"-~-~0" = 2
  "-~1" = 2
"-~-~1" = 3
"3^3^3" = 3
  "-~3" = 4
    "4" = 4

PD: Lo que no recuerdo por que no te funciona ScriptEngine, me suena algo del foro Desarroladores

[tormund]

Porque programo para Android y esta librería no está disponible. Utilizo Rhino pero es obvio que no es tan potente como la de Java.

No te preocupes, lo que hecho es pasar vuestro algoritmo a Java y funciona perfectamente. El problema inicial que tenía es que hacía un "eval" por cada caracter porque va componiendo las distintas partes del texto decodificado hasta que la expresión compuesta devuelve un valor al realizar el "eval". Esto me ralentizaba muchísimo (deduzco que la librería que te he comentado no es muy eficiente) pero lo solucioné llevando la cuenta de los parentesis de apertura y de cierre que me iba encontrando al concatenar, de manera que sólo hago un eval cuando el número de paréntesis de apertura y cierre es el mismo (lo que significa que se ha concatenado una expresión válida y puedo realizar el "eval").

Sería una pasada pasar el script tal cual y que se puediera evaluar correctamente pero al menos tengo esta alternativa que funciona.

Saludos.

[robalo]

Pues como te ofreciste, cuando tengas un rato lo dejas por donde puedas para meterme nuevas formas de hacer la cosas y desintoxicarme un poco de mi mismo

Me has hecho dudar si a las pruebas que hice con la tablet le metí ScriptEngine, ayer estaba seguro al 100% de que sí. Tendré que retomarlo cuando pueda arrancarle la table a suprema

[tormund]

Claro, aquí te lo dejo:

Código: Seleccionar todo

public static String aaDecode(String aaEncode) {
        String data;
        String[] chars;
        String txt="";
        StringBuilder c = new StringBuilder();
        StringBuilder subchar = new StringBuilder();
        String txtResult = "";
        StringBuilder txtConcat = new StringBuilder();

        aaEncode = aaEncode.replaceAll("\\s+|/\\*.*?\\*/", "");
        data = aaEncode.split("\\+\\(ﾟДﾟ\\)\\[ﾟoﾟ\\]")[1];
        chars = data.split("\\+\\(ﾟДﾟ\\)\\[ﾟεﾟ\\]\\+");

        chars = (String[]) ArrayUtils.remove(chars, 0);

        for(String ch : chars) {
            ch = ch.replace("(oﾟｰﾟo)", "u")
                    .replace("c", "0")
                    .replace("(ﾟДﾟ)['0']", "c")
                    .replace("ﾟΘﾟ", "1")
                    .replace("!+[]", "1")
                    .replace("-~", "1+")
                    .replace("o", "3")
                    .replace("_", "3")
                    .replace("ﾟｰﾟ", "4")
                    .replace("(+", "(");

            ch = ch.replaceAll("\\((\\d)\\)", "$1");

            c.delete(0, c.length());
            subchar.delete(0, subchar.length());
            int abreParentesis = 0;
            int cierraParentesis = 0;
            for(int i = 0;i < ch.length();i++) {
                c.append(ch.substring(i, i + 1));
                if(ch.substring(i, i + 1).equals("(")) {
                    abreParentesis++;
                }
                if(ch.substring(i, i + 1).equals(")")) {
                    cierraParentesis++;
                }
                String x;
                if(abreParentesis == cierraParentesis && abreParentesis > 0 && cierraParentesis > 0) {
                    try {
                        x = c.toString();
                        subchar.append(String.valueOf(((Double) runJS(x)).intValue()));
                        c.delete(0, c.length());
                        abreParentesis=0;
                        cierraParentesis=0;
                    } catch (Exception e) {
                        //Ignoro la excepción
                    }
                }
            }

            if(!subchar.toString().isEmpty()) {
                txtConcat.append(subchar + "|");
            }
        }

        txt = txtConcat.toString();
        txt = txt.substring(0, txt.length()-1).replace("+", "");

        String[] arrTxt = txt.split("\\|");
        for(int i = 0;i < arrTxt.length;i++) {
            txtResult += (char) Integer.parseInt(arrTxt[i], 8);
        }
        return toStringCases(txtResult);
    }

[robalo]

Muchas gracias!!

Le estado dando muchas vueltas y no he visto como hacer algo sin instalar nuevas librerías y que quede bonito
No he podido mirar lo que le metí a la tablet así que de momento me quedo igual, lo mismo le puse el de python con PyDev, a saber.

He estado estos días con poco tiempo para mí, así que te paso el resultado por si ayuda a la búsqueda de una librería propia y eficiente. No me gusta mucho como está, sobre todo la función e(). Pide a gritos que la en unas 15 líneas

Código: Seleccionar todo

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class aaDecode {
	
	String decode;

	aaDecode(String encode) {

		Matcher matches;

		encode = encode.replaceAll("\\s+|/\\*.*?\\*/", "");
		String[] listEnc = encode.split("\\+.ﾟДﾟ..ﾟoﾟ.");
		String strEnc = listEnc[1];

		strEnc = strEnc
				.replace("(oﾟ-ﾟo)", "u")
				.replace("c", "0")
				.replace("ﾟΘﾟ", "1")
				.replace("!+[]", "1")
				.replace("o", "3")
				.replace("_", "3")
				.replace("ﾟｰﾟ", "4");

		listEnc = strEnc.split("\\+.ﾟДﾟ..ﾟεﾟ.\\+");
		
		for(int i=0;i<listEnc.length;i++){
			String r = "";
			matches = Pattern.compile("([\\d\\^\\-~]+)").matcher(listEnc[i]);
			while (matches.find()){
				String m = matches.group(1);
				if(m.length()==1 & !m.contains("-"))
					r = m;
				else if(m.length()!=1 & !m.equals("-"))
					r = e(m);

				listEnc[i] = listEnc[i].replace("("+m+")","("+r+")");
			}

			matches = Pattern.compile("\\((\\(.*?\\))\\)").matcher(listEnc[i]);
			while (matches.find())
				listEnc[i] = listEnc[i]
					.replace(matches.group(1), matches.group(1).replace("(", "").replace(")", ""));
			
			listEnc[i] = listEnc[i].replaceAll("\\)[\\+\\-]\\(", "|");

			String strExp = listEnc[i].replace("(", "").replace(")", "");

			String[] listExp = {};
			if(!strExp.isEmpty()){
				if(strExp.contains("|"))
					listExp = strExp.split("\\|");
				else
					listExp = strExp.split("\\+");

				String chars = "";
				for(int index=0;index<listExp.length;index++)
					chars+= e(listExp[index]);

				char charsRet = (char) Integer.parseInt(chars, 8);

				decode+= charsRet; // return
			}
		}
	}

	String e(String s){

		String[] l = {};

		Integer ret = 0;
		if(s.startsWith("-~-~")){
			l = s.split("\\-~\\-~");
			for(int i=0;i<l.length;i++){
				if(!l[i].isEmpty())
					ret = -~-~ Integer.parseInt(l[i]);
			}
		}
		else if(s.startsWith("-~")){
			l = s.split("\\-~");
			for(int i=0;i<l.length;i++){
				if(!l[i].isEmpty())
					ret = -~ Integer.parseInt(l[i]);
			}
		}
		else if(s.contains("^")){
			l = s.split("\\^");
			for(int i=0;i<l.length;i++){
				if(!l[i].isEmpty())
					ret = ret ^ Integer.parseInt(l[i]);
			}
		}
		else if(s.contains("+")){
			l = s.split("\\+");
			for(int i=0;i<l.length;i++){
				if(!l[i].isEmpty())
					ret = ret + Integer.parseInt(l[i]);
			}
		}
		else if(s.contains("-")){
			l = s.split("\\-");
			for(int i=0;i<l.length;i++){
				if(!l[i].isEmpty())
					ret = ret - Integer.parseInt(l[i]);
			}
		}
		else return s;

		return ret.toString();
	}
}

[tormund]

Perdona que no te haya contestado antes pero he estado el finde de viaje.

Lo acabo de probar y el resultado es espectacular, yo estaba contento porque había conseguido reducir la decodificación de 13seg a 2seg pero es que con tu algoritmo he conseguido 0,498 seg.

Muchas gracias

[robalo]

De ná, gracias a tí por favor

Creo que se puede y que se debería mejorar un poco más, pero con un pelin de reposo y tranquilidad

A ver si lo podemos dejar más mono para incluirlo en la caja de herramientas después de un tiempo razonable de testeo