软件工程——结对项目——四则运算题目生成

最新推荐文章于 2020-10-11 23:40:36 发布
最新推荐文章于 2020-10-11 23:40:36 发布
阅读量1.3k 收藏 7
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xie_mixue/article/details/86302591
版权

软件工程——结对项目——四则运算题目生成

队友博客地址：https://blog.csdn.net/qq_37248820/article/details/86301669
-------------------------------------------------------------------------------------------------------------------
实现一个能够自动生成小学四则运算题目的Windows控制台程序，最后扩展为一个Windows图形界面程序。

第一阶段：
a. 能够生成一千道小学四则运算题目到一个文件里，保证合法、不重复。
b. 可以设置乘方的符号选择（ ** 或 ^ ）。
c. 能解最多包含10个运算符的表达式（其中括号数不受限制，运算符有+，-，*，/，^ (或 **) 五种）。
d. 除了整数之外，还支持真分数的四则运算。
e. 能接受用户输入的答案，并判定对错，统计总共的对/错数量。

第二阶段：
和队友商量后，决定选择第一个扩展方向进行扩展。
a. 把程序变成一个Windows电脑图形界面的程序。
b. 增加一个日历显示器，显示当前时间。
c. 增加倒计时功能，每个题目必须在20秒内完成。
d. 增加历史记录功能，可以保存并展示用户的做题成绩记录。
-------------------------------------------------------------------------------------------------------------------

文章目录

一、GitHub项目地址

项目的GitHub地址：https://github.com/BeckyYang/Arithmetic_SoftwareEngineeringTeamProject

二、PSP表格

PSP2.1Personal Software Process Stages预估耗时(min)实际耗时(min)
Planning计划2020
Estimate估计这个任务需要多少时间2020
Development开发28802160
Analysis需求分析（包括学习新技术）14401460
Design Spec生成设计文档00
Design Review设计复审（和同事审核设计文档）00
Coding Standard代码规范（为目前的开发制定合适的规范）00
Design具体设计6060
Coding具体编码57605760
Code Review代码复审60120
Test测试（自我测试，修改代码，提交修改）10002000
Reporting报告00
Test Report测试报告60120
Size Measurement计算工作量600
Postmortem & Process Improvement Plan事后总结，并提出过程改进计划60180
合计1136011900

三、实现思路

拿到题目之后，和队友讨论了一下分工合作，决定我负责题目生成部分，她负责题目求解部分，最后的扩展部分由我们两人共同完成。

题目分为两种类型：整数四则运算和分数四则运算，不包括整数和分数混合运算。

3.1 控制台程序的题目生成

初步思路：

  • 将分数用一个类来表示，包括分子和分母属性。分数的随机生成可通过随机生成分子和分母来实现。
  • 通过rand()函数来随机生成数和运算符（控制在1到10个之间，不包括括号），将二者组合可得到不同的表达式。
  • 再通过rand()随机生成括号。

后来在初步实现时，发现出现了随机生成的数太大，乘方的幂不是整数，表达式包含的运算符普遍偏多，随机数每次重复出现，没有做到真正随机化的情况，这样的难度并不适合小学生。于是做了如下的改进。

改进思路：

  • 将随机生成的数%10，这样可控制数字在0到9范围内。
  • 乘方后面的数采用整数形式，将随机生成的乘方的幂%3，这样可以控制幂在0到2范围内。
  • 采用正态分布来控制运算符个数和括号个数，使得大部分表达式的运算符个数为3，括号个数为3。
  • 使用 time函数来获得系统时间，然后将time_t型数据转化为(unsigned)型再传给随机数引擎。说明：一个给定的随机数发生器一直会生成相同的随机数序列，所以随机数引擎的参数一般用time(NULL)，因为系统的时间一直在变，所以rand()获得的数，也就一直在变，相当于是随机数了。
  • 判重部分：主要通过运算过程来判断题目是否重复。通过对操作数栈和运算符栈进行操作，将目前已生成的所有不重复题目的运算过程保存在运算过程记录区stack_order[ ][ ]中。之后，每生成一个题目，将其运算过程与stack_order中的每一行进行比较，若相同，则重复，重新生成题目；否则，将其运算过程存入stack_order[ ][ ]中。

3.2 Windows图形界面程序的题目生成

主要设计4个窗体界面：

  • 欢迎主界面：含有一个“开始”按键，用户点击即可进入到操作请求界面。
  • 操作请求界面：含有一个日历显示器，显示当前日期。用户输入用户名、题目数量和题目类型（默认为A（没有乘方的普通运算），也可选择B（乘方用^表示）或C（乘方用**表示））并点击Begin按键，即可开始答题。点击Record按键可查询历史答题记录（每一条记录由题目，True or False , 用户答案， 正确答案组成，因超时而未做答的题不予以记录）；点击Quit按键，可推出整个程序。
  • 答题界面：输入答案，点击OK键可提交答案（答案必须为最简形式，假分数需表示为整数+(或-)真分数），提交后显示答题结果和正确答案；另外在答题界面设置一个20秒的倒计时器，时间一到，提醒用户并切换到下一题。点击Cancle键可提出答题界面，回到操作请求界面，继续操作。
  • 记录查询界面：点击Query即可查询历史记录；点击Quit即可回到操作请求界面，执行其他操作。

