Temas

https://www.youtube.com/watch?v=1TOvTx9hrXQ


Edit:
A pedido de la moderación, agregaré algo, aunque no sé qué puede ser, si la situación se plantea en el video y la pregunta en el título.

2:15 ~ 4:25
En resumen un tío tocó un OVNI o algo similar y dijo haber recibido un mensaje en código binario. El que hizo el video dice que es un lenguaje matemático universal, que significa lo mismo en cualquier idioma. Eso me pareció un error y quería saber vuestra opinión. Me pareció un error porque distintos idiomas tienen distintas cantidades de letras, y no había pensado que este lenguaje quizá sólo usa letras del inglés.
También digamos, tengo la idea de que es posible que un mismo archivo tenga igual contenido pero diferente extensión con lo cual cada programa correspondiente leerá cosas distintas, lo cual sería un indicio de que un mismo mensaje en código binario puede ser interpretado de distintos modos. También está el tema de los intérpretes, de programas que funcionan en Windows pero en otros sistemas no, etc. Tal vez estoy mezclando cosas. Quisiera que me enseñen cosas al respecto. Gracias.

Básicamente la situación es:
1- Hice un programa que averigua un número positivo entero que yo elija; le di al programa la habilidad de producir números positivos enteros y de preguntarme si adivinó.
2- Quiero complicarlo lo cual en cierto punto implicaría que averigüe una palabra simétrica que contenga una d y termine en ar (ej: radar).
3- Me doy cuenta de que eso implica que debo decir al programa cómo ver si una palabra es simétrica, si tiene d, etc.
4- Recuerdo que los programas los hago para averiguar qué acciones deben realizarse para cumplir ciertas condiciones, porque en muchos casos no sé averiguarlo, por lo que pienso que ponerme a pensar qué acciones debo realizar para que el programa vea si una palabra es simétrica, tiene d, etc, no tiene sentido.

Lo que tendría sentido es algo así:
1- Hago un programa que me dice cómo lograr algo. A eso le llamo efecto, crear/eliminar una variable o causar una modificación en una, sea a partir de otra, o por obtener alguna propiedad de otra (ej: Número de veces que contiene la letra d).
2- Complico el programa, lo cual en algunos casos implica agregar por ahí alguno de los efectos que me dió.

Más concretamente:
1- Hago un programa que averigua cómo ver si una palabra termina en lo que le pida.
2- Hago un programa que usando el efecto antes aprendido, averigua si un texto serviría como poema (aunque sólo estaría analizando si hay rimas).
Más o menos...

Pero estoy bastante perdido.

Yo estaba haciendo esto:
1- Planteo un problema sencillo, que puede resolverse mediante 1 acción.
2- Agrego variables de situación (VdS). Difícil explicar qué es esto, pero como el problema es tan sencillo, así como la condición que debe cumplirse, esto no tiene influencia. Cuando se trata de adivinar un número al azar que no cambia mientra intenta adivinarse, no hay variable/s. El número se menciona en la condición como un número fijo. Esto sólo importa cuando estas variables pueden ser modificadas por los candidatos y además la condición no puede cumplirse en 1 acción.
3- Agrego candidatos. Ahora es que esos 2 números tengan cierta relación, ya no hay uno elegido al azar.
4- Agrego efectos sencillos. Sólo influyen en las VdS, pero es irrelevante.
5- Agrego condiciones. Esto permite que puedan ser más candidatos, que cumplan más relaciones entre sí, nada más.
6- Complico las VdS. Siguen sin usarse, así que no importa. Pasan de ser números positivos enteros a negativos enteros, luego decimales, luego texto, imágenes, arrays.
7- Complico los candidatos. Esto complica su producción. No tiene sentido que sean imagenes ya que se pueden nombrar mediante números, llegado el caso las distintas imagenes serían distintos números.
8- Complico los efectos. Esto es lo que digo que no tiene sentido hacer.

Bueno, así continuaría, en cierto punto aumentaría la cantidad de acciones requeridas para resolver el problema, pero el punto es: ¿Qué hago?

Los efectos representan cosas que no controlamos. La gravedad, el viento, cosas que haga un rival, etc. Deben estar.
Y por otro lado, lo nuevo que me estoy planteando quizá me llevaría a averiguar cosas relativas a la programación, y no a la realidad, de afuera, que es la que me interesa. Una cámara de fotos que debe tomarse fotos a si misma no sé cuántas veces antes de tomar una de afuera, no sirve de mucho. Esto parece algo así, un método que debe perfeccionarse a si mismo no sé cuántas veces antes de poderse usar afuera.

Pero bueno... supongamos que la idea fuese buena. Porque los efectos averiguados sí servirían para plantear problemas de afuera.

Supongo que está bien lo del párrafo 2 y 3, pero a ver cómo encaja o lo encajo en lo que estaba haciendo.

Veamos qué aprenden estos programas en cada punto.
1- Cómo hallar un número < 10 por ejemplo. Una tontería.
2- Nada (sólo aprendo yo).
3- Cómo hallar un número < otro número por ejemplo. Aprende a controlar más variables.
4- Igual que 2.
5- Dependiendo de la cantidad de candidatos y condiciones, por ejemplo aprendería que haya excepciones (ej: N<N2<10 pero N!=1)
6- Igual que 2.
7- Igual que 2.
8- Se supone que no debo hacer esto mientras los programas no hayan aprendido cosas... interesantes.

¿Cómo logro que aprendan cosas "interesantes"?

El orden conque agrego o complico las cosas no es arbitrario.
Lo 1ero de estos programas son las VdS, si son necesarias.
Lo 2ndo son los candidatos.
Lo 3ero los efectos.
Lo 4to las condiciones.
Por eso 1ero agrego/complico algo relativo a las VdS, luego candidatos, etc. De esas 4 cosas, algunas tienen más posibles complicaciones que otras. En esos "huecos" agregaría cosas que no parecen relativas a alguna en especial, como cantidad de acciones requeridas para que haya solución.

¿Debo cambiar el orden...?

No creo.

Volviendo a la pregunta anterior: Supongo que planteando condiciones más relativas a esos problemas, pero digamos que yo no sé, o no quiero ponerme a pensar cómo, porque las cosas las tienen que averiguar estos programas.

Un ejemplo claro...
Digamos que quiero hacer un programa que me diga cómo ganar en un juego de tenis en el cual es posible hacer tiros con comba. Para que el programa pueda responderme debo decirle "la física" del juego. Pero el proceso que hacen las combas no lo sé. ¿Puedo hacer un programa que lo averigüe o no? Como se trata de algo visual, tal vez sí: El programa inventaría procesos y yo mirando los resultados le diría cual se aproxima más. Más o menos llegaría a algo igual. O sea que... ¿no es necesario que yo diga condiciones? Eso facilita las cosas... Porque el trancazo era que yo debía plantear condiciones, y parece que si no sé plantear ciertos efectos tampoco las condiciones que un efecto debe cumplir para ser ese efecto y no otro.

Whatever. Otro ejemplo, más sencillo:
En una situación, por algún motivo, a toda palabra que escribimos se le agrega s, y debemos cumplir ciertas condiciones al elegir una palabra. El efecto es, pues, agregarle s. Supongamos que yo no sé decir al programa cómo agregar s. Intento entonces hacer uno que aprenda a hacer eso ¿pero cómo sabe él si aprendió o no? ¿qué condiciones debo decirle?
El proceso es más o menos: Variable = Variable+"s".
La condición sería más o menos VariableInicial+"s" == VariableModificada
Pero supongamos que yo no supiera nada de eso. Hay efectos más complejos en que no sabría.

¿La solución es plantear efectos al azar y chequear "con mis ojos" si cumplen la condición (que no sabría describir)?
O tal vez plantear condiciones al azar y chequear "con mis ojos" si cumplen la condición de ser las condiciones que requiero.



¿Cómo plantear efectos/condiciones al azar?

Siento que algo no encaja.

No sé por qué en general me gusta más escribir en el bloc de notas que en Word. Pero tiene la enorme desventaja de que no tiene autograbado, y que se graba en un formato raro, todo lo cual hoy contribuyó a hacerme perder unas cosas que escribía. Sin querer apreté algunas teclas, tal vez la de abrir menú de Windows, apareció la ventana de ayuda, la cerré, y se cerró el bloc de notas sin preguntarme si quería guardar los cambios. Creo que ocurrió eso porque la cerré demasiado rápido considerando lo lenta que es mi compu. Lo normal, claro, es que uno guardara las cosas que escribe, cada cierto tiempo, pero cuando grabarlas implica que aparecen saltos de línea al final de las líneas, prefiero copiarlo a Word antes y grabarlo ahí, cosa que suelo hacer sin mucho problema, salvo esta vez.

Me gustaría entonces saber cómo guardar un archivo del bloc de notas de modo que no haga los saltos de línea.

Por ejemplo lo escrito aquí puede que me quede más o menos así:

No sé por qué en general me gusta más escribir en el bloc de notas que en Word. Pero tiene la enorme desventaja de que no tiene autograbado, y que se graba en

un formato raro, todo lo cual hoy contribuyó a hacerme perder unas cosas que escribía. Sin querer apreté algunas teclas, tal vez la de abrir menú de Windows,

