BLOG-3

(1)前言

本次博客主要涵盖了Java题目的几个主要知识点，包括：

1. 面向对象的基础知识：这部分主要包括了类和对象的基本概念，构造方法，访问权限和成员变量的相关内容。在面向对象编程中，对这些基础知识的理解至关重要。

2. 面向对象的设计原则：这个题目强调了两个重要的设计原则，即继承和组合。学生需要深入了解这两种设计原则的区别，并能根据实际需求选择合适的设计原则来解决问题。

3. 异常处理：在这个题目中，涉及到了大量的异常情况，学生需要能够正确地处理这些异常。异常处理是Java编程中必不可少的一部分，对于保证程序的稳定性和可靠性非常重要。

4. 字符串处理：题目涉及到了大量的字符串处理，包括字符串的拆分、组合和转换等。这部分内容对于处理输入和输出的格式非常关键，学生需要具备相应的字符串处理技巧。

5. 基础的控制流和数据结构：题目中还涉及到了一些基础的控制流和数据结构，比如循环、条件语句、数组和列表等。对于这些基础知识的掌握，对于解决问题非常重要。

整个题目的难度属于中等偏上，适合用来考察学生对面向对象设计原则和异常处理的理解。题目的数量适中，涵盖了多个细节和需求，包括各种异常处理和特殊情况的处理。

第一次作业：练习类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构；练习数据的输入与输出；理解抽象类与子类的关系，代码聚合性的调试。

第二次作业：练习类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构；练习数据的输入与输出；理解抽象类与子类的关系，代码聚合性的调试，HashMap的构造及使用，多态的原理及使用。

第三次作业：练习类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构；练习数据的输入与输出；理解抽象类与子类的关系，代码聚合性的调试，ArrayList的构造及使用，接口的原理及使用，接口的原理及使用。

题量

第一次作业：1题

第二次作业：4题

第三次作业：5题

难度等情况

第一次作业：简单

第二次作业：中等

第三次作业：较难

(2)设计与分析

7-2 容器-HashMap-排序

分数 10

作者蔡轲

单位南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用HashMap存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

输入样例:

在这里给出一组输入。例如：

20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end

输出样例:

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

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

 1 //动物发生模拟器.  请在下面的【】处添加代码
 2 import java.util.HashMap;
 3 import java.util.*;
 4 import java.util.Map;
 5 public class Main {
 6     public static void main(String[] args) {
 7         Map<String,Student> map = new HashMap<String,Student>();
 8         Scanner input = new Scanner(System.in) ;
 9         String m="0";
10         Student[] stu = new Student[20] ;
11         int p=0;
12         while(!m.equals("end") ){
13             m =  input.nextLine();
14             String[] t = m.split(" ") ;
15             Student stu1 = new Student();
16             if(m.equals("end"))
17                 break;
18             stu1.id = t[0];
19             stu1.name  =t[1];
20             stu1.score  = Integer.parseInt(t[2]);
21             stu[p] =new Student() ;
22             stu[p] = stu1;
23             p++;
24 
25         }
26         int i,k;
27         for(i=0;i< p ;i++) {
28             for (k = p - 1; k > i; k--) {
29                 if (compareStrings(stu[i].id, stu[k].id) == 0) {
30                     Student tem = new Student();
31                     tem = stu[i];
32                     stu[i] = stu[k];
33                     stu[k] = tem;
34                 }
35             }
36         }
37         for(i= 0;i< p ;i++)
38         map.put(String.valueOf(i+1),stu[i]);
39         Set<String> keySet = map.keySet();
40         for (String key : keySet){
41             Student value = map.get(key);
42                 System.out.println(value.id +' '+value.name+' '+value.score);
43         }
44 
45     }
46     public static int compareStrings(String s1, String s2) {
47         s1 = s1.toLowerCase() ;
48         s2 = s2.toLowerCase() ;
49         int comparedResult = s1.compareTo(s2);
50 
51         if (comparedResult > 0) {
52             return 1;
53         }
54         else if(comparedResult < 0)
55             return 0;
56         else {
57             return -1;
58         }
59 
60     }
61 }
62 class Student {
63     String id;
64     String name ;
65     int  score;
66 }

在这个题中我的想法是，先把数据排序再压入哈希map中，当然我的一些同学是用listarry数组进行排序的。

7-3 课程成绩统计程序-2

分数 60

作者蔡轲

单位南昌航空大学

课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。

某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

实验的总成绩等于课程每次实验成绩的平均分

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修、实验

考核方式输入选项：考试、考察、实验

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩

实验次数至少4次，不超过9次

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

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 实验 实验
20201103 张三 java 4 70 80 90
end

输出样例1:

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

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

输入样例2:

在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 3 70 80 90
end

输出样例2:

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

wrong format
java has no grades yet

输入样例3:

在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 3 70 80 90 100
end

输出样例3:

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

java : course type & access mode mismatch
wrong format

输入样例4:

在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 4 70 80 90 105
end

输出样例4:

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

java : course type & access mode mismatch
wrong format

输入样例5:

在这里给出一组输入。例如：

java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end

输出样例5:

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

20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77

代码长度限制

30 KB

时间限制

1000 ms

内存限制

