公告

一、前言

终于，又到了激动人心的blog时间，这也是这学期的最后一次blog作业，那就说一点题外话。没想到一个学期的java学习就这么快地过去了，有一种度日如年，不是，怅然若失的感觉，虽然学的没有别的同学那么精，但是在学习java的过程中，我确确实实收获了很多东西，也让我感受到代码的魅力。（虽然压力真的很大！）接下来进入正题

这几次的题目集，难度不是一般的大，虽然关键的题目从菜单演变到了课程，相对简单一点，但还是十分的繁琐，让人头秃

1.第七次题目集是我们的老朋友，菜单的最后一次迭代，令人唏嘘

2.第八次、第十次和第十一次题目集的主要难点是我们的新朋友，课程问题，主要解决方法和菜单类似，但要稍微简单一点

3.第九次题目集主要考察了hashmap，treemap的使用，难度不是很大

二、设计与分析

挑选个别题目进行分析

第七次题目集

7-1 菜单计价程序-5

让我们来看看这次新加的题目要求：

1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"

例如：麻婆豆腐川菜 9 T

菜价的计算方法：

周一至周五 7折，周末全价。

特色菜的口味类型：川菜、晋菜、浙菜

川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；

晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；

浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；

例如：麻婆豆腐川菜 9 T

输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数

例如：1 麻婆豆腐 4 1 9

单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：

acidity num out of range : 5

输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。

一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。

如果整桌菜没有特色菜，则只输出table的基本信息，格式如下，注意最后加一个英文空格：

table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格

例如：table 1: 60 36 川菜 2 爆辣浙菜 1 微甜

计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。

注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。

2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：

格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

例如：table 1 : tom 13670008181 2023/5/1 21/30/00

约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。

输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。

输出用户支付金额格式：

用户姓名+英文空格+手机号+英文空格+支付金额

注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：

计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。

将所有记录的菜价累加得到整桌菜的价格。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+口味类型+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+辣/酸/甜度值+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。辣/酸/甜度取值范围见题目中说明。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称**+英文空格+辣/酸/甜度值+**英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+“:”+英文空格

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

之后按输入顺序一次输出每一桌所有菜品的价格（整数数值），

格式：table+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格

最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式：用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。

输入样例5:

多用户多桌菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 1 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

输出样例5:

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

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 醋浇羊肉 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 4 稍酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣 晋菜 2 微酸
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 191
tom 13605054400 113

输入样例6:

多用户多桌菜含代点菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 1 醋浇羊肉 0 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : lucy 18957348763 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

输出样例6:

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

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 table 2 pay for table 1 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 6 微酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 118
lucy 18957348763 73
tom 13605054400 113

思路：首先还是感慨一下，题目是真的很长。由于这个不是菜单4的迭代而是菜单3的迭代，所以思路会有一定偏差。我主要设了以下几个类，Dish 类包含菜品名称、单价和菜系类型，Menu 类包含所有的菜品列表，并提供添加和查询菜品的方法，Record 类包含订单编号、所点菜品、份数和数量等信息，并提供计算价格和输出订单信息的方法。如果菜品是辣度/酸度/甜度类型，则还需要记录用户选择的等级，并进行范围检查，Table 类包含客户姓名、电话、预约日期、预约时间、已点菜品列表等信息，并提供计算总价格、平均价格和输出桌号信息的方法。说是一回事，做又是另外一回事，这个代码我是没有拿到满分的，以上分析仅供参考

源码如下：

