Recursividad - Ejercicios resueltos 101

Actualización 10-10-2012:

Todo puede mejorar. Ahora puede resolver cualquier sobrecarga de paréntesis y resolver números signados. Tuve que agregar una función recursiva más (cierreParentesis()), esta vez era necesaria, para que discriminara cual paréntesis cerraba a cada cual y así saber si el primero y el último de la expresión se cerraban entre sí.

Fin actualización.

Qué tal chicos.

Para este viernes el profe nos hizo un regalito para la prueba.

Como el regalo es para todos les comparto mi versión.
Este programa funciona con las siguientes restricciones:

• No se pueden poner números signados entre las operaciones (ej: -13+-51) solo operaciones entre números naturales. (deprecado)
• Los paréntesis siempre deben estar equilibrados.
• Entre los paréntesis sólo puede haber operaciones y no números solos o signados (ej: "(+58)").(deprecado)
• No sirve para elementos con sobrecarga de parentesis, ej: (((9+8))).(deprecado)

Saquen sus versiones modifíquenlo, mejórenlo y nos vemos en la prueba este viernes.

Que nos vaya bien:

6.- Escriba un programa en Java que reciba un string que contenga una expresión aritmética y que retorne el valor de la evaluación.
Ej: "((5+1)*(7-6))" = 6.

Solución:

public class evaluaEcuacionString
{
 public static int evaluaEcuacion(String strEcuacion)
 {
  strEcuacion = quitaParentesisExteriores(strEcuacion);
  
  if(blnIsNum(strEcuacion))
   return Integer.parseInt(strEcuacion);
    
  String strEcIzq = obtenerPrimerMiembro(strEcuacion);
  char   chrOp    = strEcuacion.charAt(strEcIzq.length());
  String strEcDer = strEcuacion.substring(strEcIzq.length()+1);
  
  return opera(chrOp, evaluaEcuacion(strEcIzq), evaluaEcuacion(strEcDer));
 }
 
 private static int opera(char op, int a, int b)
 {
  switch (op)
  {
  case '+': return a + b;
  case '-': return a - b;
  case '*': return a * b;
  default : return (int) a / b;
  }
 }
 
 private static String quitaParentesisExteriores(String ecu)
 {
  if(ecu.charAt(0) =='(')
   if(ecu.charAt(ecu.length()-1) ==')')
    if(entreParentesis(ecu))
     return quitaParentesisExteriores(ecu.substring(1, ecu.length()-1));
   
        return ecu;         
    }
 
 private static boolean entreParentesis(String ecu)
 {
  return (cierreParentesis(ecu,1) == ecu.length()-1);  
 }
 
 private static int cierreParentesis(String ecu, int pos)
 {
  int i = pos;
  int cerrado=-1;
  
  while (i <= ecu.length()-1)
  {
   //if(i < ecu.length())
    if(ecu.charAt(i)==')')
     return i;
   
   if(ecu.charAt(i)=='(')
   {
    cerrado = cierreParentesis(ecu, i+1);
    i = cerrado;
   }
   
   i++;
   
   
   
  }
  return cerrado;// return i==ecu.length();
 }
 
 
 private static String obtenerPrimerMiembro(String ecu)
 {
  String miembro="";
  
  if(ecu.charAt(0)=='(')
  { 
   int equilibrio = 0;
   int i=0;
   do
   {
    char elem = ecu.charAt(i);
    miembro+= elem;
    if(elem == '(')
     equilibrio++;
    
    if(elem == ')')
     equilibrio--;
    
    i++;
    
   }while (equilibrio != 0);
  }
  else
  {
   miembro+=ecu.charAt(0);
   
   for(int i=1; Character.isDigit(ecu.charAt(i)); i++)
    miembro+=ecu.charAt(i);
  }
  return miembro;
 }
 
 private static boolean blnIsNum(String s)
 {
  //retorna true si el string representa un entero
  //con o sin signo
  
  int primerChar = 0;
  if(s.charAt(0)=='+' || s.charAt(0)=='-')
   primerChar=1;
   
  for(int i=primerChar; i< s.length(); i++)
   if(!Character.isDigit(s.charAt(i)))
    return false;
  
  return true;
 }
 
 
 public static void main(String[] args)
 {
  //Modifiquen el string para probarlo
  // ;-)
  
  System.out.println(evaluaEcuacion("(((5*3)/(2-1)))+(((5/3)+8)-60)"));
 }

}