1.前言
- 这三次题目集主要考察对字符串分割，判定输入格式，提取有用信息，最后进行对信息的处理。
- 题目的要求及信息条件较多，在写代码时很容易缺漏一些特殊情况，考虑不周。
- 对我而言并不简单，有很多测试点没过。
2.设计与分析
答题判题程序-1
点击查看题目信息
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、题目内容
一行为一道题，可以输入多行数据。
格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
3、答题信息
答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。
格式："#A:"+答案内容
格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。
样例：#A:2 #A:78
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.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n,i;
n=sc.nextInt();
sc.nextLine();
Answer A = new Answer(n);
for(i=0;i<n;i++)
{
String x=sc.nextLine();
String[] y=x.split("#[ANQ]:");
Question z = new Question(Integer.parseInt(y[1].trim()),y[2].trim(),y[3].trim());
A.x[Integer.parseInt(y[1].trim())-1]=z;
}
for(i=0;i<n;i++)
{
String x=sc.next();
String[] y=x.split("#[A]:");
A.answer[i]=y[1].trim();
}
A.showAnswer();
A.showOutcome();
}
}
class Answer{
int n;
String[] answer;
Question[] x;
public Answer(int n){
this.n=n;
answer = new String[n];
x = new Question[n];
for(int i=0;i<n;i++)
x[i]= new Question();
}
public void showAnswer(){
for(int j=0;j<n;j++)
System.out.println(x[j].question + "~" + this.answer[j]);
}
public void showOutcome(){
for(int j=0;j<n;j++)
{
if(this.answer[j].equals(x[j].answer))
System.out.print("true");
else System.out.print("false");
if(j!=n-1)
System.out.print(" ");
}
}
}
class Question{
int number;
String answer,question;
public Question(int a,String b,String c){
number=a;
question=b;
answer=c;
}
public Question(){
}
}
- 第一次题目相对简单，我通过split对输入的字符串进行分割，因为已知问题的数量，且不存在乱序输入，直接循环n次，将问题信息全部提取保存，在最后输入答案时直接判定即可。
答题判题程序-2
点击查看题目信息
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=~5~true
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=~5~false
2+2=~22~false
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=~5~false
2+2=~22~false
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=~5~false
2+2=~4~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
end
输出样例:
在这里给出相应的输出。例如：
2+2=~5~false
1+1=~22~false
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=~5~true
2+2=~22~false
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=~5~true
2+2=~22~false
70 0~70
3+2=~5~true
2+2=~4~true
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=~5~true
2+2=~22~false
7 0~7
3+2=~5~true
2+2=~4~true
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=~5~true
2+2=~22~false
7 0~7
2+2=~5~false
1+1=~4~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.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String x="";
int n,i,j;
x=sc.nextLine();
List<Question> question= new ArrayList<>();
List<Test> test= new ArrayList<>();
List<Answer> answer= new ArrayList<>();
while(!x.equals("end"))
{
if(x.startsWith("#N"))
{
String[] y=x.split("#[ANQ]:");
Question z = new Question(Integer.parseInt(y[1].trim()),y[2].trim(),y[3].trim());
question.add(z);
}
if(x.startsWith("#T"))
{
int s=0;
String[] y=x.split(" ");
Test tt = new Test(y[0].charAt(3)-'0');
for(i=1;i<y.length;i++)
{
Score ts = new Score(y[i]);
tt.score.add(ts);
for(j=0;j<question.size();j++)
{
if(question.get(j).number==ts.questionNum)
tt.question.add(question.get(j));
}
}
tt.allScore();
test.add(tt);
}
if(x.startsWith("#S"))
{
Answer t = new Answer(x);
if(t.testNum<=test.size())
t.test=test.get(t.testNum-1);//未排序!!!
else
t.test = new Test(0);
answer.add(t);
}
x=sc.nextLine();
}
for(i=0;i<answer.size();i++)
{
if(answer.get(i).test.number==0)
System.out.println("The test paper number does not exist");
else answer.get(i).showScore();
}
}
}
class Test{
int number;
List<Question> question;
List<Score> score;
public Test(int n){
number=n;
question = new ArrayList<>();
score= new ArrayList<>();
}
public void allScore(){
int i,s=0;
for(i=0;i<score.size();i++)
s+=score.get(i).score;
if(s!=100)
System.out.println("alert: full score of test paper"+number+" is not 100 points");
}
}
class Answer{
int testNum;
String[] answer;
Test test;
public Answer(String str){
answer = str.split("\\s*#[SA]:");//0="",1=s,2=a
testNum=Integer.parseInt(answer[1].trim());
test = new Test(testNum);
}
public void showScore(){
int i,j,s=0,f;
for(i=0;i<test.question.size();i++)
{
String t = "false";
if(i+2>=answer.length)
System.out.println("answer is null");
else
{
if(test.question.get(i).answer.equals(answer[i+2]))
t= "true";
System.out.println(test.question.get(i).question+"~"+answer[i+2]+"~"+t);
}
}
for(i=0;i<test.question.size();i++)
{
f=0;
if(i+2<answer.length)
if(test.question.get(i).answer.equals(answer[i+2]))
{
System.out.print(test.score.get(i).score);
s+=test.score.get(i).score;f=1;
}
if(f==0)
System.out.print("0");
if(i==test.question.size()-1)
System.out.print("~");
else System.out.print(" ");
}
System.out.println(s);
}
}
class Question{
int number;
String answer,question;
public Question(int a,String b,String c){
number=a;
question=b;
answer=c;
}
public Question(){
}
}
class Score{
int questionNum;
int score;
public Score(String x){
String[] y = x.split("-");
questionNum=Integer.parseInt(y[0].trim());
score= Integer.parseInt(y[1].trim());
}
}
-
第二次题目存在乱序输入，而且不再有问题总数的提示，只能判断输入是否为end来判定结束。这比第一次题目难了不少，而且我在第一次题目中设计过于简单，不适合本次题目，于是我只能推翻重写。
-
我设计用3个ArrayList储存 题目信息、试卷信息、答卷信息，由于3种信息的输入格式不同，我只需判断开头的输入格式即可判断是哪种信息（在做此题时，我还未考虑到错误输入的情况）。当有问题信息输入时，存入question数组；当有试卷信息输入时，将对应问题提取至试卷中，再存入test数组；当有答卷信息输入时，将对应试卷提取至答卷中，再存入answer数组。最后对answer数组中每个元素进行结果判定及输出即可。
答题判题程序-3
点击查看题目信息
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分五种，信息可能会打乱顺序混合输入。
1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2
3、学生信息
学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。
格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：
格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号
5、删除题目信息
删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+题目号
格式约束：
题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+"~"+答案++"~"+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。
样例：
3+2=~5~true
4+6=~22~false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：**学号+" "+姓名+": "**+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、被删除的题目提示信息
当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。
5、题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息
输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
例如：wrong format:2 #Q:2+2= #4
7、试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。
8、学号引用错误提示信息
如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。
本题暂不考虑出现多张答卷的信息的情况。
输入样例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=~5~false
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=~2~true
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=~5~false
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=~5~false
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=~5~false
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=~5~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=~5~false
中国第一颗原子弹的爆炸时间~4~false
20201103 Tom: 0 0~0
点击查看代码
import java.util.*;
import java.util.regex.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String x="";
int n,i,j,k;
x=sc.nextLine();
List<Test> test= new ArrayList<>();
List<Integer> delete= new ArrayList<>();
List<Student> student= new ArrayList<>();
List<StuAnswer> answer= new ArrayList<>();
List<Question> question= new ArrayList<>();
while(!x.equals("end"))//正则未判定所有出现空格的可能
{
int f=0;
//加入题目
Pattern p = Pattern.compile("\\s*#N:(\\d+)\\s*#Q:(.*)#A:(.*)");
Matcher m = p.matcher(x);
if(f==0&&m.find())//#N
{
//System.out.println("wrong format:"+1);
f=1;
Question z = new Question(Integer.parseInt(m.group(1)),m.group(2),m.group(3));
question.add(z);
}
//加入试卷
p=Pattern.compile("\\s*#T:(\\d)+\\s*((\\d+-\\d+\\s*)*)$");
//1.试卷号 2.剩余内容
m = p.matcher(x);
if(f==0&&m.find())//#T
{
//System.out.println("wrong format:"+2);
int s=0;f=1;
Test tt = new Test(Integer.parseInt(m.group(1).trim()));
String[] y = m.group(2).split(" ");
for(i=0;i<y.length;i++)
{
int f1=0;
Score ts = new Score(y[i]);
tt.score.add(ts);
for(j=0;j<question.size();j++)
if(question.get(j).number==ts.questionNum)
{
tt.question.add(question.get(j));
f1=1;
}
if(f1==0)
{
Question tq = new Question();
tt.question.add(tq);
}
}
test.add(tt);
}
//加入答卷
p=Pattern.compile("\\s*#S:(\\d+)\\s*(\\d+)\\s*((#A:\\d+-\\w*\\s*)*)$");
//1.试卷编号，2.id，3.题号.答案
m = p.matcher(x);
if(f==0&&m.find())//#S 未修改，输入可以选择题号
{
f=1;
//System.out.println("wrong format:"+3);
StuAnswer t = new StuAnswer(m.group(1),m.group(2));
String[] y = m.group(3).split("#A:");
for(i=1;i<y.length;i++)
{
Answer ta = new Answer(y[i]);
t.answer.add(ta);
}
answer.add(t);
}
//删除题目
p=Pattern.compile("\\s*#D:N-(\\d+)");
m = p.matcher(x);
if(f==0&&m.find())//#D
{
f=1;
//System.out.println("wrong format:"+4);
int t = Integer.parseInt(m.group(1).trim());
delete.add(t);
// for(i=0;t!=-1&&i<question.size();i++)
// if(question.get(i).number==t)
// {
// question.get(i).state=0;
// t=-1;
// }
}
//加入学生
p=Pattern.compile("\\s*#X:(\\d+)\\s+(\\w+)((-\\d+\\s+\\w+)*)$");
//1.2.学生1 3.剩余内容
m = p.matcher(x);
if(f==0&&m.find())//#X
{
f=1;
//System.out.println("wrong format:"+5);
Student t = new Student(m.group(1),m.group(2));
student.add(t);
String[] y = m.group(3).split("-");//0.为空
for(i=1;i<y.length;i++)
{
String[] z = y[i].split(" ");
Student tem = new Student(z[0],z[1]);
student.add(tem);
}
}
if(f==0)
System.out.println("wrong format:"+x);
x=sc.nextLine();
}
// //试卷判定
for(i=0;i<test.size();i++)
{
int s=0;
for(j=0;j<delete.size();j++)
test.get(i).deleteQuestion(delete.get(j));
if(test.get(i).addScore()!=100)
System.out.println("alert: full score of test paper"+test.get(i).number+" is not 100 points");
}
//答卷判定
for(i=0;i<answer.size();i++)
{
int f=-1;
StuAnswer t = answer.get(i);
for(j=0;f==-1&&j<test.size();j++)
if(t.testNum==test.get(j).number)
f=j;
if(f!=-1)
{
t.test=test.get(f);
t.showEachScore();
for(j=0;f!=-1&&j<student.size();j++)
{
if(t.id.equals(student.get(j).id))
{
System.out.print(t.id+" "+student.get(j).name+": ");
t.showAllScore();
f=-1;
}
}
if(f!=-1)
System.out.println(t.id+" not found");
}
else System.out.println("The test paper number does not exist");
}
}
}
class Answer{
int questionNum;
String answer;
public Answer(String x){
String[] y = x.split("-");
questionNum=Integer.parseInt(y[0].trim());
answer=y[1].trim();
}
}
class StuAnswer{
int testNum;
String id;
List<Answer> answer;
Test test;
public StuAnswer(String a,String b){
answer = new ArrayList<>();
test = new Test(testNum);
testNum=Integer.parseInt(a.trim());
id=b.trim();
}
public void showEachScore(){
int i,j,f;
for(i=0;i<test.question.size();i++)
{
String t = "false";f=-1;
Question tq = test.question.get(i);
for(j=0;j<answer.size();j++)
if(answer.get(j).questionNum==i+1)
{
f=j;
break;
}
if(f==-1)
System.out.println("answer is null");
else if(tq.number==-1)
System.out.println("non-existent question~0");
else if(test.score.get(i).score==-1)
System.out.println("the question "+tq.number+" invalid~0");
else
{
if(tq.answer.equals(answer.get(j).answer))
{
t= "true";
tq.state=2;
}
System.out.println(test.question.get(i).question+"~"+answer.get(f).answer+"~"+t);
}
}
}
//总成绩显示
public void showAllScore(){
int i,j,s=0;
for(i=0;i<test.question.size();i++)
{
Question tq = test.question.get(i);
if(tq.state==2)
{
System.out.print(test.score.get(i).score);
s+=test.score.get(i).score;
}
else System.out.print("0");
if(i==test.question.size()-1)
System.out.print("~");
else System.out.print(" ");
}
System.out.println(s);
}
}
class Student{
String id;
String name;
Student(String a,String b){
id=a.trim();
name=b.trim();
}
}
class Test{
int number;
List<Question> question;
List<Score> score;
public Test(int n){
number=n;
question = new ArrayList<>();
score= new ArrayList<>();
}
public int addScore(){
int i,s=0;
for(i=0;i<score.size();i++)
s+=score.get(i).score;
return s;
}
public void deleteQuestion(int a){
for(int i=0;i<question.size();i++)
if(a==question.get(i).number)
score.get(i).score=-1;
}
}
class Question{
int number;
int state;
String answer,question;
public Question(int a,String b,String c){
number=a;
question=b.trim();
answer=c.trim();
state=1;
}
public Question(){
number=-1;
question="";
answer="";
state=1;
}
}
class Score{
int questionNum;
int score;
public Score(String x){
String[] y = x.split("-");
questionNum=Integer.parseInt(y[0].trim());
score= Integer.parseInt(y[1].trim());
}
}
-
第三次题目要求再次提升，我发现我在第二次题目中对输入的判定在此次题目中完全不适用，于是之保留了类的基础设计，主体全部重新再写。
-
源码分析如下
-
我先利用正则表达式判断输入信息是否符合标准，若符合某种输入标准，就进入对应的操作，若不符合所以输入标准，则为输入格式错误。
-
找到对应的输入信息后，提取有用信息并存入对应数组中。
-
所有信息输入完毕后，先对试卷进行判定；再判定答卷，将对应的试卷信息存入答卷中，最后对答卷进行结果判定。
3.踩坑心得
1. 这三次题目，每次我都考虑不周，代码仅适用于本次题目，导致我每次都基本是重新写。日后在设计过程中，应广泛考虑实际可能存在的情况，让代码的适用性更广，而非局限在本次题目。
2. 从第一次题目到第三次题目，由于简单的方法不再适用于下一次题目，我逐渐利用ArrayList、正则表达式等解决问题。但在实际代码编写中，由于不熟悉对应的使用方法，写出了很多错误代码，比如：利用.length获取ArrayList的长度；在正则表达式中依靠（）进行分组，但在利用.group()时常不与预期结果匹配。
3.在写代码过程中，如
Test a = new Test();
Test b = a;
未注意：其中a、b指向同一片区域，修改直接修改b会将a修改的问题。应该将a的数据分别复制给b。
4.由于对各个类之间的关系及各种负责的功能考虑不周，时常出现推翻重新写的情况，在以后应该多加思考，想清楚再动手，
4.改进建议
- 在最后一次题目中，我设置了int数组 delete 来储存被删除的题目编号，实际上，可以在question类中加入成员int states；来标识问题的状态（0.问题正常，1.问题被删除，2.问题回答正确 等等）。
- 同时，在test类中，可以另设成员ArrayList
questionNum；来储存可能有的问题编号，等到全部信息输入完成后，再将对应的问题存入test中，即可有效解决乱序输入的问题；
5.总结
- 通过三次题目集练习，我逐渐理解了面向对象的程序设计好处，对类的设计有了更好的掌握。
- 同时，还有很多实用的新东西需要学习，如HashMap、Comparable等。