526互联

blog-6-8次PTA题目集（成绩计算系列）

发布时间 2023-06-28 22:50:12作者: .寂

（1）前言：

第6次题目集

课程成绩统计程序-1

在规范性输入时涉及到了正则表达式，数组列表及其相关方法的使用，if-else,for，foreach循环的使用，以及字符串中的substring（）方法，equals()方法的使用，Integer.toString

等相关类型之间转化的方式，数据域的封装，Comparable接口的实现，

Collections.sort()实现排序

第7次题目集

7-1 容器-HashMap-检索

使用HashMap存储学生信息，split（）方法，if-else的使用。以及hashmap类当中相关方法其中的查询。

7-2 容器-HashMap-排序

涉及HashMap存储学生信息，以及将其转化为list类，再实现comparable接口，将其进行排序。

7-3 课程成绩统计程序-2

在规范性输入时涉及到了正则表达式，数组列表及其相关方法的使用，if-else,for，foreach循环的使用，以及字符串中的substring（）方法，equals()方法的使用，Integer.toString

等相关类型之间转化的方式，数据域的封装，Comparable接口的实现，

Collections.sort()实现排序。

7-4 动物发声模拟器（多态）

定义了抽象类，以及其的子类实现其父类的抽象方法。

第8次题目集

8-1 容器-ArrayList-排序

  涉及了ArrayList列表的使用，split()方法的使用，Integer.parseInt

对数据的转化，Collections.sort对数据的排序，实现了Comparable接口

8-2 课程成绩统计程序-3

在规范性输入时涉及到了正则表达式，数组列表及其相关方法的使用，if-else,for，foreach循环的使用，以及字符串中的substring（）方法，equals()方法的使用，Integer.toString

等相关类型之间转化的方式，数据域的封装，Comparable接口的实现，

Collections.sort()实现排序

8-3 jmu-Java-02基本语法-03-身份证排序

使用了ArrayList<String> 列表，对控制台输入的数据进行存储，利用了对字符串拆分的substring(6, 10);方法，使用Collections.sort(IDList, (id1, id2) -> Lambda表达式简化排序，nextLine().trim()对后面空格的忽略，以防对输入数据残生问题，foreach对列表进行遍历。

7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

定义了一个接口 IntegerStack，利用ArrayIntegerStack implements IntegerStack对其中抽象方法进行完善，采用的是数组的方式，其中利用了++topTip，topTip--对toptip数据的不用方式的计算，利用for循环将其输出，

8-5 jmu-Java-03面向对象基础-05-覆盖

分别对输入数据用数组person1[] ，ArrayList<PersonOverride> persons2进行存储数据，for (PersonOverride p : persons2)

对列表遍历，重写equals,toString方法。

三次题目量来说还是比较少的，题量和难度成反比，最后一次作业难度较大，改变了很多的输入格式，在各个对象的存储调用之间很麻烦，造成难度较大，并且对时间有比较严格的要求，容易造成超时。

（2）设计与分析

课程成绩统计程序-1

 

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
class InputMatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修)";
    static String checkcourseTypeMatching = "(考试|考察)";
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching;
    static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + " " + scoreMatching;

    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;//输入的是课程
        }
        if (matchingScore(s) || matchingScore1(s)) {
            return 2;//输入的是成绩
        }
        return 0;
    }
    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }
    private static boolean matchingScore(String s) {
        return s.matches(scoreInput);
    }
    private static boolean matchingScore1(String s) {
        return s.matches(scoreInput1);
    }
}
//输入匹配法则
class ParseInput {
    ArrayList<Course> listCourse = new ArrayList<>();
    ArrayList<Student> listStudent = new ArrayList<>();
    ArrayList<SelectCourse> listSelectCourse = new ArrayList<>();
    ArrayList<Banji> listBanji = new ArrayList<>();
    ArrayList<String> listerror = new ArrayList<>();

    public void parseInput(String str) {
        int t = InputMatching.matchingInput(str);
        String a[] = str.split(" ");
        if (t == 0) {
            String error = "wrong format";
            listerror.add(error);
            return;
        }

        if (a.length == 3 || a.length == 2) {
            String name = a[0];
            String type = a[1];
            String checkMode = "";
            if (a.length == 3) {
                checkMode = a[2];//重复课程的输入混乱，排序重复，未改-对应5异常
            }
            if (a.length == 2) {
                if (type.equals("必修")) {
                    checkMode = "考试";
                } else {
                    String error = "wrong format";
                    listerror.add(error);
                    return;
                }
            }
            Course againCourse = findCourse(name);
            if (againCourse != null) {
                return;
            }

            if (type.equals("必修")) {
                if (checkMode.equals("考察")) {
                    String error = name + " " + ": course type & access mode mismatch";
                    listerror.add(error);
                    //System.out.println(name+": course type & access mode mismatch");
                    return;
                }
                Course course = new Course(name, type, checkMode);
                listCourse.add(course);
            }
            if (type.equals("选修")) {
                Course course = new Course(name, type, checkMode);
                listCourse.add(course);
            }
        }
        if (a.length == 4 || a.length == 5) {
            String classNum = a[0].substring(0, 6);
            String id = a[0];
            String stuName = a[1];
            Banji banji = findCla(classNum);
            if (banji == null) {
                banji = new Banji(classNum);
                listBanji.add(banji);
            }
            Student student1 = findStudent(id, stuName);
            if (student1 == null) {
                student1 = new Student(id, stuName);
                listStudent.add(student1);
                banji.addStudent(student1);
            } else {
                for (SelectCourse againselect : student1.selects) {
                    if (a[2].equals(againselect.course.name)) {
                        return;
                    }
                }
            }
            Course stuCourse = findCourse(a[2]);
            if (stuCourse == null) {
                String error = a[2] + " " + "does not exist";
                listerror.add(error);
                return;
            }
            if (stuCourse.checkMode.equals("考试")) {
                if (a.length == 4) {
                    String error = id + " " + stuName + " " + ": access mode mismatch";
                    listerror.add(error);
                    return;
                }
                Grade grade = new ExamGrade(Integer.parseInt(a[3]), Integer.parseInt(a[4]));
                SelectCourse selectCourse = new SelectCourse(stuCourse, student1, grade);
                listSelectCourse.add(selectCourse);
                student1.addSelect(selectCourse);
                stuCourse.addSelect(selectCourse);
            }
            if (stuCourse.checkMode.equals("考察")) {
                if (a.length == 5) {
                    String error5 = id + " " + stuName + " " + ": access mode mismatch";
                    listerror.add(error5);
                    return;
                }
                Grade grade = new InspectGrade(Integer.parseInt(a[3]));
                SelectCourse selectCourse = new SelectCourse(stuCourse, student1, grade);
                listSelectCourse.add(selectCourse);
                student1.addSelect(selectCourse);
                stuCourse.addSelect(selectCourse);
            }
        }
    }
        public Course findCourse (String courseName)
        {
            if (listCourse.size() == 0) {
                return null;
            }
            for (Course temp : listCourse) {
                if (temp.name.equals(courseName)) {
                    return temp;
                }
            }
            return null;
        }
        public Student findStudent (String stuName, String stuNum)
        {
            if (listStudent.size() == 0) {
                return null;
            }
            for (Student temp : listStudent) {
                if (temp.name.equals(stuName) && temp.ID.equals(stuNum)) {
                    return temp;
                }
            }
            return null;
        }
        public Banji findCla (String claNum)//测试点大致测试数据与给的样例有关，看测试点名字可得，故可根据大概的测试数据
        {
            if (listBanji.size() == 0) {
                return null;
            }
            for (Banji temp : listBanji) {
                if (temp.classID.equals(claNum)) {
                    return temp;
                }
            }
            return null;
        }
        public void showCourses () {
            Collections.sort(listCourse);
            if (listCourse.size() != 0)
                for (int i = 0; i < listCourse.size(); i++) {
                    Course cou = listCourse.get(i);
                    //丛总选课表中获取该课程记录集合
                    ArrayList<SelectCourse> couStudentSelects = getCourseSelects(cou.getName());
                    if (couStudentSelects.size() != 0) {
                        if (cou.courseType.equals("必修")) {
                            System.out.println(cou.getName() + " " + getAvgMidtermScore(couStudentSelects) + " " +getAvgfinalScore(couStudentSelects) +
                            " "+getAvgTotalScore(couStudentSelects));
                        }
                        if (cou.courseType.equals("选修") && cou.checkMode.equals("考试")) {
                            System.out.println(cou.getName() + " " + getAvgMidtermScore(couStudentSelects) + " "
                                    + getAvgfinalScore(couStudentSelects) + " " + getAvgTotalScore(couStudentSelects));
                        }
                        if (cou.courseType.equals("选修") && cou.checkMode.equals("考察")) {
                            System.out.println(cou.getName() + " " + getAvgfinalScore(couStudentSelects) + " " + getAvgTotalScore(couStudentSelects));
                        }
                    } else {
                        System.out.println(cou.getName() + " " +
                                "has no grades yet");
                    }
                }
        }
        private String getAvgfinalScore (ArrayList < SelectCourse > list) {
            int sum = 0;
            for (int i = 0; i < list.size(); i++) {
                sum += (int) (list.get(i).grade.finalExamGrade);
            }
            return Integer.toString((int) (sum / list.size()));
        }
        private String getAvgMidtermScore (ArrayList < SelectCourse > list) {
            int sum = 0;
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).course.courseType.equals("选修") || list.get(i).course.checkMode.equals("考试")) {
                    sum += (int) (list.get(i).grade.midtermGrade);
                }
            }
            return Integer.toString((int) (sum / list.size()));
        }
        private ArrayList<SelectCourse> getBanjiSelects (String classID){
            ArrayList<SelectCourse> banSelects = new ArrayList<SelectCourse>();
            for (SelectCourse selectCourse : listSelectCourse) {
                if (selectCourse.student.ID.substring(0, 6).equals(classID)) {
                    banSelects.add(selectCourse);
                }
            }
            return banSelects;
        }
        private ArrayList<SelectCourse> getCourseSelects (String name){
            ArrayList<SelectCourse> courseSelects = new ArrayList<SelectCourse>();
            for (SelectCourse selectCourse : listSelectCourse) {
                if (selectCourse.course.name.equals(name)) {
                    courseSelects.add(selectCourse);
                }
            }
            return courseSelects;
        }
        public void showStudents () {
            Collections.sort(listStudent);
            String prevID = "";
            String prevName = "";
            if (listStudent.size() != 0)
                for (int i = 0; i < listStudent.size(); i++) {
                    Student stu = listStudent.get(i);
                    ArrayList<SelectCourse> stuCourseSelects = getStudentSelects(stu.getID());
                    if (stu.getID().equals(prevID)) {
                    continue;
                   }
                    if (stuCourseSelects.size() != 0) {
                        System.out.println(stu.getID() + " " + stu.getName() +" "+getAvgTotalScore(stuCourseSelects));
                    } else {
                        System.out.println(stu.getID() + " " + stu.getName() +" " +"did not take any exams");
                    }
                    prevID = stu.getID();
                    prevName = stu.getName();
                }
        }
        public void showBanjis () {
            Collections.sort(listBanji);
            String prevID = "";
            if (listBanji.size() != 0)
                for (int i = 0; i < listBanji.size(); i++) {
                    Banji ban = listBanji.get(i);
                    ArrayList<SelectCourse> banSelects = getBanjiSelects(ban.classID);
                    if (ban.getClassID().equals(prevID)) {
                        continue;
                    }
                    if (banSelects.size() != 0) {
                        System.out.println(ban.classID + " " +getAvgTotalBanScore(banSelects));
                    } else {
                        System.out.println(ban.classID + " " + "has no grades yet");
                    }
                    prevID = ban.getClassID();
                }
        }
        private String getAvgTotalBanScore (ArrayList < SelectCourse > list) {
            int sum = 0;
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).course.courseType.equals("必修")) {
                    if (list.get(i).course.checkMode.equals("考试")) {
                        sum += (int) (list.get(i).grade.midtermGrade * 0.3 + list.get(i).grade.finalExamGrade * 0.7);
                    }

                }
                if (list.get(i).course.courseType.equals("选修")) {

                    if (list.get(i).course.checkMode.equals("考试")) {
                        sum += (int) (list.get(i).grade.midtermGrade * 0.3 + list.get(i).grade.finalExamGrade * 0.7);
                    }
                    if (list.get(i).course.checkMode.equals("考察")) {
                        sum += (int) (list.get(i).grade.finalExamGrade);
                    }
                }
            }
            return Integer.toString((int) (sum / list.size()));
        }
        private ArrayList<SelectCourse> getStudentSelects (String id){
            ArrayList<SelectCourse> studentSelects = new ArrayList<SelectCourse>();
            for (SelectCourse selectCourse : listSelectCourse) {
                if (selectCourse.student.ID.equals(id)) {
                    studentSelects.add(selectCourse);
                }
            }
            return studentSelects;
        }
        private String getAvgTotalScore (ArrayList < SelectCourse > list) {
            int sum = 0;
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).course.courseType.equals("必修")) {
                    if (list.get(i).course.checkMode.equals("考试")) {
                        sum += (int) (list.get(i).grade.midtermGrade * 0.3 + list.get(i).grade.finalExamGrade * 0.7);
                    }
                }
                if (list.get(i).course.courseType.equals("选修")) {

                    if (list.get(i).course.checkMode.equals("考试")) {
                        sum += (int) (list.get(i).grade.midtermGrade * 0.3 + list.get(i).grade.finalExamGrade * 0.7);
                    }
                    if (list.get(i).course.checkMode.equals("考察")) {
                        sum += (int) (list.get(i).grade.finalExamGrade);
                    }
                }
            }
            return Integer.toString((int) (sum / list.size()));
        }
        public void showException () {
            for (String s : listerror) {
                System.out.println(s);
            }
        }
    }

    public class Pta_6 {
        public static void main(String[] args) {
            Scanner s = new Scanner(System.in);
            String s_record = s.nextLine();
            ParseInput handle = new ParseInput();
            while (!s_record.equals("end")) {
                handle.parseInput(s_record);//解析用户输入的每一行数据
                s_record = s.nextLine();
            }
            handle.showException();
            handle.showStudents();
            handle.showCourses();
            handle.showBanjis();
        }
    }

    class Grade {
        int finalExamGrade;//期末成绩
        int midtermGrade;//平时成绩
    }

    class ExamGrade extends Grade {
        public ExamGrade(int midtermGrade, int finalExamGrade) {
            this.midtermGrade = midtermGrade;
            this.finalExamGrade = finalExamGrade;
        }
    }

    class InspectGrade extends Grade {
        public InspectGrade(int finalExamGrade) {
            this.finalExamGrade = finalExamGrade;
        }
    }

    class Student implements Comparable<Student> {
        ArrayList<SelectCourse> selects = new ArrayList<>();
        String name;
        String ID;

        public SelectCourse addSelect(SelectCourse selectCourse) {
            selects.add(selectCourse);
            return selectCourse;
        }

        public Student() {
        }

        public Student(String ID, String name) {
            this.name = name;
            this.ID = ID;
        }

        public String getName() {
            return name;
        }

        public String getID() {
            return ID;
        }

        public int compareTo(Student o) {
            return this.ID.compareTo(o.getID());//如果由于当前 ID 大于参数 ID，因此应该返回一个正整数，例如 1
        }
    }

    class Banji implements Comparable<Banji> {
        String classID;
        ArrayList<Student> students = new ArrayList<Student>();

        public Student addStudent(Student student) {
            students.add(student);
            return student;
        }

        public Banji(String classID) {
            this.classID = classID;
        }

        public String getClassID() {
            return classID;
        }

        public int compareTo(Banji o) {
            return this.classID.compareTo(o.getClassID());
        }
    }

    class SelectCourse {
        Course course;
        Student student = new Student();
        Grade grade;

        public SelectCourse(Course stuCourse, Student student1, Grade grade) {
            this.course = stuCourse;
            this.student = student1;
            this.grade = grade;
        }
    }

    class Course implements Comparable<Course> {
        ArrayList<SelectCourse> selects = new ArrayList<>();
        String name;
        String courseType;
        String checkMode;

        public SelectCourse addSelect(SelectCourse selectCourse) {
            selects.add(selectCourse);
            return selectCourse;
        }

        Course(String name, String courseType, String checkMode) {
            this.name = name;
            this.courseType = courseType;
            this.checkMode = checkMode;
        }

        public String getName() {
            return name;
        }

        @Override
        public int compareTo(Course o) {
            Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
            return compare.compare(name, o.getName());
        }
    }

 

 

 

 

 

