结对项目--四则运算生成器（Java） 刘彦享+龙俊健

结对项目--四则运算生成器（Java）

GitHub地址

合作者 刘彦享（3118005010） 龙俊健（3118005011）

https://github.com/LYX708194/calculate

一、项目简介

说明

自然数：0, 1, 2, …。

真分数：1/2, 1/3, 2/3, 1/4, 1’1/2, …。
运算符：+, −, ×, ÷。
括号：(, )。
等号：=。
分隔符：空格（用于四则运算符和等号前后）。
算术表达式：
e = n | e1 + e2 | e1 − e2 | e1 × e2 | e1 ÷ e2 | (e),

其中e, e1和e2为表达式，n为自然数或真分数。

四则运算题目：e = ，其中e为算术表达式。

功能

1. 使用 -n 参数控制生成题目的个数，例如 Myapp.exe -n 10 将生成10个题目。 （完成）

2. 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如 Myapp.exe -r 10 将生成10以内（不包括10）的四则运算题目。该参数可以设置为1或其他自然数。该参数必须给定，否则程序报错并给出帮助信息。（完成）

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

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

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

6. 程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，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，它们之间不能通过有限次交换变成同一个题目。 （完成）

7. 生成的题目存入执行程序的当前目录下的Exercises.txt文件。 （完成）

8. 在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件。（完成）

9. 程序应能支持一万道题目的生成。 （完成）

10. 程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计，输入参数如下：Myapp.exe -e .txt -a .txt，统计结果输出到文件Grade.txt，格式如下：
    Correct: 5 (1, 3, 5, 7, 9)
    Wrong: 5 (2, 4, 6, 8, 10)
    其中“:”后面的数字5表示对/错的题目的数量，括号内的是对/错题目的编号。为简单起见，假设输入的题目都是按照顺序编号的符合规范的题目。（完成）

二、PSP表格

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	60	60
· Estimate	· 估计这个任务需要多少时间	1600	2500
Development	开发	430	490
· Analysis	· 需求分析 (包括学习新技术)	100	120
· Design Spec	· 生成设计文档	30	30
· Design Review	· 设计复审 (和同事审核设计文档)	20	20
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	10	10
· Design	· 具体设计	20	25
· Coding	· 具体编码	900	1500
· Code Review	· 代码复审	100	500
· Test	· 测试（自我测试，修改代码，提交修改）	30	25
Reporting	报告	40	55
· Test Report	· 测试报告	15	20
· Size Measurement	· 计算工作量	10	15
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	30	40
合计		1670	2680

三、思路

运算式的生成采用了随机生成的方法，另外计算结果采用了将中缀表达式转换成后缀表达式再用栈求。
对于式子的重复功能，采用set的不可重复性。一开始是用一定的规则对式子进行求hash值存进set中，后面发现额外消耗性能太大了，所以后面决定直接把答案当作hash存进set中，宁可错杀，不可放过，每次获得结果将其存入其中，如果添加失败则重复了，则重新生成式子。
其他功能要求则在具体实现进行约束，如不产生负数，真分数等等。

四、设计实现过程

根据需求对功能进行分割，一共有四个功能，分别为：

• -r 生成运算式的数值范围
• -n 生成运算式的数目
• -e 检查运算结果的题目文件
• -a 检查运算结果的答案文件

其中 -r 和 -n 两个功能必须一起实现， -e 和 -a 两个功能也必须一起实现

即可把这些功能分为两类

• 一类是生成运算式子，即-r和-n功能实现
• 一类是检查答案功能，即-e和-a功能实现

五、主要代码说明

