小学生四则运算--软件工程

1.

PSP

 

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	10	10
· Estimate	· 估计这个任务需要多少时间	10	10
Development	开发	655	600
· Analysis	· 需求分析 (包括学习新技术)	30	35
· Design Spec	· 生成设计文档	30	40
· Design Review	· 设计复审 (和同事审核设计文档)	10	15
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	5	5
· Design	· 具体设计	40	70
· Coding	· 具体编码	5h*60	8h*60
· Code Review	· 代码复审	1h*60	2h*60
· Test	· 测试（自我测试，修改代码，提交修改）	3h*60	2h*60
Reporting	报告	290	60
· Test Report	· 测试报告+博客	4h*60	3h*60
· Size Measurement	· 计算工作量	10	10
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	40	30
合计		955	1785

2.项目要求

• 能自动生成小学四则运算题目
• 除了整数以外，还要支持真分数的四则运算

• 解题思路

  • 了解四则运算的大概思路，即：生成四则运算式子；用户输入结果；程序检验用户输入的结果是否正确；若用户输入的结果错误，即把正确答案输入。
  • 用数组和随机函数随机生成四则运算式子；
  • 了解逆波兰式，即将中缀表示式转换成后缀表达式，以便计算机对式子进行运算；
  • 检验结果并输出；

   

  设计实现及代码说明

  　　1、NiBoLanShi.java

  　　对四则运算式子从中缀表达式转换成后缀表达式，以便计算机计算。

• package sizeyunsuan;
  
  import java.util.List;
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.Stack;
  
  public class NiBoLanShi {
      public static String cal(String str) {
          //对表达式进行预处理，并简单验证是否是正确的表达式
          //存放处理后的表达式
          List<String> list = new ArrayList<>();
          char[] arr = str.toCharArray();
  
          //存放数字临时变量
          StringBuffer tmpStr = new StringBuffer();
          for (char c : arr) {
              //如果是数字或小数点，添加到临时变量中
              if (c>='0' && c<='9') {
                  tmpStr.append(c);
              }else if(c=='.') {
                  if(tmpStr.indexOf(".")>0) {
                      throw new RuntimeException("非法字符");
                  }
                  tmpStr.append(c);
              }
  
              //如果是加减乘除或者括号，将数字临时变量和运算符依次放入List中
              else if (c=='+' || c=='-' || c=='*' || c=='/' || c=='(' || c==')') {
                  if (tmpStr.length() > 0) {
                      list.add(tmpStr.toString());
                      tmpStr.setLength(0);
                  }
                  list.add(c + "");
              }
              else if (c==' ') {
                  continue;
              }
              else {
                  throw new RuntimeException("非法字符");
              }
          }
          if (tmpStr.length() > 0) {
              list.add(tmpStr.toString());
          }
  
          //初始化后缀表达式
          List<String> strList = new ArrayList<>();
  
          //运算过程中，使用了两次栈结构，
          //第一次是将中缀表达式转换成后缀表达式，第二次是计算后缀表达式的值
          Stack<String> stack = new Stack<>();
  
          //声明临时变量，存放栈元素
          String tmp;
  
          //将中缀表达式转换成后缀表达式
          for (String s : list) {
              //如果是左括号直接入栈
              if (s.equals("(")) {
                  stack.push(s);
              }
  
              //如果是右括号，执行出栈操作，依次添加到后缀表达式中，直到出栈元素为左括号，左括号和右括号都不添加到后缀表达式中
              else if (s.equals(")")) {
                  while (!(tmp = stack.pop()).equals("(")) {
                      strList.add(tmp);
                  }
              }
  
              //如果是加减乘除，弹出所遇优先级大于或等于该运算符的栈顶元素（栈中肯定没有右括号，认为左括号的优先级最低），然后将该运算符入栈
              else if (s.equals("*") || s.equals("/")) {
                  while(!stack.isEmpty()) {
                      //取出栈顶元素
                      tmp = stack.peek();//取出但不移除
                      if (tmp.equals("*") || tmp.equals("/")) {
                          stack.pop();
                          strList.add(tmp);
                      }
                      else {
                          break;
                      }
                  }
                  stack.push(s);
              }
              else if (s.equals("+") || s.equals("-")) {
                  while(!stack.isEmpty()) {
                      //取出栈顶元素
                      tmp = stack.peek();
                      if (!tmp.equals("(")) {
                          stack.pop();
                          strList.add(tmp);
                      }
                      else {
                          break;
                      }
                  }
                  stack.push(s);
              }
  
              //如果是数字，直接添加到后缀表达式中
              else {
                  strList.add(s);
              }
          }
  
          //最后依次出栈，放入后缀表达式中
          while (!stack.isEmpty()) {
              strList.add(stack.pop());
          }
  
          //计算后缀表达式的值
          Stack<BigDecimal> newStack = new Stack<>();
          for (String s : strList) {
              //若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符的左边
              //运算后的结果再进栈，直到后缀表达式遍历完毕
              if (s.equals("*") || s.equals("/") || s.equals("+") || s.equals("-")) {
                  BigDecimal b1 = newStack.pop();
                  BigDecimal b2 = newStack.pop();
                  switch (s) {
                  case "+":
                      newStack.push(b2.add(b1));
                      break;
                  case "-":
                      newStack.push(b2.subtract(b1));
                      break;
                  case "*":
                      newStack.push(b2.multiply(b1));
                      break;
                  case "/":
                      newStack.push(b2.divide(b1, 9, BigDecimal.ROUND_HALF_UP));
                      break;
                  }
              }
  
              //如果是数字，入栈
              else {
                  newStack.push(new BigDecimal(s));
              }
          }
  
          //最后，栈中仅有一个元素，就是计算结果
          return newStack.peek().toString();
      }
  }

  2、CreateRandom.java

  　　利用代码随机产生四则运算表达式。

