南昌航空大学软件学院-23201930-刘靖辉-第一次blog作业
1. 前言
2. 设计与分析
2.1 OOP-1：答题判题程序1
2.1.1 题目
2.1.2 源码
2.1.3 评价与分析
2.1.4 踩坑心得
2.1.5 改进建议
2.1 OOP-2：答题判题程序2
2.1.1 题目
2.1.2 源码
2.1.3 评价与分析
2.1.4 踩坑心得
2.1.5 改进建议
2.1 OOP-3：答题判题程序3
2.1.1 题目
2.1.2 源码
2.1.3 评价与分析
2.1.4 踩坑心得
2.1.5 改进建议
3.总结
1. 前言：
第一阶段的学习中，我们主要学习了如何利用单一职责原则进行编程，以及对于复杂问题的需求分析，类的设计等。并且使用这一系列的知识来进行了三次的PTA作业代码编写。前三次的PTA都是建立在类的设计，正则表达式和单一职责原则的编程题目，一次一次类数逐渐上升，难度逐渐上升，类与类的关系逐渐变得复杂。
2. 设计与分析：
2.1 OOP-1：答题判题程序1：
2.1.1 题目：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
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
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、答题信息
一行为一道题的答题信息，根据题目的数量输出多行数据。
格式：题目内容+" ~"+答案
样例：1+1=~2
2+2= ~4
3、判题信息
判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。
格式：判题结果+" "+判题结果
格式约束：
1、判题结果输出只能是true或者false，
2、判题信息的顺序与输入答题信息中的顺序相同
样例：true false true
2.1.2源码：
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int num=input.nextInt();
String[] list=new String[num];
List<String>testList=new ArrayList<>();
List<Test>tests=new ArrayList<>();
//对于排序的处理
for(int i=0;i<num;i++) {
if(i==0)
input.nextLine();
list[i]=input.nextLine();
String realList[]=list[i].split("#Q:");
String realList2[]=realList[0].split("#N:");
int number=Integer.parseInt(realList2[1].trim());
String[] realList3=(realList[1].split("#A:"));
testList.add(realList2[0].trim());
testList.add(realList3[0].trim());
testList.add(realList3[1].trim());
String content=realList3[0].trim();
String standardAnswer=realList3[1].trim();
Test test=new Test(number,content,standardAnswer);
test.setId(number);
test.setContent(content);
test.setStandardAnswer(standardAnswer);
tests.add(test);
}
for(int i=0;i<num;i++)
{
for(int j=0;j<num-i-1;j++)
{
if(tests.get(j).getId()>tests.get(j+1).getId())
{
Test temp=tests.get(j);
tests.set(j,tests.get(j+1));
tests.set(j+1,temp);
}
}
}
String answer= input.nextLine();
String answerList[]=answer.split("#A:");
{
for(int i=0;i<num;i++)
answerList[i]=answerList[i+1];
}
String[] answerList1=new String[num];
for(int i=0;i<num;i++) {
answerList1[i]=answerList[i].trim();
}
for(int i=0;i<num;i++)
{
System.out.println(tests.get(i).getContent()+"~"+answerList1[i]);
}
for(int i=0;i<num;i++)
{
if(i!=num-1) {
if (tests.get(i).correct(answerList1[i])) {
System.out.print("true ");
} else {
System.out.print("false ");
}
}
else
{
if (tests.get(i).correct(answerList1[i])) {
System.out.print("true");
} else {
System.out.print("false");
}
}
}
String end=input.nextLine();
}
}
class Test
{
private int id;
private String content;
private String standardAnswer;
public Test(int id, String content, String standardAnswer) {
this.id = id;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean correct(String answer)
{
if(answer.equals(standardAnswer))
{
return true;
}
else
{
return false;
}
}
}
2.1.3评价与分析：
本题的难度不大，重点考察了类与对象的使用和正则表达式。应当有3-4个类。
本题模拟的是单个试卷的信息处理。
分类的类主函数接受到的信息分为不同的种类，将他们分别分配为他们自己的类中的数据。
再用函数根据他们的题号来进行排序，
利用函数对答案和起对应的标答是否相同。
依据函数的布尔返回值来进行输出。
2.1.4 踩坑心得：
1、再输出阶段总是会输出多一行或者少一行，此时应当去循环中找问题，例如：循环的次数是否是对应的题目数量，是否是对应的输入的句子的行数。
2、输入是会出现有部分输入被吞掉的问题。此时应当再最后一个输入前加入一个空输入，清理掉错误的代码空间，这样就可以使我们的输入全部被提取到。
3、分类是用到动态数组来加入新的信息，这样可以解决多信息无法同时赋值到实体类中的问题。
2.1.5 改进建议：
1、应当用足够的类来解放死的数据的数组，做到分类。
2、应当注意再另外类中进行其他类的引用.
2.2 OOP-2-7-4
2.2.1 题目：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=5true
4+6=22false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
2.2.2 源码
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
List<String>list=new ArrayList<>();
List<Test>subjects=new ArrayList<>();
List<Paper>allPaper=new ArrayList<>();
List<AnswerList>allAnswer=new ArrayList<>();
List<Integer>grade=new ArrayList<>();
List<Integer>gradeNumber=new ArrayList<>();
List<String>answers=new ArrayList<>();
int num=0;
while(true)
{
String str=input.nextLine();
if(str.contains("end"))
break;
else
{
list.add(str);
num++;
}
}
for(int i=0;i<num;i++)
{
//提取题目
if(list.get(i).contains("#N"))
{
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#N:");
int number=Integer.parseInt(id[1].trim());
String contents[]=realList[1].split("#Q:");
String content=contents[1].trim();
String standard[]=realList[2].split("#A:");
String standardAnswer=standard[1].trim();
Test test=new Test(number,content,standardAnswer);
subjects.add(test);
}
else
{
//提取试卷信息
if(list.get(i).contains("#T"))
{
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#T:");
int number=Integer.parseInt(id[1].trim());
for(int j=1;j<realList.length;j++)
{
String subject1[]=realList[j].split("-");
grade.add(Integer.parseInt(subject1[1].trim()));
gradeNumber.add(Integer.parseInt(subject1[0].trim()));
}
Paper paper=new Paper(grade,gradeNumber,number);
allPaper.add(paper);
}
else
{
//提取做答信息
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#S:");
int number=Integer.parseInt(id[1].trim());
for(int j=1;j<realList.length;j++)
{
String answer[]=realList[j].split("#A:");
answers.add(answer[1].trim());
}
AnswerList answerList=new AnswerList(number,answers);
allAnswer.add(answerList);
}
}
}
int count=0;
for(int i=0;i<allPaper.size();i++)
{
for(int j=0;j<allPaper.get(i).getGrade().size();j++)
{
count=count+allPaper.get(i).getGrade().get(j);
}
if(count!=100)
System.out.println("alert: full score of test paper"+allPaper.get(i).getNum()+" is not 100 points");
}
for(int i=0;i<allPaper.size();i++) {
for (int m = 0; m < allAnswer.size(); m++)
{
int score = 0;
if(allAnswer.get(i).getNumber()!=allPaper.get(i).getNum())
System.out.println("The test paper number does not exist");
else {
for (int j = 0; j < allPaper.get(i).getGrade().size(); j++)
if (allAnswer.get(i).getAnswers().get(j+2*m).equals(subjects.get(j).getStandardAnswer())) {
System.out.println(subjects.get(j).getContent() + "~" + allAnswer.get(i).getAnswers().get(j+2*m) + "~" + "true");
score = score + allPaper.get(i).getGrade().get(j);
} else {
if(allAnswer.get(i).getAnswers().get(j+2*m)==null)
System.out.println("answer is null");
else
System.out.println(subjects.get(j).getContent() + "~" + allAnswer.get(i).getAnswers().get(j+2*m) + "~" + "false");
}
for (int j = 0; j < allPaper.get(i).getGrade().size(); j++) {
if (j != allPaper.get(i).getGrade().size() - 1) {
if (allAnswer.get(i).getAnswers().get(j + 2 * m).equals(subjects.get(j).getStandardAnswer())) {
System.out.print(allPaper.get(i).getGrade().get(j) + " ");
} else {
System.out.print("0 ");
}
} else {
if (allAnswer.get(i).getAnswers().get(j + 2 * m).equals(subjects.get(j).getStandardAnswer()))
System.out.println(allPaper.get(i).getGrade().get(j) + "~" + score);
else
System.out.println("0~" + score);
}
}
}
}
}
}
}
class Test
{
private int id;
private String content;
private String standardAnswer;
public Test(int id, String content, String standardAnswer) {
this.id = id;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class Paper
{
private List<Integer>grade=new ArrayList<>();
private List<Integer>number=new ArrayList<>();
private int num;
public Paper(List<Integer> grade, List<Integer> number, int num) {
this.grade = grade;
this.number = number;
this.num = num;
}
public List<Integer> getGrade() {
return grade;
}
public void setGrade(List<Integer> grade) {
this.grade = grade;
}
public List<Integer> getNumber() {
return number;
}
public void setNumber(List<Integer> number) {
this.number = number;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
int ag=0;
public boolean allGrade()
{
for (int i=0;i<number.size();i++)
{
ag=grade.get(i)+ag;
}
if(ag==100)
{
return true;
}
else
{
return false;
}
}
}
class AnswerList
{
private int number;
private List<String>answers=new ArrayList<>();
public AnswerList(int number, List<String> answers) {
this.number = number;
this.answers = answers;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public List<String> getAnswers() {
return answers;
}
public void setAnswers(List<String> answers) {
this.answers = answers;
}
}
2.2.3 设计与分析
本题模拟的是多张试卷和多张答卷的信息处理。
本题难度较大，新加入答题类以遵循单一职责原则。
需要用分类将信息分给每一个类中进行方法的判断，得到结论后再传递到下一个类中。
最后传到输出中进行输出。
2.2.4 踩坑心得
1、一定要遵循单一职责原则进行程序的设计，否则会大大得增长程序的运行时间，导致无法在规定的时间完成程序的运行，同时因为大量的判断句式和for循环，在编写程序的时候很容易出现逻辑问题，且很难进行更改。
2、一定要关注每一个动态数组的提取的路径，尤其是用.size来获取其长度的时候，容易提取到上一级或者下一级的长度从而导致程序出现问题。
2.2.5 改进建议
1、将主函数中的分类和输出都分别放入一个专门进行分类或者输出的类中。
2、尽量在每一个函数或者使较为复杂的方法前面加入注释，那样即使在编写代码的期间因为一些其他事打断后也能快速找回思路，继续完成代码的编写。
3、若在写完一部分后发现代码中少了某些成分，可以新加入新的类来编写新的方法以避免因为加入新方法导致大量的if语句出现使主要的程序变得冗乱。
2.3 OOP-3-7-3
2.3.1 题目：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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。
本题暂不考虑出现多张答卷的信息的情况。
2.3.2 源码：
import java.util.List;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
List<String>list=new ArrayList<>();
while(true)
{
String str=input.nextLine();
if(str.contains("end"))
break;
else
{
list.add(str);
}
}
Range range=new Range(list);
range.chess();
range.select();
range.clean();
Agent1 agent1=new Agent1(range);
Agent2 agent2=new Agent2(range);
Agent3 agent3=new Agent3(range);
PrintOut printout=new PrintOut(agent1,agent2,agent3,range);
printout.print();
}
}
class Range {
private List<Subject> subjects = new ArrayList<>();
private List<Paper> papers = new ArrayList<>();
private List<AnswerList> answerLists = new ArrayList<>();
private List<Student> students = new ArrayList<>();
private List<Delete> deletes = new ArrayList<>();
private List<String> information;
public Range(List<String> information) {
this.information = information;
}
public List<Subject> getSubjects() {
return subjects;
}
public void setSubjects(List<Subject> subjects) {
this.subjects = subjects;
}
public List<Paper> getPapers() {
return papers;
}
public void setPapers(List<Paper> papers) {
this.papers = papers;
}
public List<AnswerList> getAnswerLists() {
return answerLists;
}
public void setAnswerLists(List<AnswerList> answerLists) {
this.answerLists = answerLists;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
public List<Delete> getDeletes() {
return deletes;
}
public void setDeletes(List<Delete> deletes) {
this.deletes = deletes;
}
public List<String> getInformation() {
return information;
}
public void setInformation(List<String> information) {
this.information = information;
}
public void select() {
for (int i = 0; i < information.size(); i++) {
if (information.get(i).contains("#N")) {
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#N:");
int Id = Integer.parseInt(inform1[1].trim());
String inform2[] = informs[1].split("#Q:");
String Content = inform2[1].trim();
String inform3[] = informs[2].split("#A:");
String StandardAnswer = (inform3[1].trim());
Subject subject = new Subject(Id, Content, StandardAnswer);
subjects.add(subject);
} else {
if (information.get(i).contains("#T")) {
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#T:");
int paperId = (Integer.parseInt(inform1[1].trim()));
List<Integer> num = new ArrayList<>();
List<Integer> grade = new ArrayList<>();
for (int j = 1; j < informs.length; j++) {
String inform2[] = informs[j].split("-");
num.add(Integer.parseInt(inform2[0]));
grade.add(Integer.parseInt(inform2[1]));
}
Paper paper = new Paper(paperId, num, grade);
papers.add(paper);
} else {
if (information.get(i).contains("#X")) {
List<Integer> id = new ArrayList<>();
List<String> name = new ArrayList<>();
String informs[] = information.get(i).split("-");
String inform[] = informs[0].split("#X:");
String inform2[] = inform[1].split(" ");
id.add(Integer.parseInt(inform2[0].trim()));
name.add(inform2[1].trim());
for (int j = 1; j < informs.length; j++) {
String inform1[] = informs[j].split(" ");
id.add(Integer.parseInt(inform1[0].trim()));
name.add(inform1[1].trim());
}
Student student = new Student(id, name);
students.add(student);
} else {
if (information.get(i).contains("#S")) {
List<Integer> num = new ArrayList<>();
List<String> answer = new ArrayList<>();
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#S:");
int paperId = (Integer.parseInt(inform1[1].trim()));
int studentId = (Integer.parseInt(informs[1].trim()));
for (int j = 2; j < informs.length; j++) {
String inform2[] = informs[j].split("#A:");
String inform3[] = inform2[1].split("-");
num.add(Integer.parseInt(inform3[0].trim()));
answer.add(inform3[1].trim());
}
AnswerList answerList = new AnswerList(paperId, studentId, num, answer);
answerLists.add(answerList);
} else {
String informs[] = information.get(i).split("#D:");
String inform[] = informs[1].split("-");
int subjectId = (Integer.parseInt(inform[1].trim()));
Delete delete = new Delete(subjectId);
deletes.add(delete);
}
}
}
}
}
}
public int chess() {
int id=-1;
for (int i = 0; i < information.size(); i++) {
if (!information.get(i).contains("#Q:") && information.get(i).contains("#N")) {
System.out.println("wrong format:" + information.get(i));
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#N:");
id = Integer.parseInt(inform1[1].trim());
information.remove(i);
}
}
return id;
}
public void clean()
{
int len=papers.get(0).getSubjectId().size();
for(int i=0;i<len;i++) {
if (papers.get(0).getSubjectId().get(i) == chess())
{
papers.get(0).getSubjectId().remove(i);
papers.get(0).getSubjectGrade().remove(i);
}
}
}
}
class Student
{
private List<Integer>id=new ArrayList<>();
private List<String>name=new ArrayList<>();
public Student(List<Integer> id, List<String> name) {
this.id = id;
this.name = name;
}
public List<Integer> getId() {
return id;
}
public void setId(List<Integer> id) {
this.id = id;
}
public List<String> getName() {
return name;
}
public void setName(List<String> name) {
this.name = name;
}
}
class Paper
{
private int paperId;
private List<Integer>subjectId=new ArrayList<>();
private List<Integer>subjectGrade=new ArrayList<>();
public Paper(int paperId, List<Integer> subjectId, List<Integer> subjectGrade) {
this.paperId = paperId;
this.subjectId = subjectId;
this.subjectGrade = subjectGrade;
}
public int getPaperId() {
return paperId;
}
public void setPaperId(int paperId) {
this.paperId = paperId;
}
public List<Integer> getSubjectId() {
return subjectId;
}
public void setSubjectId(List<Integer> subjectId) {
this.subjectId = subjectId;
}
public List<Integer> getSubjectGrade() {
return subjectGrade;
}
public void setSubjectGrade(List<Integer> subjectGrade) {
this.subjectGrade = subjectGrade;
}
}
class Subject
{
private int subjectId;
private String content;
private String standardAnswer;
public Subject(int subjectId, String content, String standardAnswer) {
this.subjectId = subjectId;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class AnswerList
{
private int paperId;
private int studentId;
private List<Integer>subjectId;
private List<String>answer;
public AnswerList(int paperId, int studentId, List<Integer> subjectId, List<String> answer) {
this.paperId = paperId;
this.studentId = studentId;
this.subjectId = subjectId;
this.answer = answer;
}
public int getPaperId() {
return paperId;
}
public void setPaperId(int paperId) {
this.paperId = paperId;
}
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public List<Integer> getSubjectId() {
return subjectId;
}
public void setSubjectId(List<Integer> subjectId) {
this.subjectId = subjectId;
}
public List<String> getAnswer() {
return answer;
}
public void setAnswer(List<String> answer) {
this.answer = answer;
}
}
class Delete
{
private int subjectId;
public Delete(int subjectId) {
this.subjectId = subjectId;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
}
class Agent1
{
private Range range;
public Agent1(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
int sum=0;
//计算总分并判断其是否为100
public boolean sum()
{
for(int i=0;i<range.getPapers().get(0).getSubjectGrade().size();i++)
{
sum=sum+range.getPapers().get(0).getPaperId();
}
if(sum==100)
{
return true;
}
else
{
return false;
}
}
}
class Agent2
{
private Range range;
public Agent2(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//判断答案是否正确
public boolean[] correct()
{
int n=0;
boolean[] result=new boolean[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
for(int j=0;j<range.getSubjects().size();j++)
{
if(range.getAnswerLists().get(0).getSubjectId().get(i).equals(range.getSubjects().get(j).getSubjectId()))
{
if(range.getAnswerLists().get(0).getAnswer().get(i).equals(range.getSubjects().get(j).getStandardAnswer()))
result[i]=true;
else
result[i]=false;
}
}
}
return result;
}
//比较答案的数量，以确定答案是否存在
public boolean compare()
{
if(range.getAnswerLists().get(0).getAnswer().size()>=range.getSubjects().size())
return true;
else
return false;
}
//判断答案是否有对应的题目
public boolean[] mate()
{
int n=0;
boolean[] result=new boolean[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
for(int j=0;j<range.getPapers().get(0).getSubjectId().size();j++)
{
if(!range.getDeletes().isEmpty()) {
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getPapers().get(0).getSubjectId().get(j) || range.getAnswerLists().get(0).getSubjectId().get(i) != range.getDeletes().get(0).getSubjectId())
n++;
}
else
{
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getPapers().get(0).getSubjectId().get(j))
n++;
}
}
if(n==1)
result[i]=true;
else
result[i]=false;
}
return result;
}
//给分
public int[] giveGrade()
{
int[] grade=new int[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
if(!compare())
{
grade[i]=0;
}
else
{
if(range.getAnswerLists().get(0).getSubjectId().get(i)==range.getDeletes().get(0).getSubjectId())
{
grade[i]=0;
}
else
{
if(!mate()[i])
grade[i]=0;
else
{
if(correct()[i])
grade[i]=range.getPapers().get(0).getSubjectGrade().get(i);
else
grade[i]=0;
}
}
}
}
return grade;
}
//被删除给零分
public void deleted()
{
System.out.println("the question "+range.getDeletes().get(0).getSubjectId()+" invalid~0");
}
}
class Agent3
{
private Range range;
public Agent3(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//无效的学号引用
public boolean idEffective()
{
int n=0;
for(int i=0;i<range.getStudents().get(0).getId().size();i++)
{
if(range.getAnswerLists().get(0).getStudentId()==range.getStudents().get(0).getId().get(i))
n++;
}
if(n==1)
return true;
else
return false;
}
}
class PrintOut
{
Agent1 agent1;
Agent2 agent2;
Agent3 agent3;
Range range;
public PrintOut(Agent1 agent1, Agent2 agent2, Agent3 agent3, Range range) {
this.agent1 = agent1;
this.agent2 = agent2;
this.agent3 = agent3;
this.range = range;
}
public Agent1 getAgent1() {
return agent1;
}
public void setAgent1(Agent1 agent1) {
this.agent1 = agent1;
}
public Agent2 getAgent2() {
return agent2;
}
public void setAgent2(Agent2 agent2) {
this.agent2 = agent2;
}
public Agent3 getAgent3() {
return agent3;
}
public void setAgent3(Agent3 agent3) {
this.agent3 = agent3;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//
public void print() {
int sum = 0;
if (!agent1.sum())
System.out.println("alert: full score of test paper1 is not 100 points");
for (int i = 0; i < range.getPapers().get(0).getSubjectId().size(); i++) {
if (agent2.compare()) {
if(range.getDeletes().size()>0) {
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getDeletes().get(0).getSubjectId()) {
agent2.deleted();
} else {
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
} else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
}
} else {
System.out.println("non-existent question~0");
}
}
}
else
{
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
} else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
}
} else {
System.out.println("non-existent question~0");
}
}
} else {
if (range.getDeletes().size() > 0)
{
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getDeletes().get(0).getSubjectId()) {
agent2.deleted();
} else {
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
} else {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
}
} else {
System.out.println("non-existent question~0");
}
}
}
else
{
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
} else {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
}
} else {
System.out.println("non-existent question~0");
}
}
}
}
if (range.getAnswerLists().get(0).getSubjectId().size() <= range.getStudents().get(0).getName().size()) {
for (int i = 0; i < range.getAnswerLists().get(0).getSubjectId().size()- range.getDeletes().size(); i++) {
if (range.getAnswerLists().get(0).getStudentId() == range.getStudents().get(0).getId().get(i)) {
System.out.print(range.getAnswerLists().get(0).getStudentId() + " " + range.getStudents().get(0).getName().get(i) + ": ");
for (int j = 0; j < range.getPapers().get(0).getSubjectId().size(); j++) {
if (agent2.mate()[j]) {
if (agent2.correct()[j]) {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + " ");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
} else {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + "~");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
}
}
System.out.println(sum);
}
}
else
{
for (int i = 0; i < range.getStudents().get(0).getName().size()-range.getDeletes().size(); i++) {
if (range.getAnswerLists().get(0).getStudentId() == range.getStudents().get(0).getId().get(i)) {
System.out.print(range.getAnswerLists().get(0).getStudentId() + " " + range.getStudents().get(0).getName().get(i) + ": ");
for (int j = 0; j < range.getPapers().get(0).getSubjectId().size(); j++) {
if (agent2.mate()[j]) {
if (agent2.correct()[j]) {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + " ");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
} else {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + "~");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
}
}
System.out.println(sum);
}
}
}
}
2.3.3 设计与分析
本题目难度较大，需要使用6-11个类完成。
从主函数接收到的输入信息，通过分类的类进行分类，将每一种信息都存入以对应类为元素的动态数组中，多个控制类再通过这些动态数组来使对应方法进行下去，达到目的，得到最终的结果，由输出的类进行接收并输出。
2.3.4 踩坑心得：
1、输出类同主函数一样不要加入太多的代码，更多都依赖控制类中的方法。提前在控制类中将各类判断的方法先写好，再在输出类中引用，可以降低代码的复杂度，也可以提高正确率。
2、因为信息中部分的信息（如题目信息）可能会有多个，导致我们无法将提取的数据转到类中存储。因此需要用到以对应类为元素的动态数组来储存这些信息。调用信息时都提取那些动态数组中的内容，对动态数组中的数据进行加工。
3、一定画完类图再进行代码的编写。
2.3.5 改进建议
1、需要减少输出类的长度，将更多的判断都放到各个控制类之中，使输出类更精简。
2、理清每一个方法中循环究竟是以什么数组的长度来作为循环的长度，同时理清每一个方法的整体脉络，以避免判断句式出现问题。
3. 总结：
这三次PTA作业的核心都是单一职责原则，要求我们以此原则进行程序的设计。而我也在一次次PTA任务中逐渐完善了我的设计，为接下来第二阶段的PTA打下基础，也会为了完成PTA去学习一些常用的技巧和方法（如正则表达式）。同时我也需要在接下来的学习中加强对于类间关系的梳理和研究学习。遇到问题解决问题。