PTA6-8次题目集（成绩计算系列）

（1）前言：
在本次任务中，我们将根据新的类结构和题目要求，设计一个完成课程成绩统计的程序。该程序能够接收课程和课程成绩的输入信息，并根据输入的考核方式和分项成绩计算出学生的总成绩。最后，程序将输出学生所有课程总成绩的平均分、单门课程总成绩平均分以及班级所有课程总成绩平均分。
为了满足题目的要求和限制条件，我们将进行输入信息的解析和处理，同时处理可能出现的异常情况。在输出结果时，我们将按照一定的格式和排序方式呈现学生的总成绩、课程的平均分以及班级的平均分。
（2）设计与分析

成绩计算系列-1
1.首先，需要设计一个数据结构来存储课程和成绩信息。可以使用类来表示课程和成绩，包括属性如课程名称、课程性质、考核方式、平时成绩、期末成绩等。
2.创建一个课程列表，用于存储输入的课程信息。每当输入一个课程信息时，检查课程列表中是否已存在该课程，若存在则忽略，否则将其添加到列表中。
3.创建一个成绩列表，用于存储输入的成绩信息。每当输入一个成绩信息时，首先检查课程列表中是否存在对应的课程，若不存在则输出错误信息。然后检查成绩列表中是否已存在该学生的成绩，若存在则忽略，否则将其添加到列表中。
4.根据题目要求，对成绩列表进行统计计算。可以通过遍历成绩列表，按照学号进行排序，计算每个学生的总成绩和总课程数，然后计算各门课程的平均成绩和总成绩。同时，可以将班级号作为键，将学生成绩累加到对应班级的总成绩中，并记录每个班级的课程数。
5.最后，按照要求输出统计结果。输出学生的总成绩平均分时，根据学号从低到高排序输出。输出单门课程的平均成绩时，按照课程名称的字符顺序输出。输出班级的总成绩平均分时，按照班级号从低到高排序输出。

成绩计算系列-2
首先，我们可以设计以下几个类来表示不同的对象：
1.Course（课程类）：包含课程的名称、性质和考核方式等属性。
2.Grade（成绩类）：包含学生的学号、姓名以及课程的相关成绩信息。3.Student（学生类）：包含学生的学号、姓名和所修课程的成绩列表等属性。
4.Class（班级类）：包含班级的编号和学生列表等属性。
然后，我们可以设计一个 GradesStatistics（成绩统计类）来进行成绩的计算和报表的生成。
在 GradesStatistics 类中，我们可以定义以下方法来实现题目要求的功能：
1.parseCourseInfo(input: string): Course：解析输入的课程信息字符串，创建并返回对应的 Course 对象。
2.parseGradeInfo(input: string): Grade：解析输入的成绩信息字符串，创建并返回对应的 Grade 对象。
3.calculateTotalScore(grade: Grade, course: Course): number：根据课程的考核方式计算学生的总成绩。
4.calculateAverageGrade(student: Student): number：计算学生所有课程的平均分。
5.calculateCourseAverageGrades(course: Course, students: Student[]): [number, number, number]：计算某门课程的平均成绩（平时成绩平均分、期末考试平均分、总成绩平均分）。
6.calculateClassAverageGrades(class: Class): number：计算班级所有课程的平均成绩。
7.generateReport(students: Student[], classes: Class[]): string：生成统计报表。

成绩计算系列-3
在程序的实现中，可以通过读取输入数据，解析成对应的对象，并进行成绩的计算和统计。对于不符合要求的输入格式或异常情况，需要进行相应的错误处理和输出提示信息。
在进行程序开发的过程中，可以使用合适的数据结构来存储和管理课程、学生和成绩信息，例如使用字典或列表进行存储，并通过遍历和查找来实现统计和计算功能。

源代码：
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Locale;
import java.util.Scanner;

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