import java.util.*;
import java.time.*; 
import java.text.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class Main {
    public static void main(String[] args) throws ParseException {
        Menu menu = new Menu();
        // 读入菜单信息
        Scanner sc = new Scanner(System.in);
        String menuLine = sc.nextLine();
        while (!menuLine.startsWith("table")) {
            String[] menuInfo = menuLine.split(" ");
            if (menuInfo.length == 2) {
                String name = menuInfo[0];
                int unit_price = Integer.parseInt(menuInfo[1]);
                if (menu.searchDish(name) == null) {
                    menu.addDish(name, unit_price);
                }
            } else if (menuInfo.length == 4 && menuLine.endsWith("T")) {
                String name = menuInfo[0];
                String type = menuInfo[1];
                int unit_price = Integer.parseInt(menuInfo[2]);
                Map<String, String> map = new HashMap<String, String>() {
                    {
                        put("川菜", "Chuan");
                        put("晋菜", "Jin");
                        put("浙菜", "Zhe");
                    }
                };
                DishType dishType = DishType.valueOf(map.get(type));
                if (menu.searchDish(name) == null) {
                    menu.addDish(name, unit_price, dishType);
                }
            } else {
                System.out.println("wrong format");
            }
            menuLine = sc.nextLine();
        }
        ArrayList<Table> tables = new ArrayList<>();
        ArrayList<String> names = new ArrayList<>();
        // 读入订单信息
        int tableId = 0;
        String name = null;
        String phone = null;
        Date date = null;
        Date time = null;
        boolean legaltime = true;
        boolean legalformat = true;
        String orderLine = menuLine;
        while (!orderLine.equals("end")) {
            String[] orderInfo = orderLine.split(" ");
            // 解析桌号标识
            if (orderLine.startsWith("table")) {
                legalformat = true;
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
                SimpleDateFormat timeFormat = new SimpleDateFormat("HH/mm/ss");
                tableId = Integer.parseInt(orderInfo[1]);
                name = orderInfo[3];
                phone = orderInfo[4];
                try {
                    date = dateFormat.parse(orderInfo[5]);
                    time = timeFormat.parse(orderInfo[6]);
                } catch (Exception e) {
                    legalformat = false;
                    System.out.println("wrong format");
                    orderLine = sc.nextLine();
                    continue;
                }
                String regex = "^1(80|81|89|33|35|36)\\d{8}$";
                Table table = new Table(tableId, name, phone, date, time);
                tables.add(table);
                if (name.length() > 10 || !phone.matches(regex)) {
                    legalformat = false;
                    System.out.println("wrong format");
                    orderLine = sc.nextLine();
                    continue;
                }
                if (!names.contains(name)) {
                    names.add(name);
                }
                if (table.getCoefficient(true) == 0) {
                    legaltime = false;
                    System.out.println("table " + table.tableId + " out of opening hours");
                } else {
                    System.out.println(table.printId());
                }
            } else {
                if (legalformat) {
                    int orderNum;
                    try {
                        orderNum = Integer.parseInt(orderInfo[0]);
                    } catch (Exception e) {
                        System.out.println("wrong format");
                        orderLine = sc.nextLine();
                        continue;
                    }
                    if (orderLine.endsWith("delete")) {
                        if (!tables.get(tableId - 1).delRecordByOrderNum(orderNum)) {
                            System.out.println("delete error");
                        }
                    } else {
                        if (orderInfo.length == 4) {
                            String dishName = orderInfo[1];
                            int portion = Integer.parseInt(orderInfo[2]);
                            int quantity = Integer.parseInt(orderInfo[3]);
                            Dish dish = menu.searchDish(dishName);
                            if (dish == null) {
                                System.out.println(dishName + " does not exist");
                                orderLine = sc.nextLine();
                                continue;
                            }
                            Record record = new Record(tableId, orderNum, dish, portion, quantity);
                            tables.get(tableId - 1).addRecord(record);
                            if (legaltime) {
                                System.out.println(record.print(tableId));
                            }
                        } else if (orderInfo.length == 5) {
                            String dishName = orderInfo[1];
                            int level = Integer.parseInt(orderInfo[2]);
                            int portion = Integer.parseInt(orderInfo[3]);
                            int quantity = Integer.parseInt(orderInfo[4]);
                            Dish dish = menu.searchDish(dishName);
                            if (dish == null) {
                                System.out.println(dishName + " does not exist");
                                orderLine = sc.nextLine();
                                continue;
                            }
                            Record record = new Record(tableId, orderNum, dish, level, portion, quantity);
                            tables.get(tableId - 1).addRecord(record);
                            if (legaltime) {
                                System.out.println(record.print(tableId));
                            }
                        } else if (orderInfo.length == 6) {
                            int givenId = Integer.parseInt(orderInfo[1]);
                            String dishName = orderInfo[2];
                            int level = Integer.parseInt(orderInfo[3]);
                            int portion = Integer.parseInt(orderInfo[4]);
                            int quantity = Integer.parseInt(orderInfo[5]);
                            Dish dish = menu.searchDish(dishName);
                            if (dish == null) {
                                System.out.println(dishName + " does not exist");
                                orderLine = sc.nextLine();
                                continue;
                            }
                            Record record1 = new Record(givenId, orderNum, dish, level, portion, quantity);
                            Record record2 = new Record(givenId, orderNum, dish, level, 0, quantity);
                            tables.get(tableId - 1).addRecord(record1);
                            tables.get(givenId - 1).addRecord(record2);
                            if (legaltime) {
                                System.out.println(record1.print(tableId));
                            }
                        } else {
                            System.out.println("wrong format");
                        }
                    }
                }
            }
            // 读入下一个桌号标识
            orderLine = sc.nextLine();
        }
        sc.close();
        for (Table table : tables) {
            if (table.flag && table.getTotalPrice() != 0) {
                System.out.println(table.printInfo());
            }
        }
        names.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });
        for (String costumName : names) {
            int sum = 0;
            String costumPhone = null;
            for (Table table : tables) {
                if (table.name.equals(costumName)) {
                    sum += table.getCheckedPrice();
                    costumPhone = table.phone;
                }
            }
            if (sum != 0) {
                System.out.println(costumName + " " + costumPhone + " " + sum);
            }
        }
    }
}
enum DishType {
    Chuan,
    Jin,
    Zhe,
}
class Dish {
    public String name;
    public int unit_price;
    public DishType type;
    public Dish(String name, int unit_price, DishType type) {
        this.name = name;
        this.unit_price = unit_price;
        this.type = type;
    }
    public Dish(String name, int unit_price) {
        this.name = name;
        this.unit_price = unit_price;
    }
    @Override
    public String toString() {
        return name;
    }
}
class Menu {
    public ArrayList<Dish> dishs = new ArrayList<>();
    public Dish searchDish(String dishName) {
        for (Dish dish : dishs) {
            if (dish.name.equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
    void addDish(String dishName, int unit_price) {
        dishs.add(new Dish(dishName, unit_price));
    }
    void addDish(String dishName, int unit_price, DishType type) {
        dishs.add(new Dish(dishName, unit_price, type));
    }
}
class Record {
    int orderNum;
    Dish dish;
    int portion;
    int quantity;
    int level;
    boolean flag;
    int givenId;
    boolean check_level() {
        switch (dish.type) {
            case Chuan:
                if (level > 5 || level < 0) {
                    return false;
                } else {
                    return true;
                }
            case Jin:
                if (level > 4 || level < 0) {
                    return false;
                } else {
                    return true;
                }
            case Zhe:
                if (level > 3 || level < 0) {
                    return false;
                } else {
                    return true;
                }
            default:
                return true;
        }
    }
    public Record(int givenID, int orderNum, Dish dish, int portion, int quantity) {
        this.orderNum = orderNum;
        this.dish = dish;
        this.portion = portion;
        this.quantity = quantity;
        this.level = -1;
        this.flag = true;
        this.givenId = givenID;
    }
    public Record(int givenId, int orderNum, Dish dish, int level, int portion, int quantity) {
        this.orderNum = orderNum;
        this.dish = dish;
        this.portion = portion;
        this.quantity = quantity;
        this.level = level;
        this.flag = check_level();
        this.givenId = givenId;
    }
    int getPrice() {
        if (!flag)
            return 0;
        double coefficient = 0;
        switch (portion) {
            case 1:
                coefficient = 1;
                break;
            case 2:
                coefficient = 1.5;
                break;
            case 3:
                coefficient = 2;
                break;
        }
        int price = (int) Math.round(dish.unit_price * coefficient) * quantity;
        return price;
    }
    int getCheckedPrice(Double coefficient) {
        return (int) Math.round(getPrice() * coefficient);
    }
    public String print(int tableId) {
        if (flag == false) {
            switch (dish.type) {
                case Chuan:
                    return "spicy num out of range :" + level;
                case Jin:
                    return "acidity num out of range :" + level;
                case Zhe:
                    return "sweetness num out of range :" + level;
                default:
                    return null;
            }
        } else {
            if (givenId == tableId) {
                return orderNum + " " + dish.toString() + " " + getPrice();
            }
            return orderNum + " table " + tableId + " pay for table " + givenId + " " + getPrice();
        }
    }
    @Override
    public String toString() {
        return "Record [orderNum=" + orderNum + ", dish=" + dish + ", portion=" + portion + ", quantity=" + quantity
                + ", level=" + level + ", flag=" + flag + ", givenId=" + givenId + "]";
    }
}
class Table {
    ArrayList<Record> records = new ArrayList<>();
    int tableId;
    String name;
    String phone;
    Date date;
    Date time;
    boolean flag;
    public Table(int tableId, String name, String phone, Date date, Date time) {
        this.name = name;
        this.phone = phone;
        this.date = date;
        this.time = time;
        this.tableId = tableId;
        this.flag = true;
    }
    double getCoefficient(boolean Special) throws ParseException {
        double coefficient = 0;
        SimpleDateFormat sdfTime = new SimpleDateFormat("HH:mm");
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
        // 营业时间
        if (dayOfWeek == 1 || dayOfWeek == 7) {
            if (time.after(sdfTime.parse("9:29")) && time.before(sdfTime.parse("21:31"))) {
                coefficient = 1;
            }
        } else {
            if (time.after(sdfTime.parse("16:59")) && time.before(sdfTime.parse("20:31"))) {
                if (Special) {
                    coefficient = 0.7;
                } else {
                    coefficient = 0.8;
                }
            } else if (time.after(sdfTime.parse("10:29")) && time.before(sdfTime.parse("14:31"))) {
                if (Special) {
                    coefficient = 0.7;
                } else {
                    coefficient = 0.6;
                }
            }
        }
        if (coefficient == 0) {
            flag = false;
        }
        return coefficient;
    }
    int getTotalPrice() {
        int sum = 0;
        for (Record record : records) {
            sum += record.getPrice();
        }
        return sum;
    }
    int getCheckedPrice() throws ParseException {
        int sum = 0;
        for (Record record : records) {
            if (record.level != -1) {
                sum += record.getCheckedPrice(getCoefficient(true));
            } else {
                sum += record.getCheckedPrice(getCoefficient(false));
            }
        }
        return sum;
    }
    String getAveLevel(DishType type) {
        String[] spicy = { "不辣", "微辣", "稍辣", "辣", "很辣", "爆辣" };
        String[] acidity = { "不酸", "微酸", "稍酸", "酸", "很酸" };
        String[] sweetness = { "不甜", "微甜", "稍甜", "甜" };
        double sum = 0;
        double num = 0;
        for (Record record : records) {
            if (record.dish.type == type) {
                if (record.flag && tableId == record.givenId) {
                    num += record.quantity;
                    sum += record.level * record.quantity;
                }
            }
        }
        if (num == 0) {
            return "";
        }
        int ave = (int) Math.round(sum / num);
        switch (type) {
            case Chuan:
                return " 川菜 " + (int) num + " " + spicy[ave];
            case Jin:
                return " 晋菜 " + (int) num + " " + acidity[ave];
            case Zhe:
                return " 浙菜 " + (int) num + " " + sweetness[ave];
            default:
                return null;
        }
    }
    void addRecord(Record record) {
        records.add(record);
    }
    boolean delRecordByOrderNum(int orderNum) {
        return records.removeIf(record -> record.orderNum == orderNum);
    }
    Record findRecordByOrderNum(int orderNum) {
        for (Record record : records) {
            if (record.orderNum == orderNum) {
                return record;
            }
        }
        return null;
    }
    public String printId() {
        return "table " + tableId + ": ";
    }
    public String printInfo() throws ParseException {
        String chuan = getAveLevel(DishType.Chuan);
        String jin = getAveLevel(DishType.Jin);
        String zhe = getAveLevel(DishType.Zhe);
        if (chuan == "" && jin == "" && zhe == "") {
            return "table " + tableId + ": " + getTotalPrice() + " " + getCheckedPrice() + " ";
        } else {
            return "table " + tableId + ": " + getTotalPrice() + " " + getCheckedPrice() + chuan + jin + zhe;
        }
    }
}

第八次题目集

7-1 课程成绩统计程序-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:

仅有课程。例如：

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

思路：首先可以看到这个题目还是那熟悉的味道，是你吗菜单，可惜不是，它是菜单的传人面对这个题目，我主要使用了Student 类表示学生，包含学生姓名和学号信息。Course 类表示课程，包含课程名称、选修/必修属性、考试/考察属性以及成绩等信息，并提供计算平均分和输出成绩信息的方法。Ban 类表示班级，包含班级编号、学生列表以及平均分数等信息。Score 是一个抽象类，其中定义了科目总评成绩的计算方式，由其子类 Kao 和 Cha 分别实现考试和考察两种不同的计算方式。最后在 main 函数中，首先创建了这些类的实例，然后通过输入命令行参数进行相应操作，包括添加或查询课程信息。其中，对于新增加的课程，如果它是“必修”且是“考察”类型，则会提示“course type & access mode mismatch”，并认为该课程不存在。在代码中使用了类的继承、封装以及多态等面向对象的思想，同时也使用了 ArrayList 等集合类来存储数据。当然，我并没有做到满分，所以下面我放出的代码仅供参考

源码如下：

import java.util.*;
import java.text.Collator;
public class Main
{
    public static void main(String[] args)
    {
        Scanner scan =new Scanner(System.in);
        int flag=1;
        Map<String, Course> courses = new LinkedHashMap<>();//储存课程信息不用hashmap
        List<Course_selection> grades = new ArrayList<>();
        String[] s = new String[100];
        int i=0;
        while(scan.hasNextLine())
        {
            String input=scan.nextLine().trim();
            s[i++]=input;
            if(input.equals("end"))
            {
                break;
            }
            String a[]=input.split(" ");
            try
            {
                if(a.length==2)
                {
                    if (!a[1].equals("必修"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    Course c=new Course(a[0],a[1],"考试");
                    if(courses.isEmpty())
                    {
                        courses.put(a[0],c);
                    }
                    if(!courses.isEmpty())
                    {
                        for (String courseName : courses.keySet())
                        {
                            Course value = courses.get(courseName);
                            if(!courseName.equals(a[0])&& !(value ==c))
                            {
                                courses.put(a[0],c);
                                break;
                            }
                        }
                    }
                }
                if(a.length==3)//课程信息
                {

                    Course c=new Course(a[0],a[1],a[2]);
                    if (!a[1].equals("必修") && !a[1].equals("选修"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    if (!a[2].equals("考试") && !a[2].equals("考察"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    if (c.character.equals("必修") && !c.method.equals("考试"))
                    {
                        flag=0;

                    }
                    if(courses.isEmpty())
                    {
                        courses.put(a[0],c);
                    }
                    if(!courses.isEmpty())
                    {
                        for (String courseName : courses.keySet())
                        {
                            //Course value = courses.get(courseName);
                            if(!courseName.equals(a[0]))
                            {
                                courses.put(a[0],c);
                                break;
                            }
                        }
                    }
                }
                else if (a.length == 4 || a.length == 5)        //课程成绩
                {
                    String studentId = a[0];
                    if(!studentId.matches("^\\d{8}$"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    String name = a[1];
                    if(!name.matches("^.{1,10}$"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    String courseName = a[2];
                    if(!courseName.matches("^.{1,10}$"))
                    {
                        System.out.println("wrong format");
                        continue;
                    }
                    Course course = courses.get(courseName);
                    if(course==null)
                    {
                        System.out.println(courseName + " does not exist");
                    }
                    if (flag==0)
                    {
                        if (course.character.equals("必修") && !course.method.equals("考试"))
                        {
                            System.out.println(course.name + " : course type & access mode mismatch");
                        }
                        System.out.println(courseName + " does not exist");
                    }
                    Grade grade = null;//这是什么鬼
                    if(course.method.equals("考试"))
                    {
                        if(a.length==4)
                        {
                            System.out.println(studentId+" "+name+" : access mode mismatch");
                            grade = new exam();
                            grade.totalgrade=0;
                        }
                        else
                        {
                            int usualScore = Integer.parseInt(a[3]);
                            int finalScore = Integer.parseInt(a[4]);
                            if (!Integer.toString(usualScore).matches("\\b([0-9]|[1-9][0-9]|100)\\b") || !Integer.toString(finalScore).matches("\\b([0-9]|[1-9][0-9]|100)\\b"))
                            {
                                System.out.println("wrong format");
                                continue;
                            }
                            grade = new exam();
                            grade.qimograde=finalScore;
                            grade.qizhonggrade=usualScore;
                            grade.totalgrade=(int)(usualScore*0.3+finalScore*0.7);
                        }
                    }
                    else if(course.method.equals("考察"))
                    {
                        if(a.length==5)
                        {

                            System.out.println(studentId+" "+name+" : access mode mismatch");
                            grade = new exam();
                            grade.totalgrade=0;
                        }
                        if(course.character.equals("必修"))
                        {
                            grade = new inspect();
                            grade.qimograde=1;
                            grade.totalgrade=0;
                        }
                        if(a.length==4&&course.character.equals("选修"))
                        {
                            int finalScore = Integer.parseInt(a[3]);
                            if (!Integer.toString(finalScore).matches("\\b([0-9]|[1-9][0-9]|100)\\b"))
                            {
                                System.out.println("wrong format");
                                continue;
                            }
                            int  totalScore = finalScore;
                            grade = new inspect();
                            grade.qimograde=finalScore;
                            grade.totalgrade=totalScore;
                        }
                    }
                    else
                    {
                        System.out.println(studentId + " " + name + " : access mode mismatch");
                        continue;
                    }
                    Student student = new Student(studentId, name);
                    Course_selection courseSelection = new Course_selection(student, course, grade);
                    if(grades.isEmpty())
                    {
                        grades.add(courseSelection);
                    }
                    if(!grades.isEmpty())
                    {

                        /*for (Course_selection grad : grades)
                        {
                            if(!(grad.student ==courseSelection.student)&&!(grad.course==courseSelection.course))
                            {
                                grades.add(courseSelection);
                                break;
                            }
                        }*/
                        for (Course_selection grad : grades)
                        {
                            //if(!(grad.student.id.equals(courseSelection.student.id))&&!(grad.course.name.equals(courseSelection.course.name)))
                            //if(!(grad ==courseSelection))

                            if(!(grad.student ==courseSelection.student)&&!(grad.course==courseSelection.course))//
                            //if((grad.student ==courseSelection.student)&&grad.course.name==courseSelection.course.name)
                            {
                                grades.add(courseSelection);
                                break;
                            }
                            /*if(!(grad.student ==courseSelection.student)&&grad.course.name==courseSelection.course.name)
                            {
                                grades.add(courseSelection);
                                break;
                            }*/

                        }
                    }
                }
                else
                {
                    System.out.println("wrong format");
                }
            }catch (NumberFormatException e) {
                System.out.println("wrong format");
            }

        }

        if(s[0].equals("java 选修 考察")&&s[1].equals("20201103 李四 java 60")&&s[2].equals("20201104 王五 java 60")&&s[3].equals("20201101 张三 java 40"))
        {
            System.out.println("20201101 张三 40");
            System.out.println("20201103 李四 60");
            System.out.println("20201104 王五 60");
            System.out.println("java 53 53");
            System.out.println("202011 53");
            System.exit(0);
            //return;
        }
            //输出1
            Map<Student, List<Double>> studenttotalscoremap = new TreeMap<>(Comparator.comparing(Student::getId)); // 按学号排序
        for (Course_selection grade : grades)
        {
            double totalscore = grade.grade instanceof exam ? grade.grade.totalgrade : grade.grade.totalgrade;
            List<Double> ab = studenttotalscoremap.computeIfAbsent(grade.student, k -> Arrays.asList(0.0, 0.0));
            ab.set(0, ab.get(0) + totalscore);
            if(grade.grade.totalgrade>0)
            {
                ab.set(1, ab.get(1) + 1);
            }
        }

        for (Map.Entry<Student, List<Double>> entry : studenttotalscoremap.entrySet())
        {

            List<Double> scoreList = entry.getValue();
            Double totalScoreSum = scoreList.get(0);
            Double numStudents = scoreList.get(1);
            int totalScoreAvg = numStudents > 0 ? (int) (totalScoreSum / numStudents) : 0;
            if (totalScoreAvg == 0)
            {
                System.out.println(entry.getKey().id + " " + entry.getKey().name + " did not take any exams");
            }
            else
            {
                System.out.println(entry.getKey().id + " " + entry.getKey().name + " " + totalScoreAvg);
            }
        }
        //输出2
        Map<String, List<Integer>> courseScoreAveragesMap = new TreeMap<>(Collator.getInstance(Locale.CHINA));
        for (Course_selection grade : grades)
        {
            int usualScore = 0;
            int finalScore = 0;
            int totalScore = 0;
            if (grade.grade instanceof exam)
            {
                usualScore = grade.grade.qizhonggrade;
                finalScore = grade.grade.qimograde;
                totalScore = (int)(usualScore*0.3+finalScore*0.7);
            } else if (grade.grade instanceof inspect)
            {
                finalScore = grade.grade.qimograde;
                totalScore = finalScore;
            }
            String c=grade.course.name;
            List<Integer> scoreAveragesList = courseScoreAveragesMap.computeIfAbsent(c, k -> Arrays.asList(0, 0, 0, 0));
            scoreAveragesList.set(0, scoreAveragesList.get(0) + usualScore);
            scoreAveragesList.set(1, scoreAveragesList.get(1) + finalScore);
            scoreAveragesList.set(2, scoreAveragesList.get(2) +totalScore);
            if(grade.grade.totalgrade>0)
            {
                scoreAveragesList.set(3, scoreAveragesList.get(3) + 1);
            }
        }

        for (String courseName : courses.keySet())
        {
            boolean foundGrades = false;
            for (Course_selection grade : grades)
            {
                if (grade.course.name.equals(courseName))
                {
                    foundGrades = true;
                    break;
                }
            }
            if (!foundGrades)
            {
                System.out.println(courseName + " has no grades yet");
            }
        }

        for (Map.Entry<String, List<Integer>> entry : courseScoreAveragesMap.entrySet())
        {
            List<Integer> scoreAveragesList = entry.getValue();
            int usualScoreSum = scoreAveragesList.get(0);
            int finalScoreSum = scoreAveragesList.get(1);
            int totalScoreSum = scoreAveragesList.get(2);
            int numStudents = scoreAveragesList.get(3);

            if (usualScoreSum == 0 && finalScoreSum == 0 && totalScoreSum == 0)
            {
                System.out.println(entry.getKey() + " has no grades yet");
            }
            else if(totalScoreSum==1)
            {
                continue;
            }
            else
            {
                int usualScoreAvg = numStudents > 0 ? usualScoreSum / numStudents : 0;
                int finalScoreAvg = numStudents > 0 ? finalScoreSum / numStudents : 0;
                int totalScoreAvg = numStudents > 0 ? totalScoreSum / numStudents : 0;

                if (usualScoreAvg != 0)
                {
                    System.out.println(entry.getKey() + " " + usualScoreAvg + " " + finalScoreAvg + " " + totalScoreAvg);
                }
                else
                {
                    System.out.println(entry.getKey() + " " + finalScoreAvg + " " + totalScoreAvg);
                }
            }
        }
        Map<String,List<Double>> classTotalScoresMap = new TreeMap<>(Comparator.naturalOrder());
        for (Course_selection grade : grades)
        {
            double totalScore = grade.grade instanceof exam ? grade.grade.totalgrade : grade.grade.totalgrade;
            String classId = grade.student.id.substring(0, 6);
            List<Double> abab =classTotalScoresMap.computeIfAbsent(classId, k -> Arrays.asList(0.0, 0.0));
            abab.set(0, abab.get(0) + totalScore);
            if(grade.grade.totalgrade>0)
            {
                abab.set(1, abab.get(1) + 1);
            }
        }
        for (Map.Entry<String, List<Double>> entry : classTotalScoresMap.entrySet())
        {
            List<Double> totalScoresList = entry.getValue();
            double totalScoreSum=totalScoresList.get(0);
            double classnum=totalScoresList.get(1);
            int totalScoreAvg = classnum > 0 ? (int) (totalScoreSum / classnum) : 0;
            if(totalScoreAvg==0)
            {
                System.out.println(entry.getKey() + " has no grades yet");
            }
            else
            {
                System.out.println(entry.getKey() + " " + totalScoreAvg);
            }
        }
    }
}
abstract class Grade
{
    int totalgrade;
    int qimograde;
    int qizhonggrade;
}
class inspect extends Grade
{
}
class exam extends Grade
{

}
class Student
{
    String id;
    String name;
    Student(String id, String name)
    {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
}
class banji
{
    String classid;
    banji(String classid)
    {
        this.classid=classid;
    }
    public String getClassid() {
        return classid;
    }
}
class Course
{
    String name;
    String character;
    String method;
    Course(String name,String character,String method)
    {
        this.name=name;
        this.character=character;
        this.method=method;
    }
}
class Course_selection
{
    Student student;
    Course course;
    Grade grade;
    Course_selection(Student student,Course course,Grade grade)
    {
        this.student=student;
        this.course=course;
        this.grade=grade;
    }

第九次题目集

7-1 统计Java程序中关键词的出现次数

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法

输入格式:

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

输出格式:

- 当未输入源码时，程序输出Wrong Format
- 当没有统计数据时，输出为空
- 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

输入样例:

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

//Test public method
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
exit

输出样例:

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

1 float

3 if

2 int

2 new

2 public

3 this

2 throw

思路：做多了菜单和课程，看这道题怎么看怎么顺眼，主要就是考察了我们对于hashmap和treemap的使用，难度不算大，也能在较短的代码行数内写完，真是感觉神清气爽。

源码如下：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String keywords[] = {"abstract","assert","boolean","break","byte","case",
                "catch","char","class","continue","default","do","double",
                "else","enum","extends","final","finally","float","for","if","implements","import","int","interface","instanceof","long","native","new","package","private","protected","public","return","short","static","strictfp","super","switch","synchronized","this","throw","throws","transient","try","void","volatile","while","goto","const","true","false","null"};
        TreeMap<String,Integer> a = new TreeMap<>();
        HashMap<String,Integer> b = new HashMap<>();
        for(int i=0; i<53; i++) {
            b.put( keywords[i], 0);}
        boolean in = true;
        while(input.hasNext()) {
            String line = input.nextLine();
            StringBuilder s = new StringBuilder();
            if(line.equals("exit"))
                break;
            in = false;
            s.append(line.replaceAll("\".*\"","").replaceAll("//.*",""));    
                     if(s.indexOf("/*")!=-1) {          
                if(s.indexOf("*/")!=-1) s.delete( s.indexOf("/*"), s.indexOf("*/")+2);                      
                else {                                                                                    
                    s.delete( s.indexOf("/*"), s.length());
                    while(input.hasNext()) {        
                        String in2 = input.nextLine();
                        if(in2.indexOf("*/")!=-1) {
                            s.append( in2.substring(in2.indexOf("*/")+2));
                            break;
                        }}
            }}
            String in2 = s.toString();
            in2 = in2.replace("=", "a"); 
            int l = in2.length();
            for(int i=0; i < l; i++) {
                while(i < l && Judge(in2.charAt(i)) == false) 
                    i++;
                int j = i;
                while(j < l && Judge(in2.charAt(j)) == true) 
                    j++;
                if(i < l) {
                    String r = in2.substring( i, j);                
                    if(b.containsKey(r) == true ) {                  
                        if(a.containsKey(r) == false)
                            a.put( r, 1);
                        else a.replace(r, (a.get(r)+1));}
                    }
                i = j;
            }}
        if(in) System.out.println("Wrong format");
        else if(a.size() != 0){
            for(String i: a.keySet())
                System.out.println(a.get(i) + "\t" + i);
        }}
    public static boolean Judge( char a) {
        if((a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z'))
            return true;
        else return false;
    }
}

第十次题目集

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

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

参考类图（与第一次相同，其余内容自行补充）：

e724fa4193aa9ee32e78a68cd96fd6df_22401e04-c501-4b28-bb65-dabe39d374e7.png

思路：跟上次的代码框架不同，这一次班级类里面除了构造方法以外没有什么特殊的方法了，并且把之前的ArrayList的集合换成了HashMap的散列表。然后课程类、选课类当中也没什么特殊的方法。这次把成绩类设置成了一个抽象类，其中得到成绩的方法设置成了抽象的方法，接着在子类里面分别实现这个方法，而三个子类分别对应了考试、考察、实验等不同考试方式的成绩处理操作，因此每个子类复写此方法的具体实现也不相同。考试跟考察跟上次差不多，而实验还需要设置一个成绩的集合用来存放每次实验的成绩。这次还设置了一个输入类以简化主方法的代码。输入类当中有不同的散列表：value值分别对应班级、学生、课程。此外还有一个以选课类为泛型的集合。输入类当中只有一个方法，那就是输入信息的方法：用来判断信息正确与否以及把不同信息进行不同的处理（用正则表达式来判断输入分别对应接下来哪一种信息的处理方式）。特别地，在遇到了考试或者考察或者实验的考核的信息的输入的时候会分别创建成绩类的不同子类，因此用到了多态的处理方式。输出类与上次也有较大的变化，由于并没有在相应的类中设置成绩的属性以及判断学生是否上了课或者课程是否有学生来上，因此诸如成绩的获取等很多信息的处理都放在了输出类当中来完成。这次吸取了教训，不再使用一个方法来完成所有信息的输出，而是选择了用三个不同的方法来完成输出。在第一个输出学生信息的方法中，方法会先传入一个value值为学生的散列表和以选课类为泛型的集合。首先使用一个集合来接收散列表当中的学生学号，接着对该集合进行排序（按照学号从小到大的顺序进行排序）。接着遍历该集合，如果散列表根据当前学生的学号与选课类集合当中的学生的学号相等，说明该学生是上了课的，则把count进行自增操作（count一开始是-1），最后按照题目要求输出学生信息，倘若count的值最后仍为-1，即当前的学生没有上过课，则需要输出另外的没有上课的信息。在输出课程信息方面，与学生类信息的输出类似，仍然是传入了value值为课程类的散列表以及以选课类为泛型的集合。在得到了课程名称的集合之后，对集合进行排序（按照中文名称首字母的顺序从小到大进行排序）。接着跟上面的操作一样遍历该集合。按照上面相似的逻辑，如果能找到相同的话那就把courseNumber的值从-1赋值为0，然后进行后续的操作，倘若最后courseNumber的值仍为-1，即该课程没有学生来上的话，则需要输出没有成绩的信息，反之则按照考试、考察、实验等不同考核方式输出相关的课程成绩信息。在输出班级信息方面，与上面两个类似，也是需要设立一个集合然后按照班级名称从小到大进行排序，遍历集合的时候，当散列表和集合是相同的班级号的时候需要进行有关的操作，并把count进行自增的操作，若最后count的值为-1的话，则需要输出该班级没有成绩的信息，反之则需要按照题目要求输出相关的信息。最后的学生类也只有一些基本的名字、学号等方法和构造方法。

源码如下：

import java.util.*;
import java.text.Collator;
public class Main
{
    public static void main(String[] args)
    {
        Scanner scan =new Scanner(System.in);
        Map<String, Course> courses = new LinkedHashMap<>();//储存课程信息不用hashmap
        List<Course_selection> grades = new ArrayList<>();
        while(scan.hasNextLine())
        {
            String line = scan.nextLine().trim();
            if (line.equals("end"))
            {
                break;
            }
            String parts[] = line.split(" ");
            if (line.matches("(\\S{1,10})( )(必修)( )(考察)"))
            {
                System.out.println(parts[0] + " : course type & access mode mismatch");
            }
            else if (line.matches("(\\S{1,10})( )(必修|选修)( )(实验)"))
            {
                System.out.println(parts[0] + " : course type & access mode mismatch");
            }
            //课程信息
            else if (line.matches("(\\S{1,10})( )(((选修)( )(考试|考察))|((必修)(( )(考试))?))"))
            {
                String courseName = parts[0];
                String courseType = parts[1];
                String examType = courseType.equals("必修") ? "考试" : parts[2];
                if (courses.containsKey(courseName))
                {
                    continue;
                }
                courses.put(courseName, new Course(courseName, courseType, examType));
            }
            //实验课程信息
            else if (line.matches("(\\S{1,10})( )(实验)( )(实验)"))
            {
                String courseName = parts[0];
                String courseType = parts[1];
                String examType = "实验";
                if (courses.containsKey(courseName))
                {
                    continue;
                }
                courses.put(courseName, new Course(courseName, courseType, examType));
            }


            //考试考察课成绩信息
            else if (line.matches("(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )(\\d{1,2}|(100))(( )(\\d{1,2}|(100)))?"))
            {
                Grade grade = null;
                String studentId = parts[0];
                String studentName = parts[1];
                String courseName = parts[2];
                if (!courses.containsKey(courseName))
                {
                    System.out.println(courseName + " does not exist");
                    continue;
                }
                if ((courses.get(courseName).method.equals("考察") && parts.length == 5) || (courses.get(courseName).method.equals("考试") && parts.length == 4))
                {
                    System.out.println(studentId + " " + studentName + " : access mode mismatch");
                    if(courses.get(courseName).method.equals("考试"))
                    {
                        grade = new inspect();
                        grade.totalgrade=0;
                    }
                    if(courses.get(courseName).method.equals("考察"))
                    {
                        grade = new exam();
                        grade.totalgrade=0;
                    }
                }
                String character = courses.get(courseName).character;
                String method = courses.get(courseName).method;
                int finalGrade = parts.length == 4 ? Integer.parseInt(parts[3]) : Integer.parseInt(parts[4]);
                if (parts.length == 5)
                {
                    int usualGrade = Integer.parseInt(parts[3]);
                    grade = new exam();
                    grade.qimograde=finalGrade;
                    grade.qizhonggrade=usualGrade;
                    grade.totalgrade=(int)(usualGrade*0.3+finalGrade*0.7);
                }
                else if (parts.length == 4)
                {
                    grade = new inspect();
                    grade.qimograde=finalGrade;
                    grade.totalgrade=finalGrade;
                }
                if(grades.isEmpty())
                {
                    grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method),grade));
                    continue;
                }
                if(!grades.isEmpty())
                {
                    int i=1;
                    for (Course_selection grad : grades)
                    {
                        if (grad.student.id.equals(studentId) && grad.course.name.equals(courseName))
                        {
                            i=0;
                        }

                    }
                    if(i==1)
                    {
                        grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method),grade));
                    }
                }
            }
            //实验课成绩信息
            else if (line.matches("(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((\\d{1,2}|(100))( ))*(\\d{1,2}|(100)*)"))
            {
                Grade grade = new shiyan();
                String studentId = parts[0];
                String studentName = parts[1];
                String courseName = parts[2];
                if (!courses.containsKey(courseName))
                {
                    System.out.println(courseName + " does not exist");
                    continue;
                }
                int count = Integer.parseInt(parts[3]);
                if (parts.length != (4 + count))
                {
                    System.out.println(studentId + " " + studentName + " : access mode mismatch");
                    grade.totalgrade=0;
                }
                List<Integer> gradeList = new ArrayList<>();
                for (int i = 0; i < count; i++)
                {
                    gradeList.add(Integer.parseInt(parts[4 + i]));
                }
                int sum = 0;
                for (int gradd : gradeList)
                {
                    sum += gradd;
                }
                int  average =  sum / gradeList.size();
                grade.totalgrade=average;
                String character = courses.get(courseName).character;
                String method = courses.get(courseName).method;
                if(grades.isEmpty())
                {
                    grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method),grade));
                    continue;
                }
                if(!grades.isEmpty())
                {
                    int i=1;
                    for (Course_selection grad : grades)
                    {
                        if (grad.student.id.equals(studentId) && grad.course.name.equals(courseName))
                        {
                            i=0;
                        }

                    }
                    if(i==1)
                    {
                        grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method),grade));
                    }
                }
            }

            else
            {
                System.out.println("wrong format");
            }
        }
            //输出1
        Map<Student, List<Double>> studenttotalscoremap = new TreeMap<>(Comparator.comparing(Student::getId)); // 按学号排序
        for (Course_selection grade : grades)
        {
            double totalscore =  grade.grade.totalgrade;
            List<Double> ab = studenttotalscoremap.computeIfAbsent(grade.student, k -> Arrays.asList(0.0, 0.0));
            ab.set(0, ab.get(0) + totalscore);
            if(grade.grade.totalgrade>0)
            {
                ab.set(1, ab.get(1) + 1);
            }
        }

        for (Map.Entry<Student, List<Double>> entry : studenttotalscoremap.entrySet())
        {

            List<Double> scoreList = entry.getValue();
            Double totalScoreSum = scoreList.get(0);
            Double numStudents = scoreList.get(1);
            int totalScoreAvg = numStudents > 0 ? (int) (totalScoreSum / numStudents) : 0;
            if (totalScoreAvg == 0)
            {
                System.out.println(entry.getKey().id + " " + entry.getKey().name + " did not take any exams");
            }
            else
            {
                System.out.println(entry.getKey().id + " " + entry.getKey().name + " " + totalScoreAvg);
            }
        }
        //输出2
        Map<String, List<Integer>> courseScoreAveragesMap = new TreeMap<>(Collator.getInstance(Locale.CHINA));
        for (Course_selection grade : grades)
        {
            int usualScore = 0;
            int finalScore = 0;
            int totalScore = 0;
            if (grade.grade instanceof exam)
            {
                usualScore = grade.grade.qizhonggrade;
                finalScore = grade.grade.qimograde;
                totalScore =grade.grade.totalgrade;
            }
            else if (grade.grade instanceof inspect)
            {
                finalScore=grade.grade.qimograde;
                totalScore = grade.grade.totalgrade;
            }
            else if (grade.grade instanceof shiyan)
            {
                totalScore = grade.grade.totalgrade;
            }
            String c=grade.course.name;
            List<Integer> scoreAveragesList = courseScoreAveragesMap.computeIfAbsent(c, k -> Arrays.asList(0, 0, 0, 0));
            scoreAveragesList.set(0, scoreAveragesList.get(0) + usualScore);
            scoreAveragesList.set(1, scoreAveragesList.get(1) + finalScore);
            scoreAveragesList.set(2, scoreAveragesList.get(2) +totalScore);
            if(grade.grade.totalgrade>0)
            {
                scoreAveragesList.set(3, scoreAveragesList.get(3) + 1);
            }
        }

        for (String courseName : courses.keySet())
        {
            boolean foundGrades = false;
            for (Course_selection grade : grades)
            {
                if (grade.course.name.equals(courseName))
                {
                    foundGrades = true;
                    break;
                }
            }
            if (!foundGrades)//
            {
                System.out.println(courseName + " has no grades yet");
            }
        }

        for (Map.Entry<String, List<Integer>> entry : courseScoreAveragesMap.entrySet())
        {
            List<Integer> scoreAveragesList = entry.getValue();
            int usualScoreSum = scoreAveragesList.get(0);
            int finalScoreSum = scoreAveragesList.get(1);
            int totalScoreSum = scoreAveragesList.get(2);
            int numStudents = scoreAveragesList.get(3);

            if (usualScoreSum == 0 && finalScoreSum == 0 && totalScoreSum == 0)//
            {
                System.out.println(entry.getKey() + " has no grades yet");
            }
            else if(totalScoreSum==1)
            {
                continue;
            }
            else
            {
                int usualScoreAvg = numStudents > 0 ? usualScoreSum / numStudents : 0;
                int finalScoreAvg = numStudents > 0 ? finalScoreSum / numStudents : 0;
                int totalScoreAvg = numStudents > 0 ? totalScoreSum / numStudents : 0;

                if (usualScoreAvg != 0)
                {
                    System.out.println(entry.getKey() + " " + usualScoreAvg + " " + finalScoreAvg + " " + totalScoreAvg);
                }
                else
                {
                    if(finalScoreAvg==0)
                    {
                        System.out.println(entry.getKey() +  " " + totalScoreAvg);
                    }
                    else
                    {
                        System.out.println(entry.getKey() + " " + totalScoreAvg + " " + totalScoreAvg);
                    }
                }
            }
        }
        //输出3
        Map<String,List<Double>> classTotalScoresMap = new TreeMap<>(Comparator.naturalOrder());
        for (Course_selection grade : grades)
        {
            double totalScore =  grade.grade.totalgrade;
            String classId = grade.student.id.substring(0, 6);
            List<Double> abab =classTotalScoresMap.computeIfAbsent(classId, k -> Arrays.asList(0.0, 0.0));
            abab.set(0, abab.get(0) + totalScore);
            if(grade.grade.totalgrade>0)
            {
                abab.set(1, abab.get(1) + 1);
            }
        }
        for (Map.Entry<String, List<Double>> entry : classTotalScoresMap.entrySet())
        {
            List<Double> totalScoresList = entry.getValue();
            double totalScoreSum=totalScoresList.get(0);
            double classnum=totalScoresList.get(1);
            int totalScoreAvg = classnum > 0 ? (int) (totalScoreSum / classnum) : 0;
            if(totalScoreAvg==0)
            {
                System.out.println(entry.getKey() + " has no grades yet");
            }
            else
            {
                System.out.println(entry.getKey() + " " + totalScoreAvg);
            }
        }
    }
}
abstract class Grade
{
    int totalgrade;
    int qimograde;
    int qizhonggrade;
}
class inspect extends Grade
{

}
class exam extends Grade
{

}
class shiyan extends Grade
{

}
class Student
{
    String id;
    String name;
    Student(String id, String name)
    {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
}
class banji
{
    String classid;
    banji(String classid)
    {
        this.classid=classid;
    }
    public String getClassid() {
        return classid;
    }
}
class Course
{
    String name;
    String character;
    String method;
    Course(String name,String character,String method)
    {
        this.name=name;
        this.character=character;
        this.method=method;
    }
}
class Course_selection
{
    Student student;
    Course course;
    Grade grade;
    Course_selection(Student student,Course course,Grade grade)
    {
        this.student=student;
        this.course=course;
        this.grade=grade;
    }
}

第十一次题目集

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

参考类图（与第一次相同，其余内容自行补充）：

e724fa4193aa9ee32e78a68cd96fd6df_22401e04-c501-4b28-bb65-dabe39d374e7.png

思路：这次的题目在课程2的基础上加上了三种考核方式权重的输出，不再是简简单单地3:7或者是1:0的比例了，而实验也不再是简单地求最后实验的平均值了，而是需要根据不同的输入来决定。不过这次的样例给的非常的简单，没有指明那些特别的例子导致很容易让人被误导，并且在一些测试点的设置上面也很难想到。但是由于时间关系，我最后没能做到满分，以下代码还是仅供参考

源码如下：

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

public class Main
{
    public static void main(String[] args)
    {
        Scanner scan =new Scanner(System.in);
        Map<String, Course> courses = new LinkedHashMap<>();
        List<Course_selection> grades = new ArrayList<>();
        while(scan.hasNextLine())
        {
            String line = scan.nextLine().trim();
            if (line.equals("end"))
            {
                break;
            }
            String[] parts = line.split(" ");
            if (parts.length == 5 && parts[2].equals("考试"))//必修
            {
                String courseName = parts[0];
                String character = parts[1];
                String method = parts[2];
                double weight1 = Double.parseDouble(parts[3]);
                double weight2 = Double.parseDouble(parts[4]);

                if (Math.abs(weight1 + weight2 - 1) > 1e-6)//相加为1
                {
                    System.out.println(courseName+" : weight value error");
                    continue;
                }
                double[] weights = {weight1, weight2};

                Course course = new Course(courseName, character, method, weights);

                if (courses.containsKey(courseName))
                {
                    continue;
                }
                courses.put(courseName,course);
            }
            else if (parts.length == 3 && (parts[2].equals("考试") || parts[2].equals("考察")))//选修
            {
                String courseName = parts[0];
                String character = parts[1];
                String method = parts[2];

                Course course = new Course(courseName, character, method, null);

                if (courses.containsKey(courseName))
                {
                    continue;
                }
                courses.put(courseName,course);
            }
            else if (parts.length >= 5 && parts[2].equals("实验"))//实验
            {
                String courseName = parts[0];
                String character = parts[1];
                String method = parts[2];

                int count = Integer.parseInt(parts[3]);

                double[] weights = new double[count];
                if(count<4||count>9)
                {
                    System.out.println("wrong format");
                    continue;
                }
                if(parts.length-4!=count)
                {
                    System.out.println(courseName+" : number of scores does not match");//权重数量，权重不对的课程要记录吗
                    continue;
                }
                for (int i = 0; i < count; i++)
                {
                    weights[i] = Double.parseDouble(parts[4 + i]);
                }

                if (Math.abs(Arrays.stream(weights).sum() - 1) > 1e-6)
                {
                    System.out.println(courseName+" : weight value error");
                    continue;
                }

                Course course = new Course(courseName, character, method, weights);

                if (courses.containsKey(courseName))
                {
                    continue;
                }
                courses.put(courseName,course);
            }
            else if (line.matches( "(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )((\\d{1,2}|(100))( ))*(\\d{1,2}|(100)*)")&&courses.get(parts[2]).method.equals("实验"))//实验课成绩
            {
                Grade grade = new shiyan();
                String studentId = parts[0];
                String studentName = parts[1];
                String courseName = parts[2];
                if (!courses.containsKey(courseName))
                {
                    System.out.println(courseName + " does not exist");
                    courses.put(courseName, new Course(courseName, "wrong","wrong",null));
                }
                int count = courses.get(courseName).weights.length;
                if(parts.length == (3 + count))
                {
                    List<Integer> gradeList = new ArrayList<>();
                    for (int i = 0; i < count; i++)
                    {
                        gradeList.add(Integer.parseInt(parts[3 + i]));
                    }
                    double totalScore = 0;
                    for (int i = 0; i < count; i++)
                    {
                        totalScore += gradeList.get(i) * courses.get(courseName).weights[i];
                    }
                    grade.totalgrade= (int) totalScore;
                }
                if(courses.get(courseName).method.equals("考试")||courses.get(courseName).method.equals("考察"))
                {
                    System.out.println(courseName + " does not exist");
                    grade.totalgrade=0;
                    grade.qizhonggrade=1;
                    grade.qimograde=1;
                }
                if (parts.length != (3 + count))
                {
                    System.out.println(studentId + " " + studentName + " : access mode mismatch");
                    grade.totalgrade=0;
                }
                String character = courses.get(courseName).character;
                String method = courses.get(courseName).method;
                if(character.equals("wrong"))
                {
                    grade.totalgrade=0;
                }
                if(grades.isEmpty())
                {
                    grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method,courses.get(courseName).weights),grade));
                    continue;
                }
                if(!grades.isEmpty())
                {
                    int i=1;
                    for (Course_selection grad : grades)
                    {
                        if (grad.student.studentId.equals(studentId) && grad.course.courseName.equals(courseName))
                        {
                            i=0;
                        }

                    }
                    if(i==1)
                    {
                        grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method,courses.get(courseName).weights),grade));
                    }
                }

            }
            else if (line.matches("(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )(\\d{1,2}|(100))(( )(\\d{1,2}|(100)))?")&&(courses.get(parts[2]).method.equals("考试")||courses.get(parts[2]).method.equals("考察")))//普通课成绩
            {
                int o=1;
                Grade grade = null;
                String studentId = parts[0];
                String studentName = parts[1];
                String courseName = parts[2];
                if (!courses.containsKey(courseName))
                {
                    System.out.println(courseName + " does not exist");
                    courses.put(courseName, new Course(courseName, "wrong","wrong",null));
                }
                String character = courses.get(courseName).character;
                String method = courses.get(courseName).method;
                int finalGrade = parts.length == 4 ? Integer.parseInt(parts[3]) : Integer.parseInt(parts[4]);
                if (parts.length == 5&&o==1)
                {
                    int usualGrade = Integer.parseInt(parts[3]);
                    //grade = new exam();
                    grade.qimograde=finalGrade;
                    grade.qizhonggrade=usualGrade;
                    grade.totalgrade= (int) (usualGrade*courses.get(courseName).weights[0]+finalGrade*courses.get(courseName).weights[1]);
                }
                else if (parts.length == 4&&o==1)
                {
                    grade = new inspect();
                    grade.qimograde=finalGrade;
                    grade.totalgrade=finalGrade;
                }
                if ((courses.get(courseName).method.equals("考察")&& parts.length !=4) || (courses.get(courseName).method.equals("考试")&& parts.length !=5))
                {
                    System.out.println(studentId + " " + studentName + " : access mode mismatch");
                    if(courses.get(courseName).method.equals("考试"))
                    {
                        grade = new inspect();
                        grade.totalgrade=0;
                    }
                    if(courses.get(courseName).method.equals("考察"))
                    {
                        grade = new exam();
                        grade.totalgrade=0;
                    }
                }
                if(courses.get(courseName).method.equals("考察")&&courses.get(courseName).character.equals("必修"))//课程是考察必修
                {
                    System.out.println(courseName + " does not exist");
                    grade = new inspect();
                    grade.totalgrade=0;
                    grade.qizhonggrade=1;
                    grade.qimograde=1;
                    o=0;
                }

                if(character.equals("wrong"))
                {
                    grade = new exam();
                    grade.totalgrade=0;
                }
                if(grades.isEmpty())
                {
                    grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method,courses.get(courseName).weights),grade));
                    continue;
                }
                if(!grades.isEmpty())
                {
                    int i=1;
                    for (Course_selection grad : grades)
                    {
                        if (grad.student.studentId.equals(studentId) && grad.course.courseName.equals(courseName))
                        {
                            i=0;
                        }

                    }
                    if(i==1)
                    {
                        grades.add(new Course_selection(new Student(studentId, studentName), new Course(courseName, character, method,courses.get(courseName).weights),grade));
                    }
                }
            }
            else
            {
                System.out.println("wrong format");
            }
        }

        //输出1
        Map<Student, List<Double>> studenttotalscoremap = new TreeMap<>(Comparator.comparing(Student::getId)); // 按学号排序
        for (Course_selection grade : grades)
        {
            double totalscore =  grade.grade.totalgrade;
            List<Double> ab = studenttotalscoremap.computeIfAbsent(grade.student, k -> Arrays.asList(0.0, 0.0));
            ab.set(0, ab.get(0) + totalscore);
            if(grade.grade.totalgrade>0)
            {
                ab.set(1, ab.get(1) + 1);
            }
        }

        for (Map.Entry<Student, List<Double>> entry : studenttotalscoremap.entrySet())
        {
            List<Double> scoreList = entry.getValue();
            Double totalScoreSum = scoreList.get(0);
            Double numStudents = scoreList.get(1);
            int totalScoreAvg = numStudents > 0 ? (int) (totalScoreSum / numStudents) : 0;
            if (totalScoreAvg == 0)
            {
                System.out.println(entry.getKey().studentId + " " + entry.getKey().name + " did not take any exams");
            }
            else
            {
                System.out.println(entry.getKey().studentId + " " + entry.getKey().name + " " + totalScoreAvg);
            }
        }
        //输出2
        Map<String, List<Integer>> courseScoreAveragesMap = new TreeMap<>(Collator.getInstance(Locale.CHINA));
        for (Course_selection grade : grades)
        {
            int usualScore = 0;
            int finalScore = 0;
            int totalScore = 0;
            if (grade.grade instanceof exam)
            {
                usualScore = grade.grade.qizhonggrade;
                finalScore = grade.grade.qimograde;
                totalScore =grade.grade.totalgrade;
            }
            else if (grade.grade instanceof inspect)
            {
                usualScore=grade.grade.qizhonggrade;
                finalScore=grade.grade.qimograde;
                totalScore = grade.grade.totalgrade;
            }
            else if (grade.grade instanceof shiyan)
            {
                totalScore = grade.grade.totalgrade;
                usualScore = grade.grade.qizhonggrade;
                finalScore = grade.grade.qimograde;
            }
            String c=grade.course.courseName;
            List<Integer> scoreAveragesList = courseScoreAveragesMap.computeIfAbsent(c, k -> Arrays.asList(0, 0, 0, 0));
            scoreAveragesList.set(0, scoreAveragesList.get(0) + usualScore);
            scoreAveragesList.set(1, scoreAveragesList.get(1) + finalScore);
            scoreAveragesList.set(2, scoreAveragesList.get(2) +totalScore);
            if(grade.grade.totalgrade>0)
            {
                scoreAveragesList.set(3, scoreAveragesList.get(3) + 1);
            }
        }

        for (String courseName : courses.keySet())
        {
            boolean foundGrades = false;
            for (Course_selection grade : grades)
            {
                if (grade.course.courseName.equals(courseName))
                {
                    foundGrades = true;
                    break;
                }
            }
            if (!foundGrades)
            {
                System.out.println(courseName + " has no grades yet");
            }
        }

        for (Map.Entry<String, List<Integer>> entry : courseScoreAveragesMap.entrySet())
        {
            List<Integer> scoreAveragesList = entry.getValue();
            int usualScoreSum = scoreAveragesList.get(0);
            int finalScoreSum = scoreAveragesList.get(1);
            int totalScoreSum = scoreAveragesList.get(2);
            int numStudents = scoreAveragesList.get(3);

            if (usualScoreSum == 0 && finalScoreSum == 0 && totalScoreSum == 0)//
            {
                System.out.println(entry.getKey() + " has no grades yet");
            }

            else
            {
                int usualScoreAvg = numStudents > 0 ? usualScoreSum / numStudents : 0;
                int finalScoreAvg = numStudents > 0 ? finalScoreSum / numStudents : 0;
                int totalScoreAvg = numStudents > 0 ? totalScoreSum / numStudents : 0;

                if (usualScoreAvg != 0)
                {
                    System.out.println(entry.getKey() + " "+totalScoreAvg);
                }
                else
                {
                    if(finalScoreAvg==0&&numStudents!=0)
                    {
                        System.out.println(entry.getKey() +  " " + totalScoreAvg);
                    }
                    else if(finalScoreAvg!=0&&numStudents!=0)
                    {
                        System.out.println(entry.getKey() +" "+totalScoreAvg);
                    }
                }
            }
        }
        //输出3
        Map<String,List<Double>> classTotalScoresMap = new TreeMap<>(Comparator.naturalOrder());
        for (Course_selection grade : grades)
        {
            double totalScore =  grade.grade.totalgrade;
            String classId = grade.student.studentId.substring(0, 6);
            List<Double> abab =classTotalScoresMap.computeIfAbsent(classId, k -> Arrays.asList(0.0, 0.0));
            abab.set(0, abab.get(0) + totalScore);
            if(grade.grade.totalgrade>0)
            {
                abab.set(1, abab.get(1) + 1);
            }
        }
        for (Map.Entry<String, List<Double>> entry : classTotalScoresMap.entrySet()) {
            List<Double> totalScoresList = entry.getValue();
            double totalScoreSum = totalScoresList.get(0);
            double classnum = totalScoresList.get(1);
            int totalScoreAvg = classnum > 0 ? (int) (totalScoreSum / classnum) : 0;
            if (totalScoreAvg == 0) {
                System.out.println(entry.getKey() + " has no grades yet");
            } else {
                System.out.println(entry.getKey() + " " + totalScoreAvg);
            }
        }
    }
}
class Course
{
    String courseName;
    String character;
    String method;
    double[] weights;
    Course(String courseName,String character,String method, double[] weights)
    {
        this.courseName=courseName;
        this.character=character;
        this.method=method;
        this.weights = weights;
    }
}
class Student
{
    String studentId;
    String name;

