blog-3
总结pta成绩计算系列的题目：
1.代码：
class Calculate_grades {
final float normal_weight = 0.3f;
final float end_weight = 0.7f;
int stu_all_grades(Data_storage data_storage,String num){//单个学生总课程平均分计算 返回一个分数 1)
int count =0;//这个学生有几门课
int sum = 0;
for (Map.Entry<String, Score> entry : data_storage.stu__st_cour.get(num).gradeMap.entrySet()) {
String key = entry.getKey();
Score value = entry.getValue();
if(Integer.parseInt(value.total_scores)>=0) {
count++;
sum += Integer.parseInt(value.total_scores);
}
}
if(count!=0)
return sum/count;
else
return -100;//没有参加任何考试
}
int[] single_course_grades(Data_storage data_storage,String name){ //2) 课程名
int count = 0;
int[] aver_grade = new int[3];//0：平时成绩 1：期末考试 2：总分平均
for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//遍历选课类:num-选课类
StudentsAll_mes value = e.getValue();
for (Map.Entry<String, Score> entry : value.gradeMap.entrySet()) {//遍历选课类:course.name-Score
String key1 = entry.getKey();
Score value1 = entry.getValue();
if (key1.equals(name)) {
if(Integer.parseInt(value1.total_scores)>=0) {//总分为- 说明算成绩无效
count++;
aver_grade[2] += Integer.parseInt(value1.total_scores);
if (value1 instanceof Test_Score) {
if (Integer.parseInt(value1.total_scores) >= 0) {
aver_grade[0] += Integer.parseInt(((Test_Score) value1).normal_score);
aver_grade[1] += Integer.parseInt(((Test_Score) value1).end_score);
}
} else if (value1 instanceof Inspect_Score){
if (Integer.parseInt(value1.total_scores) >= 0) {
aver_grade[0] = -100;//不需要平时成绩
aver_grade[1] += Integer.parseInt(((Inspect_Score) value1).end_score);
}
}else if(value1 instanceof Lab_Score){
if(Integer.parseInt(value1.total_scores)>=0){
aver_grade[0] = -100;
aver_grade[1] += aver_grade[1] += Integer.parseInt(((Lab_Score) value1).total_scores); ;
}
}
}
}
}
}
if(count!=0) {
for (int i = 0; i < 3; i++) {
aver_grade[i] = aver_grade[i] / count;
}
}else {
for (int i = 0; i < 3; i++) {
aver_grade[i] = -100;
}
}
return aver_grade;
}
int Class_grades(Data_storage data_storage,String num){//3)
int sum = 0;
int count = 0;
for (Map.Entry<String, Student> mapEntry : data_storage.classes.get(num).students.entrySet()) {//班级号-Student类
Student value = mapEntry.getValue();//遍历这个班级的所有学生
for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//stu_num-选课类
String key1 = e.getKey();//遍历学生的选课类 学号
StudentsAll_mes value1 = e.getValue();
if (key1.equals(value.num)) {//选课类中 跟输入的学号一样
for (Map.Entry<String, Score> entry : value1.gradeMap.entrySet()) {//该num所有成绩遍历
Score gra = entry.getValue();
if(Integer.parseInt(gra.total_scores)>=0) {//有效才算
sum += Integer.parseInt(gra.total_scores);
count++;
}
}
}
}
}
if(count!=0)
return sum/count;
else
return -100;
}
void final_score(Data_storage data_storage,String num){//计算没门课的成绩 学号
data_storage.stu__st_cour.get(num).gradeMap.forEach((key,value)->{//学号 成绩
if(value instanceof Test_Score&&((Test_Score) value).normal_score.matches("\\d+")&&((Test_Score) value).end_score.matches("\\d+")) {
value.total_scores = String.valueOf((int)(normal_weight*Integer.parseInt(((Test_Score) value).normal_score)
+ end_weight*Integer.parseInt(((Test_Score) value).end_score)));
}else if(value instanceof Inspect_Score&&((Inspect_Score) value).end_score.matches("\\d+")){
value.total_scores = ((Inspect_Score) value).end_score;
}else if(value instanceof Lab_Score&&((Lab_Score) value).lab_num.matches("\\d+")){
int count = Integer.parseInt(((Lab_Score) value).lab_num);
int sum = 0;
for (Integer score : ((Lab_Score) value).scores) {
sum+=score;
}
value.total_scores = String.valueOf(sum/count);
}
});
}
}
class Class {
String num;
TreeMap<String, Student> students = new TreeMap<>(); //班级里的学生 学号 学生
Class(String num){
this.num = num;
}
}
class Course {
String type;
String test_way;
String name;
Course(String name,String type, String test_way){
this.type = type;
this.name = name;
this.test_way = test_way;
}
}
class Data_storage {
TreeMap<String , Course> courses;//课程 k：课程名 v:课程
TreeMap<String, Class> classes = new TreeMap<>();//班级 k:班级号V:班级
TreeMap<String, StudentsAll_mes> stu__st_cour;//选课类学生类结合 k:学号 v:选课类
WrongFormat_Check output = new WrongFormat_Check();
Data_storage(){
stu__st_cour = new TreeMap<>(new Comparator<String>(){//学生和选课类结合
@Override
public int compare(String o1, String o2) {
try {
Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
if (comparator.compare(o1, o2) < 0) {
return -1;
} else if (comparator.compare(o1, o2) > 0) {
return 1;
}
} catch (Exception e) {
}
return 0;
}
});//重写排序
courses = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
try {
Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
if (comparator.compare(o1, o2) < 0) {
return -1;
} else if (comparator.compare(o1, o2) > 0) {
return 1;
}
} catch (Exception e) {
}
return 0;
}
});
}
void setCourses(String name, String type, String test_way){
if(!courses.containsKey(name)) {
courses.put(name, new Course(name, type, test_way));
courses.get(name);
}
}
void setClasses(String num){
if(!classes.containsKey(num)) {
classes.put(num, new Class(num));
}
}
void setStudents(String clas_num, String name, String num){//班级号 姓名 学号
if(classes.containsKey(clas_num)){
classes.get(clas_num).students.put(num,new Student(name,num));
classes.get(clas_num).students.get(num);
}
}
void setStu__st_courAndMap(String num,String course,String normal_score,String end_score){//添加选课类 学生姓名 课程名称 分数
if(!stu__st_cour.containsKey(num)){
stu__st_cour.put(num,new StudentsAll_mes(num,course,normal_score,end_score));
}
else{
stu__st_cour.get(num).setGradeMap(course,normal_score,end_score);
}
}
void setStu__st_courAndMap(String num,String course,String end_score){
if(!stu__st_cour.containsKey(num)){
stu__st_cour.put(num,new StudentsAll_mes(num,course,end_score));
}
else{
stu__st_cour.get(num).setGradeMap(course,end_score);
}
}
void set_lab_grades(String stu_num,String course,String lab_num,String grades){
ArrayList<Integer> scores = new ArrayList<>();
String[] tem = grades.split(" ");
for(int i=4;i<tem.length;i++){
if(tem[i].matches("\\d+"))
scores.add(Integer.parseInt(tem[i]));
}
if(!stu__st_cour.containsKey(stu_num)){
StudentsAll_mes tem_stu_mes = new StudentsAll_mes();
tem_stu_mes.set_lab_stu_mes(stu_num,course,lab_num,scores);
stu__st_cour.put(stu_num,tem_stu_mes);
}else{
stu__st_cour.get(stu_num).set_lab_gradeMap(course,lab_num,scores);
}
}
}
class Input_Format {
String regex_c = "^[\\u4E00-\\u9FA5A-Za-z0-9]{1,10} +(必修|选修|实验)? *(考试|考察|实验)?$";
String regex_CS = "^\\d{8}\\s+[\\u4E00-\\u9FA5A-Za-z]{1,10}\\s+[\\u4E00-\\u9FA5A-Za-z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z ]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s[4-9]\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){1,20}$";
boolean isEnd = true;//结束标志
String[] strings;
void inputProcessing(String line,Data_storage data_storage) {
lineProcessing(line);//分割
data_storage.output.add_input(line);//存储
if(line.matches(regex_c)){
if(strings[1].equals("必修")&&strings[2].equals("考试")){
data_storage.setCourses(strings[0],strings[1],strings[2]);
}else if(strings[1].equals("选修")&&!strings[2].equals("实验")){
data_storage.setCourses(strings[0],strings[1],strings[2]);
}else if(strings[1].equals("实验")&&strings[2].equals("实验")){
data_storage.setCourses(strings[0],strings[1],strings[2]);
}
}else if(line.matches(regex_CS)||line.matches(regex_lab)){
data_storage.setClasses(strings[0].substring(0,6));
data_storage.setStudents(strings[0].substring(0, 6), strings[1], strings[0]);//学生的添加
if (data_storage.courses.containsKey(strings[2])) {//课程里有这个课
if (data_storage.courses.get(strings[2]).type.equals("选修")) {//
if (data_storage.courses.get(strings[2]).test_way.equals("考试")&&strings.length == 5) {
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3], strings[4]);
}else if(data_storage.courses.get(strings[2]).test_way.equals("考察")&&strings.length==4){
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3]);
} else {
data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
}
} else if (data_storage.courses.get(strings[2]).type.equals("必修")) {//
if (strings.length == 5) {
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3],strings[4]);
} else {//无效
data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
}
} else if(data_storage.courses.get(strings[2]).type.equals("实验")){
if(Integer.parseInt(strings[3])>=4&&Integer.parseInt(strings[3])<=9&&strings.length == 4+Integer.parseInt(strings[3])){
data_storage.set_lab_grades(strings[0],strings[2],strings[3],line);
}else{
data_storage.set_lab_grades(strings[0],strings[2],"num error","no access");
}
}
}else{
data_storage.setStu__st_courAndMap(strings[0], strings[2], "not exist");
}
}
}
void lineProcessing(String line){
strings = line.split(" ");
}
}
class Inspect_Score extends Score{
String end_score = "-100";
Inspect_Score(String end_score) {
this.end_score = end_score;
}
}
class Output_Format {
Calculate_grades calculate = new Calculate_grades();
String regex_c = "^[\\u4E00-\\u9FA5A-Za-z0-9]{1,10} +(必修|选修|实验)? *(考试|考察|实验)?$";
String regex_CS = "^\\d{8}\\s+[\\u4E00-\\u9FA5A-Za-z]{1,10}\\s+[\\u4E00-\\u9FA5A-Za-z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z ]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s([4-9]|1[0-9]|20)\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){1,20}$";
void outputProcessing(Data_storage data) {
data.classes.forEach((num,Class)->{
Class.students.forEach((name,student)->{
calculate.final_score(data,student.num);
});
});
for(String i:data.output.input){
String[] tem = i.split(" ");
if(i.matches(regex_c)){
if(tem[1].equals("必修")&&(tem[2].equals("考察")||tem[2].equals("实验"))){
data.output.add_output(tem[0] + " : course type & access mode mismatch");
}else if(tem[1].equals("实验")&&!tem[2].equals("实验"))
data.output.add_output(tem[0] + " : course type & access mode mismatch");
else if(tem[1].equals("选修")&&tem[2].equals("实验"))
data.output.add_output(tem[0] + " : course type & access mode mismatch");
}else if(i.matches(regex_CS)||i.matches(regex_lab)) {
if(!data.courses.containsKey(tem[2])){//不存在
data.output.add_output(tem[2]+" does not exist");
data.stu__st_cour.get(tem[0]).gradeMap.remove(tem[2]);
}else{
if(data.courses.get(tem[2]).type.equals("必修") && tem.length!=5) {//必修 但是只有期末成绩
data.output.add_output(tem[0]+" "+tem[1]+" : access mode mismatch");
}else if(data.courses.get(tem[2]).type.equals("选修")) {
if ((data.courses.get(tem[2]).test_way.equals("考试") && tem.length != 5) ||
(data.courses.get(tem[2]).test_way.equals("考察") && tem.length != 4))
data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
}else if(data.courses.get(tem[2]).type.equals("实验")){
if(data.courses.get(tem[2]).test_way.equals("实验")&&Integer.parseInt(tem[3])>=4&&Integer.parseInt(tem[3])<=9&&tem.length!=4+Integer.parseInt(tem[3]))
data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
if(data.courses.get(tem[2]).test_way.equals("实验")&&(Integer.parseInt(tem[3])<4||Integer.parseInt(tem[3])>9)) {
data.output.add_output("wrong format");
}
}
}
}else if(!i.equals("end")){
data.output.add_output("wrong format");
}
}
data.classes.forEach((cla_num,Class1)->{//遍历所有班级
Class1.students.forEach((stu_num,student)->{
int tem=calculate.stu_all_grades(data,stu_num);
if(tem>=0)
data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+tem);
else
data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+"did not take any exams");
});
});
data.courses.forEach((key,value)-> {
int[] tem = calculate.single_course_grades(data, key);
if (tem[0] < 0 && tem[1] < 0 && tem[2] < 0) {//三个为- 则没成绩
data.output.add_output(key + " has no grades yet");
}else {
if (value.type.equals("选修")) {
if(value.test_way.equals("考察"))
data.output.add_output(key + " " + tem[1] + " " + tem[2]);
else
data.output.add_output(key + " " + tem[0] + " " + tem[1] + " " + tem[2]);
} else if (value.type.equals("必修")) {
data.output.add_output(key + " " + tem[0] + " " + tem[1] + " " + tem[2]);
} else if(value.type.equals("实验")){
data.output.add_output(key+ " " +tem[2]);
}
}
});
data.classes.forEach((num,Class)->{
int tem = calculate.Class_grades(data,num);
if(tem>=0) {
data.output.add_output(num + " " + tem);
}else
data.output.add_output(num+" has no grades yet");
});
}
void output_all(Data_storage data){
data.output.output.forEach(System.out::println);
}
}
class StudentsAll_mes {
String num;//学生
TreeMap<String,Score> gradeMap =new TreeMap<>();
StudentsAll_mes(String stu_name, String course, String normal_score,String test_score){
this.num = stu_name;
gradeMap.put(course,new Test_Score(normal_score,test_score));
}
StudentsAll_mes(String stu_name, String course, String test_score){
this.num = stu_name;
gradeMap.put(course,new Inspect_Score(test_score));
}
public StudentsAll_mes() {
}
void set_lab_stu_mes(String stu_num,String course,String lab_num,ArrayList<Integer> scores){
this.num = stu_num;
gradeMap.put(course,new Lab_Score(lab_num,scores));
}
void set_lab_gradeMap(String course,String lab_num,ArrayList<Integer> scores){
if(!gradeMap.containsKey(course))
gradeMap.put(course,new Lab_Score(lab_num,scores));
}
void setGradeMap(String course, String normal_score,String test_score){
if(!gradeMap.containsKey(course))
gradeMap.put(course, new Test_Score(normal_score,test_score));
}
void setGradeMap(String course,String test_score){
if(!gradeMap.containsKey(course))
gradeMap.put(course,new Inspect_Score(test_score));
}
}
class Lab_Score extends Score {
String lab_num;//试验次数
final int min_num = 4;
final int max_num = 9;
ArrayList<Integer> scores = new ArrayList<>();
Lab_Score(String lab_num,ArrayList<Integer> scores){
this.lab_num = lab_num;
this.scores = scores;
}
}
class WrongFormat_Check {
List<String> output = new ArrayList<>();
List<String> input = new ArrayList<>();
void add_output(String out){
output.add(out);
}
void add_input(String out){
input.add(out);
}
}
2.分析：
a：首先因为自身原因，未能全部写出该系列题目写了前面两题大致上，且没得满分，只能讲讲自身错误及所用的知识点。
b：题目自身第一次作业给出口类图，让我难以理解，思考了很久，才勉强写出了一点思路的设计，尤其总是难以理解学生，课程，选课，班级几个类之间的关系。
c：对于各个信息的处理，存储，添加，删除等做的不够好，有些条例不清晰，例如下面，需配合其他方法才能达到相应的需求。
class Class {
String num;
TreeMap<String, Student> students = new TreeMap<>(); //班级里的学生 学号 学生
Class(String num){
this.num = num;
}
}
d：对于Map函数的使用不够熟练，不能轻松写出与Map相关的方法，也不能快速正确的行使Map方法的内容，例如下码，使用TreeMap实现对课程名称的排序和管理时不能顺利写出，需要大量查阅资料且时常写错方法。
class Data_all {
TreeMap<String, Course> courses;
TreeMap<String, Class> classes = new TreeMap<>();
TreeMap<String, ChooseClass> stu__st_cour;
HashMap<String, ArrayList<String>> course_up = new HashMap<>();
Data_all() {
stu__st_cour = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
try {
Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
if (comparator.compare(o1, o2) < 0) {
return -1;
} else if (comparator.compare(o1, o2) > 0) {
return 1;
}
} catch (Exception e) {
}
return 0;
}
});//重写排序
courses = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
try {
Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
if (comparator.compare(o1, o2) < 0) {
return -1;
} else if (comparator.compare(o1, o2) > 0) {
return 1;
}
} catch (Exception e) {
}
return 0;
}
});
}
void setCourses(String name, String type, String test_way) {
if (!courses.containsKey(name)) {
courses.put(name, new Course(name, type, test_way));
}
}
void setClasses(String num) {
if (!classes.containsKey(num))
classes.put(num, new Class(num));
}
void setStudents(String clas_num, String name, String num) {//班级号 姓名 学号
if (classes.containsKey(clas_num)) {
classes.get(clas_num).students.put(num, new Student(name, num));
}
}
void setStu__st_courAndMap(String num, String course, String normal_score, String end_score) {//添加选课类 学生姓名 课程名称 分数
if (!stu__st_cour.containsKey(num)) {
stu__st_cour.put(num, new ChooseClass(num, course, normal_score, end_score));
} else {
stu__st_cour.get(num).Setgrade(course, normal_score, end_score);
}
}
void setStu__st_courAndMap(String num, String course, String end_score) {
if (!stu__st_cour.containsKey(num)) {
stu__st_cour.put(num, new ChooseClass(num, course, end_score));
} else {
stu__st_cour.get(num).Setgrade(course, end_score);
}
}
void course_up_add(String num, String course) {
if (!course_up.containsKey(num)) {
ArrayList<String> tem = new ArrayList<>();
tem.add(course);
course_up.put(num, tem);
} else {
course_up.get(num).add(course);
}
}
}
e：在日常编码中，充分利用Java自带的函数库可以使我们更加高效地解决一些问题，避免不必要的麻烦，并且让我们的代码更具优雅性。因此，我们需要注重学习Java标准库中提供的各种方法和类，这些方法和类通常都有详细的文档说明，对于快速解决实际应用问题非常有帮助。最终，我们应该力求让自己的代码既能表达自己的意图，又能为其他人所理解，这也是一个好的编程习惯,就比如list和hashmap的对比,
我觉得产生以上问题的主要原因应该是我对应用JAVA编程不够熟练，各种语法不能够全面的了解，熟练的运用。
f：第一次大作业的代码没有很完善，许多地方的逻辑都不对，导致后面的迭代都十分困难。一些嵌套语句使用过多，没有做到老师说的降低圈复杂度，而且主函数里面的判断和执行语句十分冗杂，没有做到让每个类执行好他相应的职责。一开始对类图设计代码的时候也过于草率，导致后面写代码时没有一个良好的框架，遇到问题总是拆了东墙补西墙，经常过不了测试点就强行加if else语句去硬生生过测试点。这样不仅不能为后续的迭代过程做好铺垫，而且不能做到一个良好的程序应该有的可持续性和可维护性。在排序问题中，我应该加强一下我对自定义Comparator比较器的运用。
g：上述是一次作业的类图及圈复杂度的相关图片。
2.
总结：
一个困难是写出来的程序总是编译不过去，有时候会出一些很奇怪的报错，找不到原因在哪，我用了IDEA，但有时候就是找不到出错原因在哪可能有结构上的问题，另外一个困难是有时候不知道该怎么实现题目要求的功能，不知道怎么办，题目要求的功能用代码实现出来，并与以前的代码相契合，我经常会加了某一个功能之后就代码运行不了，要么是编译错误，要么是逻辑错误。好在现在我已经优化了一些地方，弥补了一些遗憾，正如上面展示的代码和分析一样。在日常编码中，充分利用Java自带的函数库可以使我们更加高效地解决一些问题，避免不必要的麻烦，并且让我们的代码更具优雅性。因此，我们需要注重学习Java标准库中提供的各种方法和类，这些方法和类通常都有详细的文档说明，对于快速解决实际应用问题非常有帮助。最终，我们应该力求让自己的代码既能表达自己的意图，又能为其他人所理解，这也是一个好的编程习惯,就比如list和hashmap的对比,
我觉得产生以上问题的主要原因应该是我对应用JAVA编程不够熟练，各种语法不能够全面的了解，熟练的运用。为使我们的代码更加易读易维护，我们需要在对类名、对象名的取名以及注释中注重见名知义的原则。这一点会变得更加明显，尤其是当我们写了很长的代码后，回忆前面写的内容也会变得困难。Java语言提供了许多文档和类库，通过熟练掌握这些文档和库函数，既可以减少不必要的工作量，又可以提高代码效率和质量，让我们的代码更加整洁易懂。学到了很多java自带的类和接口的使用以及有能力进行重写。类与类之间的各种关系也锻炼了我的逻辑思维能力，但还是题目做少了，类图转换为代码的能力还有待提高，因为我总是漫无目的的对这类图开始写一道题的代码，没有做到心中有一个成熟的框架。我认为蔡柯老师的课非常还，可惜的是我自己因为偷懒，没有在课外时间对java语法进行系统学习，导致本阶段学习一直有跟不上老师，这是我自己的问题。而作业我认为可能对我来说，迭代的大作业难度还是有点高，经常不能按时完成导致没有拿分。实验课很好，例如农夫过河的代码问题也十分有趣，课上老师可以想办法让课堂更加幽默有趣，这样可以让枯燥的java学习变得容易一些，课下可以增加一些组织活动，比如抽几个人写代码比比赛之类的，怎加同学感情的通知让大家愿意去课外自学更多的编程知识。
浙公网安备 33010602011771号