1~3次pta作业心得

123lt / 2024-04-22 / 原文

第一次作业
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:
程序输入信息分三部分：

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:
单个题目。例如：

N:1 #Q:1+1= #A:2

A:2

end
输出样例1:
在这里给出相应的输出。例如：

1+1=~2
true
输入样例2:
单个题目。例如：

N:1 #Q:1+1= #A:2

A:4

end
输出样例2:
在这里给出相应的输出。例如：

1+1=~4
false
输入样例3:
多个题目。例如：

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:
多个题目。例如：

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:
多个题目，题号顺序与输入顺序不同。例如：

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:
含多余的空格符。例如：

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:
含多余的空格符。例如：

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;

class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
scanner.nextLine();
String[] input = new String[n + 1];
Question[] question = new Question[100];
for (int i = 0; i < n; i++) {
input[i] = scanner.nextLine();
String[] parts = input[i].split("#N:|#A:|#Q:");
for (int j = 0; j < parts.length; j++) {
parts[j] = parts[j].trim();
}
question[Integer.parseInt(parts[1])-1] = new Question(parts[1], parts[2], parts[3]);
}
String ans = scanner.nextLine();
String answer[] = ans.split("#A:");
for (int j = 0; j < answer.length; j++) {
answer[j] = answer[j].trim();
}
for (int i = 0; i < n; i++) {
System.out.printf("%s~%s\n", question[i].getContent(), answer[i+1]);
}
for (int i = 0; i < n; i++) {
if(answer[i+1].equals(question[i].getStandardAnswer())){
System.out.printf("true");
} else{
System.out.printf("false");
}
if(i!=n-1){
System.out.printf(" ");
}
}
}
}

class Question {
String num; // 题目编号
String content; // 题目内容
String standardAnswer; // 标准答案

public String getNum() {
    return num;
}

public void setNum(String num) {
    this.num = num;
}

public String getContent() {
    return content;
}

public void setContent(String content) {
    this.content = content;
}

public String getStandardAnswer() {
    return standardAnswer;
}

public void setStandardAnswer(String standardAnswer) {
    this.standardAnswer = standardAnswer;
}

public Question(String num, String content, String standardAnswer) {
    this.num = num;
    this.content = content;
    this.standardAnswer = standardAnswer;
}

}

在第一次作业中，学习了正则表达式的使用办法，利用正则表达式的分辨办法对输入内容中的分辨，分割字符串。体量适中，难度还好，后来重新写过都时候发现其实没有那么难，其实很简单。

首先是根据老师的提醒设置了三个类，用于存放题目答卷试卷。
然后在main类中操控正则表达式对输入的字符串进行分割分类。
第二个循环对其进行重新输出。

前几次提交都在关注格式问题，后来开始关注结构设计，设计三个类，实行单一职责。
第一次作业被困在了多余空格这一步。在第一次的作业中，对正则表达式的学习不够，只在input[i].split("#N:|#A:|#Q:");中增加判断情况，后来经过学习利用parts[j] = parts[j].trim();去除多余空格。

至于后续的改进，应该将正则表达式的分类分割单独成类，再将输入输出的判断再单独成类。

第二次作业
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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

import java.util.*;

