一、前言：
从大一下学期开始学习java到现在，已经完成了三次PTA用java实现的大作业，三次PTA作业的难度在逐渐增大，每次最后一题都是从第一次PTA大作业里迭代而来，难度很大且每次提升，涉及的内容有很多，比如类，方法，Arraylist等，但最主要的还是类的设计，通过这三次作业，很深刻的认识的了设计对于程序的重要性，我目前在设计上还有很大的欠缺，导致每次题目的迭代都需要进行部分代码重构，甚至是全部重构，十分伤脑筋，但也有很大的收获。
二、设计与分析：
主要对每次作业的最后一题进行分析，与设计的阐述，因为除了最后一题，其他基本没难度，基本有一定基础就能过。
第一次PTA：
7-1 设计一个风扇Fan类
分数 4
入门
作者 殷伟凤
单位 浙江传媒学院
设计一个名为Fan的类表示一个风扇。这个类包括：
1.三个名为SlOW、MEDIUM和FAST，其值为1、2和3常量表示风扇的速度。
2.一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。
3.一个名为on的boolean类型私有数据域表示风扇是否打开（默认值为false）。
4.一个名为radius的double类型私有数据域表示风扇的半径（默认值为5）。
5.一个名为color的string类型数据域表示风扇的颜色（默认值为white）。
6.这四个成员变量(数据域)的访问器和修改器。
7.一个无参构造方法;
8.一个有参构造方法 public Fan(int fanSpeed,boolean fanOn,double fanRadius,String fanColor) { ... }，
9.一个名为toString()的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就会返回一个由"fan is off"和风扇颜色以及半径组合成的字符串。
请在自己的草稿本上画出UML图，养成良好的设计习惯。
要求：创建两个Fan对象：
第一个对象利用无参构造方法构造默认风扇对象Fan1；
第二个对象依据输入的风扇属性，调用有参构造方法构造自定义风扇对象Fan2。
通过调用它们的toString方法显示这些对象。
输入格式:
第二个对象的属性
输出格式:
分别输出默认风扇和自定义风扇的速度、颜色、半径以及风扇是否打开
输入样例:
在这里给出一组输入。例如：
2
True
6
Red
输出样例:
在这里给出相应的输出。例如：
------- Default-------
speed 1
color white
radius 5.0
fan is off
-------My Fan-------
speed 2
color Red
radius 6.0
fan is onfan is on
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int speed = sc.nextInt();
String str1 = sc.next();
str1 = str1.toLowerCase();
boolean on;
if(str1.equals("true")){
on = true;
}else{
on = false;
}
double radius = sc.nextDouble();
String color = sc.next();
Fan fan = new Fan();
System.out.println("-------\nDefault\n-------");
String[] str = fan.ToString();
for(int i = 0 ; i < 4 ; i++){
System.out.println(str[i]);
}
Fan fan1 = new Fan(speed,on,radius,color);
System.out.println("-------\nMy Fan\n-------");
String []str2 = fan1.ToString();
for(int i = 0 ; i < 4 ; i++){
System.out.println(str2[i]);
}
}
}
class Fan {
private int SLOW = 1;
private int MEDIUM = 2;
private int FAST = 3;
private int speed = SLOW;
private boolean on = false;
private double radius = 5.0;
private String color = "white";
public Fan(){
}
public Fan(int FanSpeed,boolean FanOn,double FanRadius,String FanColor){
speed = FanSpeed;
on = FanOn;
radius = FanRadius;
color = FanColor;
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public boolean isOn() {
return on;
}
public void setOn(boolean on) {
this.on = on;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String[] ToString(){
String[] str = new String[4];
str[0] = "speed " + speed;
str[1] = "color " + color;
String str1 = String.format("%.1f",radius);
str[2] = "radius " + str1;
if(on){
str[3] = "fan is on";
}else{
str[3] = "fan is off";
}
return str;
}
}
分析：本题考察的是类的创建与使用，创建类，输入信息，输出信息就行，很简单。
7-2 类和对象的使用
分数 6
简单
全屏浏览
切换布局
作者 向北
单位 丽江文化旅游学院
1.创建一个类Student,具体属性和方法如下：
属性：（全部私有,数据类型自己选择使用）
姓名（name）,性别(sex)，学号（studentID），年龄(age)，专业（major）
方法：
（1）定义一个空参数构造器public Student();
（2）定义一个多参数的构造器，用于为所有属性赋值public Student(String name,String sex,String studentID,int age,String major)
（3）由于所有属性私有的，为所有属性提供getter（）和setter（）方法；
（4）public String toString()用于返回学生的所有属性信息；
（5）public void printInfo()用于打印学生的信息
2.定义一个测试类Test，在main方法中创建一个Student对象，根据提示输入学生信息保存在对象中，调用printInfo()方法输出学生信息。
3.输出结果参考“输出样例”
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
姓名：Tom，性别：23，学号：20221201234,年龄：23,专业：计算机科学
输入样例:
在这里给出一组输入。例如：
张三
男
23
计算机科学
2022120
输出样例:
在这里给出相应的输出。例如：
姓名：张三，性别：男，学号：2022120,年龄：23,专业：计算机科学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
import java.util.*;
public class Main{
public static void main(String[] args){
Test test = new Test();
test.main();
}
}
class Test {
public void main(){
Scanner sc = new Scanner(System.in);
String name = sc.next();
String sex = sc.next();
int age = sc.nextInt();
String major = sc.next();
String studentID = sc.next();
Student student = new Student(name,sex,studentID,age,major);
student.printlnfo();
}
}
class Student {
private String name;
private String sex;
private String studentID;
private int age;
private String major;
public Student(){
}
public Student(String name,String sex,String studentID,int age,String major){
this.age = age;
this.major = major;
this.name = name;
this.sex = sex;
this.studentID =studentID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getStudentID() {
return studentID;
}
public void setStudentID(String studentID) {
this.studentID = studentID;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String ToString(){
String str = new String("姓名：" + name + "，性别：" + sex
+ "，学号：" + studentID + ",年龄：" + age + ",专业：" + major);
return str;
}
public void printlnfo(){
String str1;
str1 = ToString();
System.out.println(str1);
}
}
分析：与第一题一样，创建类，输入，输出就行。
后两题与第二题差别不大，就不过多叙述，重点是最后一题。
7-5 答题判题程序-1
分数 74
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、题目内容
一行为一道题，可以输入多行数据。
格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
3、答题信息
答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。
格式："#A:"+答案内容
格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。
样例：#A:2 #A:78
2是题号为1的题目的答案
78是题号为2的题目的答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、答题信息
一行为一道题的答题信息，根据题目的数量输出多行数据。
格式：题目内容+" ~"+答案
样例：1+1=~2
2+2= ~4
3、判题信息
判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。
格式：判题结果+" "+判题结果
格式约束：
1、判题结果输出只能是true或者false，
2、判题信息的顺序与输入答题信息中的顺序相同
样例：true false true
输入样例1:
单个题目。例如：
1
#N:1 #Q:1+1= #A:2
#A:2
end
输出样例1:
在这里给出相应的输出。例如：
1+1=~2
true
输入样例2:
单个题目。例如：
1
#N:1 #Q:1+1= #A:2
#A:4
end
输出样例2:
在这里给出相应的输出。例如：
1+1=~4
false
输入样例3:
多个题目。例如：
2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:4
end
输出样例3:
在这里给出相应的输出。例如：
1+1=~2
2+2=~4
true true
输入样例4:
多个题目。例如：
2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:2
end
输出样例4:
在这里给出相应的输出。例如：
1+1=~2
2+2=~2
true false
输入样例5:
多个题目，题号顺序与输入顺序不同。例如：
2
#N:2 #Q:1+1= #A:2
#N:1 #Q:5+5= #A:10
#A:10 #A:2
end
输出样例5:
在这里给出相应的输出。例如：
5+5=~10
1+1=~2
true true
输入样例6:
含多余的空格符。例如：
1
#N:1 #Q: The starting point of the Long March is #A:ruijin
#A:ruijin
end
输出样例6:
在这里给出相应的输出。例如：
The starting point of the Long March is~ruijin
true
输入样例7:
含多余的空格符。例如：
1
#N: 1 #Q: 5 +5= #A:10
#A:10
end
输出样例7:
在这里给出相应的输出。例如：
5 +5=~10
true
设计建议:
以下是针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：
题目类（用于封装单个题目的信息）：
属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、
判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）
属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标 准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能 对应
答卷类（用于封装答题信息）
属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
代码长度限制
16 KB
时间限制
400 ms
内存限制
64MB
栈限制
8192 KB
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner (System.in);
int n = sc.nextInt();
Answer[] answers = new Answer[n];
Issue[] issues = new Issue[n];
String str = new String("0");
String end = new String("end");
for(int i = 0; i<n+3&&!str.equals(end);i++){
str = sc.nextLine();
String[] str1 = str.split("([ ]*[#NQA:][ ]*)+");
if(i>=1&&i<n+1) {
Issue issue =new Issue();
issue.setIssueNum(str1[1]);
issue.setIssueMain(str1[2]);
issue.setIssueAnswer(str1[3]);
issues[i-1] = issue;
}
if(i==n+1){
for(int j = 0;j<n;j++) {
Answer answer = new Answer();
answer.setAnswer(str1[j+1]);
answers[j] = answer;
}
}
}
Paper paper = new Paper(answers,issues);
paper.sort();
paper.judge();
paper.printlnof();
}
}
class Paper {
private Answer[] answers = new Answer[]{};
private Issue[] issues = new Issue[]{};
public Paper(){
}
public Paper(Answer[] answers,Issue[] issues){
this.answers = answers;
this.issues = issues;
}
public Answer[] getAnswers() {
return answers;
}
public void setAnswers(Answer[] answers) {
this.answers = answers;
}
public Issue[] getIssues() {
return issues;
}
public void setIssues(Issue[] issues) {
this.issues = issues;
}
public void sort(){
for(int i = 0; i < issues.length-1 ; i++){
for(int j = i + 1 ; j < issues.length ; j++){
if(Integer.parseInt(issues[i].getIssueNum()) > Integer.parseInt(issues[j].getIssueNum())){
Issue issue = issues[i];
issues[i] = issues[j];
issues[j] = issue;
}
}
}
}
public void judge(){
for(int i = 0; i < answers.length ; i++){
if(answers[i].getAnswer().equals(issues[i].getIssueAnswer())){
answers[i].setJudge(true);
}else{
answers[i].setJudge(false);
}
}
}
public void printlnof(){
for(int i = 0; i < answers.length ; i++){
String str = new String(issues[i].getIssueMain() + "~" + answers[i].getAnswer());
System.out.println(str);
}
for(int i = 0 ;i < answers.length ; i++){
String str1 = String.valueOf(answers[i].getJudge());
if(i!=answers.length-1) {
System.out.printf("%s ",str1);
}else{
System.out.printf("%s",str1);
}
}
}
}
class Answer {
private String answer;
private boolean judge;
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
public boolean getJudge() {
return judge;
}
public void setJudge(boolean judge) {
this.judge = judge;
}
}
class Issue {
private String issueNum;
private String issueMain;
private String issueAnswer;
public Issue() {
}
public Issue(String issueNum, String issueMain, String issueAnswer ) {
this.issueNum = issueNum;
this.issueMain = issueMain;
this.issueAnswer = issueAnswer;
}
public String getIssueNum() {
return issueNum;
}
public void setIssueNum(String issueNum) {
this.issueNum = issueNum;
}
public String getIssueMain() {
return issueMain;
}
public void setIssueMain(String issueMain) {
this.issueMain = issueMain;
}
public String getIssueAnswer() {
return issueAnswer;
}
public void setIssueAnswer(String issueAnswer) {
this.issueAnswer = issueAnswer;
}
public String getRealIssueMain(){
String realIssueMain = issueMain.substring(2);
return realIssueMain;
}
}
设计与分析：我这次的设计在现在看来真的是太不行了，虽然最后拿了满分，但是把题目的检查，
以及输出都写在了实体类里，不符合MVC原则，对于输入的处理也没有单独分一个类，而是写入了主函数里，且有比较大的取巧的成分在里面，总的思路就是把输入的进行分割然后存进数组里，再传给试卷里，在试卷里进行批改和输出相应的结果，如果标准答案和输入的答案equals，answer里的judge就是true,对不上就是false，在进行对答案之前，先把试卷里的题目按照题号排序，使其能与答案对应上。
这个题目在刚开始看到的时候就觉得非常的困难，认为写不出来，但真正去做了才发现，真的很难，但也不是无法完成，虽然在设计上一言难尽，但也勉强拿了满分且收获了很多，比如类的创建以及运用，学会了对于字符串split，substring等方法的使用，是一个非常好的题目。
类图如下：
第二次PTA最后一题：
7-4 答题判题程序-2
分数 73
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-1基础上增补或者修改的内容。
要求输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三种，三种信息可能会打乱顺序混合输入：
1、题目信息
一行为一道题，可输入多行数据（多道题）。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
一行为一张试卷，可输入多行数据（多张卷）。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：
#T:1 3-5 4-8 5-2
3、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。
格式："#S:"+试卷号+" "+"#A:"+答案内容
格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
22是1号试卷的顺序第2题的题目答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：
3+2=~5~true
4+6=~22~false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：
5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
输入样例1:
一张试卷一张答卷。试卷满分不等于100。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#S:1 #A:5 #A:22
end
输出样例1:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
2+2=~22~false
0 0~0
输入样例2:
一张试卷一张答卷。试卷满分不等于100。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#S:1 #A:5 #A:22
end
输出样例2:
在这里给出相应的输出。例如：
1+1=~5~false
2+2=~22~false
0 0~0
输入样例3:
一张试卷、一张答卷。各类信息混合输入。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
1+1=~5~false
2+2=~4~true
0 30~30
输入样例4:
试卷题目的顺序与题号不一致。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 2-70 1-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:22
end
输出样例:
在这里给出相应的输出。例如：
2+2=~5~false
1+1=~22~false
0 0~0
输入样例5:
乱序输入。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
end
输出样例:
在这里给出相应的输出。例如：
3+2=~5~true
2+2=~22~false
70 0~70
输入样例6:
乱序输入+两份答卷。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
3+2=~5~true
2+2=~22~false
70 0~70
3+2=~5~true
2+2=~4~true
70 30~100
输入样例7:
乱序输入+分值不足100+两份答卷。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
3+2=~5~true
2+2=~22~false
7 0~7
3+2=~5~true
2+2=~4~true
7 6~13
输入样例8:
乱序输入+分值不足100+两份答卷+答卷缺失部分答案。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#T:2 2-5 1-3 3-2
#S:2 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
3+2=~5~true
2+2=~22~false
7 0~7
2+2=~5~false
1+1=~4~false
answer is null
0 0 0~0
输入样例9:
乱序输入+分值不足100+两份答卷+无效的试卷号。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:3 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<String> issueStr = new ArrayList<>();
List<String> paperStr = new ArrayList<>();
List<String> answerPaperStr = new ArrayList<>();
List<Issue> issueList = new ArrayList<>();
PaperBags paperBags = new PaperBags();
List<Answerpaper> answerpaperList = new ArrayList<>();
String stop = "end";
while(true){
String str = sc.nextLine();
if(str.equals(stop)){
break;
}
if(str.matches(" *[#][N][:].+")){
issueStr.add(str);
}
if(str.matches(" *[#][T][:].+")){
paperStr.add(str);
}
if(str.matches(" *[#][S][:].+")){
answerPaperStr.add(str);
}
}
for(int i = 0 ; i < issueStr.size() ; i++){
String[] parts = issueStr.get(i).split("([ ]*[#NQA:][ ]*)+");
Issue issue = new Issue(Integer.parseInt(parts[1]),parts[2],parts[3]);
issueList.add(issue);
}
for(int i = 0 ; i < paperStr.size() ; i++) {
String[] parts = paperStr.get(i).split("[#T:\\- ]+");
List<Issue> issueList1 = new ArrayList<>();
for (int j = 0; 2 * (j + 1) < parts.length-1; j++) {
for (int k = 0; k < issueList.size(); k++) {
if (Integer.parseInt(parts[2 * (j + 1)]) == issueList.get(k).getIssueNum()) {
Issue issue = new Issue(issueList.get(k).getIssueNum(), issueList.get(k).getIssueMain(), issueList.get(k).getIssueAnswer());
issue.setScore(Integer.parseInt(parts[2 * (j + 1) + 1]));
issueList1.add(issue);
}
}
}
Paper paper = new Paper(Integer.parseInt(parts[1]), issueList1);
paperBags.getPaperList().add(paper);
}
for(int i = 0 ; i < answerPaperStr.size() ; i++){
Answerpaper answerpaper = new Answerpaper();
String[] parts = answerPaperStr.get(i).split("[#SA: ]+");
for(int j = 2 ; j < parts.length ; j++){
Answer answer = new Answer(parts[j]);
answerpaper.getAnswerList().add(answer);
}
answerpaper.setAnswerpaperNumber(Integer.parseInt(parts[1]));
answerpaperList.add(answerpaper);
}
paperBags.checkPaperscore();
for(int i = 0 ; i < answerpaperList.size() ; i++){
int j = 0;
for(j = 0 ; j < paperBags.getPaperList().size() ; j++){
if(answerpaperList.get(i).getAnswerpaperNumber() == paperBags.getPaperList().get(j).getPaperNum()){
answerpaperList.get(i).judge(paperBags.getPaperList().get(j));
answerpaperList.get(i).calEndScore();
answerpaperList.get(i).printof(paperBags.getPaperList().get(j));
break;
}
}
if(j==paperBags.getPaperList().size()){
System.out.println("The test paper number does not exist");
}
}
}
}
class Issue {
private int issueNum;
private String issueMain;
private String standardAnswer;
private int score;
public Issue() {
}
public Issue(int issueNum, String issueMain, String issueAnswer ) {
this.issueNum = issueNum;
this.issueMain = issueMain;
this.standardAnswer = issueAnswer;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getIssueNum() {
return issueNum;
}
public void setIssueNum(int issueNum) {
this.issueNum = issueNum;
}
public String getIssueMain() {
return issueMain;
}
public void setIssueMain(String issueMain) {
this.issueMain = issueMain;
}
public String getIssueAnswer() {
return standardAnswer;
}
public void setIssueAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class Answer {
private String answer;
private boolean judge;
private int endScore = 0;
public int getEndScore() {
return endScore;
}
public void setEndScore(int endScore) {
this.endScore = endScore;
}
public boolean isJudge() {
return judge;
}
public void setJudge(boolean judge) {
this.judge = judge;
}
public Answer() {
}
public Answer(String answer) {
this.answer = answer;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Paper {
private int paperNum;
private List<Issue> issueList = new ArrayList<>();
public Paper(){
}
public Paper(int paperNum, List<Issue> issueList) {
this.paperNum = paperNum;
this.issueList = issueList;
}
public int getPaperNum() {
return paperNum;
}
public void setPaperNum(int paperNum) {
this.paperNum = paperNum;
}
public List<Issue> getIssueList() {
return issueList;
}
public void setIssueList(List<Issue> issueList) {
this.issueList = issueList;
}
public int calSumscore(){
int sum = 0;
for(int i = 0 ; i < issueList.size() ; i++){
sum = sum + issueList.get(i).getScore();
}
return sum;
}
}
class Answerpaper {
private int answerpaperNumber;
private List<Answer> answerList = new ArrayList<>();
private int endScore = 0;
public int getEndScore() {
return endScore;
}
public void setEndScore(int endScore) {
this.endScore = endScore;
}
public Answerpaper() {
}
public int getAnswerpaperNumber() {
return answerpaperNumber;
}
public void setAnswerpaperNumber(int answerpaperNumber) {
this.answerpaperNumber = answerpaperNumber;
}
public Answerpaper(int answerpaperNumber, List<Answer> answerList) {
this.answerpaperNumber = answerpaperNumber;
this.answerList = answerList;
}
public List<Answer> getAnswerList() {
return answerList;
}
public void setAnswerList(List<Answer> answerList) {
this.answerList = answerList;
}
public void judge(Paper paper){
if(answerList.size()-paper.getIssueList().size()>0){
for(int i = 0 ; i < paper.getIssueList().size() ; i++){
if(answerList.get(i).getAnswer().equals(paper.getIssueList().get(i).getIssueAnswer())){
answerList.get(i).setJudge(true);
answerList.get(i).setEndScore(paper.getIssueList().get(i).getScore());
}else{
answerList.get(i).setJudge(false);
}
}
}else{
for(int i = 0 ; i < answerList.size() ; i++){
if(answerList.get(i).getAnswer().equals(paper.getIssueList().get(i).getIssueAnswer())){
answerList.get(i).setJudge(true);
answerList.get(i).setEndScore(paper.getIssueList().get(i).getScore());
}else{
answerList.get(i).setJudge(false);
}
}
}
}
public void calEndScore(){
int sum = 0;
for(int i = 0 ; i < answerList.size() ; i++){
sum = sum + answerList.get(i).getEndScore();
}
endScore = sum;
}
public void printof(Paper paper) {
int n = paper.getIssueList().size()-answerList.size();
if(n<=0){
for(int i = 0 ; i < paper.getIssueList().size() ; i++){
System.out.println(paper.getIssueList().get(i).getIssueMain() + "~" + answerList.get(i).getAnswer() + "~" + answerList.get(i).isJudge());
}
for(int i = 0 ; i < paper.getIssueList().size() ; i++){
if(i==paper.getIssueList().size()-1){
System.out.printf("%d~%d\n",answerList.get(i).getEndScore(),getEndScore());
}else {
System.out.printf("%d ", answerList.get(i).getEndScore());
}
}
}else{
for(int i = 0 ; i < answerList.size() ; i++){
System.out.println(paper.getIssueList().get(i).getIssueMain() + "~" + answerList.get(i).getAnswer() + "~" + answerList.get(i).isJudge());
}
for(int i = 0 ; i<n ; i++){
System.out.println("answer is null");
}
for(int i = 0 ; i < answerList.size() ; i++){
System.out.printf("%d ",answerList.get(i).getEndScore());
}
for(int i = 0 ; i < n ; i++){
if(i==n-1){
System.out.printf("%d~%d\n",0,getEndScore());
}else{
System.out.printf("%d ",0);
}
}
}
}
}
class PaperBags {
private List<Paper> paperList = new ArrayList<>();
public PaperBags() {
}
public PaperBags(List<Paper> paperList) {
this.paperList = paperList;
}
public List<Paper> getPaperList() {
return paperList;
}
public void setPaperList(List<Paper> paperList) {
this.paperList = paperList;
}
public void checkPaperscore(){
for(int i = 0 ; i < paperList.size() ; i++){
if(paperList.get(i).calSumscore()!=100){
System.out.printf("alert: full score of test paper%d is not 100 points\n",paperList.get(i).getPaperNum());
}
}
}
}
设计与分析:本次的最后一题相较于第一次要难的多，添加了乱序输入，试卷信息以及答卷信息，试卷信息里为试卷里的题目顺序，试卷里的题目顺序会与输入时的题目顺序有所不同，这样一来，我第一次的代码就完全无法符合这次题目的要求，需要进行重构，新加了几个类，但依旧没有添加处理类，都是实体类在做事，把处理类做的事放进了实体类里，比如我对题目答案的检测都是在答卷里完成的。
主要的设计思路是先将输入的全部存进字符串类型的Arraylist里，等接收到end标识符输入停止以后再用循环进行分割存储，添加了试卷袋类，虽然没什么用，只是用于放试卷类型的Arraylist，还添加了Answerpapaer，即答卷类，用于存放答案类型的Arraylist以及答卷的总分和答卷的编号，等书卷分割完以后，按照试卷里题目的顺序，从存好的Issue类型Arraylist里找到对应的题号，一个一个放入试卷里，实现试卷的题目顺序与试卷想要的题目顺序一致，后通过答卷的答卷号来寻找对应的试卷，再进行check，也就是批改工作，但我进行批改工作的方法放在了Answerpaper里，所以找到试卷以后，要对方法进行传参，输出也写在了Answerpaper里，用相同的方法进行输出。
虽然最终也是侥幸拿了满分，但还是深刻的认识到了自己的不足，尤其是在类的设计方面，前两次的最后一题里，关于类仅仅只有实体类，没有类似于Agent之类的处理类来处理数据，在实际编写时也遇到了比较多的问题。
类图：
第三次PTA最后一题:
7-3 答题判题程序-3
分数 84
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分五种，信息可能会打乱顺序混合输入。
1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：
#T:1 3-5 4-8 5-2
3、学生信息
学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。
格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：
格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号
5、删除题目信息
删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+题目号
格式约束：
题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：
alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。
样例：
3+2=~5~true
4+6=~22~false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、被删除的题目提示信息
当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。
5、题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息
输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
例如：wrong format:2 #Q:2+2= #4
7、试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。
8、学号引用错误提示信息
如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。
本题暂不考虑出现多张答卷的信息的情况。
输入样例1:
简单输入，不含删除题目信息。例如：
#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-5
end
输出样例1:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
20201103 Tom: 0~0
输入样例2:
简单输入，答卷中含多余题目信息（忽略不计）。例如：
#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-2 #A:2-3
end
输出样例3
简单测试，含删除题目信息。例如：
alert: full score of test paper1 is not 100 points
1+1=~2~true
20201103 Tom: 5~5
输入样例3:
简单测试，含删除题目信息。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例3:
在这里给出相应的输出，第二题由于被删除，输出题目失效提示。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例4:
简单测试，含试卷无效题目的引用信息以及删除题目信息（由于题目本身无效，忽略）。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例4:
输出不存在的题目提示信息。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
non-existent question~0
20201103 Tom: 0 0~0
输入样例5:
综合测试，含错误格式输入、有效删除以及无效题目引用信息。例如：
#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例5:
在这里给出相应的输出。例如：
wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例6:
综合测试，含错误格式输入、有效删除、无效题目引用信息以及答案没有输入的情况。例如：
#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5
#D:N-2
end
输出样例6:
答案没有输入的优先级最高。例如：
wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
answer is null
20201103 Tom: 0 0~0
输入样例7:
综合测试，正常输入，含删除信息。例如：
#N:2 #Q:2+2= #A:4
#N:1 #Q:1+1= #A:2
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:2-4 #A:1-5
#D:N-2
end
输出样例7:
例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例8:
综合测试，无效的试卷引用。例如：
#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:2 20201103 #A:1-5 #A:2-4
end
输出样例8:
例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
输入样例9:
无效的学号引用。例如：
#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201106 Tom
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例9:
答案照常输出，判分时提示错误。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
20201103 not found
输入样例10:
信息可打乱顺序输入：序号不是按大小排列，各类信息交错输入。但本题不考虑引用的题目在被引用的信息之后出现的情况（如试卷引用的所有题目应该在试卷信息之前输入），所有引用的数据应该在被引用的信息之前给出。例如：
#N:3 #Q:中国第一颗原子弹的爆炸时间 #A:1964.10.16
#N:1 #Q:1+1= #A:2
#X:20201103 Tom-20201104 Jack-20201105 Www
#T:1 1-5 3-8
#N:2 #Q:2+2= #A:4
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例10:
答案按试卷中的题目顺序输出。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
中国第一颗原子弹的爆炸时间~4~false
20201103 Tom: 0 0~0
代码长度限制
30 KB
时间限制
1500 ms
内存限制
64 MB
栈限制
8192 KB
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<String> issueStr = new ArrayList<>();
List<String> paperStr = new ArrayList<>();
List<String> answerPaperStr = new ArrayList<>();
List<String> WrongStr = new ArrayList<>();
List<Student> studentList = new ArrayList<>();
List<Delete> deleteList = new ArrayList<>();
List<Issue> issueList = new ArrayList<>();
PaperBags paperBags = new PaperBags();
List<Answerpaper> answerpaperList = new ArrayList<>();
String stop = "end";
while(true){
String str = sc.nextLine();
if(str.equals(stop)) {
break;
}else if(str.matches("[#][N][:][0-9]+[ ][#][Q][:].+[ ][#][A][:].*")){
issueStr.add(str);
}else if(str.matches("^#T:[0-9]+([ ][0-9]+\\-[0-9]+)*")){
paperStr.add(str);
}else if(str.matches("^#S:\\d+ \\d+( #A:\\d+-.*?)*?")){
answerPaperStr.add(str);
}else if(str.matches(("[#][X][:][0-9]+([ ]\\w+[-][0-9]+)*[ ]\\w+"))){
String[] massage = str.split("[#X:\\- ]+");
for(int i = 1 ; 2*i < massage.length ; i++){
Student student = new Student(massage[2*i-1],massage[2*i]);
studentList.add(student);
}
}else if(str.matches("[#][D][:][N][-][0-9]+")){
String[] DeleteNumber = str.split("[#D:N\\- ]+");
Delete delete = new Delete(Integer.parseInt(DeleteNumber[1]));
deleteList.add(delete);
}else{
WrongStr.add(str);
}
}
for(int i = 0 ; i < issueStr.size() ; i++){
String[] parts = issueStr.get(i).split("([ ]{0,1}[#NQA:])+");
Issue issue = new Issue();
issue.setIssueNum(Integer.parseInt(parts[1]));
issue.setIssueMain(parts[2]);
if(parts.length == 3){
issue.setIssueAnswer("");
}else{
issue.setIssueAnswer(parts[3].trim());
}
issueList.add(issue);
}
for(int i = 0 ; i < paperStr.size() ; i++) {
String[] parts = paperStr.get(i).split("[#T:\\- ]+");
List<Issue> issueList1 = new ArrayList<>();
for (int j = 0; 2 * (j + 1) < parts.length-1; j++) {
int k;
for ( k = 0; k < issueList.size(); k++) {
if (Integer.parseInt(parts[2 * (j + 1)]) == issueList.get(k).getIssueNum()) {
Issue issue = new Issue(issueList.get(k).getIssueNum(), issueList.get(k).getIssueMain(), issueList.get(k).getIssueAnswer());
issue.setScore(Integer.parseInt(parts[2 * (j + 1) + 1]));
issueList1.add(issue);
break;
}
}
if(k==issueList.size()){
String noExit = "non-existent question~0";
Issue issue1 = new Issue(Integer.parseInt(parts[2*(j+1)]),noExit,noExit);
issue1.setScore(Integer.parseInt(parts[2*(j+1)+1]));
issueList1.add(issue1);
}
}
Paper paper = new Paper(Integer.parseInt(parts[1]), issueList1);
paperBags.getPaperList().add(paper);
}
for(int i = 0 ; i < answerPaperStr.size() ; i++){
Answerpaper answerpaper = new Answerpaper();
String[] parts = answerPaperStr.get(i).split("([ ]*[#SA:])+");
String[] parts1 = parts[1].split("[ ]+");
for(int j = 2 ; j < parts.length ; j++){
Answer answer = new Answer();
String[] parts2 = parts[j].split("-");
answer.setAnswerNumber(Integer.parseInt(parts2[0]));
if(parts2.length==1){
answer.setAnswer("");
}else{
answer.setAnswer(parts2[1]);
}
answerpaper.getAnswerList().add(answer);
}
answerpaper.setAnswerpaperNumber(Integer.parseInt(parts1[0]));
answerpaper.setID(parts1[1]);
answerpaperList.add(answerpaper);
}
Teacher teacher = new Teacher(answerpaperList,paperBags,deleteList,studentList);
for(int i = 0 ; i < WrongStr.size() ; i++){
System.out.println("wrong format:" + WrongStr.get(i));
}
teacher.checkPaperScore();
teacher.checkAnswer();
teacher.printOf();
}
}
class Teacher {
private List<Answerpaper> answerpaperList = new ArrayList<>();
private PaperBags paperBags = new PaperBags();
private List<Delete> deleteList = new ArrayList<>();
private List<Student> studentList = new ArrayList<>();
public Teacher() {
}
public Teacher(List<Answerpaper> answerpaperList, PaperBags paperBags, List<Delete> deleteList, List<Student> studentList) {
this.answerpaperList = answerpaperList;
this.paperBags = paperBags;
this.deleteList = deleteList;
this.studentList = studentList;
}
public List<Student> getStudentList() {
return studentList;
}
public void setStudentList(List<Student> studentList) {
this.studentList = studentList;
}
public List<Answerpaper> getAnswerpaperList() {
return answerpaperList;
}
public void setAnswerpaperList(List<Answerpaper> answerpaperList) {
this.answerpaperList = answerpaperList;
}
public PaperBags getPaperBags() {
return paperBags;
}
public void setPaperBags(PaperBags paperBags) {
this.paperBags = paperBags;
}
public List<Delete> getDeleteList() {
return deleteList;
}
public void setDeleteList(List<Delete> deleteList) {
this.deleteList = deleteList;
}
public void checkPaperScore(){
for(int i = 0 ; i < paperBags.getPaperList().size() ; i++){
if(paperBags.getPaperList().get(i).calSumscore()!=100){
System.out.printf("alert: full score of test paper%d is not 100 points\n",paperBags.getPaperList().get(i).getPaperNum());
}
}
}
public void checkAnswer(){
String noExit = "non-existent question~0";
for(int i = 0 ; i < answerpaperList.size() ; i++){
for(int j = 0 ; j <paperBags.getPaperList().size() ; j++){
if(answerpaperList.get(i).getAnswerpaperNumber() == paperBags.getPaperList().get(j).getPaperNum()){
for(int k = 0 ; k < paperBags.getPaperList().get(j).getIssueList().size() ; k++){
int r;
int sb = answerpaperList.get(i).getAnswerList().size();
for(r = 0 ; r < answerpaperList.get(i).getAnswerList().size() ; r++){
if(k+1 == answerpaperList.get(i).getAnswerList().get(r).getAnswerNumber()){
int q;
for(q = 0 ; q < deleteList.size() ; q++){
if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueNum() == deleteList.get(q).getNumber()){
int a = deleteList.get(q).getNumber();
String s = "the question " + a + " invalid~0";
answerpaperList.get(i).getAnswerList().get(r).setEndScore(0);
answerpaperList.get(i).getAnswerList().get(r).setJudge(false);
paperBags.getPaperList().get(j).getIssueList().get(k).setIssueMain(s);
break;
}
}
if(q == deleteList.size()){
if(!paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().equals(noExit)){
if(answerpaperList.get(i).getAnswerList().get(r).getAnswer().equals(
paperBags.getPaperList().get(j).getIssueList().get(k).getIssueAnswer())){
answerpaperList.get(i).getAnswerList().get(r).setEndScore(paperBags.getPaperList().get(j).getIssueList().get(k).getScore());
answerpaperList.get(i).getAnswerList().get(r).setJudge(true);
}else{
answerpaperList.get(i).getAnswerList().get(r).setEndScore(0);
answerpaperList.get(i).getAnswerList().get(r).setJudge(false);
}
}else{
answerpaperList.get(i).getAnswerList().get(r).setEndScore(0);
answerpaperList.get(i).getAnswerList().get(r).setJudge(false);
}
}
break;
}
}
if(r==answerpaperList.get(i).getAnswerList().size()){
String noAnswer = "answer is null";
paperBags.getPaperList().get(j).getIssueList().get(k).setIssueMain(noAnswer);
}
}
}
}
}
}
public void printOf(){
String noAnswer = "answer is null";
String noExit = "non-existent question~0";
for(int i = 0 ; i < answerpaperList.size() ; i++){
int j;
for(j = 0 ; j < paperBags.getPaperList().size() ; j++){
if(answerpaperList.get(i).getAnswerpaperNumber() == paperBags.getPaperList().get(j).getPaperNum()){
for(int k = 0 ; k < paperBags.getPaperList().get(j).getIssueList().size() ; k++){
if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().equals(noAnswer)){
System.out.println(noAnswer);
}else if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().equals(noExit)){
System.out.println(noExit);
}else if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().matches("the question.+")){
System.out.println(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain());
}else{
for(int q = 0 ; q < answerpaperList.get(i).getAnswerList().size() ; q++){
if(k+1 == answerpaperList.get(i).getAnswerList().get(q).getAnswerNumber()){
System.out.println(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain()
+ "~" + answerpaperList.get(i).getAnswerList().get(q).getAnswer() + "~"
+ answerpaperList.get(i).getAnswerList().get(q).isJudge());
}
}
}
}
int s;
for(s = 0 ; s < studentList.size() ; s++){
if(studentList.get(s).getID().equals(answerpaperList.get(i).getID())){
System.out.printf(studentList.get(s).getID() + " " + studentList.get(s).getName() + ":");
for(int k = 0 ; k < paperBags.getPaperList().get(j).getIssueList().size() ; k++){
if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().equals(noAnswer)){
System.out.printf(" 0");
}else if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().equals(noExit)){
System.out.printf(" 0");
}else if(paperBags.getPaperList().get(j).getIssueList().get(k).getIssueMain().matches("the question.+")){
System.out.printf(" 0");
}else{
for(int q = 0 ; q < answerpaperList.get(i).getAnswerList().size() ; q++){
if(k+1 == answerpaperList.get(i).getAnswerList().get(q).getAnswerNumber()){
System.out.printf(" " + answerpaperList.get(i).getAnswerList().get(q).getEndScore());
}
}
}
if(k==paperBags.getPaperList().get(j).getIssueList().size()-1){
answerpaperList.get(i).calEndScore();
System.out.printf("~" + answerpaperList.get(i).getEndScore());
}
}
break;
}
}
if(s==studentList.size()){
System.out.println(answerpaperList.get(i).getID() + " not found");
}
break;
}
}
if(j==paperBags.getPaperList().size()){
System.out.println("The test paper number does not exist");
}
}
}
}
class Answer {
private int answerNumber;
private String answer;
private boolean judge = false;
private int endScore = 0;
public int getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(int answerNumber) {
this.answerNumber = answerNumber;
}
public int getEndScore() {
return endScore;
}
public void setEndScore(int endScore) {
this.endScore = endScore;
}
public boolean isJudge() {
return judge;
}
public void setJudge(boolean judge) {
this.judge = judge;
}
public Answer() {
}
public Answer(int answerNumber,String answer) {
this.answer = answer;
this.answerNumber = answerNumber;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Answerpaper {
private int answerpaperNumber;
private String ID;
private List<Answer> answerList = new ArrayList<>();
private int endScore = 0;
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public int getEndScore() {
return endScore;
}
public void setEndScore(int endScore) {
this.endScore = endScore;
}
public Answerpaper() {
}
public int getAnswerpaperNumber() {
return answerpaperNumber;
}
public void setAnswerpaperNumber(int answerpaperNumber) {
this.answerpaperNumber = answerpaperNumber;
}
public Answerpaper(int answerpaperNumber, List<Answer> answerList) {
this.answerpaperNumber = answerpaperNumber;
this.answerList = answerList;
}
public List<Answer> getAnswerList() {
return answerList;
}
public void setAnswerList(List<Answer> answerList) {
this.answerList = answerList;
}
public void calEndScore() {
int sum = 0;
for (int i = 0; i < answerList.size(); i++) {
sum = sum + answerList.get(i).getEndScore();
}
endScore = sum;
}
}
class Delete {
private int number;
public Delete() {
}
public Delete(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
class Issue {
private int issueNum;
private String issueMain;
private String standardAnswer;
private int score;
public Issue() {
}
public Issue(int issueNum, String issueMain, String issueAnswer ) {
this.issueNum = issueNum;
this.issueMain = issueMain;
this.standardAnswer = issueAnswer;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getIssueNum() {
return issueNum;
}
public void setIssueNum(int issueNum) {
this.issueNum = issueNum;
}
public String getIssueMain() {
return issueMain;
}
public void setIssueMain(String issueMain) {
this.issueMain = issueMain;
}
public String getIssueAnswer() {
return standardAnswer;
}
public void setIssueAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class Paper {
private int paperNum;
private List<Issue> issueList = new ArrayList<>();
public Paper(){
}
public Paper(int paperNum, List<Issue> issueList) {
this.paperNum = paperNum;
this.issueList = issueList;
}
public int getPaperNum() {
return paperNum;
}
public void setPaperNum(int paperNum) {
this.paperNum = paperNum;
}
public List<Issue> getIssueList() {
return issueList;
}
public void setIssueList(List<Issue> issueList) {
this.issueList = issueList;
}
public int calSumscore(){
int sum = 0;
for(int i = 0 ; i < issueList.size() ; i++){
sum = sum + issueList.get(i).getScore();
}
return sum;
}
}
class PaperBags {
private List<Paper> paperList = new ArrayList<>();
public PaperBags() {
}
public PaperBags(List<Paper> paperList) {
this.paperList = paperList;
}
public List<Paper> getPaperList() {
return paperList;
}
public void setPaperList(List<Paper> paperList) {
this.paperList = paperList;
}
public void checkPaperscore(){
for(int i = 0 ; i < paperList.size() ; i++){
if(paperList.get(i).calSumscore()!=100){
System.out.printf("alert: full score of test paper%d is not 100 points\n",paperList.get(i).getPaperNum());
}
}
}
}
class Student {
private String ID;
private String Name;
public Student() {
}
public Student(String ID, String name) {
this.ID = ID;
Name = name;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
}
设计与分析:第三次练习相较于第二次加入了错误输入的提示需要的输入的格式完全匹配，如果不符则归咎为输入有误，所以在输入的时候运用了正则表达式进行完全匹配，将匹配的结果分入各个字符串Arraylist里，在第二步进行分割以及输入。本次实现了前两次为考虑的控制类teacher进行批改和输出，其属性为试卷包和答卷列表，输入的原理与第二次相差不大，由于多了不少的错误输出，所以也需要考虑优先级的问题，输入时当找不到试卷所要的题目时会放入一个IssueMain为non-existent question~0的Issue进入试卷中，删除也并不是真的删除，而是将其的IssueMain改为了被删除的错误提示，这两步都是属于取巧的成分，正好没有题目的主体是这两的错误提示的测试点，如果有肯定是过不了的，而且最后也存在其他的bug，比如删除了一个题目以后再输入了一个相同题目号的题目时，输出的结果与本应该的结果不一致等，还没找到解决方法，由于多了个学生类，答卷中多了学生ID的属性。
类图:
踩坑心得：首先就是第二次PTA的最后一题，开始因为测试样例里只有输入的题目顺序会发生改变，就觉得不用先存起来再分割，而是偷了下懒跟第一次一样边输入边分割，边存，导致提交出了很多问题，且测试样例都过了还是有很多点过不了:
后改为存完再分割才解决，但依旧有两个点过不了，因为分割表达式不正确，导致删的过多空格，如果题目是英文句子就会把英文句子里的空格也删了，导致错误：
然后就是第三次PTA的最后一题，可能因为取巧的原因，第一次提交就过了很多测试点，但依旧存在缺陷，还是分割的问题，没考虑周全，如果标准答案为空则无法输出，但其实是可以输出的，还有就是问题的主体后带有多个空格的情况，因为题目输入的格式的原因，只用删除一个空格就好，其他的空格需要全部输出，所以题目的格式很重要：
改进方法：其实还有很多行为可以单独提取出一个控制类来完成，比如分割，这样就可以减少主函数的长度，使代码更简洁，学生和序号的关联可以使用Hashmap来对应等。
总结：通过这三次PTA的练习收获很多，学会了类的使用，接触了类的设计，也有所提高，学会了使用Arraylist以及localdate类，通过后期的总结，学习到了一些方法函数，如try catch和hashmap，同时也十分深刻的了解了代码设计的重要性，只有好的设计才能写出好的代码，不能拿到题就直接写代码，要花时间好好设计，考虑多方面可能会出现的情况，比如添加信息，增加各种要求和错误信息等，如果有好的设计，这很容易就能添加上去，但如果设计不行就得将上次的推导重构。
我们的实验和PTA的作业都是依次迭代的，我认为这样的方式很好，能帮助我们更好的学习理解新学习的知识并实现运用，老师上课讲的也很好，听不懂还能在网上听老师的网课，很好。