结对编程-四则运算（第一周-阶段总结）

需求分析

• 实现一个四则运算程序，要求：
  • 自动随机生成小学四则运算题目（加，减，乘，除）
  • 支持整数、真分数且支持多项式
  • 能够利用栈的思想，将中缀转换为后缀表达式
  • 能够计算随机生成的式子
  • 能够对输入的答案进行判定
  • 统计正确率
• 扩展需求
  • 生成题目去重
  • 处理生成题目并输出到文件
  • 完成题目后从文件读入并判断
  • 多语言支持：简体中文，繁體中文 ，English

设计思路

• 1.首先需要一个能够生成随机四则运算的类ProduceProblem其中包括能够进行随机数的生成，随机符号的生成且将生成的数字串起来，并打印输出。
• 2.其次需要一个类Translate将上一个类中生成的中缀表达式转换为后缀表达式且保存,需要定义一个栈再按照栈的操作，对式子进行遍历重排
  参考链接
• 3.再次我们需要将保存起来的表达式进行运算，及引用一个新类Count对上述的后缀表达式进行遍历，然后运算结果
• 4.最后是小学生作业系统的核心，需要一个类Judge进行作业批改，且将对错与否传递给主类进行统计，并输出概率

UML类图

我们还会在之后时间在代码需要调整的时候对类图进行修改

过程中关键代码及遇到的困难及解决方法

• 1.首先是在编写随机式子时，第一个问题就是如何不仅限于生成两个数字的加减乘除运算
• 解决方法即代码展示：我们想的是利用随机数来决定生成的数字个数即int m = 2 + (int) (Math.random() * 6); //每个运算式数目的个数符号的个数就是m-1，再将生成的数字与符号交叉排序生成一个字符串。
  • 生成随机式子的主要代码：

import java.util.Random;
public class ProduceProblem {
    public int ProduceProblem () {
            String s = "";
            Random shu = new Random();//每个运算式的随机数
            int count = 1; //记录符号；
            char[] operator = new char[]{'+', '-', '*', '/'};
            int m = 2 + (int) (Math.random() * 6); //每个运算式数目的个数
                for (int j = 0; j < m; j++) {
                    int num = shu.nextInt(10);
                    s = s +" "+ num;
                    if (count < m) {
                        int c = shu.nextInt(4);
                        s = s +" "+ operator[c];
                        count++;
                    }
                }
                String [] str = s.split(" ");
                System.out.println(s + "=");
                Translate t = new Translate(str);
                return t.flag;
    }
}

• 2.其次在实现表达式转换时我们也碰到一个问题：就是原来的代码是当碰到“-或+”时我们会将之前保存到栈里的会弹出底部的一个接到式子上去
  原始代码：

  if (z.empty() != true) {
                        t = z.pop();
                        if (t.equals("(")) {
                            z.push(t);
                            z.push(args[i]);
                            break;
                        } else {
                            z.push(args[i]);
                            jieguo = jieguo + t + " ";
                            break;
                        }
                    } else {
                        z.push(args[i]);
                        break;
                    }
                    break;

本来觉得没有问题，但在后来的运行过程中我们发现当有两个没有括号的减法式子相连的时候如3-2*5-6就会发生转换错误，两个减号的顺序会发生变化导致结果错误。经过讨论后我们发现我们上述的代码有一个问题就是，我们在减号碰到减号时弹出来的减号并没有接上去，且在真正算式中应该是要直到碰到“(”才会结束，所以我们将这一式子改成了while的循环，才得以解决。

• 中缀转换代码

import java.util.Stack;
public class Translate extends Judge{
    int flag;
    public Translate (String[] args) {
        Stack<String> z = new Stack<String>();
        String jieguo = "";
        String t = "";
        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "(":
                    z.push(args[i]);
                    break;
                case "+":
                case "-":
                    while(z.empty() != true) {
                        t = z.pop();
                        if (t.equals("(")) {
                            z.push(t);
                            break;
                        }
                        jieguo = jieguo + t + " ";
                    }
                    z.push(args[i]);
                    break;
                case "*":
                case "/":
                    while(z.empty() != true) {
                        t = z.pop();
                        if (t.equals("+") || t.equals("-") || t.equals("(")) {
                            z.push(t);
                            break;
                        }
                        jieguo = jieguo + t + " ";
                    }
                    z.push(args[i]);
                    break;
                case ")":
                    while (z.empty()== false) {
                        t = z.pop();
                        if (t.equals("(")) {
                            break;
                        } else {
                            jieguo = jieguo + t + " ";
                        }
                    }
                    break;
                case" ":
                    break;

                default:
                    jieguo = jieguo + args[i] + " ";
                    break;
            }

        }

        while (z.empty() == false) {
            jieguo = jieguo + z.pop() + " ";
        }
        String [] str = jieguo.split(" ");
        Count py = new Count(str);
        int answer = py.answer;
        flag = A(answer);
    }

    public Translate() {

    }
}