apareció la ventana de ayuda, la cerré, y se cerró el bloc de notas sin preguntarme si quería guardar los cambios. Creo que ocurrió eso porque la cerré demasiado

rápido considerando lo lenta que es mi compu. Lo normal, claro, es que uno guardara las cosas que escribe, cada cierto tiempo, pero cuando grabarlas implica

que aparecen saltos de línea al final de las líneas, prefiero copiarlo a Word antes y grabarlo ahí, cosa que suelo hacer sin mucho problema, salvo esta vez.

¿Qué formato es el que graba normal?
Tengo:
ANSI
Unicode
Unicode Big endian
UTF-8

Gracias.

Vi esto
https://www.youtube.com/watch?v=gF58CO3aq80
y quiero ver más.

Descargué por ahí algo pero parece una continuación mucho tiempo después. Al principio spoilean el final de lo anterior parece.

Tras traducir el artícula japonés de wikipedia:
https://ja.wikipedia.org/wiki/%E5%80%92%E5%87%B6%E5%8D%81%E5%B0%86%E4%BC%9D#OVA
Veo que tienen:
Un OVA en 1999, pero no sé si es 1, 2, no sé.
Una continuación en 2001.
Por ahí mencionan un CD de drama y me perdí.

Para colmo parece que el título original es
tokyo juushouden

Luego dice que son 6 ovas pero si es como pienso en el medio hay un hueco enorme. Además cambió el estilo de dibujo, el 1ero era más sombrío.

¿Está tan cortado?

Esto varía los números en 1 array:

Código [Seleccionar] Expandir

C = new Array(1, 1, 1);
Max = 10;

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

// Candmod
W = 1;
SenaladordeP = 2;
do {
   if (C[SenaladordeP]<Max) {
       C[SenaladordeP] = C[SenaladordeP]+1;
       W = 0;
   } else {
       C[SenaladordeP] = 1;
       if (0 < SenaladordeP) {
           SenaladordeP = SenaladordeP-1;
       } else {
           // No hay Sol o está más allá del Max.
           stop ();
       }
   }
} while (W==1);
gotoAndPlay (2);


Intentando variar A arrays (en este ejemplo A=2) hice esto:

Código [Seleccionar] Expandir

C1 = new Array(1, 1, 1);
C2 = new Array(1, 1, 1);
Max = 10;

trace (C1+" "+C2);
// Solcheck
if (C1[0]<C2[0]) {
   // Sol
   stop ();
}

// Candmod
W = 1;
SenaladordeC = 2;
SenaladordeP = 2;
do {
   if (eval("C"+SenaladordeC+"["+SenaladordeP+"]")<Max) {
       trace (eval("C"+SenaladordeC+"["+SenaladordeP+"]"));
       set ("C"+SenaladordeC+"["+SenaladordeP+"]", eval("C"+SenaladordeC+"["+SenaladordeP+"]")+1);
       W = 0;
   } else {
       set ("C"+SenaladordeC+"["+SenaladordeP+"]", 1);
       if (0<SenaladordeP) {
           SenaladordeP = SenaladordeP-1;
       } else {
           SenaladordeP = 2;
           if (1<SenaladordeC) {
               SenaladordeC = SenaladordeC-1;
           } else {
               // No hay Sol o está más allá del Max.
               stop ();
           }
       }
   }
} while (W == 1);
gotoAndPlay (2); El contenido de los arrays debería variar más o menos así:

// Cambio 1:
C1 = 1, 1, 1
C2 = 1, 1, 2
// Cambio 2:
C1 = 1, 1, 1
C2 = 1, 1, 3

Como si fuesen 6 cifras, que en vez de ser del 0 al 9 fuesen del 1 al 10.
El problema es que el intérprete o lo que sea, cuando por ejemplo le digo:
set ("C"+SenaladordeC+"["+SenaladordeP+"]", eval("C"+SenaladordeC+"["+SenaladordeP+"]")+1);
...lo que hace es crear variables llamadas C2[SenaladordeP], es decir, C2[2], C2[1] y C2[0]. Más claro:

Level #0:
 Variable _level0.$version = "WIN 5,0,32,0"
 Variable _level0.C1 = [object #1] [
   0:1,
   1:1,
   2:1
 ]
 Variable _level0.C2 = [object #2] [
   0:1,
   1:1,
   2:1
 ]
 Variable _level0.Max = 10
 Variable _level0.W = 0
 Variable _level0.SenaladordeC = 2
 Variable _level0.SenaladordeP = 2
 Variable _level0.C2[2] = 8
 Variable _level0.C2[1] = 3
 Variable _level0.C2[0] = 1

En vez de variar las partes del array, o sea C2[2], C2[1] y C2[0], me crea y varía variables con esos mismos nombres. No puedo hacer referencia a contenidos de array porque lo interpreta como si fuese referencia a una variable llamada igual que una referencia a array. Pero yo no cree esas variables.

Tal vez el problema es usar set (aunque no hubo problema en el 1er código) o habría que modificar la referencia en el eval (quitar comillas, poner comillas, no sé).

¿Ideas?

El programa es Macromedia Flash 5, que usa una vieja versión de Action Script. Puede que el error sea cosa de dicho programa/lenguaje, aunque imagino que es posible alguna solución que no sea cambiar de programa/lenguaje.

Gracias.

Por problemas emocionales me cuesta concentrarme y además esto está difícil.

Esto es variar 1 variable número:

Código [Seleccionar] Expandir

C = 1;

// Candmod
C = C+1;

gotoAndPlay (2); Pueden usar do while, en los siguientes también. En estos códigos una línea en blanco representa un paso, como en Basic. En algunos casos uso varios pasos para que ninguno sea especialmente largo (ocurre si tienen do while).

Esto es variar 2 variables número:

Código [Seleccionar] Expandir

C1 = 1;
C2 = 1;
Max = 10;

   if (C2<Max) {
       C2 = C2+1;
   } else if (C1<Max) {
       C2 = 1;
       C1 = C1+1;
   } else {
       stop ();
   }
}

gotoAndPlay (2); Aquí hay un tope, pero tengo idea de cómo mejorar eso, no es el tema.

Esto es variar V variables número; en este caso V es 3 (se llama Parte).

Código [Seleccionar] Expandir

C1 = 1;
C2 = 1;
C3 = 1;
Max = 10;

   Parte = 3;

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

// El C señalado no puede aumentar, se resetea
set ("C"+Parte, 1);
if (1<Parte) {
   // Hay un C anterior, se señala
   Parte = Parte-1;
   // Ver si el C señalado puede aumentar
   gotoAndPlay (3);
} else {
   stop ();
}

Esto es variación de 1 string:

Código [Seleccionar] Expandir

// A~Z pero no Ñ
Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
CP1 = -1;
CLargo = 1;

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

// Concatenar.
C = "";
Parte = 0;
do {
   Parte = Parte+1;
   C = C+Chars.charAt(eval("CP"+Parte));
} while (Parte<CLargo);
gotoAndPlay (2); Probablemente usarían un array para esto, yo no quiero.

Variación de 2 strings:

Código [Seleccionar] Expandir

// A~Z pero no Ñ
Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
C1P1 = 0;
C1Largo = 1;
C1 = "A";
C2P1 = 0;
C2Largo = 1;
C2 = "A";
Max = "ZZ";
function CandMod () {
   W = 1;
   Parte = eval("C"+Up+"Largo");
   do {
       if (eval("C"+Up+"P"+Parte)<25) {
           set ("C"+Up+"P"+Parte, eval("C"+Up+"P"+Parte)+1);
           W = 0;
       } else {
           set ("C"+Up+"P"+Parte, 0);
           if (1<Parte) {
               Parte = Parte-1;
           } else {
               set ("C"+Up+"Largo", eval("C"+Up+"Largo")+1);
               set ("C"+Up+"P"+eval("C"+Up+"Largo"), 0);
               W = 0;
           }
       }
   } while (W == 1);
}

   // ¿qué Cand variar?
   if (C2 != Max) {
       Up = 2;
       CandMod();
   } else if (C1 != Max) {
       C2P1 = 0;
       C2Largo = 1;
       C2 = "A";
       Up = 1;
       CandMod();
   } else {
       stop ();
   }

// Concatenar.
set ("C"+Up, "");
Parte = 0;
do {
   Parte = Parte+1;
   set ("C"+Up, eval("C"+Up)+Chars.charAt(eval("C"+Up+"P"+Parte)));
} while (Parte<eval("C"+Up+"Largo"));
gotoAndPlay (2);

Variación de S strings es lo que estuve pensando (desconcentrándome porque estoy con la cabeza en otro lado) por horas ya.
Básicamente hay que "copiar" el método usado en 3 nums, pero como acá hay muchas más cosas no sé bien cómo. De momento agregué esto:

Código [Seleccionar] Expandir

C3P1 = 0;
C3Largo = 1;
C3 = "A";
Max = "ZZ";
CtoUp = 3;

Y supongo que en vez de esto:

Código [Seleccionar] Expandir

   // ¿qué Cand variar?)
   if (C2 != Max) {
       Up = 2;
       CandMod();
   } else if (C1 != Max) {
       C2P1 = 0;
       C2Largo = 1;
       C2 = "A";
       Up = 1;
       CandMod();
   } else {
       stop ();
   }
