四则运算题目生成系统

一、题目描述：

1. 使用 -n 参数控制生成题目的个数，例如

Myapp.exe -n 10 -o Exercise.txt

将生成10个题目。

2. 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如

Myapp.exe -r 10

将生成10以内（不包括10）的四则运算题目。该参数可以设置为1或其他自然数。该参数必须给定，否则程序报错并给出帮助信息。

3. 生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。

4. 每道题目中出现的运算符个数不超过3个。

5. 程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，23 + 45 = 和45 + 23 = 是重复的题目，6 × 8 = 和8 × 6 = 也是重复的题目。3+(2+1)和1+2+3这两个题目是重复的，由于+是左结合的，1+2+3等价于(1+2)+3，也就是3+(1+2)，也就是3+(2+1)。但是1+2+3和3+2+1是不重复的两道题，因为1+2+3等价于(1+2)+3，而3+2+1等价于(3+2)+1，它们之间不能通过有限次交换变成同一个题目。

生成的题目存入执行程序的当前目录下的Exercises.txt文件，格式如下：

1. 四则运算题目1

2. 四则运算题目2

……

其中真分数在输入输出时采用如下格式，真分数五分之三表示为3/5，真分数二又八分之三表示为2’3/8。

6. 在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件，格式如下：

1. 答案1

2. 答案2

特别的，真分数的运算如下例所示：1/6 + 1/8 = 7/24。

7. 程序应能支持一万道题目的生成。

8. 程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计，并会输出所有题目中重复的题目，输入参数如下：

Myapp.exe -e <exercisefile>.txt -a <answerfile>.txt -o Grade.txt

统计结果输出到文件Grade.txt，格式如下：

Correct: 5 (1, 3, 5, 7, 9)

Wrong: 5 (2, 4, 6, 8, 10)

Repeat:2

RepeatDetail:

(1) 2,45+32 Repeat 3,32+45

(2) 5,3+(2+1) Repeat 7,1+2+3

需求分析

随机生成四则运算的题目，可以根据输入的数字来生成响应数目的题目，还能根据输入的数的大小限制四则运算表达式中操作数的大小，并根据正确答案和手动输入答案的字符串比较答案的正确性，最后给出统计。

设计实现

生成：随机生成操作符的数量（1~3个），根据操作符的数量可以确定操作数的数量，以操作符为节点创建二叉树，每个操作符节点随机是否生成括号

计算：将优先级大的的操作符放到树的最低端，同级的操作符按表达式的顺序从左到到右将靠左边的放为右边的操作符的子节点，排序后从低自上计算就能得出最终结果

查重：按照一定的规则将二叉树排序，然后对比二叉树的每个节点，判断是否重复

代码说明

//改函数将一个操作数字符串转换为一个分数，并返回一个保存分子和分母的数组
public int[] decomposeFraction(String s) {
		char[] fra = s.toCharArray();
		if(s.contains("'")) {
			int m = s.indexOf("'");
			int n = s.indexOf("/");
			String a="",b="",c="";
			for(int i=0;i<m;i++) {
				a+=fra[i];
			}
			for(int i=m+1;i<n;i++) {
				b+=fra[i];
			}
			for(int i=n+1;i<s.length();i++) {
				c+=fra[i];
			}
			int[] result = new int[2];
			int a1=Integer.parseInt(a),b1=Integer.parseInt(b),c1=Integer.parseInt(c);
			result[0]=a1*c1+b1;
			result[1]=c1;
			return result;
		}else if(s.contains("/")) {
			//System.out.println("需要转化的分数：  "+s);
			int n = s.indexOf("/");
			String a="",b="";
			if(s.contains("-")) {
				for(int i=1;i<n;i++) {
					a+=fra[i];
				}
			}else {
				for(int i=0;i<n;i++) {
					a+=fra[i];
				}
			}			
			for(int i=n+1;i<s.length();i++) {
				b+=fra[i];
			}
			int[] result = new int[2];
			//System.out.println("要转换的数a：   "+a+"   要转换的数b：   "+b);
			int a1=Integer.parseInt(a),b1=Integer.parseInt(b);
			if(s.contains("-")) {
				result[0]=-a1;
			}else {
				result[0]=a1;
			}
			result[1]=b1;
			return result;
		}else {
			int[] result = new int[2];
			//System.out.println("要转换的数：   "+s);
			if(s.contains("-")) {
				result[0]=-Integer.parseInt(s.substring(1));
			}else{
				result[0]=Integer.parseInt(s);
			}
			result[1]=1;
			return result;
		}
	}

