题目集1~3Blog

本文主要是介绍题目集1~3Blog，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

　一·前言　

　　 习题集一的前言部分：

Java pta 习题集第一的题目相对简单，习题集一共有8个编程题，考察我们对于Java输入输出，排序及基本Java语法知识的掌握能力，关于java定义变量与C语言有很多相通的东西，pta的题目集一就很好的实现了，让我们从C语言到Java语言的过度，有些只是表达方式的不同，但语法基本相通，通过这次的习题集让我们对Java 有了一个入门的概念，习题集中的 if 以及else if的嵌套，与C语言的语法基本上相通的，总结，习题集一是我们对从c语言语法向Java语法的一个转变，考察的相对简单，题目也相对简单，更多的是让我们了解Java的一些基本的语法。

习题集二的前言部分：

　　　习题集二的难度相对于习题集一有了较大的改变，引入了字符串处理String.用for循环对字符串的遍历处理，习题集二的第一题，IP地址的转换，考察了我们对二进制的处理怎样应用到字符串上，以及Java中的数学函数，Math.pow的使用，相对于习题集一的难度有所提升，习题集二的第二题考察了Java数组的知识，也考察了我们在C语言中学习到的排序算法，选择排序，将两个排序后的数组合并成一个新的数组，习题集二的第三题第一次引入Java类的概念，Java类的单一职责，要对类实现的功能进行封装，从而进而判断第几年第几天是星期几，这里比较难过的一个知识点是闰年的情况需要另行判断，习题集二的第四题也是对Java面向对象的类的集体运用的一个题，这两个题都是对于类的考察，让我们对于类有了一个很好的理解，习题集二的第五题是这次题目最难和测试点最多的题，在通过第五题的测试点时花了很多时间。

　　 习题集三的前言部分：

Java习题集三，总共有三道编程题，相对于第一第二题目集来说，习题集三的题目难度有所提升，习题集三的得分并没有前两次的得分高，是老师发布的较难的一个题目。主要考察了我们对于类的设计以及对于字符串的处理，本次作业题目较难，我也只得到了分，第三题用到的正则表达式，我也没有完全的理解，在这个题目三中，第一题的定义账户类，和第二题的日期类，让我们对类的概念有了很好的认识，类的封装性以及单一职责性，在这两道题目中得到了很好的体现，这两道题由于前面做过有一些基础，做起来也不难，但第三题用到的正则表达式则是本次题目集中最难的一个，第三题的得分情况并没有达到预期的效果，只勉强得到了65分，题目集三的题目较难。

　二·设计与分析

　　　7-8

 1 import java.util.Scanner;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         Scanner x=new Scanner(System.in);
 6         double a,b,c,temp;
 7         a=x.nextFloat();b=x.nextFloat();c=x.nextFloat();
 8         if(a>b){
 9             temp=a;a=b;b=temp;
10         }
11         if(a>c){
12             temp=a;a=c;c=temp;
13         }
14         if(b>c){
15             temp=b;b=c;c=temp;
16         }
17         if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200){
18             if(a+b>c){
19                 if(a==b&&b==c)
20                     System.out.println("Equilateral triangle");
21                 else if(a*a+b*b-c*c<0.000001&&a==b)
22                     System.out.println("Isosceles right-angled triangle");
23                 else if((a==b&&a!=c)||(a==c&&a!=b)||(b==c&&b!=a))
24                     System.out.println("Isosceles triangle");
25                 else if(a*a+b*b-c*c<0.000001)
26                     System.out.println("Right-angled triangle");
27                 else
28                     System.out.println("General triangle");
29             }
30             else
31                 System.out.println("Not a triangle");
32         }
33         else
34             System.out.println("Wrong Format");
35     }
36 }

这一题在做的时候，有一些测试点总是出现问题：

原因有如下：

所有三角形是否考虑进去
有一些三角形是包含一些三角形，else if 的先后顺序，可以大大减少判断的次数
在判断直角三角型的精度问题，怎样准确的判断一个三角形是不是直角三角形也涉及到了一个测试点能否过去，这点当时并没有注意到。

