Cometí un error en el casi código que puse:
Act = ActIni;
es
Act = M.ActIni;
En mi programa está bien, lo que pasa que eso se hace más adelante y acá lo escribí apurado intentando que no haya quejas de que usé Act sin haberlo definido.
Otra cosa que quizá ya he aclarado pero no recuerdo, por las dudas:
Los problemas que planteen deben tener alguna solución. Sino evidentemente no podría resolverlos, no pido problemas de esos.
--------------------------------------------------------------------------------------------------------
Malenko, tu post para mí es problema que no sé resolver (cómo responderlo bien), pero no está dentro de los límites que dije xD
El hilo al que te refieres era para aprender a programar mejor o adecuarme a lo que uds decían que es mejor, y entender qué era. Ya no recuerdo bien los motivos pero era sobre aprender a resolver problemas yo, programando sí pero no una "pseudoIA" ni con ayuda de una.
Este otro hilo también es para aprender a programar, sí, pero muy relacionado con una "pseudoIA" y los problemas hemos de resolverlos ella y yo, no sólo yo. También este tema es para ver sus límites y cosas que necesita.
Hice los ejercicios que me dijiste, o más o menos, y como no se comentó más al respecto lo dejé. Igual ahora estoy con las cuestiones de este tema.
No es imposible, yo sé lo que hago, tú sígueme la corriente, si pido cómo hacer un "A"+1 ("A1") en python me dices, si pido un problema dentro de ciertos límites, y que no pueda resolver con mi pseudoIA, me dices un problema así si se te ocurre, sino ten paciencia porque iré quitando los límites.
Cita: - Usa ya de una vez variables claras, que las letras son gratis y ayudan a entender el código. Deja de usar ya "cosas" como "V1", "V2",...
¿Lo dices por el casi código que puse? Tienes razón, lo que pasa que pienso "muy en general", creo, entonces planteo los problemas como si fuesen un tipo de problema y no un ejemplo particular, me confundo. Va una corrección:
Código a:
Ver original// 2 variables tipo número:
numDeManzanasEnMiCanasto = 0;
numDeManzanasQueQuieroTenerEnMiCanasto = 5;
// Variables relacionadas con las posibles acciones:
M.actoInicial = 1;
// (*)
Acto = M.actotInicial;
// Modo en que se aplican las acciones:
numDeManzanasEnMiCanasto = numDeManzanasEnMiCanasto+Acto;
// ...es decir al valor de numDeManzanasEnMiCanasto se le suma el valor del Acto.
// Condición en que se soluciona el problema:
numDeManzanasEnMiCanasto == numDeManzanasQueQuieroTenerEnMiCanasto
// Relacionado con el límite del valor de la acción:
Si M.Acto<5
// Modo en que varía la acción:
M.Acto = M.Acto+1;
fin del si
(*): M es un objeto, como una carpeta, donde pongo variables que no quiero que se guarden en archivos. Porque cuando uso el comando para guardar variables en archivos, se guardan todas las que estén en la zona raíz, así que a las que no quiero guardar las meto en un objeto. "M" es un abreviador de memoria, pero es un nombre que le puse hace años y su función no es precisamente memorizar. Lo más "lógico" supongo que sería llamarle "ObjetoParaEvitarQueCiertasVariablesSeGuarden" pero es muy largo, quedaría así:
Código a:
Ver original// 2 variables tipo número:
numDeManzanasEnMiCanasto = 0;
numDeManzanasQueQuieroTenerEnMiCanasto = 5;
// Variables relacionadas con las posibles acciones:
ObjetoParaEvitarQueCiertasVariablesSeGuarden.actoInicial = 1;
Acto = ObjetoParaEvitarQueCiertasVariablesSeGuarden.actotInicial;
// Modo en que se aplican las acciones:
numDeManzanasEnMiCanasto = numDeManzanasEnMiCanasto+Acto;
// ...es decir al valor de numDeManzanasEnMiCanasto se le suma el valor del Acto.
// Condición en que se soluciona el problema:
numDeManzanasEnMiCanasto == numDeManzanasQueQuieroTenerEnMiCanasto
// Relacionado con el límite del valor de la acción:
Si ObjetoParaEvitarQueCiertasVariablesSeGuarden.Acto<5
// Modo en que varía la acción:
ObjetoParaEvitarQueCiertasVariablesSeGuarden.Acto = ObjetoParaEvitarQueCiertasVariablesSeGuarden.Acto+1;
fin del si
Comprendo perfectamente si te parece una trolleada pero no sé qué quieres exactamente en el sentido de qué nombre ponerle a las variables. Y si así como está no te parece una trolleada, o sea si así te parece bien, me alegro porque no es mi intención trollear, pero en general no voy a nombrar así las variables.
Te recomiendo este video:
https://www.youtube.com/watch?v=JoQhKR9Q0Jg
desde 0:30
Y te diré otros motivos de por qué uso V1, V2, etc, para todos estos problemas (
aunque me los pueden plantear con los nombres que uds quieran).
1: Debo crear archivos cuyos nombres contengan las variables. Así lo hago:
Código a:
Ver originalM.A = 1;
M.SaveID = V1;
do {
M.A = M.A+1;
M.SaveID = M.SaveID+"_"+eval("V"+M.A);
} while (M.A<M.SitElms);
// Save it
M.SaveID = M.SaveID+".txt";
fscommand ("save", M.SaveID);
Puede haber cosas ahí que no entiendas, pero el punto es que si les cambio los nombres a las variables al principio, tengo que cambiarlas luego en este fragmento también. Además, si no tienen una "forma" similar (por ejemplo texto+número: V1) no puedo usar un "loop" como este para crear el nombre del archivo.
Si son pocas variables no hay problema, pero si son muchas sí!
Hay una posible solución: Crear variables con nombres reales y otras variables como las que hago, que tengan los valores de las variables reales:
numDeManzanasEnMiCanasto = 0;
V1 = 0;
numDeManzanasQueQuieroTenerEnMiCanasto = 5;
V2 = 5;
o al revés:
V1 = 0;
numDeManzanasEnMiCanasto = V1;
V2 = 5;
numDeManzanasQueQuieroTenerEnMiCanasto = V2;
pero en definitiva es el doble de trabajo! ¿y lo entiendo más así? No!
Quizá pienses "pero por qué precisas crear archivos" o "por qué el nombre debe tener las variables", lo cual me parece bien pensado, pero eso no lo voy a responder, lo siento.
Ese código se repite en varios frames, encima eso, sé que convendría convertirlo en función pero de momento estoy preocupado por otros asuntos.
2: Debo ver que los archivos se guardaron o cargaron bien. Para números debo usar esto:
Código a:
Ver originalfunction FuncMVImp () {
Cargas = 0;
A = 0;
do {
A = A+1;
set ("V"+A, CompNum2);
} while (A<SitElms);
Act = CompNum2;
}
y además esto:
Código a:
Ver originalfunction FuncMVComp () {
Comp = Comp+1;
Verif = 1;
A = 0;
do {
A = A+1;
VA = Number(eval("V"+A));
set ("V"+A, VA);
if (CompNum>VA) {
Verif = 0;
A = SitElms;
}
} while (A<SitElms);
Act = Number(Act);
if (CompNum>Act) {
Verif = 0;
}
}
Son funciones dentro de M, que se usan fuera. Están en M porque si las defino fuera se graban cosas extra en los archivos, además la mayoría de las variables que usan están en M. Más allá de eso, son más o menos lo mismo que lo anterior: Un loop con contador, que en este caso define (la 1era) o compara (la 2nda) V1, luego V2, etc. Si les pusiera nombres "libremente" estos métodos no funcionarían y tendría que cambiar nombres. Además funciones como esta hay otras, por ejemplo:
Código a:
Ver originalfunction FuncNVImp () {
Cargas = 0;
A = 0;
do {
A = A+1;
set ("_root.N.V"+A, CompNum2);
} while (A<SitElms);
_root.N.Act = CompNum2;
}
Código a:
Ver originalfunction FuncNVComp () {
Comp = Comp+1;
Verif = 1;
A = 0;
do {
A = A+1;
VA = Number(eval("_root.N.V"+A));
set ("_root.N.V"+A, VA);
if (CompNum>VA) {
Verif = 0;
A = SitElms;
}
} while (A<SitElms);
_root.N.Act = Number(_root.N.Act);
if (CompNum>_root.N.Act) {
Verif = 0;
}
}
Como ves la diferencia es mínima, tan poca que podrían convertirse en 2 funciones (te mostré 2 de cada tipo, pero son como 4 de una y 3 de otra) si se hacen los ajustes necesarios, pero de momento estoy concentrado en otros temas. La diferencia entre estas funciones con respecto a las anteriores es que esta trabaja con "Vs" definidas en N en vez de M; es otro objeto que tiene un uso diferente que no voy a explicar.
Si en base a eso tienes una solución mejor, te la agradezco.
------------------------------------------------------------------------------------------
Por cierto es muy poco importante esto pero por si alguno se enoja porque no está definido M.Act y se usa, se debe a que hace tiempo tenía pensado que fuese posible que la siguiente acción a realizar fuese modificada por la acción actual, entonces precisaba una variable que indicara la acción que se hizo (Act) y la que se va a realizar (M.Act). Puede que no sea eso, pero es más o menos lo que recuerdo. Actualmente quizá se pueda simplificar.