Foro SofosAgora

Foro abierto a los intereses de sus usuarios. Debate, aprende y diviértete.
Fecha actual 18 Oct 2018, 07:03

Todos los horarios son UTC + 1 hora [ DST ]




Nuevo tema Responder al tema  [ 27 mensajes ]  Ir a página Anterior  1, 2, 3  Siguiente
Autor Mensaje
NotaPublicado: 10 Abr 2018, 23:04 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8489
Tachikomaia escribió:
martesk escribió:
Primero junto los que tienen la A:
Si A <B y D <A
entonces:
D < A < B

Ahora pongo juntas las que incluyen la siguiente letra de tu ejemplo la C:

Código:
A = "No listado"
B = "No listado"
C = "No listado"
D = "No listado"
martesk.

Si vas juntar las inecuaciones que tienen el 1er elemento que aparezca en la 1er inecuación, y luego las del 2ndo y así sucesivamente, tienes que marcar de algún modo qué elementos has "listado", sino podría ser que listes más de una vez el mismo.

¿Hasta ahí bien?

Simplemente he marcado que inicialmente ningún elemento ha sido listado o juntado.

Código:
Inecuaciones = 4
// Listar el 1er valor paso 1/2.
Lista1parte1 = condición1valor1
Lista1parte2 = condición1valor2
Lista1tamaño = 2
Si vamos a analizar varias inecuaciones necesitamos saber cuantas son. O al menos están escritas en algún lado, sus partes tienen un ID (en vez de decir en el renglón 2 a la izquierda decimos Condición2parte1, por ejemplo), tenemos que hacer una especie de cabeza cuyos ojos se vayan moviendo por el lugar donde estén escritas, y tenemos que decirle cuando dejar de moverse. Esto es, cuando analizó 4 inecuaciones.

Si la 1era inecuación es A<B y los ID son estos: condición1valor1 y condición1valor2, entonces hacer esto:
Lista1parte1 = condición1valor1
Lista1parte2 = condición1valor2
...equivale más o menos a hacer esto: AB

En vez de escribir como un texto normal, las cosas se organizan, más o menos como una tabla de excel. Cada escrito tiene un sitio donde está escrito. Escribimos A<B, sí, pero lo hacemos en ciertos sitios. Esos sitios se llaman condición1valor1 y condición1valor2. Les llamo condición porque trabajo con condiciones, la diferencia es que pueden tener signos de "==", o sea que podrían ser ecuaciones, pero es sólo un nombre, en este tema sólo hablamos de inecuaciones.

No sé explicártelo mejor, el tema es que estoy haciendo un programa que genera condiciones (o inecuaciones) al azar, y quiero evitar que genere contradicciones.
Y las cosas resultan más fáciles de analizar si están en un sitio.
Las computadoras en general no funcionan de modo en que uno les digas "dime si A<B y B<A es una contradicción". Porque para que entiendan eso tendrían que buscar donde empieza el 1er dato, dónde termina, dónde empieza el 2ndo, etc.
Por eso la forma conque están los datos, en mi caso, es:
Condición1valor1 = "A"
Condición1valor2 = "B"
Condición2valor1 = "C"
Condición2valor2 = "D"
Date cuenta que los signos < ni siquiera están escritos, porque como siempre son el mismo, por ahora, no es necesario.

El tamaño de la lista si mal no recuerdo es para ver desde qué posición debe empezar a correr los valores hacia adelante, si es necesario.

Cuando tienes AB y luego aparece D<A, simplemente pones la D delante de la A.

Bueno, tal vez hacer simplemente
ListaA = "DAB"
sea suficiente, no habría necesidad de
Lista1parte1 = condición1valor1
Lista1parte2 = condición1valor2
Lista1tamaño = 2
pero tengo mis dudas.

Pero bueno, de esta forma sería:
ListaA = condición1valor1+condición1valor2
Son letras, A y B. El resultado sería "AB".

Ahora hay que ir revisando las demás inecuaciones. ¿Cómo ver si hay una A y debe agregarse en la lista? Nosotros simplemente miramos de izquierda a derecha o al revés y si vemos una A ya está. La máquina tiene que hacer cosas como
Si condición2valor1 == "A" or condición2valor2 == "A"

En fin, luego lo hago, pero la verdad no sé qué me pasa, es como que me harta hacerlo.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 11 Abr 2018, 06:21 
Desconectado
Avatar de Usuario

Registrado: 10 Sep 2017, 20:00
Mensajes: 1034
Ubicación: España
Rango personalizado: Aprendiz del viento
Creo que te explicas muy bien, casi te entiendo más o menos sin saber programar ni bases de datos.

