class Dish {
    String name;
    int unit_price;

    public Dish(String name, int unit_price) {
        this.name = name;
        this.unit_price = unit_price;
    }

    public int getPrice(int portion) {
        double price;

        if (portion == 1) {
            price = unit_price;
        } else if (portion == 2) {
            price = unit_price * 1.5;
        } else if (portion == 3) {
            price = unit_price * 2;
        } else {
            throw new IllegalArgumentException("Invalid portion: " + portion);
        }

        return (int) Math.round(price);
    }
}

class Menu {
    Dish[] dishes;

    public Menu(Dish[] dishes) {
        this.dishes = dishes;
    }

    public Dish searchDish(String dishName) {
        for (Dish dish : dishes) {
            if (dish.name.equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
}

class Record {
    Dish dish;
    int portion;

    public Record(Dish dish, int portion) {
        this.dish = dish;
        this.portion = portion;
    }

    public int getPrice() {
        return dish.getPrice(portion);
    }
}

class Order {
    Record[] records;
    int size;

    public Order(int capacity) {
        records = new Record[capacity];
        size = 0;
    }

    public void addARecord(String dishName, int portion) {
        Dish dish = MenuHolder.menu.searchDish(dishName);
        if (dish != null) {
            Record record = new Record(dish, portion);
            records[size] = record;
            size++;
        } else {
            System.out.println(dishName + " does not exist");
        }
    }

    public int getTotalPrice() {
        int totalPrice = 0;
        for (int i = 0; i < size; i++) {
            totalPrice += records[i].getPrice();
        }
        return totalPrice;
    }
}

class MenuHolder {
    static Menu menu;
    static {
        Dish[] dishes = new Dish[4];
        dishes[0] = new Dish("西红柿炒蛋", 15);
        dishes[1] = new Dish("清炒土豆丝", 12);
        dishes[2] = new Dish("麻婆豆腐", 12);
        dishes[3] = new Dish("油淋生菜", 9);
        menu = new Menu(dishes);
    }
}
public class Main {
    public static void main(String[] args) {
        Order order = new Order(10);
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        while (true) {
            String input = scanner.nextLine().trim();

            if (input.equalsIgnoreCase("end")) {
                break;
            }
            String[] parts = input.split(" ");
            if (parts.length == 2) {
                String dishName = parts[0];
                int portion = Integer.parseInt(parts[1]);

                order.addARecord(dishName, portion);
            } else {
                System.out.println(input);
            }
        }

        System.out.println( order.getTotalPrice());

        scanner.close();
    }
}

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

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String information = input.nextLine();
        ParseInput handle = new ParseInput();
        while (!information.equals("end"))
        {
            handle.parseInput(information);
            information = input.nextLine();
        }
        handle.showStudents();
        handle.showCourses();
        handle.showClasses();}
    private static double calculateDuplication1(String input1, String input2) {
        Set<Character> set1 = new HashSet<>();
        Set<Character> set2 = new HashSet<>();

        for (char c : input1.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                set1.add(c);
            }
        }

        for (char c : input2.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                set2.add(c);
            }
        }
        Set<Character> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        double duplication = (double) intersection.size() / set1.size() * 100;