Debería hacer algo como que si "C"+CtoUp != Max entonces lo dicho aumenta (y ya se produce la variación), sino si CtoUp puede bajar se resetea lo relativo a C, CtoUp baja y el proceso que estoy describiendo debería repetirse, y sino stop.
Puede ser que sea eso. Tal vez, más que la solución o el código, me haría falta algo bastante distinto a como lo hice, o algo para no entreverarme tanto.

Como ven aún no apliqué soluciones a ordenar con Ñ, por ahora no me voy a complicar con eso.

Gracias.

Sólo estoy usando mayúsculas.

Si al programa le doy un texto C y quiero que el programa analice si el texto es mayor (es decir si en el abecedario está después) que "ZY", wait, creo que ya sé:
Z es considerado < Ñ.
Entonces hago:

Código [Seleccionar] Expandir

Si "ZY" < C
  Si el Char0 de C es "Ñ"
    // C < "ZY"
  sino si el Char0 de C es "Z"
    Si el Char1 de C es "Ñ"
      // C < "ZY"
    sino si el Char1 de C es "Y"
      Si el Char2 de C no es Void/Null/undefined (debo ver cómo le llama mi lenguaje)
        // C == "ZY"
      sino
        // "ZY" < C

O:

Código [Seleccionar] Expandir

Si "ZY" < C
  Si el Char0 de C es "Ñ"
    // C < "ZY"
  sino si el Char0 de C es "Z"
    Si el Char1 de C es "Ñ"
      // C < "ZY"
    sino si el Char1 de C es "Y"
      Si C == "ZY"
        // C == "ZY"
      sino
        // "ZY" < C

¿Correcto?

Ahora, si en vez de "ZY" fuese un texto variable, así como su cantidad de caracteres ¿cómo haría? Entiendo que debo usar un while pero el hecho de que pueda tener Ñ el texto también me complica un poco.

En mi última participación hace como 1 mes dije a mod "luego leo las reglas" y como no tenía ganas de leerlas no he vuelto a participar hasta ahora que quiero hacer una consulta bastante completa, y estaba dispuesto a leer las reglas.

Las busqué en palabras arriba, en la zona que está anterior al foro, en el FAQ del foro, hasta que cansado fui a ver el mensaje del mod del que hablé, el cual las tiene en la firma. Luego vi que estaban en otro lado aunque con unas siglas un tanto extrañas; yo con mis ojos buscaba rápido algo similar a "Reglas del foro" y que estuviera con negrita o algo.
Está aquí
https://foro.elhacker.net/sugerencias_y_dudas_sobre_el_foro-b10.0/
pero entreverado con muchos otros temas que no parecen tan relevantes.

El link "Leer reglas" de simorg me lleva aquí
https://foro.elhacker.net/reglas.htm
que me parece una versión más cómoda de leer. Más rápida en cargarse y demás.

Y así empieza:
"Solamente una vez leído, entendido, aceptada plenamente la declaración (no permitiéndose aceptaciones parciales o condicionales) y cumpliendo todas las condiciones expresadas a continuación se podrá permanecer en esta  web, en caso contrario usted tiene prohibido el acceso a este lugar y el uso de la misma por lo que deberá salir inmediatamente de elhacker.net."

Yo podría hacerme el olvidadizo o despistado, y seguir como si nada, pero quiero ser sincero y blablabla (justo y no sé qué más) y decir que no leeré todo lo demás que está escrito ahí, porque me parece demasiado largo.

¿Entonces...?



Podrían decir algo como "En caso de que ud no las cumpla, dependiendo de la gravedad de la infracción, sus post pueden ser movidos, borrados, ud baneado o su cuenta eliminada".
Eso daría la opción legal de permanecer sin leerlas y atenerse a las consecuencias, que me imagino no son tan graves, no es "el punto 2000 dice que si hablas a favor de Bill Gates empezaremos a enviarte un virus a cada rato", así que no me preocupan mucho las consecuencias, no soy un santo pero tampoco creo que merezca algo tan malo, ni que las reglas digan que deba recibirlo; confío en el sentido común.

Participo en otro foro donde no hay reglas casi y es un desastre, pero tampoco es que yo sea tan quisquilloso.

Y de paso me dicen si es muy pesado o algo.

Por cierto, como veo esta página en zoom 175% los avatars no entran en mi pantalla, o sea, el espacio que destina a ellos no aumenta, así que me aparecen barras desplazadoras. No me parece muy bien eso en el foro, en otros creo que no me pasa, pero bue.

Describiré una forma de hacerlo aunque creo que también se puede hacer con un árbol.

Parte 1:
Asignar una posición a un objeto. Por ejemplo el objeto O en 5 en el eje de las X.
Una posible acción es -1, o sea mover O hacia atrás. Esto es candidato, Cand.
La cantidad de situaciones nuevas no analizadas es 0. Us = 0
// Us viene de unsolved, no resuelto, que viene a ser más o menos como no analizada.
La cantidad de situaciones nuevas analizadas es 0. U = 0
// Us es el total, U marcará cual se está analizando de ese total.
Crear archivo cuyo nombre indique la posición de O y en su contenido diga que Cand es "Ninguno". O sea, para llegar a esta situación no se realizaron acciones desde otra, es la inicial.
// Nota: La situación inicial no cuenta en la cantidad de nuevas.

Parte 2:
Aplicar candidato en la situación, o sea, a OX sumarle Cand.
Si 7<OX
  // Solución hallada, ir a Parte MostrarLista.
sino si la situación no está registrada
  Crearla de modo similar a antes, pero el contenido debe marcar en qué situación se estaba antes (OX antes de modificarse), y qué Cand se aplicó.
  Us++
  Crear archivo "U"+Us, o sea, por ejemplo "U1", si Us es 1. El contenido debe ser OX, la situación nueva.
fin del si

Parte 3:
Si Cand < 1
  Cand+2
  // O sea, si el último movimiento fue -1, ahora cambia a +1. La pregunta es si queda alguna acción no realizada.
  Resetear la situación (o sea, OX debe volver al valor que tenía antes de que se le sumara Cand). Esto en realidad lo hago al inicio de la parte 2, pero es largo explicar cómo. Aquí también se puede.
  Ir a la Parte 2.
sino
  U++
  Cargar archivo U (esto implica modificar OX)
  Cand = -1, o sea, resetear Cand
  Ir a Parte 2
fin del si

Parte MostrarLista
Se agrega Cand en la lista, se carga el archivo OX, y así sucesivamente hasta que Cand sea "Ninguno", o sea, se carga un archivo, luego ese marca cual otro cargar, o sea qué situación hubo antes y qué se hizo en ella, y así sucesivamente hasta la 1er situación, a la cual no se llegó por otra. Lo que muestra es 1, 1, 1, o sea, para llegar de 5 a >7 se mueve 3 veces 1 a la derecha.

¿Qué sentido tiene eso?
El método es aplicable a casos más complejos pero quiero aprender a usarlo así que lo apliqué a algo muy simple.

Problemas que tengo al programarlo en Macromedia Flash 5:
- Cuando se da la instrucción de crear/cargar archivo, no se sabe cuando termina, por lo que hay que hacer comprobaciones y el código se hace mucho más largo y complicado de lo que debería.
- Al crear un archivo mediante código, se guardan todas las variables del LV0 (o sea las que no estén en objetos), por lo cual las que no se quieren guardar hay que ponerlas dentro de un objeto, lo cual estira y complica el code.
- Cuando hay una función en el lv0 y se crea un archivo mediante código, una variable extra se guarda en él, el nombre de la función, por ejemplo así:
&PreptoLoadSit=[type Function]&S=5&C=Ninguno
....en vez de:
&S=5&C=Ninguno
- Intenté poner funciones en objetos y llamarlas desde el LV0 pero no me funciona, por lo que, si no descubro alguna forma... tengo un montón de código repetido...

¿Por qué hago el tema?
Porque quiero ver cómo sería posible hacer más fácilmente lo que comenté.

El códogo:
Nota: Algunos nombres son distintos al del ejemplo. Creo que lo principal es que OX es S, que significa Situación pero en esencia es lo mismo.

Código [Seleccionar] Expandir