Es interesante también que Mustafá dijo que las inecuaciones son rangos, es cierto, si das valores hay que recordar eso.

Citar:
Tachikomaia
En fin, luego lo hago, pero la verdad no sé qué me pasa, es como que me harta hacerlo.


Si para ti es importante hay que provocar un poco de obsesión con eso. Te hace aprender y te hace más fuerte en tu conocimiento informático. Sobre todo te hará sentir mejor contigo si te esfuerzas en ello.
Si nos cuentas tus progresos también puede ayudarte, a veces compartirlo ayuda mucho para darse voluntad en algo.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 11 Abr 2018, 08:42 
Desconectado
Avatar de Usuario

Registrado: 03 Ene 2018, 17:00
Mensajes: 304
Tachikomaia escribió:
el tema es que estoy haciendo un programa que genera condiciones (o inecuaciones) al azar


Condiciones e inecuaciones no son lo mismo.
Partamos de que quieres programar un algoritmo que genere sistemas de n inecuaciones lineales en R2 con solución.

1) Genera las n rectas:

Si la ecuación de la recta es y = Ax + B, genera n ecuaciones donde A y B son números aleatorios.
y = random() x + random()

Por ejemplo para n=3 genera tres rectas aleatorias.

y = 3x + 5
y = x - 2
y = -2x + 3

Descarta sistemas de rectas que no intersequen.
La condición de intersección para cada par de rectas es que exista solución a su sistema.

Por ejemplo { y = 5x + 1, y = 5x + 2 } no intersecarían porque 1 ≠ 0, (5x + 1 ≠ 5x + 2)

2) Elige un punto aleatorio en R2.

v = (x,y) = (random(), random())

Por ejemplo (1, 4)

3) Modifica el signo de igualdad de cada recta generada aleatóriamente para que englobe tu punto v aleatorio.

Primera recta:

y = 3x + 5, x = 1 ⇒ y = 3+5 = 8
4 < 8 ⇒ el signo para esa recta es <

Segunda recta:

y = x - 2, x = 1 ⇒ y = 1-2 = -1
4 > -1 ⇒ el signo para esa recta es >

Tercera recta:

y = -2x + 3, x = 1 ⇒ y = -2+3 = 1
4 > 1 ⇒ el signo para esa recta es >

4) Ya tienes un sistema de n desigualdades, garantizando que tiene solución (que engloba al punto v):

y < 3x + 5
y > x - 2
y > -2x + 3

Lo que me extraña, Tachikomaia, es que todo esto es trivial.
Así que me huelo que tu objetivo final no es generar sistemas de inecuaciones.
Quizá busques generar sistemas lógicos sin referencias circulares, o un prototipo de la perceptrón de Skynet, o algo así.
En mi opinión, y no es una crítica, te complicas demasiado.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 11 Abr 2018, 21:49 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8489
Mustafá Mond escribió:
Tachikomaia escribió:
el tema es que estoy haciendo un programa que genera condiciones (o inecuaciones) al azar


Condiciones e inecuaciones no son lo mismo.
Con condiciones me refiero a este tipo de cosas:
C <= F && (C != V or C2 == V)

Si es poco exacto decir condición dime una palabra más exacta si sabes.

En este tema estoy simplificando.
- En vez de C, V, C2, etc, es A, B, C...
- En vez de <=, ==, etc, sólo es <.

Las inecuaciones son un tipo de condición. Las condiciones "<" son inecuaciones. Es lo que trato aquí.

El programa por si te interesa (aunque muy incompleto)
Spoiler: show
Código:
Cs = 0;
Vs = 0;
Fs = 0;
Lets = "CVF";
Val1 = Lets.charAt(random(3));
LetCant_Refonly = Val1+"s";
LetCant = eval(LetCant_Refonly);
LetNum = random(LetCant+1)+1;
Cond1Val1 = Val1+LetNum;
if (LetCant<=LetNum) {
    set (LetCant_Refonly, LetCant+1);
}
if (Val1 != "F") {
    Val2 = Lets.charAt(random(3));
} else {
    Val2 = Lets.charAt(random(2));
}
LetCant_Refonly = Val2+"s";
LetCant = eval(LetCant_Refonly);
LetNum = random(LetCant+1)+1;
Cond1Val2 = Val2+LetNum;
if (LetCant<=LetNum) {
    set (LetCant_Refonly, LetCant+1);
}
trace (Cond1Val1+" < "+Cond1Val2);
stop ();


Citar:
Partamos de que quieres programar un algoritmo que genere sistemas de n inecuaciones lineales en R2 con solución.
No entiendo.

Citar:
1) Genera las n rectas:
Idem...

