Foro SofosAgora

Foro abierto a los intereses de sus usuarios. Debate, aprende y diviértete.
Fecha actual 14 Dic 2018, 01:15

Todos los horarios son UTC + 1 hora [ DST ]




Nuevo tema Responder al tema  [ 17 mensajes ]  Ir a página Anterior  1, 2
Autor Mensaje
NotaPublicado: 23 Nov 2018, 01:23 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8717
No puedo ver la 1era, pero la 2nda, jajajaja.

Puede ser el caso o puede que me estés ofreciendo algo que no encaja conmigo. Quizá nunca lo sabremos, aunque tú creas que sí lo sabes.

Simplifiqué el código:
Imagen
Con diagrama de flujo sería más fácil entender, pero los tengo en papel, no tengo ganas de hacerlo en compu. Basicamente en el frame 5 se hacía lo mismo que en el 3, así que lo que estaba en el 6 lo puse en el 5 y así sucesivamente.

El error no lo corregí aún, sólo puse unos ifs... A ver, necesito que quede marcado cual será el último experimento del largo que se esté manejando. Para eso se analiza cual es el ítem más "alto" usado (no es exactamente el más alto, creo que ya expliqué eso) y se le va sumando 1 salvo al último caracter. Supongamos que el más alto es 5 y el largo es 3. Lo que sucederá es que el último exp será 566 . Eso genera un error porque el 1er exp que se probará con ese largo es 561, luego 562 y así sucesivamente hasta 566 por lo que el programa creerá que los probó todos. ¿Solución? El 1er exp DEBE tener todos los ítems diferentes si es posible, y el último exp debe ser eso -1. En general, dejar el último caracter igual al último logra eso, ejemplos:
122 es menor a 123
233 es menor a 234
etc
Pero claro, si los 2 últimos son 66 ya no sirve, yo lo que hacía era:
566 es el último exp, 561 es el 1ero,
pero debería hacer
556 es el último exp, 561 es el 1ero.
Para eso, cuando el último exp sea 566 (porque con el método que uso el último queda igual que el penúltimo, es fácil hacerlo así), tengo que restarle 1 al penúltimo caracter.

Lo que hice por ahora es convertir la terminación 66 en 61 y que el 1er exp sea 62. Hice eso porque pensé que podría ser complicado restar 1 porque si la terminación es 611 tengo que hacer 2 restas a 2 caracteres. Basicamente tengo que hacer un proceso inverso al que usaba, en vez de sumar y resetear cuando pasean el máximo, tengo que restar y maximizar cuando bajan del mínimo. Algún día haré eso.

Otra cosa que me interesa es aumentar la cantidad de números (fácil, pero por ahora estoy probando con 6 para ver que los resets funcionen bien) y que se pruebes más variedad de ítems en menos tiempo. Actualmente, como el error no está del todo corregido, el ítem 1 queda para el final más veces que los demás. Pero ese no es el mayor problema. Actualmente, el programa puede mostrar esto:
WispG
Creativo: ShadeG DryadG
ShadeG
ShadeG AuraG
Creativo: SalaG GnomeG ShadeG
DryadG
ShadeG SalaG
SalaG GnomeG DryadG
Creativo: AuraG SalaG GnomeG ShadeG
AuraG
ShadeG GnomeG
SalaG GnomeG AuraG
AuraG SalaG GnomeG DryadG
Creativo: AuraG SalaG GnomeG WispG ShadeG
etc

Rojo:
A sabiendas de que ShadeG será probado pronto (es "2", y se acaba de probar "1"), se debería probar otra cosa. Eso requiere un cálculo del que hablé en otro tema y como no quise complicarme más, porque tenía errores, lo dejé, pero voy a retomarlo.

Amarillo:
Debería ser WispG. Esto está mal porque la corrección que hice no fue la ideal. Es decir, logré que el programa haga todas las combinaciones, antes podía haber un error, pero ahora no empieza con el que yo quisiera. Lo corregiré.

El problema del cálculo es que "Creative" puede variar cuando ocurre.


