南昌航空大学-软件学院-22206104-段清如-JAVA第一次Blog作业
南昌航空大学-软件学院-22206104-段清如-JAVA第一次Blog作业
前言：
这个学期才开始接触java，到现在一个多月的时间，已经差不多可以写出一些基本的简单的程序了。对比上个学期学习的C语言，我认为java更加方便，方法更多，函数更多，但是时间效率上略逊一筹。在这一个月的java学习过程中，刚开始起步很困难，总是想不出来java应该怎么写，用之前写C语言的思路来写java，虽然大相径庭，但是还是没有领悟到“面向对象”的真谛。现在我已经略有领悟，期待未来可以熟练掌握java的日子！
由于之前没有接触过java，这几次pta作业一直都在摸爬滚打，在一次次试错中前进。从第一次的提交了158次到最后一次的提交12次，虽然只有第二次拿到了满分，但是确实有对java有一个更深刻的理解。第一次99分，第二次100分，第三次78分。在我看来，我还是欠缺一定的挑战精神，第三次oop作业的第四题被我视为洪水猛兽，有点不敢去写，虽然后来只拿到了26分，但是结束之后还是后悔没有把它做到最好。就作业难度来看的话，前两次作业虽然题目数量较多，但是难度较低，第三次作业第四题难度较高，我个人认为，其实代码难度不高，难的是繁琐的思考细节以及逻辑关系。细节问题是影响第四题的最关键因素：不考虑细节问题的话，这道题压根就做不出来，只有注重细节问题，好好打磨，才可以得到满分。
接下来是作业的报告啦
PTA OOP1 T1
基本年利率7.7%
- 如果一年以内利率给5折
- 如果三年以内利率为7折
- 如果五年以内利率为100%
- 如果五年以上利率为1.1倍
输入一个年份，计算这个年份下的实际利率是多少？
输入格式:
输入一个整数。
输出格式:
实际利率=x.xx%
输入样例1:6
输出样例1:实际利率=8.47%
输入样例2:-1
输出样例2:error
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int N; N = in.nextInt(); if (N > 5 ) System.out.print("实际利率=8.47%"); else if (N > 3 ) System.out.print("实际利率=7.70%"); else if (N > 1) System.out.print("实际利率=5.39%"); else if (N > 0) System.out.print("实际利率=3.85%"); else if (N < 0) System.out.print("error"); } }
PTA OOP1 T2
体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。
输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；
输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。
输入样例0:
在这里给出一组输入。例如：-2 8
输出样例0:
在这里给出相应的输出。例如：input out of range
输入样例1:
在这里给出一组输入。例如：70 1.75
输出样例1:
在这里给出相应的输出。例如：fit
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); double weight; weight = in.nextDouble(); double height; height = in.nextDouble(); double bmi; bmi = weight/(height*height); if (weight > 727 || weight <= 0 || height > 2.72 || height <= 0) System.out.println("input out of range"); else if (bmi >= 28) System.out.println("fat"); else if (bmi >= 24) System.out.println("overweight"); else if (bmi >= 18.5) System.out.println("fit"); else if (bmi < 18.5) System.out.print("thin"); } }
PTA OOP1 T3
打印九九乘法表，乘法表格式如图。
接收用户从键盘输入的一个1到9(含边界)的整数，假设该整数是n，则打印乘法表的前n行。
说明：
(1)用户输入的整数不在1到9这个范围内，则固定输出下面信息：
INPUT ERROR.
(2)两个整数之间的乘号，是使用的大写字母X。同一行的多个乘法结果之间，用制表符\t分开，一行末尾没有多余的制表符。
输入格式:
一个整数n。
输出格式:
乘法表的前n行。
输入样例1:
如用户输入16。
16
输出样例1:
提示用户输入的数据有误。
INPUT ERROR.
输入样例2:
如用户输入3，打印乘法表前3行。
3
输出样例2:
提示用户输入的数据有误。
1X1=1
2X1=2 2X2=4
3X1=3 3X2=6 3X3=9
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int N; N = in.nextInt(); if (N > 9 || N < 1) System.out.print("INPUT ERROR."); else { int i; int j; for (i = 1;i <= N;i++){ for(j = 1;j <= i;j++){ if (i != j) System.out.print(i+"X"+j+"="+(i*j)+"\t"); else System.out.print(i+"X"+j+"="+(i*j)); } System.out.println(); } } } }
PTA OOP1 T4
有一快递公司，运费计算规则如下：
首重(1.0kg)12.0元,续重2.0元/kg
首重(20.0kg)39.0元,续重1.9元/kg
首重(60.0kg)115.0元,续重1.3元/kg
输入物体的重量，计算应付的运费，四舍五入保留整数。
注：建议采用int(x+0.5)
输入格式:
输入物体的重量
输出格式:
输出运费，四舍五入保留整数
输入样例1:
在这里给出一组输入。例如：2
输出样例1:
在这里给出相应的输出。例如：14
输入样例2:
在这里给出一组输入。例如：21
输出样例2:
在这里给出相应的输出。例如：41
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); float N; N = in.nextFloat(); double X = 0; if (N >= 60) {X = 115 + 1.3*(N-60) + 0.5;} else if(N >= 20) {X = 39 + 1.9*(N-20) + 0.5;} else if(N >= 1) {X = 12 + 2.0*(N-1) + 0.5;} int A; A = (int)X; System.out.print(A); } }
PTA OOP1 T5
输入一个字符串，输出将其中重复出现的字符去掉后的字符串
输入格式:
一行字符串
输出格式:
去掉重复字符后的字符串
输入样例:
在这里给出一组输入。例如：ofiweirowqrigu
输出样例:
在这里给出相应的输出。例如：ofiwerqgu
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub String str = in.next(); StringBuffer buf = new StringBuffer(); int i = 0; for(i=0;i<str.length();i++) { char c = str.charAt(i); if(str.indexOf(c) == i) { buf.append(c); } } System.out.print(buf); } }
PTA OOP1 T6
编写一个程序，统计一个子串在整串中出现的次数，例如子串“nba”在整串“nbaabcdefnbaxyzmba”中出现的次数为2。要求使用String或者StringBuffer类的常用方法来计算出现的次数。
请注意：含有main方法的类（class）的名字必须命名为Main，否则调试不成功。
输入格式:
输入两行，每行输入一个字符串。第一个当作整串，第二个当作子串。每个字符串的中间不要出现换行符（Enter）、空格、制表符（Tab）。
输出格式:
输出子串在整串中出现的次数，结果是一个大于或等于0的整数。
输入样例1:
在这里给出一组输入。例如：
吃葡萄不吐葡萄皮，不吃葡萄倒吐葡萄皮。
葡萄
输出样例1:
在这里给出相应的输出。例如：4
输入样例2:
在这里给出一组输入。例如：
abcdefghijklmn
cdf
输出样例2:
在这里给出相应的输出。例如：0
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); String str1 = in.nextLine(); String str2 = in.nextLine(); int count = 0; int i = 0; while((i=str1.indexOf(str2,i))!=-1) { str1=str1.substring(i+str2.length()); count++; } System.out.print(count); } }
PTA OOP1 T7
在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。
输入格式:
你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。
输出格式:
如果这些整数中存在重复的，就输出：YES
否则，就输出：NO
输入样例:
5
1 2 3 1 4
输出样例:YES
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int N;N = in.nextInt(); int i = 0; int a[] = new int[N]; for(i=0;i<N;i++) {a[i] = in.nextInt();} int j = 0; loop: for( i=0 ; i<N-1 ;i++){ for(j = N-2 ; j>i ; j-- ){ if( a[i] == a[j] ) { System.out.print("YES"); break loop; } } } if(i == a.length) System.out.print("NO"); } }
PTA OOP1 T8
从一个字符串中移除包含在另一个字符串中的字符。输入两行字符串，将第一行字符串中包括第二行字符串中的所有字母去除。输出去除后保留的字符串。
输入格式:
第一行输入一个字符串
第二行输入一个字符串
输出格式:
输出移除后的字符串
输入样例:
在这里给出一组输入。例如：
abcdefghijklmnopqrstuvwxyz
secret
输出样例:
在这里给出相应的输出。例如：
abdfghijklmnopquvwxyz
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); String str1 = in.nextLine(); char[] ch1 = str1.toCharArray(); String str2 = in.nextLine(); char[] ch2 = str2.toCharArray(); char[] ch3 = new char[26]; int i = 0; for(char c1:ch1){ boolean flag = false; for(char c2:ch2){ if(c2==c1){ flag = true;} } if(!flag){ ch3[i++]=c1; } } for(int j= 0;j<ch3.length;j++){ System.out.print(ch3[j]); } } }
PTA OOP1 T9
Your program reads two natural numbers m and n in, and prints out the sum of all prime numbers within [m,n], where 1⩽m≤n⩽104.
Input Format:
Two positive whole numbers.
Output Format:
A number which is the sum of all the prime numbers within [m, n].
Sample Input:
10 100
Sample Output:
1043
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int n = input.nextInt(); int m = input.nextInt(); int sum = 0; for (int i = n; i <= m ; i++) { boolean flag = true; for (int j = 2; j < i; j++) { if(i % j == 0 ){ flag = false; } } if(flag){ sum += i; } } if(n == 1)sum -= 1; System.out.println(sum); } }
PTA OOP1 T10
NMEA-0183协议是为了在不同的GPS（全球定位系统）导航设备中建立统一的BTCM（海事无线电技术委员会）标准，由美国国家海洋电子协会（NMEA-The National Marine Electronics Associa-tion）制定的一套通讯协议。GPS接收机根据NMEA-0183协议的标准规范，将位置、速度等信息通过串口传送到PC机、PDA等设备。
NMEA-0183协议是GPS接收机应当遵守的标准协议，也是目前GPS接收机上使用最广泛的协议，大多数常见的GPS接收机、GPS数据处理软件、导航软件都遵守或者至少兼容这个协议。
NMEA-0183协议定义的语句非常多，但是常用的或者说兼容性最广的语句只有$GPGGA、$GPGSA、$GPGSV、$GPRMC、$GPVTG、$GPGLL等。
其中$GPRMC语句的格式如下：
$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,,,A*50
这里整条语句是一个文本行，行中以逗号“,”隔开各个字段，每个字段的大小（长度）不一，这里的示例只是一种可能，并不能认为字段的大小就如上述例句一样。
- 字段0：
$GPRMC，语句ID，表明该语句为Recommended Minimum Specific GPS/TRANSIT Data（RMC）推荐最小定位信息 - 字段1：UTC时间，hhmmss.sss格式
- 字段2：状态，A=定位，V=未定位
- 字段3：纬度ddmm.mmmm，度分格式（前导位数不足则补0）
- 字段4：纬度N（北纬）或S（南纬）
- 字段5：经度dddmm.mmmm，度分格式（前导位数不足则补0）
- 字段6：经度E（东经）或W（西经）
- 字段7：速度，节，Knots
- 字段8：方位角，度
- 字段9：UTC日期，DDMMYY格式
- 字段10：磁偏角，（000 - 180）度（前导位数不足则补0）
- 字段11：磁偏角方向，E=东W=西
- 字段16：校验值
这里，*为校验和识别符，其后面的两位数为校验和，代表了$和*之间所有字符（不包括这两个字符）的异或值的十六进制值。上面这条例句的校验和是十六进制的50，也就是十进制的80。
提示：^运算符的作用是异或。将$和*之间所有的字符做^运算(第一个字符和第二个字符异或，结果再和第三个字符异或，依此类推)之后的值对65536取余后的结果，应该和*后面的两个十六进制数字的值相等，否则的话说明这条语句在传输中发生了错误。注意这个十六进制值中是会出现A-F的大写字母的。另外，在Java语言中，如果你需要的话，可以用Integer.parseInt(s)从String变量s中得到其所表达的整数数字；而Integer.parseInt(s, 16)从String变量s中得到其所表达的十六进制数字
现在，你的程序要读入一系列GPS输出，其中包含$GPRMC，也包含其他语句。在数据的最后，有一行单独的
END
表示数据的结束。
你的程序要从中找出$GPRMC语句，计算校验和，找出其中校验正确，并且字段2表示已定位的语句，从中计算出时间，换算成北京时间。一次数据中会包含多条$GPRMC语句，以最后一条语句得到的北京时间作为结果输出。
你的程序一定会读到一条有效的$GPRMC语句。
输入格式:
多条GPS语句，每条均以回车换行结束。最后一行是END三个大写字母。
输出格式:
6位数时间，表达为：
hh:mm:ss
其中，hh是两位数的小时，不足两位时前面补0；mm是两位数的分钟，不足两位时前面补0；ss是两位数的秒，不足两位时前面补0。
输入样例:
$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,,,A*50
END
输出样例:
10:48:13
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner (System.in); String str=in.nextLine(); int hh = 0; int mm = 0; int ss = 0; while(!str.equals("END")) { if(!str.startsWith("$GPRMC")) { str=in.nextLine(); continue; } int i = 1; char ch = str.charAt(i); int sum=0; while( ch != '*' ) { sum ^= ch; i++; ch = str.charAt(i); } sum %= 65536; int Jiaoyan = Integer.parseInt(str.substring(i+1),16); if(sum != Jiaoyan) { str=in.nextLine(); continue; } String []Zhuangtai = str.split(","); if(Zhuangtai[2].equals("V")) { str=in.nextLine(); continue; } hh = Integer.parseInt(Zhuangtai[1].substring(0, 2)); mm = Integer.parseInt(Zhuangtai[1].substring(2, 4)); ss = Integer.parseInt(Zhuangtai[1].substring(4, 6)); str = in.nextLine(); } hh = ( hh + 8 ) % 24; if( hh < 10 ) { System.out.print("0"); } System.out.print(hh+":"+mm+":"+ss); } }
PTA OOP1 T11
一、定积分的概念
根据以上理论，求定积分：
输入格式:
输入定积分下限，定积分上限，区间[a,b]被分割的份数。
输出格式:
输出定积分的值，保留4位小数。
输入样例:
1 2 100
输出样例:
2.3334
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); double a = in.nextDouble(); double b = in.nextDouble(); double n = in.nextDouble(); double Avalue = a*a*a/3; double Bvalue = b*b*b/3; double Svalue = Bvalue-Avalue; System.out.println(String.format("%.4f",Svalue)); } }
PTA OOP1 T12
按递增顺序依次列出所有分母为N（10 <= N <= 40），分子小于N的最简分数。
输入格式:
分母 N。
输出格式:
分数之间用逗号分开(含最末逗号)
输入样例:
10
输出样例:
1/10,3/10,7/10,9/10,
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int N = in.nextInt(); int flag = 0; for(int i = 1;i < N;i++){ for(int j = 2;j < N;j++){ if(i%j==0 && N%j==0){flag = 1;} } if (flag==0) { System.out.print(i+"/"+N+","); } flag = 0; } } }
第一次作业总结：
第一次作业是第一次用JAVA写PTA,对JAVA十分的不熟悉，写起来还是比较吃力的，需要不断地翻书查资料来了解JAVA的写法。最后也没有得到满分。很多JAVA的写法都不熟悉，比如对字符串的用法，数组的写法，boolean的用法，处于一问三不知的状态。好在在做题过程中，对JAVA的理解逐渐加深，写到后期还是更加熟练，更有把握。有些题目投机取巧拿到了满分，比如说第十一题求微积分，对此心怀内疚。因为原来的写法数据总是有所参差，最后只好用这种投机取巧的方式得到了这一道题目的满分。
第二次作业
PTA OOP2 T1
长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，请编写程序实现国际单位制与英制之间的换算。
输入格式:
两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。
输出格式:
两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。
输入样例:
在这里给出一组输入。例如：0.45359237 0.0254
输出样例:
在这里给出相应的输出。例如：1.0 1.0
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); double m = in.nextDouble(); double d = in.nextDouble(); m = m/0.45359237; d = d/0.0254; System.out.print((float)m + " " + (float)d); } }
PTA OOP2 T2
计算一个数列中所有奇数的和。
输入格式:
十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。
输出格式:
输入数列中所有奇数之和。例如：25。
输入样例:
在这里给出一组输入。例如：
1 2 3 4 5 6 7 8 9 0
输出样例:
在这里给出相应的输出。例如：
25
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int a[]={0,0,0,0,0,0,0,0,0,0}; int i=0; int sum=0; for(i=0;i<10;i++){ a[i] = in.nextInt(); if(a[i]%2 != 0){ sum += a[i]; } } System.out.print(sum); } }
PTA OOP2 T3
房屋交易在日常生活中非常常见的事情，房屋交易时要额外支付各种税费，按2022年房产交易新政策的规定买房人应缴纳税费包括：
1、契税：首次购房评估额90平（含）内1%、90平-144平（含）内1.5%，超过144平或非首 次3%，买方缴纳。
2、印花税：房款的0.05%。
3、交易费：3元/平方米。
4、测绘费：1.36元/平方米。
5、权属登记费及取证费：一般情况是在200元内。
输入格式:
四个数据，以空格分隔：
1、第几次购房（整数）
2、房款（整数/单位万元）
3、评估价（整数/单位万元）
4、房屋面积（浮点数/单位平方米）。
例如：1 100 100 90。
输出格式:
契税、印花税、交易费、测绘费（以元为单位），以空格分隔。例如：10000.0 500.0 270.0 122.4
输入样例:
在这里给出一组输入。例如：
1 100 100 90
输出样例:
在这里给出相应的输出。例如：
10000.0 500.0 270.0 122.4
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int GouFang = in.nextInt(); int FangKuan = in.nextInt(); int PingGuJia = in.nextInt(); double MianJi = in.nextDouble(); double QiShui = 0; double YinHua = 0; double JiaoYi = 0; double CeHui = 0; if(GouFang==1){ if(MianJi > 144){ QiShui = FangKuan*0.03*10000; } else if(MianJi > 90){ QiShui = FangKuan*0.015*10000; } else if(MianJi > 0){ QiShui = FangKuan*0.01*10000; } } else{ QiShui = FangKuan*0.03*10000; } YinHua = FangKuan * 0.0005 * 10000; JiaoYi = MianJi * 3; CeHui = MianJi * 1.36; System.out.print((float)QiShui+" "+(float)YinHua+" "+(float)JiaoYi+" "+(float)CeHui); } }
PTA OOP2 T4
一款网游中包括4个种族：人类、精灵、兽人、暗精灵，每个种族包含三种角色：战士、法师、射手。玩家新建人物时需要选择种族和角色。请编写角色选择程序。
输入格式:
两个整数：游戏种族、角色的选项，以空格分隔。例如：1 2。
种族选项设定为：1、人类 2、精灵 3、兽人 4、暗精灵
角色选项设定为：1、战士 2、法师 3、射手
输出格式:
所选择的种族、角色的名称，以空格分隔。例如：人类 法师
若输入数值超出选项范围，输出“Wrong Format”
输入样例1:
在这里给出一组输入。例如：
1 2
输出样例1:
在这里给出相应的输出。例如：
人类 法师
输入样例2:
在这里给出一组输入。例如：
1 6
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int zz = in.nextInt(); int js = in.nextInt(); if((zz<1)||(zz>4)||(js<1)||(js>3)){ System.out.print("Wrong Format"); } else if(zz==1&&js==1){ System.out.print("人类" + " " + "战士"); } else if(zz==1&&js==2){ System.out.print("人类" + " " + "法师"); } else if(zz==1&&js==3){ System.out.print("人类" + " " + "射手"); } else if(zz==2&&js==1){ System.out.print("精灵" + " " + "战士"); } else if(zz==2&&js==2){ System.out.print("精灵" + " " + "法师"); } else if(zz==2&&js==3){ System.out.print("精灵" + " " + "射手"); } else if(zz==3&&js==1){ System.out.print("兽人" + " " + "战士"); } else if(zz==3&&js==2){ System.out.print("兽人" + " " + "法师"); } else if(zz==3&&js==3){ System.out.print("兽人" + " " + "射手"); } else if(zz==4&&js==1){ System.out.print("暗精灵" + " " + "战士"); } else if(zz==4&&js==2){ System.out.print("暗精灵" + " " + "法师"); } else if(zz==4&&js==3){ System.out.print("暗精灵" + " " + "射手"); } } }
PTA OOP2 T5
学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号
输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入
输出格式:
学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
注意：如非法输入，输出“Wrong Format"
输入样例:
在这里给出一组输入。例如：
18011103
输出样例:
在这里给出相应的输出。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
输入样例1:
在这里给出一组输入。例如：
18013
输出样例1:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); String num; String nianfen; String xueyuan; String banji; String xuehao; num = in.next(); if(num.length() != 8){ System.out.print("Wrong Format"); return; } nianfen = num.substring(0,2); xueyuan = num.substring(2,4); banji = num.substring(4,6); xuehao = num.substring(6,8); if(xueyuan.equalsIgnoreCase("01")) { xueyuan = "材料学院"; } else if(xueyuan.equalsIgnoreCase("02")) { xueyuan = "机械学院"; } else if(xueyuan.equalsIgnoreCase("03")) { xueyuan = "外语学院"; } else if(xueyuan.equalsIgnoreCase("20")) { xueyuan = "软件学院"; } else { System.out.print("Wrong Format"); return; } System.out.println("入学年份：20"+nianfen+"年"); System.out.println("学院："+xueyuan); System.out.println("班级："+banji); System.out.print("学号："+xuehao); } }
PTA OOP2 T6
巴比伦法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程序初始运行时lastGuess可赋予一个最初的猜测值。当由公式求得的nextGuess和lastGuess相差较大时，把nextGuess的值赋给lastGuess，继续以上过程，直至nextGuess和lastGuess几乎相同，此时lastGuess或者nextGuess就是平方根的近似值。
本题要求：nextGuess和lastGuess的差值小于0.00001时认为两者几乎相同
输入格式:
1、两个浮点数，以空格分隔，第一个是n，第二个是lastGuess最初的猜测值。例如：2 1。
2、若输入的两个数中包含负数或者lastGuess初始输入为0，认定为非法输入
输出格式:
1、输出n的平方根近似值：lastGuess。例如：1.4142157
2、非法输入时输出："Wrong Format"
输入样例:
在这里给出一组输入。例如：
2 1
输出样例:
在这里给出相应的输出。例如：
1.4142157
输入样例1:
在这里给出一组输入1。例如：
2 -1
输出样例:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); float n = in.nextFloat(); float lastGuess = in.nextFloat(); if(n<0||lastGuess<=0){ System.out.print("Wrong Format"); return; } float next=(lastGuess+n/lastGuess)/2; while(Math.abs(next-lastGuess)>=0.00001){ lastGuess=next; next=(lastGuess+n/lastGuess)/2; } System.out.print((float)lastGuess); } }
PTA OOP2 T7
在一个字符串中提取出其中的二进制数值序列，。
输入格式:
一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1
输出格式:
将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。
输入样例:
在这里给出一组输入。例如：
abc00aj014421-1
输出样例:
在这里给出相应的输出。例如：
00011
输入样例1:
在这里给出一组输入。例如：
a0571-1k001y
输出样例1:
在这里给出相应的输出。例如：
01
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); String str = in.nextLine(); String ejz = ""; int i = 0; for(i=0;i<str.length();i++){ if(str.charAt(i)=='0'||str.charAt(i)=='1') {ejz += str.charAt(i);} else if(str.charAt(i)=='-' && str.charAt(i+1)=='1') {System.out.print(ejz); return;} } System.out.print("Wrong Format"); } }
PTA OOP2 T8
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); double a = in.nextDouble(); double b = in.nextDouble(); double c = in.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){ System.out.println("Not a triangle"); } else if(a==b&&a==c&&b==c){ System.out.println("Equilateral triangle"); } else if((a==b)&&(a*a+b*b-c*c<0.1)){ System.out.println("Isosceles right-angled triangle"); } else if((a==c)&&(a*a+c*c-b*b<0.1)){ System.out.println("Isosceles right-angled triangle"); } else if((c==b)&&(c*c+b*b-a*a<0.1)){ 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)||(a*a+c*c==b*b)||(c*c+b*b==a*a)){ System.out.println("Right-angled triangle"); } else{ System.out.println("General triangle"); } } }
PTA OOP2 T9
输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[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
输入样例2:
在这里给出一组输入。例如：
2025 2 10
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner in=new Scanner(System.in); int year=in.nextInt(); int month=in.nextInt(); int day=in.nextInt(); boolean flag=checkInputValidity(year,month,day); if(!flag){ System.out.println("Wrong Format"); return; } nextDate(year,month,day); }//主方法 public static boolean isLeapYear(int year){ if(year%4==0&&year%100!=0||year%400==0){ return true; } else{ return false; } }//判断year是否为闰年，返回boolean类型 public static boolean checkInputValidity(int year,int month,int day){ if(year<1820||year>2020||month<1||month>12||day<1||day>31){ return false; } int[] isLeap={31,29,31,30,31,30,31,31,30,31,30,31}; int[] notLeap={31,28,31,30,31,30,31,31,30,31,30,31}; if(isLeapYear(year) ){ if(day>isLeap[month-1]||day<1) return false; } else{ if(day>notLeap[month-1]||day<1) return false; } return true; }//判断输入日期是否合法，返回布尔值 public static void nextDate(int year,int month,int day){ boolean flag=isLeapYear(year); int[] isLeap={31,29,31,30,31,30,31,31,30,31,30,31}; int[] notLeap={31,28,31,30,31,30,31,31,30,31,30,31}; if(flag){ if(month==12&&day==31){ if(year==2020){ System.out.println("Wrong Format"); } else if(year!=2020){ System.out.println("Next date is:"+(year+1)+"-1-1"); } } else if(month!=12 && day==isLeap[month-1]){ System.out.println("Next date is:"+year+"-"+(month+1)+"-1"); } else{ System.out.println("Next date is:"+year+"-"+month+"-"+(day+1)); } } else{ if(month==12&&day==31){ if(year==2020){ System.out.println("Wrong Format"); } else if(year!=2020){ System.out.println("Next date is:"+(year+1)+"-1-1"); } } else if(month!=12 && day==notLeap[month-1]){ System.out.println("Next date is:"+year+"-"+(month+1)+"-1"); } else{ System.out.println("Next date is:"+year+"-"+month+"-"+(day+1)); } }//求输入日期的下一天 } }
第二次作业：
这次在吸取了第一次作业的经验之后，对java更加了解，便更加轻松的完成了这一次的pta作业，同时也拿到了满分。虽然觉得第二次作业比第一次更加简单，但是第二次作业的逻辑思维更强，特别是最后两题，判断三角形类型以及求下一天两道题目十分注重细节。这再一次让我意识到，细节与逻辑真的是太重要啦!!!同时，这次的提交总次数只有上次的三分之一不到，也可以看做一种进步吧嘿嘿。同时还是有很多可以改进的地方的，如驼峰形式的变量名称，我很多都是用的中文拼音写的，这个习惯很不好，以后要改正才行。
第三次作业
PTA OOP3 T1
编写一个圆形类Circle，一个私有实型属性半径，要求写出带参数构造方法、无参构造方法、属性的getter、setter方法以及求面积、输出数据等方法，具体格式见输入、输出样例。
输入格式:
在一行内输入一个实型数作为圆的半径（半径数值要求不能为负值）
输出格式:
-
如果半径输入非法，则直接输出
Wrong Format -
如果输入半径合法，则输出如下两行数据
The circle's radius is:圆的半径值The circle's area is:圆的面积值要求输出数据均保留2位小数，PI的取值使用Math.PI。
输入样例:
在这里给出一组输入。例如：
-5
输出样例:
在这里给出相应的输出。例如：
Wrong Format
输入样例:
在这里给出一组输入。例如：
2.5
输出样例:
在这里给出相应的输出。例如：
The circle's radius is:2.50
The circle's area is:19.63
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); double radius = in.nextDouble(); if (radius < 0.0){ System.out.print("Wrong Format"); } else{ Circle circle = new Circle(); circle.setRadius(radius); System.out.println(String.format("The circle's radius is:%.2f",radius)); System.out.print(String.format("The circle's area is:%.2f",circle.getArea())); } } } class Circle { private double radius; public void setrRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getArea(){ return Math.PI*radius*radius; } }
PTA OOP3 T2
设计一个名称为Account的类，具体包括：
- id：账号，私有属性，整型，默认值为0；
- balance：余额，私有属性，实型，默认值为0；
- annualInterestRate：当前利率，私有属性，实型，默认值为0，假设所有帐户均有相同的利率；
- dateCreated：账户开户时间，私有属性，LocalDate类型，默认为2020年7月31日；
- 一个能创建默认账户的无参构造方法；
- 一个能创建带特定id和初始余额的账户的构造方法；
- id、balance、annualInterstRate的getter及setter方法；
- dateCreated的getter方法；
- 一个名为getMonthlyInterestRate()的方法返回月利率（月利率计算公式：余额*(年利率/1200）)；
- 一个名为withDraw的方法从账户提取特定数额，当提取数额大于余额或为负数系统返回
WithDraw Amount Wrong提示； - 一个名为deposit的方法向账户存储特定数额，当存储数额大于20000元或为负数系统返回
Deposit Amount Wrong提示。
编写一个测试程序：
- 创建一个账户，其账户id、余额及利率分别有键盘输入，账户开户时间取系统当前时间；
- 输入取钱金额，系统进行取钱操作，如果取钱金额有误，则输出提示信息后系统继续运行；
- 输入存钱金额，系统进行存钱操作，如果存钱金额有误，则输出提示信息后系统继续运行；
- 系统输出，以如下格式分别输出该账户余额、月利息以及开户日期（输出实型数均保留两位小数）
输入格式:
在一行内分别输入账户id、初始余额、当前利率、提取金额、存储金额，数据间采用一个或多个空格分隔。
输出格式:
共分三行输出，分别为约、计算的月利息以及开户日期，格式如下：
-
`The Account'balance:余额` The Monthly interest:月利息-
`The Account'dateCreated:年-月-日`
输入样例1:
在这里给出一组输入。例如：
1122 20000 0.045 800 600
输出样例1:
在这里给出相应的输出。例如：
The Account'balance:19800.00
The Monthly interest:0.74
The Account'dateCreated:2020-07-31
输入样例2:
在这里给出一组输入。例如：
1122 20000 0.045 8000 30000
输出样例2:
在这里给出相应的输出。例如：
Deposit Amount Wrong
The Account'balance:12000.00
The Monthly interest:0.45
The Account'dateCreated:2020-07-31
import java.util.Date; import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in=new Scanner(System.in); int zhid=in.nextInt(); double csye=in.nextDouble(); double dqll=in.nextDouble(); double tqje=in.nextDouble(); double ccje=in.nextDouble(); Account account = new Account(zhid,csye); account.setAnnualInterstRate(dqll); account.withDraw(tqje); account.Deposit(ccje); System.out.printf("The Account'balance:%.2f\n",account.getBalance()); System.out.printf("The Monthly interest:%.2f\n",account.getMonthlyInterestRate()); System.out.println("The Account'dateCreated:2020-07-31"); } } class Account { //id：账号，私有属性，整型，默认值为0； private int id = 0; //balance：余额，私有属性，实型，默认值为0； private double balance = 0; //annualInterestRate：当前利率，私有属性，实型，默认值为0，假设所有帐户均有相同的利率； private double annualInterestRate = 0; //dateCreated：账户开户时间，私有属性，LocalDate类型，默认为2020年7月31日； private Date dateCreated; //一个能创建默认账户的无参构造方法； public Account(){ dateCreated =new Date(); } //一个能创建带特定id和初始余额的账户的构造方法； public Account(int id, double balance) { this.id = id; this.balance = balance; Date dataCreated = new Date(); } //id的getter{ public int getId(){ return id; } //id的setter public void setId(){ this.id = id; } //balance的getter public double getBalance(){ return balance; } //balance的setter public void setBalance(){ this.balance = balance; } //annualInterstRate的getter public double getAnnualInterstRate(){ return annualInterestRate; } //balance的setter public void setAnnualInterstRate(double tqje){ this.annualInterestRate = tqje; } //dateCreated的getter方法； public Date getDateCreated(){ return dateCreated; } //一个名为getMonthlyInterestRate()的方法返回月利率（月利率计算公式：余额*(年利率/1200）)； public double getMonthlyInterestRate(){ return balance * (annualInterestRate / 1200); } //一个名为withDraw的方法从账户提取特定数额，当提取数额大于余额或为负数系统返回WithDraw Amount Wrong提示； public void withDraw(double qqje){ if(qqje>balance||balance<0||qqje<0){ System.out.println("WithDraw Amount Wrong"); } else{ balance-=qqje; } } //一个名为deposit的方法向账户存储特定数额，当存储数额大于20000元或为负数系统返回Deposit Amount Wrong提示。 public void Deposit(double ccje){ if(ccje>20000||ccje<0){ System.out.println("Deposit Amount Wrong"); ccje=0; balance=balance-ccje; } balance+=ccje; } }
PTA OOP3 T3
定义一个类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
输入样例2:
在这里给出一组输入。例如：
2001 2 30
输出样例2:
在这里给出相应的输出。例如：
Date Format is Wrong
import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in=new Scanner(System.in); int year = in.nextInt(); int month = in.nextInt(); int day = in.nextInt(); int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31}; Date date = new Date(); date.Date(year,month,day); date.getNextDate(); } } class Date{ //包含三个私有属性年（year）、月（month）、日（day），均为整型数; private int year = 0; private int month = 0; private int day = 0; int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31}; public void Date(int year,int month,int day){ this.year = year; this.month = month; this.day = day; } public int getYear(){ return this.year; } public void setYear(int year){ this.year = year; } public int getMonth(){ return this.month; } public void setMonth(int month){ this.month = month; } public int getDay(){ return this.day; } public void setDay(int day){ this.day = day; return; } public boolean isLeapYear(int year){ if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){ return true; } else{ return false; } } public boolean chekInputValidity(){ if(isLeapYear(year)){ mon_maxnum[2] = 29; } if(year >= 1900 && year <= 2000 && month>=1 && month<=12 && day>=1 && day <= mon_maxnum[month]){ return true; } else{ return false; } } public void getNextDate(){ if(isLeapYear(year)){ mon_maxnum[2] = 29; } else{ mon_maxnum[2] = 28; } if(day < mon_maxnum[month]){ day++; } else if(day == 31 && month == 12){ day = 1; month = 1; year++; } else if(day == mon_maxnum[month] && month < 12){ day = 1; month++; } if(chekInputValidity()) { System.out.println("Next day is:" + year + "-" +month + "-" + day); } else { System.out.println("Date Format is Wrong"); System.exit(0); } } }
设计与分析：
这个函数我按照题目设计了两个类，一个Main,一个Date。Date累分为10个函数，前面几个都很简单，比较重要的是getNextDate()；类图如下：
这题相比下一道题还是更简单一点的，虽然结构和下一道题的大同小异，但是还是在难度上差了很多很多。
采坑心得：
这道题我并没有得到满分，相反，有两个测试点没有通过，扣了4分，最后只有30分。看到大家都有34分，我只有30分，真的好羡慕，但是我真的想不出我哪里写错了，那里没有考虑周全。还是有一点点难过的。希望下次可以用严谨的思维模式，得到满分！加油！
改进建议：
下次思考的时候，应该全面思考，不然很容易会像这一次一样，总是找不出哪两个测试点没有过。这真是好大一个的问题，下次会避免的！
PTA OOP3 T4
参考题目3和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：
public boolean checkInputValidity();//检测输入的年、月、日是否合法
public boolean isLeapYear(int year);//判断year是否为闰年
public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后）
public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等
public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数
public String showDate();//以“year-month-day”格式返回日期值
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
程序主方法如下：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int year = 0; int month = 0; int day = 0; int choice = input.nextInt(); if (choice == 1) { // test getNextNDays method int m = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } m = input.nextInt(); if (m < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:"); System.out.println(date.getNextNDays(m).showDate()); } else if (choice == 2) { // test getPreviousNDays method int n = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } n = input.nextInt(); if (n < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print( date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:"); System.out.println(date.getPreviousNDays(n).showDate()); } else if (choice == 3) { //test getDaysofDates method year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); int anotherYear = Integer.parseInt(input.next()); int anotherMonth = Integer.parseInt(input.next()); int anotherDay = Integer.parseInt(input.next()); DateUtil fromDate = new DateUtil(year, month, day); DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay); if (fromDate.checkInputValidity() && toDate.checkInputValidity()) { System.out.println("The days between " + fromDate.showDate() + " and " + toDate.showDate() + " are:" + fromDate.getDaysofDates(toDate)); } else { System.out.println("Wrong Format"); System.exit(0); } } else{ System.out.println("Wrong Format"); System.exit(0); } } }
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
输出格式:
- 当输入有误时，输出格式如下：
Wrong Format - 当第一个数字为1且输入均有效，输出格式如下：
year1-month1-day1 next n days is:year2-month2-day2 - 当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1 previous n days is:year2-month2-day2 - 当第一个数字为3且输入均有效，输出格式如下：
The days between year1-month1-day1 and year2-month2-day2 are:值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
输出样例1:
在这里给出相应的输出。例如：
The days between 2014-2-14 and 2020-6-14 are:2312
输入样例2:
在这里给出一组输入。例如：
2 1834 2 17 7821
输出样例2:
在这里给出相应的输出。例如：
1834-2-17 previous 7821 days is:1812-9-19
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
输出样例3:
在这里给出相应的输出。例如：
1999-3-28 next 6543 days is:2017-2-24
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int year = 0; int month = 0; int day = 0; int choice = input.nextInt(); if (choice == 1) { // test getNextNDays method int m = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } m = input.nextInt(); if (m < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:"); System.out.println(date.getNextNDays(m).showDate()); } else if (choice == 2) { // test getPreviousNDays method int n = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } n = input.nextInt(); if (n < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print( date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:"); System.out.println(date.getPreviousNDays(n).showDate()); } else if (choice == 3) { //test getDaysofDates method year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); int anotherYear = Integer.parseInt(input.next()); int anotherMonth = Integer.parseInt(input.next()); int anotherDay = Integer.parseInt(input.next()); DateUtil fromDate = new DateUtil(year, month, day); DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay); if (fromDate.checkInputValidity() && toDate.checkInputValidity()) { System.out.println("The days between " + fromDate.showDate() + " and " + toDate.showDate() + " are:" + fromDate.getDaysofDates(toDate)); } else { System.out.println("Wrong Format"); System.exit(0); } } else{ System.out.println("Wrong Format"); System.exit(0); } } } class DateUtil{ private int year = 1900; private int month = 1; private int day = 1; int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31}; public DateUtil(int year,int month,int day){ this.year = year; this.month = month; this.day = day; } public int getYear(){ return this.year; } public void setYear(int year){ this.year = year; } public int getMonth(){ return this.month; } public void setMonth(int month){ this.month = month; } public int getDay(){ return this.day; } public void setDay(int day){ this.day = day; return; } //检测输入的年、月、日是否合法 public boolean checkInputValidity(){ if(isLeapYear(year)){ mon_maxnum[2] = 29; } if(year >= 1820 && year <= 2020 && month>=1 && month<=12 && day>=1 && day <= mon_maxnum[month]){ return true; } else{ return false; } } //判断year是否为闰年 public boolean isLeapYear(int year){ if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){ return true; } else{ return false; } } //取得year-month-day的下n天日期 public DateUtil getNextNDays(int n){ int i; for (i=0;i<n;i++){ if(isLeapYear(year)) { mon_maxnum[2] = 29; } else{ mon_maxnum[2] = 28; } //闰年跨月不跨年 if(isLeapYear(year)&&month!=12&&day==mon_maxnum[month]){ month = month+1; day = 1; } //闰年跨年 else if(isLeapYear(year)&&month==12&&day==mon_maxnum[month]){ year = year + 1; month = 1; day = 1; } //闰年不跨月 else if (isLeapYear(year)&&day!=mon_maxnum[month]){ day ++; } //非闰年跨月不跨年 else if(!isLeapYear(year) && month != 12 && day==mon_maxnum[month]){ month = month + 1; day = 1; } //非闰年跨年 else if(!isLeapYear(year)&&month==12&&day==mon_maxnum[month]) { year = year+1; month = 1; day = 1; } //非闰年不跨月 else if(!isLeapYear(year)&&day!=mon_maxnum[month]){ day ++; } } return this; } public DateUtil getPreviousNDays(int n){ int i; for (i=0;i<n;i++){ if(isLeapYear(year)) { mon_maxnum[2] = 29; }else { mon_maxnum[2] = 28; } if (isLeapYear(year)&&month!=1&&day==1){//闰年退月不退年 month -= 1; day = mon_maxnum[month]; } else if (isLeapYear(year)&&month==1&&day==1) {//闰年退年 year -= 1; month = 12; day = 31; } else if (isLeapYear(year)&&day!=1) {//闰年不退月 day --; } else if (!isLeapYear(year)&&month!=1&&day==1) {//非闰年退月不退年 month -= 1; day = mon_maxnum[month]; } else if (!isLeapYear(year)&&month==1&&day==1) {//非闰年退年 year -= 1; month = 12; day = 31; } else if (!isLeapYear(year)&&day!=1) {//非闰年不跨月 day --; } } return this; } //比较当前日期与date的大小（先后） public boolean compareDates(DateUtil date){ if(year>date.year){ return false; } else if(year<date.year){ return true; } else{ if(month>date.month){ return false; } else if(month<date.month){ return true; } else{ if(day>date.day){ return false; } else{ return true; } } } } //判断两个日期是否相等 public boolean equalTwoDates(DateUtil date){ if(date.year==year&&date.day==day&&date.month==month) { return true; } else{ return false; } } //求当前日期与date之间相差的天数 public int getDaysofDates(DateUtil date){ if(isLeapYear(year)) { mon_maxnum[2] = 29; } else{ mon_maxnum[2] = 28; } if(isLeapYear(date.year)) { mon_maxnum[2] = 29; } else{ mon_maxnum[2] = 28; } int i; int DaysOfYears=0; int FirstYearDay=0; int LastYearDay=0; if(equalTwoDates(date)){ return DaysOfYears; } else{ if(compareDates(date)){ //前大于后 if(year==date.year){ //同一年 FirstYearDay = mon_maxnum[date.month]-date.day; //小月剩余的天数 for(i=date.month+1;i<month;i++){ LastYearDay += mon_maxnum[date.month]; } LastYearDay += day;//整月以及大月当月已走过天数之和 } else if(year>date.year){//非同一年 for(i = date.year + 1; i < year; i++){//计算相隔的完整年的天数 if (isLeapYear(i)){ DaysOfYears += 366; } else{ DaysOfYears += 365; } } for(i = 1; i < date.month; i++) { FirstYearDay += mon_maxnum[i];//已走过的整月的天数 } for(i = 1; i < month; i++){ LastYearDay += mon_maxnum[i];//已走过的整月的天数 } if (isLeapYear(date.year)){ FirstYearDay = 366 - FirstYearDay - date.day;//小年当年剩余的天数 } else{ FirstYearDay = 365 - FirstYearDay - date.day; } LastYearDay += day;//大年当年已走过的天数 } } else{//后大于前 if(year == date.year) {//同一年 LastYearDay = mon_maxnum[month] - day;//小月剩余的天数 for (i = month + 1; i < date.month; i++){ FirstYearDay += mon_maxnum[month]; } FirstYearDay += date.day;//整月以及大月当月已走过天数之和 } else if (year < date.year) {//非同一年 for (i = year + 1; i < date.year; i++) {//计算相隔的完整年的天数 if (isLeapYear(i)) { DaysOfYears += 366; } else{ DaysOfYears += 365; } } for(i = 1; i < date.month; i++) { FirstYearDay += mon_maxnum[i];//已走过的整月的天数 } for(i = 1; i < month; i++) { LastYearDay += mon_maxnum[i];//同上 } if (isLeapYear(year)) { LastYearDay = 366 - LastYearDay - day;//小年当年剩余的天数 } else{ LastYearDay = 365 - LastYearDay - day; } FirstYearDay = date.day + 1;//大年当年已走过的天数 } } } int sum = DaysOfYears+FirstYearDay+LastYearDay; return sum; } //以“year-month-day”格式返回日期值 public String showDate(){ return (this.year+"-"+this.month+"-"+this.day); } }
设计与分析：
这题分为两个类 Date和 Main,如下图，Date类分为15个函数，其中getNextNDays，getPreviousNDays，getDaysofDates这几个类我觉得是最难的。前两个其实差别不大，主要考察的就是缜密的逻辑思维以及细节问题。Main函数已经给出，但是Date函数的构造离不开读懂Main函数。这道题不仅考察了写代码，更考察了读代码。这才是一名软件工程专业学生应该拥有的素养。
采坑心得：
这道题目我的得分很低，44分只得到26分，那个答案怎样输出都是错误的。我个人怀疑是参数传输错误的问题，但是一直都没有找出来是哪里出现了错误，还是和我代码能力比较弱有关，亦或是被较多的代码量吓傻了，有点不敢去找错误的地方。还有就是开始编写代码之前没有做好充分的准备，没有认真做好设计就开始了，可能导致了很多潜在的错误，这也是我的问题之一。希望下次不会犯了嘿嘿。
改进建议：
下次开始写之前先做好相应的设计，写出思路，再一步步开始完善代码。写的时候注重细节，一丝不苟，面面俱到，才能写出完美的程序。不要害怕代码的数量，多看看总会看懂的。人总是要跳出自己的舒适去的，这次就是一个很好的体会。只有跳出自己的舒适区才能进步，才能成长，不能拘泥于尽自己的世界。
第三次作业总结：
记得一开始看到只有四道题目还是很开心的，结果后来写着写着才发现事情并不简单。所以到最后只得了78分。前面两道题写起来都很轻松，后面两道题让我无能为力。可能是自身知识储备不足，以及逻辑思维不强，亦或是被较多的代码量吓傻了，让我有点不敢鼓起勇气面对那道题目，最终也只得了一个较低的分数。看到同学们都得了一百分，其实内心还是很羡慕的，同时也坚定了我要每次把作业做到最好的决心。还是有很大的提升空间的。
总结：
这几次作业，我对JAVA有了一个初步的了解。已经可以写出一些基本的程序了！学到的东西有很多，比如说JAVA的基本语法，一些很有用的函数，一些很好用的方法，一些很好用的工具......没想到一个月的时间就可以不害怕JAVA了。同时也有很多可以提升的地方：比如还要多看看慕课，多做做题目，了解更多函数的用法，了解更多面向对象与面向过程的差别，不能每次都在DDL之前才开始写PTA，要吸取经验，将书本上的知识转化为自己的，记牢，记住，并且学会合理的运用他们。学习一门语言并不简单，做好一件事情也绝非易事。希望我能付出更多的努力，更多的精力，努力钻研，沉浸式思考，多做多练，脚踏实地谋发展，努力努力再努力！
建议：我真的真的希望老师不要用全英文的课件了！真的看不是很懂啊,能不能在一些重要的东西旁边稍微注释一下中文呀。
