Reto 1:
Genera una lista así:
1
2
3
4
5
6
1 1
1 2
1 3
1 4
1 5
1 6
2 1
etc
Es como contar pero sólo se usan los números del 1 al 6 y además van separados.


Reto 2:
Genera una lista así:
1
2
3 4
3
3 5
6 7 8
4
3 6
6 7 9
10 11 12 13
etc
La 1era combinación está compuesta de 1 número.
Luego hay otra de 1 número y otra de 2.
Luego otra de 1, de 2, y de 3.
Luego 1, 2, 3, 4.
etc.
En cuanto qué números van en cada una, depende de si el largo de la combinación ya existía o no. Si existía, simplemente se le suma 1 al número final. Si no existía, el 1er número será el mayor que se haya alcanzado hasta ahora, +1.


Reto 3:
Genera una lista así:
1
2
3 4
3
3 5
6 1 2
4
3 6
6 1 3
4 5 6 1
etc
Es como la anterior pero los números van del 1 al 6. Cuando alguno se pasa de 6 vuelve a 1. El considerado máximo número es el último de la combinación que tenga más largo (y se modifica también cuando se está creando una combinación más larga, claro).


Reto 4:
Genera una lista como la anterior pero en la que luego de hacer una combinacion con el método "clásico" (como la lista anterior) se pregunte al usuario si quiere una de un largo aún no alcanzado (método "creativo"). Ej:
1
¿Creativo? Sí. 2 3
2
¿Creativo? No.
2 4
¿Creativo? No.
3
¿Creativo? Sí. 5 6 1.
2 5
etc
El máximo largo del proceso clásico no aumenta porque se creen mayores largos con el proceso creativo, pero si están creados el proceso clásico usa sus números en vez de crearlos.


Reto 5:
Genera una lista como la anterior pero en la cual el máximo de números sea 100 y en los momentos de crear una combinación de nuevo largo no se use el máximo+1 sino... no sé explicarlo pero básicamente el más alejado considerando todos los usados y considerando que forman un circulo (1 está luego de 100, el más alejado de 1 es 50 aproximadamente). Ejemplo aproximado:
1
¿Creativo? Sí. 50 51
2
¿Creativo? Sí. 25 26
25 27
¿Creativo? Sí. 75 76 77
etc
O sea, inicialmente se usa 1 como siempre. Luego lo que esté en medio de 2 y 100, que aproximadamente es 50. Luego 2, clásico. Luego, si se pide creativo o cuando haya que crear, se usa de 3 a 49, o sino de 52 a 100, lo que tenga más cantidad de números. Así sucesivamente. La cantidad de "fragmentos" va aumentando, o sea, 1ero tenemos de 2 a 100. Luego aproximadamente de 2 a 49 y de 51 a 100. Luego de un par de veces tendremos aproximadamente de 1 a 24, de 26 a 49, de 51 a 74, y de 76 a 100.


Yo estoy haciendo algo un poquitito más complicado que el 4. Tengo otro tema creado al respecto, en esta misma sección. Ver cómo harían estas cosas uds me ayudaría. Gracias.

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".
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 >___<

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.

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í:
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:
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)
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.

El texto se ve en la versión japonesa del juego 8 Eyes de NES.

Aquí hay parte:


El resto aquí:
https://www25.atwiki.jp/famicomall/pages/300.html

Hay una versión en inglés del juego pero si uno lee la historia que dice el manual, la wikipedia, y en definitiva todo lo que hallé distinto a japonés, y luego lee la historia que aparece en páginas japonesas (eso no está en una imagen, por eso lo pude traducir con Chrome) nota una diferencia abismal, por lo que la "traducción" que hayan puesto en dicha versión puede que sea distinta a lo que corresponde.

