Use operators with and without space in c#

Question

I make a program in which you can calculate an amount. And get a result out of it now that it works when I run operator 1 + 1, but not without spaces like 1 + 1. Now I want it to work in both cases. Can anyone help me with this? Since I don't know if that is also possible in my code.

I thought of removing all the spaces in my string and then splitting each character. So first replace (replace) all spaces in your string with string.Empty and then you split on an empty character.

Maybe someone can help me out?

This is my code

    private char[] SPACE = new char[] { ' ' };
    private void GetAnswer(string clipboardText)
    {
        //Loop through all questions and answers
        foreach (question q in questionList)
        {
            //If we have found an answer that is exactly the same show an Notification

            //Startwith zoekt naar alle vragen die matchen vanaf het begin van de zin en Endwith alle vragen die matchen vanaf het eind van de zin//
            if (q._question.StartsWith(clipboardText) || q._question.EndsWith(clipboardText))
            {
                ShowNotification(q._question, q._answer);
                break;
            }
        }
        var parts = clipboardText.Split(SPACE);
        var isValid = true;
        Double a, b;

        // Make sure it's format A # B
        if (parts.Length != 3)
            return;

        // Parse first number
        isValid = Double.TryParse(parts[0], out a);
        if (!isValid)
            return;

        var validOperators = new char[] { '+', '-', ':', 'x' };

        // Parse operator
        if (parts[1].Length != 1)
            return;
        var op = parts[1][0];
        if (!validOperators.Contains(op))
            return;

        // Parse 2nd number
        isValid = Double.TryParse(parts[2], out b);
        if (!isValid)
            return;

        // Now calculate the answer
        string answer = null;
        switch (op)
        {
            case '+':
                answer = (a + b).ToString();
                break;
            case '-':
                answer = (a - b).ToString();
                break;
            case ':':
                if (b == 0)
                    answer = "NaN";
                else
                    answer = (a / b).ToString();
                break;
            case 'x':
                answer = (a * b).ToString();
                break;
            default:
                throw new InvalidOperationException();
        }

        // Show the answer
        ShowNotification(clipboardText, answer);
    }

Answer 1

Your thought about removing all spaces is a good approach. Spaces are not needed for such an expression to be correct.

After removing all white spaces you should split the string into possible symbols. A number is a valid symbol and any of the operators is, too. Then you should evaluate the symbols and do the calculation.

Try searching for articles regarding "Infix Parser". Because that's what you want to do. You have a term in infix notation and want to parse it. A good start to read might be this answer: https://stackoverflow.com/a/13856790/797200

Answer 2

In case you want a way to replace the text with space before parsing the expression you can first remove space from expression, then check for what operator used and split the expression by it, like the following:

    //var parts = clipboardText.Split(SPACE); this should be commented since you need to remove spaces
    var textWithoutSpace = clipboardText.Replace(" ", "");
    var isValid = true;
    Double a, b;
    char currentOperator = '\0';
    //No need for this
    // Make sure it's format A # B
    //if (parts.Length != 3)
        //return;
    var validOperators = new char[] { '+', '-', ':', 'x' };

    foreach(var validOperator in validOperators)
    {
        if(textWithoutSpace.Contains(validOperator))
        {
            currentOperator = validOperator;
            break;
        }
    }
    if(currentOperator == '\0') {return;}

    var parts = textWithoutSpace.Split(currentOperator);
    //Then continue your work to take parts[0] and parts[1] and apply the operator

However above code assumes only that you need to parse expressions in the form of (A operand B), in case you need to parse more complex operations you need whether to find a ready made library that handles the dirty work for you, or to implement some of the algorithms that handles this task one of them is:

Shunting Yard Algorithm