软件工程个人作业03

个人项目-四则运算2

题目：

1、定义参数控制生成题目的个数。例如，参数n=10；则将生成10个题目。

2、定义参数控制题目中数值（自然数、真分数和真分数分母）的范围。例如参数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.生成的题目存储到数据库中，格式如下： 1. 四则运算题目1 2. 四则运算题目2 …… 其中真分数在输入输出时采用如下格式，真分数五分之三表示为3/5，真分数二又八分之三表示为2’3/8。

8. 在生成题目的同时，计算出所有题目的答案，并存入数据库文件。格式如下： 1. 答案1 2. 答案2 特别的，真分数的运算如下例所示：1/6 + 1/8 = 7/24。

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

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

设计思想：在之前的基础上进行修改，改善了部分功能，诸如分数运算及除法运算。

源程序代码：

package size;
import java.util.Scanner;
public class yunsuan {
    public static Scanner in=new Scanner(System.in);
    static int b1,b2,b3,b4;
    static int a1=0;
    static int a2=0;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int s;
        while(true)
        {
            System.out.println("请输入要进行的运算：");
            System.out.println("1.整数四则运算：");
            System.out.println("2.真分数四则运算：");
            System.out.println("3.退出：");
            s=in.nextInt();
            if(s==1)
            {
                System.out.println("请输入要生成题目的个数：");
                int n=in.nextInt();
                System.out.println("请输入数值范围(自然数0-2147483647)：");
                int p=in.nextInt();
                int q=in.nextInt();
                System.out.println("是否有括号？ 1:有 2:否");
                int k=in.nextInt();
                if(k==1)
                {
                    parentheses(n,p,q);
                }
                else
                {
                    IntYuan(n,p,q);
                }
                continue;
            }
            if(s==2)
            {
                System.out.println("请输入要生成题目的个数：");
                int m=in.nextInt();
                System.out.println("请输入数值范围(自然数0-2147483647)：");
                int p=in.nextInt();
                int q=in.nextInt();
                Fraction F1=new Fraction();
                for(int j=0;j<m;j++)
                {
                F1.TrueNum(p,q);
                }
                continue;
            }
            if(s==3)
            {
                break;
            }
            else
            {
                System.out.println("输入错误，请重新输入：");
                s=in.nextInt();
            }
        }
        in.close();
    }
    public static void IntYuan(int n,int p,int q)
    {
        int result1=-2147483648;//假设结果值为int类型的最小值
        String result2="";//当为除法运算时结果写为String类型
        String result3="";//当为除法运算时计算结果转化为String类型
        char ch;//将生成的运算符赋值
        String[] re = new String[20000];
        int[] re1 = new int[100];
        int[] re2 = new int[100];
       
        System.out.print("是否有乘除法？ 1:有 2:否");
        int c=in.nextInt();
        System.out.print("加减有无负数？ 1:有 2:否");
        int f=in.nextInt();
        System.out.print("除法有无余数？ 1:有 2:否");
        int y=in.nextInt();
        for(int i=0;i<n;i++) 
        {
            a1=ranNum(a1,p,q);
            a2=ranNum(a2,p,q);
            if(c==1)
            {
                ch=ranChar1();
            }
            else
            {
                ch=ranChar2();
            }
            //查重
            re[i]=String.valueOf(a1)+String.valueOf(ch)+String.valueOf(a2);
            for(int j=0;j<i;j++)
            {
                if(re[j].equals(re[i]))
                {
                    i--;
                }
            }
            //当运算符为"+"或"*"时重复
            if(ch=='+'||ch=='*')
            {
                re1[i]=a1;
                re2[i]=a2;
                for(int j=0;j<i;j++)
                {
                    if(re1[j]==re2[i] && (re2[j]==re1[i]))
                    {
                        i--;
                    }
                }
            }
            //当加减不能出现负数时执行此操作
            if(f==2 &&((a1<0||a2<0)||(a1<a2 && ch=='-')))
            {
                i--;
            }
            //生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数
            else if((y==1)&&(ch=='/')&&(a1>a2)&&(a1%a2!=0))
            {
                i--;
            }
            //当除法不能有余数时执行此操作
            else if(y==2 && ch=='/' && a1%a2!=0)
            {
                i--;
            }
            else
            {
                System.out.print(a1);
                System.out.print(ch);
                System.out.println(a2+"=");
                
                System.out.print("请输入答案：");
                if(ch!='/')
                {
                    result1=in.nextInt();
                }
                else
                {
                    Fraction F2=new Fraction(a1,a2);
                    F2.yuefen();
                    result3=F2.toString(F2);
                    //result3=String.valueOf(F2.fenzi)+"/"+String.valueOf(F2.fenmu);
                    result2=in.next();
                }
                if(ch=='+'&&(result1==a1+a2))
                {
                    
                    System.out.println("计算正确！");
                }
                else if(ch=='-'&&(result1==a1-a2))
                {
                    System.out.println("计算正确！");
                }
                else if(ch=='*'&&(result1==a1*a2))
                {
                    System.out.println("计算正确！");
                }
                else if(ch=='/'&&(result2.equals(result3)))
                {
                    System.out.println("计算正确！");
                }
                else
                {
                    System.out.println("计算错误！");
                }
            }
         }
    }
    public static void parentheses(int n,int p,int q)//带括号运算
    {
        for(int i=0;i<n;i++)
        {
            int num=(int)(Math.random()*8+3);//随机生成参与运算的数字数
            int num1=(int)(Math.random()*7+2);//随机生成括号内的数字数
            int num2=(int)(Math.random()*2+1);//随机生成括号后的数字数
            if(num1+num2<num)
            {
                
            int[] a={0,0,0,0,0,0,0,0,0,0};
            for(int m=0;m<num;m++)
            {
                a[m]=ranNum(a[m],p,q);
            }
            for(int m1=0;m1<num-num1-num2-1;m1++)//输出括号外的运算数
            {
                System.out.print(a[m1]);
                System.out.print(ranChar1());
            }
            System.out.print(a[num-num1-num2-1]);
            System.out.print(ranChar3());//打印括号
            for(int m2=num-num1-num2;m2<num-num2-1;m2++)
            {
                System.out.print(a[m2]);
                System.out.print(ranChar1());
            }
            System.out.print(a[num-num2-1]);
            System.out.print(ranChar4());
            for(int m3=num-num2;m3<num-1;m3++)
            {
                System.out.print(a[m3]);
            }
            System.out.println(a[num-1]+"=");
        }
        }
    }
    public static int ranNum(int a,int b,int c)
    {
        a=(int)(Math.random()*(c-b+1)+b);//随机数值范围为从b到c
        return a;
    }
    public static char ranChar1()//随机生成“+、-、*、/”运算符
    {
        char[] b={'+','-','*','/'};
        int c=(int)(Math.random()*4);
        return b[c];
    }
    public static char ranChar2()//随机生成“+、-”运算符
    {
        char[] b={'+','-'};
        int c=(int)(Math.random()*2);
        return b[c];
    }
    public static String ranChar3()//随机生成“+、-、*、/、(”运算符
    {
        String[] b={"+(","-(","*(","/("};
        int c=(int)(Math.random()*4);
        return b[c];
    }
    public static String ranChar4()//随机生成“+、-、*、/、(”运算符
    {
        String[] b={")+",")-",")*",")/"};
        int c=(int)(Math.random()*4);
        return b[c];
    }
}
class Fraction
{
    int fenzi,fenmu;
    public Fraction(){}
    public Fraction(int fenzi,int fenmu)
    {
        this.fenzi=fenzi;
        this.fenmu=fenmu;
        yuefen();
    }
    public int getFenzi()
    {
        return fenzi;
    }
    public int getFenmu()
    {
        return fenmu;
    }
    public void setFenzi(int fenzi)
    {
        this.fenzi=fenzi;
    }
    public void setFenmu(int fenmu)
    {
        this.fenmu=fenmu;
    }
    public void yuefen()//约分
    {
        int min=Math.abs(fenzi)<Math.abs(fenmu)?Math.abs(fenzi):Math.abs(fenmu);
        int yueshu=1;
        for(int i=min;i>=1;i--)
        {
            if((fenzi%i==0)&&(fenmu%i==0))
            {
                yueshu=i;
                break;
            }
        }
        fenzi=fenzi/yueshu;
        fenmu=fenmu/yueshu;
    }
    public Fraction add(Fraction a,Fraction b)//加
    {
        Fraction c=new Fraction();
        c.fenzi=a.fenzi*b.fenmu+a.fenmu*b.fenzi;
        c.fenmu=a.fenmu*b.fenmu;
        c=new Fraction(c.fenzi,c.fenmu);
        return c;
    }
    public Fraction subtract(Fraction a,Fraction b)//减
    {
        Fraction c=new Fraction();
        c.fenzi=a.fenzi*b.fenmu-a.fenmu*b.fenzi;
        c.fenmu=a.fenmu*b.fenmu;
        c=new Fraction(c.fenzi,c.fenmu);
        return c;
    }
    public Fraction  multiply(Fraction a,Fraction b)//乘
    {
        Fraction c=new Fraction();
        c.fenzi=a.fenzi*b.fenzi;
        c.fenmu=a.fenmu*b.fenmu;
        c=new Fraction(c.fenzi,c.fenmu);
        return c;
    }
    public Fraction division(Fraction a,Fraction b)//除
    {
        Fraction c=new Fraction();
        c.fenzi=a.fenzi*b.fenmu;
        c.fenmu=a.fenmu*b.fenzi;
        c=new Fraction(c.fenzi,c.fenmu);
        return c;
    }
    public int ranNum(int b,int c)
    {
        int a;
        a=(int)(Math.random()*(c-b+1)+b);//随机数值范围为从b到c
        return a;
    }
    public static char ranChar()//随机生成“+、-、*、/”运算符
    {
        char[] b={'+','-','*','/'};
        int c=(int)(Math.random()*4);
        return b[c];
    }
    public String toString(Fraction Fra3)
    {
        String resultS="";
        if(Fra3.fenzi>Fra3.fenmu&&(Fra3.fenzi%Fra3.fenmu!=0))
        {
            int z=Fra3.fenzi/Fra3.fenmu;
            resultS+=z+"'"+(Fra3.fenzi-z*Fra3.fenmu)+"/"+Fra3.fenmu;
        }
        else if(Fra3.fenzi%Fra3.fenmu==0)
        {
            resultS+=Fra3.fenzi/Fra3.fenmu;
        }
        else
        {
            resultS+=Fra3.fenzi+"/"+Fra3.fenmu;
        }
        return resultS;
    }
    public void TrueNum(int b,int c)
    {
        Scanner in=new Scanner(System.in);
        Fraction Fra1=new Fraction();//第一个分数
        Fraction Fra2=new Fraction();//第二个分数
        Fraction Fra3=new Fraction();
        
        Fra1.fenzi=ranNum(b,c);
        Fra1.fenmu=ranNum(b,c);
        Fra2.fenzi=ranNum(b,c);
        Fra2.fenmu=ranNum(b,c);
        Fra1.yuefen();
        Fra2.yuefen();
        char ch=ranChar();
        String resultF="";
        if((Fra1.fenzi<Fra1.fenmu) && (Fra2.fenzi<Fra2.fenmu))
        {
            System.out.print(Fra1.fenzi+"/"+Fra1.fenmu);
            System.out.print(ch);
            System.out.println(Fra2.fenzi+"/"+Fra2.fenmu+"=");
            System.out.println("请输入结果：");
            String resultS=in.next();//输入的结果
            if(ch=='+')
            {
                Fra3=add(Fra1,Fra2);
                resultF=toString(Fra3);
                if(resultS.equals(resultF))
                {
                    System.out.println("计算正确！");
                }
                else
                {
                    System.out.println("计算错误！");
                }
            }
            if(ch=='-')
            {
                Fra3=subtract(Fra1,Fra2);
                resultF=toString(Fra3);
                if(resultS.equals(resultF))
                {
                    System.out.println("计算正确！");
                }
                else
                {
                    System.out.println("计算错误！");
                }
            }
            if(ch=='*')
            {
                Fra3=multiply(Fra1,Fra2);
                resultF=toString(Fra3);
                if(resultS.equals(resultF))
                {
                    System.out.println("计算正确！");
                }
                else
                {
                    System.out.println("计算错误！");
                }
            }
            if(ch=='/')
            {
                Fra3=division(Fra1,Fra2);
                resultF=toString(Fra3);
                if(resultS.equals(resultF))
                {
                    System.out.println("计算正确！");
                }
                else
                {
                    System.out.println("计算错误！");
                }
            }
        }
        else
        {
            TrueNum(b,c);
        }
    }
}