Citar:
Si la ecuación de la recta es y = Ax + B, genera n ecuaciones donde A y B son números aleatorios.
y = random() x + random()
Parece que hablamos de cosas diferentes. Yo no intento que un programa me muestre todos los posibles valores o soluciones para una ecuación de la que no le digo algún valor.

No quiero dar la explicación larga, para simplificar ten en cuenta que un programa puede generar texto:
Generación 1: "A"
Generación 2: "B"
Generación 27?: "AA"

Con minúsculas si quieres.

Bueno, ya lo hice, y ahora quiero que genere condiciones o relaciones entre valores, usando las letras que te comenté arriba. Algo así:
Generación 1: "C < F"
Generación 2: "C <= F"
Generación ?: "C == F && C < V && C == V2"

Lo que estoy preguntando en este tema es cómo, habiendo generado una condición, veo si esa condición tiene contradicciones o no.

Yo no veo necesidad de complicarse con rectas. Tampoco ver todos los posibles números, es imposible porque los hay decimales, son infinitos. Bueno, con las rectas podría verlo todo dentro de cierto rango, pero me parece complicado usar rectas.

Además vos pareces partir de una ecuación. Si me estás respondiendo cómo generar condiciones (que no lo pregunté) no lo estás haciendo, creo, estás generando soluciones.

Citar:
Lo que me extraña, Tachikomaia, es que todo esto es trivial.
No para mí...

Citar:
Así que me huelo que tu objetivo final no es generar sistemas de inecuaciones.
Si tú lo dices, que pareces saber más matemática que yo, será así. ¿Pero qué busco entonces?

¿Qué es esto?
A < B
B < C
C < D

¿Relaciones entre valores?

Pues eso.

Sé cómo generarlas, tengo que arreglar el programa, pero bue. El problema es que se generan al azar, entonces puede haber contradicciones. Pregunto pues cómo detectarlas. Si pudiera generar relaciones que no sean contradictorias mejor, pero creo que pido algo más sencillo que eso.

Generar condiciones es fácil.

Condición1parte1 puede ser C1, V1 o F1.
Simple azar.

Condición1signo puede ser alguno de los símbolos. Más o menos igual de fácil.

Condición1valor2 puede ser C, V o F, y dependiendo de la cantidad de Cs, Vs y Fs hasta ahora, puede ser también C2, V2 o F2.
Esto es lo que me complica por ahora, por algún motivo, pero no estoy pidiendo ayuda con eso.

La ayuda que pido es... bueno, ya lo dije como 5 veces...

Spoiler: show
Una vez que se generen valores y símbolos para una condición, por azar se decide si generar otra o no. Si se generan varias quiero que el programa me diga si se contradicen.


Pero acá simplemente trato símbolos < y valores A, B, etc. Otros símbolos son otro tema.

Citar:
Quizá busques generar sistemas lógicos sin referencias circulares, o un prototipo de la perceptrón de Skynet, o algo así.
Lo dudo mucho. Luego investigo qué son esas cosas.

Citar:
te complicas demasiado.
Lo curioso es que intento hacer la vida más fácil xD
Es complicado eso.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 12 Abr 2018, 09:22 
Desconectado
Avatar de Usuario

Registrado: 03 Ene 2018, 17:00
Mensajes: 304
Tachikomaia escribió:
Con condiciones me refiero a este tipo de cosas:
C <= F && (C != V or C2 == V)


Hola Tachikomaia.

Una inecuación, hablando coloquialmente, es una ecuación matemática que presenta un operador de comparación donde normalmente esperarías encontrar uno de igualdad.

R2 significa que el ejemplo que te puse era para inecuaciones de dos variables cuyos valores eran números reales (=con posibles decimales :roll:).

Pero es evidente que tú no buscas eso.
Si te entiendo bien, tú buscas generar sentencias condicionales aleatorias de n variables que sean cumplibles.
Qué utilidad podría tener un programa así, no lo sé.
Pero vamos al ajo: a falta de un método más depurado, creo que deberías empezar por generar una tabla de la verdad.

Imaginemos n=3. Es decir, tu algoritmo va a generar tres condicionales jugando con tres variables.

1) Generas las variables:

{A, B, C}

2) Genera el primer condicional:

A < B

El operador es aleatorio =,>,<,≥,≤,≠, y las variables que relaciones también son aleatorias.
Este es cierto de forma trivial siempre que uses variables distintas (por ejemplo A>A podría ser falso, y de hecho lo es).

3) Introduce el condicional que acabas de generar en tu tabla de la verdad:
(lo lamento, pero al escribir tablas en un foro web me van a quedar destabuladas)
NOTA: ? es un wilcard.