        return duplication;
    }
    private static double calculateDuplication2(String input1, String input2) {
        Set<Character> set1 = new HashSet<>();
        Set<Character> set2 = new HashSet<>();

        for (char c : input1.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                set1.add(c);
            }
        }

        for (char c : input2.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                set2.add(c);
            }
        }
        Set<Character> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        double duplication = (double) intersection.size() / set1.size() * 100;

        return duplication;
    }
}
    class ParseInput {
        ArrayList<Student> listStudent = new ArrayList<>();
        ArrayList<Course> listCourse = new ArrayList<>();
        ArrayList<Class> listClass = new ArrayList<>();
        ArrayList<ChooseCourse> listChooseCourse = new ArrayList<>();

        public void parseInput(String str){
            InputMatching mat=new InputMatching();
            int flag=mat.matchingInput(str);
            switch (flag){
                case 0:System.out.println("wrong format");
                    break;
                //课程信息
                case 1:courseMessage(str);
                    break;
                //成绩信息
                case 2:gradeMessage(str);
                    break;
            }
        }
        private static String readInput(Scanner scanner) {
            StringBuilder sb = new StringBuilder();
            String line;

            while (!(line = scanner.nextLine()).equals("end")) {
                sb.append(line);
                sb.append(System.lineSeparator());
            }

            return sb.toString();
        }

        private static double calculateDuplication(String input1, String input2) {
            Set<Character> set1 = new HashSet<>();
            Set<Character> set2 = new HashSet<>();

            for (char c : input1.toCharArray()) {
                if (Character.isLetterOrDigit(c)) {
                    set1.add(c);
                }
            }

            for (char c : input2.toCharArray()) {
                if (Character.isLetterOrDigit(c)) {
                    set2.add(c);
                }
            }
            Set<Character> intersection = new HashSet<>(set1);
            intersection.retainAll(set2);
            double duplication = (double) intersection.size() / set1.size() * 100;

            return duplication;
        }

        public void courseMessage(String str) {

            String letters[] = str.split(" ");

            String courseName = letters[0];
            String type = letters[1];
            String testType = letters[2];

            Course course = new Course(courseName, type, testType);

            if (checkCourse(course)) {
                if (searchCourse(courseName) == null)
                    listCourse.add(course);
            }

        }

        public void gradeMessage(String str) {
            String letters[] = str.split(" ");

            String stuId = letters[0];
            String classID = letters[0].substring(0, 6);
            String name = letters[1];
            String courseName = letters[2];


            if (searchClass(classID) == null) {
                Class cla = new Class(classID);
                listClass.add(cla);
            }

            Student stu = new Student(classID, stuId, name);
            if (!searchStudent(stuId))
                listStudent.add(stu);//将学生加入列表中
            //课程是否存在
            if (searchCourse(courseName) == null) {
                System.out.println(courseName + " " + "does not exist");
            }
            //当课程存在时
            else if (searchCourse(courseName) != null) {
                Course course = searchCourse(courseName);
                //考察
                if (letters.length == 4 && course.testType.equals("考察")) {
                    int finalGrade = Integer.parseInt(letters[3]);
                    AssessGrade assessGrade = new AssessGrade(finalGrade);
                    ChooseCourse chooseCourse = new ChooseCourse(course, stu, assessGrade);
                    if (!searchChooseCourse(name, courseName))
                        listChooseCourse.add(chooseCourse);
                }
                //考试
                else if (letters.length == 5 && course.testType.equals("考试")) {
                    int usualGrade = Integer.parseInt(letters[3]);
                    int finalGrade = Integer.parseInt(letters[4]);
                    ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade);
                    ChooseCourse chooseCourse = new ChooseCourse(course, stu, examGrade);
                    listChooseCourse.add(chooseCourse);
                } else {
                    System.out.println(stuId + " " + name + " " + ": access mode mismatch");
                }
            }
        }
        public boolean checkCourse(Course course) {
            int flag1, flag2;
            switch (course.getType()) {
                case "必修":
                    flag1 = 0;
                    break;
                case "选修":
                    flag1 = 1;
                    break;
                default:
                    flag1 = -1;
                    break;
            }
            switch (course.getTestType()) {
                case "考试":
                    flag2 = 0;
                    break;
                case "考察":
                    flag2 = 1;
                    break;
                default:
                    flag2 = -1;
                    break;
            }
            if (flag1 == 0 && flag2 == 0)
                return true;
            if (flag1 == 1 && (flag2 == 0 || flag2 == 1))
                return true;
            System.out.println(course.getCourseName() + " : course type & access mode mismatch");
            return false;
        }

        public Class searchClass(String classId) {
            for (Class cls : listClass) {
                if (cls.getClassId().equals(classId))
                    return cls;
            }
            return null;
        }

        public Course searchCourse(String name) {
            for (Course course : listCourse) {
                if (course.getCourseName().equals(name))
                    return course;
            }
            return null;
        }

        public boolean searchStudent(String id) {
            for (Student stu : listStudent) {
                if (stu.getId().equals(id))
                    return true;
            }
            return false;
        }

        //查找是否有重复选课成绩
        public boolean searchChooseCourse(String stuName, String courseName) {
            for (ChooseCourse cs : listChooseCourse) {
                if (cs.student.getStuName().equals(stuName) && cs.course.getCourseName().equals(courseName))
                    return true;
            }
            return false;
        }

        public void showStudents() {
            Collections.sort(listStudent);
            for (int i = 0; i < listStudent.size(); i++) {
                Student stu = listStudent.get(i);
                //从总选课表listChooseCourse中获取该生的选课记录
                ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(stu.getId());
                if (stuCourseSelects.size() != 0) {
                    System.out.println(stu.getId() + " " + stu.getStuName() + " " + getAvgTotalScore(stuCourseSelects));
                } else if (stuCourseSelects.size() == 0) {
                    System.out.println(stu.getId() + " " + stu.getStuName() + " " + "did not take any exams");
                }
            }
        }

        public void showCourses() {
            Collections.sort(listCourse);
            for (int i = 0; i < listCourse.size(); i++) {
                Course course = listCourse.get(i);
                ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName());
                if (stuCourseSelects.size() != 0) {
                    if (course.testType.equals("考试"))
                        System.out.println(course.getCourseName() + " " + getAvgUsualScore(stuCourseSelects) + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
                    if (course.testType.equals("考察"))
                        System.out.println(course.getCourseName() + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
                } else if (stuCourseSelects.size() == 0) {
                    System.out.println(course.courseName + " " + "has no grades yet");
                }
            }
        }

        public void showClasses() {
            Collections.sort(listClass);
            for (int i = 0; i < listClass.size(); i++) {
                Class cls = listClass.get(i);
                ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
                if (stuCourseSelects.size() != 0) {
                    System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
                } else if (stuCourseSelects.size() == 0) {
                    System.out.println(cls.getClassId() + " " + "has no grades yet");
                }
            }
        }
        public ArrayList<ChooseCourse> getStudentSelects(String id) {
            ArrayList<ChooseCourse> choose = new ArrayList<>();
            for (ChooseCourse cos : listChooseCourse) {
                if (cos.student.getId().equals(id))
                    choose.add(cos);
            }
            return choose;
        }
        public ArrayList<ChooseCourse> getCourseSelects(String courseName) {
            ArrayList<ChooseCourse> choose = new ArrayList<>();
            for (ChooseCourse cos : listChooseCourse) {
                if (cos.course.getCourseName().equals(courseName))
                    choose.add(cos);
            }
            return choose;
        }
        public ArrayList<ChooseCourse> getClassSelects(String clsId) {
            ArrayList<ChooseCourse> choose = new ArrayList<>();
            for (ChooseCourse cos : listChooseCourse) {
                if (cos.student.getClsId().equals(clsId))
                    choose.add(cos);
            }
            return choose;
        }
        public int getAvgFinalScore(ArrayList<ChooseCourse> cs) {
            int average = 0;
            int sum = 0;
            for (ChooseCourse c : cs) {
                sum += c.grade.finalGrade;
            }
            average = sum / cs.size();
            return average;
        }
    }
     class ChooseCourse {
        Course course;
        Student student;
        Grade grade;
        public ChooseCourse(Course course, Student student, Grade grade) {
            this.course = course;
            this.student = student;
            this.grade = grade;
        }
    }
    class Student implements Comparable<Student> {
        String stuName;
        String id;
        String clsId;
        public String getId() {
            return id;
        }
        public String getStuName() {
            return stuName;
        }
        public String getClsId() {
            return clsId;
        }
        public Student(String clsId, String id, String stuName) {
            this.clsId = clsId;
            this.id = id;
            this.stuName = stuName;
        }
        public int compareTo(Student stu) {
            return getId().compareTo(stu.getId());
        }
    }
    class Course implements Comparable<Course> {
        String courseName;
        String type;
        String testType;
        public Course() {

        }
        public Course(String courseName, String type, String testType) {
            this.courseName = courseName;
            this.type = type;
            this.testType = testType;
        }
        public String getCourseName() {
            return courseName;
        }
        public String getType() {
            return type;
        }
        public String getTestType() {
            return testType;
        }
        }
    }

    class Class implements Comparable<Class> {
        String classId;
        public Class() {
        }
        public String getClassId() {
            return classId;
        }
        public Class(String classId) {
            this.classId = classId;
        }
        @Override
        public int compareTo(Class o) {
            return getClassId().compareTo(o.getClassId());
        }
    }
    abstract class Grade {
        int finalGrade;
        public Grade() {
        }
        public abstract int getUsualGrade();
        public abstract int getTotalGrade();
    }
    class ExamGrade extends Grade {
        int usualGrade;
        public ExamGrade(int usualGrade, int finalGrade) {
            this.usualGrade = usualGrade;
            this.finalGrade = finalGrade;
        }
        public int getUsualGrade() {
            return usualGrade;
        }
        public int getFinalGrade() {
            return 0;
        }
        public int getTotalGrade() {
            return (int) (usualGrade * 0.3 + finalGrade * 0.7);
        }
    }
