OOP第一阶段题集总结

一.前言

• 知识点：数组，字符串的使用，链表，hashmap，泛型的使用，正则表达式的使用，类的设计，类与类之间的关系，单一职责。
• 题量：题目数量为5+4+3，数量适中，其中都是前几题较简单，最后一题较为复杂，且每一次都是在前一次的基础上进行迭代。
• 难度：前几题基础简单，最后一题较难，一般需要花费四五天时间去写。

二.设计与分析

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;

class Question{//题目类

int num = 0;

String content = "";

String standerAnswer = " ";

public Question(int num,String content,String standerAnswer){

super();

this.num = num;

this.content = content;

this.standerAnswer = standerAnswer;

}

public int getNum(){

return num;

}

public void setNum(int num){

this.num = num;

}

public String getContent(){

return content;

}

public void setContent(String content){

this.content = content;

}

public String getStanderAnswer(){

return standerAnswer;

}

public void setStanderAnswer(String standerAnswer){

this.standerAnswer = standerAnswer;

}

public boolean judgeAnswer(String answer){//判断题目正误

if(answer.equals(standerAnswer)){

return true;

}

else

return false;

}

}

class Testpaper{//试卷类

int number;

Question[] question = new Question[100];//题目清单

public void setNumber(int num){

this.number=num;

}

public Testpaper(){

}
public Testpaper(int number, Question[] question) {
	super();
	this.number = number;
	this.question = question;
}
public boolean judgeAnswer(int num,String answer){判断对应编号的题目是否正确
    return question[num].judgeAnswer(answer);
}
public void keepQuestion(int num,Question question){保存题目
    this.question[num] = question;
}
public String getQuestion(int num ){//得到题目内容
    return question[num].getContent();
}

}

class Answerpaper{//答卷类

Testpaper testpaper;

String[] answerList = new String[100];//答案清单

boolean[] judgeList = new boolean[100];//判断清单

public Answerpaper(Testpaper testpaper, String[] answerList) {

super();

this.testpaper = testpaper;

this.answerList = answerList;

}

public void outQuestion(int num){//按照要求输出问题

System.out.println(testpaper.getQuestion(num)+"~"+answerList[num]);

}

public void keepAnswer(int num,String answer){//将对应题目答案进行存储

this.answerList[num] = answer;

}

public void setJudge(int i,boolean tt){//存储判断结果

judgeList[i]=tt;

}

public boolean getJudge(int i){

return judgeList[i];

}

}

public class Main{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

int num = input.nextInt();

String str = input.nextLine();

String[] questionList = new String[num];

String[] answer = new String[num];

for(int i=0;i<num;i++){

questionList[i] = input.nextLine();

questionList[i]=questionList[i].replace("#N:",""); //用字符串分割来去除特定符号

    }
    for(int i=0;i<num;i++){
        answer[i] = input.next();
        answer[i]=answer[i].replace("#A:","");
        if(answer[i].equals("end")){
            break;
        }
    }
    String[][] questionDetails = new String[num][3];//利用二维数组将字符串分块
    for(int i=0;i<num;i++){
        questionDetails[i]=questionList[i].split("#(Q|A):");
    }
    for(int i=0;i<num;i++){
        for(int j=0;j<3;j++){
            questionDetails[i][j]=questionDetails[i][j].trim();//分割空格
        }
    }
    Question[] questions=new Question[num];

    for(int i=0;i<num;i++){
        questions[i]=new Question(Integer.parseInt(questionDetails[i][0]),questionDetails[i][1],questionDetails[i][2]);
    }
    Testpaper testpaper=new Testpaper();
    testpaper.setNumber(num);
    for(int i=0;i<num;i++){//注意：因为数组下标从0开始，而题目编号从1开始，所以要减一
        int nn=Integer.parseInt(questionDetails[i][0]);
        testpaper.keepQuestion(nn-1, questions[i]);
    }
    Answerpaper answerpaper=new Answerpaper(testpaper,answer);
    for(int i=0;i<num;i++){
        answerpaper.setJudge(i,testpaper.judgeAnswer(i,answer[i]));
    }
    for(int i=0;i<num;i++){
        answerpaper.outQuestion(i);
    }
    for(int i=0;i<num;i++){
        if(i==num-1){
            System.out.printf("%b",answerpaper.getJudge(i));
            break;
        }
        System.out.printf("%b ",answerpaper.getJudge(i));
    }
}

}

类图：



复杂度分析：

• 这次代码有设计思路提示，所以类的设计不是特别费力，就主要需要我们去解决输入输出问题，写好主方法，因为不存在乱序输入，所以这里我选择的是用二维数组去存题目的三个属性。
• 由图可见：主方法设计不合理，因为里边内容太过复杂，而这次代码用的主要是数组和字符串的方法，数组遍历，利用类的set方法来存储题目和判题结果，相对来说较易理解，但是得注意题目与相应的编号，答案对应，同时要注意方法的调用。

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=₅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=₅false

2+2=₂₂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=₅false

2+2=₂₂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=₅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

end

输出样例:

在这里给出相应的输出。例如：

2+2=₅false

1+1=₂₂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=₅true

2+2=₂₂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=₅true

2+2=₂₂false

70 0~70

3+2=₅true

2+2=₄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=₅true

2+2=₂₂false

7 0~7

3+2=₅true

2+2=₄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=₅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

源码分析：

• ArrayList<Question_paper> questions;在这里与一不同的是我将数组改成了Arraylist类，方便在后面存数据。
• questions.add(question);利用Arraylist本身方法可实现数据的动态增加，不用担心数据越界，这是与判题一中所不同的，而判题一中我只是假设数组的边界。

