using System;

using System.Collections.Generic;

using System.Linq;  

public class Program

{

    static bool running = true;

    public static void Main()

    {            

            Console.WriteLine("Enter an expression, or \"stop\" to exit.");

​

            while (running)

            {

                var input = Console.ReadLine();

​

                if (input == "stop")

                {

                    running = false;

                }

                else

                {

                    var tokenList = Tokenizer.Tokenize(input);

​

                    Console.WriteLine("Tokenizer output:");

                    var depth = 0;

                    foreach (var t in tokenList.Tokens)

                    {

                        if (t.Type == TokenType.ClosedParanthesis || t.Type == TokenType.ClosedAbsolute)

                        {

                            depth--;

                        }

​

                        var space = "";

​

                        for (var i = 0; i < depth; i++)

                        {

                            space += "   ";

                        }

                        var output = space + t.Value;

                        var toAdd = 15 - output.Length;

                        for (var i = 0; i < toAdd; i++)

                        {

                            output += " ";

                        }

​

                        Console.WriteLine(output + t.StartIndex.ToString("000") + " : " + t.Type);

                        if (t.Type == TokenType.OpenParanthesis || t.Type == TokenType.OpenAbsolute)

                        {

                            depth++;

                        }

                    }

                }

            }

    }

}

public enum TokenType

{

    Undetermined,

    Number,

    Variable,

    Addition,

    Subtraction,

    Multiplacation,

    Division,

    OpenParanthesis,

    ClosedParanthesis,

    Exponent,

    Equals,

    OpenAbsolute,

    ClosedAbsolute,

    Greater,

    GreaterEquals,

    Less,

    LessEquals,

}

​

    public class Token

    {

        public int StartIndex { get; set; }

        public TokenType Type { get; set; }

        public string Value { get; set; }

​

        public Token(TokenType type, string value, int start)

        {

            Type = type;

            Value = value;

            StartIndex = start;

        }

    }

​

    public static class TokenExtensions

    {

        public static List<TokenType> OperatorTokenTypes = new List<TokenType>()

        {

            TokenType.Addition,

            TokenType.Subtraction,

            TokenType.Multiplacation,

            TokenType.Division,

            TokenType.Equals,

            TokenType.Greater,

            TokenType.Less,

            TokenType.GreaterEquals,

            TokenType.LessEquals,

            TokenType.Exponent,

        };

​

        public static List<TokenType> OperandTokenTypes = new List<TokenType>()

        {

            TokenType.Number,

            TokenType.Variable,

​

        };

​

        public static bool IsOperator(this TokenType type)

        {

            return OperatorTokenTypes.Contains(type);

        }

​

        public static bool IsOperand(this TokenType type)

        {

            return OperandTokenTypes.Contains(type);

        }

    }

