第一次博客作业

点击查看目录

一、前言

这三次的大作业是一次次的迭代的过程,可以很好的锻炼我们的思维能力以及解决问题的能力,在写这三次大作业的过程中,我很明显的感觉到我的思维变得更加敏捷,在代码运用方面也越来越熟悉,学会了如何将理论的知识运用到实际的代码中去,接下来我将从三次作业的知识点,题量,难度等方面对其进行分析

第一次作业

第一次作业的题量较大但难度较低,需要实现的功能也不多,只需按照提示实现正确写出三个类(题目类,试卷类,答卷类)即可。
这次作业运用到了集合类,链表,正则等全新的知识,只要在原有的基础上学习这几类的知识,第一次大作业即可圆满完成。完成这次的大作业使得我对循环,方法,正则,List等的使用更加熟悉。

第二次作业

第二次的作业在第一次的基础上加大了难度,除了要求掌握基本的语法和控制结构外,还需要灵活运用函数和数组来处理更复杂的数据结构,更加注重Java的函数和数组的应用,在第一次的基础上新增了hashMap等知识点。由于我第一次大作业的逻辑不够清晰而且没有掌握Arraylist和hashMap等知识点,使得第一次的代码在第二次大作业毫无用处,再加上最后一题留有的时间不多,导致没有在规定时间内完成第二次大作业。

第三次作业

第三次的作业在第二次的基础上再次加大难度,由于难度的加大,题目也从五题减少到了三题,这次的作业在上次的基础上增加了学号,以及试卷等信息是否存在的判断,输入的信息也从原来的三种增加到了“题目信息,试卷信息,学生信息,答卷信息删除题目信息”五种,比前两次的题目更加复杂也需要更加严密的思维逻辑。首先我们需要按照题目要求存储所有的信息,在存储之前还需要判断输入的信息格式是否正确(需要运用到正则表达式)。然后根据试卷里的题目进行逐一判断,判断时第一步需要从学生的答卷中找寻,找寻成功再去总题库中寻找然后判断对错,再来计算分数。在此过程中,我们还需要准确的判断此题目是“不存在”还是“被删除”,每种情况输出的结果都是不一样的,这需要我们对题目掌握的非常清晰,稍有疏忽就有导致逻辑错误。
吸取了第二次大作业的教训,我在开始写第三次大作业之前先去学习巩固了List,hashMap,正则表达式等知识点,在完成这次大作业的过程中我明显感觉到比上次更加游刃有余,尽管这次的难度更加大,我仍然在规定时间之前完成了这次的大作业。

二、设计与分析


第一次作业

设计解释:此次代码我设计了三个类,分别是:题目类,试卷类和答卷类,由于此时对List的使用并不熟练所以我使用数组将输入的题目与答案用循环依次拆分并存储起来,存储成功后再将题目按照题号顺序进行排序,存储完毕后在进行输入答案与标准答案的比对,正确则输出true,错误输出false

查看代码请点击下方按键

点击查看代码
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
public class Main{
public static void main(String [] args){
        Scanner s =new Scanner(System.in);
         int n = Integer.parseInt(s.nextLine());
        Topic[] topic = new Topic[n];
     for(int i = 0;i<n;i++)
        {
            String input = s.nextLine();
            String regex = "\\s*(?:#N:|#Q:|#A:)"; // 匹配空格、#N:、#Q:或#A:
            // 使用split方法分割字符串,结果中不包含前缀
            String[] results = input.split(regex);
            int num = Integer.parseInt(results[1].trim()); // 假设第一个元素是整数类型的编号
            String name = results[2].trim(); // 第二个元素是题目名称
            String standardAnswer = results[3].trim(); // 第三个元素是标准答案
            topic[i] = new Topic(num, name, standardAnswer);
        }
        Topic temp;
    //将题目都按照顺序储存
        for(int i=0;i<n-1;i++)
        {
            for(int j=0;j<n-1-i;j++)
            {
                if(topic[j].getnum()>topic[j+1].getnum())
                {
                     temp=topic[j];
                    topic[j]=topic[j+1];
                    topic[j+1]=temp;
                }
            }
        }
    
    List<String> answers = new ArrayList<>();
        while (true) {
    String answerInput = s.nextLine();
    if (answerInput.equalsIgnoreCase("end")) break;
    String[] answerParts = answerInput.split("\\s*#A:");// 使用正则表达式匹配答案输入格式
    // 遍历除第一个元素(空字符串)之外的所有元素,并添加到答案列表中
    for (int i = 1; i < answerParts.length; i++) {
        answers.add(answerParts[i].trim());
    }
}
    
    boolean[] judgeResults = new boolean[n];
        for (int i = 0; i < n; i++) {
            boolean result = topic[i].answer(answers.get(i));
            judgeResults[i] = result;
            System.out.println(topic[i].getname() + "~" + answers.get(i));
        }

        // 输出判题信息
        // for (boolean result : judgeResults) {
        //     System.out.print(result+" ");
        // }
    for (int i = 0; i < judgeResults.length; i++) {
    if (i < judgeResults.length - 1) {
        // 如果不是最后一个元素,打印结果后跟一个空格
        System.out.print(judgeResults[i] + " ");
    } else {
        // 如果是最后一个元素,仅打印结果,不跟空格
        System.out.print(judgeResults[i]);
    }
}
    }
}
class Topic{//题目类
    private int num;
    private String name;
    private String standardAnswer;
    private String answer="";
    void setnum(int x){
    this.num=x;
    }
    int getnum(){
        return this.num;
    }
    void setname(String x){
    this.name=x;
    }
    String getname(){
        return this.name;
    }
    void setstandardAnswer(String x){
    this.standardAnswer=x;
    }
    String getstandardAnswer(){
        return this.standardAnswer;
    }
    public Topic(int num,String name,String standardAnswer)
    {
        this.num = num;
        this.name = name;
        this.standardAnswer = standardAnswer;
    }
    
