结对项目

Node getRandomEquation() {
	int siz = (rand() % operatorLimit + 1) * 2 + 1;
	vector <Node> List(siz);//用vector实现将链缩成点的过程
	vector <int> priority;//优先级
	List[0].fr.random_init(); List[0].checkeq = List[0].eq = List[0].fr.write();
	List[0].l = -1, List[0].r = 1; List[0].bracketadd = 0;
	for (int i = 1; i < siz; i += 2) {//节点数据初始化,使链呈现数字与运算符交替的结构(即是一条合法的无括号四则运算算式)
		List[i].l = i - 1; List[i].r = i + 1;
		List[i].op = getRandomOperator();
		List[i].checkeq = List[i].eq = List[i].op;
		List[i].bracketadd = false;
		priority.push_back(i);
		List[i + 1].l = i; List[i + 1].r = i + 2;
		List[i + 1].fr.random_init();
		List[i + 1].checkeq = List[i + 1].eq = List[i + 1].fr.write();
		List[i + 1].bracketadd = false;
	}

	random_shuffle(priority.begin(), priority.end());//随机排序以获得运算符的运算优先级
	for (auto id : priority)
	{
		/*
		该合并过程可以看作将链根据节点优先级缩成一个点
		初始每个节点对应分别一条合法的无括号四则运算算式的数字和运算符
		按优先级逐级操作链上的运算符节点，每次对一个运算符节点操作时，
		首先根据两个相邻数字节点的数据更新当前运算符节点从而得到新的数字节点，并根据运算符优先级判断是否添加括号。
		然后将两个相邻的数字节点从链中删除（该操作通过修改下标实现懒删除)
		此时可以看作链上的一个运算符节点和其相邻的数字节点合并成了新的数字节点。
		重复上述操作，将链上的所有节点合并完成，最终剩下的节点包含的四则运算式即是目标算式。
		查重字符串则是数字节点在合并中按字典序较小来进行合并且始终添加括号的结果(可确保有限次交换相同的字符串其查重字符串一样）
		*/
		int lid = List[id].l, rid = List[id].r;//获取进行运算元素的下标
		string lop = List[lid].l == -1 ? "#" : List[List[lid].l].op;//获取该运算符左边的运算符
		string rop = List[rid].r == siz ? "#" : List[List[rid].r].op;//获取该运算符右边的运算符
		List[id].fr = autoCal(List[lid].fr, List[id].op, List[rid].fr);
		if (List[id].fr < 0) {//合并节点值小于0，交换合并顺序并更新括号
			if ((List[lid].op == "-" || List[lid].op == "+") && List[lid].bracketadd == false) {
				List[lid].eq = '(' + List[lid].eq + ')';
				List[lid].bracketadd = true;
			}
			if ((List[rid].op == "-" || List[rid].op == "+") && List[rid].bracketadd == true) {
				List[rid].eq = List[rid].eq.substr(1, (int)List[rid].eq.size() - 2);
				List[rid].bracketadd = false;
			}
			List[lid].swapkey(List[rid]);//交换节点的关键值
			List[id].fr = autoCal(List[lid].fr, List[id].op, List[rid].fr);
			if (List[id].fr.error_check())//算式运算过程发生除0错误
				return { Fraction(),"","","",0,0 };
		}

		if (getPriority(lop) < getPriority(List[id].op) && getPriority(List[id].op) >= getPriority(rop))//根据优先级判断是否添加括号
			List[id].eq = List[lid].eq + List[id].eq + List[rid].eq;
		else
		{
			if (getPriority(lop) >= getPriority(List[lid].op) && getPriority(List[lid].op) >= getPriority(List[id].op) && List[lid].bracketadd == true) {
				List[lid].eq = List[lid].eq.substr(1, (int)List[lid].eq.size() - 2);//移除不需要的括号
				List[lid].bracketadd = false;
			}
			List[id].eq = '(' + List[lid].eq + List[id].eq + List[rid].eq + ')';
			List[id].bracketadd = true;
		}

		if ((List[id].op == "+" || List[id].op == "*") && List[lid].checkeq > List[rid].checkeq)//根据字典序增序生成查重用字符串
			List[id].checkeq = List[rid].checkeq + List[id].checkeq + List[lid].checkeq;
		else
			List[id].checkeq = List[lid].checkeq + List[id].checkeq + List[rid].checkeq;

		List[id].r = List[rid].r;
		List[id].l = List[lid].l;
		if (List[id].l != -1)  List[List[id].l].r = id;
		if (List[id].r != siz) List[List[id].r].l = id;
	}
	Node ans = List[priority.back()];
	if (vis.find(ans.checkeq) != vis.end())
		return { Fraction(),"","","",0,0 };
	vis.insert(ans.checkeq);
	return ans;
}