7-4 求下一天

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

 1 import java.util.Scanner;
 2 class Main {
 3     //主函数
 4     public static void main(String[] args) {
 5         Scanner x = new Scanner(System.in);
 6         int year = x.nextInt();
 7         int month = x.nextInt();
 8         int day = x.nextInt();
 9         nextDate(year,month,day);
10     }
11     //判断year是否为闰年，返回boolean类型
12     public static boolean isLeapYear(int year) {
13         boolean isLeapYear;
14         isLeapYear = (year % 4 == 0 && year % 100 !=0 )||year % 400 == 0;
15         return isLeapYear;
16     }
17     //判断输入日期是否合法，返回布尔值
18     public static boolean checkInputValidity(int year,int month,int day) {
19         boolean checkInputValidity;
20         int[] a=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
21         if(!isLeapYear(year))
22             a[2] = 28;
23         checkInputValidity = (year>=1820&&year<=2020&&month>0&&month<=12&&day<=a[month]&&day>0);
24         return checkInputValidity;
25     }
26     //求输入日期的下一天
27     public static void nextDate(int year,int month,int day) {
28         int[] a=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
29         int d=0,m=0;
30         if(!isLeapYear(year))//如果不是闰年
31             a[2] = 28;
32         if(checkInputValidity(year,month,day)) {//如果输入的数字合法
33             if(month==12) {//如果是12月
34                 if(day==a[month]) {//如果是12月的最后一天
35                     year = year+1;
36                     m = 1;
37                     d=1;
38                 }
39                 else{//如果不是12月的最后一天
40                     m=month;
41                     d =day +1;
42                 }
43             }
44             else {//如果不是12月
45                 if(day==a[month]) {//如果是该月的最后一天
46                     m = month + 1;
47                     d = 1;
48                 }
49                 else{//如果不是该月的最后一天
50                     m=month;
51                     d = day+1;
52                 }
53             }
54             System.out.println("Next date is:"+year+"-"+m+"-"+d);
55         }
56         else//如果输入的数字非法
57             System.out.println("Wrong Format");
58     }
59 }

这个题我一共设计了两个类，

1 public class checkInputValidity

这个类是用来检测输入的天数是不是合法的，然后返回同一个Boolean 值，若不合法则输出 Wrong Format。

第二个类

2 public class nextDate

这个类是用来求下一天的

这个题进一步强化了我对于类的理解，不同的类有不同的功能，将功能封装在类里，主函数的代码能很好的简化。

7-5 求前N天

输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。

 1 import java.util.Scanner;
 2 class Main {
 3     public static void main(String[] args) {
 4         Scanner input = new Scanner(System.in);
 5         int y, m, d, n;
 6 
 7         y = input.nextInt();
 8         m = input.nextInt();
 9         d = input.nextInt();
10         n = input.nextInt();
11 
12         if(checkInputValidity(y,m,d)){
13             nextDate(y,m,d,n);
14         }else
15             System.out.println("Wrong Format");
16     }
17         public static boolean isLeapYear ( int year){
18             boolean ret = false;
19             if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
20                 ret = true;
21             }
22             return ret;
23         }
24     public static boolean checkInputValidity(int year,int month,int day){
25         boolean ret=false;
26         int[] mm={31,28,31,30,31,30,31,31,30,31,30,31};
27         if (isLeapYear(year))mm[1]=29;
28         if ((year>=1820&&year<=2020)&&(month>=1&&month<=12)&&(day>=1&&day<=mm[month-1])){//此处的month-1用来判断不同年份的不同月份的数据是否合法
29             ret=true;
30         }
31         return ret;
32     }
33 
34 
35         public static void nextDate ( int year, int month, int day, int n){
36             int[] mm = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
37             if (isLeapYear(year)) mm[2] = 29;
38             day -= n;
39             if (n > 0) {
40                 while (day <= 0) {
41 
42                     month--;
43                     if (month == 0) {
44                         month += 12;
45                         year--;
46                     }
47                     day += mm[month];
48                 }
49             } else if (n < 0) {
50                 while (day > mm[month]) {
51                     day -= mm[month];
52                     month++;
53                     if (month == 13) {
54                         month -= 12;
55                         year++;
56                     }
57                 }
58             }
59             System.out.printf("%d days ago is:%d-%d-%d\n", n, year, month, day);
60 
61         }
62 
63 }

这个题设计了两个类，一个类用来判断输入的年份，天数是不是合法，求下一次天数的时候，需要导入四个参数，年份，月份，天数，需要加减的天数，在加入的天数超过这个月所在的天数时，月份需要加一，当月份加入超过12时，需要进行年份加一，这个题需要注意的是年份的操作,闰年的二月月份和平年的月份是不同的。

