Foro SofosAgora

Foro abierto a los intereses de sus usuarios. Debate, aprende y diviértete.
Fecha actual 19 Ene 2020, 18:11

Todos los horarios son UTC + 1 hora [ DST ]




Nuevo tema Responder al tema  [ 2 mensajes ] 
Autor Mensaje
NotaPublicado: 07 Nov 2019, 22:08 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 10200
Los candidatos son números, textos, etc, que se varían intentando que cumplan cierta condición. Respecto a cómo cumplirla, generalmente se sabe por lo menos que debe ser un número, o sino un texto, etc, dependiendo del caso.

Cuando es sólo un candidato que es un número entero positivo, siempre:
Código:
C = 1;

// Solcheck
if (9<C) {
   // Sol
   stop ();
}

// Candmod
C = C+1;
gotoAndPlay (2);
Notas:
- C es la abreviación de candidato.
- Las líneas en blanco representan un cambio de frame o de paso.
- Solcheck es chequeo de si ocurre una solución, es decir, si C cumple la condición que se quiere que se cumpla, en cuyo caso el programa debería mostrar el estado de C, pero existe una manera manual de verlo, y en definitiva al código lo entiendo mejor así, al ver "Sol" y "stop" (el programa se detiene).
- Las condiciones que pongo siempre es obvio cómo cumplirlas, la cuestión de estos códigos que pongo no es resolver problemas complejos, sino cómo variar C. De hecho, lo relativo a Solcheck podría ser obviado, pero en el uso que yo le doy es relevante, y además me resulta más rápido copiarlos y pegarlos así.
- Candmod es modificación del C. Se puede modificar de modos más complejos, pero esa no es la cuestión aquí, alcanza conque vaya presentando una por una todas las posibilidades relativas al tipo de dato especificado al inicio.
- En vez de usar goto se puede usar do while. Yo lo hago así porque me resulta más comprensible y además en el programa que uso un do while no modifica imagenes (no se actualizan hasta que termina) y puede causar trancos (si tarda mucho). Además, este código está hecho así y lo he copiado y pegado, no tiene sentido que me ponga a modificarlo, si ya funciona así.

Cuando es un C que es un número entero negativo, siempre.
Código:
No hay mucha diferencia, C iniciaría como -1 y en Candmod se le haría -1 en vez de +1.


Cuando es un C que es un número decimal o entero.
Código:
C = -0.1;

// Solcheck
if (C<-0.9) {
   // Sol
   stop ();
}

// Candmod
C = (C*10-1)/10;
gotoAndPlay (2);
En este caso lo hice negativo, pero podría ser positivo o incluso zigzaguear. Lo importante aquí es que como en las computadoras los números decimales funcionan de manera imprecisa (por ejemplo 0.01+0.01 puede resultar en 0.019999...), lo que hago antes de modificar los C es convertirlos en entero, y luego los vuelvo a convertir en decimal. Dependiendo de la cantidad de números tras el . se multiplica/divide por 10^la cantidad de dichos números.

Cuando es un C que es un texto:
Código:
// A~Z pero no Ñ
Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
CP1 = -1;
CLargo = 1;

W = 1;
Parte = CLargo;
do {
    if (eval("CP"+Parte)<25) {
        set ("CP"+Parte, eval("CP"+Parte)+1);
        W = 0;
    } else {
        set ("CP"+Parte, 0);
        if (1<Parte) {
            Parte = Parte-1;
        } else {
            CLargo = CLargo+1;
            set ("CP"+CLargo, 0);
            W = 0;
        }
    }
} while (W == 1);

