题目集1~3的总结性Blog

时间：2021-04-03 23:14:09 阅读：31 评论：0 收藏：0 [点我收藏+]

一、前言

题目集一

知识点考察:对于Java程序的输入输出,简单运算,逻辑推理判断,以及数组的基本操作.题量:题量适中.难度:题目集一嘛,懂得都懂.

题目集二

知识点考察：主要类与对象,以及Java程序的输入输出,字符串与数组的基本处理.题量:题量适中.难度:简单,前两题为简单模拟操作题,后三题主要是逻辑推理判断.

题目集三

知识点考察:类的处理,以及逻辑推理判断.题量:适中难度:中等,前两题没啥好说的,还是简单判断,第三题涉及到新的知识点正则表达式以及思路的考虑和类与类之间的关系与设计.

二、设计与分析

(1)题目集一

7-7 对多个整数进行排序 (16 分)

先从键盘输入一个整数n，n代表需要排序的整数数量，然后再从键盘输入n个整数，对这些数从小到大排序并输出。

输入格式:

先从键盘输入一个整数n，之后回车再从键盘输入n个整数，整数之间用一个或多个空格分隔

输出格式:

按如下示例输出排序后的数据：The sorted numbers are:排序后的n个数，每个输出的整数之后有一个空格作为分隔符

输入样例:

在这里给出一组输入。例如：

10
3 5 2 4 76 89 56 4 3 8

输出样例:

在这里给出相应的输出。例如：

The sorted numbers are:2 3 3 4 4 5 8 56 76 89

这题可以直接用Java中的Arrays.sort()方法,简单快捷.

7-8 判断三角形类型 (20 分)

输入三角形三条边，判断该三角形为什么类型的三角形。

输入格式:

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。

输出格式:

（1）如果输入数据非法，则输出“Wrong Format”；（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

输入样例1:

在这里给出一组输入。例如：

50 50 50.0

输出样例1:

在这里给出相应的输出。例如：

Equilateral triangle

AC代码如下

 1 import java.util.Arrays;
 2 import java.util.Scanner;
 3 public class Main {
 4     public static void main(String [] args) {
 5         Scanner sc=new Scanner(System.in);
 6         double [] a;
 7         int i;
 8         a=new double[3];
 9         for(i=0; i<3; i++) {
10             a[i]=sc.nextDouble();
11             if(a[i]<1||a[i]>200) {
12                 System.out.println("Wrong Format");
13                 return ;
14             }
15         }
16         Arrays.sort(a);
17         if(a[0]+a[1]<=a[2]) {
18             System.out.println("Not a triangle");
19             return ;
20         }
21         if(a[0]==a[2]) {
22             System.out.println("Equilateral triangle");
23             return ;
24         }
25          //相乘精度损失 
26          if(Math.abs(a[2]*a[2]-a[0]*a[0]-a[1]*a[1])<=0.00001&&a[0]==a[1]) {
27             System.out.println("Isosceles right-angled triangle");
28             return ;
29         }
30         if(a[0]==a[1]|| a[1]==a[2]) {
31             System.out.println("Isosceles triangle");
32             return ;
33         }
34          if(a[0]*a[0]+a[1]*a[1]==a[2]*a[2]) {
35             System.out.println("Right-angled triangle");
36             return ;
37         }
38         
39         System.out.println("General triangle");
40     }
41 }

先进行输入数据判断如果不符合输出"Wrong Format",结束程序.

否则开始判断,个人思路先对边进行一遍排序这样可以知道哪两条是短边减少程序判断.之后再依次进行判断输出即可.

(2) 题目集二

7-4 求下一天 (30 分)

输入年月日的值（均为整型数），输出该日期的下一天。其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] .

注意：不许许使用Java中和日期相关的类和方法。

要求：Main类中必须含有如下方法，签名如下：

public static void main(String[] args)；//主方法 
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型 
public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值
public static void nextDate(int year,int month,int day) ; //求输入日期的下一天

输入格式:

在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。

输出格式:

当输入数据非法及输入日期不存在时，输出“Wrong Format”；
当输入日期合法，输出下一天，格式如下：Next date is:年-月-日

输入样例1:

在这里给出一组输入。例如：

2020 3 10

输出样例1:

在这里给出相应的输出。例如：

Next date is:2020-3-11
AC代码

 1 import java.util.*;
 2 import java.util.Scanner;
 3 public class Main {
 4     public static void main(String [] args) {
 5         Scanner sc= new Scanner(System.in);
 6         int year = sc.nextInt();
 7         int month = sc.nextInt();
 8         int day = sc.nextInt();
 9         int days;
10         checkInputValidity(year,month,day);
11           nextDate(year,month,day);  
12     }
13     public static boolean isLeapYear(int year) /*判断是否为闰年*/{
14         if(year % 4 == 0 && year %100 != 0 || year %400 ==0)
15             return true;
16         return false;
17     }
18     public static boolean checkInputValidity(int year,int month,int day)/*判断是否合法*/{
19         if(year<1820||year>2020) {
20             System.out.println("Wrong Format");
21             System.exit(0);
22         }
23         if(month<1||month>12) {
24             System.out.println("Wrong Format");
25             System.exit(0);
26         }
27         if(day<1||day>31) {
28             System.out.println("Wrong Format");
29             System.exit(0);
30         }
31         if(!isLeapYear(year)&&month==2&&day==29) {
32             System.out.println("Wrong Format");
33             System.exit(0);
34         }
35         return true;
36     }
37     public static void nextDate(int year,int month,int day)/*求输入日期的下一天*/
38     {
39     int i=month;
40     int j=day+1;
41     int k=month+1;
42     int z=year+1;
43     if(day<=27){
44     System.out.println("Next date is:"+year+"-"+month+"-"+j);
45         System.exit(0);}
46     if(day==28&&isLeapYear(year)&&month==2){
47     System.out.println("Next date is:"+year+"-"+month+"-"+j);
48         System.exit(0);}
49     if(day==28&&!isLeapYear(year)&&month==2){
50     System.out.println("Next date is:"+year+"-"+k+"-1");
51         System.exit(0);}
52     if(day==29){
53      System.out.println("Next date is:"+year+"-"+month+"-"+j);
54         System.exit(0);}
55     if(day==30){
56              if(i==4||i==6||i==9||i==11){
57                   System.out.println("Next date is:"+year+"-"+k+"-1");
58                  System.exit(0);}
59              else{  
60              System.out.println("Next date is:"+year+"-"+month+"-"+j);
61                  System.exit(0);}
62         }
63         if(day==31&&month!=12){
64             System.out.println("Next date is:"+year+"-"+k+"-1");
65             System.exit(0);}
66         if(month==12&&day==31){
67             System.out.println("Next date is:"+z+"-1"+"-1");
68             System.exit(0);}
69     }
70 }

(2)分析如下:

个人对题目思路:

1.日期小于等于27那就直接加一就好了.

2.日期等于28(1)如果是闰年则直接加一(2)如果不是的话那就输出下一天日期

3.日期等于29天(1)如果是二月且闰年那就直接输出下一个月的一号(2)输出下一天

4.日期等于30(1)该月有三十一天的话直接下一天(2)否则输出下一个月一号

5.日期等于31(1)不是12月直接输出下一个月一号(2)否则输出下一年一月一号

7-5 求前N天 (30 分)

输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时)
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。

输入格式:

在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。

输出格式:

当输入的年、月、日以及n的值非法时，输出“Wrong Format”；

当输入数据合法时，输出“n days ago is:年-月-日”

输入样例1:

在这里给出一组输入。例如：

2018 6 19 8

输出样例1:

在这里给出相应的输出。例如：

8 days ago is:2018-6-11

