南昌航空大学23201421-PTA1~3次大作业

news/发布时间2024/5/5 5:43:21

一．前言：
这个学期才开始接触java，到现在一个多月的时间，已经差不多可以写出一些基本的简单的程序了。对比上个学期学习的C语言，我认为java更加方便，方法更多，函数更多，但是时间效率上略逊一筹。在这一个月的java学习过程中，刚开始起步很困难，总是想不出来java应该怎么写，用之前写C语言的思路来写java，虽然大相径庭，但是还是没有领悟到“面向对象”的真谛。现在我已经略有领悟，期待未来可以熟练掌握java的日子！
Pta作业已经写了三次，从第一次的作业开始，最后一题的难度就非常大，涉及的知识面也非常广，需要自学的内容比较多，而时间也相对于上学期c语言的pta要紧，导致刚开始并没有很好的适应本学期Java课的作业量与难度，作业也经常难以完成，只能做到完成前面的相对而言较为简单的题目，但是得分因此非常低，最后一题也从没真正完成过，想着能得多少分得多少分。总体来说，前三次pta的主要知识点还是在认识java的语言，学会使用类，分割字符串，比较以及对某一字符串的识别以及用面向对象的思维方式。第一次pta作业主要是让我们学习部分java语言，毕竟之前都是c语言，课设也是c语言+ege，对完全没有接触过java语言的我们还是很有挑战的。后面两次pta作业虽然题量不多，但是难度很大，有很多类的调用，十分复杂，还需要使用很多函数，对我们来说确实十分困难。
二．设计与分析：
第一次题目集最后一题：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：

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
代码如下：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

    int questionCount = Integer.parseInt(scanner.nextLine());ExamPaper examPaper = new ExamPaper();for (int i = 0; i < questionCount; i++) {String line = scanner.nextLine();String[] parts = line.split(":");parts[1]=parts[1].substring(0, parts[1].length() - 2);parts[2]=parts[2].substring(0, parts[2].length() - 2);// parts[3]=parts[3].substring(0, parts[3].length() - 2);parts[1]=parts[1].trim();parts[2]=parts[2].trim();// parts[3]=parts[3].trim();int number = Integer.parseInt(parts[1].substring(0));String content = parts[2].substring(0);String standardAnswer = parts[3].substring(0);

// System.out.println(number);
// System.out.println(content);
// System.out.println(standardAnswer);
examPaper.saveQuestion(number, content, standardAnswer);
}

    AnswerSheet answerSheet = new AnswerSheet(examPaper);while (true) {String line = scanner.nextLine();if (line.equals("end")) {break;}String[] answers = line.split(" ");for (int i = 0; i < answers.length; i++) {answerSheet.saveAnswer(i + 1, answers[i].substring(3));}}for (int i = 1; i <=questionCount; i++) {answerSheet.output(i);}if(questionCount==1){answerSheet.printResults1();}//answerSheet.printResults2();else{answerSheet.printResults2();}
}

}
class Question {
private int number;
private String content;
private String standardAnswer;

public Question(int number, String content, String standardAnswer) {this.number = number;this.content = content;this.standardAnswer = standardAnswer;
}
public int getNumber() {return number;
}
public String getContent() {return content;
}
public String getStandardAnswer() {return standardAnswer;
}
public boolean checkAnswer(String answer) {return answer.equals(standardAnswer);
}

}
class ExamPaper {
private List questionList = new ArrayList<>();

public void saveQuestion(int number, String content, String standardAnswer) {Question question = new Question(number, content, standardAnswer);questionList.add(question);
}public boolean checkAnswer(int number, String answer) {return questionList.get(number - 1).checkAnswer(answer);
}public List<Question> getQuestionList() {return questionList;
}

}

class AnswerSheet {
private ExamPaper examPaper;
private List answerList = new ArrayList<>();
private List result = new ArrayList<>();

public AnswerSheet(ExamPaper examPaper) {this.examPaper = examPaper;
}public void saveAnswer(int number, String answer) {answerList.add(answer);result.add(examPaper.checkAnswer(number, answer));
}public void output(int number) {//int i=0;Question question = examPaper.getQuestionList().get(number - 1);System.out.println(question.getContent() + "~" + answerList.get(number-1));
}public void printResults1() {for (boolean res : result) {System.out.print(res);}
}
public void printResults2() {int count=0;for (boolean res : result) {System.out.print(res );if(count!=result.size()-1) {System.out.print(" ");}count++;}
}

}