Nil ¿conoces un programa que haga las "fechas" o rondas de un campeonato de todos contra todos? Por ejemplo si tienes A, B, C, D, E y F:
1era fecha
A vs B
C vs D
E vs F
2nda
A vs C
B vs D
¿y ahora? Ves que ahí está mal porque sólo quedan E y F pero ya jugaron. Más o menos sé cómo hacerlo bien. Bueno, en este tema lo que estoy haciendo es parecido pero suponte que los equipos se pudieran enfrentar de a 3, 4, etc, todos en la misma cancha. Sería algo así:
1era fecha (máximo 1 en la cancha, suponte que es como un contrareloj)
A
2nda fecha (máximo 2 en la cancha)
B
CD
3era fecha (máximo 3)
E
FA
BCE
etc. No fue BCD porque CD ya participaron, o sea, el partido es diferente y se hará, pero queremos obtener variedad en principio. Bueno Nil, todo eso es muy bonito, pero no sé cómo hacerlo. Lo que yo hago tiene menos variedad...

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


Arriba
 Perfil  
Responder citando  
NotaPublicado: 23 Nov 2018, 16:20 
Desconectado
Avatar de Usuario

Registrado: 28 Ene 2015, 21:06
Mensajes: 444
Programando y estudiando. Desarrollar la capacidad para solucionar problemas, que es en última instancia lo más importante. Siempre intentá solucionar problemas que no estás acostumbrado o no son fáciles de solucionar. Es importante salir de la zona de confort, de esa manera vas adquiriendo versatilidad e intuición. La sintaxis y la semántica, el lenguaje y todo lo demás es en cierta medida irrelevante si no tenés lo primero.

Saber matemáticas ayuda muchísimo en cuanto a eficiencia y optimización.

En cualquier caso vas a tener que trabajar mucho.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 23 Nov 2018, 22:57 
Desconectado
Avatar de Usuario

Registrado: 10 Jun 2011, 21:52
Mensajes: 4549
Remotamente relacionado: https://blog.openai.com/spinning-up-in-deep-rl/

_________________
Spoiler: show
Imagen


Arriba
 Perfil  
Responder citando  
NotaPublicado: 25 Nov 2018, 10:15 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8717
https://foro.elhacker.net/programacion_ ... 011.0.html

Ok Agu, ahora dime algo más personalizado. Mira mi código y dime qué te parece mal, no sé. Voy a terminar haciendo un diagrama de flujo por computadora para mostrar mejor todo esto, porque me tiene harto. Es como que estoy poniendo demasiados parches, excepciones a reglas, ifs.

Nil: Tanto que te gusta aprender y aún no aprendiste que no quiero hacer cursos... Quiero las soluciones específicas.

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


Arriba
 Perfil  
Responder citando  
NotaPublicado: 25 Nov 2018, 10:21 
Desconectado

Registrado: 05 Mar 2013, 14:43
Mensajes: 10472
Pero tachi, llega un punto donde darte una solución especifica implica que le pagués a la otra persona.

Lo que tienes que hacer es aprender a programar desde 0, otra vez pero esta vez de manera seria, y luego ser capaz de plantear tus problemas a los demás programadores en internet o donde sea de tal manera que le sea facil responderte.

Saber pasar de un ejemplo universal a uno particular o viceversa es la capacidad que tienes que alcanzar como programador.


Pero no querés hacer nada de eso, entonces, date cuenta que estás queriendo hacer cosas que realmente no querés.

Uno siempre desea algo, pero ese deseo no está muy claro. Tal vez lo que realmente deseas no es crear un programa, es hacer algo que ese programa te dará pero que podrías alcanzarlo de otra manera...


Arriba
 Perfil  
Responder citando  
NotaPublicado: 25 Nov 2018, 14:18 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8717
Mal dormido no estoy como para responder, será en otra ocasión. Pero tengo ganas de pensar acá, ya que eso ayuda (aunque me esté comportando como un salieri o telegramon), mis vecinos se han callado y estoy medio furioso.

Tengo problemas con esto (y con otra cosa muy similar):
Código:
         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.
               // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
               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);
         if ( NextRecentItem == 6 ) {
            NextRecentItem = 1;
         }
         set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
         set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