Escena 1
  actions for fotograma 1
     // SitIni.
     Base.S = 5;
     // CandIni.
     Actual.C = -1;
     // Vars de Unsolved sits.
     Actual.U = 0;
     Actual.Us = 0;
     // Save iniSit y preparar comprobación.
     S = 5;
     C = "Ninguno";
     Loading.S = -1;
     Loading.C = -10;
     Loading.Cargas = 0;
     Loading.ArchID = "S"+S+".txt";
     fscommand ("save", Loading.ArchID);
  actions for fotograma 3
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Loading");
  actions for fotograma 5
     Loading.Comps = Loading.Comps+1;
     Loading.Verif = 1;
     if (Loading.S != S) {
        Loading.Verif = 0;
     } else if (Loading.C != C) {
        Loading.Verif = 0;
     }
     if (Loading.Verif == 0) {
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              fscommand ("save", "30 fallas en savecheck de "+Loading.ArchID);
              fscommand ("quit");
           } else {
              // reload.
              gotoAndPlay (3);
           }
        } else {
           // retry.
           gotoAndPlay (4);
        }
     }
  actions for fotograma 6
     // Reset Sit. Aplic.
     Actual.S = Base.S+Actual.C;
     // ¿Sol?
     if (7<Actual.S) {
        // Sol; begin loads to show list
        List = Actual.C;
        gotoAndPlay (26);
     } else {
        // ¿Sit exist?
        Loading.Cargas = 0;
        Loading.S = -1;
        Loading.C = -10;
        Loading.ArchID = "S"+Actual.S+".txt";
     }
  actions for fotograma 7
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Loading");
  actions for fotograma 9
     Loading.Comps = Loading.Comps+1;
     Loading.Verif = 1;
     if (Loading.S == -1) {
        Loading.Verif = 0;
     } else if (Loading.C == -10) {
        Loading.Verif = 0;
     }
     if (Loading.Verif == 0) {
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              // La Sit parece no existir, crearla.
              S = Base.S;
              C = Actual.C;
              Loading.Cargas = 0;
              Loading.ArchID = "S"+Actual.S+".txt";
              gotoAndPlay (15);
           } else {
              // reload.
              gotoAndPlay (7);
           }
        } else {
           // retry.
           gotoAndPlay (8);
        }
     }
  actions for fotograma 10
     // La sit existe. ¿Candmod is pos?
     if (Actual.C<1) {
        // Candmod.
        Actual.C = Actual.C+2;
        // Reset sit, then Aplic.
        gotoAndPlay (6);
     } else {
        // Load UnsSit.
        Actual.U = Actual.U+1;
        Loading.Cargas = 0;
        Base.S = -1;
        Loading.ArchID = "U"+Actual.U+".txt";
     }
  actions for fotograma 11
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Base");
  actions for fotograma 13
     if (Base.S == -1) {
        Loading.Comps = Loading.Comps+1;
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              fscommand ("save", "30 fallas en loading "+Loading.ArchID);
              fscommand ("quit");
           } else {
              // reload.
              gotoAndPlay (11);
           }
        } else {
           // retry.
           gotoAndPlay (12);
        }
     }
  actions for fotograma 14
     Base.S = Number(Base.S);
     // Reset Cand. Aplic.
     Actual.C = -1;
     gotoAndPlay (6);
  actions for fotograma 15
     // Creando Sit.
     fscommand ("save", Loading.ArchID);
  actions for fotograma 17
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Loading");
  actions for fotograma 19
     Loading.Comps = Loading.Comps+1;
     Loading.Verif = 1;
     if (Loading.S != S) {
        Loading.Verif = 0;
     } else if (Loading.C != C) {
        Loading.Verif = 0;
     }
     if (Loading.Verif == 0) {
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              fscommand ("save", "30 fallas en savecheck de "+Loading.ArchID);
              fscommand ("quit");
           } else {
              // reload.
              gotoAndPlay (17);
           }
        } else {
           // retry.
           gotoAndPlay (18);
        }
     }
  actions for fotograma 20
     // Save UnsSit.
     delete C;
     S = Actual.S;
     Actual.Us = Actual.Us+1;
     Loading.S = -1;
     Loading.Cargas = 0;
     Loading.ArchID = "U"+Actual.Us+".txt";
     fscommand ("save", Loading.ArchID);
  actions for fotograma 22
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Loading");
  actions for fotograma 24
     if (Loading.S == -1) {
        Loading.Comps = Loading.Comps+1;
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              fscommand ("save", "30 fallas en savecheck de "+Loading.ArchID);
              fscommand ("quit");
           } else {
              // reload.
              gotoAndPlay (22);
           }
        } else {
           // retry.
           gotoAndPlay (23);
        }
     }
  actions for fotograma 25
     // ¿Candmod is pos?
     gotoAndPlay (10);
  actions for fotograma 26
     S = Base.S;
     Loading.Cargas = 0;
     Base.S = -1;
     Base.C = -10;
     Loading.ArchID = "S"+S+".txt";
  actions for fotograma 27
     Loading.Comps = 0;
     Loading.Cargas = Loading.Cargas+1;
     loadVariables (Loading.ArchID, "Base");
  actions for fotograma 29
     Loading.Comps = Loading.Comps+1;
     Loading.Verif = 1;
     if (Base.S == -1) {
        Loading.Verif = 0;
     } else if (Base.C == -10) {
        Loading.Verif = 0;
     }
     if (Loading.Verif == 0) {
        if (Loading.Comps == 10) {
           if (Loading.Cargas == 3) {
              fscommand ("save", "30 fallas en loading "+Loading.ArchID);
              fscommand ("quit");
           } else {
              // reload.
              gotoAndPlay (27);
           }
        } else {
           // retry.
           gotoAndPlay (28);
        }
     }
  actions for fotograma 30
     if (Base.C != "Ninguno") {
        List = Base.C+" "+List;
        gotoAndPlay (26);
     } else {
        stop ();
     }


Gracias.

Mandenlo a foro libre si creen que no encaja aquí. Disculpas.

Hoja 1:


Hoja 2:
http://img.fenixzone.net/i/cPEuSvM.jpeg

Son 4, cada una más larga y ancha que la anterior, así que no pondré más imágenes sino un link a descargar el archivo xls (de Excel):
https://filebin.net/5fy1ibnqsfbnimsw/IAs_Base5.xls?t=fc1w5k8m

Se llama IAs Base5.xls. Si les aparece otra cosa cancelen o borren, lo digo porque no sé cuan confiable es esa página.

Si tienen problema para ver el archivo y conocen una mejor forma de que se los pueda mostrar, díganme.

Quien lo vea, dígame qué cree que es (más allá de ser una tabla de Excel y lo ya dicho, claro), cual es la dinámica, el patrón, lo que sea.
También puede hacer eso quien sólo quiera ver las imagenes.

Quien entienda o crea entender lo que estoy haciendo, dígame consejos sobre eso y cómo automatizar en la medida de lo posible lo que ahí se hace.

Gracias.


Edit:
Preguntas bienvenidas.

En algunos casos hay contenidos más grandes que las celdas y que son tapados por otros, o sea que en las imagenes algunos contenidos no se pueden leer completamente pero en el archivo sí.
En rojo:
Ya hay una SS sin uso
Ya hay un Cand sin uso

En la imagen 2, abajo del cuadro celeste en la columna de SS hay una a que es un error. Igual, lo que está impedido de verse se puede ver más abajo repetido.

Creo que es más una duda matemática o de "algo" que de programación, pero un programa podría resolverla.

Supongamos que tengo un equipo de fútbol conformado por Alejandro, Beto, etc, ABCDEFGHIJK, o sea, cada letra representa a cada jugador y también está representado qué número tiene.

Ahora, yo quisiera variar las posiciones de los jugadores todo lo posible, aunque sin variar la formación (como 3-4-3).

Una respuesta que llega a la mente es KJIHGFEDCBA, pero ahí todos los jugadores están al lado de los mismos que antes, y su distancia hacia el centro también es la misma, por lo que no creo que esa sea la máxima variación.

Quisiera el pseudocódigo que la obtenga.

O un método para medir la variación de una serie, una vez que se plantea como posible respuesta.

Gracias.

Es decir, que la salida sea algo así:

Código [Seleccionar] Expandir

Sin modificadores:
K < C
Con +:
K < C+K
C < C+K
Con *:
K < C*K
C < C*K
Con + y *:
K*C < C+K
K < (C+K)*K
K < (C+K)*C
C < (C+K)*K
C < (C+K)*C
C+K < (C+K)*K
C+K < (C+K)*C
K < C*K+K
K < C*K+C
C < C*K+K
C < C*K+C
C*K < C*K+K
C*K < C*K+C

Y creo que sigue, por ejemplo K*C+K < C+K

Luego se agregaría "Con /" y así sucesivamente con cada operación que pueda realizarse en 1 línea de código, es decir, se acepta por ejemplo Floor(C), usar una función "común", pero no crear una. En otras palabras, Floor(C) se puede aplicar en una línea de código, dentro de un if por ejemplo, pero no se acepta por ejemplo Contar0s(C) porque sería una función creada.

C es una variable (abreviación de "Candidato") y K es una constante.

El signo comparador no me interesa vararlo por ahora.

Bueno... ¿qué lógica hay en la lista? Pues... básicamente es combinatoria de C, K y operaciones... tratando de que ciertas combinaciones no se muestren, pero uds hagan lo que puedan...

Idealmente sería:

- No se permite K+K, K*K, etc, porque estructuralmente hablando el resultado de eso es simplemente K, es decir, no le veo sentido a que se repita (Nota) por ejemplo la operación 2+2 si puedo poner simplemente 4.
Nota: Las afirmaciones que se muestran en la salida podrían ser usadas para evaluarse en otros programas, en cuyo caso habría repeticiones; con "repita" me refería a eso.

- No se permite C+C, C*C, C/C, ni cosas que son abarcables por K, es decir, C+C=C*2, C*C=C^2, C/C=1. Los números constantes pueden ser sustituídos por K... C+C=C*K, etc. El punto es que no tiene sentido poner en la lista cosas que están abarcadas por otras cosas de la lista.

