- 1.前言:
- 2.設計與分析:
- 3.採坑心得:
- 4.改進建議:
- 5.總結：
----------------------------------------------------------------------------------------------------------------------------------
PTA作業總結
1.前言:
這次的作業相比於前幾次的作業來說難度上升了很多，需要很多的時間去寫題目以及思考，第七次大作業新增的互斥開關需要考慮的點就有很多，更不要說最後一次的作業，不僅僅增加了二極體，還增加了輸出的條件，在輸出的時候還要將每個電器的各個電勢給輸出。本來物理就不是很好，寫的就更加頭疼，在圖書館裡面待了幾天，最後寫出來的分數也不盡人意。題目的難度雖然增加了，但是可能是到了學期末吧，在Java上花的時間也更多了，沒有思路的時候在圖書館裡一個人靜靜的看題目，就又有一點靈感，然後繼續寫下去。題目變難了，但是新的題目也更加的符合新增的家庭電路，更符合實際的條件，也為我們以後去寫相關的程式碼的時候增加了一些經驗，不再會像以前剛碰到此類題目一樣無從下手。總的來說的話，第七次作業加的是互斥開關需要考慮的就是它的兩個開關的狀態，而最後一次作業需要重點考慮的則是每一個電器其兩端的電勢。
2.設計與分析:
(1)第七次大作業
點選檢視題目
7-1 家居強電電路模擬程式-3
分數 100
作者 蔡軻
單位 南昌航空大學
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-2”的基礎上增加的功能要求。
1、控制裝置
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器、互斥開關。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳（接往電源端），而另一個則是輸出引腳（接網接地端）。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
互斥開關：
互斥開關有3個引腳：1個是彙總引腳，另兩個是分支引腳。
開關電路示意圖如圖1所示，左邊是彙總引腳，編號為1；右邊兩個是分支引腳，右上的輸出引腳為2，右下輸出引腳為3。圖中1、2、3引腳均可以是輸入引腳，當1為輸入引腳時，2、3引腳為輸出引腳；1為輸出引腳時，2、3引腳為輸入引腳。
互斥開關只有兩種狀態：開關接往上面的2號引腳、接往下面的3號引腳。開關每次只能接通其中一個分支引腳，而另一個分支引腳處於斷開狀態。
互斥開關的預設狀態為1、2引腳接通，1、3引腳斷開。
圖1中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。
image.png
圖1 互斥開關
為避免短路，互斥開關設定了限流電阻，12引腳之間預設電阻為5，13引腳之間預設電阻為10。
分檔調速器
按檔位調整，常見的有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 轉/分鐘；[80V,100V) 對應轉速為 80 轉/分鐘；[100,120)V 對應轉速為 160 轉/分鐘；[120,140)V 對應轉速為 260 轉/分鐘；大於等於 140V 轉速 為 360 轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。
本次迭代模擬一種受控窗簾：
受控窗簾的電路符號為S，其最低工作電壓為50V，電壓達到或超過50V，窗簾即可正常工作，不考慮室外光照強度和室內空間大小等因素，窗簾受室內燈光的光照強度控制。
當電路中所有燈光的光照強度總和在[0,50)lux範圍內，窗簾全開；
在[50,100)lux範圍內，窗簾開啟比例為0.8；
在[100,200)lux範圍內，窗簾開啟比例為0.6；
在[200,300)lux範圍內，窗簾開啟比例為0.4；
在[300,400)lux範圍內，窗簾開啟比例為0.2；
在400lux及以上範圍內，窗簾關閉。
當電壓低於50V，窗簾不工作，預設為全開狀態。
如果電路中沒有燈或者燈全部關閉，光照強度為0，窗簾處於全開狀態。
受控裝置電阻：白熾燈的電阻為 10，日光燈的電阻為 5，吊扇的電阻為 20，落地扇的電阻為 20，窗簾電阻為15。
3、輸入資訊
1）輸入裝置資訊
分別用裝置識別符號K、F、L、B、R、D、A、H、S分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇、互斥開關、受控窗簾。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
引腳格式：裝置標識-引腳編號，例如：K1-1標識編號為1的開關的輸入引腳。
開關、分檔調速器、連續調速器的輸入引腳編號為1，輸出引腳編號為2。
受控裝置的兩個引腳編號分別為1、2。
互斥開關的引腳編號已經在互斥開關的介紹部分說明。
約束條件：
不同裝置的編號可以相同。
同種裝置的編號可以不連續。
裝置資訊不單獨輸入，包含在連線資訊中。
2）輸入連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
格式："["+引腳號+" "+引腳號+"]"
例如：[K1-1 K3-2]表示K1的1引腳，K3的2引腳連線在一起。
約束條件：
不考慮調速器串聯到其他調速器的情況。
考慮各類裝置的並聯接入。例如，K1 的輸出接到 L2 的輸入，L2 的輸出再接其他裝置屬於串聯接線。K1 的輸出接到 L2 的輸出，同時 K1 的輸入接到 L2 的輸入，這種情況屬於並聯。
本次迭代的連線資訊不單獨輸入，包含線上路資訊中。
3）輸入控制裝置調節資訊
開關、互斥開關調節資訊格式：
#+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。
#+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。
分檔調速器的調節資訊格式：
#+裝置標識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的一個部分，本題考慮這種型別的輸入。
4、輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、互斥開關、受控窗簾的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：
@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on
@B1:190
@L1:0.60
互斥開關顯示1、2引腳的接通狀態，接通時顯示closed，斷開時顯示turned on。
如：
@H1:turned on
受控窗簾顯示窗簾開啟的百分比，如：
@S1:80%
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：建議設計類圖
輸入樣例1:
在這裡給出一組輸入。例如：
#T1:[IN H1-1] [H1-2 D2-1] [D2-2 OUT]
#T2:[IN H1-1] [H1-3 D1-1] [D1-2 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
#T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]
#K1
#K2
end
輸出樣例1:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:closed
@K3:turned on
@B1:87
@B2:0
@D1:0
@D2:262
@H1:closed
輸入樣例2:
在這裡給出一組輸入。例如：
#T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
#T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]
#K1
#K2
end
輸出樣例2:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:closed
@K3:turned on
@B1:87
@B2:0
@D1:0
@D2:262
@H1:closed
輸入樣例3:
在這裡給出一組輸入。例如：
#T1:[IN K1-1] [K1-2 B2-1] [B2-2 OUT]
#T2:[IN K2-1] [K2-2 R1-1] [R1-2 OUT]
#M1:[T1 T2]
#T3:[VCC K3-1] [K3-2 M1-IN] [M1-OUT S1-1] [S1-2 GND]
#K1
#K2
#K3
end
輸出樣例3:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:closed
@K3:closed
@B2:71
@R1:180
@S1:40%
輸入樣例4:
在這裡給出一組輸入。例如：
#T1:[IN K2-1] [K2-2 D2-1] [D2-2 OUT]
#T2:[IN K3-1] [K3-2 D1-1] [D1-2 OUT]
#T3:[VCC K1-1] [K1-2 T1-IN] [T1-OUT T2-IN] [T2-OUT GND]
#K1
#K2
#K3
end
輸出樣例4:
在這裡給出相應的輸出。例如：
@K1:closed
@K2:closed
@K3:closed
@D1:200
@D2:200
輸入樣例5:
在這裡給出一組輸入。例如：
#T3:[VCC B2-1] [B2-2 K1-1] [K1-2 S1-1] [S1-2 H1-1] [H1-2 GND]
#K1
end
輸出樣例5:
在這裡給出相應的輸出。例如：
@K1:closed
@B2:95
@H1:closed
@S1:80%
我的程式碼：
點選檢視程式碼
import java.util.*;
import java.io.FileNotFoundException;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Electric {// 主電器
public String s;// 型別
public String id;// 型別id
public double shuV = 220;// 電壓
public String ofopen = "turned on";// 開關K的狀態
public int speed = 0;//
public double lin = 0.00;//
public int resistance;// 電阻
public int lux;
public int xuhao;
public Electric(String s, String id) {
this.s = s;
this.id = id;
}
public void display() {
}
public void regulate(String vs) {
}
public void reshuV(double shuop) {
}
public int getL(){
return 0;
}
public int fanhui() {// 比較器用到的
if (s.equals("K"))
return 9;
else if (s.equals("F"))
return 8;
else if (s.equals("L"))
return 7;
else if (s.equals("B"))
return 6;
else if (s.equals("R"))
return 5;
else if (s.equals("D"))
return 4;
else if (s.equals("A"))
return 3;
else if (s.equals("H"))
return 2;
else if (s.equals("S"))
return 1;
else
return 0;
}
}
class Kaiguan extends Electric {// 開關
public Kaiguan(String id) {
super("K", id);
}
public void display() {
System.out.printf("@K%s:%s\n", id, ofopen);
}
public void regulate(String vs) {
}
public void reshuV(double shuop) {
if (ofopen.equals("turned on")) {
shuV = 0;
// System.out.println(shuV);
} else if (ofopen.equals("closed"))
shuV = shuop;
}
}
class Fendang extends Electric {// 分檔
public Fendang(String id) {
super("F", id);
}
public void display() {
System.out.printf("@F%s:%d\n", id, speed);
}
public void regulate(String vs) {// 分檔調節
if (vs.equals("+") && speed < 3) {
speed++;
} else if (vs.equals("-") && speed > 0) {
speed--;
}
}
public void reshuV(double shuop) {
shuV = speed * 0.3 * shuop;
}
}
class Lianxu extends Electric {// 連續
public Lianxu(String id) {
super("L", id);
}
public void display() {
String siop = String.format("@L%s:%.2f", id, lin);
System.out.printf("%s\n", siop);
}
public void regulate(String vs) {
lin = Double.parseDouble(vs);
}
public void reshuV(double shuop) {
shuV = lin * shuop;
}
}
class Baichi extends Electric {// 白熾燈
public Baichi(String id) {
super("B", id);
}
public void display() {
int a = 0;
if (shuV >= 0 && shuV <= 9) {
a = 0;
} else if (shuV >= 10 && shuV <= 219) {
a = (int) ((5 * shuV) / 7 + 43);
} else if (shuV == 220) {
a = 200;
}
System.out.printf("@B%s:%d\n", id, a);
}
public void reshuV(double shuop) {
shuV = shuop;
}
public int getL(){
int a = 0;
if (shuV >= 0 && shuV <= 9) {
a = 0;
} else if (shuV >= 10 && shuV <= 219) {
a = (int) ((5 * shuV) / 7 + 43);
} else if (shuV == 220) {
a = 200;
}
return a;
}
}
class Riguang extends Electric {// 日光燈
public Riguang(String id) {
super("R", id);
}
public void display() {
int a = 0;
if (shuV == 0)
a = 0;
else
a = 180;
System.out.printf("@R%s:%d\n", id, a);
}
public void reshuV(double shuop) {
shuV = shuop;
}
public int getL(){
int a = 0;
if (shuV == 0)
a = 0;
else
a = 180;
return a;
}
}
class Diaoshan extends Electric {// 吊扇
public Diaoshan(String id) {
super("D", id);
}
public void display() {
int a = 0;
if (shuV >= 0 && shuV < 80)
a = 0;
else if (shuV >= 80 && shuV <= 150)
a = (int) ((shuV - 80) * 4 + 80);
else if (shuV > 150)
a = 360;
System.out.printf("@D%s:%d\n", id, a);
}
public void reshuV(double shuop) {
shuV = shuop;
}
}
class Luodi extends Electric {// 落地扇
public Luodi(String id) {
super("A", id);
}
public void display() {
int a = 0;
if (shuV >= 0 && shuV < 80)
a = 0;
else if (shuV >= 80 && shuV <= 99)
a = 80;
else if (shuV >= 100 && shuV <= 119)
a = 160;
else if (shuV >= 120 && shuV <= 139)
a = 260;
else if (shuV > 140)
a = 360;
System.out.printf("@A%s:%d\n", id, a);
}
public void reshuV(double shuop) {
shuV = shuop;
}
}
class Huchi extends Electric{
public Huchi(String id,int d){
super("H", id);
this.xuhao=d;
}
public void display() {
System.out.printf("@H%s:%s\n", id, ofopen);
}
public void regulate(String vs) {
}
public void reshuV(double shuop) {
if (ofopen.equals("turned on")) {
shuV = 0;
} else if (ofopen.equals("closed"))
shuV = shuop;
}
}
class Shoukong extends Electric{//R=15
public Shoukong(String id) {
super("S", id);
}
public void display() {
String a = "100%";
if(shuV>=50){
if (lux >= 0 && lux < 50)
a = "100%";
else if (lux >= 50 && lux < 100)
a = "80%";
else if (lux >= 100 && lux < 200)
a = "60%";
else if (lux >= 200 && lux < 300)
a = "40%";
else if (lux >= 300 && lux <400)
a = "20%";
else if (lux >=400)
a = "0%";
System.out.printf("@S%s:%s\n", id, a);
}
else {
System.out.printf("@S%s:%s\n", id,a);
}
}
public void reshuV(double shuop) {
shuV = shuop;
}
}
class Bi extends Electric {
public Bi(String ml) {
super("M", ml);
}
}
class Chuan extends Electric{
public Chuan(String ml){
super("T",ml);
}
}
class Duobing{
public String s;
public ArrayList<Map<String, Electric>> map;
public double k[];
public Duobing(String s,ArrayList<Map<String, Electric>> map,double b[])
{
this.s=s;
this.map=map;
this.k=b;
}
}
public class Main {
public static void main(String[] args) throws FileNotFoundException {
Scanner in = new Scanner(System.in);
String s = "", pop = "", zong = "", chuanxu = "", bingxu = "";
int i;
ArrayList<String> connection = new ArrayList<>();
ArrayList<String> connection1 = new ArrayList<>();
ArrayList<String> chw = new ArrayList<>();
while (true) {
s = in.nextLine().trim();
if ("end".equals(s))
break;
if (s.startsWith("#T"))// 將每一條路線存進去
{
Pattern pattern = Pattern.compile("#(.*):(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
chuanxu = String.valueOf(matcher.group(1));
pop = String.valueOf(matcher.group(2));
}
connection.add(chuanxu + ":" + pop);
}
else if (s.startsWith("#M"))// 將並聯的電路放進去，後面進行判斷
{
Pattern pattern = Pattern.compile("#(.*):(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
bingxu = String.valueOf(matcher.group(1));
pop = String.valueOf(matcher.group(2));
}
connection1.add(bingxu + " " + pop);
}
else if (s.startsWith("#K"))// 對開關進行儲存後面進行更改
{
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = String.valueOf(matcher.group(1));
}
chw.add(pop);
}
else if (s.startsWith("#F")) {
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = String.valueOf(matcher.group(1));
}
chw.add(pop);
}
else if (s.startsWith("#L")) {
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = String.valueOf(matcher.group(1));
}
chw.add(pop);
}
else if(s.startsWith("#H")){
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = String.valueOf(matcher.group(1));
}
chw.add(pop);
}
}
int kllk = 0, mmm = 0;
String z1 = "", zm = "";
String bnb="";
Map<String, Map<String, Electric>> mac = new HashMap<>();
Map<String, Electric> zhu = new LinkedHashMap<>();
Map<String, Electric> map4 = new HashMap<>();
for (mmm = 0; mmm < connection.size(); mmm++) {// 將並聯的與串聯的電路分開儲存
int vb1 = 0, vb2 = 0;
Map<String, Electric> map1 = new LinkedHashMap<>();
z1 = connection.get(mmm);
Pattern pattern = Pattern.compile("(.*):(.*)");
Matcher matcher = pattern.matcher(z1);
while (matcher.find()) {
zm = String.valueOf(matcher.group(1));
pop = String.valueOf(matcher.group(2));
}
//System.out.println(zm);
String[] partsl = pop.split("]");
String jk = "", jk1 = "";
for (kllk = 0; kllk < partsl.length; kllk++) {
jk1 = partsl[0].trim();
jk = partsl[kllk].trim();
//System.out.println(jk);
if (jk1.startsWith("[IN")) {
vb1 = 1;
String[] parts4 = jk.split(" ");
//System.out.println(parts4[0]);
if(parts4[1].equals("OUT")){
if(parts4[0].startsWith("[H")) {
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0]);
while (matcher.find()) {
dkey = String.valueOf(matcher.group(1));
}
if (dkey.startsWith("H")) {
int m1 = Integer.parseInt(pinyin[1]);
if ((m1 == 2 || m1 == 3) && parts4[0] != null) {
bnb = parts4[0].substring(1, 3);
map1 = compose(dkey, bnb, map1, m1);
}
}
break;
}
else {
break;
}
}
if(parts4[0].startsWith("[H")){
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0]);
while (matcher.find()) {
dkey = String.valueOf(matcher.group(1));
}
if(dkey.startsWith("H")) {
int m1=Integer.parseInt(pinyin[1]);
if((m1==2||m1==3)&&parts4[0]!=null){
//System.out.println(parts4[0]);
bnb=parts4[0].substring(1,3);
map1 = compose(dkey, bnb, map1,m1);
}
}
if(parts4[1].equals("OUT"))
break;
String[] pinyin1 = parts4[1].split("-");
dkey = pinyin1[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin1[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1);
}
}
else{
map1 = complain(dkey, parts4[1], map1,1);
}
}
else {
String[] pinyin = parts4[1].split("-");
//System.out.println(parts4[1]);
String dkey = pinyin[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1);
}
}
else{
map1 = complain(dkey, parts4[1], map1,1);
}
}
}
else if (jk1.startsWith("[VCC")) {
//System.out.println(1);
vb2 = 1;
String[] parts4 = jk.split(" ");
if(parts4[1].equals("GND")){
if(parts4[0].startsWith("[H")) {
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0].trim());
while (matcher.find()) {
dkey = String.valueOf(matcher.group(1));
}
if (dkey.startsWith("H")) {
int m1 = Integer.parseInt(pinyin[1]);
if ((m1 == 2 || m1 == 3) && parts4[0] != null) {
bnb = parts4[0].substring(1, 3);
map1 = compose(dkey, bnb, map1, m1);
}
}
break;
}
else {
break;
}
}
if(parts4[0].startsWith("[H")){
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0].trim());
while (matcher.find()) {
dkey = String.valueOf(matcher.group(1));
}
if(dkey.startsWith("H")) {
int m1=Integer.parseInt(pinyin[1]);
//System.out.println(dkey+" "+ parts4[0]);
if((m1==2||m1==3)&&parts4[0]!=null){
bnb=parts4[0].substring(1,3);
map1 = compose(dkey, bnb, map1,m1);
}
}
if(parts4[1].equals("GND"))
break;
String[] pinyin1 = parts4[1].split("-");
dkey = pinyin1[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin1[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1);
}
}
else{
map1 = complain(dkey, parts4[1], map1,1);
}
}
else {
String[] pinyin = parts4[1].split("-");
//System.out.println(parts4[1]);
String dkey = pinyin[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1);
}
}
else{
map1 = complain(dkey, parts4[1], map1,1);
}
}
}
}
if (vb1 == 1){
mac.put(zm, map1);// 並聯電路以及其他電路
//System.out.println(mac.size());
}
if (vb2 == 1) {
zhu = map1;// 主電路
}
}
//System.out.println(zhu.size());
int flag = 0;
int flag2 = 0;
int lll = 0;
double rui = 220.0000000001;
for (i = 0; i < chw.size(); i++) {
String sid = chw.get(i);
for (Entry<String, Map<String, Electric>> entry : mac.entrySet()){
if (sid.startsWith("K")) {
String diu = sid.trim();
Electric electric = entry.getValue().get(diu);
if (electric != null) {
if (electric.ofopen.equals("turned on"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
else if (sid.startsWith("F")) {
String diu="";
String vs="";
Pattern pattern = Pattern.compile("(.*)(.)");
Matcher matcher = pattern.matcher(sid);
while (matcher.find()) {
diu = String.valueOf(matcher.group(1));
vs = String.valueOf(matcher.group(2));
}
Electric electric = entry.getValue().get(diu);
if (electric != null) {
electric.regulate(vs);
flag2++;
if (vs.equals("+")) {
flag++;
if (flag >= 3) {
flag = 3;
}
}
if (vs.equals("-")) {
flag--;
if (flag <= 0) {
flag = 0;
}
}
break;
}
}
else if (sid.startsWith("L")) {
String diu = sid.substring(0, 2);
String vs = sid.substring(3);
Electric electric = entry.getValue().get(diu);
if (electric != null) {
electric.regulate(vs);
break;
}
}
else if(sid.startsWith("H")){
String diu = sid.trim();
int n1=0;
int n2=0;
for (Entry<String, Map<String, Electric>> try1 : mac.entrySet()){
Electric electric = try1.getValue().get(diu+2);
if (electric != null) {
n1=1;
if (electric.ofopen.equals("turned on"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
//System.out.println(electric.ofopen+" "+electric.xuhao);
break;
}
}
for (Entry<String, Map<String, Electric>> try1 : mac.entrySet()){
Electric electric1 = try1.getValue().get(diu+3);
if (electric1 != null) {
n2=1;
if (electric1.ofopen.equals("turned on"))
electric1.ofopen = "closed";
else
electric1.ofopen = "turned on";
//System.out.println(electric1.ofopen+" "+electric1.xuhao);
break;
}
}
if(n1==1||n2==1)
break;
}
}
for (Entry<String, Electric> entry : zhu.entrySet()) {
if (sid.startsWith("K")) {
String diu = sid.trim();
Electric electric = zhu.get(diu);
if (electric != null) {
if (electric.ofopen.equals("turned on"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
else if (sid.startsWith("H")) {
String diu = sid.trim();
int n1=0;
int n2=0;
for (Entry<String, Electric> try1 : zhu.entrySet()){
Electric electric = zhu.get(diu+2);
if (electric != null) {
n1=1;
if (electric.ofopen.equals("turned on"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
for (Entry<String, Electric> try1 : zhu.entrySet()){
Electric electric1 = zhu.get(diu+3);
if (electric1 != null) {
n2=1;
if (electric1.ofopen.equals("turned on"))
electric1.ofopen = "closed";
else
electric1.ofopen = "turned on";
break;
}
}
if(n1==1||n2==1)
break;
}
else if (sid.startsWith("F")) {
String diu="";
String vs="";
Pattern pattern = Pattern.compile("(.*)(.)");
Matcher matcher = pattern.matcher(sid);
while (matcher.find()) {
diu = String.valueOf(matcher.group(1));
vs = String.valueOf(matcher.group(2));
}
Electric electric = zhu.get(diu);
if (electric != null) {
electric.regulate(vs);
flag2++;
break;
}
}
else if (sid.startsWith("L")) {
String diu = sid.substring(0, 2);
String vs = sid.substring(3);
Electric electric = zhu.get(diu);
if (electric != null) {
electric.regulate(vs);
break;
}
}
}
}
Map<String,ArrayList<Map<String, Electric>>> vjk=new LinkedHashMap<>();
Map<String, Map<String, Electric>> maps = new HashMap<>();
for (mmm = 0; mmm < connection1.size(); mmm++) {// 判斷那些事並聯電路並儲存
String k11 = connection1.get(mmm).substring(0, 2);
Pattern pattern = Pattern.compile("(.*)\\s\\[(.*)]");
Matcher matcher = pattern.matcher(connection1.get(mmm));
while (matcher.find()) {
pop = String.valueOf(matcher.group(2));
}
String[] partsl = pop.split(" ");
ArrayList<Map<String, Electric>> uzi=new ArrayList<>();
for (int yq = 0; yq < partsl.length; yq++) {
for (Entry<String, Map<String, Electric>> entry1 : mac.entrySet()) {
if (entry1.getKey().equals(partsl[yq])) {
maps.put(k11 + "" + yq, entry1.getValue());
uzi.add(entry1.getValue());
//System.out.println(uzi.size());
}
}
vjk.put(k11,uzi);
}
}
//System.out.println(vjk.size());
double siop = rui;
double a[] = new double[vjk.size()];// 算電阻//vjk是並聯電路所對應的路的List
double b[] = new double[1];
i = 0;
int sum1,sum2,sum3;
sum2=0;
int s1=0,mv=0;
double chuanR=0, bingR=0;
int zonglux=0;
int cw=0,cw1=0;
ArrayList<Duobing> duobing=new ArrayList<>();
for(Entry<String,ArrayList<Map<String, Electric>>> entry : vjk.entrySet()) {
double[] c= new double[entry.getValue().size()];
i = 0;
cw=0;
for (sum1 = 0; sum1 < entry.getValue().size(); sum1++) {
for (Entry<String, Electric> entry1 : entry.getValue().get(sum1).entrySet()) {
int hjh = 0;
flag = 0;
if (entry1.getKey().startsWith("K")) {
if (entry1.getValue().ofopen.equals("turned on"))
flag = 1;
if (entry1.getValue().ofopen.equals("closed"))
hjh++;
}
if (entry1.getKey().startsWith("H")) {
if (entry1.getValue().ofopen.equals("turned on")){
flag = 1;
//System.out.println(entry1.getValue().xuhao);
}
if (entry1.getValue().ofopen.equals("closed")) {
hjh++;
//System.out.println(entry1.getValue().xuhao);
}
}
if(entry1.getKey().startsWith("T")){
cw=0;
for(Entry<String, Map<String, Electric>> en6 : mac.entrySet()) {
if (en6.getKey().equals(entry1.getKey())) {
for(Entry<String, Electric> e : en6.getValue().entrySet()){
cw++;
if (e.getKey().startsWith("K")) {
if (e.getValue().ofopen.equals("turned on"))
flag = 1;
if (e.getValue().ofopen.equals("closed"))
hjh++;
}
if (e.getKey().startsWith("H")) {
if (e.getValue().ofopen.equals("turned on")){
flag = 1;
//System.out.println(entry1.getValue().xuhao);
}
if (e.getValue().ofopen.equals("closed")) {
hjh++;
//System.out.println(entry1.getValue().xuhao);
}
}
c[i] = c[i] + 1.0 * e.getValue().resistance;
}
cw1=cw+cw1;
}
}
}
if (hjh == entry.getValue().size()+cw1) {
c[i] = 0;//說明短路
break;
}
if (flag == 1)//說明斷路
{
c[i] = -1;
break;
}
else {
c[i] = c[i] + 1.0 * entry1.getValue().resistance;
}
}
i++;
}
duobing.add(new Duobing(entry.getKey(), entry.getValue(), c));
s1=0;
for (i = 0; i < c.length; i++) {
if (c[i] == 0) {
a[sum2] = 0;//短路
break;
}
else {
if (c[i] == -1){
s1++;
if(s1==c.length){
mv=1;
}
continue;
}
else {
a[sum2] = 1.0 / c[i] + a[sum2];
//System.out.println(a[sum2]);
}
}
}
sum2++;
}
for(sum3=0;sum3<a.length;sum3++){
if (a[sum3] == 0)
continue;
else{
bingR = bingR+1.0/a[sum3];
}
}
//System.out.println(bingR);
b[0]=0;
double l[]=new double[1];
int flag4 = 0;
int f1=0;
for (Entry<String, Electric> entry : zhu.entrySet()) {
flag=0;
if (entry.getKey().startsWith("K")) {
flag=0;
if (entry.getValue().ofopen.equals("turned on")){
flag = 1;
}
if(flag==1){
b[0] = -1;
break;
}
}
else if (entry.getKey().startsWith("H")) {
flag=0;
if (entry.getValue().ofopen.equals("turned on")){
flag = 1;
}
if(flag==1){
b[0] = -1;
break;
}
}
else if(entry.getKey().startsWith("T")){
l[0]=0;
for(Entry<String, Map<String, Electric>> entry6 : mac.entrySet()) {
if(entry6.getKey().equals(entry.getKey())) {
for(Entry<String, Electric> en : entry6.getValue().entrySet()) {
if (en.getKey().startsWith("K")) {
flag4=0;
if (en.getValue().ofopen.equals("turned on")) {
flag4 = 1;
}
if (flag4 == 1) {
l[0] = -1;
break;
}
}
else if(en.getKey().startsWith("H")){
flag4=0;
if (en.getValue().ofopen.equals("turned on")) {
flag4 = 1;
}
if (flag4 == 1) {
l[0] = -1;
break;
}
else
l[0]=l[0]+en.getValue().resistance;
}
else
l[0]=l[0]+en.getValue().resistance;
}
break;
}
}
if(l[0]==-1){
b[0]=-1;
break;
}
else{
b[0]=b[0]+l[0];
}
}
b[0] = b[0] + entry.getValue().resistance;
}
chuanR = b[0];
//System.out.println(chuanR+" "+bingR);
double chuanV = 0, bingV = 0;
chuanV = rui * chuanR / (bingR + chuanR);
bingV = rui * bingR / (bingR + chuanR);
zonglux=0;
Map<String, Electric> maso = new HashMap<>();
for (Entry<String, Electric> entry : zhu.entrySet()) {
String parts8 = entry.getKey();
s = parts8;
if(b[0]==-1||flag4==1||flag==1||mv==1){
siop=0;
rui=0;
chuanV=0;
bingV=0;
}
if (s.startsWith("K")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui = elc1.shuV;
chuanV = 1.0*rui * chuanR / (bingR + chuanR);
bingV = 1.0*rui * bingR / (bingR + chuanR);
maso.put(s, elc1);
}
else if (s.startsWith("H")) {
Electric elc1 = zhu.get(parts8);
if(elc1.xuhao ==3){
if(elc1.ofopen.startsWith("t")){
elc1.ofopen="closed";
}
else{
elc1.ofopen="turned on";
}
}
maso.put(s, elc1);
}
else if (s.startsWith("B")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(10*chuanV/chuanR);
zonglux=zonglux+elc1.getL();
//System.out.println(elc1.shuV);
maso.put(s, elc1);
}
else if (s.startsWith("R")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(5*chuanV/chuanR);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(20*chuanV/chuanR);
maso.put(s, elc1);
}
else if (s.startsWith("A")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(20*chuanV/chuanR);
maso.put(s, elc1);
}
else if (s.startsWith("L")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui = elc1.shuV;
chuanV = rui * chuanR / (bingR + chuanR);
bingV = rui * bingR / (bingR + chuanR);
//System.out.println(bingR);
maso.put(s, elc1);
}
else if (s.startsWith("F")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui=elc1.shuV;
chuanV = rui * chuanR / (bingR + chuanR);
bingV = rui * bingR / (bingR + chuanR);
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(15*chuanV/chuanR);
maso.put(s, elc1);
}
else if(s.startsWith("T")) {
//System.out.println("1");
for(Entry<String, Map<String, Electric>> entry6 : mac.entrySet()) {
if(entry6.getKey().equals(s)){
//System.out.println(chuanR);
for(Entry<String,Electric> jk : entry6.getValue().entrySet()) {
s=jk.getKey();
if (s.startsWith("K")) {
Electric elc1 = entry6.getValue().get(s);
maso.put(s, elc1);
}
else if(s.startsWith("H")) {
Electric elc1 = entry6.getValue().get(s);
if(elc1.xuhao ==3){
if(elc1.ofopen.startsWith("t")){
elc1.ofopen="closed";
}
else{
elc1.ofopen="turned on";
}
}
maso.put(s, elc1);
}
else if (s.startsWith("B")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(10 * chuanV / chuanR);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("R")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(5 * chuanV / chuanR);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(20 * chuanV / chuanR);
maso.put(s, elc1);
//System.out.println(elc1.shuV);
}
else if (s.startsWith("A")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(20 * chuanV / chuanR);
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(15 * chuanV / chuanR);
maso.put(s, elc1);
}
}
}
}
}
else if (s.startsWith("M")) {
for(int cmd=0;cmd<duobing.size();cmd++){
if(duobing.get(cmd)==null)continue;
Duobing d1=duobing.get(cmd); //public ArrayList<Map<String, Electric>> map;
if(d1.s.equals(s)){
for(int kkkk=0;kkkk<d1.map.size();kkkk++){
if(d1.map.get(kkkk)==null)continue;
siop=bingV*(1/a[cmd])/bingR;
if(a[cmd]==0){
siop=0;
for(Entry<String,Electric>c1:d1.map.get(kkkk).entrySet()){
parts8 = c1.getKey();
s = parts8;
if (s.startsWith("K")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.ofopen.startsWith("t")) {
siop = 0;
}
maso.put(s, elc1);
}
else if (s.startsWith("H")) {
int yy=0;
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.ofopen.startsWith("t")) {
siop = 0;
}
if(elc1.xuhao==2){
maso.put(s, elc1);
}
else if(elc1.xuhao==3){
String jkj="";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = String.valueOf(matcher.group(1));
}
for(int d=0;d<d1.map.size();d++) {
for (Entry<String, Electric> c2 : d1.map.get(d).entrySet()) {
Electric elc2 = d1.map.get(d).get(jkj+2);
if(elc2!=null)
yy=1;
}
}
if(yy==0){
if(elc1.ofopen.startsWith("t"))
elc1.ofopen="closed";
else
elc1.ofopen="turned on";
maso.put(s, elc1);
}
}
}
else if (s.startsWith("B")) {
//System.out.println(10*siop/a[i]);
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
// System.out.println(elc1.shuV);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("R")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
//System.out.println(elc1.shuV);
maso.put(s, elc1);
}
else if (s.startsWith("A")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
maso.put(s, elc1);
}
}
}
if(d1.k[kkkk]!=-1&&d1.k[kkkk]!=0) {
for (Entry<String, Electric> c1 : d1.map.get(kkkk).entrySet()) {
parts8 = c1.getKey();
s = parts8;
//System.out.printf(s);
if (s.startsWith("K")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.ofopen.startsWith("t")) {
siop = 0;
}
maso.put(s, elc1);
}
else if (s.startsWith("H")) {
int yy=0;
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.ofopen.startsWith("t")) {
siop = 0;
}
if(elc1.xuhao==2){
maso.put(s, elc1);
}
else if(elc1.xuhao==3){
String jkj="";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = String.valueOf(matcher.group(1));
}
for(int d=0;d<d1.map.size();d++) {
for (Entry<String, Electric> c2 : d1.map.get(d).entrySet()) {
Electric elc2 = d1.map.get(d).get(jkj+2);
if(elc2!=null)
yy=1;
}
}
if(yy==0){
if(elc1.ofopen.startsWith("t"))
elc1.ofopen="closed";
else
elc1.ofopen="turned on";
maso.put(s, elc1);
}
}
}
else if (s.startsWith("B")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(10 * siop/ d1.k[kkkk]);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("R")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(5 * siop/ d1.k[kkkk]);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(20 * siop/ d1.k[kkkk]);
maso.put(s, elc1);
}
else if (s.startsWith("A")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(20 * siop/ d1.k[kkkk]);
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(15 * siop/ d1.k[kkkk]);
maso.put(s, elc1);
}
}
}
else {
siop=0;
for (Entry<String, Electric> c1 : d1.map.get(kkkk).entrySet()) {
parts8 = c1.getKey();
s = parts8;
//System.out.println(s);
if (s.startsWith("K")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.shuV=0;
maso.put(s, elc1);
}
else if (s.startsWith("H")) {
int yy=0;
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.ofopen.startsWith("t")) {
siop = 0;
}
if(elc1.xuhao==2){
maso.put(s, elc1);
}
else if(elc1.xuhao==3){
String jkj="";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = String.valueOf(matcher.group(1));
}
for(int d=0;d<d1.map.size();d++) {
for (Entry<String, Electric> c2 : d1.map.get(d).entrySet()) {
Electric elc2 = d1.map.get(d).get(jkj+2);
if(elc2!=null)
yy=1;
}
}
if(yy==0){
if(elc1.ofopen.startsWith("t"))
elc1.ofopen="closed";
else
elc1.ofopen="turned on";
maso.put(s, elc1);
}
}
}
else if (s.startsWith("B")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
// System.out.println(elc1.shuV);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("R")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
//System.out.println(elc1.shuV);
maso.put(s, elc1);
}
else if (s.startsWith("A")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
//System.out.println(elc1.shuV);
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
maso.put(s, elc1);
}
}
}
}
}
}
}
}
ArrayList<Electric> arraylist6 = new ArrayList<>();
for (Entry<String, Electric> pose : maso.entrySet()) {
if(pose.getValue()==null)continue;
arraylist6.add(pose.getValue());
}
//System.out.println("1");
Comparator<Electric> numberComparator = new Comparator<Electric>() {
public int compare(Electric o1, Electric o2) {
int a = o1.fanhui();
int b = o2.fanhui();
if (a > b)
return -1;
else if (a == b) {
String c = o1.id;
String d = o2.id;
if (c.compareTo(d)>0)
return 1;
else
return -1;
} else
return 1;
}
};
Collections.sort(arraylist6, numberComparator);
for (Electric suixcs : arraylist6) {
if(suixcs.s.equals("S")){
suixcs.lux=zonglux;
}
suixcs.display();
}
}
public static Map<String, Electric> complain(String dkey, String s, Map<String, Electric> map1,int a) {
String jkj="";
Pattern pattern = Pattern.compile(".(.*)");
Matcher matcher = pattern.matcher(dkey);
while (matcher.find()) {
jkj = String.valueOf(matcher.group(1));
}
//System.out.println(dkey);
//System.out.println(s+" "+jkj);
if (s.startsWith("K")) {
Electric tric = new Kaiguan(jkj);
tric.resistance = 0;
tric.lux=0;
map1.put(dkey, tric);
}
else if (s.startsWith("F")) {
Electric tric = new Fendang(jkj);
tric.resistance = 0;
tric.lux=0;
map1.put(dkey, tric);
}
else if (s.startsWith("L")) {
Electric tric = new Lianxu(jkj);
tric.resistance = 0;
tric.lux=0;
map1.put(dkey, tric);
}
else if (s.startsWith("B")) {
Electric tric = new Baichi(jkj);
tric.resistance = 10;
map1.put(dkey, tric);
} else if (s.startsWith("R")) {
Electric tric = new Riguang(jkj);
tric.resistance = 5;
map1.put(dkey, tric);
} else if (s.startsWith("D")) {
Electric tric = new Diaoshan(jkj);
tric.resistance = 20;
map1.put(dkey, tric);
}
else if (s.startsWith("A")) {
Electric tric = new Luodi(jkj);
tric.resistance = 20;
map1.put(dkey, tric);
}
else if (s.startsWith("M")) {
Electric tric = new Bi(jkj);
tric.resistance = 0;
map1.put(dkey,tric);
}
else if (s.startsWith("T")) {
Electric tric = new Chuan(jkj);
tric.resistance = 0;
map1.put(dkey,tric);
}
else if (s.startsWith("H")) {
//System.out.println(a);
Electric tric = new Huchi(jkj,a);
tric.xuhao=a;
if(a==2) {
tric.resistance = 5;
tric.ofopen="closed";
}
if(a==3){
tric.resistance = 10;
tric.ofopen="turned on";
}
map1.put(dkey,tric);
}
else if (s.startsWith("S")) {
Electric tric = new Shoukong(jkj);
tric.resistance = 15;
tric.xuhao=2;
map1.put(dkey,tric);
}
return map1;
}
public static Map<String, Electric> compose(String dkey, String s, Map<String, Electric> map1, int m) {
//System.out.println(s);
String jkj="";
Pattern pattern = Pattern.compile(".(.*)");
Matcher matcher = pattern.matcher(dkey);
while (matcher.find()) {
jkj = String.valueOf(matcher.group(1));
}
if (s.startsWith("H")) {
Electric tric = new Huchi(jkj,m);
tric.resistance = 0;
tric.xuhao=m;
if(m==2) {
tric.resistance = 5;
tric.ofopen="closed";
}
if(m==3){
tric.resistance = 10;
tric.ofopen="turned on";
}
//System.out.println(tric.xuhao);
map1.put(dkey+m,tric);
}
return map1;
}
}
總結：
這次作業主要考慮的是互斥開關，重點也是這個，窗簾則沒有什麼難度，主要考慮互斥開關的兩個端點的狀態，在輸出的時候要輸出2的狀態，在電路中只有三的時候，要將其轉換為2。這次有三分沒有拿到，但是在寫最後一次題目的時候，突然想起來了，因為精度的問題，改了一個值，導致最後輸出的時候有一個地方導致輸出結果錯誤，在最後一次作業中也看到了相應的問題，最後在最後的作業中解決了這一問題。
(2)第八次大作業
點選檢視題目
7-1 家居強電電路模擬程式-4
分數 100
作者 蔡軻
單位 南昌航空大學
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-3”的基礎上增加的功能要求。
1、控制裝置
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器、互斥開關。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳（接往電源端），而另一個則是輸出引腳（接網接地端）。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
互斥開關：
互斥開關有3個引腳：1個是彙總引腳，另兩個是分支引腳。
開關電路示意圖如圖1所示，左邊是彙總引腳，編號為1；右邊兩個是分支引腳，右上的輸出引腳為2，右下輸出引腳為3。圖中1、2、3引腳均可以是輸入引腳，當1為輸入引腳時，2、3引腳為輸出引腳；1為輸出引腳時，2、3引腳為輸入引腳。
互斥開關只有兩種狀態：開關接往上面的2號引腳、接往下面的3號引腳。開關每次只能接通其中一個分支引腳，而另一個分支引腳處於斷開狀態。
互斥開關的預設狀態為1、2引腳接通，1、3引腳斷開。
圖1中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。
image.png
圖1 互斥開關
為避免短路，互斥開關設定了限流電阻，1、2引腳之間預設電阻為5，1、3引腳之間預設電阻為10。
分檔調速器
按檔位調整，常見的有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 轉/分鐘；[80V,100V) 對應轉速為 80 轉/分鐘；[100,120)V 對應轉速為 160 轉/分鐘；[120,140)V 對應轉速為 260 轉/分鐘；大於等於 140V 轉速 為 360 轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。
本次迭代模擬一種受控窗簾：
受控串聯的電路符號為S，其最低工作電壓為50V，電壓達到或超過50V，窗簾即可正常工作，不考慮室外光照強度和室內空間大小等因素，窗簾受室內燈光的光照強度控制。
當電路中所有燈光的光照強度總和在[0,50)lux範圍內，窗簾全開；
在[50,100)lux範圍內，窗簾開啟比例為0.8；
在[100,200)lux範圍內，窗簾開啟比例為0.6；
在[200,300)lux範圍內，窗簾開啟比例為0.4；
在[300,400)lux範圍內，窗簾開啟比例為0.2；
在400lux及以上範圍內，窗簾關閉。
窗簾預設為關閉狀態。
受控裝置電阻：白熾燈的電阻為 10，日光燈的電阻為 5，吊扇的電阻為 20，落地扇的電阻為 20，窗簾電阻為15。
3、輸入資訊
1）輸入裝置資訊
分別用裝置識別符號K、F、L、B、R、D、A、H、S、P分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇、互斥開關、受控窗簾、二極體（見第6部分說明）。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
引腳格式：
裝置標識-引腳編號，例如：K1-1標識編號為1的開關的1號引腳。
開關、分檔調速器、連續調速器的兩個引腳編號為1、2。
受控裝置的兩個引腳編號分別為1、2。
互斥開關的引腳編號已經在互斥開關的介紹部分說明。
約束條件：
不同裝置的編號可以相同。
裝置資訊不單獨輸入，包含在連線資訊中。
2）輸入連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
格式：
"["+引腳號+" "+引腳號+"]"
例如：[K1-1 K3-2]表示K1的1號引腳，K3的2號引腳連線在一起。
約束條件：
不考慮調速器串聯到其他調速器的情況。
考慮各類裝置的並聯接入。例如，K1 的輸出接到 L2 的輸入，L2 的輸出再接其他裝置屬於串聯接線。K1 的輸出接到 L2 的輸出，同時 K1 的輸入接到 L2 的輸入，這種情況屬於並聯。
連線資訊不單獨輸入，包含線上路資訊中。
3）輸入控制裝置調節資訊
開關、互斥開關調節資訊格式：
#+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。
#+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。
分檔調速器的調節資訊格式：
#+裝置標識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。
在本題中，並聯電路M中的串聯電路可以包含別的並聯電路。
約束條件：
本題不考慮輸入電壓或電壓差超過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的一個部分，本題考慮這種型別的輸入。
4、輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、互斥開關、受控窗簾、二極體（見第6部分說明）的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：
@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）+" "+裝置所有引腳的電壓（按編號從小到大順序依次輸出，電壓的小數部分直接丟棄，保留整數輸出，電壓之間用”-”分隔）
說明：
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on 32-15
@B1:190 68-17
@L1:0.60 220-176
互斥開關按1、2引腳的接通狀態顯示，1，2接通-1，3斷開時顯示closed，1，3接通-1，2斷開時顯示turned on。
如：
@H1:turned on
受控窗簾顯示窗簾開啟的百分比，如：
@S1:80%
5、家居電路模擬系列所有題目的預設規則
1）當計算電壓值等數值的過程中，最終結果出現小數時，用截尾規則去掉小數部分，只保留整數部分。為避免精度的誤差，所有有可能出現小數的數值用double型別儲存並計算，不要作下轉型資料型別轉換，例如電壓、轉速、亮度等，只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出。
2）所有連線資訊按電路從靠電源端到靠接地端的順序依次輸入，不會出現錯位的情況。VCC/IN一定是第一個連線的第一項，GND/OUT一定是最後一個連線的後一項。
3）連線資訊如果只包含兩個引腳，靠電源端的引腳在前，靠接地端的在後。
4）調速器的輸入端只會直連VCC，不會接其他裝置。整個電路最多隻有連線在電源上的一個調速器，且不包含在並聯單路中。
5）本系列題目中元件的管腳除了互斥開關的1引腳，其他所有引腳在電路中最多隻出現一次。
6、本題新增內容：
1）增加管腳電壓的顯示
在輸出每個電器的狀態資訊後，再依次輸出該電器每個管腳的電壓。（格式詳見輸出資訊部分）
2）電流限制
電器在工作時，過大的電流會引起電器過熱，從而燒壞電路。本次迭代，每個元器件都有最大電流的設定，當實時電流超過最大電流時，在該電器輸出資訊的最後加入提示“exceeding current limit error”，與前面的資訊之間用英文空格分隔。
例如：@B1:190 68-17 exceeding current limit error
本題各類電器的最大限定電流如下：
開關20、分檔調速器18、連續調速器18、白熾燈9、日光燈5、吊扇12、落地扇14、互斥開關20、受控窗簾12、二極體8。
3）短路檢測
如果電路出現無窮大的電流造成短路，所有元器件資訊不輸出，僅輸出提示“short circuit error”
4）並聯電路中包含並聯
本次迭代考慮並聯電路中包含並聯電路的情況，即構成並聯電路的串聯電路可以包含別的並聯電路。例如如下輸入的電路，並聯電路M2的其中一條串聯電路T4中包含了另一條並聯電路M1：
#T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
5）二極體
增加二極體元件，其電路特性為：正向導通，反向截止；其電器符號如圖4所示，當電流從左至右流過時，二極體導通”conduction”，電阻為0；電流從右至左流動時，二極體截止”cutoff”，電阻無窮大，相當於開關開啟。
image.png
圖2 二極體符號
二極體的識別符號為’P’，左側管腳編號為1，右側管腳編號為2。
二極體如果兩端電壓相等，沒有電流流過，分以下兩種情況輸出：
1、如果兩端電壓為0，二極體的導通/截止狀態由接入方向決定，1號引腳靠近電源則導通，反之截止。
2、如果兩端電壓不為0，二極體導通。
7、設計建議
本題包含以下電路圖中的所有連線情況：
image.png
圖3 電路示意圖
1、電路裝置類：描述所有電路裝置的公共特徵。
2、受控裝置類、控制裝置類：對應受控、控制裝置
3、串聯電路類：一條由多個電路裝置構成的串聯電路，也看成是一個獨立的電路裝置
4、並聯電路類：繼承電路裝置類，也看成是一個獨立的電路裝置
其他類以及類的屬性、方法自行設計。
image.png
圖4：建議設計類圖
輸入樣例1:
在這裡給出一組輸入。例如：
#T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
#T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]
#K1
#K2
end
輸出樣例1:
在這裡給出相應的輸出。例如：
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:turned on 220-0
@B1:200 220-0 exceeding current limit error
@D1:0 0-0
@H1:closed 0-0-0
@P2:cutoff 0-0
輸入樣例2:
在這裡給出一組輸入。例如：
#T1:[IN P2-1] [P2-2 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
#T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]
#K1
#K3
#K2
end
輸出樣例2:
在這裡給出相應的輸出。例如：
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:closed 220-220 exceeding current limit error
@B1:200 220-0 exceeding current limit error
@D1:0 220-220
@H1:closed 0-220-220 exceeding current limit error
@P2:conduction 220-220 exceeding current limit error
輸入樣例3:
在這裡給出一組輸入。例如：
#T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]
#T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]
#K1
#K3
#K2
end
輸出樣例3:
在這裡給出相應的輸出。例如：
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:closed 220-220
@B1:200 220-0 exceeding current limit error
@D1:0 220-220
@H1:closed 0-0-220
@P2:cutoff 0-220
輸入樣例4:
在這裡給出一組輸入。例如：
#T3:[VCC K2-1] [K2-2 GND]
#K2
end
輸出樣例4:
在這裡給出相應的輸出。例如：
short circuit error
我的程式碼：
點選檢視程式碼
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Electric {
public String s;
public String id;
public double shuV = 220;
public String ofopen = "turned on";
public int speed = 0;
public double lin = 0.00;
public int resistance;
public int lux;
public int xuhao;
public double current;
public double sjc;
public double ruV=0;
public double chuV=0;
public double chuV1=0;
public int xh;
public String sq=" exceeding current limit error";
public Electric(String s, String id) {
this.s = s;
this.id = id;
}
public void display() {
}
public void regulate(String vs) {
}
public void reshuV(double shuop) {
}
public void Xia(){
if(xuhao==2&&xh!=1){
if(ofopen.startsWith("t")){
double ch=ruV;
ruV=chuV1;
chuV1=ch;
}
else{
double ch=ruV;
ruV=chuV;
chuV=ch;
}
}
else if(xh!=1){
double ch=ruV;
ruV=chuV;
chuV=ch;
}
}
public void scV(int gg,double c1){
if (gg == 1) {
ruV=0;
chuV=0;
} else {
ruV = c1;
chuV = c1;
}
}
public int getL(){
return 0;
}
public int fh() {
switch (s) {
case "K":
return 10;
case "F":
return 9;
case "L":
return 8;
case "B":
return 7;
case "R":
return 6;
case "D":
return 5;
case "A":
return 4;
case "H":
return 3;
case "S":
return 2;
case "P":
return 1;
}
return 0;
}
}
class kg extends Electric {
public kg(String id) {
super("K", id);
}
public void display() {
Xia();
String ss="@K"+id+":"+ofopen+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double s) {
if (ofopen.equals("turned on")) {
shuV = 0;
chuV = 0;
} else if (ofopen.equals("closed")){
shuV = s;
chuV=shuV;
}
}
}
class fd extends Electric {
public fd(String id) {
super("F", id);
}
public void display() {
Xia();
String ss="@F"+id+":"+speed+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void regulate(String vs) {
if (vs.equals("+") && speed < 3) {
speed++;
} else if (vs.equals("-") && speed > 0) {
speed--;
}
}
public void reshuV(double s) {
shuV = speed * 0.3 * s;
}
}
class Lx extends Electric {
public Lx(String id) {
super("L", id);
}
public void display() {
Xia();
String s = String.format("@L%s:%.2f", id, lin);
s=s+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
s=s+sq;
System.out.println(s);
}
public void regulate(String vs) {
lin = Double.parseDouble(vs);
}
public void reshuV(double s) {
shuV = lin * s;
}
}
class Baichi extends Electric {
public Baichi(String id) {
super("B", id);
}
public void display() {
Xia();
int a = 0,b=(int)Math.floor(shuV);
if (b >= 0 && b <= 9) {
a = 0;
} else if (b >= 10 && b <= 219) {
a = (5 * b) / 7 + 43;
} else if (b >= 220) {
a = 200;
}
String ss="@B"+id+":"+a+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double s) {
shuV = s;
}
public int getL(){
int c=(int)Math.floor(shuV);
int a = 0;
if (c >= 0 && c <= 9) {
a = 0;
} else if (c >= 10 && c <= 219) {
a = (5 * c) / 7 + 43;
} else if (c == 220) {
a = 200;
}
return a;
}
}
class Riguang extends Electric {
public Riguang(String id) {
super("R", id);
}
public void display() {
Xia();
int a;
if (shuV == 0)
a = 0;
else
a = 180;
String ss="@R"+id+":"+a+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double s) {
shuV = s;
}
public int getL(){
int a;
if (shuV == 0)
a = 0;
else
a = 180;
return a;
}
}
class Ds extends Electric {
public Ds(String id) {
super("D", id);
}
public void display() {
Xia();
int ru=(int)Math.floor(ruV);
int chu=(int)Math.floor(chuV);
int m=(int)Math.floor(shuV);
int a = 0;
if (m >= 0 && m < 80)
a = 0;
else if (m >= 80 && m <= 150)
a = (m - 80) * 4 + 80;
else if (m > 150)
a = 360;
String ss="@D"+id+":"+a+" "+ru+"-"+chu;
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double v) {
shuV = v;
}
}
class Luodi extends Electric {
public Luodi(String id) {
super("A", id);
}
public void display() {
Xia();
int a = 0;
if (shuV >= 0 && shuV < 80)
a = 0;
else if (shuV >= 80 && shuV <= 99)
a = 80;
else if (shuV >= 100 && shuV <= 119)
a = 160;
else if (shuV >= 120 && shuV <= 139)
a = 260;
else if (shuV > 140)
a = 360;
String ss="@A"+id+":"+a+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double w) {
shuV = w;
}
}
class Huchi extends Electric{
public Huchi(String id,int d){
super("H", id);
this.xuhao=d;
}
public void display() {
String ss="@H"+id+":"+ofopen+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV)+"-"+(int)Math.floor(chuV1);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double v) {
if (ofopen.equals("turned on")) {
shuV = 0;
} else if (ofopen.equals("closed"))
shuV = v;
}
}
class Shoukong extends Electric{//R=15
public Shoukong(String id) {
super("S", id);
}
public void display() {
Xia();
int ru=(int)Math.floor(ruV);
int chu=(int)Math.floor(chuV);
String a = "100%";
if(shuV>=50){
if (lux >= 0 && lux < 50)
a = "100%";
else if (lux >= 50 && lux < 100)
a = "80%";
else if (lux >= 100 && lux < 200)
a = "60%";
else if (lux >= 200 && lux < 300)
a = "40%";
else if (lux >= 300 && lux <400)
a = "20%";
else if (lux >=400)
a = "0%";
}
String ss="@S"+id+":"+a+" "+ru+"-"+chu;
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double s) {
shuV = s;
}
}
class Erjiguan extends Electric{
public Erjiguan(String s){
super("P",s);
}
public void display() {
Xia();
String ss="@P"+id+":"+ofopen+" "+(int)Math.floor(ruV)+"-"+(int)Math.floor(chuV);
if(sjc>current)
ss=ss+sq;
System.out.println(ss);
}
public void reshuV(double c){
shuV = c;
}
}
class Bi extends Electric {
public Bi(String ml) {
super("M", ml);
}
}
class Chuan extends Electric{
public Chuan(String ml){
super("T",ml);
}
}
class Duobing{
public String s;
public ArrayList<Map<String, Electric>> map;
public double[] k;
public double a;
public Duobing(String s, ArrayList<Map<String, Electric>> map, double[] b,double a)
{
this.s=s;
this.map=map;
this.k=b;
this.a=a;
}
}
class Fanhui{
public Map<String, Electric> map;
public double zl;
public double sV;
public Fanhui(Map<String, Electric> map,double zl,double sv){
this.map=map;
this.zl=zl;
this.sV=sv;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = "", pop = "", chuanxu = "", bingxu = "";
int i;
ArrayList<String> connection = new ArrayList<>();
ArrayList<String> connection1 = new ArrayList<>();
ArrayList<String> chw = new ArrayList<>();
while (true) {
s = in.nextLine().trim();
if ("end".equals(s))
break;
if (s.startsWith("#T"))
{
Pattern pattern = Pattern.compile("#(.*):(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
chuanxu = matcher.group(1);
pop = matcher.group(2);
}
connection.add(chuanxu + ":" + pop);
}
else if (s.startsWith("#M"))
{
Pattern pattern = Pattern.compile("#(.*):(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
bingxu = matcher.group(1);
pop = matcher.group(2);
}
connection1.add(bingxu + " " + pop);
}
else if (s.startsWith("#K"))
{
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = matcher.group(1);
}
chw.add(pop);
}
else if (s.startsWith("#F")) {
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = matcher.group(1);
}
chw.add(pop);
}
else if (s.startsWith("#L")) {
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = matcher.group(1);
}
chw.add(pop);
}
else if(s.startsWith("#H")){
Pattern pattern = Pattern.compile("#(.*)");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
pop = matcher.group(1);
}
chw.add(pop);
}
}
int kllk = 0,mmm=0;
String z1 = "", zm = "",bnb="";
Map<String, Map<String, Electric>> mac = new HashMap<>();
Map<String, Electric> zhu = new LinkedHashMap<>();
for (mmm = 0; mmm < connection.size(); mmm++) {
int vb1 = 0, vb2 = 0;
Map<String, Electric> map1 = new LinkedHashMap<>();
z1 = connection.get(mmm);
Pattern pattern = Pattern.compile("(.*):(.*)");
Matcher matcher = pattern.matcher(z1);
while (matcher.find()) {
zm = matcher.group(1);
pop = matcher.group(2);
}
String[] partsl = pop.split("]");
String jk="",jk1="";
for (kllk = 0; kllk < partsl.length; kllk++) {
jk1 = partsl[0].trim();
jk = partsl[kllk].trim();
if (jk1.startsWith("[IN")) {
vb1 = 1;
String[] parts4 = jk.split(" ");
if(parts4[1].equals("OUT")){
if(parts4[0].startsWith("[H")) {
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0]);
while (matcher.find()) {
dkey = matcher.group(1);
}
if (dkey.startsWith("H")) {
int m1 = Integer.parseInt(pinyin[1]);
if ((m1 == 2 || m1 == 3) && parts4[0] != null) {
bnb = parts4[0].substring(1, 3);
map1 = compose(dkey, bnb, map1, m1,1);
}
}
break;
}
else {
break;
}
}
if(parts4[0].startsWith("[H")){
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0]);
while (matcher.find()) {
dkey = matcher.group(1);
}
int m1=Integer.parseInt(pinyin[1]);
if((m1==2||m1==3)&&parts4[0]!=null){
bnb=parts4[0].substring(1,3);
map1 = compose(dkey, bnb, map1,m1,1);
}
String[] pinyin1 = parts4[1].split("-");
dkey = pinyin1[0].trim();
if(dkey.startsWith("H")){
m1=Integer.parseInt(pinyin1[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1,2);
}
}
else{
m1=Integer.parseInt(pinyin1[1]);
map1 = complain(dkey, parts4[1], map1,m1,m1);
}
}
else {
String[] pinyin = parts4[1].split("-");
String dkey = pinyin[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1,2);
}
}
else{
if(!pinyin[1].equals("IN")){
int m1=Integer.parseInt(pinyin[1]);
map1 = complain(dkey, parts4[1], map1,m1,m1);
}
else {
map1 = complain(dkey, parts4[1], map1,1,1);
}
}
}
}
else if (jk1.startsWith("[VCC")) {
vb2 = 1;
String[] parts4 = jk.split(" ");
if(parts4[1].equals("GND")){
if(parts4[0].startsWith("[H")) {
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0].trim());
while (matcher.find()) {
dkey = matcher.group(1);
}
int m1 = Integer.parseInt(pinyin[1]);
if ((m1 == 2 || m1 == 3) && parts4[0] != null) {
bnb = parts4[0].substring(1, 3);
map1 = compose(dkey, bnb, map1, m1,1);
}
break;
}
else {break;}
}
if(parts4[0].startsWith("[H")){
String[] pinyin = parts4[0].split("-");
String dkey="";
pattern = Pattern.compile("\\[(.*)");
matcher = pattern.matcher(pinyin[0].trim());
while (matcher.find()) {
dkey = matcher.group(1);
}
int m1=Integer.parseInt(pinyin[1]);
if((m1==2||m1==3)&&parts4[0]!=null){
bnb=parts4[0].substring(1,3);
map1 = compose(dkey, bnb, map1,m1,1);
}
String[] pinyin1 = parts4[1].split("-");
dkey = pinyin1[0].trim();
m1=Integer.parseInt(pinyin1[1]);
if(dkey.startsWith("H")){
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1,2);
}
}
else{
map1 = complain(dkey, parts4[1], map1,m1,m1);
}
}
else {
String[] pinyin = parts4[1].split("-");
String dkey = pinyin[0].trim();
if(dkey.startsWith("H")){
int m1=Integer.parseInt(pinyin[1]);
if(m1==2||m1==3){
map1 = compose(dkey, parts4[1], map1,m1,2);
}
}
else{
if(!pinyin[1].equals("IN")){
int m1=Integer.parseInt(pinyin[1]);
map1 = complain(dkey, parts4[1], map1,m1,m1);
}
else {
map1 = complain(dkey, parts4[1], map1,1,1);
}
}
}
}
}
if (vb1 == 1){
mac.put(zm, map1);
}
if (vb2 == 1) {
zhu = map1;
}
}
int flag = 0;
double rui = 220;
double rui1=rui;
for (i = 0; i < chw.size(); i++) {
String sid = chw.get(i);
for (Entry<String, Map<String, Electric>> entry : mac.entrySet()){
if (sid.startsWith("K")) {
String diu = sid.trim();
Electric electric = entry.getValue().get(diu);
if (electric != null) {
if (electric.ofopen.startsWith("t"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
else if (sid.startsWith("F")) {
String diu="",vs="";
Pattern pattern = Pattern.compile("(.*)(.)");
Matcher matcher = pattern.matcher(sid);
while (matcher.find()) {
diu = matcher.group(1);
vs = matcher.group(2);
}
Electric electric = entry.getValue().get(diu);
if (electric != null) {
electric.regulate(vs);
if (vs.equals("+")) {
flag++;
if (flag >= 3) {
flag = 3;
}
}
if (vs.equals("-")) {
flag--;
if (flag <= 0) {
flag = 0;
}
}
break;
}
}
else if (sid.startsWith("L")) {
String diu = sid.substring(0, 2);
String vs = sid.substring(3);
Electric electric = entry.getValue().get(diu);
if (electric != null) {
electric.regulate(vs);
break;
}
}
else if(sid.startsWith("H")){
String diu = sid.trim();
int n1=0,n2=0;
for (Entry<String, Map<String, Electric>> try1 : mac.entrySet()){
Electric electric = try1.getValue().get(diu+2);
if (electric != null) {
n1=1;
if (electric.ofopen.startsWith("t"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
for (Entry<String, Map<String, Electric>> try1 : mac.entrySet()){
Electric electric1 = try1.getValue().get(diu+3);
if (electric1 != null) {
n2=1;
if (electric1.ofopen.startsWith("t"))
electric1.ofopen = "closed";
else
electric1.ofopen = "turned on";
break;
}
}
if(n1==1||n2==1)
break;
}
}
for (Entry<String, Electric> ignored1 : zhu.entrySet()) {
if (sid.startsWith("K")) {
String diu = sid.trim();
Electric electric = zhu.get(diu);
if (electric != null) {
if (electric.ofopen.startsWith("t"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
else if (sid.startsWith("H")) {
String diu = sid.trim();
int n1=0,n2=0;
for (Entry<String, Electric> ignored : zhu.entrySet()){
Electric electric = zhu.get(diu+2);
if (electric != null) {
n1=1;
if (electric.ofopen.startsWith("t"))
electric.ofopen = "closed";
else
electric.ofopen = "turned on";
break;
}
}
for (Entry<String, Electric> ignored : zhu.entrySet()){
Electric electric1 = zhu.get(diu+3);
if (electric1 != null) {
n2=1;
if (electric1.ofopen.startsWith("t"))
electric1.ofopen = "closed";
else
electric1.ofopen = "turned on";
break;
}
}
if(n1==1||n2==1)
break;
}
else if (sid.startsWith("F")) {
String diu="",vs="";
Pattern pattern = Pattern.compile("(.*)(.)");
Matcher matcher = pattern.matcher(sid);
while (matcher.find()) {
diu = matcher.group(1);
vs = matcher.group(2);
}
Electric electric = zhu.get(diu);
if (electric != null) {
electric.regulate(vs);
break;
}
}
else if (sid.startsWith("L")) {
String diu = sid.substring(0, 2);
String vs = sid.substring(3);
Electric electric = zhu.get(diu);
if (electric != null) {
electric.regulate(vs);
break;
}
}
}
}
Map<String,ArrayList<Map<String, Electric>>> vjk=new LinkedHashMap<>();
Map<String, Map<String, Electric>> maps = new HashMap<>();
for (mmm = 0; mmm < connection1.size(); mmm++) {
String k11 = connection1.get(mmm).substring(0, 2);
Pattern pattern = Pattern.compile("(.*)\\s\\[(.*)]");
Matcher matcher = pattern.matcher(connection1.get(mmm));
while (matcher.find()) {
pop =matcher.group(2);
}
String[] pa = pop.split(" ");
ArrayList<Map<String, Electric>> uzi=new ArrayList<>();
for (int yq = 0; yq < pa.length; yq++) {
for (Entry<String, Map<String, Electric>> entry1 : mac.entrySet()) {
if (entry1.getKey().equals(pa[yq])) {
maps.put(k11 + yq, entry1.getValue());
uzi.add(entry1.getValue());
}
}
vjk.put(k11,uzi);
}
}
double[] b = new double[1];
int sum1,sum2=0,sum3,s1,mv=0,mv1=0,zonglux,cw,cw1=0,index4=0,ind=0,index5=0;
double cR, bingR=0;
ArrayList<Duobing> db=new ArrayList<>();
for(Entry<String, Electric> fd:zhu.entrySet()) {
for (Entry<String, ArrayList<Map<String, Electric>>> entry : vjk.entrySet()) {
if (fd.getKey().equals(entry.getKey())) {
ind++;
}
}
}
double[] a = new double[ind];
for(Entry<String, Electric> fd:zhu.entrySet()){
for(Entry<String,ArrayList<Map<String, Electric>>> entry : vjk.entrySet()) {
if(fd.getKey().equals(entry.getKey())){
double[] c= new double[entry.getValue().size()];
i = 0;
int cw2=0;
for (sum1 = 0; sum1 < entry.getValue().size(); sum1++) {
c[i]=0;
int hjh = 0;
for (Entry<String, Electric> entry1 : entry.getValue().get(sum1).entrySet()) {
flag = 0;
if (entry1.getKey().startsWith("K")) {
if (entry1.getValue().ofopen.startsWith("t"))
flag = 1;
else
hjh++;
}
if (entry1.getKey().startsWith("H")) {
if (entry1.getValue().ofopen.startsWith("t"))
flag = 1;
else
hjh++;
}
if (entry1.getKey().startsWith("P")) {
if (entry1.getValue().ofopen.equals("cutoff"))
flag = 1;
else
hjh++;
}
if(entry1.getKey().startsWith("T")){
cw=0;
for(Entry<String, Map<String, Electric>> en6 : mac.entrySet()) {
if (en6.getKey().equals(entry1.getKey())) {
for(Entry<String, Electric> e : en6.getValue().entrySet()){
cw++;
if (e.getKey().startsWith("K")) {
if (e.getValue().ofopen.startsWith("t"))
flag = 1;
else
hjh++;
}
if (e.getKey().startsWith("H")) {
if (e.getValue().ofopen.startsWith("t"))
flag = 1;
else
hjh++;
}
if (e.getKey().startsWith("P")) {
if (e.getValue().ofopen.equals("cutoff"))
flag = 1;
else
hjh++;
}
c[i] = c[i] + 1.0 * e.getValue().resistance;
}
cw1=cw+cw1;
}
}
}
if(entry1.getKey().startsWith("M")){
double thisR = 0;
ArrayList<Map<String, Electric>> acm=vjk.get(entry1.getKey());
double[] qq= new double[acm.size()];
int ii = 0;
for (Map<String, Electric> stringElectricMap : acm) {
qq[ii]=0;
for (Entry<String, Electric> ent : stringElectricMap.entrySet()) {
int hjh1 = 0;
int indflag = 0;
if (ent.getKey().startsWith("K")) {
if (ent.getValue().ofopen.startsWith("t"))
indflag = 1;
else
hjh1++;
}
if (ent.getKey().startsWith("H")) {
if (ent.getValue().ofopen.equals("turned on"))
indflag = 1;
else
hjh1++;
}
if (ent.getKey().startsWith("P")) {
if (ent.getValue().ofopen.equals("cutoff"))
indflag = 1;
else
hjh1++;
}
if(entry1.getKey().startsWith("T")){
cw=0;
for(Entry<String, Map<String, Electric>> en6 : mac.entrySet()) {
if (en6.getKey().equals(entry1.getKey())) {
for(Entry<String, Electric> e : en6.getValue().entrySet()){
cw++;
if (e.getKey().startsWith("K")) {
if (e.getValue().ofopen.startsWith("t"))
indflag = 1;
else
hjh1++;
}
if (e.getKey().startsWith("H")) {
if (e.getValue().ofopen.startsWith("t"))
indflag = 1;
else
hjh1++;
}
if (e.getKey().startsWith("P")) {
if (e.getValue().ofopen.equals("cutoff"))
indflag = 1;
else
hjh1++;
}
qq[ii] =qq[ii] + 1.0 * e.getValue().resistance;
}
cw2=cw+cw2;
}
}
}
if (hjh1 == stringElectricMap.size()+cw2) {
qq[ii] = 0;
break;
}
if (indflag == 1){
qq[ii] = -1;
break;
}
else if(indflag==0) {
qq[ii] = qq[ii] + 1.0 * ent.getValue().resistance;
}
}
ii++;
}
int ss=0;
int ss1=0;
for (double v : qq) {
for(double csd:qq){
if (csd == -1) {
ss1 = 1;
break;
}
}
if (v == 0&&ss1==0) {
index5 = 1;
thisR = 0;
break;
} else {
if (v == -1) {
ss++;
if (ss == qq.length)
mv1 = 1;
} else
thisR = 1.0 / v + thisR;
}
}
if(mv1==1){
c[i]=-2;
}
else c[i]=c[i]+1.0/thisR;
db.add(new Duobing(entry1.getKey(), acm,qq,thisR));
}
if (hjh ==entry.getValue().get(sum1).size()+cw1) {
c[i] = 0;
}
if (flag == 1)
c[i] = -1;
else
c[i] = c[i] + 1.0 * entry1.getValue().resistance;
}
i++;
}
s1=0;
int sasa=0;
for (i = 0; i < c.length; i++) {
//System.out.println(c[i]);
for(double scs:c){
if(scs==-1){
sasa=1;
break;
}
}
if (c[i] == 0&&sasa==0) {
index4=0;
a[sum2] = 0;
break;
}
else if(c[i] == 0&&sasa!=0)
a[sum2]=0;
else {
if (c[i] == -1||c[i]==-2){
s1++;
if(s1==c.length){
mv=1;
}
}
else
a[sum2] = 1.0 / c[i] + a[sum2];
}
}
db.add(new Duobing(entry.getKey(), entry.getValue(), c,a[sum2]));
sum2++;
}
}
}
for(sum3=0;sum3<a.length;sum3++){
if (a[sum3] != 0) {
bingR = bingR+1.0/a[sum3];
}
}
b[0]=0;
double[] l =new double[1];
int flag4 = 0;
int index1=0,index2=0;
for (Entry<String, Electric> entry : zhu.entrySet()) {
index2++;
flag=0;
if (entry.getKey().startsWith("K")) {
flag=0;
if (entry.getValue().ofopen.startsWith("t")){
flag = 1;
}
else {
index1++;
}
if(flag==1){
b[0] = -1;
break;
}
}
else if (entry.getKey().startsWith("H")) {
flag=0;
if (entry.getValue().ofopen.startsWith("t")){
flag = 1;
}
else{
index1++;
}
if(flag==1){
b[0] = -1;
break;
}
}
else if (entry.getKey().startsWith("P")) {
flag=0;
if (entry.getValue().ofopen.startsWith("cut")){
flag = 1;
}
else
index1++;
if(flag==1){
b[0] = -1;
break;
}
}
else if(entry.getKey().startsWith("T")){
l[0]=0;
index2--;
for(Entry<String, Map<String, Electric>> entry6 : mac.entrySet()) {
index2++;
if(entry6.getKey().equals(entry.getKey())) {
for(Entry<String, Electric> en : entry6.getValue().entrySet()) {
if (en.getKey().startsWith("K")) {
flag4=0;
if (en.getValue().ofopen.startsWith("t")) {
flag4 = 1;
}
else{
index1++;
}
if (flag4 == 1) {
l[0] = -1;
break;
}
}
else if(en.getKey().startsWith("H")){
flag4=0;
if (en.getValue().ofopen.startsWith("t")) {
flag4 = 1;
}
else{
index1++;
}
if (flag4 == 1) {
l[0] = -1;
break;
}
else
l[0]=l[0]+en.getValue().resistance;
}
else if(en.getKey().startsWith("P")){
flag4=0;
if (entry.getValue().ofopen.startsWith("cut")){
flag4 = 1;
}
else
index1++;
if(flag4==1){
b[0] = -1;
break;
}
else
l[0]=l[0]+en.getValue().resistance;
}
else
l[0]=l[0]+en.getValue().resistance;
}
break;
}
}
if(l[0]==-1){
b[0]=-1;
break;
}
else{
b[0]=b[0]+l[0];
}
}
b[0] = b[0] + entry.getValue().resistance;
}
cR = b[0];
double chuanV, bingV;
double chuanliu=0;
int index=0;
chuanV = rui * cR / (bingR + cR);
bingV = rui * bingR / (bingR + cR);
chuanliu=rui/(bingR + cR);
zonglux=0;
Map<String, Electric> maso = new HashMap<>();
for (Entry<String, Electric> entry : zhu.entrySet()) {
String parts8 = entry.getKey();
s = parts8;
if(index2==index1||index4==1||index5==1||(b[0]==0&&bingR==0)){
index=1;
}
if(b[0]==-1||flag4==1||flag==1||mv==1){
rui=0;
chuanV=0;
bingV=0;
chuanliu=0;
}
if (s.startsWith("K")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui = elc1.shuV;
chuanV = 1.0*rui * cR / (bingR + cR);
bingV = 1.0*rui * bingR / (bingR + cR);
chuanliu = rui / (cR+bingR);
elc1.ruV=rui1;
if(elc1.ofopen.startsWith("t")){
elc1.chuV=0;
chuanliu=0;
rui1=0;
}
else
elc1.chuV=rui1;
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("H")) {
Electric elc1 = zhu.get(parts8);
if(elc1.xuhao ==3){
if(elc1.ofopen.startsWith("t")){
elc1.ofopen="closed";
elc1.ruV=0;
rui1=0;
chuanliu=0;
}
else{
elc1.ruV=rui1;
elc1.ofopen="turned on";
}
elc1.chuV=0;
elc1.chuV1=rui1-10*chuanV/cR;
rui1=elc1.chuV1;
}
else{
if(elc1.ofopen.startsWith("t")){
elc1.ruV=0;
rui1=0;
chuanliu=0;
}
else{
elc1.ruV=rui1;
}
elc1.chuV=rui1-5*chuanV/cR;
elc1.chuV1=0;
rui1=elc1.chuV;
}
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("B")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(10*chuanV/cR);
zonglux=zonglux+elc1.getL();
elc1.ruV=rui1;
elc1.chuV=rui1-10*chuanV/cR;
rui1=elc1.chuV;
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("R")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(5*chuanV/cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-5*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
}
else if (s.startsWith("D")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(20*chuanV/cR);
elc1.ruV=rui1;
elc1.chuV=rui1-20*chuanV/cR;
rui1=elc1.chuV;
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("A")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(20*chuanV/cR);
elc1.ruV=rui1;
elc1.chuV=rui1-20*chuanV/cR;
rui1=elc1.chuV;
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("L")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui = elc1.shuV;
chuanV = rui * cR / (bingR + cR);
bingV = rui * bingR / (bingR + cR);
chuanliu = rui / (cR+bingR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1;
maso.put(s, elc1);
}
else if (s.startsWith("F")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(rui);
rui=elc1.shuV;
chuanV = rui * cR / (bingR + cR);
bingV = rui * bingR / (bingR + cR);
chuanliu = rui / (cR+bingR);
elc1.ruV=rui1;
elc1.chuV=rui1;
elc1.sjc=chuanliu;
maso.put(s, elc1);
}
else if (s.startsWith("S")) {
Electric elc1 = zhu.get(parts8);
elc1.reshuV(15*chuanV/cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-15*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
}
else if (s.startsWith("P")) {
Electric elc1 = zhu.get(parts8);
if(elc1.ofopen.startsWith("cut")){
elc1.chuV=0;
chuanliu=0;
rui1=0;
}
else
elc1.chuV=rui1;
elc1.sjc=chuanliu;
elc1.ruV=rui1;
maso.put(s, elc1);
}
else if(s.startsWith("T")) {
for(Entry<String, Map<String, Electric>> entry6 : mac.entrySet()) {
if(entry6.getKey().equals(s)){
for(Entry<String,Electric> jk : entry6.getValue().entrySet()) {
s=jk.getKey();
if (s.startsWith("K")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(rui);
rui = elc1.shuV;
chuanV = 1.0*rui * cR / (bingR + cR);
bingV = 1.0*rui * bingR / (bingR + cR);
chuanliu = rui / (cR+bingR);
elc1.ruV=rui1;
if(elc1.ofopen.startsWith("t")){
elc1.chuV=0;
chuanliu=0;
rui1=0;
}
else
elc1.chuV=rui1;
elc1.sjc=chuanliu;
maso.put(s, elc1);
maso.put(s, elc1);
} else if(s.startsWith("H")) {
Electric elc1 = entry6.getValue().get(s);
if(elc1.xuhao ==3){
if(elc1.ofopen.startsWith("t")){
chuanliu=0;
elc1.ofopen="closed";
}
else{
elc1.ofopen="turned on";
}
elc1.ruV=rui1;
elc1.chuV=0;
elc1.chuV1=rui1-10*chuanV/cR;
rui1=elc1.chuV1;
} else{
if(elc1.ofopen.startsWith("t")){
chuanliu=0;
}
elc1.ruV=rui1;
elc1.chuV=rui1-5*chuanV/cR;
elc1.chuV1=0;
rui1=elc1.chuV;
}
elc1.sjc=chuanliu;
maso.put(s, elc1);
} else if (s.startsWith("B")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(10 * chuanV / cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-10*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
} else if (s.startsWith("R")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(5 * chuanV / cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-5*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
zonglux=zonglux+elc1.getL();
} else if (s.startsWith("D")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(20 * chuanV / cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-20*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
} else if (s.startsWith("A")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(20 * chuanV / cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-20*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
} else if (s.startsWith("S")) {
Electric elc1 = entry6.getValue().get(s);
elc1.reshuV(15 * chuanV / cR);
elc1.sjc=chuanliu;
elc1.ruV=rui1;
elc1.chuV=rui1-15*chuanV/cR;
rui1=elc1.chuV;
maso.put(s, elc1);
}
else if(s.startsWith("P")){
Electric elc1=entry6.getValue().get(s);
if(elc1.ofopen.startsWith("cut")){
elc1.chuV=0;
chuanliu=0;
rui1=0;
}
else
elc1.chuV=rui1;
elc1.sjc=chuanliu;
elc1.ruV=rui1;
maso.put(s, elc1);
}
}
}
}
}
else if (s.startsWith("M")) {
Fanhui fanhui=search(s,maso, db,bingV,bingR,zonglux, rui1);
maso=fanhui.map;
zonglux= (int) fanhui.zl;
for (Duobing duobing : db) {
if (duobing == null) continue;
if (duobing.s.equals(s)) {
if(duobing.a!=0)
rui1 = rui1 - bingV * (1.0 / duobing.a) / bingR;
}
}
}
}
if(index==1){
System.out.println("short circuit error");
}
else
{
ArrayList<Electric> arraylist6 = new ArrayList<>();
for (Entry<String, Electric> pose : maso.entrySet()) {
if(pose.getValue()==null)continue;
arraylist6.add(pose.getValue());
}
Comparator<Electric> numberComparator = (o1, o2) -> {
int a1 = o1.fh();
int b1 = o2.fh();
if (a1 > b1)
return -1;
else if (a1 == b1) {
String c = o1.id;
String d = o2.id;
if (c.compareTo(d)>0)
return 1;
else
return -1;
} else
return 1;
};
arraylist6.sort(numberComparator);
for (Electric ss : arraylist6) {
if(ss.s.equals("S")){
ss.lux=zonglux;
}
if(ss.chuV<0)
ss.chuV=0;
if(ss.chuV1<0)
ss.chuV1=0;
if(ss.ruV<=0)
ss.ruV=0;
if(ss.chuV>=220)
ss.chuV=220;
if(ss.chuV1>=220)
ss.chuV1=220;
if(ss.ruV<=0)
ss.ruV=0;
ss.display();
}
}
}
public static Map<String, Electric> complain(String d, String s, Map<String, Electric> map1,int a,int b) {
String k="";
Pattern pattern = Pattern.compile(".(.*)");
Matcher matcher = pattern.matcher(d);
while (matcher.find()) {
k = matcher.group(1);
}
if (s.startsWith("K")) {
Electric t = new kg(k);
t.resistance = 0;
t.lux=0;
t.current=20;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("F")) {
Electric t = new fd(k);
t.resistance = 0;
t.lux=0;
t.current=18;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("L")) {
Electric t = new Lx(k);
t.resistance = 0;
t.lux=0;
t.current=18;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("B")) {
Electric t = new Baichi(k);
t.resistance = 10;
t.current=9;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("R")) {
Electric t = new Riguang(k);
t.resistance = 5;
t.current=5;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("D")) {
Electric t = new Ds(k);
t.resistance = 20;
t.current=12;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("A")) {
Electric t = new Luodi(k);
t.resistance = 20;
t.current=14;
t.xh=b;
map1.put(d, t);
} else if (s.startsWith("M")) {
Electric t1 = new Bi(k);
t1.resistance = 0;
t1.current=0;
map1.put(d,t1);
} else if (s.startsWith("T")) {
Electric t = new Chuan(k);
t.resistance = 0;
t.current=0;
map1.put(d,t);
} else if (s.startsWith("H")) {
Electric t = new Huchi(k,a);
t.xuhao=a;
if(a==2) {
t.resistance = 5;
t.ofopen="closed";
}
if(a==3){
t.resistance = 10;
t.ofopen="turned on";
}
t.xh=b;
t.current=20;
map1.put(d,t);
} else if (s.startsWith("S")) {
Electric t = new Shoukong(k);
t.resistance = 15;
t.xuhao=2;
t.current=12;
t.xh=b;
map1.put(d,t);
} else if (s.startsWith("P")) {
Electric t = new Erjiguan(k);
t.resistance = 0;
t.xuhao=2;
t.current=8;
if(a==1){
t.ofopen="conduction";
}
else if(a==2){
t.ofopen="cutoff";
}
t.xh=b;
map1.put(d,t);
}
return map1;
}
public static Map<String, Electric> compose(String dkey, String s, Map<String, Electric> map1, int m,int n) {
String jkj="";
Pattern pattern = Pattern.compile(".(.*)");
Matcher matcher = pattern.matcher(dkey);
while (matcher.find()) {
jkj = matcher.group(1);
}
if (s.startsWith("H")) {
Electric t = new Huchi(jkj,m);
t.current=20;
t.xuhao=m;
if(m==2) {
t.resistance = 5;
t.ofopen="closed";
}
if(m==3){
t.resistance = 10;
t.ofopen="turned on";
}
t.xh=n;
map1.put(dkey+m,t);
}
return map1;
}
public static Fanhui search(String s, Map<String, Electric> maso, ArrayList<Duobing> ddb, double bingV, double bingR, double zonglux, double rui1) {
double m1;
Duobing d1;
for (int cmd = 0; cmd < ddb.size(); cmd++) {
if (ddb.get(cmd) == null) continue;
m1=rui1;
d1 = ddb.get(cmd);
if (d1.s.equals(s)) {
for (int kkkk = 0; kkkk < d1.map.size(); kkkk++) {
double cw;
int gg=0;
if (d1.map.get(kkkk) == null) continue;
double siop = bingV * (1.0 / d1.a) / bingR;
String parts8;
int yy=0;
double mm=m1;
//System.out.println(rui1);
if ((d1.k[kkkk] != -1 && d1.k[kkkk] != 0)||d1.k[kkkk]==-2) {
for (Entry<String, Electric> c1 : d1.map.get(kkkk).entrySet()) {
rui1 = mm;
parts8 = c1.getKey();
s = parts8;
//System.out.println(s);
if (s.startsWith("K")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.ruV = mm;
if(elc1.ofopen.startsWith("t")){
siop =0;
mm=0;
elc1.chuV = 0;
}
else
elc1.chuV = mm;
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
} else if (s.startsWith("H")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.xuhao == 3) {
yy = 1;
String jkj = "";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = matcher.group(1);
}
for (int d = 0; d < d1.map.size(); d++) {
for (Entry<String, Electric> ignored : d1.map.get(d).entrySet()) {
Electric elc2 = d1.map.get(d).get(jkj + 2);
if (elc2 != null){
yy = 2;
if (elc1.ofopen.startsWith("t")){
elc1.ofopen = "closed";
}
else{
elc1.ofopen = "turned on";
}
elc1.chuV1=mm;
mm=mm-10*siop/d1.k[kkkk];
maso.put(s, elc1);
break;
}
}
}
if (yy == 1) {
if (elc1.ofopen.startsWith("t"))
elc1.ofopen = "closed";
else
elc1.ofopen="turned on";
elc1.ruV = mm - 10 * siop / d1.k[kkkk];
elc1.chuV = 0;
elc1.chuV1 = mm;
mm = mm - 10 * siop / d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
}
}
else{
elc1.chuV = mm;
if(elc1.ofopen.startsWith("t")){
elc1.ruV = 0;
}
else{
elc1.ruV=mm;
mm = mm - 5 * siop / d1.k[kkkk];
}
elc1.sjc = siop / d1.k[kkkk];
String jkj = "";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = matcher.group(1);
}
for (int d = 0; d < d1.map.size(); d++) {
for (Entry<String, Electric> ignored : d1.map.get(d).entrySet()) {
Electric e = d1.map.get(d).get(jkj + 3);
if (e != null){
yy = 2;
e.sjc = elc1.sjc;
e.chuV=elc1.chuV;
}
}
}
if(yy!=2){
elc1.chuV1=0;
maso.put(s, elc1);
}
}
} else if (s.startsWith("B")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(10 * siop / d1.k[kkkk]);
elc1.ruV = mm;
elc1.chuV = mm - 10 * siop / d1.k[kkkk];
mm = mm - 10* siop /d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
zonglux = zonglux + elc1.getL();
} else if (s.startsWith("R")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(5 * siop / d1.k[kkkk]);
elc1.ruV = mm;
elc1.chuV = mm - 5 * siop / d1.k[kkkk];
mm = mm - 5 * siop / d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
zonglux = zonglux + elc1.getL();
} else if (s.startsWith("D")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(20 * siop / d1.k[kkkk]);
elc1.ruV = mm;
elc1.chuV = mm - 20 * siop / d1.k[kkkk];
mm = mm - 20 * siop / d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
} else if (s.startsWith("A")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(20 * siop / d1.k[kkkk]);
elc1.ruV = mm;
elc1.chuV = mm - 20 * siop / d1.k[kkkk];
mm = mm - 20 * siop / d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
} else if (s.startsWith("S")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(15 * siop / d1.k[kkkk]);
elc1.ruV = mm;
elc1.chuV = mm - 15 * siop / d1.k[kkkk];
mm = mm - 15 * siop / d1.k[kkkk];
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
} else if (s.startsWith("P")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.ruV = mm;
if(elc1.ofopen.startsWith("cut")){
siop =0;
mm=0;
elc1.chuV = 0;
}
else
elc1.chuV = mm;
elc1.sjc = siop / d1.k[kkkk];
maso.put(s, elc1);
} else if (s.startsWith("M")) {
for (int cmd1 = 0; cmd1 < ddb.size(); cmd1++) {
if (ddb.get(cmd1) == null) continue;
Duobing dd = ddb.get(cmd1);
if (dd.s.equals(s)) {
search(s, maso, ddb, siop, d1.k[kkkk], zonglux, rui1);
}
}
}
}
}
else{
siop = 0;
for (Entry<String, Electric> c1 : d1.map.get(kkkk).entrySet()) {
rui1=mm;
parts8 = c1.getKey();
s = parts8;
cw=rui1;
if (s.startsWith("K")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if(elc1.ofopen.startsWith("t")){
gg=1;
elc1.chuV=0;
}
else
elc1.chuV=cw;
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
elc1.scV(gg,cw);
maso.put(s, elc1);
} else if (s.startsWith("H")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
if (elc1.xuhao == 3) {
yy = 1;
String jkj = "";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = matcher.group(1);
}
for (int d = 0; d < d1.map.size(); d++) {
for (Entry<String, Electric> ignored : d1.map.get(d).entrySet()) {
Electric elc2 = d1.map.get(d).get(jkj + 2);
if (elc2 != null){
yy = 2;
if (elc1.ofopen.startsWith("t")){
elc1.ofopen = "closed";
}
else{
elc1.ofopen = "turned on";
}
elc1.chuV1=cw;
maso.put(s, elc1);
break;
}
}
}
if (yy == 1) {
if (elc1.ofopen.startsWith("t")){
gg=1;
elc1.ofopen = "closed";
}
else{
elc1.ofopen = "turned on";
}
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
elc1.scV(gg,cw);
elc1.chuV = 0;
elc1.chuV1 = cw;
maso.put(s, elc1);
}
}
else if (elc1.xuhao == 2) {
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
elc1.scV(gg,cw);
String jkj = "";
Pattern pattern = Pattern.compile("(.*).");
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
jkj = matcher.group(1);
}
for (int d = 0; d < d1.map.size(); d++) {
for (Entry<String, Electric> c2 : d1.map.get(d).entrySet()) {
Electric e = d1.map.get(d).get(jkj + 3);
if (e != null){
yy = 2;
e.sjc = elc1.sjc;
e.chuV=elc1.chuV;
}
}
}
if(elc1.ofopen.startsWith("t")){
elc1.ruV=0;
gg=1;
}
else
elc1.ruV=cw;
if(yy!=2){
elc1.chuV1=0;
maso.put(s, elc1);
}
}
} else if (s.startsWith("B")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
zonglux = zonglux + elc1.getL();
} else if (s.startsWith("R")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
zonglux = zonglux + elc1.getL();
} else if (s.startsWith("D")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
} else if (s.startsWith("A")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
} else if (s.startsWith("S")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
} else if (s.startsWith("P")) {
Electric elc1 = d1.map.get(kkkk).get(parts8);
elc1.reshuV(siop);
elc1.scV(gg,cw);
if(elc1.ofopen.startsWith("cut")){
gg=1;
elc1.chuV = 0;
}
else
elc1.chuV=cw;
if(cw!=0&&d1.k[kkkk]==0)
elc1.sjc=100;
else
elc1.sjc=0;
maso.put(s, elc1);
} else if (s.startsWith("M")) {
for (int cmd1 = 0; cmd1 < ddb.size(); cmd1++) {
if (ddb.get(cmd1) == null) continue;
Duobing dd = ddb.get(cmd1);
if (dd.s.equals(s)) {
search(s, maso, ddb, siop, d1.k[kkkk], zonglux, rui1);
}
}
}
}
}
}
}
}
return new Fanhui(maso, zonglux, rui1);
}
}
總結：
這次作業相較於上一次的作業來說，新增二極體，以及輸出的相關要求，在輸出電器的同時，還要輸出其兩個端點的電勢。這個對我來說難度相當大，在圖書館裡面待了好幾天也沒有解決好這個問題。最後拿到的分數很少。感覺這次的題目很難，只拿到了36分，可能也是因為期末的原因，感覺花的時間也沒有之前得多。
3.採坑心得:
題目所給的測試樣例只是最終得到結果的一部分，還有一些測試點還需要自己慢慢去摸索，比如說在寫第六次大作業的時候，題目只給了三個測試樣例，還有很多測試點要一個一個去思考，比如什麼互斥開關的問題，以及二極體的正反問題，在輸出的時候注重每個電器的端點電壓等等，這幾次的題目讀題的時候感覺不是很難，就想著直接寫應該就可以寫出來，但是到了程式碼實現的時候就完全不一樣，感覺輸出的都有一點問題，尤其是有些地方在改動的時候，因為距離上一次的作業有個五六天，導致有些地方忘記了上次是怎麼寫的，然後在修改的時候總有一些地方對不上正確的答案，然後這些地方都花了很多的時間去修改。
4.改進建議:
每次寫題目，程式碼總會有很多的報錯，將程式碼放進Idea可以快速的解決相關的問題，但是寫題目的時候還是要認真的去對待，最後一次大作業因為期末的原因，有一點鬆懈，到作業快要結束的時候才開始認真的去思考去寫程式碼。題目比較長的時候，有時候無從下手，要把重點先放在建類上面，把每個類的屬性搞清楚，然後對題目的輸入進行分析，寫出相應的正規表示式獲取重要的資訊用ArrayList或者Map存起來，在輸出的時候注意輸出的順序。有些時候題目不會把所有的測試點都寫出來，要自己一個一個去想，要先把題目說的不要求的先刪去，然後注重一些細節，拿此次作業來說吧，我感覺難度大的就是電勢，物理沒有學好，主要是思考時間也沒有很多，就得分很少，以後寫題目就要認真的去對待，花多點時間去思考，不會的就去學。
5.總結：
1.題目所給的測試樣例只是最終得到結果的一部分，還有一些測試點還需要自己慢慢去摸索，要對題目瞭解清楚之後，在進行分析，才能知道如何去輸出，以什麼樣的關係去輸出，每一個類對應關係以及各自所代表的含義，題目確實很複雜，唯有沉下心去分析類的關係，才能把題目做好。
2.仔細閱讀作業指導，確保完全理解了題目的要求。
3.基於題目要求，分析需要哪些類和物件，以及它們之間的關係。這可能涉及到繼承、介面、多型等物件導向的概念。，正確分析是很重要的，比如說這次寫程式碼，可以較簡單的去儲存需要的資料，但是當時沒有想到，然後就很複雜的去儲存Map套Map套Map，這樣很麻煩，後面快寫完的時候發現可以簡單的去儲存
4.命名規範：使用清晰、有意義的變數和類名，遵循Java的命名規範。
5.程式碼結構：保持程式碼的整潔和模組化，使用適當的註釋來解釋複雜的邏輯。
6.程式碼複用：儘量複用之前寫過的程式碼，避免重複勞動。
|