64 MB

  1 import java.text.Collator;
  2 import java.util.*;
  3 
  4 public class Main {
  5     public static void main(String[] args) {
  6         Scanner input = new Scanner(System.in);
  7         ParseInput handle=new ParseInput();
  8         int na = 1;
  9         while (na==1) {
 10             String  line = input.nextLine() ;
 11             if(line.equals("end") )
 12                 break;
 13             handle.parseInput(line);//解析用户输入的每一行数据
 14 
 15         }
 16         handle.showStudents();
 17         handle.showCourses();
 18         handle.showClasses();
 19     }
 20 }
 21 class ParseInput{
 22     ArrayList <Student> listStudent=new ArrayList<>();
 23     List<Course> listCourse=new ArrayList<>();
 24     List<Class> listClass=new ArrayList<>();
 25     List<ChooseCourse> listChooseCourse=new ArrayList<>();
 26     public void parseInput(String str){
 27         InputMat mat=new InputMat();
 28         int flag=mat.matchingInput(str);
 29         String letters[]=str.split(" ");
 30     
 31         switch (flag){
 32             case 0:System.out.println("wrong format");
 33                 break;
 34             //课程信息
 35             case 1:{
 36 
 37                 String coName=letters[0];//课程名
 38                 String type=letters[1];//课程类型
 39                 String testType=letters[2];//课程考试类型
 40                 Course course = new Course() ;
 41                 course.courseName = coName ;
 42                 course.type = type ;
 43                 course.testType  = testType ;
 44                 if(checkCourse(course)){
 45                     if(searchCourse(coName)==null)
 46                         listCourse.add(course);
 47                 }
 48                 break;
 49             }
 50             //成绩信息
 51             case 2: {
 52                 if(letters.length >5){
 53                     int p =letters.length -4;
 54                     int tim = Integer.parseInt(letters [3]);
 55                     if(tim<4||tim>9){
 56                         System.out.println("wrong format");
 57                         break;
 58                     }
 59                     int k=0;
 60                     for(int i = p; i<letters.length;i++){
 61                         if(Integer.parseInt(letters[i] ) >100)
 62                            k=1;
 63                     } 
 64                     if(k==1) {
 65                         System.out.println("wrong format");
 66                         break;
 67                     }
 68                 }
 69                 String stuId= letters[0];//学生学号
 70                 int p =letters.length -4;
 71                 int tim = Integer.parseInt(letters [3]);
 72                 String classID= letters[0].substring(0,6);
 73                 String name=letters[1];//学生姓名
 74                 String courseName=letters[2];//课程名字
 75 
 76                 //如果该班级第一次出现
 77                 if(searchClass(classID)==null){
 78                     Class cla=new Class();
 79                     cla.classId  = classID ;
 80                     listClass.add(cla);
 81                 }
 82 
 83                 Student stu = new Student() ;
 84                 stu.id = stuId ;
 85                 stu.clsId = classID ;
 86                 stu.stuName = name ;
 87 
 88                 if(!searchStudent(stuId))
 89                     listStudent.add(stu);//将学生加入列表中
 90                 //课程是否存在
 91                 if(searchCourse(courseName)==null){
 92                     System.out.println(courseName+" "+"does not exist");
 93                 }
 94                 //当课程存在时
 95                 else if(searchCourse(courseName)!=null){
 96                     Course course=searchCourse(courseName);
 97                     //考察
 98                     if(letters.length==4&&course.testType.equals("考察")){
 99                         int finalGrade= Integer.parseInt(letters[3]);
100                         AssessGrade assessGrade=new AssessGrade(finalGrade);
101                         course.flag  = 0;
102                         ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
103                         if(!searchChooseCourse(name,courseName))
104                             listChooseCourse.add(chooseCourse);
105                     }
106                     //考试
107                     else if(letters.length==5&&course.testType.equals("考试")){
108                         int usualGrade= Integer.parseInt(letters[3]);
109                         int finalGrade= Integer.parseInt(letters[4]);
110                         ExamGrade examGrade=new ExamGrade(usualGrade,finalGrade);
111                         course.flag =1;
112                         ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
113                         listChooseCourse.add(chooseCourse);
114                     }
115                     //实验
116                     else if(letters.length>5&&course.testType.equals("实验")&&p==tim) {
117                         if (Integer.parseInt(letters[3]) >= 4 && Integer.parseInt(letters[3]) <= 9) {
118                             if ((letters.length - 4) == Integer.parseInt(letters[3])) {
119                                 int sum = 0;
120                                 for (int i = 0; i < letters.length - 4; i++) {
121                                     sum += Integer.parseInt(letters[4 + i]);
122                                 }
123                                 int grade = sum / Integer.parseInt(letters[3]);
124                                 AssessGrade assessGrade=new AssessGrade(grade);
125                                 course.flag  = 2;
126                                 ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
127                                 if(!searchChooseCourse(name,courseName))
128                                     listChooseCourse.add(chooseCourse);
129                             } else {
130                                 System.out.println("wrong format");
131                                 break;
132                             }
133 
134                         }
135                     }
136 
137                     else{
138                         //学号+英文空格+姓名+英文空格+": access mode mismatch"
139                         System.out.println(stuId+" "+name+" "+": access mode mismatch");
140                     }
141                 }
142                 break;
143             }
144 
145         }
146     }
147     public boolean checkCourse(Course course){
148         int flag1,flag2;
149         if(course.getType().equals("必修") ){
150             flag1 = 0;
151         }
152         else if(course.getType().equals("选修") ){
153             flag1 = 1;
154         }
155         else if(course.getType().equals("实验")){
156             flag1 = 3;
157         }
158         else {
159             flag1  = 2;
160         }
161         if(course.getTestType() .equals("考试") ){
162             flag2 = 0;
163         }
164         else if(course.getTestType() .equals("考察") ){
165             flag2 = 1;
166         }
167         else if(course.getTestType() .equals("实验")){
168             flag2 = 3;
169         }
170         else {
171             flag2  = 2;
172         }
173         if(flag1==0&&flag2==0)
174             return true;
175         if(flag1==1&&(flag2==0||flag2==1))
176             return true;
177         if(flag1==3&&flag2==3)
178             return true;
179         System.out.println(course.getCourseName()+" : course type & access mode mismatch");
180         return false;
181     }
182 
183     public Class searchClass(String classId){
184         for(Class cls:listClass){
185             if(cls.getClassId().equals(classId))
186                 return cls;
187         }
188         return null;
189     }
190     public Course searchCourse(String name){
191         for(Course course:listCourse){
192             if(course.getCourseName().equals(name))
193                 return course;
194         }
195         return null;
196     }
197     public boolean searchStudent(String id){
198         for(Student stu:listStudent){
199             if(stu.getId().equals(id))
200                 return true;
201         }
202         return false;
203     }
204     //查找是否有重复选课成绩
205     public boolean searchChooseCourse(String stuName,String courseName){
206         for(ChooseCourse cs:listChooseCourse){
207             if(cs.student.getStuName().equals(stuName)&&cs.course.getCourseName().equals(courseName))
208                 return true;
209         }
210         return false;
211     }
212     public void showStudents(){
213         Collections.sort(listStudent);
214         int j,t;
215         int[] arr1 = new int[listStudent.size()+2];
216         Student[] stu3 = new Student[listStudent.size() ] ;
217         for(j=0;j<listStudent.size() ;j++){
218             Student stu1 = listStudent.get(j);
219             String a = stu1.id.substring(6,8) ;
220             arr1[j]= Integer.parseInt(a) ;
221             stu3[j] = new Student() ;
222             stu3[j] = stu1;
223         }
224 
225         for(int i=0;i<listStudent.size();i++){
226             Student stu=stu3[i];//listStudent.get(i);
227             //从总选课表listChooseCourse中获取该生的选课记录
228             ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
229             if(stuCourseSelects.size()==0) {
230                 System.out.print(stu.getId()+" "+stu.getStuName()+" ");
231                 System.out.println("did not take any exams");
232             }
233             else {
234                 System.out.print(stu.getId()+" "+stu.getStuName());
235                 System.out.println(" "+getAvgTotalScore(stuCourseSelects));
236             }
237         }
238     }
239     public void showCourses(){
240         Collections.sort(listCourse);
241         int j,t;
242         int[] arr3 = new int[listCourse.size()+1] ;
243         Course[] cou2 = new Course[listCourse.size() +2] ;
244         for(j=0;j<listCourse.size() ;j++){
245             Course course=listCourse.get(j);
246             cou2[j] = new Course() ;
247             cou2[j] = course;
248             ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
249             if(stuCourseSelects.size()!=0){
250                 if(course.getFlag() ==1)
251                     arr3[j] = getAvgTotalScore(stuCourseSelects ) ;
252                 if(course.getFlag() == 0)
253                     arr3[j] = getAvgTotalScore(stuCourseSelects ) ;
254             }
255             else {
256                 arr3[j] = -1;
257             }
258         }
259         for(j=0;j<listCourse.size() ;j++){
260             for(t=listClass .size()-1;t>j;t--) {
261                 if (arr3[j] != -1 || arr3[j - 1] != -1) {
262                     if (arr3[j] > arr3[t-1]) {
263                         int tem = arr3[j];
264                         arr3[j] = arr3[t];
265                         arr3[t] = tem;
266                         Course cou3 = new Course();
267                         cou3 = cou2[j];
268                         cou2[j] = cou2[t];
269                         cou2[t] = cou3;
270                     }
271                 }
272             }
273         }
274         for(int i=0;i<listCourse.size();i++){
275             Course course=listCourse.get(i) ;
276             ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
277             if(stuCourseSelects.size()!=0){
278                 if(course.getFlag() ==1)
279                     System.out.println(course.getCourseName()+" "+getAvgUsualScore(stuCourseSelects)+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
280                 if(course.getFlag() == 0)
281                     System.out.println(course.getCourseName()+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
282                 if(course.getFlag() == 2)
283                     System.out.println(course.getCourseName()+" "+getAvgTotalScore(stuCourseSelects));
284 
285             }
286             else {
287                 System.out.println(course.courseName+" "+"has no grades yet");
288             }
289         }
290     }
291     public void showClasses(){
292         Collections.sort(listClass);
293         int j,t;
294         int[] arr2 = new int[listClass.size() +1] ;
295         Class[] cla1 = new Class[listClass.size() ] ;
296         for(j=0;j<listClass.size() ;j++){
297             Class clasd1 =new Class() ;
298             clasd1 = listClass.get(j);
299             arr2[j] = Integer.parseInt(clasd1.getClassId() )-Integer .parseInt(listClass.get(0).getClassId()) ;
300             cla1[j] = new Class() ;
301             cla1[j] = clasd1  ;
302         }
303         for(j=0;j<listClass.size() ;j++){
304             for(t=j+1;t<listClass.size();t++){
305                 if(arr2[j]>arr2[t]){
306                     int temp = arr2[j];
307                     arr2[j] = arr2[t];
308                     arr2[t] = arr2[j];
309                     Class clasd2 = cla1[j];
310                     cla1[j] = cla1[t];
311                     cla1[t] = clasd2 ;
312                 }
313             }
314         }
315         for(int i=0;i<listClass.size();i++){
316             Class cls=cla1[i];
317             ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cls.getClassId());
318             if(stuCourseSelects.size()==0){
319                 System.out.print(cls.getClassId()+" ");
320                 System.out.println("has no grades yet");
321             }
322             else {
323                 System.out.print(cls.getClassId()+" ");
324                 System.out.println(getAvgTotalScore(stuCourseSelects));
325             }
326         }
327 
328     }
329     public ArrayList<ChooseCourse> getStudentSelects(String id){
330         ArrayList<ChooseCourse> choose=new ArrayList<>();
331         for(ChooseCourse cos:listChooseCourse) {
332             if (cos.student.getId().equals(id))
333                 choose.add(cos);
334         }
335         return choose;
336     }
337     public ArrayList<ChooseCourse> getCourseSelects(String courseName){
338         ArrayList<ChooseCourse> choose=new ArrayList<>();
339         for(ChooseCourse cos:listChooseCourse) {
340             if (cos.course.getCourseName().equals(courseName))
341                 choose.add(cos);
342         }
343         return choose;
344     }
345     public ArrayList<ChooseCourse> getClassSelects(String clsId){
346         ArrayList<ChooseCourse> choose =new ArrayList<>();
347         for(ChooseCourse cos:listChooseCourse) {
348             if (cos.student.getClsId().equals(clsId))
349                 choose.add(cos);
350         }
351         return choose;
352     }
353     public int getAvgTotalScore(ArrayList<ChooseCourse> cs){
354         int average=0;
355         int sum=0;
356         for(ChooseCourse c:cs) {
357             sum += c.grade.getTotalGrade();
358         }
359         average=sum/cs.size();
360         return average;
361     }
362     public int getAvgUsualScore(ArrayList<ChooseCourse> cs){
363         int average=0;
364         int sum=0;
365         for(ChooseCourse c:cs){
366             if(c.course.getFlag() == 1){
367                 sum+=c.grade.getUsualGrade();
368             }
369         }
370         average=sum/cs.size();
371         return average;
372     }
373     public int getAvgFinalScore(ArrayList<ChooseCourse> cs){
374         int average=0;
375         int sum=0;
376         for(ChooseCourse c:cs){
377             sum+=c.grade.finalGrade;
378         }
379         average=sum/cs.size();
380         return average;
381     }
382 }
383 class ChooseCourse{
384     Course course;
385     Student student;
386     Grade grade;
387     int flag;
388 
389     public ChooseCourse(Course course,Student student,Grade grade) {
390         this.course = course;
391         this.student=student;
392         this.grade=grade;
393     }
394 }
395 class Student implements Comparable<Student>{
396     String stuName;
397     String id;
398     String clsId;
399     public String getId(){
400         return id;
401     }
402     public String getStuName(){
403         return stuName;
404     }
405     public String getClsId(){
406         return clsId;
407     }
408     public int compareTo(Student stu){
409         int id = getId().compareTo(stu.getId());
410         return id;
411     }
412 }
413 class Course implements Comparable<Course>{
414     String courseName;
415     String type;
416     String testType;
417     int flag;
418     public Course() {
419 
420     }
421     public String getCourseName(){
422         return courseName;
423     }
424     public String getType(){
425         return type;
426     }
427     public String getTestType(){
428         return  testType;
429     }
430     public int getFlag (){
431         return flag;
432     }
433     public int compareTo(Course o) {
434         Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
435         int coursename = compare.compare(courseName,o.getCourseName());
436         return coursename ;
437     }
438 
439 }
440 class Class implements Comparable<Class>{
441     String classId;
442     public Class() {
443     }
444     public String getClassId(){
445         return classId;
446     }
447     public int compareTo(Class o) {
448         int claid = getClassId().compareTo(o.getClassId());
449         return claid;
450     }
451 }
452 abstract class Grade{
453     int finalGrade;
454     public Grade() {
455     }
456     public abstract int getUsualGrade();
457     public abstract int getTotalGrade();
458 }
459 
460 class ExamGrade extends Grade{
461     int usualGrade;
462 
463     public ExamGrade(int usualGrade,int finalGrade) {
464         this.usualGrade=usualGrade;
465         this.finalGrade=finalGrade;
466     }
467     public int getUsualGrade(){
468         return usualGrade;
469     }
470     public int getTotalGrade(){
471         int total = (int)(usualGrade*0.3+finalGrade*0.7);
472         return total;
473     }
474 }
475 
476 class AverGrade1 extends Grade{
477 
478     int sum=0,p=0;
479     int finalGrade;
480     public AverGrade1(int t){
481 
482         finalGrade = t;
483     }
484     @Override
485     public int getUsualGrade() {
486         return 0;
487     }
488 
489     @Override
490     public int getTotalGrade() {
491 
492 
493         return finalGrade;
494     }
495 }
496 class AssessGrade extends Grade{
497     public AssessGrade(int finalGrade) {
498         this.finalGrade=finalGrade;
499     }
500     public int getFinalGrade(){
501         return finalGrade;
502     }
503 
504     public int getUsualGrade() {
505         return 0;
506     }
507 
508     public int getTotalGrade(){
509         return finalGrade;
510     }
511 }
512 class InputMat {
513     static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
514     static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
515     static String scoreMatching = "([1-9]?[0-9]|100)";
516     static String scoreMatching1 = "([1-9]?[0-9]|100).*";
517     static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
518     static String courseTypeMatching = "(选修|必修|实验)";
519     static String checkCourseTypeMatching = "(考试|考察|实验)";
520 
521     //courseInput用于定义课程信息模式（正则表达式）
522     static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
523     //scoreInput用于定义成绩信息模式（正则表达式）
524     static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
525             scoreMatching ;
526     static String scoreInput2=  stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
527             scoreMatching + " " +scoreMatching;
528     static String scoreInput3=stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " "+scoreMatching+ " "+scoreMatching+" "+scoreMatching1 ;
529     public InputMat() {
530     }
531     public  int matchingInput(String s) {
532 
533         if (matchingCourse(s))
534             return 1;
535         if (matchingScore(s))
536             return 2;
537         return 0;
538 
539     }
540     //课程信息
541     private static boolean matchingCourse(String s) {
542         return s.matches(courseInput);
543     }
544     //成绩信息
545     private static boolean matchingScore(String s) {
546         if(s.matches(scoreInput1)||s.matches(scoreInput2)||s.matches(scoreInput3) )
547             return true;
548         return false;
549     }
550 
551 }

最后只有56分，因为只有一个半小时的时间，从24分到56分后来想改代码了，但是还有最后10秒了时间不够了，就没改过了，也没时间改了

7-1 立体图形问题

分数 10

作者段喜龙

单位南昌航空大学

编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。

类结构如下图所示（参考）：

试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input = new Scanner(System.in);
    double side = input.nextDouble();
        
    display(new Cube(side));
    display(new RegularPyramid(side));
}

