经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
使用java实现四则运算的生成 （罗彬 梁汉烽）
来源：cnblogs　　作者：Roo_0　　时间：2018/9/30 11:07:13　　对本文有异议

 

本项目Github地址:https://github.com/Rollsom/MyApp

项目简介：

实现一个自动生成小学四则运算题目的命令行程序。

项目相关要求：

 

使用 -n 参数控制生成题目的个数

 

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

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

3. 生成的题目中计算过程不能产生负数，也就是说算术表达式中如果存在形如e1 ? e2的子表达式，那么e1 ≥ e2。

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

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

6. 程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。

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

1. 四则运算题目1

2. 四则运算题目2

……

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

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

1. 答案1

2. 答案2

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

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

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

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

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

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

解题思路：

　　大致思路为：先随机生成若干个子表达式（表达式内操作数不超过2个，若操作数为2个则加上括号），根据数字特征生成合适的操作符，随后根据子表达式的总值来生成表达式之间的运算符号，期间去除多余的括号，并且将小数换成真分数。从而生成一个符合要求的表达式。

　　查重则使用二叉树，在生成子表达式的过程中构建二叉树，查重就变成了两个二叉树是否相等的问题。

　　最后输出文件以及正误判断只需要用到文件的输入输出流以及简单的字符串判断方法即可。

代码结构：

Expression类：当做数据结构来用，里面主要设置一些表达式里面的一些参数方便编程。

Data类：数据的属性，主要用来处理真分数的转换，整数及真分数的运算，生成符合输入输出的数字表达。

CQ类：生成子表达式及组合表达式，生成结果。

ExpressionArray类：用来处理生成的表达式数组，主要用来查重以及存储生成的每一个表达式。

Tree类：子表达式附加的类，用来辅助查重。

Saveanswer类：将生成的表达式输出到文件中，以及统计正误数量。

关键代码说明：

