PTA题目集1/2/3总结

PTA题目集1

PTA的第一个题目集较为简单，所以不做过多描述：

比较坑的是题目没有说明，但要都是float类型，如果在计算中用double类型，那么最后输出时要强制转换成float类型。

7-2 长度质量计量单位换算

7-4 NCHU_房产税费计算

以上两题都是这样，不去百度我都不知道要这样搞（

---

 

PTA题目集2

 

7-1 成绩计算-1-类、数组的基本运用

分数 10

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

输入样例:

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

22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94

输出样例:

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

22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67

我的答案

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {
    public static class students{
        String numberString;
        String nameString;
        int chinese;
        int math;
        int phy;
        int zong=0;
        int all() {
            zong=chinese+math+phy;
            return zong;
        }
        double average() {
            double aver=zong/(double)3;
            return aver;
        }
    }
    
        public static void main(String[] args) {
            
            students[] stus=new students[5];
            DecimalFormat df = new DecimalFormat("#.00");
            Scanner putinScanner=new Scanner(System.in);
            
            //String stu1=putinScanner.nextLine();
            for(int i=0;i<5;i++)
            {
                stus[i]=new students();
                stus[i].numberString=putinScanner.next();
                stus[i].nameString=putinScanner.next();
                stus[i].chinese=putinScanner.nextInt();
                stus[i].math=putinScanner.nextInt();
                stus[i].phy=putinScanner.nextInt();
            }
            
            for(int i=0;i<5;i++)
            {
                System.out.println(stus[i].numberString+" "+stus[i].nameString+" "+
            stus[i].all()+" "+df.format(stus[i].average()));
            }
          }
        

}

---

 

7-2 成绩计算-2-关联类

分数 10

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:

3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

输入样例:

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

22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76

输出样例:

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

22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67

我的答案

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {
    public static class result{
        int ping;
        int mo;
        int zong()
        {
            int zon=(int) (ping*0.4+mo*0.6);
            return zon;
        }
        
    }
    
    public static class students{
        String numberString;
        String nameString;
        int[] feng=new int[3];
        int zong=0;
        int all() {
            zong=feng[0]+feng[1]+feng[2];
            return zong;
        }
        double average() {
            double aver=zong/(double)3;
            return aver;
        }
    }
    
    public static void main(String[] args) {
        result[] tell=new result[3];
        students[] stus=new students[3];
        DecimalFormat df = new DecimalFormat("#.00");
        Scanner putinScanner=new Scanner(System.in);
        double[][] jun=new double[3][2];
        String putin1,putin2;
        for(int i=0;i<3;i++)
        {
            tell[i]=new result();
            stus[i]=new students();
        }
        
        for(int i=0;i<3;i++)
        {
            
            for(int n=0;n<3;n++)
            {
                
                putin1=putinScanner.next();
                if(n==1)
                    stus[i].numberString=putin1;
                putin1=putinScanner.next();
                if(n==1)
                    stus[i].nameString=putin1;
                putin1=putinScanner.next();
                
                putin1=putinScanner.next();
                tell[n].ping=Integer.parseInt(putin1);
                jun[i][0]+=tell[n].ping;
                
                putin2=putinScanner.next();
                tell[n].mo=Integer.parseInt(putin2);
                jun[i][1]+=tell[n].mo;
                
                stus[i].feng[n]=tell[n].zong();;
                
            }
        }
        
       
            
        
        
        for(int i=0;i<3;i++)
        {
            
            System.out.println(stus[i].numberString+" "+stus[i].nameString+" "+
                    stus[i].all()+" "+df.format(jun[i][0]/(double)3)+" "+
                    df.format(jun[i][1]/(double)3)+" "+
                    df.format(stus[i].average()));
        }
    }

}

---

 

 后面倒数两题对我来讲就是上难度了，倒数第二题7-7题目给了类，所以花时间磨一磨还是能做出来的

7-7 菜单计价程序-1

分数 30

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:

每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:

订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

输入样例:

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

麻婆豆腐 2
西红柿炒蛋 3
end

输出样例:

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

48

输入样例1:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end

输出样例1:

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