其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。

注：正三棱锥的体积计算公式为底面积*高/3。

输入格式:

输入一个实型数，分别作为正方体的边长和正三棱锥的边长。

输出格式:

分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)

进行小数位数控制。

输入样例:

在这里给出一组输入。例如：

2.5

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        double side = input.nextDouble();

        display(new Cube(side));
        display(new RegularPyramid(side));
    }
     static void display(Solid st){
        System.out.println(String.format("%.2f", st.getArea()));
        System.out.println(String.format("%.2f", st.getVolume()));
    }
}

abstract class Solid{
    double t = 0;
     Solid(){

    }
    public double getSide(){
        return t;
    }
    public void getSide(double side){

    }
  Solid(double side){

    }
    public double getArea(){
        return 0;
    }
    public double getVolume(){
        return 0;
    }
}
class Cube extends Solid {
    double side;
   // double height;
     Cube(){

     }
    Cube(double side){
        this.side = side;
    }
    public double getArea(){
        return 6 * side * side;
    }
    public double getVolume(){
        return  side * side * side;
    }
}
class RegularPyramid extends Solid{
    double side;
    double height;
     RegularPyramid(){

    }
    RegularPyramid(double side){
         this.side = side;
    }
    public double getArea(){
        return 4.0*side*(Math.sqrt(side*side*3.0/4))/2.0;
    }
    public double getVolume() {
        double hig=Math.sqrt(side*side*3.0/4);
        return ((side*Math.sqrt(2.0/3.0)))*side*hig/2.0/3.0;
    }
}

7-2 魔方问题

分数 20

作者段喜龙

单位南昌航空大学

问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，即魔方边长=阶数*单元边长。魔方如下图所示：

利用“立体图形”问题源码，实现如下功能：

魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：

主方法部分可参考如下源码（可拷贝直接使用）：

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();        
        
        RubikCube cube1 = new SquareCube(color, layer,new Cube(side)); 
                
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        
        RubikCube cube2 = new RegularPyramidCube(color, layer,new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }
}

其中，display(RubikCube cube)方法为Main类中定义的静态方法，用户输出魔方的信息，用于体现多态性。

输入格式:

第一部分：正方体魔方颜色、阶数、单元正方体边长，以空格或回车分隔；

第二部分：正三棱锥魔方颜色、阶数、单元正三棱锥边长，以空格或回车分隔。

输出格式:

正方体魔方颜色

正方体魔方表面积

正方体魔方体积

正三棱锥魔方颜色

正三棱锥魔方表面积
正三棱锥魔方体积

注：小数点保留两位

输入样例:

在这里给出一组输入。例如：

red 3 4.5
black 4 2.1

输出样例:

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

