PTA 第三阶段题目集总结

NCHU 南昌航空大学软件学院 22201108 郭海涛

一、前言

这一阶段的题目集相对上一个题目集难度可以说是上升了一个等级，其中有很多我们平时很少接触过的东西，比如说栈和队列、还有map和list、set等框架和工具的应用，在这一阶段的题目集中，有很多题目需要我们仔细的去设计它们类之间的关系，不然的话，在书写代码的中途多多少少都会遇到困难，有些问题甚至需要我们去重构代码，所以我们在书写代码前一定要想好代码间的逻辑关系。

二、设计与分析

题目集8的7-1

输入格式:

首先，在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：
1 3 4 2 1 3 4 2 1 3 0
然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。

输出格式:

如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边不能组成三角形），则输出Wrong Format。
如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：

排序前的各图形类型及面积，格式为图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；
排序后的各图形类型及面积，格式同排序前的输出；
所有图形的面积总和，格式为Sum of area:总面积值。

这一题主要就是判断是否合法和输出的问题。首先就是输入数据，再处理数据，保存好处理后的数据的值最后再按照顺序输出。难点就是合法性判断。但其实这一步也很好判断，只要判断输入的是否是小于等于零的数或者三角形两边之和小于等于第三边或者没有图形输入，这些就是非法，其他都是正常情况。接着再对所有的数据进行排序，我是使用的是ArrayList来存储最后处理出来的数据的，所以我直接使用了Collections.sort方法来直接对面积进行排序。最后的总和也是通过输出每一项的面积的值的时候累计的，最后直接输出即可。

import java.util.*;
public class Main {
    //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        while(num != 0){
            if(num < 0 || num > 4){
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);
        if(!dealCardList.validate()){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}


class DealCardList{
    ArrayList<Card> cardList = new ArrayList<>();//数组用于存储输入的数字

