南昌航空大学JAVA Blog-3

import java.util.*;
import java.text.Collator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Class> classes = new ArrayList<>();
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
        ArrayList<CourseSelection> courseSelections = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        while (true) {
            String strring = input.nextLine();
            if (strring.equals("end")) {
                break;
            }
            String[] nextLine = strring.split(" ");
            if (nextLine.length == 3) {
                addCourse(nextLine,courses);
            } else if (nextLine.length == 5) {
                addScoredCourseSelection1(nextLine,courseSelections,students,courses);
            } else if (nextLine.length == 4) {
                addScoredCourseSelection2(nextLine, courses, students, courseSelections);
            } else if (nextLine.length > 5) {
                addScoredCourseSelection3(nextLine,courses,students,courseSelections);
            } else {
                System.out.println("wrong format");
            }
        }
        for (Student student:students
        ) {
            int classNumber = Integer.parseInt(student.getStudentNumber()) / 100;
            if (classes.isEmpty()) {
                Class clas = new Class();
                clas.setClassNumber(classNumber);
                clas.getStudents().add(student);
                classes.add(clas);
            } else {
                ListIterator<Class> iterator = classes.listIterator();
                while (iterator.hasNext()) {
                    Class clas = iterator.next();
                    if (clas.getClassNumber() == classNumber) {
                        clas.getStudents().add(student);
                        break;
                    } else {
                        if (classes.indexOf(clas) == classes.size() - 1) {
                            Class clasNew = new Class();
                            clasNew.setClassNumber(classNumber);
                            clasNew.getStudents().add(student);
                            iterator.add(clasNew);
                        }
                    }
                }
            }
        }
        Collections.sort(classes, Comparator.comparingInt(o -> o.getClassNumber()));
        for (Class clas:classes
        ) {
            clas.setClassAverageScore(print1(clas.getStudents(), courseSelections));
        }
        print2(courses, courseSelections);
        for (Class clas:classes
        ) {
            if (clas.getClassAverageScore() == -1) {
                System.out.println(clas.getClassNumber() + " has no grades yet");
            } else System.out.println(clas.getClassNumber() + " " + clas.getClassAverageScore());
        }
    }
    public static int print1(ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
        int classAverageScore = 0;
        Collections.sort(students, Comparator.comparingInt(o -> Integer.parseInt(o.getStudentNumber())));
        for (Student student:students
        ) {
            int averageScore = 0;
            int courseNum = 0;
            for (CourseSelection cs:courseSelections
            ) {
                if (cs.getStudent().getStudentNumber().equals(student.getStudentNumber())) {
                    averageScore += cs.getScore().getTotalScore();
                    courseNum ++;
                }
            }
            if (courseNum == 0) {
                System.out.println(student.getStudentNumber() + " " + student.getStudentName() + " did not take any exams");
                return -1;
            } else {
                averageScore /= courseNum;
                System.out.println(student.getStudentNumber() + " " + student.getStudentName() + " " + averageScore);
            }
            classAverageScore += averageScore;
        }
        return classAverageScore / students.size();
    }
    public static void print2(ArrayList<Course> courses, ArrayList<CourseSelection> courseSelections) {
        Collections.sort(courses, (o1, o2) -> {
            Collator collator = Collator.getInstance(Locale.CHINA);
            return collator.compare(o1.getCourseName(), o2.getCourseName());
        });
        for (Course course:courses
        ) {
            int courseAverageScore = 0;
            int courseDailyPerformance = 0;
            int courseFinalGrade = 0;
            int studentNum = 0;
            for (CourseSelection cs:courseSelections
            ) {
                if (course.getCourseName().equals(cs.getCourse().getCourseName())) {
                    courseAverageScore += cs.getScore().getTotalScore();
                    courseDailyPerformance += cs.getScore().getDailyPerformance();
                    courseFinalGrade += cs.getScore().getFinalGrade();
                    studentNum ++;
                }
            }
            if (studentNum == 0) {
                System.out.println(course.getCourseName() + " has no grades yet");
            } else {
                courseAverageScore /= studentNum;
                courseDailyPerformance /= studentNum;
                courseFinalGrade /= studentNum;
                if (course.getAssessmentMethod().equals("考试")) {
                    System.out.println(course.getCourseName() + " " + courseDailyPerformance + " " + courseFinalGrade + " " + courseAverageScore);
                } else if (course.getAssessmentMethod().equals("考察")) {
                    System.out.println(course.getCourseName() + " " + courseFinalGrade + " " + courseAverageScore);
                } else {
                    System.out.println(course.getCourseName() + " " + courseAverageScore);
                }
            }

        }
    }
    public static boolean isCourseExist(String courseName, ArrayList<Course> courses, int length, Student student) {
        for (Course course:courses
        ) {
            if (course.getCourseName().equals(courseName)) {
                if ((course.getAssessmentMethod().equals("考试") && length != 5) ||
                        (course.getAssessmentMethod().equals("考察") && length != 4) ||
                        (course.getAssessmentMethod().equals("实验") && length != 4)) {
                    System.out.println(student.getStudentNumber() + " " + student.getStudentName() + " : access mode mismatch");
                    return false;
                } else
                    return true;
            }
        }
        System.out.println(courseName + " does not exist");
        return true;
    }
    public static boolean RepetitiveCourses(Course course,ArrayList<Course> courses) {
        for (Course cou:courses
        ) {
            if (cou.getCourseName().equals(course.getCourseName())) return true;
        }
        return false;
    }
    public static boolean RepetitiveScores(CourseSelection courseSelection,ArrayList<CourseSelection> courseSelections) {
        for (CourseSelection cs:courseSelections
        ) {
            if (cs.getStudent().getStudentName().equals(courseSelection.getStudent().getStudentName())) {
                if (cs.getCourse().getCourseName().equals(courseSelection.getCourse().getCourseName())) {
                    return true;
                }
            }
        }
        return false;
    }
    public static void addCourse(String[] nextLine, ArrayList<Course> courses) {
        Course course = new Course(nextLine[0], nextLine[1], nextLine[2]);
        if (RepetitiveCourses(course,courses)) return;
        if (nextLine[0].length() > 10 ||
                (!nextLine[1].equals("必修") && !nextLine[1].equals("选修") && !nextLine[1].equals("实验")) ||
                (!nextLine[2].equals("考试") && !nextLine[2].equals("考察") && !nextLine[2].equals("实验"))) {
            System.out.println("wrong format");
            return;
        }
        if ((course.getCourseNature().equals("必修") && !course.getAssessmentMethod().equals("考试")) ||
                (course.getCourseNature().equals("实验") && !course.getAssessmentMethod().equals("实验"))) {
            System.out.println(course.getCourseName() + " : course type & access mode mismatch");
            return;
        }
        courses.add(course);
    }
    public static void addScoredCourseSelection1(String[] nextLine, ArrayList<CourseSelection> courseSelections, ArrayList<Student> students, ArrayList<Course> courses) {
        if (!nextLine[3].matches("100|[1-9][0-9]|[0-9]") ||
                !nextLine[4].matches("100|[1-9][0-9]|[0-9]") ||
                nextLine[0].length() != 8 ||
                nextLine[1].length() > 10) {
            System.out.println("wrong format");
            return;
        }
        Student student = new Student(nextLine[0], nextLine[1]);
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student stu = iterator.next();
            if (stu.getStudentNumber().equals(student.getStudentNumber())) {
                iterator.remove();
            }
        }
        students.add(student);
        if (isCourseExist(nextLine[2], courses, nextLine.length, student)) {
            Score score = new ExaminationResults(Integer.parseInt(nextLine[3]), Integer.parseInt(nextLine[4]));
            for (Course course:courses
            ) {
                if (course.getCourseName().equals(nextLine[2])) {
                    CourseSelection courseSelection = new CourseSelection(course, student, score);
                    if (RepetitiveScores(courseSelection,courseSelections)) continue;
                    courseSelections.add(courseSelection);
                }
            }
        }
    }
    public static void addScoredCourseSelection2(String[] nextLine, ArrayList<Course> courses, ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
        if (!nextLine[3].matches("100|[1-9][0-9]|[0-9]") ||
                nextLine[0].length() != 8 ||
                nextLine[1].length() > 10) {
            System.out.println("wrong format");
            return;
        }
        Student student = new Student(nextLine[0], nextLine[1]);
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student stu = iterator.next();
            if (stu.getStudentNumber().equals(student.getStudentNumber())) {
                iterator.remove();
            }
        }
        students.add(student);
        if (isCourseExist(nextLine[2], courses, nextLine.length, student)) {
            Score score = new AssessmentResults(Integer.parseInt(nextLine[3]));
            for (Course course:courses
            ) {
                if (course.getCourseName().equals(nextLine[2])) {
                    CourseSelection courseSelection = new CourseSelection(course, student, score);
                    if (RepetitiveScores(courseSelection,courseSelections)) continue;
                    courseSelections.add(courseSelection);
                }
            }
        }
    }
    public static void addScoredCourseSelection3(String[] nextLine, ArrayList<Course> courses, ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
        ArrayList<Integer> results = new ArrayList<>();
        if (nextLine[0].length() != 8 || nextLine[1].length() > 10 || !nextLine[3].matches("[4-9]")) {
            System.out.println("wrong format");
            return;
        }
        for (int i = 4;i < nextLine.length;i ++) {
            if (!nextLine[i].matches("100|[1-9][0-9]|[0-9]")) {
                System.out.println("wrong format");
                return;
            }
            results.add(Integer.parseInt(nextLine[i]));
        }
        Student student = new Student(nextLine[0], nextLine[1]);
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student stu = iterator.next();
            if (stu.getStudentNumber().equals(student.getStudentNumber())) {
                iterator.remove();
            }
        }
        students.add(student);
        if (isCourseExist(nextLine[2], courses, nextLine.length - Integer.parseInt(nextLine[3]), student)) {
            Score score = new ExperimentalResults(results, Integer.parseInt(nextLine[3]));
            for (Course course:courses
            ) {
                if (course.getCourseName().equals(nextLine[2])) {
                    CourseSelection courseSelection = new CourseSelection(course, student, score);
                    if (RepetitiveScores(courseSelection,courseSelections)) continue;
                    courseSelections.add(courseSelection);
                }
            }
        }
    }
}
abstract class Score {
    private int dailyPerformance; // 平时成绩
    private int finalGrade; // 期末成绩