设计建议:
以下是针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：
题目类（用于封装单个题目的信息）：
属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、
判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）
属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能对应
答卷类（用于封装答题信息）
解释
属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。

第二次题目集最后一题：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=₅true
4+6=₂₂false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分

N:3 #Q:3+2= #A:5

S:1 #A:5 #A:4

end
输出样例:
在这里给出相应的输出。例如：
1+1=₅false
2+2=₄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

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=₅true
2+2=₂₂false
7 0~7
2+2=₅false
1+1=₄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
代码如下：
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input;
int testnum = 0;
int papernum = 0;
int answernum = 0;
Test[] quiz = new Test[5];
Paper[] paper = new Paper[2];
Answer[] answer = new Answer[5];
while (true) {
input = scanner.nextLine();
if (input.equals("end")) {
scanner.close();
break;
} else {
int k = sort(input);
switch (k) {
case 1:
String[] test = f1(input);
quiz[testnum] = new Test(test[0], test[1], test[2]);
testnum++;
break;
case 2:
int[] a = f2(input);
paper[papernum] = new Paper(Integer.toString(a[0]), Integer.toString(a[1]), a[2], Integer.toString(a[3]), a[4], a[2] + a[4]);
papernum++;
break;
case 3:
String[] b = f3(input);
answer[answernum] = new Answer(b[0], b[1], b[2]);
answernum++;
break;
}
}
}
for (int i = 0; i < papernum; i++) {
if (paper[i].getTotalscore() != 100) {
System.out.println("alert: full score of test paper" + paper[i].getNum() + " is not 100 points");
}
}
for (int i = 0; i < answernum; i++) {
if (Integer.parseInt(answer[i].getNum()) > papernum) {
System.out.println("The test paper number does not exist");
} else {
String num1 = paper[i].getTest1();
String num2 = paper[i].getTest2();
int score = 0;
int score1 = 0;
int score2 = 0;
for (int j = 0; j < testnum; j++) {
if (quiz[j].getNum().equals(num1)) {
if (answer[i].getAnswer1().equals(quiz[j].getAnswer())) {
score1 = paper[i].getScore1();
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer1() + "~true");
} else {
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer1() + "~false");
}
break;
}
}
for (int j = 0; j < testnum; j++) {
if (quiz[j].getNum().equals(num2)) {
if (answer[i].getAnswer2().equals(quiz[j].getAnswer())) {
score2 = paper[i].getScore2();
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer2() + "~true");
} else {
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer2() + "~false");
}
break;
}
}
score = score1 + score2;
answer[i].setUntimatescore(score);
System.out.println(score1 + " " + score2 + "~" + score );
}
}
}

public static int sort(String input) {String regex1 = "#N:(\\d+)\\s*#Q:\\s*([^\\s]+)=\\s*#A:\\s*([^\\s]+)";String regex2 = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";String regex3 = "#S:(\\d+)\\s*#A:(\\d+)\\s*#A:(\\d+)";if (input.matches(regex1)) {return 1;} else if (input.matches(regex2)) {return 2;} else if (input.matches(regex3)) {return 3;}return 0;
}public static String[] f1(String input) {String regex = "#N:(\\d+)\\s*#Q:\\s*([^\\s]+=)\\s*#A:\\s*([^\\s]+)";Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);String[] array = new String[3];if (matcher.matches()) {array[0] = matcher.group(1);array[1] = matcher.group(2);array[2] = matcher.group(3);}return array;
}public static int[] f2(String input) {String regex = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);int[] array = new int[5];if (matcher.matches()) {array[0] = Integer.parseInt(matcher.group(1));array[1] = Integer.parseInt(matcher.group(2));array[2] = Integer.parseInt(matcher.group(3));array[3] = Integer.parseInt(matcher.group(4));array[4] = Integer.parseInt(matcher.group(5));}return array;
}public static String[] f3(String input) {String regex = "#S:(\\d+)\\s*#A:(\\d+)\\s*#A:(\\d+)";Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);String[] array = new String[3];if (matcher.matches()) {array[0] = matcher.group(1);array[1] = matcher.group(2);array[2] = matcher.group(3);}return array;
}public static int[] f4(String input) {String regex = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);int[] array = new int[7];if (matcher.matches()) {array[0] = Integer.parseInt(matcher.group(1));array[1] = Integer.parseInt(matcher.group(2));array[2] = Integer.parseInt(matcher.group(3));array[3] = Integer.parseInt(matcher.group(4));array[4] = Integer.parseInt(matcher.group(5));array[5] = Integer.parseInt(matcher.group(6));array[6] = Integer.parseInt(matcher.group(7));}return array;
}

}