    public DealCardList() {
    }
    public DealCardList(ArrayList<Integer> list) {
        //根据不同的数字，匹配不同的图形，并且存储到数组中
        for(int i=0;i<list.size();i++){
            switch(list.get(i)){
                case 1:
                    Shape shape1 = new Circle(Main.input.nextDouble());
                    shape1.setShapeName("Circle");
                    Card card1 = new Card(shape1);
                    cardList.add(card1);
                    break;
                case 2:
                    Shape shape2 = new Rectangle(Main.input.nextDouble(),Main.input.nextDouble());
                    shape2.setShapeName("Rectangle");
                    Card card2 = new Card(shape2);
                    cardList.add(card2);
                    break;
                case 3:
                    Shape shape3 = new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
                    shape3.setShapeName("Triangle");
                    Card card3 = new Card(shape3);
                    cardList.add(card3);
                    break;
                case 4:
                    Shape shape4 = new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
                    shape4.setShapeName("Trapezoid");
                    Card card4 = new Card(shape4);
                    cardList.add(card4);
                    break;
                default:
                    System.out.println("Wrong Format");//不是1-4的数字就是格式错误
                    System.exit(1);

            }
        }
    }
    public boolean validate(){//检查非法性
        for(int i=0;i<cardList.size();i++){
            if(!cardList.get(i).getShape().validate())
                return false;
        }
        return true;
    }
    public void cardSort(){//对数组排序
        Collections.sort(cardList);
    }
    public double getAllArea(){//得到面积之和
        double sum = 0;
        for(int i =0;i<cardList.size();i++){
            sum += cardList.get(i).getShape().getArea();
        }
        return sum;
    }
    public void showResult(){//结果的输出
        if(!this.validate())//如果有非法数据，输出Wrong Format
            System.out.println("Wrong Format");
        else{//如果不是，就按照输出格式的要求输出
            System.out.println("The original list:");
            for(int i=0;i<cardList.size();i++){
                System.out.printf("%s:%.2f ",cardList.get(i).getShape().getShapeName(),cardList.get(i).getShape().getArea());
            }
            System.out.printf("\n");

            this.cardSort();//对原始数据进行排序
            System.out.println("The sorted list:");
            for(int i=0;i<cardList.size();i++){
                System.out.printf("%s:%.2f ",cardList.get(i).getShape().getShapeName(),cardList.get(i).getShape().getArea());
            }
            System.out.printf("\n");
            System.out.printf("Sum of area:%.2f",this.getAllArea());
        }
    }
}

class Card implements Comparable<Card>{
    private Shape shape;
    //构造方法
    public Card() {
    }
    public Card(Shape shape) {
        this.shape = shape;
    }
    //getter和setter方法
    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    //重写compareTo方法
    @Override
    public int compareTo(Card card){
        if(shape.getArea()>card.getShape().getArea())
            return -1;
        else if(shape.getArea()<card.getShape().getArea())
            return 1;
        else
            return 0;
    }
}

class Shape{
    private String shapeName;//形状的名字
    //构造方法
    public Shape() {
    }
    public Shape(String shapeName) {
        this.shapeName = shapeName;
    }
    //getter和setter方法
    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    //返回面积
    public double getArea(){
        return 0.0;
    }
    //检测非法性
    public boolean validate(){
        return false;
    }
    //返回字符串
    public String toString(){
        String str = shapeName + Double.toString(this.getArea());
        return str;
    }
}

class Circle extends Shape{
    private double radius;//半径
    //构造方法
    public Circle() {
        super();
    }
    public Circle(double radius) {
        super();
        this.radius = radius;
    }
    //getter和setter方法
    public double getRadiius() {
        return radius;
    }
    public void setRadiius(double radiius) {
        this.radius = radius;
    }
    @Override
    public double getArea(){
        return Math.PI*radius*radius;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(radius<=0)
            return false;
        else
            return true;
    }
}

class Rectangle extends Shape{
    private double width;//宽
    private double length;//长
    //构造方法
    public Rectangle() {
        super();
    }
    public Rectangle(double width, double length) {
        super();
        this.width = width;
        this.length = length;
    }
    //getter和setter方法
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    //返回面积
    @Override
    public double getArea(){
        return this.width*this.length;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(this.width<=0||this.length<=0)
            return false;
        else
            return true;
    }
}

class Triangle extends Shape{
    private double side1;//边1
    private double side2;//边2
    private double side3;//边2
    //构造方法
    public Triangle() {
        super();
    }
    public Triangle(double side1, double side2, double side3) {
        super();
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }
    //返回面积
    @Override
    public double getArea(){
        double p = (this.side1+this.side2+this.side3)/2;
        return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
    }
    //检测非法性
    @Override
    public boolean validate(){
        //两边之和必须大于第三边
        if(side1+side2<=side3)
            return false;
        else if(side1+side3<=side2)
            return false;
        else if(side2+side3<=side1)
            return false;
        else if(side1<=0||side2<=0||side3<=0)//边长不能小于等于0
            return false;
        else
            return true;
    }
}

class Trapezoid extends Shape{
    private double topSide;//顶边
    private double bottomSide;//底边
    private double height;//高
    //构造方法
    public Trapezoid() {
        super();
    }
    public Trapezoid(double topSide, double bottomSide, double height) {
        super();
        this.topSide = topSide;
        this.bottomSide = bottomSide;
        this.height = height;
    }
    //返回面积
    @Override
    public double getArea(){
        double s = ((topSide + bottomSide)*height)/2;
        return s;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(topSide<=0||bottomSide<=0)
            return false;
        else if(height <=0)
            return false;
        else
            return true;
    }
}

题目集8 的7-2

输入格式:

在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：1 3 4 2 1 3 4 2 1 3 0
根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。

输出格式:

如果图形数量非法（<=0）或图形属性值非法（数值<0以及三角形三边不能组成三角形），则输出Wrong Format。
如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：

排序前的各图形类型及面积，格式为[图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ]，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格，在结束符“]”之前；
输出分组后的图形类型及面积，格式为[圆形分组各图形类型及面积][矩形分组各图形类型及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]，各组内格式为图形名称:面积值。按照“Circle、Rectangle、Triangle、Trapezoid”的顺序依次输出；
各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出；
各组中面积之和的最大值输出，格式为The max area:面积值。

这次题目和上一题的区别主要就是在于要把数据分成几个小组：圆形组、矩形组、三角形组、梯形组，我一开始使用的是用四个ArrayList来分别存储圆形组、矩形组、三角形组、梯形组，通过这四个不同的ArrayLIst来最后实现分组的输出，但是这次的题目集设置成了要在一定运行时间和运行内存内完成所有操作，所以通过四个ArrayList来存储的话要多次存储，而且输出、判断、排序都是个问题，所以导致最后运行时间非常的长，超过了最大的运行时间。最后才想到，可以只用一个ArrayList存储信息，然后在排序后，依次判断每条信息是属于哪一个类别的，再分别输出，这样就节省了很多的运行时间，程序也就能顺利通过了。

import java.util.*;
public class Main {
    //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        while(num != 0){
            if(num < 0 || num > 4){
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);
        if(!dealCardList.validate()){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}


class DealCardList{
    ArrayList<Card> cardList = new ArrayList<>();


