Sigo sin entender bien de qué hablas, quizá ignoro demasiado del tema.

Me imagino por ejemplo que si el enemigo está a la derecha y tu bot quiere escapar de él entonces debería moverse hacia la izquierda esquivando obstáculos, ideando un trayecto para no quedar en un hueco, aunque eso último es un tanto difícil de lograr, por ejemplo en Age of Empires 2 no lo lograron del todo...
También deberías considerar varios enemigos a la vez porque si hay uno en la izquierda y otro en la derecha entonces le convendrá moverse hacia abajo o arriba.

Lo de agarrar objetos es cosa más bien tuya, los eliminas de la pantalla y de la lista de cosas en la pantalla. Y los agregas en la lista de objetos de tu bot.

Creo que haciendo muchas funciones. Función huir, función atacar, función buscar enemigo, acercarse a objeto...

Adermás, olvido esto pero creo que se puede, en vez de usar ifs, hacer llamadas a funciones variables. Por ejemplo: Llamar función "Peligro"+poderenemigo. Creo que requiere eval, no sé si tu lenguaje lo permite. Lo que logras con eso es que se active Peligro1, o Peligro2, etc, según el caso. Puedes sumar cosas en la llamada de modo que abarques todas las situaciones posibles que te interesen. Tenés que ver qué cosas te interesan y si puedes manifestarlas con un número o palabra, en lo posible sin usar ifs.
Un ejemplo:
BotfunciónBLFFFR
Significa:
El enemigo nro1 está cerca de tu Base, y cerca de ti, en Left.
El enemigo nro2 está Far de tu base, y Far de ti.
El enemigo nro3 está Far de tu base, y carca de ti, en Right.
Con eso armas la función como quieras, o sea pones en ella qué quieres que se haga. Y así con cada función posible. Puedes usar subfunciones para evitar repetir cosas.

No sé hasta qué punto es un buen método, pero a falta de otras respuestas...

¿A qué llamas asistencia? ¿que no requiera constantes instrucciones de ti como jugador?

Entonces en tu caso una IA que aprenda me parece ultra complicada, no puedo ayudarte, nunca pensé ni me interesa hacer una que cometa "errores a propósito" xD
Ponele random, o sea, posibilidad de hacer ciertas tonterías en ciertos casos.


A ver, me imagino un juego de este estilo:
https://www.youtube.com/watch?v=MO9Buh0B494
Capaz que en tu caso se pueden mover en diagonal o se ve en diagonal (tipo Final Fantasy Tactics), aunque te recomiendo este
https://www.youtube.com/watch?v=PJ2KJc61WZ4

¿Lograste que tu tanque se mueva según lo indiques?
¿que no pueda pasar por obstáculos?
¿que agarre los ítems y tengan efecto o se agreguen a la lista de usables, y realmente sean usables y tengan efecto?
¿que dispare cuando lo indiques?
¿que el disparo rompa cosas?
------------------
¿aparecen tanques enemigos?
¿se mueven?
¿chocan con obstáculos?
¿te buscan?
¿te disparan?
¿sus disparos te matan?
¿tú los matas con tus disparos?
----------------
¿tu bot se mueve en busca de enemigos?
¿les dispara?
¿sus disparos los matan?
¿lo pueden matar?
¿huye?
¿te ayuda si ve que estás en peligro?
¿busca ítems?
¿tienen efecto?

¿algo más?

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

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

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

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

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

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

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

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

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

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

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

Creo que eso, en ese orden de importancia.

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

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

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

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

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

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

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


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

Escucho ideas.

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

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

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

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

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


Gracias.

No sé mucho del tema, pero me da la impresión de que quien debe dar información eres tú.

En 1er lugar, cuando leí bot, pensé que te referías a un programa que haga cosas por Internet. Pero no se me pasó por la cabeza que pudiera ser para un videojuego. Según he visto usaste bien la palabra, pero si se trata de algo así entonces lo asocio con una inteligencia artificial. No sé los demás, pero capaz que entraron al tema pensando que hablabas de un "chateador" y al ver que era otra cosa no pudieron ayudarte, y los que sí pueden no entraron al tema porque no sabían que hablabas de algo que no es "chatear". Es una hipótesis...

Por último, hablas de matar en un mapa ¿pero cuántas dimensiones tiene? ¿tiene obstáculos? ¿plataformas? ¿cómo mata? ¿hablas de un shooter o más bien algo como Warcraft 3?

