四则运算程序（java基于控制台）

一、题目描述：

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 .txt -a .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.生成随机表达式

需要生成随机数（整数，分数，带分数）的函数，随机运算符的函数，随机添加括号函数，采用String拼接生成随机表达式。

2.表达式处理计算

将中缀表达式转换为后缀表达式，对后缀表达式进行分割处理，通过栈操作进行运算，由于存在分数和带分数，需通过自定义四则运算法则进行计算，具体为同化成分数进行运算，完成后需约分。

3.表达式查重

先通过读取答案文档，扫描相同答案的表达式进行判断，可提高效率，接着再将相同答案的中缀表达式转换成后缀表达式，判断所有元素是否相等。此方法效率较高，但存在局限性。由于本人并不是通过二叉树处理表达式，再使用二叉树显得 很繁琐，且效率不高。

4.输出至文档

需要输出的文档有表达式Exercises.txt，答案Answers.txt，成绩及查重结果Grade.txt。

三、功能实现

    1.主程序Main.java
        主要代码：
	System.out.println("---------------四则运算程序---------------");
	System.out.println("-n：生成题目个数");
	System.out.println("-r：参数数值范围");
	System.out.println("-g：查看测试结果");
	System.out.println("Do：执行程序");
	System.out.println("请输入指令：");
	Scanner in =new Scanner(System.in);
	while(in.hasNext()){
		switch(in.next()){
			case "-n" :
				System.out.println("请输入要生成的题目个数：");
				n=in.nextInt();
				break;
			case "-r":
				System.out.println("请输入运算数的数值范围：");
				m=in.nextInt();
				break;
			case "-g":
				fo.FileC(file2, file3, file4);        //答案和做题文档对比，结果写入Grade文档
				break;
			case "Do":
				for(int i=0;i<n;i++){
					String s=ex.CreatExp(n,m),fstr;   //生成随机表达式并求解
					String rus=its.suffixToArithmetic(its.infixToSuffix(s));

					fstr=i+1+":"+s+"\r\n";
					fo.FileW(file1, fstr);            //表达式写入文档

					fstr=i+1+":"+rus+"\r\n";
					fo.FileW(file2, fstr);			  //答案写入文档
				}
				break;
			default:
				System.out.println("无效指令！");
				break;
		}
		System.out.println("请输入指令：");	

    2.随机表达式生成
        主要代码：
        /*随机生成表达式*/
    public String CreatExp(int n ,int m){
	    String exp=CreatNum(m);                          //随机操作数
	    Random rd=new Random();
	    int t=rd.nextInt(2);
	    boolean flag=false;                              //是否生成括号
	    if(t>0)
		    flag=Creatkh();
	    for(int i=0;i<=t;i++){                           //生成String类型中缀表达式
		    if(flag==true){
			    if(i==0){
				    exp=exp+CreatChar()+"("+CreatNum(m);
			    }else
			    {
				    exp=exp+CreatChar()+CreatNum(m)+")";
			    }
		            }else{
			    exp=exp+CreatChar()+CreatNum(m);
		    }
	    }
	    return exp;
    }

    /*随机生成操作数*/
    public String CreatNum(int m){
	    String s="";
	    Random rd=new Random();
	    switch(rd.nextInt(2)){                            //随机类型：整数，分数
		    case 0:
			    s=Integer.toString(rd.nextInt(m-1)+1);    //整数
			    break;
		    case 1:                                       //分数
			    int a,b;
			    a=rd.nextInt(m-1)+1;
			    b=rd.nextInt(m-2)+2;
			    s=Dating(a,b);                            //分数约分处理
			    break;
	    }
	    return s;
    }

    /*随机生成运算符*/
    public String CreatChar(){
	    String s="";
	    Random rd=new Random();
	    switch(rd.nextInt(4)){
		    case 0:s="+";break;
		    case 1:s="-";break;
		    case 2:s="*";break;
		    case 3:s="÷";break;
	    }
	    return s;
    }

    /*分数进行约分*/
    public String Dating(int a,int b){
	    String s="";
	    int gongyinshu=1,c;
	    c=a/b;
	    a=a%b;
	    if(c<0){                                   //若带分数已为负数，这分数不用带负号
		    a=a*-1;
	    }
	    for (int i = 1; i <= a; i++) {             //求最小公约数
            if (a % i == 0 && b % i == 0) {
                gongyinshu = i;
            }
        }
	    a=a/gongyinshu;                            //生成最简分数
	    b=b/gongyinshu;
	    if(a==0){
		    s=Integer.toString(c);
	    }else if(c==0){
		    s=Integer.toString(a)+"/"+Integer.toString(b);
	    }else{
		    s=Integer.toString(c)+"'"+Integer.toString(a)+"/"+Integer.toString(b);
	    }
	    return s;
    }

    /*随机是否生成括号*/
    public boolean Creatkh(){
	    boolean flag=false;
	    Random rd=new Random();
	    if(rd.nextInt(3)<1)                        //生成扩号的概率为1/3
		    flag=true;
	    return flag;
    }

    3.表达式处理
        主要代码：
        /*中缀表达式转后缀表达式*/
        public String infixToSuffix(String exp) {
	        Stack<Character> s = new Stack<Character>();                // 创建操作符堆栈
            String suffix = "";                                         // 要输出的后缀表达式字符串
            int length = exp.length();                                  // 输入的中缀表达式的长度
            for (int i = 0; i < length; i++) {
                 char temp;
                 char ch = exp.charAt(i);                               // 获取该中缀表达式的每一个字符并进行判断
                 switch (ch) {
         	        case '(':
         		        s.push(ch);
         		        break;
         	        case '+':                              // 碰到'+' '-'，将栈中的所有运算符全部弹出去，直至碰到左括号为止，输出到队列中去
         	        case '-':
         		        suffix += " ";
         		        while (s.size() != 0) {
         			        temp = s.pop();
         			        if (temp == '(') {
         				        s.push('(');
         				        break;
         			        }
         			        suffix += temp;
         			        suffix += " ";
         		        }
         		        s.push(ch);
         		        break;
         	        case '*':                               // 如果是乘号或者除号，则弹出所有序列，直到碰到加好、减号、左括号为止，最后将该操作符压入堆栈
         	        case '÷':
         		        suffix += " ";
         		        while (s.size() != 0) {
                            temp = s.pop();
                            if (temp == '+' || temp == '-' || temp == '(') {
                                 s.push(temp);
                                 break;
                            } else {
                                 suffix += temp;
                                 suffix += " ";
                           }
         		        }
         		        s.push(ch);
         		        break;
         	        case ')':
                         while (!s.isEmpty()) {
                            temp = s.pop();
                            if (temp == '(') {
                                     break;
                            } else {
                    	            suffix += " ";
                                    suffix += temp;
                            }
                         }
                         break;
         	        default:
                         suffix += ch;
                         break;
                 }
            }
            while (s.size() != 0) {                            // 如果堆栈不为空，则把剩余运算符一次弹出，送至输出序列
    	            suffix += " ";
                        suffix += s.pop();
             }
            return suffix;
         }

         /*计算后缀表达式*/
         public String suffixToArithmetic(String exp) {
             String[] strings = exp.split(" ");                  //按空格分解字符串
             Stack<String> stack = new Stack<String>();          //操作数栈
             for (int i = 0; i < strings.length; i++) {
                 if(strings[i].equals("+")||strings[i].equals("-")||strings[i].equals("*")||strings[i].equals("÷")){
        	         String y=stack.pop();                        //读取到运算符，提取栈顶的两个操作数，先出的操作数为运算符后的数
        	         String x=stack.pop();
        	         String rus=calculate(x, y, strings[i]);      //调用自定义的四则运算法则
        	         stack.push(rus);
        	         if(rus.equals("无解"))                       //除数为0返回无解
        		     return rus;
                     }else{
        	             stack.push(strings[i]);
                 }
             }
             return stack.pop();
         }

        /*自定义四则运算法则*/
         public String calculate(String x, String y, String ch) {
         }
         注：四则运算过程代码较多，不展示。

    4.文件操作及表达式查重代码不展示

四、结果展示

命令选择：



表达式文档：



答案文档：



答题文档：



成绩文档：



一万道题测试:

五、实验小结

此次编程要点在于表达式的处理，重点是对分数，带分数的处理，具体解决方法是将其每个部分的整数提取出来，存于几个参数中，通过参数间的转化运算达到分数的计算，从而实现表达式的计算。过程中遇到挺多小问题，例如除数为0，6÷(3-3) ，解决方法为计算除法时，进行判断，如果除数为0直接返回结果“无解”。

六 、PSP表

    PSP2.1	Personal Software Process Stages  Time Senior Student  Time
    Planning	   计划	                        2	                2
    Estimate	估计这个任务需要多少时间	         48	                 36
    Development	 开发	                           40	               36
    Analysis	  需求分析 (包括学习新技术)	      2	                  1
    Design Spec	  生成设计文档	                 1	                  1
    Design Review  设计复审	                       2	               1
    Coding Standard	代码规范	                   0	               0
    Design	    具体设计	                       3	                4
    Coding	    具体编码	                      27	               22
    Code Review	 代码复审	                       2	                 1
    Test	   测试（自我测试，修改代码，提交修改       2	                4
    Reporting	报告                              1	                  2

七、源代码

码云项目地址：https://gitee.com/liangs96_master/FourOperations