• package sizeyunsuan;
  
  
  public class CreateRandom {
      public void create(int m, int n, String[] fuHao, String[] strArray) {
          String str = "";
  
          //随机生成式子
          for (int i = 0; i < n; i++) {
              str = "";
              int[] arr1 = new int[n];
              int[] arr2 = new int[n];
              arr2[i] = (int)(Math.random()*m+1);
              for(int j = 0; j < n; j++) {
                  int order = (int)(Math.random()*4);
                  arr1[j] = (int)(Math.random()*m+1);
                  str = str + arr1[j] + fuHao[order];
              }
              str = str + arr2[i];
              strArray[i] = str;
              System.out.println("第"+(i+1)+"题："+str);
              arr1 = null;
              arr2 = null;
          }
          System.out.println("\n");
      }
  }

  3、Student.java

  　　主类，用户输入答案，检验其答案是否正确。

• package sizeyunsuan;
  
  import java.util.Scanner;
  
  
  
  public class Student {
  
      public static void main(String[] args) {
          CreateRandom createRandom = new CreateRandom();
          NiBoLanShi niBoLanShi = new NiBoLanShi();
          String[] fuHao = {"+","-","*","/"};
          Scanner input = new Scanner(System.in);
          System.out.println("请输入范围内的计算：");
          int m = input.nextInt();
          System.out.println("请输入要产生的题数：");
          int n = input.nextInt();
          String[] strArray = new String[n];
          System.out.println("\n题目\n");
          createShiZi.create(m, n, fuHao, strArray);
          for(int i = 0; i<n; i++) {
              String result = niBoLanShi.cal(strArray[i]);
              System.out.println("第"+(i+1)+"题："+strArray[i]);
              System.out.print("你的答案：");
              String yourAnswer = input.next();
              if (yourAnswer.equals(result)) {
                  System.out.println("True\n");
              }else {
                  System.out.println("False");
                  System.out.println("正确答案："+result+"\n");
              }
          }
      }
  }

   

• 测试运行

  　　为了方便展示，测试以小数目为主：

• 

   

   

   

  
  

   

   

   总结

   　　这次的用Java实现简单的四则运算，让我重拾了以前的基础知识，譬如数组，列表等等。程序看起来比较的简陋，本来是想结合墨刀的原型进行融合的，奈何能力有限，希望在后续的学习中不断充实自己，然后能完成这一目标，设计一个精美的小学生四则运算软件，有机会的话在石墨文档等互联网平台进行发布。