También uno se podría preguntar como qué humano, o cómo es un humano, pero digamos que es demasiado. Yo te recomendaría, si otro no dice algo, que pienses en "copiarte", o sea, crear una copia de ti, pensar qué harías tú.

En caso de videojuego estilo Warcraft, por ejemplo, si uno de tus soldados se encuentra con algún enemigo, lejos de tu base:
Bueno, me cansé, pero la idea es atacar, acercarte a tu base o alejarse, según la ocasión. Parece que es más fácil hacerlo a la inversa:

Si ves un enemigo lejos de tu base:

Atacar si:
- Supones que vencerías a tu enemigo.
- No tiene el rango suficiente como para contraatacar.
- No conoce la ubicación de tu base, se dirige a ella, y tú tienes la resistencia suficiente como para atacar, que te ataque, comenzar a huir (lejos de tu base) y que te persiga.
- Conoce la ubicación de tu base, no se dirige a ella, crees conveniente atacarlo cerca de ella, y tienes la resistencia suficiente como para atacarlo, que te ataque, comenzar a huir (hacia tu base) y que te persiga.

Acercarte a tu base si:
- Conoce su ubicación, crees conveniente atacarlo cerca de ella, y te está persiguiendo.

Alejarte de tu y del enemigo base si:
- No conoce su ubicación y te está persiguiendo.

También depende del tipo de soldado.

Tendrías que hacer esto para más casos, por ejemplo si un enemigo llega a tu base. Aunque en ese caso parece obvio qué hacer.

Lo ideal sería que la IA pudiera aprender, pero es muy difícil así como para empezar.


Por otro lado, yo te intenté responder sobre la estrategia, pero codificar cómo aplicar las acciones también es difícil, quizá más. Pero para eso se necesita tener un poco del código del juego, si no das más datos menos puedo ayudarte.

Suerte y si hallas una solución publícala en lo posible!

Acabo de probar esto
Y la condición no se cumple. ¿Conclusiones de cómo se interpreta? Escucho.

NOTA: Puse números en vez de variables porque así me es más fácil modificarlos y ver si se cumplen o no. Está claro que jamás voy a poner subcondiciones que dan siempre el mismo resultado xD

Podemos resumir cada subcondición mediante un número fácilmente porque lo que está a la derecha es como un identificador:
0<1: subcondición nro 1
0<2: subcondición nro 2
etc

Si se cumplen la 1, 2 y 3, entonces la condición se cumple. Ya lo comprobé, les puse 0 delante a las 3 y 9 delante en las demás, o sea, sólo se cumplieron esas 3 y con eso ya alcanzó.

Es como si se hiciera esto:
(0<1 && 0<2 && 0<3) or (8<4 or 0<5 && 8<6 && 9<7 or 9<8)

Si se cumple la 4. se cumple la condición, ya está confirmado.

Es así:
(0<1 && 0<2 && 9<3) or (0<4) or (0<5 && 8<6 && 9<7 or 9<8)

Si se cumple la 5, 6 y 7, se cumple la condición. Si falla una y las demás, no se cumple.

(0<1 && 0<2 && 9<3) or (0<4) or (0<5 && 8<6 && 9<7) or (9<8)

Listo...

En conclusión, es como si las or marcaran el final de un paréntesis y el inicio de otro.

