示例#1
0
        private static void TestLogic()
        {
            do
            {
                Console.Clear();

                Console.Write("Введите логическое выражение: ");

                string expression = Console.ReadLine();

                string convertedExpression = PolishLogic.GetPolishNotation(expression);

                Console.WriteLine("\nВыражение в обратной польской нотации: {0}", convertedExpression);

                int result = PolishLogic.CalculatePolishExpression(convertedExpression);

                Console.WriteLine("\nРезультат вычисления: {0}", result);

                PolishArithmetic.Vars.Clear();

                Console.WriteLine("\n(Нажмите ESC, чтобы выйти)");
            }while (Console.ReadKey().Key != ConsoleKey.Escape);
        }
        // Возвращает результат арифметического выражения, представленного в обратной польской записи
        public static string CalculatePolishExpression(string polishExpression, bool useLogic = false)
        {
            string logicOperator = "";

            if (useLogic)
            {
                logicOperator    = polishExpression[polishExpression.Length - 1].ToString();
                polishExpression = polishExpression.Remove(polishExpression.Length - 1);
            }

            Stack <string> stack = new Stack <string>();

            string number = "";

            for (int i = 0; i < polishExpression.Length; i++)
            {
                // Текущий символ выражения - число
                if (Char.IsDigit(polishExpression[i]) || Char.IsLetter(polishExpression[i]))
                {
                    // Если число многозначное, то оно посимвольно считывается в буфер number
                    // А затем конвертируется в int и помещается в стек
                    while (Char.IsDigit(polishExpression[i]))
                    {
                        number += polishExpression[i];
                        i++;

                        if (i >= polishExpression.Length)
                        {
                            return(number);
                        }
                    }

                    if (Char.IsLetter(polishExpression[i]))
                    {
                        if (!Vars.ContainsKey(polishExpression[i].ToString()))
                        {
                            Console.Write("Введите значение для {0}: ", polishExpression[i]);
                            number = Console.ReadLine();
                            //if (Char.IsLetter(polishExpression[i]))
                            Vars.Add(polishExpression[i].ToString(), number);
                        }

                        number = polishExpression[i].ToString();
                    }

                    stack.Push(number);

                    number = "";
                }
                // Текущий символ выражения - оператор
                else if (polishExpression[i].IsOperator())
                {
                    int expResult = 0;
                    // Из стека извлекаются два числа и над ними производится действие оператора
                    if (polishExpression[i] == '~')
                    {
                        if (Char.IsLetter(stack.Peek()[0]))
                        {
                            expResult = Calculate(polishExpression[i], Convert.ToInt32(Vars[stack.Pop()]));
                        }
                        else
                        {
                            expResult = Calculate(polishExpression[i], Convert.ToInt32(stack.Pop()));
                        }

                        // Результат вычисления помещается в стек
                        stack.Push(expResult.ToString());
                    }
                    else if (polishExpression[i] == '=')
                    {
                        string arg1 = stack.Pop();
                        string arg2 = stack.Pop();
                        Vars[arg2] = arg1;

                        stack.Push(arg1);
                    }
                    else
                    {
                        string arg1 = stack.Pop();
                        string arg2 = stack.Pop();
                        if (Char.IsLetter(arg1[0]))
                        {
                            arg1 = Vars[arg1];
                        }
                        if (Char.IsLetter(arg2[0]))
                        {
                            arg2 = Vars[arg2];
                        }
                        expResult = Calculate(polishExpression[i], Convert.ToInt32(arg1), Convert.ToInt32(arg2));

                        // Результат вычисления помещается в стек
                        stack.Push(expResult.ToString());
                    }
                }
            }

            if (useLogic)
            {
                string arg2 = stack.Pop();
                string arg1 = stack.Pop();

                string result = PolishLogic.CalculatePolishExpression(arg1 + " " + arg2 + " " + logicOperator).ToString();

                return(result);
            }
            else
            {
                return(stack.Pop());
            }
        }