//通过调用两次该函数可以将二叉树变为可以直接计算的二叉树
public Node SortToComputable(Node no) {
		Node node= new Node(no);
		if(isOperator(node.getValue())) {//该节点是否操作符
			Node left = null;
			Node right = null;
			if(isOperator(node.getLeftChild().getValue())) {//左孩子节点是否为操作符
				//System.out.println("   左："+node.getLeftChild().getValue()+"   "+isOperator(node.getLeftChild().getValue()));
				//左孩子节点为操作符
				if(node.getLeftChild().getHasBrackets()) {//左孩子节点是否有括号
					//有括号,则将该节点作为另一个根节点去调用排列（递归调用）
					node.setLeftChild(SortToComputable(node.getLeftChild())); 
				}else {//没括号,则比较操作符级别
					if(ThisNodeOperatorValue(node)>OperatorValue(node.getLeftChild())) {
						//若该节点操作符优先级大于左孩子节点的操作符,则进行变换后处理左孩子节点,顶点节点为left
//						System.out.println("   左："+ThisNodeOperatorValue(node)+">"+OperatorValue(node.getLeftChild()));
//						System.out.println("   左："+node.getValue()+">"+node.getLeftChild().getValue());
						left = new Node(node.getLeftChild());
						node.setLeftChild(SortToComputable(node.getLeftChild().getRightChild()));
						boolean s = left.getHasBrackets();
						left.setHasBrackets(node.getHasBrackets());
						node.setHasBrackets(s);
						left.setRightChild(new Node(node));
					}else {//若优先级小于等于，则直接处理左孩子节点，顶点节点不变
						node.setLeftChild(SortToComputable(node.getLeftChild()));
					}
				}
			}
			if(isOperator(node.getRightChild().getValue())) {//右孩子节点是否为操作符
				//System.out.println("   右："+node.getRightChild().getValue()+"   "+isOperator(node.getRightChild().getValue()));		
				//右孩子节点为操作符
				if(node.getRightChild().getHasBrackets()) {//右孩子节点是否有括号
					//有括号,则将该节点作为另一个根节点去调用排列（递归调用）
					node.setRightChild(SortToComputable(node.getRightChild())); 
				}else {//没括号,则比较操作符级别
					if(ThisNodeOperatorValue(node)>=OperatorValue(node.getRightChild())) {
//						System.out.println("   右："+ThisNodeOperatorValue(node)+">"+OperatorValue(node.getRightChild()));
//						System.out.println("   右："+node.getValue()+">"+node.getRightChild().getValue());
						//若该节点操作符优先级大于右孩子节点的操作符,则进行变换后处理左孩子节点
						right = new Node(node.getRightChild());
						boolean s = right.getHasBrackets();
						right.setHasBrackets(node.getHasBrackets());
						node.setHasBrackets(s);
						node.setRightChild(SortToComputable(node.getRightChild().getLeftChild()));
						right.setLeftChild(new Node(node));
					}else {//若优先级小于等于，则直接处理右孩子节点，顶点节点不变
						node.setRightChild(SortToComputable(node.getRightChild()));
					}
				}
			}
			if(left!=null&&right!=null) {//两边都有变化则left为顶点节点
				left.setRightChild(right);
				return left;
			}else if(left!=null) {//只有左节点变换则left为顶点节点
				return left;
			}else if(right!=null) {//只有右节点变换则right为顶点节点
				return right;
			}else {//若都没有变化则仍为node为顶点节点
				return node;
			}
		}else {//该节点为操作数，直接返回
			return node;
		}
	}

测试运行

小结

将操作数直接设为String类型并不便于计算，应该另外设计一个类作为操作数，就可以避免繁琐的String转化为可计算操作数的过程。当初设计时并为多想，在写代码过程中才发现许多问题，应该多在设计上花时间，尽量考虑到更多编程过程中可能会遇到的问题。

代码链接：https://gitee.com/YayayaHong/four_arithmetic_code.git

posted @ 2018-03-31 18:15 YayayaHong 阅读(349) 评论(0) 收藏举报

刷新页面返回顶部

YayayaHong

四则运算题目生成系统

公告