Foro de elhacker.net

[(p>q).(q>r)]>(q>r)

V V V   V   V V V   V    V V V
F V V   V   V V V   V    V V V
V F F   F   F V V   V    F V V
F V F   V   F V V   V    F V V
V V v   F   V F F   V    V F F
F V v   F   V F F   V    V F F
V F F   F   F V F   V    F V F
F V F   V   F V F   V    F V F

ENTONCES EL RESULTADO ES:

V
V
V
V
V
V
V
V

LO QUE DEJA COMO UNA CONCLUSION VALIDA

Alguien sabe de esto? es logica que aprendi en filosofia, quiero hacer un programa que al yo introducir lo de arriba de todo me diga el resultado, es decir que termine el resultado en un array supongo.

Si alguien que sepa de esto se pone a pensar conmigo le agradezco mucho.

Yo ya se lo de los signos, cuando uno es verdadero y el otro falso y es el . entonces el resultado es falso, etc etc
Eso lo se, solo pido que me digan como lograrian a hacer el programa? solamente por arriba que me digan, pero pensando como lo codearian porque si me dicen:

"Haria los parentesis ( ) primero y luego los 2 primeros con el . y el resultado de eso con el otro termino que esta en parentesis que sacamos su resultado y lo hacemos con el > para obtener el final.

Si, bien pero con codigo? xDD y si por ejemplo pone esto: [(p>q)>(r>q)].[(p.r)>(p>q)] ??

Al que le guste esto y quiera ayudarme le agradezco!!

gracias!

Esto es mas o menos difícil de programar, que conocimientos tienes?, yo lo programe en haskell hace tiempo tal vez te sirva. Si lo deseas ver me avisas.

fa no conozco ni ese lenguaje pero pasalo que talvez entiendo algo.

Y dices que es dificil, pero una vez que se logra la idea de como hacerlo lo otro es facil, a mi me falta el pensarlo xD yo no se mucho de programacion talvez pero ya hecho cosas asi parecidas aunque talvez no tanto, hace poco hice un programa que el usuario ingresaba una ecuacion desordenada como: 2x+8(4+3x(5+x)-4+3x)-10=45x-32x^2+48x-10 por ejemplo y te hallaba X , talvez puedo usar algun procedimiento que hice para eso pero necesito ayuda para pensar como hacerlo, es decir yo ya tengo creado 2 funciones, uno que recibira "(p>r)" por ejemplo y separa las preposiciones y el signo en arrays y un string para el simbolo y luego manda eso como parametro para la otra funcion que hace la "operacion" para devolver el resultado en un array.

Pero tengo problemas en como llegar a tomar esos datos de los parentesis, y como guardarme cuando ya hice 3 resultados por ejemplos, como saber cual de esos tendra que operarse con cual :/

Pasame el codigo y si me puedes explicar por arriba mejor ;)

Haskell es un lenguaje funcional, por lo tanto lo único que implemente son funciones, nada de cosas imperativas.

Bueno pero lo muestras o me explicas? o sino que fue lo que hiciste vs? xD

Las "ecuaciones" lógicas, puesto que siguen una sintaxis podría considerarse como un lenguaje de programación. Podrías hacer uso de Flex y Bison. Son dos programas que sirven para crear tu propio compilador, es algo complejo y tendrías que leer algún buen manual, pero me imagino que los resultados serían bastante buenos.

También, por supuesto, se podrá realizar un programa que examine para ver si todo es correcto y la "interprete" pero me imagino que también será algo difícil.

Saludos.

Pero no se ahoguen en un vaso de agua como estoy haciendo yo xD, si se toma la ecuacion como string no se podria capturar lo que esta entre los parentesis, guardar resultados en arrays, etc? algo asi quiero hacerlo simplemente, solo que no logro encontrar el algoritmo que funcione para todo tipo de ecuacion.

Lo más complicado me parece a mi que sería dar preferencia a lo que está entre corchetes, evaluarlo primero y luego evaluar el resto de la expresión.

Con expresiones regulares se podría hacer fácilmente. Supongo que también habría que comprobar que la ecuación es correcta, es decir, que no le faltan o le sobran paréntesis o corchetes.

Es dificil porque son muy distintas las formas que podra poner el usuario, pero yo tengo codigo que saque de mi proyecto de las ecuaciones q dije anteriormente y logro hacer que cuando la ecuacion es:

[(p>q).(q>r)]>(q>r)

me crea una lista de esta forma:

>
.
p>q
q>r
q>r

Pero no se como seguir desde ahi, esque una vez que tengo la operacion de (p>q).(q>r) no se donde guardarla para luego hacer esa con q>r y con el >

Pero seguire intentando, gracias por ayudar y si tienes otra idea perfecto :P


Y para los que no sepan de que es esto, simplemente imaginense un programa que te pida que ingreses una ecuacion del tipo:

[(3+4)*(4+5)]+(4+5)

Y sacar el resultado final, pero no haciendo distributivas ni nada, solo que el programa tome los numeros 3+4, tome el 4+5, tome el 4+5 otra vez porque pueden ser otros numeros.
Y luego mande a un procedimiento para que haga la primer suma, luego la segunda suma y a esos valores los multiplique. Y luego ese resultado lo sume con el resultado de lo otro.

