第一到三次pta作业总结
（1）前言：
三次pta作业难度逐渐增大，类设计也逐渐复杂化，代码量不大但类的设计需要花费大量时间，在跟进课程学习JAVA基础中，能够渐渐熟练使用。
1.）第一次作业中主要是一些基本的类的设计，主要考察我们对面向对象的基本知识的掌握。
2.）第二次作业在第一次的基础上增加了新的类并且改变了输出格式，相较于第一题并未增加新的知识点。
3.）第三次作业在前两次的基础上难度增加，并且添加了对List的使用，如果能够合理的使用集合处理数据，会比较轻松。
（2）代码分析：
第一次作业：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
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
代码：
class PtaWork1 {
public static void main(String[] args) {
Question q1 = new Question(1," 5 +5= ","10");
//Question q2 = new Question(2,"2+3=","5");
TestPaper t = new TestPaper();
t.setQuestionNum(1);//题目数量
t.inputQuestion(1,q1);
//t.inputQuestion(2,q2);
//将试卷类放入答卷类中
AnswerPaper a = new AnswerPaper();
a.setTestPaper(t);
//每一题的答案
String[] answer = new String[10];
answer[1] = "10";
//answer[2] = "3";
a.setAnswers(answer);
a.printQ_A(1);
//a.printQ_A(2);
a.getJudge(1);
//a.getJudge(2);
for (int i = 1; i <= t.getQuestionNum(); i++) {
if(i == t.getQuestionNum()) {
System.out.println(a.getMarks()[i]);
}else {
System.out.print(a.getMarks()[i] + " ");
}
}
}
}
class Question {
private int num;
private String content;
private String standardAnswer;
public Question() {
}
public Question(int num, String content, String standardAnswer) {
this.num = num;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
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 matchingStandardAnswer(String answer) {
if(answer.equals(standardAnswer)) {
return true;
}else {
return false;
}
}
}
class TestPaper {
private int questionNum;
Question[] questions = new Question[10];
public TestPaper() {
}
public TestPaper(int questionNum,Question[] questions) {
this.questionNum = questionNum;
this.questions = questions;
}
public int getQuestionNum() {
return questionNum;
}
public void setQuestionNum(int questionNum) {
this.questionNum = questionNum;
}
public Question[] getQuestions() {
return questions;
}
public void setQuestions(Question[] questions) {
this.questions = questions;
}
public void inputQuestion(int num,Question question) {
questions[num] = question;
}
public void printQuestions() {
for (int i = 1; i <= questionNum; i++) {
System.out.println(questions[i].getContent() + "~" + questions[i].getStandardAnswer());
}
}
public boolean markQuestion(int num,String answer) {
if(questions[num].getStandardAnswer().equals(answer)) {
return true;
}else {
return false;
}
}
}
class AnswerPaper {
TestPaper testPaper;
String[] answers = new String[10];
boolean[] marks = new boolean[10];
public AnswerPaper() {
}
public AnswerPaper(TestPaper testPaper, String[] answers, boolean[] marks) {
this.testPaper = testPaper;
this.answers = answers;
this.marks = marks;
}
public TestPaper getTestPaper() {
return testPaper;
}
public void setTestPaper(TestPaper testPaper) {
this.testPaper = testPaper;
}
public String[] getAnswers() {
return answers;
}
public void setAnswers(String[] answers) {
this.answers = answers;
}
public boolean[] getMarks() {
return marks;
}
public void setMarks(boolean[] marks) {
this.marks = marks;
}
public void printQ_A(int num) {
System.out.println(testPaper.getQuestions()[num].getContent().trim() + "~" + answers[num]);
}
public void getJudge(int num) {
marks[num] = testPaper.markQuestion(num, answers[num]);
}
}
第二次作业：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=~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=5false
2+2=22false
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=5false
2+2=22false
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=5false
2+2=4true
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=5false
1+1=22false
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=5true
2+2=22false
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=5true
2+2=22false
70 0~70
3+2=5true
2+2=4true
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=5true
2+2=22false
7 0~7
3+2=5true
2+2=4true
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=5true
2+2=22false
7 0~7
2+2=5false
1+1=4false
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
代码：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//创建集合录入所有信息
ArrayList<String> all = new ArrayList<>();
//建立循环，将“end”之前的信息录入集合中
while (true) {
String str = sc.nextLine();
if(str.equals("end")) {
break;
}else {
all.add(str);
}
}
//创建集合，存入所有题目类
ArrayList<String> topic = new ArrayList<>();
//创建集合，存入所有试卷类
ArrayList<String> testPaper = new ArrayList<>();
//创建集合，存入所有答卷类
ArrayList<String> answerPaper = new ArrayList<>();
//循环遍历存有所有信息的集合，根据首个字符判断属于哪一类，将其存入对应的集合中
for (int i = 0; i < all.size(); i++) {
if(all.get(i).charAt(1) == 'N') {
topic.add(all.get(i));
}else if(all.get(i).charAt(1) == 'T') {
testPaper.add(all.get(i));
}else {
answerPaper.add(all.get(i));
}
}
//创建有一个数组，存储对应的题目类的题号的内容
String[] content = new String[10];
//创建一个数组，存储对应的题目类的题号的标准答案
String[] standardAnswer = new String[10];
for (int i = 0; i < topic.size(); i++) {
String[] arr = topic.get(i).split("#[A-Z]:");
content[Integer.parseInt(arr[1].trim())] = arr[2].trim();
standardAnswer[Integer.parseInt(arr[1].trim())] = arr[3].trim();
}
//创建集合，存储试卷类的试卷号
ArrayList<String> testPaperNum = new ArrayList<>();
for (int i = 0; i < testPaper.size(); i++) {
String[] arr = testPaper.get(i).split("#T:|[1-9]-[1-9]\\d?");
testPaperNum.add(arr[1]);
}
//存储试卷内的题目数量
ArrayList<Integer> testPaperTopicAmount = new ArrayList<>();
//存储所有试卷信息
ArrayList<String> testPaperContent = new ArrayList<>();
for (int i = 0; i < testPaper.size(); i++) {
String[] arr = testPaper.get(i).split("#T:[1-9]|\\s");
testPaperTopicAmount.add(arr.length - 2);
for (int i1 = 2; i1 < arr.length; i1++) {
testPaperContent.add(arr[i1]);
}
}
//试卷的题号
ArrayList<String> testPaperTopicNum = new ArrayList<>();
for (int i = 0; i < testPaperContent.size(); i++) {
String[] arr = testPaperContent.get(i).split("-[1-9](\\d*)");
testPaperTopicNum.add(arr[0]);
}
//试卷的分数
ArrayList<String> testPaperTopicScore = new ArrayList<>();
for (int i = 0; i < testPaperContent.size(); i++) {
String[] arr = testPaperContent.get(i).split("[1-9]-");
testPaperTopicScore.add(arr[1]);
}
//存储答卷号
ArrayList<String> answerPaperNum = new ArrayList<>();
//存储答案
ArrayList<String> answer = new ArrayList<>();
for (int i = 0; i < answerPaper.size(); i++) {
String[] arr = answerPaper.get(i).split("#[A-Z]:");
answerPaperNum.add(arr[1]);
answer.add(arr[2]);
answer.add(arr[3]);
}
int j = 0;
int t = testPaperTopicAmount.get(0);
for (int i = 0; i < testPaper.size(); i++) {
int sum = 0;
if(i > 0) {
t = t + testPaperTopicAmount.get(i);
}
for (int i1 = 0; i1 < testPaperTopicAmount.get(i); i1++) {
sum = sum + Integer.parseInt(testPaperTopicScore.get(j));
if(j == t - 1) {
j = t;
}else {
j++;
}
}
if(sum != 100) {
System.out.println("alert: full score of test paper"+testPaperNum.get(i)+"is not 100 points");
}
}
boolean flag = false;
int y = 0;
int x = 0;
for (int i = 0; i < testPaperNum.size(); i++) {
for (int i1 = 0; i1 < answerPaperNum.size(); i1++) {
int[] finalScore = new int[10];
if(testPaperNum.get(i).equals(answerPaperNum.get(i1))) {
flag = true;
if(answerPaper.size() == 2) {
if(!answerPaperNum.get(0).equals(answerPaperNum.get(1))) {
x = x + testPaperTopicAmount.get(i1);
}else {
x = testPaperTopicAmount.get(0);
}
}else {
x = x + testPaperTopicAmount.get(i1);
}
for (int k = 0; k < testPaperTopicAmount.get(i); k++) {
if(answer.size() < testPaperContent.size() && y == answer.size() ) {
System.out.println("answer is null");
break;
}
if(testPaperNum.size() == 1) {
if(check(answer.get(y).trim(),standardAnswer[Integer.parseInt(testPaperTopicNum.get(k))])) {
finalScore[k] = Integer.parseInt(testPaperTopicScore.get(k));
}else {
finalScore[k] = 0;
}
}else if(testPaperNum.size() == 2) {
if(check(answer.get(y).trim(),standardAnswer[Integer.parseInt(testPaperTopicNum.get(y))])) {
finalScore[k] = Integer.parseInt(testPaperTopicScore.get(y));
}else {
finalScore[k] = 0;
}
}
if(testPaperNum.size() == 1) {
System.out.println(content[Integer.parseInt(testPaperTopicNum.get(k))]+"~"+answer.get(y).trim()+"~"
+ check(answer.get(y).trim(),standardAnswer[Integer.parseInt(testPaperTopicNum.get(k))]));
}else if(testPaperNum.size() == 2) {
System.out.println(content[Integer.parseInt(testPaperTopicNum.get(y))]+"~"+answer.get(y).trim()+"~"
+ check(answer.get(y).trim(),standardAnswer[Integer.parseInt(testPaperTopicNum.get(y))]));
}
if(y == x - 1) {
y = x;
}else {
y++;
}
}
//System.out.println("666");
int sum = 0;
for (int q = 0; q < testPaperTopicAmount.get(i); q++) {
sum = sum + finalScore[q];
if(q == testPaperTopicAmount.get(i) - 1) {
System.out.println(finalScore[q]+"~"+sum);
}else {
System.out.print(finalScore[q] + " ");
}
}
}
}
}
if(!flag) {
System.out.print("The test paper number does not exist");
}
}
public static boolean check(String answer,String standardAnswer) {
if(answer.equals(standardAnswer)) {
return true;
}else {
return false;
}
}
}
第三次作业：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=5false
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=5true
4+6=22false.
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=5false
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=2true
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=5false
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=5false
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=5false
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=5false
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=5false
中国第一颗原子弹的爆炸时间4false
20201103 Tom: 0 0~0
代码：import java.util.*;
class Question { private int number; private String content; private String answer;
public Question(int number, String content, String answer) {
this.number = number;
this.content = content;
this.answer = answer;
}
public int getNumber() {
return number;
}
public String getContent() {
return content;
}
public String getAnswer() {
return answer;
}
}
class TestPaper { private int number; private List questionNumbers; private List scores;
public TestPaper(int number, List
this.number = number;
this.questionNumbers = questionNumbers;
this.scores = scores;
}
public int getNumber() {
return number;
}
public List
return questionNumbers;
}
public List
return scores;
}
}
class Student { private int id; private String name; private Map<Integer, List> answers;
public Student(int id, String name) {
this.id = id;
this.name = name;
this.answers = new HashMap<>();
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void addAnswer(int testPaperNumber, List
this.answers.put(testPaperNumber, answerList);
}
public Map<Integer, List
return answers;
}
}
public class TestProgram { private List questionList; private List testPaperList; private List studentList; private List deletedQuestions;
public TestProgram() {
this.questionList = new ArrayList<>();
this.testPaperList = new ArrayList<>();
this.studentList = new ArrayList<>();
this.deletedQuestions = new ArrayList<>();
}
public void addQuestion(int number, String content, String answer) {
Question question = new Question(number, content, answer);
questionList.add(question);
}
public void addTestPaper(int number, List
TestPaper testPaper = new TestPaper(number, questionNumbers, scores);
testPaperList.add(testPaper);
}
public void addStudent(int id, String name) {
Student student = new Student(id, name);
studentList.add(student);
}
public void addAnswer(int studentId, int testPaperNumber, List
for (Student student : studentList) {
if (student.getId() == studentId) {
student.addAnswer(testPaperNumber, answerList);
break;
}
}
}
public void deleteQuestion(int number) {
deletedQuestions.add(number);
}
public void gradeTest() {
for (Student student : studentList) {
StringBuilder sb = new StringBuilder();
sb.append(student.getId()).append(" ").append(student.getName()).append(": ");
int totalScore = 0;
for (Integer testPaperNumber : student.getAnswers().keySet()) {
TestPaper testPaper = getTestPaper(testPaperNumber);
List<Integer> questionNumbers = testPaper.getQuestionNumbers();
List<Integer> scores = testPaper.getScores();
List<String> answerList = student.getAnswers().get(testPaperNumber);
if (questionNumbers.size() != answerList.size()) {
sb.append("0 ");
} else {
int paperScore = 0;
for (int i = 0; i < questionNumbers.size(); i++) {
int questionNumber = questionNumbers.get(i);
int score = scores.get(i);
if (deletedQuestions.contains(questionNumber)) {
sb.append("0 ");
} else if (answerList.get(i).equals(questionList.get(questionNumber - 1).getAnswer())) {
paperScore += score;
} else {
sb.append("0 ");
}
}
totalScore += paperScore;
sb.append(paperScore).append(" ");
}
}
sb.append("~").append(totalScore);
System.out.println(sb.toString());
}
}
private TestPaper getTestPaper(int number) {
for (TestPaper testPaper : testPaperList) {
if (testPaper.getNumber() == number) {
return testPaper;
}
}
return null;
}
public static void main(String[] args) {
TestProgram testProgram = new TestProgram();
Scanner scanner = new Scanner(System.in);
String line;
while (scanner.hasNextLine()) {
line = scanner.nextLine();
if (line.equals("end")) {
break;
}
if (line.startsWith("#N:")) {
String[] tokens = line.substring(4).split(" #Q:| #A:");
int number = Integer.parseInt(tokens[0]);
String content = tokens[1];
String answer = tokens[2];
testProgram.addQuestion(number, content, answer);
} else if (line.startsWith("#T:")) {
String[] tokens = line.substring(4).split(" ");
int number = Integer.parseInt(tokens[0]);
List<Integer> questionNumbers = new ArrayList<>();
List<Integer> scores = new ArrayList<>();
for (int i = 1; i < tokens.length; i++) {
String[] subTokens = tokens[i].split("-");
questionNumbers.add(Integer.parseInt(subTokens[0]));
scores.add(Integer.parseInt(subTokens[1]));
}
testProgram.addTestPaper(number, questionNumbers, scores);
} else if (line.startsWith("#X:")) {
String[] tokens = line.substring(4).split("-");
int id = Integer.parseInt(tokens[0]);
String name = tokens[1];
testProgram.addStudent(id, name);
} else if (line.startsWith("#S:")) {
String[] tokens = line.substring(4).split(" ");
int testPaperNumber = Integer.parseInt(tokens[0]);
int studentId = Integer.parseInt(tokens[1].substring(1));
List<String> answerList = new ArrayList<>();
for (int i = 2; i < tokens.length; i++) {
answerList.add(tokens[i].substring(1));
}
testProgram.addAnswer(studentId, testPaperNumber, answerList);
} else if (line.startsWith("#D:")) {
int questionNumber = Integer.parseInt(line.substring(4).split("-")[1]);
testProgram.deleteQuestion(questionNumber);
}
}
scanner.close();
testProgram.gradeTest();
}
}
（3）总结：
第一次作业的要求是实现一个判题程序，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。在这题中，首先创建出题目类存储每道题，然后创建试卷类来按照答案的顺序将题目存入试卷类中的数组中，最后通过答卷类来输出结果。这道题目的关键点就是在试卷类中定义题目类的成员变量，将答案与题目一一对应起来。
通过题目类中的setQuestionNum（）方法来存入题目数量
再使用inputQuestion（）方法存入题号和题目内容
创建答卷类，将题目放入答卷中
创建答案数组，将答卷中的答案按顺序存入数组中
调用题目类中的setAnswers（）方法将数组存入答卷类中
调用printQ_A（）方法将对应题号的内容和答案输出
调用getJudge（）方法对对应题号的答案进行判断，判断完毕后将其存入答卷类中的数组中
第二次作业是在第一次的基础上新增加了试卷信息，且将各种信息打乱顺序输入，这也增加了对数据的处理难度，在创建试卷信息类的时候还应对输入的题目分数进行判断，如果小于100分，还需在输出语句中额外输出内容。本题的难点有题目输入的顺序与试卷信息类中的顺序不符，还需通过排序来进行顺序的调整，使得输出的结果能够按照试卷信息类中的顺序进行输出，还增加了试卷号与答卷号的对应关系，如果对应不上或是答卷中的答案少于试卷中的题目，均会给出对应的输出结果。
第三次作业在一二题基础中新增了学生信息、删除题目信息以及多种异常输入的监测，如答案为空字符、仅有学生信息没有答案内容的空白卷、试卷引用、试题引用错误等。大量的新增信息可以通过对集合的合理使用来减小我们的编程难度，在此次作业中我使用了集合对数据进行了存储，在对有序的类的存储中，使用双链集合会更为方便快捷。
（4）不足：
在我完成第一次作业时没有对类进行明确的设计，只是草草的进行了输入和输出的判断，这也导致了我之后的两次作业是思路更加的混乱。我也认识到了c语言中的面向程序设计和JAVA中的面向对象设计之间的区别，在JAVA编程中，合理的类设计会使程序更加高效，我也会在之后的作业中加强类间的设计。
ps:对数据的输入使用正则表达式会更加方便，尤其是在对无序输入的数据进行处理时更为明显。
浙公网安备 33010602011771号