• 软件工程个人作业03


     四则运算3

    设计思想

    1、输入:输入选择;

    2、选择内容:选择出2位数的题还是多位数的题还是退出程序

               选择1是否有乘除法(运算符0-1或0-3);

                 选择5加减有无负数;

                 选择6除法有无余数;

                 选择7是选择数量或打印方式。

                 3是数值范围的前域

                 4是数值范围的后域

    3、加工:2位数的题设置循环,令其长度为一个足够大的数,满足程序一次运行可多次使用

         是否有乘除法:在前面做出选择后,在下面只需设置运算符随机出数的范围在0-1之间还是0-3之间

         数值范围:即四则运算随机出数的范围在前域~后域

         加减有无负数:对随机生成的数字进行运算,如果进行加/减运算之后,有负数,则根据选择进行保留或舍弃

         控制题目不能重复:将之前的题目存放在数组中,然后依次进行比较

         打印方式:根据用户输入要求一行输出几列后,利用取余的方法判断是否要换行输出

         计算则按照顺序计算即可

        多位数的题:

    设置循环,令其长度为一个足够大的数,满足程序一次运行可多次使用

        是否有乘除法:在前面做出选择后,在下面只需设置运算符随机出数的范围在0-1之间还是0-3之间

        数值范围:即四则运算随机出数的范围在前域~后域

        加减有无负数:对随机生成的数字进行运算,如果进行加/减运算之后,有负数,则根据选择进行保留或舍弃

        有无括号:用随机数来进行选择在原来式子之前还是之后进行添加

        控制题目不能重复:将之前的题目存放在数组中,然后依次进行比较

        打印方式:根据用户输入要求一行输出几列后,利用取余的方法判断是否要换行输出

        带括号的计算是直接从最里层括号开始往外依次计算

        不带括号的计算则分为没有乘除法和有乘除法

        没有乘除法的是将运算式存为二维数组,将数值和运算符依次分别存放于两个数组中,然后按从左到右的顺序进行计算

        有乘除法的则需进一步统计,在哪有除法或者乘法,然后先进行这两个运算。

    4、输出:2位数运算,显示运算式以及用户输入的结果,还有系统判断的结果

                最后,则是系统统计用户的做题情况

                 多位数运算则是显示运算式以及系统产生的结果

    源程序代码

      1 import java.util.Random;
      2 import java.util.Scanner;
      3 import javax.swing.JOptionPane;
      4 
      5 public class Arithmetic {
      6 
      7     public static void main(String[] args) {
      8         // TODO 自动生成的方法存根
      9         int c;//选择
     10         int c1,c4,c5,c6,c7,c8;
     11         int a,b,d1;//二位数运算
     12         int c2,c3;
     13         int e=0;//运算符
     14         String s="";
     15         double d=0.0;//2位数的结果,用户
     16         double f=0.0,g=0.0;//2位数结果,系统,多位数结果,系统
     17         int flag=0;//判断是否输出
     18         int m=0;//题数
     19         Random rand = new Random();
     20         for(int i=0;i<100000000;i++)
     21             {
     22                 System.out.println("请输入选择:1、2位数运算  2、多位数运算 3、退出");
     23                 Scanner input=new Scanner(System.in) ;
     24                 c=input.nextInt();
     25                 if(c==1)
     26                 {
     27                     System.out.println("请输入选择:1 、有乘除法 2、无乘除法");
     28                      Scanner input1=new Scanner(System.in) ;
     29                      c1=input1.nextInt();
     30                      System.out.println("请输入数值范围的前域 ");
     31                      Scanner input2=new Scanner(System.in) ;
     32                      c2=input2.nextInt();
     33                      System.out.println("请输入数值范围的后域");
     34                      Scanner input3=new Scanner(System.in) ;
     35                      c3=input3.nextInt();
     36                      System.out.println("请输入选择:1、加减有负数 2、加减无负数");
     37                      Scanner input4=new Scanner(System.in) ;
     38                      c4=input4.nextInt();
     39                      System.out.println("请输入选择:1、除法有余数 2、除法无余数");
     40                      Scanner input5=new Scanner(System.in) ;
     41                      c5=input5.nextInt();
     42                      System.out.println("请输入出题数量");
     43                      Scanner input6=new Scanner(System.in) ;
     44                      c6=input6.nextInt();
     45                      System.out.println("请输入在一行中输出几列运算式?");
     46                      Scanner input7=new Scanner(System.in) ;
     47                      c7=input7.nextInt();
     48                         String []Repeat=new String[2*c6];
     49                      for(int w=0;w<c6;w++)
     50                      {
     51                          int w1;
     52                          w1=w;
     53                         //有无乘除法
     54                          if(c1==1)
     55                          {
     56                              e=rand.nextInt(4);
     57                          }
     58                          if(c1==2)
     59                          {
     60                              e=rand.nextInt(2);
     61                          }
     62                          //数值范围
     63                          a=rand.nextInt(c3)%(c3-c2+1)+c2;
     64                          b=rand.nextInt(c3)%(c3-c2+1)+c2;
     65                          //加减有无负数
     66                          if(c4==1)//有负数
     67                          {
     68                              flag=0;
     69                          }
     70                          if(c4==2)
     71                          { 
     72                              if(e==0)
     73                              {
     74                                  if((a+b)>=0)
     75                                  {
     76                                      flag=0;
     77                                  }
     78                                  else 
     79                                  {
     80                                      flag=1;
     81                                  }
     82                              }
     83                              if(e==1)
     84                              {
     85                                  if((a-b)>=0)
     86                                  {
     87                                      flag=0;
     88                                  }
     89                                  else
     90                                  {
     91                                      flag=1;
     92                                  }
     93                              }
     94                          }
     95                         //符号
     96                          if(e==0)
     97                          {
     98                              s="+";
     99                              f=a+b;
    100                          }
    101                          if(e==1)
    102                          {
    103                              s="-";
    104                              f=a-b;
    105                          }
    106                          if(e==2)
    107                          {
    108                              s="*";
    109                              f=a*b;
    110                          }
    111                          if(e==3)
    112                          {
    113                              if(b!=0)
    114                              {
    115                                  if(c5==1)
    116                                  {
    117                                     s="/"; 
    118                                     f=a/b;
    119                                  }
    120                                  if(c5==2)
    121                                  {
    122                                      if(a%b==0)
    123                                      {
    124                                          s="/";
    125                                          f=a/b;
    126                                      }
    127                                      if(a%b!=0)
    128                                      {
    129                                          flag=1;
    130                                      }
    131                                  }
    132                                  
    133                              }
    134                          }
    135                          //判断重复
    136                          if(a<0.0&&b>=0.0)
    137                          {
    138                              Repeat[w]="("+a+")"+s+b;
    139                          }
    140                          if(a>=0.0&&b<0.0)
    141                          {
    142                              Repeat[w]=a+s+"("+b+")";
    143                          }
    144                          if(a<0.0&&b<0.0)
    145                          {
    146                              Repeat[w]="("+a+")"+s+"("+b+")";
    147                          }
    148                          if(a>=0.0&&b>=0.0)
    149                          {
    150                              Repeat[w]=a+s+b;
    151                          }
    152                          for(int w2=0;w2<w1;w2++)
    153                          {
    154                              if(Repeat[w].equals(Repeat[w2]))
    155                              {
    156                                  flag =1;
    157                              }
    158                              else
    159                              {flag =0;}
    160                          }
    161                          //打印
    162                          if(flag==0)
    163                          {
    164                              if((w+1)%c7==0)
    165                                {
    166                                  for(int k=0;k<10000000;k++)
    167                                    {
    168                                        String inputx=JOptionPane.showInputDialog(Repeat[w]+"="+"请输入计算结果");
    169                                        if(inputx!=null&&!inputx.equals(""))
    170                                       {
    171                                          d=Double.parseDouble(inputx);
    172                                          break;
    173                                       }     
    174                                    }
    175                                    if(d==f)
    176                                      {
    177                                          System.out.println(Repeat[w]+"="+d+"正确");    
    178                                          m++;
    179                                      }
    180                                      if(d!=f)
    181                                      {
    182                                          System.out.println(Repeat[w]+"="+d+"不正确");
    183                                      }
    184                                }
    185                                else
    186                                {
    187                                    
    188                                    for(int k=0;k<10000000;k++)
    189                                    {
    190                                        String inputx=JOptionPane.showInputDialog(Repeat[w]+"="+"请输入计算结果");
    191                                        if(inputx!=null&&!inputx.equals(""))
    192                                       {
    193                                          d=Double.parseDouble(inputx);
    194                                          break;
    195                                       }     
    196                                    }
    197                                  if(d==f)
    198                                  {
    199                                      System.out.print(Repeat[w]+"="+d+"正确");    
    200                                      m++;
    201                                  }
    202                                  if(d!=f)
    203                                  {
    204                                      System.out.print(Repeat[w]+"="+d+"不正确");
    205                                  }
    206                                }
    207                          }
    208                          if(flag==1)
    209                          {
    210                              c6++;
    211                          }
    212                          
    213                      }
    214                      System.out.println("共"+c6+"道题"+"    "+m+"道题正确");
    215                   }
    216                 if(c==2)
    217                 {
    218                      
    219                     System.out.println("请输入选择:1 、有乘除法 2、无乘除法");
    220                      Scanner input1=new Scanner(System.in) ;
    221                      c1=input1.nextInt();
    222                      System.out.println("请输入数值范围的前域 ");
    223                      Scanner input2=new Scanner(System.in) ;
    224                      c2=input2.nextInt();
    225                      System.out.println("请输入数值范围的后域");
    226                      Scanner input3=new Scanner(System.in) ;
    227                      c3=input3.nextInt();
    228                     /* System.out.println("请输入选择:1、加减有负数 2、加减无负数");
    229                      Scanner input4=new Scanner(System.in) ;
    230                      c4=input4.nextInt();
    231                      System.out.println("请输入选择:1、除法有余数 2、除法无余数");
    232                      Scanner input5=new Scanner(System.in) ;
    233                      c5=input5.nextInt();*/
    234                      System.out.println("请输入出题数量");
    235                      Scanner input6=new Scanner(System.in) ;
    236                      c6=input6.nextInt();
    237                      System.out.println("请输入在一行中输出几列运算式?");
    238                      Scanner input7=new Scanner(System.in) ;
    239                      c7=input7.nextInt();
    240                      System.out.println("请输入选择: 1、有括号 2、无括号");
    241                      Scanner input8=new Scanner(System.in) ;
    242                      c8=input8.nextInt();
    243                     //有无乘除法
    244                      if(c1==1)
    245                      {
    246                          e=rand.nextInt(4);
    247                      }
    248                      if(c1==2)
    249                      {
    250                          e=rand.nextInt(2);
    251                      }
    252                      //数值范围
    253                      a=rand.nextInt(c3)%(c3-c2+1)+c2;
    254                      b=rand.nextInt(c3)%(c3-c2+1)+c2;
    255                      String []Repeat=new String[2*c6];
    256                      if(e==0)
    257                      {
    258                          s="+";
    259                          g=a+b;
    260                      }
    261                      if(e==1)
    262                      {
    263                          s="-";
    264                          g=a-b;
    265                      }
    266                      if(e==2)
    267                      {
    268                          s="*";
    269                          g=a*b;
    270                      }
    271                      if(e==3)
    272                      {
    273                          if(b==0)
    274                          {
    275                              flag=1;
    276                          }
    277                          if(b!=0)
    278                          {
    279                              flag=0;
    280                              s="/";
    281                              g=a/b;
    282                          }
    283                      }
    284                      //出题数量
    285                      for(int w=0;w<c6;w++)
    286                      {
    287                          int p;//0为在原来基础上前面加数,1则是在后面加数
    288                          int ws;//几位数的运算
    289                          ws=rand.nextInt(8);
    290                          Repeat[w]=a+s+b;
    291                          if(c8==1)//有括号
    292                          {
    293                              
    294                              for(int w1=0;w1<ws;w1++)
    295                              {
    296                                  d1=rand.nextInt(c3)%(c3-c2+1)+c2;
    297                                  p=rand.nextInt(2);
    298                                  if(c1==1)
    299                                  {
    300                                      e=rand.nextInt(4);
    301                                  }
    302                                  if(c1==2)
    303                                  {
    304                                      e=rand.nextInt(2);
    305                                  }
    306                                  if(e==0)
    307                                  {
    308                                      s="+";
    309                                      g=d1+g;
    310                                  }
    311                                  if(e==1)
    312                                  {
    313                                      s="-";
    314                                      if(p==0)
    315                                      {
    316                                          g=d1-g;
    317                                      }
    318                                      if(p==1)
    319                                      {
    320                                          g=g-d1;
    321                                      }
    322                                  }
    323                                  if(e==2)
    324                                  {
    325                                      s="*";
    326                                      g=d1*g;
    327                                  }
    328                                  if(e==3)
    329                                  {
    330                                      if(b==0||g==0)
    331                                      {
    332                                          flag=1;
    333                                      }
    334                                      if(b!=0&&g!=0)
    335                                      {
    336                                          flag=0;
    337                                          s="/";
    338                                          if(p==0)
    339                                          {
    340                                              g=d1/g;
    341                                          }
    342                                          if(p==1)
    343                                          {
    344                                              g=g/d1;
    345                                          }
    346                                      }
    347                                  }
    348                              if(p==0)
    349                              {
    350                                   Repeat[w]=d1+s+"("+Repeat[w]+")"; 
    351                              }
    352                              if(p==1)
    353                              {
    354                                  Repeat[w]="("+Repeat[w]+")"+s+d1;         
    355                              }
    356                              }
    357                          }
    358                          if(c8==2)//无括号
    359                          {
    360                              int length=0;
    361                              
    362                              String [][]Repeat1=new String[2*c6][100];
    363                              Repeat1[w][0]=""+a;
    364                              Repeat1[w][1]=s;
    365                              Repeat1[w][2]=""+b;
    366                              for(int w1=0;w1<ws;w1++)
    367                              {
    368                                 
    369                                  d1=rand.nextInt(c3)%(c3-c2+1)+c2;
    370                                  p=rand.nextInt(2);
    371                                  if(c1==1)
    372                                  {
    373                                      e=rand.nextInt(4);
    374                                  }
    375                                  if(c1==2)
    376                                  {
    377                                      e=rand.nextInt(2);
    378                                  }
    379                                  if(e==0)
    380                                  {
    381                                      s="+";
    382                                     
    383                                  }
    384                                  if(e==1)
    385                                  {
    386                                      s="-";
    387                                     
    388                                  }
    389                                  if(e==2)
    390                                  {
    391                                      s="*";
    392                                      
    393                                  }
    394                                  if(e==3)
    395                                  {
    396                                      if(b==0)
    397                                      {
    398                                          flag=1;
    399                                      }
    400                                      if(b!=0)
    401                                      {
    402                                          flag=0;
    403                                          s="/";
    404                                         
    405                                      }
    406                                  }
    407 
    408                              if(p==0)
    409                              {
    410                                  int sl=0;//实际长度
    411                                  Repeat[w]=d1+s+Repeat[w];
    412                                  length=Repeat1[w].length;
    413                                  for(int xx=0;xx<length;xx++)
    414                                  {
    415                                      String ss="";
    416                                      ss=Repeat1[w][xx];
    417                                      if(ss!=null&&!ss.equals(""))
    418                                      {
    419                                          sl++;
    420                                      }
    421                                      else
    422                                      {
    423                                         break;
    424                                      }
    425                                  }
    426                                  
    427                                   for(int l=0;l<sl;l++)
    428                                   {
    429                                       Repeat1[w][l+2]=Repeat1[w][l];
    430                                   }
    431                                   Repeat1[w][0]=""+d1;
    432                                   Repeat1[w][1]=s;
    433                              }
    434                              if(p==1)
    435                              {
    436                                  int sl=0;
    437                                  Repeat[w]=Repeat[w]+s+d1;
    438                                  length=Repeat1[w].length;
    439                                  for(int xx=0;xx<length;xx++)
    440                                  {
    441                                      String ss="";
    442                                      ss=Repeat1[w][xx];
    443                                      if(ss!=null&&!ss.equals(""))
    444                                      {
    445                                          sl++;
    446                                      }
    447                                      else
    448                                      {
    449                                          break;
    450                                      }
    451                                  }
    452                                  Repeat1[w][sl]=s;
    453                                  Repeat1[w][sl+1]=""+d1;
    454                              }
    455                             }
    456                              //计算结果
    457                              int []ns=new int[10];
    458                              int []nf=new int[9];
    459                              int ll=(Repeat1[w].length);
    460                              int sl=0;
    461                              for(int xx=0;xx<ll;xx++)
    462                              {
    463                                  String ss="";
    464                                  ss=Repeat1[w][xx];
    465                                  if(ss!=null&&!ss.equals(""))
    466                                  {
    467                                      sl++;
    468                                  }
    469                                  else
    470                                  {
    471                                      break;
    472                                  }
    473                              }                             
    474                              for(int l1=0;l1<sl;l1++)
    475                              {
    476                                  if(l1%2==0)
    477                                  {
    478                                      ns[l1/2]=Integer.parseInt(Repeat1[w][l1]);
    479                                  }
    480                                  if(l1%2!=0)
    481                                  {
    482                                      
    483                                      nf[l1/2]=Repeat1[w][l1].charAt(0);
    484                                  }
    485                              }
    486                              
    487                              if(c1==1)
    488                              {
    489                                  
    490                              }
    491                              if(c1==2)
    492                              {
    493                                 g=ns[0];
    494                              for(int l2=1;l2<(sl/2+1);l2++)
    495                              {
    496                                  if(nf[l2-1]==43)
    497                                  {
    498                                      g=g+ns[l2];
    499                                  }
    500                                  if(nf[l2-1]==45)
    501                                  {
    502                                      g=g-ns[l2];
    503                                  }
    504                              }
    505                              }
    506                          }
    507                          
    508                            
    509                          
    510                        //判断重复
    511                          int w3=w;
    512                          for(int w2=0;w2<w3;w2++)
    513                          {
    514                              if(Repeat[w].equals(Repeat[w2]))
    515                              {
    516                                  flag =1;
    517                              }
    518                              else
    519                              {flag =0;}
    520                          }
    521                          //打印
    522                          if(flag==1)
    523                          {
    524                              c6++;
    525                          }
    526                          if(flag==0)
    527                          {
    528                              if((w+1)%c7==0)
    529                              {
    530                                  System.out.println(Repeat[w]+"="+g+"  ");
    531                              }
    532                              else
    533                              {
    534                                  System.out.print(Repeat[w]+"="+g+"  ");
    535                              }
    536                          }
    537                      }
    538                 }
    539                 if(c==3)
    540                 {
    541                     break;
    542                 }
    543                 
    544             }
    545     }
    546 
    547 }

    运行结果截图

    编程总结分析

    每次拿到题目,都不能冷静分析思考,这次结对编程,何同学是主力,在讨论的过程中,我发现了自身的很多问题,如思考的不全面

    项目计划总结

    姓名:张一博     日期:2016/3/26

     

    听课

    编写代码

    阅读课本

    准备考试

     讨论设计思想

     查阅资料

    日总计

    周日3.20

     

     

     

     

     

     

     

    周一3.21

    100

     

    33

     

     

     

    133

    周二3.22

     

     

     25

     

     

     

    25

    周三3.23

     

     118

     

     

     55

     40

    213

    周四3.24

     

    109

     

     

     

    20 

    129

    周五3.25

     

    207

     

     

     

     35

    242

    周六3.26

     

     153

     

     

     

     

     153

    周总计

    100

    587

    58

     

     55

     95

    895

    时间记录日志                                     

    学生:张一博                   日期:2016/3/26

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

    日期

    开始时间

    结束时间

    中断时间

    净时间

    活动

    备注

    C

    U

    3/21

    8:00

    9:50

    10

    100

    听课

    下课,休息

     

     

     

    19:05

    19:38

    0

    33

    阅读构建之法

     

     

     

    3/22

    21:44

    22:09

    0

    25

    阅读梦断代码

     

     

     

    3/23

    16:02

    20:30

    55

    213

    讨论设计思想查资料,写程序

    吃饭,休息,聊天

     

     

    3/24

    15:40

    18:04

    15

    129

    编程序,查资料

    休息,玩手机

     

     

    3/25

    16:30

    21:36

    64

    242

    编程序,查资料

    吃饭,休息

     

     

     3/26

     9:09

     11:30

     10

     71

    写代码

     休息聊天

     

     

     

     13:30

     15:00

     8

     82

     优化整理程序

     聊天,休息

     

     

     缺陷记录日志

    姓名:张一博       日期:2016/3/26

    教师:王建民      程序:四则运算3

    日期 编号 引入阶段 排除阶段 修复时间 修复缺陷 缺陷类型
    3/23 1 编码 设计 1min 程序打印方式 20
      描述 程序打印方式不正确
    3/23 2 编码 编译 5min  数组溢出 20
      描述 用于无括号四则运算的的数组溢出
    3/24 3 编码 编译 10min 二维数组实际长度 20
      描述 实际长度不正确
    3/24 4 编码 编译 5min 运算符转换为int 20
      描述 string“+”、“-”转换为int出错
    3/25 5 编码 设计 5min   20
      描述 用户输入“”出错
    3/25 6 编码 设计 5min   20
      描述 无括号四则运算结果输出错误
    3/25 7 编码 编译 5min   20
      描述 ss!=null&&!ss.equals(""),,漏掉!

     附工作照片

  • 相关阅读:
    navicat12破解版
    mysql-5.6.40-winx64的安装,只需解压,个人感觉最容易的方法windows系统
    JavaIO流学习总结-FileReader和FileWriter基本操作练习
    JavaIO流学习总结-CharArrayReader和CharArrayWriter基本操作练习
    JavaIO流学习总结-PipedReader和PipedWriter基本操作练习
    JavaIO流学习总结-BufferedWriter和BufferedReader基本操作练习
    JavaIO流学习总结-StringReader和StringWriter基本操作练习
    JavaIO流学习总结-InputStreamReader和OutputStreamWriter基本操作练习
    JavaIO流学习总结-FilterReader和FilterWriter分析
    JavaIO流学习总结-字节流总结
  • 原文地址:https://www.cnblogs.com/qianxia/p/5322056.html
Copyright © 2020-2023  润新知