炒脆肚 does not exist
48

我的答案

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    
     static class Dish {
        String name;//菜品名称
        int unit_price; //单价
        int getPrice(int portion){
            int price=0;
            if(portion==1)
            {price =unit_price;}
            else if(portion==2)
            {price=Math.round((float)(unit_price*1.5));}
            else if(portion==3)
            {price=Math.round((float)(unit_price*2));}
            
            return price;
        }//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
        }
     static class Menu {
        
        static Dish dishs[]=new Dish[4];//菜品数组，保存所有菜品信息
        void Menu2() {
            dishs[0]=new Dish();
            dishs[0].name="西红柿炒蛋";
            dishs[0].unit_price=15;
            dishs[1]=new Dish();
            dishs[1].name="清炒土豆丝";
            dishs[1].unit_price=12;
            dishs[2]=new Dish();
            dishs[2].name="麻婆豆腐";
            dishs[2].unit_price=12;
            dishs[3]=new Dish();
            dishs[3].name="油淋生菜";
            dishs[3].unit_price=9;
        }
        
        
        static Dish searthDish(String dishName){
            for(int i=0;i<4;i++)
            {
                if(dishs[i].name.equals(dishName)==true)
                {
                    return dishs[i];
                }
            }
            return null;
        }
        //根据菜名在菜谱中查找菜品信息，返回Dish对象。
        }
     static class Record {
        Dish d;//菜品
        int portion;//份额（1/2/3代表小/中/大份）
        int getPrice(){
            
            int price=d.getPrice(portion);
            return price;
        }//计价，计算本条记录的价格
        }
     static class Order {
        Record[] records=new Record[10];//保存订单上每一道的记录
        int n=-1,all=0;
        int getTotalPrice(){
            for(int i=0;i<=n;i++)
            {
                all+=records[i].getPrice();
            }
            return all;
        }//计算订单的总价
        void addARecord(String dishName,int portion) {
            /*if(n==0)
            {
                records[n]=new Record();
                records[n].d=Menu.searthDish(dishName);
                records[n].portion=portion;
                
            }else {*/
            records[n+=1]=new Record();
            records[n].d=Menu.searthDish(dishName);
            records[n].portion=portion;
            
            
        }
        //添加一条菜品信息到订单中。
        }

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Menu menu1=new Menu();
        menu1.Menu2();
        //Record jilu=new Record();
        Order dingdangOrder=new Order();
        Scanner inputScanner=new Scanner(System.in);
        ArrayList<String> list = new ArrayList<String>();
        String iString;
        while(!"end".equals(iString=inputScanner.next()))
        {
            list.add(iString);
        }
        for (int i = 0; i < list.size(); i+=2) {
            if(menu1.searthDish(list.get(i))==null)
            {
                System.out.println(list.get(i)+" does not exist");
                
            }else {
                dingdangOrder.addARecord(list.get(i), Integer.parseInt(list.get(i+1)));
            }
        
        }
        System.out.println(dingdangOrder.getTotalPrice());

    }

}

---

最后一题7-8坐大牢（，一开始想用蠢方法一个一个用scannner输入，但去百度后发现java提供了许多关于时间的类，所以我花了一晚上的时间去了解Localdate类。

其实Localdate类的操作看懂后关于日期的计算也还好，主要一开始的输入我不知道怎么限定就没去管（这里给我自己挖坑了！），利用Localdate就能轻松的计算是否闰年，该日期是当年第几天、当月第几天、当周第几天。判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、年数。

不过我不懂为什么月数要是单纯的做减法？人家Localdate类都是按时间算差的月数（老师你喜欢就好），经过一晚上的折腾终于觉得搞好的时候！Pta最后的两个测试点一直过不去，折磨我到凌晨两点想放弃了，结果听隔壁说是输入判定没有考虑，结果果然如此！如果没有按给定的格式输入就输出日期不合法，最后折磨我的竟然是开头的输入判定！

最后时间到了才知道这件事！我裂开（

7-8 jmu-java-日期类的基本使用

分数 10

全屏浏览题目

切换布局

作者 郑如滨

单位 集美大学

