题目集总结
一：前言：
这三次的 PTA 题目难度逐步上升，由第一次十分钟甚至更少时间的一题，到第二次作业一两个小时做出一题（第二小题），再到第三次作业花一整天时间才能解出一个题。考察的主要内容包括：
1. 对字符串的理解和使用，以及与字符串有关的函数的应用。
2. 对类和对象的初步认识和运用，加深对其理解。
3. 逐步实现从面向过程到面向对象思维方式的转变，提高编程思维的转换能力。
二：作业的设计与分析
第一次作业：
这次作业的主要目的是让我们从放假的状态过渡到学习的状态，同时熟悉Java语言。虽然有十个题目，但都是基础的算法题，需要我们使用Java语言进行编写。在完成作业的过程中，我们需要注意到 PTA 检测点的要求，即必须使用 float 进行最后的输出，而不能使用 double，因为 double 的精度太高可能导致答案出错。最初很少人能够得满分，但当大家掌握了 PTA 检测点的要求后，一下子所有人都得到了满分。
其中有两道与字符串有关的题目，这时我们还没有学习字符串的知识。因此，在完成这两道题目时，我花费了很多时间在 MOOC、CSDN 和百度搜索上寻找基础代码学习，才能够完成第一次作业。总的来说，第一次作业相对简单，我没有想到要使用面向对象的思维去解题，而是延续之前写题的习惯，直接上手解题，缺乏思考和分析。这与题目的相对简单性有很大的关系。
第二次作业：
这次的作业难度有了较大的提升，都是很基础的内容。
7-1 成绩计算-1-类、数组的基本运用
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
注意：未用学生类对象封装数据的，本题计0分
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00 22201312 黄昊 229 76.33 22201313 李少辰 233 77.67 22201314 袁婷 231 77.00 22201315 朱哲一 266 88.67
import java.util.Scanner; /** * Created with IntelliJ IDEA. * * @author : halalala222 * @version : 1.0 */ class Student { String studentID; String name; int chineseScore; int mathScore; int physicsScore; 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; } @Override public String toString() { int totalScore = this.chineseScore + this.mathScore + this.physicsScore; float averageScore = (float) totalScore / 3; return this.studentID + " " + this.name + " " + totalScore + " " + String.format("%.2f", averageScore); } } public class Main { public static int studentNum = 5; public static void main(String[] args) { Scanner scanner = new Scanner(System.in); for (int i = 0; i < studentNum; i++) { String studentID = scanner.next(); String name = scanner.next(); int chineseScore = scanner.nextInt(); int mathScore = scanner.nextInt(); int physicsScore = scanner.nextInt(); Student student = new Student(studentID, name, chineseScore, mathScore, physicsScore); if (i != studentNum - 1) { System.out.println(student); } else { System.out.print(student); } } } }
期间，我也遇到过很多困难，因为对Java语言和字符串的陌生，我很多东西都要上网查询，或者翻书查找。代码提交通过不了，通过eclip的debug功能才发现。
定义了一个 Student 类，包含学生的学号、姓名和三门科目的成绩，还有计算总分和平均分的方法。然后在主函数中，使用 Scanner 对象从标准输入读入每个学生的信息，创建一个 Student 对象，并将其转换成字符串形式输出，其中保留两位小数（使用 String.format 方法）。最后一个 Student 对象后没有空格，而是回车。
这段代码的运行时间是 O(N)，其中 N 是学生数量。由于学生数量固定为 5，因此该代码的时间复杂度是 O(1)。是一个非常高效的算法。
7-2 成绩计算-2-关联类
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67 22201312 黄昊 234 75.00 80.67 78.00 22201313 李少辰 236 83.67 76.00 78.67
import java.lang.reflect.Member; import java.util.Scanner; /** * Created with IntelliJ IDEA. * * @author : halalala222 * @version : 1.0 */ class Student { public static double usualScoreProportion = 0.4; public static double finalScoreProportion = 0.6; String studentID; String name; Score chineseScore; Score mathScore; Score physicsScore; Student(String studentID, String name) { this.studentID = studentID; this.name = name; } public void setChineseScore(Score chineseScore) { this.chineseScore = chineseScore; } public void setMathScore(Score mathScore) { this.mathScore = mathScore; } public void setPhysicsScore(Score physicsScore) { this.physicsScore = physicsScore; } @Override public String toString() { int totalScore = this.chineseScore.getTotalScore() + this.physicsScore.getTotalScore() + this.mathScore.getTotalScore(); int totalUsualScore = this.chineseScore.usualScore + this.physicsScore.usualScore + this.mathScore.usualScore; int totalFinalScore = this.chineseScore.finalScore + this.physicsScore.finalScore + this.mathScore.finalScore; float averageScore = (float) totalScore / 3; return this.studentID + " " + this.name + " " + totalScore + " " + String.format("%.2f", (float) totalUsualScore / 3) + " " + String.format("%.2f", (float) totalFinalScore / 3) + " " + String.format("%.2f", averageScore); } } class Score { int usualScore; int finalScore; public Score(int usualScore, int finalScore) { this.usualScore = usualScore; this.finalScore = finalScore; } public int getTotalScore() { return (int) (this.usualScore * Student.usualScoreProportion + this.finalScore * Student.finalScoreProportion); } } public class Main { public static int studentNum = 3; public static int lessonNum = 3; public static String chineseLesson = "语文"; public static String mathLesson = "数学"; public static String physicsLesson = "物理"; public static void main(String[] args) { Scanner scanner = new Scanner(System.in); for (int i = 0; i < studentNum; i++) { Student student = null; for (int j = 0; j < lessonNum; j++) { String studentID = scanner.next(); String name = scanner.next(); String lesson = scanner.next(); int usualScore = scanner.nextInt(); int finalScore = scanner.nextInt(); if (j == 0) { student = new Student(studentID, name); } Score score = new Score(usualScore, finalScore); if (lesson.equals(mathLesson)) { student.setMathScore(score); } if (lesson.equals(chineseLesson)) { student.setChineseScore(score); } if (lesson.equals(physicsLesson)) { student.setPhysicsScore(score); } } if (i != studentNum - 1) { System.out.println(student); } else { System.out.print(student); } } } }
定义了一个学生类（Student）和成绩类（Score），并在主函数中使用 Scanner 对象从标准输入读入学生信息和成绩，并计算每个学生的总分、平时成绩、期末成绩和平均成绩。
学生类（Student）包含学生的学号（studentID）、姓名（name）以及语文成绩（chineseScore）、数学成绩（mathScore）和物理成绩（physicsScore）。该类还定义了设置各科成绩的方法。
成绩类（Score）包含平时成绩（usualScore）和期末成绩（finalScore），以及计算总分的方法（getTotalScore）。总分的计算公式为：平时成绩乘以平时成绩比例再加上期末成绩乘以期末成绩比例。
主函数根据预设的学生数（studentNum）和科目数（lessonNum），通过循环读取每个学生的学号、姓名和各科成绩。根据科目的名称，将对应的成绩对象设置给学生对象的相应成绩属性。最后，将每个学生对象转换为字符串形式输出，其中包括学生的学号、姓名、总分、平时成绩、期末成绩和平均成绩。
整个代码逻辑简单明了，功能是获取多个学生的成绩信息并输出。时间复杂度为 O(studentNum * lessonNum)，其中 studentNum 是学生数，lessonNum 是科目数。代码的效率较高，适用于小规模的数据处理任务。
7-7 菜单计价程序-1
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist 48
import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static void main(String[] args) { Menu menu = new Menu(new Dish[]{ new Dish("西红柿炒蛋", 15), new Dish("清炒土豆丝", 12), new Dish("麻婆豆腐", 12), new Dish("油淋生菜", 9) }); Order order = new Order(); List<String> notFounds = new ArrayList<>(); Scanner scanner = new Scanner(System.in); while (scanner.hasNextLine()) { String line = scanner.nextLine(); if ("end".equals(line)) { break; } String[] lineArray = line.split(" "); String dishName = lineArray[0]; int portion = Integer.parseInt(lineArray[1]); Dish dish = menu.searthDish(dishName); if (dish == null) { notFounds.add(dishName); } else { order.addARecord(dish, portion); } } for (String dishName : notFounds) { System.out.println(dishName + " does not exist"); } System.out.println(order.getTotalPrice()); } } class Menu { private final Dish[] dishes;//菜品数组，保存所有菜品信息 Menu(Dish[] dishes) { this.dishes = dishes; } Dish searthDish(String dishName) { for (Dish dish : dishes) { if (dish.getName().equals(dishName)) { return dish; } } return null; } } class Dish { String name; int unitPrice; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getUnitPrice() { return unitPrice; } public void setUnitPrice(int unitPrice) { this.unitPrice = unitPrice; } public Dish(String name, int unit_price) { this.name = name; this.unitPrice = unit_price; } int getPrice(int portion) { float[] b = {1, 1.5f, 2}; return Math.round((unitPrice * b[portion - 1])); } } class Record { Dish dish; int portion; public Dish getDish() { return dish; } public void setDish(Dish dish) { this.dish = dish; } public int getPortion() { return portion; } public void setPortion(int portion) { this.portion = portion; } public Record(Dish d, int portion) { this.dish = d; this.portion = portion; } int getPrice() { return dish.getPrice(portion); } } class Order { private final List<Record> records = new ArrayList<>();//保存订单上每一道的记录 //计算订单的总价 int getTotalPrice() { int sum = 0; for (Record record : records) { sum += record.getPrice(); } return sum; } //添加一条菜品信息到订单中。 void addARecord(Dish dish, int portion) { Record record = new Record(dish, portion); records.add(record); } }
实现了一个简单的餐厅点餐系统。餐厅菜单由 Menu 类定义，其中包含 Dish 对象数组，每个 Dish 对象保存一道菜的名字和价格。Order 类表示一个订单，保存了订单上的每一道菜品信息，通过 addARecord 方法添加一条记录到订单中，并通过 getTotalPrice 计算订单的总价。主函数使用 Scanner 对象从标准输入读入用户输入的菜品和份数，然后根据菜品名称查询菜品对象并添加到订单中，最后输出订单的总价。
代码逻辑简单明了，功能清晰，容易理解和维护。对于菜品的搜索采用了线性查找算法，时间复杂度为 O(n)，n 是菜品数量；计算一个订单的总价需要对订单上的所有菜品进行遍历，时间复杂度也是 O(n)，n 是订单中菜品的数量。因此，代码的时间复杂度与数据规模相关，适合小规模的数据处理任务。
第三次作业：
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）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例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 java.text.Collator; import java.util.*; class Matching { private final static String studentIdMatching = "[0-9]{8}"; private final static String studentNameMatching = "\\S{1,10}"; private final static String scoreMatching = "([1-9]?[0-9]|100)"; private final static String courseNameMatching = "\\S{1,10}"; private final static String courseNatureMatching = "(选修|必修)"; private final static String assessmentMethodTypeMatching = "(考试|考察)"; private final static String courseInput = courseNameMatching + " " + courseNatureMatching + " " + assessmentMethodTypeMatching; private final static String scoreInputWithoutUsualGrades = studentIdMatching + " " + studentNameMatching + " " + courseNameMatching + " " + scoreMatching; private final static String scoreInputWithUsualGrades = studentIdMatching + " " + studentNameMatching + " " + courseNameMatching + " " + scoreMatching + " " + scoreMatching; public static boolean Course(String input) { return input.matches(courseInput); } public static boolean Score(String input) { return input.matches(scoreInputWithoutUsualGrades) || input.matches(scoreInputWithUsualGrades); } } class Course implements Comparable<Course> { private final String name; private final String nature; private final String assessmentMethod; public static String requiredNature = "必修"; public static String electiveNature = "选修"; public static String examAssessmentMethod = "考试"; public static String inspectionAssessmentMethod = "考察"; public static int courseNameIndex = 0; public static int natureIndex = 1; public static int assessmentMethodIndex = 2; public Course(String name, String nature, String assessmentMethod) { this.name = name; this.nature = nature; this.assessmentMethod = assessmentMethod; } public String getName() { return name; } public String getNature() { return nature; } public String getAssessmentMethod() { return assessmentMethod; } @Override public int compareTo(Course o) { Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA); return compare.compare(name, o.getName()); } public boolean checkCourseMatch() { if (this.nature.equals(Course.electiveNature)) { return true; } return this.nature.equals(Course.requiredNature) && this.assessmentMethod.equals(Course.examAssessmentMethod); } } class ExamGrade implements Grade { private final int usualGrade; private final int finalGrade; public ExamGrade(int usualGrade, int finalGrade) { this.usualGrade = usualGrade; this.finalGrade = finalGrade; } public int getUsualGrade() { return usualGrade; } public int getTotalGrade() { double usualGradeProportion = 0.3; double finalGradeProportion = 0.7; return (int) (usualGrade * usualGradeProportion + finalGrade * finalGradeProportion); } @Override public int getFinalGrade() { return finalGrade; } } class InspectionGrade implements Grade { private final int finalGrade; public InspectionGrade(int finalGrade) { this.finalGrade = finalGrade; } public int getTotalGrade() { return finalGrade; } @Override public int getFinalGrade() { return finalGrade; } } interface Grade { int getTotalGrade(); int getFinalGrade(); } class Student implements Comparable<Student> { private final String name; private final int id; private final int classId; public static final int idIndex = 0; public static final int nameIndex = 1; public static final int courseIndex = 2; public static final int usualGradeIndex = 3; public static final int finalGradeIndex = 4; public int getId() { return id; } public String getName() { return name; } public int getClassId() { return classId; } public Student(int classId, int id, String name) { this.classId = classId; this.id = id; this.name = name; } public int compareTo(Student student) { return Integer.compare(id, student.id); } } class Class implements Comparable<Class> { private final int classId; public int getClassId() { return classId; } public Class(int classId) { this.classId = classId; } @Override public int compareTo(Class theClass) { return Integer.compare(classId, theClass.classId); } } class ChooseCourse { private final Course course; private final Student student; private final Grade grade; public ChooseCourse(Course course, Student student, Grade grade) { this.course = course; this.student = student; this.grade = grade; } public Course getCourse() { return course; } public Student getStudent() { return student; } public Grade getGrade() { return grade; } } public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String record = scanner.nextLine(); ParseInput handle = new ParseInput(); while (!record.equals("end")) { handle.parseInput(record); record = scanner.nextLine(); } handle.showStudents(); handle.showCourses(); handle.showClasses(); } } class ParseInput { ArrayList<Student> Students = new ArrayList<>(); ArrayList<Course> Courses = new ArrayList<>(); ArrayList<Class> Classes = new ArrayList<>(); ArrayList<ChooseCourse> ChooseCourses = new ArrayList<>(); private static final int inspectionDataLength = 4; private static final int examDataLength = 5; public void parseInput(String input) { if (Matching.Course(input)) { courseMessage(input); return; } if (Matching.Score(input)) { gradeMessage(input); return; } System.out.println("wrong format"); } public void courseMessage(String input) { String[] inputData = input.split(" "); String courseName = inputData[Course.courseNameIndex]; String nature = inputData[Course.natureIndex]; String assessmentMethod = inputData[Course.assessmentMethodIndex]; Course course = new Course(courseName, nature, assessmentMethod); if (checkCourse(course)) { if (isExitedCourse(courseName)) Courses.add(course); } } public void gradeMessage(String input) { String[] data = input.split(" "); String studentIdStr = data[Student.idIndex]; int classId = Integer.parseInt(studentIdStr.substring(0, 6)); int studentId = Integer.parseInt(studentIdStr); String name = data[Student.nameIndex]; String courseName = data[Student.courseIndex]; if (!isExitedClass(classId)) { Class newClass = new Class(classId); Classes.add(newClass); } Student student = new Student(classId, studentId, name); if (!isExitedStudent(studentId)) Students.add(student); if (isExitedCourse(courseName)) { System.out.println(courseName + " " + "does not exist"); } else { Course course = getCourseByName(courseName); if (data.length == inspectionDataLength && course.getAssessmentMethod().equals(Course.inspectionAssessmentMethod)) { int finalGrade = Integer.parseInt(data[Student.usualGradeIndex]); InspectionGrade assessGrade = new InspectionGrade(finalGrade); ChooseCourse chooseCourse = new ChooseCourse(course, student, assessGrade); if (!isExitedChooseCourse(studentId, courseName)) ChooseCourses.add(chooseCourse); return; } if (data.length == examDataLength && course.getAssessmentMethod().equals(Course.examAssessmentMethod)) { int usualGrade = Integer.parseInt(data[Student.usualGradeIndex]); int finalGrade = Integer.parseInt(data[Student.finalGradeIndex]); ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade); ChooseCourse chooseCourse = new ChooseCourse(course, student, examGrade); ChooseCourses.add(chooseCourse); return; } System.out.println(studentIdStr + " " + name + " " + ": access mode mismatch"); } } public boolean checkCourse(Course course) { if (!course.checkCourseMatch()) { System.out.println(course.getName() + " : course type & access mode mismatch"); return false; } return true; } public boolean isExitedClass(int classId) { for (Class theClass : Classes) { if (theClass.getClassId() == classId) return true; } return false; } public boolean isExitedCourse(String name) { for (Course course : Courses) { if (course.getName().equals(name)) return false; } return true; } public boolean isExitedStudent(int id) { for (Student stu : Students) { if (stu.getId() == id) return true; } return false; } public Course getCourseByName(String courseName) { for (Course course : Courses) { if (course.getName().equals(courseName)) return course; } return null; } public boolean isExitedChooseCourse(int studentId, String courseName) { for (ChooseCourse chooseCourse : ChooseCourses) { if (chooseCourse.getStudent().getId() == studentId && chooseCourse.getCourse().getNature().equals(courseName)) { return true; } } return false; } public void showStudents() { Collections.sort(Students); for (Student student : Students) { ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(student.getId()); if (!stuCourseSelects.isEmpty()) { System.out.println(student.getId() + " " + student.getName() + " " + getAvgTotalScore(stuCourseSelects)); } else { System.out.println(student.getId() + " " + student.getName() + " " + "did not take any exams"); } } } public void showCourses() { Collections.sort(Courses); for (Course course : Courses) { ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getName()); if (!stuCourseSelects.isEmpty()) { if (course.getAssessmentMethod().equals(Course.examAssessmentMethod)) { System.out.println(course.getName() + " " + getAvgUsualScore(stuCourseSelects) + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects)); } if (course.getAssessmentMethod().equals(Course.inspectionAssessmentMethod)) { System.out.println(course.getName() + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects)); } } else { System.out.println(course.getName() + " " + "has no grades yet"); } } } public void showClasses() { Collections.sort(Classes); for (Class cls : Classes) { ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId()); if (!stuCourseSelects.isEmpty()) { System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects)); } else { System.out.println(cls.getClassId() + " " + "has no grades yet"); } } } public ArrayList<ChooseCourse> getStudentSelects(int studentId) { ArrayList<ChooseCourse> choose = new ArrayList<>(); for (ChooseCourse chooseCourse : ChooseCourses) { if (chooseCourse.getStudent().getId() == studentId) { choose.add(chooseCourse); } } return choose; } public ArrayList<ChooseCourse> getCourseSelects(String courseName) { ArrayList<ChooseCourse> choose = new ArrayList<>(); for (ChooseCourse chooseCourse : ChooseCourses) { if (chooseCourse.getCourse().getName().equals(courseName)) { choose.add(chooseCourse); } } return choose; } public ArrayList<ChooseCourse> getClassSelects(int classId) { ArrayList<ChooseCourse> choose = new ArrayList<>(); for (ChooseCourse chooseCourse : ChooseCourses) { if (chooseCourse.getStudent().getClassId() == classId) choose.add(chooseCourse); } return choose; } public int getAvgTotalScore(ArrayList<ChooseCourse> chooseCourses) { int sum = 0; for (ChooseCourse chooseCourse : chooseCourses) { sum += chooseCourse.getGrade().getTotalGrade(); } return sum / chooseCourses.size(); } public int getAvgUsualScore(ArrayList<ChooseCourse> chooseCourses) { int sum = 0; for (ChooseCourse chooseCourse : chooseCourses) { Course course = chooseCourse.getCourse(); Grade grade = chooseCourse.getGrade(); if (course.getAssessmentMethod().equals(Course.examAssessmentMethod)) { sum += ((ExamGrade) grade).getUsualGrade(); } } return sum / chooseCourses.size(); } public int getAvgFinalScore(ArrayList<ChooseCourse> chooseCourses) { int sum = 0; for (ChooseCourse course : chooseCourses) { sum += course.getGrade().getFinalGrade(); } return sum / chooseCourses.size(); } }
三：踩坑心得
这三次作业当然也不可能是一帆风顺，路途中也是遭遇了很多风雨：
1. 对Java语言和字符串的陌生，我很多东西都要上网查询，或者翻书查找；
2. 第一次作业中，要使用float输出才能正确；
3. 但我在将字符串转化为坐标的时候遇到了一些问题，困扰了我一些时间：b = Double.parseDouble(n);这串代码是指将一个字符串类型的b，转化为double类型，但是我在使用的时候会有一些测试点过不了，原因是b有可能不能转化为double类型。之后通过上网查询资料，我了解到了可以使用异常处理来解决这个问题：
```java
try {
b = Double.parseDouble(n);
} catch (NumberFormatException e) {
// 处理异常，例如给b赋一个默认值或提示用户输入合法的数值
}
```
这段代码的意思是，尝试执行try代码块中的内容，如果转换失败，则执行catch代码块中的操作。这样做的好处是：(1). 可以解决一些测试点无法通过的问题；(2). 实现了对非法输入的判断和处理。
4. 在提交到pta时，如果直接全选eclipse中的内容复制粘贴，可能会连同包声明一起复制过来，导致全部错误。
四：改进建议
1. 第二次作业第二题，我认为使用截掉字符串的方法并不是最佳方案，建议尝试使用其他方法实现同样的功能；
2. 第三次作业第一题和第二题，可以考虑运用面向对象编程的思想，将数据存储到类中，并创建对象来获取相应属性，这样会更加方便和易于维护；
3. 第三次作业第三题，可以继续补充三角形类的特有方法，如判断三角形类型等，从而使程序更加丰富和完善。
五：总结
在学习Java的过程中，我经历了三次难度逐步上升的PTA大作业，从中学到了很多东西：
1. 掌握了Java的基础语法和应用，发现与之前学习的C语言相比，它们之间只有细微的差别，尤其是输入输出方面；
2. 渐渐理解了类的强大功能，并初步掌握了类与对象的使用方法，开始运用面向对象的思维方式解决问题；
3. 学习了许多关于字符串在Java中的使用方法，包括string类型的一些语法；
4. 提升了自主动手能力，并加强了思维能力。
同时，我也意识到还有一些需要进一步学习的方面：
1. 对于类这个强大的功能，我打算以后专注学习和灵活应用；
2. 我计划更多地使用面向对象的思维方式来分析问题，将问题细化为一个个小点，未来在做题之前先列出类，画出类图，进行深入思考。
