关于三次pta习题总结

前言

前三次作业内容由浅入深，先是对对程序的输入输出、选择还有字符串进行了考察，而后考察了类与对象、还有正则表达式的使用。由于第一次作业比较简单，因此相比后两次数量较多，但是难度较低，后面题目集的难度依次递增，题量依次递减。

1.初学java的体会

刚开始写题目集1的时候，对于java的语法没有一点了解，虽然现在看来非常简单但是对当时的我来说还是有些挑战的，例如，实现输入输出要用到Scanner，但是Scanner是如何工作的呢？一点都不知道。根据C语言的语法，输出hello word只需要printf("hello word");因此我们可以暂且不管Scanner是否是如何工作的，照葫芦画瓢，将Scanner.out.print类比C语言中的printf;输出hello word只需Scanner.out.print("hello word"); 

之后学习java，将java中的语法与类比C语言中的语法。刚开始非常不适应Java的语法，在编写程序的时候总是下意识的写成C语言，但是写完这些题目，开始逐渐适应java语言。

2.三次作业遇到的问题

题目集1比较简单，几乎没有遇到什么问题，就是对java的语法很不了解，几乎都是将C语言中的语法套用在这里；因此在编码时总是不经意写成C语言。而第二次题目集相对较难，考察了类与对象；刚开始了解类的时候，很容易联想到C语言中的结构体，类里面多加了一个函数（中的方法）；第三次题目集考到正则表达式，我在这里第三题卡了很久，因为写出来的正则表达式总是或多或少有些不符合题意，离提交的时间越来越近，于是没有在继续卡在这里接着去完成下面的内容。更令我烦恼的是，我写了好久的代码突然发现完全是错的，思路完全错误。这个时候是感到很颓废的，看着同学都差不多写好了，而我在这里卡了这么久，本来打算就这样的，及格就行了。之后的几天里我没有碰过一下第三题，但最后我还是继续写了下去，因为我很不服气，凭什么我就会写错，别人就能写好。于是就又开始学呀，写呀......虽然最后成绩也不高，但是我似乎知道java该怎么学了，这个过程却是很难过，但是当你千辛万苦写出的代码通过了测试点，哪怕是一个测试点，都会感到很满足，有些成就在里面。

2.设计与分析

接下来就进入正题了，分别对题目集1的7-8，题目集2的7-4,7-5以及题目集3的7-2,7-3进行解释分析

7-8 判断三角形类型

输入格式:

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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”。

import java.util.Scanner;
public class Text178 {
    public static void main(String[] args){
        Scanner input = new Scanner (System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        double c = input.nextDouble();
        if(a<1||a>200||b<1||b>200||c<1||c>200)
            System.out.println("Wrong Format");
        else if(a+b<=c||a+c<=b||b+c<=a||a-b>=c||a-c>=b||b-c>=a||b-a>=c||c-a>=b||c-b>=a)
            System.out.println("Not a triangle");
        else if(a==b||b==c||a==c){
            if(a==b&&a==c)
                System.out.println("Equilateral triangle");
        else if(a*a+b*b-c*c < 0.0000001||a*a+c*c-b*b < 0.0000001||b*b+c*c-a*a < 0.0000001)
                System.out.println("Isosceles right-angled triangle");
        else if(a==b||a==c||b==c)
                System.out.println("Isosceles triangle");
        }
        else if(a*a+b*b==c*c||b*b+c*c==a*a||a*a+c*c==b*b)
            System.out.println("Right-angled triangle");
        else
            System.out.println("General triangle");
        
    }
}

在判断直角时，有一点要注意

a*a+b*b == c*c//第15行不能这么写

类图

只有一个类

 

复杂度

7-4 求下一天

输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[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) ; //求输入日期的下一天

 

输入格式:

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

输出格式:

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

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        int y=input.nextInt();
        int m=input.nextInt();
        int d=input.nextInt();
        if(checkInputValidity(y,m,d)){
            nextDate(y,m,d);
        }
        else{
            System.out.print("Wrong Format");
        }
    }