• 生成式子（中缀表达式）

    /**
     * 生成式子
     * @param p 生成数的范围
     * @return 返回str[]数组，str[0]是假分数形式，str[1]是正常形式
     */
    public static String[] getVal(int p){

        String[] s = new String[2];

        //操作数
        Operation[] ops = new Operation[4];
        for (int i = 0; i < 4; i++) {
            ops[i] = getOp(p);
        }

        int[] n = new int[3];
        for (int i = 0; i < 3; i++) {
            n[i] = (int)(Math.random()*4);
        }
        //假分数形式
        s[0] = ops[0].getValue()+on[n[0]]+ops[1].getValue()+on[n[1]]+ops[2].getValue()+on[n[2]]+ops[3].getValue();
        //正常形式
        s[1] = ops[0].getStr()+on[n[0]]+ops[1].getStr()+on[n[1]]+ops[2].getStr()+on[n[2]]+ops[3].getStr();
        return s;
    }


    /**
     * 生成操作数
     * @Param 生成数的范围
     * @return
     */
    public static Operation getOp(int n){
        Operation op = new Operation();
        int a = (int)(Math.random()*(n)) ;
        if (a == 0){
            a = 1;
        }

        op.setA(a);

        //有分数
        if ((int)(Math.random()*(100)) > 60){
            //分母默认在20以内
            int fenMu = (int) (Math.random()*(20));
            if (fenMu <= 1) fenMu = 5;
            int fenZi = (int) (Math.random()*(100));
            fenZi = fenZi % fenMu;
            if (fenZi == 0){
                fenZi = 1;
            }
            op.setB(fenZi+"/"+fenMu);
        }

        return op;
    }

    /**
     * 把文件的式子转成分数形式
     * @param s：文件的式子
     * @return ：str[0]是文件式子序号，str[1]是分数式子
     * 例子 "22.  15 +  22'7/8 -   5 x 4"
     */
    public static String[] changeFile(String s){
        //去掉序号
        String[] split = s.split("\.");

        String[] ps = split[1].split("\s+");
        for (int i = 1; i < ps.length; i+=2) {
            if (ps[i].contains("'")){
                //es[0]为整数部分 ， es[1]为分数部分
                String[] es = ps[i].split("'");
                //fen[0]为分子，fen[1]为分母
                String[] fen = es[1].split("/");
                long fenzi = Long.parseLong(es[0]) * Long.parseLong(fen[1]) + Long.parseLong(fen[0]);
                ps[i] = fenzi+"/"+fen[1];
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 1; i < ps.length; i++) {
            sb.append(ps[i]+" ");
        }
        split[1] = sb.toString();
        return split;
    }

• 计算

    /**
     * 计算
     * @param poland
     * @return
     */
    public static String calculate(String poland){

        Stack stack = new Stack();
        String result = "";

        String[] split = poland.split("\s+");
        for (int i = 0; i < split.length; i++) {
            //是操作数
            if (split[i].matches("^[0-9]+.*")){
                stack.push(split[i]);
            }else {
                String e2 = stack.pop();
                String e1 = stack.pop();
                if (split[i].equals("+")){
                    result = add(e1, e2);
                }else if(split[i].equals("-")){
                    result = sub(e1,e2);
                }else if (split[i].equals("x")) {
                    result = mul(e1,e2);
                }else{
                    result = div(e1,e2);
                }
                if (result.equals("error") || result == null){
                    return "error";
                }
                //把计算结果入栈
                stack.push(result);
            }
        }
        result = stack.getTop();
        //约分
        if (result.contains("/")){
            String[] qs = result.split("/");
            long w1 = Long.parseLong(qs[0]);
            long w2 = Long.parseLong(qs[1]);

            long w = w1 % w2;
            if (w == 0){
                return w1/w2+"";
            }else {
                //整数部分
                long a = (w1-w)/w2;
                //分数部分
                long reduce = reduce(w,w2);
                w /= reduce;
                w2 /= reduce;
                if (a==0){
                    return w+"/"+w2;
                }else {
                    return a+"'"+w+"/"+w2;
                }
            }
        }

        return stack.getTop();
    }
/**
     * 加法
     * @return
     */
    public static String add(String e1 , String e2 ){
        if (e1 == null || e2 == null) return "error";
        if (e1.contains("/")){
            String[] e1s = e1.split("/");
            long e1z = Long.parseLong(e1s[0]);
            long e1m = Long.parseLong(e1s[1]);
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                //分子
                long e2z = Long.parseLong(e2s[0]);

                //分母
                long e2m = Long.parseLong(e2s[1]);

                //计算
                long ei = e1z * e2m + e2z * e1m;
                long em = e1m * e2m;
                //约分，避免数太大超界
                long reduce = reduce(ei, em);
                ei /= reduce;
                em /= reduce;
                return ei+"/"+em;
            }else {
                e1z = e1z + Long.parseLong(e2) * e1m;
                long reduce = reduce(e1z, e1m);
                e1z /= reduce;
                e1m /= reduce;
                return e1z+"/"+e1m;
            }
        }else {
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                long e2z = Long.parseLong(e2s[0]);
                long e2m = Integer.parseInt(e2s[1]);

                e2z = e2z + Long.parseLong(e1) * e2m;
                long reduce = reduce(e2z, e2m);
                e2z /= reduce;
                e2m /= reduce;
                return e2z+"/"+e2m;
            }else {
                return (Long.parseLong(e1)+Long.parseLong(e2))+"";
            }
        }
    }

    /**
     * 减法
     * 若中间出现负数，返回 "error"
     * @return
     */
    public static String sub(String e1 , String e2 ){
        if (e1 == null || e2 == null) return "error";
        if (e1.contains("/")){
            String[] e1s = e1.split("/");
            int e1z = Integer.parseInt(e1s[0]);
            int e1m = Integer.parseInt(e1s[1]);
            // e1 e2都是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                //分子
                long e2z = Long.parseLong(e2s[0]);
                //分母
                long e2m = Long.parseLong(e2s[1]);

                //计算
                long ei = e1z * e2m - e2z * e1m;
                if (ei < 0){
                    return "error";
                }
                if (ei == 0){
                    return "0";
                }
                long em = e1m * e2m;
                long reduce = reduce(ei, em);
                ei /= reduce;
                em /= reduce;
                return ei+"/"+em;
            }else {
                // e1 是分数  e2是整数
                e1z = e1z - Integer.parseInt(e2) * e1m;
                if (e1z < 0) return "error";
                if (e1z == 0) return "0";
                long reduce = reduce(e1z, e1m);
                e1z /= reduce;
                e1m /= reduce;
                return e1z+"/"+e1m;
            }
        }else {
            //e1是整数，e2是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                long e2z = Long.parseLong(e2s[0]);
                long e2m = Long.parseLong(e2s[1]);

                e2z = Long.parseLong(e1) * e2m - e2z;
                if (e2z < 0) return "error";
                if (e2z == 0) return "0";
                long reduce = reduce(e2z, e2m);
                e2z /= reduce;
                e2m /= reduce;
                return e2z+"/"+e2m;
            }else {
                //e1 e2 都是整数
                long result = Long.parseLong(e1)-Long.parseLong(e2);
                if (result < 0){
                    return "error";
                }
                return result+"";
            }
        }

    }

    /**
     * 乘法
     * @return
     */
    public static String mul( String e1 , String e2){
        if (e1 == null || e2 == null) return "error";
        if (e1.contains("/")){
            String[] e1s = e1.split("/");
            int e1z = Integer.parseInt(e1s[0]);
            int e1m = Integer.parseInt(e1s[1]);
            // e1 e2都是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                //分子
                long e2z = Long.parseLong(e2s[0]);
                //分母
                long e2m = Long.parseLong(e2s[1]);

                //计算
                long ei = e1z *  e2z;
                if (ei == 0) return "0";
                long em = e1m *  e2m;
                long reduce = reduce(ei, em);
                ei /= reduce;
                em /= reduce;
                return ei+"/"+em;
            }else {
                // e1 是分数  e2是整数
                e1z = e1z * Integer.parseInt(e2);
                if (e1z < 0) return "error";
                if (e1z == 0) return "0";
                long reduce = reduce(e1z, e1m);
                e1z /= reduce;
                e1m /= reduce;
                return e1z+"/"+e1m;
            }
        }else {
            //e1是整数，e2是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                long e2z = Long.parseLong(e2s[0]);
                long e2m = Long.parseLong(e2s[1]);

                e2z = Long.parseLong(e1) *  e2z;
                if (e2z < 0) return "error";
                if (e2z == 0) return "0";
                long reduce = reduce(e2z, e2m);
                e2z /= reduce;
                e2m /= reduce;
                return e2z+"/"+e2m;
            }else {
                //e1 e2 都是整数
                long result = Long.parseLong(e1)*Long.parseLong(e2);
                if (result < 0){
                    return "error";
                }
                return result+"";
            }
        }
    }

    /**
     * 除法
     * @return
     */
    public static String div ( String e1 , String e2){
        if (e1 == null || e2 == null) return "error";
        if (e1.contains("/")){
            String[] e1s = e1.split("/");
            int e1z = Integer.parseInt(e1s[0]);
            int e1m = Integer.parseInt(e1s[1]);
            // e1 e2都是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                //分子
                long e2z = Long.parseLong(e2s[0]);
                //分母
                long e2m = Long.parseLong(e2s[1]);

                //计算
                long ei = e1z *  e2m;
                if (ei == 0) return "0";
                long em = e1m *  e2z;

                long reduce = reduce(ei, em);
                ei /= reduce;
                em /= reduce;
                return ei+"/"+em;
            }else {
                // e1 是分数  e2是整数
                e1m = e1m * Integer.parseInt(e2);
                //分母不可为0
                if (e1m <= 0){
                    return "error";
                }

                long reduce = reduce(e1z, e1m);
                e1z /= reduce;
                e1m /= reduce;
                return e1z+"/"+e1m;
            }
        }else {
            //e1是整数，e2是分数
            if (e2.contains("/")){
                String[] e2s = e2.split("/");
                long e2z = Long.parseLong(e2s[0]);
                long e2m = Long.parseLong(e2s[1]);

                e2m = Long.parseLong(e1) *  e2m;
                if (e2m < 0) return "error";
                if (e2m == 0) return "0";

                long reduce = reduce(e2m, e2z);
                e2m /= reduce;
                e2z /= reduce;

                return e2m+"/"+e2z;
            }else {
                //e1 e2 都是整数
                if (Long.parseLong(e1) % Long.parseLong(e2) == 0){
                    return (Long.parseLong(e1)/Long.parseLong(e2))+"";
                }else {
                    long e1z = Long.parseLong(e1);
                    long e2m = Long.parseLong(e2);

                    long reduce = reduce(e1z, e2m);
                    e1z /= reduce;
                    e2m /= reduce;
                    String result = e1z+"/"+e2m;
                    return result;
                }

            }
        }
    }
    /**
     * 约分分数
     * @param a：分子
     * @param b：分母
     * @return
     */
    public static long reduce(long a , long b){
        long min = a < b ? a : b;
        long c,d;

        for( int i = 1;i <= min/2;i ++){
            c = a > b ? a : b;//两个数字的大值
            d = a < b ? a : b;//两个数字的小值
            a = c % d;
            b = d;
            if(a == 0) {
                return d;
            }
        }
        return 1L;
    }

