pta第一次大作業-盧文博

Mist_123發表於2024-10-26

第一次大作業

7-1設計一個風扇Fan類

主要程式碼如下：

  import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Fan fan1 = new Fan();
        System.out.println("-------");
    System.out.println("Default");
    System.out.println("-------");
    System.out.println(fan1);
    int speed = in.nextInt();
    boolean on = "True".equals(in.next());
    double radius = in.nextDouble();
    String color = in.next();
    Fan fan2 = new Fan(speed,on,radius,color);
    System.out.println("-------");
    System.out.println("My Fan");
    System.out.println("-------");
    System.out.println(fan2);
}

}

class Fan{
    private final int SLOW = 1;
    private final int MEDIUM = 2;
    private final int FAST = 3;
    private int speed = SLOW;
    private boolean on = false;
    private double radius = 5;
    private String color = "white";
public Fan(int speed, boolean on, double radius, String color) {
    this.speed = speed;
    this.on = on;
    this.radius = radius;
    this.color = color;
}

public Fan() {
}

public int getSpeed() {
    return speed;
}

public void setSpeed(int speed) {
    this.speed = speed;
}

public boolean isOn() {
    return on;
}

public void setOn(boolean on) {
    this.on = on;
}

@Override
public String toString() {
    if(on){
        return  "speed "+speed+"\ncolor "+color+"\nradius "+radius+"\nfan is on";
    }else{
        return "speed "+speed+"\ncolor "+color+"\nradius "+radius+"\nfan is off";
    }
}

public double getRadius() {
    return radius;
}

public void setRadius(double radius) {
    this.radius = radius;
}

public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}

}

這個fan類主要考察了：
類和物件的基本概念
構造方法的使用
變數的封裝（使用私有資料域和訪問器、修改器）
方法重寫（toString方法）
條件語句和使用者輸入處理

7-2類和物件的使用

我認為這個題題目和上面fan類比較類似
下面是student類的程式碼

class Student{
    private String name;
    private String sex;
    private String ID;
    private int age;
    private String major;
    public Student(){};
    public Student(String name,String sex,String ID,int age,String major){
        this.name=name;
        this.sex=sex;
        this.ID=ID;
        this.age=age;
        this.major=major;
    }
    public void set(){
    }
    public String getname(String name){
        return this.name;
    }
    public String getsex(String sex){
        return this.sex;
    }
    public String ID(String ID){
        return this.ID;
    }
    public int age(int age){
        return this.age;
    }
    public String major(String major){
        return this.major;
    }
 