运行结果截图：

编程总结分析：对于除法（或分数）应用字符串形式判断输入的计算值是否正确，未能成功连接数据库。

项目计划日志：

周活动总结表

学生：曹婷婷日期：2017.3.20

日期	听课（min）	编写程序（min）	查阅资料（min）	日总计（min）
周一3.6		60		60
周二3.7
周三3.8		30		30
周四3.9
周五3.10	60	30	10	40
周六3.11		60	30	90
周日3.12		3000		3000
周总计：	60	3180	40	3220

时间记录日志：

时间记录日志

学生：曹婷婷日期：2017.3.20

教师：王建民课程：软件工程概论

日期	开始时间	结束时间	中断时间	净时间	活动	备注
3.18	14:00	16:00	10min	110min	上课	休息
3.18	18:30	19:00	0	30min	在“二柱子02”基础上做改动
3.19	10:00	11:35	13min	82min	写“二柱子02”，改进除法部分	休息
3.20	9:30	11:30	30min	90min	写“二柱子02”完善分数计算的方法	休息
	14:30	17:00	30min	2h	写“二柱子03”完成查重功能	玩儿
	18:00	20:00	30,min	90min	写连接数据库部分，未完成	休息

缺陷记录日志：

缺陷记录日志

学生：曹婷婷教师：王建民

程序：“二柱子03 日期：2017/3/20

日期	编号	引入阶段	排除阶段	修复时间	修复缺陷
3.18	1	编码	编译	30min	控制除法有余数时的输入
3.19	2	编码	编译	30min	控制分数的运算
3.20	3	编码	编译	10min	括号运算的改进