基于C++版本的实现改进：

  • 由于没有C#的基础，所以只能边学边做。为了控制题目的长度，在用C#实现满足正态分布的随机数时，因为没有现成的函数可以调用，所以参照了网上的部分代码。在未采用之前，题目长度普遍偏长，难度偏大，不适合小学生做。（参照的正态分布随机函数代码地址）
  • 另外，C#版本相对于C++版本的控制台程序作了一定改进：在判重时，将整数也用分数表示，统一采用分数类fraction的重载运算符来计算，这样可以很好地解决“/”对于整数而言为整除的问题，使得结果更加准确。

四、生成题目代码设计实现

由于代码太长，仅说明部分函数。完整代码链接

生成题目的主要函数包括：

int GetGCD(int a, int b);  //求分子a好分母b的最大公约数

int RandomSymbolGenerate(char type);  //随机生成运算符

int RandLeftBracketGenerate();  //随机生成左括号

int RandRightBracketGenerate();  //随机生成右括号

int RandIntegerGeneate();   //随机生成0到9的整数

fraction& RandFractionGeneate();  //随机生成真分数（不包括0和1）,分子和分母均在0到9之间

int IntPartialResult(int A, int B, int sym); //两个整数的四则运算

fraction& FractionPartialResult(fraction &A, fraction& B, int sym);  // 两个分数的四则运算

int Check(int puzzle[], int puzzle_len, int puzzle_num, int num_type);  //判断题目是否重复

void PuzzleGenerate(char* argv, int N, char type);  //生成N个四则表达式

生成表达式部分：通过借助随机函数rand(), 来随机生成操作数和运算符以及括号。将三者组合形成一个表达式。

  • 随机生成0到9的整数
int RandIntegerGeneate() //随机生成0到9的整数
{
	int number = rand() % 10;
	if (number < 0) number = 0;
	return number;
}
  • //随机生成真分数（不包括0和1）,分子和分母均在0到9之间

fraction& RandFractionGeneate() //随机生成真分数（不包括0和1）,分子和分母均在0到9之间
{
	int t;
	int rand_numerator = rand() % 10;
	if (rand_numerator <= 0) rand_numerator = 1;
	int rand_denominator = rand() % 10;
	if (rand_denominator <= 0) rand_denominator = 1;
	if (rand_numerator > rand_denominator)
	{
		t = rand_numerator;
		rand_numerator = rand_denominator;
		rand_denominator = t;
	}
	else if (rand_numerator == rand_denominator)
	{
		rand_denominator += 1;
	}
	int GCD = GetGCD(rand_numerator, rand_denominator);
	fraction number(rand_numerator/GCD, rand_denominator/GCD);
	return number;
}
  • int RandLeftBracketGenerate(); //随机生成左括号
int RandLeftBracketGenerate() //随机生成左括号
{
	int left_bracket = rand() % 2;
	return left_bracket;//1表示当前生成左括号，0表示当前不生成左括号
}
  • int RandRightBracketGenerate(); //随机生成右括号
int RandRightBracketGenerate() //随机生成右括号
{
	int right_bracket = rand() % 2;
	return right_bracket; //1表示当前生成右括号，0表示当前不生成右括号
}

判重部分：主要借助栈来使实现题目的判重。

  • 运算符优先级：
运算符( 、)+ 、-* 、/^ 、**
优先级0123
  • 记录题目运算过程流程图：
    在这里插入图片描述
  • 将当前题目的解题过程order[]与stack_order[][]中的所有题目的解题过程比较，若重复，则重新生成；否则将order[]记录到stack_order[][]中。
  • 判重部分实现代码