    public String toString(){
        return "姓名："+this.name+", 性別："+this.sex+", 學號："+this.ID+", 年齡："+this.age+", 專業："+this.major;}//獲取學生所有屬性的方法
    public void printInfo(){
        System.out.print("姓名："+this.name);
        System.out.print("，性別："+this.sex);
        System.out.print("，學號："+this.ID);
 
        System.out.print(",年齡："+this.age);
        System.out.print(",專業："+this.major);
 
    }

主要考察和fan類類似幾個方面：
物件導向程式設計：理解類的屬性和方法的使用。
封裝：透過私有屬性和公共 getter/setter 方法來保護資料。
構造器的使用：理解如何使用多種構造器來初始化物件。
輸入輸出操作：透過控制檯輸入輸出學生資訊。
方法重寫：理解 toString() 方法的重寫和使用。

7-3與7-4與上面兩個相似都是一些簡單的類的構造，就不作贅述了

7-5答題判題程式-1

這個題目是這次作業中最難的一道題目，也是以後幾次作業要作更新迭代的程式，但題目有些難度
下面是我的部分程式碼


class Question {
    String Number;
    String content;
    String StandardAnswer; 
    public String getNumber() {
    return Number;
    }
    public Question(String Number, String content, String StandardAnswer) {
    this.Number = Number;
    this.content = content;
    this.StandardAnswer = StandardAnswer;
    }
public void setNumber(String Number) {
    this.Number = Number;
}
public String getContent() {
    return content;
}
public void setContent(String content) {
    this.content = content;
}
public String getStandardAnswer() {
    return StandardAnswer;
}
public void setStandardAnswer(String StandardAnswer) {
    this.StandardAnswer = StandardAnswer;
}

在我構造的類中
Main 類負責讀取輸入、處理資料並輸出結果。
Question 類封裝了問題的編號、內容和標準答案，提供了相應的 getter 和 setter 方法。
在程式碼中用到了一些正規表示式例如
分割輸入字串：
String[] parts = input[i].split("#N:|#A:|#Q:");
這裡的 split 方法使用了正規表示式 #N:|#A:|#Q:，表示將輸入字串根據 #N:, #A: 和 #Q: 這三個標記進行分割。
分割答案字串：
String answer[] = ans.split("#A:");
這裡的 split 方法同樣使用了正規表示式 #A:，用於將答案字串按 #A: 分割。
正規表示式允許靈活地匹配字串模式，非常適合處理這類文字分割的需求，似的資料更便於處理。
並且因為自己對正規表示式的理解不夠，出現了很多問題

第二次大作業

這次大作業共有四題與第一次差不多重點在最後一題

手機按價格排序、查詢

這個題目要求該類實現Comparable介面，重寫compareTo方法
實現 Comparable 介面使得類的物件能夠被排序，是 Java 中一種非常強大的功能。它使得開發者可以簡單地定義物件的自然順序，便於進行排序、搜尋等操作。
下面是程式碼的實現

import java.util.*;  
import java.util.Scanner;  
  
class MobilePhone implements Comparable<MobilePhone> {  
    private String type;  
    private int price;  
  
class Main {  
    public static void main(String[] args) {  
        Scanner sc = new Scanner(System.in);
        List<MobilePhone> list = new ArrayList<>();  
        for (int i = 0; i < 3; i++) {  
            String type = sc.next();  
            int price = sc.nextInt();  
            MobilePhone mobilePhone = new MobilePhone(type, price);  
            list.add(mobilePhone);  
        }  
  
        System.out.println("排序前，連結串列中的資料：");  
        for (MobilePhone phone : list) {  
            System.out.println(phone);  
        }
        Collections.sort(list);
        System.out.println("排序後，連結串列中的資料：");  
        for (MobilePhone phone : list) {
            System.out.println(phone);
        }
        String typeToFind = sc.next();  
        int priceToFind = sc.nextInt();  
        MobilePhone mobilePhoneToFind = new MobilePhone(typeToFind, priceToFind);  
  
        boolean found = false;  
        for (MobilePhone phone : list) {  
            if (phone.getPrice() == mobilePhoneToFind.getPrice()) {  
                found = true;  
                System.out.println(typeToFind + "與連結串列中的" + phone.getType() + "價格相同");  
            }  
        }  
        if (!found) {  
            System.out.println("連結串列中的物件，沒有一個與" + typeToFind + "價格相同的");  
        }  
    }  
}

MobilePhone 類
class MobilePhone implements Comparable {
這個類實現了 Comparable 介面，允許對 MobilePhone 物件進行排序。
屬性
private String type;
private int price;
type：手機的型號（型別）。
price：手機的價格。
建構函式
public MobilePhone(String type, int price) {
this.type = type;
this.price = price;
}
用於初始化 MobilePhone 物件的型別和價格。
Getter 和 Setter 方法
public String getType() { return type; }
public void setType(String type) { this.type = type; }
public int getPrice() { return price; }
public void setPrice(int price) { this.price = price; }
提供獲取和設定 type 和 price 的方法。
compareTo 方法
public int compareTo(MobilePhone other) {
return Integer.compare(this.price, other.price);
}
實現了價格的比較邏輯，使得可以根據價格對 MobilePhone 物件進行排序。
toString 方法
public String toString() {
return "型號：" + type + "，價格：" + price;
}
重寫了 toString 方法，以便列印出手機的型號和價格。

sdut-oop-4-求圓的面積（類與物件）

第2題程式碼也作省略
主要講一下我寫的類的屬性和方法
Circle 類:
包含一個私有成員變數 radius，表示圓的半徑。
提供了無參構造方法和有參構造方法。
setRadius 方法用於設定半徑值，若輸入小於等於0，則設定為2。
getRadius 方法返回當前半徑值。
getArea 方法用於計算圓的面積。
重寫了 toString 方法以便於輸出物件的字串表示。
Main 類:
建立了 Circle 類的物件 c1 和 c2，並輸出其資訊和麵積。
透過鍵盤輸入接收整型半徑並賦值給 c2。
再次接收整型半徑，並使用有參構造方法建立第三個 Circle 物件 c3，輸出其資訊和麵積。

答題判題程式-2

這一道題是第一次大作業最後一題的迭代題目
由於我第一次大作業的類的屬性方法的構造思考方法不夠全面以及正規表示式的運用不夠熟練
這次題目只得到了一點分數
下面是我的程式碼

import java.util.Scanner;  

class Question {
    String id;
    String content;
    String answer;
    public Question(String id, String content, String answer) {
        this.id = id;
        this.content = content;
        this.answer = answer;
    }
    public String getId() {  
        return id;  
    }  
   public void setID(String id) {
        this.id = id;
    }
    public String getContent() {  
        return content;  
    }  
   public void setContent(String content) {
        this.content = content;
    }
        public String getAnswer() {  
        return answer;  
    }  
   public void setAnswer(String answer) {
        this.answer = answer;
    }

}

class TestPaper {
    String id;
    Map<String, Integer> questions; // 題目ID和分值的對映

