第一次博客作业

一、前言

总结三次题目集的知识点、题量、难度等情况

java的面向对象编程和c++有一定的区别，因此在最开始接触此类题目的时候不太适应，不过任何东西上手都要有一个过程，阶段性的总结可以学到更多的东西。

知识点

除了java基本语法的运用，大部分题目用到的还是一些基础的计算和逻辑判断，简单的题目无非就是为了熟悉java编程的一套方法和规则，像严格的类型匹配之类的。

在这几次pta里面练习了无参和有参的变量构造方法。

像综合运用的大题目，涉及到的知识点比较多，更多考量的是类之间的互相调用。

题量和难度

三次题目集的题量很大也很有难度，题目集一都是很基础的计算判断和逻辑题，最后一题是难度较高的综合类题目，题目集二和三中的综合类题目难度就很大了，很有挑战。

二、设计与分析

重点对题目的提交源码进行分析，可参考SourceMonitor的生成报表内容以及PowerDesigner的相应类图，要有相应的解释和心得

题目集一

这是接触java开始做的第一次作业，虽然题目难度对于初学者来说也很高，因为不熟练，代码非常的生硬和简朴

7-5 答题判题程序-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

答题判断程序是本套题目的重点和难点，需要重点分析。

因为本题题目已经将类分好给我们，只需要完善相应代码就好，大大降低了难度。先上代码的分析图。

从分析中就可以看出代码十分的复杂，拥有很多的循环和选择语句，不仅运行负载高，还非常容易出错。题目的难点在于输入的判断和各种复杂的计算。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

class Question {
    private int num;
    private String question;
    private String standardAnswer;

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

    public boolean judgeAnswer(String answer) {
        return answer.trim().equalsIgnoreCase(standardAnswer.trim());
    }

    public int getNum() {
        return num;
    }

    public String getQuestion() {
        return question;
    }

    public String getStandardAnswer() {
        return standardAnswer;
    }
}

class ExamPaper {
    private Map<Integer, Question> questionMap;

    public ExamPaper() {
        questionMap = new HashMap<>();
    }

    public void saveQuestion(int num, String question, String standardAnswer) {
        questionMap.put(num, new Question(num, question, standardAnswer));
    }

    public Question getQuestion(int num) {
        return questionMap.get(num);
    }
}

class AnswerSheet {
    private ExamPaper examPaper;
    private List<String> answers;
    private List<Boolean> judgingResults;

    public AnswerSheet(ExamPaper examPaper) {
        this.examPaper = examPaper;
        answers = new ArrayList<>();
        judgingResults = new ArrayList<>();
    }

    public void judgeAnswers() {
        for (int i = 0; i < answers.size(); i++) {
            Question question = examPaper.getQuestion(i + 1);
            boolean result = question.judgeAnswer(answers.get(i));
            judgingResults.add(result);
        }
    }

    public String output() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < answers.size(); i++) {
            Question question = examPaper.getQuestion(i + 1);
            sb.append(question.getQuestion()).append("~").append(answers.get(i)).append("\n");
        }
        return sb.toString();
    }

    public String judgeResultsOutput() {
        StringBuilder sb = new StringBuilder();
        for (boolean result : judgingResults) {
            sb.append(result).append(" ");
        }
        // 删除最后一个结果后面的空格
        sb.deleteCharAt(sb.length() - 1);
        return sb.toString();
    }

    public void saveAnswer(String answer) {
        answers.add(answer);
    }

    public List<Boolean> getJudgingResults() {
        return judgingResults;
    }

    public List<String> getAnswers() {
        return answers;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numQuestions = Integer.parseInt(scanner.nextLine().trim());

        ExamPaper examPaper = new ExamPaper();

        for (int i = 0; i < numQuestions; i++) {
            String line = scanner.nextLine().trim();
            String[] parts = line.split("#N:| #Q:| #A:");
            int num = Integer.parseInt(parts[1].trim());
            String question = parts[2].trim();
            String standardAnswer = parts[3].trim();
            examPaper.saveQuestion(num, question, standardAnswer);
        }

        AnswerSheet answerSheet = new AnswerSheet(examPaper);

        while (true) {
            String line = scanner.nextLine().trim();
            if (line.equals("end")) {
                break;
            }
            String[] answers = line.split("#A:");
            for (String answer : answers) {
                if (!answer.trim().isEmpty()) {
                    answerSheet.saveAnswer(answer.trim());
                }
            }
        }

        answerSheet.judgeAnswers();
        System.out.print(answerSheet.output());
        System.out.print(answerSheet.judgeResultsOutput());
    }
}

