软件工程个人作业02

四则运算在上周实现了两个运算符的加减乘除和真分数的运算，本周又加了一些新的内容。

一、题目：

二、程序设计思想

1、生成随机数，整数的和分数的，分数的用字符串表示，单独写一个分数类，分子分母，写出分数加减乘除的方法。

2、生成随机运算符数组，每道题最多有10个运算数，所以最多有9个运算符。

3、生成表达式，用控制语句选择要生成的表达式。

3、结果的处理，是分数的要化简。

三、源代码

import java.util.Random;
import java.util.Scanner;

public class SiZeKuo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        menu(in);
    }
     public static void menu(Scanner in){
         int type,n,chengchu,kuohao,num,fushu,yushu;
         System.out.println("请选择：1、整式，2、分式");
         type=in.nextInt();
         System.out.println("请输入生成的运算式的个数：");
         n=in.nextInt();
         System.out.println("请选择是否有乘除：1、有，2、没有");
         chengchu=in.nextInt();
         System.out.println("请选择是否有括号：1、有，2、没有");
         kuohao=in.nextInt();
         System.out.println("请输入数值范围：");
         num=in.nextInt();
         System.out.println("请选择加减有无负数：1、有，2、没有");
         fushu=in.nextInt();
         System.out.println("请选择除法有无余数：1、有，2、没有");
         yushu=in.nextInt();
         
         String[] question = null;
         question=TiMu(type,n,kuohao,num,chengchu,fushu,yushu);
         for(int i=0;i<question.length;i++){
             System.out.println(question[i]);
         }
         
     }
   /*  public static String[] chu(int type,int n,int chengchu,int kuohao,int num,int fushu,int yushu){
         String[] question = null;
             question=TiMu(n,kuohao,num,chengchu,fushu,yushu);
         return question;
     }*/
     public static String[] TiMu(int type,int n,int kuohao,int num,int chengchu,int fushu,int yushu){
        int a[]=null;//每个运算式的运算数
        String aa[]=null;
         String question[]=new String[n];
         char[] ch=null;//运算符
         int kuohao1[]=null;
        //--------n道题,有乘除
         if(chengchu==1&&type==1)
         {
             for(int i=0;i<n;i++){
               ch=SuiJiFu(chengchu);//---每道题的运算符的个数//----这个运算式的所有运算符
               int length=ch.length+1;//运算式的长度
               a = new int[length];
               for(int j=0;j<length;j++)
               {
                   a[j]=SuiJi(num);//每道题的运算数//----------产生一个运算数
                               //计算结果------单独调用方法
               }
                if(kuohao==1)//---------生成括号//----------需要括号
                   kuohao1=kuohao(length);//---------生成括号数值数组
              // 运算式
                question[i] = "";
               for(int jj=0;jj<length;jj++){
                   //添加左括号
                   if(kuohao==1){
                       for(int k=0;k<kuohao1[jj];k++){
                           question[i]+="(";
                       }
                   }
                   question[i]+=a[jj];
                   //----添加有括号
                   if(kuohao==1){
                       for(int k=0;k>kuohao1[jj];k--)
                           question[i]+=")";
                   }
                   //----如果不是最后一个运算数要加上运算符
                   if(jj!=length-1){
                       question[i]+=ch[jj];
                   }
               }
             //  检验是否重复
               for(int jj=0;jj<i;jj++){
                   if(question[i].equals(question[jj]))
                       i--;//重复则重新出题
               }

               
          }
         }
         //--------n道题,没有乘除
         if(chengchu==2&&type==1)
         {
             for(int i=0;i<n;i++){
               ch=SuiJiFu(chengchu);//---每道题的运算符的个数
               int length=ch.length+1;
              a = new int[length];
               for(int j=0;j<length;j++)
               {
                   a[j]=SuiJi(num);//每道题的运算数
               }
               if(kuohao==1)//---------生成括号
                   kuohao1=kuohao(length);
               //运算式
               question[i] = "";
               for(int jj=0;jj<length;jj++){
                   //添加左括号
                   if(kuohao==1){
                       for(int k=0;k<kuohao1[jj];k++){
                           question[i]+="(";
                       }
                   }
                   question[i]+=a[jj];
                   //----添加右括号
                   if(kuohao==1){
                       for(int k=0;k>kuohao1[jj];k--)
                           question[i]+=")";
                   }
                   //----如果不是最后一个运算数要加上运算符
                   if(jj!=length-1){
                       question[i]+=ch[jj];
                   }
               }
               //检验是否重复
               for(int jj=0;jj<i;jj++){
                   if(question[i].equals(question[jj]))
                       i--;//重复则重新出题
               }  

               
          }
         }
         //---------------分数
         //--------n道题,有乘除
         if(chengchu==1&&type==2)
         {
             for(int i=0;i<n;i++){
               ch=SuiJiFu(chengchu);//---每道题的运算符的个数
               int length=ch.length+1;
              aa = new String[length];
               for(int j=0;j<length;j++)
               {
                   aa[j]=SuiJiFen(num);//每道题的运算数
                                    //计算结果------单独调用方法
               }
               
               
              if(kuohao==1)//---------生成括号
                  kuohao1=kuohao(length);
              //运算式
             question[i] = "";
              for(int jj=0;jj<length;jj++){
                  //添加左括号
                  if(kuohao==1){
                      for(int k=0;k<kuohao1[jj];k++){
                          question[i]+="(";
                      }
                  }
                  question[i]+=aa[jj];
                  //----添加右括号
                  if(kuohao==1){
                      for(int k=0;k>kuohao1[jj];k--)
                          question[i]+=")";
                  }
                  //----如果不是最后一个运算数要加上运算符
                  if(jj!=length-1){
                      question[i]+=ch[jj];
                  }
              }
              //检验是否重复
              for(int jj=0;jj<i;jj++){
                  if(question[i].equals(question[jj]))
                      i--;//重复则重新出题
              }

               
          }
         }
         //--------n道题,有乘除
         if(chengchu==2&&type==2)
         {
             for(int i=0;i<n;i++){
               ch=SuiJiFu(chengchu);//---每道题的运算符的个数
               int length=ch.length+1;
              aa = new String[length];
               for(int j=0;j<length;j++)
               {
                   aa[j]=SuiJiFen(num);//每道题的运算数
                 
                   //计算结果------单独调用方法
               }
              if(kuohao==1)//---------生成括号
                  kuohao1=kuohao(length);
              //运算式
             question[i] = "";
              for(int jj=0;jj<length;jj++){
                  //添加左括号
                  if(kuohao==1){
                      for(int k=0;k<kuohao1[jj];k++){
                          question[i]+="(";
                      }
                  }
                  question[i]+=aa[jj];
                  //----添加括右号
                  if(kuohao==1){
                      for(int k=0;k>kuohao1[jj];k--)
                          question[i]+=")";
                  }
                  //----如果不是最后一个运算数要加上运算符
                  if(jj!=length-1){
                      question[i]+=ch[jj];
                  }
              }
              
              //检验是否重复
              for(int jj=0;jj<i;jj++){
                  if(question[i].equals(question[jj]))
                      i--;//重复则重新出题
              }
          }
         }
//         for(int i = 0;i < n;i++){
//             String answer = stack.execute(question[i]);
//             question[i] += "=" + answer;
//         }
        return question;
     }
     //运算数,整数
     public static int SuiJi(int n){
         Random ra=new Random();
         return ra.nextInt(n+1);
     }
     //运算数，分数
     public static String SuiJiFen(int n){
         int a=SuiJi(n);
         int b=SuiJi(n);
         FenShu c=new FenShu(a,b);
         return c.toString();
     }
     //运算符
     public static char[] SuiJiFu(int n3){
         //10个运算数最多有9个运算符，n2运算符的个数
            Random ra=new Random();
            int n2=ra.nextInt(9)+1;
            char fu[]=new char[n2];
            char a1[]={'+','-','*','/'};
            int a[]=new int[n2];
            if(n3==1)
            {
                for(int i=0;i<n2;i++)
              {
                a[i]=ra.nextInt(4);
                fu[i]=a1[a[i]];
              }
            }
            //没有乘除
            if(n3==2)
            {
                for(int i=0;i<n2;i++)
              {
                a[i]=ra.nextInt(2);
                fu[i]=a1[a[i]];
              }
            } 
            return fu;
     }
     //----------生成括号数组，length为运算式中运算数的长度
   //随机生成括号，参数为运算式的运算数的个数
        public static int[] kuohao(int length){
             int[] kuohao = new int[length];
            for(int i = 0;i < kuohao.length;i++)   kuohao[i] = 0;
            Random rd = new Random();
            for(int i = 2;i < length;i++){//添加的括号长度（括号包围的运算数的个数）
               for(int j = 0;j < length - i + 1;j++){
                   int t = rd.nextInt(2);//随机生成0或1，0代表不加括号，1代表加括号
                   if(t == 1){
                       if(kuohao[j] >= 0 && kuohao[j + i - 1] <= 0){//要加的括号的第一个运算数周围没有右括号，且 最后一个运算数周围没有左括号
                           int counteract = 0;
                              for(int k = j;k < j + i;k++){//将要加的括号之间的所有运算数对应的brackets相加，
                                                              //如果和为0说明这个括号之间的括号是匹配的，不会出现括号交叉现象
                                  counteract += kuohao[k];
                              }
                              if(counteract == 0){
                                  kuohao[j]++;
                                  kuohao[j + i - 1]--;
                              }
                          }
                      }
                  }
            }
            return kuohao;
          }
     
}