    public TestPaper(String id) {
        this.id = id;
        this.questions = new HashMap<>();
    }

    public void addQuestion(String questionId, int score) {
        questions.put(questionId, score);
    }

    public int getTotalScore() {
        return questions.values().stream().mapToInt(Integer::intValue).sum();
    }
}

class AnswerSheet {
    String testPaperId;
    List<String> answers;
    public AnswerSheet(String testPaperId) {
        this.testPaperId = testPaperId;
        this.answers = new ArrayList<>();
    }

    public void addAnswer(String answer) {
        answers.add(answer);
    }
}
public class Main {
    private static final List<Question> questions = new ArrayList<>();
    private static final List<TestPaper> testPapers = new ArrayList<>();
    private static final List<AnswerSheet> answerSheets = new ArrayList<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line;
        // 讀取輸入
        while (!(line = sc.nextLine()).equals("end")) {
            processInput(line.trim());
        }
       sc.close();
        // 處理輸出
        processOutput();
    }
    private static void processInput(String line) {
        if (line.startsWith("#N:")) {
            // 處理題目資訊
            String[] parts = line.split(" ");
            String id = parts[0].substring(3);
            String content = parts[1].substring(3);
            String answer = parts[2].substring(3);
            questions.add(new Question(id, content, answer));
        } else if (line.startsWith("#T:")) {
            // 處理試卷資訊
            String[] parts = line.split(" ");
            String testPaperId = parts[0].substring(3);
            TestPaper testPaper = new TestPaper(testPaperId);
            for (int i = 1; i < parts.length; i++) {
                String[] questionParts = parts[i].split("-");
                String questionId = questionParts[0];
                int score = Integer.parseInt(questionParts[1]);
                testPaper.addQuestion(questionId, score);
            }
            testPapers.add(testPaper);
        } else if (line.startsWith("#S:")) {
            // 處理答卷資訊
            String[] parts = line.split(" ");
            String testPaperId = parts[0].substring(3);
            AnswerSheet answerSheet = new AnswerSheet(testPaperId);
            for (int i = 1; i < parts.length; i++) {
                String answer = parts[i].substring(3);
                answerSheet.addAnswer(answer);
            }
            answerSheets.add(answerSheet);
        }
    }

}

下面是我寫的程式碼幾個類以及思路邏輯

Question 類
屬性:
String id: 題目的唯一識別符號。
String content: 題目的內容。
String answer: 題目的正確答案。
方法:
Question(String id, String content, String answer): 建構函式，用於初始化題目。
getId(): 返回題目ID。
setID(String id): 設定題目ID。
getContent(): 返回題目內容。
setContent(String content): 設定題目內容。
getAnswer(): 返回答案。
setAnswer(String answer): 設定答案。
TestPaper 類
屬性:
String id: 試卷的唯一識別符號。
Map<String, Integer> questions: 題目ID與分數的對映。
方法:
TestPaper(String id): 建構函式，用於初始化試卷。
addQuestion(String questionId, int score): 新增題目及其分數。
getTotalScore(): 計算並返回試卷的總分。
AnswerSheet 類
屬性:
String testPaperId: 關聯的試卷ID。
List answers: 答案列表。
方法:
AnswerSheet(String testPaperId): 建構函式，用於初始化答卷。
addAnswer(String answer): 新增答案到答卷。
主類 Main
屬性:
List questions: 儲存所有題目的列表。
List testPapers: 儲存所有試卷的列表。
List answerSheets: 儲存所有答卷的列表。
方法:
main(String[] args): 程式的入口，處理輸入和輸出。
processInput(String line): 處理輸入的每一行，根據字首判斷是題目、試卷還是答卷。
如果以 #N: 開頭，解析題目資訊並建立 Question 物件。
如果以 #T: 開頭，解析試卷資訊並建立 TestPaper 物件。
如果以 #S: 開頭，解析答卷資訊並建立 AnswerSheet 物件。
processOutput(): 處理輸出，驗證並輸出每份答卷的結果。
遍歷試卷，檢查是否總分為100。
遍歷答卷，校對答案，並輸出每道題的結果和總分
但由於種種問題，以及我給的限制條件不夠導致只有幾個測試用例是正確的只得了12分

第三次大作業

這次大作業只有三道題目，仍然是最後一題為迭代更新的題目

物件導向程式設計(封裝性)

這道題目主要考察類：封裝成員變數的訪問修飾符使用（private），以及如何透過公共方法（getter 和 setter）來訪問和修改這些私有變數。
封裝的概念，以及它如何提高程式碼的安全性和可維護性。
下面是我構造的兩個類與方法

Student 類
屬性
sid：學生的學號（字串型別）。
name：學生的姓名（字串型別）。
age：學生的年齡（整型）。
major：學生的專業（字串型別）。
構造方法
無參構造方法：提供一個預設的構造方法，允許建立 Student 物件而不初始化任何屬性。
有參構造方法：接收 sid、name、age 和 major 作為引數，並初始化相應的屬性。
對 age 屬性進行合法性檢查，確保其值大於0，如果不合法，則將其設定為0。
方法
print()：列印學生的詳細資訊，包括學號、姓名、年齡和專業。
訪問器（getter）和修改器（setter）：
setSid() 和 getSid()：設定和獲取學號。
setName() 和 getName()：設定和獲取姓名。
setAge() 和 getAge()：設定和獲取年齡，setAge() 方法同樣包含合法性檢查。
setMajor() 和 getMajor()：設定和獲取專業。
Main 類
main 方法
建立一個 Scanner 物件 sc，用於從標準輸入讀取資料。
使用 sc.next() 和 sc.nextInt() 方法分別讀取學生的學號、姓名、年齡和專業。
建立第一個 Student 物件 student1：
使用無參構造方法，然後透過 setter 方法設定屬性。
建立第二個 Student 物件 student2：
直接使用有參構造方法初始化屬性。
列印學生資訊
呼叫 student1.print() 和 student2.print()，列印兩個學生的詳細資訊。

答題判題程式-3

這次的迭代由於前面兩次的漏洞過於多導致這次的迭代我完成不了，
下面是我的程式碼僅供記錄（沒有任何作用）

import java.util.*;

public class QuizApp {
    static class Question {
        String content;
        String answer;
        boolean isDeleted;