string calculate(string eq) {
    stack<string> opt;
    queue<pair<string, Fraction>> postOrder;
    size_t last = 0;
    for (size_t i = 0; i < eq.size(); i++) { //求后缀表达式
        if (eq[i] == '=') {//算式存在等于号，加载最后一个数字
            if (last != i)
                postOrder.push({ "",Fraction(stringToFraction(eq.substr(last,i - last))) });
            last = i + 1;
            continue;
        }
        else if (eq[i] == '+' || eq[i] == '-' || eq[i] == '*') {
            if (last != i)
                postOrder.push({ "",Fraction(stringToFraction(eq.substr(last,i - last))) });
            last = i + 1;
            while (!(opt.empty() || getPriority(eq.substr(i, 1)) > getPriority(opt.top()))) {
                postOrder.push({ opt.top(),Fraction() });
                opt.pop();
            }
            opt.push(eq.substr(i, 1));
        }
        else if (eq.substr(i, 2) == "÷") {
            if (last != i)
                postOrder.push({ "",Fraction(stringToFraction(eq.substr(last,i - last))) });
            last = i + 2;
            while (!(opt.empty() || getPriority(eq.substr(i, 2)) > getPriority(opt.top()))) {
                postOrder.push({ opt.top(),Fraction() });
                opt.pop();
            }
            opt.push(eq.substr(i, 2));
        }
        else if (eq[i] == '(') {
            opt.push(eq.substr(i, 1));
            last++;
        }
        else if (eq[i] == ')') {
            if (last != i)
                postOrder.push({ "",Fraction(stringToFraction(eq.substr(last,i - last))) });
            last = i + 1;
            while (!opt.empty() && opt.top() != "(") {
                postOrder.push({ opt.top(),Fraction() });
                opt.pop();
            }
            if (!opt.empty()) opt.pop();
        }
    }
    if (last < eq.size())//算式不存在等于号时，加载最后一个数字
        postOrder.push({ "",Fraction(stringToFraction(eq.substr(last))) });
    while (!opt.empty()) {
        postOrder.push({ opt.top(),Fraction() });
        opt.pop();
    }
    stack<Fraction> st;
    while (!postOrder.empty())
    {
        if (postOrder.front().first != "") {
            Fraction fra1 = st.top();
            if (!st.empty()) st.pop();
            Fraction fra2 = st.top();
            if (!st.empty()) st.pop();
            st.push(autoCal(fra2, postOrder.front().first, fra1));
        }
        else {
            st.push(postOrder.front().second);
        }
        postOrder.pop();
    }
    if (st.empty())
        throw out_of_range("Index out of range");
    return st.top().write();
}

