526互联

题目集：作业1-作业3

发布时间 2023-10-07 22:49:49作者: 因为啊

(1):前言：第一次第二次作业数量较多但是难度并不是很大，因此只要稍微努力便可完成，等到做第三次作业时候，第二道题目便把难度提上来了，由于难度较高因此只能完成部分测试点，由于之后改动较多前面能过的测试点反而不能过了，哈哈哈。


(2)设计与分析：

第二次作业7-1：

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

public class Main {
    private String id;
    private String name;
    private int chinese;
    private int math;
    private int physic;

    public Main(String id, String name, int chinese, int math, int physic) {
        this.id = id;
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.physic = physic;
    }

    public int sum() {
        return chinese + math + physic;
    }

    public double average() {
        return (chinese + math + physic) / 3.0;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Main[] students = new Main[5];

        for (int i = 0; i < students.length; i++) {
            String id = scanner.next();
            String name = scanner.next();
            int chinese = scanner.nextInt();
            int math = scanner.nextInt();
            int physic = scanner.nextInt();

            students[i] = new Main(id, name, chinese, math, physic);
        }

        scanner.close();

        DecimalFormat df = new DecimalFormat("#.00");
        df.setRoundingMode(RoundingMode.HALF_UP);

        for (int i = 0; i < students.length; i++) {
            int sum = students[i].sum();
            double average = students[i].average();
            System.out.println(students[i].id + " "+ students[i].name  + " " +  sum + " " + df.format(average));
        }
    }
}

代码结构：

 

这段代码是一个简单的Java程序，用于计算学生的总分和平均分，并输出结果。程序首先定义了一个名为Main的类，该类有五个属性：id、name、chinese、math和physic，分别表示学生的学号、姓名、语文成绩、数学成绩和物理成绩。

在Main类中，有一个构造函数用于初始化对象的属性。构造函数接受学号、姓名和三门科目的成绩作为参数，并将它们赋值给对应的属性。

类中还定义了两个方法：sum()用于计算学生的总分，average()用于计算学生的平均分。sum()方法直接返回语文、数学和物理成绩的总和，average()方法通过将总分除以3.0来计算平均分，并返回结果。

程序的main方法是程序的入口点。在main方法中，首先创建一个Scanner对象来读取输入。然后创建一个Main类型的数组students，长度为5。接下来使用for循环遍历数组，每次迭代都从控制台读取学生的信息，并创建Main对象并将其存储在数组中。

在循环结束后，关闭Scanner对象。然后创建一个DecimalFormat对象df，用于格式化输出的平均分，保留两位小数并进行四舍五入。

最后，再次使用for循环遍历students数组，计算每个学生的总分和平均分，并将结果打印输出。

第二次作业7-3：

import java.util.Scanner;

public class Main {
    public static class Scores {
        private int primaryScore;//
        private int quizScore;//

        public Scores(int primaryScore, int quizScore) {
            this.primaryScore = primaryScore;//
            this.quizScore = quizScore;//
        }

        public double calculateScore() {
            double score = primaryScore * 0.4 + quizScore * 0.6;
            return Math.floor(score);
        }
    }

    public static class Student {
        private String name;
        private String id;
        private Scores chineseScores;
        private Scores mathScores;
        private Scores physicsScores;

        public Student() {
            this.name = "";
            this.id = "";
            this.chineseScores = new Scores(0, 0);
            this.mathScores = new Scores(0, 0);
            this.physicsScores = new Scores(0, 0);
        }

        public void setChineseScores(int primaryScore, int quizScore) {
            chineseScores = new Scores(primaryScore, quizScore);
        }

        public void setMathScores(int primaryScore, int quizScore) {
            mathScores = new Scores(primaryScore, quizScore);
        }

        public void setPhysicsScores(int primaryScore, int quizScore) {
            physicsScores = new Scores(primaryScore, quizScore);
        }

        public void printIdAndName() {
            System.out.print(id + " " + name + " ");
        }

        public double calculateTotalScore() {
            double chineseTotal = chineseScores.calculateScore();
            double mathTotal = mathScores.calculateScore();
            double physicsTotal = physicsScores.calculateScore();
            return chineseTotal + mathTotal + physicsTotal;
        }

