软件工程个人作业03

 软件工程个人作业03

                                           组员：李锦

设计思想：使用for循环，是的输入的结果与别人输入的结果进行比较，如果相等，则定义一个数使其增加一，如果不相等，则定义另一个数使其增加一。

   源代码：

package pkg;
import java.util.Random ;
import java.util.Scanner;
import java.lang.reflect.Array;
import java.util.LinkedList;
import java.util.List;

public class FourOperation1 
{
    public static void main(String[] ages)
    {
        while(1>0)
        {
            System.out.print("
请选择要求："
                +"
  是否有乘除法；(True/False)"
                +"
  是否有括号（最多可以支持十个数参与运算）(True/False)；"
                +"
  数值范围(True(1~10)/False(1~100))；"
                +"
  加减乘除有无负数(True/False)；"
                +"
  除法有无余数(True/False)；");
            Scanner sc = new Scanner(System.in);
            Boolean[] a=new Boolean[5];
            for(int i=0;i<5;i++)
            {
                 a[i]=sc.nextBoolean();
            }
            System.out.println("请输入要出题的个数");
            Scanner N = new Scanner(System.in);
            int index=N.nextInt();
            int right=0,wrong=0;
        
            for(int ii=0;ii<index;ii++)
            {    
                if(a[1]==false)
                {
                    
                    int a1,a2,sign;
                    a1=RandomNum(100);
                    a2=RandomNum(100);
                    sign=RandomNum(4);
                    
                    /**按照用户规定的各种要求对数据进行修改使数据合乎规范**/
                    if(a[0]==false){
                        sign=sign%2;
                    }
                    else{
                        if(sign==3&&a[4]==false){
                            a1=a1*a2;
                        }    
                    }
                    if(a[3]==true&&(sign==0||sign==1)){
                        int ssign=RandomNum(2);
                        if(ssign==0){
                            a1=-a1;
                        }
                        int ssign2=RandomNum(2);
                        if(sign==0){
                            a2=-a2;
                        }
                    }        
                    if(a[2]==true){
                        a1=a1%10;
                        a2=a2%10;
                    }
                    if(a[4]==false){
                        a1=a1*a2;
                    }
                    //无效算式被取消
                    if(sign==3&&a2==0){
                        ii--;
                    }
                    else{
                        System.out.print(a1);
                        PrintSign(sign);
                        System.out.print(a2+"  =  ");
                        int jjudge,result;
                        if(sign==0){
                            result=a1+a2;
                        }
                        else if(sign==1){
                            result=a1-a2;
                        }
                        else if(sign==2){
                            result=a1*a2;
                        }
                        else{
                            result=a1/a2;
                        }
                        jjudge=judge(result);
                        if(jjudge==0){
                            right++;
                        }
                        if(jjudge==1){
                            wrong++;
                        }
                    }
                }
                else if(a[1]==true)
                {
                    int size=RandomNum(9);
                    int[] array=new int[size*2+4];
                    /**二叉树非叶子结点的取值，即四则运算运算符的随机选择**/
                    if(a[0]==false)//条件 没有乘除法
                    {
                        for(int i=0;i<=size;i++){
                            array[i]=RandomNum(2);
                        }
                    }
                    else {
                        for(int i=0;i<=size;i++){
                            array[i]=RandomNum(4);
                        }
                    }
                    /**二叉树叶子结点的取值，即四则运算运算数的随机取值**/
                    if(a[2]==true)//数的取值范围为0~10
                    {
                        for(int i=size+1;i<=size*2+2;i++)
                        {
                            array[i]=RandomNum(6)+4;//防止取值为0~3 打印时显示成运算符
                        } 
                    }
                    else{
                        for(int i=size+1;i<=size*2+2;i++){
                            
                            array[i]=RandomNum(96)+4;
                        } 
                    }
                    //限制条件：运算数随机选择是否为负数
                    if(a[3]==true){
                        for(int i=size+1;i<=size*2+2;i++){
                            int ssign=RandomNum(2);
                            if((array[i/2-1]==0||array[i/2-1]==1)&&ssign==0){
                            array[i]=-array[i];
                            }
                        } 
                    } 
                    /**将数组结点构建成二叉树**/
                    LinkedList<Node> nodeList = new LinkedList<Node>();
                    for(int nodeIndex=0;nodeIndex<array.length;nodeIndex++){
                         nodeList.add(new Node(array[nodeIndex]));       
                    }
                    creatBinTree(array,nodeList);
                    Node root = nodeList.get(0);
                    inOrderTraverse(root);
                    System.out.println("  =  "); 
                    values(root);   
                    int jjudge=judge(root.result);
             
                    if(jjudge==0){
                        right++;
                    }
                    if(jjudge==1){
                        wrong++;
                    }
                }
            }
            System.out.println("正确题数："+right+"错误题数："+wrong);
        }
    }
    
    /**取要求范围内的随机数**/
    public static int RandomNum(int i)
    {
        Random a=new Random();
        int a1=a.nextInt (i);
        return a1;
    }
    
    /**打印运算符**/
    public static void PrintSign(int sign)
    {
        if(sign==0){
            System.out.print("  +  ");
        }
        else if(sign==1){
            System.out.print("  -  ");
        }
        else if(sign==2){
            System.out.print("  *  ");
        }
        else if(sign==3){
            System.out.print("  /  ");
        }
        else
            System.out.print(sign);
    }
    
    /**定义二叉树结构**/
    public static class Node
    {
        Node leftchild;
        Node rightchild;
        int data;
        int result;//各二叉树分支之下的四则运算结果
        
        Node(int newData){
            leftchild=null;
            rightchild=null;
            data=newData;
            result=data;
        }
    }
    /**构建二叉树**/
    public static void creatBinTree(int array[],LinkedList<Node> nodeList){
        
        for(int parentIndex=0;parentIndex<array.length/2-1;parentIndex++){
            nodeList.get(parentIndex).leftchild = nodeList.get(parentIndex * 2 + 1);
            nodeList.get(parentIndex).rightchild = nodeList.get(parentIndex * 2 + 2);            
        }
    }
    /**中序遍历二叉树    即打印四则运算算式**/
    public static void inOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        if (node.leftchild != null) {
        System.out.print("(");  
        }
        inOrderTraverse(node.leftchild);  
        PrintSign(node.data );  
        inOrderTraverse(node.rightchild); 
        if (node.rightchild != null) {
            System.out.print(")");  
        }
    } 
    /**计算四则运算的值，和括号内每一步运算的值 采用递归算法**/
    public static void values(Node node){
        if (node.leftchild== null) {
             return;
        }
        values(node.leftchild);
        values(node.rightchild);
        if(node.data==0){
            node.result=node.leftchild.result+node.rightchild.result;
            }
        else if(node.data==1){
            node.result=node.leftchild.result-node.rightchild.result;
        }
        else if(node.data==2){
            node.result=node.leftchild.result*node.rightchild.result;
        }
        else 
        {
            if(node.rightchild.result==0){
                System.out.println("被除数为零，该算式无效！");
                return;
            }
            node.result=node.leftchild.result/node.rightchild.result;
        }
    }
    /**判断用户输入答案是否正确**/
    public static int judge(int answer){
         System.out.println("  请输入您的答案：  "); 
            Scanner sc2 = new Scanner(System.in);
            int userResult=sc2.nextInt();
            System.out.println(" 正确答案是："+answer  ); 
            if(userResult==answer){
                return 0;
            }
            else {
                return 1;
            }
    }
}