        public Question(String content, String answer) {
            this.content = content;
            this.answer = answer;
            this.isDeleted = false;
        }
    }

    static class Paper {
        String id;
        List<QuestionScore> questionScores;
        int totalScore;

        public Paper(String id) {
            this.id = id;
            this.questionScores = new ArrayList<>();
            this.totalScore = 0;
        }
    }

    static class QuestionScore {
        String questionContent;
        String studentAnswer;
        boolean isCorrect;
        int score;

        public QuestionScore(String questionContent, String studentAnswer, boolean isCorrect, int score) {
            this.questionContent = questionContent;
            this.studentAnswer = studentAnswer;
            this.isCorrect = isCorrect;
            this.score = score;
        }
    }

    static class Student {
        String id;
        String name;

        public Student(String id, String name) {
            this.id = id;
            this.name = name;
        }
    }

    private static Map<String, Question> questions = new HashMap<>();
    private static Map<String, List<Paper>> papers = new HashMap<>();
    private static Map<String, Student> students = new HashMap<>();
    private static Set<String> deletedQuestions = new HashSet<>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input;
        while (!(input = scanner.nextLine()).equals("end")) {
            processInput(input);
        }
        outputResults();
    }

    private static void processInput(String input) {
        String[] parts = input.split(" ");
        if (input.startsWith("#N:")) {
            // 處理題目資訊
            handleQuestion(parts);
        } else if (input.startsWith("#T:")) {
            // 處理試卷資訊
            handleTestPaper(parts);
        } else if (input.startsWith("#X:")) {
            // 處理學生資訊
            handleStudent(parts);
        } else if (input.startsWith("#S:")) {
            // 處理答卷資訊
            handleStudentAnswer(parts);
        } else if (input.startsWith("#D:")) {
            // 處理刪除題目資訊
            handleDeleteQuestion(parts);
        } else {
            System.out.println("wrong format:" + input);
        }
    }

