String equation for simple to complex equations (2)

Question

Yes! Thanks for the help on the last question! For the specified string equation, it worked perfectly! But now I'm having trouble when it comes to two parentheses (whether open or close) are together

example: 4+(2+(1+1))

Somewhere in my code it gets trapped in a loop, but I don't know where! What's wrong? My code:

import java.util.ArrayList;

public class StringEquation
{
    public static void main(String[] args) 
    {
        String s = "2+(8*(7+1))";

        ArrayList<String> equation = new ArrayList<>();

        String ns = "";

        String b;

        int nsi = 0;

        double n;

        double res;

        for(int c=0; c<s.length(); c++)
        {
             b = s.substring(c,c+1);
             if("0".equals(b)||"1".equals(b)||"2".equals(b)||"3".equals(b)||"4".equals(b)||"5".equals(b)||"6".equals(b)||"7".equals(b)||"8".equals(b)||"9".equals(b))
             {
                 ns += b;
                 if(c==s.length()-1)
                 {
                     nsi = Integer.parseInt(ns);
                     equation.add(Integer.toString(nsi));
                 }
             }
             else if(("+".equals(b)||"-".equals(b)||"*".equals(b)||"/".equals(b)||"%".equals(b))&&!"".equals(ns))
             {
                nsi = Integer.parseInt(ns);
                equation.add(Integer.toString(nsi));
                equation.add(b);
                ns = "";
             }
             else if("(".equals(b))
             {
                 equation.add(b);
             }
             else if (")".equals(b))
             {
                if(!"".equals(ns))
                {
                    nsi = Integer.parseInt(ns);
                }
                equation.add(Integer.toString(nsi));
                equation.add(b);
                ns = "";
             }
             else if("+".equals(b)||"-".equals(b)||"*".equals(b)||"/".equals(b)||"%".equals(b))
             {
                 equation.add(b);
             }
        }

        while(equation.contains("(")||equation.contains(")"))
        {
            for(int d=0; d<equation.size(); d++)
            {
                if("*".equals(equation.get(d))||"/".equals(equation.get(d))||"%".equals(equation.get(d)))
                {
                    if("(".equals(equation.get(d-1))||")".equals(equation.get(d-1))||"(".equals(equation.get(d+1))||")".equals(equation.get(d+1)))
                    {
                        switch(equation.get(d))
                        {
                            case "*": equation.set(d, "TIMES"); break;
                            case "/": equation.set(d, "DIVBY"); break;
                            default: equation.set(d, "MOD");
                        }
                    }
                    else
                    {
                        switch(equation.get(d))
                        {
                            case "*":
                                n = Double.parseDouble(equation.get(d-1));
                                n *= Double.parseDouble(equation.get(d+1));
                                equation.set(d-1, Double.toString(n));
                                equation.remove(d);
                                equation.remove(d);
                                break;
                            case "/":
                                n = Double.parseDouble(equation.get(d-1));
                                n /= Double.parseDouble(equation.get(d+1));
                                equation.set(d-1, Double.toString(n));
                                equation.remove(d);
                                equation.remove(d);
                                break;
                            default:
                                n = Double.parseDouble(equation.get(d-1));
                                n %= Double.parseDouble(equation.get(d+1));
                                equation.set(d-1, Double.toString(n));
                                equation.remove(d);
                                equation.remove(d);
                        }
                    }
                }
            }

            for(int d=0; d<equation.size(); d++)
            {
                if("+".equals(equation.get(d))||"-".equals(equation.get(d)))
                {
                    if("(".equals(equation.get(d-1))||")".equals(equation.get(d-1))||"(".equals(equation.get(d+1))||")".equals(equation.get(d+1)))
                    {
                        switch(equation.get(d))
                        {
                            case "+": equation.set(d, "PLUS"); break;
                            default: equation.set(d, "MINUS");
                        }
                    }
                    else
                    {
                        switch(equation.get(d))
                        {
                            case "+":
                                n = Double.parseDouble(equation.get(d-1));
                                n += Double.parseDouble(equation.get(d+1));
                                equation.set(d-1, Double.toString(n));
                                equation.remove(d);
                                equation.remove(d);
                                break;
                            default:
                                n = Double.parseDouble(equation.get(d-1));
                                n -= Double.parseDouble(equation.get(d+1));
                                equation.set(d-1, Double.toString(n));
                                equation.remove(d);
                                equation.remove(d);
                        }
                    }
                }
            }

            for(int d=0; d<equation.size(); d++)
            {
                switch(equation.get(d))
                {
                    case "PLUS":    equation.set(d, "+"); break;
                    case "MINUS":   equation.set(d, "-"); break;
                    case "TIMES":   equation.set(d, "*"); break;
                    case "DIVBY":   equation.set(d, "/"); break;
                    case "MOD":     equation.set(d, "%"); break;
                }
            }

            for(int d=0; d<equation.size(); d++)
            {
                if(d>0)
                {
                    if("(".equals(equation.get(d-1))&&")".equals(equation.get(d+1)))
                    {
                        equation.remove(d-1);
                        equation.remove(d);
                    }
                }
            }
        }

        for(int d=0; d<equation.size(); d++)
        {
            if("*".equals(equation.get(d))||"/".equals(equation.get(d))||"%".equals(equation.get(d)))
            {
                switch(equation.get(d))
                {
                    case "*":
                        n = Double.parseDouble(equation.get(d-1));
                        n *= Double.parseDouble(equation.get(d+1));
                        equation.set(d-1, Double.toString(n));
                        equation.remove(d);
                        equation.remove(d);
                        break;
                    case "/":
                        n = Double.parseDouble(equation.get(d-1));
                        n /= Double.parseDouble(equation.get(d+1));
                        equation.set(d-1, Double.toString(n));
                        equation.remove(d);
                        equation.remove(d);
                        break;
                    default:
                        n = Double.parseDouble(equation.get(d-1));
                        n %= Double.parseDouble(equation.get(d+1));
                        equation.set(d-1, Double.toString(n));
                        equation.remove(d);
                        equation.remove(d);
                }
            }
        }

        for(int d=0; d<equation.size(); d++)
        {
            if("+".equals(equation.get(d))||"-".equals(equation.get(d)))
            {
                switch(equation.get(d))
                {
                    case "+":
                        n = Double.parseDouble(equation.get(d-1));
                        n += Double.parseDouble(equation.get(d+1));
                        equation.set(d-1, Double.toString(n));
                        equation.remove(d);
                        equation.remove(d);
                        break;
                    default:
                        n = Double.parseDouble(equation.get(d-1));
                        n -= Double.parseDouble(equation.get(d+1));
                        equation.set(d-1, Double.toString(n));
                        equation.remove(d);
                        equation.remove(d);
                }
            }
        }

        res = Double.parseDouble(equation.get(0));

        System.out.println(res);

    }
}

Use a debugger to find out. For equations with `()`, you might want to consider a stack data structure. — Sotirios Delimanolis, Apr 12 '13 at 18:50
Is there a reason you're doing this by hand? What about the options provided in the answers to this question: http://stackoverflow.com/questions/1432245/java-parse-a-mathematical-expression-given-as-a-string-and-return-a-number — jefflunt, Apr 12 '13 at 18:54
Learn about "lexers" and "parsers". The canonical textbook on this is the *Dragon Book*, **Compilers: Principles, Techniques, and Tools**, by Aho, et. al. Then, choose a Java lexer and parser. ANTLR is probably the most accessible. — Eric Jablow, Apr 12 '13 at 19:50

score 0 · Answer 1 · answered May 17 '13 at 12:58

remove all extra elements from string say "(" ")" and put number and symbols in separate queue and then get each element from both the queue and at same time keep on checking weather it is a number or not if it is a number get next element as a symbol

String equation for simple to complex equations (2)

1 Answers1