南昌航空大学-软件学院-23201524-刘子平-JAVA第一次Blog作业
前言
本学期已经学习JAVA一个多月的时间，对比上学期所学习的C语言，JAVA更加方便和更好理解。最开始起步困难，想不出来从何入手JAVA程序，一直用C语言的思路来写JAVA程序，没有领悟到面对“对象”程序设计中对象的含义，依旧是面向过程进行整体的程序设计。现在略微掌握了JAVA的基本思路，期望经过之后的进一步学习，最后熟练掌握JAVA。
PTA的前三次作业在知识点上逐渐深入，逐步展现出面向对象的特性，每次作业的前面几个题目的难度都适中，最后一题的答题判题程序才是每次OOP作业的重难点，也因此它的得分很重。虽然三次作业我都得了满分，但实际上我所写的代码即使经过了繁琐的细节思考和逻辑思考，依旧有很多不足之处。以下是对三次PTA作业的概要分析。
设计与分析
PTA第一次作业
7-1 答题判题程序-1
分数 50
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、题目内容
一行为一道题，可以输入多行数据。
格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
3、答题信息
答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。
格式："#A:"+答案内容
格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。
样例：#A:2 #A:78
2是题号为1的题目的答案
78是题号为2的题目的答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、答题信息
一行为一道题的答题信息，根据题目的数量输出多行数据。
格式：题目内容+" ~"+答案
样例：1+1=~2
2+2= ~4
3、判题信息
判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。
格式：判题结果+" "+判题结果
格式约束：
1、判题结果输出只能是true或者false，
2、判题信息的顺序与输入答题信息中的顺序相同
样例：true false true
输入样例1:
单个题目。例如：
1
#N:1 #Q:1+1= #A:2
#A:2
end
输出样例1:
在这里给出相应的输出。例如：
1+1=~2
true
输入样例2:
单个题目。例如：
1
#N:1 #Q:1+1= #A:2
#A:4
end
输出样例2:
在这里给出相应的输出。例如：
1+1=~4
false
输入样例3:
多个题目。例如：
2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:4
end
输出样例3:
在这里给出相应的输出。例如：
1+1=~2
2+2=~4
true true
输入样例4:
多个题目。例如：
2
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#A:2 #A:2
end
输出样例4:
在这里给出相应的输出。例如：
1+1=~2
2+2=~2
true false
输入样例5:
多个题目，题号顺序与输入顺序不同。例如：
2
#N:2 #Q:1+1= #A:2
#N:1 #Q:5+5= #A:10
#A:10 #A:2
end
输出样例5:
在这里给出相应的输出。例如：
5+5=~10
1+1=~2
true true
输入样例6:
含多余的空格符。例如：
1
#N:1 #Q: The starting point of the Long March is #A:ruijin
#A:ruijin
end
输出样例6:
在这里给出相应的输出。例如：
The starting point of the Long March is~ruijin
true
输入样例7:
含多余的空格符。例如：
1
#N: 1 #Q: 5 +5= #A:10
#A:10
end
输出样例7:
在这里给出相应的输出。例如：
5 +5=~10
true
设计建议:
以下针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：
题目类（用于封装单个题目的信息）：
属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、
判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）
属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能对应
答卷类（用于封装答题信息）
属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
import java.util.*;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int count =input.nextInt();
input.nextLine();
Question[] question = new Question[count];
for(int i=0;i<count;i++)
{
String q = input.nextLine();
int index1 = q.indexOf("#N:");
int index2 = q.indexOf("#Q:");
int index3 = q.indexOf("#A:");
String num = q.substring(index1+3,index2).trim();
int number = Integer.parseInt(num);
String content = q.substring(index2+3,index3).trim();
String standardAnswer = q.substring(index3+3,q.length()).trim();
question[number-1] = new Question(number,content,standardAnswer);
}
TestPaper testPaper = new TestPaper(question);
String an=input.nextLine();
int index[]=new int[count];
int n=0;
String[] answers = new String[count];
for(int i=0;i<count;i++)
{
index[i]=an.indexOf("#A:",n);
n=index[i] + 1;
}
for(int i=0;i<count;i++)
{
if(i==count-1)
answers[i] = an.substring(index[i]+3,an.length()).trim();
else
answers[i] = an.substring(index[i]+3,index[i+1]).trim();
}
Answer answer = new Answer(count,testPaper,answers);
for(int i=0;i<count;i++)
answer.check(i);
for(int i=0;i<count;i++)
System.out.println(question[i].getContent()+"~"+answers[i]);
for(int i=0;i<count;i++){
if(i!=count-1)
System.out.print(answer.getresults(i)+" ");
else
System.out.printf("%s",answer.getresults(i));
}
}
}
class Question {
private int number;
private String content;
private String standardAnswer;
public Question(){
}
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 isCorrectAnswer(String answer) {
return standardAnswer.equals(answer);
}
}
class TestPaper {
private Question[] questions;
TestPaper(Question[] questions)
{
this.questions = questions;
}
public boolean check(int id,String ans)
{
return questions[id].isCorrectAnswer(ans);
}
}
class Answer {
private TestPaper testPaper;
private String[] answers;
private boolean[] results;
public Answer(int num,TestPaper testPaper,String[] answers)
{
this.answers = new String[num];
this.results = new boolean[num];
this.testPaper = testPaper;
this.answers=answers;
}
public void check(int id)
{
this.results[id] = testPaper.check(id,answers[id]);
}
public boolean getresults(int id)
{
return results[id];
}
}
分析：本题主要涉及对题目内容和格式的理解，以及确定如何有效地将题目信息和答题信息存储在各个类中，以便进行比较和判断。因为刚接触正则表达式，几次都没用对，最后换了indexOf判断下标来记录题目信息和答题信息，在后面的迭代中把信息存储进行了大改，换成了正则表达式。
PTA第二次作业
7-2 答题判题程序-2
分数 54
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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，建议增加答题类，类的内容以及类之间的关联自行设计。
输入样例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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
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<Answer> ans = new LinkedList<>();
while(true)
{
String newin = input.nextLine();
//System.out.println(newin);
if(newin.equals("end"))
{
break;
}
if(newin.startsWith("#N:"))
{
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(content,standardAnswer));
}
if(newin.startsWith("#T:"))
{
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);
}
if(newin.startsWith("#S:"))
{
String regex = "#S:\\s*(\\d*)\\s*(#A:(.*))*";
Pattern pat2 = Pattern.compile(regex);
Matcher mat2 = pat2.matcher(newin);
mat2.find();
int aid = Integer.parseInt(mat2.group(1).trim());
//System.out.print(aid);
List<String>answers = null;
int count=0;
if(testpaper.containsKey(aid))
{
int n = testpaper.get(aid).getnumber();
Pattern pat3 = Pattern.compile("#A:");
Matcher mat3 = pat3.matcher(newin);
while(mat3.find())
{
count++;
}
int index[]=new int[count];
for(int i=0;i<count;i++)
{
index[i]=newin.indexOf("#A:",n);
n=index[i] + 1;
}
answers = new ArrayList<String>();
for(int i=0;i<count;i++)
{
if(i==count-1)
answers.add(newin.substring(index[i]+3,newin.length()).trim());
else
answers.add(newin.substring(index[i]+3,index[i+1]).trim());
}
for(int i=count;i<n;i++)
{
answers.add(null);
}
}
Answer answer = new Answer(answers,count,aid);
ans.add(answer);
}
}
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(key))
{
System.out.println("The test paper number does not exist");
continue;
}
int m=0;
for(int key1:testpaper.get(key).getquestions().keySet())
{
a.setresults(question.get(key1).getStandardAnswer().equals(a.getanswers().get(m++)));
}
m=0;
if(a.getcount()<testpaper.get(key).getnumber())
{
if(a.getcount()==0)
{
for(int i=0;i<testpaper.get(key).getnumber();i++)
System.out.println("answer is null");
}
else
{
for(int key1:testpaper.get(key).getquestions().keySet())
{
System.out.println(question.get(key1).getContent()+"~"+a.getanswers().get(m)+"~"+question.get(key1).getStandardAnswer().equals(a.getanswers().get(m++)));
if(m==a.getcount())
break;
}
for(int i=a.getcount();i<testpaper.get(key).getnumber();i++)
System.out.println("answer is null");
}
}
else
{
for(int key1:testpaper.get(key).getquestions().keySet())
{
// System.out.println(ans.get(key).getanswers().get(1));
System.out.println(question.get(key1).getContent()+"~"+a.getanswers().get(m)+"~"+question.get(key1).getStandardAnswer().equals(a.getanswers().get(m++)));
}
}
m=0;
int all=0;
for(int key1:testpaper.get(key).getquestions().keySet())
{
if(a.getresults().get(m))
{
if(m++==0)
System.out.print(testpaper.get(key).getquestions().get(key1));
else
System.out.print(" "+testpaper.get(key).getquestions().get(key1));
all+=testpaper.get(key).getquestions().get(key1);
}
else
{
if(m++==0)
System.out.print(0);
else
System.out.print(" "+0);
}
}
System.out.println("~"+all);
}
}
}
class Question {
private String content;
private String standardAnswer;
public Question(){
}
public Question(String content, String standardAnswer) {
this.content = content;
this.standardAnswer = standardAnswer;
}
public String getContent() {
return content;
}
public String getStandardAnswer() {
return standardAnswer;
}
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 List<String>answers = new ArrayList<String>();
private List<Boolean>results = new ArrayList<Boolean>();
public Answer(List<String> answers,int count,int aid)
{
this.answers=answers;
this.count=count;
this.aid=aid;
}
public int getid()
{
return aid;
}
public int getcount()
{
return count;
}
public List<String> getanswers(){
return answers;
}
public void setresults(boolean result){
this.results.add(result);
}
public List<Boolean> getresults(){
return results;
}
}
分析：此次作业在上一次的情况下增加了试卷和答卷的信息，以及输出增加了多个警示。本次作业中开始时使用了hashMap，但调试过程中发现hashMap会进行自动的覆盖和排序，所以换成了LinkedhashMap。
以及answer is null的输出最开始以为无论少了几个答案都只用输出一次，后来发现是少一个答案输出一次。
PTA第三次作业
7-3 答题判题程序-3
分数 80
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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
代码长度限制
30 KB
时间限制
1500 ms
内存限制
64 MB
栈限制
8192 KB
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<Answer> ans = new LinkedList<>();
LinkedList<Student> 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);
}
else
System.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);
}
}
else
System.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);
}
}
else
System.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);
}
else
System.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 List<Boolean>results = new ArrayList<Boolean>();
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<Boolean> 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;
}
}
分析：第三次的程序新增了学生这一类，同时还有删除题目的输入。本次作业中的最后三个测试点卡了很久，找了很久问题发现是输入中匹配#S：的正则表达式需要修改，之前的正则表达式经过修改后不能完全匹配输入，二次修改完后就全通过了。
踩坑心得
第二次的作业中对于答案少于试卷题目数量时，answer is null 的输出，我以为只用输出一次，实际上是少几题就要输出几次。
第三次的作业中第九和第十一的测试点卡了我2到3小时，最后发现当随便输入一串不符合的字符串时，要输出wrong format。
第三次作业中，当试卷为空白卷时，也要输出学生的信息。
以上所有的坑全都是细节上的坑，在写代码前先进行细节和逻辑思考就可以避免踩进去。
改进建议
我觉得需要在我自己的类的基础上，增加一些类让原有的类之间串接起来，形成一种关联性，使部分代码更加清晰简洁。
总结
写完PTA的前三次大作业，我对JAVA的理解，也就是面对对象的理解更上一层楼，不再是茫然无措，不知从何下手的状态。
每次作业的最后一题中的错误测试点很多，需要进行很细致的细节思考和逻辑思考。
这三次大作业中，我主要学会使用类与对象、正则表达式和hashMap的用法，但对于其中的正则表达式的使用还不是特别的熟练，需要进一步的学习和研究。
总之，这三次作业使我受益匪浅，找出了我在面对对象程序设计时的思维错误和编写代码时的一些基础错误，让我找到自己应改变的地方。
浙公网安备 33010602011771号