    public DealCardList() {
    }
    public DealCardList(ArrayList<Integer> list) {
        for(int i=0;i<list.size();i++){
            switch(list.get(i)){
                case 1:
                    Shape shape1 = new Circle(Main.input.nextDouble());
                    shape1.setShapeName("Circle");
                    Card card1 = new Card(shape1);
                    cardList.add(card1);
                    break;
                case 2:
                    Shape shape2 = new Rectangle(Main.input.nextDouble(),Main.input.nextDouble());
                    shape2.setShapeName("Rectangle");
                    Card card2 = new Card(shape2);
                    cardList.add(card2);
                    break;
                case 3:
                    Shape shape3 = new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
                    shape3.setShapeName("Triangle");
                    Card card3 = new Card(shape3);
                    cardList.add(card3);
                    break;
                case 4:
                    Shape shape4 = new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
                    shape4.setShapeName("Trapezoid");
                    Card card4 = new Card(shape4);
                    cardList.add(card4);
                    break;
                default:
                    break;
            }
        }
    }
    public boolean validate(){
        for(int i=0;i<cardList.size();i++){
            if(!cardList.get(i).getShape().validate())
                return false;
        }
        if(cardList.size()==0)
            return false;
        else
            return true;
    }
    public void cardSort(){
        Collections.sort(cardList);
    }
    public double getAllArea(){
        double sum = 0;
        for(int i =0;i<cardList.size();i++){
            sum += cardList.get(i).getShape().getArea();
        }
        return sum;
    }
    public void showMax(){
        double maxArea = 0;
        double sum1 =0 ,sum2 = 0,sum3 = 0,sum4 =0;
        for(int i =0 ;i<cardList.size();i++){
            if(cardList.get(i).getShape().getShapeName().equals("Circle"))
                sum1 += cardList.get(i).getShape().getArea();
            if(cardList.get(i).getShape().getShapeName().equals("Rectangle"))
                sum2 += cardList.get(i).getShape().getArea();
            if(cardList.get(i).getShape().getShapeName().equals("Triangle"))
                sum3 += cardList.get(i).getShape().getArea();
            if(cardList.get(i).getShape().getShapeName().equals("Trapezoid"))
                sum4 += cardList.get(i).getShape().getArea();
        }
        maxArea = Math.max(Math.max(Math.max(sum1,sum2),sum3),sum4);
        System.out.printf("The max area:%.2f\n",maxArea);
    }