    public Score() {
    }

    public Score(int finalGrade) {
        this.finalGrade = finalGrade;
    }

    public Score(int dailyPerformance, int finalGrade) {
        this.dailyPerformance = dailyPerformance;
        this.finalGrade = finalGrade;
    }

    public int getDailyPerformance() {
        return dailyPerformance;
    }

    public void setDailyPerformance(int dailyPerformance) {
        this.dailyPerformance = dailyPerformance;
    }

    public int getFinalGrade() {
        return finalGrade;
    }

    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }

    public abstract int getTotalScore();
}
class ExaminationResults extends Score {

    public ExaminationResults(int dailyPerformance, int finalGrade) {
        super(dailyPerformance, finalGrade);
    }

    @Override
    public int getTotalScore() {
        return (int) (getDailyPerformance() * 0.3 + getFinalGrade() * 0.7);
    }
}
class AssessmentResults extends Score {

    public AssessmentResults(int finalGrade) {
        super(finalGrade);
    }
    public int getTotalScore() {
        return getFinalGrade();
    }
}
class ExperimentalResults extends Score {
    private ArrayList<Integer> results = new ArrayList<>();
    private int NumberOfTests;
    public ExperimentalResults(ArrayList<Integer> results, int numberOfTests) {
        this.results = results;
        this.NumberOfTests = numberOfTests;
    }