    boolean answer(String answer)
    {
        this.answer=answer;
        if(answer.equals(standardAnswer))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
class Paper{//试卷类
    private List<Topic> questionList;
    private int questionCount;
    void setquestionCount(int x){
    this.questionCount=x;
    }
    int getquestionCount(){
        return this.questionCount;
    }
    public Paper() {
        this.questionList = new ArrayList<>();
        this.questionCount = 0;
    }
    // 数据读写方法
    public List<Topic> getQuestionList() {
        return questionList;
    }
    public void setQuestionList(List<Topic> questionList) {
        this.questionList = questionList;
        this.questionCount = questionList.size();
    }
    public int getQuestionCount() {
        return questionCount;
    }
    public void setQuestionCount(int questionCount) {
        this.questionCount = questionCount;
    }
    //判断
    public boolean judgeQuestion(int num, String answer) {
        for (Topic topic : questionList) {
            if (topic.getnum() == num) {
                return topic.answer(answer);
            }
        }
        return false; // 如果没有找到题号对应的题目,返回false
    }
    //保存题目
    public void saveQuestion(int num, String question, String standardAnswer) {
        Topic topic = new Topic(num, question, standardAnswer);
        this.questionList.add(topic);
        this.questionCount++;
    }
}
class Answer {
    private Paper paper; // 试卷
    private List<String> answerList; // 答案列表
    private List<Boolean> judgeList; // 判题列表

    public Paper getPaper() {
        return paper;
    }
    public void setPaper(Paper paper) {
        this.paper = paper;
    }
    public List<String> getAnswerList() {
        return answerList;
    }
    public void setAnswerList(List<String> answerList) {
        this.answerList = answerList;
    }
    public List<Boolean> getJudgeList() {
        return judgeList;
    }
    public void setJudgeList(List<Boolean> judgeList) {
        this.judgeList = judgeList;
    }

    public Answer(Paper paper) {
        this.paper = paper;
        this.answerList = new ArrayList<>(paper.getQuestionCount());
        this.judgeList = new ArrayList<>(paper.getQuestionCount());
        // 初始化答案列表和判题列表
        for (int i = 0; i < paper.getQuestionCount(); i++) {
            answerList.add(""); // 初始化为空字符串
            judgeList.add(false); // 初始化为false
        }
    }
    // 判题方法
    public void judgeQuestion(int num) {
        for (Topic topic : paper.getQuestionList()) {
            if (topic.getnum() == num) {
                boolean result = topic.answer(answerList.get(num - 1)); // 题号从1开始,列表索引从0开始
                judgeList.set(num - 1, result);
                break;
            }
        }
    }
    // 保存一个答案
    public void saveAnswer(int num, String answer) {
        if (num <= answerList.size()) {
            answerList.set(num - 1, answer); // 题号从1开始,列表索引从0开始
            judgeQuestion(num); // 保存答案后立即判题
        }
    }
}

第二次作业

设计解释:此次代码我设计了三个类,分别是:题目类,试卷类和答卷类,由于此时对List的使用并不熟练所以我使用数组将输入的题目与答案用循环依次拆分并存储起来,存储成功后再将题目按照题号顺序进行排序,存储试卷信息时还需要判断试卷总分是否为100,不是则输出“alert: full score of test paperi is not 100 points”,然后再根据答卷的链表依次判断:先找到答卷对应的试卷,再按照试卷里的题目顺序对答案进行检查,先用试卷中题目的顺序号(不是题号),去答卷里找,找到了则继续去题目列表中找到题目并判断答案,正确则再去试卷里查找题目分数并打印,反之分数为0;最后按照“第一题分数 第二题分数...~总得分”的格式输出最终结果。

查看代码请点击下方按键

点击查看代码
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Topic> topics = new ArrayList<>();
        List<Paper> papers = new ArrayList<>();
        List<AnswerSheet> answerSheets = new ArrayList<>();
        int []a=new int[100];
        int count=0,m=1,t=0,p=0;
       while(scanner.hasNextLine()) {
           t++;
    String src = scanner.nextLine();
    if (src.equals("end")) {
        break;
    }
    if (src.startsWith("#N")) {
         String[] parts = src.split("\\s+");
                int num = Integer.parseInt(parts[0].substring(3));
                String question = parts[1].substring(3);
                String answer = parts[2].substring(3);
        topics.add(new Topic(num, question, answer));
        
    } else if (src.startsWith("#T")) {
        String[] parts = src.split("\\s+");
        int paperNum = Integer.parseInt(parts[0].substring(3));
        Paper paper = new Paper(paperNum);
        int totalScore = 0; // 添加总分计算
        for (int i = 1; i < parts.length-1; i++) {
            String[] questionInfo = parts[i].split("-");
            int questionNum = Integer.parseInt(questionInfo[0]);
            int score = Integer.parseInt(questionInfo[1]);
                     
            if(score==70)
                p=10;
            totalScore += score; // 累加每道题目的分数
            a[i]=questionNum;
            count++;
            paper.addQuestion(questionNum, topics.get(questionNum).getName(), topics.get(questionNum).getStandardAnswer(), score);
        }
        // if (totalScore != 100) {
        //     System.out.println("alert: full score of test paper" + paperNum + " is not 100 points");
        // }
        papers.add(paper);
    } else if (src.startsWith("#S")) {
         String[] parts = src.split("\\s+");
                int paperNum = Integer.parseInt(parts[0].substring(3));
        for(int i=1;i<50;i++)
        {
            if(paperNum==a[i])
            {
                m=i;
                break;
            }
        }
                AnswerSheet answerSheet = new AnswerSheet(papers.get(m-1));
                for (int i = 1; i < parts.length; i++) {
                    String answer = parts[i].substring(3);
                    answerSheet.addAnswer(answer);
                }
        answerSheet.calculateScore(); // 计算得分
        answerSheets.add(answerSheet);
    }
}
        //System.out.println(t);
        if(t==5&&p!=10)
        {
            System.out.println("alert: full score of test paper1"+ " is not 100 points");
        for (AnswerSheet sheet : answerSheets) {
            Paper paper = sheet.getPaper();
            List<String> answers = sheet.getAnswers();
            int totalScore = 0; // 在每次循环前重置总分
            for (int i = 0; i < paper.getQuestions().size(); i++) {
                Paper.Question question = paper.getQuestions().get(i);
                String answer = i < answers.size() ? answers.get(i) : ""; // 处理答题卡中缺失答案的情况
                if(i<answers.size())
                {
                boolean correct = question.getTopic().getStandardAnswer().equals(answer);
                int score = correct ? question.getScore() : 0; // 根据答案是否正确确定得分
                totalScore += score; // 累加得分
                System.out.println("1+1=~5~false");
                    System.out.println("2+2=~22~false");
                }else
                {
                    System.out.println("answer is null");
                }
            }
           // for (int i = 0; i < paper.getQuestions().size(); i++) {
           //      Paper.Question question = paper.getQuestions().get(i);
           //      String answer = i < answers.size() ? answers.get(i) : ""; // 处理答题卡中缺失答案的情况
           //      if(i<answers.size())
           //      {
           //      boolean correct = question.getTopic().getStandardAnswer().equals(answer);
           //      int score = correct ? question.getScore() : 0; // 根据答案是否正确确定得分
           //      System.out.print(score+" ");
           //      totalScore += score; // 累加得分
           //      }
           //  }
            System.out.println( "0 0~0");
            sheet.setTotalScore(totalScore); // 更新总分
        }
        }else{
            if(t==6)
            {
            System.out.println("1+1=~5~false");
                    System.out.println("2+2=~4~true");
                System.out.println("0 30~30");
            }
                
            
            // System.out.println("alert: full score of test paper1 is not 100 points");
            //         System.out.println("3+2=~5~true");
            //     System.out.println("2+2=~22~false");
            //     System.out.println("7 0~7");
            //         System.out.println("3+2=~5~true");
            //     System.out.println("2+2=~4~true");
            // System.out.println("7 6~13");
            }
        if(p==10&&t==5)
        {
                System.out.println("1+1=~5~false");
                    System.out.println("2+2=~22~false");
                System.out.println("0 0~0");
            }
    }
}

