BOLG-3

import java.text.Collator;
import java.util.*;
public class Main {
    static Scanner scanner = new Scanner(System.in);
    static SortedMap<String, Course> courses = new TreeMap<>(Comparator.comparing(String::toString, Collator.getInstance(Locale.CHINESE)));
    static Map<String, Student> students = new HashMap<>();
    static Map<String, Class> classes = new HashMap<>();

    static Map<String,Set<String>> studentCourse = new HashMap<>();

    public static void main(String[] args) {
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) break;
            String[] inputs = input.split(" ");
            if (inputs.length == 2 || inputs.length == 3) {
                addCourse(inputs);
            } else if (inputs.length == 4 || inputs.length == 5) {
                addGrade(inputs);
            } else {
                System.out.println("wrong format");
            }
        }
        printStudentAvg();
        printCourseAvg();
        printClassAvg();
    }

    private static void addCourse(String[] inputs) {
        String name = inputs[0];
        String type = inputs[1];
        String mode = inputs.length == 3 ? inputs[2] : "";
        if (courses.containsKey(name)) return;
        if (type.equals("必修") && !mode.equals("考试")) {
            System.out.println(name + " : course type & access mode mismatch");
            return;
        }
        courses.put(name, new Course(name, type, mode));
    }

    private static void addGrade(String[] inputs) {
        String id = inputs[0];
        String name = inputs[1];
        String courseName = inputs[2];

        int regularGrade = -1;
        int finalGrade;
        if (!courses.containsKey(courseName)) {
            System.out.println(courseName + " does not exist");
            students.put(id, new Student(id, name));
            return;
        }
        Course course = courses.get(courseName);
        int bool = 0;
        if (course.mode.equals("考试") && inputs.length != 5) {
            System.out.println(id + " " + name + " : access mode mismatch");
            bool = 1;
        }
        if (course.mode.equals("考察") && inputs.length != 4) {
            System.out.println(id + " " + name + " : access mode mismatch");
            bool = 1;
        }


        Set<String> courseSet = studentCourse.get(name);
        if(courseSet == null) {
            Set<String> courseCount = new HashSet<>();
            courseCount.add(courseName);
            studentCourse.put(name, courseCount);
        } else {
            if(courseSet.contains(courseName)) {
                return;
            } else {
                courseSet.add(courseName);
                studentCourse.put(name, courseSet);
            }
        }

        if(bool ==1) {
            students.put(id, new Student(id, name));
            return;
        }
        if (course.mode.equals("考试")) {
            regularGrade = Integer.parseInt(inputs[3]);
            finalGrade = Integer.parseInt(inputs[4]);
            if (regularGrade < 0 || regularGrade > 100 || finalGrade < 0 || finalGrade > 100) {
                System.out.println("wrong format");
                return;
            }
        } else {
            finalGrade = Integer.parseInt(inputs[3]);
            if (finalGrade < 0 || finalGrade > 100) {
                System.out.println("wrong format");
                return;
            }
        }

        if (!students.containsKey(id)) students.put(id, new Student(id, name));
        Student student = students.get(id);
        student.addGrade(courseName, regularGrade, finalGrade);
    }

    private static void printStudentAvg() {
        List<Student> studentList = new ArrayList<>(students.values());
        studentList.sort(Comparator.comparing(o -> o.id));
        for (Student student : studentList) {
            System.out.print(student.id + " " + student.name + " ");
            if (student.grades.size() == 0) {
                System.out.println("did not take any exams");
                continue;
            }
            int sum = 0;
            for (Map.Entry<String, Grade> entry : student.grades.entrySet()) {
                Grade grade = entry.getValue();
                sum += grade.totalGrade;
            }
            System.out.println(sum / student.grades.size());
        }
    }

    private static void printCourseAvg() {
        List<Course> courseList = new ArrayList<>(courses.values());
        for (Course course : courseList) {
            System.out.print(course.name + " ");
            int regularSum = 0;
            int finalSum = 0;
            int totalSum = 0;
            int count = 0;
            for (Student student : students.values()) {
                if (!student.grades.containsKey(course.name)) continue;
                Grade grade = student.grades.get(course.name);
                regularSum += grade.regularGrade;
                finalSum += grade.finalGrade;
                totalSum += grade.totalGrade;
                count++;
            }
            if (count == 0) {
                System.out.println("has no grades yet");
                continue;
            }
            if (course.mode.equals("考试")) System.out.print(regularSum / count + " ");
            System.out.println(finalSum / count + " " + totalSum / count);
        }
    }

    private static void printClassAvg() {
        for (Student student : students.values()) {
            String classId = student.id.substring(0, 6);
            if (!classes.containsKey(classId)) classes.put(classId, new Class(classId));
            Class aClass = classes.get(classId);
                for (Map.Entry<String, Grade> entry : student.grades.entrySet()) {
                    Grade grade = entry.getValue();
                    aClass.addGrade(grade.totalGrade);
            }
        }
        List<Class> classList = new ArrayList<>(classes.values());
        classList.sort(Comparator.comparing(o -> o.id));
        for (Class aClass : classList) {
            System.out.print(aClass.id + " ");
            if (aClass.grades.size() == 0) {
                System.out.println("has no grades yet");
                continue;
            }
            int sum = 0;
            for (Integer grade : aClass.grades) {
                sum += grade;
            }
            System.out.println(sum / getStudentSumByClassId(aClass.id));
        }
    }

    public static int getStudentSumByClassId(String classId) {
        int result = 0;
        for(Student student : students.values()) {
            String classIdTemp = student.id.substring(0, 6);
            if(classIdTemp.equals(classId)) {
                result+=student.grades.size()==0?1:student.grades.size();
            }
        }
        return result;
    }



    static class Course {
        String name;
        String type;
        String mode;

        public Course(String name, String type, String mode) {
            this.name = name;
            this.type = type;
            this.mode = mode;
        }
    }

    static class Student {
        String id;
        String name;
        Map<String, Grade> grades;

        public Student(String id, String name) {
            this.id = id;
            this.name = name;
            grades = new HashMap<>();
        }

        public void addGrade(String courseName, int regularGrade, int finalGrade) {
            if (grades.containsKey(courseName)) return;
            Course course = courses.get(courseName);
            int totalGrade;
            if (course.mode.equals("考试")) {
                totalGrade = (int) (regularGrade * 0.3 + finalGrade * 0.7);
            } else {
                totalGrade = finalGrade;
            }
            grades.put(courseName, new Grade(regularGrade, finalGrade, totalGrade));
        }
    }

    static class Grade {
        int regularGrade;
        int finalGrade;
        int totalGrade;

        public Grade(int regularGrade, int finalGrade, int totalGrade) {
            this.regularGrade = regularGrade;
            this.finalGrade = finalGrade;
            this.totalGrade = totalGrade;
        }
    }

    static class Class {
        String id;
        List<Integer> grades;

        public Class(String id) {
            this.id = id;
            grades = new ArrayList<>();
        }

        public void addGrade(int grade) {
            grades.add(grade);
        }
    }
}

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Locale;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String tip = s.nextLine();
        systemin pi=new systemin();
        while (!tip.equals("end")) {
            pi.systemin(tip);
            tip = s.nextLine();
        }
        pi.Sort();
        pi.getnum();
        pi.getcourse();
        pi.getclass();
    }
}

