一、前言：
這是第二次的blog，接下來關於這最近三次的PTA大作業，只有第一次是上次答題判題程式的延續，接下來則是一個全新的關於電路的設計，最新的電路設計相較於之前的答題判題程式來說的話，難度確實有所下降。前兩次中都含有三道題，而最後一次的PTA則是刪去了其餘兩道題，讓我們專心鑽研新的電路設計。而關於第四次的PTA大作業，第二三題依舊是對於我們基礎的訓練，而由於第一題依舊是前三次的答題判題的迭代，這就導致我沒有辦法去很好的完成它，同時也是我很後悔的一個點，但是段老師為了照顧我們，特意讓蔡老師設計了一個新的，也就是第五、六次的第一題，讓我們可以重新開始設計，不要再踩之前設計的欠缺的坑了。後兩次雖然難度相較於之前要小了，但是對於我來說也是一個不小的挑戰。
二、設計與分析：
PTA第四次作業：
關於P他的第四次大作業，第二題是要求我們設計一個學生類和它的一個子類——本科生類，這道題目呢主要是考察我們對於繼承的理解和運用，所以並不是很複雜，只是一個較為常見的繼承，所以這裡我們就簡單看一下題目和程式碼就行了。
題目描述：
設計一個學生類（Student）和它的一個子類——本科生類（Undergraduate）。要求如下：
（1）Student類有姓名（name）和年齡（age）屬性，兩者的訪問許可權為protected；一個包含兩個引數的構造方法，用於給姓名和年齡屬性賦值；一個show( )方法用於輸出Student的屬性資訊，輸出格式為Student[name=XXX,age=XX]。
（2）Undergraduate類增加一個專業（major）屬性，該屬性的訪問許可權為private；有一個包含三個引數的構造方法，前兩個引數用於給繼承的年齡和姓名屬性賦值，第三個引數給專業屬性賦值；一個show( )方法用於輸出Undergraduate的屬性資訊，輸出格式為Undergraduate[name=XXX,age=XXX,major=XXX]。
在測試類Main的main( )方法中，呼叫Student類的帶引數的構造方法建立物件object1，呼叫Undergraduate類的帶引數的構造方法建立物件object2，然後分別呼叫它們的show( )方法。
輸入格式:
第一行從鍵盤輸入姓名（字串）、年齡（整數）給Student類的物件object1，中間以空格隔開。
第二行從鍵盤輸入姓名（字串）、年齡（整數）、專業（字串）給Undergraduate類的物件object2，中間以空格隔開。
輸出格式:
第一行輸出object1的姓名、年齡，格式為：Student[name=XXX,age=XX]
第二行輸出object2的姓名、年齡、專業，格式為： Undergraduate[name=XXX,age=XXX,major=XXX]
輸入樣例:
在這裡給出一組輸入。例如：
張三 12
李四 19 電腦科學與技術
輸出樣例:
在這裡給出相應的輸出，其中的標點符號為英文格式。例如：
Student[name=張三,age=12]
Undergraduate[name=李四,age=19,major=電腦科學與技術]
接下來是我的一個程式碼實現，因為這題比較簡單我就不放類圖了。
`import java.util.Scanner;
class Student {
protected String name;
protected int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println("Student[name=" + name + ",age=" + age + "]");
}
}
class Undergraduate extends Student {
private String major;
public Undergraduate(String name, int age, String major) {
super(name, age);
this.major = major;
}
public void show() {
System.out.println("Undergraduate[name=" + name + ",age=" + age + ",major=" + major + "]");
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String name1 = scanner.next();
int age1 = scanner.nextInt();
Student object1 = new Student(name1, age1);
String name2 = scanner.next();
int age2 = scanner.nextInt();
String major = scanner.next();
Undergraduate object2 = new Undergraduate(name2, age2, major);
object1.show();
object2.show();
scanner.close();
}
}`
接下來是第四次P他的第一題的題面，相較於上次增加了輸入選擇題題目資訊、輸入填空題題目資訊、輸出順序變化、多張試卷資訊等方面：
設計實現答題程式，模擬一個小型的測試，要求輸入題目資訊、試卷資訊、答題資訊、學生資訊、刪除題目資訊，根據輸入題目資訊中的標準答案判斷答題的結果。本題在答題判題程式-3基礎上新增的內容統一附加在輸出格式說明之後，用粗體標明。
輸入格式:
程式輸入資訊分五種，資訊可能會打亂順序混合輸入。
1、題目資訊
題目資訊為獨行輸入，一行為一道題，多道題可分多行輸入。
格式："#N:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式約束：
1、題目的輸入順序與題號不相關，不一定按題號順序從小到大輸入。
2、允許題目編號有缺失，例如：所有輸入的題號為1、2、5，缺少其中的3號題。此種情況視為正常。
樣例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、試卷資訊
試卷資訊為獨行輸入，一行為一張試卷，多張卷可分多行輸入資料。 \
格式："#T:"+試卷號+" "+題目編號+"-"+題目分值+" "+題目編號+"-"+題目分值+...
格式約束：
題目編號應與題目資訊中的編號對應。
一行資訊中可有多項題目編號與分值。
樣例：#T:1 3-5 4-8 5-2
3、學生資訊
學生資訊只輸入一行，一行中包括所有學生的資訊，每個學生的資訊包括學號和姓名，格式如下。
格式："#X:"+學號+" "+姓名+"-"+學號+" "+姓名....+"-"+學號+" "+姓名
格式約束：
答案數量可以不等於試卷資訊中題目的數量，沒有答案的題目計0分，多餘的答案直接忽略，答案之間以英文空格分隔。
樣例：
#S:1 #A:5 #A:22
1是試卷號
5是1號試卷的順序第1題的題目答案
4、答卷資訊
答卷資訊按行輸入，每一行為一張答卷的答案，每組答案包含某個試卷資訊中的題目的解題答案，答案的順序號與試 卷資訊中的題目順序相對應。答卷中：
格式："#S:"+試卷號+" "+學號+" "+"#A:"+試卷題目的順序號+"-"+答案內容+...
格式約束：
答案數量可以不等於試卷資訊中題目的數量，沒有答案的題目計0分，多餘的答案直接忽略，答案之間以英文空格分隔。
答案內容可以為空，即””。
答案內容中如果首尾有多餘的空格，應去除後再進行判斷。
答卷資訊中僅包含試卷號、學號，而沒有後續內容的，視為一張空白卷，為有效資訊，不做格式錯誤處理。
樣例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是試卷號
20201103是學號
2-5中的2是試卷中順序號，5是試卷第2題的答案，即T中3-2的答案
6-4中的6是試卷中順序號，4是試卷第6題的答案，即T中7-3的答案
注意：不要混淆順序號與題號
5、刪除題目資訊
刪除題目資訊為獨行輸入，每一行為一條刪除資訊，多條刪除資訊可分多行輸入。該資訊用於刪除一道題目資訊，題目被刪除之後，引用該題目的試卷依然有效，但被刪除的題目將以0分計，同時在輸出答案時，題目內容與答案改為一條失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+題目號
格式約束：
題目號與第一項”題目資訊”中的題號相對應，不是試卷中的題目順序號。
本題暫不考慮刪除的題號不存在的情況。
樣例：
N:1 #Q:1+1= #A:2
N:2 #Q:2+2= #A:4
T:1 1-5 2-8
X:20201103 Tom-20201104 Jack
S:1 20201103 #A:1-5 #A:2-4
D:N-2
end
輸出：
alert: full score of test paper1 is not 100 points
1+1=5false
the question 2 invalid~0
20201103 Tom: 0 0~0
答題資訊以一行"end"標記結束，"end"之後的資訊忽略。
輸出格式:
1、試卷總分警示
該部分僅當一張試卷的總分分值不等於100分時作提示之用，試卷依然屬於正常試卷，可用於後面的答題。如果總分等於100 分，該部分忽略，不輸出。
格式："alert: full score of test paper"+試卷號+" is not 100 points"
約束：有多張試卷時，按輸入資訊的先後順序輸出警示。
樣例：alert: full score of test paper2 is not 100 points
2、答卷資訊
一行為一道題的答題資訊，根據試卷的題目的數量輸出多行資料。
格式：題目內容+""+答案++""+判題結果（true/false）
約束：如果輸入的答案資訊少於試卷的題目數量，每一個缺失答案的題目都要輸出"answer is null" 。
樣例：
answer is null
3+2=~5~true
4+6=~22~false.
answer is null
3、判分資訊
判分資訊為一行資料，是一條答題記錄所對應試卷的每道小題的計分以及總分，計分輸出的先後順序與題目題號相對應。
格式：學號+" "+姓名+": "+題目得分+" "+....+題目得分+"~"+總分
格式約束：
1、沒有輸入答案的題目、被刪除的題目、答案錯誤的題目計0分
2、判題資訊的順序與輸入答題資訊中的順序相同
樣例：20201103 Tom: 0 0~0
根據輸入的答卷的數量以上2、3項答卷資訊與判分資訊將重複輸出。
4、被刪除的題目提示資訊
當某題目被試卷引用，同時被刪除時，答案中輸出提示資訊。樣例見第5種輸入資訊“刪除題目資訊”。
5、題目引用錯誤提示資訊
試卷錯誤地引用了一道不存在題號的試題，在輸出學生答案時，提示”non-existent question~”加答案。例如：
輸入：
N:1 #Q:1+1= #A:2
T:1 3-8
X:20201103 Tom-20201104 Jack-20201105 Www
S:1 20201103 #A:1-4
end
輸出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案輸出時，一道題目同時出現答案不存在、引用錯誤題號、題目被刪除，只提示一種資訊，答案不存在的優先順序最高，例如：
輸入：
N:1 #Q:1+1= #A:2
T:1 3-8
X:20201103 Tom-20201104 Jack-20201105 Www
S:1 20201103
end
輸出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式錯誤提示資訊
輸入資訊只要不符合格式要求，均輸出”wrong format:”+資訊內容。
例如：wrong format:2 #Q:2+2= #4
7、試卷號引用錯誤提示輸出
如果答卷資訊中試卷的編號找不到，則輸出”the test paper number does not exist”，答卷中的答案不用輸出，參見樣例8。
8、學號引用錯誤提示資訊
如果答卷中的學號資訊不在學生列表中，答案照常輸出，判分時提示錯誤。參見樣例9。
本次作業新增內容：
1、輸入選擇題題目資訊
題目資訊為獨行輸入，一行為一道題，多道題可分多行輸入。
格式："#Z:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式基本的約束與一般的題目輸入資訊一致。
新增約束：標準答案中如果包含多個正確答案（多選題），正確答案之間用英文空格分隔。
例如：
Z:2 #Q:宋代書法有蘇黃米蔡四家，分別是： #A:蘇軾 黃庭堅 米芾 蔡襄
多選題輸出：
輸出格式與一般答卷題目的輸出一致，判斷結果除了true、false，增加一項”partially correct”表示部分正確。
多選題給分方式：
答案包含所有正確答案且不含錯誤答案給滿分；包含一個錯誤答案或完全沒有答案給0分；包含部分正確答案且不含錯誤答案給一半分，如果一半分值為小數，按截尾規則只保留整數部分。
例如：
N:1 #Q:1+1= #A:2
Z:2 #Q:黨十八大報告提出要加強()建設。A 政務誠信 B 商務誠信 C社會誠信 D司法公信 #A:A B C D
T:1 1-5 2-9
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-A C
end
輸出：
alert: full score of test paper1 is not 100 points
1+1=5false
黨十八大報告提出要加強()建設。A 政務誠信 B 商務誠信 C社會誠信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
2、輸入填空題題目資訊
題目資訊為獨行輸入，一行為一道題，多道題可分多行輸入。
格式："#K:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式基本的約束與一般的題目輸入資訊一致。
例如：#K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
填空題輸出：
輸出格式與一般答卷題目的輸出一致，判斷結果除了true、false，增加一項”partially correct”表示部分正確。
填空題給分方式：
答案與標準答案內容完全匹配給滿分，包含一個錯誤字元或完全沒有答案給0分，包含部分正確答案且不含錯誤字元給一半分，如果一半分值為小數，按截尾規則只保留整數部分。
例如：
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
T:1 1-5 2-10
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-瑤琴
end
輸出：
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被稱為：瑤琴partially correct
20201103 Tom: 0 5~5
3、輸出順序變化
只要是正確格式的資訊，可以以任意的先後順序輸入各類不同的資訊。比如試卷可以出現在題目之前，刪除題目的資訊可以出現在題目之前等。
例如：
T:1 1-5 2-10
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-古箏
end
輸出：
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被稱為：古箏false
20201103 Tom: 0 0~0
4、多張試卷資訊
本題考慮多個同學有多張不同試卷的答卷的情況。輸出順序優先順序為學號、試卷號，按從小到大的順序先按學號排序，再按試卷號。
例如：
T:1 1-5 2-10
T:2 1-8 2-21
N:1 #Q:1+1= #A:2
S:2 20201103 #A:1-2 #A:2-古箏
S:1 20201103 #A:1-5 #A:2-瑤琴或七絃琴
S:1 20201104 #A:1-2 #A:2-瑟
S:2 20201104 #A:1-5 #A:2-七絃琴
X:20201103 Tom-20201104 Jack
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
end
輸出：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=5false
古琴在古代被稱為：瑤琴或七絃琴true
20201103 Tom: 0 10~10
1+1=2true
古琴在古代被稱為：古箏false
20201103 Tom: 8 0~8
1+1=2true
古琴在古代被稱為：瑟false
20201104 Jack: 5 0~5
1+1=5false
古琴在古代被稱為：七絃琴partially correct
20201104 Jack: 0 10~10
新增的題目異常情況的處理與一般題目相同，具體樣例參考上一次大作業的樣例說明：
答題判題程式-3題面.pdf
輸入樣例1:
多選題測試，不含刪除。例如：
N:1 #Q:1+1= #A:2
Z:2 #Q:黨十八大報告提出要加強()建設。A 政務誠信 B 商務誠信 C社會誠信 D司法公信 #A:A B C D
T:1 1-5 2-9
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-A C
end
輸出樣例1:
在這裡給出相應的輸出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
黨十八大報告提出要加強()建設。A 政務誠信 B 商務誠信 C社會誠信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
輸入樣例2:
填空題測試，不含刪除。例如：
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
T:1 1-5 2-10
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-瑤琴
end
輸出樣例2:
在這裡給出相應的輸出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被稱為：瑤琴partially correct
20201103 Tom: 0 5~5
輸入樣例3:
亂序測試，不含刪除。例如：
T:1 1-5 2-10
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-古箏
end
輸出樣例3:
在這裡給出相應的輸出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被稱為：古箏false
20201103 Tom: 0 0~0
輸入樣例4:
兩個同學多張不同試卷的答卷，不含刪除。例如：
T:1 1-5 2-10
T:2 1-8 2-21
N:1 #Q:1+1= #A:2
S:2 20201103 #A:1-2 #A:2-古箏
S:1 20201104 #A:1-2 #A:2-瑟
S:1 20201103 #A:1-5 #A:2-瑤琴或七絃琴
S:2 20201104 #A:1-5 #A:2-七絃琴
X:20201103 Tom-20201104 Jack
K:2 #Q:古琴在古代被稱為： #A:瑤琴或七絃琴
end
輸出樣例4:
在這裡給出相應的輸出。例如：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=5false
古琴在古代被稱為：瑤琴或七絃琴true
20201103 Tom: 0 10~10
1+1=2true
古琴在古代被稱為：古箏false
20201103 Tom: 8 0~8
1+1=2true
古琴在古代被稱為：瑟false
20201104 Jack: 5 0~5
1+1=5false
古琴在古代被稱為：七絃琴partially correct
20201104 Jack: 0 10~10
點選檢視程式碼
import java.util.*;
import java.util.regex.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;
class Question {
private String content;
private String answer;
public Question(String content, String answer) {
this.content = content;
this.answer = answer;
}
public String getContent() {
return content;
}
public String getAnswer() {
return answer;
}
}
class TestPaper {
private int paperNumber;
private Map<Integer, Question> questions = new HashMap<>();
private Map<Integer, Integer> questionScores = new HashMap<>();
public TestPaper(int paperNumber) {
this.paperNumber = paperNumber;
}
public void addQuestion(int number, String content, String answer, int score) {
questions.put(number, new Question(content, answer));
questionScores.put(number, score);
}
public int getPaperNumber() {
return paperNumber;
}
public Map<Integer, Question> getQuestions() {
return questions;
}
public Map<Integer, Integer> getQuestionScores() {
return questionScores;
}
}
class Student {
private String id;
private String name;
// 其他欄位和方法
public Student(String id, String name) {
this.id = id;
this.name = name;
}
// getter 和 setter 方法
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class AnswerSheet {
private TestPaper testPaper;
private String[] answers;
private boolean[] judgments;
public AnswerSheet(TestPaper testPaper) {
this.testPaper = testPaper;
this.answers = new String[testPaper.getQuestionScores().size()];
this.judgments = new boolean[testPaper.getQuestionScores().size()];
}
public void addAnswer(String answer, int index) {
answers[index] = answer;
}
public void judgeAnswers() {
for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
String correctAnswer = testPaper.getQuestions().get(i + 1).getAnswer();
judgments[i] = answers[i] != null && answers[i].equals(correctAnswer);
}
}
public void outputResults(String studentId, String studentName) {
int totalScore = 0;
for (int score : testPaper.getQuestionScores().values()) {
totalScore += score;
}
if (totalScore != 100) {
System.out.println("alert: full score of test paper" + testPaper.getPaperNumber() + " is not 100 points");
}
for (int i = 0; i < answers.length; i++) {
Question question= testPaper.getQuestions().get(i + 1);
if (question != null) {
String content = question.getContent(); // 獲取題目內容
String answer = (answers[i] != null ? answers[i] : "answer is null");
String judgment = String.valueOf(judgments[i]);
String result = content + "~" + answer + "~" + judgment;
System.out.println(result); // 輸出題目內容、學生答案、判斷結果
} else {
System.out.println("the question " + (i + 1) + " invalid ~ 0");
}
}
int totalStudentScore = 0;
for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
if (judgments[i]) {
totalStudentScore += testPaper.getQuestionScores().get(i + 1);
}
}
// 輸出學生的得分情況
System.out.println(studentId + " " + studentName + ": " + formatStudentScore() + "~" + totalStudentScore);
}
private String formatStudentScore() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < testPaper.getQuestionScores().size(); i++) {
sb.append(judgments[i] ? testPaper.getQuestionScores().get(i + 1) : "0").append(" ");
}
return sb.toString().trim();
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
TestPaper testPaper = null;
Map<String, Student> studentMap = new HashMap<>();
String studentId = "";
String studentName = "";
while (true) {
String line = scanner.nextLine();
if (line.equals("end")) {
break;
}
Matcher matcher;
if ((matcher = Pattern.compile("#N:(\\d+) #Q:(.*?) #A:(\\d+)").matcher(line)).matches()) {
// Parse #N: section
int number = Integer.parseInt(matcher.group(1));
String questionContent = matcher.group(2); // 獲取題目內容
String answer = matcher.group(3);
testPaper = new TestPaper(number);
testPaper.addQuestion(number, questionContent, answer, 5); // 將題目內容新增到試卷中
} else if ((matcher = Pattern.compile("#T:(\\d+) (\\d+-\\d+)").matcher(line)).matches()) {
// Parse #T: section
int paperNumber = Integer.parseInt(matcher.group(1));
String[] parts = matcher.group(2).split("-");
int questionNumber = Integer.parseInt(parts[0]);
int score = Integer.parseInt(parts[1]);
testPaper.addQuestion(questionNumber, "", "", score);
} else if ((matcher = Pattern.compile("#X:(\\d+) (.+)").matcher(line)).matches()) {
// Parse #X: section
studentId = matcher.group(1);
studentName = matcher.group(2);
} else if ((matcher = Pattern.compile("#S:(\\d+) (\\d+) #A:(\\d+-\\d+)").matcher(line)).matches()) {
// Parse #S: section
if (testPaper != null) {
AnswerSheet answerSheet = new AnswerSheet(testPaper);
String[] parts = matcher.group(3).split("-");
int questionNumber = Integer.parseInt(parts[0]);
String answer = parts[1];
answerSheet.addAnswer(answer, questionNumber - 1);
answerSheet.judgeAnswers();
answerSheet.outputResults(studentId, studentName);
} else {
System.out.println("Test paper not initialized!");
}
}
}
}
}
上面是我的程式碼，下面是我的類圖：
關於這道題目，相信透過我的類圖也能看出我前幾次設計的問題，從根本上也就是設計上出現了缺陷和漏洞，也就是我的類設計中類太少了，每一個類都承擔了太多的職責，沒法達到單一職責不說，還造成了每一個類都十分的繁瑣和冗長，這也就使得在檢查測試點時，我根本沒法進行有效的修改從而透過測試點，更別提效率問題了。然而這道題目又不僅僅是簡單的設計，它已經無法改變，所以我只能硬著頭皮寫下去，導致我也就不出意外的沒有及格。
第五次PTA:
首先我們看一下他的其他兩道題目，大同小異，都是透過修改老師給的程式碼從而實現功能，由於較為基礎，所以這裡我們隨便挑選一道題目進行展示：
閱讀程式，按照題目需求修改程式
功能需求：
使用集合儲存3個員工的資訊（有序);
透過迭代器依次找出所有的員工。
提示：學生複製以下程式碼到程式設計區，並按需求進行除錯修改。
// 1、匯入相關包
//定義員工類
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函式
public class Main {
public static void main(String[] args) {
// 1、建立有序集合物件
Collection c ;
// 建立3個員工元素物件
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、建立迭代器遍歷集合
Iterator it;
//3、遍歷
while (it.hasnext) {
//4、集合中物件未知，向下轉型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
輸入樣例:
在這裡給出一組輸入。例如：
zs
10
ls
20
ww
30
輸出樣例:
在這裡給出相應的輸出。例如：
zs---10
ls---20
ww---30
接下來是程式碼實現：
點選檢視程式碼
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Scanner;
// 定義員工類
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
// 主函式
public class Main {
public static void main(String[] args) {
// 1、建立有序集合物件
Collection<Employee> c = new ArrayList<>();
// 建立3個員工元素物件
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
String employeeName = sc.nextLine();
int employeeAge = Integer.parseInt(sc.nextLine());
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、建立迭代器遍歷集合
Iterator<Employee> it = c.iterator();
// 3、遍歷
while (it.hasNext()) {
// 4、集合中物件未知，向下轉型
Employee e = it.next();
System.out.println(e.getName()+"---"+e.getAge());
}
}
}
這道題非常簡單我就不過多贅述了，接下來是新增的第一題，這道題目是關於電路設計，下面是題面：
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。
1、控制裝置模擬
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳，而另一個則是輸出引腳。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
分檔調速器
按檔位調整，常見的有3檔、4檔、5檔調速器，檔位值從0檔-2（3/4）檔變化。本次迭代模擬4檔調速器，每個檔位的輸出電位分別為0、0.3、0.6、0.9倍的輸入電壓。
連續調速器
沒有固定檔位，按位置比例得到檔位引數，數值範圍在[0.00-1.00]之間，含兩位小數。輸出電位為檔位引數乘以輸入電壓。
所有調速器都有兩個引腳，一個固定的輸入（引腳編號為1）、一個輸出引腳（引腳編號為2）。當輸入電位為0時，輸出引腳輸出的電位固定為0，不受各類開關調節的影響。
所有控制裝置的初始狀態/檔位為0。
控制裝置的輸入引腳編號為1，輸出引腳編號為2。
2、受控裝置模擬
本題模擬的受控裝置包括：燈、風扇。兩種裝置都有兩根引腳，透過兩根引腳電壓的電壓差驅動裝置工作。
燈有兩種工作狀態：亮、滅。在亮的狀態下，有的燈會因引腳電位差的不同亮度會有區別。
風扇在接電後有兩種工作狀態：停止、轉動。風扇的轉速會因引腳的電位差的不同而有區別。
本次迭代模擬兩種燈具。
白熾燈：
亮度在0~200lux（流明）之間。
電位差為0-9V時亮度為0,其他電位差按比例，電位差10V對應50ux，220V對應200lux，其他電位差與對應亮度值成正比。白熾燈超過220V。
日光燈：
亮度為180lux。
只有兩種狀態，電位差為0時，亮度為0，電位差不為0，亮度為180。
本次迭代模擬一種吊扇。
工作電壓區間為80V-150V，對應轉速區間為80-360轉/分鐘。80V對應轉速為80轉/分鐘，150V對應轉速為360轉/分鐘，超過150V轉速為360轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。其他電壓值與轉速成正比，輸入輸出電位差小於80V時轉速為0。
輸入資訊：
1、裝置資訊
分別用裝置識別符號K、F、L、B、R、D分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
引腳格式：裝置標識-引腳編號，例如：K1-1標識編號為1的開關的輸入引腳。
三種控制開關的輸入引腳編號為1，輸出引腳編號為2。
受控裝置的兩個引腳編號分別為1、2。
約束條件：
不同裝置的編號可以相同。
同種裝置的編號可以不連續。
裝置資訊不單獨輸入，包含在連線資訊中。
2、連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
格式："["+引腳號+" "+...+" "+引腳號+"]"
例如：[K1-1 K3-2 D5-1]表示K1的輸入引腳，K3的輸出引腳，D5的1號引腳連線在一起。
約束條件：
本次迭代不考慮兩個輸出引腳短接的情況
考慮調速器輸出串聯到其他控制裝置（開關）的情況
不考慮調速器串聯到其他調速器的情況。
不考慮各類控制裝置的並聯接入或反饋接入。例如，K1的輸出接到L2的輸入，L2的輸出再接其他裝置屬於串聯接線。K1的輸出接到L2的輸出，同時K1的輸入接到L2的輸入，這種情況屬於並聯。K1的輸出接到L2的輸入，K1的輸入接到L2的輸出，屬於反饋接線。
3、控制裝置調節資訊
開關調節資訊格式：
+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。
分檔調速器的調節資訊格式：
+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。
+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。
連續調速器的調節資訊格式：
+裝置標識L+裝置編號+":" +數值 代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。
4、電源接地標識：VCC，電壓220V，GND，電壓0V。沒有接線的引腳預設接地，電壓為0V。
輸入資訊以end為結束標誌，忽略end之後的輸入資訊。
輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on
@B1:190
@L1:0.60
本題不考慮輸入電壓或電壓差超過220V的情況。
本題只考慮串聯的形式，所以所有測試用例的所有連線資訊都只包含兩個引腳
本題電路中除了開關可能出現多個，其他電路裝置均只出現一次。
電源VCC一定是第一個連線的第一項，接地GND一定是最後一個連線的後一項。
家居電路模擬系列所有題目的預設規則：
1、當計算電壓值等數值的過程中，最終結果出現小數時，用截尾規則去掉小數部分，只保留整數部分。為避免精度的誤差，所有有可能出現小數的數值用double型別儲存並計算，不要作下轉型資料型別轉換，例如電壓、轉速、亮度等，只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出。
2、所有連線資訊按電路從電源到接地的順序依次輸入，不會出現錯位的情況。
3、連線資訊如果只包含兩個引腳，靠電源端的引腳在前，靠接地端的在後。
4、對於調速器，其輸入端只會直連VCC，不會接其他裝置。整個電路中最多隻有一個調速器，且連線在電源上。
家居電路模擬系列1-4題目後續迭代設計：
1、電路結構變化：
迭代1：只有一條線路，所有元件串聯
迭代2：線路中包含一個並聯電路
迭代3：線路中包含多個串聯起來的並聯電路
迭代4：並聯電路之間可能出現包含關係
電路結構變化示意圖見圖1。
2、輸入資訊的變化
串聯線路資訊：用於記錄一段串聯電路的元件與連線資訊。
例如： #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]
並聯線路資訊：用於記錄一段並聯電路所包含的所有串聯電路資訊。
例如：#M1:[T1 T2 T3]
以上格式僅做參考，格式細節可能會調整，以具體釋出的為準。
3、計算方式的變化
迭代1只包含1個受控元件，不用計算電流，之後的電路計算要包含電流、電阻等電路引數。
4、電路元件的變化
每次迭代會增加1-2個新的電路元件。
image.png
圖1：電路結構示意圖
設計建議：
1、電路裝置類：描述所有電路裝置的公共特徵。
2、受控裝置類、控制裝置類：對應受控、控制裝置
3、串聯電路類：一條由多個電路裝置構成的串聯電路，也看成是一個獨立的電路裝置
其他類以及類的屬性、方法自行設計。
image.png
圖2：建議設計類圖
輸入樣例1:
在這裡給出一組輸入。例如：
[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]
K1
end
輸出樣例1:
在這裡給出相應的輸出。例如：
@K1:closed
@D2:360
輸入樣例2:
在這裡給出一組輸入。例如：
[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]
K1
K1
end
輸出樣例2:
在這裡給出相應的輸出。例如：
@K1:turned on
@D2:0
輸入樣例3:
在這裡給出一組輸入。例如：
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
end
輸出樣例3:
在這裡給出相應的輸出。例如：
@F1:1
@D2:0
輸入樣例4:
在這裡給出一組輸入。例如：
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
F1+
end
輸出樣例4:
在這裡給出相應的輸出。例如：
@F1:2
@D2:288
輸入樣例5:
在這裡給出一組輸入。例如：
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
F1+
F1+
end
輸出樣例5:
在這裡給出相應的輸出。例如：
@F1:3
@D2:360
輸入樣例6:
在這裡給出一組輸入。例如：
[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]
L1:1.00
end
輸出樣例6:
在這裡給出相應的輸出。例如：
@L1:1.00
@D2:360
輸入樣例7:
在這裡給出一組輸入。例如：
[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]
L1:0.68
end
輸出樣例7:
在這裡給出相應的輸出。例如：
@L1:0.68
@D2:358
輸入樣例8:
在這裡給出一組輸入。例如：
[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]
L1:0.68
end
輸出樣例8:
在這裡給出相應的輸出。例如：
@L1:0.68
@B2:149
輸入樣例9:
在這裡給出一組輸入。例如：
[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]
L1:1.00
end
輸出樣例9:
在這裡給出相應的輸出。例如：
@L1:1.00
@B2:200
輸入樣例10:
在這裡給出一組輸入。例如：
[VCC L1-1]
[L1-2 R2-1]
[R2-2 GND]
end
輸出樣例10:
在這裡給出相應的輸出。例如：
@L1:1.00
@R2:180
關於這道題目其實我想說，這個引腳之間的電壓差是非常重要的一點，因為受控裝置的燈和風扇都隨著引腳間電壓差的變化而發生改變，同時這道題目由於不需要考慮短接以及其他的並聯等情況，所以一開始看上去還是比較簡單的。
下面是我的程式碼：
點選檢視程式碼
import java.util.*;
abstract class Device {
protected String deviceType;
protected int inputPin;
protected int outputPin;
protected double inputVoltage = 0;
protected String currentState;
public Device(String deviceType, int inputPin, int outputPin) {
this.deviceType = deviceType;
this.inputPin = inputPin;
this.outputPin = outputPin;
this.currentState = "0";
}
public abstract void setState(String state);
public abstract double calculateOutput();
public String getDeviceType() {
return deviceType;
}
public double getInputVoltage() {
return inputVoltage;
}
public void setInputVoltage(double inputVoltage) {
this.inputVoltage = inputVoltage;
}
public String getCurrentState() {
return currentState;
}
}
class Switch extends Device {
public Switch(int inputPin, int outputPin) {
super("Switch", inputPin, outputPin);
}
@Override
public void setState(String state) {
this.currentState = state;
}
@Override
public double calculateOutput() {
return currentState.equals("1") ? inputVoltage : 0;
}
@Override
public String getCurrentState() {
return currentState.equals("1") ? "closed" : "turned on";
}
}
class StepRegulator extends Device {
private static final double[] OUTPUT_MULTIPLIERS = {0, 0.3, 0.6, 0.9};
private int level;
public StepRegulator(int inputPin, int outputPin) {
super("StepRegulator", inputPin, outputPin);
this.level = 0;
}
@Override
public void setState(String state) {
if (state.equals("+")) {
level = Math.min(level + 1, OUTPUT_MULTIPLIERS.length - 1);
} else if (state.equals("-")) {
level = Math.max(level - 1, 0);
}
this.currentState = Integer.toString(level);
}
@Override
public double calculateOutput() {
return inputVoltage * OUTPUT_MULTIPLIERS[level];
}
}
class ContinuousRegulator extends Device {
private double position;
public ContinuousRegulator(int inputPin, int outputPin) {
super("ContinuousRegulator", inputPin, outputPin);
this.position = 0.0;
}
@Override
public void setState(String state) {
this.position = Double.parseDouble(state);
this.currentState = String.format("%.2f", position);
}
@Override
public double calculateOutput() {
return inputVoltage * position;
}
}
abstract class ControlledDevice extends Device {
public ControlledDevice(String deviceType, int inputPin, int outputPin) {
super(deviceType, inputPin, outputPin);
}
}
class IncandescentLight extends ControlledDevice {
public IncandescentLight(int inputPin, int outputPin) {
super("IncandescentLight", inputPin, outputPin);
}
@Override
public void setState(String state) {
// Not applicable for this type
}
@Override
public double calculateOutput() {
double voltageDifference = inputVoltage;
if (voltageDifference <= 9) {
return 0;
}
return Math.min(200, (voltageDifference / 220) * 200);
}
}
class FluorescentLight extends ControlledDevice {
public FluorescentLight(int inputPin, int outputPin) {
super("FluorescentLight", inputPin, outputPin);
}
@Override
public void setState(String state) {
// Not applicable for this type
}
@Override
public double calculateOutput() {
double voltageDifference = inputVoltage;
return voltageDifference > 0 ? 180 : 0;
}
}
class Fan extends ControlledDevice {
public Fan(int inputPin, int outputPin) {
super("Fan", inputPin, outputPin);
}
@Override
public void setState(String state) {
// Not applicable for this type
}
@Override
public double calculateOutput() {
double voltageDifference = inputVoltage;
if (voltageDifference < 80) {
return 0;
} else if (voltageDifference > 150) {
return 360;
} else {
return (voltageDifference - 80) / 70 * 280 + 80;
}
}
}
public class Main {
private static Map<String, Device> devices = new HashMap<>();
private static Map<String, List<String>> connections = new HashMap<>();
private static Map<String, Double> voltages = new HashMap<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String line = scanner.nextLine().trim();
if (line.equals("end")) {
break;
}
if (line.startsWith("[")) {
parseConnection(line);
} else if (line.startsWith("#")) {
parseControl(line);
}
}
updateVoltages();
printDeviceStates();
}
private static void parseConnection(String line) {
line = line.substring(1, line.length() - 1).trim();
String[] parts = line.split(" ");
for (String part : parts) {
connections.putIfAbsent(part, new ArrayList<>());
for (String p : parts) {
if (!p.equals(part)) {
connections.get(part).add(p);
}
}
}
for (String part : parts) {
if (part.startsWith("VCC")) {
voltages.put(part, 220.0);
} else if (part.startsWith("GND")) {
voltages.put(part, 0.0);
} else {
String deviceType = part.substring(0, 1);
int deviceId = Integer.parseInt(part.substring(1, part.indexOf('-')));
int pin = Integer.parseInt(part.substring(part.indexOf('-') + 1));
Device device;
switch (deviceType) {
case "K":
device = new Switch(1, 2);
break;
case "F":
device = new StepRegulator(1, 2);
break;
case "L":
device = new ContinuousRegulator(1, 2);
break;
case "B":
device = new IncandescentLight(1, 2);
break;
case "R":
device = new FluorescentLight(1, 2);
break;
case "D":
device = new Fan(1, 2);
break;
default:
continue;
}
devices.put(deviceType + deviceId, device);
}
}
}
private static void parseControl(String line) {
String deviceId = line.substring(1, 3);
Device device = devices.get(deviceId);
if (device instanceof Switch) {
((Switch) device).setState(device.getCurrentState().equals("1") ? "0" : "1");
} else if (device instanceof StepRegulator) {
((StepRegulator) device).setState(line.charAt(3) == '+' ? "+" : "-");
} else if (device instanceof ContinuousRegulator) {
((ContinuousRegulator) device).setState(line.substring(4));
}
}
private static void updateVoltages() {
for (String key : connections.keySet()) {
if (voltages.containsKey(key)) {
updateVoltage(key, voltages.get(key));
}
}
}
private static void updateVoltage(String pin, double voltage) {
voltages.put(pin, voltage);
for (String connectedPin : connections.get(pin)) {
if (!voltages.containsKey(connectedPin)) {
voltages.put(connectedPin, voltage);
String deviceId = connectedPin.substring(0, connectedPin.indexOf('-'));
Device device = devices.get(deviceId);
if (device != null) {
if (connectedPin.endsWith("1")) {
device.setInputVoltage(voltage);
}
}
updateVoltage(connectedPin, voltage);
}
}
}
private static void printDeviceStates() {
List<String> deviceTypes = Arrays.asList("K", "F", "L", "B", "R", "D");
for (String type : deviceTypes) {
devices.entrySet().stream()
.filter(e -> e.getKey().startsWith(type))
.sorted(Comparator.comparingInt(e -> Integer.parseInt(e.getKey().substring(1))))
.forEach(e -> {
Device device = e.getValue();
String state = device instanceof ContinuousRegulator ?
String.format("%.2f", Double.parseDouble(device.getCurrentState())) :
device instanceof Switch ? device.getCurrentState() :
String.valueOf((int) device.calculateOutput());
System.out.println("@" + e.getKey() + ":" + state);
});
}
}
}
下面是我的類圖：
在這個電路設計上我吸取了上一次設計的教訓，避開了我的缺點，所以我這次設計了多個類使它們各司其職，從而較好的完成單一職責，具體的類間關係以及他們各自的方法之類的我就不過多贅述了，可以從我的類圖中看出。關於這次的題目，我認為這道題目的關鍵點在於處理狀態管理和裝置的初始狀態和狀態切換邏輯；以及電壓傳播，因為它根據連線關係傳播電壓，從而影響裝置狀態；還有指令處理，包括解析和執行控制裝置的調節指令；最後是輸出生成，要按要求輸出所有裝置的當前狀態或引數。雖然話是這麼說，但是我沒有辦法把這些都給實現，所以這次相對簡單的大作業我也沒有達到要求，但是我也在努力尋找解題的關鍵點，希望能慢慢得高分。接下來是第六次大作業。
第六次PTA作業：
這次的作業就只有一道傢俱強電電路問題了，也是延續上一次的題目，話不多說直接上題目要求：
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-1”的基礎上增加的功能要求。
1、控制裝置
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳，而另一個則是輸出引腳。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
分檔調速器
按檔位調整，常見的有3檔、4檔、5檔調速器，檔位值從0檔-2（3/4）檔變化。本次迭代模擬4檔調速器，每個檔位的輸出電位分別為0、0.3、0.6、0.9倍的輸入電壓。
連續調速器
沒有固定檔位，按位置比例得到檔位引數，數值範圍在[0.00-1.00]之間，含兩位小數。輸出電位為檔位引數乘以輸入電壓。
所有調速器都有兩個引腳，一個固定的輸入（引腳編號為1）、一個輸出引腳（引腳編號為2）。當輸入電位為0時，輸出引腳輸出的電位固定為0，不受各類開關調節的影響。
所有控制裝置的初始狀態/檔位為0。
控制裝置的輸入引腳編號為1，輸出引腳編號為2。
所有開關的電阻為 0。
2、受控裝置
本題模擬的受控裝置包括：燈、風扇。兩種裝置都有兩根引腳，透過兩根引腳電壓的電壓差驅動裝置工作。
燈有兩種工作狀態：亮、滅。在亮的狀態下，有的燈會因引腳電位差的不同亮度會有區別。
風扇在接電後有兩種工作狀態：停止、轉動。風扇的轉速會因引腳間電位差的不同而有區別。
本次迭代模擬兩種燈具。
白熾燈：
亮度在0~200lux（流明）之間。
電位差為0-9V時亮度為0,其他電位差按比例，電位差10V對應50ux，220V對應200lux，其他電位差與對應亮度值成正比。白熾燈超過220V。
日光燈：
亮度為180lux。
只有兩種狀態，電位差為0時，亮度為0，電位差不為0，亮度為180。
本次迭代模擬一種吊扇。
工作電壓區間為80V-150V，對應轉速區間為80-360轉/分鐘。80V對應轉速為80轉/分鐘，150V對應轉速為360轉/分鐘，超過150V轉速為360轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。其他電壓值與轉速成正比，輸入輸出電位差小於80V時轉速為0。
本次迭代模擬一種落地扇。
工作電壓區間為 [80V,150V]，對應轉速區間為 80-360 轉/分鐘。電壓在[80,100)V 區間對應轉速為 80 轉/分 鍾，[100-120)V 區間對應轉速為 160 轉/分鐘，[120-140)V 區間對應轉速為 260 轉/分鐘，超過 140V 轉速 為 360 轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）輸入資訊：
本次迭代考慮電阻：白熾燈的電阻為 10，日光燈的電阻為 5，吊扇的電阻為 20，落 地扇的電阻為 20
3、輸入資訊
1）輸入裝置資訊
分別用裝置識別符號K、F、L、B、R、D、A分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
引腳格式：裝置標識-引腳編號，例如：K1-1標識編號為1的開關的輸入引腳。
三種控制開關的輸入引腳編號為1，輸出引腳編號為2。
受控裝置的兩個引腳編號分別為1、2。
約束條件：
不同裝置的編號可以相同。
同種裝置的編號可以不連續。
裝置資訊不單獨輸入，包含在連線資訊中。
2）輸入連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
格式："["+引腳號+" "+...+" "+引腳號+"]"
例如：[K1-1 K3-2 D5-1]表示K1的輸入引腳，K3的輸出引腳，D5的1號引腳連線在一起。
約束條件：
不考慮調速器串聯到其他調速器的情況。
不考慮調速器串聯到其他調速器的情況。
考慮各類裝置的並聯接入。例如，K1 的輸出接到 L2 的輸入，L2 的輸出再接其他裝置屬於串聯接線。K1 的輸出接到 L2 的輸出，同時 K1 的輸入接到 L2 的輸入，這種情況屬於並聯。
本次迭代的連線資訊不單獨輸入，包含線上路資訊中。
3）輸入控制裝置調節資訊
開關調節資訊格式：
+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。
分檔調速器的調節資訊格式：
+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。
+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。
連續調速器的調節資訊格式：
+裝置標識L+裝置編號+":" +數值 代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。
4）電源接地標識：
VCC，電壓220V，GND，電壓0V。沒有接線的引腳預設接地，電壓為0V。
5）輸入串聯電路資訊
一條串聯電路佔一行，串聯電路由按從靠電源端到接地端順序依次輸入的 n 個連線 資訊組成，連線資訊之間用英文空格" "分隔。
串聯電路資訊格式：
"#T"+電路編號+":"+連線資訊+" "+連線資訊+...+" "+連線資訊
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一個串聯電路的第一個引腳是 IN，代表起始端，靠電源。最後一個引腳是 OUT，代表結尾端， 靠接地。
約束條件：
不同的串聯電路資訊編號不同。
輸入的最後一條電路資訊必定是總電路資訊，總電路資訊的起始引腳是 VCC，結束引腳是 GND。
連線資訊中的引腳可能是一條串聯或並聯電路的 IN 或者 OUT。例如：
T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]
T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]
6）輸入並聯電路資訊
一條並聯電路佔一行，並聯電路由其包含的幾條串聯電路組成，串聯電路標識之間用英文空格" "分隔。
格式：
"#M"+電路編號+":"+”[”+串聯電路資訊+" "+....+" "+串聯電路資訊+”]”
例如：#M1:[T1 T2 T3]
該例宣告瞭一個並聯電路，由 T1、T2、T3 三條串聯電路並聯而成，三條串聯電路的 IN 短 接在一起構成 M1 的 IN，三條串聯電路的 OUT 短接在一起構成 M1 的 OUT。
約束條件：
本次迭代不考慮並聯電路中包含並聯電路的情況，也不考慮多個並聯電路串聯的情況。
本題不考慮輸入電壓或電壓差超過220V的情況。
輸入資訊以end為結束標誌，忽略end之後的輸入資訊。
本題中的並聯資訊所包含的串聯電路的資訊都在並聯資訊之前輸入，不考慮亂序輸入的情況。
電路中的短路如果不會在電路中產生無窮大的電流燒壞電路，都是合理情況，在本題測試點的考慮範圍之內。
本題不考慮一條串聯電路中包含其他串聯電路的情況。例如：
T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]
本例中T1\T2兩條串聯電路實際是T3的一個部分，本題不考慮這種型別的輸入，而是當將T1\T2的所有連線資訊直接包含在T3中定義。
下次迭代中需要考慮這種型別的輸入。
4、輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on
@B1:190
@L1:0.60
5、家居電路模擬系列所有題目的預設規則：
1）當計算電壓值等數值的過程中，最終結果出現小數時，用截尾規則去掉小數部分，只保留整數部分。為避免精度的誤差，所有有可能出現小數的數值用double型別儲存並計算，不要作下轉型資料型別轉換，例如電壓、轉速、亮度等，只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出。
2）所有連線資訊按電路從電源到接地的順序依次輸入，不會出現錯位的情況。電源VCC一定是第一個連線的第一項，接地GND一定是最後一個連線的後一項。
3）連線資訊如果只包含兩個引腳，靠電源端的引腳在前，靠接地端的在後。
4）調速器的輸入端只會直連VCC，不會接其他裝置。整個電路最多隻有連線在電源上的一個調速器，且不包含在並聯單路中。
6、家居電路模擬系列1-4題目後續迭代設計：
1）電路結構變化：
迭代1：只有一條線路，所有元件串聯
迭代2：線路中包含一個並聯電路
迭代3：線路中包含多個串聯起來的並聯電路
迭代4：並聯電路之間可能出現包含關係
電路結構變化示意圖見圖1。
2）計算方式的變化
迭代1只包含1個受控元件，不用計算電流，之後的電路計算要包含電流、電阻等電路引數。
3）電路元件的變化
每次迭代會增加1-2個新的電路元件。
image.png
圖1：電路結構示意圖
設計建議：
1、電路裝置類：描述所有電路裝置的公共特徵。
2、受控裝置類、控制裝置類：對應受控、控制裝置
3、串聯電路類：一條由多個電路裝置構成的串聯電路，也看成是一個獨立的電路裝置
4、並聯電路類：繼承電路裝置類，也看成是一個獨立的電路裝置
其他類以及類的屬性、方法自行設計。
image.png
圖2：建議設計類圖
輸入格式:
請在這裡寫輸入格式。例如：輸入在一行中給出2個絕對值不超過1000的整數A和B。
輸出格式:
請在這裡描述輸出格式。例如：對每一組輸入，在一行中輸出A+B的值。
輸入樣例1:
在這裡給出一組輸入。例如：
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
end
輸出樣例1:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:turned on
@L1:0.00
@D1:0
@D2:0
@D3:0
輸入樣例2:
在這裡給出一組輸入。例如：
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
L1:1.00
end
輸出樣例2:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:turned on
@L1:1.00
@D1:0
@D2:200
@D3:200
輸入樣例3:
在這裡給出一組輸入。例如：
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
K2
L1:1.00
end
輸出樣例3:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:closed
@L1:1.00
@D1:0
@D2:0
@D3:346
這一次給出的測試點較少，輸入輸出樣例也少。我認為這道題目還是比較棘手的，接下來是我修改後的新程式碼，但是編譯器沒有按預期生成二進位制檔案，所以我這道題目並沒有透過測試點。
點選檢視程式碼
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
class Circuit {
private Map<String, Device> devices = new HashMap<>();
private List<List<String>> connections = new ArrayList<>();
public void addDevice(Device device) {
devices.put(device.getId(), device);
}
public Device getDevice(String id) {
return devices.get(id);
}
public void addConnection(List<String> connection) {
connections.add(connection);
}
public void updateVoltage() {
for (List<String> connection : connections) {
double voltage = 220;
for (String pin : connection) {
if (pin.contains("-")) { // 檢查連線資訊是否包含分隔符
String[] parts = pin.split("-");
String deviceId = parts[0];
int pinNumber = Integer.parseInt(parts[1]);
Device device = devices.get(deviceId);
if (device != null) {
if (pinNumber == 1) {
device.setVoltage(voltage);
} else {
voltage = device.getVoltage();
}
}
} else {
System.out.println("Invalid connection format: " + pin);
}
}
}
}
public void printStatus() {
devices.values().stream()
.sorted(Comparator.comparing(Device::getId))
.forEach(device -> System.out.println("@" + device.getId() + ":" + device.getStatus()));
}
}
abstract class AbstractDevice implements Device {
protected String id;
protected double voltage;
public AbstractDevice(String id) {
this.id = id;
this.voltage = 0.0;
}
public String getId() {
return id;
}
public double getVoltage() {
return voltage;
}
public void setVoltage(double voltage) {
this.voltage = voltage;
}
public abstract String getStatus();
}
class CeilingFan extends Fan {
public CeilingFan(String id) {
super(id);
}
@Override
public double getVoltage() {
if (voltage < 80) return 0;
return Math.min(360, ((voltage - 80) / (150 - 80)) * (360 - 80) + 80);
}
@Override
public String getStatus() {
return String.valueOf((int) getVoltage());
}
}
class ContinuousController extends AbstractDevice {
private double level;
public ContinuousController(String id) {
super(id);
this.level = 0.0;
}
public void setLevel(double level) {
if (level >= 0.0 && level <= 1.0) {
this.level = level;
}
}
@Override
public double getVoltage() {
return voltage * level;
}
@Override
public String getStatus() {
return String.format("%.2f", level);
}
}
interface Device {
String getId();
double getVoltage();
void setVoltage(double voltage);
String getStatus();
}
abstract class Fan extends AbstractDevice {
public Fan(String id) {
super(id);
}
protected double calculateSpeed(double voltage) {
return 0.0;
}
}
class FloorFan extends Fan {
public FloorFan(String id) {
super(id);
}
@Override
public double getVoltage() {
if (voltage < 80) return 0;
else if (voltage < 100) return 80;
else if (voltage < 120) return 160;
else if (voltage < 140) return 260;
else return 360;
}
@Override
public String getStatus() {
return String.valueOf((int) getVoltage());
}
}
class FluorescentLight extends Light {
public FluorescentLight(String id) {
super(id);
}
@Override
public double getVoltage() {
return voltage == 0 ? 0 : 180;
}
@Override
public String getStatus() {
return String.valueOf((int) getVoltage());
}
}
class IncandescentLight extends Light {
public IncandescentLight(String id) {
super(id);
}
@Override
public double getVoltage() {
if (voltage < 10) return 0;
return Math.min(200, (voltage / 220) * 200);
}
@Override
public String getStatus() {
return String.valueOf((int) getVoltage());
}
}
abstract class Light extends AbstractDevice {
public Light(String id) {
super(id);
}
protected double calculateBrightness(double voltage) {
return 0.0;
}
}
class SmartHomeSimulation {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Circuit circuit = new Circuit();
while (scanner.hasNextLine()) {
String line = scanner.nextLine().trim();
if (line.equals("end")) break;
if (line.startsWith("#")) {
// Process control commands
if (line.contains(":")) {
String[] parts = line.split(":");
String command = parts[0];
String info = parts[1];
if (command.startsWith("#T")) {
// Handle series circuit
List<String> connection = Arrays.asList(info.replace("[", "").replace("]", "").split(" "));
circuit.addConnection(connection);
} else if (command.startsWith("#M")) {
// Handle parallel circuit
String[] seriesCircuits = info.replace("[", "").replace("]", "").split(" ");
for (String seriesCircuit : seriesCircuits) {
List<String> connection = Arrays.asList(seriesCircuit.split(" "));
circuit.addConnection(connection);
}
}
} else {
// Handle device adjustment
char type = line.charAt(1);
String id = line.substring(2);
if (type == 'K') {
Switch sw = (Switch) circuit.getDevice(id);
if (sw != null) {
sw.toggle();
}
} else if (type == 'F') {
StepController sc = (StepController) circuit.getDevice(id);
if (line.endsWith("+")) {
sc.increaseLevel();
} else if (line.endsWith("-")) {
sc.decreaseLevel();
}
} else if (type == 'L') {
ContinuousController cc = (ContinuousController) circuit.getDevice(id);
double level = Double.parseDouble(line.split(":")[1]);
cc.setLevel(level);
}
}
} else if (line.startsWith("[")) {
// Process connection information
List<String> connection = Arrays.asList(line.replace("[", "").replace("]", "").split(" "));
circuit.addConnection(connection);
} else {
// Add device
String[] parts = line.split(" ");
for (String part : parts) {
char type = part.charAt(0);
String id = part.substring(1);
switch (type) {
case 'K':
circuit.addDevice(new Switch(id));
break;
case 'F':
circuit.addDevice(new StepController(id));
break;
case 'L':
circuit.addDevice(new ContinuousController(id));
break;
case 'B':
circuit.addDevice(new IncandescentLight(id));
break;
case 'R':
circuit.addDevice(new FluorescentLight(id));
break;
case 'D':
circuit.addDevice(new CeilingFan(id));
break;
case 'A':
circuit.addDevice(new FloorFan(id));
break;
}
}
}
}
circuit.updateVoltage();
circuit.printStatus();
}
}
class StepController extends AbstractDevice {
private int level;
private double[] levels = {0.0, 0.3, 0.6, 0.9};
public StepController(String id) {
super(id);
this.level = 0;
}
public void increaseLevel() {
if (level < levels.length - 1) level++;
}
public void decreaseLevel() {
if (level > 0) level--;
}
@Override
public double getVoltage() {
return voltage * levels[level];
}
@Override
public String getStatus() {
return String.valueOf(level);
}
}
class Switch extends AbstractDevice {
private boolean isOn;
public Switch(String id) {
super(id);
this.isOn = false;
}
public void toggle() {
this.isOn = !this.isOn;
}
@Override
public double getVoltage() {
return isOn ? voltage : 0;
}
@Override
public String getStatus() {
return isOn ? "turned on" : "closed";
}
}
關於這道題目呢，我認為還是在於處理狀態管理和裝置的初始狀態和狀態切換邏輯的問題上需要下心思去琢磨。
三、踩坑心得
我們在寫程式碼的時候經常可能會出現陣列越界的問題，就像是我的Circuit類中的updateVoltage方法中，就因為疏忽而出現了這個問題，這是我之前的程式碼：
點選檢視程式碼
public void updateVoltage() {
for (List<String> connection : connections) {
double voltage = 220;
for (String pin : connection) {
String deviceId = pin.split("-")[0];
int pinNumber = Integer.parseInt(pin.split("-")[1]); // 這裡出現越界異常
Device device = devices.get(deviceId);
if (device != null) {
if (pinNumber == 1) {
device.setVoltage(voltage);
} else {
voltage = device.getVoltage();
}
}
}
}
}
點選檢視程式碼
public void updateVoltage() {
for (List<String> connection : connections) {
double voltage = 220;
for (String pin : connection) {
if (pin.contains("-")) { // 檢查連線資訊是否包含分隔符
String[] parts = pin.split("-");
String deviceId = parts[0];
int pinNumber = Integer.parseInt(parts[1]);
Device device = devices.get(deviceId);
if (device != null) {
if (pinNumber == 1) {
device.setVoltage(voltage);
} else {
voltage = device.getVoltage();
}
}
} else {
System.out.println("Invalid connection format: " + pin);
}
}
}
}
四、改進建議：
我認為呢，改進的不應該是題目，而是自己，自己的思維要進行轉變和更新。
五、總結：
現在作業也已經做到了第六次，還剩最後幾次就結束了，現在這個新的電路設計是可以很好的幫助我這種之前並沒有很好的完成前面一次設計的同學的，透過這些程式的編寫啊，課程的設計啊，以及配套的教學，我認為我們是可以學習到很多東西的。類似於在程式中使用類和物件的概念，將裝置、電路等抽象為物件，並實現它們之間的互動和功能。又或者是使用合適的資料結構來儲存裝置資訊和連線資訊。還有學習如何處理可能出現的異常情況，例如陣列越界異常、裝置未找到等，保證程式的穩定性和健壯性，以及如何進行檔案讀寫操作。這些都是我們以後可能會用到的技能。最後我想說還是加油吧，最起碼也要跟上大家的步伐！共同進步！！！