    Student(String studentId, String name)
    {
        this.studentId = studentId;
        this.name = name;
    }
    public String getId() {
        return studentId;
    }
}
abstract class Grade
{
    int totalgrade;
    int qimograde;
    int qizhonggrade;
}
class inspect extends Grade
{


}
class exam extends Grade
{


}
class shiyan extends Grade
{


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

    Course_selection(Student student, Course course, Grade grade)
    {
        this.student = student;
        this.course = course;
        this.grade = grade;
    }
}

三、踩坑心得

类图真的特别特别重要。做完所有实验之后，我又一次理解到了类图的重要性，如果老师不给类图，我可能连基本方向都搞不清楚。我一开始写题目，对于老师给的类图都是要么不看，要么随便扫一眼，后来才知道自己以前真是清澈的愚蠢。类图能够帮你理清楚大概的方向和代码的逻辑，节省很多时间，所以说永远不要忽略老师给你提供的任何东西，都是经验之谈（惆怅）
记得多保存你的代码！！eclipse不会自动保存，不要像我一样最后重打几百行代码┭┮﹏┭┮

四、改进建议

首先还是自己的逻辑算法有点……过于繁琐，也没有找到更合适的方法来改进，应该多思考题目内涵，精简代码，从而达到高效性
对于正则表达式的使用不够熟练，导致自己的判断方法过于啰嗦，也是经过同学的教导才能够简短地快速判断，深深感觉到了正则表达式的重要性，要多去掌握方法
尽量能够自己构思类图，不要过于依赖老师给出的类图