1. 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
2. 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。

输入格式:

第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

输出格式:

如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。

输入样例1:

第一行日期非法、第二行有日期非法

2020-02-30
2020-02-30 2020-01-02

输出样例1:

2020-02-30无效!
2020-02-30或2020-01-02中有不合法的日期.

输入样例2:

均有效且合法

2021-02-28
2019-08-01 2020-01-02

输出样例2:

2021-02-28是当年第59天,当月第28天,当周第7天.
2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.

输入样例3:

日期均有效，但结束日期早于开始日期

2020-02-28
2020-02-02 2020-02-01

输出样例3:

2020-02-28是闰年.
2020-02-28是当年第59天,当月第28天,当周第5天.
2020-02-01早于2020-02-02,不合法!

我的答案

import java.time.LocalDate;
import java.time.Month;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.ResolverStyle;
import java.time.temporal.ChronoUnit;
import java.util.Locale;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public interface DateValidator {
        boolean isValid(String dateStr);
    }
    
    public static class DateValidatorUsingDateTimeFormatter implements DateValidator {
        private final DateTimeFormatter dateFormatter;

        public DateValidatorUsingDateTimeFormatter(DateTimeFormatter dateFormatter) {
            this.dateFormatter = dateFormatter;
        }

        //@Override
        public boolean isValid(String dateStr) {
            try {
                this.dateFormatter.parse(dateStr);
            } catch (DateTimeParseException e) {
                return false;
            }
            return true;
        }
    }
    
    

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.CHINA);
        final DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        final DateTimeFormatter dateFormatter = DATE_FORMATTER.withResolverStyle(ResolverStyle.STRICT);
        DateValidatorUsingDateTimeFormatter niuniUsingDateTimeFormatter=
                new DateValidatorUsingDateTimeFormatter(dateFormatter);
        
        Scanner inpScanner=new Scanner(System.in);
        String ru1=inpScanner.nextLine();
        String ru2=inpScanner.next();
        String ru3=inpScanner.nextLine();
        ru1=ru1.trim();
        ru2=ru2.trim();
        ru3=ru3.trim();
        
        String pattern = "[0-9]{4}\\-(?:(01|03|05|07|09|11)(\\-0[1-9]|\\-[1-2]\\d|\\-3[0-1])|(02|04|06|08|10|12)(\\-0[1-9]|\\-[1-2]\\d|\\-30))";
        Pattern r1 = Pattern.compile(pattern);
        Pattern r2 = Pattern.compile(pattern);
        Pattern r3 = Pattern.compile(pattern);
        Matcher m1 = r1.matcher(ru1);
        Matcher m2 = r2.matcher(ru2);
        Matcher m3 = r3.matcher(ru3);
        
        
        if(ru1.length()!=10|m1.matches()==false)
        {System.out.println(ru1+"无效!");
        }
        else {
            
            LocalDate date = LocalDate.parse(ru1,fmt);
            if(niuniUsingDateTimeFormatter.isValid(ru1)==false) {
                System.out.println(ru1+"无效!");
            }
            else {
                if(date.isLeapYear())
                    System.out.println(date+"是闰年.");
                System.out.println(date+"是当年第"+date.getDayOfYear()+
                        "天,当月第"+date.getDayOfMonth()+"天,当周第"+date.getDayOfWeek().getValue()
                        +"天.");
            }
        }
        if(ru2.length()!=10|m2.matches()==false|ru3.length()!=10|m3.matches()==false|
        niuniUsingDateTimeFormatter.isValid(ru2)==false|niuniUsingDateTimeFormatter.isValid(ru3)==false)
        {System.out.println(ru2+"或"+ru3+"中有不合法的日期.");
            return;}
        
        LocalDate chi1=LocalDate.parse(ru2,fmt);
        LocalDate chi2=LocalDate.parse(ru3,fmt);
        
        if(niuniUsingDateTimeFormatter.isValid(ru2)&niuniUsingDateTimeFormatter.isValid(ru3)) {
            
            if(chi1.isBefore(chi2))
                
            {int year = chi2.getYear()-chi1.getYear();
            int month = chi2.getMonthValue()-chi1.getMonthValue();
            //int months = chi2.getMonthValue();
            long days = chi1.until(chi2, ChronoUnit.DAYS);
            
            System.out.println(ru3+"与"+ru2+"之间相差"+days+
                    "天,所在月份相差"+month+",所在年份相差"+year+".");
            }
            else {
                System.out.println(ru3+"早于"+ru2+",不合法!");
            }
            
        }
        
        
        
        //LocalDate newnewDate=

    }

}

 

 