red
1093.50
2460.38
black
122.21
69.85

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);

        // 输入正方体魔方信息
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();
        RubikCube cube1 = new SquareCube(color, layer, new Cube(side));

        // 输入正三棱锥魔方信息
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        RubikCube cube2 = new RegularPyramidCube(color, layer, new RegularPyramid(side));

        // 输出魔方信息
        display(cube1);
        display(cube2);
    }
    public static void display(RubikCube cube) {
        cube.displayInfo();
        System.out.println();
    }
}

abstract class Solid{
    double t = 0;
     Solid(){

    }
    public double getSide(){
        return t;
    }
    public void getSide(double side){

    }
  Solid(double side){

    }
    public double getArea(){
        return 0;
    }
    public double getVolume(){
        return 0;
    }
}
class Cube extends Solid {
    double side;
   // double height;
     Cube(){

     }
    Cube(double side){
        this.side = side;
    }
    public double getArea(){
        return 6 * side * side;
    }
    public double getVolume(){
        return  side * side * side;
    }
}
class RegularPyramid extends Solid{
    double side;
    double height;
     RegularPyramid(){

    }
    RegularPyramid(double side){
         this.side = side;
    }
    public double getArea(){
        return 4.0*side*(Math.sqrt(side*side*3.0/4))/2.0;
    }
    public double getVolume() {
        double hig=Math.sqrt(side*side*3.0/4);
        return ((side*Math.sqrt(2.0/3.0)))*side*hig/2.0/3.0;
    }
}
abstract class RubikCube {
    protected String color;
    protected int layer;

    public RubikCube(String color, int layer) {
        this.color = color;
        this.layer = layer;
    }

    abstract double getArea();

    abstract double getVolume();

    public void displayInfo() {
        System.out.println( color);
        System.out.println( String.format("%.2f", getArea()));
        System.out.print( String.format("%.2f", getVolume()));
    }
}

class SquareCube extends RubikCube {
    Cube unitCube;

    public SquareCube(String color, int layer, Cube unitCube) {
        super(color, layer);
        this.unitCube = unitCube;
    }

    double getArea() {
        return layer * layer * unitCube.getArea();
    }

    @Override
    double getVolume() {
        return layer * layer * layer * unitCube.getVolume();
    }
}

class RegularPyramidCube extends RubikCube {
     RegularPyramid unitPyramid;

    public RegularPyramidCube(String color, int layer, RegularPyramid unitPyramid) {
        super(color, layer);
        this.unitPyramid = unitPyramid;
    }


    double getArea() {
        return layer * layer * unitPyramid.getArea();
    }

        double getVolume() {
            double hig=Math.sqrt(layer*layer*unitPyramid.side* unitPyramid.side*3.0/4);
            return ((layer*unitPyramid.side*Math.sqrt(2.0/3.0)))*layer *unitPyramid.side*hig/2.0/3.0;
       // return layer * layer * unitPyramid.getVolume();
    }
}

7-3 魔方排序问题

分数 20

作者段喜龙

单位南昌航空大学

在魔方问题的基础上，重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。

提示：题目中RubikCube类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color;
        int layer;
        double side;
        RubikCube cube;
        
        ArrayList<RubikCube> list = new ArrayList<>();
        
        int choice = input.nextInt();
        
        while(choice != 0) {
            switch(choice) {
            case 1://SquareCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new SquareCube(color, layer,new Cube(side)); 
                list.add(cube);
                break;
            case 2://RegularPyramidCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new RegularPyramidCube(color, layer,new RegularPyramid(side)); 
                list.add(cube);
                break;
            }
            choice = input.nextInt();
        }
        
        list.sort(Comparator.naturalOrder());//正向排序
        
        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " + 
        String.format("%.2f", list.get(i).getArea()) + " " + 
        String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }            
    }    
}

输入格式:

输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）

魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长

..循环..

输出格式:

按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。

输入样例:

在这里给出一组输入。例如：

1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0

输出样例:

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

red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

  1 import java.util.ArrayList;
  2 import java.util.Comparator;
  3 import java.util.Scanner;
  4 
  5 class Cube {
  6     private double side;
  7 
  8     public Cube(double side) {
  9         this.side = side;
 10     }
 11 
 12     public double getSide() {
 13         return side;
 14     }
 15 }
 16 
 17 abstract class RubikCube implements Comparable<RubikCube> {
 18     protected String color;
 19     protected int layer;
 20 
 21     public RubikCube(String color, int layer) {
 22         this.color = color;
 23         this.layer = layer;
 24     }
 25 
 26     abstract double getSurfaceArea();
 27     abstract double getVolume();
 28 
 29     public String getColor() {
 30         return color;
 31     }
 32 
 33     @Override
 34     public int compareTo(RubikCube other) {
 35         double volume1 = this.getVolume();
 36         double volume2 = other.getVolume();
 37         if (volume1 < volume2) {
 38             return -1;
 39         } else if (volume1 > volume2) {
 40             return 1;
 41         } else {
 42             return 0;
 43         }
 44     }
 45 }
 46 
 47 class SquareCube extends RubikCube {
 48     private final Cube cube;
 49 
 50     public SquareCube(String color, int layer, Cube cube) {
 51         super(color, layer);
 52         this.cube = cube;
 53     }
 54 
 55 
 56     double getSurfaceArea() {
 57         double side = layer * cube.getSide();
 58         return 6 * side * side;
 59     }
 60 
 61     double getVolume() {
 62         double side = layer * cube.getSide();
 63         return side * side * side;
 64     }
 65 }
 66 
 67 class RegularPyramidCube extends RubikCube {
 68     private final RegularPyramid pyramid;
 69     public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
 70         super(color, layer);
 71         this.pyramid = pyramid;
 72     }
 73 
 74     double getSurfaceArea() {
 75         double side = layer * pyramid.getSide();
 76         double height = layer * pyramid.getHeight();
 77         return side * side * Math.sqrt(3)  ;
 78     }
 79 
 80     double getVolume() {
 81         double side = layer * pyramid.getSide();
 82         double height = layer * pyramid.getHeight();
 83         return (side * side * Math.sqrt(3) * height) / 12.0 ;
 84     }
 85 }
 86 
 87 class RegularPyramid {
 88     private double side;
 89     private double height;
 90 
 91     public RegularPyramid(double side) {
 92         this.side = side;
 93         this.height = side * Math.sqrt(2.0 / 3.0);
 94     }
 95 
 96     public double getSide() {
 97         return side;
 98     }
 99 
100     public double getHeight() {
101         return height;
102     }
103 
104     public double getSurfaceArea() {
105         return 4 * getTriangleArea();
106     }
107 
108     public double getVolume() {
109         return (getTriangleArea() * height) / 3.0;
110     }
111 
112     private double getTriangleArea() {
113         return (side * side * Math.sqrt(3)) / 4.0;
114     }
115 }
116 
117 public class Main {
118     public static void main(String[] args) {
119         Scanner input = new Scanner(System.in);
120 
121         String color;
122         int layer;
123         double side;
124         RubikCube cube;
125 
126         ArrayList<RubikCube> list = new ArrayList<>();
127 
128         int choice = input.nextInt();
129 
130         while (choice != 0) {
131             switch (choice) {
132                 case 1://SquareCube
133                     color = input.next();
134                     layer = input.nextInt();
135                     side = input.nextDouble();
136                     cube = new SquareCube(color, layer, new Cube(side));
137                     list.add(cube);
138                     break;
139                 case 2://RegularPyramidCube
140                     color = input.next();
141                     layer = input.nextInt();
142                     side = input.nextDouble();
143                     cube = new RegularPyramidCube(color, layer, new RegularPyramid(side));
144                     list.add(cube);
145                     break;
146             }
147             choice = input.nextInt();
148         }
149 
150         list.sort(Comparator.naturalOrder());//正向排序
151 
152         for (int i = 0; i < list.size(); i++) {
153             System.out.print(list.get(i).getColor() + " " +
154                     String.format("%.2f", list.get(i).getSurfaceArea()) + " " +
155                     String.format("%.2f", list.get(i).getVolume()));
156             System.out.println("");
157         }
158     }
159 }

7-4 销售步枪问题（附加题）

分数 10

作者段喜龙

单位南昌航空大学

前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。

根据每个月的销售情况，计算销售商的佣金（提成）算法如下：

不到（含）1000美元的部分为10%；
1000（含）~1800美元的部分为15%；
超过1800美元的部分为20%。

佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。

编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。

提示：可以设置一个销售订单类。参考类图如下：

输入格式:

输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。

输出格式:

分别输出销售商在该月的销售额和佣金，中间用空格分开。

输入样例1:

在这里给出一组输入。例如：

30 40 50

输出样例1:

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

3800.00 620.00

输入样例2:
在这里给出一组输入。例如：

88 56 98

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