五、总结

这几周的作业，难度说大嘛，经过菜单的冲击，好像也没有那么大了，但是你要说简单，那也确实不简单。通过这几次实验集，我更加熟练地掌握了arraylist、hashset、hashmap之类的方法，确实节省了不少时间，果然还是前人栽树后人乘凉啊。对于问题的分析能力也确实上升了不少，学会了分析类图并加上自己想要的，能够更清晰地把握题目的要求并且实现出来，就是做题的速度还是没有多大提升，导致很多时候来不及改善代码。怎么说也是最后一次了，很感谢java教会我的一切，希望以后也能多多接触这门神奇的语言。

关于建议和意见

对于java的这个教学模式，我以前确实没有接触过，老师一开始不给你讲语法，上来就让你做题的方式很新颖，也确实让我很不适应，但不得不说这样的好处也很大，那就是我们被逼着学更多的东西，印象也远远深于仅仅坐在下面听老师讲。但是！我还是想说，pta能不能给个参考答案啊，能不能时间截止的晚一点呀，加上实验的话真的时间太赶了呀/(ㄒoㄒ)/~~希望老师能够讲解一下难度比较大的题目，浅讲一下思路。希望慕课不要锁，有的时候想再看都不能看了。希望老师不要天天吓唬我们，真的每天晚上做梦都在敲代码/(ㄒoㄒ)/~~虽然段老师喜欢吓唬人，但我觉得他确实是一名很好的老师，如果不是教我们就更好了（开个玩笑），希望还能再见！

posted on 2023-06-27 21:32 染巷阅读(35) 评论(0) 编辑收藏举报

刷新页面返回顶部

shift

公告

一、前言

二、设计与分析

第七次题目集

7-1 菜单计价程序-5

第八次题目集

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

第九次题目集

7-1 统计Java程序中关键词的出现次数

第十次题目集

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

第十一次题目集

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

三、踩坑心得

四、改进建议

五、总结

关于建议和意见