class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Paper[] paper = new Paper[100];
for (int i = 0; i < paper.length; i++) {
paper[i] = new Paper();
}
Answer[] answerSheet = new Answer[100];
for (int i = 0; i < answerSheet.length; i++) {
answerSheet[i] = new Answer(paper[i]);
}
Student student=new Student();
String Q="";//用来记住所有题目；
int paperCount=0;
int answerCount=0;
int questionCount=0;

    while (true) {
        String input = scanner.nextLine();
        if (input.contains("#N:")) {
            String[] parts2 = Q.split("#N:|#Q:|#A:");
            for (int i = 0; i < parts2.length; i++) {
                parts2[i] = parts2[i].trim();
            }
            Q = Q + input;
            questionCount++;
        } else if (input.contains("#T:")) {
            String[] parts1 = input.split("#T:|-|\\s");
            for (int i = 0; i < parts1.length; i++) {
                parts1[i] = parts1[i].trim();
            }
            paper[paperCount].setPoint(parts1);
            String[] parts2 = Q.split("#N:|#Q:|#A:");
            for (int i = 0; i < parts2.length; i++) {
                parts2[i] = parts2[i].trim();
            }
            for(int i=1;i<questionCount*3+1;i=i+3){
                paper[paperCount].setQuestion(Integer.parseInt(parts2[i]),new Question(parts2[i], parts2[i+1], parts2[i+2]));
            }
            paperCount++;
        } else if (input.contains("#S:")) {
            String[] parts = input.split("#S:| #A:|\\s|-");
            for (int i = 0; i < parts.length; i++) {
                parts[i] = parts[i].trim();
            }
            if(Integer.parseInt(parts[1])>paperCount){
                answerSheet[answerCount].T=false;
            }
            else {
                answerSheet[answerCount]=new Answer(paper[Integer.parseInt(parts[1])]);
                answerSheet[answerCount].answers.addAll(Arrays.asList(parts));
                answerSheet[answerCount].T=true;
                for (int j = 0, p = 2; j < paper[Integer.parseInt(parts[1])-1].questionCount; j++, p = p + 2) {
                    if (answerSheet[answerCount].answers.size() <= j + 2) {
                        answerSheet[answerCount].Q[j] = false;
                    } else {
                        answerSheet[answerCount].Q[j] = true;
                        answerSheet[answerCount].judgeResults.add(paper[Integer.parseInt(parts[1]) - 1].judge(paper[Integer.parseInt(parts[1]) - 1].point[p], answerSheet[answerCount].answers.get(j + 2)));
                    }
                }
            }
            answerCount++;
        }else if (input.contains("#X:")) {
            String[] parts = input.split("#X:|\\s");
            for (int i = 1; i < parts.length; i++) {
                if(i%2==1) {
                    student.setNumber(parts[i]);
                }else{
                    student.setName(parts[i]);
                }
            }
        }else if (input.equals("end")) {
            break;
        }
    }
    for (int i = 0; i < paperCount; i++) {
        int sum = 0;
        for (int j = 3; j < paper[i].point.length; j=j+2) {
            sum += paper[i].point[j];
        }
        if(sum<100){
            System.out.printf("alert: full score of test paper%d is not 100 points\n",i+1);
        }
    }

    for (int j = 0; j < answerCount; j++) {
        if(answerSheet[j].T){
            int[] score = new int[paper[Integer.parseInt(answerSheet[j].answers.get(1))-1].questionCount];
            int num = 3;
            int sum = 0;

            for (int i = 0; i < paper[Integer.parseInt(answerSheet[j].answers.get(1))-1].questionCount; i++) {
                if(answerSheet[j].Q[i]) {
                    System.out.printf("%s~%s", paper[Integer.parseInt(answerSheet[j].answers.get(1)) - 1].getQuestion(paper[Integer.parseInt(answerSheet[j].answers.get(1)) - 1].point[num - 1]).getContent(), answerSheet[j].getAnswer(i + 2));
                    if (answerSheet[j].judgeResults.get(i)){
                        System.out.print("~true\n");
                        score[i] = paper[Integer.parseInt(answerSheet[j].answers.get(1)) - 1].getPoint(num);
                    } else {
                        System.out.print("~false\n");
                        score[i] = 0;
                    }
                }else{
                    System.out.print("answer is null\n");
                    score[i] = 0;
                }
                num = num + 2;
                sum = sum + score[i];
            }
            for(int i=0;i<student.getNumber().length;i++) {
                if (answerSheet[j].answers.get(2).equals(student.getNumber(i))) {
                    System.out.printf("%s %s:",student.getNumber(i), student.getName(i));
                    break;
                }
            }
            for (int i = 0; i < paper[Integer.parseInt(answerSheet[j].answers.get(1))-1].questionCount; i++) {
                if (i != paper[Integer.parseInt(answerSheet[j].answers.get(1))-1].questionCount - 1) {
                    System.out.printf("%d ", score[i]);
                } else {
                    System.out.printf("%d~%d\n", score[i], sum);
                }
            }
        }
        else {
            System.out.print("The test paper number does not exist\n");
        }
    }
}

}