int Check(int puzzle[], int puzzle_len, int puzzle_num, int num_type) //判断题目是否重复
{
	int i, j, L = 1, s, A, B, t, first = 0;
	fraction FA, FB, Ft;
	stack<int> stack_integer;
	stack<fraction> stack_fraction;
	stack<int> stack_operator;
	int order[600];
	memset(order, 0, sizeof(order));
	/********整数表达式*******/
	if (num_type == 0)
	{
		for (i = 0; i < puzzle_len; i++)
		{
			if (puzzle[i] < 0) continue;
			if (puzzle[i] < 100 && puzzle[i] >=0) //遇到数字，数字直接进入stack_integer栈
			{
				stack_integer.push(puzzle[i]);
			}
			else
			{
				if (puzzle[i] == 106) //遇到左括号，左括号直接入stack_operator栈
				{
					stack_operator.push(106);
				}
				else if (puzzle[i] == 107) //遇到右括号，弹出所有运算符，直至遇到左括号
				{
					if (!stack_operator.empty())
					{
						do
						{
							s = stack_operator.top(); //运算符出栈
							stack_operator.pop();
							B = stack_integer.top(); //操作数B出栈
							stack_integer.pop();
							A = stack_integer.top(); //操作数A出栈
							stack_integer.pop();
							if (s == 100 || s == 102) //+,*法，统一按照大数在前，小数在后方式运算
							{
								if (A < B)
								{
									t = A;
									A = B;
									B = t;
								}
							}
							order[L++] = A;
							order[L++] = s;
							order[L++] = B;
							if ((s == 103 && B == 0) || ((s == 104 || s == 105) && A == 0 && B == 0))
							{
								return -1;
							}
							stack_integer.push(IntPartialResult(A, B, s)); //运算结果入栈
						} while (stack_operator.empty() == false && stack_operator.top() != 106);
						if (!stack_operator.empty()) stack_operator.pop(); //弹出左括号
					}
				}
				else
				{
					if (puzzle[i] == 104 || puzzle[i] == 105) //遇到乘方，乘方优先级最高,乘方直接进运算符栈
					{
						stack_operator.push(puzzle[i]);
					}
					else
					{
						//遇到运算符，且运算符栈为空或者栈顶运算符优先级小于当前运算符优先级,运算符直接进运算符栈
						if (stack_operator.empty() == true || (stack_operator.empty() == false && priority[stack_operator.top()-100] < priority[puzzle[i]-100])) stack_operator.push(puzzle[i]);
						else
						{
							do
							{
								s = stack_operator.top(); //运算符出栈
								stack_operator.pop();
								B = stack_integer.top(); //操作数B出栈
								stack_integer.pop();
								A = stack_integer.top(); //操作数A出栈
								stack_integer.pop();
								if ((s == 100 || s == 102) && A < B) //+,*法，统一按照大数在前，小数在后方式运算
								{
									t = A;
									A = B;
									B = t;
								}
								order[L++] = A;
								order[L++] = s;
								order[L++] = B;
								if ((s == 103 && B == 0) || ((s == 104 || s == 105) && A == 0 && B == 0))
								{
									return -1;
								}
								stack_integer.push(IntPartialResult(A, B, s)); //运算结果入栈
							} while (stack_operator.empty() == false && priority[stack_operator.top() - 100] >= priority[puzzle[i]-100]);
							stack_operator.push(puzzle[i]); //运算符进运算符栈
						}
					}	
				}
			}
		}
		if (stack_operator.empty() == false)
		{
			do
			{
				s = stack_operator.top(); //运算符出栈
				stack_operator.pop();
				B = stack_integer.top(); //操作数B出栈
				stack_integer.pop();
				A = stack_integer.top(); //操作数A出栈
				stack_integer.pop();
				if ((s == 100 || s == 102) && A < B) //+,*法，统一按照大数在前，小数在后方式运算
				{
					t = A;
					A = B;
					B = t;
				}
				order[L++] = A;
				order[L++] = s;
				order[L++] = B;
				if ((s == 103 && B == 0) || ((s == 104 || s == 105) && A == 0 && B == 0))
				{
					return -1;
				}
				stack_integer.push(IntPartialResult(A, B, s)); //运算结果入栈
			}while (stack_operator.empty() == false);
		}
		order[0] = L;
	}
	/****分数表达式****/
	else
	{
		for (i = 0; i < puzzle_len; i++)
		{
			if (puzzle[i] < 0) continue;
			if (puzzle[i] < 100 && puzzle[i] >= 0) //遇到分数，分数直接进入stack_fraction栈
			{
				fraction f(puzzle[i], puzzle[i + 2]);
				stack_fraction.push(f);
				i += 2;
			}
			else
			{
				if (puzzle[i] == 106) //遇到左括号，左括号直接入stack_operator栈
				{
					stack_operator.push(106);
				}
				else if (puzzle[i] == 107) //遇到右括号，弹出所有运算符，直至遇到左括号
				{
					s = stack_operator.top(); //运算符出栈
					do 
					{
						stack_operator.pop();
						FB = stack_fraction.top(); //操作数FB出栈
						stack_fraction.pop();
						FA = stack_fraction.top(); //操作数FA出栈
						stack_fraction.pop();
						if (s == 100 || s == 102) //+,*法，统一按照大数在前，小数在后方式运算
						{
							if (FA < FB)
							{
								Ft = FA;
								FA = FB;
								FB = Ft;
							}
						}
						order[L++] = FA.GetNumerator();
						order[L++] = 1030;
						order[L++] = FA.GetDenominator();
						order[L++] = s;
						order[L++] = FB.GetNumerator();
						order[L++] = 1030;
						order[L++] = FB.GetDenominator();
						if (FB.GetNumerator() == 0 && s == 103) return -1;
						fraction ff = FractionPartialResult(FA, FB, s);
						stack_fraction.push(ff); //运算结果入栈
					} while (stack_operator.empty() == false && (s = stack_operator.top()) != 106);
					stack_operator.pop(); //弹出左括号
				}
				else
				{
					//遇到运算符，且运算符栈为空或者栈顶运算符优先级小于当前运算符优先级,运算符直接进运算符栈
					if (stack_operator.empty() == true || (stack_operator.empty() == false && priority[stack_operator.top() - 100] < priority[puzzle[i] - 100])) stack_operator.push(puzzle[i]);
					else
					{
						do
						{
							s = stack_operator.top(); //运算符出栈
							stack_operator.pop();
							FB = stack_fraction.top(); //操作数B出栈
							stack_fraction.pop();
							FA = stack_fraction.top(); //操作数A出栈
							stack_fraction.pop();
							if ((s == 100 || s == 102) && FA < FB) //+,*法，统一按照大数在前，小数在后方式运算
							{
								Ft = FA;
								FA = FB;
								FB = Ft;
							}
							order[L++] = FA.GetNumerator();
							order[L++] = 1030;
							order[L++] = FA.GetDenominator();
							order[L++] = s;
							order[L++] = FB.GetNumerator();
							order[L++] = 1030;
							order[L++] = FB.GetDenominator();
							if (FB.GetNumerator() == 0 && s == 103) return -1;
							fraction ff = FractionPartialResult(FA, FB, s);
							stack_fraction.push(ff); //运算结果入栈
						} while (stack_operator.empty() == false && priority[stack_operator.top() - 100] >= priority[puzzle[i] - 100]);
						stack_operator.push(puzzle[i]); //运算符进运算符栈
					}
				}
			}
		}
		if (stack_operator.empty() == false)
		{
			do
			{
				s = stack_operator.top(); //运算符出栈
				stack_operator.pop();
				FB = stack_fraction.top(); //操作数B出栈
				stack_fraction.pop();
				FA = stack_fraction.top(); //操作数A出栈
				stack_fraction.pop();
				if ((s == 100 || s == 102) && FA < FB) //+,*法，统一按照大数在前，小数在后方式运算
				{
					Ft = FA;
					FA = FB;
					FB = Ft;
				}
				order[L++] = FA.GetNumerator();
				order[L++] = 1030;
				order[L++] = FA.GetDenominator();
				order[L++] = s;
				order[L++] = FB.GetNumerator();
				order[L++] = 1030;
				order[L++] = FB.GetDenominator();
				if (FB.GetNumerator() == 0 && s == 103) return -1;
				fraction ff = FractionPartialResult(FA, FB, s);
				stack_fraction.push(ff); //运算结果入栈
			} while (stack_operator.empty() == false);
		}
		order[0] = L;
	}

	/**********判断与之前的题目是否重复************/
	int flag = 0, label = 0;
	for (i = 0; i < puzzle_num; i++)
	{
		if (labels[i] != num_type || order[0] != stack_order[i][0]) continue;
		else
		{
			flag = 0;
			for (j = 1; j < stack_order[i][0]; j++)
			{
				if (stack_order[i][j] != order[j])
				{
					flag = 1;
					break;
				}
			}
			if (flag == 0)
			{
				label = 1;
				break;
			}
		}	
	}
	if (label == 1) return -1; //有重复
	else
	{
		for (j = 0; j < order[0]; j++) //登记到题目记录里
		{
			stack_order[puzzle_num][j] = order[j];
		}
		return 1; //无重复
	}
}

