主页 / 问题 / 1266739
Accepted
Vardan_Karapetian
Asked:2022-04-06 18:29:57 +0000 UTC2022-04-06 18:29:57 +0000 UTC

使用 Regex.Split 解析数学表达式

  • 772

看，例如，我有这个表达string expression = "(-2)+3";

我需要把它变成

string[] split = { "(" , "-2" , ")" , "+" , "3" };

我试过什么

string[] split = Regex.Split(expression, @"(\b[-+*\/]|[+-]?\d+|[-+*\/()])").Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();

Output
string[] split = { "(" , "-2" , ")" , "+3" };
c#

1 个回答

  1. Best Answer

    实现解析、表达式解析、计算，考虑到运算的数学优先级，而不使用第三方库或产生最终结果（类型DataTable.Compute或类似类型）的组件

    这是一个支持括号和一元运算符的工作解决方案示例，供您解析。

    基本上，解决方案是由我的 3 个答案组装而成的：1、2和3。

    class Program
{
    static void Main(string[] args)
    {
        string expression = "(-2)+3";
        try
        {
            Console.WriteLine(Compute(expression));
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }

    public static int Compute(string expression)
    {
        if (string.IsNullOrWhiteSpace(expression))
            throw new ArgumentException("Получено пустое выражение", nameof(expression));

        CheckParenthesis(expression);

        return EvaluateParenthesis(expression);
    }

    private static int EvaluateParenthesis(string expression)
    {
        string planarExpression = expression;
        while (planarExpression.Contains('('))
        {
            int clauseStart = planarExpression.IndexOf('(') + 1;
            int clauseEnd = IndexOfRightParenthesis(planarExpression, clauseStart);
            string clause = planarExpression.Substring(clauseStart, clauseEnd - clauseStart);
            planarExpression = planarExpression.Replace("(" + clause + ")", EvaluateParenthesis(clause).ToString());
        }
        return ParseExpression(planarExpression);
    }

    private static int IndexOfRightParenthesis(string expression, int start)
    {
        int c = 1;
        for (int i = start; i < expression.Length; i++)
        {
            switch (expression[i])
            {
                case '(': c++; break;
                case ')': c--; break;
            }
            if (c == 0) return i;
        }
        return -1;
    }

    private static void CheckParenthesis(string expression)
    {
        int i = 0;
        foreach (char c in expression)
        {
            switch (c)
            {
                case '(': i++; break;
                case ')': i--; break;
            }
            if (i < 0)
                throw new ArgumentException("Не хватает '('", nameof(expression));
        }
        if (i > 0)
            throw new ArgumentException("Не хватает ')'", nameof(expression));
    }

    private static readonly char[] supportedOperators = new[] { '*', '/', '+', '-' };
    private static readonly int[] priorities = new[] { 0, 0, 1, 1 };

    private static int ParseExpression(string expression)
    {
        List<char> ops = new List<char>();
        List<int> numbers = new List<int>();
        string[] tokens = Regex.Split(expression.Replace(" ", ""), @"(\b[-+*\/]|[+-]?\d+|[-+*\/])").Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();

        foreach(string token in tokens)
        {
            if (int.TryParse(token, out int number))
                numbers.Add(number);
            else
                ops.Add(token[0]);
        }
        
        if (ops.Count + 1 != numbers.Count)
            throw new FormatException("Ошибка в выражении");

        foreach (int priority in priorities.Distinct())
        {
            List<char> operators = new List<char>();
            for (int i = 0; i < priorities.Length; i++)
            {
                if (priorities[i] == priority)
                    operators.Add(supportedOperators[i]);
            }
            for (int i = 0; i < ops.Count; i++)
            {
                if (operators.Contains(ops[i]))
                {
                    numbers[i] = Calculate(numbers[i], numbers[i + 1], ops[i]);
                    numbers.RemoveAt(i + 1);
                    ops.RemoveAt(i);
                    i--;
                }
            }
        }
        return numbers[0];
    }

    private static int Calculate(int left, int right, char op)
    {
        switch (op)
        {
            case '*': return left * right;
            case '/': return left / right;
            case '+': return left + right;
            case '-': return left - right;
            default: throw new NotSupportedException("Неподдерживаемый оператор");
        }
    }
}

    我不假装自己是天才，我也认为解决方案不是很理想，但它确实有效。这个想法的本质是你需要解析已经没有括号的常规字符串进行计算，并单独处理括号。

    • (-1+-2)+(20*2/-4)结果-13
    • (-2)+3结果1
    • 1

相关问题