• 两个功能的实现

    /**
     * 生成题目
     * @param n 生成题目的个数
     * @param r 生成题目中值的范围
     */
    public static void generateFormulas(int n,int r) throws Exception {
        BufferedWriter exercises = FileUtil.getFileOutputStream("./Exercises.txt");
        BufferedWriter answers = FileUtil.getFileOutputStream("./Answers.txt");
        for (int i = 0; i < n; i++) {
            while (true){
                String[] val = Generation.getVal(r);
                String poland = Changes.changeToPoland(val[0]);
                String result = Changes.calculate(poland);
                if (set.add(result)){
                    if (!result.equals("error")){
                        exercises.write(i+1+". "+val[1]);
                        exercises.newLine();
                        answers.write(i+1+". "+result);
                        answers.newLine();
                        break;
                    }
                }else{
                    continue;
                }
            }
        }
        exercises.close();
        answers.close();
    }

    /**
     * 通过输入的两个文件名检查答案是否正确
     * @param exercisefile 式子文件名
     * @param answerfile 答案文件名
     * @throws Exception
     */
    public static void checkAnswer(String exercisefile,String answerfile) throws Exception {
        //读取式子文件和答案文件
        BufferedReader exercise = FileUtil.getFileInputStream(exercisefile);
        BufferedReader answer = FileUtil.getFileInputStream(answerfile);
        //输出正确和错误序号到grade文件
        BufferedWriter grade = FileUtil.getFileOutputStream("./Grade.txt");
        if (exercise!=null&&answer!=null){
            String formula;
            String resultInFile;
            //存储答案正确题目的序号
            List<String> right = new ArrayList<String>();
            //存储答案错误的题目的序号
            List<String> wrong = new ArrayList<String>();
            while ((formula=exercise.readLine())!=null){
                //将此行的序号和式子分割并且将式子的真分数转化为假分数
                String[] split1 = Generation.changeFile(formula);
                //通过式子计算结果
                String poland = Changes.changeToPoland(split1[1]);
                String result = Changes.calculate(poland);
                //获得答案文件的内容
                resultInFile = answer.readLine();
                String[] split2 = Generation.changeAnswerFile(resultInFile);
                if (result == split2[1]||result.equals(split2[1])){
                    //答案正确，添加到正确list中
                    right.add(split1[0]);
                }else{
                    //答案错误，添加到错误list中
                    wrong.add(split1[0]);
                }
            }
            String s1 = "Correct: "+right.size()+" "+right;
            String s2 = "Wrong: "+wrong.size()+" "+wrong;
            grade.write(s1);
            grade.newLine();
            grade.write(s2);
        }
        //关闭流
        exercise.close();
        answer.close();
        grade.close();
    }