Wrong Format

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

 1 import java.util.Scanner;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         Scanner scanner = new Scanner(System.in);
 6         String input = scanner.nextLine();
 7         String[] sales = input.split(" ");
 8 
 9         int gunCount = Integer.parseInt(sales[0]);
10         int stockCount = Integer.parseInt(sales[1]);
11         int barrelCount = Integer.parseInt(sales[2]);
12             if(gunCount>stockCount ||gunCount>barrelCount||stockCount>barrelCount||gunCount>70||stockCount>80||barrelCount>90){
13                 System.out.printf("Wrong Format");
14             }else{
15         GunSalesman salesman = new GunSalesman(gunCount, stockCount, barrelCount);
16         salesman.calculateSalesAmount();
17         salesman.calculateCommission();
18 
19         System.out.printf("%.2f %.2f", salesman.getSalesAmount(), salesman.getCommission());
20     }
21     }
22 }
23 
24 class GunSalesman {
25     private int gunCount;
26     private int stockCount;
27     private int barrelCount;
28     private double salesAmount;
29     private double commission;
30 
31     public GunSalesman(int gunCount, int stockCount, int barrelCount) {
32         this.gunCount = gunCount;
33         this.stockCount = stockCount;
34         this.barrelCount = barrelCount;
35     }
36 
37     public void calculateSalesAmount() {
38         salesAmount = gunCount * 45 + stockCount * 30 + barrelCount * 25;
39     }
40 
41     public void calculateCommission() {
42         if (salesAmount <= 1000) {
43             commission = salesAmount * 0.1;
44         } else if (salesAmount <= 1800) {
45             commission = 1000 * 0.1 + (salesAmount - 1000) * 0.15;
46         } else {
47             commission = 1000 * 0.1 + 800 * 0.15 + (salesAmount - 1800) * 0.2;
48         }
49     }
50 
51     public double getSalesAmount() {
52         return salesAmount;
53     }
54 
55     public double getCommission() {
56         return commission;
57     }
58 }

这一题我我没时间写了在后面的10秒才提交成功得到了9分，后来同学告诉我要判断机枪的数量大于0，就可以了

7-3 jmu-Java-02基本语法-03-身份证排序

分数 9

作者郑如滨

单位集美大学

输入n，然后连续输入n个身份证号。
然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。

注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。

输入样例:

6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e

输出样例:

1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

 1 import java.util.*;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         Scanner scanner = new Scanner(System.in);
 7         //System.out.println("请输入身份证个数：");
 8         int n = Integer.parseInt(scanner.nextLine());
 9         String[] idCards = new String[n];
10         ArrayList<String> arry = new ArrayList<>();
11         for (int i = 0; i < n; i++) {
12            // System.out.println("请输入第" + (i + 1) + "个身份证号：");
13             idCards[i] = scanner.nextLine();
14             arry.add(idCards[i]) ;
15         }
16         //System.out.println("请输入sort1或sort2：");
17         String t = String.valueOf(0);
18         while(!t.equals("exit") ) {
19             String command = scanner.nextLine();
20             if (command.equals("sort1")) {
21                 sort1(idCards);
22             } else if (command.equals("sort2")) {
23 
24                 Collections.sort(arry, (o1, o2) -> {
25                     String s1 = o1.substring(6, 14);
26                     String s2 = o2.substring(6, 14);
27                     return s1.compareTo(s2);
28                 });
29                 sort2(arry);
30             } else {
31                 t = "exit";
32                 System.out.println("exit");
33             }
34         }
35     }
36 
37     private static void sort1(String[] idCards) {
38         for (int i = 0; i < idCards.length; i++) {
39             String year = idCards[i].substring(6, 10);
40             String month = idCards[i].substring(10, 12);
41             String day = idCards[i].substring(12, 14);
42             idCards[i] = year + "-" + month + "-" + day;
43         }
44         Arrays.sort(idCards);
45         for (String idCard : idCards) {
46             System.out.println(idCard);
47         }
48     }
49 
50     public static void sort2(ArrayList arry) {
51 
52 
53         for (Object o : arry) {
54             System.out.print(o + "\n");
55         }
56     }
57 }

在这个题中我用了String数组和listarry数组以及两个不一样的数组排序，发现还是list数组比较好用，效率也比较高

7-2 课程成绩统计程序-3

分数 64

作者蔡轲

单位南昌航空大学

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，

要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。

题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。

某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验次数至少4次，不超过9次

课程性质输入项：必修、选修、实验

考核方式输入选项：考试、考察、实验

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

2）学号由8位数字组成

3）姓名不超过10个字符

4）课程名称不超过10个字符

5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"

7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：

输入样例1:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
end

输出样例1:

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

java has no grades yet

输入样例2:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2
end

输出样例2:

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

java : number of scores does not match

输入样例3:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.1
end

输出样例3:

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

java : weight value error

输入样例4:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end

输出样例4:

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

20201116 张三 86
java 86
202011 86

输入样例5:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end

输出样例5:

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

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

代码长度限制

25 KB

时间限制

1500 ms

内存限制