Código:
   A    B    C
A  =    <    ?
B  >    =    ?
C  ?    ?    =


4) Genera el segundo condicional:

B > C

Mismas consideraciones que antes.

5) Verifica que el condicional es posible en tu tabla de la verdad:

Vas a la fila B, columna C, y si te encuentras algo que contradiga el > sabrás que el condicional es imposible.
En este caso hay una ? que he utilizado para indicar que todos los casos son posibles, luego el condicional generado es bueno.

6) Actualiza tu tabla de la verdad con el nuevo condicional generado:

Código:
   A    B    C
A  =    <    ?
B  ?    =    >
C  ?    <    =


7) Genera tu tercer condicional:

Ejemplo, te sale: C > A
La tabla de la verdad (fila C, columna A) dice que ?, luego es válido.

Ejemplo, te sale: C < A
La tabla de la verdad (fila C, columna A) dice que ?, luego es válido.

Ejemplo, te sale: C > B
La tabla de la verdad (fila C, columna B) dice que <, no puede ser < si la tabla dice >, luego es inválido.

¿Pillas por donde vamos?.

8) Entonces la expresión condicional booleana (A < B) && (B > C) && (C < A) es cumplible,
y con ello tu algoritmo ya genera casos simples de lo que pedías.

Puedes extender el algoritmo a cualquier número de variables, de condicionales, y de operadores booleanos (&, |, !, etc) como quieras si al consultar la tabla de la verdad tienes en cuenta el operador booleano que vas a aplicar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 12 Abr 2018, 23:33 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8489
Fail.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Última edición por Tachikomaia el 13 Abr 2018, 02:53, editado 1 vez en total

Arriba
 Perfil  
Responder citando  
NotaPublicado: 13 Abr 2018, 01:31 
Desconectado
Avatar de Usuario

Registrado: 10 Jun 2011, 21:52
Mensajes: 4494
Haces todas las combinaciones de dos en dos, si juntas dos tal que X < Y, Y < Z, entonces añades otro X < Z, si ya lo tenías lo descartas, si no lo tenías haces las combinaciones con todos los anteriores, hasta que no puedes añadir nuevos. Si durante el proceso llegas a V < V, entonces es que hay una contradicción, si no, no la hay.

_________________
Spoiler: show
Imagen


Arriba
 Perfil  
Responder citando  
NotaPublicado: 13 Abr 2018, 03:30 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8489
Mustafa

Te dije "Muy buen método", pero tras pensar cómo aplicarlo me parece que en realidad no sirve.

Spoiler: show
Mustafá Mond escribió:
R2 significa que el ejemplo que te puse era para inecuaciones de dos variables cuyos valores eran números reales (=con posibles decimales :roll:).
Lo de R=Reales siempre se me olvida. Lo de "al cuadrado" no lo agarro ni con un halcón entrenado.

Citar:
Si te entiendo bien, tú buscas generar sentencias condicionales aleatorias de n variables que sean cumplibles.
Digamos que sí, aunque N sería aleatorio también.

Respuesta más realista (el doble spoiler no funciona como debe, pero la intención está):
[spoiler2]En este tema sí, aunque yo pregunté cómo detectar si son cumplibles, es decir, una cosa es A):
1- Generar sistema de inecuaciones.
2- Chequar que sea cumplible. Volver al punto 1 en caso de que no.
y otra cosa es B):
1- Generar sistema de inecuaciones cumplibles.

Yo estoy pidiendo el paso 2 del método A. Creo que es el menos exigente. Y no pido todo el método, sólo la parte 2.[/spoiler2]

Citar:
Qué utilidad podría tener un programa así, no lo sé.
Quiero hacer un programa que me diga cómo lograr ciertas cosas. No sé hacerlo. Para aprender a hacerlo supongo que me serviría hacer programas similares aunque más sencillos. Ya hice uno de los más sencillos. Puedo complicar manualmente los problemas a resolver (ergo también los programas), parte de ello consiste en complicar las condiciones que deben cumplirse. Pero para qué hacerlo yo, si puedo hacer un programa que genere condiciones. Si puedo...

Citar:
El operador es aleatorio =,>,<,≥,≤,≠
De hecho el > y => no los uso. Dicen algo que se puede decir de otro modo (con los < y <=, e invertir los valores), y resulta más sencillo (lo menor a la izquierda, como en los ejes de las x).
Los resultados van a ser los mismos...

Citar:
Este es cierto de forma trivial siempre que uses variables distintas (por ejemplo A>A podría ser falso, y de hecho lo es).
Es algo que debo evitar. No es tan difícil supongo.