生成子表达式：

  1. public void CQQ(Expression e,int Range) {//创造表达式
  2.         e.flag1 = true;
  3.     Random r = new Random();
  4.     if(this.CurrentOperateNum==3||this.CurrentOperateNum==0)
  5.       {     
  6.         e.Operate1.CreatNumble(Range);        
  7.          this.CurrentOperateNum += 1;
  8.          e.value = e.Operate1.ExpressionValue;         
  9.          e.Result = e.Operate1;
  10.          this.ExpressionNum += 1;
  11.          e.flag1=true;
  12.          e.Node.value = e.Operate1.ExpressionValue;
  13.          }
  14.     else if(this.CurrentOperateNum==4) return ;
  15.     else {
  16.         e.Operate1.CreatNumble(Range);
  17.             this.ExpressionNum += 1;
  18.             e.flag1 = true;
  19.         if(r.nextInt(2)==1) //生成两个操作数
  20.         {            
  21.                e.flag = true;                   
  22.                e.Operate2.CreatNumble(Range);                   
  23.            this.CurrentOperateNum += 2;
  24.            switch(r.nextInt(4)) 
  25.            {
  26.            case 0 : e.value = e.Operate1.ExpressionValue + e.Operate2.ExpressionValue; e.Operator = '+';                         
  27.                  break;
  28.            case 1 : while(e.Operate1.ExpressionValue < e.Operate2.ExpressionValue) 
  29.                        {
  30.                        e.Operate1.CreatNumble(Range); 
  31.                        e.Operate2.CreatNumble(Range); 
  32.                        }
  33.                      e.value = e.Operate1.ExpressionValue - e.Operate2.ExpressionValue; e.Operator = '-';                
  34.                  break;
  35.            case 2 : e.value = e.Operate1.ExpressionValue * e.Operate2.ExpressionValue; e.Operator = '*';
  36.                  break;
  37.            case 3 : 
  38.                      e.value = e.Operate1.ExpressionValue / e.Operate2.ExpressionValue; e.Operator = '÷';
  39.                      break;         
  40.            }
  41.            e.Result = e.Result.Carculate(e, e.Operate1, e.Operate2, e.Operator);
  42.            e.Node.e1.value = e.Operate1.ExpressionValue;
  43.            e.Node.e2.value = e.Operate2.ExpressionValue;
  44.            e.Node.value = e.value;
  45.            
  46.             }
  47.             else {                        
  48.                 this.CurrentOperateNum += 1; 
  49.                 e.value = e.Operate1.ExpressionValue;
  50.                 e.Result = e.Operate1;
  51.                 e.Node.value = e.Operate1.ExpressionValue;
  52.              }                
  53.              }

 

组建已经生成的表达式：

  1. public String GroupSonExpression(Expression e1,Expression e2,Expression father)
  2.     {
  3.         int Operate;
  4.         Random r = new Random();
  5.         Operate = r.nextInt(4);
  6.         while((e1.value<e2.value&&Operate==1)||(e2.value==0&&Operate==3))
  7.             Operate = r.nextInt(3);
  8.         if(e1.flag1==true&&e2.flag1==true)
  9.         {
  10.             switch(Operate)
  11.             {
  12.             case 0 :     father.Operator = '+';father.value = e1.value + e2.value;
  13.                         if(e1.flag==true)
  14.                             {
  15.                                 e1.flag = false;
  16.                                 e1.GetExpression();                       
  17.                             }                   
  18.                         if(e2.Operator=='*'||e2.Operator=='÷')
  19.                             {
  20.                             e2.flag = false;
  21.                             e2.GetExpression();
  22.                             }            
  23.                         break;
  24.             case 1 :    father.Operator = '-';father.value = e1.value - e2.value;
  25.                         if(e1.flag==true)
  26.                         {
  27.                             e1.flag = false;                   
  28.                             e1.GetExpression();                    
  29.                         }
  30.                         if(e2.Operator=='*'||e2.Operator=='÷')
  31.                         {
  32.                             e2.flag = false;
  33.                             e2.GetExpression();                    
  34.                         }
  35.                         break;
  36.             case 2 :    father.Operator = '*';father.value = e1.value * e2.value;
  37.                         if(e1.Operator=='*'||e1.Operator=='÷')
  38.                             {e1.flag = false;
  39.                             e1.GetExpression();}
  40.                             break;
  41.             case 3 :father.Operator = '÷';father.value = e1.value / e2.value;
  42.                     if(e1.Operator=='*'||e1.Operator=='÷')
  43.                             {e1.flag = false;
  44.                             e1.GetExpression();}
  45.                     break;        
  46.             }
  47.             father.Result = father.Result.Carculate(father, e1.Result, e2.Result, father.Operator);            
  48.             father.SonExpression = e1.Expression + father.Operator + e2.Expression;
  49.             father.Expression =  "("+ father.SonExpression +")";
  50.             father.flag1 = true;
  51.             father.Node.value = father.value;
  52.             father.Node.e1 = e1.Node;
  53.             father.Node.e2 = e2.Node;
  54.         }    
  55.         else if(e2.flag1==false&&e1.flag1==true)        
  56.             {
  57.             father.value = e1.value;
  58.               father.Operate1 = e1.Operate1;
  59.               father.Operate2 = e1.Operate2;          
  60.               father.Expression = e1.Operate1.Fraction;
  61.               father.Operator = e1.Operator;
  62.               father.Result = e1.Result;
  63.               father.flag = e1.flag;
  64.               father.Result.ExpressionValue = e1.Result.ExpressionValue;
  65.               father.flag1 = true;
  66.               if(e1.Operator==' ')
  67.               father.SonExpression = e1.Expression;
  68.               else 
  69.                   father.SonExpression = e1.Operate1.Fraction+ father.Operator + e1.Operate2.Fraction;              
  70.                father.Node = e1.Node;
  71.             }
  72.             else  father = e2;        
  73.         return father.Expression;
  74.             }

 

 真分数的各种运算：

  1. public Data Carculate(Expression e,Data d1,Data d2,char Operator) {
  2.     Data d = new Data();
  3.     switch(Operator)
  4.     {
  5.     case '+':d.Molecule = d1.Molecule * d2.Deno + d2.Molecule * d1.Deno;
  6.              d.Deno = d1.Deno * d2.Deno;
  7.              d.integer = d1.integer + d2.integer;             
  8.              d.Simplication();
  9.              d.ExpressionValue = (double)d.integer+(double)(d.Molecule)/(double)d.Deno;
  10.              d.CreatFractor();
  11.              e.valueExpression = d.Fraction;
  12.              break;
  13.     case '-':
  14.             d.Molecule = d2.Deno * (d1.integer * d1.Deno+d1.Molecule) - d1.Deno * (d2.integer * d2.Deno + d2.Molecule);
  15.             //d1.Molecule * d2.Deno - d2.Molecule * d1.Deno;
  16.               d.Deno = d1.Deno * d2.Deno;
  17.               d.integer = 0;              
  18.               d.Simplication();
  19.               d.ExpressionValue = (double)d.integer+(double)(d.Molecule)/(double)d.Deno;
  20.               d.CreatFractor();
  21.               e.valueExpression = d.Fraction;
  22.               break;
  23.     case '*':
  24.              d.Molecule = (d1.Molecule+d1.integer * d1.Deno) * (d2.Molecule + d2.integer * d2.Deno);
  25.              d.Deno = d1.Deno * d2.Deno;
  26.              d.integer = 0;
  27.              d.Simplication();
  28.              d.ExpressionValue = (double)d.integer+(double)(d.Molecule)/(double)d.Deno;
  29.              d.CreatFractor();
  30.              e.valueExpression = d.Fraction;
  31.              break;
  32.     case '÷':d.Molecule = (d1.Molecule+d1.integer * d1.Deno) * d2.Deno;
  33.              d.Deno = d1.Deno * (d2.Molecule + d2.integer * d2.Deno);    
  34.              d.integer = 0;
  35.              d.Simplication();
  36.              d.ExpressionValue = (double)d.integer+(double)(d.Molecule)/(double)d.Deno;
  37.              d.CreatFractor();
  38.              e.valueExpression = d.Fraction;
  39.              break;
  40.              default : System.out.println("计算出错");break;
  41.     }    
  42.     return d;
  43. }

查重：

  1. boolean IFequal(Tree T1,Tree T2) {
  2.           if(T1==null&&T2==null) return true;
  3.           else if(T1==null||T2==null) return false;
  4.      else if(T1.value!=T2.value||T1.Operator!=T2.Operator) 
  5.               return false;
  6.      else  if((IFequal(T1.e1,T2.e1)&&IFequal(T1.e2,T2.e2))||(IFequal(T1.e2,T2.e1)&&IFequal(T1.e1,T2.e2)))
  7.      return true;
  8.      return false;
  9.  }

运行测试举例：

生成10000条表达式并且操作数范围为20，输出到.txt文件上面。

测试比较答案对错：

 

psp：

 

PSP2.1

Personal Software Process Stages

预估耗时（分钟）

实际耗时（分钟）

Planning

计划

 60

 120

· Estimate

· 估计这个任务需要多少时间

 60

 120

Development

开发

 1800

 2140

· Analysis

· 需求分析 (包括学习新技术)

 60

 60

· Design Spec

· 生成设计文档

 60

 90

· Design Review

· 设计复审 (和同事审核设计文档)

 20

 30

· Coding Standard

· 代码规范 (为目前的开发制定合适的规范)

 40

 40

· Design

· 具体设计

 120

 180

· Coding

· 具体编码

 720

 960

· Code Review

· 代码复审

 60

 60

· Test

· 测试（自我测试，修改代码，提交修改）

 720

 720

Reporting

报告

 40

 40

· Test Report

· 测试报告

 15

 15

· Size Measurement

· 计算工作量

 0

 0

· Postmortem & Process Improvement Plan

· 事后总结, 并提出过程改进计划

 25

 25

合计

 

 1900

 2300

代码覆盖率：

执行-n 与 -r 时：

执行-e 与 -a 时：

项目总结：

　　本次项目比上一次的项目的难度要高许多，制作时间比较紧张。在这一次编程中，我实现功能需要用到的类比较多，类比较简单所以多而且繁琐，相互又有联系，所以出bug的时候总是会卡很久。而且这次随我个人而言也是一次很大的挑战，我平时没有学习技术，只有要做项目的时候才去学，是非常痛苦的事情，这痛苦的经历也告诉了我平时练习的重要性。。最主要的是，这一次是结对编程，两个人在一起编写程序，相互提出想法，轻松解决小错误，有小的问题与失误常常能够及时发现，避免了到时候重新观看代码耗费大量时间，是一次非常好的体验。两人相互督促，效率比较高，虽然没有一个人打码那么自在，但是确实感受到了结对编程的好处。

评价：

　　我的队友梁汉烽在我打码的时候给了我很多的帮助，他常常坐在我旁边看我打码，在旁边给出他的思路，人也很幽默，没有头绪的时候也会说一些骚话活跃气氛。我从他那里学到了不少东西，他指导我代码的规范性，让我对设计程序时的结构性有了进一步的了解，而且经常提醒我犯得一些小错误。 　　

　　罗彬进行了对功能的基本架构，并且提供了基本思路，在此过程中我为他提供意见，尽可能的求同存异，改善基本情况，两个人同时进行编码可以在编码过程中看出错误，避免BUG的过多产生，导致任务进度的减慢。

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号