class ParseInput {
ArrayList courseArrayList = new ArrayList<>();
ArrayList studentArrayList = new ArrayList<>();
ArrayList chooseArrayList = new ArrayList<>();
ArrayList classArrayList = new ArrayList<>();

public void parseInput(String nextLine) {
String[] arraylist = nextLine.split(" ");
switch (InputMatching.matchingInput(nextLine)) {
case 1:
inputCourse(arraylist);
break;
case 2:
inputScore(arraylist);
break;
case 0:
System.out.println("wrong format");
break;
}
}

Course getCourse(String courseName) {
for (Course course : courseArrayList) {
if (course.getCsName().equals(courseName))
return course;
}
return null;
}

myClass getClass(String classId) {
for (myClass myClass : classArrayList) {
if (myClass.getID().equals(classId))
return myClass;
}
return null;
}

Student getStudent(String stuId) {
for (Student student : studentArrayList) {
if (student.getStNumber().equals(stuId))
return student;
}
return null;
}

private void inputScore(String[] a) {
myClass myclass;
Student student;
myclass = getClass(a[0].substring(0, 6));
if (myclass == null) {
myclass = new myClass(a[0].substring(0, 6));
classArrayList.add(myclass);
}
student = getStudent(a[0]);
if (student == null) {
student = new Student(a[0], a[1]);
studentArrayList.add(student);
myclass.addStudent(student);
}
Course course = getCourse(a[2]);
if (course == null) {
System.out.println(a[2] + " does not exist");
return;
}
if (!checkGrade(a, course))
return;
Score score;
if (a.length == 4) {
score = new kcScore(Integer.parseInt(a[3]));
} else if (a.length == 5) {
score = new ksScore(Integer.parseInt(a[3]), Integer.parseInt(a[4]));
} else {
ArrayList exScores = new ArrayList<>();
for (int i = 4; i < a.length; i++)
exScores.add(Integer.parseInt(a[i]));
score = new exScore(exScores, Integer.parseInt(a[3]));
}
if (existChooseCourse(student, course))
return;// 重复
Choose chooseCourse = new Choose(course, student, score);
chooseArrayList.add(chooseCourse);
}

public void inputCourse(String[] a) {
Course course = new Course(a[0], a[1], a[2]);
if (!checkCourse(course))
return;
if (getCourse(a[0]) == null) {// 没有重复的课程
course = new Course(a[0], a[1], a[2]);
courseArrayList.add(course);
}
}

boolean checkCourse(Course course) {
if (course.getCsCharacter().equals("必修") && course.getCsExamine().equals("考试"))
return true;
if (course.getCsCharacter().equals("选修") && course.getCsExamine().equals("考试"))
return true;
if (course.getCsCharacter().equals("选修") && course.getCsExamine().equals("考察"))
return true;
if (course.getCsCharacter().equals("实验") && course.getCsExamine().equals("实验"))
return true;
System.out.println(course.getCsName() + " : course type & access mode mismatch");
return false;
}

boolean existChooseCourse(Student stu, Course course) {
for (Choose choose : chooseArrayList) {
if (choose.getCourse().getCsName().equals(course.getCsName())) {
if (choose.getStudent().getStName().equals(stu.getStName()))
return true;
}
}
return false;
}

private boolean checkGrade(String[] items, Course course) {
String courseType = course.getCsExamine();
if (courseType.equals("考试") && items.length == 5) {
return true;
}
if (courseType.equals("考察") && items.length == 4) {
return true;
}
if (courseType.equals("实验")) {
if (items.length == Integer.parseInt(items[3]) + 4)
return true;
}
System.out.println(items[0] + " " + items[1] + " : access mode mismatch");
return false;
}

public static int getAvagScore1(ArrayList courseSelects)// 平时
{
int sum = 0;
for (Choose cs : courseSelects) {
sum += ((ksScore) (cs.score)).getUsualScore();
}
return sum / courseSelects.size();
}

public int getAvagScore2(ArrayList courseSelects)// 期末
{
int sum = 0;
for (Choose cs : courseSelects) {
sum += cs.score.getFinalScore();
}
return sum / courseSelects.size();
}

public int getAvgTotalScore(ArrayList listChooseCourse) {
int sum = 0;
for (Choose cs : listChooseCourse) {
sum += cs.score.getTotalScore();
}
return sum / listChooseCourse.size();
}

public ArrayList getStudentSelects(String stNumber) {
ArrayList stus = new ArrayList<>();
for (Choose choose : chooseArrayList) {
if (choose.student.getStNumber().equals(stNumber)) {
stus.add(choose);
}
}
if (stus.size() != 0)
return stus;
else
return null;
}

public ArrayList getCourseSelects(String courseName) {
ArrayList courses = new ArrayList<>();
for (Choose choose : chooseArrayList) {
if (choose.course.getCsName().equals(courseName)) {
courses.add(choose);
}
}
if (courses.size() != 0)
return courses;
else
return null;
}

public ArrayList getClassSelects(String classID) {
ArrayList classes = new ArrayList<>();
for (Choose choose : chooseArrayList) {
if (choose.student.getStNumber().substring(0, 6).equals(classID)) {
classes.add(choose);
}
}
if (classes.size() != 0)
return classes;
else
return null;
}

public void showStudents() {
Collections.sort(studentArrayList);
for (Student student : studentArrayList) {
ArrayList stuCourseSelects = getStudentSelects(student.getStNumber());
// 从总选课表Choose中获取该生的选课记录集合
if (stuCourseSelects != null) {
System.out.println(
student.getStNumber() + " " + student.getStName() + " " + getAvgTotalScore(stuCourseSelects));
} else {
System.out.println(student.getStNumber() + " " + student.getStName() + " " + "did not take any exams");
}
}
}

public void showCourses() {
Collections.sort(courseArrayList);
for (Course course : courseArrayList) {
ArrayList CourseSelects = getCourseSelects(course.getCsName());
if (CourseSelects != null) {
if (course.getCsExamine().equals("考试"))
System.out.println(course.getCsName() + " " + getAvagScore1(CourseSelects) + " "
+ getAvagScore2(CourseSelects) + " " + getAvgTotalScore(CourseSelects));
if (course.getCsExamine().equals("考察"))
System.out.println(course.getCsName() + " " + getAvagScore2(CourseSelects) + " "
+ getAvgTotalScore(CourseSelects));
if (course.getCsExamine().equals("实验"))
System.out.println(course.getCsName() + " " + getAvgTotalScore(CourseSelects));
} else {
System.out.println(course.getCsName() + " has no grades yet");
}
}
}

public void showClasses() {
Collections.sort(classArrayList);
for (myClass myClass : classArrayList) {
ArrayList stuClassSelects = getClassSelects(myClass.getID());
if (stuClassSelects != null) {
System.out.println(myClass.getID() + " " + getAvgTotalScore(stuClassSelects));
} else {
System.out.println(myClass.getID() + " " + "has no grades yet");
}
}
}
}

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 exCountMatching = "[4-9]";
static String exScores = "(([1-9]?\d|100)\s){3,8}([1-9]?\d|100)";
// cousrInput用于定义课程信息模式（正则表达式）
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
// scoreInput用于定义成绩信息模式（正则表达式）
static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " + scoreMatching;
static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " + scoreMatching
+ " " + scoreMatching;
static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " "
+ exCountMatching + " " + exScores;

public static 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) {
return (s.matches(scoreInput) || s.matches(scoreInput1) || s.matches(scoreInput2));
}
}

class Course implements Comparable {
private String csName;
private String csCharacter;
private String csExamine;

public Course(String csName, String csCharacter, String csExamine) {
this.csName = csName;
this.csCharacter = csCharacter;
this.csExamine = csExamine;
}

public String getCsName() {
return csName;
}

public String getCsCharacter() {
return csCharacter;
}

public String getCsExamine() {
return csExamine;
}

@Override
public int compareTo(Course o) {
Comparator