五、程序性能分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
由性能分析报告可知，题目生成和查重函数比较耗时，而题目生成的主要调用函数也是Check()函数。因此仅需要对查重函数Check()进行改进即可。对其的改进为：设置一个题型标记数组Labels[]，在判重时，优先判断题型是否一样，再判断解题过程的长度是否一样，最后再判断解题过程内容是否完全一样，这样可以减少判重时间。

六、测试数据

主要测试了题目查重和分数类运算符重载部分。

1、分数类运算符重载测试：

因为分数类运算符重载是最底层的重要部分，会受到上层函数的多次调用, 一旦这一部分出现错误，将直接导致上层函数的错误。所以对于分数类运算符重载部分的测试是有必要的。

测试用例如下：

数A运算符数B预期结果
2/3^01
2/3*2/34/9
2/3+15/3
2/3-1/31/3
6求最大公约数102
2求最大公约数31
5求最大公约数105

2、题目查重测试：

因为题目重复主要是由加法和乘法的交换律，以及括号的左结合性导致的，所以题目查重部分的测试主要针对 + 、* 、和（）以及三者的结合进行测试。

测试用例如下：

表达式1表达式2预期结果
1+2+33+(2+1)重复
1+2+33+2+1不重复
1 * 2 * 33 * 2 * 1不重复
(1+2) * 33 * (2+1)重复
1+2 ** 3 ** 12 ** 3 ** 1 + 1重复
(1+(1+2)*(3-2))+11+((3-2)*(1+2))+1)不重复
(1+(1+2)*(3-2))+11+((1+2)*(3-2))+1)重复
1+2 ** 3 ** 12 ** 3 ** 1 + 1重复
1/2 + （1/3 + 1/4）1/4 + 1/3 + 1/2重复
1/2 * （1/3 + 1/4）（1/4 + 1/3） * 1/2重复

