java答题程序的问题

Question

import java.util.*;
import java.util.regex.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;

class Question {
    private String content;
    private String answer;

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

    public String getContent() {
        return content;
    }

    public String getAnswer() {
        return answer;
    }
}

class TestPaper {
    private int paperNumber;
    private Map<Integer, Question> questions = new HashMap<>();
    private Map<Integer, Integer> questionScores = new HashMap<>();

    public TestPaper(int paperNumber) {
        this.paperNumber = paperNumber;
    }

    public void addQuestion(int number, String content, String answer, int score) {
        questions.put(number, new Question(content, answer));
        questionScores.put(number, score);
    }

    public int getPaperNumber() {
        return paperNumber;
    }

    public Map<Integer, Question> getQuestions() {
        return questions;
    }

    public Map<Integer, Integer> getQuestionScores() {
        return questionScores;
    }
}
class Student {
    private String id;
    private String name;
    // 其他字段和方法
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
    // getter 和 setter 方法
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}


class AnswerSheet {
    private TestPaper testPaper;
    private String[] answers;
    private boolean[] judgments;
    
    public AnswerSheet(TestPaper testPaper) {
        this.testPaper = testPaper;
        this.answers = new String[testPaper.getQuestionScores().size()];
        this.judgments = new boolean[testPaper.getQuestionScores().size()];
    }
    
    public void addAnswer(String answer, int index) {
        answers[index] = answer;
    }
    
    public void judgeAnswers() {
        for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
            String correctAnswer = testPaper.getQuestions().get(i + 1).getAnswer();
            judgments[i] = answers[i] != null && answers[i].equals(correctAnswer);
        }
    }
    public void outputResults(String studentId, String studentName) {
    int totalScore = 0;
    for (int score : testPaper.getQuestionScores().values()) {
    totalScore += score;
    }
    if (totalScore != 100) {
    System.out.println("alert: full score of test paper" + testPaper.getPaperNumber() + " is not 100 points");
    }
    
    for (int i = 0; i < answers.length; i++) {
    Question question= testPaper.getQuestions().get(i + 1);
    if (question != null) {
    String content = question.getContent(); // 获取题目内容
    String answer = (answers[i] != null ? answers[i] : "answer is null");
    String judgment = String.valueOf(judgments[i]);
    String result = content + "~" + answer + "~" + judgment;
    System.out.println(result); // 输出题目内容、学生答案、判断结果
    } else {
    System.out.println("the question " + (i + 1) + " invalid ~ 0");
    }
    }
    
    int totalStudentScore = 0;
    for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
        if (judgments[i]) {
            totalStudentScore += testPaper.getQuestionScores().get(i + 1);
        }
    }
    
    // 输出学生的得分情况
    System.out.println(studentId + " " + studentName + ": " + formatStudentScore() + "~" + totalStudentScore);
    }
    
    private String formatStudentScore() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
            sb.append(judgments[i] ? testPaper.getQuestionScores().get(i + 1) : "0").append(" ");
        }
        return sb.toString().trim();
    }
}

    
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
TestPaper testPaper = null;
Map<String, Student> studentMap = new HashMap<>();
String studentId = "";
String studentName = "";

    while (true) {
        String line = scanner.nextLine();
        if (line.equals("end")) {
            break;
        }

        Matcher matcher;
        if ((matcher = Pattern.compile("#N:(\\d+) #Q:(.*?) #A:(\\d+)").matcher(line)).matches()) {
            // Parse #N: section
            int number = Integer.parseInt(matcher.group(1));
            String questionContent = matcher.group(2); // 获取题目内容
            String answer = matcher.group(3);
            testPaper = new TestPaper(number);
            testPaper.addQuestion(number, questionContent, answer, 5); // 将题目内容添加到试卷中
        } else if ((matcher = Pattern.compile("#T:(\\d+) (\\d+-\\d+)").matcher(line)).matches()) {
            // Parse #T: section
            int paperNumber = Integer.parseInt(matcher.group(1));
            String[] parts = matcher.group(2).split("-");
            int questionNumber = Integer.parseInt(parts[0]);
            int score = Integer.parseInt(parts[1]);
            testPaper.addQuestion(questionNumber, "", "", score);
        } else if ((matcher = Pattern.compile("#X:(\\d+) (.+)").matcher(line)).matches()) {
            // Parse #X: section
            studentId = matcher.group(1);
            studentName = matcher.group(2);
        } else if ((matcher = Pattern.compile("#S:(\\d+) (\\d+) #A:(\\d+-\\d+)").matcher(line)).matches()) {
            // Parse #S: section
            if (testPaper != null) {
                AnswerSheet answerSheet = new AnswerSheet(testPaper);
                String[] parts = matcher.group(3).split("-");
                int questionNumber = Integer.parseInt(parts[0]);
                String answer = parts[1];
                answerSheet.addAnswer(answer, questionNumber - 1);
                answerSheet.judgeAnswers();
                answerSheet.outputResults(studentId, studentName);
            } else {
                System.out.println("Test paper not initialized!");
            }
        }
    }
}
}
输入格式:

程序输入信息分五种，信息可能会打乱顺序混合输入。

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
为什么上面代码测试样例一的时候没有输出内容，其他样例全为空

Answer 1

代码修改如下：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;


class Question {
    private int id;  //题目编号
    private String content;
    private String answer;
    private boolean live; //是否有效（如果被删除，则无效）

    public Question(int id ,String content, String answer) {
        this.id = id;
        this.content = content;
        this.answer = answer;
        this.live = true; 
    }

    public int getId(){
        return id;
    }

    public String getContent() {
        return content;
    }

    public String getAnswer() {
        return answer;
    }

    public boolean isLive(){
        return live;
    }
    
    public void setValid(boolean f){
        this.live = f;
    }
}


//定义题目管理类，保存所有题目
class QuestionMgr {
    private ArrayList<Question> questions = new ArrayList<>(); //保存所有题目

    public void addQuestion(int id, String content,String answer){
        questions.add(new Question(id,content,answer));
    }

    //判断题目是否存在
    public boolean isExist(int id){
        for(int i=0;i<questions.size();i++){
            if(questions.get(i).getId() == id)
                return true;
        }
        return false;
    }
    
    // 设置题目失效
    public void setInvalid(int id){
        for(int i=0;i<questions.size();i++){
            if(questions.get(i).getId() == id)
                questions.get(i).setValid(false);
        }
    }

    //判断题目是否有效
    public boolean isValid(int id){
        for(int i=0;i<questions.size();i++){
            if(questions.get(i).getId() == id)
                return questions.get(i).isLive();
        }
        return false;
    }

    //根据题目编号获取题目正确答案
    public String getCorrectAnswer(int id){
        for(int i=0;i<questions.size();i++){
            if(questions.get(i).getId() == id)
                return questions.get(i).getAnswer();
        }
        return null; //没有题目id返回空
    }
    
    //根据题目编号获取题目内容
    public String getContentById(int id){
        for(int i=0;i<questions.size();i++){
            if(questions.get(i).getId() == id)
                return questions.get(i).getContent();
        }
        return null; //没有题目id返回空
    }
    
}

//保存试卷的所有实体和分值
class TestPaper {
    private int paperNumber; //试卷编号
    private int questionnumber; //试卷中题目的数量
    private ArrayList<Integer> paperQuestions = new ArrayList<>(); //本试卷的题目
    private ArrayList<Integer> paperScore = new ArrayList<>();     //本试卷的题目对应的分值

    public TestPaper(int paperNumber) {
        this.paperNumber = paperNumber;
        questionnumber = 0;
    }

    //获取试卷题目数量
    public int getQuestionNumber(){
        return questionnumber;
    }

    //添加一个函数，用来增加试卷题目
    public void addPaperQuestion(int number,int score){
        paperQuestions.add(number);
        paperScore.add(score);
        questionnumber++;
    }

    //获取试卷编号
    public int getPaperNumber() {
        return paperNumber;
    }


    // 获取试卷第n题的编号
    public int getQuestionIdByIndex(int index){
        return paperQuestions.get(index);
    }
    // 获取试卷第n题的分值
    public int getScoreByIndex(int index){
        return paperScore.get(index);
    }

    // 判断试卷是否够100分
    public boolean isFulll(){
        int sum = 0;
        for(int i=0;i<paperScore.size();i++)
            sum += paperScore.get(i);
        if(sum == 100)
            return true;
        else
            return false;
    }

    public ArrayList<Integer> getQuestions() {
        return paperQuestions;
    }

    public ArrayList<Integer> getQuestionScores() {
        return paperScore;
    }
}

// 试卷管理类
class TestPaperMgr{
    private ArrayList<TestPaper> paperMgr = new ArrayList<>(); //本试卷的题目

    //更新试卷
    public void updatePaper(TestPaper paper){
        for(int i=0;i<paperMgr.size();i++){
            if(paperMgr.get(i).getPaperNumber() == paper.getPaperNumber()){
                paperMgr.remove(i);
                break;
            }
        }
        paperMgr.add(paper);
    }

    //根据试卷编号获取对应的试卷
    public TestPaper getPaper(int id){
        for(int i=0;i<paperMgr.size();i++){
            if(paperMgr.get(i).getPaperNumber() == id)
                return paperMgr.get(i);
        }
        return null;
    }
}



