题目集1~3的总结性Blog-526互联

前言：

到目前为止，本人已经完成了三次Java编程习题作业，逐步掌握Java语言的各种特性和用法。在三次题目集中，我学习了Java编程语言的各种知识点，包括条件语句、循环结构、数组、字符串处理、面向对象编程等。总体来说，题目集分为基础、进阶和高级部分，难度逐步增加，涵盖了Java编程的各个方面。完成编程练习题可以锻炼解决问题的能力，在解答问题的过程中，需要分析问题、设计解决方案，并将其转化为可执行的代码。

第一次作业：本次作业有9道练习题，看似很多，但都是比较简单的题目，主要让我们熟悉常用的语句，如：if，switch，for......。通过本次作业熟悉了Java编程的框架以及基础语句。

第二次作业：本次作业有8 道练习题，题目难度有所上升，编写代码所花费的时间也更长。在这次作业里主要学习内容是类的封装，之前并没有接触过，所以在最开始花费了部分时间理解该内容，类的封装指的是将数据和操作封装在一个类内部，对外部提供公共的接口方法来访问和修改内部数据。在练习过后，逐渐了解类的封装，编写速度较最开始提升了不少，也知道了进行封装的好处，封装可以隐藏类的内部实现细节，只暴露必要的接口。这样可以增强代码的安全性，防止外部误操作导致数据错误或不一致。同时，封装也方便了类的维护和修改，因为只需要关注公共接口是否需要调整，而不会影响到外部的使用。封装提供了良好的抽象层次，使得类的使用者只需要关注类的功能和使用方法，而不需要了解具体的实现细节。这降低了代码的复杂度，提高了代码的可读性和可维护性。封装还可以实现数据的访问控制，通过将类的属性设置为私有，只能通过公共的接口方法来进行读写操作。这样可以确保数据的合法性和一致性，避免了外部直接修改数据导致的错误。在部分题目中需要调用Java的一些库函数，也花费了部分时间去了解，并学习如何使用。通过本次作业熟悉了Java编程中类的封装以及库函数的调用和使用方法。

第三次作业：本次作业有4道练习题，其中部分题目与第二次作业相同，题目量虽然很少，但难度进一步上升。在类逐步增多的情况下，容易不知从何下手，对本人来说是个挑战。

设计与分析：

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

创建学生类，包含

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

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

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

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

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

输入格式:
5个学生信息，每个学生信息格式：

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

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:
5个学生信息，每个学生信息格式：

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

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

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

22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：

22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.util.Scanner;
import java.text.DecimalFormat;
class Student {
    private String id;
    private String name;
    private int[] scores;
    public Student(String id, String name, int[] scores) {
        this.id = id;
        this.name = name;
        this.scores = scores;
    }
    public String getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public int countSum() {
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        return sum;
    }
    public double countAverage() {
        int sum = countSum();
        double average = (double) sum / scores.length;
        return average;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Student[] students = new Student[5];
   for (int i = 0; i < students.length; i++) {
            String line = input.nextLine();
            String[] parts = line.split(" ");
            String id = parts[0];
            String name = parts[1];
            int[] scores = new int[3];
            scores[0] = Integer.parseInt(parts[2]);
            scores[1] = Integer.parseInt(parts[3]);
            scores[2] = Integer.parseInt(parts[4]);
            students[i] = new Student(id, name, scores);
        }
         DecimalFormat df = new DecimalFormat("0.00");
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].getId() + " " + students[i].getName() + " " + students[i].countSum() + " " + df.format(students[i].countAverage()));
        }
    }
}

这是一个学生成绩统计程序，定义了一个Student类，用于存储学生的学号、姓名和分数，通过构造方法初始化这些属性。Student类还提供了一些方法，如getId()获取学号、getName()获取姓名、countSum()计算总分以及countAverage()计算平均分。在Main类的main方法中，首先创建了一个长度为5的students数组，用于存储学生对象。然后通过循环逐个读取用户输入的学生信息，并将其存储到Student对象中。其中，通过Scanner类读取一行输入，并使用空格分割成不同的部分，分别表示学号、姓名和三个分数。然后将这些信息传递给Student类的构造方法，创建一个新的Student对象，并将其存储到students数组中。接下来，使用DecimalFormat类创建了一个格式化实例df，用于将平均分保留两位小数输出。最后，通过循环遍历students数组，依次输出每个学生的学号、姓名、总分和平均分，使用getId()、getName()、countSum()和countAverage()方法获取相应的信息。这段代码实现了学生信息的输入和统计，并将结果输出到控制台。它使用了面向对象的思想，通过封装学生的属性和方法在Student类中，实现了数据与操作的分离，提高了代码的可读性和可维护性。

7-2 成绩计算-2-关联类
分数 10

全屏浏览题目

切换布局
作者蔡轲
单位南昌航空大学
创建成绩类，包含：

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

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

创建学生类，包含：

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

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

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

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

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

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

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

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

例如：
22201311 张琳语文 70 80

22201311 张琳数学 85 89

22201311 张琳物理 75 83

22201312 黄昊语文 66 78

22201312 黄昊数学 76 82

22201312 黄昊物理 83 82

22201313 李少辰语文 86 76

22201313 李少辰数学 78 76

22201313 李少辰物理 87 76

输出格式:
3个学生信息，每个学生信息格式：

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

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

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

22201311 张琳语文 70 80
22201311 张琳数学 85 89
22201311 张琳物理 75 83
22201312 黄昊语文 66 78
22201312 黄昊数学 76 82
22201312 黄昊物理 83 82
22201313 李少辰语文 86 76
22201313 李少辰数学 78 76
22201313 李少辰物理 87 76
输出样例:
在这里给出相应的输出。例如：

22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Student[] student = new Student[3];
for (int i = 0; i < 9; i++) {
String line = input.nextLine();
String[] parts = line.split(" ");
String id = parts[0];
String name = parts[1];
Score chinese = null;
Score math = null;
Score physics = null;
for (int j = 2; j < parts.length; j+=4) {
String courseName = parts[j];
int dailygrade = Integer.parseInt(parts[j + 1]);
int finalgrade = Integer.parseInt(parts[j + 2]);
switch (courseName) {
case "语文" : chinese = new Score(dailygrade, finalgrade);
case "数学" : math = new Score(dailygrade, finalgrade);
case "物理" : physics = new Score(dailygrade, finalgrade);
}
}
int m = i%3;
student[m] = new Student(id, name, chinese, math, physics);
}
for (int i = 0; i < student.length; i++) {
if (student[i] != null) {
student[i].print();
}
}
}
}

class Score {
public int dailygrade;
public int finalgrade;

public Score(int dailygrade, int finalgrade) {
this.dailygrade = dailygrade;
this.finalgrade = finalgrade;
}

public int countSumgrade() {
return (int) Math.floor(dailygrade * 0.4 + finalgrade * 0.6);
}
}

class Student {
private String id;
private String name;
private Score chinese;
private Score math;
private Score physics;

public Student(String id, String name, Score chinese, Score math, Score physics) {
this.id = id;
this.name = name;
this.chinese = chinese;
this.math = math;
this.physics = physics;
}

public int countSumscore() {
int sum = 0;
if (chinese != null) {
sum += chinese.countSumgrade();
}
if (math != null) {
sum += math.countSumgrade();
}
if (physics != null) {
sum += physics.countSumgrade();
}
return sum;
}
public int countdailyscore() {
int sum = 0;
if (chinese != null) {
sum += chinese.dailygrade;
}
if (math != null) {
sum += math.dailygrade;
}
if (physics != null) {
sum += physics.dailygrade;
}
return sum;
}
public int countfinalscore() {
int sum = 0;
if (chinese != null) {
sum += chinese.finalgrade;
}
if (math != null) {
sum += math.finalgrade;
}
if (physics != null) {
sum += physics.finalgrade;
}
return sum;
}
public double countAveragescore() {
double sum = countSumscore();
int count = 0;
if (chinese != null) {
count++;
}
if (math != null) {
count++;
}
if (physics != null) {
count++;
}
return sum / count;
}
public double countdailyAveragescore() {
double sum = countdailyscore();
int count = 0;
if (chinese != null) {
count++;
}
if (math != null) {
count++;
}
if (physics != null) {
count++;
}
return sum / count;
}
public double countfinalAveragescore() {
double sum = countfinalscore();
int count = 0;
if (chinese != null) {
count++;
}
if (math != null) {
count++;
}
if (physics != null) {
count++;
}
return sum / count;
}
public void print() {
System.out.println(id + " " + name + " " + countSumscore() + " " + String.format("%.2f", countdialyAveragescore()) + " " + String.format("%.2f", countfianlAveragescore()) + " " + String.format("%.2f", countAveragescore()));
}
}

这是一个学生成绩管理系统，通过输入学生信息和各科成绩，计算并输出学生的总分、平均分和各科的平均分。首先，在主函数中创建了一个Scanner对象用于输入数据。然后创建了一个长度为3的Student数组，用于存储学生信息。接下来通过循环进行输入，并使用split方法将输入的一行数据按空格切分成多个部分。其中，parts[0]存储学生的id，parts[1]存储学生的姓名，从parts[2]开始每4个为一组，依次为科目名称、日常成绩、期末成绩。使用switch语句根据科目名称初始化对应的Score对象（chinese、math、physics）。然后，根据循环变量i对3取余，确定当前学生信息要存储在student数组的哪个位置。循环结束后，再次遍历student数组，如果元素不为null，则调用print方法输出学生的信息。在Score类中，定义了dailygrade和finalgrade两个成员变量，以及构造函数和countSumgrade方法用于计算总成绩。在Student类中，定义了id、name、chinese、math和physics等成员变量，以及构造函数和多个计算成绩的方法。countSumscore方法用于计算学生的总成绩，countdailyscore方法用于计算学生的日常成绩之和，countfinalscore方法用于计算学生的期末成绩之和，countAveragescore方法用于计算学生的平均成绩，countdailyAveragescore方法用于计算学生的日常成绩平均分，countfinalAveragescore方法用于计算学生的期末成绩平均分，print方法用于输出学生的信息。最后，使用String.format方法控制输出格式，保留两位小数，输出学生的id、name、总分、日常成绩平均分、期末成绩平均分和平均成绩。

7-7 菜单计价程序-1
分数 30

全屏浏览题目

切换布局
作者蔡轲
单位南昌航空大学
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

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

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

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

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

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

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

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

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

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

麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：

48
输入样例1:
订单中包含不存在的菜品记录。例如：

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：

炒脆肚 does not exist
48
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.util.Scanner;
class Dish {
    String name; // 菜品名称
    int unit_price; // 单价

    int getPrice(int portion) { // 计算菜品价格的方法
        double price = unit_price;
        if (portion == 2) {
            price *= 1.5;
        } else if (portion == 3) { 
            price *= 2;
        }
        return (int) Math.round(price); // 四舍五入取整
    }
}

class Menu {
    Dish[] dishes; // 菜品数组
    Dish searchDish(String dishName) { // 根据菜名在菜谱中查找菜品信息
        for (Dish dish : dishes) {
            if (dish.name.equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
}

class Record {
    Dish dish; // 菜品
    int portion; // 份额
    int getPrice() { // 计价，计算本条记录的价格
        return dish.getPrice(portion);
    }
}

class Order {
    Record[] records; // 订单上每一道的记录
     int getTotalPrice() { // 计算订单的总价
     int totalPrice = 0;
     for (Record record : records) {
         if (record != null && record.dish != null) {
         totalPrice += record.getPrice();
        }
        }
        return totalPrice;
    }

    Record addARecord(Menu menu,String dishName, int portion) { // 添加一条菜品信息到订单中
        Dish dish = menu.searchDish(dishName);
        if (dish == null) {
            System.out.println(dishName + " does not exist");
            return null;
        } else {
            Record record = new Record();
            record.dish = dish;
            record.portion = portion;
            return record;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Menu menu = new Menu();
        menu.dishes = new Dish[4];

        Dish dish1 = new Dish();
        dish1.name = "西红柿炒蛋";
        dish1.unit_price = 15;
        menu.dishes[0] = dish1;

        Dish dish2 = new Dish();
        dish2.name = "清炒土豆丝";
        dish2.unit_price = 12;
        menu.dishes[1] = dish2;

        Dish dish3 = new Dish();
        dish3.name = "麻婆豆腐";
        dish3.unit_price = 12;
        menu.dishes[2] = dish3;

        Dish dish4 = new Dish();
        dish4.name = "油淋生菜";
        dish4.unit_price = 9;
        menu.dishes[3] = dish4;

        Order order = new Order();
        order.records = new Record[10];

        Scanner scanner = new Scanner(System.in);
        int i = 0;
        while (true) {
            String input = scanner.nextLine().trim();
            if (input.equals("end")) {
                break;
            }
            String[] inputs = input.split(" ");
            String dishName = inputs[0];
            int portion = Integer.parseInt(inputs[1]);
            Record record = order.addARecord(menu, dishName, portion);
            if (record != null) {
                order.records[i] = record;
                i++;
            }
        }
        int totalPrice = order.getTotalPrice();
        System.out.println(totalPrice);
    }
}

这是一个简单的餐厅点餐系统，包含了菜单、菜品、订单等多个类。首先定义了Dish（菜品）、Menu（菜单）、Record（记录）和Order（订单）等几个类。Dish类中包含了菜品的名称和单价，以及计算菜品价格的方法。Menu类中包含了菜品数组，可以根据菜名在菜谱中查找菜品信息。Record类中包含了菜品和份额，可以计算本条记录的价格。Order类中包含了多条记录，可以计算订单的总价。其中，addARecord方法用于添加一条菜品信息到订单中。在main函数中创建了一个菜单menu和一个订单order。然后使用Scanner对象进行输入，通过循环获取每个顾客所点的菜品和份额，并且添加到order的记录数组中。当输入"end"时结束循环，调用order.getTotalPrice方法计算订单的总价，并输出到控制台。

7-2 课程成绩统计程序-1
分数 65

全屏浏览题目

切换布局
作者蔡轲
单位南昌航空大学
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

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

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

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

1、输入：

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

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

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

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

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

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

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

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

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

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图：

输入样例1:
仅有课程。例如：

java 必修考试
数据结构选修考试
形式与政治选修考察
end
输出样例1:
在这里给出相应的输出。例如：

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet
输入样例2:
单门考试课程单个学生。例如：

java 必修考试
20201103 张三 java 20 40
end
输出样例2:
在这里给出相应的输出。例如：

20201103 张三 34
java 20 40 34
202011 34
输入样例3:
单门考察课程单个学生。例如：

java 选修考察
20201103 张三 java 40
end
输出样例3:
在这里给出相应的输出。例如：

20201103 张三 40
java 40 40
202011 40
输入样例4:
考试课程单个学生不匹配的考核方式。例如：

java 必修考试
20201103 张三 java 20
end
输出样例4:
在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修考察
20201103 张三 java 40
end
输出样例5:
在这里给出相应的输出。例如：

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：

java 选修考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end
输出样例6:
在这里给出相应的输出。例如：

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治必修考试
数据库选修考试
java 选修考察
数据结构选修考察
20201103 李四数据结构 70
20201103 李四形式与政治 80 90
20201103 李四 java 60
20201103 李四数据库 70 78
end
输出样例7:
在这里给出相应的输出。例如：

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：

数据结构选修考察
20201103 李四数据结构 101
end
输出样例8:
在这里给出相应的输出。例如：

wrong format
数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：

形式与政治必修考试
数据库选修考试
java 选修考察
数据结构选修考察
20201205 李四数据结构 70
20201103 李四形式与政治 80 90
20201102 王五 java 60
20201211 张三数据库 70 78
end
输出样例9:
在这里给出相应的输出。例如：

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72
代码长度限制
16 KB
时间限制
1000 ms
内存限制
64 MB

import java.util.Scanner;
import java.util.concurrent.ExecutionException;
class CourseSelect {
    private Course course;
    private Student student;
    private Abstract score;
}
class Course {
    private String courseName;
    private String curriculum;
    private String method;
    public Course(String courseName, String curriculum, String method){
        this.courseName = courseName;
        this.curriculum = curriculum;
        this.method = method;
    }
    public String getCourseName(){
            return courseName;
    }
    public String getCurriculum(){
        return curriculum;
    }
    public String getMethod(){
        return method;
        }
    }
    class Abstract {
    private TestScore Tscore;
    private ReviewScore Rscore;

    }
    class TestScore {
            private int Dscore;
            private int Fscore;
            public int countScore() {
                return (int)Math.floor(Dscore*0.3+Fscore*0.7);
            }
        }
        class ReviewScore {

        }

    class Class {
        private String[] students;
        private String classId;

    }

    class Student {
        private String studentId;
        private String name;
        public Student(String studentId,String name){
            this.studentId = studentId;
            this.name = name;
        }

    }
class CheckInput {
    public void parseInput(String line) {
        
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        CheckInput checkInput = new CheckInput();
        while (!checkInput.equals("end")) {
            checkInput.parseInput(line);
            line = sc.nextLine();
        }
    }
}

这是一个学生选课系统，包含了课程、学生、成绩等相关类，以及一个用于检查输入的类CheckInput。CourseSelect类表示学生选课，并且保存了课程、学生和成绩等信息。Course类表示具体课程，包含了课程名称、课程内容和教学方式等属性。Abstract类表示学生成绩，其中分为TestScore类和ReviewScore类。TestScore类表示考试成绩，包含了Dscore（平时成绩）和Fscore（期末成绩）两个属性。ReviewScore类表示评价成绩。Student类表示学生信息，包含了学生学号和姓名两个属性。Class类表示课程班级，保存了学生名单和班级编号两个属性。CheckInput类用于检查输入，parseInput方法可以解析输入内容并且进行处理。在main函数中，通过Scanner对象获取用户输入，并进行循环处理每一条输入信息，直到输入"end"为止。该题目并没有写出来，所以不过多讲解。

踩坑心得：

7-7 判断三角形类型
分数 20

全屏浏览题目

切换布局
作者段喜龙
单位南昌航空大学
输入三角形三条边，判断该三角形为什么类型的三角形。

输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。

输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

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

50 50 50.0
输出样例1:
在这里给出相应的输出。例如：

Equilateral triangle
输入样例2:
在这里给出一组输入。例如：

60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：

Isosceles triangle
输入样例3:
在这里给出一组输入。例如：

0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：

Wrong Format
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner (System.in);
        double side1 = input.nextDouble();
        double side2 = input.nextDouble();
        double side3 = input.nextDouble();
        if(side1<1||side1>200||side2<1||side2>200||side3< 1||side3>200){
            System.out.println("Wrong Format");
            return;
        }
        if (side1+side2<=side3||side1+side3<=side2||side2+side3 <=side1){
            System.out.println("Not a triangle");
            return;
        }
         if (side1==side2&&side2==side3){
            System.out.println("Equilateral triangle");
        } else if (side1==side2&&(side1*side1+side2*side2==side3*side3)){
            System.out.println("Isosceles right-angled triangle");
        } /*else if (side1==side3&&(side1*side1+side3*side3==side2*side2)){
            System.out.println("Isosceles right-angled triangle");
        }  else if (side2==side3&&(side3*side3+side2*side2==side1*side1)){
            System.out.println("Isosceles right-angled triangle");
        }  */else if (side1==side2||side1==side3||side2==side3){
            System.out.println("Isosceles triangle");
        } else if (side1*side1+side2*side2==side3*side3||side1*side1+side3*side3==side2*side2||side2*side2+side3*side3==side1*side1){
            System.out.println("Right-angled triangle");
        } else {
            System.out.println("General triangle");
        }
        
    }
}

等腰直角三角形，边长带根号，变为小数时无法完全相等，导致判断错误。调整方法，更改判断条件。

else·if·(side1==side2&&(side1*side1+side2*side2-side3*side3)<0.0001){
············System.out.println("Isosceles·right-angled·triangle");
········}

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

全屏浏览题目

切换布局
作者蔡轲
单位南昌航空大学
长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，请编写程序实现国际单位制与英制之间的换算。

输入格式:
两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。

输出格式:
两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。

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

0.45359237 0.0254
输出样例:
在这里给出相应的输出。例如：

1.0 1.0
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double kg = input.nextDouble();
        double m = input.nextDouble();
        //double quality,length;
        if (kg==0&&m==0){
            double quality = 0;
            double length = 0;
        System.out.print(quality+" ");
        System.out.print(length);
        }
        else
            if(kg!=0&&m!=0){
        double quality = kg/0.45359237;
        double length = m/0.0254;
        System.out.print(quality+" ");
        System.out.print(length);
        }
        else
            if(kg!=0&&m==0){
        double quality = kg/0.45359237;
        double length = 0;
        System.out.print(quality+" ");
        System.out.print(length);
        }
        else{
        double quality = 0;
        double length = m/0.0254;
        System.out.print(quality+" ");
        System.out.print(length);
        }
       // System.out.print(quality+" ");
       // System.out.print(length);
        }
    }

输出格式错误，测试点的结果格式需要float类型。调整方法，强制类型转换。

System.out.print((float)quality+" ");
       System.out.print((float)length);

7-3 有重复的数据
分数 10

全屏浏览题目

切换布局
作者翁恺
单位浙江大学
在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。

你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。

输入格式:
你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。

输出格式:
如果这些整数中存在重复的，就输出：

YES
否则，就输出：

NO
输入样例:
5
1 2 3 1 4
输出样例:
YES
代码长度限制
16 KB
时间限制
800 ms
内存限制
64 MB

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] num = new int[n];
        for(int i = 0 ; i < n ; i++){
            num[i] = input.nextInt();
        }
        for (int i = 0; i < n; i++) {
        for (int j = n - i; j < n; j++) {
            if (num[i] == num[j]) {
                System.out.print("YES");
                return;
            }
        }
        }
        System.out.print("NO");
    }
}

用双重for循环超时，在查找资料后使用Java的库函数，先排序再比较，既不会超时也不会内存超限。

import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = scanner.nextInt();
}
Arrays.sort(nums);
for (int i = 1; i < n; i++) {
    if (nums[i] == nums[i-1]) {
        System.out.println("YES");
        return;
    }
}
    System.out.println("NO");
}
}

7-1 jmu-java-日期类的基本使用
分数 10

全屏浏览题目

切换布局
作者郑如滨
单位集美大学
给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

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

输入样例1:
第一行日期非法、第二行有日期非法

2020-02-30
2020-02-30 2020-01-02
输出样例1:
2020-02-30无效!
2020-02-30或2020-01-02中有不合法的日期.
输入样例2:
均有效且合法

2021-02-28
2019-08-01 2020-01-02
输出样例2:
2021-02-28是当年第59天,当月第28天,当周第7天.
2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.
输入样例3:
日期均有效，但结束日期早于开始日期

2020-02-28
2020-02-02 2020-02-01
输出样例3:
2020-02-28是闰年.
2020-02-28是当年第59天,当月第28天,当周第5天.
2020-02-01早于2020-02-02,不合法!
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String inputDate1 = sc.nextLine();
        String line = sc.nextLine();
        String[] parts = line.split(" ");
        String inputDate2 = parts[0];
        String inputDate3 = parts[1];
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        sdf.setLenient(false);
        try {
            Date date1 = sdf.parse(inputDate1);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date1);
            int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
            int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
            int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
            int year = date1.getYear() + 1900;
            if ((year % 4 == 0 && year % 100 != 0) || ((year % 400 == 0))) {
                System.out.println(inputDate1 + "是闰年.");
            }
            if (dayOfWeek == 1) {
                dayOfWeek = 7;
            } else {
                dayOfWeek--;
            }
            System.out.println(inputDate1 + "是当年第" + dayOfYear + "天, 当月第" + dayOfMonth + "天, 当周第" + dayOfWeek + "天.");
        } catch (Exception e) {
            System.out.println(inputDate1+"无效!");
        }
        try{
            Date date2 = sdf.parse(inputDate2);
            Calendar calendar2 = Calendar.getInstance();
            calendar2.setTime(date2);
            Date date3 = sdf.parse(inputDate3);
            Calendar calendar3 = Calendar.getInstance();
            calendar3.setTime(date3);
            if (date3.before(date2)) {
                System.out.print(inputDate3 + "早于" + inputDate2 + ",不合法!");
            } else {
                int days = (int) ((date3.getTime() - date2.getTime()) / (1000 * 60 * 60 * 24));
                int months = calendar3.get(Calendar.MONTH) - calendar2.get(Calendar.MONTH);
                int years = calendar3.get(Calendar.YEAR) - calendar2.get(Calendar.YEAR);
                System.out.println(inputDate3 + "与" + inputDate2 + "之间相差" + days + "天, 所在月份相差" + months + ", 所在年份相差" + years + ".");
            }
        } catch (Exception e) {
            System.out.print(inputDate2 + "或" + inputDate3 + "中有不合法的日期.");
            e.printStackTrace();
        }
    }
    }

只检测了日期是否合法，没有检测格式是否正确，后增加判断条件，判断格式是否正确。

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String inputDate1 = sc.nextLine();
        String line = sc.nextLine();
        String[] parts = line.split(" ");
        String inputDate2 = parts[0];
        String inputDate3 = parts[1];
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        sdf.setLenient(false);
        if (inputDate1.matches("\\d{4}-\\d{2}-\\d{2}")) {
            try {
                Date date1 = sdf.parse(inputDate1);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date1);
                int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
                int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
                int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
                int year = date1.getYear() + 1900;
                if ((year % 4 == 0 && year % 100 != 0) || ((year % 400 == 0))) {
                    System.out.println(inputDate1 + "是闰年.");
                }
                if (dayOfWeek == 1) {
                    dayOfWeek = 7;
                } else {
                    dayOfWeek--;
                }
                System.out.println(inputDate1 + "是当年第" + dayOfYear + "天, 当月第" + dayOfMonth + "天, 当周第" + dayOfWeek + "天.");
            } catch (Exception e) {
                System.out.println(inputDate1 + "无效!");
                e.printStackTrace();
            }
        }
            if (!inputDate1.matches("\\d{4}-\\d{2}-\\d{2}")) {
                System.out.println(inputDate1 + "无效!");
            }
            if (inputDate2.matches("\\d{4}-\\d{2}-\\d{2}") && inputDate3.matches("\\d{4}-\\d{2}-\\d{2}")) {
                try {
                    Date date2 = sdf.parse(inputDate2);
                    Calendar calendar2 = Calendar.getInstance();
                    calendar2.setTime(date2);
                    Date date3 = sdf.parse(inputDate3);
                    Calendar calendar3 = Calendar.getInstance();
                    calendar3.setTime(date3);
                    if (date3.before(date2)) {
                        System.out.print(inputDate3 + "早于" + inputDate2 + ",不合法!");
                    } else {
                        int days = (int) ((date3.getTime() - date2.getTime()) / (1000 * 60 * 60 * 24));
                        int months = calendar3.get(Calendar.MONTH) - calendar2.get(Calendar.MONTH);
                        int years = calendar3.get(Calendar.YEAR) - calendar2.get(Calendar.YEAR);
                        System.out.println(inputDate3 + "与" + inputDate2 + "之间相差" + days + "天, 所在月份相差" + months + ", 所在年份相差" + years + ".");
                    }
                } catch (Exception e) {
                    System.out.println(inputDate2 + "或" + inputDate3 + "中有不合法的日期.");
                    e.printStackTrace();
                }
            }
            if (!inputDate2.matches("\\d{4}-\\d{2}-\\d{2}") || !inputDate3.matches("\\d{4}-\\d{2}-\\d{2}")) {
                System.out.println(inputDate2 + "或" + inputDate3 + "中有不合法的日期.");
            }
        }
    }

主要困难以及改进建议：

有时候习题的描述可能比较抽象或者难以理解，导致对问题的需求理解有偏差。在解题之前，应该仔细阅读题目，并确保对问题需求有清晰的理解。如果有疑问，可以查阅相关资料或者向他人寻求帮助，确保理解了问题的本质。某些习题可能需要使用合适的算法或者设计出精确的逻辑来解决问题。在解题过程中，我们可能会面临找不到有效算法或者思路不清晰的问题。在这种情况下，可以尝试将问题分解为更小的子问题，然后逐步解决。另外，多与他人交流和讨论，分享思路和经验也是很有帮助的。在编写代码时，可能会遇到语法错误、逻辑错误或者运行时错误。为了解决这些问题，建议使用适当的调试工具，例如IDE的调试器。同时，良好的代码组织和注释也能够提高代码的可读性和可维护性，便于定位和解决问题。Java编程习题的难度和复杂度各不相同，有时可能需要更多的学习资源和实践来提升自己的编程能力。

总结：

通过这三次题目集，我学会了如何应对不同类型和难度的编程问题。通过解决这些题目，我提高了自己的逻辑思考能力和问题解决能力。我学会了如何分析问题、设计算法，并利用编程语言实现解决方案。我认识到编程是一个不断学习和实践的过程。每个题目都有自己的难点和挑战，而且编程领域也在不断发展和更新。因此，我意识到需要持续学习并保持对新知识和技术的敏感度。特别是在面对一些高级或复杂的问题时，我需要进一步学习和研究相关的概念、算法和技术。我希望能够更深入地了解编程语言的特性和常用库的使用。这将有助于我编写更高效、可读性更好的代码。改进建议：强调团队合作和交流。总的来说，我认为本阶段的编程习题集给了我很好的学习机会，让我在解决问题和编写代码方面得到了锻炼。我相信，通过持续的学习和实践，我将逐渐提升自己的编程能力和创造力。