软件工程个人作业03

设计思路：

用split()将数字与符号分离，分别按顺序压入栈1中，将栈1出栈压入栈2中，先运算乘除再运算加减，从栈1出栈，判断是否为乘或除，如果是分别从栈1和栈2中取栈顶元素，作乘除法，将结果压入栈1；同理运算加减。输出结果后与用户输入的结果进行比较，正确的话，累加记录正确题数量的变量，在输出所有算式之后，输出用户正确的数量和错误的数量。

源程序：

import java.util.*; 
import java.util.regex.*; 
import java.lang.*; 
 
public class CalculateThree {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("请输入题目的数量：");
        Scanner sc1 = new Scanner(System.in);
        int quantity = sc1.nextInt();
        System.out.println("请输入每行输出几道题目：");
        Scanner sc2 = new Scanner(System.in);
        int num = sc2.nextInt();
        int size=quantity;
        String[]suanshizu=new String[size];
        equation(quantity,suanshizu);
        output(suanshizu,num,quantity);
    }
    static void equation(int quantity,String a[])//产生算式函数

    {
        System.out.println("请输入数值范围的最大值：");
        Scanner sc1 = new Scanner(System.in);
        int max = sc1.nextInt();
        System.out.println("请输入数值范围的最小值：");
        Scanner sc2 = new Scanner(System.in);
        int min = sc2.nextInt();
        System.out.println("请选择是否有负数（是：1   否：0）");
        Scanner sc3 = new Scanner(System.in);
        int x = sc3.nextInt();
        int iffu=x;
        System.out.println("请选择是否有分数（是：1   否：0）");
        Scanner sc4 = new Scanner(System.in);
        int y = sc4.nextInt();
        int iffen=y;
        System.out.println("请选择是否有乘除法（是：1   否：0）");
        Scanner sc5 = new Scanner(System.in);
        int z = sc5.nextInt();
        int ifcheng=z;
        System.out.println("请选择除法是否有余数（是：1   否：0）");
        Scanner sc6 = new Scanner(System.in);
        int ifyu = sc6.nextInt();
        for(int i=0;i<quantity;)
        {
            String suanshi;
            int c=1+(int)(Math.random()*7);
            suanshi=randomNumber(max,min,iffu,iffen);
            for(int t=0;t<c;t++)
            {
                if(x==1)
                    iffu=(int)(Math.random()*2);
                if(y==1)
                    iffen=(int)(Math.random()*2);
                if(z==1)
                    ifcheng=(int)(Math.random()*2);
                int n0=(int)(Math.random()*2);
                if(n0==0)
                {
                    suanshi=suanshi+randoSymbol(ifcheng,max,ifyu);  //
                    suanshi=suanshi+randomNumber(max,min,iffu,iffen);
                }
                if(n0==1)
                {
                    suanshi=randoSymbol(ifcheng,max,ifyu)+suanshi;
                    suanshi=randomNumber(max,min,iffu,iffen)+suanshi;
                }
                int n=(int)(Math.random()*3);
                if(n==5)
                {suanshi='('+suanshi+')';}
                }
            i=i+ti(a,suanshi,i);
        }
    }
    static String randomNumber(int max,int min,int iffu,int iffen)//产生随机数
    {
        String number;
        if(iffen==0)
            {
            int a=(int)(Math.random()*max);
            number=String.valueOf(a);
            }
        else
        {
            int a=(int)(Math.random()*max);
            int b=(int)(Math.random()*max);
            if(b<a)
            {
            int t=b;
            b=a;
            a=t;
            }
        for(int i=a;i>1;i--)
        {
            if(a%i==0&&b%i==0)
            {
                a=a/i;
                b=b/i;
            }
        }
            number='('+String.valueOf(a)+'/'+String.valueOf(b)+')';
        }
        if(iffu==1)
            number='('+"-"+number+')';
        return number;
    }
    static String randoSymbol(int ifcheng,int max,int ifyu)//产生随机运算符
    {
        String symbol;
        int a=1+(int)(Math.random()*4);
        symbol=String.valueOf(a);
        if(ifcheng==0)
        {
            if(a==1||a==2)
            {
                char s='+';
                symbol=String.valueOf(s);
            }
            if(a==3||a==4)
            {
                char s='-';
                symbol=String.valueOf(s);
            }
        }
        if(ifcheng==1)
        {
            if(a==1)
            {
                char s='+';
                symbol=String.valueOf(s);
            }
            if(a==2)
            {
                char s='-';
                symbol=String.valueOf(s);
            }
            if(a==3)
            {
                char s='*';
                symbol=String.valueOf(s);
            }
            if(a==4)
            {
                int number1,number2;
                char s='/';
                symbol=String.valueOf(s);
                if(ifyu==0)
                {for(;;)
                {
                    number1=1+(int)(Math.random()*max);
                    number2=2+(int)(Math.random()*max);
                    if(number1%number2==0)
                        break;
                }
                String num1=String.valueOf(number1);
                String num2=String.valueOf(number2);
                symbol=randoSymbol(0,max,ifyu)+num1+symbol+num2+randoSymbol(0,max,ifyu);
                }
            }
        }
        return symbol;
    }
    static void output(String a[],int num,int quantity)
    {
        int t=0,f=0;
        for(int i=0;i<quantity;i++)
        {
            if((i+1)%num==0)
                {System.out.println(a[i]+'=');
                Scanner sc1 = new Scanner(System.in);
                int answer = sc1.nextInt();
                System.out.println("正确结果："+jiandanyunsuan(a[i]));//输出正确结果
                if(answer-jiandanyunsuan(a[i])==0)//累计对错
                    t=t+1;
                }
            else
                {System.out.print(a[i]+jiandanyunsuan(a[i])+'='+'	'+'	');
                Scanner sc1 = new Scanner(System.in);
                int answer = sc1.nextInt();
                System.out.println("正确结果："+jiandanyunsuan(a[i]));
                if(answer-jiandanyunsuan(a[i])==0)
                    t=t+1;
                }
            }
        System.out.println("正确的个数是："+t+"错误的个数是："+(quantity-t));

    }
    static int ti(String a[],String v,int i)
    {
        
        int j;
        if(i!=0)
        {
            for(j=0;j<i;j++)
                {
                    if(a[j]==v)
                    {
                        break;
                    }
                }
            if(j==i)
            {
                a[i]=v;
                return 1;
                }
            else
                return 0;
            
        }
        else
        {
            a[0]=v;
            return 1;
        }
    }
    static double jiandanyunsuan(String str) 
    {
        String[] operater =new String[20]; 
        String[] number = new String[20];  
        Stack countStack1 = new Stack(); 
        Stack countStack2 = new Stack(); 
        int result =0; 
        number = str.split("\/|\*|\+|\-"); //分离出数字
        operater= str.split("\d+"); //分离出符号
            for(int i = 0; i<number.length;i++)
            { 
                countStack1.push(number[i]); 
                if(i!=number.length-1){ 
                    countStack1.push(operater[i+1]); 
                    } 
            } //将数字和符号按一定顺序压入栈中
            while(!countStack1.isEmpty()) 
                countStack2.push(countStack1.pop()); //为了按照从左到右的顺序计算算式
            String op; 
            while(!countStack2.isEmpty())
            { 
                result=0; 
                op = countStack2.pop().toString(); 
                if(op.equals("*"))//乘法运算
                { 
                    result=Integer.parseInt(countStack1.pop().toString())*Integer.parseInt(countStack2.pop().toString()); 
                    countStack1.push(result); 
                    continue; 
                } 
                if(op.equals("/"))//除法运算
                { 
                    result=Integer.parseInt(countStack1.pop().toString())/Integer.parseInt(countStack2.pop().toString()); 
                    countStack1.push(result); 
                    continue; 
                } 
                countStack1.push(op); //如果涉及乘除运算直接压入栈中
            } 
            while(!countStack1.isEmpty()) 
                countStack2.push(countStack1.pop()); //为了运算顺序
            while(!countStack2.isEmpty())
            {
                result=0; 
                op = countStack2.pop().toString(); 
                if(op.equals("+")){ //运算加法
                    result=Integer.parseInt(countStack1.pop().toString())+Integer.parseInt(countStack2.pop().toString()); 
                    countStack1.push(result); 
                    continue; 
                    } 
                if(op.equals("-"))//运算减法
                {
                    result=Integer.parseInt(countStack1.pop().toString())-Integer.parseInt(countStack2.pop().toString()); 
                    countStack1.push(result); 
                    continue; 
                } 
                countStack1.push(op); 
                } 
            return result;  //返回结果
            } 

}

截图：

总结：这次的任务比较难，我和我的小组成员尤凯丽上网上搜索了一下，发现有javascript的做法，但是应用时我们发现有很多问题，就舍弃了这个方法，有机会的话可以尝试看看，我们这次用了split()函数，学会了关于这个函数的一些用法。相对而言，这次的实现并不完美，以后要继续努力。

周活动总结表

        姓名：张雪晴                            日期 2016/3/26

	听   课	编写代码	阅读课本	准备考试	日总计
周日
周一	100分钟				100分钟
周二
周三
周四			《构建之法》
周五		200		讨论程序
周六		74
周总计	100分钟	274			100分钟

  

                           时间记录日志

          学生：张雪晴                   日期：2016/3/26

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

日期	开始时间	结束时间	中断时间	净时间	活动	备注	C	U
3.21	8:00	9:50	8:50-9:00	100	听课		✔
3.23	20:40	21:10		30	写设计思想		✔
3.24	19:00	20:50	共计70分钟	40	读构建之法		✔
3.25	18:00	19:50	18:23-18:33	100	讨论程序		✔
3.26	9:50	11:30		100	写程序		✔
	14:30	19：25	18:40-19:00	275	写程序并发表

                      

   缺陷记录日志

              学生：张雪晴             日期：2016/3/26

              教员：王建民             程序号：四则运算第二季

日期	编    号	类    型	引入阶段	排除阶段	修复时间	修复缺陷
3.25	1	20	编程	编程	5min
	描述：变量str重复命名
3.26	2	20	编程	编译	2min
	描述：数组下标越界，更改循环变量
	3	70	编程	编译	30min
	描述：判断括号时的算法错误
	4	20	编程	编译	2min
	描述：数据类型输出时出错
	5	70	编程	编译	3min
	描述：判断计算结果时出错，改为if(answer-jiandanyunsuan(a[i])==0)

 合作照片：