Citar:
3) Introduce el condicional que acabas de generar en tu tabla de la verdad:
NOTA: ? es un wilcard.

Código:
   A    B    C
A  =    <    ?
B  >    =    ?
C  ?    ?    =
Bien. Yo estaba pensando que sería innecesario poner signos diferentes en cada caso, pero veremos.

Citar:
A < B
B > C

7) Genera tu tercer condicional:

Ejemplo, te sale: C > A
La tabla de la verdad (fila C, columna A) dice que ?, luego es válido.

Ejemplo, te sale: C < A
La tabla de la verdad (fila C, columna A) dice que ?, luego es válido.
Acá es donde está el error que no vimos, creo.

¿Qué pasaría si los 2 1eros resultados fuesen A<B y B<C?
Que C<A daría una contradicción, pero tu método, que yo sepa, no lo vería.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 13 Abr 2018, 03:34 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8489
Nil escribió:
Haces todas las combinaciones de dos en dos, si juntas dos tal que X < Y, Y < Z, entonces añades otro X < Z, si ya lo tenías lo descartas, si no lo tenías haces las combinaciones con todos los anteriores, hasta que no puedes añadir nuevos. Si durante el proceso llegas a V < V, entonces es que hay una contradicción, si no, no la hay.
Lo pensaré.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
NotaPublicado: 13 Abr 2018, 11:21 
Desconectado
Avatar de Usuario

Registrado: 03 Ene 2018, 17:00
Mensajes: 304
Tachikomaia escribió:
Acá es donde está el error que no vimos, creo.

¿Qué pasaría si los 2 1eros resultados fuesen A<B y B<C?
Que C<A daría una contradicción, pero tu método, que yo sepa, no lo vería.



Tienes razón. Muy bien visto.

Necesitas cambiar el algoritmo para que cada vez que actualices la tabla de la verdad no solo modifique la fila y columna actuales, sino que la recorra recursivamente.

Pero eso no es eficiente.

¿Y si lo planteamos al revés?:
Primero generamos todas las variables implicadas en orden aleatorio,
y posteriormente generamos algunas sentencias correspondientes a ese orden.

Por ejemplo, c# para 5 sentencias con un máximo de 20 variables:

Código:
        static void Main(string[] args)
        {
            // buffer resultado.

            StringBuilder sb = new StringBuilder();

            // colección de las n variables implicadas.

            List<char> entities = "ABCDEFGHIJKLMNOPQRST".ToCharArray().ToList();

            // orden aleatorio de las variables.

            Random rnd = new Random();
            entities = entities.OrderBy(x => rnd.Next()).ToList();

            // 5 bloques condicionales aleatorios.

            for (int i = 0, len = 5; i < len; i++)
            {
                // dos variables al azar.

                int idx0 = rnd.Next(entities.Count);
                int idx1 = rnd.Next(entities.Count);

                // protección para que no sean iguales.

                while (idx0 == idx1) idx1 = rnd.Next(entities.Count);

                // genera la condición.

                if (sb.Length > 0)
                {
                    if (rnd.NextDouble() >= 0.5)
                    {
                        sb.Append(" && ");
                    }
                    else
                    {
                        sb.Append(" || ");
                    }
                }

                if (idx0 > idx1)
                {
                    sb.Append("(" + entities.ElementAt(idx0) + " > " + entities.ElementAt(idx1) + ")");
                }
                else if (idx0 < idx1)
                {
                    sb.Append("(" + entities.ElementAt(idx0) + " < " + entities.ElementAt(idx1) + ")");
                }
            }

            Console.WriteLine(sb.ToString());
            Console.ReadLine();

            return;
    }


Nota que no me preocupo de no repetir condicionales, ni de generar buenos números aleatorios, ni de generar sentencias muy complicadas.

PD: Un espacio vectorial se nombra con el tipo de números que contiene y la cantidad de grados de libertad con que lo dimensionas. R2 no es R al cuadrado, sino el espacio de los números reales de dos dimensiones.


Arriba
 Perfil  
Responder citando  
Mostrar mensajes previos:  Ordenar por  
Nuevo tema Responder al tema  [ 27 mensajes ]  Ir a página Anterior  1, 2, 3  Siguiente

Todos los horarios son UTC + 1 hora [ DST ]


¿Quién está conectado?

Usuarios navegando por este Foro: Bing [Bot] y 1 invitado


No puede abrir nuevos temas en este Foro
No puede responder a temas en este Foro
No puede editar sus mensajes en este Foro
No puede borrar sus mensajes en este Foro

Buscar:
Saltar a:  
POWERED_BY
Traducción al español por Huan Manwë para phpbb-es.com
phpBB SEO