    public void show(){
        System.out.print("[");
        for (int i=0;i<cardList.size();i++){
            if (cardList.get(i).getShape().getShapeName().equals("Circle")){
                System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
            }
        }
        System.out.print("]");
        System.out.print("[");
        for (int i=0;i<cardList.size();i++){
            if (cardList.get(i).getShape().getShapeName().equals("Rectangle")){
                System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
            }
        }
        System.out.print("]");
        System.out.print("[");
        for (int i=0;i<cardList.size();i++){
            if (cardList.get(i).getShape().getShapeName().equals("Triangle")){
                System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
            }
        }
        System.out.print("]");
        System.out.print("[");
        for (int i=0;i<cardList.size();i++){
            if (cardList.get(i).getShape().getShapeName().equals("Trapezoid")){
                System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
            }
        }
        System.out.print("]\n");
    }
    public void showResult(){
        if(!this.validate())
            System.out.println("Wrong Format");
        else{
            System.out.println("The original list:");
            for(int i=0;i<cardList.size();i++){
                if(i==0)
                    System.out.print("[");
                System.out.printf("%s:%.2f ",cardList.get(i).getShape().getShapeName(),cardList.get(i).getShape().getArea());
                if(i==cardList.size()-1)
                    System.out.print("]\n");
            }
            System.out.println("The Separated List:");
            show();

            Collections.sort(cardList);
            System.out.println("The Separated sorted List:");
            show();
            showMax();
        }
    }
}
class Card implements Comparable<Card>{
    private Shape shape;
    //构造方法
    public Card() {
    }
    public Card(Shape shape) {
        this.shape = shape;
    }
    //getter和setter方法
    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    //重写compareTo方法
    @Override
    public int compareTo(Card card){
        if(shape.getArea()>card.getShape().getArea())
            return -1;
        else if(shape.getArea()<card.getShape().getArea())
            return 1;
        else
            return 0;
    }
}

class Shape{
    private String shapeName;//形状的名字
    //构造方法
    public Shape() {
    }
    public Shape(String shapeName) {
        this.shapeName = shapeName;
    }
    //getter和setter方法
    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    //返回面积
    public double getArea(){
        return 0.0;
    }
    //检测非法性
    public boolean validate(){
        return false;
    }
    //返回字符串
    public String toString(){
        String str = shapeName + Double.toString(this.getArea());
        return str;
    }
}

class Circle extends Shape{
    private double radius;//半径
    //构造方法
    public Circle() {
        super();
    }
    public Circle(double radius) {
        super();
        this.radius = radius;
    }
    //getter和setter方法
    public double getRadiius() {
        return radius;
    }
    public void setRadiius(double radiius) {
        this.radius = radius;
    }
    @Override
    public double getArea(){
        return Math.PI*radius*radius;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(radius<=0)
            return false;
        else
            return true;
    }
}

class Rectangle extends Shape{
    private double width;//宽
    private double length;//长
    //构造方法
    public Rectangle() {
        super();
    }
    public Rectangle(double width, double length) {
        super();
        this.width = width;
        this.length = length;
    }
    //getter和setter方法
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    //返回面积
    @Override
    public double getArea(){
        return this.width*this.length;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(this.width<=0||this.length<=0)
            return false;
        else
            return true;
    }
}

class Triangle extends Shape{
    private double side1;//边1
    private double side2;//边2
    private double side3;//边2
    //构造方法
    public Triangle() {
        super();
    }
    public Triangle(double side1, double side2, double side3) {
        super();
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }
    //返回面积
    @Override
    public double getArea(){
        double p = (this.side1+this.side2+this.side3)/2;
        return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
    }
    //检测非法性
    @Override
    public boolean validate(){
        //两边之和必须大于第三边
        if(side1+side2<=side3)
            return false;
        else if(side1+side3<=side2)
            return false;
        else if(side2+side3<=side1)
            return false;
        else if(side1<=0||side2<=0||side3<=0)//边长不能小于等于0
            return false;
        else
            return true;
    }
}

class Trapezoid extends Shape{
    private double topSide;//顶边
    private double bottomSide;//底边
    private double height;//高
    //构造方法
    public Trapezoid() {
        super();
    }
    public Trapezoid(double topSide, double bottomSide, double height) {
        super();
        this.topSide = topSide;
        this.bottomSide = bottomSide;
        this.height = height;
    }
    //返回面积
    @Override
    public double getArea(){
        double s = ((topSide + bottomSide)*height)/2;
        return s;
    }
    //检测非法性
    @Override
    public boolean validate(){
        if(topSide<=0||bottomSide<=0)
            return false;
        else if(height <=0)
            return false;
        else
            return true;
    }
}

题目集10 的7-1

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

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

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

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

1、输入：

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

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

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

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

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

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

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

以上信息的相关约束：

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、这是一道比较综合、难度比较大的题目，选课系统，既要考虑一个学科有多个班级，也要考虑一个班级有多个学生，不过这里主要是将学生看作班级的一部分，因为最后要输出班级的平均分，而学科的各项平均分只需要将该门学科中所有学生的各项分数相加，最后再求和，即可得出。

2、成绩应该和班级、学生分开，因为从输入的信息来看，输入的学科信息有该门课程名称、科目种类（必修选修）、科目考察方式（考试、考察），这就既要考虑课程的类型、还要考虑该科目下面的学生所对应的成绩是考试成绩（平均分和考试构成）、考察成绩（没有平时分）中的哪一种。然后学生的信息给出了学生的姓名、学号、该条信息给出对应的科目、以及成绩的具体分数。这两种信息，一种学科的信息，一种学生的信息，都包含着成绩的信息，两个数据来确定成绩信息，课程信息给出成绩的类型，学生信息给出成绩的具体数字。所以成绩要和班级、学生分开，并且由一个控制类（选课类）来对应课程、学生、和成绩信息。

3、输入：由于要先输入课程的信息，在输入学生的信息，所以我们需要要判断每一行的信息是属于那一种情况，再根据不同的信息类别对信息进行处理。

4、错误：这次的题目有非常多的错误格式，需要依据类别而输出不同的报错信息。在输入信息时，信息格式均既不属于课程信息，也不属于学生信息的信息会被判定为非法输入，输出“Wrong Format”输出如果课程名称不在已输入的课程列表中的报错信息，同样的，成绩数量和课程的考核方式不匹配也是在输入信息并进行处理的时候来报错的。

在后面，准备对成绩输出再来判定课程或者班级是否没有任何成绩，如果有，就报错。

5、输出，输出需要对各个学生的成绩进行处理，在本次题目中，使用的是一个选课类的ArrayList，来判断信息是否属于该门科目和该班级。

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

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        Input handle=new Input();
        while (!input.equals("end")) {
            handle.parseInput(input);//处理数据
            input = s.nextLine();
        }
        handle.display();//输出
    }
}
class Input{//处理类
    ArrayList<Student> students=new ArrayList<>();//临时存储学生信息
    ArrayList<Course> courses=new ArrayList<>();//临时存储课程信息
    ArrayList<Class> classes=new ArrayList<>();//临时存储班级信息
    ArrayList<ChooseCourse> listChooseCourse = new ArrayList<>();//存储选课信息
    public void parseInput(String str){
        //用于判断课程信息的正确
        String courseStr = "\\S{1,10}"+" " + "(选修|必修)" + " " + "(考试|考察)";
        //用于判断分数信息的正确
        String score1 = "[0-9]{8}" + " " + "\\S{1,10}" + " " + "\\S{1,10}" + " "+ "([1-9]?[0-9]|100)";
        String score2 = "[0-9]{8}" + " " + "\\S{1,10}" + " " + "\\S{1,10}" + " "+"([1-9]?[0-9]|100)" + " " + "([1-9]?[0-9]|100)";

        //根据正则表达式来判断是否正确
        //符合课程信息条件
        if(str.matches(courseStr))
            inputCourse(str);
        //符合分数信息条件
        else if(str.matches(score1) ||str.matches(score2))
            inputGrade(str);
        //不符合输入信息格式
        else
            System.out.println("wrong format");
    }
    public void inputCourse(String str){//输入课程

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

        String courseName=parts[0];//课程名称
        String type=parts[1];//课程的性质（选修或者必修
        String testType=parts[2];//课程考核的方式（考试或者考察

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

        if(checkCourse(course)){//存在就不添加
            if(searchCourse(courseName)==null)
                courses.add(course);
        }

    }
    public void inputGrade(String str){//输入成绩，在所有的课程输入完之后再执行的
        String parts[]=str.split(" ");

        String stuId= parts[0];//学生学号
        String classID= parts[0].substring(0,6);//班级号
        String name=parts[1];//学生名称
        String courseName=parts[2];//课程名字

        //如果该班级第一次出现
        if(searchClass(classID)==null){
            Class cla=new Class(classID);
            classes.add(cla);
        }

        Student stu=new Student(classID,stuId,name);
        if(!searchStudent(stuId))
            students.add(stu);//将学生加入列表中
        //如果课程为空，就输出。。。。
        if(searchCourse(courseName)==null){
            System.out.println(courseName+" "+"does not exist");
        }
        //当课程存在时
        else if(searchCourse(courseName)!=null){
            Course course=searchCourse(courseName);
            //考察的情况
            if(parts.length==4&&course.testType.equals("考察")){
                int exam= Integer.parseInt(parts[3]);
                AssessGrade assessGrade=new AssessGrade(exam);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
                if(!searchChooseCourse(name,courseName))
                    listChooseCourse.add(chooseCourse);
            }
            //考试的情况
            else if(parts.length==5&&course.testType.equals("考试")){
                int pinshi= Integer.parseInt(parts[3]);
                int exam= Integer.parseInt(parts[4]);
                ExamGrade examGrade=new ExamGrade(pinshi,exam);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
                listChooseCourse.add(chooseCourse);
            }
            else{
                System.out.println(stuId+" "+name+" "+": access mode mismatch");
            }
        }
    }
    public boolean checkCourse(Course course){
        boolean flag = false;//判断必修选修和考试考察格式之间是否对应正确
        if(course.getType().equals("必修")&&course.getTestType().equals("考试"))
            flag = true;
        else if(course.getType().equals("选修")&&(course.getTestType().equals("考试")||course.getTestType().equals("考察")))
            flag = true;
        
        if(flag)
            return true;
        else {
            System.out.println(course.getCourseName() + " : course type & access mode mismatch");
            return false;
        }
    }
    public Class searchClass(String classId){
        for(Class cls:classes){
            if(cls.getClassId().equals(classId))
                return cls;
        }
        return null;
    }
    public Course searchCourse(String name){
        for(Course course:courses){
            if(course.getCourseName().equals(name))
                return course;
        }
        return null;
    }
    public boolean searchStudent(String id){
        for(Student stu:students){
            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 displayStudents(){//输出学生信息
        Collections.sort(students);
        for(int i=0;i<students.size();i++){
            Student stu=students.get(i);
            //从选课信息中提取学生学号相对的选课信息
            ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
            if(stuCourseSelects.size()!=0) {
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+getAvgSumScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+"did not take any exams");
            }
        }
    }
    public void displayCourses(){
        Collections.sort(courses);
        for(int i=0;i<courses.size();i++){
            Course course=courses.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
            if(stuCourseSelects.size()!=0){
                if(course.testType.equals("考试"))
                    System.out.println(course.getCourseName()+" "+getAvgPinshiScore(stuCourseSelects)+" "+getAvgExamScore(stuCourseSelects)+" "+getAvgSumScore(stuCourseSelects));
                if(course.testType.equals("考察"))
                    System.out.println(course.getCourseName()+" "+getAvgExamScore(stuCourseSelects)+" "+getAvgSumScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(course.courseName+" "+"has no grades yet");
            }
        }
    }
    public void displayClasses(){
        Collections.sort(classes);
        for(int i=0;i<classes.size();i++){
            Class cls=classes.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cls.getClassId());
            if(stuCourseSelects.size()!=0){
                System.out.println(cls.getClassId()+" "+getAvgSumScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(cls.getClassId()+" "+"has no grades yet");
            }
        }
    }
    public void display(){//总输出
        displayStudents();
        displayCourses();
        displayClasses();
    }
    public ArrayList<ChooseCourse> getStudentSelects(String id){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.student.getId().equals(id))
                choose.add(cc);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getCourseSelects(String courseName){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.course.getCourseName().equals(courseName))
                choose.add(cc);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getClassSelects(String clsId){
        ArrayList<ChooseCourse> chooseCourse =new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.student.getClsId().equals(clsId))
                chooseCourse.add(cc);
        }
        return chooseCourse;
    }
    public int getAvgSumScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.getSumGrade();
        }
        
        return (int)sum/cs.size();
    }
    public int getAvgPinshiScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c : cs){
           sum+=c.grade.getpinshi();
        }
        return (int)sum/cs.size();
    }
    public int getAvgExamScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.exam;
        }
        return (int)sum/cs.size();
    }

}
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;
    }
    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(courseName,o.getCourseName());
    }
}
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 exam;
    public Grade() {
    }
    public abstract int getpinshi();
    public abstract int getSumGrade();
}
class ExamGrade extends Grade{
    int pinshi;