        public double calculatePrimaryScoreAverage(){
            return (chineseScores.primaryScore + mathScores.primaryScore + physicsScores.primaryScore) / 3.0;
        }

        public double calculateQuizScoreAverage(){
            return (chineseScores.quizScore + mathScores.quizScore + physicsScores.quizScore) / 3.0;
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        Student[] students = new Student[3];
        students[0] = new Student();//第一个学生
        students[1] = new Student();//第二个
        students[2] = new Student();//第三个
        for (int i = 0; i < 9; i++) {
            String id = scan.next();
            String name = scan.next();
            students[i / 3].id = id;
            students[i / 3].name = name;
            String subject = scan.next();
            int primaryScore = scan.nextInt();
            int quizScore = scan.nextInt();
            switch (subject) {
                case "语文":
                    students[i / 3].setChineseScores(primaryScore, quizScore);
                    break;
                case "数学":
                    students[i / 3].setMathScores(primaryScore, quizScore);
                    break;
                case "物理":
                    students[i / 3].setPhysicsScores(primaryScore, quizScore);
                    break;
            }
        }
        for (int i = 0; i < 3; i++) {
            students[i].printIdAndName();
            double totalScore = students[i].calculateTotalScore();
            double primaryScoreAverage = students[i].calculatePrimaryScoreAverage();
            double quizScoreAverage = students[i].calculateQuizScoreAverage();
            System.out.print(String.format("%.0f %.2f %.2f ",totalScore, primaryScoreAverage,quizScoreAverage));
            System.out.println(String.format("%.2f", totalScore / 3.0));
        }
    }
}

代码结构：

 

该代码实现了一个学生成绩统计和输出的程序。以下是代码的分析：

             （1）首先定义了两个内部类：Scores和Student。

    1.Scores类用于表示一门科目的成绩，包含primaryScore（期中成绩）和quizScore（平时成绩）两个属性。
    2.Student类表示学生，包含name（姓名）、id（学号）和三门科目的Scores对象（chineseScores、mathScores、physicsScores）作为属性。
      2.Student类中有一些方法：

    （2）构造函数用于初始化学生对象的属性。
    2.setChineseScores()、setMathScores()、setPhysicsScores()方法用于设置学生的语文、数学、物理成绩。
    3.printIdAndName()方法用于输出学生的学号和姓名。
    4.calculateTotalScore()方法计算学生的总分。
    5.calculatePrimaryScoreAverage()方法计算学生的期中成绩平均分。
    6.calculateQuizScoreAverage()方法计算学生的平时成绩平均分。
    （3） 在main方法中：
  1. 创建一个Scanner对象用于读取输入。
  2. 创建一个长度为3的Student数组。
  3. 使用for循环遍历数组，每次迭代都从控制台读取学生的信息，并创建相应的Student对象并存储在数组中。
  4. 使用switch语句根据输入的科目设置学生的相应科目成绩。
  5. 再次使用for循环遍历数组，输出每个学生的学号、姓名、总分、期中成绩平均分、平时成绩平均分和总平均分。

第二次作业7-7:

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

public class Main {
    public static void main(String[] args) {
        Menu menu = new Menu(new Dish[]{
                new Dish("西红柿炒蛋", 15),
                new Dish("清炒土豆丝", 12),
                new Dish("麻婆豆腐", 12),
                new Dish("油淋生菜", 9)
        });

        Order order = new Order();

        List<String> notFounds = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            if ("end".equals(line)) {
                break;
            }
            String[] lineArray = line.split(" ");
            String dishName = lineArray[0];
            int portion = Integer.parseInt(lineArray[1]);
            Dish dish = menu.searchDish(dishName);
            if (dish == null) {
                notFounds.add(dishName);
            } else {
                order.addRecord(dish, portion);
            }
        }

        for (String dishName : notFounds) {
            System.out.println(dishName + " does not exist");
        }

        System.out.println(order.getTotalPrice());
    }
}

class Menu {
    private Dish[] dishes;

    Menu(Dish[] dishes) {
        this.dishes = dishes;
    }

