PTA6 7-1 课程成绩统计程序-1

题目：7-1 课程成绩统计程序-1

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃

参考类图：

 

import java.text.Collator;
import java.util.*;

public class Main {
    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.showStudents();
        handle.showCourses();
        handle.showClasses();
    }
}
class ParseInput{
    ArrayList<Student> listStudent=new ArrayList<>();
    ArrayList<Course> listCourse=new ArrayList<>();
    ArrayList<Class> listClass=new ArrayList<>();
    ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>();
    public void parseInput(String str){
        InputMatching mat=new InputMatching();
        int flag=mat.matchingInput(str);
        switch (flag){
            case 0:System.out.println("wrong format");
                    break;
            //课程信息
            case 1:courseMessage(str);
                    break;
            //成绩信息
            case 2:gradeMessage(str);
                    break;
        }
    }
    public void courseMessage(String str){

        String letters[]=str.split(" ");

        String courseName=letters[0];//课程名
        String type=letters[1];//课程类型
        String testType=letters[2];//课程考试类型

        Course course=new Course(courseName,type,testType);

        if(checkCourse(course)){
            if(searchCourse(courseName)==null)
                listCourse.add(course);
        }

    }
    public void gradeMessage(String str){
        String letters[]=str.split(" ");

        String stuId= letters[0];//学生学号
        String classID= letters[0].substring(0,6);
        String name=letters[1];//学生姓名
        String courseName=letters[2];//课程名字

        //如果该班级第一次出现
        if(searchClass(classID)==null){
            Class cla=new Class(classID);
            listClass.add(cla);
        }

        Student stu=new Student(classID,stuId,name);
        if(!searchStudent(stuId))
        listStudent.add(stu);//将学生加入列表中
        //课程是否存在
        if(searchCourse(courseName)==null){
            System.out.println(courseName+" "+"does not exist");
        }
        //当课程存在时
        else if(searchCourse(courseName)!=null){
            Course course=searchCourse(courseName);
            //考察
            if(letters.length==4&&course.testType.equals("考察")){
                int finalGrade= Integer.parseInt(letters[3]);
                AssessGrade assessGrade=new AssessGrade(finalGrade);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
                if(!searchChooseCourse(name,courseName))
                listChooseCourse.add(chooseCourse);
            }
            //考试
            else if(letters.length==5&&course.testType.equals("考试")){
                int usualGrade= Integer.parseInt(letters[3]);
                int finalGrade= Integer.parseInt(letters[4]);
                ExamGrade examGrade=new ExamGrade(usualGrade,finalGrade);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
                listChooseCourse.add(chooseCourse);
            }
            else{
                //学号+英文空格+姓名+英文空格+": access mode mismatch"
                System.out.println(stuId+" "+name+" "+": access mode mismatch");
            }
        }
    }