    public ExamGrade(int pinshi,int exam) {
        this.pinshi=pinshi;
        this.exam=exam;
    }
    public int getpinshi(){
        return pinshi;
    }
    public  int getexam(){
        return 0;
    }
    public int getSumGrade(){
        return (int)(pinshi*0.3+exam*0.7);
    }
}
class AssessGrade extends Grade{

    public AssessGrade(int exam) {
        this.exam=exam;
    }
    public int getexam(){
        return exam;
    }

    @Override
    public int getpinshi() {
        return 0;
    }

    public int getSumGrade(){
        return exam;
    }
}

第11次题目集的7-3

课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

这次的题目大体上都和上一题一样，只是增加一个实验课程信息，只需要更改判断信息类别的正则表达式，然后再增加一个实验信息的正确判断，以及在判断是实验课程后的处理，以及增加一个实验成绩类继承自抽象成绩类，基本上就可以完成本次作业。

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

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        Input handle=new Input();
        while (!input.equals("end")) {
            handle.parseInput(input);//处理数据
            input = s.nextLine();
        }
        handle.display();//输出
    }
}
class Input{//处理类
    ArrayList<Student> students=new ArrayList<>();//临时存储学生信息
    ArrayList<Course> courses=new ArrayList<>();//临时存储课程信息
    ArrayList<Class> classes=new ArrayList<>();//临时存储班级信息
    ArrayList<ChooseCourse> listChooseCourse = new ArrayList<>();//存储选课信息
    public void parseInput(String str){
        //用于判断课程信息的正确
        String courseStr = "\\S{1,10}"+" " + "(选修|必修|实验)" + " " + "(考试|考察|实验)";
        //用于判断分数信息的正确
        String score1 = "[0-9]{8}" + " " + "\\S{1,10}" + " " + "\\S{1,10}" + " "+ "([1-9]?[0-9]|100)";
        String score2 = "[0-9]{8}" + " " + "\\S{1,10}" + " " + "\\S{1,10}" + " "+"([1-9]?[0-9]|100)" + " " + "([1-9]?[0-9]|100)";
        String score3 = "[0-9]{8}" + " " + "\\S{1,10}" + " " + "\\S{1,10}" + " "+"[4-9]" +"((\\s)([1-9]?[0-9]|100))+";
        //根据正则表达式来判断是否正确
        //符合课程信息条件
        if(str.matches(courseStr))
            inputCourse(str);
        //符合分数信息条件
        else if(str.matches(score1) ||str.matches(score2))
            inputGrade(str);
        //不符合输入信息格式
        else if(str.matches(score3))
            inputGrade(str);
        else
            System.out.println("wrong format");
    }
    public void inputCourse(String str){//输入课程

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

        String courseName=parts[0];//课程名称
        String type=parts[1];//课程的性质（选修或者必修
        String testType=parts[2];//课程考核的方式（考试或者考察

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

        if(checkCourse(course)){//存在就不添加
            if(searchCourse(courseName)==null)
                courses.add(course);
        }

    }
    public void inputGrade(String str){//输入成绩，在所有的课程输入完之后再执行的
        String parts[]=str.split(" ");

        String stuId= parts[0];//学生学号
        String classID= parts[0].substring(0,6);//班级号
        String name=parts[1];//学生名称
        String courseName=parts[2];//课程名字

        //如果该班级第一次出现
        if(searchClass(classID)==null){
            Class cla=new Class(classID);
            classes.add(cla);
        }

        Student stu=new Student(classID,stuId,name);
        if(!searchStudent(stuId))
            students.add(stu);//将学生加入列表中
        //如果课程为空，就输出。。。。
        if(searchCourse(courseName)==null){
            System.out.println(courseName+" "+"does not exist");
        }
        //当课程存在时
        else if(searchCourse(courseName)!=null){
            Course course=searchCourse(courseName);
            //考察的情况
            if(parts.length==4&&course.testType.equals("考察")){
                int exam= Integer.parseInt(parts[3]);
                AssessGrade assessGrade=new AssessGrade(exam);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
                if(!searchChooseCourse(name,courseName))
                    listChooseCourse.add(chooseCourse);
            }
            //考试的情况
            else if(parts.length==5&&course.testType.equals("考试")){
                int pinshi= Integer.parseInt(parts[3]);
                int exam= Integer.parseInt(parts[4]);
                ExamGrade examGrade=new ExamGrade(pinshi,exam);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
                listChooseCourse.add(chooseCourse);
            }
            //实验的情况
            else if(parts.length==4+Integer.parseInt(parts[3])&&
                    course.testType.equals("实验")){

                int repeat = Integer.parseInt(parts[3]);
                ExperienceGrade exGrade = new ExperienceGrade();
                for(int i = 4;i<repeat+4;i++){//向列表中添加每次实验的得分
                    int score = Integer.parseInt(parts[i]);
                    exGrade.getScores().add(score);
                }
                ChooseCourse chooseCourse = new ChooseCourse(course,stu,exGrade);
                listChooseCourse.add(chooseCourse);
            }
            else{
                System.out.println(stuId+" "+name+" "+": access mode mismatch");
            }
        }
    }