题目集二

这是第二次作业，题目难度对于一来说高了一些，前面的三道题较为简单，最后的答题判题程序-2修改了试卷类的内容。

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=~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，建议增加答题类，类的内容以及类之间的关联自行设计。

类图分析如下：

代码如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

import java.util.*;
//学生信息类

//题目信息类
class Question {
 String number;
 String content;
 String answer;

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

public String getNumber() {
    return number;
}

public void setNumber(String number) {
    this.number = number;
}

public String getContent() {
    return content;
}

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

public String getAnswer() {
    return answer;
}

public void setAnswer(String answer) {
    this.answer = answer;
}
 
}

//试卷信息类
class TestPaper {
 String number;
 Map<String, Integer> questions = new LinkedHashMap();
 List<Question> question = new ArrayList<>();

 public List<Question> getQuestion() {
    return question;
}

public void setQuestion(List<Question> question) {
    this.question = question;
}

public TestPaper(String number) {
     this.number = number;
 }

 public void addQuestion(String questionNumber, int score) {
     questions.put(questionNumber, score);
 }

public String getNumber() {
    return number;
}

public void setNumber(String number) {
    this.number = number;
}

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

public void setQuestions(Map<String, Integer> questions) {
    this.questions = questions;
}
 
}

//答卷信息类
class AnswerSheet {
 String testPaperNumber;
 List<String> answers = new ArrayList<>();

 public AnswerSheet(String testPaperNumber) {
     this.testPaperNumber = testPaperNumber;
 }

 public void addAnswer(String answer) {
     answers.add(answer);
 }
}