AC代码

  1 import java.util.*;
  2 import java.util.Scanner;
  3 public class Main {
  4     public static void main(String [] args) {
  5         Scanner sc= new Scanner(System.in);
  6         int year = sc.nextInt();
  7         int month = sc.nextInt();
  8         int day = sc.nextInt();
  9         int n= sc.nextInt();
 10         checkInputValidity(year,month,day,n);
 11         if(n<0){
 12             nextNDate(year,month,day,Math.abs(n));}
 13         else{
 14              beforeNDate(year,month,day,Math.abs(n));}
 15     }
 16       public static boolean isLeapYear(int year) {
 17         if(year % 4 == 0 && year %100 != 0 || year %400 ==0)
 18             return true;
 19         return false;
 20     }
 21       public static boolean checkInputValidity(int year,int month,int day,int n) {
 22         if(year<1820||year>2020) {
 23             System.out.println("Wrong Format");
 24             System.exit(0);
 25         }
 26         if(month<1||month>12) {
 27             System.out.println("Wrong Format");
 28             System.exit(0);
 29         }
 30         if(day<1||day>31) {
 31             System.out.println("Wrong Format");
 32             System.exit(0);
 33         }
 34         if(!isLeapYear(year)&&month==2&&day==29) {
 35             System.out.println("Wrong Format");
 36             System.exit(0);
 37         }
 38           if(n<-10||n>10) {
 39             System.out.println("Wrong Format");
 40             System.exit(0);
 41         }
 42         return true;
 43       }
 44      public static void nextNDate(int year,int month,int day,int n){
 45          int x=n;
 46          for(;n!=0;){
 47              if(day<=27){
 48              day++;
 49              n--;
 50              continue;}
 51     if(day==28&&isLeapYear(year)&&month==2){
 52         day++;
 53         n--;
 54         continue;
 55         }
 56     if(day==28&&!isLeapYear(year)&&month==2){
 57         month++;
 58         day=1;
 59         n--;
 60         continue;
 61           }
 62     if(day==28){
 63          day++;
 64         n--;
 65         continue;
 66     }
 67     if(day==29){
 68           if(isLeapYear(year)&&month==2){
 69               month++;
 70                day=1;
 71                n--;
 72                continue;
 73           }
 74         else{
 75         day++;
 76         n--;
 77         continue;}
 78        }
 79     if(day==30){
 80              if(month==4||month==6||month==9||month==11){
 81                  month++;
 82                  day=1;
 83                   n--;
 84                   continue;
 85                   }
 86              else{
 87                day++;
 88                n--;
 89                continue;
 90             }
 91         }
 92         if(day==31&&month!=12){
 93             month++;
 94             day=1;
 95                n--;
 96                continue;
 97            }
 98         if(month==12&&day==31){
 99             year++;
100               month=1;
101                day=1;
102                n--;
103                continue;
104            }
105      }
106          System.out.println("-"+x+" days ago is:"+year+"-"+month+"-"+day);
107      }
108       public static void beforeNDate(int year,int month,int day,int n){
109           int x=n;
110           for(;n!=0;){
111               if(day>1){
112                   day--;
113                   n--;
114                   continue;
115               }
116               if(day==1){
117                   if(isLeapYear(year)&&month==3){
118                       day=29;
119                       month--;
120                       n--;
121                       continue;
122                     }
123                   if(!isLeapYear(year)&&month==3){
124                       day=28;
125                       month--;
126                       n--;
127                       continue;
128                     }
129                   if(month==2||month==4||month==6||month==8||month==9||month==11){
130                       day=31;
131                       month--;
132                       n--;
133                       continue;
134                   }
135                   if(month==5||month==7||month==10||month==12){
136                        day=30;
137                       month--;
138                       n--;
139                       continue;
140                   }
141                   if(month==1){
142                       year--;
143                       month=12;
144                       day=31;
145                       n--;
146                       continue;
147                   }
148               }
149           }
150           System.out.println(x+" days ago is:"+year+"-"+month+"-"+day);
151       }
152 }

2.分析如下
1.检查数据合法性
2.n<0则用一个for循环一天一天的计算把问题分解成小问题即求多次下一天一次n--直到n为0退出循环输出
            1.日期小于等于27那就直接加一就好了.
            2.日期等于28(1)如果是闰年则直接加一(2)如果不是的话那就输出下一天日期
            3.日期等于29天(1)如果是二月且闰年那就直接输出下一个月的一号(2)输出下一天
            4.日期等于30(1)该月有三十一天的话直接下一天(2)否则输出下一个月一号
            5.日期等于31(1)不是12月直接输出下一个月一号(2)否则输出下一年一月一号

3.n>0还是那个循环
       1.日期大于一天直接减一天
    2.日期等于一的话考虑上一个月就好了
(3)题目集三

7-2 定义日期类 (28 分)

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,

日期合法取值范围为[1,31] 。注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。