Actualmente, el último número de la combinación que se cree ahí será igual al penúltimo salvo que ese sea 6, en cuyo caso el último cambia a 1. Eso es para corregir un error en el que se supone que es el modo más simple de crear una combinación como quiero.
Pero como expliqué en otro post, esa corrección no está del todo bien. Lo que debo hacer, creo, es que si el penúltimo no es 6, el último es igual, pero si el penúltimo es 6 entonces cambia a 5 y el último queda en 6. Es difícil explicar por qué debe ser así, ni yo estoy seguro de si eso es correcto. Pero lo expliqué en otro post, asumo que está bien y sino me daré cuenta luego.

El do while hace desde el 1er número hasta el penúltimo, y fuera del while se genera el último. Nunca necesita generar combinaciones de 1 sólo número, así que no hay problema. Si lo necesitara sería un problema porque genera el 1ero y luego otro, pero eso no puede ser porque sólo se quiere 1.
Ahora, necesitaría que genere sólo hasta el antepenúltimo, lo cual es fácil pero si la combinación fuese de 2 números el proceso fallaría porque ahora el mínimo de números creados es 3: En el while 1 como mínimo, y fuera el penúltimo y el último.

Entonces según pensé, tengo que poner un if para que en caso de necesitarse un largo 2 (que es sólo una vez), haga algo distinto. Pero un if sólo por eso me parece mal.

Otra alternativa que se me acaba de ocurrir es que el while haga hasta el penúltimo y que luego lo modifique si es necesario. Eso me parece un tanto tonto ¿por qué no darle el valor correcto desde el inicio? Pero bueno, de momento es lo que haré. A ver:
Código:
         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.
               // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
               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);
         // Evitar el error "maxmax".
         if ( NextRecentItem != 6 ) {
            // El último char queda igual al penúltimo.
            set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
            set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
         } else {
            // El penúltimo char queda como 5.
            set ("L"+ClasicMaxL+"P"+(Cursor-1), NextRecentItem);
            set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
Waaaack, olvidé una cosa: Eso último es una concatenación de las partes, no me sirve modificarla por fuera si no corrijo eso cosa que es difícil y no debería tener que ocurrir. Tampoco usar 2 whiles.

Joder...

Una posible solución es usar un while en vez de un do while, pero tendría 1 condición extra, es peor que poner un if afuera.

Supongo que hay que programar como salga y luego sí intentar que no haya tonterías, pero bueno uno busca hacerlo bien desde el inicio.

¿Entendieron más o menos? Yo no mucho. Así como acababa de olvidar una cosa, si paso un tiempo sin pensar en esto se me olvidan otras.

Da la sensación de que hay un método más sencillo, que no requiere semejantes parches. Pero yo que sé cual será.


Código:
Se comienza la concatenación de la combinación a crear. Esto es necesario para marcar cual es la última combinación que se hará con el largo de números que tenga. De momento no quiero pensar si hay otra manera, quiero concentrarme en qué hacer con lo que ya tengo.
En definitiva: set ("LastL"+ClasicMaxL, "");

Luego se elige el 1er número de la combinación a crear.
Lo concatenamos.
[s]Repetimos eso para los números hasta llegar al antepenúltimo inclusive, si es que hay. Uf. Malditos ifs. O debería decir condenados, inevitables. Vale:
[/s]Si la combinación tiene largo 3 o más,
    repetir lo anterior hasta el antepenúltimo inclusive.
    Elegir el penúltimo número de la combinación a crear.
    Si dicho número no es 6
        Concatenarlo.
        El último número es igual al penúltimo.
    sino       
        Convertirlo en 5.
        Concatenarlo.
        El último número es 6.
    fin del si
    Concatenar el último número
sino (es de largo 2, menos no es posible)
    Si dicho número no es 6
        Concatenarlo.
        El último número es igual al penúltimo.
    sino       
        Convertirlo en 5.
        Concatenarlo.
        El último número es 6.
    fin del si
    Concatenar el último número
Supongo que puede simplificarse así:
Código:
set ("LastL"+ClasicMaxL, "");

Luego se elige el 1er número de la combinación a crear.
Lo concatenamos.
Si la combinación tiene largo 3 o más,
    repetir lo anterior hasta el antepenúltimo inclusive.
    Elegir el penúltimo número de la combinación a crear.
Si dicho número no es 6
    Concatenarlo.
    El último número es igual al penúltimo.
sino       
    Convertirlo en 5.
    Concatenarlo.
    El último número es 6.
Concatenar el último número
En el AS que uso sería... un poco diferente. No se puede crear 1 y en un caso repetir y en otro no, conviene más que en un caso haga X y en otro nada (sé que suena raro pero parece ser así).
Código:
   set ("LastL"+ClasicMaxL, "");
      Cursor = 1;
      // Cálculo del ítem más recientemente usado.
      NextRecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL);
      if (3<ClasicMaxL) {
         // Preparar exp y last hasta el antepenúltimo char.
         do {
            NextRecentItem = NextRecentItem+1;
            if (6<NextRecentItem) {
               // Si resulta un ítem inexistente, arreglarlo.
               // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
               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-1);
      }
      // Sino nada, porque debe crearse hasta el antepenúltimo...
      // ... pero en este caso no hay.
      // Evitar el error "maxmax": Penúltimo char.
      NextRecentItem = NextRecentItem+1;
      if (6<NextRecentItem) {
         // Si resulta un ítem inexistente, arreglarlo.
         // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
         NextRecentItem = NextRecentItem-((Math.floor(NextRecentItem/6))*6);
      }
      if ( NextRecentItem != 6 ) {
         // El penúltimo char se define normal.
         set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
         set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+"
         // El último char queda igual al penúltimo.
         Cursor = Cursor+1;
         set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
");
      } else {
         // El penúltimo char cambia a 5.
         set ("L"+ClasicMaxL+"P"+(Cursor-1), 5);
         set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+"
         // El último char es 6.
         Cursor = Cursor+1;
         set ("L"+ClasicMaxL+"P"+Cursor, 6);
         set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+eval("Item"+NextRecentItem)+" ");
      }
