public String solveExpression( String expression ) {

	boolean done = false;
	// The current string keeps our working version of the answer.
	String current = expression;

	// The current and eventually final numerical answer.
	int result = 0;

	// The index of the next operator we have to consider. Default is 0 which will mean we
	// haven't found a real operator since all real operators need arguments on both sides of them.
	int minimumIndex = -1;
	int m = -1;

	int l = -1;
	int r = -1;

	// while we're not done solving...
	while ( !done ) {
		
          m = -1;
	  if ( current.contains( "*" ) || current.contains( "/" ) || current.contains( "%" )  ){

            // get the index in the string of the first occurence of these operators since java will do them
            // from left to right
            int multiplication = current.indexOf("*");
            int division = current.indexOf("/");
            int modulas = current.indexOf("%");

            // if there's a valid index for mult then pick it else take a valid index for div else take one for mod.
            m = (multiplication != -1) ? multiplication : ( (division != -1) ? division : ( (modulas != -1) ? modulas : -1 ) ) ;

            // Let's make sure we have a valid index before going further...
            if (m != -1) {
              // One of the indices is valid so let's make sure it's the first
              if (modulas > -1 && multiplication > -1 && division > -1) {
                if ( modulas < division && modulas < multiplication ) {
                  m = modulas;
                } else if ( division < multiplication ) {
                  m = division;
                } else { m = multiplication; }
              }
              else if ( division > -1 && multiplication > -1 ) {
                if ( multiplication < division ) {
                  m = multiplication;
                } else {
                  m = division;
                }
              }
              else if ( modulas > -1 && multiplication > -1 ) {
                if ( multiplication < modulas ) {
                  m = multiplication;
                } else {
                  m = modulas;
                }
              }  else if ( modulas > -1 && division > -1 ) {
                if ( division < modulas ) {
                  m = division;
                } else {
                  m = modulas;
                }
              }

              // Now perform arithmetic and check to make sure we're not dividing or mod'ing by 0
              if ( current.charAt( m ) == '*' ) {
                l = getNumberAt(current, m - 1);
                r = getNumberAt(current, m + 1);
                result = l * r;
              } else if ( current.charAt( m ) == '/' ) {
                l = getNumberAt(current, m - 1);
                r = getNumberAt(current, m + 1);

                // since divide by 0 is normally an error condition we're going to return
                // in the middle of the method
                if (r == 0) {
                  return "undefined";
                }

                result = l / r;

              } else if ( current.charAt( m ) == '%' ) {
                l = getNumberAt(current, m - 1);
                r = getNumberAt(current, m + 1);
                // since divide/mod by 0 is normally an error condition we're going to return
                // in the middle of the method
                if (r == 0) {
                  return "undefined";
                }
                result = l % r;
              }
            }

            
	  
          } 
	  else if (current.contains( "+" ) || current.contains( "-" )){
            // next precedence
            int a = current.indexOf("+");
            int b = getFirstSubtractionIndex(current);
            m = a;

            if (a > -1 && b > -1 ) {
                if ( a < b ) m = a;
                else a = b;
            }
            else if ( b > -1 ) {
              m = b;
            }

            if (m != -1) {
              if ( current.charAt( m ) == '+' ) {
                l = getNumberAt(current, m - 1);
                r = getNumberAt(current, m + 1);
                result = l + r;
              } else if ( current.charAt( m ) == '-' ) {
                l = getNumberAt(current, m - 1);
                r = getNumberAt(current, m + 1);
                result = l - r;
              }
            }

			
	  } 
	  minimumIndex = m;
          int leftSide = l;
	  int rightSide = r;
	  if (minimumIndex >= 1) {
	    int rightSize = new Integer(rightSide).toString().length();
	    int leftSize = new Integer(leftSide).toString().length();

	    if (minimumIndex-leftSize != 0 && minimumIndex+rightSize!=current.length()-1) {
	      current = current.substring(0, minimumIndex- leftSize ) + result  + 
		current.substring(minimumIndex + rightSize+1, current.length()); 
	    } else if (minimumIndex-leftSize != 0 ) {
	      current = current.substring(0, minimumIndex-leftSize) + result ;
	    } else if (minimumIndex+rightSize!=current.length()-1) {
	      current = result + 
		current.substring(minimumIndex +rightSize+1, current.length()); 
	    } else {
	      current = result + "";
	    }
	  }
	  
	  if (current.length() <= 1 || minimumIndex == -1 ) {
	    done = true;
	  }
	  minimumIndex = -1;
	  
	}

	return ""+result;
  }