namespace UnitTest
{
	TEST_CLASS(UnitTest)
	{
	public:
		TEST_METHOD(TestMethod1)
		{
			char* argv[5] = { "main.exe","-n","10000","-r","100" };
			Assert::AreEqual(main(5, argv), 0);
		}
		TEST_METHOD(TestMethod2)
		{
			char* argv[3] = { "main.exe","-n","10000" };
			Assert::AreEqual(main(3, argv), 0);
		}
		TEST_METHOD(TestMethod3)
		{
			char* argv[3] = { "main.exe","-n","-10000" };
			Assert::AreEqual(main(3, argv), 1);
		}
		TEST_METHOD(TestMethod4)
		{
			char* argv[5] = { "main.exe","-e","10000","-a","100" };
			Assert::AreEqual(main(5, argv), 3);
		}
		TEST_METHOD(TestMethod5)
		{
			char* argv[4] = { "main.exe","-e","10000","-a" };
			Assert::AreEqual(main(4, argv), -1);
		}
		TEST_METHOD(TestMethod6)
		{
			char* argv[5] = { "main.exe","-e","Exercises.txt","-a","Answers.txt" };
			Assert::AreEqual(main(5, argv), 0);
		}
		TEST_METHOD(TestMethod7)
		{
			Assert::AreEqual(getPriority("+"), 1);
			Assert::AreEqual(getPriority("-"), 1);
			Assert::AreEqual(getPriority("*"), 2);
			Assert::AreEqual(getPriority("÷"), 2);
			Assert::AreEqual(getPriority("#"), 0);
		}
		TEST_METHOD(TestMethod8)
		{
			string eq = "1.  3'5/7+(1*6'2/3-6)=";
			string str = "1.  4'8/21";
			Assert::IsTrue(str.compare(calculate(eq)));
		}
		TEST_METHOD(TestMethod9)
		{
			Fraction x(100, 10), y(-50, 10);
			string op1 = "+";
			string op2 = "-";
			string op3 = "*";
			string op4 = "÷";
			string ans = "15";
			Assert::IsTrue(ans.compare(autoCal(x, op1, y).write()));
			ans = "5";
			Assert::IsTrue(ans.compare(autoCal(x, op2, y).write()));
			ans = "50";
			Assert::IsTrue(ans.compare(autoCal(x, op3, y).write()));
			ans = "2";
			Assert::IsTrue(ans.compare(autoCal(x, op4, y).write()));

		}
		TEST_METHOD(TestMethod10)
		{
			string eq = "1'1/10";
			string str = "101/10";
			Assert::IsTrue(str.compare(stringToFraction(eq).write()));
		}
		TEST_METHOD(TestMethod11)
		{
			char* argv[5] = { "main.exe","-n","10000","-r","0" };
			Assert::AreEqual(main(5, argv), 2);
		}
		TEST_METHOD(TestMethod12)
		{
			char* argv[5] = { "main.exe","-n","100000","-r","2" };
			Assert::AreEqual(main(5, argv), 5);
		}
		TEST_METHOD(TestMethod13)
		{
			char* argv[5] = { "main.exe","-a","Exercises.txt","-e","Answers.txt" };
			ofstream fileExample("Exercises.txt");
			ofstream fileAnswer("Answers.txt");
			fileExample << "1.  " << "1+1" << "=" << endl;
			fileExample << "2.  " << "10+1" << "=" << endl;
			fileExample << "3.  " << "1+15" << "=" << endl;
			fileAnswer << "1.  " << "0" << endl;
			fileAnswer << "2.  " << "5" << endl;
			fileAnswer << "3.  " << "8" << endl;
			Assert::AreEqual(main(5, argv), 0);
		}
		TEST_METHOD(TestMethod14)
		{
			char* argv[5] = { "main.exe","-x","Exercises.txt","-t","Answers.txt" };
			Assert::AreEqual(main(5, argv), 7);
		}
		TEST_METHOD(TestMethod15)
		{
			char* argv[5] = { "main.exe","-e","Exercises.txt","-a","Answers.txt" };
			ofstream fileExample("Exercises.txt");
			fileExample << "%#%$" << "=" << endl;
			Assert::AreEqual(main(5, argv),6);
		}
	};
}