Autor
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:
// 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:
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:
Si V1C1 C1S V2C1
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:
// 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.
En línea