    public boolean checkCourse(Course course){
        boolean flag = false;//判断必修选修和考试考察格式之间是否对应正确
        if(course.getType().equals("必修")&&course.getTestType().equals("考试"))
            flag = true;
        else if(course.getType().equals("选修")&&(course.getTestType().equals("考试")||course.getTestType().equals("考察")))
            flag = true;
        else if (course.getType().equals("实验")&&course.getTestType().equals("实验"))
            flag=true;
        else
            flag=false;


        if(flag)
            return true;
        else {
            System.out.println(course.getCourseName() + " : course type & access mode mismatch");
            return false;
        }
    }
    public Class searchClass(String classId){
        for(Class cls:classes){
            if(cls.getClassId().equals(classId))
                return cls;
        }
        return null;
    }
    public Course searchCourse(String name){
        for(Course course:courses){
            if(course.getCourseName().equals(name))
                return course;
        }
        return null;
    }
    public boolean searchStudent(String id){
        for(Student stu:students){
            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 displayStudents(){//输出学生信息
        Collections.sort(students);
        for(int i=0;i<students.size();i++){
            Student stu=students.get(i);
            //从选课信息中提取学生学号相对的选课信息
            ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
            if(stuCourseSelects.size()!=0) {
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+getAvgSumScore(stuCourseSelects));
            }
            if(stuCourseSelects.size()==0){
                System.out.println(stu.getId()+" "+stu.getStuName()+" "+"did not take any exams");
            }
        }
    }
    public void displayCourses(){
        Collections.sort(courses);
        for(int i=0;i<courses.size();i++){
            Course course=courses.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
            if(stuCourseSelects.size()!=0){
                if(course.testType.equals("考试"))
                    System.out.println(course.getCourseName()+" "+getAvgPinshiScore(stuCourseSelects)+" "+getAvgExamScore(stuCourseSelects)+" "+getAvgSumScore(stuCourseSelects));
                if(course.testType.equals("考察"))
                    System.out.println(course.getCourseName()+" "+getAvgExamScore(stuCourseSelects)+" "+getAvgSumScore(stuCourseSelects));
                if(course.testType.equals("实验"))
                    System.out.println(course.getCourseName()+" "+getAvgSumScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(course.courseName+" "+"has no grades yet");
            }
        }
    }
    public void displayClasses(){
        Collections.sort(classes);
        for(int i=0;i<classes.size();i++){
            Class cls=classes.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cls.getClassId());
            if(stuCourseSelects.size()!=0){
                System.out.println(cls.getClassId()+" "+getAvgSumScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(cls.getClassId()+" "+"has no grades yet");
            }
        }
    }
    public void display(){//总输出
        displayStudents();
        displayCourses();
        displayClasses();
    }
    public ArrayList<ChooseCourse> getStudentSelects(String id){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.student.getId().equals(id))
                choose.add(cc);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getCourseSelects(String courseName){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.course.getCourseName().equals(courseName))
                choose.add(cc);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getClassSelects(String clsId){
        ArrayList<ChooseCourse> chooseCourse =new ArrayList<>();
        for(ChooseCourse cc:listChooseCourse) {
            if (cc.student.getClsId().equals(clsId))
                chooseCourse.add(cc);
        }
        return chooseCourse;
    }
    public int getAvgSumScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.getSumGrade();
        }
        return (int)sum/cs.size();
    }
    public int getAvgPinshiScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c : cs){
           sum+=c.grade.getpinshi();
        }
        return (int)sum/cs.size();
    }
    public int getAvgExamScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.exam;
        }
        return (int)sum/cs.size();
    }
    public int getExperienceScore(ArrayList<ChooseCourse> cs){
        int sum = 0;
        for(ChooseCourse c:cs){
            sum+=c.grade.getSumGrade();
        }
        return (int)sum/cs.size();
    }
}
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;
    }
    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(courseName,o.getCourseName());
    }
}
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 exam;
    public Grade() {
    }
    public abstract int getpinshi();
    public abstract int getSumGrade();
}
class ExamGrade extends Grade{
    int pinshi;