public static boolean isLeapYear(int year) {
    if(year%4==0&&year%100!=0||year%400==0){
        return true;
    }
    else{
        return false;
    }
}
public static boolean checkInputValidity(int year,int month,int day){
    if(year>=1820&&year<=2020&&month>=1&&month<=12&&day>=1&&day<=31){
        if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
            return true;
        }
        else if(month==2){
            if(isLeapYear(year)){
                if(day==31||day==30){
                    return false;
                }
                else{
                    return true;
                }
            }
            else{
                if(day==31||day==30||day==29){
                    return false;
                }
                else{
                    return true;
                }
            }
        }
        else{
            if(day==31){
                return false;
            }
            else{
                return true;
            }
        }
    }
    else{
        return false;
    }
}
public static void nextDate(int year,int month,int day){
    day++;
    if(checkInputValidity(year,month,day)){
        System.out.print("Next date is:"+year+"-"+month+"-"+day);
    }
    else{
        day=1;
        if(month==12){
            month=1;
            year++;
        }
        else{
            month++;
        }
        System.out.print("Next date is:"+year+"-"+month+"-"+day);
    }
}
}

 

这里要注意的是在求下一天的时候也要进行合法判断，在快要完成题目的时候一定要保持应有的冷静

下面是类图

 

复杂度

 

7-5 求前N天 (30 分)

 

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

输入格式:

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

输出格式:

1. 当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
2. 当输入数据合法时，输出“n days ago is:年-月-日”

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        int y=input.nextInt();
        int m=input.nextInt();
        int d=input.nextInt();
        int n=input.nextInt();
        if(checkInputValidity(y,m,d,n)){
            nextNDate(y,m,d,n);
        }
        else{
            System.out.print("Wrong Format");
        }
    }

public static boolean isLeapYear(int year) {
    if(year%4==0&&year%100!=0||year%400==0){
        return true;
    }
    else{
        return false;
    }
}
public static boolean checkInputValidity(int year,int month,int day,int n){
    if(year>=1820&&year<=2020&&month>=1&&month<=12&&day>=1&&day<=31&&n>=-10&&n<=10){
        if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
            return true;
        }
        else if(month==2){
            if(isLeapYear(year)){
                if(day==31||day==30){
                    return false;
                }
                else{
                    return true;
                }
            }
            else{
                if(day==31||day==30||day==29){
                    return false;
                }
                else{
                    return true;
                }
            }
        }
        else{
            if(day==31){
                return false;
            }
            else{
                return true;
            }
        }
    }
    else{
        return false;
    }
}
public static void nextNDate(int year,int month,int day,int n){
    if(checkInputValidity(year,month,day-n,n)){//n等于0时；
        System.out.print(n+" days ago is:"+year+"-"+month+"-"+(day-n));
    }
    else{
        if(n>0){
            if(month==1){
                year-=1;
                month=12;
                day=31+(day-n);
            }
            else if(month==3){
                if(isLeapYear(year)){
                    month=2;
                    day=29+(day-n);
                }
                else{
                    month=2;
                    day=28+(day-n);
                }
            }
            else if(month==2||month==4||month==6||month==8||month==9||month==11){
                month-=1;
                day=31+(day-n);
            }
            else{
                month-=1;
                day=30+(day-n);
            }
        }
        else if(n<0){
            if(month==12){
                year+=1;
                month=1;
                day=day-n-31;
            }
            else if(month==2){
                month+=1;
                if(isLeapYear(year)){
                    day=(day-n)-29;
                }
                else{
                    day=(day-n)-28;
                }
            }
            else if(month==1||month==3||month==5||month==7||month==8||month==10){
                month+=1;
                day=day-n-31;
            }
            else{
                month+=1;
                day=day-n-30;
            }
        }
        System.out.print(n+" days ago is:"+year+"-"+month+"-"+day);
    }
}
}

 

 类图

 

 复杂度

公告

题目集3，难度有所提升，期限为10天，建议提早做作业

 

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

 

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。

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

输入格式:

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

输出格式:

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

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        int y=input.nextInt();
        int m=input.nextInt();
        int d=input.nextInt();
        Date date = new Date(y,m,d);
        if(date.checkInputValidity()){
            date.nextDate();
        }
        else{
            System.out.print("Date Format is Wrong");
        }
    }

}
class Date{
    private int year;
    private int month;
    private int day;
    public Date() {
    }
    public Date(int year,int month,int day) {
        this.month = month;
        this.day = day;
        this.year = year;
    }
    public boolean checkInputValidity(){
        if(year>=1900&&year<=2000&&month>=1&&month<=12&&day>=1&&day<=31){
            if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
                return true;
            }
            else if(month==2){
                if(isLeapYear()){
                    if(day==31||day==30){
                        return false;
                    }
                    else{
                        return true;
                    }
                }
                else{
                    if(day==31||day==30||day==29){
                        return false;
                    }
                    else{
                        return true;
                    }
                }
            }
            else{
                if(day==31){
                    return false;
                }
                else{
                    return true;
                }
            }
        }
        else{
            return false;
        }
    }
    //判断是否合法
    public void nextDate(){
        day++;
        if(checkInputValidity()){
            System.out.print("Next day is:"+year+"-"+month+"-"+day);
        }
        else{
            day=1;
            if(month==12){
                month=1;
                year++;
            }
            else{
                month++;
            }
            System.out.print("Next day is:"+year+"-"+month+"-"+day);
        }
    }
    public boolean isLeapYear() {
        if(year%4==0&&year%100!=0||year%400==0){
            return true;
        }
        else{
            return false;
        }
    }
}

