PTA7-8次PTA题目集以及期末考试总结

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;

class student_message{
    Class classes;
    Student students;
    Course courses;

    public student_message() {
    }

    public student_message(Class classes, Student students, Course courses) {
        this.classes = classes;
        this.students = students;
        this.courses = courses;
    }

}

class Class extends student_message{
     String classNum;
    HashMap<String, Student> students;

    Class(String classNum) {
        this.classNum = classNum;
    }

    public String get_ClassNum() {
        return classNum;
    }

}

class Student extends student_message{
     String name;
     String studentNum;

    Student(String name, String studentNum) {
        this.name = name;
        this.studentNum = studentNum;
    }

    public String getName() {
        return name;
    }

    public String getStudentNum() {
        return studentNum;
    }

}

class Course extends student_message {
     String className;
    int courseid1;
    int courseid2;
    ArrayList<Float> course_classProcess = new ArrayList<>();

    Course(String className, int courseid1, int courseid2) {
        this.className = className;
    }

    public String getClassName() {
        return className;
    }


}

class CourseSelection {
    Student student;
    Course course;
    Grade grade;
}

class Grade {
    ArrayList<Integer> grades = new ArrayList<>();
    ArrayList<Float> stuiate_grade = new ArrayList<>();
    public int getGrade() {
        float allGrades = 0;
        for (int i = 0; i < stuiate_grade.size(); i++) {
            allGrades += stuiate_grade.get(i) * grades.get(i);
        }
        return (int) allGrades;
    }
}



abstract class Print {
    abstract public void studentPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections);

    abstract public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections);

    abstract public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections);
}
class printer extends Print {
    public void studentPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections) {
        Set<String> set = students.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        student_process(arr, courseSelections, students);
    }

    public void student_process(Object[] arr, ArrayList<CourseSelection> courseSelections, HashMap<String, Student> students) {
        for (Object key : arr) {
            int x = 0, y = 0, z = -1;
            for (CourseSelection courseSelection : courseSelections) {
                if (students.get(key).getStudentNum().equals(courseSelection.student.getStudentNum())) {
                    z = 0;
                    x += courseSelection.grade.getGrade();
                    y++;
                }
            }
            if (z == -1) {
                System.out.println(students.get(key).getStudentNum() + " " + students.get(key).getName() + " did not take any exams");
            }
            if (z == 0) {
                x = x / y;
                System.out.println(students.get(key).getStudentNum() + " " + students.get(key).getName() + " " + x);
            }
        }
    }

    public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
        List<String> list = courses.keySet().stream().collect(Collectors.toList());
        Collections.sort(list, new SoftName());
        course_process(list, courseSelections, courses);
    }

    public void course_process(List<String> list, ArrayList<CourseSelection> courseSelections, HashMap<String, Course> courses) {
        for (String key : list) {
            int x = 0, y = 0, z = -1;
            for (CourseSelection courseSelection : courseSelections) {
                if (courses.get(key).getClassName().equals(courseSelection.course.getClassName())) {
                    z = 0;
                    x += courseSelection.grade.getGrade();
                    y++;
                }
            }
            if (z == -1) {
                System.out.println(courses.get(key).getClassName() + " has no grades yet");
            }
            if (z == 0) {
                x = x / y;
                System.out.println(courses.get(key).getClassName() + " " + x);
            }
        }
    }

    public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
        Set<String> set = classes.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        class_process(arr, courseSelections, classes);
    }

    public void class_process(Object[] arr, ArrayList<CourseSelection> courseSelections, HashMap<String, Class> classes) {
        for (Object key : arr) {
            int x = 0, y = 0, z = -1;
            for (CourseSelection courseSelection : courseSelections) {
                if (classes.get(key).students.containsKey(courseSelection.student.getStudentNum())) {
                    z = 0;
                    x += courseSelection.grade.getGrade();
                    y++;
                }
            }
            if (z == -1) {
                System.out.println(classes.get(key).get_ClassNum() + " has no grades yet");
            }
            if (z == 0) {
                x = x / y;
                System.out.println(classes.get(key).get_ClassNum() + " " + x);
            }
        }
    }

    static class SoftName implements Comparator<String> {
        public int compare(String name1, String name2) {
            Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
            return compare.compare(name1, name2);
        }
    }
}
abstract class Course_Process{
    abstract public void input_process(String strs);

    abstract  public void Is_inputype(String[] inputs);
    abstract public void Is_inputmode(String[] inputs);
}
class ALL_print extends Course_Process{
    printer print;
    HashMap<String, student_message> stu = new HashMap<>();
    HashMap<String, Class> classes = new HashMap<>();
    HashMap<String, Student> students = new HashMap<>();
    HashMap<String, Course> courses = new HashMap<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();

