Generar secuencias evitando redundancias, loops en que nada ocurra, etc.
(1/1)
Tachikomaia:
Con 1 if:
Cada código está dentro de un while eterno.
Lo que está en la celda contigua a un if o del mismo color, verde, es lo que se hace en caso de que se cumpla la condiciòn.
Lo que está en celeste se hace siempre.
Las líneas vacías separan códigos, marcan que son independientes, sea hacia abajo o a la derecha.
Todos tienen 1ero Punch y luego Kick, la diferencia entre los de izquierda y derecha es qué cosa está en el if.
Con un do:
Las reglas son muy parecidas.
Me salteé uno arriba a la derecha porque es redundante, como:
Código:
Repetir
Punch
por siempre
Kick
Nunca se usará Kick, no tiene sentido ponerlo, ni al repetir, porque como dije ya hay uno "invisible" (que por cuestiones prácticas no vale la pena poner, se entiende que está).
Al final pongo una copia de códigos anteriores, o sea con 1 if. Quiero saber de qué formas le puedo meter do whiles sin caer en redundancias ni que nada se pueda hacer. Siempre tiene que haber algo que se pueda realizar siempre. Por ejemplo si pongo:
Código:
Punch
Do
Si HP is full
Kick
por siempre
se usará Punch, y luego sólo se usará Kick si Hp is full, sino nada, eso no puede ser.
No sé uds pero yo como que me mareo pensando cómo meter los do en los códigos mostrados, no estoy queriendo lograr una secuencia específica sino crear una lista de las posibles que cumplan las condiciones...
Tachikomaia:
Creo que tenía un tema más reciente que esto pero no lo hallé. Lo que pongo a continuación está relacionado, lo pongo por si sirve a alguien:
Tachikomaia:
Quiero que las genere un programa, pongo lo que se me ocurre, agreguen lo faltante o denme ideas.
Código
Con ayuda de una IA logré esto:
// Para códigos de 1 cosa (acción, if, do while o while):
//
// Las líneas se guardarán en elementos de arrays,
// así que en este contexto línea y elemento son...
// conceptos bastante equivalentes:
NewCodes = 0;
// Generar código agregando acción:
set("Code"+NewCodes, new Array("1"));
// Generar código agregando if:
NewCodes++;
set("Code"+NewCodes, new Array("if", "}"));
// Generar código agregando do while:
NewCodes++;
set("Code"+NewCodes, new Array("do {", "} while"));
// Generar código agregando while:
NewCodes++;
set("Code"+NewCodes, new Array("while {", "}"));
//
// Mostrar los códigos:
CodeaMostrar = 0;
do {
Resumen = "Code"+CodeaMostrar;
trace(Resumen+":");
trace(eval(Resumen));
CodeaMostrar++;
} while (CodeaMostrar <= NewCodes);
Salida:
Code0:
1
Code1:
if,}
Code2:
do {,} while
Code3:
while {,}
Me interesa:
- Que a partir de esos se generen otros sin que haya repeticiones, y cuando haya if puede haber else. Como mostré en la imagen del post anterior.
- Que al mostrarse los códigos, en vez de mostrarse los elementos del array todos seguidos en uina misma línea, se mueste 1 por línea.
Tachikomaia:
No hay mucha respuesta :(
Frame 1:
Código
// Para códigos de 1 cosa (acción, if, do while o while):
//
// Las líneas se guardarán en elementos de arrays,
// así que en este contexto nro de línea y de elemento...
// son lo mismo:
CodesLV1 = 0;
// Generar código agregando acción:
set ("LV1Code"+CodesLV1, new Array("1"));
// Generar código agregando if:
CodesLV1++;
set ("LV1Code"+CodesLV1, new Array("if", "}"));
// Generar código agregando do while:
CodesLV1++;
set ("LV1Code"+CodesLV1, new Array("do {", "} while"));
// Generar código agregando while:
CodesLV1++;
set ("LV1Code"+CodesLV1, new Array("while {", "}"));
//
// Mostrar los códigos:
CodeaMostrar = 0;
do {
NombredeNewCode = "LV1Code"+CodeaMostrar;
trace (NombredeNewCode);
TextoLineaPorLinea = eval(NombredeNewCode).join("\n");
trace (TextoLineaPorLinea+"\n");
CodeaMostrar++;
} while (CodeaMostrar<=CodesLV1);
Salida:
Citar
LV1Code0
1
LV1Code1
if
}
LV1Code2
do {
} while
LV1Code3
while {
}
Está bien.
Frame 2:
Código
// Para códigos de 2 cosas:
CodesLV2 = -1;
CodeBase = -1;
do {
CodeBase++;
LineaDondeAgregar = -1;
do {
CodesLV2++;
NombredeNewCode = "LV2Code"+CodesLV2;
LineaDondeAgregar++;
// Para generar código agregando acción, 1ero se copia a otro:
set (NombredeNewCode, eval("LV1Code"+CodeBase).slice());
// Insertar en la posición LineaDondeAgregar
// Parámetros: (índice, elementos_a_eliminar, nuevo_elemento)
eval(NombredeNewCode).splice(LineaDondeAgregar, 0, "2");
trace (NombredeNewCode);
TextoLineaPorLinea = eval(NombredeNewCode).join("\n");
trace (TextoLineaPorLinea+"\n");
} while (LineaDondeAgregar<eval("LV1Code"+CodeBase).length);
} while (CodeBase < CodesLV1);
stop ();
Salida:
Citar
LV2Code0
2
1
LV2Code1
1
2
LV2Code2
2
if
}
LV2Code3
if
2
}
LV2Code4
if
}
2
LV2Code5
2
do {
} while
LV2Code6
do {
2
} while
LV2Code7
do {
} while
2
LV2Code8
2
while {
}
LV2Code9
while {
2
}
LV2Code10
while {
}
2
Cosas que deben corregirse o agregarse:
- No debe haber "2" si antes no hay "1".
- Lo que esté dentro de un if o loop, debe tener 3 espacios.
- Sólo se está agregando "2", se debe también agregar if, etc, y else en caso de haber if.
¿Bien? ¿alguien lo hace? ¿alguna duda? ¿alguna optimización que se les ocurra, o mejores nombres?
Navegación