Como dice el título me serviría:
A- Hallar el texto en japonés o pistas para hallarlo, o sea, no en una imagen sino que "normal", cosa de poder copiarlo y pegarlo en un traductor de textos así.
El juego en japonés se escribe:
エイト・アイズ
Usando el traductor lo busqué conjuntamente con "ending", "final", "end", o sea, esas palabras pero en japonés, pero por ahora no hallé lo que busco. (Bastante normal: ¿Quién escribiría el texto si existen las imagenes?).
También usando una página para escribir en japonés escribí parte del texto y lo busqué con el nombre del juego pero no me apareció algo. Escribir el texto me pareció desagradable y largo, o sea, cada letra hay que buscar dónde está en el abecedario, pero algunas son un poco distintas del juego, y encima la página tiene 2 abecedarios y cuando cambias se borra lo escrito (se puede copiar y pegar). O sea, esta es la página:
https://www.lexilogos.com/keyboard/japanese.php
...posiblemente hay otras mejores pero por ahora sólo probé esa.
B- Un link a un programa que capte el texto de las imagenes de modo que pueda copiarlo y pegarlo en otro lado.
C- Que alguien traduzca el texto de las imagenes de la "estatua" que aparecen en la página. Y de paso esta:
http://tn.smilevideo.jp/smile?i=25276311.M
Fue hecha por videogamer/guider japonés. La estatua original no tiene una esvástica, pero puede que tenga sentido porque en el juego hay un alemán que desaparece, y cuya arma se parece a una:
https://img.webme.com/pic/p/portalnes-8eyes/8eyes_067_b_german.png
Además en Japón ese símbolo tiene otro significado.

Gracias.


¿Para qué o por qué es esto?
Quiero hacer un videojuego que mezcle varios personajes, lugares, historia, etc, de videojuego de NES y otras máquinas. El 1er juego sería 8 Eyes, porque es de la 1era consola que jugué y es el juego que más me gustó dentro de los que empiezan con un número, o sea, voy por consola-abecedario.
Quisiera que la historia sea coherente a la versión japonesa, porque la yanquie tiene varios puntos flojos (ej: Un tipo restaura al mundo, da 8 gemas a 8 dukes, y los 8 lo traicionan ¿es genio o boludo?), aunque la japonesa no se queda muy atrás (¿James Bond con un halcón y una espada?), o sea, probablemente ponga ambas versiones xD pero necesito saber si la "estatua" de la japonesa dice algo importante o no (como qué es esa "estatua": En la yanquie no tiene mucho sentido, y en la japonesa podría ser el demonio que Ruth intentaba convocar pero no tiene sentido que Bond hable con él). En la versión de usa, no.

Me canso de leer ciertas defensas a Dios en un foro que se supone es de filosofía. Por ejemplo más o menos esto:
"Creó al mundo y ahora no interviene ¿Qué culpa tiene Dios si te cae un árbol encima?"
"Nos da libertad. Lo malo que hace el humano es culpa del humano"
Combinada con la creencia de que Dios ha visto el futuro, sabe lo que pasará, y puede evitarlo se supone, lo cual es paradójico, pero eh, mucho de lo relacionado con él lo es.

---

Si tú creas un personaje de modo que camine por un sitio justo cuando algo está por caer allí, es que:
A- No sabías lo que estabas haciendo. Tu personaje es aplastado por culpa de tu ignorancia. Dios sería ignorante.
B- Le haz puesto azar. El aplastamiento se debe a tu irresponsabilidad, a dejar las cosas en manos del azar. Dios no sería necesariamente malvado, pero habría causado desastres debido a no programar bien o en pos del bien.
C- Querías que lo aplastara. Eso en general te convierte en un malvado, si el personaje fuese sensible. Si lo aplastarás, sería más coherente haber creado un personaje más apropiado, que pueda ser feliz sin tener que ser aplastado. Dios sería malvado o tonto.
D- Le has puesto libre albedrío a tu personaje o a lo que sea que derribó el árbol. Esto me parece imposible. ¿Alguien lo cree posible y tiene idea de cómo se haría? Pero de hecho parece entrar en las anteriores categorías. Ponerle un "diagrama de flujo desconocido que lo lleva a ser aplastado", parece lo mismo que aplastarlo (sólo que el proceso es más complejo o misterioso), o que poner azar o no tener idea de lo que se está haciendo. Un creyente puede decir que es un sacrificio necesario para que haya eso tan preciado que llama libertad, aunque bien sabemos que los árboles podrían evaporarse en vez de caerse, por ejemplo. Si puede dar eso tan mágico que parece ser la libertad, debería poder hacer eso otro con los árboles, o que se derritan, o que se caigan lentamente, o que un bicho los coma, etc. Hablo de árboles viejos. Los que por ejemplo caen por vientos fuertes se evita evitando vientos fuertes.