    Dish searchDish(String dishName) {
        for (Dish dish : dishes) {
            if (dish.getName().equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
}

class Dish {
    private String name;
    private int unitPrice;

    public Dish(String name, int unitPrice) {
        this.name = name;
        this.unitPrice = unitPrice;
    }

    public String getName() {
        return name;
    }

    public int getUnitPrice() {
        return unitPrice;
    }

    int getPrice(int portion) {
        float[] prices = {1, 1.5f, 2};
        return Math.round(unitPrice * prices[portion - 1]);
    }
}

class Record {
    private Dish dish;
    private int portion;

    public Record(Dish dish, int portion) {
        this.dish = dish;
        this.portion = portion;
    }

    public Dish getDish() {
        return dish;
    }

    public int getPortion() {
        return portion;
    }

    int getPrice() {
        return dish.getPrice(portion);
    }
}

class Order {
    private List<Record> records = new ArrayList<>();

    int getTotalPrice() {
        int sum = 0;
        for (Record record : records) {
            sum += record.getPrice();
        }
        return sum;
    }

    Record addRecord(Dish dish, int portion) {
        Record record = new Record(dish, portion);
        records.add(record);
        return record;
    }
}

代买结构：

 

该代码实现了一个简单的餐厅点餐系统。以下是代码的分析：

1.主函数中：

创建了一个Menu对象menu，并初始化了一些菜品信息。
创建了一个Order对象order，用于记录点餐信息。
创建了一个空的List<String>对象notFounds，用于存储未找到的菜品名称。
创建了一个Scanner对象用于读取用户输入。
2.while循环中：

通过scanner.nextLine()读取用户的输入。
如果输入为"end"，则跳出循环。
否则，将输入按空格分割成菜品名称和份数。
使用menu对象的searchDish方法查找菜品对象。
如果查找到了菜品对象，使用order对象的addRecord方法添加点餐记录。
如果未找到菜品对象，将菜品名称存入notFounds列表。
3.遍历notFounds列表，输出未找到的菜品信息。

4.输出order对象的getTotalPrice方法返回的总价格。

第三次作业7-2：错误代码：

import java.util.*;

class Course {
    private String name;
    private String type;
    private String accessMode;
    private int[] grades;

    public Course(String name, String type, String accessMode) {
        this.name = name;
        this.type = type;
        this.accessMode = accessMode;
        this.grades = null;
    }

    public String getName() {
        return name;
    }

    public String getType() {
        return type;
    }

    public String getAccessMode() {
        return accessMode;
    }

    public void setGrades(int[] grades) {
        this.grades = grades;
    }

    public int[] getGrades() {
        return grades;
    }

    public String getGradeReport() {
        if (grades == null) {
            return "has no grades yet";
        }

        StringBuilder sb = new StringBuilder();
        int sum = 0;
        for (int grade : grades) {
            sb.append(grade).append(" ");
            sum += grade;
        }
        int average = sum / grades.length;
        sb.append(average);

        return sb.toString();
    }
}

class Student {
    private String id;
    private String name;
    private Map<String, Course> courses;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
        this.courses = new HashMap<>();
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void addCourse(Course course) {
        courses.put(course.getName(), course);
    }

    public Course getCourse(String courseName) {
        return courses.get(courseName);
    }

    public String getGradeReport() {
        StringBuilder sb = new StringBuilder();
        sb.append(id).append(" ").append(name).append("\n");
        for (Course course : courses.values()) {
            sb.append(course.getName()).append(" ").append(course.getGradeReport()).append("\n");
        }
        sb.append(id).append(" ").append(getOverallAverageGrade());
        return sb.toString();
    }

    private String getOverallAverageGrade() {
        int sum = 0;
        int count = 0;
        for (Course course : courses.values()) {
            if (course.getGrades() != null) {
                for (int grade : course.getGrades()) {
                    sum += grade;
                    count++;
                }
            }
        }
        if (count == 0) {
            return "has no grades yet";
        } else {
            int average = sum / count;
            return String.valueOf(average);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        List<Course> courses = new ArrayList<>();
        Map<String, Student> students = new HashMap<>();

        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }

            String[] tokens = input.split(" ");
            if (tokens.length == 3) { // Course information
                String courseName = tokens[0];
                String type = tokens[1];
                String accessMode = tokens[2];

                Course course = new Course(courseName, type, accessMode);
                courses.add(course);
            } else { // Student information
                String id = tokens[0];
                String name = tokens[1];
                String courseName = tokens[2];
                int[] grades = new int[tokens.length - 3];
                for (int i = 3; i < tokens.length; i++) {
                    grades[i - 3] = Integer.parseInt(tokens[i]);
                }

                if (!students.containsKey(id)) {
                    Student student = new Student(id, name);
                    students.put(id, student);
                }

                Student student = students.get(id);
                Course course = null;
                for (Course c : courses) {
                    if (c.getName().equals(courseName)) {
                        course = c;
                        break;
                    }
                }

                if (course == null) {
                    System.out.println(courseName + " does not exist");
                } else {
                    if (!course.getType().equals(student.getCourse(courseName).getType()) ||
                            !course.getAccessMode().equals(student.getCourse(courseName).getAccessMode())) {
                        System.out.println(courseName + " : course type & access mode mismatch");
                    } else {
                        student.addCourse(course);
                        course.setGrades(grades);
                    }
                }
            }
        }

        // Output grade reports
        for (Student student : students.values()) {
            System.out.println(student.getGradeReport());
        }
    }
}

 

结构分析：

 

这段代码是一个学生成绩管理系统。主要包含了三个类：Course（课程类）、Student（学生类）和Main（主程序类）。

Course类表示一个课程，有课程名称、类型和访问模式等属性，还有一个存储成绩的数组。Course类提供了构造方法和一些获取和设置属性的方法，以及一个获取成绩报告的方法。

Student类表示一个学生，有学生ID、姓名和所选课程等属性，还有一个存储课程的映射表。Student类提供了构造方法和一些获取和添加课程的方法，以及一个获取成绩报告的方法。

Main类是程序的入口，其中包含了主方法。在主方法中，首先创建了一个Scanner对象用来接收用户输入。然后定义了一个ArrayList<Course>用来存储所有的课程，以及一个HashMap<String, Student>用来存储所有的学生。

接下来通过循环读取用户的输入，如果输入是"end"，则跳出循环；否则根据输入的内容判断是课程信息还是学生信息。如果是课程信息，则创建一个新的Course对象，并将其添加到courses列表中；如果是学生信息，则创建一个新的Student对象，并将其添加到students映射表中，并根据课程名查找对应的Course对象，并进行比较，如果课程不存在或者课程类型或访问模式不匹配，则输出错误信息；否则，将该课程添加到学生的课程列表中，并设置该课程的成绩。

最后，通过遍历students映射表，输出每个学生的成绩报告（因为这段代码最终还是没有成功运行出达到正确的答案大概只能输出部分错误的节点所以分析比较简陋）

3.采坑心得：

1.在第一次写作业时由于是第一次写所以有时候会写的和C语言比较混淆，因为是刚学JAVA语言，也因此在使用import导入数据包时根本不知道该导入哪些，只能在网上一边查找一边慢慢琢磨该导入哪些数据包

2.在打开定义的scanner输入中（Scanner scanner=new Scanner(System.in);）将这段代码放在了FOR循环中导致输入异常，调试了很久输出都是空，后面才发现了这个错误

4.主要困难以及改进：（1）对JAVA语言不是很熟悉，因此以后需要多进行实践性编程这样可能会加快熟悉JAVA的速度

                                    （2）对JAVA语言中自带的函数所知道的很少例如（import java.time.format.DateTimeFormatter;     和import java.time.temporal.ChronoUnit;）这两个调用时间有关的函数导入包，以后在一边学习一                                                边 编程的时候会尽量多学习一些函数，多掌握一些函数

5.总结：JAVA语言的学习难度比想象中的要高，可能是由于大一学C语言时候觉得C语言比较简单入门容易（数据结构太难辣）觉得JAVA语言应该也比较好入门因此可能前期学习有所懈怠，等到第三次作业时在网上一边学习一边使用一些其他没见过的函数才发现JAVA语言并没有想象中的简单，所以现在回过头来看觉得可能还是有一点心高气傲吧，还好发现了不然期末考试就生死难料了，hahha，直到现在第三次作业的7-2都没能完成，还是有一定难度的希望我能够早点做出来，也希望在学习JAVA的过程中能够从现在开始有个好的开头。（给个高分给孩子吧谢谢，给高分以后考试都拿高分，什么考试都过，谢谢大佬）