Todo esto puede parecer muy obvio, pero yo no sabía si se interpretaba así:
(0<1 && 0<2) && (9<3 or 8<4 or 0<5) && (8<6 && (9<7 or 9<8)
o de alguna de las no sé cuántas formas posibles.


Ahora la siguiente pregunta que había planteado.

Cosas como esta:
(9<1 or 0<2) && (9<3 or 0<4)
¿Se pueden expresar sin paréntesis, en una condición, tal como se hace en el lenguaje que he mostrado (porque las notaciones polacas que me comentaron son interesantes, pero en el Action Script que uso no creo que sean válidas)?

No se me ocurre.

Lo que se podría hacer es usar ifs anidados (me lo habían comentado pero no me dieron detalles, recién ahora lo entiendo):

Creo que mis dudas en este sentido están resueltas.

Gracias.

Yo diría que hiciste ambas cosas xD

Creo que te desviaste porque creo que me hablaste de cómo interpretar cosas que tienen paréntesis, lo cual yo ya sé, yo lo que quería era entender cómo se interpreta algo que no los tiene.

Pero me ayudaste porque me hablaste de que "y" une y "o" separa. La verdad eché un vistazo a tu post hace rato y no entendí mucho, pero tu idea se ve que me quedó y me ayudó con el análisis que hice arriba.

Qué interesante. Recientemente había empezado a escribir así por ejemplo "rojo (y amarillo) o azul", porque sino veía una ambigüedad. Con tu forma de poner paréntesis también está bien, lo que quiero decir es que el problema o la duda yo l@ tenía no sólo en programación sino en el lenguaje natural también. Y aunque se diga que está clarísimo yo lo seguiría agarrando con pinzas, o con paréntesis, jaja.

También me gustó tu idea de resumir conjuntos de subcondiciones. Eso de llamarles "amarillo" por ejemplo. Me puede servir.

¿Pero esto sirve de algo? Alargaste la expresión. Y no es que hayas quitado los paréntesis.

El Benjo:
Sin paréntesis me hago un lío en casos como este:
((A y B) y (C o D) o (E y F)) o G
Creo que tendré que usarlos. El problema es que un programa que genere ese tipo de expresiones, con paréntesis, me parece bastante difícil. Por otro lado ¿cómo expresarías eso, sin paréntesis? Porque mi pregunta era si se podía expresar cualquier cosa sin paréntesis. Yo pensé que sí, pero como no me da la mente para interpretar de izquierda a derecha como si tuviese sólo una interpretación, ya no sé.

El artículo de wikipedia está interesante, pero difícil, no lo entendí del todo. En el 2ndo ejemplo de propiedad distributiva no han quitado los paréntesis. ¿Y se supone que el and tiene prioridad como si fuese un *?

Digamos que tienes razón en que no pueden decir nada al respecto, pero yo no pedí que hablaran de ello.
Dije que no sé si mi lenguaje admite paréntesis en las condiciones, ejemplo "V1<V2 or (V1==V2 and V2==V3)" ni cómo las toma, lo cual evidentemente es algo que yo debo averiguar, no pedí ayuda con eso.

Action Script de Macromedia Flash 5. Es prácticamente el único que uso y mi favorito.

Puse inventar entre comillas, significa en ese caso que la expresión se tome con pinzas, que no es tan literal. Nunca había visto paréntesis en una condición para separar partes or-and, y se los puse, o sea que desde mi punto de vista es algo nuevo.

Sí.

Exacto, las expresiones que mencioné parecen ser ambiguas, es lo que quisiera saber cómo arreglar, en lo posible sin usar paréntesis.

No entiendo tu critica.

Ante mi pregunta
"¿Cualquier relación puede expresarse sin necesidad de paréntesis, y se interpretaría bien?"
no veo un problema.

La que tú preguntas parece responderse sólo, como ¿hay alguna forma de hacer triángulos que no requiera algún ángulo >90? Claro, la mayoría no lo requieren.

El problema son las expresiones que parecen requerirlo (a algún paréntesis) ¿realmente lo requieren o hay otra forma de decirlas que no use paréntesis?

Por ejemplo si digo "rojo" y pregunto ¿hay alguna forma de expresar ese color sin mencionar la "o"? Me puedes decir "Sí, red", entre otras cosas.

EDIT:
En tu caso diciendo "requiera" en vez de "requieran", ahí sí.
Porque si dices "requieran" pareces referirte a las expresiones, no a LA forma o método.

...

Hombre, yo estoy hablando de los operadores AND y OR.

Tú me vienes con +, *, -.

Por el link que me dió El Benjo parece que se pueden traducir a eso, pero intenta no entreverarme ¿estamos hablando de lo mismo o no?

Notación de infijo (o normal): Las que solemos usar, porque las entendemos bién al 'leerlas', los operadores aparecen a ambos lados y el operador en medio.
Ejemplos: A o B
(A y B) o (C-(D y E)) <-- nota que los ejemplos son los mismos para los 3, para que veas las diferencias).
Notación de prefijo (o polaca): Los operadores van delante, los operadores detrás.
Ejemplos: oAB; oyABC-yDE
Notación de sufijo (o postfijo, inversa):Los operandos van delante, los operadores al final.
Ejemplos: ABo; AByCoDEy-

En tus descripciones de los operadores te has hecho un lío, pero la idea la entendí gracias a los ejemplos.

EDIT2: El "xor" y cosas así más complejas que and y or creo que no las necesito, pero supongo que acortan ciertas expresiones, veremos...

Probablemente sea la respuesta que necesitaba. Lo que no entiendo bien es cómo se interpretaría cada uno, pero sería cuestión de investigar y de práctica.

Más bien necesito lo inverso, pero veremos.

