elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


  Mostrar Mensajes
Páginas: 1 ... 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 [188] 189 190 191 192
1871  Foros Generales / Dudas Generales / Re: ¿que tipo de interacción se da al utilizar un método de búsqueda? en: 20 Noviembre 2018, 04:44 am
¿Búsqueda con perros? Jajaja. Pensé que se refería a algo como Google, qué datos obtenía él además de la palabra que se le escribe. Igual ni se molestó en aclarar a pesar de que le explicaste.
1872  Programación / Programación General / Re: ¿Cómo programar mejor? en: 20 Noviembre 2018, 01:19 am
NEBIRE, entré al link y tuve más o menos el mismo problema que tú aquí, no entiendo bien de qué están hablando y el link para descargar tiene varios archivos, en formatos extraños para mí. ¿Podemos simplificar?


Para Nebire o cualquier otro:

¿Entiendes esto?
Código:
Escena 1
   actions for fotograma 1
      Char0 = -1;
      Chars = 1;
      function Concatenarytrace () {
         Print = "";
         Cursor = 0;
         do {
            Print = Print+eval("Char"+Cursor);
            Cursor = Cursor+1;
         } while (Cursor<Chars);
         trace (Print);
      }
   actions for fotograma 2
      Cursor = Chars-1;
   actions for fotograma 3
      if (eval("Char"+Cursor)<9) {
         // Si el char es aumentable, aumenta.
         set ("Char"+Cursor, eval("Char"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (2);
      }
   actions for fotograma 4
      // El char no es aumentable, ergo Se resetea.
      set ("Char"+Cursor, 0);
      if (0<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino (el cursor no puede bajar), se agrega un char.
         set ("Char"+Chars, 0);
         Chars = Chars+1;
         Concatenarytrace();
         gotoAndPlay (2);
      }
   actions for fotograma 5
      if (eval("Char"+Cursor)<9) {
         // Si el char es aumentable, aumenta.
         set ("Char"+Cursor, eval("Char"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (2);
      } else {
         // Sino, se resetea y reinicia un proceso.
         gotoAndPlay (4);
      }
Yo con esfuerzo lo entendería, lo cual indica un problema ¿no? ¿por qué algo que hice me resulta difícil entenderlo?

El output:
0
1
2
3
4
5
6
7
8
9
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
000
001
002
003
y sigue.

Como ves, es un código que muestra todas las posibles mezclas de los números del 0 al 1.

Te comentaré todo el código.

Código:
Escena 1
   actions for fotograma 1
      Char0 = -1;
      Chars = 1;
Char0 marca el valor del caracter que esté 1ero. En el output ves por ejemplo 12, lo cual está formado por Char0 valiendo 1 y Char1 valiendo 2. 12. Por ahora Char1 no existe. Char0 inicia como -1 pero por la forma conque está programado se aumentará antes de mostrarse, por lo que en el output el 1er valor que se muestre será 0.
Chars es la cantidad de caracteres.

Código:
      function Concatenarytrace () {
         Print = "";
         Cursor = 0;
         do {
            Print = Print+eval("Char"+Cursor);
            Cursor = Cursor+1;
         } while (Cursor<Chars);
         trace (Print);
      }
Esta función inicia Print como algo vacío y Cursor como 0.
Print al final de la función será un número que se mostrará en pantalla, más especificamente es la concatenación de Char0, Char1 y todo el que haya sido creado, marcado por Chars. Si Chars es 3 entonces concatenará desde Char0 al Char2.
Para comprender Cursor ayuda imaginar la mezcla y que el cursor es una rayita debajo de una parte. También lo puedes considerar un contador, que determina qué Char se está concatenando.
¿eval entiences cómo funciona ahí? Si por ejemplo Cursor es 1 entonces hace Print+Char1.
trace muestra Print en pantalla.

Código:
actions for fotograma 2
      Cursor = Chars-1;
Cursor se pone en la última posición de la mezcla.

Código:
   actions for fotograma 3
      if (eval("Char"+Cursor)<9) {
         // Si el char es aumentable, aumenta.
         set ("Char"+Cursor, eval("Char"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (2);
      }
Esto tiene un comentario, así que... Igual bueno, se suma 1 al último caracter, si su valor es menor que 9. Luego se concatena en Print y se muestra en pantalla. Tienes que entender que los caracteres no están en una misma variable, salvo cuando se unen en Print, pero piensa que si fuesen palabras en una misma variable sería complicado modificarlas del modo que lo estoy haciendo. Supongo que usarías un array, pero como no pude guardarlos y cargarlos en un archivo, hace mucho, decidí no usarlos. Y nunca me gustaron. Acá no preciso archivos externos, pero por costumbre lo hago así. O sea, supongo que tú lo harías algo así:
Numero = [1, 2]
Y tendrías una función en el lenguaje que sea "concatenar las partes del array", pero yo lo hago así:
Char0 = 1
Char1 = 2
Y para concatenar uso la función esa que te mostré al inicio.

Sí, es más complicado capaz, pero no uso arrays.

Código:
  actions for fotograma 4
      // El char no es aumentable, ergo Se resetea.
      set ("Char"+Cursor, 0);
      if (0<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino (el cursor no puede bajar), se agrega un char.
         set ("Char"+Chars, 0);
         Chars = Chars+1;
         Concatenarytrace();
         gotoAndPlay (2);
      }
Si le aumentamos 1 a 9, queda en 0, eso es resetearse. Luego de eso, vemos si hay más números hacia atrás, hacia la izquierda. Si los hay, movemos el cursor hacia él. Tienes que imaginarte que las variables estuvieran una al lado de la otra, como si formaran un número.
Si no hay más números, es hora de crear uno, como cuando al sumar 1 a 9 obtenemos 10, o sea 2 caracteres, uno más que antes. Pero en este caso obtendremos 00.

Código:
   actions for fotograma 5
      if (eval("Char"+Cursor)<9) {
         // Si el char es aumentable, aumenta.
         set ("Char"+Cursor, eval("Char"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (2);
      } else {
         // Sino, se resetea y reinicia un proceso.
         gotoAndPlay (4);
      }
Esto es muy similar a lo del frame 3. El tema es que generalmente los números finales son aumentables, por lo que pensé que todo quedaría más simple si pusiera el caso más simple al inicio, limpio, aunque en cuanto a eficiencia no sé si es mejor así (no carga tantas veces un else innecesario, pero el code queda más largo).
Lo de "reinicia un proceso" es muy vago, fue lo que me salió en el momento... Se refiere a que vuelve a la parte donde se resetea el char y se fija si es posible bajar el cursor.

¿Ok? Como ves, eso es una versión simplificada del problema inicial que plantee. Esto lo había hecho antes y lo otro está bastado bastante en esto.

Bueno. si entendiste mi código, quisiera que me digas cómo harías para mejorarlo, hacerlo más legible, editalo, no sé.

Si entendés eso te planteo otra cosa y así sucesivamente hasta llegar al problema original.

Saludos!
1873  Programación / Programación General / Re: ¿Alguien sabe algún curso para aprender a programar? en: 20 Noviembre 2018, 00:59 am
Una pregunta por curiosidad. ¿A qué llamas haber aprendido a programar?

Supongo que no a "saber dar cualquier instrucción a la computadora de modo que la ejecute", porque eso nadie lo logró creo, pero si preguntas es porque crees que hay gente que sí sabe programar. ¿Entonces? ¿"saber dar instrucciones que todo buen programador sabe dar"? Algo intuyo pero es una definición circular, sigo sin entender del todo. ¿Qué cosas quieres aprender a programar? Me parece que la programación es muy amplia, si quieres leer de todo adelante, pero es posible que te aburras o canses antes. No era mi intención pero esto lleva a "céntrate más", sí, disculpa.

En otro foro se acostumbra decir "Soy X" o "me pasó X" y "y respondo vuestras preguntas". Una vez allí dije, medio en broma, "Sé lo básico de programación y respondo vuestras preguntas". Hubo mucha gente que se enojó porque según ellos no sé lo básico y me estaba burlando de la gente que había estudiado años.


Yo no soy programador, no tengo un buen título/curso hecho (sólo Clipper, y fue un curso así nomás), no podría trabajar de ello, pero intento programar ciertas cosas. Muchas de ellas me han parecido demasiado difíciles, te diría que en general nada he logrado. También depende del lenguaje que uses. Puedes hacer un juego 3d con ciertos programas, sólo agregando cubitos y otras cositas. Creo que eso no es programar, pero como resultado vale más a la vista. La programación consiste en parte en entender cómo explicar cosas que a los humanos nos parecen obvias. Y suele ser complicado, paradojicamente.

Si ya tienes un lenguaje, y en donde programar... programa. Di qué quieres y se te dirá cómo, si sabemos.

Suerte!
1874  Programación / Programación General / Re: ¿Cómo programar mejor? en: 17 Noviembre 2018, 03:58 am
Cita de: NEBIRE en 16 Noviembre 2018, 14:39 pm
mmm.  No... explícate con palabras, no esperes que nadie perda su tiempo mirando un chorro de líneas para intentar deducir-dilucidar que orden es ése.
Bueno, más correcto hubiera sido decir que la lista que quiero generar está compuesta de 2 sublistas que se influyen entre sí, pero me pareció mejor explicar 1ero una de ellas, lo cual es una simplificación de la lista en sí.

Y la mejor forma de explicarla que se me ocurre es con el ejemplo, o sea, lo demás es complicado (y conste que aún estoy hablando de la simplificada).
1
2
3, 4
3
3, 5
6, 1, 2
etc
¿En otras palabras?
El máximo largo inicia siendo 1.
La 1era combinación está compuesta de 1 número, es decir tiene largo 1.
Se alcanzó el máximo largo, ergo aumenta 1 y el largo inicial vuelve a ser 1.
La 2nda combinación estará compuesta de largo 1, y el número será el mismo que hubo con ese largo, pero se le sumará 1.
La 3era tendrá un largo+1 y comenzará con el número más alto+1. Los números se resetean a partir de 7 y en tal caso se considera que son más altos. Es como un circulo.
...
En definitiva en cada línea aumenta el largo, pero si llega al máximo se resetea pero el máximo aumenta. Cuando se alcanza un largo que no se había alcanzado, se eligen números posteriores a los más altos hasta ahora.

Puse los ítems en vez de los números porque es lo que genera el código, me resultaba más fácil así. Yo también me canso de todo esto.

Citar
usa números, letras, no palabras... que se pueda entender de un vistazo.
Vale, se entiende más como dices, pero cuando ponen ejemplos de combinatoria suelen nombrar colores y no creo que te quejes de eso. No debería ser tanto problema que en vez de colores sean unas palabras. Y dije que eran 6, así que no es que hubiera alguna que apareciera nuevo por ahí, ni son tantas como para que sea tan complicado.

Citar
bien explicado bastan dos frases para describirlo
Bueno xD si llegas a entenderlo hazme el favor de describirlo como dices xD
No creo que se pueda. La lista que busco es así:
1
Creativo:   2 3
2
2 4
5 6 1
3
2 5
5 6 2
Creativo:   3 4 5 6
etc
O sea, es como la lista anterior pero hay líneas en que hay otro modo de elección, uno en que se usa un largo antes no usado. ¿Qué líneas? Eso es variable y no viene a cuento.

Creo que es más sencillo de lo que pensé, pero por las dudas... Me refiero a que los nuevos largos siempre ocurren en la línea "Creativo" (salvo el 3, pero si ajustando eso se simplifica todo lo demás no hay problema), o sea que con esto la parte (del programa) que genera líneas normales no necesita saber qué hacer en caso de alcanzar un largo nunca antes alcanzado, porque eso siempre lo haría el proceso alternativo, la línea "Creativo".

¿En qué más puedo ayudarte?

El tema también podría plantearlo de otro modo: ¿Cómo hacer una inteligente búsqueda de una solución a un problema?

Si dices que depende mucho del problema, te lo digo, pero te estoy preguntando por algo general, considero que puede haber una búsqueda que dependiendo del tipo de problema haga un proceso u otro. Si me vas a responder mediante un proceso para 1 tipo de problema, me sirve pero no es lo mismo.

Bueno, el problema es, en el Legend of Mana de Play 1, modificar un CotKnife de modo que quede lo mejor posible o más o menos así (en caso de no existir realmente "lo mejor"), sin usar guías, etc. CotKnife en realidad es sólo un ejemplo, pero si te digo "un arma" tarde o temprano me dirías "depende de cual", así que ya he dicho.
La modificación de armas consiste en que se le agregan cosas. ¡He ahí la combinatoria de cualquier número de elementos, donde importa el orden y pueden repetirse!
Yo podría probar...
Item1+Item2
Item1+Item3
etc
Pero eso es aburrido y poco óptimo (o poco inteligente) ¿verdad? Lo inteligente en este caso sería siempre probar distintos ítems y distintos largos, al menos si aumentar el largo parece mejorar el resultado. El problema es que hacer eso manualmente llega un punto en que es complicado porque hay que ponerse a pensar "qué combinación toca ahora". Especialmente si se quiere evitar que ciertos ítems sean contiguos (si ya se probaron), como pretendí al inicio (ya no) cuando quise hacerlo manualmente.

En fin, es el problema del tema, pero la última pregunta que te hice es más amplia.

Cita de: antopixel en 16 Noviembre 2018, 16:24 pm
Recuerda:
Combinacion = No importa el orden de los elementos, no admite repeticion.
Permutacion = Importa el orden, no admite repeticion.
Siempre tengo líos con eso, y eso que antes de preguntar googlé. En mi caso se admite repetición e importa el orden.
1875  Programación / Programación General / ¿Cómo programar mejor? en: 16 Noviembre 2018, 07:04 am
Quiero que un programa muestre todas las posibles combinaciones de 6 ítems pudiendo repetirse infinitamente. Ej:
1
2
3
4
5
6
1 1
1 2
1 3
1 4
etc

Pero quiero que las muestre en cierto orden. Supongamos que fuese así:
Nota: En vez de números se muestran ciertas palabras pero es que los números son convertidos en ellas.
WispG
ShadeG
ShadeG DryadG
DryadG
ShadeG AuraG
AuraG SalaG GnomeG
AuraG
ShadeG SalaG
AuraG GnomeG WispG
WispG ShadeG DryadG AuraG
SalaG
ShadeG GnomeG
AuraG GnomeG ShadeG
WispG ShadeG DryadG SalaG
SalaG GnomeG WispG ShadeG DryadG
GnomeG
DryadG WispG
AuraG GnomeG DryadG
WispG ShadeG DryadG GnomeG
SalaG GnomeG WispG ShadeG AuraG
AuraG SalaG GnomeG WispG ShadeG DryadG
DryadG ShadeG
AuraG GnomeG AuraG
WispG ShadeG AuraG WispG
SalaG GnomeG WispG ShadeG SalaG
AuraG SalaG GnomeG WispG ShadeG AuraG
AuraG SalaG GnomeG WispG ShadeG DryadG AuraG
etc
En realidad sería más bien así:
WispG
ShadeG
DryadG AuraG
DryadG
DryadG SalaG
GnomeG WispG ShadeG
es decir, cada vez que se crea un nuevo largo se inicia con el ítem (o número) más reciente +1.

Eso lo pude hacer:
Nota: Ignoren de él todo lo relativo a "Creative".
Código:
Escena 1
   actions for fotograma 1
      // Ítems.
      Item1 = "WispG";
      Item2 = "ShadeG";
      Item3 = "DryadG";
      Item4 = "AuraG";
      Item5 = "SalaG";
      Item6 = "GnomeG";
      // Parte 1 del experimento de largo 1.
      L1P1 = 0;
      // Último experimento de largo 1 que se hará.
      LastL1 = "GnomeG ";
      // Último ítem usado.
      RecentItem = 1;
      // Relativo al largo de los experimentos...
      // ...del método clásico.
      ClasicMinL = 1;
      ClasicActualL = 1;
      ClasicMaxL = 1;
      ClasicMaxLReached = 1;
      Info = "";
      function Concatenarytrace () {
         // Concatena las partes de los experimentos.
         Print = "";
         Cursor = 0;
         do {
            Cursor = Cursor+1;
            Print = Print+eval("Item"+eval("L"+ClasicActualL+"P"+Cursor))+" ";
         } while (Cursor<ClasicActualL);
         trace (Print);
         Info = "Func dice exp: "+Print+"\n"+Info;
      }
   actions for fotograma 2
      // Cursor indicará la parte última de un experimento.
      Cursor = ClasicActualL;
      Info = "F2: Cursor está en la última P de un exp, "+ClasicActualL+"\n"+Info;
   actions for fotograma 3
      if (eval("L"+ClasicActualL+"P"+Cursor)<6) {
         // Si el char es aumentable, aumenta.
         set ("L"+ClasicActualL+"P"+Cursor, eval("L"+ClasicActualL+"P"+Cursor)+1);
         Concatenarytrace();
         Info = "F3: Exp del método clásico creado fácil: "+Print+"\n"+Info;
         gotoAndPlay (6);
      }
   actions for fotograma 4
      // El char no es aumentable, ergo se resetea.
      set ("L"+ClasicActualL+"P"+Cursor, 1);
      if (1<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino, se muestra el reseteado.
         Concatenarytrace();
         gotoAndPlay (6);
      }
   actions for fotograma 5
      if (eval("L"+ClasicActualL+"P"+Cursor)<6) {
         // Si el char es aumentable, aumenta.
         set ("L"+ClasicActualL+"P"+Cursor, eval("L"+ClasicActualL+"P"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (6);
      } else {
         // Sino, se resetea y reinicia un proceso.
         gotoAndPlay (4);
      }
   actions for fotograma 6
      // Esto es aftertrace de clasic.
      if (Print == eval("LastL"+ClasicActualL)) {
         // Si el experimento mostrado es igual al grabado como último...
         // ...no se hacen más experimentos con ese largo.
         Info = "F6: Exps de largo "+ClasicMinL+" completados.\n"+Info;
         ClasicMinL = ClasicMinL+1;
      }
      if (CreativeL<=ClasicActualL && ClasicMaxL-1<=ClasicActualL) {
         // Si el largo del último experimento del método creativo...
         // ...es menor o igual al largo de este experimento clásico...
         // ...y ese es igual o mayor al máximo-1 que puede ser...
         // ..., Recentitem cambia.
         RecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL);
         Info = "F6: RecentItem cambiado a "+RecentItem+"\n"+Info;
      }
      if (ClasicActualL<ClasicMaxL) {
         // Si el largo es aumentable, aumenta.
         ClasicActualL = ClasicActualL+1;
         Info = "F6: El siguiente exp de clasic será de Largo "+ClasicActualL+"\n"+Info;
      } else {
         // Sino, quedará al mínimo pero el máximo aumenta.
         ClasicMaxLReached = ClasicMaxL;
         Info = "F6: Clasic alcanzó su máximo L: "+ClasicMaxL+"\n"+Info;
         if (ClasicMaxL<7) {
            // Ese if es sólo para pruebas del code.
            ClasicMaxL = ClasicMaxL+1;
            Info = "F6: Clasic aumentó su máximo L a "+ClasicMaxL+"\n"+Info;
            if (CreativeL<ClasicMaxL) {
               // Si el método creativo no creó un experimento...
               // ...del largo alcanzado por el método clásico...
               // ..., crearlo (no se usará aún) y marcar que será...
               // ...el último experimento de ese largo.
               Info = "F6: Clasic llegó a un L mayor que creative: "+ClasicMaxL+" > "+CreativeL+"\n"+Info;
               set ("LastL"+ClasicMaxL, "");
               Cursor = 1;
               // Cálculo del ítem más recientemente usado.
               NextRecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL);
               do {
                  NextRecentItem = NextRecentItem+1;
                  if (6<NextRecentItem) {
                     // Si resulta un ítem inexistente, arreglarlo.
                     NextRecentItem = NextRecentItem-((Math.floor(NextRecentItem/6))*6);
                  }
                  set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
                  set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
                  Cursor = Cursor+1;
               } while (Cursor<ClasicMaxL);
               set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
            }
         }
         ClasicActualL = ClasicMinL;
         Info = "F6: El siguiente exp de clasic será de Largo "+ClasicMinL+"\n"+Info;
         Info = "F6: Está listo el exp de máx L: "+eval("LastL"+ClasicMaxL)+"\n"+Info;
      }
      gotoAndPlay (2);
O sea, este programa produce la 2nda lista. Sería más correcto que produzca la 3era, pero lo que pasa es que este programa es parte de otro y no viene mucho al caso ver qué debería modificar para que produzca la 3era. Ya fue. Pero si ven algo que pueda simplificarse no duden en decirlo.

Entendidas las listas anteriores podemos pasar a la que me interesa. Es como la anterior pero en X circunstancias (no se preocupen por X) se produce otro método de selección: Creativo. Así:
WispG
Creativo:   ShadeG DryadG
ShadeG
ShadeG AuraG
Creativo:   SalaG GnomeG WispG
DryadG
ShadeG SalaG
SalaG GnomeG ShadeG
Creativo:   DryadG AuraG SalaG GnomeG
AuraG
ShadeG GnomeG
SalaG GnomeG DryadG
DryadG AuraG GnomeG WispG
Creativo:   ShadeG DryadG AuraG SalaG GnomeG
SalaG
DryadG WispG
SalaG GnomeG AuraG
DryadG AuraG GnomeG ShadeG
ShadeG DryadG AuraG GnomeG WispG
Creativo:   ShadeG DryadG AuraG SalaG GnomeG WispG
GnomeG
DryadG ShadeG
SalaG GnomeG SalaG
DryadG AuraG GnomeG DryadG
ShadeG DryadG AuraG GnomeG ShadeG
ShadeG DryadG AuraG SalaG GnomeG ShadeG
Creativo:   DryadG AuraG SalaG GnomeG WispG ShadeG DryadG
DryadG DryadG
SalaG GnomeG GnomeG
DryadG AuraG GnomeG AuraG
ShadeG DryadG AuraG GnomeG DryadG
ShadeG DryadG AuraG SalaG GnomeG DryadG
DryadG AuraG SalaG GnomeG WispG ShadeG AuraG
GnomeG WispG WispG
etc

Eso se logra quitando el goto del final y agregando esto:
   actions for fotograma 7
      TimeforCreative = TimeforCreative-1;
      if (TimeforCreative<=0) {
         // Elección creativa.
         if (CreativeL<7) {
            // Ese if es sólo para pruebas del code.
            CreativeL = CreativeL+1;
            if (CreativeL<ClasicMaxLReached) {
               // Si el método creativo no creó un...
               // ...experimento de largo mayor al...
               // ...del método clásico, aumentarlo.
               CreativeL = ClasicMaxLReached+1;
            }
            Info = "F7: Elección creativa de largo "+CreativeL+"\n"+Info;
            set ("LastL"+CreativeL, "");
            Cursor = 1;
            Print = "";
            do {
               RecentItem = RecentItem+1;
               if (6<RecentItem) {
                  // Si resulta un ítem inexistente, arreglarlo.
                  RecentItem = RecentItem-((Math.floor(RecentItem/6))*6);
               }
               set ("L"+CreativeL+"P"+Cursor, RecentItem);
               set ("LastL"+CreativeL, eval("LastL"+CreativeL)+eval("Item"+RecentItem)+" ");
               Cursor = Cursor+1;
            } while (Cursor<CreativeL);
            Print = eval("LastL"+CreativeL);
            set ("LastL"+CreativeL, eval("LastL"+CreativeL)+eval("Item"+RecentItem)+" ");
            Info = "F7: Last creado: "+eval("LastL"+CreativeL)+"\n"+Info;
            RecentItem = RecentItem+1;
            if (6<RecentItem) {
               // Si resulta un ítem inexistente, arreglarlo.
               RecentItem = RecentItem-((Math.floor(RecentItem/6))*6);
            }
            set ("L"+CreativeL+"P"+Cursor, RecentItem);
            Print = Print+eval("Item"+RecentItem)+" ";
            trace ("Creativo:\t"+Print);
            Info = "F7: Método creativo creó exp "+Print+"\n"+Info;
            Info = "F7: RecentItem es "+RecentItem+".\n"+Info;
         } else {
            gotoAndPlay (2);
            Info = "F7: Método creativo alcanzó el máximo.\n"+Info;
         }
      } else {
         Info = "F7: Para la elección creativa falta "+TimeforCreative+"\n"+Info;
         gotoAndPlay (2);
      }
   actions for fotograma 8
      stop ();

En el F8 se determina si hay Creative o no, pero no den bola a eso. Una vez determinado vuelve al frame 2.

En este caso creo que no hay errores en cuanto a usar ítems diferentes cuando inicia un nuevo largo. De hecho eso parece suceder siempre con Creative e imposible de otro modo.
Lo señalado en rojo sí es un error que de momento no sé corregir. El programa debería mostrar más combinaciones de 2, pero por algún motivo cree que las mostró todas. Más info:
F2: Cursor está en la última P de un exp, 1
Func dice exp: WispG
F3: Exp del método clásico creado fácil: WispG
F6: RecentItem cambiado a 1
F6: Clasic alcanzó su máximo L: 1
F6: Clasic aumentó su máximo L a 2
F6: Clasic llegó a un L mayor que creative: 2 > 1
F6: El siguiente exp de clasic será de Largo 1
F6: Está listo el exp de máx L: ShadeG ShadeG
F7: Elección creativa de largo 2
F7: Last creado: ShadeG ShadeG
F7: Método creativo creó exp ShadeG DryadG
F7: RecentItem es 3.
F2: Cursor está en la última P de un exp, 1
Func dice exp: ShadeG
F3: Exp del método clásico creado fácil: ShadeG
F6: El siguiente exp de clasic será de Largo 2
F7: Para la elección creativa falta 1
F2: Cursor está en la última P de un exp, 2
Func dice exp: ShadeG AuraG
F3: Exp del método clásico creado fácil: ShadeG AuraG
F6: RecentItem cambiado a 4
F6: Clasic alcanzó su máximo L: 2
F6: Clasic aumentó su máximo L a 3
F6: Clasic llegó a un L mayor que creative: 3 > 2
F6: El siguiente exp de clasic será de Largo 1
F6: Está listo el exp de máx L: SalaG GnomeG GnomeG
F7: Elección creativa de largo 3
F7: Last creado: SalaG GnomeG GnomeG
F7: Método creativo creó exp SalaG GnomeG WispG
F7: RecentItem es 1.
F2: Cursor está en la última P de un exp, 1
Func dice exp: DryadG
F3: Exp del método clásico creado fácil: DryadG
F6: El siguiente exp de clasic será de Largo 2
F7: Para la elección creativa falta 2
F2: Cursor está en la última P de un exp, 2
Func dice exp: ShadeG SalaG
F3: Exp del método clásico creado fácil: ShadeG SalaG
F6: El siguiente exp de clasic será de Largo 3
F7: Para la elección creativa falta 1
F2: Cursor está en la última P de un exp, 3
Func dice exp: SalaG GnomeG ShadeG
F3: Exp del método clásico creado fácil: SalaG GnomeG ShadeG
F6: RecentItem cambiado a 2
F6: Clasic alcanzó su máximo L: 3
F6: Clasic aumentó su máximo L a 4
F6: Clasic llegó a un L mayor que creative: 4 > 3
F6: El siguiente exp de clasic será de Largo 1
F6: Está listo el exp de máx L: DryadG AuraG SalaG SalaG
F7: Elección creativa de largo 4
F7: Last creado: DryadG AuraG SalaG SalaG
F7: Método creativo creó exp DryadG AuraG SalaG GnomeG
F7: RecentItem es 6.
F2: Cursor está en la última P de un exp, 1
Func dice exp: AuraG
F3: Exp del método clásico creado fácil: AuraG
F6: El siguiente exp de clasic será de Largo 2
F7: Para la elección creativa falta 3
F2: Cursor está en la última P de un exp, 2
Func dice exp: ShadeG GnomeG
F3: Exp del método clásico creado fácil: ShadeG GnomeG
F6: El siguiente exp de clasic será de Largo 3
F7: Para la elección creativa falta 2
F2: Cursor está en la última P de un exp, 3
Func dice exp: SalaG GnomeG DryadG
F3: Exp del método clásico creado fácil: SalaG GnomeG DryadG
F6: El siguiente exp de clasic será de Largo 4
F7: Para la elección creativa falta 1
F2: Cursor está en la última P de un exp, 4
Func dice exp: DryadG AuraG GnomeG WispG
F6: RecentItem cambiado a 1
F6: Clasic alcanzó su máximo L: 4
F6: Clasic aumentó su máximo L a 5
F6: Clasic llegó a un L mayor que creative: 5 > 4
F6: El siguiente exp de clasic será de Largo 1
F6: Está listo el exp de máx L: ShadeG DryadG AuraG SalaG SalaG
F7: Elección creativa de largo 5
F7: Last creado: ShadeG DryadG AuraG SalaG SalaG
F7: Método creativo creó exp ShadeG DryadG AuraG SalaG GnomeG
F7: RecentItem es 6.
F2: Cursor está en la última P de un exp, 1
Func dice exp: SalaG
F3: Exp del método clásico creado fácil: SalaG
F6: El siguiente exp de clasic será de Largo 2
F7: Para la elección creativa falta 4
F2: Cursor está en la última P de un exp, 2
Func dice exp: DryadG WispG
F6: El siguiente exp de clasic será de Largo 3
F7: Para la elección creativa falta 3
F2: Cursor está en la última P de un exp, 3
Func dice exp: SalaG GnomeG AuraG
F3: Exp del método clásico creado fácil: SalaG GnomeG AuraG
F6: El siguiente exp de clasic será de Largo 4
F7: Para la elección creativa falta 2
F2: Cursor está en la última P de un exp, 4
Func dice exp: DryadG AuraG GnomeG ShadeG
F3: Exp del método clásico creado fácil: DryadG AuraG GnomeG ShadeG
F6: El siguiente exp de clasic será de Largo 5
F7: Para la elección creativa falta 1
F2: Cursor está en la última P de un exp, 5
Func dice exp: ShadeG DryadG AuraG GnomeG WispG
F6: RecentItem cambiado a 1
F6: Clasic alcanzó su máximo L: 5
F6: Clasic aumentó su máximo L a 6
F6: Clasic llegó a un L mayor que creative: 6 > 5
F6: El siguiente exp de clasic será de Largo 1
F6: Está listo el exp de máx L: ShadeG DryadG AuraG SalaG GnomeG GnomeG
F7: Elección creativa de largo 6
F7: Last creado: ShadeG DryadG AuraG SalaG GnomeG GnomeG
F7: Método creativo creó exp ShadeG DryadG AuraG SalaG GnomeG WispG
F7: RecentItem es 1.
F2: Cursor está en la última P de un exp, 1
Func dice exp: GnomeG
F3: Exp del método clásico creado fácil: GnomeG
F6: Exps de largo 1 completados.
F6: El siguiente exp de clasic será de Largo 2
F7: Para la elección creativa falta 5
F2: Cursor está en la última P de un exp, 2
Func dice exp: DryadG ShadeG
F3: Exp del método clásico creado fácil: DryadG ShadeG
F6: El siguiente exp de clasic será de Largo 3
F7: Para la elección creativa falta 4
F2: Cursor está en la última P de un exp, 3
Func dice exp: SalaG GnomeG SalaG
F3: Exp del método clásico creado fácil: SalaG GnomeG SalaG
F6: El siguiente exp de clasic será de Largo 4
F7: Para la elección creativa falta 3
F2: Cursor está en la última P de un exp, 4
Func dice exp: DryadG AuraG GnomeG DryadG
F3: Exp del método clásico creado fácil: DryadG AuraG GnomeG DryadG
F6: El siguiente exp de clasic será de Largo 5
F7: Para la elección creativa falta 2
F2: Cursor está en la última P de un exp, 5
Func dice exp: ShadeG DryadG AuraG GnomeG ShadeG
F3: Exp del método clásico creado fácil: ShadeG DryadG AuraG GnomeG ShadeG
F6: El siguiente exp de clasic será de Largo 6
F7: Para la elección creativa falta 1
F2: Cursor está en la última P de un exp, 6
Func dice exp: ShadeG DryadG AuraG SalaG GnomeG ShadeG
F3: Exp del método clásico creado fácil: ShadeG DryadG AuraG SalaG GnomeG ShadeG
F6: RecentItem cambiado a 2
F6: Clasic alcanzó su máximo L: 6
F6: Clasic aumentó su máximo L a 7
F6: Clasic llegó a un L mayor que creative: 7 > 6
F6: El siguiente exp de clasic será de Largo 2
F6: Está listo el exp de máx L: DryadG AuraG SalaG GnomeG WispG ShadeG ShadeG
F7: Elección creativa de largo 7
F7: Last creado: DryadG AuraG SalaG GnomeG WispG ShadeG ShadeG
F7: Método creativo creó exp DryadG AuraG SalaG GnomeG WispG ShadeG DryadG
F7: RecentItem es 3.
F2: Cursor está en la última P de un exp, 2
Func dice exp: DryadG DryadG
F3: Exp del método clásico creado fácil: DryadG DryadG
F6: El siguiente exp de clasic será de Largo 3
F7: Para la elección creativa falta 6
F2: Cursor está en la última P de un exp, 3
Func dice exp: SalaG GnomeG GnomeG
F3: Exp del método clásico creado fácil: SalaG GnomeG GnomeG
F6: Exps de largo 2 completados.

Ya lo veo más o menos. Luego de establecer el último exp de largo 3, SalaG GnomeG GnomeG, el exp que se produce es ese sumándole 1 a la última parte, lo que daría GnomeG WispG WispG, pero da SalaG GnomeG WispG porque programé mal la suma... o mejor dicho no me di cuenta que fuese necesario eso. Ahora entonces lo que está en los 1eros frames lo tengo que aplicar más adelante también. Deberé crear otra función o algo. Lioso ¿no? ¿será que programar funciones desde el inicio es mejor? Pero entiendo más si veo un flujo del código, sin tener que ir a otro lado a ver qué hace cada función.

Ah, y acabo de darme cuenta que en los frames 4 y 5 no he puesto "Info". Es que las puse buscando un error que supuse no estaba ahí. Un error difícil de hallar: En un if del F6 había escrito "Crative" en vez de Creative >___<
1876  Programación / Programación General / Re: ¿Cómo captar los pares de una combinación de varios? en: 14 Noviembre 2018, 03:34 am
Había olvidado varios detalles de este problema, pero luego de mucho pude hacer una buena base para la investigación:
Código:
Escena 1
   actions for fotograma 1
      // Ítems.
      Item1 = "WispG";
      Item2 = "ShadeG";
      Item3 = "DryadG";
      Item4 = "AuraG";
      Item5 = "SalaG";
      Item6 = "GnomeG";
      Item7 = "JinnG";
      Item8 = "UndineG";
      Item9 = "WispS";
      Item10 = "ShadeS";
      Item11 = "DryadS";
      Item12 = "AuraS";
      Item13 = "SalaS";
      Item14 = "GnomeS";
      Item15 = "JinnS";
      Item16 = "UndineS";
      Item17 = "FireC";
      Item18 = "EarthC";
      Item19 = "WindC";
      Item20 = "WaterC";
      Item21 = "SunC";
      Item22 = "MoonC";
      Item23 = "GlowC";
      Item24 = "ChaosC";
      Item25 = "RoundS";
      Item26 = "OblongS";
      Item27 = "CroakedS";
      Item28 = "BigS";
      Item29 = "SmallS";
      Item30 = "LongS";
      Item31 = "FlatS";
      Item32 = "SpinyS";
      Item33 = "Bellgrapes";
      Item34 = "DiceB";
      Item35 = "LShoes";
      Item36 = "PShoes";
      Item37 = "Squalphin";
      Item38 = "Citrisquid";
      Item39 = "Springanana";
      Item40 = "PeachP";
      Item41 = "Apricat";
      Item42 = "Whalamata";
      Item43 = "POclock";
      Item44 = "FishyF";
      Item45 = "Boarmelon";
      Item46 = "Rhinoloupe";
      Item47 = "Orcaplant";
      Item48 = "Garlicrown";
      Item49 = "HoneyO";
      Item50 = "SMoai";
      Item51 = "SCarrot";
      Item52 = "Conchurnip";
      Item53 = "CornF";
      Item54 = "Cabadilllo";
      Item55 = "Needletuce";
      Item56 = "CherryB";
      Item57 = "MPotato";
      Item58 = "Lilipods";
      Item59 = "Bumpkin";
      Item60 = "HearhM";
      Item61 = "SpadeB";
      Item62 = "Mushroom";
      Item63 = "AnimalM";
      Item64 = "BugM";
      Item65 = "LizardM";
      Item66 = "FishM";
      Item67 = "BirdM";
      Item68 = "MorphM";
      Item69 = "DemonM";
      Item70 = "DragonS";
      Item71 = "OddM";
      Item72 = "MagicM";
      Item73 = "RottenM";
      Item74 = "SharpC";
      Item75 = "PoisonC";
      Item76 = "Scisors";
      Item77 = "HealingC";
      Item78 = "ZombieC";
      Item79 = "VampireF";
      Item80 = "LittleE";
      Item81 = "SleeptyE";
      Item82 = "SillyE";
      Item83 = "DangerousE";
      Item84 = "AngryE";
      Item85 = "BlankE";
      Item86 = "CreepyE";
      Item87 = "WickedE";
      Item88 = "AngelF";
      Item89 = "RavenF";
      Item90 = "CFeather";
      Item91 = "MothW";
      Item92 = "FlamingQ";
      Item93 = "WhiteF";
      Item94 = "AromaO";
      Item95 = "DBlood";
      Item96 = "Acid";
      Item97 = "HolyW";
      Item98 = "Ether";
      Item99 = "Mercury";
      Item100 = "StinkyB";
      Item101 = "GhostH";
      Item102 = "DBreath";
      Item103 = "VirginS";
      Item104 = "Electr";
      Item105 = "Moss";
      Item106 = "EarW";
      Item107 = "BBat";
      Item108 = "Sulpher";
      Item109 = "PoisonP";
      Item110 = "SleepP";
      Item111 = "KnockD";
      Item112 = "Rust";
      Item113 = "GraveD";
      Item114 = "Ash";
      Item115 = "Hairball";
      Item116 = "Needle";
      Item117 = "Mirror";
      Item118 = "WadW";
      Item119 = "MessyS";
      Item120 = "GreenballB";
      Item121 = "TakoB";
      // Parte 1 del experimento de largo 1.
      L1P1 = 0;
      // Último experimento de largo 1 que se hará.
      LastL1 = "TakoB ";
      // Último ítem usado.
      RecentItem = 1;
      // Relativo al largo de los experimentos...
      // ...del método clásico.
      ClasicMinL = 1;
      ClasicActualL = 1;
      ClasicMaxL = 1;
      ClasicMaxLReached = 1;
      // Largo del método creativo.
      CreativeL = 1;
      // Experimentos antes de hacer uno del método creativo.
      TimeforCreative = 1;
      // Valor de TimeforCreative cuando debe recargarse.
      ChargedTimeforCreative = 1;
      // Mayor largo alcanzado por cualquier método.
      AnyMaxL = 1;
      Info = "";
      function Concatenarytrace () {
         // Concatena las partes de los experimentos.
         Print = "";
         Cursor = 0;
         do {
            Cursor = Cursor+1;
            Print = Print+eval("Item"+eval("L"+ClasicActualL+"P"+Cursor))+" ";
         } while (Cursor<ClasicActualL);
         trace (Print);
         Info = "Func dice exp: "+Print+"\n"+Info;
      }
   actions for fotograma 2
      // Cursor indicará la parte última de un experimento.
      Cursor = ClasicActualL;
      Info = "F2: Cursor está en la última P de un exp, "+ClasicActualL+"\n"+Info;
   actions for fotograma 3
      if (eval("L"+ClasicActualL+"P"+Cursor)<6) {
         // Si el char es aumentable, aumenta.
         set ("L"+ClasicActualL+"P"+Cursor, eval("L"+ClasicActualL+"P"+Cursor)+1);
         Concatenarytrace();
         Info = "F3: Exp del método clásico creado fácil: "+Print+"\n"+Info;
         gotoAndPlay (6);
      }
   actions for fotograma 4
      // El char no es aumentable, ergo se resetea.
      set ("L"+ClasicActualL+"P"+Cursor, 1);
      if (1<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino, se muestra el reseteado.
         Concatenarytrace();
         gotoAndPlay (6);
      }
   actions for fotograma 5
      if (eval("L"+ClasicActualL+"P"+Cursor)<6) {
         // Si el char es aumentable, aumenta.
         set ("L"+ClasicActualL+"P"+Cursor, eval("L"+ClasicActualL+"P"+Cursor)+1);
         Concatenarytrace();
         gotoAndPlay (6);
      } else {
         // Sino, se resetea y reinicia un proceso.
         gotoAndPlay (4);
      }
   actions for fotograma 6
      // Esto es aftertrace de clasic.
      if (Print == eval("LastL"+ClasicActualL)) {
         // Si el experimento mostrado es igual al grabado como último...
         // ...no se hacen más experimentos con ese largo.
         Info = "F6: Exps de largo "+ClasicMinL+" completados.\n"+Info;
         ClasicMinL = ClasicMinL+1;
      }
      if (CreativeL<=ClasicActualL && ClasicMaxL-1<=ClasicActualL) {
         // Si el largo del último experimento del método creativo...
         // ...es menor o igual al largo de este experimento clásico...
         // ...y ese es igual o mayor al máximo-1 que puede ser...
         // ..., Recentitem cambia.
         RecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL);
         Info = "F6: RecentItem cambiado a "+RecentItem+"\n"+Info;
      }
      if (ClasicActualL<ClasicMaxL) {
         // Si el largo es aumentable, aumenta.
         ClasicActualL = ClasicActualL+1;
         Info = "F6: El siguiente exp de clasic será de Largo "+ClasicActualL+"\n"+Info;
      } else {
         // Sino, quedará al mínimo pero el máximo aumenta.
         ClasicMaxLReached = ClasicMaxL;
         Info = "F6: Clasic alcanzó su máximo L: "+ClasicMaxL+"\n"+Info;
         if (ClasicMaxL<7) {
            // Ese if es sólo para pruebas del code.
            ClasicMaxL = ClasicMaxL+1;
            Info = "F6: Clasic aumentó su máximo L a "+ClasicMaxL+"\n"+Info;
            if (CreativeL<ClasicMaxL) {
               // Si el método creativo no creó un experimento...
               // ...del largo alcanzado por el método clásico...
               // ..., crearlo (no se usará aún) y marcar que será...
               // ...el último experimento de ese largo.
               Info = "F6: Clasic llegó a un L mayor que creative: "+ClasicMaxL+" > "+CreativeL+"\n"+Info;
               set ("LastL"+ClasicMaxL, "");
               Cursor = 1;
               // Cálculo del ítem más recientemente usado.
               NextRecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL);
               do {
                  NextRecentItem = NextRecentItem+1;
                  if (6<NextRecentItem) {
                     // Si resulta un ítem inexistente, arreglarlo.
                     NextRecentItem = NextRecentItem-((Math.floor(NextRecentItem/6))*6);
                  }
                  set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
                  set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
                  Cursor = Cursor+1;
               } while (Cursor<ClasicMaxL);
               set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
            }
         }
         ClasicActualL = ClasicMinL;
         Info = "F6: El siguiente exp de clasic será de Largo "+ClasicMinL+"\n"+Info;
         Info = "F6: Está listo el exp de máx L: "+eval("LastL"+ClasicMaxL)+"\n"+Info;
      }
   actions for fotograma 7
      TimeforCreative = TimeforCreative-1;
      if (TimeforCreative<=0) {
         // Elección creativa.
         if (CreativeL<7) {
            // Ese if es sólo para pruebas del code.
            CreativeL = CreativeL+1;
            if (CreativeL<ClasicMaxLReached) {
               // Si el método creativo no creó un...
               // ...experimento de largo mayor al...
               // ...del método clásico, aumentarlo.
               CreativeL = ClasicMaxLReached+1;
            }
            Info = "F7: Elección creativa de largo "+CreativeL+"\n"+Info;
            set ("LastL"+CreativeL, "");
            Cursor = 1;
            Print = "";
            do {
               RecentItem = RecentItem+1;
               if (6<RecentItem) {
                  // Si resulta un ítem inexistente, arreglarlo.
                  RecentItem = RecentItem-((Math.floor(RecentItem/6))*6);
               }
               set ("L"+CreativeL+"P"+Cursor, RecentItem);
               set ("LastL"+CreativeL, eval("LastL"+CreativeL)+eval("Item"+RecentItem)+" ");
               Cursor = Cursor+1;
            } while (Cursor<CreativeL);
            Print = eval("LastL"+CreativeL);
            set ("LastL"+CreativeL, eval("LastL"+CreativeL)+eval("Item"+RecentItem)+" ");
            Info = "F7: Last creado: "+eval("LastL"+CreativeL)+"\n"+Info;
            RecentItem = RecentItem+1;
            if (6<RecentItem) {
               // Si resulta un ítem inexistente, arreglarlo.
               RecentItem = RecentItem-((Math.floor(RecentItem/6))*6);
            }
            set ("L"+CreativeL+"P"+Cursor, RecentItem);
            Print = Print+eval("Item"+RecentItem)+" ";
            trace ("Creativo:\t"+Print);
            Info = "F7: Método creativo creó exp "+Print+"\n"+Info;
            Info = "F7: RecentItem es "+RecentItem+".\n"+Info;
         } else {
            gotoAndPlay (2);
            Info = "F7: Método creativo alcanzó el máximo.\n"+Info;
         }
      } else {
         Info = "F7: Para la elección creativa falta "+TimeforCreative+"\n"+Info;
         gotoAndPlay (2);
      }
   actions for fotograma 8
      stop ();
   actions for Símbolo 1
      on (release, keyPress "<Left>") {
         ChargedTimeforCreative = 1;
         TimeforCreative = ChargedTimeforCreative;
         gotoAndPlay (2);
      }
   actions for Símbolo 2
      on (release, keyPress "<Right>") {
         ChargedTimeforCreative = ChargedTimeforCreative+1;
         TimeforCreative = ChargedTimeforCreative;
         gotoAndPlay (2);
      }
Aunque son más de 100 ítems, lo limité a 6 para ver mejor que el "reset" (ver abajo) funcione bien. Parecido en cuanto al largo, está limitado a 7. En el frame 8 hay un par de botones, nombrados en el código al final como Símbolo 1 y 2. El programa pide que en el juego se pruebe el ítem 1. Luego el 2 y 3. Luego pregunta si eso fue mejor que lo anterior (para eso los botones). O sea, intercala 2 métodos. A uno le llamo Clasic y es:
1
2
34
3
35
612
etc
Al otro le llamo Creative y sería así:
1
23
356
1234
etc
Cuando se produce un largo no alcanzado, se compone de los siguientes ítems al más elevado. Cuando es 6, cambia a 1. Los métodos, al intercalarse forman esto:
WispG
Creativo:   ShadeG DryadG
ShadeG
Creativo:   AuraG SalaG GnomeG
ShadeG AuraG
Creativo:   WispG ShadeG DryadG AuraG
DryadG
Creativo:   SalaG GnomeG WispG ShadeG DryadG
ShadeG SalaG
Creativo:   AuraG SalaG GnomeG WispG ShadeG DryadG
AuraG GnomeG WispG
Creativo:   AuraG SalaG GnomeG WispG ShadeG DryadG AuraG
AuraG
ShadeG GnomeG
AuraG GnomeG ShadeG
WispG ShadeG DryadG SalaG
SalaG
DryadG WispG
AuraG GnomeG DryadG
WispG ShadeG DryadG GnomeG
SalaG GnomeG WispG ShadeG AuraG
GnomeG
DryadG ShadeG
AuraG GnomeG AuraG
WispG ShadeG AuraG WispG
SalaG GnomeG WispG ShadeG SalaG
AuraG SalaG GnomeG WispG ShadeG AuraG
WispG
El programa no muestra números sino ítems, pero es lo mismo. Por algún motivo esto no se está aplicando:
Código:
      if (Print == eval("LastL"+ClasicActualL)) {
         // Si el experimento mostrado es igual al grabado como último...
         // ...no se hacen más experimentos con ese largo.
         Info = "F6: Exps de largo "+ClasicMinL+" completados.\n"+Info;
         ClasicMinL = ClasicMinL+1;
      }
Por eso repitió "WispG". Sinceramente, no sé cuántos errores puede haber, y el método no es perfecto (por ejemplo en
"Creativo:   AuraG SalaG GnomeG WispG ShadeG DryadG
AuraG GnomeG WispG
Creativo:   AuraG SalaG GnomeG WispG ShadeG DryadG AuraG"
El submétodo creativo produce 2 resultados casi iguales...
...aunque creo que eso se arreglará cuando le ponga un contador de resets y los contiguos se elijan basados en él. Sería por ejemplo:
"Creativo:   AuraG SalaG GnomeG WispG ShadeG DryadG
AuraG GnomeG WispG
Creativo:   AuraG GnomeG ShadeG AuraG GnomeG ShadeG AuraG"

Eeen fin, lo importante es que se diría todo experimento, en un orden interesante, variado. De hecho, la pregunta de si el submétodo creativo fue efectivo hace que la lista pueda variar. Si la respuesta es sí, el submétodo se ejecutará en su lugar correspondiente, sino se salteará 1 vez, y en la próxima si se responde de nuevo que no entonces serán 2 veces y así sucesivamente. El método dice experimentos de más largo más seguidos si eso fue efectivo, y sino los dice menos seguidos.

En realidad esto no responde el tema, y los métodos pueden mejorar, seguiré con ello, pero bueno, la base está...
1877  Programación / Programación General / ¿Cómo captar los pares de una combinación de varios? en: 18 Octubre 2018, 07:03 am
O algo así.

El juego Legend of Mana de Play tiene un sistema de modificación de armas/armaduras en el cual puedes agregar cosas a ellas infinitamente, pero algunas cosas perjudican al equipo y algunos resultados sólo ocurren cuando se cumplen ciertos requisitos. Hay guías de esto, pero quiero hacer una investigación por mi mismo, la cual implica probar diferentes combinaciones en el juego.

Supongamos que sólo hay X cantidad de ítems y cada uno se llama como una letra, distinta. X es la cantidad de letras. Qué pruebas hacer y en qué orden es todo un tema, yo diría que aparte, pero si quieren lo hablamos. La cuestión es que quiero usar un método más o menos óptimo, o sea, esta serie de pruebas:
A
B+C
D+E+F
G+H+I+J
...etc, parece más óptimo que esta:
A
A+A
A+B
A+C
...parece, pero bue, digamos que sí es.

Yo uso una serie más o menos así:
A
B
C+D
E
F+G
H+I+J

Cuando haya probado todos los elementos (aún no las combinaciones), quiero que las próximas combinaciones sean de elementos que aún no se hayan combinado. Por ejemplo en este caso, I+H debería probarse posteriormente a I+F, porque en cierto modo ya fue probado en H+I+J (no es que a priori pueda concluirse el resultado, pero por una cuestión de probabilidad y lógica tiene sentido probar algo más diferente).

A medida que avance, cada vez me será más complicado ver qué pares de elementos probé y cuales no, por eso quisiera algo que si yo le escribo por ejemplo A+B+C me devuelva
AB
AC
BC

Ahora que pienso es algo de permutaciones o algo así, pensé que era un problema más extraño... pero en lo posible no quiero programar tanto, hice una tabla en Excel donde marco con un número las veces que ciertos elementos se combinaron, y le puse un sumador así que busco los que tienen 0 y así sucesivamente. Me gustaría que de alguna forma esos números se escribieran solos, o sea, supongamos que la tabla sólo tuviera 3 elementos:
_____A__B__C
_____0__0__0
A_0
B_0
C_0
Los 0 son las sumas. En las filas, las veces que ese elemento se combinó con otro y estuvo antes. En las columnas, lo mismo pero si estuvo después.

En un texto aparte voy anotando las combinaciones y los resultados:
A: Poder de ataque+1, esencia de fuego+1, etc.
B: Poder de ataque+1, técnica+1, etc.
C+A: Poder de ataque+2, esencia de fuego+1. etc.
etc

Luego marco en la tabla las cosas que se combinaron:
_____A__B__C
_____0__0__0
A_0
B_0
C_1__1

Yo quisiera que de alguna forma, si es posible, escriba el texto, y luego esos números aparezcan.
Por ejemplo escriba C+A y se le sume 1 a lo que haya en la celda correspondiente.

El texto puede estar en celdas separadas, es decir, cada elemento en una celda, lo puedo ir poniendo en otra hoja.

Si en Excel es muy complicado o imposible, bueno, lo pensaré en algo más "técnico", de hecho está bueno si pudiera hacer que las selecciones de qué elementos combinar se hicieran automáticamente, no tendría que andar viendo cuales tienen menos uso ni anotando tanto en la tabla...


Nos veremos.
1878  Foros Generales / Foro Libre / Re: Un niño acaba perdido entre diversos portales donde abundan los fantasmas, inten en: 28 Agosto 2018, 09:02 am
No sé si denunciarte por título engañoso o agradecerte el video. Pero pensé que era en serio...

Es que aún Internet no me atrapó, más bien me atrapó un sitio donde todo debería ser... como debería ser... por ejemplo los títulos deben ser descriptivos del tema, sin ser ambiguos o al menos la interpretación más obvia o probable debe surgir por el título. En fin, quizá ese mundo se llama filosofía o programación.

Hablando de niños perdidos en otro mundo y filosofía me acordé de "El mundo de Sofía", una película muy delirante.

O quizá estoy como en alguna película de justiciero, pero más de las palabras y l lógica que de los puñetazos y similares.
1879  Programación / Programación General / Re: (Resuelto): Errores en generador de sentencias condicionales. en: 19 Agosto 2018, 02:16 am
Faltaba esto:
Cursor1 = SCs;
en el 2ndo fotograma, o sea acá:
Código:
      if (eval("SC"+Cursor1+"P"+Cursor2)<MaxValor) {
         set ("SC"+Cursor1+"P"+Cursor2, eval("SC"+Cursor1+"P"+Cursor2)+1);
         PrintCond();
         ACÁAAAAAAAAAAAAAAAAAAAA Cursor1 = SCs;
         Cursor2 = 3;
Con eso se marca que el valor a modificarse será el de la última subcondición (la que esté más a la derecha).

Y en el while del fotograma 1 había que poner Print al inicio en vez de al final:
Código:
         while (Cursor3<SCs) {
            if (eval("SC"+Cursor3+"P2")<5) {
               Print = "V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3")+eval("Rel"+eval("SC"+Cursor3+"P4"))+Print;
            } else {
               Print = "V"+eval("SC"+Cursor3+"P3")+eval("Op"+(eval("SC"+Cursor3+"P2")-4))+"V"+eval("SC"+Cursor3+"P1")+eval("Rel"+eval("SC"+Cursor3+"P4"))+Print;
            }
            Cursor3 = Cursor3+1;
         }

O sea quedaría así:
Print =  Print + "V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3")+eval("Rel"+eval("SC"+Cursor3+"P4"));
Y:
Print = Print + "V"+eval("SC"+Cursor3+"P3")+eval("Op"+(eval("SC"+Cursor3+"P2")-4))+"V"+eval("SC"+Cursor3+"P1")+eval("Rel"+eval("SC"+Cursor3+"P4"));

Les dejo una versión simplificada, o sea, esta usa los 6 símbolos en vez de 4 e invertir. La diferencia es que no hay ifs en la función PrintCond.
Código:
Escena 1
   actions for fotograma 1
      // Subcondiciones en la condición.
      SCs = 1;
      // Valores de las partes de la SC.
      SC1P1 = 1;
      SC1P2 = 1;
      SC1P3 = 0;
      // Cosas para evitar ifs.
      Op1 = " < ";
      Op2 = " <= ";
      Op3 = " == ";
      Op4 = " != ";
      Op5 = " => ";
      Op6 = " > ";
      Rel1 = " && ";
      Rel2 = " or ";
      Cursor1 = 1;
      Cursor2 = 3;
      function PrintCond () {
         Cursor3 = 1;
         Print = "";
         while (Cursor3<SCs) {
            Print = Print+"V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3")+eval("Rel"+eval("SC"+Cursor3+"P4"));
            Cursor3 = Cursor3+1;
         }
         // Eso traduce los valores en variables o símbolos y los va concatenando.
         Print = Print+"V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3");
         // Eso es la subcondición final, la que no tiene parte 4 ("&&" o "or").
         trace (Print);
      }
   actions for fotograma 2
      if (Cursor2 == 1 or Cursor2 == 3) {
         MaxValor = SCs*2;
      } else if (Cursor2 == 2) {
         MaxValor = 6;
      } else {
         MaxValor = 2;
      }
      // Máximo valor de la parte donde esté el cursor 2. Si por ejemplo es la parte 2 su máximo valor es 6, o sea los 6 posibles operadores.
      if (eval("SC"+Cursor1+"P"+Cursor2)<MaxValor) {
         // Si el valor señalado puede aumentar.
         set ("SC"+Cursor1+"P"+Cursor2, eval("SC"+Cursor1+"P"+Cursor2)+1);
         PrintCond();
         Cursor1 = SCs;
         Cursor2 = 3;
         // Aumenta, se muestra y se resetean los cursores.
      } else {
         // El valor se resetea.
         set ("SC"+Cursor1+"P"+Cursor2, 1);
         if (Cursor2>1) {
            // Si el cursor 2 puede retroceder, o sea marcar una parte más en la izquierda, se reduce.
            Cursor2 = Cursor2-1;
         } else if (Cursor1>1) {
            // Sino, si el cursor 1 puede retroceder, se reduce. El cursor 1 marca la subcondición y la el 2 marca la parte (variable1, operador, variable2, relación. En vez de operador debería decir comparador, no me di cuenta). Y el cursor 2 se queda al máximo (marcando la parte más a la derecha de la subcondición, la relación "&&" o "or").
            Cursor1 = Cursor1-1;
            Cursor2 = 4;
         } else {
            // Sino, se crea la parte relación o 4 de la última subcondición (derecha), aumenta la cantidad de subcondiciones, los cursores quedan al máximo (en la derecha), se crea una nueva subcondición, de 3 partes, y se muestra todo.
            set ("SC"+SCs+"P4", 1);
            SCs = SCs+1;
            Cursor1 = SCs;
            Cursor2 = 3;
            set ("SC"+SCs+"P1", 1);
            set ("SC"+SCs+"P2", 1);
            set ("SC"+SCs+"P3", 1);
            PrintCond();
         }
      }
   actions for fotograma 3
      gotoAndPlay (2);
La cantidad de condiciones que muestra es abrumadora. Aunque claro muchas son repetidas y son simplonas. Por algo se empieza...

Aquí he reducido el número de posibles valores. O sea, con 2 subcondiciones son
4*6*4*2*4*6*4
que según calculé son 9216 posibilidades (con repeticiones y chorradas, luego las intentaré evitar).
Pero en esta versión es
2*2*2*2*2*2*2
Así es el resultado:
[spoiler]V1 < V1
V1 < V2
V1 <= V1
V1 <= V2
V2 < V1
V2 < V2
V2 <= V1
V2 <= V2
V1 < V1 && V1 < V1
V1 < V1 && V1 < V2
V1 < V1 && V1 <= V1
V1 < V1 && V1 <= V2
V1 < V1 && V2 < V1
V1 < V1 && V2 < V2
V1 < V1 && V2 <= V1
V1 < V1 && V2 <= V2
V1 < V1 or V1 < V1
V1 < V1 or V1 < V2
V1 < V1 or V1 <= V1
V1 < V1 or V1 <= V2
V1 < V1 or V2 < V1
V1 < V1 or V2 < V2
V1 < V1 or V2 <= V1
V1 < V1 or V2 <= V2
V1 < V2 && V1 < V1
V1 < V2 && V1 < V2
V1 < V2 && V1 <= V1
V1 < V2 && V1 <= V2
V1 < V2 && V2 < V1
V1 < V2 && V2 < V2
V1 < V2 && V2 <= V1
V1 < V2 && V2 <= V2
V1 < V2 or V1 < V1
V1 < V2 or V1 < V2
V1 < V2 or V1 <= V1
V1 < V2 or V1 <= V2
V1 < V2 or V2 < V1
V1 < V2 or V2 < V2
V1 < V2 or V2 <= V1
V1 < V2 or V2 <= V2
V1 <= V1 && V1 < V1
V1 <= V1 && V1 < V2
V1 <= V1 && V1 <= V1
V1 <= V1 && V1 <= V2
V1 <= V1 && V2 < V1
V1 <= V1 && V2 < V2
V1 <= V1 && V2 <= V1
V1 <= V1 && V2 <= V2
V1 <= V1 or V1 < V1
V1 <= V1 or V1 < V2
V1 <= V1 or V1 <= V1
V1 <= V1 or V1 <= V2
V1 <= V1 or V2 < V1
V1 <= V1 or V2 < V2
V1 <= V1 or V2 <= V1
V1 <= V1 or V2 <= V2
V1 <= V2 && V1 < V1
V1 <= V2 && V1 < V2
V1 <= V2 && V1 <= V1
V1 <= V2 && V1 <= V2
V1 <= V2 && V2 < V1
V1 <= V2 && V2 < V2
V1 <= V2 && V2 <= V1
V1 <= V2 && V2 <= V2
V1 <= V2 or V1 < V1
V1 <= V2 or V1 < V2
V1 <= V2 or V1 <= V1
V1 <= V2 or V1 <= V2
V1 <= V2 or V2 < V1
V1 <= V2 or V2 < V2
V1 <= V2 or V2 <= V1
V1 <= V2 or V2 <= V2
V2 < V1 && V1 < V1
V2 < V1 && V1 < V2
V2 < V1 && V1 <= V1
V2 < V1 && V1 <= V2
V2 < V1 && V2 < V1
V2 < V1 && V2 < V2
V2 < V1 && V2 <= V1
V2 < V1 && V2 <= V2
V2 < V1 or V1 < V1
V2 < V1 or V1 < V2
V2 < V1 or V1 <= V1
V2 < V1 or V1 <= V2
V2 < V1 or V2 < V1
V2 < V1 or V2 < V2
V2 < V1 or V2 <= V1
V2 < V1 or V2 <= V2
V2 < V2 && V1 < V1
V2 < V2 && V1 < V2
V2 < V2 && V1 <= V1
V2 < V2 && V1 <= V2
V2 < V2 && V2 < V1
V2 < V2 && V2 < V2
V2 < V2 && V2 <= V1
V2 < V2 && V2 <= V2
V2 < V2 or V1 < V1
V2 < V2 or V1 < V2
V2 < V2 or V1 <= V1
V2 < V2 or V1 <= V2
V2 < V2 or V2 < V1
V2 < V2 or V2 < V2
V2 < V2 or V2 <= V1
V2 < V2 or V2 <= V2
V2 <= V1 && V1 < V1
V2 <= V1 && V1 < V2
V2 <= V1 && V1 <= V1
V2 <= V1 && V1 <= V2
V2 <= V1 && V2 < V1
V2 <= V1 && V2 < V2
V2 <= V1 && V2 <= V1
V2 <= V1 && V2 <= V2
V2 <= V1 or V1 < V1
V2 <= V1 or V1 < V2
V2 <= V1 or V1 <= V1
V2 <= V1 or V1 <= V2
V2 <= V1 or V2 < V1
V2 <= V1 or V2 < V2
V2 <= V1 or V2 <= V1
V2 <= V1 or V2 <= V2
V2 <= V2 && V1 < V1
V2 <= V2 && V1 < V2
V2 <= V2 && V1 <= V1
V2 <= V2 && V1 <= V2
V2 <= V2 && V2 < V1
V2 <= V2 && V2 < V2
V2 <= V2 && V2 <= V1
V2 <= V2 && V2 <= V2
V2 <= V2 or V1 < V1
V2 <= V2 or V1 < V2
V2 <= V2 or V1 <= V1
V2 <= V2 or V1 <= V2
V2 <= V2 or V2 < V1
V2 <= V2 or V2 < V2
V2 <= V2 or V2 <= V1
V2 <= V2 or V2 <= V2
V1 < V1 && V1 < V1 && V1 < V1
V1 < V1 && V1 < V1 && V1 < V2
V1 < V1 && V1 < V1 && V1 <= V1
V1 < V1 && V1 < V1 && V1 <= V2
[/spoiler] Y sigue. ¿Errores? Si no aviso, es que no veo.
1880  Programación / Programación General / (Resuelto): Errores en generador de sentencias condicionales. en: 18 Agosto 2018, 04:21 am
EDIT:
Solución en el 2ndo post. Dejo el tema por si a alguno le interesa, pero si quieren bórrenlo o ciérrenlo.

El resultado que intenté obtener sería así:
Citar
V1 < V1
V1 < V2
V1 <= V1
V1 <= V2
V1 == V1
V1 == V2
V1 != V1
V1 != V2
V1 < V1
V2 < V1
V1 <= V1
V2 <= V1
V2 < V1
V2 < V2
V2 <= V1
V2 <= V2
V2 == V1
V2 == V2
V2 != V1
V2 != V2
V1 < V2
V2 < V2
V1 <= V2
V2 <= V2

24
2 variables * 6 símbolos * 2 variables

V1 < V1 && V1 < V1
V1 < V1 && V1 < V2
V1 < V1 && V1 < V3
V1 < V1 && V1 < V4
V1 < V1 && V1 <= V1
V1 < V1 && V1 <= V2
V1 < V1 && V1 <= V3
V1 < V1 && V1 <= V4
V1 < V1 && V1 == V1
V1 < V1 && V1 == V2
V1 < V1 && V1 == V3
V1 < V1 && V1 == V4
V1 < V1 && V1 != V1
V1 < V1 && V1 != V2
V1 < V1 && V1 != V3
V1 < V1 && V1 != V4
V1 < V1 && V1 < V1
V1 < V1 && V2 < V1
V1 < V1 && V3 < V1
V1 < V1 && V4 < V1
V1 < V1 && V1 <= V1
V1 < V1 && V2 <= V1
V1 < V1 && V3 <= V1
V1 < V1 && V4 <= V1
V1 < V1 && V2 < V1
V1 < V1 && V2 < V2
V1 < V1 && V2 < V3
V1 < V1 && V2 < V4
V1 < V1 && V2 <= V1
V1 < V1 && V2 <= V2
V1 < V1 && V2 <= V3
V1 < V1 && V2 <= V4
V1 < V1 && V2 == V1
V1 < V1 && V2 == V2
V1 < V1 && V2 == V3
V1 < V1 && V2 == V4
V1 < V1 && V2 != V1
V1 < V1 && V2 != V2
V1 < V1 && V2 != V3
V1 < V1 && V2 != V4
V1 < V1 && V1 < V2
V1 < V1 && V2 < V2
V1 < V1 && V3 < V2
V1 < V1 && V4 < V2
V1 < V1 && V1 <= V2
V1 < V1 && V2 <= V2
V1 < V1 && V3 <= V2
V1 < V1 && V4 <= V2
V1 < V1 && V3 < V1
V1 < V1 && V3 < V2
V1 < V1 && V3 < V3
V1 < V1 && V3 < V4
V1 < V1 && V3 <= V1
V1 < V1 && V3 <= V2
V1 < V1 && V3 <= V3
V1 < V1 && V3 <= V4
V1 < V1 && V3 == V1
V1 < V1 && V3 == V2
V1 < V1 && V3 == V3
V1 < V1 && V3 == V4
V1 < V1 && V3 != V1
V1 < V1 && V3 != V2
V1 < V1 && V3 != V3
V1 < V1 && V3 != V4
V1 < V1 && V1 < V3
V1 < V1 && V2 < V3
V1 < V1 && V3 < V3
V1 < V1 && V4 < V3
V1 < V1 && V1 <= V3
V1 < V1 && V2 <= V3
V1 < V1 && V3 <= V3
V1 < V1 && V4 <= V3
V1 < V1 && V4 < V1
V1 < V1 && V4 < V2
V1 < V1 && V4 < V3
V1 < V1 && V4 < V4
V1 < V1 && V4 <= V1
V1 < V1 && V4 <= V2
V1 < V1 && V4 <= V3
V1 < V1 && V4 <= V4
V1 < V1 && V4 == V1
V1 < V1 && V4 == V2
V1 < V1 && V4 == V3
V1 < V1 && V4 == V4
V1 < V1 && V4 != V1
V1 < V1 && V4 != V2
V1 < V1 && V4 != V3
V1 < V1 && V4 != V4
V1 < V1 && V1 < V4
V1 < V1 && V2 < V4
V1 < V1 && V3 < V4
V1 < V1 && V4 < V4
V1 < V1 && V1 <= V4
V1 < V1 && V2 <= V4
V1 < V1 && V3 <= V4
V1 < V1 && V4 <= V4
V1 < V1 or V1 < V1
V1 < V1 or V1 < V2
V1 < V1 or V1 < V3
V1 < V1 or V1 < V4
V1 < V1 or V1 <= V1
V1 < V1 or V1 <= V2
V1 < V1 or V1 <= V3
V1 < V1 or V1 <= V4
V1 < V1 or V1 == V1
V1 < V1 or V1 == V2
V1 < V1 or V1 == V3
V1 < V1 or V1 == V4
V1 < V1 or V1 != V1
V1 < V1 or V1 != V2
V1 < V1 or V1 != V3
V1 < V1 or V1 != V4
V1 < V1 or V1 < V1
V1 < V1 or V2 < V1
V1 < V1 or V3 < V1
V1 < V1 or V4 < V1
V1 < V1 or V1 <= V1
V1 < V1 or V2 <= V1
V1 < V1 or V3 <= V1
V1 < V1 or V4 <= V1
V1 < V1 or V2 < V1
V1 < V1 or V2 < V2
V1 < V1 or V2 < V3
V1 < V1 or V2 < V4
V1 < V1 or V2 <= V1
V1 < V1 or V2 <= V2
V1 < V1 or V2 <= V3
V1 < V1 or V2 <= V4
V1 < V1 or V2 == V1
V1 < V1 or V2 == V2
V1 < V1 or V2 == V3
V1 < V1 or V2 == V4
V1 < V1 or V2 != V1
V1 < V1 or V2 != V2
V1 < V1 or V2 != V3
V1 < V1 or V2 != V4
V1 < V1 or V1 < V2
V1 < V1 or V2 < V2
V1 < V1 or V3 < V2
V1 < V1 or V4 < V2
V1 < V1 or V1 <= V2
V1 < V1 or V2 <= V2
V1 < V1 or V3 <= V2
V1 < V1 or V4 <= V2
V1 < V1 or V3 < V1
V1 < V1 or V3 < V2
V1 < V1 or V3 < V3
V1 < V1 or V3 < V4
V1 < V1 or V3 <= V1
V1 < V1 or V3 <= V2
V1 < V1 or V3 <= V3
V1 < V1 or V3 <= V4
V1 < V1 or V3 == V1
V1 < V1 or V3 == V2
V1 < V1 or V3 == V3
V1 < V1 or V3 == V4
V1 < V1 or V3 != V1
V1 < V1 or V3 != V2
V1 < V1 or V3 != V3
V1 < V1 or V3 != V4
V1 < V1 or V1 < V3
V1 < V1 or V2 < V3
V1 < V1 or V3 < V3
V1 < V1 or V4 < V3
V1 < V1 or V1 <= V3
V1 < V1 or V2 <= V3
V1 < V1 or V3 <= V3
V1 < V1 or V4 <= V3
V1 < V1 or V4 < V1
V1 < V1 or V4 < V2
V1 < V1 or V4 < V3
V1 < V1 or V4 < V4
V1 < V1 or V4 <= V1
V1 < V1 or V4 <= V2
V1 < V1 or V4 <= V3
V1 < V1 or V4 <= V4
V1 < V1 or V4 == V1
V1 < V1 or V4 == V2
V1 < V1 or V4 == V3
V1 < V1 or V4 == V4
V1 < V1 or V4 != V1
V1 < V1 or V4 != V2
V1 < V1 or V4 != V3
V1 < V1 or V4 != V4
V1 < V1 or V1 < V4
V1 < V1 or V2 < V4
V1 < V1 or V3 < V4
V1 < V1 or V4 < V4
V1 < V1 or V1 <= V4
V1 < V1 or V2 <= V4
V1 < V1 or V3 <= V4
V1 < V1 or V4 <= V4

192
1 * 1 * 1 * 2 * 4 * 6 * 4
Luego variarían las cosas que están en la izquierda, o sea, así debería ser:
4 * 6 * 4 * 2 * 4 * 6 * 4

Luego se agregarían partes, como ya se ha visto.
V1 < V1 && V1 < V1 or V1 < V1
V1 < V1 && V1 < V1 or V1 < V2
V1 < V1 && V1 < V1 or V1 < V3
etc.
6 * 6 * 6 * 2 * 6 * 6 * 6 * 2 * 6 * 6 * 6

NOTA: Luego del símbolo "!=" viene ">" y luego "=>" pero yo los invertí ("<" y "<=") y también al orden de las variables. Puede ser confuso a la vista pero no hay problema con eso.

Esto es lo que obtuve:
Citar
V1 < V1
(ok)
V2 <= V2
V1 < V1 && V1 < V1
(ok)
V1 < V1 && V4 <= V4
V1 < V1 or V1 < V1
V1 < V2 or V1 < V1
V1 < V3 or V1 < V1
V1 < V4 or V1 < V1
(eso está mal)
V4 <= V4 or V1 < V1
V1 < V1 && V1 < V1 or V1 < V1
(esto está mal también)
El 1er error es que se salteó las combinaciones
V1 < V2 && V1 < V1
V1 < V3 && V1 < V1
V1 < V4 && V1 < V1
O sea, es como si hubiera hecho
1111464
1112111
1122111
1132111
1142111
o sea... en el 1er número, desde el 2 todo estaba al máximo, como si fuese
1119999
pero en vez de hacer
1112111
1112112
1112113
1112114
aumentó las cosas de la izquierda.

El 2ndo error es que pasó de
4642111
a
11111112111

Es horroroso. Es más o menos como si hubiese hecho
9999111
10090000
O sea se salteó cosas y no reseteó un número. Son 2 errores. Debería ser
4642464
11111111111

Este es el código (action script de Macromedia Flash 5 if that really matters)
Código:
Escena 1
   actions for fotograma 1
      // Subcondiciones en la condición.
      SCs = 1;
      // Valores de las partes de la SC.
      SC1P1 = 1;
      SC1P2 = 1;
      SC1P3 = 0;
      // Cosas para evitar ifs.
      Op1 = " < ";
      Op2 = " <= ";
      Op3 = " == ";
      Op4 = " != ";
      Op5 = " > ";
      Op6 = " => ";
      Rel1 = " && ";
      Rel2 = " or ";
      Cursor1 = 1;
      Cursor2 = 3;
      function PrintCond () {
         Cursor3 = 1;
         Print = "";
         while (Cursor3<SCs) {
            if (eval("SC"+Cursor3+"P2")<5) {
               Print = "V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3")+eval("Rel"+eval("SC"+Cursor3+"P4"))+Print;
            } else {
               Print = "V"+eval("SC"+Cursor3+"P3")+eval("Op"+(eval("SC"+Cursor3+"P2")-4))+"V"+eval("SC"+Cursor3+"P1")+eval("Rel"+eval("SC"+Cursor3+"P4"))+Print;
            }
            Cursor3 = Cursor3+1;
         }
         if (eval("SC"+Cursor3+"P2")<5) {
            Print = Print+"V"+eval("SC"+Cursor3+"P1")+eval("Op"+eval("SC"+Cursor3+"P2"))+"V"+eval("SC"+Cursor3+"P3");
         } else {
            Print = Print+"V"+eval("SC"+Cursor3+"P3")+eval("Op"+(eval("SC"+Cursor3+"P2")-4))+"V"+eval("SC"+Cursor3+"P1");
         }
         trace (Print);
      }
   actions for fotograma 2
      if (Cursor2 == 1 or Cursor2 == 3) {
         MaxValor = SCs*2;
      } else if (Cursor2 == 2) {
         MaxValor = 6;
      } else {
         MaxValor = 2;
      }
      if (eval("SC"+Cursor1+"P"+Cursor2)<MaxValor) {
         set ("SC"+Cursor1+"P"+Cursor2, eval("SC"+Cursor1+"P"+Cursor2)+1);
         PrintCond();
         Cursor2 = 3;
      } else {
         set ("SC"+Cursor1+"P"+Cursor2, 1);
         if (Cursor2>1) {
            Cursor2 = Cursor2-1;
         } else if (Cursor1>1) {
            Cursor1 = Cursor1-1;
            Cursor2 = 4;
         } else {
            set ("SC"+SCs+"P4", 1);
            SCs = SCs+1;
            Cursor1 = SCs;
            Cursor2 = 3;
            set ("SC"+SCs+"P1", 1);
            set ("SC"+SCs+"P2", 1);
            set ("SC"+SCs+"P3", 1);
            PrintCond();
         }
      }
   actions for fotograma 3
      gotoAndPlay (2);
Lo voy a revisar pero si alguien ve fácil cómo corregirlo, bien por él. Y si me dice acá pronto cómo se haría dicha corrección, buenísimo.
Páginas: 1 ... 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 [188] 189 190 191 192
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines