（1）前言：這幾次的pta難度適中，很好的鍛鍊了寫程式碼的能力，也同時跟進課堂，讓我們對新學的知識更加的熟悉，熟練
（2）設計與分析：
答題判序四：
設計實現答題程式，模擬一個小型的測試，要求輸入題目資訊、試卷資訊、答題資訊、學生資訊、刪除題目資訊，根據輸入題目資訊中的標準答案判斷答題的結果。本題在答題判題程式-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
該題在前一個題的基礎上有新增了一些功能，輸入方式也發生變化，在讀取輸入時需改變一下方式，在建立類的物件，完成要求
習題四-7-2 設計一個學生類和它的一個子類——本科生類：
設計一個學生類（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]
在這道題中我們需要建立子類繼承父類實現題目的要求，我的程式碼為import java.util.Scanner;
class Student
{
protected String name;
protected int age;
public Student(){
}
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
void show()
{
System.out.println("Student[name="+name+",age="+age+"]");
}
}
class Undergraduate extends Student{
private String major;
public Undergraduate(){
}
public Undergraduate(String name,int age,String major)
{
this.name=name;
this.age=age;
this.major=major;
}
void show()
{
System.out.println("Undergraduate[name="+name+",age="+age+",major="+major+"]");
}
}
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String re=s.next();
int a=s.nextInt();
Student student = new Student(re,a);
String re1=s.next();
int age=s.nextInt();
String major=s.next();
Undergraduate student2=new Undergraduate(re1,age,major);
student.show();
student2.show();
}
}
習題四-7-3 校園角色類設計-1：
學校需要構建綜合系統，使用者包含多種角色。角色Role分兩類：學生Student和僱員Employee；僱員又分為教員Faculty和職員Staff。
每個角色都有姓名、性別。學生有學號、班級。一個僱員有工號、入職日期。教員有職稱。職員有職位稱號。
請以如下Main類為基礎，構建各個角色類，將程式碼補充完整。
public class Main {
public static void main(String[] args) {
Faculty fac = new Faculty("張三",32,"33006","2019","10","25","講師");
Student stu=new Student("李四",19,"20201103","202011");
Staff sta = new Staff("王五",27,"32011","2015","06","17","教務員");
fac.show();
sta.show();
stu.show();
}
這道題僅需建立一個父類和兩個子類繼承父類實現學生，教員，職員三個角色的輸入資訊即可我的程式碼為import java.util.Scanner;
class Student
{
protected String name;
protected int age;
String xuhao;
String banji;
public Student(){
}
public Student(String name,int age,String xuhao,String banji)
{
this.name=name;
this.age=age;
this.xuhao=xuhao;
this.banji=banji;
}
void show()
{
System.out.println("我是"+name+"，年齡"+age+"歲。學號是"+xuhao+"，來自"+banji+"班。");
}
}
class Faculty{
String name;
int age;
String gonghao;
String year;
String month;
String day;
String cheng;
public Faculty() {
}
public Faculty(String name,int age,String gonghao,String year,String month,String day,String cheng) {
this.name=name;
this.age=age;
this.gonghao=gonghao;
this.year=year;
this.month=month;
this.day=day;
this.cheng=cheng;
}
void show() {
System.out.println("我是"+name+"，年齡"+age+"歲。工號是"+gonghao+"，"+year+"年"+month+"月"+day+"日入職。是一名教師，"+cheng+"職稱。");
}
}
class Staff extends Faculty{
public Staff() {
}
public Staff(String name,int age,String gonghao,String year,String month,String day,String cheng) {
this.name=name;
this.age=age;
this.gonghao=gonghao;
this.year=year;
this.month=month;
this.day=day;
this.cheng=cheng;
}
void show() {
System.out.println("我是"+name+"，年齡"+age+"歲。工號是"+gonghao+"，"+year+"年"+month+"月"+day+"日入職。是一名"+cheng+"。");
}
}
public class Main {
public static void main(String[] args) {
Faculty fac = new Faculty("張三",32,"33006","2019","10","25","講師");
Student stu=new Student("李四",19,"20201103","202011");
Staff sta = new Staff("王五",27,"32011","2015","6","17","教務員");
fac.show();
sta.show();
stu.show();
}
}
習題五-7-1 家居強電電路模擬程式-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，不會接其他裝置。整個電路中最多隻有一個調速器，且連線在電源上。
根據題目的資訊可以得到第一次的作業只要求我們求得一個串聯電路的狀態資訊，我的實現思路是定義電器類和開關類，在建立各個電器的類來繼承一個總的電器類，建立各個開關繼承開關類，在輸入的方式中，我們採用讀取輸入判斷所輸入的電器或開關，建立對應的類將其存入一個集合中方便以後使用，在讀取完所有資訊之後即可判斷集合中的類是啥，在利用電壓計算電器所對應的狀態最後在列印出來，我的程式碼為import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void show(List<Kai> kai, List<Dianqi> dianqi) {
Map<Class<? extends Kai>, List<Kai>> kaiMap = new LinkedHashMap<>();
Map<Class<? extends Dianqi>, List<Dianqi>> dianqiMap = new LinkedHashMap<>();
for (Kai k : kai) {
kaiMap.computeIfAbsent(k.getClass(), key -> new ArrayList<>()).add(k);
}
for (Dianqi d : dianqi) {
dianqiMap.computeIfAbsent(d.getClass(), key -> new ArrayList<>()).add(d);
}
for (List<Kai> kList : kaiMap.values()) {
Collections.sort(kList, new Comparator<Kai>() {
@Override
public int compare(Kai k1, Kai k2) {
return extractNumber(k1.getName()).compareTo(extractNumber(k2.getName()));
}
});
}
for (List<Dianqi> dList : dianqiMap.values()) {
Collections.sort(dList, new Comparator<Dianqi>() {
@Override
public int compare(Dianqi d1, Dianqi d2) {
return extractNumber(d1.getName()).compareTo(extractNumber(d2.getName()));
}
});
}
for (List<Kai> kList : kaiMap.values()) {
for (Kai k : kList) {
k.show();
}
}
for (List<Dianqi> dList : dianqiMap.values()) {
for (Dianqi d : dList) {
d.show();
}
}
}
private static Integer extractNumber(String name) {
return Integer.parseInt(name.replaceAll("\\D", ""));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in=new Scanner(System.in);
String input;
ArrayList<T> t=new ArrayList<>();
ArrayList<Kai> kai=new ArrayList<>();
ArrayList<Dianqi> dianqi=new ArrayList<>();
M m=new M("M1");
while(!( input = in.nextLine()).equals("end"))
{
if(input.startsWith("#T"))
{
String part=input.substring(1,3);
T t1=new T(part);
t.add(t1);
Pattern pattern = Pattern.compile("\\[(.*?) (.*?)\\]");
Matcher matcher = pattern.matcher(input);
while(matcher.find()) {
String to=matcher.group(2);
if(to.startsWith("K")) {
K k=new K(to.substring(0, 2));
kai.add(k);
t1.setKai(k);
}
else if(to.startsWith("F")) {
F f=new F(to.substring(0, 2));
kai.add(f);
t1.setKai(f);
}
else if(to.startsWith("L")) {
L l=new L(to.substring(0, 2));
//l.setName(to.substring(0, 2));
kai.add(l);
t1.setKai(l);
}
else if(to.startsWith("B")) {
B b=new B(to.substring(0, 2));
dianqi.add(b);
t1.setDianzu(10);
t1.setDian(b);
}
else if(to.startsWith("R")) {
R r=new R(to.substring(0, 2));
dianqi.add(r);
t1.setDianzu(5);
t1.setDian(r);
}
else if(to.startsWith("D")) {
D d=new D(to.substring(0, 2));
dianqi.add(d);
t1.setDianzu(20);
t1.setDian(d);
}
else if(to.startsWith("A")) {
A a=new A(to.substring(0, 2));
dianqi.add(a);
t1.setDianzu(20);
t1.setDian(a);
}
else if(to.startsWith("M")) {
t1.setM(m);
}
}
}
else if(input.startsWith("#M")) {
Pattern pattern = Pattern.compile("#M\\d+:\\[(.*?)]");
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
String content = matcher.group(1);
String[] parts = content.split(" ");
for(int i=0;i<parts.length;i++) {
m.addT(t.get(i));
}
}
}
else if(input.startsWith("#K")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof K) {
K kk=(K) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
else if(input.startsWith("#F")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof F)
{
F kk=(F) kais;
if(kk.getName().contains(k)) {
if(input.contains("F+")) {
kk.jiaF();
}
else if(input.contains("F-")) {
kk.jianF();
}
}
}
}
}
else if(input.startsWith("#L")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof L) {
L kk=(L) kais;
if(kk.getName().contains(k)) {
String ae=input.substring(4,input.length());
double a=Double.parseDouble(ae);
kk.setA(a);
}
}
}
}
}
T tt=t.get(t.size()-1);
if(tt.kai instanceof K) {
K k=(K)tt.kai;
int a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
double dianya1=220*(tt.getDianzu()/(tt.getDianzu()+m.getDianzu()));
double dianya2=220*(m.getDianzu()/(tt.getDianzu()+m.getDianzu()));
tt.dian.setzhuangtai(dianya1);
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(gi.kai.getName().contains("K"))
{
K ki=(K)gi.kai;
gi.dian.setzhuangtai(dianya2*ki.getA());
}
else if(gi.kai.getName().contains("F")) {
F fi=(F)gi.kai;
gi.dian.setzhuangtai(dianya2*fi.getA());
}
else if(gi.kai.getName().contains("L")) {
L li=(L)gi.kai;
gi.dian.setzhuangtai(dianya2*li.getA());
}
}
show(kai,dianqi);
}
}
if(tt.kai instanceof F) {
F k=(F)tt.kai;
double a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
double dianya1=220*(tt.getDianzu()/(tt.getDianzu()+m.getDianzu()));
double dianya2=220*(m.getDianzu()/(tt.getDianzu()+m.getDianzu()));
tt.dian.setzhuangtai(dianya1);
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(gi.kai.getName().contains("K"))
{
K ki=(K)gi.kai;
gi.dian.setzhuangtai(dianya2*ki.getA());
}
else if(gi.kai.getName().contains("F")) {
F fi=(F)gi.kai;
gi.dian.setzhuangtai(dianya2*fi.getA());
}
else if(gi.kai.getName().contains("L")) {
L li=(L)gi.kai;
gi.dian.setzhuangtai(dianya2*li.getA());
}
}
show(kai,dianqi);
}
}
if(tt.kai instanceof L) {
L k=(L)tt.kai;
double a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
double dianya1=220*(tt.getDianzu()/(tt.getDianzu()+m.getDianzu()));
double dianya2=220*(m.getDianzu()/(tt.getDianzu()+m.getDianzu()));
tt.dian.setzhuangtai(dianya1);
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(gi.kai.getName().contains("K"))
{
K ki=(K)gi.kai;
gi.dian.setzhuangtai(dianya2*ki.getA());
}
else if(gi.kai.getName().contains("F")) {
F fi=(F)gi.kai;
gi.dian.setzhuangtai(dianya2*fi.getA());
}
else if(gi.kai.getName().contains("L")) {
L li=(L)gi.kai;
gi.dian.setzhuangtai(dianya2*li.getA());
}
}
show(kai,dianqi);
}
}
}
}
class T{
String name;
double dianzu;
public Dianqi dian;
public Kai kai;
M m;
void setDianzu(double dianzu) {
this.dianzu=dianzu;
}
double getDianzu(){
return dianzu;
}
void setM(M m) {
this.m=m;
}
T(){
}
T(String name){
this.name=name;
}
void setDian(Dianqi dian) {
this.dian=dian;
}
void setKai(Kai kai) {
this.kai=kai;
}
}
class M{
String name;
double dianzu;
ArrayList<T> chuan;
M(){
}
M(String name){
this.name=name;
this.chuan=new ArrayList<>();
}
void addT(T t) {
chuan.add(t);
}
double getDianzu() {
double b = 0;
for (T chuans : chuan) {
if (!isduan(chuans.kai)) { // Only add resistance if the switch is not disconnected
b += (1.0 / chuans.getDianzu());
}
}
if (b == 0) { // Avoid division by zero
return Double.MAX_VALUE;
}
return 1.0 / b;
}
boolean isduan(Kai kai) {
if (kai instanceof K) {
return ((K) kai).getA() == 0; // 0 means turned on
} else if (kai instanceof F) {
return ((F) kai).getA() == 0;
} else if (kai instanceof L) {
return ((L) kai).getA() == 0;
}
return true; // Default to assume it's open
}
}
abstract class Kai{
abstract void show();
abstract String getName();
}
class K extends Kai{
String name;
int a=0;
void gai() {
if(a0) {
a=1;
}
else if(a1) {
a=0;
}
}
public void show(){
if(a1) {
System.out.println("@"+name+":closed");
}
else if(a0)
{
System.out.println("@"+name+":turned on");
}
}
K(){
}
K(String name){
this.name=name;
}
int getA() {
return a;
}
String getName() {
return name;
}
}
class F extends Kai{
String name;
double a=0.0;
F(){
}
F(String name){
this.name=name;
}
void jiaF() {
this.a+=0.3;
}
void jianF() {
this.a-=0.3;
}
public void show() {
int ds=0;
if(a==0) {
ds=0;
}
else if(a==0.3) {
ds=1;
}
else if(a==0.6) {
ds=2;
}
else {
ds=3;
}
String sd=Integer.toString(ds);
System.out.println("@"+name+":"+sd);
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class L extends Kai{
String name;
double a;
L(){
}
L(String name)
{
this.name=name;
this.a=0;
}
void setName(String name) {
this.name=name;
}
String getName() {
return name;
}
void setA(double a) {
this.a=a;
}
double getA() {
return a;
}
public void show() {
String abs=String.format("%.2f",a);
System.out.println("@"+name+":"+abs);
}
}
abstract class Dianqi{
String name;
abstract void show();
abstract String getName();
abstract void setzhuangtai(double a);
}
class B extends Dianqi{
double liang;
B(){
}
B(String name){
this.name=name;
this.liang=0;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a>=0&&a<10) {
this.liang=0;
}
else if(a>=10&&a<=220) {
double l=5.0/7;
double ll=300.0/7;
double lll=l*a+ll;
this.liang=lll;
}
}
String getName() {
return name;
}
}
class R extends Dianqi{
double liang;
R(){
}
R(String name){
this.name=name;
this.liang=0;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a==0) {
this.liang=0;
}
else {
this.liang=180;
}
}
String getName() {
return name;
}
}
class D extends Dianqi{
double zhuan;
D(){
}
D(String name){
this.name=name;
this.zhuan=0;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<=150) {
double y=4.0*a-240.0;
this.zhuan=y;
}
else if(a>150&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class A extends Dianqi{
double zhuan;
A(){
}
A(String name){
this.name=name;
this.zhuan=0;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<100) {
this.zhuan=80;
}
else if(a>=100&&a<120) {
this.zhuan=160;
}
else if(a>=120&&a<140) {
this.zhuan=260;
}
else if(a>=140&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
習題5-7-2 請閱讀程式並除錯改正程式，獲得正確答案;
功能：
使用集合儲存多個學生的資訊（有序);
獲取學生總數，並按照儲存順序;
按照儲存順序獲取各個學生的資訊並逐條輸出
備註：請學生複製以下程式碼到程式設計區進行改錯。
//1考查集合導包
class Student{
private String no;
private String name;
public Student(String no, String name) {
super();
this.no = no;
this.name = name;
}
public Student() {
super();
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + "]";
}
}
public class Main {
public static void main(String[] args) {
// 建立學生物件
Student stu1 = new Student("1001","zs");
Student stu2 = new Student("1002","ls");
//2考查集合介面的例項化
//建立有序集合List，並向集合中新增學生，
List students=new List();
students.add(stu1);
students.add(stu2);
//計算學生人數,顯示學生資訊
for(int i=0;i<students.size();i++) {
//3考查遍歷方法和向下轉型
Student stu=students.get(i);
System.out.println("no:"+stu.getNo()+"\t name:"+stu.getName());
}
}
}
該題僅需修改一下集合的建立方式即可，我的程式碼為import java.util.ArrayList;
class Student{
private String no;
private String name;
public Student(String no, String name) {
super();
this.no = no;
this.name = name;
}
public Student() {
super();
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + "]";
}
}
public class Main {
public static void main(String[] args) {
// 建立學生物件
Student stu1 = new Student("1001","zs");
Student stu2 = new Student("1002","ls");
//2考查集合介面的例項化
//建立有序集合List，並向集合中新增學生，
ArrayList<Student> students=new ArrayList<>();
students.add(stu1);
students.add(stu2);
//計算學生人數,顯示學生資訊
for(int i=0;i<students.size();i++) {
//3考查遍歷方法和向下轉型
Student stu=students.get(i);
System.out.println("no:"+stu.getNo()+"\t name:"+stu.getName());
}
}
}
習題5-7-3 閱讀程式，按照題目需求修改程式：
使用集合儲存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());
}
}
}
該題的迭代器建立出現問題，我的程式碼為import java.util.Collection;
import java.util.Iterator;
import java.util.ArrayList;
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個員工元素物件
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<Employee> it=c.iterator();
//3、遍歷
while (it.hasNext()) {
//4、集合中物件未知，向下轉型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
習題6-7-1 家居強電電路模擬程式-2：
本次迭代模擬一種吊扇。
工作電壓區間為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，不會接其他裝置。整個電路最多隻有連線在電源上的一個調速器，且不包含在並聯單路中。
該題在原有的基礎上新增了一個電器，並改變了輸入方式，同時也新增了並聯電路的使用，需要大改程式碼，同樣的建立類方式，在輸入中，我們利用正規表示式對輸入的資訊進行讀取並建立相應的類，先建立一個開關類和一個電器的類的集合，方便之後使用並列印出來他們的詳細資訊，這次新增了兩個類，一個是串聯電路類，一個是並聯電路類，類中都含有電器和開關的集合，在讀取資訊時我們要先向並聯或串聯電路新增所輸入的東西在將其加入對應的類的集合，最後在讀取完資訊之後，透過計算電路的電阻來計算電流，最後算出所有電器的狀態，最後在按題目所給的順序進行列印輸出，我的程式碼為import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
// public static void show(List
// Map<Class<? extends Kai>, List
// Map<Class<? extends Dianqi>, List
// for (Kai k : kai) {
// kaiMap.computeIfAbsent(k.getClass(), key -> new ArrayList<>()).add(k);
// }
//
// for (Dianqi d : dianqi) {
// dianqiMap.computeIfAbsent(d.getClass(), key -> new ArrayList<>()).add(d);
// }
//
// for (List
// Collections.sort(kList, new Comparator
// @Override
// public int compare(Kai k1, Kai k2) {
// return extractNumber(k1.getName()).compareTo(extractNumber(k2.getName()));
// }
// });
// }
//
// for (List
// Collections.sort(dList, new Comparator
// @Override
// public int compare(Dianqi d1, Dianqi d2) {
// return extractNumber(d1.getName()).compareTo(extractNumber(d2.getName()));
// }
// });
// }
//
// for (List
// for (Kai k : kList) {
// k.show();
// }
// }
//
// for (List
// for (Dianqi d : dList) {
// d.show();
// }
// }
// }
//
private static Integer extractNumber(String name) {
return Integer.parseInt(name.replaceAll("\D", ""));
}
public static void show(List
Map<String, List
Map<String, List
for (Kai k : kai) {
String className = getClassIdentifier(k);
kaiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(k);
}
for (Dianqi d : dianqi) {
String className = getClassIdentifier(d);
dianqiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(d);
}
for (String className : Arrays.asList("K", "F", "L")) {
List<Kai> kList = kaiMap.get(className);
if (kList != null) {
Collections.sort(kList, Comparator.comparingInt(k -> extractNumber(k.getName())));
for (Kai k : kList) {
k.show();
}
}
}
for (String className : Arrays.asList("B", "R", "D", "A")) {
List<Dianqi> dList = dianqiMap.get(className);
if (dList != null) {
Collections.sort(dList, Comparator.comparingInt(d -> extractNumber(d.getName())));
for (Dianqi d : dList) {
d.show();
}
}
}
}
private static String getClassIdentifier(Object obj) {
if (obj instanceof Kai) {
Kai kai = (Kai) obj;
return kai.getClass().getSimpleName();
} else if (obj instanceof Dianqi) {
Dianqi dianqi = (Dianqi) obj;
return dianqi.getClass().getSimpleName();
}
return null;
}
public static boolean isduan(List<Kai> kai) {
for(Kai kais:kai) {
if(((K)kais).getA()==0) {
return false;
}
}
return true;
}
public static int dianzu(List<Dianqi>dianqi) {
int a=0;
for(Dianqi dianqis:dianqi) {
a+=dianqis.getdianzu();
}
return a;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in=new Scanner(System.in);
String input;
ArrayList<T> t=new ArrayList<>();
ArrayList<Kai> kai=new ArrayList<>();
ArrayList<Dianqi> dianqi=new ArrayList<>();
M m=new M("M1");
while(!( input = in.nextLine()).equals("end"))
{
if(input.startsWith("#T"))
{
String part=input.substring(1,3);
T t1=new T(part);
t.add(t1);
Pattern pattern = Pattern.compile("\\[(.*?) (.*?)\\]");
Matcher matcher = pattern.matcher(input);
while(matcher.find()) {
String to=matcher.group(2);
if(to.startsWith("K")) {
K k=new K(to.substring(0, 2));
kai.add(k);
t1.setKai(k);
}
else if(to.startsWith("F")) {
F f=new F(to.substring(0, 2));
kai.add(f);
t1.setKai(f);
}
else if(to.startsWith("L")) {
L l=new L(to.substring(0, 2));
//l.setName(to.substring(0, 2));
kai.add(l);
t1.setKai(l);
}
else if(to.startsWith("B")) {
B b=new B(to.substring(0, 2));
dianqi.add(b);
// t1.setDianzu(10);
t1.setDian(b);
}
else if(to.startsWith("R")) {
R r=new R(to.substring(0, 2));
dianqi.add(r);
// t1.setDianzu(5);
t1.setDian(r);
}
else if(to.startsWith("D")) {
D d=new D(to.substring(0, 2));
dianqi.add(d);
// t1.setDianzu(20);
t1.setDian(d);
}
else if(to.startsWith("A")) {
A a=new A(to.substring(0, 2));
dianqi.add(a);
// t1.setDianzu(20);
t1.setDian(a);
}
else if(to.startsWith("M")) {
t1.setM(m);
}
}
}
else if(input.startsWith("#M")) {
Pattern pattern = Pattern.compile("#M\\d+:\\[(.*?)]");
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
String content = matcher.group(1);
String[] parts = content.split(" ");
for(int i=0;i<parts.length;i++) {
m.addT(t.get(i));
}
}
}
else if(input.startsWith("#K")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof K) {
K kk=(K) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
else if(input.startsWith("#F")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof F)
{
F kk=(F) kais;
if(kk.getName().contains(k)) {
if(input.contains("+")) {
kk.jiaF();
}
else if(input.contains("-")) {
kk.jianF();
}
}
}
}
}
else if(input.startsWith("#L")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof L) {
L kk=(L) kais;
if(kk.getName().contains(k)) {
String ae=input.substring(4,input.length());
double a=Double.parseDouble(ae);
kk.setA(a);
}
}
}
}
}
T tt=t.get(t.size()-1);
if(tt.kai.isEmpty()) {
double aa=0;
if(t.size()-1!=0)
{
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
double id=1.0/dianzu(gi.dian);
aa+=id;
gi.setDianzu(dianzu(gi.dian));
}
}
if(aa==0) {
show(kai,dianqi);
return;
}
}
double aaaa=0;
if(aa==0) {
aaaa=0;
}
else {
aaaa=1.0/aa;
}
double aaa=(double)dianzu(tt.dian);
double dianliu=220.0/(aaa+aaaa);
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
double u=(1.0/aa)*dianliu;
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
for( int j=0;j<gi.dian.size();j++) {
dianliu=u/dianzu(gi.dian);
gi.dian.get(j).setzhuangtai(dianliu*gi.dian.get(j).getdianzu());
}
}
}
show(kai,dianqi);
}
else if(tt.kai.get(0) instanceof K) {
K k=(K)tt.kai.get(0);
double a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
for(Kai kais:tt.kai) {
if(((K)kais).getA()==0) {
show(kai,dianqi);
return;
}
}
double aa=0;
if(t.size()-1!=0)
{
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
double id=1.0/dianzu(gi.dian);
aa+=id;
gi.setDianzu(dianzu(gi.dian));
}
}
if(aa==0) {
show(kai,dianqi);
return;
}
}
double aaaa=0;
if(aa==0) {
aaaa=0;
}
else {
aaaa=1.0/aa;
}
double aaa=(double)dianzu(tt.dian);
double dianliu=220.0/(aaa+aaaa);
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
double u=(1.0/aa)*dianliu;
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
for(int j=0;j<gi.dian.size();j++) {
dianliu=u/dianzu(gi.dian);
gi.dian.get(j).setzhuangtai(dianliu*gi.dian.get(j).getdianzu());
}
}
}
show(kai,dianqi);
}
}
else if(tt.kai.get(0) instanceof F) {
F k=(F)tt.kai.get(0);
double a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
for(Kai kais:tt.kai) {
if(kais instanceof F)
{
continue;
}
if(kais.getA()==0) {
show(kai,dianqi);
return;
}
}
double aa=0;
if(t.size()-1!=0)
{
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
double id=1.0/dianzu(gi.dian);
aa+=id;
gi.setDianzu(dianzu(gi.dian));
}
}
if(aa==0) {
show(kai,dianqi);
return;
}
}
double aaaa=0;
if(aa==0) {
aaaa=0;
}
else {
aaaa=1.0/aa;
}
double aaa=(double)dianzu(tt.dian);
double dianliu=(220.0*a)/(aaa+aaaa);
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
double u=(1.0/aa)*dianliu;
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
for( int j=0;j<gi.dian.size();j++) {
dianliu=u/dianzu(gi.dian);
gi.dian.get(j).setzhuangtai(dianliu*gi.dian.get(j).getdianzu());
}
}
}
show(kai,dianqi);
}
}
else if(tt.kai.get(0) instanceof L) {
L k=(L)tt.kai.get(0);
double a=k.getA();
if(a==0) {
show(kai,dianqi);
}
else {
for(Kai kais:tt.kai) {
if(kais instanceof L) {
continue;
}
if(((K)kais).getA()==0) {
show(kai,dianqi);
return;
}
}
double aa=0;
if(t.size()-1!=0)
{
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
double id=1.0/dianzu(gi.dian);
aa+=id;
gi.setDianzu(dianzu(gi.dian));
}
}
if(aa==0) {
show(kai,dianqi);
return;
}
}
double aaaa=0;
if(aa==0) {
aaaa=0;
}
else {
aaaa=1.0/aa;
}
double aaa=(double)dianzu(tt.dian);
double dianliu=(a*220.0)/(aaa+aaaa);
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
double u=(1.0/aa)*dianliu;
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
for( int j=0;j<gi.dian.size();j++) {
dianliu=u/dianzu(gi.dian);
gi.dian.get(j).setzhuangtai(dianliu*gi.dian.get(j).getdianzu());
}
}
}
show(kai,dianqi);
}
}
}
}
class T{
String name;
int dianzu;
public ArrayList< Dianqi> dian;
public ArrayList
M m;
void setDianzu(int dianzu) {
this.dianzu=dianzu;
}
double getDianzu(){
return dianzu;
}
void setM(M m) {
this.m=m;
}
T(){
}
T(String name){
this.name=name;
this.dian=new ArrayList<>();
this.kai=new ArrayList<>();
}
void setDian(Dianqi dian) {
this.dian.add(dian);
}
void setKai(Kai kai) {
this.kai.add(kai);
}
}
class M{
String name;
double dianzu;
ArrayList<T> chuan;
M(){
}
M(String name){
this.name=name;
this.chuan=new ArrayList<>();
}
void addT(T t) {
chuan.add(t);
}
double getDianzu() {
double b = 0;
for(T chuans:chuan) {
for (Kai chaunss : chuans.kai) {
if (!isduan(chaunss)) { // Only add resistance if the switch is not disconnected
b += (1.0 / chuans.getDianzu());
}
}
}
if (b == 0) { // Avoid division by zero
return Double.MAX_VALUE;
}
return 1.0 / b;
}
boolean isduan(Kai kai) {
if (kai instanceof K) {
return ((K) kai).getA() == 0; // 0 means turned on
} else if (kai instanceof F) {
return ((F) kai).getA() == 0;
} else if (kai instanceof L) {
return ((L) kai).getA() == 0;
}
return true; // Default to assume it's open
}
}
abstract class Kai{
abstract void show();
abstract String getName();
abstract double getA();
}
class K extends Kai{
String name;
double a=0;
void gai() {
if(a0) {
a=1;
}
else if(a1) {
a=0;
}
}
public void show(){
if(a1) {
System.out.println("@"+name+":closed");
}
else if(a0)
{
System.out.println("@"+name+":turned on");
}
}
K(){
}
K(String name){
this.name=name;
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class F extends Kai{
String name;
double a=0.0;
F(){
}
F(String name){
this.name=name;
}
void jiaF() {
this.a+=0.3;
}
void jianF() {
this.a-=0.3;
}
public void show() {
int ds=0;
if(a==0) {
ds=0;
}
else if(a==0.3) {
ds=1;
}
else if(a==0.6) {
ds=2;
}
else {
ds=3;
}
String sd=Integer.toString(ds);
System.out.println("@"+name+":"+sd);
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class L extends Kai{
String name;
double a;
L(){
}
L(String name)
{
this.name=name;
this.a=0;
}
void setName(String name) {
this.name=name;
}
String getName() {
return name;
}
void setA(double a) {
this.a=a;
}
double getA() {
return a;
}
public void show() {
String abs=String.format("%.2f",a);
System.out.println("@"+name+":"+abs);
}
}
abstract class Dianqi{
String name;
abstract void show();
abstract String getName();
abstract void setzhuangtai(double a);
abstract int getdianzu();
}
class B extends Dianqi{
double liang;
int dianzu=10;
B(){
}
B(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a>=0&&a<10) {
this.liang=0;
}
else if(a>=10&&a<=220) {
double l=5.0/7;
double ll=300.0/7;
double lll=l*a+ll;
this.liang=lll;
}
}
String getName() {
return name;
}
}
class R extends Dianqi{
double liang;
int dianzu=5;
R(){
}
R(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a==0) {
this.liang=0;
}
else {
this.liang=180;
}
}
String getName() {
return name;
}
}
class D extends Dianqi{
double zhuan;
int dianzu=20;
D(){
}
D(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<=150) {
double y=4.0*a-240.0;
this.zhuan=y;
}
else if(a>150&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class A extends Dianqi{
double zhuan;
int dianzu=20;
A(){
}
A(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<100) {
this.zhuan=80;
}
else if(a>=100&&a<120) {
this.zhuan=160;
}
else if(a>=120&&a<140) {
this.zhuan=260;
}
else if(a>=140&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
（3）採坑心得：在傢俱電路的編寫程式碼過程中，很容易忽略一些小細節，比如double型別的資料，在計算並聯電路的電阻時，需要利用到總電阻的倒數等於各分支的電阻的倒數相加，要用1.0/對應的電阻，並且還需要判斷電路是否是斷路狀態，一開始忽略了，在除錯的時候所發現了
還有在電路二中對於電路的電壓計算，忘記在220v上調節器的擋位了導致部分正確
double dianliu=(220.0a)/(aaa+aaaa);這個程式碼也是在除錯的時候發現的
還有在最後的除錯中，發現沒有考慮主電路中不存在開關的情況最後新增了一種沒有開關的情況判斷if(tt.kai.isEmpty()) {
double aa=0;
if(t.size()-1!=0)
{
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
double id=1.0/dianzu(gi.dian);
aa+=id;
gi.setDianzu(dianzu(gi.dian));
}
}
if(aa0) {
show(kai,dianqi);
return;
}
}
double aaaa=0;
if(aa0) {
aaaa=0;
}
else {
aaaa=1.0/aa;
}
double aaa=(double)dianzu(tt.dian);
double dianliu=220.0/(aaa+aaaa);
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliutt.dian.get(i).getdianzu());
}
double u=(1.0/aa)dianliu;
for(int i=0;i<t.size()-1;i++) {
T gi=t.get(i);
if(isduan(gi.kai)) {
for( int j=0;j<gi.dian.size();j++) {
dianliu=u/dianzu(gi.dian);
gi.dian.get(j).setzhuangtai(dianliu*gi.dian.get(j).getdianzu());
}
}
}
show(kai,dianqi);
}
（4）改進建議：在對應的題目中程式碼有些受限制了，即有點只能滿足題目的味道，希望下次可以改進改進。
（5）總結：對於各個類的建立，多型的利用，還有集合的使用有更加的深刻，還有對正規表示式的利用。