• main函数实现

 public static void main(String[] args) throws Exception {

        //生成式子数量参数
        int n = 0;
        //生成式子值范围参数
        int r = 0;
        //读取四则运算式子文件名
        String exercisefile = null;
        //读取答案文件名
        String answerfile = null;
        //标志，为真则表示是生成式子命令，为假则是检查答案命令
        boolean isGernate = false;
        //是否有命令的标志
        boolean hasOrder = false;
        int i =0;
        while(i<args.length){
            String s = args[i];
            switch (s){
                case "-n":
                    if (args[i+1].matches("\d+")){
                        n = Integer.parseInt(args[i+1]);
                        isGernate = true;
                        hasOrder = true;
                    }
                    break;
                case "-r":
                    if (args[i+1].matches("\d+")){
                        r = Integer.parseInt(args[i+1]);
                        isGernate = true;
                        hasOrder = true;
                    }
                    break;
                case "-e":
                    exercisefile = args[i+1];
                    isGernate = false;
                    hasOrder = true;
                    break;
                case "-a":
                    answerfile = args[i+1];
                    isGernate = false;
                    hasOrder = true;
                    break;
            }
            i++;
        }
        //是否有命令输入
        if (hasOrder){
            //是生成式子命令
            if (isGernate){
                if (n <= 0||r <= 0){
                    System.out.println("没有输入 -n 命令或输入数值不为正数，正确格式为 -n 生成式子数 -r 生成数范围 ");
                }else{
                    if (r > 150){
                        System.out.println("生成数的范围只能在0-150之间");
                    }else{
                        //命令正确，生成式子
                        System.out.println("命令正确，生成"+n+"道数值在"+r+"范围内的式子存在当前目录文件夹下的Exercises.txt和Answers.txt");
                        generateFormulas(n,r);
                    }
                }
            }else{  //是检查结果命令
                if (exercisefile == null||answerfile == null){
                    //式子文件和答案文件存在空值
                    if (exercisefile == null){
                        System.out.println("没有输入 -e 命令，正确格式为  -e <exercisefile>.txt -a <answerfile>.txt ");
                    }else if (answerfile == null){
                        System.out.println("没有输入 -a 命令，正确格式为  -e <exercisefile>.txt -a <answerfile>.txt ");
                    }
                }else{
                    System.out.println("命令正确，检查式子和答案是否正确的结果在当前目录文件夹下的Grade.txt");
                    checkAnswer(exercisefile,answerfile);
                }
            }
        }else{
            System.out.println("没有输入命令或者命令错误，请输入正确的命令！");
        }
    }

六、测试运行

• 生成10000道式子
  
  
  
  
• 生成式子
  
  
  
• 检查结果 （直接使用之前生成的文件，全部正确）
  
  
• 检查结果 （修改一些答案）
  
  
• 一些错误命令
  
  
  

七、总结

• 刘彦享
  开始的项目都是将一些情况简单化，没有打算考虑得那么多，开始并不是用栈来写得，是直接对生成得式子进行计算，很蠢，后面看了一下博客，才和队友决定重构项目，把主要的计算方法重新写了，可以说前面浪费了很多没必要的时间吧，但也收获到了很多。因为是在线上搞的，很多时候沟通没有那么方便，造成了些许困难。
• 龙俊健
  本来看到这个题目，感觉很难，因为不知道有逆波兰式的存在，所以开始时想的是用ifelse来区分式子的顺序。直到提交的前几天，觉得不行，才和队友决定重写项目。
  我负责写式子的生成，还有计算，学习到了逆波兰式，收获不少。