目录
1.前言：
题目集1：这次的作业题目量较大，而且最后一题难度不小，然后是第一次使用Java语言编写代码，对于类的使用以及Java的一些语法还是很不适应，加上c语言基础不大好，所以在写的时候即使是在前面几个较为简单的题目上也花了很多时间。
题目集2：这次的作业题目作业量减少了蛮多，而且前面三题在有了第一次作业的基础下，没啥困难，但是最后一题难度陡增。
题目集3：这次的题目集可以说对我而言难度非常大，第二题还使用了java的一种新的变量类型--LocalDate，而第三题则是让我看题目都看了很久。
2.设计与分析：
第一次大作业7-5：
题目：
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
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= ~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。
我的代码：
import java.util.Scanner;
import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
class Question
{
int num;
String content;
String answer;
}
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int questionNum=sc.nextInt();
sc.nextLine();
Question[] questions=new Question[questionNum];
for(int i=0;i<questionNum;i++)
{
questions[i]=new Question();
String line=sc.nextLine();
String []parts=line.split("#");
for(String part:parts)
{
if(part.startsWith("N:"))
{
questions[i].num=Integer.parseInt(part.substring(2).trim());
}
else if(part.startsWith("Q:"))
{
questions[i].content=part.substring(2).trim();
}
else if(part.startsWith("A:"))
{
questions[i].answer=part.substring(2).trim();
}
}
}
if(questionNum>=2)
{
for (int i = 0; i < questionNum-1; i++)
{
for(int j=0;j<questionNum-i-1;j++)
{
if(questions[j].num>questions[j+1].num)
{
Question temp=questions[j];
questions[j]=questions[j+1];
questions[j+1]=temp;
}
}
}
}
// sc.nextLine();
String line=" ";
String answers[]=new String [questionNum];
int index=0;
while(sc.hasNextLine())
{
line=sc.nextLine();
if(line.equals("end"))
{
break;
}
String [] parts=line.split(" ");
for(String part:parts)
{
if(part.startsWith("#A:"))
{
answers[index++]=part.substring(3);
}
}
}
for (int i = 0; i < questionNum; i++) {
System.out.println(questions[i].content + "~" + answers[i]);
}
for(int i=0;i<questionNum;i++)
{
if(questions[i].answer.equals(answers[i])&&i!=questionNum-1)
{
System.out.print("true ");
}
else if(!questions[i].answer.equals(answers[i])&&i!=questionNum-1)
{
System.out.print("false ");
}
else if(questions[i].answer.equals(answers[i])&&i==questionNum-1)
{
System.out.print("true");
}
else if(!questions[i].answer.equals(answers[i])&&i==questionNum-1) {
System.out.print("false");
}
}
}
}
第一次大作业7-5总结：
第一次作业我只用了一个题目类，然后在主函数中定义了一个Question数组，将问题使用split拆开并存入数组，再创建一个答案 数组，将答案也使用split拆解并放入答案数组，最后比较，将true与false输出，这样完成了第一次作业。
第二次大作业7-4：
题目：
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=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.*;
class Question {
int number;
String content;
String answer;
public Question(int number, String content, String answer) {
this.number = number;
this.content = content;
this.answer = answer;
}
}
class TestPaper {
int number;
Map<Integer, Integer> questionScores;
public TestPaper(int number, Map<Integer, Integer> questionScores) {
this.number = number;
this.questionScores = questionScores;
}
}
class AnswerSheet {
int testPaperNumber;
List<String> answers;
public AnswerSheet(int testPaperNumber, List<String> answers) {
this.testPaperNumber = testPaperNumber;
this.answers = answers;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<Question> questions = new ArrayList<>();
List<TestPaper> testPapers = new ArrayList<>();
List<AnswerSheet> answerSheets = new ArrayList<>();
while (scanner.hasNextLine())
{
String line = scanner.nextLine();
if (line.equals("end")) {
break;
}
if (line.startsWith("#N:")) {
// 解析题目信息
String[] parts = line.split(" ");
int number = Integer.parseInt(parts[0].substring(3));
String content = parts[1].substring(4).trim();
String answer = parts[2].substring(3).trim();
questions.add(new Question(number, content, answer));
for (int i = 0; i < questions.size() - 1; i++) {
for (int j = 0; j < questions.size() - i - 1; j++) {
if (questions.get(j).number > questions.get(j + 1).number) {
// 使用Collections.swap方法交换两个元素的位置
Collections.swap(questions, j, j + 1);
}
}
}
} else if (line.startsWith("#T:")) {
// 解析试卷信息
String[] parts = line.split(" ");
int number = Integer.parseInt(parts[0].substring(3));
Map<Integer, Integer> questionScores = new HashMap<>();
for (int i = 1; i < parts.length; i++) {
String[] scoreParts = parts[i].split("-");
int questionNumber = Integer.parseInt(scoreParts[0]);
int score = Integer.parseInt(scoreParts[1]);
questionScores.put(questionNumber, score);
}
testPapers.add(new TestPaper(number, questionScores));
} else if (line.startsWith("#S:")) {
// 解析答卷信息
String[] parts = line.split(" ");
int testPaperNumber = Integer.parseInt(parts[0].substring(3));
List<String> answers = new ArrayList<>();
for (int i = 1; i < parts.length; i++) {
answers.add(parts[i].substring(3));
}
answerSheets.add(new AnswerSheet(testPaperNumber, answers));
}
}
// 输出试卷总分警示
for (TestPaper testPaper : testPapers) {
int totalScore = testPaper.questionScores.values().stream().mapToInt(Integer::intValue).sum();
if (totalScore != 100) {
System.out.println("alert: full score of test paper" + testPaper.number + " is not 100 points");
}
}
// 判卷
for (AnswerSheet answerSheet : answerSheets) {
TestPaper testPaper = findTestPaper(testPapers, answerSheet.testPaperNumber);
if (testPaper != null) {
evaluateAnswerSheet(answerSheet, testPaper, questions);
}
}
}
private static TestPaper findTestPaper(List<TestPaper> testPapers, int testPaperNumber) {
for (TestPaper testPaper : testPapers) {
if (testPaper.number == testPaperNumber) {
return testPaper;
}
}
System.out.println("The test paper number"+" does not exist");
return null;
}
private static void evaluateAnswerSheet(AnswerSheet answerSheet, TestPaper testPaper, List<Question> questions) {
List<Integer> scores = new ArrayList<>();
for (int i = 0; i < testPaper.questionScores.size(); i++) {
String answer = answerSheet.answers.get(i);
Question question = findQuestion(questions, answerSheet.testPaperNumber, i + 1);
if (question != null) {
boolean isCorrect = answer.equals(question.answer);
int score = isCorrect ? testPaper.questionScores.get(question.number) : 0;
scores.add(score);
System.out.println(question.number + question.content + "~" + answer + "~" + isCorrect);
}
}
int totalScore = scores.stream().mapToInt(Integer::intValue).sum();
String scoreLine = scores.stream().map(Object::toString).reduce("", (a, b) -> a + " " + b) + "~" + totalScore;
System.out.println(scoreLine.trim());
}
private static Question findQuestion(List<Question> questions, int testPaperNumber, int questionNumber) {
for (Question question : questions) {
if (question.number == questionNumber) {
return question;
}
}
System.out.println("The question number " + questionNumber + " in test paper " + testPaperNumber + " does not exist");
return null;
}
}
第二次大作业7-4总结：
这次的作业得分也不高，因为在判断乱序输入时出了问题，这题我也是定义了三个类，然后使用正则表达式分割信息并存入map，然后分别将试卷答卷和问题添加进入arraylist数组，但是在后面的输出过程因为前面的信息存入出现了问题，导致乱序输入时无法正确输出
第三次大作业7-3：
题目：
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=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.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Question {
int number;
String content;
String answer;
boolean isValid;
boolean isRight;
public Question(){
}
public Question(int number, String content, String answer, boolean isValid) {
this.number = number;
this.content = content;
this.answer = answer;
this.isValid = isValid;
}
public void setInvalid() {
this.isValid = false;
}
}
class TestPaper {
int number;
Map<Integer, Integer> questionNumbersAndScores;
public TestPaper(){
}
public TestPaper(int number, Map<Integer, Integer> questionNumbersAndScores) {
this.number = number;
this.questionNumbersAndScores = questionNumbersAndScores;
}
}
class Student {
int id;
String name;
int totalScore;
Map<Integer, String> answers;
public Student(int id, String name) {
this.id = id;
this.name = name;
this.answers = new HashMap<>();
}
public void addAnswer(int sequenceNumber, String answer) {
this.answers.put(sequenceNumber, answer);
}
}
class AnswerSheet {
int testPaperNumber;
Student student;
List<String> answers;
public AnswerSheet(int testPaperNumber, Student student, List<String> answers) {
this.testPaperNumber = testPaperNumber;
this.student = student;
this.answers = answers;
}
}
public class Main {
private static List<Question> questions = new ArrayList<>();
private static List<TestPaper> testPapers = new ArrayList<>();
private static List<Student> students = new ArrayList<>();
private static List<AnswerSheet> answerSheets = new ArrayList<>();
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
while (true) {
int flag=0;
int flag1=0;
String line = scanner.nextLine();
if (line.equals("end")) {
break;
} else if (line.startsWith("#N:")) {
String str=line;
Pattern pattern = Pattern.compile("#N:(\\s*\\d+\\s*)#Q:(.*)#A:(.*)");
Matcher matcher = pattern.matcher(str);
boolean isMatch = matcher.matches() ;
if(!isMatch){
flag1++;
System.out.println("wrong format:"+line);
}else {
flag1++;
String[] parts = line.split(" ");
int number = Integer.parseInt(parts[0].substring(3));
String content = parts[1].substring(3);
String answer = parts[2].substring(3);
questions.add(new Question(number,content,answer,true));
}
}else if (line.startsWith("#T:")) {
String str=line;
Pattern pattern = Pattern.compile("#T:\\s*(\\d*)\\s*(\\s*\\d+-\\d+\\s*)*");
Matcher matcher = pattern.matcher(str);
boolean isMatch = matcher.matches() ;
if(!isMatch) {
System.out.println("wrong format:" + line);
} else {
String[] parts = line.split(" ");
int paperNumber = Integer.parseInt(parts[0].substring(3));
Map<Integer, Integer> questionNumbersAndScores = new TreeMap<>();
for (int i = 1; i < parts.length; i++) {
String[] questionScoreParts = parts[i].split("-");
int questionNumber = Integer.parseInt(questionScoreParts[0]);
int score = Integer.parseInt(questionScoreParts[1]);
questionNumbersAndScores.put(questionNumber, score);
}
testPapers.add(new TestPaper(paperNumber, questionNumbersAndScores));
}
}else if (line.startsWith("#X:")) {
String str=line;
// Assuming the format is "#X: id-name", update the regex accordingly
Pattern pattern = Pattern.compile("#X:\\s*(\\d+)\\s*(.*)(-(\\d+)\\s*(.*))*");
Matcher matcher = pattern.matcher(str);
boolean isMatch = matcher.matches();
if(isMatch) {
int id = Integer.parseInt(matcher.group(1));
String name = matcher.group(2).replaceFirst("-", ""); // Remove the '-' from the name
Student student = new Student(id, name.trim());
students.add(student);
} else {
System.out.println("wrong format:" + line);
}
} else if (line.startsWith("#D:N-")) {
String str=line;
Pattern pattern = Pattern.compile("#D:N-\\s*\\d+\\s*");
Matcher matcher = pattern.matcher(str);
boolean isMatch = matcher.matches() ;
if(!isMatch) {
System.out.println("wrong format:" + line);
}
else{
String[] parts = line.split("-");
int questionNumber = Integer.parseInt(parts[1]);
for (Question q : questions) {
if (q.number == questionNumber) {
q.setInvalid();
break;
}
}
}
}
else if (line.startsWith("#S:")) {
String[] parts = line.split(" ");
int testPaperNumber = Integer.parseInt(parts[0].substring(3));
int studentId = Integer.parseInt(parts[1]);
Student student = findStudentById(studentId);
//System.out.println("1");
List<String> answers = new ArrayList<>();
for (int i = 2; i < parts.length; i++) {
if (!parts[i].startsWith("#A:")) {
continue;
}
String answerPart = parts[i].substring(3);
String[] answerInfo = answerPart.split("-");
if (answerInfo.length != 2) {
System.out.println("Invalid answer format detected at index " + i);
continue;
}
int sequenceNumber = Integer.parseInt(answerInfo[0]);
String answer = answerInfo[1];
student.addAnswer(sequenceNumber,answer);
answers.add(answer);
}
AnswerSheet answerSheet = new AnswerSheet(testPaperNumber, student, answers);
answerSheets.add(answerSheet);
}
else {
System.out.println("wrong format:"+line);
}
}
// 输出试卷总分警示
for (TestPaper testPaper : testPapers) {
int totalScore = testPaper.questionNumbersAndScores.values().stream().mapToInt(Integer::intValue).sum();
if (totalScore != 100 ) {
System.out.println("alert: full score of test paper" + testPaper.number + " is not 100 points");
}
}
// 判卷
for (AnswerSheet answerSheet : answerSheets) {
TestPaper testPaper = new TestPaper();
testPaper = findTestPaper(testPapers, answerSheet.testPaperNumber);
if (testPaper != null) {
evaluateAnswerSheet(answerSheet, testPaper, questions);
}
}
}
private static Question findQuestionByNumber(List<Question> questions, int questionNumber) {
for (Question question : questions) {
if (question.number == questionNumber && question.isValid) {
return question;
}
}
return null;
}
private static Student findStudentById(int id) {
for (Student student : students) {
if (student.id==id) {
return student;
}
}
return null;
}
private static TestPaper findTestPaper(List<TestPaper> testPapers, int testPaperNumber) {
for (TestPaper testPaper : testPapers) {
if (testPaper.number == testPaperNumber) {
return testPaper;
}
}
System.out.println("The test paper number " + testPaperNumber + " does not exist");
return null;
}
private static void evaluateAnswerSheet(AnswerSheet answerSheet, TestPaper testPaper, List<Question> questions) {
Map<Integer, Integer> sequenceToQuestionNumber = new HashMap<>();
for (Map.Entry<Integer, Integer> entry : testPaper.questionNumbersAndScores.entrySet()) {
sequenceToQuestionNumber.put(entry.getKey(), entry.getKey()); // 假设序列号与题号一致
}
int totalScore = 0;
for (Map.Entry<Integer, String> answerEntry : answerSheet.student.answers.entrySet()) {
int sequenceNumber = answerEntry.getKey();
String answer = answerEntry.getValue();
if(sequenceToQuestionNumber.containsKey(sequenceNumber)){
int questionNumber = sequenceToQuestionNumber.get(sequenceNumber);
Question question = new Question();
question = findQuestionByNumber(questions, questionNumber);
if (question != null && question.isValid) {
if (question.answer.equals(answer)) {
//System.out.println("2");
question.isRight = true;
totalScore += testPaper.questionNumbersAndScores.get(questionNumber);
System.out.println(question.content + "~" + answer + "~true");
} else {
question.isRight = false;
System.out.println(question.content + "~" + answer + "~false");
}
} else if (!question.isValid) {
System.out.println("the question " + questionNumber + " invalid~0");
} else {
System.out.println("answer is null");
}
System.out.print(answerSheet.student.id + " " + answerSheet.student.name + ": ");
if(question.isRight)
System.out.print(testPaper.questionNumbersAndScores.get(questionNumber));
else
System.out.print("0");
}
System.out.print("~"+totalScore);
}
}
}
第三次大作业7-3总结：
这次的作业得分很低，然后写的时候是先定义了一些Hashmap来分割输入信息，然后在定义四个动态数组分别添加题目 试卷 学生 和答卷，但是整体的逻辑出现了问题，我是从试卷到答卷来对应，导致输出出现了很大的问题，这也是我对题目还不够了解，所以会出现这样的问题。
3.踩坑心得：
在第一次题目集的分割题目信息以及答卷和试卷中，我没有使用正则表达式，只是用的split，然后在后面第三次的题目集中一开始也是这么用的，在格式错误那里就一直过不去。还有就是在使用substring时，起初一直写成subString，然后也是一直报错，然后我也没发现。还有就是在输出时要记得写一些非空的判断条件，否则就会一直非零返回。还有就是第三题测试点也没有明显提示，导致很多点都得自己探索，然后就很困难。
4.改进建议：
尽量把数组改为ArrayList链表或HashMap，这样在存入信息会更好操作，且效率更高
然后就是类的使用要准确，写题目之前最好先在纸上画好结构图，这样写起来会更方便准确率也更高
5.总结：
在对待每个最后一题，都要多花时间，把题目要求仔仔细细分析清楚，然后这样对于每个测试点才能做到心里有数。
然后就是每个类中所包含的属性和方法也要仔仔细细想清楚，这样才能在复杂的调用中不乱套。
还有就是要好好学习数据存储等知识，比如Arraylist，Hashmap，还有正则表达式，这三者都是非常重要的做题工具，而且类与对象提供了更加结构化和模块化的编程方式，而正则表达式则提供了一种高效且灵活的文本处理方式，必须能够熟练使用，否则别说是写，看别的写的都费力
然后还有就是写题目心态要好，在面对难题时也不要一直拖拉不写，要坚持写