    private static void handleQuestion(String[] parts) {
        String questionId = parts[0].substring(3);
        String questionContent = parts[1].substring(3);
        String answer = parts[2].substring(3);
        questions.put(questionId, new Question(questionContent, answer));
    }

    private static void handleTestPaper(String[] parts) {
        String testId = parts[0].substring(3);
        List<QuestionScore> questionScores = new ArrayList<>();
        int totalScore = 0;

        for (int i = 1; i < parts.length; i++) {
            String[] questionInfo = parts[i].split("-");
            String questionId = questionInfo[0];
            int score = Integer.parseInt(questionInfo[1]);
            totalScore += score;
            questionScores.add(new QuestionScore(questions.get(questionId).content, "", false, score));
        }

        Paper paper = new Paper(testId);
        paper.questionScores = questionScores;
        paper.totalScore = totalScore;
        papers.put(testId, paper);
    }

    private static void handleStudent(String[] parts) {
        for (int i = 1; i < parts.length; i++) {
            String[] studentInfo = parts[i].split("-");
            String studentId = studentInfo[0];
            String studentName = studentInfo[1];
            students.put(studentId, new Student(studentId, studentName));
        }
    }

    private static void handleStudentAnswer(String[] parts) {
        String testId = parts[0].substring(3);
        String studentId = parts[1];
        String studentName = students.containsKey(studentId) ? students.get(studentId).name : null;

        Paper paper = papers.get(testId);
        if (paper == null) {
            System.out.println("the test paper number does not exist");
            return;
        }

        for (int i = 2; i < parts.length; i++) {
            String[] answerInfo = parts[i].split("-");
            int questionIndex = Integer.parseInt(answerInfo[0]) - 1;
            String answer = answerInfo[1].trim();
            QuestionScore questionScore = paper.questionScores.get(questionIndex);
            if (questionScore.questionContent == null) {
                System.out.println("non-existent question~" + answer);
            } else if (deletedQuestions.contains(questionScore.questionContent)) {
                System.out.println("the question " + questionIndex + " invalid~0");
            } else {
                questionScore.studentAnswer = answer;
                questionScore.isCorrect = answer.equals(questions.get(questionIndex).answer);
            }
        }

        int totalScore = 0;
        for (QuestionScore qs : paper.questionScores) {
            totalScore += qs.isCorrect ? qs.score : 0;
        }
        System.out.println(studentId + (studentName != null ? " " + studentName : " not found") + ": " + totalScore + "~" + totalScore);
    }

    private static void handleDeleteQuestion(String[] parts) {
        String questionId = parts[0].substring(3);
        deletedQuestions.add(questionId);
    }

    private static void outputResults() {
        // 輸出總分警示
        for (Paper paper : papers.values()) {
            if (paper.totalScore != 100) {
                System.out.println("alert: full score of test paper" + paper.id + " is not 100 points");
            }
        }

        // 輸出每道題的結果
        // 此部分的實現可以根據具體需求調整
    }
}import java.util.*;

public class QuizApp {
    static class Question {
        String content;
        String answer;
        boolean isDeleted;

        public Question(String content, String answer) {
            this.content = content;
            this.answer = answer;
            this.isDeleted = false;
        }
    }