class Test {
private String num;
private String question;
private String answer;
public Test() {
}
public Test(String num, String question, String answer) {
this.num = num;
this.question = question;
this.answer = answer;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getQuestion() {
return question;
}
public void setQuestion(String question) {
this.question = question;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Paper {
private String num;
private String test1;
private int score1;
private String test2;
private int score2;
private int totalscore;
public Paper() {
}
public Paper(String num, String test1, int score1, String test2, int score2, int totalscore) {
this.num = num;
this.test1 = test1;
this.score1 = score1;
this.test2 = test2;
this.score2 = score2;
this.totalscore = totalscore;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getTest1() {
return test1;
}
public void setTest1(String test1) {
this.test1 = test1;
}
public int getScore1() {
return score1;
}
public void setScore1(int score1) {
this.score1 = score1;
}
public String getTest2() {
return test2;
}
public void setTest2(String test2) {
this.test2 = test2;
}
public int getScore2() {
return score2;
}
public void setScore2(int score2) {
this.score2 = score2;
}
public int getTotalscore() {
return totalscore;
}
public void setTotalscore(int totalscore) {
this.totalscore = totalscore;
}
}
class Answer {
private String num;
private String answer1;
private String answer2;
private int untimatescore;
public int getUntimatescore() {
return untimatescore;
}
public void setUntimatescore(int untimatescore) {
this.untimatescore = untimatescore;
}
public Answer() {
}
public Answer(String num, String answer1, String answer2) {
this.num = num;
this.answer1 = answer1;
this.answer2 = answer2;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getAnswer1() {
return answer1;
}
public void setAnswer1(String answer1) {
this.answer1 = answer1;
}
public String getAnswer2() {
return answer2;
}
public void setAnswer2(String answer2) {
this.answer2 = answer2;
}
}

第二次题目集最后一题与第一次题目集最后一题总体相差并不大，大致框架是一样的，但是相对于第一题来说多了每一题具体的分值，同时还可能出现两张试卷，不同试卷有不同的题目，还得判断试卷中题目的分值是否达到一百，并由此出现不同的应对，在第一次的基础上添加相应代码给题目赋分，同时加上一些函数，计算答题卡得分情况并输出即可。
第三次题目集最后一题：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=₅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=₅true
4+6=₂₂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

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=₅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=₅false
中国第一颗原子弹的爆炸时间₄false
20201103 Tom: 0 0~0
代码如下：
import java.util.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.LinkedList;
import java.util.LinkedHashMap;

public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
LinkedHashMap<Integer,Question> question = new LinkedHashMap<Integer,Question>();
LinkedHashMap<Integer,TestPaper> testpaper = new LinkedHashMap<Integer,TestPaper>();
LinkedList ans = new LinkedList<>();
LinkedList studentlist = new LinkedList<>();
//输入
while(true)
{
LinkedHashMap<Integer,String> an = new LinkedHashMap<>();
String newin = input.nextLine();
// System.out.println(newin);
if(newin.equals("end"))
{
break;
}
if(newin.startsWith("#N:"))
{
if(newin.matches("#N:(\s\d+\s)#Q:(.)#A:(.)"))
{
int index1 = newin.indexOf("#N:");
int index2 = newin.indexOf("#Q:");
int index3 = newin.indexOf("#A:");
String num = newin.substring(index1+3,index2).trim();
int number = Integer.parseInt(num);
String content = newin.substring(index2+3,index3).trim();
String standardAnswer = newin.substring(index3+3,newin.length()).trim();
question.put(number,new Question(number,content,standardAnswer,true));
}
else
System.out.println("wrong format:"+newin);
}
else if(newin.startsWith("#T:"))
{
if(newin.matches("#T:\s(\d)\s(\s\d+-\d+\s)"))
{
String regex = "#T:\s(\d+)\s(.)";
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(newin);
mat.find();
int pid = Integer.parseInt(mat.group(1).trim());
//System.out.printf("%d\n",pid);
TestPaper paper = new TestPaper();
Pattern pat1 = Pattern.compile("(\d+)-(\d+)");
Matcher mat1 = pat1.matcher(newin);
while(mat1.find())
{
int qid=Integer.parseInt(mat1.group(1));
int score =Integer.parseInt(mat1.group(2));
paper.addQuestion(qid,score);
//System.out.printf("%d %d\n",qid,score);
}
testpaper.put(pid,paper);
}
else
System.out.println("wrong format:"+newin);
}
else if(newin.startsWith("#S:"))
{
if(newin.matches("#S:\s(\d+)\s+(\w)\s(#A:\s(\d+-?[^#]))"))
{
String regex = "#S:\s(\d+)\s+(\w)\s(#A:\s(\d+-?[^#]))*";
Pattern pat2 = Pattern.compile(regex);
Matcher mat2 = pat2.matcher(newin);
mat2.find();
int aid = Integer.parseInt(mat2.group(1).trim());
int sid = Integer.parseInt(mat2.group(2).trim());
//System.out.print(aid);

                int count=0;if(testpaper.containsKey(aid)){Pattern pat3 = Pattern.compile("#A:(\\d+)-?([^#]*)");Matcher mat3 = pat3.matcher(newin);while(mat3.find()){int order =Integer.parseInt (mat3.group(1).trim());String a = mat3.group(2).trim();an.put(order,a);count++;}}Answer answer = new Answer(an,count,aid,sid);ans.add(answer);}elseSystem.out.println("wrong format:"+newin);}else if(newin.startsWith("#X:")){if(newin.matches("#X:\\s*(\\d+)\\s*(.*)(-(\\d+)\\s*(.*))*")){Pattern pat4 = Pattern.compile("#X:(\\s*(\\d+)\\s*(.*)(-\\s*(\\d+)\\s*(.*))*)");Matcher mat4 = pat4.matcher(newin);mat4.find();String in = mat4.group(1).trim();Pattern pat5 = Pattern.compile("\\s*(\\d+)\\s*(\\w+)\\-*");Matcher mat5 = pat5.matcher(newin);while(mat5.find()){int sid=Integer.parseInt(mat5.group(1).trim());String name = mat5.group(2).trim();//System.out.println(sid+name);Student stu = new Student(sid,name);studentlist.add(stu);}}elseSystem.out.println("wrong format:"+newin);}else if(newin.startsWith("#D:N-")){if(newin.matches("#D:N-\\s*\\d+\\s*")){Pattern pat6 = Pattern.compile("#D:N-\\s*(\\d+)\\s*");Matcher mat6 = pat6.matcher(newin);mat6.find();int did = Integer.parseInt(mat6.group(1).trim());if(question.containsKey(did)){question.get(did).setisvalid(false);}}elseSystem.out.println("wrong format:"+newin);}else System.out.println("wrong format:"+newin);}//输出for(int key:testpaper.keySet()){if(testpaper.get(key).getfullscore()!=100){System.out.println("alert: full score of test paper"+key+" is not 100 points");}}for(Answer a:ans){int key=a.getid();if(!testpaper.containsKey(a.getid())){System.out.println("The test paper number does not exist");continue;}else{int flag = 0;Student student = new Student();for(Student stu:studentlist){if(a.getsid()==stu.getsid()){student=stu;flag=1;break;}}int m=1;for(int key1:testpaper.get(key).getquestions().keySet()){if(a.getanswers().containsKey(m)){if(question.containsKey(key1)){if(question.get(key1).getStandardAnswer().equals(a.getanswers().get(m))){a.setresults(true);}else{a.setresults(false);}}}else{a.setresults(false);}m++;}m=0;int o=1;int all=0;if(a.getcount()==0){//System.out.println(testpaper.get(key).getnumber());for(int z=0;z<testpaper.get(key).getnumber();z++)System.out.println("answer is null");if(flag==1){System.out.print(student.getsid()+" "+student.getname()+":");for(int i=0;i<testpaper.get(key).getnumber();i++){System.out.print(" "+0);}System.out.println("~"+0);}else{System.out.println(a.getsid()+" not found");}}else{for(int i:testpaper.get(key).getquestions().keySet()){if(a.getanswers().containsKey(o)){if(!question.containsKey(i)){System.out.println("non-existent question~0");o++;continue;}if(question.get(i).getisvalid()){System.out.println(question.get(i).getContent()+"~"+a.getanswers().get(o)+"~"+question.get(i).getStandardAnswer().equals(a.getanswers().get(o)));// all+=testpaper.get(key).getquestions().get(i);}else{System.out.println("the question "+i+" invalid~0");}}else{System.out.println("answer is null");}o++;}if(flag==1){System.out.print(student.getsid()+" "+student.getname()+":");if(testpaper.get(key).getnumber()==0){System.out.print(" 0");break;}m=0;o=1;for(int i:testpaper.get(key).getquestions().keySet()){if(a.getanswers().containsKey(o)){if(!question.containsKey(i)){System.out.print(" 0");}else{if(question.get(i).getisvalid()){if(question.get(i).getStandardAnswer().equals(a.getanswers().get(o))){System.out.print(" "+testpaper.get(key).getquestions().get(i));all+=testpaper.get(key).getquestions().get(i);}else{System.out.print(" 0");}}else{System.out.print(" 0");}}}else{System.out.print(" 0");}o++;}System.out.println("~"+all);}elseSystem.out.println(a.getsid()+" not found");}}}
}

}
class Question {
public int qid;
private String content;
private String standardAnswer;
private boolean isvalid;
public Question(){

}
public Question(int qid,String content, String standardAnswer,boolean isvalid) {  this.qid=qid;this.content = content;  this.standardAnswer = standardAnswer;  this.isvalid = isvalid;
}
public int getqid(){return qid;
}
public void setisvalid(boolean isvalid)
{this.isvalid=isvalid;
}
public String getContent() {  return content;  
}  public String getStandardAnswer() {  return standardAnswer;  
}

public boolean getisvalid()
{
return isvalid;
}
public boolean isCorrectAnswer(String answer) {
return standardAnswer.equals(answer);
}
}

class TestPaper {
private int number=0;
private LinkedHashMap<Integer, Integer> questions = new LinkedHashMap<Integer, Integer>();
private int fullscore=0;
TestPaper()
{

}
public int getnumber()
{return number;
}
public int getfullscore()
{return fullscore;
}
public Map<Integer, Integer> getquestions(){return Collections.unmodifiableMap(questions);
}
public void addQuestion(int qid, int score) {questions.put(qid, score);fullscore += score;number++;
}

}

class Answer {
private int aid;
private int count;
private int sid;
private LinkedHashMap<Integer,String> answers = new LinkedHashMap<>();
private Listresults = new ArrayList();
public Answer(LinkedHashMap<Integer,String>answers,int count,int aid,int sid)
{
this.answers=answers;
this.count=count;
this.aid=aid;
this.sid=sid;
}
public int getid()
{
return aid;
}
public int getcount()
{
return count;
}
public int getsid()
{
return sid;
}
public LinkedHashMap<Integer,String> getanswers(){
return answers;
}
public void setresults(boolean result){
this.results.add(result);
}
public List getresults(){
return results;
}
}

class Student{
private int sid;
private String name;
public int getsid(){
return sid;
}
public String getname(){
return name;
}
public void setsid(int sid){
this.sid=sid;
}
public Student(){}
public Student(int sid,String name){
this.sid=sid;
this.name=name;
}
}

第三次题目集最后一题和前两次的也是大致相同的结构框架也同样是多了一些需要补充的内容和功能，在原有代码的基础上进行修改就可以实现。
3.采坑心得:
题目所给的测试样例只是最终得到结果的一部分，还有一些测试点还需要自己慢慢去摸索，有时候即使测试点通过，也没有分得，这些都是一些细节方面得问题，需要在写的时候就非常谨慎，尽量不去犯，不然修改的时候会很难察觉这些细节方面得问题，有一个题目就是一个数据输入错误，导致多花了两三个小时的时间去查找修改这个错误，非常不应该
4.改进建议:
在写代码时要更加谨慎，同时不能想着一次性就把整体代码写好，要分点进行，出错了就及时修改，要不然整体写完却还是有一些细节方面得错误时就难以找到这个错误并进行修改。
5.总结：
1.题目的难度和时间相对于上个学期有较大改变，需要尽快适应过来
2.类的构建各类使用还不够成熟
3.正则表达式的运用并不熟练
4.前期应该化一部分时间完成整体题目的设计，明白基本思路方便后续拓展与优化，而不是看到题目直接敲代码，这样后续修修补补会更改困难，而且可能因为前期设计的失误导致部分功能无法实现进而导致整个代码重写

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.ulsteruni.cn/article/24762351.html

如若内容造成侵权/违法违规/事实不符，请联系编程大学网进行投诉反馈email:xxxxxxxx@qq.com，一经查实，立即删除！