- No se permiten estructuras con contenido igual en ambos lados. Las he quitado pero si me quedó alguna sorry.

- El signo "-" me pareció innecesario ya que K puede ser negativo, pero si uds creen que es necesario en algo como *-C en alguna parte, úsenlo. La idea de esto es que estén todas las estructuras de modificaciones posibles, no sé mucho de matemática así que no sé bien cuales serían.

- No se permiten afirmaciones que tras un "reflejo" sean iguales a otras de la lista. Por ejemplo K < C, más allá del símbolo comparador, es igual que C < K, estructuralmente: Hay una K suelta de un lado y una C del otro, de qué lado sea no me importa aquí. Como dije estas afirmaciones podrían ser usadas por otros programas, aunque yo las seleccionaría, y para eso me basta con ver la estructura, y sabiendo que no están las "reflejables" si quisiera una de esas reflejo una de las que hay. Obviamente no es una explicación muy profunda pero tampoco viene mucho al caso entender por qué lo quiero así. Bueno... es que la selección que haría sería en base a lo compleja de la estructura por lo que me da igual si es "A y B" o "B y A".

- No se permite lo simplificable, por ejemplo "(C+C)", es decir, con paréntesis que sobran. No sé más allá de paréntesis si hay algo más que no haya sido explicado y prohibido antes.

Bueno... con respecto a las operaciones, de momento serían estas:
+x
-x
*x
/x
Math.abs(x)
Math.ceil(x)
Math.floor(x)
Math.pow(x, x2)
Math.round(x)
Math.sqrt(x)

En x iría cualquier cosa que incluya C o K

No recuerdo si con pow se puede hacer sqrt, en tal caso sqrt podría ser innecesario.

Gracias y suerte en pila.

Sí, no es para un trabajo, profesor, etc, a menos que alguien espere algo de mí y me pague en cierto modo por ello, quizá algún familiar, no sé, pero daré el crédito al que me ayude. Y digo "suerte en pila" porque no tengo mucha idea de cómo hacerlo, al menos de momento. Tengo un programa que genera todas las palabras posibles, quizá cambiando "A" por "+K" por ejemplo, y así sucesivamente, podría transformarlo en un generador de las combinaciones que necesito... ¿Creen que sí?

Creo haber visto, pero googlé cosas relacionadas y me aparecieron más bien de física, matemática, etc, incluso de economía y música, pero no de programación.

En caso de que la respuesta sea sí ¿a qué se debe? Creo haber visto que en inglés se dice "constant", sin k. ¿Por qué la K entonces?

Edit:
Acá hallé la respuesta:
https://stackoverflow.com/questions/500030/what-is-the-significance-of-starting-constants-with-k
https://stackoverflow.com/questions/472103/lower-case-k-in-cocoa

Borren el tema si quieren, gracias, disculpas.

[¿Qué nombre sería adecuado para "dato que no es una función ni array, etc"?]

Estaba describiendo algo en que pretendía llamar variable sólo a lo que fuese "cosa de la situación de la duda", por ejemplo si la duda es:
¿Qué 3 movimientos debo realizar para hacer jaque mate antes que mi rival?
...entonces las variables o cosas de la situación de esa duda serían las posiciones de las fichas y de quién es el turno.

El problema, me pareció, es que iba a resultar confuso porque en mis códigos hay otras cosas que en programación llaman variables pero que yo no llamaría así.

Para arreglar eso inventé la palabra "Sitpart" que abreviaría "parte de la situación".

Ahora bien, ya que estamos quisquillosos, el término "variable" en programación es ya de por sí confuso, porque si bien un programa puede variar el dato si se dan las instrucciones necesarias, hay programas con datos que no varían, es decir, "variables que no varían".

¿Pero qué sentido tienen esos programas, ponerle un nombre a algo que no variará, por qué no decir simplemente el dato?
En lo que estoy haciendo creo que puede tener sentido, ciertos datos pueden existir o no, y en tal caso variar las consecuencias del programa, aunque esos datos de por sí no varíen. Supongo que se puede hacer de otra forma, pero de momento no veo por qué.
Otro caso en que podrían tener sentido es cuando cierto dato se usará muchas veces pero no se sabe exactamente cómo debe ser, por lo que el programador probaría uno, luego otro, y así sucesivamente hasta hallarlo, momento en que sería una pérdida de tiempo sustituir por el dato todas las referencias a él. Como lo hubiera sido modificar varias veces el mismo número pudiendo simplemente modificar el dato.

Por eso intenté crear un nuevo "glosario" de términos de programación:

Valor bautizado o ValB:
Es lo que en programación se acostumbra llamar variable, pero ahí ocurre que es posible hacer códigos que tengan "variables que no varían", lo cual es una contradicción que con las nombres que estoy asignando no ocurre, y es por eso en parte que los estoy asignando, para evitar contradicciones y confusiones. Es claro que en un código ponerle un nombre a por ejemplo un número no hace que dicho número sea "variable".

Pero veo 2 problemas con la palabra "valor".

1-
Hay cosas de los programas, que no son variables, como las funciones, pero yo no pretendí referirme a ellas ni a otras cosas distintas a lo que en programación son "variables". ¿Sería una función un "valor bautizado"? ¿qué cosas serían un "valor bautizado"?

2-
Dudo mucho que un texto o cualquier dato pueda ser un "valor". La palabra "dato" se me ocurrió mientras hacía este tema así que podría ser una corrección (y todo dato está por definición bautizado creo), aunque parece complicar más el problema 1.

¿Qué nombre sería adecuado para "dato que no es una función ni array, etc"? Correcciones a mis descripciones también...

Agradezco.

Quiero hacer algo como lo que describo a continuación:
1- Crear documento llamado "000_Nada".
2- En la hoja 1 de dicho documento, pegar un código C, y agregarle una variable.
3- A la hoja 1 llamarle "Vars".
4- A la hoja 2 llamarle "VVary", pegarle C, y hacer que la cantidad de variables varíe.
Y así sucesivamente, con unas 25 hojas aprox, y creando un nuevo archivo con nuevas hojas, cuyo nombre (del archivo) exprese qué se agregó al código base C, ya que cada archivo tomará un código generado en un archivo anterior.

Probablemente no entiendan por qué quiero hacer eso, y no lo explicaré, pues no es el tema. La cuestión es que en lo posible sólo quiero usar el teclado, no el mouse. En Excel puedo cambiar las hojas usando Control+Av Pag, por ejemplo, no necesito el mouse para eso Pero el problema de Excel es que al pegar un código queda como Dios quiere, es decir... no sé, creo que si una línea tiene tabulación se pega en la columna 2, y si sólo tiene espacios no. Los códigos que copiaré no sé si tienen tabulaciones o espacios, pero cuando intenté hacer lo que digo, tuve el problema que comenté, de las tabulaciones. Otra opción sería pegar todo en una misma celda, pero se hace difícil editar, ya saben, presionar abajo pone el puntero en la celda de abajo, y además para editar una celda (sin que seb borre lo que tiene) hay que hacerle doble clic...
Probé "Insertar objeto, Documento de Word", pero parece requerir mouse para editarlo. No querer usar el mouse en lo posible, no es de mañoso o algo, sino porque ya de por sí lo que quiero hacer me resulta tedioso y por lo tanto quiero hacerlo lo más cómodo posible, lo cual en las condiciones que tengo implica usar poco el mouse. Es decir, por ejemplo en el IDE que uso puedo agregar ciertas funciones haciendo clics, eso me gusta, pero en lo que quiero hacer, en Excel u otro sitio, no se me ocurre que hacer clics pueda ahorrarme tiempo.
Y por qué Excel o algo similar. Porque me parece más ordenado. Un distinto agregado en cada distinta hoja. ¿Cómo lo podría hacer, sino? Por ejemplo:
Código___Agregado A___Agregado B
0________0A__________0B
0A_______0AA_________0AB
Esto tiene varios problemas:
1- Como dije, son unos 30 posibles agregados, o sea 30 columnas, no entran en pantalla, prefiero usar distintas hojas.
2- Los códigos puede que tengan líneas largas, o sea que, o las columnas llegarían a ser muy anchas lo cual implica perder más tiempo desplazándome por ellas, o que no todo el texto estaría visible, pero quiero que lo esté.
3- Poner códigos debajo del otros me resulta confuso al verlos, o tendría que poner una fila pintada por ejemplo, como separador, pero igual... Y habría columnas bastante vacías porque los códigos de otras serían más largos. Obviamente "0", "0A", etc, son resumenes, pues en realidad ocuparían varias líneas.

Otra posibilidad sería usando Word:
1- Creo archivo cuyo nombre diga el código base.
2- Pego el código base, y le agrego algo.
3- Lo pego de nuevo, y le agrego otra cosa.
Así sucesivamente. Lo de Excel, si se pudiera hacer sin mouse, me parece mejor, más prolijo, ordenado, 1 agregado en cada distinta hoja... pudiendo cambiar de hoja simplemente con Control+Av Pag... En Word un código puede ocupar más de una hoja...

Uso las versiones de 2003, pero dudo que ese sea el problema.