    static class Paper {
        String id;
        List<QuestionScore> questionScores;
        int totalScore;

        public Paper(String id) {
            this.id = id;
            this.questionScores = new ArrayList<>();
            this.totalScore = 0;
        }
    }

    static class QuestionScore {
        String questionContent;
        String studentAnswer;
        boolean isCorrect;
        int score;

        public QuestionScore(String questionContent, String studentAnswer, boolean isCorrect, int score) {
            this.questionContent = questionContent;
            this.studentAnswer = studentAnswer;
            this.isCorrect = isCorrect;
            this.score = score;
        }
    }

    static class Student {
        String id;
        String name;

        public Student(String id, String name) {
            this.id = id;
            this.name = name;
        }
    }

    private static Map<String, Question> questions = new HashMap<>();
    private static Map<String, List<Paper>> papers = new HashMap<>();
    private static Map<String, Student> students = new HashMap<>();
    private static Set<String> deletedQuestions = new HashSet<>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input;
        while (!(input = scanner.nextLine()).equals("end")) {
            processInput(input);
        }
        outputResults();
    }

    private static void processInput(String input) {
        String[] parts = input.split(" ");
        if (input.startsWith("#N:")) {
            // 處理題目資訊
            handleQuestion(parts);
        } else if (input.startsWith("#T:")) {
            // 處理試卷資訊
            handleTestPaper(parts);
        } else if (input.startsWith("#X:")) {
            // 處理學生資訊
            handleStudent(parts);
        } else if (input.startsWith("#S:")) {
            // 處理答卷資訊
            handleStudentAnswer(parts);
        } else if (input.startsWith("#D:")) {
            // 處理刪除題目資訊
            handleDeleteQuestion(parts);
        } else {
            System.out.println("wrong format:" + input);
        }
    }

    private static void handleQuestion(String[] parts) {
        String questionId = parts[0].substring(3);
        String questionContent = parts[1].substring(3);
        String answer = parts[2].substring(3);
        questions.put(questionId, new Question(questionContent, answer));
    }

    private static void handleTestPaper(String[] parts) {
        String testId = parts[0].substring(3);
        List<QuestionScore> questionScores = new ArrayList<>();
        int totalScore = 0;

        for (int i = 1; i < parts.length; i++) {
            String[] questionInfo = parts[i].split("-");
            String questionId = questionInfo[0];
            int score = Integer.parseInt(questionInfo[1]);
            totalScore += score;
            questionScores.add(new QuestionScore(questions.get(questionId).content, "", false, score));
        }

        Paper paper = new Paper(testId);
        paper.questionScores = questionScores;
        paper.totalScore = totalScore;
        papers.put(testId, paper);
    }

    private static void handleStudent(String[] parts) {
        for (int i = 1; i < parts.length; i++) {
            String[] studentInfo = parts[i].split("-");
            String studentId = studentInfo[0];
            String studentName = studentInfo[1];
            students.put(studentId, new Student(studentId, studentName));
        }
    }

    private static void handleStudentAnswer(String[] parts) {
        String testId = parts[0].substring(3);
        String studentId = parts[1];
        String studentName = students.containsKey(studentId) ? students.get(studentId).name : null;

        Paper paper = papers.get(testId);
        if (paper == null) {
            System.out.println("the test paper number does not exist");
            return;
        }

        for (int i = 2; i < parts.length; i++) {
            String[] answerInfo = parts[i].split("-");
            int questionIndex = Integer.parseInt(answerInfo[0]) - 1;
            String answer = answerInfo[1].trim();
            QuestionScore questionScore = paper.questionScores.get(questionIndex);
            if (questionScore.questionContent == null) {
                System.out.println("non-existent question~" + answer);
            } else if (deletedQuestions.contains(questionScore.questionContent)) {
                System.out.println("the question " + questionIndex + " invalid~0");
            } else {
                questionScore.studentAnswer = answer;
                questionScore.isCorrect = answer.equals(questions.get(questionIndex).answer);
            }
        }

        int totalScore = 0;
        for (QuestionScore qs : paper.questionScores) {
            totalScore += qs.isCorrect ? qs.score : 0;
        }
        System.out.println(studentId + (studentName != null ? " " + studentName : " not found") + ": " + totalScore + "~" + totalScore);
    }