// Concatenar.
C = "";
Parte = 0;
do {
    Parte = Parte+1;
    C = C+Chars.charAt(eval("CP"+Parte));
} while (Parte<CLargo);
// Solcheck
if ("ZY"<C) {
    // Sol
    stop ();
} else {
    // Candmod
    gotoAndPlay (2);
}
Con esto en mi opinión se va un poco al caraj*, pero así es esta actividad.
- Ñ no la puse porque en la condición pido que el texto, si estuviera en un diccionario, estuviera después que "ZY" pero, en el programa que uso resulta que la Ñ no es considerada una letra normal, es como que está después de la Z o antes, no me fijé, así que de momento para no complicarme (y no era ni es el tema) no la he puesto.
- En realidad es parecido a si fuesen números: 8, 9, 10, 11... sólo que, en vez de ser números, son letras: Y, Z, AA, AB... en este caso habría un 00, 000, etc, pero bueno, es lógico ya que se trata de distintas variaciones, combinaciones o como se llame.
- Lo que se hace es usar variables CP, o sea Partes de C, que mediante un número cada uno, representan qué letra contendrá C en esa posición, es decir, CP1 se refiere a la posición 0, CP2 (cuando se cree) a la posición 1 (cuando la haya), y así sucesivamente. Podría iniciarse de CP0 y parecería más claro, pero en el fondo es lo mismo, lo que pasa es que el programa que uso considera que la 1era posición de un texto es la 0, el lío viene de ahí, pero yo tengo números que representan partes y luego las uno, o sea que perfectamente puedo hablar de la parte 1, la parte 2, etc.
- Uso do whiles para que sea más rápido. No ocurrieron tranques en las pruebas que hice. Además, los whiles no son "mientras se resuelve el problema", sino que, el 1ero es sólo para variar una parte de C y otras si es necesario (caso 9+1=10, Z+1=AA, o AZ+1=BA, variaron 2 partes), y el 2ndo es para actualizar C. El hecho de que estén en distintos frames reduce la probabilidad de trancazo.

En definitiva, yo no lo entiendo así al 100%, lo hice sí, pero saber hacer no es entender, o al menos uno no siempre está tan consciente. La cuestión es que por esto, en parte, estoy haciendo el tema.

Si conocen una forma más simple, sin arrays (eso viene más adelante), agradezco.

También supongo que es posible hacer las variaciones de un modo más útil, por ejemplo llegado AA sería BA, CA, etc, o sea, asumiendo que lo 1ero es más relevante que lo último. Sin duda hay variaciones más útiles incluso, pero siempre son más difíciles de hacer, y en realidad eso no es la cuestión del tema, sino cómo hacer una variación básica del tipo de C que se requiera.

Y es posible que haya más símbolos disponibles.

Cuando son varios C de tipo número entero positivo, siempre:
Código:
C1 = 1;
C2 = 1;
C3 = 1;
Max = 10;

// Solcheck
if (C3<C2 && C2<C1) {
    // Sol
    stop ();
} else {
    // Preparación para Candsmod: Se señala el last Cand
    Parte = 3;
}

// Candsmod
if (eval("C"+Parte)<Max) {
    // Si el Cand señalado no está al máximo, aumenta
    set ("C"+Parte, eval("C"+Parte)+1);
    // Listo, ir a Solcheck
    gotoAndPlay (2);
}

// El Cand señalado no puede aumentar, se resetea
set ("C"+Parte, 1);
if (1<Parte) {
    // Hay un Cand anterior, se señala
    Parte = Parte-1;
    // Ver si el Cand señalado puede aumentar
    gotoAndPlay (3);
} else {
    // No hay Sol o está más allá del Max
    stop ();
}
En ese ejemplo son 3. Para que sean más hay que crear más C al inicio (se puede simplificar con while, eval, etc) y cambiar Parte por el número en cuestión.
Es... más simple que el texto, creo. Tenemos 3 números, por ejemplo 1, 1 y 1, y vamos aumentando el último hasta que llega a un máximo especificado, momento en que se resetea, vemos si podemos aumentar el número anterior, y así sucesivamente hasta que ya no sea necesario o posible aumentarlo.

Cambiando algunas cosas sería posible hacer modificaciones de otros modos, aunque no es el tema.

En cuanto a que haya máximos distintos para cada C, creo que sería fácil marcándolos desde el inicio y luego haciendo referencias variables mediante eval. Algo como Si eval("C"+Parte) < eval("CMax"+Parte), no lo pensé mucho así que lo aseguro poco.
Sin embargo, a menos que se crea que enlentece mucho el hallar la solución, se puede poner en Solcheck, como que cierto C deba ser < el máximo personalizado.