abstract class gd{
    double Totalgd;
    public int getTotalgd() {
        return (int) Totalgd;
    }
    public int getUsualgd() {
        return 0;
    }
    public int getFinalgd() {
        return 0;
    }
}

class Examgd extends gd{
    int Usualgd;
    int Finalgd;
    public int getTotalgd(){
        return (int)(0.3*this.getUsualgd()+0.7*this.getFinalgd());
    }
    public int getUsualgd() {
        return Usualgd;
    }
    public void setUsualgd(int usualgd) {
        Usualgd = usualgd;
    }
    public int getFinalgd() {
        return Finalgd;
    }
    public void setFinalgd(int finalgd) {
        Finalgd = finalgd;
    }
}


class NoExamgd extends gd{
    int Finalgd;
    public int getTotalgd(){
        return Finalgd;
    }
    public int getFinalgd() {
        return Finalgd;
    }
    public void setFinalgd(int finalgd) {
        Finalgd = finalgd;
    }
}


class Course{
    String name;
    String kind;
    String method;

    public Course(String name, String kind, String method) {
        this.name = name;
        this.kind = kind;
        this.method = method;
    }
    public String getName() {
        return name;
    }
    public String getMethod() {
        return method;
    }
}

class Student{
    String num;
    String name;
    public Student(String num, String name) {
        this.num = num;
        this.name = name;
    }
    public String getNum() {
        return num;
    }
    public String getName() {
        return name;
    }
}


class SelectCourse{
    Course course;
    Student student;
    gd gd;
    public Course getCourse() {
        return course;
    }
    public void setCourse(Course course) {
        this.course = course;
    }
    public Student getStudent() {
        return student;
    }
    public void setStudent(Student student) {
        this.student = student;
    }
    public gd getgd() {
        return gd;
    }
    public void setgd(gd gd) {
        this.gd = gd;
    }
}

class systemin{
    private final ArrayList<SelectCourse> selectCourses = new ArrayList<>();
    private final ArrayList<Course> courses = new ArrayList<>();
    private final ArrayList<Student> students = new ArrayList<>();
    private final ArrayList<String> Class = new ArrayList<>();
    private final HashMap<String,String> cm=new HashMap();
    public void systemin(String input){
        String []inputs=input.split(" ");
        if(Imatch.minput(input)==1){
            cm.put(inputs[0],inputs[2]);
            if(checkC(inputs[0])!=null)return;
            else {
                if(inputs[1].equals("必修")&&(!inputs[2].equals("考试"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else if(inputs[1].equals("选修")&&!(inputs[2].equals("考试")||inputs[2].equals("考察"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else if(inputs[1].equals("实验")&&!(inputs[2].equals("实验"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else courses.add(new Course(inputs[0],inputs[1],inputs[2]));
            }
        }
        else if(Imatch.minput(input)==2){
            Course findcourse=checkC(inputs[2]);
            if(inputs.length>5&&(Integer.parseInt(inputs[3])<4||Integer.parseInt(inputs[3])>9)) {
                System.out.println("wrong format");
                return;
            }
            Student newStudent = new Student(inputs[0],inputs[1]);
            if(!checkStudent(newStudent.getNum()))students.add(newStudent);
            if(!checkClass(inputs[0].substring(0,6))){
                Class.add(inputs[0].substring(0,6));
            }
            if(cs(inputs[0],inputs[2]))return;
            if(findcourse==null){

                System.out.println(inputs[2]+" does not exist");
                return;
            }
            else if(findcourse.getMethod().equals("考试")&&inputs.length!=5){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else if(findcourse.getMethod().equals("考察")&&inputs.length!=4){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else if(findcourse.getMethod().equals("实验")&&(inputs.length-4!=Integer.parseInt(inputs[3]))){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else{
                SelectCourse newSelectCourse=new SelectCourse();
                newSelectCourse.setCourse(findcourse);
                gd gd=null;
                if(findcourse.getMethod().equals("考试")){
                    Examgd examgd=new Examgd();
                    examgd.setUsualgd(Integer.parseInt(inputs[3]));
                    examgd.setFinalgd(Integer.parseInt(inputs[4]));
                    gd=examgd;
                }
                else if(findcourse.getMethod().equals("实验")){
                    NoExamgd noExamgd=new NoExamgd();
                    double sumScore=0;
                    for (int i=4;i<inputs.length;i++)sumScore+=Integer.parseInt(inputs[i]);
                    noExamgd.setFinalgd((int)(sumScore/Integer.parseInt(inputs[3])));
                    gd=noExamgd;
                }
                else {
                    NoExamgd noExamgd=new NoExamgd();
                    noExamgd.setFinalgd(Integer.parseInt(inputs[3]));
                    gd=noExamgd;
                }
                newSelectCourse.setgd(gd);
                newSelectCourse.setStudent(newStudent);
                selectCourses.add(newSelectCourse);
            }
        }
        else System.out.println("wrong format");
    }

    private Course checkC(String courseName){
        for (Course course:courses){
            if(course.getName().equals(courseName))return course;
        }
        return null;
    }
    
    private Boolean checkStudent(String num){
        for (Student student:students){
            if(student.getNum().equals(num))return true;
        }
        return false;
    }
    private Boolean checkClass(String classnum){
        for (String cname:Class){
            if(cname.equals(classnum))return true;
        }
        return false;
    }

    private Boolean cs(String stunum,String cname){
        for (SelectCourse selectCourse:selectCourses){
            if(selectCourse.getStudent().getNum().equals(stunum)&&selectCourse.getCourse().getName().equals(cname))return true;
        }
        return false;
    }

    public void getnum(){

        for (Student student:students){
            double sum=0;
            int count=0;
            for (SelectCourse selectCourse:selectCourses){
                if (selectCourse.getStudent().getNum().equals(student.getNum()))
                {
                    sum+=selectCourse.getgd().getTotalgd();
                    count++;
                }
            }
            if(count==0) System.out.println(student.getNum()+' '+student.getName()+' '+"did not take any exams");
            else System.out.println(student.getNum()+' '+student.getName()+' '+(int)(sum/count));
        }
    }
    public void getcourse(){
        for (Course course:courses){
            double sumUsualScore=0;
            double sumFinalScore=0;
            double sumTotalScore=0;
            int count=0;
            for(SelectCourse selectCourse:selectCourses){
                if(selectCourse.getCourse().getName().equals(course.getName())){
                    count++;
                    sumTotalScore+=selectCourse.getgd().getTotalgd();
                    sumFinalScore+=selectCourse.getgd().getFinalgd();
                    if(selectCourse.getCourse().getMethod().equals("考试")){
                        sumUsualScore+=selectCourse.getgd().getUsualgd();
                    }
                }
            }
            if (count==0) System.out.println(course.getName()+' '+"has no grades yet");
            else if(course.getMethod().equals("考试"))System.out.println(course.getName()+' '+(int)(sumUsualScore/count)+' '+(int)(sumFinalScore/count)+' '+(int)(sumTotalScore/count));
            else if(course.getMethod().equals("考察"))System.out.println(course.getName()+' '+(int)(sumFinalScore/count)+' '+(int)(sumTotalScore/count));
            else if(course.getMethod().equals("实验"))System.out.println(course.getName()+' '+(int)(sumFinalScore/count));
        }
    }
    public void getclass(){
        for (String classnum:Class){
            double sum=0;
            int count=0;
            for (SelectCourse selectCourse:selectCourses){
                if(selectCourse.getStudent().getNum().substring(0,6).equals(classnum)){
                    sum+=selectCourse.getgd().getTotalgd();
                    count++;
                }
            }
            if(count==0) System.out.println(classnum+' '+"has no grades yet");
            else System.out.println(classnum+' '+(int)(sum/count));
        }
    }
    public void Sort(){
        students.sort(Comparator.comparing(Student::getNum));
        courses.sort((x,y)->{
            Collator instance = Collator.getInstance(Locale.CHINA);
            return instance.compare(x.getName(), y.getName());
        } );
        Collections.sort(Class);
    }
}

class Imatch {
    static String stuNumMatching = "[0-9]{8}";
    static String stuNameMatching = "\\S{1,10}";
    static String scoreMatching = "(\\d|[1-9]\\d|100)";
    static String courseNameMatching = "\\S{1,10}";
    static String courseTypeMatching = "(选修|必修|实验)";
    static String  checkcourseTypeMatching = "(考试|考察|实验)";
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + "(\\s"+scoreMatching+")*";
    public static int minput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(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);
    }

}

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {

    public static Scanner sc = new Scanner(System.in);
    // 课程性质
    public static String[] natures = {"必修","选修","实验"};
    // 考核方式
    public static String[] assessmentMethods = {"考试","考察","实验"};

    // 保存课程信息
    public static Map<String,Course> courseMap = new HashMap<>();

    //保存班级信息
    public static Map<String,Class> classMap = new HashMap<>();

    //保存学生信息
    public static Map<String,Student> studentMap = new HashMap<>();

    public static List<String> errorMsg = new ArrayList<>();

    public static void main(String[] args) {
        while (sc.hasNextLine()){
            String input = sc.nextLine();
            if (input.isEmpty() || "end".equals(input)) {
                break;
            }
            try {
                inputProcessor(input);
            } catch (Exception e) {
                errorMsg.add(e.getMessage());
            }
        }
        //计算分数
        calculateScore();
    }

    /**
     * 计算分数
     */
    private static void calculateScore() {

        // 先计算所有学生的成绩
        List<Student> values = new ArrayList<>(studentMap.values());
        ervey(values);
        //打印所有学生成绩信息
        values.stream()
                .filter(student -> student.getCourseGrades().getTotalGrade() >= 0 && courseMap.containsKey(student.getCourseGrades().getCourseName())).sorted(Comparator.comparing(Student::getStudentId))
                .forEach(student -> System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+student.getCourseGrades().getTotalGrade()));

        //打印单门课程名称成绩
        Object[] array = courseMap.keySet().toArray();
        Arrays.sort(array);
        List<Object> strings =  new ArrayList<>();
        for (Object s : array) {
            List<Student> stus = values.stream().filter(student -> student.getCourseGrades().getCourseName().equals(s) && student.getCourseGrades().getTotalGrade() >= 0).collect(Collectors.toList());
            if (stus.size() == 0){
                strings.add(s);
                continue;
            }
            int i = (stus.stream().map(Student::getCourseGrades).mapToInt(CourseGrades::getTotalGrade).sum() / stus.size());
            System.out.println(s+" "+i);
        }


        //打印所有班级的成绩
        for (Class value : classMap.values()) {
            List<Student> studentList = value.getStudentMap().values().stream()
                    .filter(student -> student.getCourseGrades().getTotalGrade() >= 0).collect(Collectors.toList());
            if (studentList.size() == 0){
                continue;
            }
            int i = (studentList.stream().map(Student::getCourseGrades).mapToInt(CourseGrades::getTotalGrade).sum() / studentList.size());
            value.setScore(i);
        }
        classMap.values().stream().filter(aClass -> aClass.getScore() != null && aClass.getScore() >= 0).sorted(Comparator.comparing(Class::getClassId)).forEach(aClass -> System.out.println(aClass.getClassId()+" "+aClass.getScore()));


        printError(values, strings);


    }

    private static void printError(List<Student> values, List<Object> strings) {
        errorMsg.forEach(System.out::println);
        //打印错误信息
        values.stream()
                .filter(student -> student.getCourseGrades().getTotalGrade() < 0)
                .sorted(Comparator.comparing(Student::getStudentId))
                .forEach(student -> {
                    if (student.getCourseGrades().getTotalGrade() == -2){
                        System.out.println("wrong format");
                    }else if(student.getCourseGrades().getTotalGrade() == -1){
                        System.out.println(student.getStudentId()+" "+student.getStudentName()+" : access mode mismatch");
                        System.out.println(student.getStudentId()+" "+student.getStudentName()+" did not take any exams");
                    }else if (student.getCourseGrades().getTotalGrade() == -3){
                        System.out.println(student.getStudentId()+" "+ student.getStudentName()+" :"+student.getCourseGrades().getCourseName()+" does not exist");
                    }
                });

        strings.stream().sorted().forEach(s -> System.out.println(s+" has no grades yet"));
        classMap.values().stream().filter(aClass -> aClass.getScore() == null || aClass.getScore() < 0 ).sorted(Comparator.comparing(Class::getClassId)).forEach(aClass -> System.out.println(aClass.getClassId()+" has no grades yet"));
    }

    //计算每个学生的成绩
    private static void ervey(List<Student> students) {
        for (Student student : students) {
            CourseGrades courseGrades = student.getCourseGrades();
            if (!courseMap.containsKey(courseGrades.getCourseName())) {
                courseGrades.setTotalGrade(-3);
                continue;
            }
            try {
                if (courseGrades.getGrades().size() == 0){
                    continue;
                }
                double sum = 0;
                for (Grade grade : courseGrades.getGrades()) {
                    if (grade.getScore() < 0 || grade.getScore() > 100) {
                        throw new Exception("-2");
                    }else {
                        sum += grade.getScore() * grade.getWeight();
                    }
                }
                courseGrades.setTotalGrade((int) sum);
                courseGrades.setTotalGradeD(sum);
            } catch (Exception e) {
                if ("-2".equals(e.getMessage())) {
                    courseGrades.setTotalGrade(-2);
                }
            }
        }
    }


    /**
     * 输入处理器
     * @param input
     * @throws Exception
     */
    public static void inputProcessor(String input) throws Exception {
        // 判断输入的课程信息还是学生信息
        String[] parts = input.split(" ");
        if (parts.length < 3){
            throw new Exception("wrong format");
        }
        // 课程性质 和 考核方式 输入是否正确，如果都符合则是课程信息
        if (Arrays.asList(natures).contains(parts[1]) || Arrays.asList(assessmentMethods).contains(parts[2])){
            curriculumProcessor(parts);
        }else { // 否则是成绩信息
            gradeProcessor(parts);
        }
    }

    /**
     * 课程处理器
     * @param parts
     * @throws Exception
     */
    public static void curriculumProcessor(String[] parts) throws Exception {
        if (parts.length < 3){
            throw new Exception("wrong format");
        }
        // 课程名称
        String courseName = parts[0];
        // 课程性质
        String nature = parts[1];
        // 考核方式
        String assessmentMethod = parts[2];

        // 判断是否已有课程,有的话什么也不干
        if (courseMap.containsKey(courseName)){
            return;
        }

        // 判断输入的课程信息是否匹配
        if (courseName.length() > 10) {
            throw new Exception("wrong format");
        }
        isValidNatureAndAssessment(courseName, nature, assessmentMethod);

        Course course;
        if (parts.length == 3){ // 说明是考查课：课程名称+英文空格+课程性质+英文空格+考核方式
            // 保存课程
            course = new Course(courseName,nature,assessmentMethod,new double[]{1});
        }else if (parts.length == 5){ // 说明是考试：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
            // 获取权重
            double[] weights = {Double.parseDouble(parts[3]), Double.parseDouble(parts[4])};
            // 判断权重值
            determineWeightValue(courseName,weights);
            // 保存课程
            course = new Course(courseName,nature,assessmentMethod,weights);
        }else { // 说明实验课：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
            // ==============下面检验实验课数据是否正常==================
            int n = Integer.parseInt(parts[3]);
            if (n < 4 || n > 9){ // 实验次数小于 4 次大于 9 次
                // throw new Exception("wrong format");
                errorMsg.add("wrong format");
            }
            if (n != parts.length - 4){ // 输入的分项成绩数量值和分项成绩权重的个数不匹配
                throw new Exception(courseName + " : number of scores does not match");
            }
            // 判断权重之和是否为 1,先把权重取出来
            double[] weights = new double[n];
            for (int i = 4; i < parts.length; i++) {
                weights[i-4] = Double.parseDouble(parts[i]);
            }
            // 判断权重值
            determineWeightValue(courseName, weights);
            // ==================== 检测完成 =========================
            // 保存课程
            course = new Course(courseName,nature,assessmentMethod,weights);
        }
        courseMap.put(courseName,course);

    }


    /**
     * 分数处理器
     * @param parts
     */
    private static void gradeProcessor(String[] parts) throws Exception {
        String studentId = parts[0];
        String studentName = parts[1];
        String courseName = parts[2];

        if (studentMap.containsKey(studentId)) {
            return;
        }

        // 姓名格式是否正确
        if (studentName.length() > 10) {
            throw new Exception("wrong format");
        }
        // 判断学号是否为8位数字
        if (!isNumber(studentId)){
            throw new Exception("wrong format");
        }
        //班级 id
        String classId = studentId.substring(0,6);

        // 保存班级信息
        Class aClass;
        if (classMap.containsKey(classId)) {
            aClass = classMap.get(classId);
        }else {
            aClass = new Class(classId);
            classMap.put(classId, aClass);
        }
        // 获取此课程的权重
        double[] weights;
        if (courseMap.containsKey(courseName)) { // 如果有此课程
            weights = courseMap.get(courseName).getWeights();
        }else {
            weights = new double[]{};
        }
        // 保存用户信息
        CourseGrades courseGrades = new CourseGrades(courseName, Grade.getGrades(weights, parts));
        Student student = new Student(studentId, studentName, courseGrades);
        aClass.addStudent(student);
        studentMap.put(studentId,student);
        classMap.put(classId,aClass);
    }
    /**
     * 判断字符串是否是数字
     * @param string
     * @return
     */
    public static boolean isNumber(String string) {
        if (string == null)
            return false;
        Pattern pattern = Pattern.compile("^\\d{8}$");
        return pattern.matcher(string).matches();
    }
    /**
     * 判断权重值是否为 1
     * @param courseName 课程名称
     * @param weights 权重数组
     * @throws Exception
     */
    private static void determineWeightValue(String courseName, double[] weights) throws Exception {
        if (Arrays.stream(weights).sum() != 1){ // 判断权重和是否为 1
            throw new Exception(courseName + " : weight value error");
        }
    }
    /**
     * 输入的课程性质和课程的考核方式是否匹配（必修必须考试）
     * @param nature 课程性质
     * @param assessmentMethod 考核方式
     */
    private static void isValidNatureAndAssessment(String courseName,String nature, String assessmentMethod) throws Exception {
        if (!(Arrays.asList(natures).contains(nature) && Arrays.asList(assessmentMethods).contains(assessmentMethod))){
            throw new Exception("wrong format");
        }
        if (natures[0].equals(nature) && !assessmentMethods[0].equals(assessmentMethod)) {
            throw new Exception(courseName + " : course type & access mode mismatch");
        }
        if (natures[1].equals(nature) && !(assessmentMethods[0].equals(assessmentMethod) || assessmentMethods[1].equals(assessmentMethod))){
            throw new Exception(courseName + " : course type & access mode mismatch");
        }
        if (natures[2].equals(nature) && !assessmentMethods[2].equals(assessmentMethod)) {
            throw new Exception(courseName + " : course type & access mode mismatch");
        }

    }
}






















// 课程成绩类
class CourseGrades{
    private Integer totalGrade = -1;

    private Double totalGradeD = -1.0;

    private String courseName;

    private List<Grade> grades;

    public CourseGrades(String courseName, List<Grade> grades) {
        this.courseName = courseName;
        this.grades = grades;
    }

    public Double getTotalGradeD() {
        return totalGradeD;
    }

    public void setTotalGradeD(Double totalGradeD) {
        this.totalGradeD = totalGradeD;
    }

    public Integer getTotalGrade() {
        return totalGrade;
    }

    public void setTotalGrade(Integer totalGrade) {
        this.totalGrade = totalGrade;
    }

    public void setGrades(List<Grade> grades) {
        this.grades = grades;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public CourseGrades(List<Grade> grades) {
        this.grades = grades;
    }

    public List<Grade> getGrades() {
        return grades;
    }
    @Override
    public String toString() {
        return "CourseGrades{" +
                "totalGrade=" + totalGrade +
                ", courseName='" + courseName + '\'' +
                ", grades=" + grades +
                '}';
    }
}



// 分项成绩类
class Grade{
    //权重
    private Double weight;

    //分值
    private Double score;

    public Grade() {
    }

    public static List<Grade> getGrades(double[] weights, String[] parts) throws Exception {
        ArrayList<Grade> grades = new ArrayList<>();
        int max = Math.max(weights.length, parts.length - 3);
        for (int i = 0; i < max; i++) {
            Grade grade = new Grade();
            if (i < weights.length){
                grade.setWeight(weights[i]);
            }
            if (i + 3 < parts.length){
                grade.setScore(Double.parseDouble(parts[i+3]));
            }
            grades.add(grade);
        }
        return grades;
    }

    public Grade(Double weight, Double score) {
        this.weight = weight;
        this.score = score;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }
    
    @Override
    public String toString() {
        return "Grade{" +
                "weight=" + weight +
                ", score=" + score +
                '}';
    }
}





// 保存课程信息
class Course {
    // 课程名称
    private String courseName;
    // 课程类型
    private String courseType;
    // 考核方式
    private String assessmentMethod;
    // 权重
    private double[] weights;

    public Course(String courseName, String courseType, String assessmentMethod) {
        this.courseName = courseName;
        this.courseType = courseType;
        this.assessmentMethod = assessmentMethod;
    }

    public Course(String courseName, String courseType, String assessmentMethod, double[] weights) {
        this.courseName = courseName;
        this.courseType = courseType;
        this.assessmentMethod = assessmentMethod;
        this.weights = weights;
    }

    public Course() {
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCourseType() {
        return courseType;
    }

    public void setCourseType(String courseType) {
        this.courseType = courseType;
    }

    public String getAssessmentMethod() {
        return assessmentMethod;
    }

    public void setAssessmentMethod(String assessmentMethod) {
        this.assessmentMethod = assessmentMethod;
    }

    public double[] getWeights() {
        return weights;
    }

    public void setWeights(double[] weights) {
        this.weights = weights;
    }
}



//班级
class Class{
    private Integer score;
    private String classId;
    private Map<String,Student> studentMap = new HashMap<>();

    public Student getStudent(String stuId){
        return studentMap.get(stuId);
    }
    public void addStudent(Student student){
        studentMap.put(student.getStudentId(), student);
    }

    public Class(String classId) {
        this.classId = classId;
    }

    public String getClassId() {
        return classId;
    }

    public void setClassId(String classId) {
        this.classId = classId;
    }

    public Map<String, Student> getStudentMap() {
        return studentMap;
    }

    public void setStudentMap(Map<String, Student> studentMap) {
        this.studentMap = studentMap;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }
}




// 学生
class Student{
    private String studentId;
    private String studentName;
    private CourseGrades courseGrades;

    public Student(String studentId, String studentName, CourseGrades courseGrades) {
        this.studentId = studentId;
        this.studentName = studentName;
        this.courseGrades = courseGrades;
    }

    public CourseGrades getCourseGrades() {
        return courseGrades;
    }

    public void setCourseGrades(CourseGrades courseGrades) {
        this.courseGrades = courseGrades;
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    @Override
    public String toString() {
        return "Student{" +
                "studentId='" + studentId + '\'' +
                ", studentName='" + studentName + '\'' +
                ", courseGrades=" + courseGrades +
                '}';
    }
}