精华内容
下载资源
问答
  • 四则运算

    2017-09-24 05:10:00
    自动生成小学四则运算的题目2.Myapp.exe -n 10 -o Exercise.txt 通过-n控制题目数量 Myapp.exe -r 10 -r控制数值范围3.假分数转为真分数表示5.程序生成题目不能重复(PS:通过有限次交换+或者×变成同一道题目)...

    coding.net:https://git.coding.net/vambo/Caculates.git

    需求分析:
    编写一个程序
    1.自动生成小学四则运算的题目
    2.Myapp.exe -n 10 -o Exercise.txt 通过-n控制题目数量 Myapp.exe -r 10 -r控制数值范围
    3.假分数转为真分数表示
    5.程序生成的题目不能重复(PS:通过有限次交换+或者×变成同一道题目)
    6.生成的题目存入执行程序的当前目录下的Exercises.txt文件,同时生成答案,存入当前目录下的Answers.txt文件。
    特别的,真分数的运算如下例所示:1/6 + 1/8 = 7/24。
    7.程序能支持生成1W题
    8.给定题目文件和答案文件,能判定对错 :如Myapp.exe -e <exercisefile>.txt -a <answerfile>.txt -o Grade.txt

    设计文档:
    1.设计一个类来存储运算数,类成员分别表示整数部分,分子部分,分母部分,boolean型表示是否带有分数。
    2.设计一个类来存储运算符,+,-,×,÷。
    3.获取控制台参数,有-e则为校验答案,否则为生成式子。设计文档:
    4.用两个数组分别存储操作数和操作符,根据操作符数组来决定式子的运算方法。
    5.计算过程用假分数表示,得出最终结果再约分。
    具体实现:

    • com.main
      • Main    提供方法入口,接收控制台参数
    • com.operationBean  bean包
      • Operand  操作数类
      • Operator 操作符类
    • com.tools      工具包
      • Caculate 提供计算方法
      • Reduction 提供方法将数化为规范的真分数           

    PS:加减乘除方法相近,故只贴加法

    同理类推,三个运算符则为(++)+,(++)-,++(×),++(÷)

     

     

     运行结果

     

     

     

    为了方便在myeclipse集成环境下测试运行

     

     

     

    PSP

     

    PSP2.1

    Personal Software Process Stages

    Time Senior Student

    Time

     

    Planning

    计划

    5

    10

     

    · Estimate

    估计这个任务需要多少时间

    5

    5

     

    Development

    开发  

    105

    410

     

    · Analysis

    需求分析 (包括学习新技术)

    10

    10

     

    · Design Spec

    生成设计文档

    10

    10

     

    · Design Review

    设计复审

    10

    5

     

    · Coding Standard

    代码规范

    10

    5

     

    · Design

    具体设计

    10

    20

     

    · Coding

    具体编码

    50

    300

     

    · Code Review

    代码复审

    5

    30

     

    · Test

    测试(自我测试,修改代码,提交修改)

    13

    30

     

    Reporting

    报告

    15

    20

     

    ·

    测试报告

    6

    10

     

    ·

    计算工作量

    6

    5

     

    ·

    并提出过程改进计划

    6

    10

     

     

     

     

     

     

     

     总结

      最近课余心思比较多的花在参加宣讲会和简历上,所以对于课业花的心思会比较少。对于这个项目我觉得是一个比较好的方式去学习和实践算法,但我应该是没做到。

    在考虑查重的时候,看到王文基学长分享的《【四则运算】作业--如何判断重复》中,当算式使用二叉树形式存储时,可以通过最小子树判断算式的运算步骤。根据这种思路从而推出更浅显且暴力,能适用于我这个项目中的用法(因为项目并没有使用二叉树作为存储结构),既通过运算过程来判断算式是否重复,因为当1+2+3和3+2+1在我这个项目中实则为caculate(caculate(1+2),3)和caculate(caculate(3+2),1),即判断最小的caculate(操作数1,操作数2,操作符)是否相同(或者操作符为+、×时通过交换两个操作数位置后相同),但是在读取字符串时,想将字符串读取为操作数数组和操作符数组存储时出现逻辑问题,所以现在卡在这里。也因为此输入题目文件和答案文件时检查题目正确性也使用直接读取答案文件来匹配了。

    一片绿。。。。。为了赶上deadline,就先提交目前的版本,之后在改进。

     

     

    转载于:https://www.cnblogs.com/vambo/p/7584863.html

    展开全文
  • 四则运算

    2017-03-17 16:05:00
    例如参数r= 10,将生成10以内(不包括10)的四则运算题目。该参数可以设置为1或其他自然数。 该参数必须给定,否则程序报错并给出帮助信息。3.程序一次运行生成的题目不能重复,即任何两道题目不能通过有限次交换+...

    一.

    1、定义参数控制生成题目的个数。 例如,参数n=10;则将生成10个题目。 2、定义参数控制题目中数值(自然数、真分数和真分数分母)的范围。 例如参数r= 10,将生成10以内(不包括10)的四则运算题目。该参数可以设置为1或其他自然数。 该参数必须给定,否则程序报错并给出帮助信息。3.程序一次运行生成的题目不能重复,即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目 例如,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,它们之间不能通过有限次交换变成同一个题目。4.

    二.

        我重新将程序写了一遍,为了将自己的思路理的更加清晰一些。前面不变利用while循环,在进行选项之后,引用后面的方法。在整数方法中,定义了一个d1,d1是式子运行的结果,然后在后面定义一个值z,当z与d1进行比较之后,如果值一样就会输出结果正确,如果结果错误,在输出结果错误语句之后,同时会输出正确答案,对于分数的方法,我定义了一个值Z和M,分别代表分数同分过后的分子和分母,剩下的基本和整数的方法一样。

    三.

     

    import java.util.Scanner;
    
    public class suanshu3 {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            int m=0;
            while(m==0)
            {
                System.out.println("1、整数计算式,2、真分数计算式");
                int a1 = input.nextInt();
                if(a1==1)
                {
                    zhengshu(a1);
                }
                else
                {
                    fenshu(a1);
                }
            }
        }
        public static void fenshu(int a1) {
             int x,y,i,a2,C;//a代表计算类型,x代表题目数量,y代表数值的范围,i为循环变量,d代表是否有乘除法
             int M,Z;
             int h = 0;
             String d = null;
             System.out.println("请输入题目的数量");
             Scanner input2=new Scanner(System.in);
             x=input2.nextInt();
             String daan[]=new String [x];
             int x1,x2,B,m1,m2;
             System.out.println("请输入分母数值的范围");
             B=input2.nextInt();
             System.out.println("是否有乘除法?(是输入1,否则输入0)");
             C=input2.nextInt();
             if(C==1){
                 for(i=0;i<x;i++){
                     m1=1+(int)(Math.random()*B);//随机生成一个小于B的分母
                     x1=1+(int)(Math.random()*m1);//生成一个比分母小的分子,实现真分数
                     m2=1+(int)(Math.random()*B);//随机生成一个小于B的分母
                     x2=1+(int)(Math.random()*m2);//生成一个比分母小的分子,实现真分数
                     int c=(int)(Math.random()*3);//生成运算符
                     if(c==0)
                     {
                         Z=x1*m2+x2*m1;
                         M=m1*m2; 
                         System.out.print(x1+"/"+m1+"+"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if(c==1)
                     {
                         Z=x1*m2-x2*m1;
                         M=m1*m2;
                         System.out.print(x1+"/"+m1+"-"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if(c==2)
                     {
                         Z=x1*x2;
                         M=m1*m2;
                         System.out.print(x1+"/"+m1+"*"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if(c==3)
                     {
                         Z=m1*x2;
                         M=m2*x1;
                         System.out.print(x1+"/"+m1+"/"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if((i+1)%3==0)
                     {
                         System.out.println();
                     }
                     daan[i]=d;
                      
                 }
             }
             if(C==0)
             {
                 for(i=0;i<x;i++){
                     m1=1+(int)(Math.random()*B);//随机生成一个小于B的分母
                     x1=1+(int)(Math.random()*m1);//生成一个比分母小的分子,实现真分数
                     m2=1+(int)(Math.random()*B);//随机生成一个小于B的分母
                     x2=1+(int)(Math.random()*m2);//生成一个比分母小的分子,实现真分数
                     int c=(int)(Math.random()*2);//生成运算符
                     if(c==0)
                     {
                         Z=x1*m2+x2*m1;
                         M=m1*m2; 
                         System.out.print(x1+"/"+m1+"+"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if(c==1)
                     {
                         Z=x1*m2-x2*m1;
                         M=m1*m2;
                         System.out.print(x1+"/"+m1+"-"+x2+"/"+m2+"=       ");
                         Scanner e1 = new Scanner(System.in);
                         System.out.println("分子:");
                         int z = e1.nextInt();
                         System.out.println("分母:");
                         int m = e1.nextInt();
                         if(z==Z&&m==M){
                             System.out.println("回答正确!");
                             h++;
                         }else{
                             System.out.println("回答错误!正确答案是"+Z+"/"+M);
                         }
                     }
                     if((i+1)%3==0)
                     {
                         System.out.println();
                     }
                     daan[i]=d;
                      
                 }
             }
        }
        public static void zhengshu(int a1) {//整数
            int x,y,i,a2,C;//a代表计算类型,x代表题目数量,y代表数值的范围,i为循环变量,d代表是否有乘除法
            int d1=0;
            String d = null;//d用来储存答案
            System.out.println("请输入题目的数量");
            Scanner input2=new Scanner(System.in);
            x=input2.nextInt();
            int daan[]=new int [x];
            System.out.println("请输入数值的范围");
            y=input2.nextInt();
            System.out.println("是否有乘除法?(是输入1,否则输入0)");
            C=input2.nextInt();
            if(C==1)
            {
                for(i=0;i<x;i++){
                    int a=(int)(Math.random()*y);//随机生成一个1-10的整数
                    int b=(int)(Math.random()*y);//随机生成一个1-10的整数
                    int c=(int)(Math.random()*3);//随机生成一个1-4的整数,0表示加法,1表示减法,2表示乘法,3表示除法
                    if(c==0)
                    {
                        d1=a+b;
                        y = a + b;
                        System.out.printf(a+"+"+b+"= ");
                        Scanner e1 = new Scanner(System.in);
                        int z = e1.nextInt();
                        if(z==y){
                            System.out.println("回答正确!");
                            d1++;
                        }else{
                            System.out.println("回答错误!正确答案是"+y);
                        }
                    }
                    if(c==1)
                    {
                        d1=a-b;
                        y = a - b;
                        System.out.printf(a+"-"+b+"= ");
                        Scanner e1 = new Scanner(System.in);
                        int z = e1.nextInt();
                        if(z==y){
                            System.out.println("回答正确!");
                            d1++;
                        }else{
                            System.out.println("回答错误!正确答案是"+y);
                        }
                    }
                    if(c==2)
                    {
                        d1=a*b;
                        y = a * b;
                        System.out.printf(a+"*"+b+"= ");
                        Scanner e1 = new Scanner(System.in);
                        int z = e1.nextInt();
                        if(z==y){
                            System.out.println("回答正确!");
                            d1++;
                        }else{
                            System.out.println("回答错误!正确答案是"+y);
                        }
                    }
                    if(c==3)
                    {
                        d1=a/b;
                        y = a / b;
                        System.out.printf(a+"+"+b+"= ");
                        Scanner e1 = new Scanner(System.in);
                        int z = e1.nextInt();
                        if(z==y){
                            System.out.println("回答正确!");
                            d1++;
                        }else{
                            System.out.println("回答错误!正确答案是"+y);
                        }
                    }
                    if((i+1)%3==0){
                        System.out.println();
                    }
                    daan[i]=d1;
                }
                 
            }
            else
            {
                    for(i=0;i<x;i++)
                    {
                        int a=(int)(Math.random()*y);//随机生成一个1-的整数
                        int b=(int)(Math.random()*y);//随机生成一个1-10的整数
                        int c=(int)(Math.random()*2);//随机生成一个1-4的整数,0表示加法,1表示减法
                        if(c==0)
                        {
                            d1=a+b;
                            y = a + b;
                            System.out.printf(a+"+"+b+"= ");
                            Scanner e1 = new Scanner(System.in);
                            int z = e1.nextInt();
                            if(z==y){
                                System.out.println("回答正确!");
                                d1++;
                            }else{
                                System.out.println("回答错误!正确答案是"+y);
                            }
                        }
                        if(c==1)
                        {
                            d1=a-b;
                            y = a - b;
                            System.out.printf(a+"-"+b+"= ");
                            Scanner e1 = new Scanner(System.in);
                            int z = e1.nextInt();
                            if(z==y){
                                System.out.println("回答正确!");
                                d1++;
                            }else{
                                System.out.println("回答错误!正确答案是"+y);
                            }
                        }
                        if((i+1)%3==0){
                            System.out.println();
                        }
                        daan[i]=d1;
                    }
                    
                
            }
        }
    }

     

    四.

     

    转载于:https://www.cnblogs.com/gong123/p/6566808.html

    展开全文
  • 实现一个自动生成小学四则运算题目命令行程序。程序一次运行生成题目不重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。例如,23 + 45 = 和45 + 23 = 是重复题目,6 × 8 = 和...

    ###git地址:https://gitee.com/mouse123/operation.git
    #一、代码说明
    实现一个自动生成小学四则运算题目的命令行程序。程序一次运行生成的题目不重复,即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如,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,它们之间不能通过有限次交换变成同一个题目。

    #二、解题思路

    • 首先这个题目有分数的要求,所以在一开始就应该考虑到分数的实现,因为java不存在可以处理分数运算的类,这个应该在一开始就考虑清楚,我们的处理方式是将整数与分数作为一个对象来处理,即整数就是分母为1的分数。
    • 计算便可以直接用分数的运算了。
    • 因为题目要求命令行,所以我们找了脚本的方法来实现命令行操作

    #三、设计实现过程

    • 有三个包,分别为service(服务包),model(实体包),main(主程序)
    • service里有四个类,分别包括了计算操作,分数实体类处理操作,检查操作与生成式子操作
    • model里有三个类,计算等式的计算类,分数类,结果集合
    • main里主要是以上两个包中的方法对应整合

    #四、代码说明

    整个程序难点就在于分数的运算,整数,小数运算可以用自带的操作运算符,但是在java里面却没有一个基本类型去表示分数。很多人可能会考虑到把分数化成小数再运算再转为分数,其实不然,有很多情况下是无法进行转换的,因为java语言中的double类型所表示的精度也是有限的。于是结合java面向对象的思想特征,应该先定义要给分数类,并封装相关的运算方法。代码如下

    分数类:

    /*
     * 构建一个分数类,用来表示分数,封装相关的方法
     */
    public class Fraction {
    
    	private int denominator;// 分母
    	private int nominator;// 分子
    
    	// 构建一个分数
    	public Fraction(int denominator, int nominator) {
    		super();
    		this.denominator = denominator;
    		this.nominator = nominator;
    	}
    
    	public Fraction(int nominator) {
    		this.denominator = 1;
    		this.nominator = nominator;
    	}
    
    	public Fraction() {
    		super();
    	}
    
    	// 判断构建的是一个分数还是一个整数,不超过limit的数值
    	public Fraction(boolean l, int limit) {
    		Random r = new Random();
    		// 这是一个分数
    		if (l == true) {
    			int index = r.nextInt(limit);
    			int index2 = r.nextInt(limit);
    
    			while(index==0) {
    				index = r.nextInt(limit);
    //				System.out.println("会生成0:"+index);
    			}
    //			System.out.println("不会生成0:"+index);
    			this.denominator = index;
    			this.nominator = index2;
    
    			// 这是一个整数
    		} else {
    			int index = r.nextInt(limit);
    			this.denominator = 1;
    			this.nominator = index;
    		}
    	}
    
    	public int getDenominator() {
    		return denominator;
    	}
    
    	public void setDenominator(int denominator) {
    		this.denominator = denominator;
    	}
    
    	public int getNominator() {
    		return nominator;
    	}
    
    	public void setNominator(int nominator) {
    		this.nominator = nominator;
    	}
    
    
    
    	// 加法运算
    	public Fraction add(Fraction r) {
    		int a = r.getNominator();// 获得分子
    		int b = r.getDenominator();// 获得分母
    		int newNominator = nominator * b + denominator * a;
    		int newDenominator = denominator * b;
    		Fraction result = new Fraction(newDenominator, newNominator);
    		return result;
    	}
    
    	// 减法运算
    	public Fraction sub(Fraction r) {
    		int a = r.getNominator();// 获得分子
    		int b = r.getDenominator();// 获得分母
    		int newNominator = nominator * b - denominator * a;
    		int newDenominator = denominator * b;
    		Fraction result = new Fraction(newDenominator, newNominator);
    		return result;
    	}
    
    	// 分数的乘法运算
    	public Fraction muti(Fraction r) { // 乘法运算
    		int a = r.getNominator();// 获得分子
    		int b = r.getDenominator();// 获得分母
    		int newNominator = nominator * a;
    		int newDenominator = denominator * b;
    		Fraction result = new Fraction(newDenominator, newNominator);
    		return result;
    	}
    
    	// 分数除法运算
    	public Fraction div(Fraction r) {
    		int a = r.getNominator();// 获得分子
    		int b = r.getDenominator();// 获得分母
    		int newNominator = nominator * b;
    		int newDenominator = denominator * a;
    		Fraction result = new Fraction(newDenominator, newNominator);
    		return result;
    	}
    
    	// 用辗转相除法求最大公约数
    	private static long gcd(long a, long b) {
    		return b == 0 ? a : gcd(b, a % b);
    	}
    
    	// 对分数进行约分
    	public void Appointment() {
    		if (nominator == 0 || denominator == 1)
    			return;
    		// 如果分子是0或分母是1就不用约分了
    		long gcd = gcd(nominator, denominator);
    		this.nominator /= gcd;
    		this.denominator /= gcd;
    	}
    	
    	public int existZero(){
    		if(this.nominator<0||this.denominator<0){
    			return 0;
    		}else {
    			return 1;
    		}
    	}
    }
    

    在这个分数类中,我们定义了分子和分母,然而整数其实一个分数,只不过这个分数的分母为1.
    至于运算也只是根据运算法则对分数的分子分母进行运算,保证了


    在程序中,运算符的出现数量以及类型是随机的,用数组进行存储,用一个随机数Ramdon
    char[] c = { '+', '-', '*', '÷' }//显示四种基本运算符
    
    r.nextInt(4);//随机生成四种基本运算符的一种
    
    int s = r.nextInt(3);// 生成运算符的数量
    
    

    用这种随机数的形式保证了式子的随机性。随机出现,随机生成,之后只要根据多项式的运算,对式子进行运算即可。之后将生成的式子放在一个list里面,包括运算符以及分数类

    运算

    四则运算具有优先级,先算乘除再算加减,如果采用if表达的形式,对优先级进行判定,那么三个运算符就有64种情况,很明显是不可采取的,容易使代码失去可读性,在这种情况下,我们采取递归来解决这种问题。

    //分式的计算方法
    	public Fraction calculate(List l){
    		
    		int muldiv = MulDivExist(l);
    		if(muldiv != -1){
    			String s = MulDiv(l,muldiv);
    			if(s.equals("error")){
    				return null;
    			}
    		}else {
    			String s = AddSub(l);
    			if(s.equals("error")){
    				return null;
    			}
    		}
    		if (l.size() == 1) {
                return (Fraction) l.get(0);
            }
    		return calculate(l);
    	}
    	
    	/*
    	 * 判断分式里面是否有乘除
    	 * 有乘除返回乘除的位置,没乘除返回-1
    	 */
    	public int MulDivExist(List list){
    		for (int i = 0; i < list.size(); i++) {
                if (list.get(i).equals("*") || list.get(i).equals("/")) {
                    return i;
                }
            }
            return -1;
    		
    	}
    	
    	//计算分式的乘除,计算结果往前放
    	public String MulDiv(List l,int muldiv){
    		String fuhao = (String) l.remove(muldiv);
    		Fraction first = (Fraction) l.get(muldiv-1);
            Fraction last = (Fraction) l.get(muldiv);
            l.remove(muldiv);
            if (fuhao.equals("*")) {
            	Fraction result = first.muti(last);
                l.set(muldiv - 1,result);
                if(result.existZero()==0){
                	return "error";
                }
            }
            if (fuhao.equals("/")) {
            	Fraction result = first.div(last);
                l.set(muldiv - 1,result);
                if(result.existZero()==0){
                	return "error";
                }
            }
            return "right";
            
    	}
    	
    	//计算分式的加减,计算结果往前放
    	public String AddSub(List list){
    		for (int i = 0; i < list.size(); i++) {
                if (list.get(i).equals("+")) {
                	Fraction first = (Fraction) list.get(i-1);
                    list.remove(i);
                    Fraction last = (Fraction) list.get(i);
                    list.remove(i);
                    Fraction result = first.add(last);
                    list.set(i - 1, result);
                    i--;
                    if(result.existZero()==0){
                    	return "error";
                    }
                }
                if (list.get(i).equals("-")) {
                	Fraction first = (Fraction) list.get(i-1);
                    list.remove(i);
                    Fraction last = (Fraction) list.get(i);
                    list.remove(i);
                    Fraction result = first.sub(last);
                    list.set(i - 1, result);
                    i--;
                    if(result.existZero()==0){
                    	return "error";
                    }
                }
            }
    		return "right";
    	}
    	
    

    在递归计算之前,先做一个判定,对生成的式子进行判别,如果有乘除,那就优先采用乘除的递归,然后再用递归计算加减。这样就保证了运算的优先级问题。

    去重

    式子需要去重,保证每次生成的都是不一样的式子。去重采用了一种字符串比较的方法,在此之前,重写了分数类的toString方法,只要两个字符串组成字符完全相同即:组成两个式子的字符完全一样就可以说明这两个式子是重复的。

    重写的toString方法

    	@Override
    	public String toString() {
    		Appointment();
    		if(this.denominator == 0){
    			System.out.println(this.nominator + "|" + this.denominator);
    			System.out.println("分母为0");
    		}
    		if (this.denominator == 1 || this.nominator == 0) {
    			return "" + this.nominator;
    		}else if (this.nominator > this.denominator) {
    			if(nominator % denominator==0){
    				return "" + nominator / denominator;
    			}
    			return "" + nominator / denominator + "," + nominator % denominator + "/" + denominator;
    		}else{
    			return "" + this.nominator + "/" + this.denominator;
    		}
    		
    		
    	}
    	
    

    去重代码:

    //查重,若有重复那就返回ture
    	public boolean isRepeat(List<List<String>> list, List<String> set) {
    
    		if (list.size() <= 0) {
    			return false;
    		}
    		
    		Iterator<String> iterator = set.iterator();
    
    		
    		for (List l_set : list) {
    			if (l_set == null || l_set.size() != set.size() || l_set.size() <= 0 || set.size() <= 0) {
    				continue;
    			}
    			int i = 0;
    			while(iterator.hasNext()){
    				if(l_set.contains(iterator.next())){
    					i = i+1;
    				}
    			}
    			
    			if(i == set.size()){
    				return true;
    			}
    			
    		}
    
    		return false;
    	}
    

    通过这段去重代码可以将重复的式子筛选出去,保证了整个文件中式子的独立性。

    计算结果的校验

    一个式子,等式右边的就是结果,一个式子就是一个字符串,只要用字符串处理函数将等式右边的结果截取出来,与用户的输入进行对比就能得出结果与否。
    相关代码如下:

    while((str1=reader1.readLine())!=null&&(str2=reader2.readLine())!=null){
    			if(!str1.trim().equals(str2.trim())){
    				String[] str = str1.split("\\.");
    				error = error + str[0]+ ",";
    				errornum ++ ;
    			}else {
    				String[] str = str1.split("\\.");
    				correct = correct + str[0] + ",";
    				correctnum ++;
    			}
    			
    		}
    		
    		if(error.equals("")){
    			error = "Wrong: " + errornum + "";
    		}else {
    			error = "Wrong: " + errornum + "(" + error.substring(0,error.length()-1) + ")";
    		}
    		if(correct.equals("")){
    			correct = "Correct: " + correctnum + "";
    		}else {
    			correct = "Correct: " + correctnum + "("+correct.substring(0, correct.length()-1)+")";
    		}
    		m.put("wrong", error);
    		m.put("correct", correct);
    		return m;
    		}
    	
    

    将结果放在一个map中,便于读取,得出结果。

    #五、测试运行

    ###首先要将jar文件与bat文件放置在同一目录下

    ###进入命令行界面

    ###若是未输入参数,则

    正确输入生成题目的参数命令



    ###正确输入测试文件与答案文件

    ###若是全对

    ###出现错误

    #六、总结
    ###问题

    • 一开始并没有思考清楚题目中的分数问题,想着解决了分数就行,结果最后推倒重来。
    • 在程序开发过程中,虽然使用了git管理,但因为不熟悉发生了一些错误,修改的代码上传后下拉发生了冲突,以后在团队编程中,要注意代码改动情况,和队员对接好。
    展开全文
  • 结对开发-四则运算

    2016-04-06 20:12:00
    一、题目及要求 详细要求: 1、 生成题目中计算过程不能产生负数,也就是说算术表达式中如果...4、程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。 ...

    一、题目及要求

    详细要求:
    1、 生成的题目中计算过程不能产生负数,也就是说算术表达式中如果存在形如e1 − e2的子表达式,那么e1 ≥ e2。
    2、生成的题目中如果存在形如e1 ÷ e2的子表达式,那么其结果应是真分数。

    3、每道题目中出现的运算符个数不超过3个,括号不限。

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

    5、把程序变成一个网页程序或智能手机程序, 用户通过设定参数,就可以得到各种题目,并可实现在线答题并评判。

     

    二、源程序代码

    index.html

    复制代码
    <!DOCTYPE html>
    <!--
        Licensed to the Apache Software Foundation (ASF) under one
        or more contributor license agreements.  See the NOTICE file
        distributed with this work for additional information
        regarding copyright ownership.  The ASF licenses this file
        to you under the Apache License, Version 2.0 (the
        "License"); you may not use this file except in compliance
        with the License.  You may obtain a copy of the License at
    
        http://www.apache.org/licenses/LICENSE-2.0
    
        Unless required by applicable law or agreed to in writing,
        software distributed under the License is distributed on an
        "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
         KIND, either express or implied.  See the License for the
        specific language governing permissions and limitations
        under the License.
    -->
    <html>
        <head>
            <!--
            Customize this policy to fit your own app's needs. For more guidance, see:
                https://github.com/apache/cordova-plugin-whitelist/blob/master/README.md#content-security-policy
            Some notes:
                * gap: is required only on iOS (when using UIWebView) and is needed for JS->native communication
                * https://ssl.gstatic.com is required only on Android and is needed for TalkBack to function properly
                * Disables use of inline scripts in order to mitigate risk of XSS vulnerabilities. To change this:
                    * Enable inline JS: add 'unsafe-inline' to default-src
            -->
           <link rel=stylesheet type="text/css" href="color.css">
          <title>四则运算</title>
    </style>
    <!--最佳化屏幕宽度-->
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=Edge,chrome=1">
    <!--引用jQuery Mobile函数库 应用ThemeRoller制作的样式-->
    <link rel="stylesheet" href="themes/mythheme.min.css" />
    <link rel="stylesheet" href="themes/jquery.mobile.icons.min.css" />
    <link rel="stylesheet" href="http://code.jquery.com/mobile/1.4.5/jquery.mobile.structure-1.4.5.min.css" />
    <script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
    <script src="http://code.jquery.com/mobile/1.4.5/jquery.mobile-1.4.5.min.js"></script>
    
    
        </head>
        <body>           
    <div data-role="page" data-title="小学四则运算" id="first" data-theme="a">
            <div data-role="header">
                <h1>小学四则运算</h1>
            </div>
    <div data-role="content" id="content">
              <ul>
           <a href="login.htm" rel="external">登录</a>
           <a href="#" rel="external">注销</a>
           <a href="formula.htm" rel="external">数学公式</a>
           <a href="advice.htm" rel="external">意见反馈</a>
           </ul>
        
        <h4>打好基础,数学高分更容易</h4>
    <div class="content">
        <div class="nav">
            <span>请输入题目的数量:</span><input type="text" id="shu">
            <button type='button' class="btn btn-success" onclick="play_allE()">开始生成题目</button><br> <span id="textE" ></span><span id="text2E"></span>
            <div data-role="footer">
                <h4>版权所有 侵版必究</h4

    转载于:https://www.cnblogs.com/qizhonh/p/5360940.html

    展开全文
  • 一、题目及要求 详细要求: 1、 生成题目中计算过程不能产生负数,也就是说算术表达式中如果...4、程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。 ...
  • 四则运算(3)

    2017-03-17 18:33:00
    程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。 设计思路:将产生int类型随机数在方法中通过随机方法确定这个数据是否为分数,对真分数进行判断...
  • 4网页版四则运算

    2016-04-10 19:19:00
    4 n详细要求: n1、生成题目中计算过程不能产生负数,也就是说算术表达式中如果存在形如e1− e2子表达式,...n4、程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变...
  • 结对编程项目-四则运算(挑战出题) 结伴对象:20162304 需求分析 题目去重 1 . 程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。 2 . 要能指定生成题目...
  • 一:详细要求: 1、 生成题目中计算过程不能产生负数,也就是说算术表达式中如果存在形如e1 −...4、程序一次运行生成题目不能重复,即任何两道题目不能通过有限次交换+和×左右算术表达式变换为同一道题目。...
  • 个人作业1——四则运算题目生成程序(基于控制台) 使用 -n 参数控制生成题目个数 使用 -r 参数控制题目中数值 生成题目中如果存在形如e1 ÷ e2子表达式,那么其结果应是真分数 每道题目中出现运算符个数不...
  • 第一写博客,如有不足,多多包涵本文所有代码均为C语言代码,未在C++下测试,不保证作为C++编译兼容性学过C语言程序员都知道,C语言内置整数类型长度十分有限。那么,当参与运算的整数或计算结果连long long...
  • [数学学习笔记]导数的运算

    千次阅读 2019-02-03 18:45:31
    初等函数是由基本初等函数经过有限次的四则运算和复合运算所得到的函数。基本初等函数和初等函数在其定义区间内均为连续函数。 高等数学将基本初等函数归为五类:幂函数、指数函数、对数函数、三角函数、反三角函数...
  • 数学中初等函数

    2017-02-28 21:09:56
    初等函数是实变量或复变量的指数函数、对数函数、幂函数、三角函数和反三角函数经过有限次的四则运算(有理运算)及有限次复合后所构成的函数类。这是分析学中最常见的函数,在研究函数的一般理论中起重要作用。 ...
  • 函数 函数的定义 函数就是将一个对象转化为另一个对象的规则.起始对象称为输入,来自称为定义域的集合.返回对象称为输出,来自称为上域的集合. ...由常数和基本初等函数经有限次的四则运算和有限次函数...
  • 辨析:分段函数是不是初等函数?

    万次阅读 2018-10-22 19:15:54
    关于初等函数,《高等数学》(同济七版)中是这样子定义的:由常数和基本初等函数经过有限次的四则运算和有限次的函数复合步骤所构成并可用一个式子表示的函数,称为初等函数。 这个定义中,有两个需要注意的:(1) ...
  • 初等函数

    2021-02-04 17:12:13
    由常数和基本初等函数经过有限次的四则运算和有限次的函数复合步骤所构成并可用于一个解析式表示的函数,称为初等函数,例如: (幂函数复合),(三角函数和幂函数复合)(三角函数和幂函数复合). 应用上常常遇到以为...
  • ​ 初等函数是由基本初等函数经过有限次的四则运算和复合运算所得到的函数。基本初等函数和初等函数在其定义区间内均为连续函数。目前对基本初等函数有两种分类方法:数学分析有六种基本初等函数,高等数学只有五种...
  • 我们姑且界说f=f(a,b,…,c)显式为:对a,b,…c只进行固定的有限次数四则运算及取〔〕运算。本文证明了:如果能给出M_3显式,则能给出一同余方程之解显式。
  • 基本初等函数 本文主要记载五种基本初等函数。...由这些基本初等函数经过有限次的四则运算(加减乘除)和函数的复合所得到的函数称为初等函数。 幂函数 power function 公式 $y=x^\alpha$ 其中,$x$是自变量,$...
  • 初等函数简述

    2020-10-10 20:38:38
    由常数和基本初等函数经过有限次的四则运算和有限次的函数复合步骤所构成并可用一个式子表示的函数,称为初等函数。 二 幂函数 y=x^α(α为有理数且为常数)的函数,即以底数为自变量,幂为因变量,指数为常数的...
  • 这一节让大家回忆下高中所学的数学.整式方程未知数次数最高项次数高于2次的方程,...对于5次及以上的一元高次方程没有通用的代数解法和求根公式(即通过各项系数经过有限次四则运算和乘方和开方运算无法求解),这称...
  • 软件工程第一作业

    2017-04-18 01:31:00
    花20分钟写一个能自动生成小学四则运算题目的“软件”,要求:除了整数以外,还要支持真分数的四则运算。将代码上传至coding.net,并将地址发布至自己的博客。 四则运算代码链接 看完构建之法后的疑问: 1、由于...
  • 第三作业 题目: 请编写一个能自动生成小学四则运算题目的... 2、 该软件可以进行简单的四则运算并进行判断; 扩展功能:  1、 程序可以出带括号的正整数四则运算,支持分数,除法保留两位小数。 2、 可...
  • 步骤:判断运算符, 若为乘号, 对乘号前后两个数做乘法运算, 结果保存到临时变量中, 依次删除"乘号"后面"数字"和"乘号", 把临时变量附给"乘号"前面值. 这就完成了一次运算. 注意, 因为删除操...

空空如也

空空如也

1 2 3 4 5 6
收藏数 105
精华内容 42
关键字:

有限次的四则运算