Sí, la verdad que sí. Pero si son como las expresiones matemáticas entonces no. ¿Cómo interpretarías esto, si fueses de izquierda a derecha?
A y B y C o D o E y F o G

Yo
ABC o D o E y (F o G)

Pero si fuese como en matemática sería:
ABC o D o EF o G

Ni siquiera sé de lo que me estás hablando. Para mí pila es un "aparato" que se guarda en otros para darle energía, o una montaña con cierto orden.
Ni te preocupes en aclarármelo, sólo te comento.

Voy a tener que practicar cosas. Nos veremos.

Me falta experimentar, sí. Los paréntesis los "inventé" para mostrar que una misma expresión (sin paréntesis o sin suficientes paréntesis) se podría interpretar de distintas formas según dónde se pusieran. Nunca usé paréntesis en una condición, no sé si mi lenguaje lo admite.

Igual te faltó responder algo:
¿Cualquier relación puede expresarse sin necesidad de paréntesis, y se interpretaría bien?

En otro sitio me recomendaron "ifs anidados, arrays, funciones, y objetos" pero no entiendo bien cómo aplicar esas cosas en este asunto.

Como siga así voy a tener que practicar hacer las complicaciones manualmente y cuando tenga más experiencia con eso intentar pasar a este nivel. No pensé que fuese tan difícil.

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?

Te explico.

No soy de leer o hacer cursos, soy mas bien de pensar e intentar hacer cosas pidiendo ayuda, o sea que no conozco mucho los tecnicismos y no me interesan.

Leí un manual para principiantes, de BASIC, hice un curso de Clipper, y desde entonces hago cosas con MACROMEDIA Flash 5 porque no he visto otro IDE/lenguaje que me gustara más. Su lenguaje es Action Script 1.0 digamos (dije "digamos" porque no sé si en aquella época le ponían un número a la versión),

Es muy similar a BASIC, pero hay "clips de película" con propiedades como su posición en la pantalla, que puedes cambiar con una línea de código. Nada que ver con Clipper donde sólo podías pintar la pantalla usando ciertos rectángulos con puntitos y si querías mover un dibujo hecho de ellos tenías que borrarlos y crearlos en otro lugar, cosa que requería muchas líneas de código. En BASIC creo que se podían crear circulos y cosas por el estilo pero nunca usé tanto eso y creo que no podías moverlo, tenías que borrarlo y redibujarlo.

El punto es que veo por ejemplo
y más allá de alguna condición que están diciendo ahí, no entiendo una m*****, nunca vi algo así.

¿Están creando una variable?

¿Qué es lambda? Me da asco porque no suena a nada salvo a lambida. Lo acabo de buscar:
https://es.wikipedia.org/wiki/Expresi%C3%B3n_lambda
Lo más parecido que he visto es "function", pero rara vez le pongo parámetros a las que creo, y jamás he visto que se le pongan condiciones o lo que sea que le han puesto.

El código en cuestión me lo han dado como respuesta a algo que pedí, más o menos así:
"Quisiera hacer un programa que genere X sentencias condicionales entre Y variables, de modo que no se contradigan".
Por ejemplo si las variables son A, B, C y D, el programa podría generar A<B, B<C, A<C y así sucesivamente, no pretendo que evite redundancias (en el ejemplo, A<C lo es), pero contradicciones sí: Si generó A<B no quiero que genere A==B, por ejemplo.

Bueno, comienza con una función que parece al p***, porque si pregunto cómo hacer una pizza por ejemplo no pones al inicio "receta para hacer pizza, sartén (vacía), tomates(en la mesa)" o vaya a saber qué cosas, me dices los pasos a seguir y listo.

¿Qué es esto? ¿están definiendo una variable? Pero de valor le están poniendo algo que no han definido aún.

Siguen definiendo cosas con algo que aún no definieron.
Esto "[:]" no sé qué es, imagino que marca el tipo de variable (en AS nunca hago eso, se define automáticamente basado en el valor que le ponga), pero está claro que no sé cual es, y menos si no han definido qué es "inequations".
¿Acaso todo este código es para usar una vez que se haya definido eso? Entonces me dieron algo bastante distinto de lo que pedí porque yo no tengo una variable llamada inequations. A lo mejor es que una vez generadas las sentencias condicionales (les había llamado inecuaciones, ahora que recuerdo), esta función analizaría si contradice a las demás, inecuaciones iría variando...

En fin, quiero el pseudocódigo.

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

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

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


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

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

Vuestro turno, gracias.