7-2 定义日期类

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

  1 import java.util.Scanner;
  2 import java.text.DecimalFormat;
  3 public class Main {
  4 
  5     public static void main(String[] args) {
  6         Scanner input = new Scanner(System.in);
  7         int year = input.nextInt();
  8         int month = input.nextInt();
  9         int day = input.nextInt();
 10         Account account = new Account(year, month, day);
 11 
 12         if (account.checkinoutValidity()) {
 13             DecimalFormat df = new DecimalFormat("0");
 14 
 15             account.getNextDate();
 16             System.out.println("Next day is:" + account.getYear() + "-" + account.getMonth() + "-" + df.format(account.getDay()));
 17         }
 18 
 19     }
 20 }
 21  class Account {
 22 
 23      private int year = 0;
 24       private int month = 0 ;
 25       private int day = 0;
 26       private int panduan = 0;
 27       public  boolean checkinoutValidity() {
 28                    if(month>0&&month<=12){
 29 
 30                             if(isLeapYear(year))
 31                                 {
 32                                   if(day<=month1[month]&&day>0)
 33                                       panduan=1;
 34                                 }
 35                             else
 36                             {
 37                                   if(day<=month2[month]&&day>0)
 38                                       panduan=1;
 39 
 40                                 }
 41                        }
 42 
 43 
 44                       if(year<1900||year>2000||month<1||month>12||day<1||day>31||panduan==0) {
 45                               System.out.println("Date Format is Wrong");
 46                               return false;
 47                           }
 48                       return true;
 49 
 50               }
 51       public static boolean isLeapYear(int year){
 52                   if((year%4==0&&year%100!=0)||year%400==0) {
 53                           return true;
 54                       }
 55                   else
 56                       return false;
 57               }
 58        int[] month2=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
 59        int[] month1=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
 60 
 61               public Account(int a ,int b,int c) {
 62                   this.year = a;
 63                   this.month = b;
 64                   this.day = c;
 65               }
 66       public int getYear() {
 67                   return year;
 68               }
 69       public void setYear(int year) {
 70                   this.year = year;
 71               }
 72       public int getMonth() {
 73                   return month;
 74               }
 75       public void setMonth(int month) {
 76                   this.month = month;
 77               }
 78       public double getDay() {
 79                   return day;
 80               }
 81       public void setDay(int day) {
 82                   this.day = day;
 83               }
 84       public void getNextDate() {
 85                   if(isLeapYear(this.year)==true ) {
 86                           this.day+=1;
 87                           if(day>month1[month]) {
 88                                   this.day=this.day-month1[month];
 89                                   this.month+=1;
 90                                   if(this.month>12) {
 91                                           this.month -=12;
 92                                           this.year+=1;
 93                                       }
 94                               }
 95                       }
 96                   else {
 97                           this.day+=1;
 98                           if(day>month2[month]) {
 99                                   this.day=this.day-month2[month];
100                                   this.month+=1;
101                                   if(this.month>12) {
102                                           this.month -=12;
103                                           this.year+=1;
104                                       }
105                               }
106 
107                       }
108               }
109 
110          }

7-3 一元多项式求导（类设计）

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

import java.util.Scanner;
import java.text.DecimalFormat;
public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        char zm[]= new char[30];
                 String string=input.nextLine();
                 String th = string.replaceAll("[ ]", "");
                 Account account = new Account(th);
                 int zm1[] = new int[30];
                 String PowerFunction = "((([-+]?([1-9][0-9]*)?(\\*x(\\^[+-]?([1-9][0-9]*))?)))*"; //幂函数正则
                 String C = "(([1-9][0-9]*|[-+]([1-9][0-9]*)))*"; //常数正则
                 String Term = ""; //
             if (th.matches("^(([-+]([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]*))?)))+$"))
                 {
                         System.out.println("0");
                     }
                 else {
                     System.out.println("Wrong Format");
             }
             }
         }
class Account{
    private String s;
    public Account(String zf){
        this.s = zf;
    }
    
}

正则表达式没有完全掌握；

有关将每一项的系数与指数提取出来的算法没有掌握

怎样在字符串处理的同时匹配，幂函数的正则表达式再进行运算没有实现

三.踩坑心得

学习首先要做的就是静下来，这次题目集三的第三题，一定程度起了启示作用，我们要想学号Java，只混日子是不行的，还需要钻研进去，不断的提高自己的能力，要以击败困难为乐。

四.改进建议

暂无，可能个人原因，编程能力比较差，无法发现所出现的问题，目前还处于一个蹒跚学步的状态，还望持续地跟住老师的步伐，不要掉队，另外抓紧抽出空闲时间，提前进行后续相关知识点的学习，

感觉课上老师讲理论知识的时间越来越少了，都是直接实践了，为了避免再出现大眼瞪小眼的情况，多多加强敲代码的质量。

五.总结

面向对象程序设计的概念基本形成，以前我根本不知道什么是面向对象程序设计，直觉的和C语言应该是一样的，但是现在我发现Java语言很灵活，有C语言没有的东西，这些东西用起来都非常的方便

学习态度也发生了转变，靠混日子学好Java是不可能的，不能有惧怕困难的心理，要迎难而上。提高自己的编程思维，多练习老师讲的重要题目，在今后的日子里不断提高自己。

这篇关于题目集1~3Blog的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

题目集1~3Blog

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