Question

在最近的几个小时中，我一直在尝试如何解析带有代数符号的字符串。

例如，如果我输入以下内容：

df.iloc[:,3:]=df.iloc[:,3:][df.iloc[:,3:].eq(1).shift(axis=1).cumsum(1).fillna(0).eq(0)]
df
Out[85]: 
   IndividualID  Ifmarried  Sex  Trip1  Trip2  Trip3  Trip4  Trip5  Trip6  \
0     200100001          1    2     23    1.0    NaN    NaN    NaN    NaN   
1     200100002          1    1     21    2.0   12.0    3.0    1.0    NaN   
2     200100003          2    1     12    3.0    1.0    NaN    NaN    NaN   
3     200100004          1    2      1    NaN    NaN    NaN    NaN    NaN   
4     200100005          1    2      6    5.0    1.0    NaN    NaN    NaN   
5     200100006          1    2     23    4.0    4.0    1.0    NaN    NaN   
   Trip7  Trip8  Trip9  
0    NaN    NaN    NaN  
1    NaN    NaN    NaN  
2    NaN    NaN    NaN  
3    NaN    NaN    NaN  
4    NaN    NaN    NaN  
5    NaN    NaN    NaN

输出应为：

from __future__ import absolute_import, division, print_function
from mayavi import mlab
import numpy as np

fig = mlab.figure(figure=None, bgcolor=(0,0,0), fgcolor=None, engine=None, size=(400, 400))
data = np.random.rand(3, 3)
x, y, z = np.transpose(data)
mlab.points3d(x, y, z, -y, colormap="RdYlBu", scale_factor=1, scale_mode='none')
mlab.show()

到目前为止，如果我尝试查看X后面是否存在数字并尝试了许多情况，但是我一直在使索引越界错误，正是如此。关于如何解决它的任何建议？

X+8X-21X+21X+16

Answer 1

我会使用一种更易于维护的方法。
分离不同的代码部分，并使用表示代数方程中“部分”的类的集合。这是我的建议：

class Program
{
    static void Main(string[] args)
    {
        string[] operators = { "+", "-", "/", "*" };
        string test = "X+8X-21X+21X+16";
        int locationcounter = 0;
        string part = string.Empty;
        List<Part> partsList = new List<Part>();

        for (int i = 0; i < test.Length; i++)
        {
            if (operators.Contains(test[i].ToString()))
            {
                var operatorbeofore = (partsList.Count <= 0 ? "" : partsList[partsList.Count - 1].OperatorAfter);
                partsList.Add(new Part(part, operatorbeofore, test[i].ToString(), locationcounter));
                locationcounter++;
                part = string.Empty;
            }
            else
            {
                part += test[i].ToString();
            }
        }

        // last part that remain
        if (part != string.Empty)
        {
            partsList.Add(new Part(part, partsList[partsList.Count() - 1].OperatorAfter, "", locationcounter++));
        }
        // output
        Console.WriteLine(GetResultOutput(partsList));
        Console.ReadLine();
    }

    private static string GetResultOutput(List<Part> algebraicexpression)
    {
        // reduce all vars
        var vars = algebraicexpression.Where(x => x.IsVar).OrderBy(x => x.locationInEqution).ToList();
        int lastVarResult = 0;
        int varResult = 0;
        if (vars.Count() > 1)
        {
            lastVarResult = GetCalculation(vars[0].Value, vars[1].Value, vars[1].OperatorBefore);
            for (int i = 2; i < vars.Count(); i++)
            {
                varResult = GetCalculation(lastVarResult, vars[i].Value, vars[i].OperatorBefore);
                lastVarResult = varResult;
            }
        }
        else if (vars.Count() == 1)
        {
            lastVarResult = vars[0].Value;
        }
        // calculate all "free" numbers
        var numbers = algebraicexpression.Where(x => x.IsVar == false).OrderBy(x => x.locationInEqution).ToList();
        int lastResult = 0;
        int Result = 0;
        if (numbers.Count() > 1)
        {
            lastResult = GetCalculation(vars[0].Value, vars[1].Value, vars[1].OperatorBefore);
            for (int i = 2; i < vars.Count(); i++)
            {
                Result = GetCalculation(lastResult, vars[i].Value, vars[i].OperatorBefore);
                lastResult = varResult;
            }
        }
        else if (numbers.Count() == 1)
        {
            Result = numbers[0].Value;
        }

        string stringresult = string.Empty;
        if (varResult != 0)
        {
            stringresult = varResult.ToString() + vars[0].Notation;
        }

        if (Result > 0)
        {
            stringresult = stringresult + "+" + Result.ToString();
        }
        else if (Result < 0)
        {
            stringresult = stringresult + "-" + Result.ToString();
        }

        return stringresult;
    }

    private static int GetCalculation(int x, int y, string eqoperator)
    {
        if (eqoperator == "+")
        {
            return x + y;
        }
        else if (eqoperator == "-")
        {
            return x - y;
        }
        else if (eqoperator == "*")
        {
            return x * y;
        }
        else if (eqoperator == "/")
        {
            return x / y;
        }
        else
        {
            return 0;
        }

    }
}

class Part
{
    public string MyAlgebricPart;
    public string OperatorBefore;
    public string OperatorAfter;
    public int locationInEqution;

    public Part(string part, string operatorbefore, string operatorafter, int location)
    {
        this.MyAlgebricPart = part;
        this.OperatorAfter = operatorafter;
        this.OperatorBefore = operatorbefore;
        this.locationInEqution = location;
    }

    public int Value
    {
        get
        {
            if (MyAlgebricPart.Count() == 1 && Notation != string.Empty)
            {
                return 1;
            }
            else
            {
                string result = new String(MyAlgebricPart.Where(Char.IsDigit).ToArray());
                return Convert.ToInt32(result);
            }
        }
    }
    public string Notation
    {
        get
        {
            var onlyLetters = new String(MyAlgebricPart.Where(Char.IsLetter).ToArray());
            if (onlyLetters != "")
            {
                return onlyLetters[0].ToString();
            }
            else
            {
                return string.Empty;
            }

        }
    }

    public bool IsVar
    {
        get
        {
            if (Notation == string.Empty)
                return false;
            else
                return true;
        }
    }
}

添加代数X表示法

1 个答案: