本体大部分内容与菜单计价程序-3相同，增加的部分用加粗文字进行了标注。
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 份额 分数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的桌号从小到大的顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计（本内容与计价程序之前相同，其他类根据需要自行定义）：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号
Dish d;//菜品\\
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
本次课题比菜单计价系列-3增加的异常情况：
1、菜谱信息与订单信息混合，应忽略夹在订单信息中的菜谱信息。输出："invalid dish"
2、桌号所带时间格式合法（格式见输入格式部分说明，其中年必须是4位数字，月、日、时、分、秒可以是1位或2位数），数据非法，比如：2023/15/16 ，输出桌号＋" date error"
3、同一桌菜名、份额相同的点菜记录要合并成一条进行计算，否则可能会出现四舍五入的误差。
4、重复删除，重复的删除记录输出"deduplication :"+序号。
5、代点菜时，桌号不存在，输出"Table number ："+被点菜桌号+" does not exist"；本次作业不考虑两桌记录时间不匹配的情况。
6、菜谱信息中出现重复的菜品名，以最后一条记录为准。
7、如果有重复的桌号信息，如果两条信息的时间不在同一时间段，（时段的认定：周一到周五的中午或晚上是同一时段，或者周末时间间隔1小时（不含一小时整，精确到秒）以内算统一时段），此时输出结果按不同的记录分别计价。
8、重复的桌号信息如果两条信息的时间在同一时间段，此时输出结果时合并点菜记录统一计价。前提：两个的桌号信息的时间都在有效时间段以内。计算每一桌总价要先合并符合本条件的饭桌的点菜记录，统一计价输出。
9、份额超出范围（1、2、3）输出：序号+" portion out of range "+份额，份额不能超过1位，否则为非法格式，参照第13条输出。
10、份数超出范围，每桌不超过15份，超出范围输出：序号+" num out of range "+份数。份数必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
11、桌号超出范围[1,55]。输出：桌号 +" table num out of range"，桌号必须为1位或多位数值，最高位不能为0，否则按非法格式参照第16条输出。
12、菜谱信息中菜价超出范围（区间（0,300）），输出：菜品名+" price out of range "+价格，菜价必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
13、时间输入有效但超出范围[2022.1.1-2023.12.31]，输出："not a valid time period"
14、一条点菜记录中若格式正确，但数据出现问题，如：菜名不存在、份额超出范围、份数超出范围，按记录中从左到右的次序优先级由高到低，输出时只提示优先级最高的那个错误。
15、每桌的点菜记录的序号必须按从小到大的顺序排列（可以不连续，也可以不从1开始），未按序排列序号的输出："record serial number sequence error"。当前记录忽略。（代点菜信息的序号除外）
16、所有记录其它非法格式输入，统一输出"wrong format"
17、如果记录以“table”开头，对应记录的格式或者数据不符合桌号的要求，那一桌下面定义的所有信息无论正确或错误均忽略，不做处理。如果记录不是以“table”开头，比如“tab le 55 2023/3/2 12/00/00”，该条记录认为是错误记录，后面所有的信息并入上一桌一起计算。
本次作业比菜单计价系列-3增加的功能：
菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+基础价格+"T"
例如：麻婆豆腐 9 T
菜价的计算方法：
周一至周五 7折， 周末全价。
注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：
计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。
最后将所有记录的菜价累加得到整桌菜的价格。
输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 1 2
2 delete
2 delete
endimport java.util.*;
// 学生类
class Student {
private String studentId;
private String name;
public Student(String studentId, String name) {
this.studentId = studentId;
this.name = name;
}
public String getStudentId() {
return studentId;
}
public String getName() {
return name;
}
}
// 课程类
class Course {
private String courseName;
private String courseType;
private String assessmentMode;
public Course(String courseName, String courseType, String assessmentMode) {
this.courseName = courseName;
this.courseType = courseType;
this.assessmentMode = assessmentMode;
}
public String getCourseName() {
return courseName;
}
public String getCourseType() {
return courseType;
}
public String getAssessmentMode() {
return assessmentMode;
}
}
// 成绩类
abstract class Score {
private int score;
private String course;
public String getCourse() {
return course;
}
public Score setCourse(String course) {
this.course = course;
return this;
}
public Score(int score, String course) {
this.score = score;
this.course = course;
}
public int getScore() {
return score;
}
public Score setScore(int score) {
this.score = score;
return this;
}
public abstract int calculateTotalScore();
}
// 考试成绩类
class ExamScore extends Score {
private int ordinaryScore;
private int finalScore;
public ExamScore(String course, int ordinaryScore, int finalScore) {
super((int) (ordinaryScore * 0.3 + finalScore * 0.7), course);
this.ordinaryScore = ordinaryScore;
this.finalScore = finalScore;
}
public int getOrdinaryScore() {
return ordinaryScore;
}
public ExamScore setOrdinaryScore(int ordinaryScore) {
this.ordinaryScore = ordinaryScore;
return this;
}
public int getFinalScore() {
return finalScore;
}
public ExamScore setFinalScore(int finalScore) {
this.finalScore = finalScore;
return this;
}
@Override
public int calculateTotalScore() {
return getScore();
}
}
// 考察成绩类
class ReviewScore extends Score {
public int ordinaryScore;
public int getOrdinaryScore() {
return ordinaryScore;
}
public ReviewScore setOrdinaryScore(int ordinaryScore) {
this.ordinaryScore = ordinaryScore;
return this;
}
public ReviewScore(String course, int ordinaryScore, int score) {
super(score, course);
this.ordinaryScore = ordinaryScore;
}
@Override
public int calculateTotalScore() {
return getScore();
}
}
// 实验成绩类
class LabScore extends Score {
private List<Integer> Score;
public LabScore(String course, List<Integer> score) {
super(score.stream().reduce(Integer::sum).orElse(0) / score.size(), course);
}
@Override
public int calculateTotalScore() {
return getScore();
}
}
// 主程序类
public class Main {
private Map<String, Student> students;
private Map<String, Course> courses;
private Map<String, List<Score>> scores;
public Main() {
students = new HashMap<>();
courses = new HashMap<>();
scores = new HashMap<>();
}
public void processInput(String input) {
String[] tokens = input.split(" ");
String type = tokens[0];
if (type.matches("[0-9]+")) {
processScore(tokens);
} else if (type.equals("end")) {
calculateGrades();
} else {
processCourse(tokens);
}
// switch (type) {
// case "java":
// case "C语言":
// case "编译原理":
// processCourse(tokens);
// break;
// case "end":
// calculateGrades();
// break;
// default:
// processScore(tokens);
// break;
// }
}
private void processCourse(String[] tokens) {
String courseName = tokens[0];
String courseType = tokens[1];
String assessmentMode = tokens[2];
if (courseType.equals("必修") && !assessmentMode.equals("考试")) {
System.out.println(courseName + " : course type & access mode mismatch");
return;
}
if (courseType.equals("考察") && assessmentMode.equals("实验")) {
System.out.println(courseName + " : course type & access mode mismatch");
return;
}
if (courseType.equals("实验") && !assessmentMode.equals("实验")) {
System.out.println(courseName + " : course type & access mode mismatch");
return;
}
if(courses.get(courseName)==null) {
Course course = new Course(courseName, courseType, assessmentMode);
courses.put(courseName, course);
}
}
private void processScore(String[] tokens) {
String studentId = tokens[0];
String name = tokens[1];
String courseName = tokens[2];
boolean b = true;
for (int i = 3; i < tokens.length; i++) {
String token = tokens[i];
int i1 = Integer.parseInt(token);
if (i1 > 100 || i1 < 0) {
System.out.println("wrong format");
b = false;
return;
}
}
if (tokens.length > 5) {
int testNumber = Integer.parseInt(tokens[3]);
if (testNumber < 4 || testNumber > 9) {
System.out.println("wrong format");
b = false;
return;
}
Course course = courses.get(courseName);
if (course == null) {
System.out.println(studentId + " " + name + " : " + courseName + " does not exist");
return;
}
if (tokens.length - 4 != testNumber) {
System.out.println(studentId + " " + name + " : access mode mismatch");
Student student = students.get(studentId);
if (student == null) {
student = new Student(studentId, name);
students.put(studentId, student);
}
return;
}
}
if (b) {
Student student = students.get(studentId);
if (student == null) {
student = new Student(studentId, name);
students.put(studentId, student);
}
}
Course course = courses.get(courseName);
if (course == null) {
System.out.println(studentId + " " + name + " : " + courseName + " does not exist");
return;
}
String courseType = course.getCourseType();
String assessmentMode = course.getAssessmentMode();
int numScores = tokens.length - 3;
if (courseType.equals("必修") && numScores != 2) {
System.out.println(studentId + " " + name + " : access mode mismatch");
}
if ((numScores > 2 || numScores < 1) && (assessmentMode.equals("考察"))) {
System.out.println(studentId + " " + name + " : access mode mismatch");
}
List<Score> scoreList = scores.get(studentId);
if (scoreList == null) {
scoreList = new ArrayList<>();
scores.put(studentId, scoreList);
}
switch (assessmentMode) {
case "考试":
int ordinaryScore = Integer.parseInt(tokens[3]);
int finalScore = Integer.parseInt(tokens[4]);
ExamScore examScore = new ExamScore(courseName, ordinaryScore, finalScore);
scoreList.add(examScore);
break;
case "考察":
if (numScores == 1) {
int reviewScore = Integer.parseInt(tokens[3]);
scoreList.add(new ReviewScore(courseName, 0, reviewScore));
} else {
int ordinaryScores = Integer.parseInt(tokens[3]);
int reviewScore = Integer.parseInt(tokens[4]);
scoreList.add(new ReviewScore(courseName, ordinaryScores, reviewScore));
}
break;
case "实验":
List<Integer> labScores = new ArrayList<>();
for (int i = 4; i < tokens.length; i++) {
int labScore = Integer.parseInt(tokens[i]);
labScores.add(labScore);
}
scoreList.add(new LabScore(courseName, labScores));
break;
}
}
private void calculateGrades() {
List<String> studentIds = new ArrayList<>(students.keySet());
Collections.sort(studentIds);
for (String studentId : studentIds) {
Student student = students.get(studentId);
List<Score> scoreList = scores.get(studentId);
if (scoreList == null || scoreList.isEmpty()) {
System.out.println(studentId + " " + student.getName() + " did not take any exams");
continue;
}
int totalScore = calculateTotalScore(scoreList);
int averageScore = totalScore / scoreList.size();
System.out.println(studentId + " " + student.getName() + " " + averageScore);
}
List<String> courseNames = new ArrayList<>(courses.keySet());
Collections.sort(courseNames);
for (String courseName : courseNames) {
Course course = courses.get(courseName);
String courseType = course.getCourseType();
String assessmentMode = course.getAssessmentMode();
List<Integer> examScores = new ArrayList<>();
List<Integer> ordinaryScores = new ArrayList<>();
List<Integer> totalScores = new ArrayList<>();
List<Integer> labScores = new ArrayList<>();
for (String studentId : scores.keySet()) {
List<Score> scoreList = scores.get(studentId);
Score score = findScoreByCourse(scoreList, courseName);
if (score == null) {
continue;
}
if (score instanceof ExamScore) {
ExamScore examScore = (ExamScore) score;
examScores.add(examScore.getFinalScore());
ordinaryScores.add(examScore.getOrdinaryScore());
totalScores.add(examScore.getScore());
} else if (score instanceof ReviewScore) {
ReviewScore reviewScore = (ReviewScore) score;
ordinaryScores.add(reviewScore.getOrdinaryScore());
examScores.add(reviewScore.getScore());
} else if (score instanceof LabScore) {
LabScore labScore = (LabScore) score;
labScores.add(labScore.getScore());
}
}
//
int averageExamScore = calculateAverage(examScores);
int averageOrdinaryScore = (calculateAverage(ordinaryScores) != 0) ? calculateAverage(ordinaryScores) : calculateAverage(examScores);
int averageLabScore = calculateAverage(labScores);
int averageTotalScore = calculateAverage(totalScores);
if (assessmentMode.equals("考试")) {
System.out.println(courseName + " " + averageOrdinaryScore + " " + averageExamScore + " " + averageTotalScore);
} else if (assessmentMode.equals("考察")) {
System.out.println(courseName + " " + averageOrdinaryScore + " " + averageExamScore);
} else if (assessmentMode.equals("实验")) {
System.out.println(courseName + " " + (averageLabScore != 0 ? averageLabScore : "has no grades yet"));
}
}
List<String> classIds = getClassIds();
Collections.sort(classIds);
for (String classId : classIds) {
List<String> studentsInClass = getStudentsInClass(classId);
int totalScore = 0;
int count = 0;
for (String studentId : studentsInClass) {
List<Score> scoreList = scores.get(studentId);
if (scoreList != null) {
for (Score score : scoreList) {
totalScore += score.getScore();
count++;
}
}
}
if (count > 0) {
int averageScore = totalScore / count;
System.out.println(classId + " " + averageScore);
} else {
System.out.println(classId + " has no grades yet");
}
}
}
private Score findScoreByCourse(List<Score> scoreList, String courseName) {
for (Score score : scoreList) {
if (score.getCourse().equals(courseName)) {
return score;
}
}
return null;
}
private int calculateTotalScore(List<Score> scoreList) {
int totalScore = 0;
for (Score score : scoreList) {
totalScore += score.getScore();
}
return totalScore;
}
private int calculateAverage(List<Integer> scores) {
int total = 0;
if (scores.size() != 0) {
for (int score : scores) {
total += score;
}
return total / scores.size();
}
return 0;
}
private List<String> getClassIds() {
List<String> classIds = new ArrayList<>();
for (String studentId : students.keySet()) {
String classId = studentId.substring(0, 6);
if (!classIds.contains(classId)) {
classIds.add(classId);
}
}
return classIds;
}
private List<String> getStudentsInClass(String classId) {
List<String> studentsInClass = new ArrayList<>();
for (String studentId : students.keySet()) {
if (studentId.startsWith(classId)) {
studentsInClass.add(studentId);
}
}
return studentsInClass;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Main scoreStatistics = new Main();
StringBuffer stringBuffer = new StringBuffer();
while (scanner.hasNextLine()) {
String input = scanner.nextLine();
stringBuffer.append(input).append("\n");
if (input.equals("end")) {
break;
}
}
scoreStatistics.processAllInput(stringBuffer.toString());
}
private void processAllInput(String allInput) {
String[] input = allInput.split("\n");
for (String s : input) {
processInput(s);
}
}
}