    private static void handleDeleteQuestion(String[] parts) {
        String questionId = parts[0].substring(3);
        deletedQuestions.add(questionId);
    }

    private static void outputResults() {
        // 輸出總分警示
        for (Paper paper : papers.values()) {
            if (paper.totalScore != 100) {
                System.out.println("alert: full score of test paper" + paper.id + " is not 100 points");
            }
        }
    }
}

下面是上面這段程式碼原本的思路
類定義：
Question類表示測驗中的題目，包括內容、答案和刪除狀態。
Paper類表示試卷，包含試卷ID、題目分數列表和總分。
QuestionScore類儲存每道題目的分數及學生回答的情況。
Student類包含學生的ID和姓名。
資料儲存：
程式使用三個主要的資料結構：
questions: 儲存所有題目，鍵為題目ID。
papers: 儲存所有試卷，鍵為試卷ID。
students: 儲存所有學生，鍵為學生ID。
deletedQuestions: 儲存被標記為刪除的題目的ID。
輸入處理：
程式透過控制檯讀取輸入（以字串形式），根據不同的字首（如#N:、#T:、#X:、#S:和#D:）呼叫不同的處理函式，新增題目、試卷、學生或處理學生提交的答案。
輸出結果：
程式在輸入結束後檢查每個試卷的總分是否為100，並輸出警告資訊。
因為我的資料的結構不夠完整，答案比較的邏輯錯誤以及handleStudentAnswer方法中的邏輯錯誤等等問題導致這次的題目沒有完成

總結

正規表示式在處理和解析複雜的文字輸入時有很大的優勢，是一種高效、靈活且功能強大的工具。資料結構設計要合理，寫這種複雜的程式，切記不可看完題目直接來敲程式碼，設計思路是重中之重，透過合理的設計可以在寫程式碼是少走很多彎路。

pta大作業總結
2024-06-02
pta答題大作業1~3總結
2024-10-26
題目集4-6次PTA大作業總結
2024-06-09
9.1作業博文
2024-09-01
第4到6次PTA大作業課後分析與反思 BLOG
2024-06-09
第一次至第三次PTAJava大作業分析
2024-04-21
Java
南昌航空大學23201421-PTA1~3次大作業
2024-04-21
南昌航空大學23201421-PTA4~6次大作業
2024-06-09
大作業
2024-05-26
PTA題目集1-3總結（22207331-張博文）
2024-10-26
java第一次到第三次大作業總結
2024-10-25
Java
博文標題
2024-03-17
MySQL大作業
2020-12-03
MySql
java大作業
2018-03-19
Java
南昌空大學第一次PTA小結blog
2024-04-21
PTA大作業家居強電電路模擬7-8 第三次總結Blog
2024-06-29
PTA三次作業
2024-04-21
第二輪PTA作業
2024-06-08
23201421-PTA第7，8次大作業總結-第三次Bolg
2024-06-29
ORACLE 優秀博文收藏
2013-05-31
Oracle
1.博文標題
2024-08-15
Python期末大作業
2020-12-21
Python
軟體工程大作業
2024-06-05
軟體工程
第一次部落格：PTA題目集1-3總結
2023-04-01
PTA4-6次作業
2024-06-09
PTA作業7~8總結
2024-06-30
Python 大作業網易雲歌單資料分析及視覺化（參考多位博主文章）
2023-01-05
Python視覺化
南昌航空大學-軟體學院23201813-第一次pta-blog作業
2024-04-21
BLOG - 個人博文系統開發總結二：使用Lucene完成博文檢索功能
2018-03-20
pta
2024-06-29
OOP大作業二輪總結
2024-06-09
OOP
大作業7-8總結
2024-06-30
PTA第1~3次作業blog
2024-04-21
PTA4~6次作業總結
2024-06-09
【安卓乾貨鋪】-52篇博文分享
2017-11-08
安卓
我的Android博文整理彙總
2015-08-16
Android
黃博文：敏捷地寫部落格
2013-04-15
敏捷
selenium + xpath爬取csdn關於python的博文博主資訊
2020-12-19
Python