Term-3-IT/ExpressionProcessor.cs at master · Egor01b/Term-3-IT · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
using System.Collections.Generic;
using System;

namespace Algorithms1;

public class ExpressionProcessor
{
    private char[] _signs = "+-/*^".ToCharArray();

    private char[] _numbers = "1234567890".ToCharArray();

    private Dictionary<char, int> _operatorPrior = new Dictionary<char, int>()
    {
        {
            '+', 1
        },
        {
            '-', 1
        },
        {
            '*', 2
        },
        {
            '/', 2
        },
        {
            '^', 4
        }
    };

    public Stack TokenizeString(string str)
    {
        var ar = str.ToCharArray();
        double buffer  = 0;
        var returnValue = new Stack();
        var operationStack = new Stack();
        foreach (var s in ar)
        {
            if (_numbers.Contains(s))
            {
                buffer *= 10;
                buffer += s - '0';
            }
            else if (s == ' ')
            {
                if (buffer != 0)
                {
                    returnValue.Push(buffer);
                    buffer = 0;
                }
                continue;
            }
            else if (_signs.Contains(s))
            {
                if (buffer != 0)
                {
                    returnValue.Push(buffer);
                    buffer = 0;
                }


                if (operationStack.GetTop() != null && _signs.Contains((char)operationStack.GetTop()))
                {
                    var stackPrior = _operatorPrior[(char)operationStack.GetTop()];
                    while (_operatorPrior[s] <= stackPrior && operationStack.GetTop() != null)
                    {
                        returnValue.Push(operationStack.Pop());
                        if (operationStack.GetTop() == null)
                        {
                            break;
                        }
                        stackPrior = _operatorPrior[(char)operationStack.GetTop()];
                    }
                }
                operationStack.Push(s);
            }
            else if (s == '(')
                operationStack.Push(s);
            else if (s == ')')
            {
                while ((char) operationStack.GetTop() != '(')
                    returnValue.Push(operationStack.Pop());
                operationStack.Pop();
            }
        }

        if (buffer != 0)
            operationStack.Push(buffer);
        while (operationStack.GetTop() != null)
            returnValue.Push(operationStack.Pop());

        return returnValue;
    }

    public double Calculate(Stack expression_)
    {
        var s = new Stack();
        var expression = new Stack();
        while(expression_.GetTop() != null)
        {
            expression.Push(expression_.Pop());
        }
        while (true)
        {
            var t = expression.Pop();
            if (t is double)
            {
                s.Push(t);
            }
            else if (t is char)
            {
                var first = (double)s.Pop();
                var f = s.Pop();
                var second = (double) f;
                if ((char) t == '+') s.Push(second + first);
                else if ((char) t == '-') s.Push(second - first);
                else if ((char) t == '*') s.Push(second * first);
                else if ((char) t == '/') s.Push(second / first);
                else if ((char) t == '^') s.Push(Math.Pow(second, first));
            }

            if (expression.GetTop() == null) return (double) s.Pop();
        }
    }
}