3、测试代码

namespace ArithmeticGUI.Tests
{
    [TestClass()]
    public class ClassTests
    {
//----------------fraction.cs的单元测试------------------

        [TestMethod()]//正常情况
        public void FracionGetGCDTest1()
        {
            int x = 6;
            int y = 10;
            Assert.AreEqual(fraction.FracionGetGCD(x, y), 2);
        }
        [TestMethod()]//最大公因数为1
        public void FracionGetGCDTest2()
        {
            int x = 2;
            int y = 3;
            Assert.AreEqual(fraction.FracionGetGCD(x, y), 1);
        }
        [TestMethod()]//最大公因数为其中较小的数
        public void FracionGetGCDTest3()
        {
            int x = 5;
            int y = 10;
            Assert.AreEqual(fraction.FracionGetGCD(x, y), 5);
        }
//---------------N_Puzzle.cs的单元测试-----------------

        //--------------------题目查重测试------------------
        //加法交换+括号测试
        [TestMethod()]//测试1+2+3与3+(2+1)是否重复，预期结果为重复 -1
        public void CheckTest1()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 100, 2, 100, 3 };
            int[] puzzle2 = new int[] { 3, 100, 106, 2, 100, 1, 107 };
            int puzzle_len1 = 5;
            int puzzle_len2 = 7;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //加法顺序交换测试
        [TestMethod()]//测试1+2+3与3+2+1是否重复，预期结果为不重复 1
        public void CheckTest2()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 100, 2, 100, 3 };
            int[] puzzle2 = new int[] { 3, 100, 2, 100, 1 };
            int puzzle_len1 = 5;
            int puzzle_len2 = 5;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), 1);
        }
        //乘法顺序交换测试
        [TestMethod()]//测试1*2*3与3*2*1是否重复，预期结果为不重复 1
        public void CheckTest3()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 102, 2, 102, 3 };
            int[] puzzle2 = new int[] { 3, 102, 2, 102, 1 };
            int puzzle_len1 = 5;
            int puzzle_len2 = 5;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), 1);
        }
        //除法顺序交换测试
        [TestMethod()]//测试1/2/3与3/2/1是否重复，预期结果为不重复 1
        public void CheckTest4()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 103, 2, 103, 3 };
            int[] puzzle2 = new int[] { 3, 103, 2, 103, 1 };
            int puzzle_len1 = 5;
            int puzzle_len2 = 5;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), 1);
        }
        //乘法交换+括号测试
        [TestMethod()]//测试(1+2)*3与3*(2+1)是否重复，预期结果为重复 -1
        public void CheckTest5()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 106, 1, 100, 2, 107, 102, 3 };
            int[] puzzle2 = new int[] { 3, 102, 106, 2, 100, 1 ,107 };
            int puzzle_len1 = 7;
            int puzzle_len2 = 7;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //^乘方测试
        [TestMethod()]//测试1+2^3^1与2^3^1 + 1是否重复，预期结果为重复 -1
        public void CheckTest6()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 100, 2, 104, 3, 104, 1 };
            int[] puzzle2 = new int[] { 2, 104, 3, 104, 1, 100, 1 };
            int puzzle_len1 = 7;
            int puzzle_len2 = 7;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //括号嵌套测试
        [TestMethod()]//测试 (1+(1+2)*(3-2))+1 与 1+((3-2)*(1+2))+1) 是否重复，预期结果为不重复 1
        public void CheckTest7()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 106, 1, 100, 106, 1, 100, 2, 107, 102, 106, 3, 101, 2, 107, 107, 100, 1 };
            int[] puzzle2 = new int[] { 1, 100, 106, 106, 3, 101, 2, 107, 102, 106, 1, 100, 2, 107, 107, 100, 1 };
            int puzzle_len1 = 17;
            int puzzle_len2 = 17;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), 1);
        }
        //括号嵌套测试+乘法顺序变换
        [TestMethod()]//测试 (1+(1+2)*(3-2))+1 与 1+((1+2)*(3-2))+1) 是否重复，预期结果为重复 -1
        public void CheckTest8()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 106, 1, 100, 106, 1, 100, 2, 107, 102, 106, 3, 101, 2, 107, 107, 100, 1 };
            int[] puzzle2 = new int[] { 1, 100, 106, 106, 1, 100, 2, 107, 102, 106, 3, 101, 2, 107, 107, 100, 1 };
            int puzzle_len1 = 17;
            int puzzle_len2 = 17;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //**乘方测试
        [TestMethod()]//测试1+2**3**1与2**3**1 + 1是否重复，预期结果为重复 -1
        public void CheckTest9()
        {
            N_Puzzle.labels[0] = 0;
            N_Puzzle.labels[1] = 0;
            int[] puzzle1 = new int[] { 1, 100, 2, 105, 3, 105, 1 };
            int[] puzzle2 = new int[] { 2, 105, 3, 105, 1, 100, 1 };
            int puzzle_len1 = 7;
            int puzzle_len2 = 7;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 0;
            int num_type2 = 0;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //分数的加法+括号测试
        [TestMethod()]//测试 1/2 + （1/3 + 1/4） 与 1/4 + 1/3 + 1/2 是否重复，预期结果为重复 -1
        public void CheckTest10()
        {
            N_Puzzle.labels[0] = 1;
            N_Puzzle.labels[1] = 1;
            int[] puzzle1 = new int[] { 1, 1030, 2, 100, 106, 1, 1030, 3, 100, 1, 1030, 4, 107 };
            int[] puzzle2 = new int[] { 1, 1030, 4, 100, 1, 1030, 3, 100, 1, 1030, 2 };
            int puzzle_len1 = 13;
            int puzzle_len2 = 11;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 1;
            int num_type2 = 1;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }
        //分数的加法+乘法测试
        [TestMethod()]//测试 1/2 * （1/3 + 1/4） 与 （1/4 + 1/3） * 1/2 是否重复，预期结果为重复 -1
        public void CheckTest11()
        {
            N_Puzzle.labels[0] = 1;
            N_Puzzle.labels[1] = 1;
            int[] puzzle1 = new int[] { 1, 1030, 2, 102, 106, 1, 1030, 3, 100, 1, 1030, 4, 107 };
            int[] puzzle2 = new int[] { 106, 1, 1030, 4, 100, 1, 1030, 3, 107, 102, 1, 1030, 2 };
            int puzzle_len1 = 13;
            int puzzle_len2 = 13;
            int puzzle_num1 = 0;
            int puzzle_num2 = 1;
            int num_type1 = 1;
            int num_type2 = 1;
            N_Puzzle.Check(puzzle1, puzzle_len1, puzzle_num1, num_type1);
            Assert.AreEqual(N_Puzzle.Check(puzzle2, puzzle_len2, puzzle_num2, num_type2), -1);
        }

    //--------------运算符重载测试-------------------------

        [TestMethod()] //分数类 ^ 运算符重载
        public void CheckTest12()
        {
            bool z = false;
            fraction A = new fraction (2,3);
            fraction B = new fraction (0, 1);
            fraction C = A ^ B;
            fraction E = new fraction(1, 1);
            if (C == E) z = true;
            Assert.IsTrue(z);
        }

        [TestMethod()] //分数类 * 运算符重载
        public void CheckTest13()
        {
            bool z = false;
            fraction A = new fraction(2, 3);
            fraction B = new fraction(2, 3);
            fraction C = A * B;
            fraction E = new fraction(4, 9);
            if (C == E) z = true;
            Assert.IsTrue(z);
        }
        [TestMethod()] //分数类 / 运算符重载
        public void CheckTest14()
        {
            bool z = false;
            fraction A = new fraction(2, 3);
            fraction B = new fraction(1, 3);
            fraction C = A / B;
            fraction E = new fraction(2, 1);
            if (C == E) z = true;
            Assert.IsTrue(z);
        }
        [TestMethod()] //分数类 + 运算符重载
        public void CheckTest15()
        {
            bool z = false;
            fraction A = new fraction(2, 3);
            fraction B = new fraction(1, 1);
            fraction C = A + B;
            fraction E = new fraction(5, 3);
            if (C == E) z = true;
            Assert.IsTrue(z);
        }
        [TestMethod()] //分数类 - 运算符重载
        public void CheckTest16()
        {
            bool z = false;
            fraction A = new fraction(2, 3);
            fraction B = new fraction(1, 3);
            fraction C = A - B;
            fraction E = new fraction(1, 3);
            if (C == E) z = true;
            Assert.IsTrue(z);
        }

    } 
}