    public ArrayList<Integer> getResults() {
        return results;
    }

    public void setResults(ArrayList<Integer> results) {
        this.results = results;
    }

    public int getNumberOfTests() {
        return NumberOfTests;
    }

    public void setNumberOfTests(int numberOfTests) {
        NumberOfTests = numberOfTests;
    }

    @Override
    public int getTotalScore() {
        int totalScore = 0;
        for (int score:this.results
        ) {
            totalScore += score;
        }
        return totalScore / this.NumberOfTests;
    }
}
class Course {
    private String courseName; // 课程名称
    private String courseNature; // 课程性质
    private String AssessmentMethod; // 考核方式

    public Course(String courseName, String courseNature, String assessmentMethod) {
        this.courseName = courseName;
        this.courseNature = courseNature;
        AssessmentMethod = assessmentMethod;
    }

    public Course() {
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCourseNature() {
        return courseNature;
    }

    public void setCourseNature(String courseNature) {
        this.courseNature = courseNature;
    }

    public String getAssessmentMethod() {
        return AssessmentMethod;
    }

    public void setAssessmentMethod(String assessmentMethod) {
        AssessmentMethod = assessmentMethod;
    }
}
class Student {
    private String studentNumber;
    private String studentName;

    public Student(String studentNumber, String studentName) {
        this.studentNumber = studentNumber;
        this.studentName = studentName;
    }

    public String getStudentNumber() {
        return studentNumber;
    }

    public void setStudentNumber(String studentNumber) {
        this.studentNumber = studentNumber;
    }

    public String getStudentName() {
        return studentName;
    }
}
class Class {

    private int classNumber;
    private int classAverageScore;
    private ArrayList<Student> students = new ArrayList<>();

    public Class(int classNumber, ArrayList<Student> students) {
        this.classNumber = classNumber;
        this.students = students;
    }

    public Class() {

    }

    public int getClassAverageScore() {
        return classAverageScore;
    }

    public void setClassAverageScore(int classAverageScore) {
        this.classAverageScore = classAverageScore;
    }

    public int getClassNumber() {
        return classNumber;
    }