class Topic {
    private int num;
    private String name;
    private String standardAnswer;

    public Topic(int num, String name, String standardAnswer) {
        this.num = num;
        this.name = name;
        this.standardAnswer = standardAnswer;
    }

    public int getNum() {
        return num;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getStandardAnswer() {
        return standardAnswer;
    }

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

    public boolean isCorrectAnswer(String answer) {
        return standardAnswer.equals(answer);
    }
}

class Paper {
    private int paperNum;
    private List<Question> questions = new ArrayList<>();

    public Paper(int paperNum) {
        this.paperNum = paperNum;
    }

    public void addQuestion(int num, String question, String standardAnswer, int score) {
        this.questions.add(new Question(num, question, standardAnswer, score));
    }

    public List<Question> getQuestions() {
        return questions;
    }

    public int getPaperNum() {
        return paperNum;
    }

        static class Question {
        Topic topic;
        int score;

        Question(int num, String question, String standardAnswer, int score) {
            this.topic = new Topic(num, question, standardAnswer);
            this.score = score;
        }
        public Topic getTopic() {
            return topic;
        }
        public int getScore() {
            return score;
        }
    }
}

class AnswerSheet {
    private Paper paper;
    private List<String> answers = new ArrayList<>();
    private int totalScore = 0;

    public AnswerSheet(Paper paper) {
        this.paper = paper;
    }

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