Ahora quiero irme a un sitio así que no lo probaré aún, pero teóricamente ya está...
Luego me falta corregir una parte muy similar, sería una corrección similar...

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


Arriba
 Perfil  
Responder citando  
NotaPublicado: 28 Nov 2018, 23:42 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8717
Si la lista a producir fuese:
1
2
3 1
3
3 2
3 1 2
etc
...¿Alguien nota un error en esta?
Spoiler: show
1
2
3 1
3
3 2
3 1 2
3 3
3 1 3
1 2 3 1
1 1
3 2 1
1 2 3 2
3 1 2 3 1
1 2
3 2 2
1 2 3 3
3 1 2 3 2
3 1 2 3 1 2
1 3
3 2 3
1 3 1 1
3 1 2 3 3
3 1 2 3 1 3
1 2 3 1 2 3 1
2 1
3 3 1
1 3 1 2
3 1 3 1 1
3 1 2 3 2 1
1 2 3 1 2 3 2
3 1 2 3 1 2 3 1
2 2
3 3 2
1 3 1 3
3 1 3 1 2
3 1 2 3 2 2
1 2 3 1 2 3 3
3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2
2 3
3 3 3
1 3 2 1
3 1 3 1 3
3 1 2 3 2 3
1 2 3 1 3 1 1
3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1
1 1 1
1 3 2 2
3 1 3 2 1
3 1 2 3 3 1
1 2 3 1 3 1 2
3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1
1 1 2
1 3 2 3
3 1 3 2 2
3 1 2 3 3 2
1 2 3 1 3 1 3
3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2
1 1 3
1 3 3 1
3 1 3 2 3
3 1 2 3 3 3
1 2 3 1 3 2 1
3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1
1 2 1
1 3 3 2
3 1 3 3 1
3 1 3 1 1 1
1 2 3 1 3 2 2
3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1
1 2 2
1 3 3 3
3 1 3 3 2
3 1 3 1 1 2
1 2 3 1 3 2 3
3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 3 2
1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
1 2 3
2 1 1 1
3 1 3 3 3
3 1 3 1 1 3
1 2 3 1 3 3 1
3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 3 3
1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
1 3 1
2 1 1 2
3 2 1 1 1
3 1 3 1 2 1
1 2 3 1 3 3 2
3 1 2 3 1 3 3 1
3 1 2 3 1 3 1 1 1
1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
1 3 2
2 1 1 3
3 2 1 1 2
3 1 3 1 2 2
1 2 3 1 3 3 3
3 1 2 3 1 3 3 2
3 1 2 3 1 3 1 1 2
1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 3 2
1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
1 3 3
2 1 2 1
3 2 1 1 3
3 1 3 1 2 3
1 2 3 2 1 1 1
3 1 2 3 1 3 3 3
3 1 2 3 1 3 1 1 3
1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 3 3
1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 1 1
2 1 2 2
3 2 1 2 1
3 1 3 1 3 1
1 2 3 2 1 1 2
3 1 2 3 2 1 1 1
3 1 2 3 1 3 1 2 1
1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 3 1 1 1
1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 1 2
2 1 2 3
3 2 1 2 2
3 1 3 1 3 2
1 2 3 2 1 1 3
3 1 2 3 2 1 1 2
3 1 2 3 1 3 1 2 2
1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 3 1 1 2
1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 3 2
1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
2 1 3
2 1 3 1
3 2 1 2 3
3 1 3 1 3 3
1 2 3 2 1 2 1
3 1 2 3 2 1 1 3
3 1 2 3 1 3 1 2 3
1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 3 1 1 3
1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 2 3 3 3
1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 2 1
2 1 3 2
3 2 1 3 1
3 1 3 2 1 1
1 2 3 2 1 2 2
3 1 2 3 2 1 2 1
3 1 2 3 1 3 1 3 1
1 2 3 1 2 3 2 1 1 2
3 1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 3 1 2 1
1 2 3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 3 1 1 1
1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 2 2
2 1 3 3
3 2 1 3 2
3 1 3 2 1 2
1 2 3 2 1 2 3
3 1 2 3 2 1 2 2
3 1 2 3 1 3 1 3 2
1 2 3 1 2 3 2 1 1 3
3 1 2 3 1 2 3 2 1 1 2
3 1 2 3 1 2 3 1 3 1 2 2
1 2 3 1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 2 3 1 3 1 1 2
1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
2 2 3
2 2 1 1
3 2 1 3 3
3 1 3 2 1 3
1 2 3 2 1 3 1
3 1 2 3 2 1 2 3
3 1 2 3 1 3 1 3 3
1 2 3 1 2 3 2 1 2 1
3 1 2 3 1 2 3 2 1 1 3
3 1 2 3 1 2 3 1 3 1 2 3
1 2 3 1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 2 3 1 3 1 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 3 1
2 2 1 2
3 2 2 1 1
3 1 3 2 2 1
1 2 3 2 1 3 2
3 1 2 3 2 1 3 1
3 1 2 3 1 3 2 1 1
1 2 3 1 2 3 2 1 2 2
3 1 2 3 1 2 3 2 1 2 1
3 1 2 3 1 2 3 1 3 1 3 1
1 2 3 1 2 3 1 2 3 2 1 1 2
3 1 2 3 1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 2 3 1 3 1 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 3 2
2 2 1 3
3 2 2 1 2
3 1 3 2 2 2
1 2 3 2 1 3 3
3 1 2 3 2 1 3 2
3 1 2 3 1 3 2 1 2
1 2 3 1 2 3 2 1 2 3
3 1 2 3 1 2 3 2 1 2 2
3 1 2 3 1 2 3 1 3 1 3 2
1 2 3 1 2 3 1 2 3 2 1 1 3
3 1 2 3 1 2 3 1 2 3 2 1 1 2
3 1 2 3 1 2 3 1 2 3 1 3 1 2 2
1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
2 3 3
2 2 2 1
3 2 2 1 3
3 1 3 2 2 3
1 2 3 2 2 1 1
3 1 2 3 2 1 3 3
3 1 2 3 1 3 2 1 3
1 2 3 1 2 3 2 1 3 1
3 1 2 3 1 2 3 2 1 2 3
3 1 2 3 1 2 3 1 3 1 3 3
1 2 3 1 2 3 1 2 3 2 1 2 1
3 1 2 3 1 2 3 1 2 3 2 1 1 3
3 1 2 3 1 2 3 1 2 3 1 3 1 2 3
1 2 3 1 2 3 1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
3 1 1
2 2 2 2
3 2 2 2 1
3 1 3 2 3 1
1 2 3 2 2 1 2
3 1 2 3 2 2 1 1
3 1 2 3 1 3 2 2 1
1 2 3 1 2 3 2 1 3 2
3 1 2 3 1 2 3 2 1 3 1
3 1 2 3 1 2 3 1 3 2 1 1
1 2 3 1 2 3 1 2 3 2 1 2 2
3 1 2 3 1 2 3 1 2 3 2 1 2 1
3 1 2 3 1 2 3 1 2 3 1 3 1 3 1
1 2 3 1 2 3 1 2 3 1 2 3 2 1 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 2 1 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 3 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 2 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 3 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 3 1 1
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2 1
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 2
3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1
2 2 2 3
Sino funciona bien.
- La lista fue detenida, sino no termina.
- cambié los ítems por números
- el límite de 6 a 3
- quité el uso del método Creative.