截图：

                                   周活动总结表

        姓名：苏月                           日期 2016/3/26

	听课	编写代码	阅读课本	准备考试			日总计
周日
周一	100分钟	78行	0				178
周二		0行	20				20
周三		220行	0				220
周四		100行	30				1300
周五		0行	0				0
周六		170行	0				170
周总计	100分钟	569行	50				719

  

                                  时间记录日志

          学生：苏月                   日期：2016/3/26

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

日期	开始时间	结束时间	中断时间	净时间	活动	备注	C	U
3/20	8:00	9:50	10	100	上课	课间
	3：00	5：30	25	125	写代码	休息
3/21
3/22	2：00	5：00	15	105	编程序	休息
3/23	2：00	5：30	20	130	写程序写进度条	休息
3/24
3/25	9：00	11：00	30	90	写总结，改代码	送朋友
	2：00	6：00	50	190	做最后的修改与完善	休息，吃饭

                                     缺陷记录日志

          学生：苏月                      日期：2016/3/26

          教员：王建民                    程序号：四则运算3

日期	编号	类型	引入阶段	排除阶段	修复时间	修复缺陷
3/20	1		编程	编译	10分钟
	描述：在写代码的过程中，引用类的方式的不同
3/22	2		编程	编译	30分钟
	描述：在数组的字符的输出过程中，“=”的输出遇到了问题，       在数组的使用过程中，数组特别的容易出现数组越界的现象
3/20	3		设计	编译	1小时
	描述：for循环出现了无限循环的情况
	描述：出现了数组越界的现象

个人总结：

在这一次的写代码的过程中，仿佛比原来写代码的过程容易了好多，没有了原来的那些盲目，也没有原来的那些烦躁，仿佛自己更加的懂得了怎样才能使自己冷静下来去思考怎样去完成这现工作。但是我仍然有很多的不足，例如：对于一些java的知识点还不是那么的熟悉；对于一些语句还不能够很好的掌握等等，所以，我知道我还有很多的东西要去学习。

照片：