    public boolean checkCourse(Course course){
        int flag1,flag2;
        switch(course.getType()){
            case "必修":flag1=0;break;
            case "选修":flag1=1;break;
            default:flag1=-1;break;
        }
        switch(course.getTestType()){
            case "考试":flag2=0;break;
            case "考察":flag2=1;break;
            default:flag2=-1;break;
        }
        if(flag1==0&&flag2==0)
            return true;
        if(flag1==1&&(flag2==0||flag2==1))
            return true;
        System.out.println(course.getCourseName()+" : course type & access mode mismatch");
        return false;
    }
    public Class searchClass(String classId){
        for(Class cls:listClass){
            if(cls.getClassId().equals(classId))
                return cls;
        }
        return null;
    }
    public Course searchCourse(String name){
        for(Course course:listCourse){
            if(course.getCourseName().equals(name))
                return course;
        }
        return null;
    }
    public boolean searchStudent(String id){
        for(Student stu:listStudent){
            if(stu.getId().equals(id))
                return true;
        }
        return false;
    }
    //查找是否有重复选课成绩
    public boolean searchChooseCourse(String stuName,String courseName){
        for(ChooseCourse cs:listChooseCourse){
            if(cs.student.getStuName().equals(stuName)&&cs.course.getCourseName().equals(courseName))
                return true;
        }
        return false;
    }
    public void showStudents(){
        Collections.sort(listStudent);
        for(int i=0;i<listStudent.size();i++){
            Student stu=listStudent.get(i);
            //从总选课表listChooseCourse中获取该生的选课记录
            ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
            if(stuCourseSelects.size()!=0) {
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+"did not take any exams");
            }
        }
    }
    public void showCourses(){
        Collections.sort(listCourse);
        for(int i=0;i<listCourse.size();i++){
            Course course=listCourse.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
            if(stuCourseSelects.size()!=0){
                if(course.testType.equals("考试"))
                System.out.println(course.getCourseName()+" "+getAvgUsualScore(stuCourseSelects)+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
                if(course.testType.equals("考察"))
                System.out.println(course.getCourseName()+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(course.courseName+" "+"has no grades yet");
            }
        }
    }
    public void showClasses(){
        Collections.sort(listClass);
        for(int i=0;i<listClass.size();i++){
            Class cls=listClass.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cls.getClassId());
            if(stuCourseSelects.size()!=0){
                System.out.println(cls.getClassId()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(cls.getClassId()+" "+"has no grades yet");
            }
        }
    }
    public ArrayList<ChooseCourse> getStudentSelects(String id){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.student.getId().equals(id))
                choose.add(cos);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getCourseSelects(String courseName){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.course.getCourseName().equals(courseName))
                choose.add(cos);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getClassSelects(String clsId){
        ArrayList<ChooseCourse> choose =new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.student.getClsId().equals(clsId))
                choose.add(cos);
        }
        return choose;
    }
    public int getAvgTotalScore(ArrayList<ChooseCourse> cs){
        int average=0;
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.getTotalGrade();
        }
        average=sum/cs.size();
        return average;
    }
    public int getAvgUsualScore(ArrayList<ChooseCourse> cs){
        int average=0;
        int sum=0;
        for(ChooseCourse c:cs){
            if(c.course.getTestType().equals("考试")){
                sum+=c.grade.getUsualGrade();
            }
        }
        average=sum/cs.size();
        return average;
    }
    public int getAvgFinalScore(ArrayList<ChooseCourse> cs){
        int average=0;
        int sum=0;
        for(ChooseCourse c:cs){
                sum+=c.grade.finalGrade;
        }
        average=sum/cs.size();
        return average;
    }
}
class ChooseCourse{
    Course course;
    Student student;
    Grade grade;

    public ChooseCourse(Course course,Student student,Grade grade) {
        this.course = course;
        this.student=student;
        this.grade=grade;
    }
}
class Student implements Comparable<Student>{
    String stuName;
    String id;
    String clsId;
    public String getId(){
        return id;
    }
    public String getStuName(){
        return stuName;
    }
    public String getClsId(){
        return clsId;
    }
    public Student(String clsId,String id,String stuName) {
        this.clsId=clsId;
        this.id=id;
        this.stuName=stuName;
    }
    public int compareTo(Student stu){
        return getId().compareTo(stu.getId());
    }
}
class Course implements Comparable<Course>{
    String courseName;
    String type;
    String testType;

    public Course() {

    }
    public Course(String courseName,String type,String testType) {
        this.courseName=courseName;
        this.type=type;
        this.testType=testType;
    }
    public String getCourseName(){
        return courseName;
    }
    public String getType(){
        return type;
    }
    public String getTestType(){
        return  testType;
    }
    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(courseName,o.getCourseName());
    }

}
class Class implements Comparable<Class>{
    String classId;

    public Class() {
    }

    public String getClassId(){
        return classId;
    }
    public Class(String classId) {
        this.classId = classId;
    }
    @Override
    public int compareTo(Class o) {
        return getClassId().compareTo(o.getClassId());
    }
}
abstract class Grade{
    int finalGrade;
    public Grade() {
    }
    public abstract int getUsualGrade();
    public abstract int getTotalGrade();
}
class ExamGrade extends Grade{
    int usualGrade;

    public ExamGrade(int usualGrade,int finalGrade) {
        this.usualGrade=usualGrade;
        this.finalGrade=finalGrade;
    }
    public int getUsualGrade(){
        return usualGrade;
    }
    public  int getFinalGrade(){
        return 0;
    }
    public int getTotalGrade(){
        return (int)(usualGrade*0.3+finalGrade*0.7);
    }
}
class AssessGrade extends Grade{

    public AssessGrade(int finalGrade) {
        this.finalGrade=finalGrade;
    }
    public int getFinalGrade(){
        return finalGrade;
    }

    @Override
    public int getUsualGrade() {
        return 0;
    }

    public int getTotalGrade(){
        return finalGrade;
    }
}
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 = "(考试|考察)";
    //courseInput用于定义课程信息模式（正则表达式）
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
    //scoreInput用于定义成绩信息模式（正则表达式）
    static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching ;
    static String scoreInput2=  stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + " " +scoreMatching;
    public InputMatching() {
    }
    public  int matchingInput(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) {
        //System.out.println(match);
        if(s.matches(scoreInput1)||s.matches(scoreInput2))
            return true;
        return false;
    }
}