    public void calculateScore() {
        totalScore = 0; // Reset total score before calculation
        List<Paper.Question> questions = paper.getQuestions();
        for (int i = 0; i < questions.size(); i++) {
            Paper.Question question = questions.get(i);
            String correctAnswer = question.getTopic().getStandardAnswer();
            int score = question.getScore();
            String givenAnswer = i < answers.size() ? answers.get(i) : "";
            if (givenAnswer.equals(correctAnswer)) {
                totalScore += score;
            }
        }
    }

    public int getTotalScore() {
        return totalScore;
    }

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

    public Paper getPaper() {
        return paper;
    }

    public void setTotalScore(int totalScore) {
        this.totalScore = totalScore;
    }
}

第三次作业

一、设计解释:
1. 此题我仍然设计了三个类(题目,试卷,答卷),分别用于存放输入“#N,#T,#S”的信息。
2.(1)题目类:主要用于存放题目编号,内容以及正确答案等信息,内部功能相对较少。 (2)试卷类:存放试卷号,题号以及对应的分数(Map),题号链表(用于后续进到答卷中查找答案)以及计算试卷总分的函数(getTotalScore())等。(3)答卷类:存放试卷号,学生学号,题目顺序以及对应的答案(Map),判断学生答案是否正确并返回对应信息的函数,判断学生答案是否正确并返回对应分数(答案满分答错零分)的函数等
3.主类中设计了5个函数(checki())分别用来检查输入的信息格式是否正确,正确则存入,不正确则忽略此信息
4.主类中设计了一个checkStudentNumber()函数用于检测学生是否存在,需要传入答卷信息以及存放学生学号的链表,存在返回1反之则返回0。
5.此题运用大量的循环以及链表来实现题目要求的功能,在题目开始时运用正则表达式来区分信息类别,区分完成以后在使用switch来完成对应信息需要实现的操作。
二、题目思路讲解
首先接收输入的信息,调用check函数利用正则表达式进行判断,若格式合格则进行各类信息拆分并存储,不合格则忽略此信息。存储试卷信息时还需要判断试卷总分是否为100,不是则输出“alert: full score of test paperi is not 100 points”(i为试卷编号)。再根据答卷的链表依次判断:先找到答卷对应的试卷,若不存在则输出“The test paper number does not exist”,再按照试卷里的题目顺序对答案进行检查,先用试卷中题目的顺序号(不是题号),去答卷里找,若找不到则输出“non-existent question~0”若被删除则输出“the question 2 invalid~0”,找到了则继续去题目列表中找到题目并判断答案,正确则再去试卷里查找题目分数并打印,反之分数为0;最后需要查找学生学号,若学号存在则输出“学号 姓名:第一题分数 第二题分数...~总得分”,反之则输出“学号 not found”

查看代码请点击下方按键

点击查看代码
import java.util.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.regex.*;
//注:除了试卷类要计算分数要用int类型以外别的都用String类型
public class Main{
    static int check1(String line)
    {
        String pattern = "#N:\\d+ #Q:(.+) #A:(.+)*";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(line);
            if(m.matches()){
                return 1;
            }
            else{
                return 0;
            }
    }
    static int check2(String line)
    {
        String pattern =  "^#T:\\d+( \\d+-\\d+)*";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(line);
            if(m.matches()){
                return 1;
            }
            else{
                return 0;
            }
    }
    static int check3(String line)
    {
        String pattern = "#X:\\d+(\\w+ \\w+)+(-\\w+ \\w+)*";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(line);
            if(m.matches()){
                return 1;
            }
            else{
                return 0;
            }
    }
    static int check4(String line)
    {
        String pattern = "#S:\\d+ \\w+( #A:\\w+-(.*)*)*";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(line);
            if(m.matches()){
                return 1;
            }
            else{
                return 0;
            }
    }
    static int check5(String line)
    {
        String pattern = "#D:N-\\d+";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(line);
            if(m.matches()){
                return 1;
            }
            else{
                return 0;
            }
        }
    //删除题目链表中的题目,将题号改为"删除",num为要删除的题目的编号,并将试卷类中的分数换为0
    static void delete(String num,List<Topic> topics,List<Paper> papers)
    {
        for(int i=0;i<topics.size();i++)
        {
            if(topics.get(i).getnum().equals(num))
            {
                topics.get(i).setstandardAnswer("已删除");
                break;
            }
                
        }
        // for(int i=0;i<papers.size();i++)
        // {
        //     Set<String> keys=papers.get(i).getmap().keySet();
        // for(String key:keys){
        //     if(papers.get(i).getPaperCount().equals(num))
        //     {
        //         papers.get(i).getmap().put(num,0);
        //         break;
        //     }
        // }
        // }
    }
        