Por supuesto un creyente podrá decir que una máquina no puede ser libre pero un humano sí, pero los argumentos que suelo leer sobre eso son muy pobres. Que un programador programa a la máquina, como si Dios no hubiera programado al hombre en caso de que realmente lo hubiera creado. Yo dudo que los humanos tengamos alma o cosas raras así que probablemente seamos imitables, pero hay creyentes que afirman la libertad humana incluso sin que haya algo sobrenatural. Así que no se trata de demostrar que tenemos alma, sino de demostrar que el libre albedrío es una ilusión. Esta creencia está implicada en el determinismo fuerte:
https://es.wikipedia.org/wiki/Determinismo#Determinismo_en_los_individuos
A los amantes de la física cuántica, que parece refutar a ese determinismo, les advierto que las teorías de cosas que suceden "porque sí", son interpretaciones de los hechos, el azar ontológico es indemostrable. Capaz que para uds un determinista es lo que para un determinista es un creyente, pero bue, tampoco es que importe mucho.

Si alguno cree que por algún motivo las máquinas no pueden tener libre albedrío pero el humano sí, me gustaría escuchar sus razones.


El caso de los "seres libres que hacen maldades" es muy similar al del "ser libre que es aplastado", no lo explicaré para no alargar tanto el post.


Por cierto, originalmente estaban hablando de niños que mueren de cáncer, por si el caso del árbol parece una tontería. Por algún motivo el creyente puso ese otro ejemplo al responder.

Resumen en negrita.

Parece que expresiones como esta:
Variable1 < Variable2 y Variable1 < Variable3 o Variable2 == Variable3
son análogas a esta:
2 * 3 + 4
en el sentido de la prioridad: Así como los * se aplican antes que los +, las "y" se aplican antes que las "o".

Supongamos que tenemos:
A s B s C s D s E
donde las letras mayúsculas representan números y las s representan signos.


Los paréntesis son redundantes cuando no alteran el orden de las operaciones.


Redundantes tipo 1: Envuelven sólo un valor.
Ej: (A) s B s C s D s E

Quiero el pseudocódigo de un programa que genere expresiones que no tengan paréntesis redundantes. Generar las expresiones no es difícil (al menos las que intenté por ahora; hay otras), lo difícil para mí actualmente se relaciona con los paréntesis. Según pensé, luego de generar una expresión la podría variar poniéndole paréntesis.

Los que abren sólo se pueden poner en las posiciones indicadas por los números de arriba y los que cierran en los de abajo. Básicamente al inicio de una expresión no tiene sentido cerrarlo y al final no tiene sentido abrirlo. El programa siempre en algún punto cerraría los que abra así que no tiene que revisar si todos están abiertos y cerrados. Ej:
Posición de los abiertos: 1, 3
Cerrados: 2, 4
Resultado: (A s (B s C) s D) s E

Unos paréntesis son redundantes tipo 1 si un número está en ambos grupos
En criollo: Si se cierra a penas se abre.
Ej:
Posición de los abiertos: 1, 3
Cerrados: 3, 4
Resultado: (A s B s (C) s D) s E
¿De acuerdo? ¿se les ocurre un método mejor de nombrarlos/generarlos?


Redundantes tipo 2: Envuelven a todo el resto.
Ej: (A s B s C s D s E)

Ocurren cuando:
- En abiertos está el nro 1.
- En cerrados está el número más alto admisible.
y alguna otra condición que no llego a entender. ¿Cual/es?
El problema son casos como por ejemplo este:
(A s B s C) s (D s E)
Posición de los abiertos: 1, 4
Cerrados: 3, 5
Ahí hay 1 y 5 pero no hay falla, por eso falta alguna condición más.


Redundantes tipo 3: No envuelven algún + y no hay un * fuera.
Recuerden que eso del + y * es una analogía. Pero la cosa es que A * B * C = A * (B * C). En la práctica puede que no si el resultado de A * B o B * C es infinito en extensión, pero por ahora no trabajo con eso. Condición1 y Condición2 y Condición3 = C1 y (C2 y C3). Los paréntesis tienen sentido si implican alguna + y hay alguna * fuera. Es decir, cuando alteran el orden normal de las operaciones.