在class InputMatching当中利用了正则表达式对输入数据进行了严格的模式筛选，下图由于考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。便进行相关的处理。

 

 

通过findCla等自定义的方法对是否已经输入进行判断，避免重复判断。以及对相关信息匹配与否的判断，以及对学生和班级对象的数据存入。

 

 

对考察方式的判断，如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"实现上述判断，并对课程成绩，选课增加。

 

学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"，通过private ArrayList<SelectCourse> getStudentSelects (String id)方法对同一学生的选课列表整合起来。在private String getAvgTotalScore (ArrayList < SelectCourse > list) 方法中计算出全科的总成绩，其中对于不同的考试方式匹配不同的成绩的计算。其中if (stu.getID().equals(prevID)) {
    continue;
}

该判断是为了不重复输出

单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

private ArrayList<SelectCourse> getCourseSelects (String name)在该方法中利用foreach将指定的课程其中的选课列表找出来。然后在 getAvgMidtermScore(couStudentSelects)+getAvgfinalScore(couStudentSelects) +getAvgTotalScore(couStudentSelects))

这三个方法里面分别计算平时成绩平均分，期末考试平均分成绩平均分。

 

展示班级相关信息也和上述一致，其中通过相关数据来查找选课列表方法如下。

 

在成绩类当中有考察成绩和考试成绩两种类型继承考试类，利用多态很好的解决了相关的问题，并且在student，Grade，banji，类当中都实现了Comparable