class InputMatching {
    static String stuNumMatching = "[0-9]{8}";
    static String stuNameMatching = "\\S{1,10}";
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";
    static String courseTypeMatching = "(选修|必修)";
    static String checkCourseTypeMatching = "(考试|考察)";
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
    static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching;
    static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + " " + scoreMatching;
    public InputMatching() {
    }

    public int matchingInput(String s) {

        if (matchingCourse(s))
            return 1;
        if (matchingScore(s))
            return 2;
        return 0;

    }

    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }

    private static boolean matchingScore(String s) {
        if (s.matches(scoreInput1) || s.matches(scoreInput2))
            return true;
        return false;
    }
}

class AssessGrade extends Grade {
        public AssessGrade(int finalGrade) {
            this.finalGrade = finalGrade;
        }
        public int getFinalGrade() {
            return finalGrade;
        }
        @Override
        public int getUsualGrade() {
            return 0;
        }
        public int getTotalGrade() {
            return finalGrade;
        }
    }
用SourceMonito分析代码所得结果如下：

分析：在这道题目中用了Arraylist容器来储存学生类对象和成绩类对象，并在其他的类中调用该容器中的对象数据，student类中储存学生的有关信息，score类中储存课程信息。

三、踩坑心得：

在这三次作业的解答过程中我遇到了很多问题，现总结如下：

