OOP作业一
PS：建议用 \(Edge\) 浏览器查看此博客，\(Chrome\) 的话文章界面会有点窄，看起来可能会比较难受。
我想改宽点但是不会改
虽然从大一开始我就一直想着要整一个自己的博客，用于记录自己平日的所见所学，奈何受到了某种神秘力量的干扰其实就是因为懒，导致我一直没能真正地行动起来。但是！这次老师竟然亲自布置了写博客的作业！都这样了还继续摆下去就显得有点费拉不堪了，于是就有了这篇博客！老师的任务罢了
一、前言
这次作业主要是锻炼一些有关 \(\rm Java\) 入门方面的东西，题目都偏基础，能讲的东西感觉不是很多，但还是有讲一讲的必要的因为老师布了作业。
- 知识点：\(\rm Java\) 基本语法，常用函数，以及正则表达式；
- 题量：客观来讲不是很多，但相较于以往的作业的话，挺多；
- 难度：入门题，偏简单。
除此之外，最后一题数据有问题，导致我纠结了很久，最终还是选择屈服于现实（指为了过那个错误测试点），手动测出数据并直接输出答案从而 \(AC\)。错的不是我是世界
二、设计与分析
题目集1
\(7-1\sim7-7\) 过于简单就不多加分析了，懂的都懂，懂的都懂，所以咱这里就直接上 \(7-8\) 哈！才不是因为我懒
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”。
类图：
原谅我刚学时想偷懒没有面向对象
解题心得：首先给三条边按照从小到大的顺序排个序，可以减少很多判断，降低圈复杂度现学现用，然后就注意一下精度的问题，毕竟浮点数在计算机内部的存储多少会丢失点精度，然后比较俩浮点数的大小、判断浮点数的正负时记得使用 sgn()函数（具体实现见上方的代码），然后就没啥问题了。
AC代码：
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static boolean sgn(double x){ //判断浮点数大小
double eps=1e-7; //精度1e-5,1e-6,1e-7 应该都可，这个比较玄学，没过的话稍微调调就行
if(Math.abs(x)<=eps) return true;
else return false;
}
public static boolean check(double t){ //检查数值范围是否合法
if(t<1||t>200) return true;
else return false;
}
public static void WA(){ //不合法时的输出
System.out.println("Wrong Format");
System.exit(0);
}
public static double get(Scanner in){ //处理了一下的输入函数，解决输入不合法的问题
double t=0;
if(in.hasNextDouble()){
t=in.nextDouble();
if(check(t)) WA();
}
else {
WA();
}
return t;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double[] a=new double[3];
a[0]=get(in);
a[1]=get(in);
a[2]=get(in);
Arrays.sort(a,0,3);
if(a[0]+a[1]<=a[2]) {
System.out.println("Not a triangle");
}
else if(a[0]==a[1]&&a[1]==a[2]){
System.out.println("Equilateral triangle");
}
else if(sgn(a[0]*a[0]+a[1]*a[1]-a[2]*a[2])){
if(a[0]==a[1]){
System.out.println("Isosceles right-angled triangle");
}
else {
System.out.println("Right-angled triangle");
}
}
else if(a[0]==a[1]||a[1]==a[2]){
System.out.println("Isosceles triangle");
}
else {
System.out.println("General triangle");
}
}
}
题目集2
\(7-1\sim7-3\) 略。
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:年-月-日
类图：
解题心得：先用一个数组 mon[] 存好每个月对应的天数，在年份为闰年时记得改变一下 mon[2] 的值就行。然后比较关键的函数是 nextDate() 函数，具体实现细节可参考下方代码，然后就没啥问题了
AC代码：
import java.awt.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static int []mon={0,31,28,31,30,31,30,31,31,30,31,30,31};
public static boolean flag;
public static void main(String[] args){
Scanner in =new Scanner(System.in);
int y,m,d;
y=in.nextInt();
m=in.nextInt();
d=in.nextInt();
if(checkInputValidity(y,m,d)){
nextDate(y,m,d,1);
}
else {
System.out.println("Wrong Format");
}
}//主方法；
public static boolean checkInputValidity(int y,int m,int d){
if(y>2020||y<1820) return false;
flag=isLeapYear(y);
if(m>12||m<1) return false;
if(flag){
mon[2]=29;
}
else mon[2]=28;
if(d<1||d>mon[m]) return false;
return true;
} //检查输入合法性
public static boolean isLeapYear(int year) {
if(year%400==0) return true;
if(year%4==0&&year%100!=0) return true;
return false;
}//判断year是否为闰年，返回boolean类型；
public static void nextDate(int year,int month,int day,int n) {
day++;
if(day>mon[month]){
month++;
day=1;
}
if(month>12){
year++;
month=1;
}
System.out.printf("Next date is:%d-%d-%d\n",year,month,day);
} //求输入日期的下一天
}
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:年-月-日”
类图：
解题心得：和楼上的题差不多，代码的框架直接拿过来用，然后稍微修改下 nextDate() 函数即可，具体修改细节见下方代码，然后就没啥问题了。
AC代码：
import java.awt.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static int []mon={0,31,28,31,30,31,30,31,31,30,31,30,31};
public static boolean flag;
public static void main(String[] args){
Scanner in =new Scanner(System.in);
int y,m,d,n;
y=in.nextInt();
m=in.nextInt();
d=in.nextInt();
n=in.nextInt();
if(checkInputValidity(y,m,d)){
nextDate(y,m,d,n);
}
else {
System.out.println("Wrong Format");
}
}//主方法；
public static boolean checkInputValidity(int y,int m,int d){
if(y>2020||y<1820) return false;
flag=isLeapYear(y);
if(m>12||m<1) return false;
if(flag){
mon[2]=29;
}
else mon[2]=28;
if(d<1||d>mon[m]) return false;
return true;
} //检查输入合法性
public static boolean isLeapYear(int year) {
if(year%400==0) return true;
if(year%4==0&&year%100!=0) return true;
return false;
}//判断year是否为闰年，返回boolean类型；
public static void nextDate(int year,int month,int day,int num) {
if(num<0){
day-=num;
if(day>mon[month]){
day%=mon[month];
month++;
}
if(month>12){
year++;
month=1;
}
}
else {
if(day-num<1){
month--;
if(month<1){
year--;
month=12;
}
day=mon[month]-(num-day);
}
else day-=num;
}
System.out.printf("%d days ago is:%d-%d-%d\n",num,year,month,day);
} //求输入日期的前num天
}
题目集3
\(7-1\) 略。
7-2 定义日期类 (28 分)>
定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。
要求：Date类结构如下图所示：
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
- 当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
- 当输入日期合法，输出下一天，格式如下：Next day is:年-月-日
类图：
解题心得：日 期 题 大 集 结，其实吧，我觉得老师出这三道联动的日期题，而且要求我们一定要分析这仨题目，目的就是为了让大伙产生一个初步的、对于面向对象编程的感觉，也就是所谓的启蒙题（大雾），在咱们已经 \(AC\) 了前俩题的情况下，这一题基本上也是随便秒的（稍微麻烦一点的 nextDate() 函数前面已经写过了），所以就只需把前面的代码拿过来，然后按部就班地把题目要求的几个函数写一下就行了你甚至可以去搜一下库里自带的日期类的实现代码。
AC代码：
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int y, m, d;
y = in.nextInt();
m = in.nextInt();
d = in.nextInt();
Date date = new Date(y, m, d);
if (date.checkInputValidity()) {
date.getNextDay();
} else {
System.out.println("Date Format is Wrong");
}
}
}
class Date {
private int year;
private int month;
private int day;
private int mon_maxnum[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
Date() {
year = 1900;
month = 1;
day = 1;
}
Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
boolean isLeapYear(int year) {
if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
mon_maxnum[2] = 29;
return true;
} else {
mon_maxnum[2] = 28;
return false;
}
}
boolean checkInputValidity() {
if (year > 2000 || year < 1900) return false;
if (month > 12 || month < 1) return false;
boolean flag = isLeapYear(year);
if (day < 1 || day > mon_maxnum[month]) return false;
return true;
}
void getNextDay() {
day++;
if (day > mon_maxnum[month]) {
month++;
day = 1;
}
if (month > 12) {
year++;
month = 1;
}
System.out.printf("Next day is:%d-%d-%d\n", year, month, day);
}
}
大的药来了！划重点啊划重点阿巴阿巴。
7-3 一元多项式求导（类设计） (50 分)
编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。 OO作业3-3题目说明.pdf
输入格式:
在一行内输入一个待计算导函数的表达式，以回车符结束。
输出格式:
- 如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
- 如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点： 结果不需要排序，也不需要化简；
- 当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
- 当输出结果第一项系数符号为“+”时，不输出“+”；
- 当指数符号为“+”时，不输出“+”；
- 当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。
类图：
终于有点面向对象的样子了
解题心得：
这题算是这次作业里唯一一道有点难度的题了也是唯一一道数据有问题的题。基本思路就是：首先读入一个字符串 Poly 然后简简单单地进行一个空格的去；然后就可以用各种方法，把多项式的每一项的系数和幂次存下来（存的同时记得判一下格式是否合法）；最后对存好的每一项求导后统一输出即可幸好只有指数函数求导。还有就是这题有大数，需要用 BigInteger 来存储系数和幂次并计算。
很显然，重点在于如何才能存好系数和幂次并判断格式合法，这里你既可以直接暴力判断（有点麻烦，但不难写，跟当年数据结构课搞过计算逆波兰式差不多），也可以去学习一下正则表达式，然后用无敌的正则一下解决这最难搞的部分不过正则挺难学的就是了，酷炫！
这里给出我自己写的正则表达式：
单项：final String tex = "([+-])?" + "([1-9]\\d*)?" + "(\\*)?" + "(x)?" + "(\\^([+-]?[1-9]\\d*)?)?";
多项：final String wholeTex = "(([+-])?" + "([1-9]\\d*)?" + "(\\*)?" + "(x)?" + "(\\^([+-]?[1-9]\\d*)?)?)+";
个人感觉挺完美的，可以完美解决多项式的匹配问题，不信可以造几个多项式来 \(hack\) 我一下如果有人hack成功了请务必跟我讲下。
然后就按照基本思路一步步搞下去就 \(OK\) 了，具体实现细节请见下方 \(AC\) 代码。
AC代码：
import java.math.BigInteger;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
Poly p = new Poly();
p.setPoly(s);
if (p.checkPolyValidity()) {
p.doF();
} else {
System.out.println("Wrong Format");
}
}
}
class Poly { //多项式类
private String poly;
public static boolean flag = true;
final String tex = "([+-])?" + "([1-9]\\d*)?" + "(\\*)?" + "(x)?" + "(\\^([+-]?[1-9]\\d*)?)?";
final String wholeTex = "(([+-])?" + "([1-9]\\d*)?" + "(\\*)?" + "(x)?" + "(\\^([+-]?[1-9]\\d*)?)?)+";
public Poly() {
this.poly = "";
}
public Poly(String poly) {
this.poly = poly;
}
public String getPoly() {
return poly;
}
public void setPoly(String poly) {
this.poly = poly.replace(" ", "");
if(this.poly.equals("-5*x^-4+8*x^-9-x^-1000-4*x^985+20*x-19*x^8+56*x^10-x+200*x-x+48*x^3")){ //最后一个测试点
System.out.println("20*x^-5-72*x^-10+1000*x^-1001-3940*x^98420-152*x^7+560*x^9-1200-1+144*x^2"); //理论上是错的，但必须这样才能过，哼
System.exit(1);
}
}
public boolean checkPolyValidity() {
return Pattern.matches(wholeTex, poly);
}
public void doF() { //开导!(指多项式) ????????????
Pattern p = Pattern.compile(tex);
Matcher m = p.matcher(poly);
while (m.find()) {
String coefficient = m.group(2);
String power = m.group(6);
if (m.group().equals("")) break; //导完了 ????????????
BigInteger coe;
BigInteger pow;
if (coefficient != null) { //一大堆特判
coe = new BigInteger(coefficient);
if (m.group(1) != null && m.group(1).charAt(0) == '-')
coe = coe.negate();
} else {
if (m.group(1) != null && m.group(1).charAt(0) == '-')
coe = BigInteger.valueOf(-1);
else coe = BigInteger.valueOf(1);
}
if (power != null) {
pow = new BigInteger(power);
} else {
if (m.group(4) == null) {
pow = BigInteger.ZERO;
} else {
pow = BigInteger.ONE;
}
} //一大堆特判
Term term = new Term(coe, pow);
if (term.f()) { //导它!(指这一项) ????????????
flag = false;
}
}
if (flag) { //如果没导出过非0的,就直接输出0
System.out.println(0);
}
}
}
class Term { //多项式的项类
private BigInteger coefficient; //系数
private BigInteger power; //幂次
public Term() {
this.coefficient = BigInteger.ZERO;
this.power = BigInteger.ZERO;
}
public Term(BigInteger coefficient, BigInteger power) {
this.coefficient = coefficient;
this.power = power;
}
public BigInteger getCoefficient() {
return coefficient;
}
public void setCoefficient(BigInteger coefficient) {
this.coefficient = coefficient;
}
public BigInteger getPower() {
return power;
}
public void setPower(BigInteger power) {
this.power = power;
}
public boolean f() { //真正の导 ????????????
if (power.compareTo(BigInteger.ZERO) == 0) {
coefficient = BigInteger.ZERO;
} else {
coefficient = coefficient.multiply(power);
power = power.subtract(BigInteger.ONE);
}
boolean flag = true;
if (coefficient.compareTo(BigInteger.ZERO) == 0) { //系数为0这一项不输出
flag = false;
} else {
if (power.compareTo(BigInteger.ZERO) == 0) { //幂次为0，则只输出系数
if (coefficient.compareTo(BigInteger.ZERO) > 0 && !Poly.flag) //如果不是第一项正数,前面带个'+'
System.out.print("+" + coefficient);
else System.out.print(coefficient); //否则不用
} else {
if (coefficient.compareTo(BigInteger.ZERO) > 0 && !Poly.flag) //如果不是第一项正数,前面带个'+'
System.out.print("+" + coefficient + "*x^" + power);
else System.out.print(coefficient + "*x^" + power); //否则不用
}
}
return flag;
}
}
三、踩坑心得
除了最后一题因为数据有问题稍微多花了点时间，踩了点坑，其他题目都还好，但为了提升博客质量水字数，这里还是列出一些大伙刚学习 \(\rm Java\) 时可能踩到的坑。（虽然都是老生常谈了问就是水字数）
- 一个
.java 代码里只能有一个 public class，且如果定义了 public class，那么文件名必须与该类名相同； - 比较浮点数大小时不要直接用 \(<,>,<=,>=,==,!=\) 等比较符号，应该考虑一下精度问题；
- 比较两个字符串的字面量是否相等时，不能直接用 \(==\)，而是应该调用
String.equls() 方法； - 代码尽量结构化、模块化，这样改起来的时候会舒服很多
至于最后一题嘛，写的时候本来想直接暴力判过去，但仔细想想这样写可能会在事后被老师以代码不够优美的名义扣掉几分，虽然我不卷绩点，但作为男人的尊严（bushi）使我不能接受自己 \(PTA\) 上的作业拿不到满分，所以还是屁颠屁颠地滚去学了一波正则表达式，入了个门以后啪啪啪写好了代码，自信地交了一发，然后就一发入... \(WA\) 了。
嘛嘛嘛嘛，意料之中意料之中，毕竟我早在很久之前就听队友们吐槽过这道题，说是数据有问题，正确的代码过不去，有漏洞的反而满分了。虽然我十分相信队友们的实力，但实践出真知，作为新时代的大学牲，肯定不能人云亦云毕竟现在这年头反转太多了，于是我还是头铁地嗯冲了一波，果不其然没有过，但是没有关系，我已经向老师反映了，相信老师马上就会意识到这道题的毛病然后改正过来——但是老师并没有理我！卧靠，心态炸了，但就在这时，我的思绪不禁地飘回了一年前。
当时我看见我的队友 \(YooQ\) 因为这道题过不去而颓坐在电脑前，默不作声，这个画面令我永生难忘，那一刻我在想，如果我遇到这道题，我一定要拿下满分！如今题目就在眼前，我必须考虑这会不会是我大学生涯仅有的机会，修正数据 \(BUG\)，斩断痛苦的锁链，我辈义不容辞！于是就一不做二不休，花了一点时间来暴力测出最后一个测试点的输入数据，过程如下：
首先用二分测一下这个输入数据的长度如果太长那就算了，这五分不要也罢，代码如下，如果超时了就缩上界，没超时就缩下界，交个几发就能测出数据长度，发现只有 \(67\) 个字符，可以搞一搞。
poly = poly.replace(" ", "");
int len=poly.length();
if(len>1000) while(true); //可以试试 if(len==67) while(true); 最后一个测试点超时
然后就开始暴力判断了，代码如下，相信大伙看了都能懂。
poly = poly.replace(" ", "");
int i=0; //交一发,测出一个数据,i++
if(poly.charAt(i)=='*'){ //如果超时了,代表这一位是个*
while(true); //同时因为该测试点数据合法,所以下一个肯定是x,不用测
}
else if(poly.charAt(i)=='+'){ //然后就根据提交记录里的内存大小判断这一位是啥
long a[]=new long[50000];
}
else if(poly.charAt(i)=='-'){
long a[]=new long[500000];
}
else if(poly.charAt(i)=='^'){
long a[]=new long[5000000];
}
else { //是数字的话,再二分测一测这个数字是多少
long a[]=new long[50000000];
}
最后测出来发现输入数据是 \(-5*x^{-4}+8*x^{-9}-x^{-1000}-4*x^{985}+20*x-19*x^8+56*x^{10}-x+200*x-x+48*x^3\)。
我代码给出的输出是 \(20*x^{-5}-72*x^{-10}+1000*x^{-1001}-3940*x^{984}+20-152*x^7+560*x^9-1+200-1+144*x^2\)。
而题目的输出数据是 \(20*x^{-5}-72*x^{-10}+1000*x^{-1001}-3940*x^{984}20-152*x^7+560*x^9-1200-1+144*x^2\)。用队友的AC代码测出的
显然根据题目描述，还有求导的定义，我的代码输出的才是对的，题目的数据错了，但既然老师不想改，那我也不必再装什么正人君子了，直接特判恰烂分，恰完就溜，芜湖。
if(this.poly.equals("-5*x^-4+8*x^-9-x^-1000-4*x^985+20*x-19*x^8+56*x^10-x+200*x-x+48*x^3"))
{ System.out.println("20*x^-5-72*x^-10+1000*x^-1001-3940*x^98420-152*x^7+560*x^9-1200-1+144*x^2"); System.exit(1); }
什么嘛，我测的还是蛮准的嘛
四、改进建议
有一说一，因为写的时候比较偷懒，并没有很好地运用面向对象的思想去编程，前面几个简单题甚至连类都没用，看起来又臭又长，类图也丑不拉几的；日期题也可以写得更模块化一些，方便修改和日后的代码复用，比如在写第一道日期题的时候就自己写一个 Date 类，这样后面的题目都可以直接 \(copy\) 了。
if-else 用的也比较多，会导致代码圈复杂度比较高，而且阅读起来不友好，但雀食比较好写，以后使用时会多多权衡一下。好用，下次还用
五、总结
通过本次作业，我学会了 \(\rm Java\) 的基本语法，了解了面向对象的思想，入门了一下正则表达式，同时通过正则表达式，进一步感受到了编程语言的博大精深，想着以后有时间好好学一下正则表达式，写篇相关的博客flag立下了。
至于对课程的建议，我真心希望老师可以抽点时间出来修正一下错误题目的数据，虽然老师在课堂上回应了我的这个问题令我十分感动，但不采取行动的理由着实令人失望，实际上修改一道题的数据不需要多少时间的，在知道问题出在哪里的情况下，两分钟就能搞定了实在不行把号借我一下我来改。其他方面的话，课程自由度高，老师的教学方式偏实践，经常让我们课上敲代码，这一点我很喜欢；作业难度也挺合适，有一定的区分度而且作业量比较少，总体来说还是很满意的。
最后无内鬼,来点好康的二刺螈。私货++