    public ExamGrade(int pinshi,int exam) {
        this.pinshi=pinshi;
        this.exam=exam;
    }
    public int getpinshi(){
        return pinshi;
    }
    public  int getexam(){
        return 0;
    }
    public int getSumGrade(){
        return (int)(pinshi*0.3+exam*0.7);
    }
    public int getExperience(){
        return 0;
    }
}
class AssessGrade extends Grade{
    public AssessGrade(int exam) {
        this.exam=exam;
    }
    public int getexam(){
        return exam;
    }
    @Override
    public int getpinshi() {
        return 0;
    }

    public int getSumGrade(){
        return exam;
    }
    public int getExperience(){
        return 0;
    }
}
class ExperienceGrade extends Grade{//实验分数
    private ArrayList<Integer> scores = new ArrayList<>();
    public ArrayList<Integer> getScores() {
        return scores;
    }
    public void setScores(ArrayList<Integer> scores) {
        this.scores = scores;
    }

    @Override
    public int getpinshi() {
        return 0;
    }
    public int getExam(){
        return 0;
    }
    public int getSumGrade(){//得到总分
        int sum = 0;
        for(Integer i: scores){
            sum+=i;
        }
        return (int)sum/scores.size();
    }
}

三、踩坑心得

查找java关键字

在解决这个题目时，有一些常见的踩坑点需要注意。