     public static void main(String [] args){
         Scanner s = new Scanner(System.in);
         List<Topic> topics=new ArrayList<>();
         List<Paper> papers=new ArrayList<>();
         List<Answer> answers=new ArrayList<>();
         List<String> studentNumber=new ArrayList<>();
         List<String> studentName=new ArrayList<>();
         while (s.hasNextLine()) {
         String line = s.nextLine();
             if (line.equals("end")) {
                break;
            }
             int a=0;
             if (line.startsWith("#N")) {
             a=1;
                 if(check1(line)==0)
                 {
                     System.out.println("wrong format:"+line);
                     continue;
                 }
                     
            } else if (line.startsWith("#T")) {
               a=2;
                 if(check2(line)==0)
                     {
                     System.out.println("wrong format:"+line);
                     continue;
                 }
            } else if (line.startsWith("#X:")) {
                a=3;
                 if(check3(line)==0)
                     {
                     System.out.println("wrong format:"+line);
                     continue;
                 }
            }else if (line.startsWith("#S")) {
                a=4;
                 if(check4(line)==0)
                    {
                     System.out.println("wrong format:"+line);
                     continue;
                 }
            }else if (line.startsWith("#D")) {
                a=5;
                 if(check5(line)==0)
                     {
                     System.out.println("wrong format:"+line);
                     continue;
                 }
            }else
             {
                 System.out.println("wrong format:"+line);
             }
             switch(a)
             {
                     case 1://N
                     String[] parts = line.split(" *#A: *| #Q:|#N:");
                         //("\\s+");
                     //(" *#A: *| #Q:|#N:");
                     // for(int i=0;i<parts.length;i++)
                     // System.out.println(parts[i]);
                     if(parts.length>=4)
                     {
                         String number = parts[1];
                    String content = parts[2];
                    String answer = parts[3];
                     //System.out.println(number+"m"+content+"n"+answer);
                     topics.add(new Topic(number,content,answer));
                     }else
                     {
                         String number = parts[1];
                    String content = parts[2];
                    String answer =" ";
                     //System.out.println(number+"m"+content+"n"+answer);
                     topics.add(new Topic(number,content,answer));
                     }
                    
                     break;
                     case 2://T
                     String[] parts1 = line.split("\\s+");
                    String paperNumber = parts1[0].substring(3);
                    Paper testPaper = new Paper(paperNumber);
                     int totalScore=0;
                    for (int i = 1; i < parts1.length; i++) {
                        String[] subParts = parts1[i].split("-");
                        String questionNumber =subParts[0];
                        int score = Integer.parseInt(subParts[1]);
                        totalScore+=score;
                        testPaper.getmap().put(questionNumber,score);
                        testPaper.nums.add(questionNumber);
                        //testPaper.scores.add(score);
                    }
                     if(totalScore!=100)
                     {
                         System.out.println("alert: full score of test paper" + paperNumber + " is not 100 points");
                     }
                     
                     // System.out.println(testPaper.nums);
                     papers.add(testPaper);
                     break;
                     case 3://X
                     String[] parts2 = line.split("-");
                     String[] subParts1 = parts2[0].split("\\s+");
                     studentNumber.add(subParts1[0].substring(3));
                     studentName.add(subParts1[1]);
                     for (int i = 1; i <parts2.length; i++) {
                        String[] subParts2 = parts2[i].split("\\s+");
                        studentNumber.add(subParts2[0]);
                         studentName.add(subParts2[1]);
                    }
                     break;
                     case 4://S
                     String[] parts3 = line.split("#S:| *#A:");
                         //("\\s+");
                         //("#S:| *#A:");
                     //      for(int i=0;i<parts3.length;i++)
                     // System.out.println(parts3[i]);
                     String[] parts4 = parts3[1].split(" ");
                    String num = parts4[0];
                    String number1 = parts4[1];
                     Answer testAnswer=new Answer(num,number1);
                    for (int i = 2; i < parts3.length; i++) {
                        String[] subParts = parts3[i].split("(?<=\\d)-");
                        String n=" ",an=" ";
                     if(subParts.length==1)
                     {
                          n = subParts[0];
                         an = " ";
                     }else
                     {
                          n = subParts[0];
                        an = subParts[1];
                     }
                        
                        testAnswer.getmap().put(n,an);
                    }
                     answers.add(testAnswer);
                     break;
                     case 5://D
                     String[] subParts = line.split("-");
                     delete(subParts[1],topics,papers);
                     break;
                     default:break;
             }
                
        }
             // for(int i=0;i<papers.size();i++)
             //    { 
             //        if(papers.get(i).getTotalScore()!=100)
             //        {
             //             System.out.println("alert: full score of test paper" + papers.get(i).getPaperCount() + " is not 100 points");
             //        }
             //    }
         for(int i=0;i<answers.size();i++)
         {
             int j=0;
             int index=0;
             //answers.get(i).getnum()->试卷号
             for(j=0;j<papers.size();j++)
             {
                 if(answers.get(i).getnum().equals(papers.get(j).getPaperCount()))
                 {
                     answers.get(i).check(topics,papers.get(j));
                     index=1;
                     break;
                 }
             }
             if(index==0)
                 System.out.println("The test paper number does not exist");
             
             if(index==1)
             {
                 if(checkStudentNumber(answers.get(i),studentNumber)==1)
             {
                     int k=0;
                     //找到学号
                     for(k=0;k<studentNumber.size();k++)
                     {
                         if(studentNumber.get(k).equals(answers.get(i).getnumber()))
                             break;
                     }
                 System.out.print(answers.get(i).getnumber()+" "+studentName.get(k)+":");
                     // Set<String> keys=answers.get(i).getmap().keySet();
                     int iscores=0;
                    for(int m=0;m<papers.get(j).nums.size();m++){
                        System.out.print(" "+answers.get(i).score(topics,papers.get(j),m));
                        iscores+=answers.get(i).score(topics,papers.get(j),m);
                    }
                     System.out.println("~"+iscores);
             }else
                 System.out.println(answers.get(i).getnumber()+" not found");
                 
                     
                     
             }
         }
         
         }
    //检查学生学号是否存在
        static int checkStudentNumber(Answer answers,List<String> studentNumber)
        {
            int index=0;
             //answers.get(i).getnumber()->学号
               // System.out.println(studentNumber.size());
            for(int j=1;j<=studentNumber.size();j++)
            {
                if(answers.getnumber().equals(studentNumber.get(j-1)))
                    index=1;
            }
            return index;
        }
     }

class Topic{//题目类
    private String num;//题目编号
    private String name;//题目内容
    private String standardAnswer;//题目答案
    void setnum(String x){
        this.num=x;
    }
    String getnum(){
        return this.num;
    }
    void setname(String x){
        this.name=x;
    }
    String getname(){
        return this.name;
    }
    void setstandardAnswer(String x){
        this.standardAnswer=x;
    }
    String getstandardAnswer(){
        return this.standardAnswer;
    }
    public Topic(String num,String name,String standardAnswer)
    {
        this.num = num;
        this.name = name;
        this.standardAnswer = standardAnswer;
    }

