C#：脑力劳动者

所以是的，我正在制作Brainfuck解释器，但我还需要从它的代码中创建AST。

---

基本操作（+-，>++[>++据我所知，如果创建

元组

，则需要这两个值。因此，我将滚动我自己的类：

class MyTuple { public int A; public int B; }

然后，在解析过程中，每次遇到一个左括号时，创建一个

MyTuple

并将位置分配给

.a

。然后

将该实例推到
堆栈上
。继续解析，如果遇到另一个左括号，则创建一个新的
MyTuple
实例并
Psuh
将其也推到de>Stack

变量。如果遇到一个右括号

Pop

来自

堆栈的一个实例，请指定
.B
值，并将其作为完整的对放入数据结构中

var s = "brainfuck";
var q = new Stack<MyTuple>();
var res = new YourResultClass();

for(int i = 0; i < s.Length; i++)
{
    if(s[i] == '[')
    {
        var m = new MyTuple();
        m.A = i;
        q.Push(m);
    }
    if(s[i] == ']')
    {
        var e = q.Pop();
        e.B = i;
        res.lsTuples.Add(e);
    }
}
if(q.Count > 0)
    throw new IOException();

var s=“brainfuck”；
var q=新堆栈（）；
var res=新建YourResultClass（）；
对于（int i=0；i0）
抛出新IOException（）；
这里有一个“不是很有效但很简单”的方法

对于每个开口支架
X
，执行以下操作以查找其对：


声明一个变量
bracketCount
循环遍历
X之后的字符

如果看到另一个左括号，请将1添加到
bracketCount
如果看到另一个结束括号，请检查
bracketCount
是否为0，如果为0，则您已找到与
X
对应的结束括号！如果不是0，请从
bracketCount
中减去1
嗯，我有各种输入异常，所以我只能使用一个堆栈

class Program
{
    static void Main(string[] args)
    {
        Solver s = new Solver();
        s.Solve("++[>+[>++<-]<-]++[>++<-]>.");
        s.Visualize();
        Console.Read();
    }
}

public class Solver
{
    private readonly List<int> rightBracketsIds;
    private readonly List<int> leftBracketsIds;

    private readonly List<Tuple<int, int>> lsTuples;
    public Solver()
    {
        rightBracketsIds = new List<int>();
        leftBracketsIds = new List<int>();
        lsTuples = new List<Tuple<int, int>>();
    }

    public void Solve(string s)
    {
        Stack<int> st = new Stack<int>();
        for (int i = 0; i < s.Length; i++)
        {
            switch (s[i])
            {
                case '[':
                    st.Push(i);
                    break;
                case ']':
                    int index = st.Any() ? st.Pop() : -1;
                    lsTuples.Add(new Tuple<int, int>(index, i));
                    break;
            }
        }
    }

    public void Visualize()
    {
        foreach (Tuple<int, int> tuple in lsTuples)
        {
            Console.WriteLine(tuple.Item1 + " " + tuple.Item2);
        }
    }
}

类程序
{
静态void Main（字符串[]参数）
{
解算器s=新解算器（）；
s、 求解（“++[>+[>++
var s = "brainfuck";
var q = new Stack<MyTuple>();
var res = new YourResultClass();

for(int i = 0; i < s.Length; i++)
{
    if(s[i] == '[')
    {
        var m = new MyTuple();
        m.A = i;
        q.Push(m);
    }
    if(s[i] == ']')
    {
        var e = q.Pop();
        e.B = i;
        res.lsTuples.Add(e);
    }
}
if(q.Count > 0)
    throw new IOException();

class Program
{
    static void Main(string[] args)
    {
        Solver s = new Solver();
        s.Solve("++[>+[>++<-]<-]++[>++<-]>.");
        s.Visualize();
        Console.Read();
    }
}

public class Solver
{
    private readonly List<int> rightBracketsIds;
    private readonly List<int> leftBracketsIds;

    private readonly List<Tuple<int, int>> lsTuples;
    public Solver()
    {
        rightBracketsIds = new List<int>();
        leftBracketsIds = new List<int>();
        lsTuples = new List<Tuple<int, int>>();
    }

    public void Solve(string s)
    {
        Stack<int> st = new Stack<int>();
        for (int i = 0; i < s.Length; i++)
        {
            switch (s[i])
            {
                case '[':
                    st.Push(i);
                    break;
                case ']':
                    int index = st.Any() ? st.Pop() : -1;
                    lsTuples.Add(new Tuple<int, int>(index, i));
                    break;
            }
        }
    }

    public void Visualize()
    {
        foreach (Tuple<int, int> tuple in lsTuples)
        {
            Console.WriteLine(tuple.Item1 + " " + tuple.Item2);
        }
    }
}