¿Tiene sentido que haya varios candidatos?
Suelo olvidar la respuesta, si es que llego a una.
Tiene sentido si se quiere elegir unos C que cumplan alguna condición entre sí, o si representan propiedades de un objeto, por ejemplo su posición X e Y, no vale mucho la pena decirla mediante 1 solo número.

Cuando son varios C de tipo número entero negativo, siempre:
Código:
Casi nada de diferencia.


Cuando son varios C de tipo número entero negativo, siempre:
Código:
Idem.


Varios C de tipo texto:
Código:
// A~Z pero no Ñ
Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
C1CharID1 = 0;
C1Largo = 1;
C1 = "A";
C2CharID1 = 0;
C2Largo = 1;
C2 = "A";
C3CharID1 = 0;
C3Largo = 1;
C3 = "A";
Max = "ZZ";
function CandMod () {
    W = 1;
    SenaladordeChar = eval("C"+SenaladordeC+"Largo");
    do {
        if (eval("C"+SenaladordeC+"CharID"+SenaladordeChar)<25) {
            set ("C"+SenaladordeC+"CharID"+SenaladordeChar, eval("C"+SenaladordeC+"CharID"+SenaladordeChar)+1);
            W = 0;
        } else {
            set ("C"+SenaladordeC+"CharID"+SenaladordeChar, 0);
            if (1<SenaladordeChar) {
                SenaladordeChar = SenaladordeChar-1;
            } else {
                set ("C"+SenaladordeC+"Largo", eval("C"+SenaladordeC+"Largo")+1);
                set ("C"+SenaladordeC+"CharID"+eval("C"+SenaladordeC+"Largo"), 0);
                W = 0;
            }
        }
    } while (W == 1);
}

// Solcheck
if (C2<C1) {
    // Sol
    stop ();
} else {
    // Candmod (¿qué Cand variar?)
    W2 = 1;
    SenaladordeC = 3;
    do {
        if (eval("C"+SenaladordeC) != Max) {
            W2 = 0;
            CandMod();
        } else {
            set ("C"+SenaladordeC+"CharID1", 0);
            set ("C"+SenaladordeC+"Largo", 1);
            set ("C"+SenaladordeC, "A");
            if (1<SenaladordeC) {
                SenaladordeC = SenaladordeC-1;
            } else {
                // No hay Sol o está más allá del Max.
                stop ();
            }
        }
    } while (W2 == 1);
}

// Concatenar.
set ("C"+SenaladordeC, "");
SenaladordeChar = 0;
do {
    SenaladordeChar = SenaladordeChar+1;
    set ("C"+SenaladordeC, eval("C"+SenaladordeC)+Chars.charAt(eval("C"+SenaladordeC+"CharID"+SenaladordeChar)));
} while (SenaladordeChar<eval("C"+SenaladordeC+"Largo"));
gotoAndPlay (2);
Made by me, pero no me pregunten.
Por lo que veo usa 2 señaladores, no llamados con ñ porque no sé si funcionaría con ella. Se modifica el último caracter (más bien su representante número) del último C. Si llega al máximo se resetea, si hay un caracter anterior aumenta si es posible (sino se resetea y se repite eso), etc (sorry, esto me cuesta y encima los gritos del perro de mi vecino me lo hacen aún más difícil).

De nuevo es posible variarlos de otro modo, establecer distintos máximos, usar más símbolos...

¿Tiene sentido usar muchos C de tipo texto? ¿por qué no uno?
Si se quiere hacer una rima o cambiar algunas palabras supongo que es mejor que estén separadas así, son más fáciles de señalar.
Por lo demás no sé.

Un C que es un array de números enteros positivos:
Código:
C = new Array(1, 1, 1);
Max = 10;

// Solcheck
if (C[1]<C[0]) {
    // Sol
    stop ();
}

// Candmod
W = 1;
SenaladordeP = 2;
do {
    if (C[SenaladordeP]<Max) {
        C[SenaladordeP] = C[SenaladordeP]+1;
        W = 0;
    } else {
        C[SenaladordeP] = 1;
        if (0 < SenaladordeP) {
            SenaladordeP = SenaladordeP-1;
        } else {
            // No hay Sol o está más allá del Max.
            stop ();
        }
    }
} while (W==1);
gotoAndPlay (2);
No me gustan los arrays, pero en teoría es como si se usaran muchos C. Luego me fijo mejor.
La ventaja que veo de usar arrays es que hay una función que ordena sus contenidos. Por lo demás no, ya que cuando lo intenté no pude mandarlos a un archivo externo y yo tengo pensado usar eso mucho.

Varios C que son arrays de números enteros positivos:
No lo pude hacer funcionar.
Código:
Escena 1
   actions for fotograma 1
      C1 = new Array(1, 1, 1);
      C2 = new Array(1, 1, 1);
      Max = 10;
   actions for fotograma 2
      trace (C1+" "+C2);
      // Solcheck
      if (C1[0]<C2[0]) {
         // Sol
         stop ();
      }
   actions for fotograma 3
      // Candmod
      W = 1;
      SenaladordeC = 2;
      SenaladordeP = 2;
      do {
         if (eval("C"+SenaladordeC+"["+SenaladordeP+"]")<Max) {
            trace ("Sin comillas ni signo: "+eval("C"+SenaladordeC[SenaladordeP]));
            trace ("Sin comillas con signo: "+eval("C"+SenaladordeC+[SenaladordeP]));
            trace ("En pars: "+eval("C"+SenaladordeC+"["+SenaladordeP+"]"));
            trace ("En senaladoer sin signo: "+eval("C"+SenaladordeC["SenaladordeP"]));
            trace ("En senalador con signo: "+eval("C"+SenaladordeC+["SenaladordeP"]));
            trace ("En rarezas con signo: "+eval("C"+SenaladordeC+"[SenaladordeP]"));
            set ("C"+SenaladordeC+"["+SenaladordeP+"]", eval("C"+SenaladordeC+"["+SenaladordeP+"]")+1);
            W = 0;
         } else {
            set ("C"+SenaladordeC+"["+SenaladordeP+"]", 1);
            if (0<SenaladordeP) {
               SenaladordeP = SenaladordeP-1;
            } else {
               SenaladordeP = 2;
               if (1<SenaladordeC) {
                  SenaladordeC = SenaladordeC-1;
               } else {
                  // No hay Sol o está más allá del Max.
                  stop ();
               }
            }
         }
      } while (W == 1);
      gotoAndPlay (2);
Copiado directamente de Flash. En el frame 3 pueden notar muchos trace, que hice para ver posibles formas de referirse al contenido de un array y cómo interpretaría eso el programa.
El problema es que cuando digo
set ("C"+SenaladordeC+"["+SenaladordeP+"]", eval("C"+SenaladordeC+"["+SenaladordeP+"]")+1);
...lo que debería hacer es sumar 1 a la parte número (SenaladordeP) del C número (SenaladordeC), pero en vez de eso lo que hace es crear una variable que tiene el mismo nombre que la referencia a la parte del array.

En fin. Hice este tema por preocupación de cómo serían variaciones de candidatos de distintos tipos, pero creo que ya sé. Sería cuestión de decir C1Tipo, C2Tipo, etc. Y luego, dependiendo del tipo, Candmod sería de un modo u otro.

Igual tengo que seguir avanzando. Obviamente me falta arrays de tipo texto. ¿Algo más? ¿es un array el tipo de candidato más complejo que puede haber? ¿y cuales son los tipos de contenidos posibles de un array? Relevantes, porque el tipo boolean, es como un número.
Se me acaba de ocurrir que referencias a otros arrays. Aunque creo que paso de eso.
Referencias a archivos también, no creo que vaya a usar eso. Sí uso archivos, y referencias a ellos, pero representan situaciones, acciones usadas, y consecuencias, no es que ellos vayan a ser evaluados en un Solcheck como un C.
Las imagenes y los sonidos (que no creo que vaya a usar) pueden ser nombrados como números, así que no veo mucho problema. Por ejemplo ¿la imagen1 tapa a toda la imagen3?
Cosas de Internet no sé si el programa me permite usar, por ahora ni me meto.
De otras PC, menos.
¿Algo más?

