(第二周)新小学四则运算

需求分析

1、选择答题数目

2、随机生成4个100以内的整数

3、随机生成3个运算符

4、使用for循环生成指定数量的题目,并进行作答

5、输入结果与计算结果进行判断

若结果一致,则回答正确,继续下一题

若结果不一致,则回答错误,并显示正确答案,继续答题

直到完成指定数量的题目,并输出答对题目数量及题目总数。

4、在选择开始下一轮或结束答题时,若连续两次输入错误,则答题结束

https: https://git.coding.net/yanzouzhe/szys.git

SSH:   [email protected]:yanzouzhe/szys.git

功能实现

1、指定题目数量h、并用result存储结果,right统计回答正确的题目数量

System.out.println("*******随机四则运算*******");
        Scanner sc = new Scanner(System.in);   //创建Scanner类的对象
        System.out.println("请输入题目数量:");
        int h = sc.nextInt();
        double result = 0;
        int right=0;                           //统计正确题目的数量

2、用for循环生成指定数量的题目,用random()生成随机整数和运算符,在此不考虑效能的问题,只求能出结果,用比较笨的方法,用switch,case列出所有64种可能并对结果进行判断并统计回答正确的题目数

for(int m=0;m<h;m++){                   //for循环用来生成指定数量的题目
            Random r = new Random();               //生成一个100以内随机数的方法
            int a = r.nextInt(100);
            int b = r.nextInt(100);
            int c = r.nextInt(100);
            int d = r.nextInt(100);
            Random r2 = new Random();
            int i = r2.nextInt(3) + 1;             //另一个生成随机数1~4的方法
            int j = r2.nextInt(3) + 1;               //另一个生成随机数1~4的方法
            int k = r2.nextInt(3) + 1;               //另一个生成随机数1~4的方法
            char chrs[] = { ‘+‘, ‘-‘, ‘*‘, ‘/‘ };  //将运算符号存到数组里
            String.valueOf(chrs[i]);
            String.valueOf(chrs[j]);
            String.valueOf(chrs[k]);
            //用switch,case对三个运算符进行判断,方法比较笨,列出了全部64种情况
            switch(i){
                case 1:{
                        switch(j){
                            case 1:{
                                    switch(k){
                                        case 1:System.out.println(a+"+"+b+"+"+c+"+"+d+"=?");
                                                result=a+b+c+d;
                                                break;
                                        case 2:System.out.println(a+"+"+b+"+"+c+"-"+d+"=?");
                                                result=a+b+c-d;
                                                break;
                                        case 3:System.out.println(a+"+"+b+"+"+c+"*"+d+"=?");
                                                result=a+b+c*d;
                                                break;
                                        case 4:System.out.println(a+"+"+b+"+"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a+b+f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 2:{
                                    switch(k){
                                        case 1:System.out.println(a+"+"+b+"-"+c+"+"+d+"=?");
                                                result=a+b-c+d;
                                                break;
                                        case 2:System.out.println(a+"+"+b+"-"+c+"-"+d+"=?");
                                                result=a+b-c-d;
                                                break;
                                        case 3:System.out.println(a+"+"+b+"-"+c+"*"+d+"=?");
                                                result=a+b-c*d;
                                                break;
                                        case 4:System.out.println(a+"+"+b+"-"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a+b-f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 3:{
                                    switch(k){
                                        case 1:System.out.println(a+"+"+b+"*"+c+"+"+d+"=?");
                                                result=a+b*c+d;
                                                break;
                                        case 2:System.out.println(a+"+"+b+"*"+c+"-"+d+"=?");
                                                result=a+b*c-d;
                                                break;
                                        case 3:System.out.println(a+"+"+b+"*"+c+"*"+d+"=?");
                                                result=a+b*c*d;
                                                break;
                                        case 4:System.out.println(a+"+"+b+"*"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a+b*f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 4:{
                                    switch(k){
                                        case 1:System.out.println(a+"+"+b+"/"+c+"+"+d+"=?");
                                                float f1 = b;
                                                float g1 = c;
                                                if(g1!=0){
                                                    result =a+f1/g1+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"+"+b+"/"+c+"-"+d+"=?");
                                                float f2 = b;
                                                float g2 = c;
                                                if(g2!=0){
                                                    result =a+f2/g2-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"+"+b+"/"+c+"*"+d+"=?");
                                                float f3 = b;
                                                float g3 = c;
                                                if(g3!=0){
                                                    result =a+f3/g3*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"+"+b+"/"+c+"/"+d+"=?");
                                                float f4 = b;
                                                float g4 = c;
                                                float p4 = d;
                                                if(g4!=0 && p4!=0){
                                                    result =a+f4/g4/p4;
                                                }
                                                break;
                                    }
                            }
                            break;
                        }
                }
                break;
                case 2:{
                        switch(j){
                            case 1:{
                                    switch(k){
                                        case 1:System.out.println(a+"-"+b+"+"+c+"+"+d+"=?");
                                                result=a-b+c+d;
                                                break;
                                        case 2:System.out.println(a+"-"+b+"+"+c+"-"+d+"=?");
                                                result=a-b+c-d;
                                                break;
                                        case 3:System.out.println(a+"-"+b+"+"+c+"*"+d+"=?");
                                                result=a-b+c*d;
                                                break;
                                        case 4:System.out.println(a+"-"+b+"+"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a-b+f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 2:{
                                    switch(k){
                                        case 1:System.out.println(a+"-"+b+"-"+c+"+"+d+"=?");
                                                result=a-b-c+d;
                                                break;
                                        case 2:System.out.println(a+"-"+b+"-"+c+"-"+d+"=?");
                                                result=a-b-c-d;
                                                break;
                                        case 3:System.out.println(a+"-"+b+"-"+c+"*"+d+"=?");
                                                result=a-b-c*d;
                                                break;
                                        case 4:System.out.println(a+"-"+b+"-"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a-b-f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 3:{
                                switch(k){
                                        case 1:System.out.println(a+"-"+b+"*"+c+"+"+d+"=?");
                                                result=a-b*c+d;
                                                break;
                                        case 2:System.out.println(a+"-"+b+"*"+c+"-"+d+"=?");
                                                result=a-b*c-d;
                                                break;
                                        case 3:System.out.println(a+"-"+b+"*"+c+"*"+d+"=?");
                                                result=a-b*c*d;
                                                break;
                                        case 4:System.out.println(a+"-"+b+"*"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a-b*f/g;
                                                }
                                                break;
                                }
                            }
                            break;
                            case 4:{
                                switch(k){
                                        case 1:System.out.println(a+"-"+b+"/"+c+"+"+d+"=?");
                                                float f1 = b;
                                                float g1 = c;
                                                if(g1!=0){
                                                    result =a-f1/g1+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"-"+b+"/"+c+"-"+d+"=?");
                                                float f2 = b;
                                                float g2 = c;
                                                if(g2!=0){
                                                    result =a-f2/g2-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"-"+b+"/"+c+"*"+d+"=?");
                                                float f3 = b;
                                                float g3 = c;
                                                if(g3!=0){
                                                    result =a-f3/g3*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"-"+b+"/"+c+"/"+d+"=?");
                                                float f4 = b;
                                                float g4 = c;
                                                float p4 = d;
                                                if(g4!=0 && p4!=0){
                                                    result =a-f4/g4/p4;
                                                }
                                                break;
                                }
                            }
                            break;
                        }
                }
                break;
                case 3:{
                        switch(j){
                            case 1:{
                                    switch(k){
                                        case 1:System.out.println(a+"*"+b+"+"+c+"+"+d+"=?");
                                                result=a*b+c+d;
                                                break;
                                        case 2:System.out.println(a+"*"+b+"+"+c+"-"+d+"=?");
                                                result=a*b+c-d;
                                                break;
                                        case 3:System.out.println(a+"*"+b+"+"+c+"*"+d+"=?");
                                                result=a*b+c*d;
                                            break;
                                        case 4:System.out.println(a+"*"+b+"+"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a*b+f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 2:{
                                    switch(k){
                                        case 1:System.out.println(a+"*"+b+"-"+c+"+"+d+"=?");
                                                result=a*b-c+d;
                                                break;
                                        case 2:System.out.println(a+"*"+b+"-"+c+"-"+d+"=?");
                                                result=a*b-c-d;
                                                break;
                                        case 3:System.out.println(a+"*"+b+"-"+c+"*"+d+"=?");
                                                result=a*b-c*d;
                                                break;
                                        case 4:System.out.println(a+"*"+b+"-"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a*b-f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 3:{
                                    switch(k){
                                        case 1:System.out.println(a+"*"+b+"*"+c+"+"+d+"=?");
                                                result=a*b*c+d;
                                                break;
                                        case 2:System.out.println(a+"*"+b+"*"+c+"-"+d+"=?");
                                                result=a*b*c-d;
                                                break;
                                        case 3:System.out.println(a+"*"+b+"*"+c+"*"+d+"=?");
                                                result=a*b*c*d;
                                                break;
                                        case 4:System.out.println(a+"*"+b+"*"+c+"/"+d+"=?");
                                                float f = c;
                                                float g = d;
                                                if(g!=0){
                                                    result =a*b*f/g;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 4:{
                                    switch(k){
                                        case 1:System.out.println(a+"*"+b+"/"+c+"+"+d+"=?");
                                                float f1 = b;
                                                float g1 = c;
                                                if(g1!=0){
                                                    result =a*f1/g1+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"*"+b+"/"+c+"-"+d+"=?");
                                                float f2 = b;
                                                float g2 = c;
                                                if(g2!=0){
                                                    result =a*f2/g2-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"*"+b+"/"+c+"*"+d+"=?");
                                            float f3 = b;
                                            float g3 = c;
                                            if(g3!=0){
                                                result =a*f3/g3*d;
                                            }
                                            break;
                                        case 4:System.out.println(a+"*"+b+"/"+c+"/"+d+"=?");
                                                float f4 = b;
                                                float g4 = c;
                                                float p4 = d;
                                                if(g4!=0 && p4!=0){
                                                    result =a*f4/g4/p4;
                                                }
                                                break;
                                    }
                            }
                            break;
                        }
                }
                break;
                case 4:{
                        switch(j){
                            case 1:{
                                    switch(k){
                                        case 1:System.out.println(a+"/"+b+"+"+c+"+"+d+"=?");
                                                float f1 = a;
                                                float g1 = b;
                                                if(g1!=0){
                                                    result =f1/g1+c+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"/"+b+"+"+c+"-"+d+"=?");
                                                float f2 = a;
                                                float g2 = b;
                                                if(g2!=0){
                                                    result =f2/g2+c-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"/"+b+"+"+c+"*"+d+"=?");
                                                float f3 = a;
                                                float g3 = b;
                                                if(g3!=0){
                                                    result =f3/g3+c*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"/"+b+"+"+c+"/"+d+"=?");
                                                float f4 = a;
                                                float g4 = b;
                                                float p4 = c;
                                                float q4 = d;
                                                if(g4!=0 && q4!=0){
                                                    result =f4/g4+p4/q4;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 2:{
                                    switch(k){
                                        case 1:System.out.println(a+"/"+b+"-"+c+"+"+d+"=?");
                                                float f1 = a;
                                                float g1 = b;
                                                if(g1!=0){
                                                    result =f1/g1-c+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"/"+b+"-"+c+"-"+d+"=?");
                                                float f2 = a;
                                                float g2 = b;
                                                if(g2!=0){
                                                    result =f2/g2-c-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"/"+b+"-"+c+"*"+d+"=?");
                                                float f3 = a;
                                                float g3 = b;
                                                if(g3!=0){
                                                    result =f3/g3-c*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"/"+b+"-"+c+"/"+d+"=?");
                                                float f4 = a;
                                                float g4 = b;
                                                float p4 = c;
                                                float q4 = d;
                                                if(g4!=0 && q4!=0){
                                                    result =f4/g4-p4/q4;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 3:{
                                    switch(k){
                                        case 1:System.out.println(a+"/"+b+"*"+c+"+"+d+"=?");
                                                float f1 = a;
                                                float g1 = b;
                                                if(g1!=0){
                                                    result =f1/g1*c+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"/"+b+"*"+c+"-"+d+"=?");
                                                float f2 = a;
                                                float g2 = b;
                                                if(g2!=0){
                                                    result =f2/g2*c-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"/"+b+"*"+c+"*"+d+"=?");
                                                float f3 = a;
                                                float g3 = b;
                                                if(g3!=0){
                                                    result =f3/g3*c*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"/"+b+"*"+c+"/"+d+"=?");
                                                float f4 = a;
                                                float g4 = b;
                                                float p4 = c;
                                                float q4 = d;
                                                if(g4!=0 && q4!=0){
                                                    result =f4/g4*p4/q4;
                                                }
                                                break;
                                    }
                            }
                            break;
                            case 4:{
                                    switch(k){
                                        case 1:System.out.println(a+"/"+b+"/"+c+"+"+d+"=?");
                                                float f1 = a;
                                                float g1 = b;
                                                float p1 = c;
                                                if(g1!=0 && p1!=0){
                                                    result =f1/g1/p1+d;
                                                }
                                                break;
                                        case 2:System.out.println(a+"/"+b+"/"+c+"-"+d+"=?");
                                                float f2 = a;
                                                float g2 = b;
                                                float p2 = c;
                                                if(g2!=0 && p2!=0){
                                                    result =f2/g2/p2-d;
                                                }
                                                break;
                                        case 3:System.out.println(a+"/"+b+"/"+c+"*"+d+"=?");
                                                float f3 = a;
                                                float g3 = b;
                                                float p3 = c;
                                                if(g3!=0 && p3!=0){
                                                    result =f3/g3/p3*d;
                                                }
                                                break;
                                        case 4:System.out.println(a+"/"+b+"+"+c+"/"+d+"=?");
                                                float f4 = a;
                                                float g4 = b;
                                                float p4 = c;
                                                float q4 = d;
                                                if(g4!=0 && p4!=0 && q4!=0){
                                                    result =f4/g4/p4/q4;
                                                }
                                                break;
                                    }
                            }
                            break;
                        }
                }
                break;
            }
            float jg = sc.nextFloat();                  //将自算结果赋给jg
            if(jg==result){                             //用if,else对结果进行判断,正确则继续,若错误则显示正确答案,然后继续
                System.out.println("答对了,你真是个天才!");
                right++;
            }else{
                System.out.println("结果错误!");
                System.out.println("再想想吧,答案似乎是:"+result+"喔!");
                }
        }

3、运用switch、case进行判断,进行下步选择

System.out.println("你一共答对"+right+"道题,"+"共"+h+"道题。");
        System.out.println("1.开始下一轮\t2.结束答题");
        Scanner select = new Scanner(System.in);
        int se = select.nextInt();
        switch(se){                                 //两层switch,case判断,
        case 1:main(null);                          //如果两次选择均输入错误,则结束程序
                break;
        case 2:System.out.println("答题结束!");
                break;
        default:System.out.println("输入有误,请重新输入!");
                System.out.println("1.开始下一轮\t2.结束答题");
                Scanner rp = new Scanner(System.in);
                int rt = rp.nextInt();
                switch(rt){
                case 1:main(null);
                        break;
                case 2:System.out.println("答题结束!");
                        break;
                default:System.out.println("连续两次输入错误,答题结束!");
                }
        }

运行结果

总结:对上周四则运算的改进。在分析阶段的时候考虑的很久,怎么样可以很方便的对4个随机数的四则运算,但是一直没有想到好的办法。最后只能妥协,选择了最笨的方法,列出了所有的可能性,在这里就不考虑效能的问题了。编码阶段就比较费劲了,每种可能性都需要写出来,真的很容易弄乱了,翻来覆去看了好多遍。先是完成一道题的随机生成并判断,成功后进而完成指定题目数量的任务。考虑到for循环应该放到哪里的问题,边运行边改正。最后确定完成答题后的下一步选择,是继续答题还是结束答题。在代码审查阶段的时候更费劲,代码太长了。还得考虑代码格式的问题,有问题的地方进行改成。最大的收获就是没有放弃而选择了最笨的方法,坚持就会有结果的。

照片晚些再传。

不足:无法实现带括号的四个随机数的四则运算及支持分数的运算。

时间: 2024-10-14 05:52:59

(第二周)新小学四则运算的相关文章

20165322 第二周结队编程-四则运算

结对编程-四则运算 整体总结 学习笔记 中缀表达式转换为后缀表达式 如果遇到数字,我们就直接将其输出. 如果遇到非数字时,若栈为空或者该符号为左括号或者栈顶元素为括号,直接入栈. 如果遇到一个右括号,持续出栈并输出符号,直到栈顶元素为左括号,然后将左括号出栈(注意,左括号只出栈,不输出),右括号不入栈. 如果遇到运算符号且栈非空,查看栈顶元素,如果栈顶元素的运算优先级大于或者等于该运算符号,则持续出栈,直到栈顶元素优先级小于该运算符.最后将该元素入栈. 如果我们读到了输入的末尾,则将栈中所有元素

第一周作业——小学四则运算题

作业要求: 写一个能自动生成小学四则运算题目的命令行 “软件”, 分别满足下面的各种需求,这些需求都可以用命令行参数的形式来指定: a) 支持整数.真分数的四则运算.例如:  1/6 + 1/8 = 7/24 b) 逐步扩展功能和可以支持的表达式类型,最后希望能支持下面类型的题目(最多 10 个运算符,括号的数量不限制) 25 - 3 * 4 - 2 / 2 + 89 = ?      1/2 + 1/3 - 1/4 = ?       ( 5 - 4 ) * ( 3 +28 ) =? 设计思路

软工概论第二周个人项目四则运算二(改进)

设计思想: 设计思想:输出表达式的个数n,利用随机数方法产生小于100的随机数,用for循环产生多个随机数,然后在进行判断,判断两个证书的和小于100,差大于0,乘积小于100,能够整除如果不符合要求则跳过本次循环,如果符合则赋值当总数到n时跳出循环,用字符串保存表达式,用double类型的数组保存正确结果,然后循环输出表达式,输入结果后跳转到判断结果界面,循环判断结果,如果相等flag[]为1,不等为0,最后给出正确的题目数量和错误的数量和未作的数量,在循环输出不正确的那些题目 改进的地方:表

20165330 结对编程项目-四则运算 第二周

需求分析 实现一个命令行程序,要求:自动生成小学四则运算题目(加.减.乘.除) 可实现多个运算符一起运算 可以真分数形式输出结果 测试结果的正确性 统计题目完成数并计算正确率 设计思路 实验首先是完成一个计算器的功能,可以实现简单的+.-.*./运算,在这里设计一个主类生成随机数,生成题目,并判断正确率 实现多运算符,编入四个类分别实现整数运算.真分数运算.判断结果正确并计算正确率 利用JUnit检测非法输入 设计测试类,利用JUnit测试整数类与分数类的四则运算 UML类图 功能截图 Juni

20175314 结队编程项目——四则运算第二周

20175314 结队编程项目--四则运算第二周 一.需求分析 实现一个命令行程序,要求: 自动生成小学四则运算题目(加.减.乘.除) 支持整数 支持多运算符(比如生成包含100个运算符的题目) 支持真分数 统计正确率 能生成随机数 产生的算式要有括号 要建立堆栈,进行中缀转后缀,以及后续后缀的运算 能输入想要产生的题目数 能输入用户计算的答案 能够比较用户输入的答案是否正确 能够统计用户答题的正确率 二.设计思路 生成一个有加减乘除支持括号的算式,以字符串的形式输出,每个操作数或操作符中间都用

20175325 第二周结对编程项目 四则运算

20175325 第二周结对编程项目 四则运算 一.需求分析: 实现一个命令行程序,要求: 自动生成小学四则运算题目(加.减.乘.除) 支持整数 支持多运算符(比如生成包含100个运算符的题目) 支持真分数 统计正确率 题目去重 能多次生成四则运算题目 能根据用户输入的数字生成四则运算的题目数量 多语言支持: 简体中文, 繁體中文, English 文件: 处理生成题目并输出到文件 完成题目后从文件读入并判题 用户能够选择是否开始答题 二. 设计思路: 产生随机数并且考虑符号的优先级. 能实现整

20175311胡济栋 2018-2019-2《Java程序设计》结对编程项目-四则运算 第二周 阶段性总结

20175311胡济栋 2018-2019-2<Java程序设计>结对编程项目-四则运算 第二周 阶段性总结 需求分析 这是利用栈来设计一个计算器的第二阶段总结. 自动生成四则运算的题目(加.减.乘.除) 需要实现计算结果的输出 将正确的计算结果与用户输入的计算结果进行比较得出最终的正确率 之前编写的程序还有很多问题,这周主要对这些问题进行改进和升级,我们成功实现了这些功能. 设计思路 1. 首先我们需要编写随机生成数字和随机生成符号的代码,把他们编写好后保存 2. 我们需要利用之前编写好的随

小学四则运算APP 第一个冲刺 第二天

团队成员:陈淑筠.杨家安.陈曦 团队选题:小学四则运算APP 第一次冲刺阶段时间:11.17~11.27 本次程序是为了解决上次判断的问题,但是还是出现新的问题页面无法调整,需要进行改进 本次改进代码为: import java.util.Random; import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.view.View; import android.

20165214 结队编程项目-四则运算(第二周)

20165214 第一次结队编程项目--四则运算第二周 需求分析 本周的结队编程想要实现一个四则运算系统,它可以自动生成n个计算题(本周不包括分数),其中n由我们输入.每输出一道题目,运行程序的人需要输入相应的答案,直到最后一道题做完.最后,统计正确率.然后,在这个基础上可以进行相应的功能扩展,比如语言支. 设计思路 我需要在上周的基础上对程序进行补充.在题目的生成上,应该再加上括号.÷./ 本周达成: ①能够随机生成n道题目,n由我们输入,最大长度可直接在程序里面修改: ②支持真分数运算: ③