using System;

using System.Collections.Generic;

​

// By Seqi

// For Wasa <3

public class InfixPostfixClient

{

    public static void Main()

    {

        string input, expected;

        // Wew Tests        

        input = "a+b*c-d";

        expected = "abc*+d-";

        Test(input, expected);

        Console.WriteLine("\n");

        input = "2*3-4/5";

        expected = "23*45/-";

        Test(input, expected);

    }

    public static void Test(string input, string expected)

    {

        InfixPostfixManager manager = new InfixPostfixManager(input);       

        // Use same operator data every time

        manager.AddOperator('+', 1);

        manager.AddOperator('-', 1);

        manager.AddOperator('*', 2);

        manager.AddOperator('/', 2);

        Console.WriteLine("Input: " + input);

        Console.WriteLine("Expected: " + expected);

        string actual = manager.Calculate();

        Console.WriteLine("Actual: " + actual);

        Console.WriteLine("Passed? " + (actual == expected).ToString());

    }

}

​

public class InfixPostfixManager

{

    public string Input{get;set;}

    // Store the weightings of each operator here. This lets us modify this at design time

    // and maybe even run time if we wanted.

    public Dictionary<char, int> OperatorWeightings {get; private set;} 

    // Create access methods for this for validation of input

    public void AddOperator(char op, int weight)

    {

        if (!Char.IsLetterOrDigit(op))

            OperatorWeightings.Add(op, weight);

        else throw new ArgumentException("Input character must be a mathmatical operator.", "op");

    }

    public string Calculate()

    {

        // Create a container for the operators and operands

        string operators = String.Empty;

        string result = String.Empty;

        // Cycle through each character

        for(int i = 0; i < Input.Length; i++)

        {

            // If a Letter/Digit, append to result

            if (Char.IsLetterOrDigit(Input[i])) 

            {

                result += Input[i];         

            }

            // If not, while the operator has a lower presidence than the operator stack, pop them off

            // and then put the new operand back on the stack

            else                

            {   

                while(!IsOperatorHigherPresidence(Input[i], operators))

                {

                    result += PopStringStack(ref operators);                

                }

                operators += Input[i];

            }

        }

        //Pop the remainder of the stack

        while (operators.Length > 0)

            result += PopStringStack(ref operators);

        return result;

    }

    private char PopStringStack(ref string stack)

    {   

        // Take the char

        char poppedChar = stack[stack.Length - 1];

        // Trim the array

        stack = stack.Substring(0, stack.Length - 1);

        return poppedChar;

    }

    private bool IsOperatorHigherPresidence(char op, string stack)

    { 

        if (stack.Length == 0) return true;

        char peek = stack[stack.Length - 1];

        int peekValue = GetOperatorValue(peek);

        int opValue = GetOperatorValue(op);

        return opValue > peekValue;

    }

    private int GetOperatorValue(char op)

    {

        int opValue;

        if (!OperatorWeightings.TryGetValue(op, out opValue))

            throw new ArgumentException("Input string contains an operator that was not supplied a weighting.");

        return opValue;

    }

    public InfixPostfixManager(string input)

    {

        OperatorWeightings = new Dictionary<char, int>();

        Input = input;

    }

}

​

​