Tengo Windows XP SP3, 504 de RAM.

Bueno ¿qué me recomiendan, en cuanto al tema?

Gracias.

Es que es obvio que no responden y el cartel se mete encima de cualquier otra cosa que esté haciendo, así que molesta, sólo sirve para enlentecer más la carga supongo.

He googleado en distintas ocasiones pero no encontré la solución.

Me parece que, desde que quité las actualizaciones automáticas de Avast, sucede.

Es que en aquél entonces supuestamente Avast iniciaba un proceso llamado instup.exe que prácticamente trancaba mi computadora (y no me pasa sólo a mí, pero en el foro de Avast no me dieron la solución), no podía cerrarlo, ni bajarle la prioridad, y ni taskkill, ni taskill, o algo similar, funcionaron.

Por supuesto quizá nada tiene que ver con eso es un problema de hardware. Por ejemplo al encender la computadora me dice que tengo un disco checksum status bad, replace, o algo así, y tengo que presionar F4. Sí, uno de mis discos funciona mal. A veces la computadora deja de captarlo. Y quizá no es casualidad que, cuando se autoreinicia (auto porque yo no la mandé hacerlo) mi computadora no me aparece el mensaje. En este momento... exacto, según veo el disco no está siendo reconocido. Probablemente sea eso...

¿Y sino? ¿qué me recomiendan?

Ah, sí, tengo windows Xp sp3 (32 bits creo).

Es posible crear procesos (AI) y personalidades (PER). Hay datos por ahí en Internet. El problema que he visto es que si uno pone 8 jugadores (7 de sistema), la computadora parece que aplicara sólo la PER de 1 o 2. Juego en modo muy rápido. No sé si es un problema de que mi computadora es muy lenta y entonces el juego se hace el boludo (en vez de decirme "oye, para que no tarde en cargarse o funcionar el juego, sólo hemos cargado la PER de un par de jugadores") o si es que el juego está mal programado.

Me refiero al tema de los soldados, otras cosas no me fijé. Si por ejemplo la PER dice que debe tener 1 grupo de atacantes, puede que no ataque, sólo atacará 1 o 2 jugadores porque la PER de los demás parece no funcionar al menos en ese aspecto.

Aunque al inicio sería con 1 sólo stat: Pow, y no habría speed sino turnos en orden al azar.
Pow es como HP pero también determina el daño. Algunos ataques hacen 10% de daño del Pow del atacante por ejemplo.

Código [Seleccionar] Expandir

// Datos (nombres de los personajes y su pow inicial):
BondPow = 100;
RuthPow = 100;
// Especificaciones de esta batalla:
P1ID = "Bond";
P1Pow = eval(P1ID+"Pow");
Es = 1;
// Es=Enemigos
E1ID = "Ruth";
E1Pow = eval(E1ID+"Pow");
E1Frozen = 0;
// Cuan congelada está.
function Chose1E () {
// Por ahora sólo para Bond:
if (Key.isDown(65)) {
P1.gotoAndPlay(31);
gotoAndPlay (5);
//Hasta acá esta ok pero hay que corregir el error de "if keep pressing"
}
}

Código [Seleccionar] Expandir

// Por ahora sólo Bond y Ruth.
if (random(2) >= 0) {
// Eso en realidad es == 0, pero como por ahora estoy programando al personaje del jugador vale cualquier número. Esto determina de quien es el turno.
attachMovie( "D", "D", 11 );
Act = "Bola congelante";
attachMovie( "Puntero", "P", 10 );
D._x = 760.5;
D._y = 300;
P._x = 39.4;
P._y = 300;
// Eso agrega un cuadro de diálogo, pero a modo de pensamiento, que indica qué acción el personaje realizará. Sí, por ahora la acción no se elige. Y también agrega un puntero que indica en donde se aplicará la acción.
} else {
E1.play();
//Add ef
gotoAndPlay (5);
}
Se ve así aunque animado:

Obviamente debo cambiar al personaje de la izquierda y agregar un fondo, pero el puntero va cambiando a color rojo y se mueve suavemente de atrás a adelante, al igual que el diálogo de pensamiento, que además aparece de una forma bonita y tiene algunos efectos de brillantez.

Chose1E();


En cuanto a los niveles, quisiera lograr algo así:
1er nivel: 1 personaje, 1 opción, 1 stat, 1 enemigo.
Para que tenga algo de gracia le pondría que debe realizarse el ataque en menos de 1 minuto...
El 2ndo nivel agregaría algo de lo dicho anteriormente.

De peleas y quizá algunas carreras o competiciones varias.

De momento tengo algo así:

Código [Seleccionar] Expandir


Player.Facing = 1;
Player.Attacking = 0;
Player.Action = 1;
// 0 crouching, 1 nothing, 2 walking, 3 falling, 4 jumping.
function PersControl () {
if (Player.Attacking == 0) {
// Si el personaje no está atacando.
if (Player.Action == 2) {
// Si el personaje está caminando.
if (Key.isDown(65)) {
// Si se presiona A.
Player.SpeedX = 0.9*Player.Facing;
Jump ();
} else if (Key.isDown(83)) {
// Si se presiona S.
Player.gotoAndPlay(2);
Player.Attacking = 1;
Player.Action = 1;
} else if (Key.isDown(39)) {
// Si se presiona derecha.
FaceRight ();
Player._x = Player._x+0.9;
} else if (Key.isDown(37)) {
// Si se presiona izquierda.
FaceLeft ();
Player._x = Player._x-0.9;
} else {
Player.gotoAndStop(1);
Player.Action = 1;
}
} else if (Player.Action == 1) {
// Si el personaje está en reposo.
if (Key.isDown(65)) {
// Si se presiona A.
Player.SpeedX = 0;
Jump ();
} else if (Key.isDown(83)) {
// Si se presiona S.
Player.gotoAndPlay(2);
Player.Attacking = 1;
Player.Action = 1;
} else if (Key.isDown(39)) {
// Si se presiona derecha.
FaceRight ();
Player._x = Player._x+0.9;
Player.gotoAndPlay(35);
Player.Action = 2;
} else if (Key.isDown(37)) {
// Si se presiona izquierda.
FaceLeft ();
Player._x = Player._x-0.9;
Player.gotoAndPlay(35);
Player.Action = 2;
}
} else if (Player.Action == 3) {
// Si el personaje está cayendo.
Player._x = Player._x+Player.SpeedX;
Player.SpeedY = Player.SpeedY+0.1;
Player._y = Player._y+Player.SpeedY;
if ( Player._y >= 554 ) {
// Si el personaje toca el suelo.
Player._y = 554;
Player.gotoAndStop(1);
Player.Action = 1;
}
} else if (Player.Action == 4) {
// Si el personaje está saltando.
if (Key.isDown(65)) {
// Si se presiona A.
Player.SpeedY = Player.SpeedY+0.1;
if (Player.SpeedY >= 0) {
// Si el personaje comienza a caer.
Player.Action = 3;
//Falta animación
}
} else {
// Si se suelta A.
Player.SpeedY = 0.1
Player.Action = 3;
//Falta animación
}
Player._x = Player._x+Player.SpeedX;
Player._y = Player._y+Player.SpeedY;
// faltan otras teclas, no elseif
}
}
}
// Otras funciones.
function FaceRight () {
if (Player.Facing == -1) {
Player.Facing = 1;
Player._xscale = 100;
}
}
function FaceLeft () {
if (Player.Facing == 1) {
Player.Facing = -1;
Player._xscale = -100;
}
}
function Jump () {
// Dada cierta speed esto hace que disminuya??
Player.gotoAndPlay(96);
Player.Action = 4;
Player._x = Player._x+Player.SpeedX;
Player.SpeedY = -4;
Player._y = Player._y+Player.SpeedY;
}


Error:
Luego de caer y "tocar el suelo" (no hice plataformas por ahora pero no sé bien cómo se hace eso de ver si está cayendo y va a tocar una plataforma entonces que deje de caer y vuelva a al estado de reposo), si se sigue manteniendo presionada la tecla a, saltará instantáneamente de nuevo, y para colmo no lo hará hacia una dirección aunque se esté presionando -> o <-.
En otras palabras, luego de esto:

Código [Seleccionar] Expandir

// Si el personaje toca el suelo.
Player._y = 554;
Player.gotoAndStop(1);
Player.Action = 1; ...el programa cree que el personaje está en reposo y el código está hecho de modo que en tal caso si se presiona la a salta no hacia un costado.

Posible solución:
Poner un if dentro del caso en que se presiona la tecla a en el estado de reposo, de modo que si también se presione una tecla -> o <- el salto sea hacia un costado.
No obstante, en el juego original (8 Eyes), el personaje que estoy copiando, cuando cae se queda agachado unos momentos. Tendré que arreglar varias cosas.

Este post está dividido en 3 partes.
La 1era es esta aclaración, la 2nda es la clave y la 3era es info extra a quien requiera o le interese.
Además en café puse lo menos importante.

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