Todo para que sea más fácil detectar un posible error.

Lo importante es que todas las combinaciones se produzcan y sin repetirse (y que sigan cierto orden de aparición).

Las de largo 1 se producen:
1
2
3

Las de 2:
3 1
3 2
3 3
1 1
1 2
1 3
2 1
2 2
2 3

Las de 3:
3 1 2
3 1 3
3 2 1
3 2 2
3 2 3
3 3 1
3 3 2
3 3 3
1 1 1
1 1 2
1 1 3
1 2 1
1 2 2
1 2 3
1 3 1
1 3 2
1 3 3
2 1 1
2 1 2
2 1 3
2 2 1
2 2 2
2 2 3
2 3 1
2 3 2
2 3 3
3 1 1

Las demás ni siquiera están todas en la lista. Puedo hacer que sólo aparezcan las de 4, o 5, etc, pero en el fondo nunca voy a saber si en algún punto habrá un error. Lo dejo así, casi un "si Dios quiere".

El código:
Código:
Escena 1
   actions for fotograma 1
      // Parte 1 del experimento de largo 1.
      L1P1 = 0;
      // Último experimento de largo 1 que se hará.
      LastL1 = "3 ";
      // Ú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("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)<3) {
         // 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 (5);
      }
   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;
         // Prueba aumentar el nuevo char señalado.
         gotoAndPlay (3);
      } else {
         // Sino, se muestra el reseteado.
         Concatenarytrace();
         gotoAndPlay (5);
      }
   actions for fotograma 5
      // 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 = "F5: 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 = "F5: RecentItem cambiado a "+RecentItem+"\n"+Info;
      }
      if (ClasicActualL<ClasicMaxL) {
         // Si el largo es aumentable, aumenta.
         ClasicActualL = ClasicActualL+1;
         Info = "F5: 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 = "F5: Clasic alcanzó su máximo L: "+ClasicMaxL+"\n"+Info;
         ClasicMaxL = ClasicMaxL+1;
         Info = "F5: 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 = "F5: Clasic llegó a un L mayor que creative: "+ClasicMaxL+" > "+CreativeL+"\n"+Info;
            set ("LastL"+ClasicMaxL, "");
            Cursor = 1;
            // Cálculo del próximo ítem más recientemente usado.
            NextRecentItem = eval("L"+ClasicActualL+"P"+ClasicActualL)+1;
            if (3<NextRecentItem) {
               // Si resulta un ítem inexistente, arreglarlo.
               NextRecentItem = 1;
            }
            if (2<ClasicMaxL) {
               // Preparar exp y last hasta el antepenúltimo char.
               do {
                  NextRecentItem = NextRecentItem+1;
                  if (3<NextRecentItem) {
                     // Si resulta un ítem inexistente, arreglarlo.
                     // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
                     NextRecentItem = NextRecentItem-((Math.floor(NextRecentItem/3))*3);
                  }
                  set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
                  set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+NextRecentItem+" ");
                  Cursor = Cursor+1;
               } while (Cursor<ClasicMaxL-1);
            }
            // Sino nada, porque debe crearse hasta el antepenúltimo...
            // ... pero en este caso no hay.
            // Evitar el error "maxmax": Penúltimo char.
            NextRecentItem = NextRecentItem+1;
            if (3<NextRecentItem) {
               // Si resulta un ítem inexistente, arreglarlo.
               // El cálculo creo que sólo tiene sentido si en vez de aumentar 1 aumenta según rondas.
               NextRecentItem = NextRecentItem-((Math.floor(NextRecentItem/3))*3);
            }
            if (NextRecentItem != 3) {
               // El penúltimo char se define normal.
               set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+NextRecentItem+" ");
               // El último char queda igual al penúltimo.
               Cursor = Cursor+1;
               set ("L"+ClasicMaxL+"P"+Cursor, NextRecentItem);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+NextRecentItem+" ");
            } else {
               // El penúltimo char cambia a 2.
               set ("L"+ClasicMaxL+"P"+Cursor, 2);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+2+" ");
               // El último char es 3.
               Cursor = Cursor+1;
               set ("L"+ClasicMaxL+"P"+Cursor, 3);
               set ("LastL"+ClasicMaxL, eval("LastL"+ClasicMaxL)+3+" ");
            }
         }
         ClasicActualL = ClasicMinL;
         Info = "F5: El siguiente exp de clasic será de Largo "+ClasicMinL+"\n"+Info;
         Info = "F5: Está listo el exp de máx L: "+eval("LastL"+ClasicMaxL)+"\n"+Info;
      }
      gotoAndPlay (2);