class FenShu {
    private int fenmu,fenzi;

    public int getFenMu() {
        return fenmu;
    }

    public void setFenMu(int FenMu) {
        this.fenmu= fenmu;
    }

    public int getFenZi() {
        return fenzi;
    }

    public void setFenZi(int fenzi) {
        this.fenzi = fenzi;
    }

    public FenShu(int fenmu, int fenzi) {
        this.fenmu = fenmu;
        this.fenzi = fenzi;
        yueJian();
    }
    
    FenShu(){}
    
    //化简
    public void yueJian(){
        int y = 1;
        for(int i = fenzi;i > 1;i--){
            if(fenzi % i == 0 && fenmu % i == 0){
                y = i;
                break;
            }
        }

            fenzi /= y;
            fenmu /= y;
        
    }
    
    //加
    public FenShu add(FenShu b){
        FenShu c = null;
        int fenzi = this.fenzi * b.getFenMu() + this.fenmu * b.getFenZi();
        int fenmu = this.fenmu* b.getFenMu();
        c = new FenShu(fenmu,fenzi);
        return c;
    }
    
    //减
    public FenShu jian(FenShu b){
        FenShu c = null;
        int fenzi = this.fenzi * b.getFenMu() - this.fenmu * b.getFenZi();
        int fenmu = this.fenmu* b.getFenMu();
        c = new FenShu(fenmu,fenzi);
        return c;
    }
    