El juego es así:
1- Se genera un número al azar de 3 cifras usando números enteros del 0 al 5, sin repetir. Yo no sé el número que se genera (a menos que haga trampa, pero no quiero).
2- Yo elijo un número de dichas condiciones (excepto el ser por azar).
3- El juego informa cuántos números bien colocados (considerando el número elegido por la computadora) puse, y cuántos números están mal colocados.
El paso 2 y 3 se repiten hasta digamos decir 6 códigos fallidos o hasta que yo acierte el número elegido por la compu.

Cuando digo hacer fuerza bruta me refiero a hacer un "programa" (lo digo entre comillas porque más de uno dice que yo no programo, que hago otra cosa) que encuentre las mejores respuestas o algo que luego un humano pueda usar para ganar rápido en el juego, digamos procesos a seguir. Y que además dicho "programa" sea lo más fácil posible de hacer sin importar lo poco eficiente que sea. Pero que además esté hecho en un lenguaje "normal", no en lenguaje máquina.

Bueno, yo hice algunas cosas así, pero esto la verdad me sobrepasa por el tema de las pistas creo (entiendo que es muy vago decirlo así, pero no lo entiendo más que eso), por ahora no sé hacerlo, por eso hago este tema para pedir ayuda.

Lo que hice hace años fue algo así:
Hay un objeto en el punto 0 del eje de las X.
El objetivo es que llegue al 10 en la menor cantidad de movimientos posibles teniendo estos 2:
1: Moverse +1 a la derecha (hacia el 10).
2: Moverse -1 a la izquierda.
Es obvio que conviene usar la acción 1 10 veces, pero mi idea era que el programa lo descubriera sin que yo le diera pistas como "te estás acercando", no me gusta hacer eso porque uno no siempre sabe cuando una acción es buena o mala, prefiero evaluar "desde el final". Mi programa realizaba una acción, si llegaba a una situación nueva generaba un archivo cuyo nombre la describía y el contenido marcaba cual fue la anterior y qué hizo en ella, y se generaba otro archivo que marcaba que esa situación aún no había sido analizada. Tras probar todas las acciones en una situación (reseteándola luego de cada una), se hacía lo mismo pero desde una de esas situaciones no analizadas. El resultado básicamente son archivos así:
1.txt que tiene X=0; Action=1
2.txt que tiene X=1; Action=1
3.txt que tiene X=2; Action=1
etc, hasta
10.txt que tiene X=9; Action=1
Y por supuesto los otros archivos de situaciones por acciones estúpidas como -1.txt por haberse movido hacia atrás.
Cuando el programa llegaba a colocar el objeto en el punto 10, decía la acción que realizó, cargaba la situación anterior, decía la acción que se realizó en ella, y así sucesivamente hasta llegar a la situación inicial.

Eso me parece que es aplicable a "todo":
Hacer un jaque mate, hallar la cura a una enfermedad o a un país mal gobernado, etc.
Si no se puede es porque hay variables desconocidas por ejemplo, pero quizá el mismo método con los ajustes necesarios las puede averiguar, al fin y al cabo es un método para averiguar cosas.
En un foro me plantearon un problema del que sin embargo no podía: Hacer la serie de fibonacci con alguna condición que no creo venga al caso. Quizá no pude porque no lo apliqué bien, pero tampoco creo que venga mucho al caso, aunque por decir algo...:
Si se genera una serie a comprobar si sirve o no, necesito la serie verdadera para hacer esa comprobación. Si no sé cómo es ("variable desonocida") no puedo hacer la comprobación, y si sé cómo es y la voy a usar para hacer comprobaciones entonces qué sentido tiene buscarla.
Es un caso distinto de lo que yo plantee, en que se puede saber qué se quiere pero no cómo conseguirlo, saber el final de una serie pero no la serie en sí que además es irrelevante (pueden ser cualquier números, simplemente dependen de las acciones/situaciones posibles). Sólo porque un número esté bien ya tengo "la serie" (los movimientos para llegar a dicho número), pero en el caso de la serie de fibonacci es necesario que estén bien todos sus números y si no tengo la serie (o no la genero a propósito) no puedo. En fin, no tengo mucha idea de eso (quizá hay una ecuación matemática para saber si un número está en la serie, aunque no se tenga la serie, pero ni idea tampoco, no sé hallar condiciones o efectos aún, sólo hallé series de números basados en el último principalmente).

Y aquí estoy de nuevo con un problema que ese método supuestamente "todo terreno" no sé cómo puede solucionar esto, y si es que no puede, por qué no.

¿Cual sería el método más parecido al mío, que solucionaría el problema?

¿Cómo deben ser los archivos?
Se me ocurre por ejemplo esto:
012,00_345,03_453,03_534.txt
El nombre contiene las acciones realizadas y las pistas recibidas (el contenido en sí del archivo no se me ocurre). ¿pero cómo se generaría eso?

¿Cual es la situación inicial, debo mencionar el número que yo en teoría no conozco? El resultado sería este:
Para el 012 conviene usar 012
Para el 013 conviene usar 013
Inútil.

Necesito que se generen los procesos y contar la cantidad de pasos que requieren en cada caso, o al menos la máxima cantidad de pasos que requiere en un caso.

¿Esos procesos no se pueden describir mediante una línea?

Pero a ver, por ejemplo me serviría que exista un archivo
012,01_304,01_135,02_253,01_541.txt
y otro:
012,01_304,02etc.txt
Suponiendo que iniciar con 012 y luego 304 (si la pista es 01) fuese uno de los procesos que mejor funciona en general. O sea, no necesito que un proceso con todas sus variaciones esté en 1 línea, pueden ser muchas líneas/archivos indicando las diferentes variaciones según las pistas.

Luego de algún modo buscaría los archivos más cortos, de hecho podría ponerles LX al inicio y sustituir X por la cantidad de números que tienen luego.
Entonces si jugando al juego pongo 012 y obtengo 11 busco el proceso 012,11, veo qué dice después, y así sucesivamente.


Algo que se me ocurrió es generar un proceso, que puede ser 012,013,014etc, y contar en todos los casos cuánto tardaría en averiguarlos. Es decir, ignora las pistas. ¿Será esa la respuesta? No creo, sin pistas cualquier proceso puede tardar mucho.

¿Pistas en los nombres de archivos y acciones dentro? No sabría bien cómo contar qué tarda más. Podría eliminar los archivos más largos y ver cual proceso se repite más ¿?
Creo que esto no serviría, iguales pistas pueden obtenerse por distintas situaciones, los archivos serían sustituidos por otros.

Af. dado un número N el proceso P1 tarda 1 paso.
No, tampoco, porque cuando digo proceso me refiero a una línea y si me basara sólo en los que tardan menos obtendría los que por suerte aciertan de una.

En fin, como ven le doy vueltas pero no me sale.

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

MasterMind:
https://es.wikipedia.org/wiki/Mastermind
Más info aquí:
https://en.wikipedia.org/wiki/Mastermind_(board_game)#Algorithms

Ejemplo del juego que dije:
1- Se genera el número 210
2.1- Digo 012
3.1- Me dice 1-2, lo cual significa que hay 1 número bien colocado (el 1, pero yo eso en realidad no puedo saberlo en este punto porque en el caso real no sé el número generado) y 2 mal colocados.
2.2- Debido a que en este caso habría tenido bastante suerte porque acerté cuales números son los presentes, sólo me queda averiguar el orden correcto. Sé que el número es alguno de estos 3: 021, 210 o 102. A partir de ahora es cuestión de probar esos 3, no sé si hay un orden de pruebas mejor que otro.

Búsqueda de modos de ganar antes de hacer este tema:
Quería tener un diagrama de flujo o algo similar:

Dado que habría muchas flechas en cada caso, pensé en hacer algo así:
012__0-0__345__0-3__453__0-3__534
_______________1-2__354__0-3__435__0-3__543
_____0-1

Por otro lado, pensando una explicación para un ejemplo en que me equivoqué, se me ocurrió un método que no me interesa usar en programación pero es interesante:
En cada columna de la siguiente "tabla" están los posibles números de cada cifra:
000
111
222
333
444
555
La mayoría de las posibles pistas nos permiten tachar algunos números.

El ejemplo siempre será 012.

0-1 o 0-2:
_00
1_1
22_
333
444
555

0-3:
_00
1_1
22_
___
___
___

1-0 o 2-0:
0__
_1_
__2
333
444
555

0-0:
___
___
___
333
444
555

1-2:
000
111
222
___
___
___

1-1:
Creo que esta no.

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

Código [Seleccionar] Expandir

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

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.

[El resultado que intenté obtener sería así:]

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

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:

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 [Seleccionar] Expandir

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.

[me serviría]

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.

[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?]

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.]

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.

[- Aumentar cantidad de condiciones en que un estado responde la duda (siempre y cuando no sean tantas), o que debe cumplir para resolverla.]

¿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:

Código [Seleccionar] Expandir

Candidato = 0
Hacer
  Candidato++
Mientras Candidato < 5
Mostrar "Una solución es " + Candidato 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:

Código [Seleccionar] Expandir

K1 = 0
K2 = 0
Hacer
  K1++
  Si K1==10
     K1 = 0
     K2++
  fin del si
Mientras K1 < 5
Mostrar "Una solución es " + K1 + " y " + K2 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.

Código [Seleccionar] Expandir