Ahora me falta lo del método creative.

Edu escribió:
Pero tachi, llega un punto donde darte una solución especifica implica que le pagués a la otra persona.
Puede ser, pero ¿por qué cuando uno pregunta algo filosófico no se cobra el dar una respuesta y cuando se pide un pseudocódigo, sí?

Citar:
Lo que tienes que hacer es aprender a programar desde 0, otra vez pero esta vez de manera seria, y luego ser capaz de plantear tus problemas a los demás programadores en internet o donde sea de tal manera que le sea facil responderte.
No entiendo la critica. ¿No sé plantear mis dudas de manera que sean fáciles de responder? ¿por qué? Algo más específico que "no sabes programar", please.

Citar:
Saber pasar de un ejemplo universal a uno particular o viceversa es la capacidad que tienes que alcanzar como programador.
Si te refieres a que un programador debe saber poner excepciones en ciertos casos, sí.

Citar:
Pero no querés hacer nada de eso, entonces, date cuenta que estás queriendo hacer cosas que realmente no querés.
Bueno, la verdad el asunto este de "crear experimentos en un orden variado y divertido" me empieza a hartar, pero me servirá para hacer experimentos en el juego (modificación de armas en Legend of Mana de Play), y está vinculado con otras cosas que me interesan, es un entrenamiento interesante.

