Преобразовать строку в обратную польскую запись.

  private string polsk(string Text)
        {
            string s = "";
            item<char> stack = new item<char>();
            char [] mass = Text.ToCharArray();
            for (int i = 0; i < mass.Length; i++)
            {
                if (mass[i] >= 'A' && mass[i] <= 'Z')
                {
                    s += " " + mass[i];
                }
                if(mass[i]=='!'||mass[i]=='v'||mass[i]=='^'||mass[i]=='→'||mass[i]=='↔'||mass[i]=='(')
                {
                    stack.Add(mass[i]);
                }
                if (mass[i] == ')')
                {
                    if (stack.Data != ')')
                        s += " " + stack.Del_And_ReturnData();
                    else
                        stack.Del();
                }
            }
            return s;
        }

static void Main(string[] arg)
        {
            var log = LogManager.GetCurrentClassLogger();
            var output = new Queue<string>();
            var operators = new Stack<string>();
            string input = Console.In.ReadToEnd();
            for (int i = 0; i < input.Length; i++){
                char token = input[i];
 
                if (char.IsNumber(token)) {
                    int j = i + 1;
                    while (j < input.Length && (char.IsNumber(input[j]) || input[j] == '.')) j++;
                    var value = input.Substring(i, j-i);
                    i = j - 1;
                    output.Enqueue(value);
                    log.Trace("Enqueue {0}", value);
                } else if (char.IsLetter(token)) {
                    int j = 0;
                    while (j < input.Length && char.IsLetter(input[j])) j++;
                    var function = input.Substring(i, j-i);
                    operators.Push(function.ToString());
                    log.Trace("Push {0}", function);
                } else if (token == ',') {
                    while (operators.Peek() != "(") {
                        log.Trace("Pop {0} to output", operators.Peek());
                        output.Enqueue(operators.Pop());
                    }
                    if (operators.Count == 0)
                        throw new FormatException("The separator was misplaced or parentheses were mismatched.");
                } else if (IsOperator(token)) {
                    if (token == '-') {
                        log.Info("{0}    {1}", string.Join(" ", output.ToArray()), string.Join(" ", operators.ToArray()));
                        Console.ReadKey();
                    }
                    while (operators.Count > 0 && IsOperator(operators.Peek()) && ( ( IsLeftAssociative(token) && Precedense(token) <= Precedense(operators.Peek()) ) || IsRightAssociative(token) && Precedense(token) < Precedense(operators.Peek()) )) {
                        log.Trace("Pop {0} to output", operators.Peek());
                        output.Enqueue(operators.Pop());
                    }
                    operators.Push(token.ToString());
                    log.Trace("Push {0}", token);
                } else if (token == '(') {
                    operators.Push(token.ToString());
                    log.Trace("Push {0}", token);
                } else if (token == ')') {
                    while (operators.Count > 0 && operators.Peek() != "(") {
                        log.Trace("Pop {0} to output", operators.Peek());
                        output.Enqueue(operators.Pop());
                        if (operators.Count == 0)
                            throw new FormatException("Mismatched parentheses");
                    }
                    log.Trace("Pop {0}", operators.Pop()); // Pop the left paranthesis
 
                    if (operators.Count > 0) {
                        var top = operators.Peek();
                        if (!IsOperator(top) && top != ")" && top != "(") {
                            log.Trace("Pop {0} to output", top);
                            output.Enqueue(operators.Pop());
                        }
                    }
                } else {
                    continue;
                }
 
                log.Debug("{0} | {1}", string.Join(" ", output.ToArray()), string.Join(" ", operators.ToArray()));
            }
 
            while (operators.Count > 0)
                if (operators.Peek() == "(" || operators.Peek() == ")")
                    throw new FormatException("Mismatched parentheses");
                else {
                    log.Trace("Pop {0} to output", operators.Peek());
                    output.Enqueue(operators.Pop());
                    log.Debug("{0} | {1}", string.Join(" ", output.ToArray()), string.Join(" ", operators.ToArray()));
                }
                
                string reversePolish = string.Join(" ", output.ToArray());
 
            Console.ReadKey();
        }
        static bool IsOperator(string token)
        {
            return token.Length == 1 && IsOperator(token[0]);
        }
        static bool IsOperator(char token)
        {
            return token == '-' || token == '+' || token == '/' || token == '*' || token == '^';
        }
        static bool IsLeftAssociative(char token)
        {
            return IsOperator(token) && token != '^';
        }
        static bool IsRightAssociative(char token)
        {
            return token == '^';
        }
        static int Precedense(string token)
        {
            if (token.Length != 1)
                throw new FormatException(string.Format("String '{0}' is not a valid operator", token));
 
            return Precedense(token[0]);
        }
        static int Precedense(char token)
        {
            if (token == '+' || token == '-') return 2;
            if (token == '*' || token == '/') return 3;
            if (token == '^') return 4;
            throw new FormatException(token + " is not a valid operator");
        }

 string s = "";
            item<char> stack = new item<char>();
            char [] mass = Text.ToCharArray();
            for (int i = 0; i < mass.Length; i++)
            {
                if (mass[i] >= 'A' && mass[i] <= 'Z')
                {
                    s += " " + mass[i];
                }
                if (mass[i] == '!' || mass[i] == 'v' || mass[i] == '^' || mass[i] == '→' || mass[i] == '↔' || mass[i] == '(')
                {
                    stack.Add(mass[i]);
                }
                if (mass[i] == ')')
                {
                    while (stack.Data != '(')
                        s += " " + stack.Del_And_ReturnData();
                    stack.Del();
                }
            }
            s += " " + stack.ToString();
            return s;