Hola amigos como están, bueno tengo un pequeño inconveniente, casi siempre estudio y soluciono todo lo que puedo, pero esta vez si quisiera como una ayudita externa.

Resulta que necesito realizar una calculadora en notación polaca prefija, pero la debo hacer con signos de paréntesis, es decir, algo así: 5(7+(8-9)/6)*8

Hasta ahora solo he hecho códigos de prueba, pero nada en concreto. Y estoy un poco perdido porque no se como empezar, pensé en usar StringTokenizer, pero no logro encajar las cosas.

La idea, es que pueda dar el resultado perfecto de lo que se ponga, siempre y cuando lleve paréntesis. Pero no se como hacerlo :S

He pensado en hacer la entrada como cadena de caracteres y separarla, pero pierdo en el orden y en la jerarquía de los signos, si alguien sabe de algún método o código que me pueda pasar estaré muy agradecido.

De antemano muchas gracias por su colaboración y atención, estaré atento a sus respuestas.

Saludos

Gracias redfireblue ^^

mira, yo pensaria en usar otra clase mas que el StreamTokenizer
como Scanner porque StreamTokenizer es deprecated, y lo van a remover...

Atualmente te puede facilitar bastante...

Mas o menos la idea es andar leyendo -> es parentesis -> es signo -> es numero (en esa prioridad)

e ir viendo si cierras el parentesis, tienes que hacer la porcion de coigo referida a dicho parentesis... si abres "dejan en pausa la actual" y te pones con la nueva...

El codigo aun tengo que pensarlo, si se me ocurre algo actualizo...

Bueno, como el objetivo no es que sea la calculadora más rápida sino que funcione (la rapidez se verá después), creo que la idea más sencilla es:

Ve separando por los paréntesis más "profundos" o más a la derecha (si te fijas, da igual):
- indexOf ("(") e indexOf (")", lastIndexOf ("(") ) --> con esto puedes obtener el contenido del paréntesis que primero te interesa (un substring)
- Realizas las operaciones contenidas en él...
- ... Y sustituyes en la cadena original

Ejemplo (lo hago con sumas para que sea lo más simple posible):

Cadena de entrada: 4+(7+5)+(8+(6+3))+(2+3)

1) obtenemos el paréntesis abierto más a la derecha:
Resultado: (2+3)
2) realizamos la operación:
Resultado: 5
3) sustituímos en la cadena original:
Resultado: 4+(7+5)+(8+(6+3))+5

Volvemos al paso 1):
(6+3) = 9 --> 4+(7+5)+(8+9)+5
Otra vez:
(8+9) = 17 --> 4+(7+5)+17+5
Y la última:
(7+5) = 12 --> 4+12+17+5

Ahora solo hay que realizar las operaciones que quedan y listo.



Consejos de construcción:

- Crea un método que calcule cualquier operación básica (ej: 2+3 --> 5):
double calcular (char operacion, double valor1, double valor2)

- Crea un método que, dados dos operadores, indique cuál tiene prioridad:
boolean obtenerPrioridad(char operador1, char operador2)

- Crea un método que reciba como parámetro una expresión sin paréntesis y la calcule, teniendo en cuenta la prioridad de operaciones.
double calcularOperacionSinParentesis (String expresion)

- Crea un método que reciba como parámetro una expresión con paréntesis y devuelva la operación contenida en el paréntesis "más profundo"
String obtenerOperacionEntreParentesis (String expresion)

- Crea un método que reciba como parámetro una expresión con paréntesis y devuelva su resultado.
double calcularOperacionConParentesis (String expresion)



Como ves, he seguido con la idea de recibir la operación como una cadena completa, pero incluso podría ser más simple ir realizando las operaciones conforme vas introduciendo la expresión, ya que solo tienes que controlar 2 expresiones simples a la vez.
En cualquier caso, como eso es más lioso, creo que con esto te debería ser bastante simple realizar esa calculadora.


Nota: Arriba he indicado los métodos básicos que yo crearía. A partir de ahí, tú puedes implementar los que creas conveniente, de hecho a mi se me ocurren 2 o 3 más que resultarían bastante interesantes, pero ya lo dejo a tu elección.


Si tienes alguna duda más, no dudes en preguntar

Un saludo

