Automatizar complicamiento de duda y de programa que intenta resolverla.

[Tachikomaia]

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