输入格式处理：根据题目要求，输入的Java源码可以是多行的，以输入"exit"作为结束标志。因此，在读取输入时，需要使用循环来逐行读取输入，直到遇到"exit"为止。
1. 关键字的判断：在统计关键字的数量时，需要注意以下两点：注释中出现的关键字不用统计：需要判断当前行是否是注释行，如果是注释行，则忽略该行中的关键字。
2. 字符串中出现的关键字不用统计：需要判断当前行是否在字符串中，如果在字符串中，则忽略该行中的关键字。
关键字的排序和输出：统计完成后，需要按照关键字的升序进行排序，并按照指定的输出格式进行输出。可以使用Java的集合类来存储关键字和对应的数量，然后对集合进行排序，最后按照指定格式输出。
异常处理：当未输入源码时，需要输出"Wrong Format"。可以在读取完输入后，判断源码字符串是否为空，如果为空，则输出"Wrong Format"。

随堂测验最后一题

当解决这个问题时，我们需要注意以下坑：
1. 单词的定义：在统计单词数量和出现次数时，需要明确单词的定义。根据题目的要求，单词之间以空格为间隔，忽略空行或者空格行。所以我们可以使用split()函数将每一行的文字按照空格分割成单词。
2. 字母大小写：在统计单词出现次数时，需要忽略单词的大小写。所以我们可以将每个单词转换成小写形式，再进行统计。
3. 删除指定标点符号：在进阶版中，需要从文字中删除指定的标点符号，并用空格替换。可以使用replace()函数来实现。
4. 输出结果：需要输出单词数量和出现次数排名前10的单词及出现次数。可以使用字典来统计每个单词的出现次数，并按照次数进行降序排序。然后取前10个单词输出。

四、改进建议

1、检测java关键词：

目前的代码使用List和Set来存储数据。根据需求，考虑使用更适合的数据结构，例如Map或者HashMap来存储关键字和它们的出现次数。因为关键词不会重复，因此可以将代码改进，用HashMap来存储关键字以及对应的出现次数，这样搜索更加简便（只需要判定关键词是啥），统计出现次数也比较方便（关键词对应的值）。

2、选课系统

在增加实验信息的时候，是直接修改原有的方法，直接在方法体中增加一个是否实验信息的判断，这样做非常不符合开闭原则，可以通过程序适当的改写，让后续增加的信息，都能只增加新的类或方法，而不修改原来的类和方法。

五、总结

在这一阶段，我们学习到了很多，比如关于Comparable接口的运用，以及栈和队列等工具的应用，还有复杂程序的编写建构，任何复杂结构经过逐步分解，最后的一小部分一定都是非常简单的东西，我们只需要设计好各个类间的关系，剩下来的程序编写工作就比较常规，比较简单了。当然，也有很多东西我仍然需要进一步的学习，比如HashMap和Set的运用，在几次的程序作业中，我最常用的还是ArrayList，因此对其他可能在某些情况下会更好用的工具并没有熟练的掌握，导致有些题目利用好工具就能很简单的解决的题目，用不太匹配的ArrayList来写，出现了很多不必要的过程，增加了复杂度，耗费了许多不必要的时间。

第二部分：

我觉得本门课程（面向对象程序设计）中的教学设计还是没啥问题的，但是有些时候，具体内容的讲解不太全面，导致听后半知半解，还要在课后花时间自己学。不过这也一定程度上提高了我们的自学的能力。

然后Pta，第一阶段到第二阶段再到第三阶段，整体来说是循序渐进，难度逐渐加大的，但是有些题目中出现了难度过高或者过低的题目，比如前几个题目集的点菜系统，突然来一道难题，想解决它非常的困难。还有第三阶段的题目，也就是最近的几个题目，有一个模拟动物叫声的题目，非常简单，虽然一定程度上写这种简单的题目能够缓解难题的压力，但是题目难度最好还是适中，不需要太难，也不需要太过简单。

posted @ 2023-06-27 10:09 Swery_X 阅读(33) 评论(0) 收藏举报

刷新页面返回顶部

swery-x-

PTA 第三阶段题目集总结

输入格式:

输出格式:

输入格式:

输出格式:

公告

swery-x-

PTA 第三阶段 题目集总结

输入格式:

输出格式:

输入格式:

输出格式:

公告

PTA 第三阶段题目集总结