​

    public static class Tokenizer

    {

        public static List<char> AllowedVariables = new List<char>()

        {

            'a',

            'b',

            'c',

            'd',

            'e',

            'f',

            'g',

            'h',

            'i',

            'j',

            'k',

            'l',

            'm',

            'n',

            'o',

            'p',

            'q',

            'r',

            's',

            't',

            'u',

            'v',

            'w',

            'x',

            'y',

            'z',

        };

​

        public static TokenList Tokenize(string input)

        {

            var searchTerm = '=';

            var matchQuery = from word in input.ToCharArray()

                             where word == searchTerm

                             select word;

​

            if (matchQuery.Count() > 1)

            {

                throw new InvalidEquationExpressionException("More than one equals sign!");

            }

​

            var searchTerm2 = '(';

            var matchQuery2 = from word in input.ToCharArray()

                             where word == searchTerm2

                              select word;

​

            var searchTerm3 = ')';

            var matchQuery3 = from word in input.ToCharArray()

                             where word == searchTerm3

                              select word;

​

            if (matchQuery2.Count() != matchQuery3.Count())

            {

                throw new InvalidEquationExpressionException("Different counts of open paranthesis as closed paranthesis!");

            }

​

            var tokens = new List<Token>();

​

            var inputChars = input.ToCharArray();

​

            var index = 0;

            for (var i = 0; i < inputChars.Length; i++)

            {

                var type = TokenType.Undetermined;

                var character = inputChars[i];

​

                switch (character)

                {

                    case ')':

                        type = TokenType.ClosedParanthesis;

                        break;

                    case '+':

                        type = TokenType.Addition;

                        break;

                    case '/':

                        type = TokenType.Division;

                        break;

                    case '*':

                        type = TokenType.Multiplacation;

                        break;

                    case '^':

                        type = TokenType.Exponent;

                        break;

                    case '=':

                        type = TokenType.Equals;

                        break;

                    case '}':

                        type = TokenType.ClosedAbsolute;

                        break;

                }

​

                if (type != TokenType.Undetermined)

                {

                    tokens.Add(new Token(type, character + "", index));

                    continue;

                }

​

                if (character == '(' || character == '{')

                {

                    if (tokens.Count == 0)

                    {

                        tokens.Add(new Token(character == '(' ? TokenType.OpenParanthesis : TokenType.OpenAbsolute, character + "", index));

                        continue;

                    }

​

                    var lastToken = tokens.LastOrDefault();

​

                    if (lastToken.Type == TokenType.Number || lastToken.Type == TokenType.Variable)

                    {

                        tokens.Add(new Token(TokenType.Multiplacation, "*", index));

                        tokens.Add(new Token(character == '(' ? TokenType.OpenParanthesis : TokenType.OpenAbsolute, character + "", index));

                        continue;

                    }

                    else

                    {

                        tokens.Add(new Token(character == '(' ? TokenType.OpenParanthesis : TokenType.OpenAbsolute, character + "", index));

                        continue;

                    }

                }

​

                if (character == '-')

                {

                    if (tokens.Count == 0 || 

                        tokens.LastOrDefault().Type == TokenType.OpenParanthesis ||

                        tokens.LastOrDefault().Type == TokenType.OpenAbsolute)

                    {

                        tokens.Add(new Token(TokenType.Number, "-", index));

                        continue;

                    }

                    else

                    {

                        tokens.Add(new Token(TokenType.Subtraction, "-", index));

                        continue;

                    }

                }

                int b = 0;

                if (Int32.TryParse(character + "", out b) || character == '.')

                {

                    type = TokenType.Number;

                }

​

                if (AllowedVariables.Contains(character))

                {

                    if (tokens.Count > 0)

                    {

                        if (tokens.LastOrDefault().Type == TokenType.Number)

                        {

                            type = TokenType.Multiplacation;

                            tokens.Add(new Token(type, "*", index));

                        }

                    }

                    type = TokenType.Variable;

                }

​

                if (tokens.Count == 0 || type != tokens[tokens.Count - 1].Type || type == TokenType.Variable)

                {

                    tokens.Add(new Token(type, character + "", index));

                }

                else

                {

                    tokens[tokens.Count - 1].Value += character;

                }

​

                index++;

            }

​

            return new TokenList(tokens);

        }

    }

​

    public class InvalidEquationExpressionException : Exception

    {

        public string Error { get; set; }

​

        public InvalidEquationExpressionException(string error)

        {

            Error = error;

        }

    }

    public class TokenList

    {

        public List<Token> Tokens {get; set;}

        public TokenList(List<Token> tokens)

        {

            Tokens = tokens;

        }

        public int CountType(TokenType type)

        {

            var output = 0;

            foreach (var t in Tokens)

            {

                if (t.Type == type)

                {

                    output++;

                }

            }

            return output;

        }

    }

​

    public class BinaryTokenTree

    {

        public BinaryNode Root { get; set; }

​

        public static BinaryTokenTree Parse(TokenList tokenList)

        {

            var hasEquals = tokenList.CountType(TokenType.Equals) == 1;

            if (hasEquals)

            {

                Root = new BinaryNode(null);

            }

        }

    }

​

    public class BinaryNode

    {

        public BinaryNode Parent { get; set; }

​

        public BinaryNode Left { get; set; }

        public BinaryNode Right { get; set; }

​

        public Token Token;

​

        public NodeType Type

        {

            get

            {

                if (Token.Type.IsOperand())

                {

                    return NodeType.Operand;

                }

                return NodeType.Operator;

            }

        }

        public BinaryNode(BinaryNode parent, Token t)

        {

            Parent = parent;

            Token = t;

        }

    }

​

    public enum NodeType

    {

        Operator,

        Operand,

    }