public class Main {
 public static void main(String[] args) {
     Scanner scanner = new Scanner(System.in);

     List<Question> questions = new ArrayList<>();
     List<TestPaper> testPapers = new ArrayList<>();
     List<AnswerSheet> answerSheets = new ArrayList<>();
    
     while (scanner.hasNextLine()) {
         String line = scanner.nextLine().trim();

         if (line.equals("end")) {
             break;
         }

         if (line.startsWith("#N:")) {
             
             String[] parts = line.split(" ");
             String number = parts[0].substring(3);
             String content = parts[1].substring(3);
             String answer = parts[2].substring(3);
             questions.add(new Question(number, content, answer));
            
         } else if (line.startsWith("#T:")) {
             String[] parts = line.split(" ");
             String testPaperNumber = parts[0].substring(3);
             TestPaper testPaper = new TestPaper(testPaperNumber);
             for (int i = 1; i < parts.length; i++) {
                 String[] subParts = parts[i].split("-");
                 testPaper.addQuestion(subParts[0], Integer.parseInt(subParts[1]));
             }
             testPapers.add(testPaper);
         }
         else if (line.startsWith("#S:")) {
             String[] parts = line.split(" ");
             String testPaperNumber = parts[0].substring(3);
             AnswerSheet answerSheet = new AnswerSheet(testPaperNumber);
             for (int i = 1; i < parts.length; i++) {
                 answerSheet.addAnswer(parts[i].substring(3));
             }
             answerSheets.add(answerSheet);
         }
         
     }
    
     // 处理试卷总分不等于100的情况
     for (int i = 0; i < testPapers.size(); i++) {
         int totalScore = 0;
         for (Integer value: testPapers.get(i).questions.values()) {
             totalScore += value;
         }
         if (totalScore != 100) {
             System.out.println("alert: full score of test paper" + testPapers.get(i).getNumber() + " is not 100 points");
         }
     }
     // 输出答卷信息
     for (AnswerSheet answerSheet : answerSheets) {
         TestPaper testPaper = null;
         for (TestPaper paper : testPapers) {
             if (paper.number.equals(answerSheet.testPaperNumber)) {
                 testPaper = paper;
                 break;
             }
         }
         if (testPaper == null) {
             System.out.println("The test paper number does not exist");
             continue;
         }
         Iterator<String> answerIterator = answerSheet.answers.iterator();
         for (String questionNumber : testPaper.questions.keySet()) {
             String answer = answerIterator.hasNext() ? answerIterator.next() : "answer is null";
             boolean isCorrect = answer.equals(questions.stream()
                     .filter(q -> q.number.equals(questionNumber))
                     .findFirst()
                     .orElseThrow(() -> new IllegalArgumentException("Question not found"))
                     .answer);
             System.out.println(questions.stream()
                     .filter(q -> q.number.equals(questionNumber))
                     .findFirst()
                     .orElseThrow(() -> new IllegalArgumentException("Question not found"))
                     .content + "~" + answer + "~" + isCorrect);
         }

         int totalScore = 0;
         Iterator<String> answerIterator2 = answerSheet.answers.iterator();
         StringBuilder scoreInfo = new StringBuilder(); // 用于存储判分信息
         for (String questionNumber : testPaper.questions.keySet()) {
             String answer = answerIterator2.hasNext() ? answerIterator2.next() : "answer is null";
             int score = 0;
             boolean isCorrect;
            if(answer.equals("answer is null")) {
                 score = 0;
             }
             else

             score = answer.equals(questions.stream().filter(q -> q.number.equals(questionNumber)).findFirst().orElseThrow(() -> new IllegalArgumentException("Question not found")).answer) ? testPaper.questions.get(questionNumber) : 0;
             scoreInfo.append(score).append(" "); // 将每道题的得分添加到scoreInfo中
             totalScore += score;
         }
         scoreInfo.deleteCharAt(scoreInfo.length() - 1); // 删除最后一个空格
         System.out.println(scoreInfo + "~" + totalScore); // 输出判分信息和总分
             }
         }

       
        
     }

这个代码是修改过的，在pta2中没有得到很高的分，很多案例没有通过，修改完之后虽然通过了给出的案例，但是分数还是没有完全满，有一些案例可能还是没有考虑到，还会继续再修改。

题目集三

第三次作业，题目难度高了很多，最后的答题判题程序-3不仅要修改之前的类，还要增加一个新的学生类，增加了很多的代码。

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=~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。

本题暂不考虑出现多张答卷的信息的情况。

类图分析如下：

第三次pta的答题判断程序难度就高了很多，在原有的基础上还增加了学生类，通过分各种类型的案例输入输出去调整代码，但是空白输入时候的案例也正常输出这里出现了一些问题，其他案例都能通过，在空白输入时也可以做到正常输出空白，但是案例没有通过。

以下是代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

import java.util.*;
//学生信息类
class Student{
    String student_id;
    String name;
     public Student(String student_id, String name) {
         this.student_id = student_id;
         this.name = name;
     }
    public String getStudent_id() {
        return student_id;
    }
    public void setStudent_id(String student_id) {
        this.student_id = student_id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}
//题目信息类
class Question {
 String number;
 String content;
 String answer;

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

public String getNumber() {
    return number;
}

public void setNumber(String number) {
    this.number = number;
}

public String getContent() {
    return content;
}

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

public String getAnswer() {
    return answer;
}

public void setAnswer(String answer) {
    this.answer = answer;
}
 
}

//试卷信息类
class TestPaper {
 String number;
 Map<String, Integer> questions = new LinkedHashMap();
 List<Question> question = new ArrayList<>();

 public List<Question> getQuestion() {
    return question;
}

public void setQuestion(List<Question> question) {
    this.question = question;
}

public TestPaper(String number) {
     this.number = number;
 }