1、在处理判断等腰直角三角形时，一直没有那种近似的转换思想，导致在这个问题上卡了很久，我现在知道该在对应的情况采取最合适的算法来获取正确答案。

2、在对字符输入以及字符多余空格的处理，我不够熟练，有两道题目就是因为字符串后的空格多余而导致测试点始终过不了，我现在学会了用trim（）来消除输入时的多余空格，熟练掌握了string类的应用，掌握了string类的很多方法来使字符串符合需求。

3、在创建类时，对于有参构造和无参构造的把握不够熟练，在面向对象数据封装那个题目就遇到了卡壳，最后通过查阅资料。才对他们的应用和区别得以区分。

3、在类的关联以及类之间的相互调用不够清晰，在处理菜单计价问题以及学生成绩问题时，在哪一个类的属性和对象的调用不够清楚，经常存在数据类型和数据定义不批撇而导致报错的情况，例如在order类封装的是record类的对象，但是上面总是用string类的方法来调用他，得益于idea这款软件的调试功能才得以解决报错问题，但是最后还是没有能完成这道题目，很多测试点没有能够通过，关于这道题目代码我还会继续修改。

 四、困难及改进建议：

在完成第三次作业时，我明显感到有些力不从心，对于如何处理输入的一大段字符串，将其转化为我所需的内容，这一点需要很多其他类的知识，我还不够熟练，在7-2 课程成绩统计程序-1这道题目里面体现的尤为明显，我采用的方法只能通过几个例子，可能只是几个普通的例子，但在异常情况以及边缘情况时考虑不够完善，并且我写的代码很复杂，ifelse语句太多、太冗余了，导致代码的圈复杂度很高，代码利用率低，在解题时只想着能够通过测试点，却并未考虑到代码的复杂度和复用性。

改进建议：我认为可以适当降低难题和复杂的题目的分数，如在第三次作业中占65分的第二道题，如果对这道题目束手无策，就算其他的题目都满分通过，这次作业也难以及格，所以我认为可以把难题作为优秀学生的挑战性尝试，适当提高平均分。

五、总结：

通过完成这三次pta的作业，我对面向对象的基本过程和知识有了一定的了解，我掌握了类的构建，如何查询java自带的API的应用，常用API的使用，正则表达式的的使用。在一道一道解决题目的过程中，我感受到了面向对象和面向过程的编程的区别，感受到了面向对象编程在优化代码结构，排除冗余代码块的方面所具有的巨大作用，并对其产生了更加浓厚的i兴趣和更加深入的了解。作为没有接触过面向对象的新人，在一开始的解题过程中，我还是偏向于C语言式的面向过程，慢慢转变到面向对象，这个过程不快，导致我有一道题目并未完美解决，在未来我依然会努力加深java的代码量，对面向对象编程的熟悉。