- 前言
- [ 1 ] 知識點：本次PTA主要是新增的知識點是類的繼承和多型，第4次題目集是針對類的繼承，第5，6次題目集是針對類的多型。
- [ 2 ] 題量：第4次和第5次題目集都是三題，第6次題目集是一題，題量不是很大
- [ 3 ] 難度：第4次題目集還是答題判題程式，難度還行，就是增加了選擇題和填空題，我感覺難點就是多選和多填的情況。第5，6次題目集是家居強電電路模擬程式。這個程式的難點就在於會有串並聯電路連線和計算各個部分的分壓。
- 設計與分析
- [ 1 ] 答題判題程式-4
題目要求：設計實現答題程式，模擬一個小型的測試，要求輸入題目資訊、試卷資訊、答題資訊、學生資訊、刪除題目資訊，根據輸入題目資訊中的標準答案判斷答題的結果。
點選檢視題目具體要求
輸入格式:
程式輸入資訊分五種，資訊可能會打亂順序混合輸入。
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=~5~false
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=~5~false
黨十八大報告提出要加強()建設。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=~5~false
古琴在古代被稱為：~瑤琴~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=~5~false
古琴在古代被稱為：~古箏~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=~5~false
古琴在古代被稱為：~瑤琴或七絃琴~true
20201103 Tom: 0 10~10
1+1=~2~true
古琴在古代被稱為：~古箏~false
20201103 Tom: 8 0~8
1+1=~2~true
古琴在古代被稱為：~瑟~false
20201104 Jack: 5 0~5
1+1=~5~false
古琴在古代被稱為：~七絃琴~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=~5~false
黨十八大報告提出要加強()建設。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=~5~false
古琴在古代被稱為：~瑤琴~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=~5~false
古琴在古代被稱為：~古箏~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=~5~false
古琴在古代被稱為：~瑤琴或七絃琴~true
20201103 Tom: 0 10~10
1+1=~2~true
古琴在古代被稱為：~古箏~false
20201103 Tom: 8 0~8
1+1=~2~true
古琴在古代被稱為：~瑟~false
20201104 Jack: 5 0~5
1+1=~5~false
古琴在古代被稱為：~七絃琴~partially correct
20201104 Jack: 0 10~10
class ZQuestion extends Question{
}
class KQuestion extends Question{
}
這是選擇題和填空題的類，直接繼承了普通題。
ZQuestion q=new ZQuestion();
String str = a.substring(a.indexOf("#Z:") + 3, a.indexOf("#Q:"));
str = str.strip();
q.setNum(Integer.parseInt(str));
q.setQue(a.substring(a.indexOf("#Q:") + 3, a.indexOf("#A:")));
q.setQue(q.getQue().strip());
q.setAns(a.substring(a.indexOf("#A:") + 3));
q.setAns(q.getAns().strip());
q.setExist(true);
ZQue.add(q);
KQuestion q=new KQuestion();
String str = a.substring(a.indexOf("#K:") + 3, a.indexOf("#Q:"));
str = str.strip();
q.setNum(Integer.parseInt(str));
q.setQue(a.substring(a.indexOf("#Q:") + 3, a.indexOf("#A:")));
q.setQue(q.getQue().strip());
q.setAns(a.substring(a.indexOf("#A:") + 3));
q.setAns(q.getAns().strip());
q.setExist(true);
KQue.add(q);
這是選擇題和填空題的題目儲存，和普通題一樣的。
for(int i=0;i<Que.length;i++)
{
if(Que[i].getNum() ==Del.get(j).getNum())
Que[i].setExist(false);
}
for(int i=0;i<ZQue.size();i++)
{
if(ZQue.get(i).getNum()==Del.get(j).getNum())
ZQue.get(i).setExist(false);
}
for(int i=0;i<KQue.size();i++)
{
if(KQue.get(i).getNum()==Del.get(j).getNum())
KQue.get(i).setExist(false);
}
這是將題庫裡要刪除的題目刪除。
if(Que[z].getAns().compareTo(Ans[i].getAns()[j])==0&& Que[z].isExist())
{
Ans[i].getPoint()[j]+= Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint();
Ans[i].getCheck()[j]= String.valueOf(true);
Ans[i].setSum(Ans[i].getSum()+ Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint());
}
if(ZQue.get(z).getNum() == Tes[x].que[Ans[i].getAnu()[j] - 1].getNum()&&ZQue.get(z).getExist())
{
String tres=Ans[i].getAns()[j].strip();
String[] ans=ZQue.get(z).getAns().split(" ");
String[] res=tres.split(" ");
int t=0;
boolean rig=true;
for(int k=0;k < res.length&&rig;k++) {
for(int l=0;l < ans.length;l++){
if(res[k].equals(ans[l])){
t++;
break;
}
else if(l == ans.length-1){
rig=false;
}
}
}
if(rig){
if(t==ans.length){
Ans[i].getPoint()[j]+= Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint();
Ans[i].getCheck()[j]= String.valueOf(true);
Ans[i].setSum(Ans[i].getSum()+ Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint());
}
else {
Ans[i].getPoint()[j]+= Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint()/2;
Ans[i].getCheck()[j]= "partially correct";
Ans[i].setSum(Ans[i].getSum()+ Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint()/2);
}
}
}
if(KQue.get(z).getNum() == Tes[x].que[Ans[i].getAnu()[j] - 1].getNum()&&KQue.get(z).getExist())
{
String tres=Ans[i].getAns()[j].strip();
String[] ans=KQue.get(z).getAns().split("或");
String[] res=tres.split("或");
int t=0;
boolean rig=true;
for(int k=0;k < res.length&&rig;k++) {
for(int l=0;l < ans.length;l++){
if(res[k].equals(ans[l])){
t++;
break;
}
else if(l == ans.length-1){
rig=false;
}
}
}
if(rig){
if(t==ans.length){
Ans[i].getPoint()[j]+= Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint();
Ans[i].getCheck()[j]= String.valueOf(true);
Ans[i].setSum(Ans[i].getSum()+ Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint());
}
else {
Ans[i].getPoint()[j]+= Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint()/2;
Ans[i].getCheck()[j]= "partially correct";
Ans[i].setSum(Ans[i].getSum()+ Tes[x].que[Ans[i].getAnu()[j] - 1].getPoint()/2);
}
}
}
這是對答卷的批改，統分。選擇題和填空題當出現多個答案時，選擇題是按空格分開，填空題是按或分開，所以用split分割就行。然後再判斷答案的正誤，我是用了一個計數器來統計答對的個數，只要有一個答錯就是零分，如果沒有錯誤的答案，拿就看答對的個數和正確答案的個數是否相等，相等就是滿分，小於正確答案個數就是一半的分，但是這個程式的最後得分沒有小數，得的一半分會向下取整。
for (int y = 0; y < Tes[x].que.length; y++) {
for(int j = 0; j< Ans[i].getAns().length; j++)
{
if(Ans[i].getAnu()[j]==(y+1))
{
boolean exist=false;
for(int z=0;z<Que.length;z++)
{
if(Que[z].getNum() == Tes[x].que[y].getNum())
{
exist=true;
if(Que[z].isExist())
{
System.out.println(Que[z].getQue() + "~" + Ans[i].getAns()[j] + "~" + Ans[i].getCheck()[j]);
break;
}
else {
System.out.println("the question " + Tes[x].que[y].getNum() + " invalid~0");
break;
}
}
};
for(int z=0;z<ZQue.size();z++){
if(ZQue.get(z).getNum() == Tes[x].que[y].getNum())
{
exist=true;
if(ZQue.get(z).isExist())
{
System.out.println(ZQue.get(z).getQue() + "~" + Ans[i].getAns()[j] + "~" + Ans[i].getCheck()[j]);
break;
}
else {
System.out.println("the question " + Tes[x].que[y].getNum() + " invalid~0");
break;
}
}
}
for(int z=0;z<KQue.size();z++){
if(KQue.get(z).getNum() == Tes[x].que[y].getNum())
{
exist=true;
if(KQue.get(z).isExist())
{
System.out.println(KQue.get(z).getQue() + "~" + Ans[i].getAns()[j] + "~" + Ans[i].getCheck()[j]);
break;
}
else {
System.out.println("the question " + Tes[x].que[y].getNum() + " invalid~0");
break;
}
}
}
if(!exist)
System.out.println("non-existent question~0");
break;
}
else if(j== Ans[i].getAns().length-1)
System.out.println("answer is null");
}
}
boolean cout=false;
for(int j=0;j<Stu.length;j++)
{
if(Stu[j].getSid().compareTo(Ans[i].getSid())==0) {
System.out.printf("%s %s: ", Stu[j].getSid(), Stu[j].getName());
break;
}
else if(j==Stu.length-1) {
System.out.println(Ans[i].getSid() + " not found");
cout=true;
}
}
if(cout)
break;
for (int y = 0; y < Tes[x].que.length; y++) {
for(int j = 0; j< Ans[i].getAns().length; j++) {
if (Ans[i].getAnu()[j] == (y+1)) {
System.out.printf("%d", Ans[i].getPoint()[j]);
if (y < Tes[x].que.length - 1)
System.out.printf(" ");
else
System.out.printf("~");
break;
}
else if(j== Ans[i].getAns().length-1)
{
System.out.printf("0");
if (y < Tes[x].que.length - 1)
System.out.printf(" ");
else
System.out.printf("~");
}
}
}
System.out.printf("%d\n", Ans[i].getSum());
break;
最後輸出的輸出和之前的差不多。就是要分別遍歷普通題，選擇題，填空題的題庫，找到相對應的題目。
- [ 2 ] 家居強電電路模擬程式-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。
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]
#T2:[VCC T1-1] [T1-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]
#L1:1.00
end
輸出樣例10:
在這裡給出相應的輸出。例如：
@L1:1.00
@R2:180
class Electric implements Comparable<Electric> {
private String name;
private boolean state;
HashMap<String,Electric> pin1 = new HashMap<>();
HashMap<String,Electric> pin2 = new HashMap<>();
private double inVolt=0;
private double outVolt=0;
private double PD=inVolt-outVolt;
public Electric() {
}
public double getPD() {
return PD;
}
public void setPD(double PD) {
this.PD = PD;
}
public boolean isState() {
return state;
}
public void setState(boolean state) {
this.state = state;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getInVolt() {
return inVolt;
}
public void setInVolt(double inVolt) {
this.inVolt = inVolt;
}
public double getOutVolt() {
return outVolt;
}
public void setOutVolt(double outVolt) {
this.outVolt = outVolt;
}
Electric(String name){
this.name=name;
}
void set(){
}
void set(String state){}
void show(){}
@Override
public int compareTo(Electric o) {
String[] str={"K","F","L","B","R","D"};
for(int i=0;i<str.length;i++)
{
if(this.name.startsWith(str[i])){
for(int j=0;j<str.length;j++)
{
if(o.getName().startsWith(str[j])) {
if (i < j)
return -1;
else if (i == j)
return this.name.compareTo(o.getName());
else
return 1;
}
}
}
}
return 0;
}
}
這是電器類的設計，有名字，狀態，輸入電壓，輸出電壓，電壓差，輸入引腳和輸出引腳以及一個排序方法。這個排序是在最後輸出各個電器的時候要的排序，是按照開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇的順序依次輸出所有裝置，因為每個電器裝置的名字都有特定的格式，以特定的字母開頭，我就利用了這個特性，先將這些字母按輸出順序放在字串陣列裡，然後按其在字串陣列裡的位置排序。
void set(String a){
if(super.isState()){
super.setState(false);
super.setOutVolt(0);
super.setPD(super.getOutVolt()-super.getInVolt());
}
else{
super.setOutVolt(super.getInVolt());
super.setPD(super.getOutVolt()-super.getInVolt());
super.setState(true);
}
}
void show(){
if(super.isState())
System.out.println("@"+super.getName()+":closed");
else
System.out.println("@"+super.getName()+":turned on");
}
void set(String state){
if(state.equals("+")){
if(position<3)
position++;
super.setOutVolt(super.getInVolt()*gear[position]);
super.setPD(super.getOutVolt()-super.getInVolt());
}
else if(state.equals("-")){
if(position>0)
position--;
super.setOutVolt(super.getInVolt()*gear[position]);
}
}
void show(){
System.out.println("@"+super.getName()+":"+position);
}
void set(String state){
position=Double.parseDouble(state);
super.setOutVolt(super.getInVolt()*position);
super.setPD(super.getOutVolt()-super.getInVolt());
}
void show(){
System.out.println("@"+super.getName()+":"+String.format("%.2f",position));
}
void set(){
if(super.getPD()<10)
luminance=0;
else if(super.getPD()>=10&&super.getPD()<220)
luminance=50+(super.getPD()-10)*(5.0/7);
else
luminance=200;
}
void show(){
System.out.println("@"+super.getName()+":"+(int)luminance);
}
void set(){
if(super.getPD()==0)
luminance=0;
else
luminance=180;
}
void show(){
System.out.println("@"+super.getName()+":"+(int)luminance);
}
void set(){
if(super.getPD()<80)
speed=0;
else if(super.getPD()<=150)
speed=80+(super.getPD()-80)*4;
else
speed=360;
}
void show(){
System.out.println("@"+super.getName()+":"+(int)speed);
}
每一個裝置都有其自己的set()和show()方法。
class ElementLine extends Electric{
LinkedList<Electric> ele = new LinkedList<>();
boolean pass;
ElementLine() {}
ElementLine(String name) {
super(name);
}
}
還有一個串聯電路類，並有一個boolean型別的變數來判斷這條電路是否是通路。
static ArrayList<Electric> electric = new ArrayList<>();
static ElementLine elementLine = new ElementLine();
在main方法前我先設定了一個Electric的ArryList來儲存每一個電器裝置，而且在這裡排序和輸出，並設定了串聯電路，以便後面計算各個裝置的分壓。
String[] a = str.split(" ");
int volt = 0;
for(int i=0;i<a.length;i++)
{
if(a[i].equals("VCC")){
volt=220;
continue;
}
else if(a[i].equals("GND")){
continue;
}
else
{
String[] element = a[i].split("-");
if(element[1].equals("1")) {
Electric elec=null;
if(element[0].startsWith("K")){
elec=new KSwitch(element[0]);
}else if(element[0].startsWith("F")){
elec=new FGovernor(element[0]);
}
else if(element[0].startsWith("L")){
elec=new LGovernor(element[0]);
}
else if(element[0].startsWith("B")){
elec=new BLamp(element[0]);
}
else if(element[0].startsWith("R")){
elec=new RLamp(element[0]);
}
else if(element[0].startsWith("D")){
elec=new DFan(element[0]);
}
if(volt==220){
elec.setInVolt(220);
volt=0;
}
electric.add(elec);
elementLine.ele.add(elec);
}
}
}
這是處理每一個裝置連線資訊。由於每次只輸入兩個引腳，只需要用split把兩個引腳分開，當是引腳1的就new一個新裝置，根據名字判斷是哪種裝置。再將裝置放入裝置陣列裡和串聯電路里。因為是同一個物件，只要修改其中一個，那麼這兩個裡的裝置都會被修改。
static void K(String str){
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(str)){
electric.get(i).set("開關");
}
}
}
static void F(String str){
String name="";
String state="";
if(str.contains("+")){
name=str.substring(0,str.indexOf("+"));
state="+";
}
if(str.contains("-")){
name=str.substring(0,str.indexOf("-"));
state="-";
}
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(name)){
electric.get(i).set(state);
}
}
}
static void L(String str){
String name=str.substring(0,str.indexOf(":"));
String state=str.substring(str.indexOf(":")+1);
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(name)){
electric.get(i).set(state);
}
}
}
這是處理控制裝置調節資訊，呼叫的是裝置的set()方法。
for(int i=0;i<elementLine.ele.size();i++){
if(i==0) {
if (elementLine.ele.get(i).getName().startsWith("K") || elementLine.ele.get(i).getName().startsWith("F") || elementLine.ele.get(i).getName().startsWith("L")) {
continue;
}else {
elementLine.ele.get(i).setPD(elementLine.ele.get(i).getInVolt()-elementLine.ele.get(i).getOutVolt());
elementLine.ele.get(i).set();
}
}else{
elementLine.ele.get(i).setInVolt(elementLine.ele.get(i-1).getOutVolt());
elementLine.ele.get(i).setPD(elementLine.ele.get(i).getInVolt()-elementLine.ele.get(i).getOutVolt());
elementLine.ele.get(i).set();
}
}
這是計算裝置的分壓，並透過裝置的set()方法將裝置的引數計算出來。
int cn=0;
int t=0;
for(int i=0;i<elementLine.ele.size();i++){
if (elementLine.ele.get(i).getName().startsWith("K")){
cn++;
if(elementLine.ele.get(i).isState())
t++;
}
}
if(cn==t)
elementLine.setState(true);
判斷是否為通路
Collections.sort(electric);
for(int i=0;i<electric.size();i++){
if (electric.get(i).getName().startsWith("K") || elementLine.ele.get(i).getName().startsWith("F") || elementLine.ele.get(i).getName().startsWith("L")){
electric.get(i).show();
}
else{
if(elementLine.isState()){
electric.get(i).show();
}
else{
System.out.println("@"+ electric.get(i).getName()+":"+0);
}
}
}
將裝置排序並輸出裝置資訊。
- [ 3 ] 家居強電電路模擬程式-2
題目要求：智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-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
void set(){
if(super.getPD()<80)
speed=0;
else if(super.getPD()<=100)
speed=80;
else if(super.getPD()<=120)
speed=160;
else if(super.getPD()<=140)
speed=260;
else
speed=360;
}
void show(){
System.out.println("@"+super.getName()+":"+(int)speed);
}
這次新增了落地扇，這是其set()和show()方法。
String[] str={"K","F","L","B","R","D","A"};
排序只需要在原來的陣列後面加上落地扇的命名開頭字母。
class ParallelLine extends Electric{
ArrayList<ElementLine> TLine = new ArrayList<>();
ParallelLine(){}
ParallelLine(String name){super(name);}
}
新加了一個並聯電路類
static ArrayList<ElementLine> TLine = new ArrayList<>();
static ArrayList<ParallelLine> MLine=new ArrayList<>();
在上一次的基礎上新設定了一個串聯電路各分路和並聯電路
static void saveElement(String str){
String name=str.substring(0,str.indexOf(":"));
ElementLine eleLine=null;
str=str.substring(str.indexOf(":")+1);
String pat = "\\[(.+?)\\]";
Pattern pattern = Pattern.compile(pat);
Matcher m = pattern.matcher(str);
if(name.startsWith("T")) {
boolean mainLine = false;
while (m.find()) {
String[] a = m.group(1).split(" ");
for (int i = 0; i < a.length; i++) {
if (a[i].equals("IN")) {
eleLine = new ElementLine(name);
TLine.add(eleLine);
continue;
} else if (a[i].equals("OUT")) {
continue;
} else if (a[i].equals("VCC")) {
mainLine = true;
elementLine = new ElementLine(name);
continue;
} else if (a[i].equals("GND")) {
continue;
} else {
String[] st = a[i].split("-");
if (st[1].equals("1")) {
Electric elec = null;
if (st[0].startsWith("K")) {
elec = new KSwitch(st[0]);
} else if (st[0].startsWith("F")) {
elec = new FGovernor(st[0]);
} else if (st[0].startsWith("L")) {
elec = new LGovernor(st[0]);
} else if (st[0].startsWith("B")) {
elec = new BLamp(st[0]);
} else if (st[0].startsWith("R")) {
elec = new RLamp(st[0]);
} else if (st[0].startsWith("D")) {
elec = new DFan(st[0]);
} else if (st[0].startsWith("A")) {
elec = new AFan(st[0]);
}
electric.add(elec);
if (mainLine) {
elementLine.ele.add(elec);
elementLine.setResistance(elementLine.getResistance() + elec.getResistance());
} else {
eleLine.ele.add(elec);
eleLine.setResistance(eleLine.getResistance() + elec.getResistance());
}
}
if (st[1].equals("IN")) {
elementLine.ele.add(new Electric(st[0]));
}
}
}
}
}
if(name.startsWith("M")){
MLine.add(new ParallelLine(name));
while(m.find())
{
String[] a=m.group(1).split(" ");
for(int i=0;i<a.length;i++)
{
for(int j=0;j<MLine.size();j++)
{
if(name.equals(MLine.get(j).getName())){
for(int x=0;x<TLine.size();x++){
if(TLine.get(x).getName().equals(a[i])){
MLine.get(j).TLine.add(TLine.get(x));
}
}
}
}
}
}
}
}
這是對每條裝置連線資訊的處理，分了是以T開頭還是M開頭。如果以T開頭，透過是含"IN"還是"VCC"來判斷是主路還是分路。在主路中還會穿插並聯電路，並聯電路的引腳是"IN"，所以還要判斷會不會有引腳是"IN"的。如果以M開頭就要將輸入的串聯電路放入並聯電路里。
static void K(String str){
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(str)){
electric.get(i).set("開關");
}
}
}
static void F(String str){
String name="";
String state="";
if(str.contains("+")){
name=str.substring(0,str.indexOf("+"));
state="+";
}
if(str.contains("-")){
name=str.substring(0,str.indexOf("-"));
state="-";
}
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(name)){
electric.get(i).set(state);
}
}
}
static void L(String str){
String name=str.substring(0,str.indexOf(":"));
String state=str.substring(str.indexOf(":")+1);
for(int i=0;i<electric.size();i++){
if(electric.get(i).getName().equals(name)){
electric.get(i).set(state);
}
}
}
控制裝置調節資訊和之前的一樣。
if(elementLine.ele.get(i).getName().startsWith("M")){
for(int j=0;j<MLine.size();j++){
if(MLine.get(j).getName().equals(elementLine.ele.get(i).getName())){
for(int x=0;x<MLine.get(j).TLine.size();x++){
for(int n=0;n<MLine.get(j).TLine.get(x).ele.size();n++)
{
if(MLine.get(j).TLine.get(x).ele.get(n).getName().startsWith("K"))
{
MLine.get(j).TLine.get(x).setCnOfK(MLine.get(j).TLine.get(x).getCnOfK()+1);
if(MLine.get(j).TLine.get(x).ele.get(n).isState())
MLine.get(j).TLine.get(x).setCnOfONK(MLine.get(j).TLine.get(x).getCnOfONK()+1);
}
}
if(MLine.get(j).TLine.get(x).getCnOfK()==MLine.get(j).TLine.get(x).getCnOfONK()) {
MLine.get(j).TLine.get(x).setState(true);
MLine.get(j).setState(true);
MLine.get(j).setResistance(MLine.get(j).getResistance()+1/MLine.get(j).TLine.get(x).getResistance());
}
}
elementLine.setCnOfK(elementLine.getCnOfK()+1);
if(MLine.get(j).isState()) {
elementLine.setCnOfONK(elementLine.getCnOfONK()+1);
MLine.get(j).setResistance(1 / MLine.get(j).getResistance());
elementLine.setResistance(elementLine.getResistance() + MLine.get(j).getResistance());
}
}
}
}
if(elementLine.ele.get(i).getName().startsWith("K")){
elementLine.setCnOfK(elementLine.getCnOfK()+1);
if(elementLine.ele.get(i).isState()){
elementLine.setCnOfONK(elementLine.getCnOfONK()+1);
}
}
這是計算每條並聯電路的電阻，並將電阻加到主電路里面，在計算電阻時就將每條串聯電路是否是通路判斷出來。
if(elementLine.getCnOfK() == elementLine.getCnOfONK()) {
elementLine.setState(true);
if(elementLine.ele.get(0).getName().startsWith("F")||elementLine.ele.get(0).getName().startsWith("L"))
elementLine.setPD(220*elementLine.ele.get(0).getPD());
else
elementLine.setPD(220);
elementLine.setElectricity(elementLine.getPD()/elementLine.getResistance());
}else {
elementLine.setElectricity(0);
}
計算出主路的電流。
if(elementLine.ele.get(i).getName().startsWith("K") || elementLine.ele.get(i).getName().startsWith("F") || elementLine.ele.get(i).getName().startsWith("L"))
continue;
else if(elementLine.ele.get(i).getName().startsWith("M")){
for(int j=0;j<MLine.size();j++){
if(MLine.get(j).getName().equals(elementLine.ele.get(i).getName())){
MLine.get(j).setPD(elementLine.getElectricity()*MLine.get(j).getResistance());
for(int x=0;x<MLine.get(j).TLine.size();x++){
if(MLine.get(j).TLine.get(x).isState()) {
MLine.get(j).TLine.get(x).setElectricity(MLine.get(j).getPD()/MLine.get(j).TLine.get(x).getResistance());
for (int n = 0; n < MLine.get(j).TLine.get(x).ele.size(); n++){
MLine.get(j).TLine.get(x).ele.get(n).setPD(MLine.get(j).TLine.get(x).getElectricity()*MLine.get(j).TLine.get(x).ele.get(n).getResistance());
MLine.get(j).TLine.get(x).ele.get(n).set();
}
}
}
}
}
}else {
elementLine.ele.get(i).setPD(elementLine.getElectricity()*elementLine.ele.get(i).getResistance());
elementLine.ele.get(i).set();
}
這是計算裝置的分壓，並透過裝置的set()方法將裝置的引數計算出來。
Collections.sort(electric);
for(int i=0;i<electric.size();i++){
if (electric.get(i).getName().startsWith("K") || electric.get(i).getName().startsWith("F") || electric.get(i).getName().startsWith("L")){
electric.get(i).show();
}
else{
if(elementLine.isState()){
electric.get(i).show();
}
else{
System.out.println("@"+ electric.get(i).getName()+":"+0);
}
}
}
將裝置排序並輸出裝置資訊。
3. 踩坑心得
- [ 1 ] 這次的家居強電電路模擬程式在每次釋出前會給出初稿讓我們設計，我會根據題目後在腦子裡構思但是沒有寫程式碼去實現，導致我會想得比較多，有些設計都不是很合理，而且還會忘記了。就像每個裝置都會有引腳。我當時是想這這些裝置透過引腳連線的，不就得有引腳嘛。但是最後在寫的過程中就感覺直接在串聯電路里連起來，然後在串聯電路里分析就行了。所以在寫程式的時候不能只想，還要根據實際，一邊設計一邊把思考寫下來，這樣才是有用的思考。
- [ 2 ] 在寫程式碼的時候一定要仔細分析。這次設計的分檔開關一開始是錯的，因為他是有上限和下限的，而我的上限沒設定好，導致了當超過了擋位就錯了。
下面是剛開始的
void set(String state){
if(state.equals("+")){
if(position<4)
position++;
super.setOutVolt(super.getInVolt()*gear[position]);
super.setPD(super.getOutVolt()-super.getInVolt());
}
else if(state.equals("-")){
if(position>0)
position--;
super.setOutVolt(super.getInVolt()*gear[position]);
}
}
這是改正後的
void set(String state){
if(state.equals("+")){
if(position<3)
position++;
super.setOutVolt(super.getInVolt()*gear[position]);
super.setPD(super.getOutVolt()-super.getInVolt());
}
else if(state.equals("-")){
if(position>0)
position--;
super.setOutVolt(super.getInVolt()*gear[position]);
}
}
- [ 3 ] 在計算分壓的時候沒有考慮到第一個不是開關或者是調速器，導致有非零返回。
這是之前的
if(elementLine.ele.get(i).getName().startsWith("K")||elementLine.ele.get(i).getName().startsWith("F")||elementLine.ele.get(i).getName().startsWith("L")){
continue;
}else{
elementLine.ele.get(i).setInVolt(elementLine.ele.get(i-1).getOutVolt());
elementLine.ele.get(i).setPD(elementLine.ele.get(i).getInVolt()-elementLine.ele.get(i).getOutVolt());
elementLine.ele.get(i).set();
}
這是改正之後的
if(i==0) {
if (elementLine.ele.get(i).getName().startsWith("K") || elementLine.ele.get(i).getName().startsWith("F") || elementLine.ele.get(i).getName().startsWith("L")) {
continue;
}else {
elementLine.ele.get(i).setPD(elementLine.ele.get(i).getInVolt()-elementLine.ele.get(i).getOutVolt());
elementLine.ele.get(i).set();
}
}else{
elementLine.ele.get(i).setInVolt(elementLine.ele.get(i-1).getOutVolt());
elementLine.ele.get(i).setPD(elementLine.ele.get(i).getInVolt()-elementLine.ele.get(i).getOutVolt());
elementLine.ele.get(i).set();
}
- [ 4 ] 題目要求了只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出，但是按照我的計算方法當我的計算結果是6.9999999999999999時我的結果是6，但是正確的答案應該是7.這個可能的在計算的過程的差異導致了我計算出的數值出錯了
原來是直接把double型別轉換成int型別
void show(){
System.out.println("@"+super.getName()+":"+(int)luminance);
}
改正之後
void show(){
double df1=Math.ceil(luminance)-luminance;
double df2=luminance-Math.floor(luminance);
if(df1<1e-10||df2<1e-10)
luminance=Math.round(luminance);
System.out.println("@"+super.getName()+":"+(int)luminance);
}
- 總結
- 透過這三次題目集，我更深刻的理解了類的繼承和多型，也能運用類的這個特性。但是類的多型的使用還是不那麼靈活，還需要更深入的學習。
- 在釋出P他的初稿的時候，要是有多一點的輸入樣例會更好地讓我們提前設計程式。