64 MB

  1 import java.util.*;
  2 import java.text.*;
  3 class Calculate_grades {
  4     int stu_all_grades(Data_storage data_storage,String num){//单个学生总课程平均分计算  返回一个分数 1)
  5         int count =0;//这个学生有几门课
  6         int sum = 0;
  7         for (Map.Entry<String, Score> entry : data_storage.stu__st_cour.get(num).gradeMap.entrySet()) {
  8             Score value = entry.getValue();
  9             if(Integer.parseInt(value.total_scores)>=0) {
 10                 count++;
 11                 sum += Integer.parseInt(value.total_scores);
 12             }
 13         }
 14         if(count!=0)
 15             return sum/count;
 16         else
 17             return -100;//没有参加任何考试
 18     }
 19     int[] single_course_grades(Data_storage data_storage,String name){ //2) 课程名
 20         int count = 0;
 21         int[] aver_grade = new int[3];//0：平时成绩 1：期末考试 2：总分平均
 22         for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//遍历选课类:num-选课类
 23             StudentsAll_mes value = e.getValue();
 24             for (Map.Entry<String, Score> entry : value.gradeMap.entrySet()) {//遍历选课类:course.name-Score
 25                 String key1 = entry.getKey();
 26                 Score value1 = entry.getValue();
 27                 if (key1.equals(name)) {
 28                     if(Integer.parseInt(value1.total_scores)>=0) {//总分为- 说明算成绩无效
 29                         count++;
 30                         aver_grade[2] += Integer.parseInt(value1.total_scores);
 31                         if (value1 instanceof Test_Score) {
 32                             if (Integer.parseInt(value1.total_scores) >= 0) {
 33                                 aver_grade[0] += Integer.parseInt(((Test_Score) value1).normal_score);
 34                                 aver_grade[1] += Integer.parseInt(((Test_Score) value1).end_score);
 35                             }
 36                         } else if (value1 instanceof Inspect_Score){
 37                             if (Integer.parseInt(value1.total_scores) >= 0) {
 38                                 aver_grade[0] = -100;//不需要平时成绩
 39                                 aver_grade[1] += Integer.parseInt(((Inspect_Score) value1).end_score);
 40                             }
 41                         }else if(value1 instanceof Lab_Score){
 42                             if(Integer.parseInt(value1.total_scores)>=0){
 43                                 aver_grade[0] = -100;
 44                                 aver_grade[1] += aver_grade[1] += Integer.parseInt(value1.total_scores);
 45                             }
 46                         }
 47                     }
 48                 }
 49             }
 50         }
 51         if(count!=0) {
 52             for (int i = 0; i < 3; i++) {
 53                 aver_grade[i] = aver_grade[i] / count;
 54             }
 55         }else {
 56             for (int i = 0; i < 3; i++) {
 57                 aver_grade[i] = -100;
 58             }
 59         }
 60         return aver_grade;
 61     }
 62     int Class_grades(Data_storage data_storage,String num){//3)
 63         int sum = 0;
 64         int count = 0;
 65         for (Map.Entry<String, Student> mapEntry : data_storage.classes.get(num).students.entrySet()) {//班级号-Student类
 66             Student value = mapEntry.getValue();//遍历这个班级的所有学生
 67             for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//stu_num-选课类
 68                 String key1 = e.getKey();//遍历学生的选课类 学号
 69                 StudentsAll_mes value1 = e.getValue();
 70                 if (key1.equals(value.num)) {//选课类中 跟输入的学号一样
 71                     for (Map.Entry<String, Score> entry : value1.gradeMap.entrySet()) {//该num所有成绩遍历
 72                         Score gra = entry.getValue();
 73                         if(Integer.parseInt(gra.total_scores)>=0) {//有效才算
 74                             sum += Integer.parseInt(gra.total_scores);
 75                             count++;
 76                         }
 77                     }
 78                 }
 79             }
 80         }
 81         if(count!=0)
 82             return sum/count;
 83         else
 84             return -100;
 85     }
 86     void final_score(Data_storage data_storage,String num){//计算没门课的成绩 学号
 87         data_storage.stu__st_cour.get(num).gradeMap.forEach((key,value)->{//学号  成绩
 88             if(value instanceof Test_Score&&((Test_Score) value).normal_score.matches("\\d+")&&((Test_Score) value).end_score.matches("\\d+")) {
 89                 double tem = ((Test_Course) data_storage.courses.get(key)).normal_weight*Integer.parseInt(((Test_Score) value).normal_score);
 90                 double tem1 = ((Test_Course) data_storage.courses.get(key)).end_weight*Integer.parseInt(((Test_Score) value).end_score);
 91                 value.total_scores = String.valueOf((int)(tem+tem1));
 92             }else if(value instanceof Inspect_Score&&((Inspect_Score) value).end_score.matches("\\d+")){
 93                 value.total_scores = ((Inspect_Score) value).end_score;
 94             }else if(value instanceof Lab_Score&&((Lab_Score) value).lab_num.matches("\\d+")){
 95                 float sum = 0;
 96                 int i=0;
 97                 for (Integer score : ((Lab_Score) value).scores) {
 98                     sum+= score* ((Lab_Course) data_storage.courses.get(key)).weights.get(i);
 99                     i++;
100                 }
101                 value.total_scores = String.valueOf((int)sum);
102             }
103         });
104     }
105 }
106 class Class {
107     String num;
108     TreeMap<String, Student> students = new TreeMap<>(); //班级里的学生 学号 学生
109     Class(String num){
110         this.num = num;
111     }
112 }
113 class Course {
114     String type;
115     String test_way;
116     String name;
117     Course(String name,String type, String test_way){
118         this.type = type;
119         this.name = name;
120         this.test_way = test_way;
121     }
122 }
123 class Inspect_Course extends Course{
124     Inspect_Course(String name, String type, String test_way) {
125         super(name, type, test_way);
126     }
127 }
128 class Test_Course extends Course{
129     double normal_weight;
130     double end_weight;
131 
132     Test_Course(String name, String type, String test_way,String normal_weight,String end_weight) {
133         super(name, type, test_way);
134         this.normal_weight = Float.parseFloat(normal_weight);
135         this.end_weight = Float.parseFloat(end_weight);
136     }
137 }
138 class Lab_Course extends Course{
139     int sub_scores_num;
140     ArrayList<Float> weights = new ArrayList<>();
141     Lab_Course(String name, String type, String test_way,String line) {
142         super(name, type, test_way);
143         String[] lines = line.split(" ");
144         sub_scores_num = Integer.parseInt(lines[3]);
145         for(int i=4;i<lines.length; i++){
146             weights.add(Float.parseFloat(lines[i]));
147         }
148     }
149 }
150 class Data_storage {
151     TreeMap<String , Course> courses;//课程  k：课程名 v:课程
152     TreeMap<String, Class> classes = new TreeMap<>();//班级 k:班级号V:班级
153     TreeMap<String, StudentsAll_mes> stu__st_cour;//选课类学生类结合 k:学号 v:选课类
154     InAndOut_put output = new InAndOut_put();
155     Data_storage(){
156         //学生和选课类结合
157         stu__st_cour = new TreeMap<>(Data_storage::compare);//重写排序
158         courses = new TreeMap<>(Data_storage::compare);
159     }
160 
161     private static int compare(String o1, String o2) {
162 
163         try {
164             Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
165             if (comparator.compare(o1, o2) < 0) {
166                 return -1;
167             } else if (comparator.compare(o1, o2) > 0) {
168                 return 1;
169             }
170         } catch (Exception ignored) {
171         }
172         return 0;
173     }
174 
175     void setInspectCourses(String name, String type, String test_way){
176         if(!courses.containsKey(name)) {
177             courses.put(name, new Inspect_Course(name, type, test_way));
178         }
179     }
180     void setTestCourses(String name, String type, String test_way,String normal_weight, String end_weight){
181         if(!courses.containsKey(name)) {
182             courses.put(name, new Test_Course(name, type, test_way,normal_weight, end_weight));
183         }
184     }
185     void setLabCourses(String name, String type, String test_way,String line){
186         if(!courses.containsKey(name)) {
187             courses.put(name, new Lab_Course(name, type, test_way,line));
188         }
189     }
190     void setClasses(String num){
191         if(!classes.containsKey(num)) {
192             classes.put(num, new Class(num));
193         }
194     }
195     void setStudents(String clas_num, String name, String num){//班级号 姓名 学号
196         if(classes.containsKey(clas_num)){
197             if(!classes.get(clas_num).students.containsKey(num))
198                 classes.get(clas_num).students.put(num,new Student(name,num));
199         }
200     }
201     void setStu__st_courAndMap(String num,String course,String normal_score,String end_score){//添加选课类  学生姓名 课程名称 分数
202         if(!stu__st_cour.containsKey(num)){
203             stu__st_cour.put(num,new StudentsAll_mes(num,course,normal_score,end_score));
204         }
205         else{
206             stu__st_cour.get(num).setGradeMap(course,normal_score,end_score);
207         }
208     }
209     void setStu__st_courAndMap(String num,String course,String end_score){
210         if(!stu__st_cour.containsKey(num)){
211             stu__st_cour.put(num,new StudentsAll_mes(num,course,end_score));
212         }
213         else{
214             stu__st_cour.get(num).setGradeMap(course,end_score);
215         }
216     }
217     void set_lab_grades(String stu_num,String course,String lab_num,String grades){
218         ArrayList<Integer> scores = new ArrayList<>();
219         String[] tem = grades.split(" ");
220         for(int i=3;i<tem.length;i++){
221             if(tem[i].matches("\\d+"))
222                 scores.add(Integer.parseInt(tem[i]));
223         }
224         if(!stu__st_cour.containsKey(stu_num)){
225             StudentsAll_mes tem_stu_mes = new StudentsAll_mes();
226             tem_stu_mes.set_lab_stu_mes(stu_num,course,lab_num,scores);
227             stu__st_cour.put(stu_num,tem_stu_mes);
228         }else{
229             stu__st_cour.get(stu_num).set_lab_gradeMap(course,lab_num,scores);
230         }
231     }
232 }
233 class ipfor{
234     String[] strings;
235     String wenzi = "^[\\u4e00-\\u9fa5a-zA-Z0-9]";
236     String wenzi1 = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+";
237     String wenzi2 = "[\\u4E00-\\u9FA5A-Za-z0-9]";
238     String wenzi3 = "{1,10}\\s*";
239     String wenzi4 = "{1,10}\\s";
240     String wenzi5 = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s";
241     String object1 ="{1,10}\\s(必修|选修)\\s考试\\s";
242     String object2 = "{1,10}\\s选修\\s考察$";
243     String object3 = "{1,10}\\s实验\\s实验\\s[4-9]\\s";
244 
245     String num1 = "((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
246     String num2 ="((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){3,9}$";
247     String num3 ="((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
248     String num4="((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){2,9}$";
249 
250     String regex_c_test = wenzi+object1+num1;
251     String regex_c_inspect = wenzi+object2;
252     String regex_c_lab = wenzi+object3+num2;
253     String regex_CS = wenzi1+wenzi2+wenzi3+num3;
254     String regex_lab =wenzi5+ wenzi2+wenzi4+num4;
255     public int input6(String s){
256         if(s.matches(regex_c_test) )
257             return 1;
258         else if(s.matches(regex_c_inspect) )
259             return 3;
260         else if(s.matches( regex_c_lab) )
261             return 4;
262         else if(s.matches(regex_CS) )
263             return 5;
264         else if(s.matches(regex_lab) )
265             return 6;
266         else
267             return 0;
268     }
269     public int objecttxt(String s){
270         if(s.equals("必修") ){
271             return 1;
272         }
273         else if(s.equals("考察") )
274             return 2;
275         else if(s.equals("实验") )
276             return 3;
277         else if(s.equals("选修") )
278             return 4;
279         else if(s.equals("考试") )
280             return 5;
281         else return 0;
282     }
283     String[] lineProcessing(String line){
284         strings = line.split(" ");
285         return strings;
286     }
287 }
288 
289 class Input_Format {
290     boolean isEnd = true;//结束标志
291     ipfor  judge = new ipfor();
292     Print print = new Print() ;
293     void inputProcessing(String line,Data_storage data_storage) {
294         String[] strings =judge.lineProcessing(line);//分割
295         data_storage.output.add_input(line);//存储
296         if( judge.input6(line) == 3){
297             data_storage.setInspectCourses(strings[0],strings[1],strings[2]);
298         }else if( judge.input6(line) == 4 ){
299             data_storage.setLabCourses(strings[0],strings[1],strings[2],line);
300         }else  if( judge.input6(line) == 1){
301             data_storage.setTestCourses(strings[0],strings[1],strings[2],strings[3],strings[4]);//成绩信息
302         } else  if( judge.input6(line) == 5 || judge.input6(line) == 6){
303             data_storage.setClasses(strings[0].substring(0,6));
304             data_storage.setStudents(strings[0].substring(0, 6), strings[1], strings[0]);//学生的添加
305             if (data_storage.courses.containsKey(strings[2])) {//课程里有这个课
306                 if( judge.objecttxt(data_storage.courses.get(strings[2]).type)== 4 ){
307                     if( judge.objecttxt(data_storage.courses.get(strings[2]).test_way)== 5&&strings.length == 5){
308                         data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3], strings[4]);
309                     }else if( judge.objecttxt(data_storage.courses.get(strings[2]).test_way)== 2 && strings.length == 4){
310                         data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3]);
311                     } else {
312 
313                         print.error(data_storage,strings[0], strings[2]) ;
314                     }
315                 } else if( judge.objecttxt(data_storage.courses.get(strings[2]).type)== 1){
316                     if (strings.length == 5) {
317                         data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3],strings[4]);
318                     } else {//无效
319 
320                         print.error(data_storage,strings[0], strings[2]) ;
321                     }
322                 } else if( judge.objecttxt(data_storage.courses.get(strings[2]).type)== 3){
323                     if(strings.length == 3+((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num){
324                         data_storage.set_lab_grades(strings[0],strings[2], String.valueOf(((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num),line);
325                     }else{
326 
327                         print.error1(data_storage,strings[0], strings[2]) ;
328                     }
329                 }
330             }else{
331 
332                 print.error2(data_storage,strings[0], strings[2]) ;
333             }
334         }
335     }
336 }
337 class Inspect_Score extends Score{
338     String end_score;
339     Inspect_Score(String end_score) {
340         this.end_score = end_score;
341     }
342 }
343 class outjudge extends ipfor {
344     //String wenzi = "^[\\u4e00-\\u9fa5a-zA-Z0-9]";
345     String wenzi1 = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+";
346     String wenzi2 = "[\\u4E00-\\u9FA5A-Za-z0-9]";
347     String wenzi3 = "{1,10}\\s*";
348     String wenzi4 = "{1,10}\\s";
349     String wenzi5 = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s";
350     String object1 ="{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s";
351 
352     String object4 = "{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)$";
353     String num1 = "((\\d{1,2})|(1-9?))\\s((\\d{1,2})|(1-9?))$";
354     String num2 ="[4-9]\\s((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){1,10}$";
355     String num3 ="((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
356     String num4="((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){1,20}$";
357     String num5 = "((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
358     String regex_c_test = wenzi +object1+ num1;
359     String regex_c_test_e = wenzi+object1 +num5;
360     String regex_c_inspect =wenzi2+ object4;
361     String regex_c_lab = wenzi+object1+num2 ;
362     String regex_CS =wenzi1+wenzi2+wenzi3+num3 ;
363     String regex_lab = wenzi5+wenzi2+wenzi4+num4  ;
364     public int iput1(String s){
365         if(s.matches(regex_c_test) )
366             return 1;
367         else if(s.matches(regex_c_test_e) ){
368             return 2;
369         }
370         else if(s.matches(regex_c_inspect) )
371             return 3;
372         else if(s.matches( regex_c_lab) )
373             return 4;
374         else if(s.matches(regex_CS) )
375             return 5;
376         else if(s.matches(regex_lab) )
377             return 6;
378         else
379             return 0;
380     }
381     void output_all(Data_storage data){
382         data.output.output.forEach(System.out::println);
383     }
384 }
385 class Print{
386     public void error(Data_storage data_storage,String p,String p1){
387         data_storage.setStu__st_courAndMap(p,p1, "no access", "no access");
388     }
389     public void error1(Data_storage data_storage,String p,String p1){
390         data_storage.set_lab_grades(p,p1,"num error","no access");
391     }
392     public void error2(Data_storage data_storage,String p,String p1){
393         data_storage.setStu__st_courAndMap(p, p1, "   not exist");
394     }
395     public void error3(Data_storage data,String p){
396         data.output.add_output(p + " : course type & access mode mismatch");
397     }
398     public void error4(Data_storage data,String p){
399         data.output.add_output(p + " : number of scores does not match");
400     }
401     public void error5(Data_storage data,String p,String p1){
402         data.output.add_output(p+" "+p1+" : access mode mismatch");
403     }
404 }
405 class  Output_Format {
406     Calculate_grades calculate = new Calculate_grades();
407     outjudge judege = new outjudge() ;
408     Print print = new Print() ;
409     void outputProcessing(Data_storage data) {
410         data.classes.forEach((num,Class)-> Class.students.forEach((name, student)-> calculate.final_score(data,student.num)));
411         for(String i:data.output.input){
412             String[] tem = i.split(" ");
413             if(judege.iput1(i)==2 || judege.iput1(i)==1||judege.iput1(i)== 3 ||judege.iput1(i)== 4 ){
414                 if(judege.objecttxt(tem[1])== 1&& (judege.objecttxt(tem[2])== 2||judege.objecttxt(tem[2])== 3)){
415                    print.error3(data,tem[0]) ;
416                 }else  if(judege.objecttxt(tem[1])== 3&&judege.objecttxt(tem[2])!= 3){
417                     print.error3(data,tem[0]) ;
418                 }else if(judege.objecttxt(tem[1])== 4 && judege.objecttxt(tem[2])== 3){
419                     print.error3(data,tem[0]) ;
420                 }
421                 if(judege.objecttxt(tem[1])== 3&&judege.objecttxt(tem[2])== 3){
422                     if(tem.length-4>=4&&tem.length - 4<=9) {
423                         if (Integer.parseInt(tem[3]) != tem.length - 4) {
424                             print.error4(data,tem[0]) ;
425                             data.courses.remove(tem[0]);
426                             continue;
427                         }
428                         float tem_weight = 0;
429                         for (int j = 4; j < tem.length; j++) {
430                             tem_weight += Float.parseFloat(tem[j]);
431                         }
432                         if (Math.abs(tem_weight - 1) > 0.0001) {
433                             data.output.add_output(tem[0] + " : weight value error");
434                             data.courses.remove(tem[0]);
435                             continue;
436                         }
437                     }else{
438                         try {
439                             if (Integer.parseInt(tem[3]) != tem.length - 4) {
440                                 print.error4(data,tem[0]) ;
441                                 data.courses.remove(tem[0]);
442                                 continue;
443                             }
444                         } catch (Exception ignored) {
445 
446                         }
447                     }
448                 }
449                 if((judege.objecttxt(tem[1])== 1||judege.objecttxt(tem[1])== 1)&&judege.objecttxt(tem[2])== 6){
450                     if(tem.length-3==2) {
451                         float tem_weight = Float.parseFloat(tem[3]) + Float.parseFloat(tem[4]);
452                         if (Math.abs(tem_weight - 1) > 0.0001) {
453                             data.output.add_output(tem[0] + " : weight value error");
454                             data.courses.remove(tem[0]);
455                         }
456                     }
457                 }
458             }else if(judege.iput1(i) == 5||judege.iput1(i) == 6){
459                 if(!data.courses.containsKey(tem[2])){//不存在
460                     data.output.add_output(tem[2]+" does not exist");
461                     data.stu__st_cour.get(tem[0]).gradeMap.remove(tem[2]);
462                 }else{ if(judege.objecttxt(data.courses.get(tem[2]).type)== 1 && tem.length!=5) {//必修 但是只有期末成绩
463                     print.error5(data,tem[0],tem[1]) ;
464                 }else
465                 if(judege.objecttxt(data.courses.get(tem[2]).type)== 4 ){
466                     if((judege.objecttxt(data.courses.get(tem[2]).test_way)== 5&&tem.length != 5 )|| (judege.objecttxt(data.courses.get(tem[2]).test_way)== 2&&tem.length != 4))
467                         print.error5(data,tem[0],tem[1]) ;
468                 }else if(judege.objecttxt(data.courses.get(tem[2]).type)== 3){
469                     if(judege.objecttxt(data.courses.get(tem[2]).test_way)==3&&(tem.length-3<4||tem.length-3>9||tem.length-3!=((Lab_Course) data.courses.get(tem[2])).sub_scores_num))
470                         print.error5(data,tem[0],tem[1]) ;
471                 }
472                 }
473             }else if(!i.equals("end")){
474                 data.output.add_output("wrong format");
475             }
476         }
477         data.classes.forEach((cla_num,Class1)->{//遍历所有班级
478             Class1.students.forEach((stu_num,student)->{
479                 int tem=calculate.stu_all_grades(data,stu_num);
480                 if(tem>=0)
481                     data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+tem);
482                 else
483                     data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+"did not take any exams");
484             });
485         });
486         data.courses.forEach((key,value)-> {
487             int[] tem = calculate.single_course_grades(data, key);
488             if (tem[0] < 0 && tem[1] < 0 && tem[2] < 0) {//三个为- 则没成绩
489                 data.output.add_output(key + " has no grades yet");
490             }else {
491                 if(judege.objecttxt(value.type)==4||judege.objecttxt(value.type)==1||judege.objecttxt(value.type)==3){
492                     data.output.add_output(key + " " + tem[2]);
493                 }
494             }
495         });
496         data.classes.forEach((num,Class)->{
497             int tem = calculate.Class_grades(data,num);
498             if(tem>=0) {
499                 data.output.add_output(num + " " + tem);
500             }else
501                 data.output.add_output(num+" has no grades yet");
502         });
503     }
504 
505 }
506 abstract class Score {
507     String total_scores = "-100";
508 }
509 class Student {
510     String name;
511     String num;
512     Student(String name, String num) {
513         this.name = name;
514         this.num = num;
515     }
516 }
517 class StudentsAll_mes {
518     String num;//学生
519     TreeMap<String,Score> gradeMap =new TreeMap<>();
520     StudentsAll_mes(String stu_name, String course, String normal_score,String test_score){
521         this.num = stu_name;
522         gradeMap.put(course,new Test_Score(normal_score,test_score));
523     }
524     public StudentsAll_mes() {
525 
526     }
527     StudentsAll_mes(String stu_name, String course, String test_score){
528         this.num = stu_name;
529         gradeMap.put(course,new Inspect_Score(test_score));
530     }
531 
532 
533     void set_lab_stu_mes(String stu_num,String course,String lab_num,ArrayList<Integer> scores){
534         this.num = stu_num;
535         gradeMap.put(course,new Lab_Score(lab_num,scores));
536     }
537     void set_lab_gradeMap(String course,String lab_num,ArrayList<Integer> scores){
538         if(!gradeMap.containsKey(course))
539             gradeMap.put(course,new Lab_Score(lab_num,scores));
540     }
541     void setGradeMap(String course, String normal_score,String test_score){
542         if(!gradeMap.containsKey(course))
543             gradeMap.put(course, new Test_Score(normal_score,test_score));
544     }
545     void setGradeMap(String course,String test_score){
546         if(!gradeMap.containsKey(course))
547             gradeMap.put(course,new Inspect_Score(test_score));
548     }
549 
550 }
551 class Test_Score extends Score{
552     String normal_score;
553     String end_score;
554     Test_Score(String normal_score,String end_score) {
555         this.normal_score = normal_score;
556         this.end_score = end_score;
557     }
558 }
559 class Lab_Score extends Score {
560     String lab_num;//试验次数
561 
562     ArrayList<Integer> scores;
563     Lab_Score(String lab_num,ArrayList<Integer> scores){
564         this.lab_num = lab_num;
565         this.scores = scores;
566     }
567 }
568 class InAndOut_put {
569     List<String> output = new ArrayList<>();
570     List<String> input = new ArrayList<>();
571     void add_output(String out){
572         output.add(out);
573     }
574     void add_input(String out){
575         input.add(out);
576     }
577 }
578 public class Main {
579     public static void main(String[] args) {
580         Scanner scanner = new Scanner(System.in);
581         outjudge judege = new outjudge() ;
582         Input_Format inputFormat = new Input_Format();//输入
583         Output_Format outputFormat = new Output_Format();//输出
584         Data_storage data_storage = new Data_storage();
585         int falg =0;
586         while (falg !=1){
587             String inputLine = scanner.nextLine();
588             if(inputLine.equals("end")){
589                 inputFormat.isEnd = false;
590                 falg =1;
591                 break;
592             }
593             inputFormat.inputProcessing(inputLine,data_storage);
594         }
595         outputFormat.outputProcessing(data_storage);
596         judege.output_all(data_storage);
597     }
598 }