// 学生类
class Student {
    private String id;
    private String name;
    // 其他字段和方法
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
    // getter 和 setter 方法
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

// 学生管理类
class StudentMgr{
    ArrayList<Student> allStudents = new ArrayList<>();

    //根据学号获取学生姓名
    public String getStudentNameById(String id){
        for(int i=0;i<allStudents.size();i++){
            if(allStudents.get(i).getId().equals(id))
                return allStudents.get(i).getName();
        }
        return null;
    }

    //添加学生信息
    public void addStudents(ArrayList<Student> stus){
        for(int i=0;i<stus.size();i++)
            allStudents.add(stus.get(i));
    }
}



class AnswerSheet {
    private TestPaper testPaper;                                  //试卷（因为题目限制只有1张试卷，所以，这里直接使用TestPaper实例，没有添加管理类
    private QuestionMgr questionMgr;                              //管理所有试题
    private ArrayList<Integer> questionsOder = new ArrayList<>(); //这里保存所有答题的序号（序号是试题在试卷中的位置，不是题目编号）
    private ArrayList<String> answers = new ArrayList<>();        //题目对应的答案


    public AnswerSheet(TestPaper testPaper,QuestionMgr mgr) {
        this.testPaper = testPaper;
        this.questionMgr = mgr;
    }

    //添加回答
    public void addAnswer(int index,String ans){
        questionsOder.add(index);
        answers.add(ans);
    }

    
    //输出结果
    public void outputResults(String studentId, String studentName) {
        // 判断是否够100分
        if (!testPaper.isFulll()) {
            System.out.println("alert: full score of test paper" + testPaper.getPaperNumber() + " is not 100 points");
        }

        int sumScore = 0; //总得分
        int cnt = 0; //答题的数量
        String strScore = ""; //判分信息
        
        if(studentName == null)
            strScore = studentId + " not found";
        else
            strScore = studentId+" "+ studentName+":";
        
        ArrayList<String> logs = new ArrayList<>();
        int ok = 0,err=0;
        //遍历所有的回答
        for(int i=0;i<questionsOder.size();i++){
            //1.试卷题目序号
            int index = questionsOder.get(i); 
            //2.回答
            String ans = answers.get(i); 
        
            //3.判断序号是否超出试卷题目个数
            
            if(index > testPaper.getQuestionNumber())
                continue;
            
            cnt++; //答题数量+1
            
            //4.根据试题序号获取题目编号
            int questionId = testPaper.getQuestionIdByIndex(index-1);
            //5.根据试题序号获取题目分值
            int questionScore = testPaper.getScoreByIndex(index-1);

            //6.判断题目编号对应的题目是否存在
            if(!questionMgr.isExist(questionId)){
                System.out.println("non-existent question~0");
            }else{
                //7.判断题目是否已经失效
                if(!questionMgr.isValid(questionId)){
                    String ls = "the question "+ String.valueOf(index) +" invalid~0";
                    logs.add(ls);
                    //System.out.println("the question "+ index +" invalid~0");
                }else{
                    //8.根据题目编号获取正确答案
                    String right = questionMgr.getCorrectAnswer(questionId);
                    //9.判断答案是否正确
                    if(right.equals(ans)){
                        //回答正确
                        System.out.println(questionMgr.getContentById(questionId)+"~"+ans+"~true");
                        strScore = strScore +" " + String.valueOf(questionScore);
                        sumScore += questionScore;
                        ok++;
                    }else{
                        //回答错误
                        System.out.println(questionMgr.getContentById(questionId)+"~"+ans+"~false");
                        strScore = strScore +" 0";
                        err++;
                    }
                    
                }
            }//else end


        }//for end
        
        for(int i=0;i<logs.size();i++){
            strScore = strScore +" 0";
            err++;
            System.out.println(logs.get(i));
        }
        for(int i = (ok+err);i<testPaper.getQuestionNumber();i++)
            strScore = strScore +" 0";
        
        //10.判断试卷是否全部回答
        if(cnt < testPaper.getQuestionNumber())
            System.out.println("answer is null");
        
        //11.输出总分
        if(studentName == null)
            System.out.println(strScore);
        else{
            strScore = strScore + "~"+String.valueOf(sumScore);
            System.out.println(strScore);
        }
            
        
    }


}


public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        TestPaperMgr paperMgr = new TestPaperMgr();  //管理所有试卷
        QuestionMgr questionMgr = new QuestionMgr(); //管理所有试题
        StudentMgr stuMgr = new StudentMgr();        //管理所有学生信息