    public void setClassNumber(int classNumber) {
        this.classNumber = classNumber;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public void addStudent(Student student) {
        students.add(student);
    }
}
class CourseSelection {
    private Course course;
    private Student student;
    private Score score;

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

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }
}

  1 import java.util.*;
  2 import java.text.Collator;
  3 
  4 public class Main {
  5     public static void main(String[] args) {
  6         ArrayList<Class> classes = new ArrayList<>();
  7         ArrayList<Course> courses = new ArrayList<>();
  8         ArrayList<Student> students = new ArrayList<>();
  9         ArrayList<CourseSelection> courseSelections = new ArrayList<>();
 10         Scanner input = new Scanner(System.in);
 11         while (true) {
 12             String strrings = input.nextLine();
 13             if (strrings.equals("end")) {
 14                 break;
 15             }
 16             String[] nextLine = strrings.split(" ");
 17             if (nextLine[1].equals("必修") || nextLine[1].equals("选修") || nextLine[1].equals("实验")) {
 18                 addCourse(nextLine,courses);
 19             } else if (nextLine.length == 5) {
 20                 addScoredCourseSelection1(nextLine,courseSelections,students,courses);
 21             } else if (nextLine.length == 4) {
 22                 addScoredCourseSelection2(nextLine, courses, students, courseSelections);
 23             } else if (nextLine.length > 5) {
 24                 addScoredCourseSelection3(nextLine,courses,students,courseSelections);
 25             } else {
 26                 System.out.println("wrong format");
 27             }
 28         }
 29         for (Student student:students
 30         ) {
 31             int classNumber = Integer.parseInt(student.getstudentNumberID()) / 100;
 32             if (classes.isEmpty()) {
 33                 Class clasS = new Class();
 34                 clasS.setClassNumber(classNumber);
 35                 clasS.getStudents().add(student);
 36                 classes.add(clasS);
 37             } else {
 38                 ListIterator<Class> iterator = classes.listIterator();
 39                 while (iterator.hasNext()) {
 40                     Class clas = iterator.next();
 41                     if (clas.getClassNumber() == classNumber) {
 42                         clas.getStudents().add(student);
 43                         break;
 44                     } else {
 45                         if (classes.indexOf(clas) == classes.size() - 1) {
 46                             Class clasNew = new Class();
 47                             clasNew.setClassNumber(classNumber);
 48                             clasNew.getStudents().add(student);
 49                             iterator.add(clasNew);
 50                         }
 51                     }
 52                 }
 53             }
 54         }
 55         Collections.sort(classes, Comparator.comparingInt(O -> O.getClassNumber()));
 56         for (Class clas:classes
 57         ) {
 58             clas.setClassAverageScore(print1(clas.getStudents(), courseSelections));
 59         }
 60         print2(courses, courseSelections);
 61         for (Class clas:classes
 62         ) {
 63             if (clas.getClassAverageScore() == -1) {
 64                 System.out.println(clas.getClassNumber() + " has no grades yet");
 65             } else System.out.println(clas.getClassNumber() + " " + clas.getClassAverageScore());
 66         }
 67     }
 68     public static int print1(ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
 69         int classAverageScore = 0;
 70         Collections.sort(students, Comparator.comparingInt(O -> Integer.parseInt(O.getstudentNumberID())));
 71         for (Student student:students
 72         ) {
 73             int averageScore = 0;
 74             int courseNum = 0;
 75             for (CourseSelection cs:courseSelections
 76             ) {
 77                 if (cs.getStudent().getstudentNumberID().equals(student.getstudentNumberID())) {
 78                     averageScore += cs.getScore().getTotalScore();
 79                     courseNum ++;
 80                 }
 81             }
 82             if (courseNum == 0) {
 83                 System.out.println(student.getstudentNumberID() + " " + student.getStudentName() + " did not take any exams");
 84                 return -1;
 85             } else {
 86                 averageScore /= courseNum;
 87                 System.out.println(student.getstudentNumberID() + " " + student.getStudentName() + " " + averageScore);
 88             }
 89             classAverageScore += averageScore;
 90         }
 91         return classAverageScore / students.size();
 92     }
 93     public static void print2(ArrayList<Course> courses, ArrayList<CourseSelection> courseSelections) {
 94         Collections.sort(courses, (O1, O2) -> {
 95             Collator collator = Collator.getInstance(Locale.CHINA);
 96             return collator.compare(O1.getCourseName(), O2.getCourseName());
 97         });
 98         for (Course course:courses
 99         ) {
100             int courseAverageScore = 0;
101             int studentNum = 0;
102             for (CourseSelection cs:courseSelections
103             ) {
104                 if (course.getCourseName().equals(cs.getCourse().getCourseName())) {
105                     courseAverageScore += cs.getScore().getTotalScore();
106                     studentNum ++;
107                 }
108             }
109             if (studentNum == 0) {
110                 System.out.println(course.getCourseName() + " has no grades yet");
111             } else {
112                 courseAverageScore /= studentNum;
113                 System.out.println(course.getCourseName() + " " + courseAverageScore);
114             }
115 
116         }
117     }
118     public static boolean isCourseExist(String courseName, ArrayList<Course> courses, int length, Student student) {
119         for (Course course:courses
120         ) {
121             if (course.getCourseName().equals(courseName)) {
122                 if ((course.getAssessmentMethod().equals("考试") && length == 5) ||
123                         (course.getAssessmentMethod().equals("考察") && length == 4) ||
124                         (course.getAssessmentMethod().equals("实验") && length == course.getWeightNumber())) {
125                     return true;
126                 } else {
127                     System.out.println(student.getstudentNumberID() + " " + student.getStudentName() + " : access mode mismatch");
128                     return false;
129                 }
130             }
131         }
132         System.out.println(courseName + " does not exist");
133         return false;
134     }
135     public static boolean RepetitiveCourses(String courseName,ArrayList<Course> courses) {
136         for (Course cou:courses
137         ) {
138             if (cou.getCourseName().equals(courseName)) return true;
139         }
140         return false;
141     }
142     public static boolean RepetitiveScores(CourseSelection courseSelection,ArrayList<CourseSelection> courseSelections) {
143         for (CourseSelection cs:courseSelections
144         ) {
145             if (cs.getStudent().getStudentName().equals(courseSelection.getStudent().getStudentName())) {
146                 if (cs.getCourse().getCourseName().equals(courseSelection.getCourse().getCourseName())) {
147                     return true;
148                 }
149             }
150         }
151         return false;
152     }
153     public static void addCourse(String[] nextLine, ArrayList<Course> courses) {
154         if (RepetitiveCourses(nextLine[0],courses)) return;
155         if (nextLine[0].length() > 10 ||
156                 (!nextLine[2].equals("考试") && !nextLine[2].equals("考察") && !nextLine[2].equals("实验"))) {
157             System.out.println("wrong format");
158             return;
159         }
160         int weightNumber;
161         double totalWeight = 0;
162         ArrayList<Double> weights = new ArrayList<>();
163         if (nextLine[1].equals("必修")) {
164             if (nextLine.length != 5) {
165                 System.out.println(nextLine[0] + " : number of scores does not match");
166                 return;
167             }
168             weightNumber = 2;
169             weights.add(Double.parseDouble(nextLine[3]));
170             weights.add(Double.parseDouble(nextLine[4]));
171             for (double weight:weights
172             ) {
173                 totalWeight += weight;
174             }
175         } else if (nextLine[1].equals("选修")) {
176             weightNumber = 1;
177             totalWeight = 1;
178             weights.add(1.0);
179         } else if (nextLine[1].equals("实验")) {
180             weightNumber = Integer.parseInt(nextLine[3]);
181             if (nextLine.length != 4 + weightNumber) {
182                 System.out.println(nextLine[0] + " : number of scores does not match");
183                 return;
184             }
185             if (!nextLine[3].matches("[4-9]")) {
186                 System.out.println("wrong format");
187                 return;
188             }
189             for (int i = 4;i < nextLine.length;i ++) {
190                 weights.add(Double.parseDouble(nextLine[i]));
191                 totalWeight += Double.parseDouble(nextLine[i]);
192             }
193         } else {
194             System.out.println("wrong format");
195             return;
196         }
197         if (Math.abs(totalWeight - 1) > 0.01) {
198             System.out.println(nextLine[0] + " : weight value error");
199             return;
200         }
201         Course course = new Course(nextLine[0], nextLine[1], nextLine[2], weightNumber, weights);
202         if ((course.getcourseType().equals("必修") && !course.getAssessmentMethod().equals("考试")) ||
203                 (course.getcourseType().equals("实验") && !course.getAssessmentMethod().equals("实验"))) {
204             System.out.println(course.getCourseName() + " : course type & access mode mismatch");
205             return;
206         }
207         courses.add(course);
208     }
209     public static void addScoredCourseSelection1(String[] nextLine, ArrayList<CourseSelection> courseSelections, ArrayList<Student> students, ArrayList<Course> courses) {
210         if (!nextLine[3].matches("100|[1-9][0-9]|[0-9]") ||
211                 !nextLine[4].matches("100|[1-9][0-9]|[0-9]") ||
212                 nextLine[0].length() != 8 ||
213                 nextLine[1].length() > 10) {
214             System.out.println("wrong format");
215             return;
216         }
217         Student student = new Student(nextLine[0], nextLine[1]);
218         Iterator<Student> iterator = students.iterator();
219         while (iterator.hasNext()) {
220             Student stu = iterator.next();
221             if (stu.getstudentNumberID().equals(student.getstudentNumberID())) {
222                 iterator.remove();
223             }
224         }
225         students.add(student);
226         if (isCourseExist(nextLine[2], courses, nextLine.length, student)) {
227             for (Course course:courses
228             ) {
229                 if (course.getCourseName().equals(nextLine[2])) {
230                     Score score = new Score(new ExaminationResults(Integer.parseInt(nextLine[3]), Integer.parseInt(nextLine[4])), course);
231                     CourseSelection courseSelection = new CourseSelection(course, student, score);
232                     if (RepetitiveScores(courseSelection,courseSelections)) break;
233                     courseSelections.add(courseSelection);
234                 }
235             }
236         }
237     }
238     public static void addScoredCourseSelection2(String[] nextLine, ArrayList<Course> courses, ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
239         if (!nextLine[3].matches("100|[1-9][0-9]|[0-9]") ||
240                 nextLine[0].length() != 8 ||
241                 nextLine[1].length() > 10) {
242             System.out.println("wrong format");
243             return;
244         }
245         Student student = new Student(nextLine[0], nextLine[1]);
246         Iterator<Student> iterator = students.iterator();
247         while (iterator.hasNext()) {
248             Student stu = iterator.next();
249             if (stu.getstudentNumberID().equals(student.getstudentNumberID())) {
250                 iterator.remove();
251             }
252         }
253         students.add(student);
254         if (isCourseExist(nextLine[2], courses, nextLine.length, student)) {
255             for (Course course:courses
256             ) {
257                 if (course.getCourseName().equals(nextLine[2])) {
258                     Score score = new Score(new AssessmentResults(Integer.parseInt(nextLine[3])), course);
259                     CourseSelection courseSelection = new CourseSelection(course, student, score);
260                     if (RepetitiveScores(courseSelection,courseSelections)) break;
261                     courseSelections.add(courseSelection);
262                 }
263             }
264         }
265     }
266     public static void addScoredCourseSelection3(String[] nextLine, ArrayList<Course> courses, ArrayList<Student> students, ArrayList<CourseSelection> courseSelections) {
267         ArrayList<Integer> results = new ArrayList<>();
268         if (nextLine[0].length() != 8 || nextLine[1].length() > 10) {
269             System.out.println("wrong format");
270             return;
271         }
272         for (int i = 3;i < nextLine.length;i ++) {
273             if (!nextLine[i].matches("100|[1-9][0-9]|[0-9]")) {
274                 System.out.println("wrong format");
275                 return;
276             }
277             results.add(Integer.parseInt(nextLine[i]));
278         }
279         Student student = new Student(nextLine[0], nextLine[1]);
280         Iterator<Student> iterator = students.iterator();
281         while (iterator.hasNext()) {
282             Student stu = iterator.next();
283             if (stu.getstudentNumberID().equals(student.getstudentNumberID())) {
284                 iterator.remove();
285             }
286         }
287         students.add(student);
288         if (isCourseExist(nextLine[2], courses, nextLine.length - 3, student)) {
289             for (Course course:courses
290             ) {
291                 if (course.getCourseName().equals(nextLine[2])) {
292                     Score score = new Score(new ExperimentalResults(results), course);
293                     CourseSelection courseSelection = new CourseSelection(course, student, score);
294                     if (RepetitiveScores(courseSelection,courseSelections)) break;
295                     courseSelections.add(courseSelection);
296                 }
297             }
298         }
299     }
300 }
301 
302 class Course {
303     private String courseName; // 课程名称
304     private String courseType; // 课程性质
305     private String AssessmentMethod; // 考核方式
306     private int weightNumber;
307     private ArrayList<Double> weight;
308 
309     public Course(String courseName, String courseType, String assessmentMethod, int weightNumber, ArrayList<Double> weight) {
310         this.courseName = courseName;
311         this.courseType = courseType;
312         AssessmentMethod = assessmentMethod;
313         this.weightNumber = weightNumber;
314         this.weight = weight;
315     }
316 
317     public String getCourseName() {
318         return courseName;
319     }
320 
321  /*   public void setCourseName(String courseName) {
322         this.courseName = courseName;
323     }*/
324 
325     public String getcourseType() {
326         return courseType;
327     }
328 
329  /*   public void setcourseType(String courseType) {
330         this.courseType = courseType;
331     }*/
332 
333     public String getAssessmentMethod() {
334         return AssessmentMethod;
335     }
336 
337 /*    public void setAssessmentMethod(String assessmentMethod) {
338         AssessmentMethod = assessmentMethod;
339     }*/
340 
341     public int getWeightNumber() {
342         return weightNumber;
343     }
344 
345 /*   public void setWeightNumber(int weightNumber) {
346         this.weightNumber = weightNumber;
347     }*/
348 
349     public ArrayList<Double> getWeight() {
350         return weight;
351     }
352 
353  /*   public void setWeight(ArrayList<Double> weight) {
354         this.weight = weight;
355     }*/
356 }
357 
358 class Score {
359     private ExaminationResults examinationResults;
360     private AssessmentResults assessmentResults;
361     private ExperimentalResults experimentalResults;
362     private Course course;
363 
364     public Score(ExaminationResults examinationResults, Course course) {
365         this.examinationResults = examinationResults;
366         this.course = course;
367     }
368 
369     public Score(AssessmentResults assessmentResults, Course course) {
370         this.assessmentResults = assessmentResults;
371         this.course = course;
372     }
373 
374     public Score(ExperimentalResults experimentalResults, Course course) {
375         this.experimentalResults = experimentalResults;
376         this.course = course;
377     }
378 
379     public int getTotalScore() {
380         if (course.getAssessmentMethod().equals("考试")) {
381             return (int) (examinationResults.getDailyPerformance() * course.getWeight().get(0) + examinationResults.getFinalGrade() * course.getWeight().get(1));
382         } else if (course.getAssessmentMethod().equals("考察")) {
383             return assessmentResults.getTotalScore();
384         } else {
385             double totalScore = 0;
386             int i = 0;
387             for (int result:experimentalResults.getResults()
388             ) {
389                 totalScore += result * course.getWeight().get(i);
390                 i ++;
391             }
392             return (int) (totalScore);
393         }
394     }
395 }
396 class ExaminationResults {
397 
398     private int dailyPerformance;
399     private int finalGrade;
400     public ExaminationResults(int dailyPerformance, int finalGrade) {
401         this.dailyPerformance = dailyPerformance;
402         this.finalGrade = finalGrade;
403     }
404 
405     public int getDailyPerformance() {
406         return dailyPerformance;
407     }
408 
409 /*    public void setDailyPerformance(int dailyPerformance) {
410         this.dailyPerformance = dailyPerformance;
411     }*/
412 
413     public int getFinalGrade() {
414         return finalGrade;
415     }
416 
417 /*    public void setFinalGrade(int finalGrade) {
418         this.finalGrade = finalGrade;
419     }*/
420 }
421 
422 class AssessmentResults {
423     private int totalScore;
424 
425     public int getTotalScore() {
426         return totalScore;
427     }
428 
429  /*   public void setTotalScore(int totalScore) {
430         this.totalScore = totalScore;
431     }*/
432 
433     public AssessmentResults(int totalScore) {
434         this.totalScore = totalScore;
435     }
436 }
437 
438 class ExperimentalResults {
439     private ArrayList<Integer> results = new ArrayList<>();
440     public ExperimentalResults(ArrayList<Integer> results) {
441         this.results = results;
442     }
443 
444     public ArrayList<Integer> getResults() {
445         return results;
446     }
447 
448 /*    public void setResults(ArrayList<Integer> results) {
449         this.results = results;
450     }*/
451 }
452 
453 
454 class Student {
455     private String studentNumberID;
456     private String studentName;
457 
458     public Student(String studentNumberID, String studentName) {
459         this.studentNumberID = studentNumberID;
460         this.studentName = studentName;
461     }
462 
463     public String getstudentNumberID() {
464         return studentNumberID;
465     }
466 
467     public void setstudentNumberID(String studentNumberID) {
468         this.studentNumberID = studentNumberID;
469     }
470 
471     public String getStudentName() {
472         return studentName;
473     }
474 }
475 
476 class PersonOverride {
477     private String name;
478     private int age;
479     private boolean gender;
480 
481     public PersonOverride(String name, int age, boolean gender) {
482         this.name = name;
483         this.age = age;
484         this.gender = gender;
485     }
486 
487     public PersonOverride() {
488 
489         this("default", 1, true);
490 
491     }
492 
493     @Override
494     public String toString() {
495 
496         return name + "-" + age + "-" + gender;
497 
498     }
499 
500     @Override
501     public boolean equals(Object obj) {
502         if (obj == this) {
503             return true;
504         }
505         if (!(obj instanceof PersonOverride)) {
506             return false;
507         }
508         PersonOverride other = (PersonOverride) obj;
509         return this.name.equals(other.name) && this.age == other.age && this.gender == other.gender;
510     }
511 }
512 
513 class TotalScore{
514     
515 }
516 class Class {
517 
518     private int classNumber;
519     private int classAverageScore;
520     private ArrayList<Student> students = new ArrayList<>();
521 
522 /*    public Class(int classNumber, ArrayList<Student> students) {
523         this.classNumber = classNumber;
524         this.students = students;
525     }*/
526 
527     public Class() {
528 
529     }
530 
531     public int getClassAverageScore() {
532         return classAverageScore;
533     }
534 
535     public void setClassAverageScore(int classAverageScore) {
536         this.classAverageScore = classAverageScore;
537     }
538 
539     public int getClassNumber() {
540         return classNumber;
541     }
542 
543     public void setClassNumber(int classNumber) {
544         this.classNumber = classNumber;
545     }
546 
547     public ArrayList<Student> getStudents() {
548         return students;
549     }
550 
551  /*   public void setStudents(ArrayList<Student> students) {
552         this.students = students;
553     }
554     public void addStudent(Student student) {
555         students.add(student);
556     }*/
557 }
558 class CourseSelection {
559     private Course course;
560     private Student student;
561     private Score score;
562 
563     public CourseSelection(Course course, Student student, Score score) {
564         this.course = course;
565         this.student = student;
566         this.score = score;
567     }
568 
569     public Course getCourse() {
570         return course;
571     }
572 
573 /*    public void setCourse(Course course) {
574         this.course = course;
575     }*/
576 
577     public Student getStudent() {
578         return student;
579     }
580 
581  /*   public void setStudent(Student student) {
582         this.student = student;
583     }*/
584 
585     public Score getScore() {
586         return score;
587     }
588 
589 /*    public void setScore(Score score) {
590         this.score = score;
591     }*/
592 }