 public void addQuestion(String questionNumber, int score) {
     questions.put(questionNumber, score);
 }

public String getNumber() {
    return number;
}

public void setNumber(String number) {
    this.number = number;
}

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

public void setQuestions(Map<String, Integer> questions) {
    this.questions = questions;
}
 
}

//答卷信息类
class AnswerSheet {
 String testPaperNumber;
 String id;
 Map<String, String> answers = new LinkedHashMap();

 public AnswerSheet(String testPaperNumber,String id) {
     this.testPaperNumber = testPaperNumber;
     this.id = id;
 }

 public String getTestPaperNumber() {
    return testPaperNumber;
}

public void setTestPaperNumber(String testPaperNumber) {
    this.testPaperNumber = testPaperNumber;
}

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public Map<String, String> getAnswers() {
    return answers;
}

public void setAnswers(Map<String, String> answers) {
    this.answers = answers;
}

public void addAnswer(String number,String answer) {
     answers.put(number,answer);
 }
}

public class Main {
 public static void main(String[] args) {
     Scanner scanner = new Scanner(System.in);

     List<Question> questions = new ArrayList<>();
     List<TestPaper> testPapers = new ArrayList<>();
     List<AnswerSheet> answerSheets = new ArrayList<>();
     List<Student> students = new ArrayList<>();
     List<String> Deletes = new ArrayList<>();
//     String s = "#N:[1-9]\\s#Q:[0-9][+-][0-9]=\\s#A:[0-9]";
     String s = "#N:[1-9]\\s#Q:.+\\s#A:.+";
     String s1 = "#T:[1-9](\\s[0-9]-[0-9])+";
     String s2 = "#X:[0-9]{8}\\s.*(-[0-9]{8}\\s.*)*";
     String s3 = "#S:[0-9]\\s[0-9]{8}(\\s#A:[0-9]-.*)*";
     String s4 = "#D:N-[0-9](\\sN-[0-9])*";
     List<String> Wrong = new ArrayList<>();
     List<String> link = new ArrayList<>();
     while (scanner.hasNextLine()) {
         String line = scanner.nextLine().trim();

         if (line.equals("end")) {
             break;
         }

         if (line.startsWith("#N:")) {
             boolean flag = line.matches(s);
             if(flag) {
             String[] parts = line.split(" ");
             String number = parts[0].substring(3);
             String content = parts[1].substring(3);
             String answer = parts[2].substring(3);
             questions.add(new Question(number, content, answer));
             link.add("N"+number);
             }
             else {
                 Wrong.add(line);
//                 System.out.println("\nwrong format:"+line);
             }
         } else if (line.startsWith("#T:")) {
             boolean flag = line.matches(s1);
             if(flag) {
             String[] parts = line.split(" ");
             String testPaperNumber = parts[0].substring(3);
             TestPaper testPaper = new TestPaper(testPaperNumber);
             for (int i = 1; i < parts.length; i++) {
                 String[] subParts = parts[i].split("-");
                 
                 testPaper.addQuestion(subParts[0], Integer.parseInt(subParts[1]));
             }
             testPapers.add(testPaper);
             link.add("T"+testPaperNumber);
             }
             else {
                 Wrong.add(line);
             }
         }else if (line.startsWith("#X:")) {
             boolean flag = line.matches(s2);
             if(flag) {
             String line1 = line.substring(3);
             String[] parts = line1.split("-");
             for (int i = 0; i < parts.length; i++) {
                 String[] subParts = parts[i].split(" ");
                 students.add(new Student(subParts[0],subParts[1]));
                 link.add("S");
             }
             }
             else
                 Wrong.add(line);
         } 
         else if (line.startsWith("#S:")) {
             boolean flag = line.matches(s3);
             if(flag) {
             String[] parts = line.split(" ");
             String testPaperNumber = parts[0].substring(3);
             String id = parts[1];
             AnswerSheet answerSheet = new AnswerSheet(testPaperNumber,id);
             
             for (int i = 2; i < parts.length; i++) {
                 String[] subParts = parts[i].split("-");
                 if(subParts.length<2)
                     answerSheet.addAnswer(subParts[0].substring(3)," ");
                 else
                     answerSheet.addAnswer(subParts[0].substring(3),subParts[1]);
             }
             answerSheets.add(answerSheet);
             link.add("S"+testPaperNumber);
             }
             else
                 Wrong.add(line);
         }
         else if (line.startsWith("#D:")) {
             boolean flag = line.matches(s4);
             if(flag) {
             String line1 = line.substring(3);
             String[] parts = line1.split(" ");
             for (int i = 0; i < parts.length; i++) {
                 String[] subParts = parts[i].split("-");
                 link.add("D"+subParts[1]);
                 if(link.indexOf("D"+subParts[1])>link.indexOf("N"+subParts[1])&&link.indexOf("N"+subParts[1])!=-1)
                 Deletes.add(subParts[1]);
             }
             }
             else
                 Wrong.add(line);
         } 
     }
     //输出错误的输出格式
     for(int i = 0;i<Wrong.size();i++) {
         System.out.println("wrong format:"+Wrong.get(i));
     }
     // 处理试卷总分不等于100的情况
     for (int i = 0; i < testPapers.size(); i++) {
         int totalScore = 0;
         for (Integer value: testPapers.get(i).questions.values()) {
             totalScore += value;
         }
         if (totalScore != 100) {
             System.out.println("alert: full score of test paper" + testPapers.get(i).getNumber() + " is not 100 points");
         }
     }
     // 输出答卷信息
     for (AnswerSheet answerSheet : answerSheets) {
         TestPaper testPaper = null;
         int t=0;//第几道题
         for (TestPaper paper : testPapers) {
             if (paper.number.equals(answerSheet.testPaperNumber)) {
                 if(link.indexOf("T"+paper.number)<link.indexOf("S"+answerSheet.testPaperNumber)) {
                 testPaper = paper;
                 break;
                 }
             }
         }
         if (testPaper == null) {
             System.out.println("The test paper number does not exist");
             continue;
         }
         
        
//         Iterator<String> answerIterator1 = answerSheet.answers.iterator();
         for (String questionNumber1 : testPaper.questions.keySet()) {
             int e = 0;//试卷的题目是否存在
             int p = 0;//判断题目是否被删除
             t++;
            
                 int q = 0;//判断答案是否为空
                 
             for (String answerNumber : answerSheet.answers.keySet()) {
                 
                 
                 if(answerNumber.equals(String.valueOf(t))) {
//                     boolean n = answerSheet.answers.get(answerNumber).equals("");
                     q = 1;//答案不为空
                     for(int i = 0;i<questions.size();i++) {
                         if(questionNumber1.equals(questions.get(i).number)&&link.indexOf("N"+questions.get(i).number)<link.indexOf("T"+testPaper.number)) {
                             e = 1;
                             
                             break;
                         }
                     }
                     if(e==0) {
                         System.out.println("non-existent question~0");
                         break;
                     }
                     for(int i = 0;i<Deletes.size();i++) {
                         if(questionNumber1.equals(Deletes.get(i))) {
                             p = 1;
                             break;
                         }
                         }
                     if(p==1) {//题目被删除
                         System.out.println("the question "+questionNumber1+" invalid~0");
                         break;
                     }
                 
                 
                     boolean isCorrect = answerSheet.answers.get(answerNumber).equals(questions.stream()
                             .filter(a -> a.number.equals(questionNumber1))
                             .findFirst()
                             .orElseThrow(() -> new IllegalArgumentException("Question not found"))
                             .answer);
                     System.out.println(questions.stream()
                           .filter(a -> a.number.equals(questionNumber1))
                           .findFirst()
                           .orElseThrow(() -> new IllegalArgumentException("Question not found"))
                           .content + "~" + answerSheet.answers.get(answerNumber) + "~" + isCorrect);
                 
                 
                 
             }
            
            
             }
             if(q==0) {
                 System.out.println("answer is null");
             }
             
         }
         int x = 0;//判断学生是否存在
         String name = "";
        for(int i = 0;i<students.size();i++) {
            if(answerSheet.getId().equals(students.get(i).student_id)) {
                x = 1;//学生存在
                name = students.get(i).name;
                break;
            }
        }
        if(x==0) {
            System.out.println(answerSheet.getId()+" not found");
            continue;
        }
        

         // 输出判分信息
        StringBuilder scoreInfo = new StringBuilder(); // 用于存储判分信息
        int totalscore = 0;
        for (String questionNumber : testPaper.questions.keySet()) {
            int score = 0;
             int e1 = 0;//试卷的题目是否存在
             int p1 = 0;//判断题目是否被删除
             for(int i = 0;i<questions.size();i++) {
                 if(questionNumber.equals(questions.get(i).number)) {
                     e1 = 1;//试卷题目存在
                     break;
                 }
             }
             if(e1==0) {//试卷题目不存在
                 score = 0;
                 scoreInfo.append(score).append(" "); // 将每道题的得分添加到scoreInfo中
                       totalscore += score;
                 continue;
             }
             for(int i = 0;i<Deletes.size();i++) {
                 if(questionNumber.equals(Deletes.get(i))) {
                     p1 = 1;
                     break;
                 }
                 }
             if(p1==1) {//题目被删除
                 score = 0;
                 scoreInfo.append(score).append(" "); // 将每道题的得分添加到scoreInfo中
                       totalscore += score;
                 continue;
             }
        int k = 0;//判断答案是否为空
         
        for (String answerNumber : answerSheet.answers.keySet()) {
            
            
            if(questionNumber.equals(answerNumber)) {
                k = 1;//答案不为空
            
            
            
                score = answerSheet.answers.get(answerNumber).equals(questions.stream().filter(q -> q.number.equals(questionNumber)).findFirst().orElseThrow(() -> new IllegalArgumentException("Question not found")).answer) ? testPaper.questions.get(questionNumber) : 0;
           
            
            }
            
        }
        if(k==0) {
             score = 0;
             
         }
       scoreInfo.append(score).append(" "); // 将每道题的得分添加到scoreInfo中
       totalscore += score;
        }
        scoreInfo.deleteCharAt(scoreInfo.length() - 1); // 删除最后一个空格
      System.out.println(answerSheet.getId()+" "+name+":"+" "+scoreInfo + "~" + totalscore); // 输出判分信息和总分
//         
     }
 }
}

总结

通过三次大作业，学会了java的基本知识，也逐渐学会了使用类和对象，但还是不熟练，要勤加练习，尤其第三次大作业题目的难度，也让我知道了自己的很多不足的地方，Java这门语言，不仅考验了逻辑思维能力还有用代码的表达能力，用最好的方式最好的思维写出最简洁的代码，这是很难的地方，还要多多学习Java这门语言，面对难题的时候要多思考，多练习，寻找最优解。

在这三次作业中，遇到了很多困难，也有很多严重的问题，最开始是语法，后来熟悉后思维方式还没有变通，还是总爱使用面向过程的方式，对Java没有更深的认知，所以在后面的练习中，要多用类和对象的方式，使用面向对象的程序设计，加强自己对Java的理解，这样才能更好的写出优秀的代码。

posted @ 2024-04-18 22:59 早该结束阅读(31) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 第一次博客作业

· 第一次博客Java作业分析

· 对java面向对象设计的pta前三次作业总结

· JAVA第一次大作业blog

· PTA前三次题目集总结

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· C#/.NET/.NET Core技术前沿周刊 | 第 29 期（2025年3.1-3.9）
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异

公告

昵称：早该结束
园龄： 2年5个月
粉丝： 1
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

biezaixiayu

第一次博客作业

一、前言

知识点

题量和难度

二、设计与分析

题目集一

7-5 答题判题程序-1

输入格式:

输出格式:

题目集二

题目集三

总结

公告

搜索

常用链接

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论