接口处理了之后排序输出的问题。

课程成绩统计程序-2

 

 

 

 

 

 

大体与之前没啥区别，主要是增加了实验课的考试方式，以及在正则表达式上的改变，实验课成绩为每次的成绩求平均，正则表达式变化如下。

 

主要是考虑了对输入的实验成绩格式的判断，以及添加了一个实验课成绩的列表，便于对实验课成绩的存入

 

对于实验成绩的计算 if (list.get(i).course.courseType.equals("实验")) {
        sum += (int) (list.get(i).grade.totalgrade);
    }
}

利用列表遍历将所有实验数据，来计算一组实验成绩的平均成绩。

 

新增加一个实验成绩类，其中构造器构造TextGrade(int num,ArrayList<Integer> pergrade)

将实验类成绩平均成绩计算得来

 

课程成绩统计程序-3

 

 

 

 

 

 

与前两个差别还是要蛮大的，要改变很多东西

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，

要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。

应该采用组合的方式，如果采用继承累的方式来写的化，容易因为时间超时导致代码不让过。

实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验次数至少4次，不超过9次

针对上述信息正则表达式有很大的修该，

 

由于输入格式的不同，在相应数据的存储时判断也要进行相应改变，由于考察考试界限分明，将没有了之前的判断，只需要对相应是否匹配的判断即可。

 