  1 import java.util.Scanner;
  2 
  3 public class Main {
  4     public static void main(String[] args) {
  5         // TODO Auto-generated method stub
  6         Scanner input = new Scanner(System.in);
  7         
  8         String color = input.next();
  9         int layer = input.nextInt();
 10         double side = input.nextDouble();        
 11         
 12         RubikCube cube1 = new SquareCube(color, layer, new Cube(side)); 
 13                 
 14         color = input.next();
 15         layer = input.nextInt();
 16         side = input.nextDouble();
 17         
 18         RubikCube cube2 = new RegularPyramidCube(color, layer, new RegularPyramid(side));
 19         display(cube1);
 20         display(cube2);
 21     }
 22 
 23     public static void display(RubikCube cube) {
 24         System.out.println(cube.getColor());
 25         System.out.println(String.format("%.2f", cube.surfaceArea()));
 26         System.out.println(String.format("%.2f", cube.volume()));
 27     }
 28 }
 29 
 30 interface Solid { 
 31     double surfaceArea();
 32     double volume();
 33 }
 34 
 35 class Cube implements Solid { 
 36     private double side;
 37     public Cube(double side) {
 38         this.side = side;
 39     }
 40 
 41     @Override
 42     public double surfaceArea() {
 43         return  6 * side * side;
 44     }
 45 
 46     @Override
 47     public double volume() {
 48         return side * side * side;
 49     }
 50 }
 51 
 52 class RegularPyramid implements Solid { 
 53     private double side;
 54     public RegularPyramid(double side) {
 55         this.side = side;
 56     }
 57 
 58     @Override
 59     public double surfaceArea() {
 60         return (side/2)*(side/2)*Math.sqrt(3)*4;
 61     }
 62 
 63     @Override
 64     public double volume() {
 65         return  side * Math.sqrt(6) * side * side * Math.sqrt(3) / 36;
 66     }
 67 }
 68 
 69 abstract class RubikCube {
 70     protected String color;
 71     protected int layer;
 72     protected Solid unit;
 73 
 74     public RubikCube(String color, int layer, Solid unit) {
 75         this.color = color;
 76         this.layer = layer;
 77         this.unit = unit;
 78     }
 79 
 80     public String getColor() {
 81         return color;
 82     }
 83 
 84     public abstract double surfaceArea();
 85 
 86     public abstract double volume();
 87 }
 88 
 89 class SquareCube extends RubikCube {
 90     public SquareCube(String color, int layer, Solid unit) {
 91         super(color, layer, unit);
 92     }
 93 
 94     @Override
 95     public double surfaceArea() {
 96         return  layer * layer * unit.surfaceArea();
 97     }
 98 
 99     @Override
100     public double volume() {
101         return layer * layer * layer * unit.volume();
102     }
103 }
104 
105 class RegularPyramidCube extends RubikCube {
106     public RegularPyramidCube(String color, int layer, Solid unit) {
107         super(color, layer, unit);
108     }
109 
110     @Override
111     public double surfaceArea() {
112         return  layer * layer * unit.surfaceArea();
113     }
114 
115     @Override
116     public double volume() {
117         return layer * layer * layer * unit.volume();
118     }
119 }