class Question {
private String num; // 题号
private String content; // 题目内容
private String standardAnswer; // 标准答案

public Question(String num, String content, String standardAnswer) {
    this.num = num;
    this.content = content;
    this.standardAnswer = standardAnswer;
}

public String getNum() {
    return num;
}

public String getContent() {
    return content;
}

public String getStandardAnswer() {
    return standardAnswer;
}

public boolean Judge(String answer) {
    return answer.equals(getStandardAnswer());
}

}

class Paper {
private List questions;
int[] point;
public int questionCount=0;

public Paper() {
    questions = new ArrayList<>();
    point = new int[100];
    questionCount = 0;
}

public void setQuestion(int i,Question question) {
    if (i >= questions.size()) {
        for (int j = questions.size(); j <= i; j++) {
            questions.add(null);
        }
    }
    questions.set(i,question);
    questionCount++;
}

public Question getQuestion(int index) {
    return questions.get(index);
}

public void setPoint(String[] nums) {
    for (int i = 1; i < nums.length; i++) {
        point[i] = Integer.parseInt(nums[i]);
    }
}

public int getPoint(int num) {
    return point[num];
}

public boolean judge(int questionNumber, String answer) {
    Question question = questions.get(questionNumber);
    return question.Judge(answer);
}

}

class Answer {
public Paper examinationPaper;
public List answers;
public List judgeResults;
public Boolean T=true;
public Boolean[] Q=new Boolean[100];

public Answer(Paper examinationPaper) {
    this.examinationPaper = examinationPaper;
    answers = new ArrayList<>();
    judgeResults = new ArrayList<>();
}

public void saveAnswer(int questionNumber, String answer) {
    answers.add(answer);
    judgeResults.add(examinationPaper.judge(questionNumber, answer));
}

public String getAnswer(int questionNumber) {
    return answers.get(questionNumber);
}

public boolean judge(int questionNumber) {
    return judgeResults.get(questionNumber);
}

}

class Student{
private String[] name;
private String[] number;
private int nameCount;
private int numberCount;

public Student() {
    name=new String[100];
    number=new String[100];
    nameCount=0;
    numberCount=0;
}

public String getName(int i) {
    return name[i];
}

public void setName(String name) {
    this.name[nameCount] = name;
    nameCount++;
}

public String[] getNumber() {
    return number;
}

public String getNumber(int i) {
    return number[i];
}

public void setNumber(String number) {
    this.number[numberCount] = number;
    numberCount++;
}

}

class delete{
private String[] num;

public delete(){
    num=new String[100];
}

public String[] getNum() {
    return num;
}

public void setNum(String[] num) {
    this.num = num;
}

}

第二次作业中，依旧保持三个类，题目的难度开始增加，增加分数。

开始使用数组对不同答卷和试卷进行一一对应。
在题目输入的时候用一个字符串数组记录全部题目用于保证不同试卷对不同题目的要求。
在题目乱序的时候，一开始用输入顺序当作题目顺序从而导致错误。后来更改，用输入的题号当作顺序。并对程序进行了修改。
在空题的时候新增了一个判断用于是否存在该题。

在第一次写针对不同答卷不同试卷的时候，我并不能做到题目不同。对于list的使用方法不太熟练，后来改用类数组得到了实现，目前也没有得到满分，实在惭愧。后续可以在判断方法上做出改进。实在太多了，每一个判断后面的长度都太长了，耦合性太强了，之后会改进类间关系。

第三次作业
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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

第三次作业到目前为止还没有满分。
代码越堆越密，结构差不多崩了，目前正在改进。在面对各种情况的补充时发现自己的代码逻辑依旧挤不下了，如果继续堆叠应该也成不了了。
第三次作业被困在了答案输出没有先后顺序上。
在删除题目和增加学号上多增加了两个类，学生类和删除类用于存放数据和匹配答题人。对于前几个测试点都是增加了判断情况进行叠加，并没有什么设计，接下来的设计和改进方向会关注在类间关系设计和对mian类的轻减，让mian类成为只用输入和输出的类。

经过这三次作业，让我对于类间关系的设计，和单一职责等设计理念有了更进一步理解。不过对于继承还是不是很理解，下一次的作业对于我来说估计会更加艰难。还有对于基本语法和编码工具的使用更加熟练。