    //乘
    public FenShu cheng(FenShu b){
        FenShu c = null;
        int fenzi = this.fenzi *  b.getFenZi();
        int fenmu = this.fenmu* b.getFenMu();
        c = new FenShu(fenmu,fenzi);
        return c;
    }
    
    //除
    public FenShu chu(FenShu b){
        FenShu c = null;
        int fenzi = this.fenzi *  b.getFenMu();
        int fenmu = this.fenmu* b.getFenZi();
        c = new FenShu(fenmu,fenzi);
        return c;
    }
    //输出分数形式
    public String toString(){
        if(fenzi != 0){
            return fenzi + "/" + fenmu;
        }
        return "0";
    }
    
}

四、实验结果截图

整式有乘除有括号加减有负数

整式没有乘除没有括号加减有负数，乘除没有余数

 分式有括号，加减有负数，除法有余数

分式没有括号，加减没有负数，除法没有余数

五、反思总结

1、最大的困难就是怎么在运算式上加括号以及计算的问题。

2、数据结构学的算法，计算表达式用后缀到栈的思想，将中缀表达式变成表达式，根据运算符的优先级来堆栈弹栈。

3、加不加括号也用随机数决定，但是一定要匹配。

4、作业要及时写，及时写。

PSP0级过程文档

时间记录日志

缺陷记录日志