•         if (str.startsWith("#N:")) {
            String[] parts = str.split("#");
            int num = Integer.parseInt(parts[1].split(":")[1].trim());
            String content = parts[3].split(":")[1].trim();
            String answer = parts[5].split(":")[1].trim();
            questionsNum.put(parts[1].split(":")[1].trim(), new Question(num, content, answer));
        }
  

  由于输入顺序不确定所以在这里我用了if语句和字符串的startswith()语法进行判断，再进行分割，其他类型如此判断，但由于代码并不是特别完善，测试结果也不是过了很多，所以这里不再具体展开。
  
  类图：
  
  
  
  这里由于主方法存在一点问题没解决，所以类图仅是设计所需类之间的关系。
  
  复杂度分析：
  
  
  
  
  
  这里给出试卷和答卷的复杂度分析，因为问题的复杂化加大，所以类也需要增多，相应试卷和答卷所需对象和方法也会增多。

• 很明显，第二次在第一次的基础上进行迭代，如果没有好的结果，好的设计，那么判题二就很难搞定，甚至需要重新进行设计分析。

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=₅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

S:1 20201103 #A:1-5

end

输出样例1:

在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points

1+1=₅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=₂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=₅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=₅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=₅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=₅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

源码分析：

• ArrayList questionList = new ArrayList<>();这里利用泛型定义题目清单，方便数据增加以及方法调用，其实在这里用hashmap效率会更高更方便，但是用着用着反而把自己绕进去了。

•     while (input.hasNextLine()) {//检查是否有下一项输入
        String str = input.nextLine();
        if (str.equals("end")) {//最后一行以end结束
            break;
        }
    没错，我还是一如既往使用字符串加判断的方法来处理输入的字符串，到后面就会发现有很大问题，判断不全面，测试点过不了。
  

• String firstNumberRegex = "(\d+)(?<=\s*[^\d]+:\d+)";//利用正则表达式匹配第一个数字，例如试卷编号
  
  Pattern pattern = Pattern.compile(firstNumberRegex+"|");
  
  Matcher matcher = pattern.matcher(input);
  
  String firstNumber;
  
  while(matcher.find()){
  
  String group = matcher.group();
  
  if(firstNumber==NULL&&matcher.group(0).equals(matcher.group(1))){//判断是否是第一个数字
  
  firstNumber = group;
  
  }
  
  }
  
  类图：
  
  
  
  复杂度分析：
  
  
• 由类图和复杂度分析可见，我的设计还存在问题，即字符串处理和错误信息处理有问题，我有想过把处理字符串这一块单独设计类和对象，用正则表达式处理，可惜处理不到位我还是使用了老方法，结果是行不通。

三.踩坑心得

1.首先对于这种很长信息量大的题目一定要有耐心去读题，去分析，去思考，不然连题目都看不懂，更别提写出来了。

2.认真审题真的很重要，由于判题一老师给出了设计思路，那么整道题也就降低了难度，因为最复杂的类设计思路已经有了，所以第一次的测试成功通过。而后来的题目没有了设计思路，就需要我们自己去设计，而我自己也是对代码反反复复写了好几遍再修改，这也正是这道题的重难点。

3.数据存不进去，可能是由于我没有将字符串内容处理正确带入相应链表和构造方法。

4.会使用正则表达式真的很重要，因为内容题目答案不断增多，使用字符串去判断真的很慢很复杂。

5.不要因为过测试点而做题，取巧的方法过测试点能过一次不代表次次都能过，简单取巧违背做题初心，漏洞的结构不合理的设计终不会长久，反而让自己的代码不可迭代，修改也不好改，重写也会浪费很多时间，得不偿失。

6.要注重单一职责原则，很明显以上的复杂度分析无不显示我的主方法太过臃肿，这明显违背单一职责，主方法的作用应该是用来输入输出的，因此我们要自己增设类处理问题，而不是把所有动西全部塞进主方法。

四.改进建议

• 好好读题，虽然题确实很难，但是需要我去迈出第一步，就是把它读懂弄明白，再去构思动手敲代码
• 对于类的设计要再多多思考其合理性，并且将处理字符串的操作多增设一个类来处理
• 尽量用hashmap来处理数据类型以提高代码效率
• 使用正则表达式来处理输入
• 考虑单一职责和开闭原则，这样才可使自己的代码持续改进而不是每次都在女蜗补天
• 让自己的代码结构完整，搭好固定框架，依次迭代去改进

五.总结

1.对于本阶段的学习，理解了类与类间的关系，学到了ArrayList,hashmap,正则表达式的基本使用方法，学会了类与类间定义对象和调用方法，学会了去设计类与对象。

2.对于hashmap和正则表达式还需要进一步学习和研究，三次题集之后老师给出了设计思路和类图，我会根据这些重新设计类和对象，完善自己的结构。

3.这几次的训练让我理解了设计合理的重要性，我会再反复斟酌讲过的雨刷例子和这三道题，更深入理解如何去合理设计需求，同时也不违背设计的基本原则。

4.我希望作业时间可以稍微再长一点，因为虽然一周时间已经够长了，但是每个星期都基本满课，能静下来思考去写题和讨论的时间真的太少了，还有就是能在作业截止后给我们一些指导。

5.虽然这几道题我当时没做出来，但是我还是会尽力抽时间好好再去思考，争取把它做出来，改掉自己过度思考动手少的坏毛病，眼高手低，操作跟不上想法都是不切实际的。