4、测试结果
在这里插入图片描述

七、C#版实现效果

欢迎主界面
在这里插入图片描述
操作请求界面
在这里插入图片描述
答题界面
在这里插入图片描述
记录查询界面
在这里插入图片描述

八、结队项目开发总结

这次结队项目的开发让我认识到了队友的重要性。还记得以前也有一次结队项目，7个人一起完成，但是由于彼此不熟悉，交流不到位，导致任务工作分配不合理，最后对接时，漏洞百出。这一点正好映证了“增加开发人员，不一定能加快项目开发速度。”这一句话。而这一次因为只有两个人，且彼此熟悉，交流起来也就很容易了，所以整体的项目开发还算比较顺利。但是由于时间紧张，程序实现的功能比较简单，如果时间充裕的话，相信我们还能将程序优化得更好。另外，吸取上一次个人项目的开发经验和教训，这一次采用了类的思想，代码组织也更加有序。在实现过程中，我们也遇到了很多问题，主要是初始值被覆盖，访问地址越界等，好在经过人工检测和代码调试最后改正了过来。对于扩展功能的实现，由于没有什么基础，所以在开发过程中学习到了很多新的知识。此外，程序的一个不足之处是检查用户输入答案时，我们限制了结果的表示形式，也许还可以改进一下，允许用户灵活输入。总的来说，有了上一次个人项目的经验，这一次要顺手多了，毕竟熟能生巧。