        String studentId="";
        String studentName = "";
        TestPaper currentpaper = null;
        AnswerSheet answerSheet = null;

        //读取数据开始处理
        while (true) {
            String line = scanner.nextLine();
            //System.out.println(line);
            if (line.equals("end")) {
                break;
            }

            Matcher matcher;
            if ((matcher = Pattern.compile("#N:(\\d+) #Q:(.*?) #A:(\\d+)").matcher(line)).matches()) {
                // Parse #N: section
                int number = Integer.parseInt(matcher.group(1));
                String questionContent = matcher.group(2); // 获取题目内容
                String answer = matcher.group(3);

                questionMgr.addQuestion(number, questionContent, answer); // 将题目内容添加到试卷中 
            } else if ((matcher = Pattern.compile("#T:(\\d+) (.+)").matcher(line)).matches()) {
                // Parse #T: section
                //#T:(\\d+) (\\d+-\\d+)
                int paperNumber = Integer.parseInt(matcher.group(1));
                //System.out.println("p1: " + matcher.group(1));
                //System.out.println("p2: " + matcher.group(2));

                //获取试卷
                TestPaper paper = paperMgr.getPaper(paperNumber);
                if(paper == null){
                    paper = new TestPaper(paperNumber);
                }
                //System.out.println("---------------");
                //将试题加入试卷
                String[] parts = matcher.group(2).split(" ");
                for(int i=0;i<parts.length;i++){
                    String[] pt = parts[i].split("-");
                    int questionNumber = Integer.parseInt(pt[0]);
                    int score = Integer.parseInt(pt[1]);
                    //System.out.println("  >> "+ questionNumber +"   " + score);
                    paper.addPaperQuestion(questionNumber, score);
                }
                paperMgr.updatePaper(paper);
                //System.out.println( "paper.getQuestionNumber() ="+paper.getQuestionNumber());

            } else if ((matcher = Pattern.compile("#X:(\\d+) (.+)").matcher(line)).matches()) {
                // Parse #X: section
                // 因为这一行可以有多个学生，所以不能直接使用matcher.group(),需要通过-和空格进行分割
                int index = line.indexOf(":");
                line = line.substring(index+1);
                //使用-分隔
                String[] parts = line.split("-");
                //使用空格分隔
                ArrayList<Student> stus = new ArrayList<>();
                for(int i=0;i<parts.length;i++){
                    String[] stu = parts[i].split(" ");
                    if(stu.length==2){
                        stus.add(new Student(stu[0],stu[1]));
                    }
                }
                stuMgr.addStudents(stus);
            } else if ((matcher = Pattern.compile("#S:(\\d+) (\\d+) (.+)").matcher(line)).matches()) {
                //"#S:(\\d+) (\\d+) #A:(\\d+-\\d+)"
                // Parse #S: section
                /*System.out.println("p0:  "+matcher.group(0));
                System.out.println("p1:  "+matcher.group(1));
                System.out.println("p2:  "+matcher.group(2));
                System.out.println("p3:  "+matcher.group(3));
                 */
                
                int paperNmb = Integer.parseInt(matcher.group(1)); //获取试卷编号
            
                currentpaper = paperMgr.getPaper(paperNmb);  //根据试卷编号找到试卷
                if(currentpaper != null){
                    //获取学生信息
                    studentId = matcher.group(2);
                    studentName = stuMgr.getStudentNameById(studentId);
                    //拆分答案部分
                    String[] ques =  matcher.group(3).split(" ");

                    //创建答卷
                    answerSheet = new AnswerSheet(currentpaper,questionMgr);

                    for(int i=0;i<ques.length;i++){
                        String ans = ques[i].substring(ques[i].indexOf(":")+1);
                        String[] pts = ans.split("-");
                        if (pts.length == 2){
                            //System.out.println(" >> "+pts[0]);
                            //System.out.println(" >> "+pts[1]);
                            int questionNumber = Integer.parseInt(pts[0]);
                            String answer = pts[1];
                            answerSheet.addAnswer(questionNumber,answer);
                        }
                    }
                    
                }
            }else if(line.startsWith("#D:N-")){
                int index = line.indexOf("-");
                if(index < line.length()){
                    int id = Integer.parseInt(line.substring(index+1));
                    //System.out.println("Delete "+id);
                    questionMgr.setInvalid(id);
                }
            } else {
                //格式错误
                System.out.println("wrong format:"+line);
            }
        }
        //读取结束，输出结果
        if(currentpaper == null){
            System.out.println("The test paper number does not exist");
        }else {
            //判断并输出结果
            answerSheet.outputResults(studentId, studentName);
        }

    }
}