X = 0;
Lets = "CVF";
Cs = 0;
Vs = 0;
Fs = 0;
// Elegible.
Vars = 10;
//
CVs = 0;
do {
X = X+1;
LetX = Lets.charAt(random(3));
set (LetX+"s", eval(LetX+"s")+1);
set ("Var"+X, LetX + eval(LetX+"s"));
set (eval("Var"+X), random(Vars+1));
if ( LetX != "F" ) {
CVs = CVs+1;
set ("CVs"+CVs, LetX + eval(LetX+"s"));
}
} while (X<Vars);
if ( CVs == 0 ) {
Fs = Fs-1;
LetX = Lets.charAt(random(2));
set (LetX+"s", eval(LetX+"s")+1);
set ("Var"+X, LetX + eval(LetX+"s"));
set (eval("Var"+X), random(Vars+1));
CVs = CVs+1;
set ("CVs"+X, LetX + eval(LetX+"s"));
} Me genera, por ejemplo, esto:

Variable _level0.X = 10
 Variable _level0.Lets = "CVF"
 Variable _level0.Cs = 3
 Variable _level0.Vs = 5
 Variable _level0.Fs = 2
 Variable _level0.Vars = 10
 Variable _level0.CVs = 8
 Variable _level0.LetX = "V"
 Variable _level0.Var1 = "C1"
 Variable _level0.C1 = 7
 Variable _level0.CVs1 = "C1"
 Variable _level0.Var2 = "V1"
 Variable _level0.V1 = 8
 Variable _level0.CVs2 = "V1"
 Variable _level0.Var3 = "C2"
 Variable _level0.C2 = 0
 Variable _level0.CVs3 = "C2"
 Variable _level0.Var4 = "V2"
 Variable _level0.V2 = 7
 Variable _level0.CVs4 = "V2"
 Variable _level0.Var5 = "V3"
 Variable _level0.V3 = 3
 Variable _level0.CVs5 = "V3"
 Variable _level0.Var6 = "F1"
 Variable _level0.F1 = 6
 Variable _level0.Var7 = "V4"
 Variable _level0.V4 = 4
 Variable _level0.CVs6 = "V4"
 Variable _level0.Var8 = "F2"
 Variable _level0.F2 = 9
 Variable _level0.Var9 = "C3"
 Variable _level0.C3 = 0
 Variable _level0.CVs7 = "C3"
 Variable _level0.Var10 = "V5"
 Variable _level0.V5 = 4
 Variable _level0.CVs8 = "V5"

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?

Código [Seleccionar] Expandir

resolve = lambda a, b: [(a[0], b[1])] if a[1] == b[0] else []

def isconsistent(inequations):
  pending = inequations[:]
  done = []
  hashes = set()
  while pending:
    c = pending.pop()
    if c[0] == c[1]:
      return False
    for i in done:
      n = resolve(c, i) + resolve(i, c)
      for e in n:
        h = "%s<%s"%e
        if h in hashes:
          continue
        hashes.add(h)
        pending.append(e)
    done.append(c)
  return True

print(isconsistent([("A", "B"), ("B", "C"), ("C", "D")]))
print(isconsistent([("A", "B"), ("B", "C"), ("C", "A")]))

Gracias.

Superado esto
https://foro.elhacker.net/programacion_general/mostrar_o_o_o_en_pantalla-t478377.0.html
...pasamos a cosas más interesantes, lamentablemente más difíciles.

A bote pronto es como si quisiéramos generar un texto de 7 palabras que representan:
1: La variable1 de condición1
2: El símbolo comparador de la condición1
3: La variable2 de la condición1
5: La variable1 de condición2
6: El símbolo comparador de la condición2
7: La variable2 de la condición2

La parte 4 no representa algo, siempre es "&&".

Las partes 2 y 6 pueden ser ==, !=, <= o <. Y pueden ser iguales entre sí o no.

La parte 1 o la 3 debe ser V.
La parte 5 o la 7 debe ser V.
En otras palabras, en cada condición debe estar la variable V.

Las partes 1, 3, 5 y 7 que no sean V, pueden ser V, A o B, pero no puede haber B si no hubo A. Pueden ser iguales entre sí o no.

V, A y B digamos que representan un número entero.

A < B.

Las condiciones que se generen debe haber casos en que se cumplan y otros en que no, y no deben tener redundancia. Tienen redundancia cuando una condición exige lo mismo que la otra y más aún. Por ejemplo: A == V && A <= V. En este caso alcanzaría con decir A == V.

Si no hay problema, quisiera que las variables menores aparezcan 1ero, por ejemplo así:
A < V && V < B
...en vez de así:
V < B && A < V
Por eso también, es que no uso los signos > y =>. No son necesarios ¿no?

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

Si tienen dudas respecto a qué se quiere hacer, pregunten. Si se entendió, pasamos a cómo hacerlo.

Se me ocurren algunos métodos... aunque ninguno es del todo bueno o completo...

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

Método 1:
Ponerme a pensar "manualmente" cuales son las combinaciones de condiciones que sirven, y escribirlas en una lista, en el código.

Esto no sólo carece de "gracia" (hacer que piense/escriba/etc la máquina, no ponerme a hacerlo yo), sino que además no me sirve porque más adelante quiero generar condiciones más complejas y tomaría mucho tiempo pensar una a una cual sirve y cual no, y escribirlas.

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

Método 2:
Asignar valores al azar hasta que se cumplan los requisitos.

Poco eficiente ¿y cómo escribir en el código a los requisitos?

Se me ocurre algo así:

Código [Seleccionar] Expandir

// La parte 1 o la 3 debe ser V.
Requisitos = "No"
Si V1C1 == "V" or V2C1 == "V"
   // La parte 5 o la 7 debe ser V.
   Si V1C2 == "V" or V2C2 == "V"
       // no puede haber B si no hubo A.
       Si V1C1 == "A"
          Requisitos = "Ok"
       sino si V1C1 != "B"
          Si V2C1 == "A"
             Requisitos = "Ok"
          sino si V2C1 != "B"
             Si V1C2 == "A"
                Requisitos = "Ok"
             sino si V1C2 != "B" && V2C1 != "B"
                   Requisitos = "Ok"
fin de los si
Si Requisitos == "Ok"
  // A < B
  Si condición1 es "V < A" o "V <= A"
     Si condición2 es "B < V" o "B <= V" o "B == V" o "V == B"
        Requisitos = "No"
fin de los si

Esto vendría luego pero no sólo me parece dudoso, sino incompleto.

Código [Seleccionar] Expandir

Si Requisitos = "Ok"
  Requisitos = "No"
  // Las condiciones que se generen debe haber casos en que se cumplan y otros en que no, y no deben tener redundancia.
  A = 10
  B = 20
  V = 5
  Caso1 = "No"
  Caso2 = "No"
  Caso3 = "No"
  Caso4 = "No"
  Hacer
     Si condición1 se cumple
        Si condición2 se cumple
           Caso1 = "Ok"
        sino
           Caso2 = "Ok"
        fin del si
     sino si condición2 se cumple
        Caso3 = "Ok"
     sino
        Caso4 = "Ok"
     fin del si
     V = V+5
  mientras 30 < V
  Si todos los casos son "Ok"
     Requisitos = "Ok"
  fin del si
fin del si

Según HABÍA pensado (ahora no me estoy concentrando en eso), que se den los 4 casos significa que la condición puede cumplirse o no, y que no hay redundancia. Pero tendría que analizarlo de nuevo.

Además, cada condición que se nombra en el pseudocódigo debería ser nombrada mediante sus partes, que sería algo así:

Código [Seleccionar] Expandir

Si V1C1 C1S V2C1 Pero si alguna vez puse algo así en un if, ya no lo recuerdo bien.

Esto
"Si no hay problema, quisiera que las variables menores aparezcan 1ero."
...creo que se cumple con el código para A < B.

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

Método 3:
Partiendo del método 2, pensar algunas cosas como cómo generar las condiciones de modo que cumplan los requisitos, con lo cual, ya no sería necesario chequearlos.

También me parece que carece de gracia, no tanto pero sí.

Nota: A partir de ahora invierto el orden de los nombres de algunas variables, por ejemplo V1C1 cambia a C1V1. No sé bien por qué, pero estoy más acostumbrado a eso, antes lo hice de la otra forma porque con palabras normales lo había planteado de ese modo.

Código [Seleccionar] Expandir

// La parte 1 o la 3 debe ser V.
C1V1 = random("V" o "A")
Si C1V1 == "V"
  C1V2 = "A"
sino
  C1V2 = "V"
fin del si
// La parte 5 o la 7 debe ser V.
C2V1 = random("V" o "B")
Si C2V1 == "V"
  C2V2 = "B"
sino
  C2V2 = "V"
fin del si
// Considero que no tiene sentido comparar A dos veces. Pero no tengo una demostración...
// no puede haber B si no hubo A.
// Eso está hecho.
// A < B.

Bueno, habría que seguir, pero no me gusta este método y por hoy ya escribí mucho.

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

Vuestro turno, gracias.

hola mundo!!!

hice 1 programa q me muestra el num 0 o 1 o 2 o 3 al azar y ahora quiero q en ves de eso me muestre <> o < o <= o == al azar tambien ¿como seria el seudocode?

gracias!!!