---

 PTA题目集3

这里临近国庆中秋假期，所以老师只布置了4道题，其中3题是做过的，只有一道是新的，但这个新的好难，光代码要写到400行，而且超纲了，要求使用继承，还没学就去搞，我假期花了两天时间去做这道题，最后还是搞不定，也没有使用题目提供的参考类图去创作类，所以我坐大牢了（

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

分数 65

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

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

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

输出样例1:

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

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

输入样例2:

单门考试课程 单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

输出样例2:

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

20201103 张三 34
java 20 40 34
202011 34

输入样例3:

单门考察课程 单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

输出样例3:

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

20201103 张三 40
java 40 40
202011 40

输入样例4:

考试课程 单个学生 不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

输出样例4:

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

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

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

输出样例5:

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

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

输出样例6:

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

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

输出样例7:

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

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

输出样例8:

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

wrong format
数据结构 has no grades yet

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

输出样例9:

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

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    /*
     * 课程类里实现输入规范
     * 存入课程名字，考试还是考察
     * 使用封装
     */
      static class ke{
        //private String pattern = "[\\u4E00-\\u9FA5A-Za-z]{1,10} (必修( 考试)?|选修( 考察| 考试))";
        //private Pattern r = Pattern.compile(pattern);
        private  ArrayList<String> ru=new ArrayList<>();
        private int num=0,peacetime=0,finalexam=0,total=0;
        void setnum() {
            this.num+=1;
        }
        int getnum() {
            return num;
        }
        void setpeacetime(int j) {
            this.peacetime+=j;
        }
        void setpeacetimeplus(int j) {
            this.peacetime=j;
        }
        int getpeacetime() {
            return peacetime;
        }
        void setfinalexam(int j) {
            this.finalexam+=j;
        }
        void setfinalexamplus(int j) {
            this.finalexam=j;
        }
        int getfinalexam() {
            return finalexam;
        }
        int getsize() {
            return ru.size();
        }
        void settotal() {
            if(ru.get(2).equals("考试")||ru.get(1).equals("必修")) {
            total=(int) ((double)0.3*peacetime+(double)0.7*finalexam);}
            else {
                total=finalexam;
            }
        }
        int gettotal() {
            return total;
        }

        void match(String str) {
        
            for(String retval: str.split(" ")) {
            ru.add(retval);
            }
        if(ru.get(1).equals("必修")&&ru.get(2).equals("考察")) {
            ru.add("error");
            ru.set(1,"123");
            ru.set(2,"asd");
            System.out.println(ru.get(0)+" : course type & access mode mismatch");
        }
            
        //return true;
    }
        
        String getcoursename() {
            return ru.get(0);
        }
         String getway() {
            if(ru.get(1).equals("必修"))
            return "考试";
            else {
                return ru.get(2);
            }
        }
    }
    /*
     * 学生类输入规范
     * 存入学生名字，学号，成绩
     */
    public static class student{
        //private String pattern = "\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} (?:([0-9][0-9]?|100) ([0-9][0-9]?|100)|([0-9][0-9]?|100))\\b";
        //private Pattern r = Pattern.compile(pattern);
        private ArrayList<String> ru=new ArrayList<>();
        private int num=0,stuexam=0;
        String getnumber() {
            return ru.get(0);
        }
        String getname() {
            return ru.get(1);
        }
        void setnum() {
            this.num+=1;
        }
        int getnum() {
            return num;
        }
        void setstuexam(int j) {
            this.stuexam+=j;
        }
        void setstuexamplus(int j) {
            this.stuexam=j;
        }
        int getstuexam() {
            return stuexam;
        }
        int getsize() {
            return ru.size();
        }
        void match(String str) {
                for(String retval: str.split(" ")) {
                ru.add(retval);
                }

        }
        void err(String str) {
            for(String retval: str.split(" ",3)) {
                ru.add(retval);
                }
        }
        
        String getcoursename() {
            return ru.get(2);
        }
        int getgrade1() {
            return Integer.parseInt(ru.get(3));
        }
        int getgrade2() {
            return Integer.parseInt(ru.get(4));
        }
    }
    
    public static class grade{
        
         static void stugrade(student stu,ke lesson) {
            if(stu.getcoursename().equals(lesson.getcoursename())) {
                if(lesson.getway().equals("考试")) {
                    if(stu.getsize()!=5) {
                        System.out.println(stu.getnumber()+" "+stu.getname()+" : access mode mismatch");
                        //System.out.println(stu.getnumber()+" "+stu.getname()+" did not take any exams");
                        return;
                    }
                    stu.setstuexam((int) ((double)0.3*stu.getgrade1()+(double)0.7*stu.getgrade2()));
                    lesson.setpeacetime(stu.getgrade1());
                    lesson.setfinalexam(stu.getgrade2());
                   stu.setnum();lesson.setnum();
                   }
                else if(lesson.getway().equals("考察")){
                    if(stu.getsize()!=4) {
                        System.out.println(stu.getnumber()+" "+stu.getname()+" : access mode mismatch");
                        
                        return;
                    }
                    
                        stu.setstuexam(stu.getgrade1());
                    lesson.setfinalexam(stu.getgrade1());
                    stu.setnum();lesson.setnum();
                    }
                else {
                    System.out.println(lesson.getcoursename()+" does not exist");
                }
                }
            
        }
        
    }
     public static class count{
         static void cal(int n,int m,student[] stu,ke[] lesson) {
            for(int i=0;i<m;i++) {
                for(int j=0;j<n;j++) {
                    
                    grade.stugrade(stu[i],lesson[j]);
                    
                }
            }
            for(int i=0;i<n;i++) {
                if(lesson[i].getnum()==0)
                    continue;
            lesson[i].setfinalexamplus(lesson[i].getfinalexam()/lesson[i].getnum());
            lesson[i].setpeacetimeplus(lesson[i].getpeacetime()/lesson[i].getnum());
            lesson[i].settotal();
            
            }
            
        }
    }
     
     public static class quchong{
         static void qu1(int m,student[] stu) {
             String numberString=stu[0].getnumber();
             String nameString=stu[0].getname();
             int ins=0;
             if(stu[0].getnum()!=0) 
              ins=stu[0].getstuexam()/stu[0].getnum();
             
             int num=0;
             for(int i=1;i<m;i++) {
                 if(numberString.equals(stu[i].getnumber())) {
                     ins+=stu[i].getstuexam()/stu[i].getnum();
                     num++;
                     
                 }else {
                     if(ins==0) {
                         System.out.println(stu[i].getnumber()+" "+stu[i].getname()+" did not take any exams");
                     }else {
                        System.out.println(numberString+" "+nameString+" "+ins/(num+1));
                    }
                    num=0;
                    ins=stu[i].getstuexam()/stu[i].getnum();
                    numberString=stu[i].getnumber();
                    nameString=stu[i].getname();
                }
             }if(num!=0||m==1||num==0) {
                 if(ins==0) {
                     System.out.println(numberString+" "+nameString+" did not take any exams");
                 }else {
                    System.out.println(numberString+" "+nameString+" "+ins/(num+1));
                }
                 
             }
                 
                     
         }
     }
     
     public static class xu{
         static void xu1(int m,student[] stu) {
             for(int i=0;i<m;i++) {
                    for(int j=0;j<m;j++) {
                        if(Integer.parseInt(stu[i].getnumber())<Integer.parseInt(stu[j].getnumber())) {
                            student temp=new student();
                            temp=stu[i];
                            stu[i]=stu[j];
                            stu[j]=temp;
                        } 
                    }
                }
             quchong.qu1(m, stu);
         }
         
         static void xu2(int n,ke[] lesson) {
             
             for(int i=0;i<n;i++) {
                    for(int j=0;j<n;j++) {
                        if(lesson[j].gettotal()==0&&lesson[j].getsize()==3) {
                            System.out.println(lesson[j].getcoursename()+" has no grades yet");
                            continue;
                        }
                        if(lesson[i].gettotal()<lesson[j].gettotal()) {
                            ke temp1=new ke();
                            temp1=lesson[i];
                            lesson[i]=lesson[j];
                            lesson[j]=temp1;
                        } 
                    }
                }
             for(int i=0;i<n;i++) {
                    if(lesson[i].getway().equals("考试")&&lesson[i].gettotal()!=0) {
                        
                        System.out.println(lesson[i].getcoursename()+" "+lesson[i].getpeacetime()+" "+lesson[i].getfinalexam()+" "+lesson[i].gettotal());
                        
                    }
                    else if(lesson[i].gettotal()!=0){
                        System.out.println(lesson[i].getcoursename()+" "+lesson[i].getfinalexam()+" "+lesson[i].gettotal());
                    }
                }
         }
     }
     
     public static class chu{
         static void niuzi(int m,student[] stu) {
             String numberString=stu[0].getnumber().substring(0,6);
             int ins=0;
             if(stu[0].getnum()!=0)
             ins=stu[0].getstuexam()/stu[0].getnum();
             
             int num=0;
             for(int i=1;i<m;i++) {
                 if(numberString.equals(stu[i].getnumber().substring(0,6))) {
                     ins+=stu[i].getstuexam()/stu[i].getnum();
                     num++;
                 }else {
                     if(ins==0) {
                         System.out.println(numberString+" has no grades yet");
                     }else {
                        System.out.println(numberString+" "+(ins/(num+1)));
                    }
                    num=0;
                    ins=stu[i].getstuexam()/stu[i].getnum();
                    numberString=stu[i].getnumber().substring(0,6);
                }
             }
             if(num!=0||m==1||num==0) {
                 if(ins==0) {
                     System.out.println(numberString+" has no grades yet");
                 }else {
                    System.out.println(numberString+" "+(ins/(num+1)));
                }
                 
             }
             
         }
     }
    
    
     
    public static void main(String[] args) {
        Scanner inScanner=new Scanner(System.in);
        ArrayList<String> ru=new ArrayList<>();
        int n=0,m=0;
        student[] stu=new student[50];
        ke[] lesson=new ke[50];
        String str="";
        
        do {
            str=inScanner.nextLine();            
            ru.add(str);
        }while(!str.equals("end"));
        String pattern1 = "\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} ([0-9][0-9]?|100)( [0-9][0-9]?| 100)?\\b";
        String pattern2 = "[\\u4E00-\\u9FA5A-Za-z]{1,10} (必修( 考察| 考试)?|选修( 考察| 考试))";
        Pattern r1 = Pattern.compile(pattern1);
            Pattern r2 = Pattern.compile(pattern2);
        for(int i=0;i<ru.size();i++) {

            Matcher pi1 = r1.matcher(ru.get(i));
            Matcher pi2 = r2.matcher(ru.get(i));
            if(pi2.matches()) {
            lesson[n]=new ke();
            lesson[n].match(ru.get(i));
            n++;
            }
            if(pi1.matches()) {
            stu[m]=new student();
            stu[m].match(ru.get(i));
            m++;
            }
        else if(ru.get(i).equals("end")){
            break;
        }else if(!pi1.matches()&&!pi2.matches()){
            //stu[m]=new student();
            //stu[m].err(ru.get(i));
            //m++;
            System.out.println("wrong format");
            
        }
            
        }
        if(m==0) {
            for(int i=0;i<n;i++) {
                System.out.println(lesson[i].getcoursename()+" "+"has no grades yet");
            }
        }else {
        count.cal(n,m,stu,lesson);
        xu.xu1(m,stu);
        xu.xu2(n,lesson);
        chu.niuzi(m, stu);
        }
        
        
        //System.out.println();
        //System.out.println(grade.finalgrade1/grade.kao);
    }


}