• 3.计算式子结果的代码:在运行过程中发生过格式转换错误，因为一个目前还没看出来的原因，Translate引用Count类时传入的字符数组中出现了空，所以我们只能加一句case "":来排除错误

import java.util.Stack;
public class Count{
    int answer;
    public  Count (String[] args) {
        Stack<String> z = new Stack<String>();
        int num1,num2,d;
        for(int i=0;i<args.length;i++) {
            switch (args[i]){
                case"+":
                    num2 = Integer.valueOf(z.pop());
                    num1 = Integer.valueOf(z.pop());
                     d = num1+num2;
                    z.push(String.valueOf(d));
                    break;
                case"-":
                     num2 = Integer.valueOf(z.pop());
                     num1 = Integer.valueOf(z.pop());
                     d = num1-num2;
                    z.push(String.valueOf(d));
                    break;
                case"*":
                     num2 = Integer.valueOf(z.pop());
                     num1 = Integer.valueOf(z.pop());
                     d = num1*num2;
                    z.push(String.valueOf(d));
                    break;
                case"/":
                     num2 = Integer.valueOf(z.pop());
                     num1 = Integer.valueOf(z.pop());
                     d = num1/num2;
                    z.push(String.valueOf(d));
                    break;
                case"":
                case" ":
                    break;

                default:
                    z.push(args[i]);
                    break;
            }
        }
        while (z.empty() == false) {
            answer =  Integer.valueOf(z.pop());
        }
    }
}

• 4.判断正误的代码：刚开始我们的想法是将Translate定为Judge的父类借此来继承它计算出的answer以此来比较正误，不过发现行不通（目前未找到原因，找到后会写入下一篇博客）。后来我两商议，反着来将Judge作为父类，让转换类来继承判断正误这项方法。

import java.util.Scanner;
public class Judge {
    public int A(int answer) {
        Scanner scanner = new Scanner(System.in );
        System.out.println("请输入你的答案：");
        int flag=0;
        int n = scanner.nextInt();
        if( n == answer) {
            System.out.println("正确！");
            flag = 1;
        }
        else {
            System.out.println("错误，正确答案是:"+answer);

        }
        return flag;
    }

    public Judge() {

    }
}

• 5.主类代码：在最后进行串联的时候发现了一个比较重大的问题，就是我们该如何统计正确题目的个数。最后我们决定flag的反复继承应用直到传递到主类中，为1即count加一进行统计

import java.util.Scanner;

public class WpyZry {
    public static void main(String[] args) {
        System.out.println("请输入要生成的题目数：");
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int count=0;
        for (int i = 1; i <= n; i++) {
            System.out.println("题目"+i+"：");
            ProduceProblem problem = new ProduceProblem();
            if(problem.ProduceProblem() == 1){
                count++;
            }
            }
        double zql = (double)count/n;
        System.out.println("完成"+n+"道题目，正确率为"+zql*100+"%");
        }
    }

运行过程测试截图

代码托管链接

托管链接：https://gitee.com/wpyzka/20175226/tree/master/src/%E5%9B%9B%E5%88%99%E8%BF%90%E7%AE%97

评价同伴

挺开心我的同伴能接受与我组队的请求，在这个阶段的研讨中他就像比喻中的副驾驶的位置，为我观察这我发现不了的坑，也在必要的分叉口给了我很多有用的建议，比如在生成随机式子的时候我在弄出简单的随机生成之后，生成较长式子的算法就是由他提醒编写的，当然这样的情况会有很多，我负责大体，而他就负责细节，检查。他很好的在结对下扮演了一个领航员的位置。

本阶段大致总结和下阶段计划

• 总结：
  • 1.我们完成了当初计划的大部分类与主程序的编写
  • 2.运行后能达到我们预期的目的
  • 3.我们没有完成的计划是关于插入括号这一项的编写
• 下阶段计划
  • 1.完成括号(已有思路)，且回到博客进行查缺补漏
  • 2.完成扩展需求包括(真分数，文件，语言等)
  • 3.进行测试
  • 4.完成总结博客

PSP

20175226 2018-2019-2《java程序设计》结对编程-四则运算（第一周-阶段总结）

原文：https://www.cnblogs.com/20175226wpy/p/10656070.html