Terminar mejor el programa.

(1/1)

Tachikomaia:
Estoy ampliándolo, ya acaba cuando halla una solución, pero la forma en que acaba es algo confusa, a ver si la pueden mejorar.

Código
Datos = 3;
Dato1 = 1;
BuenResultado1 = 2;
Dato2 = 2;
BuenResultado2 = 3;
Dato3 = 3;
BuenResultado3 = 4;
TiposDePaso = 2;
Pasos = 0;
while (Pasos < 2) {
// Se prueba un método con un paso más, para probar métodos que sólo tienen 1 paso, luego métodos que tienen 2, etc:
Pasos++;
trace("Aumentó la cantidad de pasos, es "+Pasos);
// Crea nuevo paso:
this["PasoaProbar"+Pasos] = 0;
trace("Creado PasoaProbar"+Pasos+", su tipo es "+this["PasoaProbar"+Pasos]);
NroDePasoaVariar = Pasos+1;
trace("Se definió NroDePasoaVariar");
// Se indica que el paso a variar sea otro, para que varíe el último hasta que no se pueda, se reseteé, luego el penúltimo, y así, para lograr todas las variaciones posibles:
while (NroDePasoaVariar > 1) {
NroDePasoaVariar--;
trace("Se redujo NroDePasoaVariar, ahora es "+NroDePasoaVariar);
// Prepara el valor que usará el paso:
this["ValoraProbar"+NroDePasoaVariar] = -2;
trace("Se definió ValoraProbar"+NroDePasoaVariar);
// Se modifica ese valor, para que por ejemplo se pruebe +1, +2, etc:
while (this["ValoraProbar"+NroDePasoaVariar] < 1) {
this["ValoraProbar"+NroDePasoaVariar] = this["ValoraProbar"+NroDePasoaVariar]+1;
trace("Se varió ValoraProbar, ahora es "+this["ValoraProbar"+NroDePasoaVariar]);
// Resumen:
PasoaProbar_ = "PasoaProbar"+NroDePasoaVariar;
// trace("El paso que se variará es "+PasoaProbar_);
this[PasoaProbar_] = 0;
trace("Se definió "+PasoaProbar_);
// trace("Su valor es "+this[PasoaProbar_]);
// Se modifica el paso indicado, para que por ejemplo haga Dato+Valor, Dato*Valor, etc:
while (this[PasoaProbar_] < TiposDePaso) {
this[PasoaProbar_] = this[PasoaProbar_]+1;
trace("Se varió "+PasoaProbar_+", ahora su tipo es "+this[PasoaProbar_]);
// trace(PasoaProbar1+" y "+PasoaProbar2);
// Se verá si el método logra los resultados para cada dato:
BuenResultadoHallado = true;
NroDeDatoaProbar = 0;
trace("Se definió NroDeDatoaProbar");
// Se modifica qué dato o "Input" se chequea:
while (NroDeDatoaProbar < Datos && BuenResultadoHallado == true) {
NroDeDatoaProbar++;
trace("Se varió NroDeDatoaProbar, ahora es "+NroDeDatoaProbar);
trace("Su correspondiente buen resultado es "+eval("BuenResultado"+NroDeDatoaProbar));
NroDePasoaEjecutar = 0;
// Se modifica el paso a ejecutar, para ver si el método (fórmula) sirve para lograr el resultado deseado con ese dato de input:
while (NroDePasoaEjecutar < Pasos) {
NroDePasoaEjecutar++;
trace("Se ejecutó el paso "+NroDePasoaEjecutar);
this["TipoDePaso"+this["PasoaProbar"+NroDePasoaEjecutar]]();
// Resultado = this["Resultado"+NroDePasoaEjecutar];
trace("El resultado es "+this["Resultado"+NroDePasoaEjecutar]);
}
if (this["Resultado"+Pasos] != this["BuenResultado"+NroDeDatoaProbar]) {
BuenResultadoHallado = false;
trace("El resultado no es el deseado");
} else {
trace("El resultado es el deseado");
if (NroDeDatoaProbar == 3) {
trace("Solución hallada");
trace("Paso1: "+this["PasoaProbar"+Pasos]);
trace("Valor1: "+this["ValoraProbar"+Pasos]);
// Para detener los loops:
Pasos = 9;
NroDePasoaVariar = 0;
ValoraProbar0 = 9;
TiposDePaso = 0;
}
}
}
}
}
if (BuenResultadoHallado == false) {
this[PasoaProbar_] = 1;
trace("El paso "+this[PasoaProbar_]+" ya no puede variar, se reseteó ");
}
}
}
function TipoDePaso1 () {
trace("El paso ejecutado fue Dato+Valor");
_root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]+_root["ValoraProbar"+NroDePasoaVariar];
}
function TipoDePaso2 () {
trace("El paso ejecutado fue Dato*Valor");
_root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]*_root["ValoraProbar"+NroDePasoaVariar];
}

pingperdido:
Para evitar forzar los contadores de los bucles externos, lo más limpio es meter toda la búsqueda dentro de una función y hacer un return en cuanto encuentres la solución. Si prefieres no usar funciones, una variable booleana tipo encontrado = true con un break en cada nivel te dejará el flujo mucho más claro.

Danielㅤ:
Hola, yo creo que la mejor forma de detener un bucle o ciclos recursivos, es usar una condición If, que si se cumple entonces continua nuevamente, también se puede usar break o return, pero no son recomendables porque es detener a la fuerza un proceso o salir a la fuerza de un ciclo.

Navegación

[0] Índice de Mensajes