下面代码快中对于权重也进行了相应计算，看是否符合题给相应条件

 

我的想法是在这里对实验成来进行计算：通过调用相应实验课程成绩和权重列表来进行计算。

 

（3）踩坑心得

在第一次作业的中一开始没有考虑到必修可以没有考试这两个字默认，没有相对应进行更改。以及在后面同一个人相对应课程重复录入的时候没有做处理，以及输出时会重复输出相同的成绩。

 

在第二次作业提交时由于因为第一次作业代码的冗长导致代码无法上传，进行了一些删改，以及简化。

第三次作业就出现了比较多的问题，有些测试点没有给出，不清楚哪里报错，没有修改，但是最多的还是超时，这可能是因为我没有修改成绩框架的原因吧。

（4）改进建议

该代码块其实可以合并与总成绩，这样可以缩减代码长度

我发现自己在理解题意时有时候

 

会出现偏差，导致最终的编码结果与题目要求不符。其次，我在编码时有时候会出现逻辑错误，导致程序无法正常运行。最后，我发现自己在处理一些复杂的算法时，会出现思路不清晰的情况，导致编码效率低下。

掌握的知识面还是太窄了，可以更多的冲网上获取一写更加简单减少运行时间的方式，以及复用自己代码。

（5）总结

输入处理和数据管理：通过处理输入的课程和成绩信息，我学会了如何解析并存储这些数据，并根据约束条件进行相应的验证和有效性检查。算法设计与计算逻辑：为了计算各种平均分和总成绩，我设计了相应的算法逻辑，包括累加和除以总数的计算方法，并按要求进行排序异常情况处理：通过实现异常情况的处理逻辑，我了解了如何根据不同的输入错误类型提供正确的错误提示信息，并进行适当的输出和处理。和格式化输出。提高编码能力：完成这个任务需要熟练运用字符串操作、条件判断、循环等编程概念和技巧，锻炼了我的编码能力和问题解决能力

在进一步学习和研究方面

优化算法和数据结构：对于大规模数据和复杂逻辑场景，可以探索更高效的算法和数据结构，以提高代码的执行效率和运行速度。

对老师的建议，可不可以早点开放，让我有更加充足的时间完成。