Xie_mixue
关注
【软件工程基础】结对项目——四则运算题目生成项目介绍及制作流程
星羽的博客
05-10 1073
一、项目介绍首先附上项目的GitHub地址：拿到题目后，我和组队的同学经过讨论后，决定选择第二个项目——四则运算题目生成项目，在项目第三阶段中，我们选择的是第一个扩展方向，即将程序扩展为Windows电脑图形界面程序。然后我们对该项目的需求进行了分析：第一阶段：（1）生成一千道不重复的四则运算题目（2）能解最多10个运算符的，带括号的四则运算表达式题目，并给出解（3）支持真分数运算（4）能接收用户...
BIT软件工程结对项目——四则运算题目生成
weixin_41709195的博客
01-20 462
BIT软件工程结对项目——四则运算题目生成 目录： (点击可页内跳转) 1. 项目地址 2. PSP表格 3. 解题思路描述 ——3.1初期思考 ——3.2数独终局生成 ——3.3求解数独 4. 设计实现 ——4.1 类的组织 ——4.2 类中主要成员、方法的调用关系 ——4.3 单元测试的设计及代码覆盖率测试 5. 程序优化 6. 代码说明 7. 心得感悟 ...
四则运算题目生成程序（基于控制台）
weixin_34297300的博客
04-19 208
一、需求分析：1. 使用 -n 参数控制生成题目的个数，使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围2.每道题目中的运算符个数不超过3个3. 题目和运算结果中如果出现假分数应用真分数表示4.将生成的题目存入Exercise.txt，题目答案存入Answer.txt，用户做题结果存入Grade.txt5.程序支持1万道题目的生成6.对生成的题目进行查重二、功能设计根据用户输入的...
个人作业1——四则运算题目生成
weixin_30911451的博客
03-07 629
码市地址：https://git.coding.net/cholin/Task.git 一、题目要求： 写一个能自动生成小学四则运算题目的命令行 “软件”，满足以下需求： 1.除了整数以外，还要支持真分数的四则运算，真分数的运算，例如：1/6 + 1/8 = 7/24 2.运算符为 +, −, ×, ÷ 3.并且要求能处理用户的输入，并判断对错，打分统计正确率。 4.要求能...
结对编程-四则运算
weixin_33716941的博客
10-22 222
一、结对成员： 蔡少杭 201421122111 XXX XXXXXXXXXXXX 项目开发的coding.net 地址：https://git.coding.net/HangZhe/HomeWork3.git   二、题目描述： 在个人作业1中，用各种语言实现了一个命令行的四则运算小程序。进一步，本次要求把这个程序做成GUI，成为一个有基本功能、一定价值的程序。在下面的功能需求中实现两个： ...
四则运算题目自动生成
banyinyou7366的博客
09-23 579
一、程序要求： 1. 使用 -n 参数控制生成题目的个数，例如 Myapp.exe -n 10-o Exercise.txt 将生成10个题目。 2. 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如 Myapp.exe -r 10 将生成10以内（不包括10）的四则运算题目。该参数可以设置为1或其...
四则运算——软件工程结对项目（四则运算题目生成+网页程序）
weixin_37861541的博客
01-18 1498
四则运算题目生成+网页程序一、项目简介1、项目要求2、psp表格时间预估和实际二、项目解决思路生成运算题目思路关于括号匹配关于查重求解四则运算题目思路三、网页程序实现 github地址(cmd版) https://github.com/felinae98/virgo-calc github地址(web版) https://github.com/felinae98/virgo-calc/tree/w...
结对项目——自动生成小学四则运算题目的命令行程序（基于Python）
qq_43812127的博客
10-11 1014
这个作业属于课程 软件工程 这个作业的要求在哪里 结对项目 这个作业的目标是 实现一个自动生成小学四则运算题目的命令行程序 成员 3118005408 方俊涛 、3118005409 冯宇航 GitHub： 文章目录PSP PSP PSP 2.1 Personal Software Process Stages 预估耗时（分钟） 实际耗时（分钟） Planning 计划 - Estimate 估计这个任务需要多少时间 60 45 Development...
软件工程——结对项目
weixin_41067683的博客
01-21 483
文章目录一. github项目地址二. PSP表格三.题目分析四. 解题思路1.将运算数统一分数表示2. 生成四则运算式3. 运算式的判重4. 求解四则运算式5.单元测试的设计五. 性能改进六.代码说明七.拓展功能1——VS图形界面八.拓展功能2——unity游戏版本九.总结 一. github项目地址 https://github.com/laopangpyy/Four-arithmetic-o...
2015个人项目——四则运算题目生成程序
avzy42601的博客
09-22 161
2015个人项目——四则运算题目生成程序 性能测试 生成表达式 首先我们来看一组图： 生成500算式 生成1000算式 生成3000算式 生成6000算式 生成10000算式 由这一组图可以明显的看出，我的程序主要用时点是calc()、find()这两个函数，其实原因很简单： 生成运算表达式是完全随机的方式，而且是用标准文法的方式生成，所以运算式很容易产生，因而占用...
自己做的四则运算题生成器
06-14
女儿上小学了，打算给她练练四则运算。希望出点题目，让她自己算去。网上的出题软件，用起来不方便。所以自己写了一个。专用于生成需要的计算题，方便复制到word文档中，直接打印，同时，我也懒得给她校对答案，所以，本程序也可以选择“显示/或不显示”答案，供用户自行选择。
自动生成四则运算题目
aohui6632的博客
03-16 259
·主要功能：用于计算小学四则运算。 ·设计思想：一个能处理四则运算的程序，实现语言C#，可以处理实数。 ·源代码： #include "stdafx.h"#include "calc_win.h"#include "calc_winDlg.h" #ifdef _DEBUG#define new DEBUG_NEW#endif BEGIN_MESSAGE_MAP(Ccalc...
结对编程——四则运算
weixin_30709635的博客
04-11 118
　 结对对象：吴鹏宇2013110438 博客地址：http://www.cnblogs.com/wpy0032/ 双方贡献比例： 1:1 结对照片 题目 　　某公司程序员二柱的小孩上了小学二年级，老师让家长每天出30道（100以内）四则运算题目给小学生做。二柱立马就想到写一个小程序来做这件事。 这个事情可以用很多语言或者工具来实现： •Exc...
软件工程导论 四则运算
weixin_30752699的博客
03-26 216
这次作业在基础的四则运算基础上，实现了生成括号的功能。虽然括号生成的规则具有一定的规律性，生成的括号运算式形如$(a \otimes b)$，其中$\otimes$是$+,-,*,/$四种运算符中的一种，但是对于每一对$a$和$b$是否生成括号是随机的，所以依然可以达到练习四则运算的目的。对于$num=3,4,5$个运算符的式子，生成的括号对数的区间是通过自己构造的随机数函数$rnd(2...
结对编程之四则运算（马仪生、李瑞恒）
weixin_33763244的博客
09-28 140
github项目传送门：https://github.com/bpgg/FourArithmeticOperation 项目要求 　　-功能列表 [完成] 使用 -n 参数控制生成题目的个数 [完成] 使用 -r 参数控制题目中数值的范围, 。该参数可以设置为1或其他自然数。 [完成] 生成的题目中计算过程不能产生负数 [完成] 生成的题目中如果存在形如e1÷ e2的子...
结对编程实现四则运算
deafw26406的专栏
03-16 159
结对编程技术是指两位程序员坐在同一工作台前开发软件。与两位程序员各自独立工作相比，结对编程能编写出质量更高的代码。 按照结对编程的原则，我和小组另一个成员进行了两人进行了结对编程，我们开发的结对项目的是小学的四则运算，具体就是随机生成 30道题，供学生答题并返回正误。经过讨论，我们将采用Java的图形化界面完成，分工为两部分，一人负责四则运算的产生，一个界面 以及运算后的界面...
四则运算结对编程
weixin_34087307的博客
04-03 143
GitHub项目地址：https://github.com/Juneflyfire/jisuan2 a. 需求分析： 设计开发一个小学生四则运算练习软件，使之具有以下功能： （1）由计算机从题库文件中随机选择20道加减乘除混合算式，用户输入算式答案，程序检查答案是否正确，每道题正确计5分，错误不计分，20道题测试结束后给出测试总分； （2）题库文件可采用实验二的方式自动生成，也可以手工编辑...
个人作业1——四则运算题目生成程序（基于控制台）
03-29 321
一、题目描述： 1. 使用 -n 参数控制生成题目的个数，例如 Myapp.exe -n 10-o Exercise.txt 将生成10个题目。 2. 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如 Myapp.exe -r 10 将生成10以内（不包括10）的四则运算题目。该参数可以设置为...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值