Gracias por tu respuesta. Agregare algo mas, primero que nada, se sabe que en una operación como por ejemplo la que puse: 5(7+(8-9)/6)*8, hay que resolver primero los paréntesis, luego lo que este multiplicando/dividiendo, y por ultimo lo que esta fuera de los paréntesis y las sumas, Algo así:

5(7+(8-9)/6)*8 ==> 5(7+(-1)/6)*8 ==> 5(7+(-0.17))*8 ==> 5(6,83)*8 ==> 34.15*8 ==> 273.2 => Resultado redondeado.

Cabe aclarar que la notación debe ser polaca o prefija. Como soy principiante en el mundo Java empezare a buscar sobre el método que pusiste. Si lo resuelvo o adelanto algo publicare el código, pero si alguien lo hace, de nuevo mil gracias.

Saludos

EDIT:

@Mortadelo: Esa idea me gusta mas, pero, bueno varias preguntas:

- Según esto, me tomara las expresiones de los paréntesis del final, pero como lo reemplazo en la cadena original y en la posición que iba?
- Para hacer la suma/resta/multiplicación/división, debo separar lo que saque de la cadena con un charAt()?

Por ahora así, voy a probar y comento después. Lo de la prioridad con el boolean me quedo algo confuso pero probare primero.

Gracias redfireblue ^^

Aquí tienes varias posibilidades, pero la más sencilla es la siguiente:
- Para extraer el contenido del paréntesis supongamos que usamos los métodos lastIndexOf e indexOf, que nos devuelven la última posición del caracter pasado y la primera, respectivamente ("hola Pepe".lastIndexOf('e') = 8; "hola Pepe".indexOf('e') = 6
- Por tanto, sabemos que la cadena entre paréntesis está entre las posiciones x e y, con lo que podemos hacer un substring(x,y) y obtener la cadena.
- Para reemplazarlo una vez calculado el resultado, podemos hacer un replaceFirst desde la posición x, que obtuvimos antes y listo, cadena reemplazada.

Ejemplo (no lo he probado, así que puede que sea necesario retocarlo):

Si estuviera bien (como digo no lo he probado), el resultado sería "programando asdfva"


Existen alternativas a charAt que pueden resultar más cómodas, pero lo importante ahora es que tú estés cómodo programando, así que si controlas charAt más que otros métodos, adelante.

De todas formas, tienes la seguridad de que solo vas a tener paréntesis, como mucho, al principio y al final de la expresión una vez que la extraigas, con lo que personalmente tiraría con indexOf a muerte para localizar los operadores (+-*/) y lo que haya en medio serán números.
A partir de ahí, ya debes decidir si te conviene incluirlos en algún tipo de estructura o no (objetos, arrays, etc), para manejarlos con más facilidad.

No he dicho nada, no leí lo de la notación polaca... en ese caso lo tienes más o menos fácil, pues el operador va a preceder siempre a los números, y cada número debe ir separado del siguiente al menos por un espacio en blanco u otro operador...


Es muy simple:
El método que indiqué solo compara 2 operadores, con lo que un "verdadero/falso" basta para saber cuál es prioritario.
La idea del método es dar por sentado que el primer parámetro es prioritario al segundo (true) y, en caso de no serlo, devolver false, ejemplo:

obtenerPrioridad(*, +);

si op2 prioritario a op1 --> false
si no --> true

De todas formas, como dije antes, esto solo es una orientación y lo importante es que te sientas lo más cómodo posible programando, con lo que puedes cambiar estos métodos, sustituirlos, cambiar nuevos, ...

haber...
lo que tienes que hacer simplemente es ir substituyendo los parentesis por el resultado del mismo.

primero cojes la entrada del campo de texto como un string y vas buscando estructuras con parentesis. cuando encuentres una pones esta estructura en un array y miras si tambien tienes parentesis, y asi succesivamente hasta que no hayan mas.

piensa que puede ser que haya: 2+3+4 asi que tendras que buscar todos los signos y darles prioridad. una buena manera si tienes esto: 2+2*2 es simplemente poner parentesis y quedaria 2+(2*2) asi puedes reaprovechar el codigo que detecta los parentesis

yo he hecho una simple calculadora en java (un applet) si quieres me envias un MP y te paso el código para que puedas tener una mayor orientacion.