He estado pensando en si podria ser mas facil si lo uso como deberia, es decir que:

p == 10101010
q == 11001100
r ==  11110000

Y entonces en la programacion haria el uso de operadores logicos y listo. En vez de:

p.q haria P and Q

Pero.. no se como hacer que me tome el resultado ni tampoco se por ejemplo en > que seria el Entonces, ni otros, pero quiero saber si seria mejor hacerlo asi como digo.

Te comento que tienes que trabajar con lógica Proposicional. Vamos, básicamente lo que estas haciendo, unas proposiciones que son las variables, y las conectivas que son los enlaces(&&, |, etc...).

El problema que tienen estos programas es que el algoritmo de resolución básico que harías(que son las tablas de verdad) tiene esta forma:

2^n

Donde n es el número de proposiciones(ya que pueden ser verdaderas o falsas).

Es un verdadero problema, ya que una vez que tengas un gran número de proposiciones se va a disparar el número de ejecuciones que vas a realizar. Para eso se han creado una serie de métodos(como sacarlo por contradicción) que hacen que el algoritmo tenga una complejidad menor. De hecho, asi fue como surgio uno de los primeros problemas np complejos, que todavia sigue sin resolver.

Pero bueno, el caso es que hay una pagina en la que se compite por ver quien es capaz de idear el algoritmo mas eficiente:

http://www.satcompetition.org

Se trata de saber si una fórmula es satisfacible, lo que usaras para ver si un razonamiento es correcto(el razonamiento deberia de ser siempre satisfacible).

http://es.wikipedia.org/wiki/Problema_de_satisfacibilidad_booleana#Algoritmos

En el apartado de algoritmos tienes un resumen, yo que tu me lo leeria, ya que el tema de logica es muy importante en el desarrollo de la computacion y la algoritmia en general, ademas de ser realmente fascinante.

Cualquier duda pregunta, que probablemente me pase poniendo conceptos XD

Un saludo!

eso de 2 a la n, lo hice ya, es decir mire que si tenia hasta la variable S serian 16 el tamaño de mis arrays para lo de VVVVVVVVFFFFFFFF para la preposicion S, pero claro si ponian otra variable mas ya mi codigo no funciona, pero es que mi idea era para hacer ejercicios que nos mandaba el profesor de filosofia, que son de los simples:

Si Juan estudia mucho entonces salvara el examen.
Juan estudio mucho por lo tanto salvara el examen.

[(p>q).(q)]>q

Creo que seria asi, como ves son cosas simples pero veo que para hacerlo bien de bien necesitare estudiar mucho asique lo dejo para cuando aprenda en la universidad mejor.

Aunque yo queria lograr hacerlo con lo poco que se hasta ahora, es decir tomando un string que ingresara el usuario en el programa como por ejemplo:

[(p>q).(q)]>q

Y mi programa haria (p>q) y lo guardaria en un array a su valor que sera un array de strings [ "V", "V", etc, etc]
Luego haria (q) y lo guardaria en otro array.
Despues haria lo mismo con q, para despues hacer el primer array con el segundo por medio del "." y ese resultado con el resultado del q por medio del >


Mis avances son:

- El programa capta el tamaño de esos strings, ya que puede aparecer otra preposicion y se hara mas largo el tamaño.
- Tengo un metodo que si le envias (p>q), te lee esas preposiciones para saber cuales son y cual es el simbolo ( el operador  ">" en este caso) y luego envia esos datos a otro metodo que devuelve el string[] resultado.

El problema que tengo es como ir guardando esos arrays de resultados, ya que pueden ser muchos, a veces pocos, etc. Pense en una lista de arrays ya que lo estoy haciendo en C# en .net y se me hace facil eso. Pero si una vez que los guarde en una lista, como se cuales son los que se tienen que operar otra vez y cual es el que queda al final?
La logica me llevo a que los 2 primeros en el ejemplo que puse, son los que se tienen que operar otra vez y luego el resultado de esos con el 3ero que es solamente "q".
Pero que pasa? cuando no es asi? cuando esta mas desordenado? con "[" por ejemplo aca me caga todo:

[(p>q)].[(q>r).p] -- para dar un ejemplo nomas.

Ya que ahi seria al revez, se operarian otra vez los 2 ultimos xD.
Y otra cosa, como leo el simbolo que hara que se operen otra vez esos 2, en este ultimo caso el "." ?


Si alguien leyo todo esto y lo entendio, se merece un premio jajaja

No te entendi un poroto :)

Y que parentesis, coges como prioridad? te habran enseñado los conectivos logicos supongo..y sabras su jerarquia.

Y sabiendo su jerarquia, debes saber que no hace falta que hayan parentesis en algunas proposiciones logicas. Asi que en lo que debes centrarte, es en analizar la proposicion, buscando los conectivos, dando prioridad para hacer la tabla de la verdad    a la conjunción y ddisyunción, luego a la condicional y por ultimo a la bicondicional.

Y apartir de ahi, vas sacando tablas y tablas hasta que llegas a hacer todo.

Yo la idea la tengo clara, loo que no tengo es el tiempo

Saludos

Mmm pero el usuario lo que ingresara sera la ecuacion , ya pensada por el, el programa solo hara las operaciones, fijate en mi penultimo mensaje a ver en que me podrias dar una mano