要求：Date类结构如下图所示：

技术分享图片

输入格式:

在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。

输出格式:

当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
当输入日期合法，输出下一天，格式如下：Next day is:年-月-日

输入样例1:

在这里给出一组输入。例如：

1912 12 25

输出样例1:

在这里给出相应的输出。例如：

Next day is:1912-12-26
代码类图如下:

AC代码如下:

  1 import java.util.Scanner;
  2 public class Main{
  3   public static void main(String [] args){
  4       Scanner in=new Scanner(System.in);
  5       int year=in.nextInt();
  6     int month=in.nextInt();
  7     int day=in.nextInt();
  8     Date hh=new Date();
  9       hh.Date2(year,month,day);
 10       hh.isLeapYear(year);
 11       if(!hh.checkInputValidity()){
 12           return;}
 13       hh.getNextDay();
 14   }
 15 }
 16 class Date/*日期类*/{
 17     private int year;
 18     private int month;
 19     private int day;
 20 public void Date1()/*构造方法一*/{
 21     this.year=1;
 22     this.month=0;
 23     this.day=0;
 24 }
 25 public void Date2(int year,int month,int day)/*构造方法二*/{
 26     this.year=year;
 27     this.month=month;
 28     this.day=day;
 29 }
 30   public void setYear(int year)/*设置年份*/{
 31   this.year=year;
 32   }
 33   public int getYear(){
 34   return this.year;
 35   }
 36    public void setMonth(int month)/*设置月份*/{
 37       this.month=month;
 38   }
 39   public int getMonth(){
 40       return this.month;
 41   }
 42   public void setDay(int day)/*设置日期*/{
 43       this.day=day;
 44   } 
 45   public int getDay(){
 46       return this.day;
 47   }
 48   public boolean isLeapYear(int year)/*判断是不是闰年*/{
 49       if(year%400==0||year%4==0&&year%100!=0)
 50       return true;
 51       else
 52       return false;
 53   }
 54   public boolean checkInputValidity()/*是否合法*/{
 55        if(this.year<1900||this.year>2000) {
 56             System.out.println("Date Format is Wrong");
 57          return false;
 58         }
 59         if(this.month<1||this.month>12) {
 60             System.out.println("Date Format is Wrong");
 61               return false;
 62         }
 63         if(this.day<1||this.day>31) {
 64             System.out.println("Date Format is Wrong");
 65               return false;
 66         }
 67         if(!isLeapYear(year)&&this.month==2&&this.day==29) {
 68             System.out.println("Date Format is Wrong");
 69               return false;
 70         }
 71         return true;
 72     }
 73     public void getNextDay()/*计算下一天*/{
 74          int i=this.month;
 75     int j=this.day+1;
 76     int k=this.month+1;
 77     int z=this.year+1;
 78     if(this.day<=27){
 79     System.out.println("Next day is:"+this.year+"-"+this.month+"-"+j);}
 80     if(this.day==28&&this.isLeapYear(this.year)&&this.month==2){
 81     System.out.println("Next day is:"+this.year+"-"+this.month+"-"+j);}
 82     if(this.day==28&&!this.isLeapYear(this.year)&&this.month==2){
 83     System.out.println("Next day is:"+this.year+"-"+k+"-1");}
 84     if(this.day==29){
 85         if(this.isLeapYear(this.year)&&this.month==2)
 86              System.out.println("Next day is:"+this.year+"-"+k+"-"+1);
 87         else
 88      System.out.println("Next day is:"+this.year+"-"+this.month+"-"+j);}
 89     if(this.day==30){
 90              if(i==4||i==6||i==9||i==11){
 91                   System.out.println("Next date is:"+this.year+"-"+k+"-1");}
 92              else{
 93              System.out.println("Next day is:"+this.year+"-"+this.month+"-"+j);}
 94         }
 95         if(this.day==31&&this.month!=12){
 96             System.out.println("Next day is:"+year+"-"+k+"-1");}
 97         if(this.month==12&&this.day==31){
 98             System.out.println("Next day is:"+z+"-1"+"-1");}
 99   }
100 }

分析如下:
主要就是类的构造以及设置设为private属性确保类的封装性.设置set方法.获得get方法.
至于题目要求可以说都做第三遍了上面例题有详细分析实在不想重复说了.