Por ahora no puedo decir cómo detectaría estos, si acaso puedo averiguarlo. Necesito hacer ciertos códigos o pseudos antes de poder analizar esto. Pero si alguno sabe detectarlos, agradezco la respuesta.


¿Hay algún otro tipo?

Eso que oculta parte de los mensajes hasta que el lector les hace clic.

Sirve para ocultar cosas que puedan ser obvias para algunos.

O sea... me gustaría que en el foro pusieran eso.

Gracias.

¿Este foro no permite spoilers?
En la sección mensajes, de ayuda, no encontré. Son útiles para ocultar cosas que puedan ser redundantes o irrelevantes para algunos...

En otro tema yo plantee parte de un método para lograr lo que dice el título, pero como dicho método me resulta tan complicado voy a plantear el asunto desde 0 a ver si a uds se les ocurre algún método que me sea más fácil.

Estos son probablemente la duda más simple y el programa más simple que intenta resolverla:
Por si no queda claro, la duda allí es qué número entero es > 4. Y  ese programa es una búsqueda por fuerza bruta. Aquí tienen info:
https://es.wikipedia.org/wiki/B%C3%BAsqueda_de_fuerza_bruta

¿Y por qué el programa no es
Candidato = 5
?
Porque ese no implica un intento de resolver la duda, o búsqueda de solución, es simplemente la solución. La idea es formar un método para que un programa busque respuestas que nosotros no sepamos (o como si no las supiéramos, si estamos practicando hacer estos programas), no darle las soluciones.
Más o menos automatizar nuestra forma de buscar respuestas.

¿Y cómo se puede complicar la duda y al programa?
Por lo que pensé sería haciendo cualquiera de estas cosas:
- Aumentar cantidad de variables de la situación inicial. O complicarlas.
- Aumentar cantidad de candidatos. O...
- Complicar método conque varía algún candidato.
- Aumentar cantidad de efectos involuntarios (EFI). O complicarlos.
- Aumentar cantidad de condiciones en que algún EFI se aplique o que debe cumplir para que se aplique. O...
- Aumentar cantidad de efectos de algún candidato. O....
- Aumentar cantidad de condiciones en que algún candidato sea aplicable o que debe cumplir para que lo sea. O...
- Aumentar cantidad de condiciones en que un estado responde la duda (siempre y cuando no sean tantas), o que debe cumplir para resolverla. O...
- Aumentar cantidad de soluciones que se quiere.

Quizá hay más, quizá algunas que dije sobran. Si quieren las explico, pero la que más me interesa en este momento es la que puse en negrita (y nótese que dejé la "O..." fuera) y parece que da para rato, así que empecemos por esa y luego vemos.

Significa, dada una condición, ponerle otras alternativas (or) o agregarle otras (and).

En el ejemplo tenemos
Candidato < 5
Como la duda y las cosas en él son tan simples, no se puede hacer mucho. El programa de complicamiento debería ser capaz de determinar qué se puede y qué no, pero no me voy a complicar con eso aún. Simplemente vamos a poner otras complicaciones antes de continuar. Por ejemplo agregar un candidato. Vamos a llamarles K1 y K2. Nos queda:
Nótese que también se complicó el método de variar los candidatos. Y quizá algo más.

Idealmente, la cosa sería pegar ese código en el programa complicador y que le agregue condiciones donde corresponde. Pero no intento algo tan ideal aún. Me sirve que genere X condiciones al azar (en este caso X=2), las copio, y las pongo en ese código sustituyendo las que había.

Cosas así
4 < K1 && K1 == K2 || 9 < K2
sé generar.

¿Entonces cual es mi problema?
- No sé exactamente cuando/dónde tiene sentido poner paréntesis.
- No sé cómo evitar redundancias al agregar condiciones.

Creo que eso, en ese orden de importancia.

