码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2020-04-14 12:31:57      阅读:100      评论:0      收藏:0      [点我收藏+]

标签:code   exce   个数   不重复   line   ring   逆波兰式   命令   出现   

结对项目--四则运算生成器(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来区分式子的顺序。直到提交的前几天,觉得不行,才和队友决定重写项目。
    我负责写式子的生成,还有计算,学习到了逆波兰式,收获不少。

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

标签:code   exce   个数   不重复   line   ring   逆波兰式   命令   出现   

原文地址:https://www.cnblogs.com/lyx708194/p/12696974.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!