这个代码最多只能610行代码，但是其他人是可以到800行甚至更多，所以我认为行数的有限与代码的调用的函数有关

(3)踩坑心得

前两次作业没啥说的，没有啥坑。第三次作业坑就挺多的了，首先就是运行超时，主要原因是正则表达式部分写得过于冗长，简化过后便没有运行超时的结果了；其次就是权重等于1的问题了，有时权重之和确实等于1，但运行出来总会有些误差，于是乎把权重之和等于1的条件改成与1的差值小于1e-6，便过了一个测试点；最后就是审题问题了，他最后的输出与前两次的输出都不一样，因此需要注意改动。

在处理输入输出时，需要注意格式的要求，使用适当的分隔符进行分割。还要注意数组越界的问题，确保课程索引在合法范围内。

在解决问题时要选择合适的数据结构来存储和处理数据，例如使用列表和映射。

计算平均成绩时，需设计合适的算法处理课程成绩和权重，例如使用循环遍历计算总成绩。

编写代码时，要注意可读性和可维护性，使用合适的命名、注释和代码结构。可以考虑封装一些功能成函数，提高代码的可维护性。

(4)改进建议

在处理数据时，需要考虑使用合适的数据结构来存储和处理数据。例如，使用Set来存储班级信息，使用Map来存储学生和成绩的关系。这样可以更方便地进行数据的查找和操作。