    public void input_process(String strs) {
        String[] inputs = strs.split(" ");
        if (strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
                strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*)( )(0.(0)+[1-9]|0.[1-9][0-9]*)$)") ||
                strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*))$")
        ) {
            Is_inputype(inputs);
        } else if (strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
                strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
                strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )((([0-9]|[1-9][0-9]|100)( ))*)([0-9]|[1-9][0-9]|100)$")
        ) {
            Is_inputmode(inputs);
        } else
            System.out.println("wrong format");
    }

    public void Is_inputype(String[] inputs) {
        if (courses.containsKey(inputs[0])) {
            return;
        }
        int i = 0, j = 0;
        if (inputs[1].equals("必修")) {
            i = 1;
        }
        if (inputs[1].equals("选修")) {
            i = 2;
        }
        if (inputs[1].equals("实验")) {
            i = 3;
        }
        if (inputs[2].equals("考试")) {
            j = 1;
        }
        if (inputs[2].equals("考察")) {
            j = 2;
        }
        if (inputs[2].equals("实验")) {
            j = 3;
        }
        if ((i == 1 && j != 1) || (i == 3 && j != 3) || (i != 3 && j == 3)) {
            System.out.println(inputs[0] + " : course type & access mode mismatch");
            return;
        }
        if ((j == 1 && inputs.length != 5) || (j == 2 && inputs.length != 3) || (j == 3 && inputs.length - 4 != Integer.parseInt(inputs[3]))) {
            System.out.println(inputs[0] + " : number of scores does not match");
            return;
        }
        if (j == 1 && Float.parseFloat(inputs[3]) + Float.parseFloat(inputs[4]) != 1) {
            System.out.println(inputs[0] + " : weight value error");
            return;
        }
        if (j == 3) {
            float value = 0;
            for (int k = 0; k < Integer.parseInt(inputs[3]); k++) {
                value += Float.parseFloat(inputs[4 + k]);
            }
            if (value > 1.001 || value < 0.999) {
                System.out.println(inputs[0] + " : weight value error");
                return;
            }
        }
        Course course = new Course(inputs[0], i, j);
        if (j == 1) {
            course.course_classProcess.add(Float.parseFloat(inputs[3]));
            course.course_classProcess.add(Float.parseFloat(inputs[4]));
        }
        if (j == 2)
            course.course_classProcess.add(1F);
        if (j == 3) {
            for (int k = 0; k < Integer.parseInt(inputs[3]); k++) {
                course.course_classProcess.add(Float.parseFloat(inputs[4 + k]));
            }
        }
        courses.put(inputs[0], course);
    }

    public void Is_inputmode(String[] inputs) {
        for (CourseSelection courseSelection : courseSelections) {
            if (courseSelection.student.getStudentNum().equals(inputs[0]) && courseSelection.student.getName().equals(inputs[1]) && courseSelection.course.getClassName().equals(inputs[2])) {
                return;
            }
        }
        Student student = new Student(inputs[1], inputs[0]);
        students.put(inputs[0], student);
        String classNum = inputs[0].substring(0, 6);
        if (!classes.containsKey(classNum)) {
            Class class_num = new Class(classNum);
            classes.put(classNum, class_num);
            classes.get(classNum).students = new HashMap<>();
        }
        classes.get(classNum).students.put(student.getStudentNum(), student);
        if (!courses.containsKey(inputs[2])) {
            System.out.println(inputs[2] + " does not exist");
            return;
        }
        if (inputs.length - 3 != courses.get(inputs[2]).course_classProcess.size()) {
            System.out.println(inputs[0] + " " + inputs[1] + " : access mode mismatch");
            return;
        }
        CourseSelection courseSelection = new CourseSelection();
        courseSelection.student = student;
        courseSelection.course = courses.get(inputs[2]);
        Grade grade = new Grade();
        for (int i = 0; i < inputs.length - 3; i++) {
            grade.grades.add(Integer.parseInt(inputs[3 + i]));
        }
        grade.stuiate_grade = courses.get(inputs[2]).course_classProcess;
        courseSelection.grade = grade;
        courseSelections.add(courseSelection);
    }
}

public class Main {
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static ALL_print allprint = new ALL_print();

    public static void main(String[] args) throws IOException {
        allprint.print = new printer();
        end_printf();
    }

    public static void end_printf() throws IOException {
        for (; ; ) {
            String str = in.readLine();
            if (str.equals("end")) {
                allprint.print.studentPrint(allprint.students, allprint.courseSelections);
                allprint.print.coursePrint(allprint.courses, allprint.courseSelections);
                allprint.print.classPrint(allprint.classes, allprint.courseSelections);
                break;
            }
            allprint.input_process(str);
        }
    }
}

import java.util.Scanner;

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));

    }
    public  static void display(Solid solid){
        System.out.println(String.format("%.2f",solid.getarea()));
        System.out.println(String.format("%.2f",solid.getvolum()));
    }
}
abstract class Solid{
    abstract double getarea();
    abstract double getvolum();
}

class Cube extends Solid{

    double side;

    public Cube(double side) {
        this.side = side;
    }

    @Override
    double getarea() {
        double area=0;
        area=side*side*6;
        return area;
    }

    @Override
    double getvolum() {
        double volum=0;
        volum=side*side*side;
        return volum;
    }

}
class RegularPyramid extends Solid{
    double side;


    public RegularPyramid(double side) {
        this.side = side;
    }

    @Override
    double getarea() {
        double baseArea = (Math.sqrt(3) / 4) * side * side;
        double lateralArea = 3 * baseArea;  // 正三棱锥有三个等边三角形的侧面
        return baseArea + lateralArea;
    }

    @Override
    double getvolum() {
        return (Math.sqrt(2) / 12) * side * side * side ;
    }

}