Citar:
es hacer algo que ese programa te dará pero que podrías alcanzarlo de otra manera...
A ver Edu... En el juego pones ítems en un arma. Dependiendo del orden se causa un resultado u otro. Hay guías, y hay unas reglas, no hay azar, pero sí hay cosas bastante impredecibles y no me gusta confiar en las guías, no es que lo sepan todo, y me gusta averiguar ciertas cosas por mí mismo. Entonces, tengo que probar poner ítems en diferentes órdenes. Para que no sea aburrido (1 y 2, 1 y 3, 1 y 4, etc hasta el 150 ponele) quiero generar una lista con variedad. Eso siempre un programa lo hará más fácil que yo porque yo en cada momento tendría que pensar "a ver cual fue el anterior que probé con ese largo...", y "cómo debe ser el nuevo largo...", y con el tema de "crear nuevo largo si el anterior dió el mejor resultado hasta ahora, sino hacer que tarde más en crearse", tendría que ir contando a ver cuánto tarda. Buscar en listas, escribir cuales probé... Anotar los nombres de los ítems, porque yo de memoria no sé cuales números representarían cada uno.

Además, esto me sirve para juegos que requieran investigaciones similares, como el pokemon. En vez de poner ítems en un orden divertido podría pokemons, ataques, evs, etc. Pero bueno, eso sería mucho más adelante, quizá nunca si hago mis propios juegos en que una IA pueda investigarlos ella misma.

No sé si me explico... si te interesa más jugá Legend of Mana 1 de play y decime cómo sin guías averigarías cómo generar las mejores armas. Está bueno, tenés que hacerte teorías sobre cual es el sistema que se sigue. En guías lo dicen, pero jugá a ver si llegás a las mismas o no.
Eso sí, para tener la opción de modificar armas tenés que cumplir ciertas misiones, puedes tardar horas si no sabes cuales son. Pero el juego está bueno.

_________________
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  [ 17 mensajes ]  Ir a página Anterior  1, 2

Todos los horarios son UTC + 1 hora [ DST ]


¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 1 invitado


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