Java 8引入了流式操作和Lambda表达式，可以借助它们来简化代码，提高代码的可读性。例如，可以使用stream()方法和filter()方法来过滤数据，使用map()方法来转换数据等。

在处理输入时需要考虑错误处理和异常处理。例如，当解析学生信息时，可以使用try-catch块来捕获可能产生的异常，如数组越界异常，并进行相应的处理。

在设计和实现功能时，遵循单一职责原则，确保每个类和方法只负责一项具体的功能。这样可以提高代码的可维护性和复用性。

编写适当的单元测试来验证代码的正确性是很重要的。可以使用JUnit等单元测试框架编写测试用例，并进行测试。这样可以确保代码在不同情况下的正确性。

为代码添加适当的注释和文档也是很重要的。注释可以解释代码的意图和实现细节，文档可以提供代码的使用方法和示例。

(5)总结

Java是一门广泛应用于软件开发的高级编程语言。通过学习Java，我获得了以下几方面的知识和技能：

1. 语法基础：掌握了Java的基本语法规则，了解了标识符、变量、数据类型、运算符、流程控制语句等基本概念。通过练习和实践，熟悉了Java的编写风格和命名规范。

2. 面向对象编程：学习了面向对象的思想和相关的概念，包括类、对象、封装、继承、多态等。掌握了如何使用类和对象来组织代码，提高代码的可重用性和可维护性。

3. 常用类库和API：了解并熟悉了Java的常用类库和API，如字符串处理、集合框架、I/O操作、异常处理等。学会了使用这些工具来简化开发过程，提高效率。

4. 多线程编程：学习了Java多线程编程的基本概念和技巧，包括线程的创建、同步与互斥、线程池等。了解了如何使用多线程来提高程序的性能和响应性。

5. 异常处理：学习了如何设计和处理异常，包括如何捕获异常、抛出异常以及异常处理的机制。通过实践，提升了代码的健壮性和可靠性。

6. 输入输出操作：掌握了Java中的输入输出操作，包括文件读写、网络通信等。了解了如何使用Java提供的输入输出流来实现数据的读写和传输。

7. 开发工具和环境：熟悉了常用的开发工具和环境，如Eclipse、IntelliJ IDEA等。了解了如何配置和使用开发工具，提高开发效率。

通过Java的学习，我不仅获得了编程的基础知识和技能，还培养了分析问题、解决问题和合作开发的能力。Java作为一门广泛应用的编程语言，它的应用领域非常广泛，为我未来的学习和工作提供了坚实的基础。我会继续深入学习Java，并将它应用于实际的项目开发中。

posted @ 2023-12-05 22:25 你好k 阅读(56) 评论(0) 收藏举报

刷新页面返回顶部

BLOG

BLOG-3

(1)前言

题量

难度等情况

(2)设计与分析

输入格式:

输出格式:

输入样例:

输出样例:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

输入格式:

输出格式:

输入样例:

输出样例:

输入格式:

输出格式:

输入样例:

输出样例:

输入格式:

输出格式:

输入样例:

输出样例:

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例:

输出样例:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

(3)踩坑心得

(4)改进建议

(5)总结

公告