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<Integer> 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<Choose> courseSelects)// 平时
{
	int sum = 0;
	for (Choose cs : courseSelects) {
		sum += ((ksScore) (cs.score)).getUsualScore();
	}
	return sum / courseSelects.size();
}

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

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

public ArrayList<Choose> getStudentSelects(String stNumber) {
	ArrayList<Choose> 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<Choose> getCourseSelects(String courseName) {
	ArrayList<Choose> 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<Choose> getClassSelects(String classID) {
	ArrayList<Choose> 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<Choose> 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<Choose> 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<Choose> 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<Object> compare = Collator.getInstance(Locale.CHINA);
	return compare.compare(csName, o.getCsName());
}

}

class ksScore extends Score {// 考试
private int Score1;// 平时

public int getUsualScore() {
	return Score1;
}

public ksScore(int usualScore, int finalScore) {
	super(finalScore);
	this.Score1 = usualScore;
	this.totalScore = (int) (finalScore * 0.7 + usualScore * 0.3);
}

}

class exScore extends Score {
ArrayList exScores = new ArrayList<>();

public exScore(ArrayList<Integer> exScores, int finalScore) {
	super(finalScore);
	this.exScores = exScores;
	int sum = 0;
	for (Integer exScore : this.exScores) {
		sum += exScore;
	}
	finalScore = sum / exScores.size();
	this.totalScore = finalScore;
}

}

class kcScore extends Score {// 考察
public kcScore(int finalScore) {
super(finalScore);
this.totalScore = finalScore;
}
}

class Student implements Comparable {
private String stuNumber;
private myClass myclass;
private String stuName;

public Student(String stuNumber, String stuName) {
	this.stuName = stuName;
	this.stuNumber = stuNumber;
}

public String getStNumber() {
	return stuNumber;
}

public String getStName() {
	return stuName;
}

@Override
public int compareTo(Student student) {
	return getStNumber().compareTo(student.getStNumber());
}

}

class Choose {
Course course;
Student student;
Score score;

public Course getCourse() {
	return course;
}

public Student getStudent() {
	return student;
}

public Choose(Course course, Student student, Score score) {
	this.course = course;
	this.student = student;
	this.score = score;
}

}

class myClass implements Comparable {
private String ID;
ArrayList listStudent = new ArrayList<>();

void addStudent(Student stu) {
	listStudent.add(stu);
}

public myClass(String ID) {
	this.ID = ID;
}

public String getID() {
	return ID;
}

@Override
public int compareTo(myClass myclass) {
	return ID.compareTo(myclass.getID());
}

}

class Score {
protected int Score2;// 期末
protected int totalScore;

public int getTotalScore() {
	return totalScore;
}

public int getFinalScore() {
	return Score2;
}

public Score(int finalScore) {
      this.Score2=finalScore;
  }

}
（3）采坑心得：
问题1：修改类结构 在修改类结构时，我需要将成绩类的继承关系改为组合关系。具体来说，我需要创建课程成绩类和分项成绩类，并将它们组合在一起。课程成绩类包含了分项成绩类的实例作为其中的一部分。
问题2：课程成绩计算 根据题目要求，不同类型的课程成绩计算方式不同。必修课是通过平时成绩和期末成绩按照权重值计算总成绩；选修课可以选择考试或考察，考试成绩按照权重值计算总成绩，考察成绩直接等于期末成绩；实验课的总成绩是根据每次实验成绩乘以权重值后累加而得。在修改类结构后，我需要根据不同的考核方式和课程类型，对课程成绩的计算进行相应的修改和调整。
问题3：数据输入和解析 题目要求输入包括课程信息和学生成绩信息，其中课程信息包括课程名称、课程性质、考核方式、分项成绩数量和每个分项成绩的权重。学生成绩信息包括学号、姓名、课程名称以及相应的成绩数据。在输入和解析数据时，我需要按照指定的格式进行输入，并对输入的数据进行解析和处理。
心得1：详细阅读题目要求 在进行代码编写之前，我详细阅读了题目要求，并理解了每个要求的具体含义。这有助于我对问题进行合理的分析和解决，并且在编写代码时可以更加明确地知道需要实现哪些功能。
心得2：模块化设计和代码复用 在修改类结构和实现功能时，我采用了模块化的设计思路，将不同功能和操作封装成独立的方法或类。这样可以提高代码的可读性和可维护性，并且可以方便地复用已经实现好的功能模块。
心得3：测试和调试 在编写代码的过程中，我进行了多次的测试和调试，以确保代码的正确性和功能的完整性。我使用了一些样例数据进行测试，并逐步调试和修复代码中出现的问题。同时，我也注意了代码的异常处理和错误提示，以便在出现错误时能够及时发现并进行修复。

（4）改进建议：
在代码中，可以考虑使用更具有可读性和可维护性的命名规范，以增强代码的可理解性。例如，变量和方法命名可以更加清晰和具有描述性，以便于他人理解和维护代码。
此外，在代码注释方面可以进一步完善，提供更详细的解释和说明，特别是在涉及复杂逻辑或关键功能的部分，以帮助他人快速理解代码的意图和实现方式。
另外，可以考虑对输入进行更严格的验证和处理，确保输入的数据符合预期的格式和约束条件。这样可以避免程序在处理不合规范的输入时出现异常或错误结果。
此外，可以进一步优化代码结构和逻辑，将重复的代码抽象成可复用的方法或函数，提高代码的可维护性和可扩展性。
最后，建议添加适当的异常处理机制，以应对可能的运行时异常和错误情况，提高程序的健壮性和容错性。

（5）总结：
在本阶段的学习中，我学到了很多关于编程和软件开发的知识和技能。通过完成课程的作业和实验，我深入了解了各种编程语言、算法和数据结构的基本概念，并学会了使用它们来解决实际问题。我也学到了如何进行代码调试和错误处理，以及如何编写清晰、可读性强的代码。
然而，我也认识到在一些方面仍需要进一步学习和研究。首先，我希望深入了解更多关于软件工程的实践和方法，例如软件设计模式、代码重构和测试驱动开发等。这将有助于我提高代码的可维护性和可扩展性。
另外，我还需要加强对于计算机网络和数据库的理解和应用能力。这些领域在现代软件开发中起着重要作用，深入了解它们将使我能够设计和开发更复杂的应用程序。
对于教师、课程、作业、实验、课上及课下组织方式等方面，我有一些建议和意见。首先，我建议教师在课程中注重理论与实践的结合，通过实际案例和项目来应用所学知识。这样可以更好地巩固学生的学习成果，并提高他们解决实际问题的能力。
其次，对于作业和实验，我建议提供更具挑战性和实用性的任务，以激发学生的兴趣和动力。同时，及时给予反馈和指导，帮助学生发现和纠正问题，提高他们的学习效果。
此外，课堂组织方式可以更加互动和参与性，例如通过小组讨论、实践演示或问题解答等形式，激发学生的思考和讨论。此外，提供额外的学习资源和参考资料，以满足学生不同层次和兴趣的需求。
总之，本阶段的学习让我获得了许多宝贵的知识和技能，但仍需要进一步学习和探索。通过改进教学方式和提供更好的学习资源，可以进一步提高学生的学习效果和满意度。

本栏目推荐文章
• 成绩管理系统软件体系结构设计说明书
• 记一次docker出全linux的内网渗透题目(仿照2023铸剑杯)
• 盘点一个AI都无法解决的Python基础题目（下篇）
• 低压电工题目解析
• KY2 成绩排序C
• KY2 成绩排序C++
• 经典算法题之成绩排序C
• 经典算法题之-成绩排序C++
• 2024年题目选讲
• 用vfp统计测验成绩，多学科，多班级

题目 成绩 PTA6 PTA题目 成绩pta6 pta 管理系统 成绩 系统pta6 题目 成绩pta 题目 成绩blog pta pta题目 成绩nchu pta6 java pta6 pta blog pta6 pta 报告pta6 pta 成绩pta