Para condiciones and me dijeron un método para evitar contradicciones (supongo que también sirve para condiciones or... ¿its ok?), aunque aún no lo apliqué del todo, tengo que ver. Consiste en darle un valor a cada posible variable y elegir el operador en base a una comparación entre ellas. O sea, el operador no se elige al azar. Suena bien, tan sencillo que me aburre hacerlo.
Intenté que las "variables" pudieran ser: Candidatos, Variables o Fijas.
Las variables son algo que usaría en el futuro, se refieren a lo que describe la situación, por ejemplo dónde están las fichas en el tablero. Las fijas son valores fijos. O sea, cuando creo las condiciones pueden ser por ejemplo K1 < K2 o puede ser K1 < F1, siendo F1 un número que permanecerá fijo todo el programa de búsqueda.
Toda condición debe tener una K o V.
El siguiente código es un poco viejo así que en vez de K digo C.
Me genera, por ejemplo, esto:
Siempre genera alguna variable V o C, de hecho genera 2 listas: Vars y CVs, lo que facilitaría que las condiciones siempre tengan alguna C o V. Me faltaría la parte de elegir 2 variables, el operador, y repetir eso cierta cantidad de veces. Más tarde lo hago.

----------------------------------------------------------------------------------------

- No sé exactamente cuando/dónde tiene sentido poner paréntesis.

Pensé:
Cuando implican algún "||" no implicado por otros, y hay "&&" fuera.
pero creo que no es correcto.

Con que tenga sentido me refiero a que pueda ponerse (lo cual cambiaría la condición, sí, es la idea), no que deba ponerse.

Por ejemplo acá tiene sentido:
K1 < K2 && K2 < K3 || K3 < K4
así:
K1 < K2 && (K2 < K3 || K3 < K4)

De hecho sólo estoy pensando, pero yo quisiera que los ponga el programa, no sé bien cómo. Considerando que tendría variables Op1, Op2, etc (operadores), sería cuestión de ver si alguna es "||" y... el resto no sé bien.


Quizá sea posible evitar este asunto si en vez de paréntesis pusiera ifs anidados o alguna otra cosa. De hecho, yo suelo usar más ifs y goto que whiles, aunque también se podría usar whiles anidados creo...

Escucho ideas.

----------------------------------------------------------------------------------------

- No sé cómo evitar redundancias al agregar condiciones.

Básicamente, mi problema es que como las variables son elegidas al azar pueden ocurrir cosas como:
K1 < K2 && K2 < K3 || K1 < K3
lo cual resulta redundante porque... si se cumple la última se cumplen las demás, no tiene sentido decirlas.

No todas las redundancias aparecen por una condición or, ejemplo:
K1 < K2 && K2 < K3 && K1 < K3
Parece lo mismo pero no sé si siempre es tan así.

Cosas como:
K1 == K1
creo que sé evitarlas.


Gracias.

Variable1 < Variable2 es una expresión condicional. Y sino, me refiero a cosas así.

A dichas expresiones se las podría resumir, por ejemplo así: C1.

También se las puede "relacionar", por ejemplo así: C1 or C2 and C3 or C4

No entiendo cómo se interpreta eso, o sea, cuando se cumpliría "la" condición. Ejemplo:
(C1 o C2) y (C3 o C4): 1/2 y 1/2
C1 o (C2 y C3) o C4: 1/1 o 2/2 o 1/1
C1 o (C2 y (C3 o C4)): 1/1 o (1/1 y 1/2)

Tampoco entiendo cuántas formas de interpretar hay, cómo verlas todas.

Suponiendo que la 1era sea la correcta, me pregunto si todas las posibles relaciones son expresables, o sea, si interpretando de izquierda a derecha existe para toda posible relación una forma de expresarla que mediante dicho método se tome como tal. Mejor no puedo explicarme.

Por ejemplo, la 2nda expresión ¿cómo sería?
C2 y C3 o C1 o C4
Bien.
¿Y la 3era?
No entiendo.

En otras palabras ¿cualquier relación puede expresarse sin necesidad de paréntesis, y se interpretaría bien?

------------------------------------------------------------------------------------------------

Tengo un programa que intenta cumplir cierta condición.

Quiero complicar esa condición, que la cumpla, y así sucesivamente.

En vez de complicar la condición manualmente cada vez, quiero que se haga automáticamente y al azar.

Entonces tengo que hacer un código que genere expresiones de condiciones. Básicamente si se quiere 8 expresiones, se elige una al azar, luego se elige "y" o "o", y así sucesivamente hasta elegir la octava. Hay que evitar casos como "C1 y C1" o  "C2 o C2", entre otras cosas, pero mi problema por ahora es otro.
Puedo generar por ejemplo esto:
C1 y C3 y C4 o C2 o C3 y C5
Pero se me complica la interpretación...

¿Qué puedo hacer?