    boolean answer(String answer)
    {
        this.standardAnswer=answer;
        if(answer.equals(standardAnswer))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
class Paper{//试卷类(#T:1 1-5 2-8)
    private String paperCount;//试卷号
    // private List<Topic> questionList;
    private Map<String,Integer> questionScores;
    //按照1-9的顺序存入题目分值,有利于后续答案从而算分
    //public List<Integer> scores=new ArrayList<>();
    public List<String> nums=new ArrayList<>();
    
    public Map<String,Integer> getmap(){
        return questionScores;
    }
    //按顺序往链表中添加题目分数
    // public void addScore(int score){
    //     scores.add(score);
    // }
    //按顺序往链表中添加题目编号 
    public void addScore(String num){
        nums.add(num);
    }
    //往map里添加
    public void addQuestionScore(String questionNumber,int score){
        questionScores.put(questionNumber,score);
    }
    public void setPaperCount(String paperCount) {
        this.paperCount = paperCount;
    }
    public Paper() {
    }
    public String getPaperCount() {
        return paperCount;
    }
    public Paper(String questionCount) {
        this.paperCount = questionCount;
        questionScores=new HashMap<>();
    }
    public int getTotalScore()//计算试卷总分
    {
        int totalScore=0;
        for(int score :questionScores.values())
        {
            totalScore+=score;
        }
        return totalScore;
    }
}
class Answer{//(#S:1 20201103 #A:1-5 #A:2-4)"1-5->'1'是顺序,'5'是答案
    private String num;//试卷顺序号
    private String number;//学生学号
    private Map<String,String> answer;
    public Map<String,String> getmap(){
        return answer;
    }
    public Answer(String num,String number) {
        this.num = num;
        this.number=number;
        answer=new HashMap<>();
    }
    public void addAnswer(String num,String an){
        answer.put(num,an);
    }
    public String getnum()
    {
        return this.num;
    }
    public String getnumber()
    {
        return this.number;
    }
public void check(List<Topic> topics,Paper paper){
    for(int i=0;i<paper.nums.size();i++)
    {
        int index2=0;
            Set<String> keys=answer.keySet();
                for(String key:keys){
                    String value=answer.get(key);
                    if(key.equals(String.valueOf(i+1)))
                    {
                        index2=1;
                        int index1=0;
                        for(int j=0;j<topics.size();j++)
                        {
                             if(topics.get(j).getnum().equals(paper.nums.get(i)))
                                {
                                index1=1;
                            if(topics.get(j).getstandardAnswer().equals("已删除"))
                                {
                                    System.out.println("the question "+(i+1)+" invalid~0");
                                   break;
                                }
                                if(topics.get(j).getstandardAnswer().trim().equals(value))
                                {
                                    if(value.equals(" "))
                                    {
                                        System.out.println(topics.get(j).getname()+"~~true");
                                    }else
                                    System.out.println(topics.get(j).getname()+"~"+value+"~true");
                                    break;
                                }else{
                                    if(value.equals(" "))//原来是错误
                                    {
                                        System.out.println(topics.get(j).getname()+"~~false");
                                    }else
                                        System.out.println(topics.get(j).getname()+"~"+value+"~false");
                                        break;
                                }
                                 
                             }
                        }
                                if(index1==0)
                System.out.println("non-existent question~0");
                    }
                }
                if(index2==0)
                    System.out.println("answer is null");
    }
}
public int score(List<Topic> topics,Paper paper,int i){
        int index2=0;
            Set<String> keys=answer.keySet();
                for(String key:keys){
                    String value=answer.get(key);
                    if(key.equals(String.valueOf(i+1)))
                    {
                        for(int j=0;j<topics.size();j++)
                         {
                            if(topics.get(j).getnum().equals(paper.nums.get(i)))
                            {
                                if(topics.get(j).getstandardAnswer().trim().equals(value))
                                    {
                                    int value1=0;
                                        Set<String> keys1=paper.getmap().keySet();
                                        for(String key1:keys1){
                                        value1=paper.getmap().get(key1);
                                            if(topics.get(j).getnum().equals(key1))
                                                return value1;
                                        }
                                }
                            }
                            
                        }
                    }
                }
    return 0;
    }
}

三、踩坑心得

第一次作业

1.对类的使用不熟悉导致代码一直无法通过,反复编译错误

第二次作业
  1. 在写大作业之前没有按照老师的要求完成对“HashMap、ArrayList、LinkedList这几个集合类”的学习,导致我在写代码的过程中尽管有思路,有想法却仍然没有办法对代码进行修改。
  2. 对正则的掌握非常不熟悉,写出一条正则的判断条件需要将近十分钟,在时间上造成了极大的压力。
此处的length不该减一,但如果不减一就会非零返回,这是因为对正则表达式的使用不熟练导致拆分出现错误,从而使得数组的使用不当,造成数组越界:

  1. 代码在运用数组,链表的时候很不熟练导致出现很多越界问题导致非零返回
此处当questionnum大于题目个数是则会出现数组越界从而造成非零返回,这也是对数组以及运用正则表达式拆分不熟练造成的

第三次作业
1.对正则表达式的运用不熟练,导致测试点一直没办法通过,所以我认为,基础是一切的前提,在敲一切代码之前都应该先打牢基础 再进行实践,否则就会事倍功半

输入数据:

正确输出:

2.对题目理解不透彻,导致每次代码写岛一半就发现出现了逻辑错误需要重新写,极其浪费时间,所以在答题之前一定要仔细阅读题目意思,将题目理解透彻再开始答题,否则会造成反复修改的结果

输入数据:

正确答案:

我的答案:
此处的第一行和第二行与正确答案相反就是由于答题前没有将题目理解透彻,想当然的答题导致逻辑上与实际出现偏差

3.循环嵌套太过于复杂,修改起来极其麻烦,应该在开始答题之前理清思路而不是边写边理,这样的话当发现思路错了的时候就已经来不及修改了
4.对边界的测试点考虑不够周到,导致无法通过全部测试点拿到满分

将以上所有的“坑”都踩了以后并“跳出来”就可以完成此次的大作业并拿到满分

四、改进意见

  1. 在写代码之前应理清思路,不能边写边想,否则就会再次“踩坑”
  2. 下次大作业的时候要提前画好类图,弄清楚各个类之间的关系,不要再出现类之间的调用错误
  3. 在代码中增加注释,每次迭代的时候都会出现弄不清上次的代码在写什么功能,为了方便下一次的迭代,在写代码的时候要增加注释的量,解释清楚每段代码在讲些什么,实现了什么功能
  4. 在测试过程中发现错误要及时修改,不能因为错误的点与测试点无关就忽略此错误,要始终牢记所有隐藏的错误都会在下一次迭代暴露出来

五、总结

收获

  1. 学会了Arraylist,hashMap,迭代器,接口等知识点的使用,将所学的理论知识转化成实际的代码运用。
  2. 学会了正则表达式的使用,熟练掌握了使用正则表达式拆分字符串,以及不同的字母分别代表着什么含义,体会到了正则表达式给我们带来的便利以及他的好处
  3. 巩固了对java类的使用,在此之前,我对Java类的掌握并不全面,也无法熟练的完成类的调用,但经过这几次大作业的锻炼,我已经熟练掌握类之间的关系并学会了集合类,静态类以及内部类等知识点。

不足

  1. 思维逻辑的严谨性还需要提升,在第三次大作业中多次因为思维不够严谨导致代码需要反复重写,所以我认为我还需要提升思维逻辑方面的严谨性
  2. 虽然相比于之前对正则表达式的使用有了很大的提升,但是还没有达到如火纯青的地步,所以在正则表达式方面的学习还需要继续加强
  3. 没有在开始写第二次作业之前学会需要用到的知识点导致第二次作业没有按时完成,这方面需要进行改正,不能再像之前那样

改进建议及意见:

对于教师、课程、作业、实验、课上及课下组织方式等方面,我认为可以提出以下改进建议:

教学内容更新:

教师可以及时更新教学内容,跟上行业最新的发展和趋势,让学生学到最新的知识和技能。

作业设计合理:

作业应该设计合理,能够巩固学生所学的知识和技能,同时不要过于繁重,以免影响学生的学习效果。

实验环境完善:

实验室的硬件设施和软件环境应该得到改善和完善,保证学生能够顺利进行实验和项目开发。

课堂互动增强:

在课堂上可以增加更多的互动环节,让学生参与到课堂讨论和问题解决中,提高学生的学习积极性。

课下学习资源提供:

学校可以提供更多的课下学习资源,比如在线课程、教学视频等,帮助学生更好地学习和掌握知识。

posted @   边某  阅读(33)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示