类图

复杂度

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

 

编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。 OO作业3-3题目说明.pdf

输入格式:

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

输出格式:

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

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

  import java.util.*;
  import java.util.regex.*;
  import java.util.ArrayList;
  import java.util.List;
  
  public class Main {
      public static void main(String[] args) {
          String regex = "^(([-+]([1-9][0-9]*)(\\*x(\\^[+-]?([1-9][0-9]*))?))|(([1-9][0-9]*)\\*(x(\\^[+-]?([1-9][0-9]*))?))|([-+](x(\\^[+-]?([1-9][0-9]*))?))|([-+]([1-9][0-9]*))|(([1-9][0-9]*))|((x(\\^[+-]?([1-9][0-9]*))?)))+$";
          String regex2 = "-?([1-9][0-9]*)\\*x(\\^[+-]?([1-9][0-9]*))?";
          String regex1 = "(\\*x\\^)|(\\*x)";
          String regex3 = "-?[1-9][0-9]*";
          Scanner in = new Scanner(System.in);
          String s = in.nextLine();
          s =s.replace(" ","");
          ArrayList<String> list = new ArrayList<>();
          ArrayList<String> list1 = new ArrayList<>();
          if(s.matches(regex3)) {
              System.out.print(0);
          }
          if(s.matches(regex)) {
              Pattern pattern = Pattern.compile(regex2);
              Matcher matcher = pattern.matcher(s);
              while(matcher.find()) {
                  list.add(matcher.group(0));
              }
              int sum = 0;
              int x = 0,y = 0;
              for(int i = 0;i  < list.size();i++) {
                  if(i == 1) {
                      String[] stt= list.get(i).split("(\\*x\\^)|(\\*x)");
                      if(stt.length == 1) {
                          sum += Integer.parseInt(stt[0]);
                      }else {
                          x = Integer.parseInt(stt[0]);
                          y = Integer.parseInt(stt[1]);
                          x *= y;
                          y --;
                          if(y == 1) {
                              System.out.print("+" + x + "*x^" + y);
                          }else {
                              System.out.print("+" + x + "*x^" +y);
                          }
                      }
                  }else {
                      String[] stt= list.get(i).split("(\\*x\\^)|(\\*x)");
                      if(stt.length == 1) {
                          sum += Integer.parseInt(stt[0]);
                      }else {
                          x = Integer.parseInt(stt[0]);
                          y = Integer.parseInt(stt[1]);
                          x *= y;
                          y --;
                          if(y == 1) {
                              System.out.print(x + "*x^" + y);
                          }else {
                              System.out.print(x + "*x^" +y);
                          }
                      }
                  }
                  if(sum < 0) {
                      System.out.print(sum);
                  }
                  else if(sum > 0) {
                      System.out.print(sum);
                  }
              }
          }else {
              System.out.print("Wrong Format");
          }
          
      } 
  }

 

 类图

 

复杂度

 3.改进意见

每次写题目的时候，由于初学java，对于语法很不熟练，而且每次都涉及新的语法。我觉得应该里面加入提示，关于该题所涉及的语法。这样可以我们就可以有目的性的学习，更有效率。

4.总结

这三次题目集让开始慢慢接触java，开始掌握java语法，让我学会了如何在网上找学习资料。

老师的教学方法很独特，这是我从未见过的，但是也是最有效的方法，鞭策自己学习java。

作业的难度和量刚刚好。

实验不是很有目的性，实验里的题目可以放到题目集里，只要规定交实验报告就行，这样将课后习题和实验分开多此一举。

课下慕课感觉也不用强制性，慕课的根本目的是让同学们学好这门课程，这个最终结果就好了，因为大家可以将慕课作为学习资料，没必要强制观看。