7-3 一元多项式求导（类设计） (50 分)

编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。

输入格式:

在一行内输入一个待计算导函数的表达式，以回车符结束。

输出格式:

如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点：结果不需要排序，也不需要化简；

当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
当输出结果第一项系数符号为“+”时，不输出“+”；
当指数符号为“+”时，不输出“+”；
当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。

输出格式见输入输出示例。

输入样例1:

在这里给出一组输入。例如：

-2*     x^-2+  5*x^12-4*x+       12

输出样例1:

在这里给出相应的输出。例如：

4*x^-3+60*x^11-4
程序类图;

个人代码

  1 import java.util.regex.Matcher;
  2 import java.util.regex.Pattern;
  3 import java.util.*;
  4 import java.math.*;
  5 public class Main{
  6 public static void main(String[] args) {
  7      int i,s1,flag=0,s2=0,K,s4=0;
  8      long t;
  9      long [] a=new long[3];
 10       Scanner in =new Scanner(System.in);
 11       String s = in.nextLine();
 12       String b = s.replaceAll(" ","");
 13        if(constant(b)||Wrong(b))
 14            System.exit(0);
 15        Match match = new Match(); 
 16        match.setB(b);
 17        match.setP();
 18        match.setM();
 19        match.setT();
 20        while(match.getM().find()){
 21            Matcher x = match.getT().matcher(match.getM().group());
 22   //System.out.println(m.group());
 23       for(i=1;i<=2;i++)
 24           a[i]=0;
 25         i=1;
 26      while(x.find()){
 27         a[i++] =Long.parseLong(x.group());
 28          }
 29      for(i=1,s1=0;i<=2&&a[i]!=0;i++)
 30      {
 31 //     System.out.println(a[i]);
 32         s1++;
 33      }
 34  //  System.out.println(s1);
 35      if(a[1]==1||a[2]==1){
 36         if(a[1]==1){
 37             if(flag==1&&!match.getM().group().contains("*")){
 38        for(K=0,s4=0;K<match.getM().group().length();K++){
 39           if(match.getM().group().charAt(K)==‘-‘)
 40               s4++;}
 41             if(s4==1)
 42                   System.out.print("-1");
 43             else
 44                  System.out.print("+1");}
 45             if(flag==0&&!match.getM().group().contains("*")){
 46          for(K=0,s4=0;K<match.getM().group().length();K++){
 47           if(match.getM().group().charAt(K)==‘-‘)
 48               s4++;}
 49             if(s4==1)
 50                   System.out.print("-1");
 51             else{
 52                  System.out.print("1");
 53                  flag=1;}
 54              }
 55                     if(flag==1&&match.getM().group().contains("*")){
 56                   t=a[2]-1;
 57                 if((a[1]>0&&a[2]>0)||(a[1]<0&&a[2]<0)){
 58                         System.out.print("+"+Math.abs(a[2])+"*x");
 59                     if(t!=1)
 60                          System.out.print("^"+t);
 61                 }
 62                     else{
 63                          System.out.print("-"+Math.abs(a[2])+"*x");
 64                           if(t!=1)
 65                          System.out.print("^"+t);
 66                     }
 67             }
 68                  if(flag==0&&match.getM().group().contains("*")){
 69                   t=a[2]-1;
 70                 if((a[1]>0&&a[2]>0)||(a[1]<0&&a[2]<0)){
 71                         System.out.print(Math.abs(a[2])+"*x");
 72                         if(t!=1)
 73                          System.out.print("^"+t);}
 74                     else{
 75                          System.out.print("-"+Math.abs(a[2])+"*x");
 76                             if(t!=1)
 77                          System.out.print("^"+t);}
 78                        flag=1;
 79             }
 80          }
 81          else{
 82               if(flag==1){
 83        for(K=0,s4=0;K<match.getM().group().length();K++){
 84           if(match.getM().group().charAt(K)==‘-‘)
 85               s4++;}
 86             if(s4==1)
 87                   System.out.print("-"+Math.abs(a[1]));
 88             else
 89                  System.out.print("+"+a[1]);}
 90             if(flag==0){
 91          for(K=0,s4=0;K<match.getM().group().length();K++){
 92           if(match.getM().group().charAt(K)==‘-‘)
 93               s4++;}
 94             if(s4==1)
 95                   System.out.print("-"+Math.abs(a[1]));
 96             else{
 97                  System.out.print(a[1]);
 98                  flag=1;}
 99              }
100          }
101      }
102      else{
103      if(s1==2){
104          if(flag==1){
105             if((a[1]>0&&a[2]>0)||(a[1]<0&&a[2]<0)){
106                String W=Long.toString(a[1]);
107              String E=Long.toString(a[2]);
108              BigInteger R=new  BigInteger(W);
109                BigInteger U=new  BigInteger(E);
110           System.out.print("+"+R.multiply(U).toString());
111              System.out.print("*x");}
112              else{
113                   String W=Long.toString(a[1]);
114              String E=Long.toString(a[2]);
115              BigInteger R=new  BigInteger(W);
116                BigInteger U=new  BigInteger(E);
117           System.out.print(R.multiply(U).toString());
118              System.out.print("*x");
119                  flag=1;
120              }
121          t=a[2]-1;
122              if(t!=1)
123       System.out.print("^"+t);
124         }
125          if(flag==0){
126                String W=Long.toString(a[1]);
127              String E=Long.toString(a[2]);
128              BigInteger R=new  BigInteger(W);
129                BigInteger U=new  BigInteger(E);
130           System.out.print(R.multiply(U).toString());
131              System.out.print("*x");
132          t=a[2]-1;
133              if(t!=1)
134       System.out.print("^"+t);
135          flag=1;
136      }
137      }
138      if(s1==1)
139      {   
140         if(match.getM().group().contains("*")){
141              if(a[1]>0&&flag==1)
142                 System.out.print("+"+a[1]);
143             if(a[1]>0&&flag==0){
144                System.out.print(a[1]);
145                 flag=1;}
146             if(a[1]<0){
147                  System.out.print(a[1]);
148                 if(flag==0)
149                     flag=1;}
150         }
151        
152    if(match.getM().group().contains("^")){
153       for(K=0,s2=0;K<match.getM().group().length();K++){
154           if(match.getM().group().charAt(K)==‘-‘)
155               s2++;
156       }
157      // System.out.println(s2);
158        if(s2==2||s2==0){
159           if(flag==1){
160                t=a[1]-1;
161               if(s2==2&&a[1]==-1){
162                System.out.print("+x^"+t);
163               }
164               if(t!=1&&a[1]!=-1)
165                System.out.print("+"+Math.abs(a[1])+"*x^"+t);
166               if(t==1&&a[1]!=-1)
167                   System.out.print("+"+Math.abs(a[1])+"*x");
168            }
169            if(flag==0){
170                 t=a[1]-1;
171                 if(s2==2&&a[1]==-1){
172                System.out.print("x^"+t);
173                     flag=1;
174               }
175                if(t!=1&&a[1]!=-1)
176                System.out.print(Math.abs(a[1])+"*x^"+t);
177                if(t==1&&a[1]!=-1)
178                System.out.print(Math.abs(a[1])+"*x");
179                flag=1;
180            }
181        }
182        if(s2==1){
183            if(flag==1){
184                t=a[1]-1;
185                if(t!=1&&a[1]!=-1)
186                System.out.print("-"+Math.abs(a[1])+"*x^"+t);
187                else if(t!=1&&a[1]==-1)
188                    System.out.print("-x^"+t);
189                 else
190                System.out.print("-"+Math.abs(a[1])+"*x");
191            }
192            if(flag==0){
193                 t=a[1]-1;
194                if(t!=1&&a[1]!=-1)
195                System.out.print("-"+Math.abs(a[1])+"*x^"+t);
196                else if(t!=1&&a[1]==-1)
197                    System.out.print("-x^"+t);
198                 else
199                System.out.print("-"+Math.abs(a[1])+"*x");
200                flag=1;
201            }
202        }
203    }
204  }
205      if(s1==0)
206      {
207          if(flag==1){
208              if(match.getM().group().contains("-"))
209              System.out.print("-1");
210              else
211                   System.out.print("+1");
212          }
213         if(flag==0){
214             if(match.getM().group().contains("-"))
215              System.out.print("-1");
216              else 
217                   System.out.print("1");
218             flag=1;
219         }
220      }
221      }
222     }      
223    }
224 
225 public static boolean constant(String b) {
226       boolean flag = Pattern.matches("\\d{1,}|-\\d{1,}|\\+\\d{1,}",b);
227       if(flag){
228           System.out.println("0");
229       }
230       return flag;
231 }
232 
233 public static boolean Wrong(String b) {
234     long j;
235        Pattern u = Pattern.compile("\\d{1,}|-\\d{1,}");
236        Matcher o = u.matcher(b);
237        while(o.find()) {
238            j=Long.parseLong(o.group());
239            if(j == 0) {
240                System.out.println("Wrong Format");
241                 return true;
242              }
243           }
244        return false;
245   }
246 
247 }
248 
249 class Match{
250     private String b;
251     private Pattern p ;
252     private Matcher m ;
253     private Pattern T;
254     public String getB() {
255         return b;
256     }
257     public void setB(String b) {
258         this.b = b;
259     }
260     public Pattern getP() {
261         return p;
262     }
263     public void setP() {
264         this.p =  Pattern.compile("\\+\\d{1,}\\*x\\^\\+\\d{1,}|\\d{1}\\*x\\^\\+\\d{1,}|-\\d{1,}\\*x\\^\\+\\d{1,}|\\+x\\^\\+\\d{1,}|x\\^\\+\\d{1,}|-x\\^\\+\\d{1,}|\\d{1,}\\*x\\^\\d{1,}|\\+\\d{1,}\\*x\\^\\d{1,}|-\\d{1,}\\*x\\^\\d{1,}|\\d{1,}\\*x\\^-\\d{1,}|\\+\\d{1,}\\*x\\^-\\d{1,}|-\\d{1,}\\*x\\^-\\d{1,}|x\\^\\d{1,}|x\\^-\\d{1,}|-x\\^\\d{1,}|\\+x\\^\\d{1,}|\\+x\\^-\\d{1,}|-x\\^-\\d{1,}|\\+\\d{1,}\\*x|-\\d{1,}\\*x|\\d{1,}\\*x|\\+\\d{1,}|-\\d{1,}|\\d{1,}|x|\\+x|-x");;
265     }
266     public Matcher getM() {
267         return m;
268     }
269     public void setM() {
270         this.m = this.p.matcher(this.b);
271     }
272     public Pattern getT() {
273         return T;
274     }
275     public void setT() {
276         this.T = Pattern.compile("\\d{1,}|-\\d{1,}|\\+\\d{1,}"); ;
277     }
278   }  
279


