没有正则表达式的字符串中的多个数字

Question

我正在构建一个控制台计算器，它将输入数字作为字符串。

例如：

string inputNumber = "190+154+114"
double[] number = new double[5];

我希望将该字符串转换为数字数组，例如：

number[0] = 190;
number[1] = 154;
number[2] = 114;

我知道有一个库可以处理它，但我想了解如何读取符号然后将数字放入数组中。

到目前为止，我所能想到的就是将字符串作为单个字符读取，然后找到“+”字符，然后将数字作为字符读取，直到 character!="null" || character=='+'。但问题是我不知道如何转换成代码。

================================================ ======================== 编辑

我阅读了答案，发现它们非常有趣。但是，插入运算符符号时如何创建新字符串？

例如：

string inputNumber = string.Empty;
string[] number = new string[20];
//Input number
Console.WriteLine("enter a number"); //190+155+220
inputNumber = Console.ReadLine();

那么当输入运算符时如何获取字符串，所以新的字符串必须是这样的：

number[0] = "190";
number[1] = "155";
number[2] = "220";

Answer 1

这对我有用：

string inputNumber = "190+154+114";
double[] number = inputNumber.Split('+').Select(x => double.Parse(x)).ToArray();

我明白了：

当然，当您需要其他数学运算时，这会变得更加复杂，尤其是带有负数和括号的 -。

您真正需要的是一种解析数学表达式并生成表达式树的方法。

Answer 2

我最初的答案只是拆分“+”字符，但听起来您还需要存储运算符，然后在构建计算器时进行一些数学运算。如果是这种情况，那么这里有另一种方法。

首先，创建一个您将使用的已知运算符的数组。然后，我们将通过搜索这些运算符来分解字符串。每次我们找到一个，我们从前一个操作符到当前操作符获取字符串并将其存储在我们的“数字”List<double>，然后我们获取当前操作符并将其存储在我们的“操作符”List<char>。最后，我们抓取最后一个数字（最后一个运算符之后的字符串的其余部分）。

在一个数组中包含数字并且在另一个数组中包含运算符后，您可以验证是否比运算符多一个数字（因为如果不匹配，那么我们可能会得到错误的输出）。假设字符串格式良好，可以将第一个数字存储为result，读取下一个运算符和下一个数字，对result进行运算。我会留给你来实现某种运算符优先级！

也许代码比所有这些词更容易阅读：

static void Main()
{
    var knownOperators = new[] { '+', '-', '*', '/' };

    // Get input string from user
    Console.Write("Please input a math string: ");
    string inputNumber = Console.ReadLine(); // "190+154+114";

    var numbers = new List<double>();
    var operators = new List<char>();
    double tmp = 0;

    // We will break up the string by searching for operators. Each time we find
    // one, we grab the string from the previous operator to the current one and
    // store it in 'numbers' as a double, then we grab the current operator and
    // store it in 'operators' as a char. At the very end, we grab the last number.
    var previousOperatorIndex = 0;
    var operatorIndex = inputNumber.IndexOfAny(knownOperators, previousOperatorIndex);
    while (operatorIndex > -1)
    {
        // Add the number part - the string from the previous operator to this one
        if (double.TryParse(inputNumber.Substring(previousOperatorIndex, 
            operatorIndex - previousOperatorIndex), out tmp))
        {
            numbers.Add(tmp);
        }

        operators.Add(inputNumber[operatorIndex]);
        previousOperatorIndex = operatorIndex + 1;
        operatorIndex = inputNumber.IndexOfAny(knownOperators, previousOperatorIndex);
    }
    // Add the last number (after the last operator)
    if (double.TryParse(inputNumber.Substring(previousOperatorIndex), out tmp))
    {
        numbers.Add(tmp);
    }

    // Validate we have one more number than operator
    if (numbers.Count < (operators.Count + 1))
    {
        Console.WriteLine("Error: there were too many operators!");
    }
    else if (numbers.Count > (operators.Count + 1))
    {
        Console.WriteLine("Error: there were too many numbers!");
    }
    else
    {
        // Do the math!
        double result = numbers[0];

        for (int i = 1; i < numbers.Count; i++)
        {
            switch (operators[i - 1])
            {
                case '+':
                    result += numbers[i];
                    break;
                case '-':
                    result -= numbers[i];
                    break;
                case '*':
                    result *= numbers[i];
                    break;
                case '/':
                    result /= numbers[i];
                    break;
                default:
                    break;
            }
        }

        Console.WriteLine("The result is: {0}", result);
    }

    Console.Write("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}