BLOG-1

前三次题目集考察日期类运用，数组类运用， 二进制数值提取，判断三角形类型，巴比伦法求平方根近似值，学号识别，游戏角色选择，房产税费计算，奇数求和，长度质量计量单位换算，身体质量指数（BMI）测算，题量均衡，但难度较大，第三次作业7-2完成难度较大。

7-1 成绩计算-1-类、数组的基本运用

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Student {
private String studentId;
private String name;
private int chineseScore;
private int mathScore;
private int physicsScore;

public Student(String studentId, String name, int chineseScore, int mathScore, int physicsScore) {
this.studentId = studentId;
this.name = name;
this.chineseScore = chineseScore;
this.mathScore = mathScore;
this.physicsScore = physicsScore;
}

public String getStudentId() {
return studentId;
}

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

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getChineseScore() {
return chineseScore;
}

public void setChineseScore(int chineseScore) {
this.chineseScore = chineseScore;
}

public int getMathScore() {
return mathScore;
}

public void setMathScore(int mathScore) {
this.mathScore = mathScore;
}

public int getPhysicsScore() {
return physicsScore;
}

public void setPhysicsScore(int physicsScore) {
this.physicsScore = physicsScore;
}

public int calculateTotalScore() {
return chineseScore + mathScore + physicsScore;
}

public double calculateAverageScore() {
double average = (double) (chineseScore + mathScore + physicsScore) / 3;
return Math.round(average * 100) / 100.0; // 保留两位小数
}
}

public class Main {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
String[] info = scanner.nextLine().split(" ");
if (info.length == 5) {
String studentId = info[0];
String name = info[1];
int chineseScore = Integer.parseInt(info[2]);
int mathScore = Integer.parseInt(info[3]);
int physicsScore = Integer.parseInt(info[4]);
Student student = new Student(studentId, name, chineseScore, mathScore, physicsScore);
students.add(student);
}
}

for (Student student : students) {
int totalScore = student.calculateTotalScore();
double averageScore = student.calculateAverageScore();
System.out.printf("%s %s %d %.2f%n", student.getStudentId(), student.getName(), totalScore, averageScore);
}
}
}

 

程序分析：

  1. import java.util.ArrayList; 和 import java.util.List; 导入了 ArrayList 和 List 类，用于创建一个学生列表。

  2. import java.util.Scanner; 导入了 Scanner 类，用于接收用户输入。

  3. 定义了一个名为 Student 的类，表示学生对象。该类包含了学号（studentId）、姓名（name）、语文成绩（chineseScore）、数学成绩（mathScore）和物理成绩（physicsScore）等属性。

  4. public Student(String studentId, String name, int chineseScore, int mathScore, int physicsScore) 是 Student 类的构造方法，用于初始化学生对象的属性。

  5. public String getStudentId() 和 public void setStudentId(String studentId) 是用于获取和设置学号属性的方法。

  6. public String getName() 和 public void setName(String name) 是用于获取和设置姓名属性的方法。

  7. public int getChineseScore() 和 public void setChineseScore(int chineseScore) 是用于获取和设置语文成绩属性的方法。

  8. public int getMathScore() 和 public void setMathScore(int mathScore) 是用于获取和设置数学成绩属性的方法。

  9. public int getPhysicsScore() 和 public void setPhysicsScore(int physicsScore) 是用于获取和设置物理成绩属性的方法。

  10. public int calculateTotalScore() 是用于计算学生总成绩的方法，返回语文成绩、数学成绩和物理成绩的总和。

  11. public double calculateAverageScore() 是用于计算学生平均成绩的方法，返回语文成绩、数学成绩和物理成绩的平均值（保留两位小数）。

  12. public static void main(String[] args) 是程序的入口，其中的代码将在程序运行时执行。

  13. 创建了一个空的学生列表 List<Student> students = new ArrayList<>();，用于存储学生对象。

  14. 创建一个 Scanner 对象 Scanner scanner = new Scanner(System.in);，用于接收用户输入。

  15. 使用 for 循环 5 次 for (int i = 0; i < 5; i++)，读取用户输入的学生信息并创建 Student 对象，将其添加到学生列表中。

  16. 使用 scanner.nextLine().split(" ") 接收用户输入的一行字符串，并以空格为分隔符将其拆分为一个字符串数组，存储在 info 变量中。

  17. 判断 info 数组的长度是否为 5 if (info.length == 5)，确保输入了正确的学生信息。

  18. 将 info 数组中的元素分别提取出来，并转换为对应的类型，例如学号为字符串，语文成绩、数学成绩和物理成绩为整型。

  19. 创建一个新的 Student 对象 Student student = new Student(studentId, name, chineseScore, mathScore, physicsScore);，并传入学生信息参数。

  20. 将创建的学生对象添加到学生列表中 students.add(student);。

  21. 使用增强型 for 循环遍历学生列表 for (Student student : students)。

  22. 对于每个学生对象，调用 calculateTotalScore 方法计算总成绩，将结果存储在 totalScore 变量中。

  23. 调用 calculateAverageScore 方法计算平均成绩，将结果存储在 averageScore 变量中。

  24. 使用 System.out.printf 方法格式化输出学生的学号、姓名、总成绩和平均成绩，并换行输出。