Gracias.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 13 Nov 2019, 18:08 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 10200
Hallé una manera:
Código:
Escena 1
   actions for fotograma 1
      C1 = new Array(1, 1, 1);
      C2 = new Array(1, 1, 1);
      Max = 5;
   actions for fotograma 2
      trace (C1+" "+C2);
      // Solcheck
      if (C2[0]<C1[0]) {
         // Sol
         stop ();
      }
   actions for fotograma 3
      // Candmod
      W = 1;
      SenaladordeC = 2;
      SenaladordeP = 2;
      do {
         if (eval("C"+SenaladordeC)[SenaladordeP]<Max) {
            eval("C"+SenaladordeC).splice(SenaladordeP, 1, eval("C"+SenaladordeC)[SenaladordeP]+1);
            W = 0;
         } else {
            eval("C"+SenaladordeC).splice(SenaladordeP, 1, 1);
            if (0<SenaladordeP) {
               SenaladordeP = SenaladordeP-1;
            } else {
               SenaladordeP = 2;
               if (1<SenaladordeC) {
                  SenaladordeC = SenaladordeC-1;
               } else {
                  // No hay Sol o está más allá del Max.
                  stop ();
               }
            }
         }
      } while (W == 1);
      gotoAndPlay (2);


Pienso que debería haber funcionado como dije, aunque con algunos ajustes.
En el if había puesto
if (eval("C"+SenaladordeC+"["+SenaladordeP+"]")<Max) {
y era
if (eval("C"+SenaladordeC)[SenaladordeP]<Max) {

Y en la modificación había puesto
set ("C"+SenaladordeC+"["+SenaladordeP+"]", eval("C"+SenaladordeC+"["+SenaladordeP+"]")+1);
lo cual según mi interpretación debería ser más o menos así
set ("C"+SenaladordeC[SenaladordeP], eval("C"+SenaladordeC)[SenaladordeP]+1);
(digo más o menos porque ya no recuerdo cómo interpreta la 1era parte)
pero eso causa el error que comenté. Leyendo respecto a arrays encontré esto:
Citar:
Array.splice
Sintaxis

myArray.splice(inicio, Cuenta_elim, valor0,valor1...valorN);
Argumentos

inicio El índice del elemento de la matriz donde comienza la inserción y/o el borrado.

Cuenta_elim El número de elementos que se van a borrar. Este número incluye el elemento especificado en el argumento inicio. Si no se especifica valor para Cuenta_elim, el método borra todos los valores desde el elemento inicio hasta el último elemento de la matriz.

valor Cero o más valores que se van a insertar en la matriz en el punto de inserción especificado en el argumento inicio. Este argumento es opcional.

Descripción

Método; agrega y/o elimina elementos de una matriz. Este método modifica la propia matriz sin hacer una copia.

Reproductor

Flash 5 o posterior.
Que con los ajustes del caso sirvió.

O sea, en vez de simplemente hacer una referencia a una parte y sustituirla por otra, lo que me vi forzado a hacer (porque no sé otra forma) es borrar una parte y en su lugar poner otra. A efectos prácticos es lo mismo.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
Mostrar mensajes previos:  Ordenar por  
Nuevo tema Responder al tema  [ 2 mensajes ] 

Todos los horarios son UTC + 1 hora [ DST ]


¿Quién está conectado?

Usuarios navegando por este Foro: Salieri y 6 invitados


No puede abrir nuevos temas en este Foro
No puede responder a temas en este Foro
No puede editar sus mensajes en este Foro
No puede borrar sus mensajes en este Foro

Buscar:
Saltar a:  
POWERED_BY
Traducción al español por Huan Manwë para phpbb-es.com
phpBB SEO