第三阶段pta题目集分析

 

前言：菜单题目刚过，学生成绩分析题目又来。 和菜单题目类似。这次又涉及到了组合，继承，正则表达式的应用。虽然老师给了一个简单的类图，但是不够完整，仅供参考，类图里只有类的名称和大概的关系。但就菜单题目的比对，类图里缺少了一些对现有类进行操作的类，比如老师给的类图里面有选课这个类，选课里包含了课程还有成绩信息，我倾向它是对输入里面选课信息的存储和处理。但是它只能存储一行信息，还要再加一个类作为处理选课信息的帮手，再给选课类再加一个父类。但这只是我一开始的想法，接下来的在设计分析里。

设计与分析：毫无疑问，一道题目的开始是做好统筹。先想好大概要写什么，也就是说把那设计图做得更加完美。当然，一开始肯定都是不完善的。一些分析在前言里面也说过了。接下来，我要诉说我之后的想法。这也是一个我要在踩坑心得里面写的东西。总之。前言的方法不行，要用另外一种。其实，想要处理选课信息，没必要再弄一个处理处理选课信息的东西。在选课信息里面使用套娃去套选课信息的组的话又会变成递归，造成内存泄漏。最好就是在主类里面，创造一个选课信息类的对象数组。把每一行的选课信息都存进这个数组里面，然后对这个数组进行排序等操作。不过在学生类里面加上成绩等内容，在班级类里面存学生类的对象数组，这样就避免了主方法的代码过长。这个时候，选课类与学生类就不是组合的关系了。班级类成了我之前想要有的处理处理选课信息的类。这样子设计代码也不会过长。对输入的信息处理依旧是每一行每一行来，利用正则表达式判断输入的到底是选课信息还是课程信息。在考试成绩类和考察成绩类里面计算期末成绩(平时成绩)的总分。在班级里面设计排序的方法。

题目如下：

 

7-1 课程成绩统计程序-1
分数 100
作者 蔡轲
单位 南昌航空大学
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

 

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩0.3+期末成绩0.7。

 

考察的总成绩直接等于期末成绩

 

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。

 

1、输入：

 

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

 

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

 

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

 

课程性质输入项：必修、选修

 

考核方式输入选项：考试、考察

 

课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

 

课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

 

以上信息的相关约束：

 

1）平时成绩和期末成绩的权重默认为0.3、0.7

 

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

 

3）学号由8位数字组成

 

4）姓名不超过10个字符

 

5）课程名称不超过10个字符

 

6）不特别输入班级信息，班级号是学号的前6位。

 

2、输出：

 

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

 

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

 

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

 

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

 

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

 

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

 

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

 

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

 

3）班级所有课程总成绩平均分按班级由低到高排序输出

 

格式：班级号+英文空格+总成绩平均分

 

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

 

异常情况：

 

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

 

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

 

以上两种情况如果同时出现，按第一种情况输出结果。

 

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

 

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

 

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

 

信息约束：

 

1）成绩平均分只取整数部分，小数部分丢弃

 

在这里给出一组输入。例如：

 

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

 

 

 

输出样例1:

 

---

 

仅有课程。例如：

 

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

 

 

 

输入样例2:

 

---

 

单门考试课程 单个学生。例如：

 

java 必修 考试
20201103 张三 java 20 40
end

 

 

 

输出样例2:

 

---

 

在这里给出相应的输出。例如：

 

20201103 张三 34
java 20 40 34
202011 34

 

 

 

输入样例3:

 

---

 

单门考察课程 单个学生。例如：

 

java 选修 考察
20201103 张三 java 40
end

 

 

 

输出样例3:

 

---

 

在这里给出相应的输出。例如：

 

20201103 张三 40
java 40 40
202011 40

 

 

 

输入样例4:

 

---

 

单门课程，单个学生，课程类型与考核类型不匹配。例如：

 

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

 

 

包含了学生的信息以及选课的信息，StudentGrade，CourseGrade，Classroom，中的计算价格都需要用到Choose_Course中的信息

其中计算班级分数的代码如下：

Map<String, Classroom> classrooms = new HashMap<>();

        // 遍历Choose_courses，将学生按班级分组，并累计每个班级的总成绩和班级人数
        for (Choose_course choose_course : grades.Choose_courses) {
            String number = choose_course.number;
            String classroomNum = number.substring(0, 6);
            Classroom classroom = classrooms.getOrDefault(classroomNum, new Classroom(classroomNum));
            classroom.add(choose_course.Full_Grade);
            classrooms.put(classroomNum, classroom);
        }

        // 计算每个班级的平均分，并将平均分存储到班级对象中
        List<Classroom> classroomList = new ArrayList<>(classrooms.values());
        for (Classroom classroom : classroomList) {
            classroom.calculateAverage();
        }
        // 按平均分排序，
        Collections.sort(classroomList, (c1, c2) -> c1.getClassroomNum().compareTo(c2.getClassroomNum()));
        for (Classroom classroom : classroomList) {
            if(classroom.getAverage()!=0){
                System.out.println( classroom.getClassroomNum()+" "+classroom.getAverage());}
            if(classroom.getAverage()==0){
                System.out.println( classroom.getClassroomNum()+" has no grades yet");

            }
        }

 

第2次题目迭代增加了“实验”部分，实验有实验的次数以及成绩，在读取数据时进行了分：

 if (parts[0].charAt(0) > 58) {
                int Flag = 0;
                if(parts[1].equals("实验")&&parts[2].equals("实验")&&parts[0].length()<= 10){
                    Flag = -2;
                    String course_Name = parts[0];
                    String course_Nature = parts[1];
                    String course_Way = parts[2];
                    Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                    Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                }
                if (parts[0].length() <= 10&&parts[1].equals("选修")&&(parts[2].equals("考试")||parts[2].equals("考察"))) {
                    Flag = 1;
                    String course_Name = parts[0];
                    String course_Nature = parts[1];
                    String course_Way = parts[2];
                    Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                    Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                }
                if(parts[0].length()<=10&&parts[1].equals("必修")&&parts[2].equals("考试")){
                    Flag = 1;
                    String course_Name = parts[0];
                    String course_Nature = parts[1];
                    String course_Way = parts[2];
                    Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                    Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                }
                if(!parts[1].equals("实验")){
                    Flag = -3;
                    if(parts[2].equals("实验")){
                        System.out.println(parts[0] + " : course type & access mode mismatch");
                        String course_Name = parts[0];
                        String course_Nature = parts[1];
                        String course_Way = parts[2];
                        Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                        Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                    }
                }
                if (parts[0].charAt(0) > 58 && parts.length == 3 && parts[1].equals("必修") && parts[2].equals("考察")) {
                    Flag = -3;
                    System.out.println(parts[0] + " : course type & access mode mismatch");
                    // System.out.println(parts[0] + " does not exist");//修改后的值
                    String course_Name = parts[0];
                    String course_Nature = parts[1];
                    String course_Way = parts[2];
                    Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                    Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                }//不匹配
                if(Flag==0){
                    System.out.println("wrong format");
                    String course_Name = parts[0];
                    String course_Nature = parts[1];
                    String course_Way = parts[2];
                    Course course = courses.addCourse(course_Name, course_Nature, course_Way, Flag);
                    Course course_1 = courses.addCourse1(course_Name, course_Nature, course_Way, Flag);
                }
            }

 第三次源码（不完全正确）：

import java.text.Collator;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int findanexit=0;
        int u;
        grade gra_gra=new grade(null);
        String five="^(\\d{8})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([0-9]|[1-9][0-9]|100)\\s+([0-9]|[1-9][0-9]|100)$";
        String four="^(\\d{8})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([0-9]|[1-9][0-9]|100)$";
        Chosecoure date = new Chosecoure();
        int cont = 0;
        int sin=0;
        int run;
        while (in.hasNextLine()) {
            run=0;
            String a = in.nextLine().trim();
            String[] b = a.split(" ");
            int length = b.length;
            int iq = 0;
            if (a.equals("end"))
                break;
            else {
                if (length == 3) {
                    int su=0;
                    float []s = new float[2];
                    s[0]=1;
                    Course c = new Course(b[0],b[1],b[2],1,s);
                    IfWeightRight(date, b, iq, su, c);
                }
                else if (length == 6) {
                    int su=0;
                    float []s = new float[2];
                    s[0]=Float.parseFloat(b[4]);
                    s[1]=Float.parseFloat(b[5]);
                    Course c = new Course(b[0], b[1], b[2],2,s);
                    IfWeightRight(date, b, iq, su, c);
                }
                else if(length>6&&(b[2].equals("实验")||b[2].equals("考察")||b[2].equals("考试"))) {
                    int su=1;
                    float[] s = new float[length - 4];
                    for (int i = 0; i < length - 4; i++) {
                        s[i] = Float.parseFloat(b[i+4]);
                    }
                    Course c = new Course(b[0], b[1], b[2], Integer.parseInt(b[3]), s);
                    if (c.Right()) {
                        if (c.IfMatch(su))
                            if(length - 4 == Integer.parseInt(b[3])){
                                ifWeightRight(date, b, iq, c);
                            }
                            else if(!c.IfMatch(su)){
                                System.out.println(b[0]+" : course type & access mode mismatch");
                            }
                            else {
                                System.out.println(b[0]+" : number of scores does not match");
                            }
 
                    }
                    else{
                        System.out.println("wrong format");
                    }
                }
                date.course.forEach(Course::decide_mark);
                for(Course e: date.course){
                    if(e.name.equals(b[2]))
                        run=e.mark;
                }
                if ((length == 4 || length == 5)&&run!=3) {
                    if (length == 4) {
                        if (!a.matches(four)) {
                            System.out.println("wrong format");
                        }else{
                            int []s = new int[9];
                            s[0]=-1;
                            s[1]=Integer.parseInt(b[3]);
                            Score sco = new Score(b[0], b[1],b[2],s);
                            Student stu = new Student(b[0], b[1]);
                            date.student.add(stu);
                            date.grades.add(new grade(gra_gra.get_gradenumber(b[0])));
                            for(Course e: date.course)
                            {
                                if (e.name.equals(b[2]) && e.mark == 1)
                                    sin = 1;
                                if(e.name.equals(b[2]))
                                {
                                    sco.get_weight(e.weight);
                                    sco.get_size(e.size);
                                }
                            }
                            if (sco.HaveThisCourse(b[2], date.course) && sco.NumberMatchMode(b[2], date.course))
                            {
                                if (cont == 0&&sin==1) {
                                    sco.dailyScore = 0;
                                    sco.decide_course(date.course);
                                    date.score.add(sco);
                                    sco.dailyScore = -1;
                                    cont++;
                                }
                                for (Score e : date.score) {
                                    if (!e.number.equals(b[0]) || !e.name.equals(b[1]) || !e.course.name.equals(b[2]) || e.dailyScore != -1 || e.examScore != Integer.parseInt(b[3]) || sin != 1) {
                                        sco.dailyScore = 0;
                                        sco.decide_course(date.course);
                                        date.score.add(sco);
                                        findanexit = getFindanexit(findanexit, gra_gra, date, b);
                                    }
                                    break;
                                }
                            } else println1(date, b, sco);
                        }
                    }
                    if (length == 5) {
                        if (!a.matches(five)) {
                            System.out.println("wrong format");
                        }
                        else{
                            u=0;
                            int []s=new int [9];
                            s[0]= Integer.parseInt(b[3]);
                            s[1]= Integer.parseInt(b[4]);
                            Score sco = new Score(b[0],b[1],b[2],s);
                            Student stu = new Student(b[0], b[1]);
                            date.student.add(stu);
                            date.grades.add(new grade(gra_gra.get_gradenumber(b[0])));
                            for(Course e: date.course){
                                if(e.name.equals(b[2])&&e.mark==2)
                                    sin=2;
                                if(e.name.equals(b[2]))
                                {
                                    sco.get_weight(e.weight);
                                    sco.get_size(e.size);
                                }
                            }
                            if (sco.HaveThisCourse(b[2], date.course) && sco.NumberMatchMode(b[2], date.course) && a.matches(five)&&sin==2)//判断数据是否合法
                            {
                                if (cont == 0) {
                                    sco.decide_course(date.course);
                                    date.score.add(sco);
                                    cont++;
                                }
                                for (Score e : date.score) {
                                    if (e.number.equals(b[0]) && e.name.equals(b[1]) && e.course.name.equals(b[2]) && e.dailyScore == Integer.parseInt(b[3]) && e.examScore == Integer.parseInt(b[4])) {
                                        u=1;
                                    }
                                } if(u == 0 && sco.HaveThisCourse(b[2], date.course) && sco.NumberMatchMode(b[2], date.course) && a.matches(five)) {
                                date.score.add(sco);
                                findanexit = getFindanexit(findanexit, gra_gra, date, b);
                            }
                            } else {
                                println1(date, b, sco);
                            }
                        }
                    }
                }
                if ((length > 5||run==3)&&!b[2].equals("实验")&&!b[2].equals("考察")&&!b[2].equals("考试")) {
                    int []s = new int[9];
                    for(int i=0;i<9;i++)
                        s[i]=-1;
                    for(int i=0;i<length-3;i++)
                    {
                        s[i]=Integer. parseInt(b[i+3]);
                    }
                    Student stu = new Student(b[0], b[1]);
                    Score sco = new Score(b[0], b[1], b[2],s);
                    date.student.add(stu);
                    date.grades.add(new grade(gra_gra.get_gradenumber(b[0])));
                    sco.get_length(length);
                    for(Course e: date.course){
                        if(e.name.equals(b[2])&&e.mark==3)
                            sin=3;
                        if(e.name.equals(b[2]))
                        {
                            sco.get_weight(e.weight);
                            sco.get_size(e.size);
                        }
                    }
                    if (sco.HaveThisCourse(b[2], date.course) && sco.NumberMatchMode(b[2], date.course) && sco.IfRight()&&sin==3) {
                        sco.decide_course(date.course);
                        date.score.add(sco);
                        findanexit = getFindanexit(findanexit, gra_gra, date, b);
                        cont++;
                    }
                    else if (!sco.HaveThisCourse(b[2], date.course) && !sco.NumberMatchMode(b[2], date.course)&& sco.IfRight()) {
                        System.out.println(b[2] + " does not exist");
                    } else if (!sco.HaveThisCourse(b[2], date.course)) {
                        System.out.println(b[2] + " does not exist");
                    } else if (!sco.NumberMatchMode(b[2], date.course)&&sco.IfRight()) {
                        System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                    }
                    else if(!sco.IfRight()&&sco.HaveThisCourse(b[2], date.course))
                    {
                        System.out.println("wrong format");
                    }
                }
            }
        }
        for (Student e : date.student) {
            Student.getStudenttotol(e, date.score);
        }
        int flag;
        int flag1;
        String num = "000";
        Collections.sort(date.student);
        for (Student q : date.student) {
            flag = 0;
            if(!num.equals(q.number))
                flag = 1;
            num = q.number;
            if(flag == 1)
            {
                if (q.JudgeEmpty())
                    System.out.println(q.number + " " + q.name + " " + (int)q.student_score);
                else
                    System.out.println(q.number+" "+q.name+" "+"did not take any exams");
            }
        }
        date.Course_and_Score();
        Collections.sort(date.grades);
        Collections.sort(date.course);
        date.output();
        date.grade_score(date.score);
        String num1="000";
        for(grade e : date.grades){
            flag1=0;
            if(!num1.equals(e.gradenumber))
            {
                flag1=1;
                num1=e.gradenumber;
            }
            if(flag1==1)
            {
                if(e.size!=0)
                    System.out.println(e.gradenumber+" "+ e.grade_score);
            }
        }
    }
 
    public static void println1(Chosecoure date, String[] b, Score sco) {
        if (!sco.HaveThisCourse(b[2], date.course) && !sco.NumberMatchMode(b[2], date.course)) {
            System.out.println(b[2] + " does not exist");
        } else if (!sco.HaveThisCourse(b[2], date.course)) {
            System.out.println(b[2] + " does not exist");
        } else if (!sco.NumberMatchMode(b[2], date.course)) {
            System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
        }
    }
 
    public static int getFindanexit(int findanexit, grade gra_gra, Chosecoure date, String[] b) {
        for (grade m : date.grades) {
            if (m.gradenumber.equals(gra_gra.get_gradenumber(b[0]))) {
                findanexit = 1;
                break;
            } else
                findanexit = 0;
        }
        if (findanexit == 0)
            date.grades.add(new grade(gra_gra.get_gradenumber(b[0])));
        return findanexit;
    }
 
    public static void ifWeightRight(Chosecoure date, String[] b, int iq, Course c) {
        if (c.IfWeightEqual1()) {
            for (Course e : date.course) {
                if (e.name.equals(b[0])) {
                    iq = 1;
                    break;
                } else
                    iq = 0;
            }
            if (iq == 0)
                date.course.add(c);
        }
        else{
            System.out.println(b[0] + " : weight value error");
        }
    }
 
    public static void IfWeightRight(Chosecoure date, String[] b, int iq, int a, Course c) {
        if (c.IfMatch(a)) {
            ifWeightRight(date, b, iq, c);
        }
        else {
            System.out.println(b[0]+" : course type & access mode mismatch");
        }
    }
}
class Course implements Comparable<Course>{
    String name,nature,assessment;
    int size,course_score=0,course_dailyscore=0,course_finalscore=0,found=0,mark=0;
    float []weight;
    float am=0;
    Course(String name, String nature, String assessment, int size, float[] s)
    {
        this.assessment=assessment;
        this.nature=nature;
        this.name=name;
        this.size=size;
        this.weight=s;
    }
    boolean  IfMatch(int a)
    {
        return nature.equals("必修") && assessment.equals("考试") && a == 0 || nature.equals("实验") && assessment.equals("实验") && a == 1 || nature.equals("选修") && assessment.equals("考试") && a == 0 || nature.equals("选修") && assessment.equals("考察") && a == 0;
    }
    public int compareTo(Course o) {
 
        try {
            Comparator<Object> compator = Collator.getInstance(Locale.CHINA);
            if (compator.compare(this.name, o.name) < 0) {
                return -1;
            } else if (compator.compare(this.name, o.name) > 0) {
                return 1;
            }
        } catch (Exception ignored) {
        }
        return 0;
    }
    @Override
    public String toString() {
        return name;
    }
    void decide_mark(){
        if(nature.equals("必修")||assessment.equals("考试"))
            this.mark=2;
        if(assessment.equals("考察"))
            this.mark=1;
        if(assessment.equals("实验")&&nature.equals("实验"))
            this.mark=3;
    }
    boolean IfWeightEqual1(){
        for(int i=0;i<size;i++)
        {
            am+=weight[i];
        }
        return Math.abs(am - 1) < 0.0001;
    }
    boolean Right(){
        return size >= 4 && size <= 9;
    }
}
class Score{
    String number,name;
    Course course = new Course(null,null,null,0,null);
    int dailyScore,examScore,flag=-1,size=0,mark=0,length;
    int[] Grade;
    float [] weight=new float[9];
    void get_size(int size){
        this.size=size;
    }
    void get_weight(float[] weight){
        this.weight=weight;
    }
    void  get_length(int length){
        this.length=length;
    }
    Score(String number, String name , String coursename, int[] grade)
    {
        this.number=number;
        this.course.name=coursename;
        this.name=name;
        this.Grade=grade;
        for(int i=0;i<9;i++)
        {
            if(grade[i]==-1)
                this.Grade[i]=0;
        }
    }
    void decide_course(List<Course> course){
        course.forEach((e)->{
            if(e.name.equals(this.course.name))
            {
                this.course=e;
            }
        });
    }
    boolean IfRight(){
        if(size<4||size>9)
            return false;
        for(int i=0;i<9;i++)
        {
            if(Grade[i]<0||Grade[i]>100)
                return false;
        }
        return true;
    }
    int getFinalScore()
    {
        float am=0;
        if(course.assessment.equals("考察")&&course.nature.equals("选修"))
            return examScore;
        else if(course.nature.equals("必修")&&!course.assessment.equals("实验"))
        {
            return (int)(examScore*weight[0]+dailyScore*weight[1]);
        }
        else if(course.assessment.equals("考试")&&course.nature.equals("选修"))
        {
            return (int)(examScore*weight[0]+dailyScore*weight[1]);
        }
        else if(course.assessment.equals("实验") && course.nature.equals("实验")){
            for(int q=0;q<size;q++)
            {
                am+=Grade[q]*weight[q];
            }
            return (int)(am);
        }
        else
            return 0;
    }
    boolean HaveThisCourse(String name,List<Course> course){
        for (Course e : course) {
            if (name.equals(e.name)) {
                return true;
            }
        }
        return false;
    }
    boolean NumberMatchMode(String name,List<Course> course){
        boolean b = true;
        for (Course e : course) {
            if(e.name.equals(name)) {
                b = (!e.assessment.equals("考察") || flag != 1 || mark == 2) && (!e.assessment.equals("考试") || flag != 0 || mark == 1) && (!e.nature.equals("必修") || flag != 0 || mark == 1) && (!e.nature.equals("实验") || length - 3 == size);
                break;
            }
        }
        return b;
    }
}
class Chosecoure {
    List<Score> score = new ArrayList<>();
    List<Course> course = new ArrayList<>();
    List<Student> student = new ArrayList<>();
    List<grade> grades=new ArrayList<>();
    grade gardes=new grade(null);
    int m = 0;
    void Course_and_Score() {
        for (Course f : course) {
            m = 0;
            for (Score e : score) {
                if (e.course.name.equals(f.name)) {
                    f.course_score += e.getFinalScore();
                    f.course_dailyscore += e.dailyScore;
                    f.course_finalscore += e.examScore;
                    m++;
                }
            }
            if (m != 0) {
                f.course_score = f.course_score / m;
                f.course_finalscore = f.course_finalscore / m;
                f.course_dailyscore = f.course_dailyscore / m;
            } else {
                System.out.println(f.name + " has no grades yet");
                f.found=1;
            }
        }
    }
    void grade_score(List<Score> e)
    {
        grades.forEach((q)->{
            e.forEach((p)->{
                if(q.gradenumber.equals(gardes.get_gradenumber(p.number)))
                {
                    q.grade_score+=p.getFinalScore();
                    q.size++;
                }
            });
            if(q.size != 0)
                q.grade_score/=q.size;
            if(q.size==0)
                System.out.println(q.gradenumber+" has no grades yet");
        });
    }
 
    void output() {
        course.forEach((e) -> {
            {
                if ((e.assessment.equals("考试") || e.nature.equals("必修"))&&e.found==0)
                    System.out.println(e.name + " " + e.course_dailyscore + " " + e.course_finalscore + " " + e.course_score);
                if (e.assessment.equals("考察")&&e.found==0) {
                    System.out.println(e.name + " " + e.course_finalscore + " " + e.course_finalscore);
                }
                if(e.assessment.equals("实验")&&e.nature.equals("实验")&&e.found==0)
                {
                    System.out.println(e.name+ " " + e.course_score);
                }
            }
        });
    }
}
class Student implements Comparable<Student>{
    String number,name;
    float student_score = 0;
    int student_score_size=0;
    Student(String number,String name)
    {
        this.number=number;
        this.name=name;
    }
    boolean JudgeEmpty(){
        return student_score_size != 0;
    }
    static void getStudenttotol(Student student, List<Score> e){
        e.forEach((f)->{
            if(f.number.equals(student.number))
            {
                student.student_score +=f.getFinalScore();
                student.student_score_size++;
            }
        });
        if(student.student_score_size != 0)
            student.student_score = student.student_score / student.student_score_size;
    }
    public int compareTo(Student o) {
        return this.number.compareTo(o.number);
    }
    public String toString() {
        return number;
    }
}
class grade implements Comparable<grade>{
    String gradenumber;
    grade(String gradenumber){
        this.gradenumber=gradenumber;
    }
    int grade_score = 0,size=0;
    String get_gradenumber(String number){
        this.gradenumber=number.substring(0,6);
        return gradenumber;
    }
    public int compareTo(grade o) {
        return this.gradenumber.compareTo(o.gradenumber);
    }
    public String toString() {
        return gradenumber;
    }
}

 

踩坑心得：1、在知道题目要求里有对代码长度的限制的时候千万不能在最后一刻才把自己的答案上传进行测评，不然会造成以为自己已经写完了结果却根本没办法把答案上传到情况。结果就是得要重新写过，无论是类的种类还是类的里面的方法和方法的引用全都要重新考虑。这样很锻炼人的心态。根据我的惨痛经历。不能够为课程还有选课类加上他们各自的父类。这样会造成代码长度过长。因为假如我想要引用一个学生的选课信息里面的课程名称。我首先要有一个选课类的父类。在这个负里面。找到那个学生的选课信息，然后再根据这个选课信息找到这个课程，再根据这个课程找到里面的课程名称。光是写着就有一长串了，引用的时候碰上两者对比，比如进行排序的时候，一行代码会非常非常长，超出限制。为了避免这种情况，精简类与类之间的关系必不可少。

总结：学这门课，我有一点迷茫，因为我时常觉得我在自学，如果要用练习检验我课上学到的东西，那么是否也应该告诉我题目的解决方法。 老师课上给我们讲的是例题。我们回去写 PTA 的题目集是作业，诚然，我们就是要根据例题进行学习，然后去写作业，在写作业的期间，老师不应该告诉我们答案，但是当题目集截止日期过了的时候，老师为什么不告诉我们题目的答案？我觉得会影响我们自主思考不是理由，拿高中学数学为例。答案的解法叫做标准答案，但是我们学生总是能给出各种不一样的解法。我们不会因为老师给了我们标准答案，就完全不考虑其他解法。我们只是根据标准答案去感受一道题它基本的答题模板应该是怎样的。只有一道题的答题模板是不够的。因为题目总是多样的，在我们还不熟悉解法的时候，很难把其他的题目都完全的跟例题进行比对，至少对我来说举一反三实在是太难了。在看到学生答题情况很糟糕的时候。不就说明学生对这道题无从下手吗？这时候老师不应该对题目进行一番讲解吗？特别是像我们的p ta题目集，总是进行题目的迭代。然后时间呢，也给的很少，也就是一旦一次题目没有完成后面就很难再进行下去。老师总以为我们不写，但有没有可能只是我们在开发集成环境上不断的去改答案。我个人习惯是答案完全写好以后，再放到p ta上进行测评，如果我写不出来，我是不会放到PTA上的。如果这样，就说我们懒，不学习，老师看问题也太片面了。问题还是在于，老师根本不告诉我们一道难题该怎么去写，我反正是从自己的错题里面找到经验，例题对我来说太没用了。听说别的班会进行答案的讲解，他们老师还会提醒一道题目的难点，这个难点是指数据要用 float 不能用 int 这种，老师期望我们能够在平台上进行讨论，然后发现，但关键是大佬他可不觉得这是问题，而菜鸟却始终不明白问题出在哪，菜鸟也不好意思上去问，大佬也懒得回答。诚然，老师想培养具有团队合作意识，能自主找到问题的理想状态的大学生，但是也请考虑一下，所有人的性格都是不一样的，每个人都变成一种标版是不可能的。强迫我们进行团队合作，这种事情在我们心情愉快且活动不是很紧急的时候才有效果。 像写p ta题目集这样的时间非常短很紧急的时候，没有人有闲心去聊天讨论难道我写不来的时候我不想问一下那些经常拿一百分的人吗？但事实上是他们很忙。忙到他们没有空理我们。 请老师也稍微考虑一下实际情况，我们不可能强迫别人帮我们。学习的过程中，老师才是我们的指导者。老师才有义务为我们提供教育。如果老师都不教的话，又凭什么要求同学教我们呢？物以类聚，人以群分。学习好的跟学习好的才会玩在一起，学习差的跟学习差的抱团。那这样的情况下，学习差的永远都不能够与上层的人接触。对老师来说，这些题目都太简单了，简单到怎么能够区分出学习好跟学习差的呢？ 但就结果而言，就是区分出了学习好的跟学习差的。再加上老师又经常性地提醒，威胁我们要查重，发现抄袭，并且抄袭的双方都将会取消考试资格。在这样的情况下，你让大家怎么放下心来互相交流？面对同学的那种遮遮掩掩的态度，我常常就懒得问他们了。反正我学的很痛苦，而且觉得这很不正常。我觉得老师应该是要教我们怎么写题目的。当然，如果老师觉得我在放屁呢，我就在放屁。

大体上，我们的教学是实现了课程的要求的。课程理念，通俗地讲，就是让我们有能力去根据要求写代码。教学方法，边讲边练，老师边想边说边写代码，我们边看边听边想代码，没有问题。线上线下的教学混合没看出来。线下教学，有 ，就是上课，线上教学如果指的是让我们自己做p ta，我觉得不算，这简直就是把题目扔出来，放养我们。P ta题目集应该是很好的，毕竟是我们老师自己写题目，这样让我们上网不能找到答案，在写的过程中，我们一定是努力自己思考的， 绝对有思维的锻炼。题目集还有迭代这样比较具有特色的题目，很像是我们接下来步入社会工作的模式，根据甲方的要求，不断改进自己的程序。具有前瞻锻炼的本质，可以说一切都很好。教学模式的话，我们没有前测，当然我也觉得这没有必要。上一次课堂翻转的时候，我作为写教案的人可以清楚的知道我们有导入这个环节，只是大多数时候都忽略了，作为课堂的主体而已。课程理念里有要有明确的目标。这里跳过不讲。总结就是，我现在正在写的 blog。参与式学习，我觉得如果课堂上老师例题讲解时的思考算是，可以说不足。毕竟上课的时候很难一直做到专注，特别是这学期。我们的课总是排在离散数学之后。离散数学老师要求很严，上课要求我们要一直看着黑板，绝对不能够低头，被他抓到了，就要被他说一通。上课的时候可以说是非常耗精神。第二节课的Java自然就更难专注了，但这个是可以改进的。量提上去就可以了。正好就是加上讲解课后习题，新题被老师带着走，跟一道题自己写过之后再被老师带着是完全不一样的。毫无疑问，后者让人更加专注，这才是参与式学习。因为用心了。但是整个过程缺乏了一件事情，叫改正。总结，不是改正，我一直都在总结，却从来没有改正过。题目错了就是错了，不会就是不会，一直放在那里。