经过编译测试，代码通过。

7-2 成绩计算-2-关联类

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Score {
    private int dailyScore;
    private int finalScore;

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

    public int calculateTotalScore() {
        return (int) (dailyScore * 0.4 + finalScore * 0.6);
    }
}

class Student {
    private String studentId;
    private String name;
    private Score chineseScore;
    private Score mathScore;
    private Score physicsScore;

    public Student(String studentId, String name, Score chineseScore, Score mathScore, Score physicsScore) {
        this.studentId = studentId;
        this.name = name;
        this.chineseScore = chineseScore;
        this.mathScore = mathScore;
        this.physicsScore = physicsScore;
    }

    public int calculateTotalScore() {
        int chinese = chineseScore != null ? chineseScore.calculateTotalScore() : 0;
        int math = mathScore != null ? mathScore.calculateTotalScore() : 0;
        int physics = physicsScore != null ? physicsScore.calculateTotalScore() : 0;
        return chinese + math + physics;
    }

    public double calculateAverageScore() {
        double average = calculateTotalScore() / 3.0;
        return Math.round(average * 100) / 100.0; // 保留两位小数
    }

    public String getStudentId() {
        return studentId;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            String[] info = scanner.nextLine().split(" ");
            if (info.length == 8) {
                String studentId = info[0];
                String name = info[1];

                int chineseDailyScore = Integer.parseInt(info[2]);
                int chineseFinalScore = Integer.parseInt(info[3]);
                Score chineseScore = new Score(chineseDailyScore, chineseFinalScore);

                int mathDailyScore = Integer.parseInt(info[4]);
                int mathFinalScore = Integer.parseInt(info[5]);
                Score mathScore = new Score(mathDailyScore, mathFinalScore);

                int physicsDailyScore = Integer.parseInt(info[6]);
                int physicsFinalScore = Integer.parseInt(info[7]);
                Score physicsScore = new Score(physicsDailyScore, physicsFinalScore);

                Student student = new Student(studentId, name, chineseScore, mathScore, physicsScore);
                students.add(student);
            }
        }

        for (Student student : students) {
            int totalScore = student.calculateTotalScore();
            double averageScore = student.calculateAverageScore();
            System.out.printf("%s %s %d %.2f%n", student.getStudentId(), student.getName(), totalScore, averageScore);
        }
    }
}

 

程序分析：

  1. import java.util.ArrayList; 和 import java.util.List; 导入了 ArrayList 和 List 类，用于创建一个学生列表。

  2. import java.util.Scanner; 导入了 Scanner 类，用于接收用户输入。

  3. 定义了名为 Score 的类，表示分数对象。该类包含了日常成绩（dailyScore）和期末成绩（finalScore）等属性。

  4. public Score(int dailyScore, int finalScore) 是 Score 类的构造方法，用于初始化分数对象的属性。

  5. public int calculateTotalScore() 是用于计算分数总评成绩的方法，根据日常成绩和期末成绩按一定权重计算得出总评成绩。

  6. 定义了名为 Student 的类，表示学生对象。该类包含了学号（studentId）、姓名（name）、语文成绩（chineseScore）、数学成绩（mathScore）和物理成绩（physicsScore）等属性。

  7. public Student(String studentId, String name, Score chineseScore, Score mathScore, Score physicsScore) 是 Student 类的构造方法，用于初始化学生对象的属性。

  8. public int calculateTotalScore() 是用于计算学生总成绩的方法，调用各科目的 calculateTotalScore 方法计算各科目成绩，并将结果相加。

  9. public double calculateAverageScore() 是用于计算学生平均成绩的方法，调用 calculateTotalScore 方法计算总成绩，然后除以科目数得到平均成绩，并保留两位小数。

  10. public String getStudentId() 和 public String getName() 是用于获取学号和姓名属性的方法。

  11. 创建了一个空的学生列表 List<Student> students = new ArrayList<>(); 用于存储学生对象。

  12. 创建一个 Scanner 对象 Scanner scanner = new Scanner(System.in); 用于接收用户输入。

  13. 使用 for 循环 3 次 for (int i = 0; i < 3; i++)，读取用户输入的学生信息并创建 Student 对象，将其添加到学生列表中。

  14. 使用 scanner.nextLine().split(" ") 接收用户输入的一行字符串，并以空格为分隔符将其拆分为一个字符串数组，存储在 info 变量中。

  15. 判断 info 数组的长度是否为 8 if (info.length == 8)，确保输入了正确的学生信息。

  16. 将 info 数组中的元素分别提取出来，并转换为对应的类型，例如学号和姓名为字符串，各科目的日常成绩和期末成绩为整型。

  17. 创建三个新的 Score 对象 Score chineseScore = new Score(chineseDailyScore, chineseFinalScore);、Score mathScore = new Score(mathDailyScore, mathFinalScore); 和 Score physicsScore = new Score(physicsDailyScore, physicsFinalScore);，并传入相应的日常成绩和期末成绩参数。

  18. 创建一个新的 Student 对象 Student student = new Student(studentId, name, chineseScore, mathScore, physicsScore); 并传入学生信息参数。

  19. 将创建的学生对象添加到学生列表中 students.add(student);。

  20. 使用增强型 for 循环遍历学生列表 for (Student student : students)。

  21. 对于每个学生对象，调用 calculateTotalScore 方法计算总成绩，将结果存储在 totalScore 变量中。

  22. 调用 calculateAverageScore 方法计算平均成绩，将结果存储在 averageScore 变量中。

  23. 使用 System.out.printf 方法格式化输出学生的学号、姓名、总成绩和平均成绩，并换行输出。

以上就是代码中每句代码的含义和作用。

经过测试代码，编译没通过，具体错误未知。

 

7-7 菜单计价程序-1

import java.util.Scanner;

class Dish {
String name; // 菜品名称
int unit_price; // 单价

Dish(String name, int unit_price) {
this.name = name;
this.unit_price = unit_price;
}

int getPrice(int portion) {
double price = 0;
if (portion == 1) { // 小份
price = unit_price;
} else if (portion == 2) { // 中份
price = unit_price * 1.5;
} else if (portion == 3) { // 大份
price = unit_price * 2;
}
return (int) Math.round(price);
}
}

class Menu {
Dish[] dishes; // 菜品数组，保存所有菜品信息

Dish searchDish(String dishName) {
for (Dish dish : dishes) {
if (dish.name.equals(dishName)) {
return dish;
}
}
return null;
}
}

class Record {
Dish dish; // 菜品
int portion; // 份额（1/2/3代表小/中/大份）

int getPrice() {
return dish.getPrice(portion);
}
}

class Order {
Record[] records; // 保存订单上每一道的记录

int getTotalPrice() {
int totalPrice = 0;
for (Record record : records) {
totalPrice += record.getPrice();
}
return totalPrice;
}

void addRecord(Record record) {
// 判断是否需要扩展数组容量
if (records == null) {
records = new Record[1];
records[0] = record;
} else {
int length = records.length;
Record[] temp = new Record[length + 1];
System.arraycopy(records, 0, temp, 0, length);
temp[length] = record;
records = temp;
}
}
}

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

// 构建菜谱
Menu menu = new Menu();
menu.dishes = new Dish[4];
menu.dishes[0] = new Dish("西红柿炒蛋", 15);
menu.dishes[1] = new Dish("清炒土豆丝", 12);
menu.dishes[2] = new Dish("麻婆豆腐", 12);
menu.dishes[3] = new Dish("油淋生菜", 9);

// 创建订单
Order order = new Order();
Record record;
while (true) {
String input = sc.nextLine();
if (input.equals("end")) {
break;
}
String[] parts = input.split(" ");
String dishName = parts[0];
int portion = Integer.parseInt(parts[1]);

record = addARecord(dishName, portion, menu);
if (record != null) {
// 将记录添加到订单中
order.addRecord(record);
}
}

// 计算总价并输出
int totalPrice = order.getTotalPrice();
System.out.println(totalPrice);
}

static Record addARecord(String dishName, int portion, Menu menu) {
Dish dish = menu.searchDish(dishName);
if (dish == null) {
System.out.println(dishName + " does not exist");
return null;
}
Record record = new Record();
record.dish = dish;
record.portion = portion;
return record;
}
}

 

分析代码：

代码中定义了四个类：Dish、Menu、Record和Order。

Dish类表示菜品，包含菜品名称（name）和单价（unit_price）两个属性，以及一个方法getPrice，根据传入的份额参数，返回该份菜品的价格。

Menu类表示菜谱，包含一个dishes数组，保存所有菜品信息，以及一个searchDish方法，通过指定菜品名字搜索菜品，返回对应的Dish对象。

Record类表示一个记录，包含一个Dish对象和份额（portion）两个属性，以及一个getPrice方法，返回该记录所选菜品的价格。

Order类表示一个订单，包含一个records数组，保存所有记录信息，以及一个getTotalPrice方法，计算出当前订单的总价，以此来完成餐厅点餐的功能。

在Main主类中，用Scanner实现菜品选择，并通过构建菜谱Menu和订单Order来处理输入。其中，addARecord方法用于将Record记录添加到订单Order中。

在while循环中，根据用户输入创建Record对象，然后调用order.addRecord方法将其添加到订单中。最后，通过调用order.getTotalPrice方法计算订单总价并输出。

经过编译测试，代码出现错误，如图所示：

多条记录测试--含异常菜名 26708 140
非零返回

 

7-2 课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

参考类图：


image.png

输入样例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 张三 java 20
end

输出样例4:

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

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

输入样例5:

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

java 必修 考察
20201103 张三 java 40
end

输出样例5:

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

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

输出样例6:

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

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

输入样例7:

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

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

输出样例7:

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

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

输出样例8:

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

wrong format
数据结构 has no grades yet

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

输出样例9:

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

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

具体代码：
import sys

导入sys模块。

class Exam:
    def __init__(self, name, nature, access_method):
        self.name = name
        self.nature = nature
        self.access_method = access_method
        self.total_score_list = []

定义一个名为Exam的类，包含三个属性name、nature和access_method，分别表示考试科目名称、性质和考核方式，并定义一个空列表用来存储学生成绩。

    def add_score(self, score_info_str):
        try:
            student_id, name, course_name, usual_score, final_score = score_info_str.split()
            if len(student_id) != 8 or not student_id.isdigit() \
                    or 0 > int(usual_score) or int(usual_score) > 100 \
                    or 0 > int(final_score) or int(final_score) > 100 \
                    or len(name) > 10 or len(course_name) > 10:
                raise ValueError
            if self.access_method == '考试' and (not usual_score.isdigit() or usual_score is None):
                raise ValueError
            if self.access_method == '考察' and usual_score is not '':
                raise ValueError
            if self.nature == '必修' and self.access_method == '考察':
                self.total_score_list.append(int(final_score))
            else:
                total_score = int(usual_score) * 0.3 + int(final_score) * 0.7
                self.total_score_list.append(total_score)

        except ValueError:
            print("wrong format")

定义一个名为add_score的成员函数用来向考试科目添加学生成绩，函数输入参数为一个字符串score_info_str，表示一条学生成绩信息，包含学生ID、姓名、科目名称、平时分和期末分。在函数中首先对输入参数格式进行检查，判断是否符合要求；然后根据科目性质和考核方式计算总成绩并将其添加到成绩列表中。如果出现数值异常，则捕获ValueError异常，并输出提示信息。

    def get_total_score_avg(self):
        course_scores = sorted(self.total_score_list)
        length = len(course_scores)
        if length == 0:
            return 0
        return sum(course_scores) // length

定义一个名为get_total_score_avg的成员函数用来计算考试科目的平均分，具体实现是从成绩列表中取出成绩，计算总分并求取平均分。如果列表中没有任何成绩，则返回0。

class CourseStat:
    def __init__(self):
        self.course_dict = {}

定义一个名为CourseStat的类，包含一个字典属性course_dict，用来存储所有考试科目及其成绩。

    def add_course(self, course_str):
        try:
            if len(course_str.split()) == 2:
                name, nature = course_str.split()
                access_method = ''
            else:
                name, nature, access_method = course_str.split()
            if nature not in ['必修', '选修'] or access_method not in ['', '考试', '考察']:
                raise ValueError
            self.course_dict[name] = Exam(name, nature, access_method)
        except ValueError:
            print("wrong format")

定义一个名为add_course的成员函数用来向课程列表中添加考试科目，函数输入参数为一个字符串course_str，表示一条考试科目信息，包含科目名称、性质和考核方式。在函数中首先对输入参数格式进行检查，判断是否符合要求；然后将该科目的信息存储在字典course_dict中。如果出现数值异常，则捕获ValueError异常，并输出提示信息。

    def add_score(self, score_info_str):
        try:
            student_id, name, course_name, usual_score, final_score = score_info_str.split()
            if course_name not in self.course_dict:
                print(f"{student_id} {name} :{course_name} does not exist")
                return
            exam = self.course_dict[course_name]
            if exam.access_method == '' and usual_score is not '':
                print(f"{student_id} {name} : access mode mismatch")
                return
            exam.add_score(score_info_str)

        except ValueError:
            print("wrong format")

定义一个名为add_score的成员函数用来向指定科目添加学生成绩，函数输入参数为一个字符串score_info_str，表示一条学生成绩信息，包含学生ID、姓名、科目名称、平时分和期末分。在函数中首先检查指定科目是否存在，若不存在则输出提示信息；然后检查考核方式是否匹配，若不匹配则输出提示信息；最后调用考试类的add_score函数进行成绩添加。

    def get_student_total_score_avg(self):
        student_score_list = []
        for exam in self.course_dict.values():
            student_score_list += [(student_id, name, exam.get_total_score_avg()) for student_id, name, _, _, _
                                   in exam.total_score_list]
        student_score_list.sort(key=lambda x: x[0])
        for student_score in student_score_list:
            print(f"{student_score[0]} {student_score[1]} {student_score[2] or 'did not take any exams'}")

定义一个名为get_student_total_score_avg的成员函数用来计算学生的总平均分，具体实现是从考试科目中取出每个学生的总成绩，并将其存储在一个列表中，然后按照学生ID排序输出结果。

    def get_course_total_score_avg(self):
        sorted_exam_list = sorted(self.course_dict.values(), key=lambda exam: exam.name)
        for exam in sorted_exam_list:
            if exam.access_method == '考试':
                usual_avg = sum([int(usual_score) for _, _, _, usual_score, _ in exam.total_score_list if usual_score is not '']) // len(
                    [usual_score for _, _, _, usual_score, _ in exam.total_score_list if usual_score is not ''])
            else:
                usual_avg = '-'
            final_avg = sum([int(final_score) for _, _, _, _, final_score in exam.total_score_list]) // len(
                exam.total_score_list) if len(exam.total_score_list) > 0 else 0
            total_avg = exam.get_total_score_avg()
            print(f"{exam.name} {usual_avg} {final_avg} {total_avg or 'has no grades yet'}")

定义一个名为get_course_total_score_avg的成员函数用来计算每个科目的平均分，具体实现是从考试科目中取出平时分、期末分和总成绩，然后按指定格式输出结果。如果是以考试方式进行考核，则按平时成绩计算平均分；否则平时平均分输出为“-”。

    def get_class_total_score_avg(self):
        class_score_dict = {}
        for exam in self.course_dict.values():
            if exam.access_method == '考试':
                for student_id, name, course_name, usual_score, final_score in exam.total_score_list:
                    class_id = student_id[:6]
                    if class_id not in class_score_dict:
                        class_score_dict[class_id] = []
                    class_score_dict[class_id].append(int(usual_score) * 0.3 + int(final_score) * 0.7)
            else:
                for student_id, name, course_name, _, final_score in exam.total_score_list:
                    class_id = student_id[:6]
                    if class_id not in class_score_dict:
                        class_score_dict[class_id] = []
                    class_score_dict[class_id].append(int(final_score))

        sorted_class_list = sorted(class_score_dict.items(), key=lambda x: x[0])
        for class_id, score_list in sorted_class_list:
            print(f"{class_id} {sum(score_list) // len(score_list)}")

定义一个名为get_class_total_score_avg的成员函数用来计算班级的总平均分，具体实现是对每个参加考试的班级进行成绩汇总，并按照班级代码排序输出结果。如果是以考试方式进行考核，则按平时成绩计算平均分；否则只有期末成绩参与计算

经过测试代码，未通过编译，答案出错。

在代码编译过程中，出现较多错误，例如语法错误，括号等的缺失，命名和类型错误，逻辑错误。通过这三次作业，意识到自己代码知识的缺失，和想法方面无法通过java语言表达，在后续中需要进行进一步学习。

posted @ 2023-10-08 20:27  zxy0212  阅读(31)  评论(0)    收藏  举报