三.采坑心得
数组排序Arrays.sort(str)加入java.util.Arrays;
实型数与实型数相乘注意会有精度损失故计算时Math.abs(a[2]*a[2]-a[0]*a[0]-a[1]*a[1])<=0.00001才行.
返回值为String的方法有时需要return " ";不然Main.java:68: error: missing return statement } ^ 1 error.
对于年份日期考虑闰年二月以及月份进位以及年份的进位.对于类的引用需要先用构造方法创建一个类.
private类型其他函数不能够直接获得修改需要通过创建的类来进行操作.
多项式提取注意符合以及该一项是否在开头也要考虑计算
四.改进建议
题目集一:都是简单题要注意的是代码规范以及细节的逻辑考虑
题目集二:逻辑推理要求更高跟需要细致的思考分类,代码规范仍要改进
题目集三:对于类的设计不够清晰有序,应当做到单一职责原则,以及耦合性需要注意,还有代码规范问题.
五.总结与分析
通过学习java以及对于三次题目集的练习,我逐渐开始了解java这门语言,老师目前出的题目绝大部分是基础逻辑题,我们应当多编程
多做题提高自己的逻辑能力,在这个过程中我学到了一些最基础的语法知识,数组字符串以及Arrays<int>list的一些操作,
能通过java编程解决一些简单小问题.当然了这也仅仅是学习java的开始而已,自己仍需努力学习.
老师上课挺幽默形象的,比较易懂,重要的也讲的比较细,感觉其它也没什么改进的(毕竟老师教了这么久了,保持就OK.

题目集1~3的总结性Blog

原文：https://www.cnblogs.com/hh228/p/14614521.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)