对java面向程序设计的pta 4,5,6次作业的总结

1.前言

第四次pta作业是判题程序的最后一次的作业练习，难度有，但一般，只需要多花一些时间总能完成任务的，第五次的pta改用物理电学题，在设计上的考虑要更高于判题程序，可以说多次练习让我对设计有了进一步的认识和学习，哪有小孩天天哭？哪有pta次次不会做？

1）第四次作业

输入格式:

程序输入信息分五种，信息可能会打乱顺序混合输入。

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=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
约束：有多张试卷时，按输入信息的先后顺序输出警示。

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。

样例：

 answer is null

 3+2=~5~true

 4+6=~22~false.

 answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、被删除的题目提示信息

当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。

5、题目引用错误提示信息

试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：

输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103 #A:1-4

end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：

输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103

end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息

输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。

  例如：wrong format:2 #Q:2+2= #4

7、试卷号引用错误提示输出

如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。

8、学号引用错误提示信息

如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。

本次作业新增内容：

1、输入选择题题目信息

题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#Z:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。

新增约束：标准答案中如果包含多个正确答案（多选题），正确答案之间用英文空格分隔。
例如：

Z:2 #Q:宋代书法有苏黄米蔡四家，分别是： #A:苏轼黄庭坚米芾蔡襄

多选题输出：

输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。

多选题给分方式：

答案包含所有正确答案且不含错误答案给满分；包含一个错误答案或完全没有答案给0分；包含部分正确答案且不含错误答案给一半分，如果一半分值为小数，按截尾规则只保留整数部分。
例如：

N:1 #Q:1+1= #A:2

Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D

T:1 1-5 2-9

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-A C

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4

2、输入填空题题目信息

题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#K:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
例如：#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
填空题输出：

输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。

填空题给分方式：

答案与标准答案内容完全匹配给满分，包含一个错误字符或完全没有答案给0分，包含部分正确答案且不含错误字符给一半分，如果一半分值为小数，按截尾规则只保留整数部分。

例如：

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

T:1 1-5 2-10

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-瑶琴

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_瑶琴partially correct
20201103 Tom: 0 5~5

3、输出顺序变化

只要是正确格式的信息，可以以任意的先后顺序输入各类不同的信息。比如试卷可以出现在题目之前，删除题目的信息可以出现在题目之前等。

例如：

T:1 1-5 2-10

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-古筝

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_古筝false
20201103 Tom: 0 0~0

4、多张试卷信息

本题考虑多个同学有多张不同试卷的答卷的情况。输出顺序优先级为学号、试卷号，按从小到大的顺序先按学号排序，再按试卷号。

例如：

T:1 1-5 2-10

T:2 1-8 2-21

N:1 #Q:1+1= #A:2

S:2 20201103 #A:1-2 #A:2-古筝

S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴

S:1 20201104 #A:1-2 #A:2-瑟

S:2 20201104 #A:1-5 #A:2-七弦琴

X:20201103 Tom-20201104 Jack

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

end
输出：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=₅false
古琴在古代被称为：_{瑶琴或七弦琴}true
20201103 Tom: 0 10~10
1+1=₂true
古琴在古代被称为：_古筝false
20201103 Tom: 8 0~8
1+1=₂true
古琴在古代被称为：_瑟false
20201104 Jack: 5 0~5
1+1=₅false
古琴在古代被称为：_七弦琴partially correct
20201104 Jack: 0 10~10

这道题增加了多选题，还要对答案的内容判断是否正确或半对，相对前面的单选题要考虑的东西更多，还有新增的填空题就比较简单，总体来讲新增的内容复杂度不高，细细研究就能够写出来
对有合理类设计的同学会更简单，不像他们，我只会hardcoding

2）第五次作业

智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。

1、控制设备模拟

本题模拟的控制设备包括：开关、分档调速器、连续调速器。

开关：包括0和1两种状态。

开关有两个引脚，任意一个引脚都可以是输入引脚，而另一个则是输出引脚。开关状态为0时，无论输入电位是多少，输出引脚电位为0。当开关状态为1时，输出引脚电位等于输入电位。
分档调速器

按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器

没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚，一个固定的输入（引脚编号为1）、一个输出引脚（引脚编号为2）。当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。

所有控制设备的初始状态/档位为0。

控制设备的输入引脚编号为1，输出引脚编号为2。

2、受控设备模拟

本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。

灯有两种工作状态：亮、灭。在亮的状态下，有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态：停止、转动。风扇的转速会因引脚的电位差的不同而有区别。
本次迭代模拟两种灯具。

白炽灯：

亮度在0~200lux（流明）之间。
电位差为0-9V时亮度为0,其他电位差按比例，电位差10V对应50ux，220V对应200lux，其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯：

亮度为180lux。
只有两种状态，电位差为0时，亮度为0，电位差不为0，亮度为180。
本次迭代模拟一种吊扇。

工作电压区间为80V-150V，对应转速区间为80-360转/分钟。80V对应转速为80转/分钟，150V对应转速为360转/分钟，超过150V转速为360转/分钟（本次迭代暂不考虑电压超标的异常情况）。其他电压值与转速成正比，输入输出电位差小于80V时转速为0。
输入信息：

1、设备信息

分别用设备标识符K、F、L、B、R、D分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇。

设备标识用标识符+编号表示，如K1、F3、L2等。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。

三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件：

不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入，包含在连接信息中。

2、连接信息

一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。

格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。
约束条件：

本次迭代不考虑两个输出引脚短接的情况
考虑调速器输出串联到其他控制设备（开关）的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如，K1的输出接到L2的输入，L2的输出再接其他设备属于串联接线。K1的输出接到L2的输出，同时K1的输入接到L2的输入，这种情况属于并联。K1的输出接到L2的输入，K1的输入接到L2的输出，属于反馈接线。
3、控制设备调节信息

开关调节信息格式：

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

分档调速器的调节信息格式：

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

连续调速器的调节信息格式：

+设备标识L+设备编号+":" +数值代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

4、电源接地标识：VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。

输入信息以end为结束标志，忽略end之后的输入信息。

输出信息：

按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。

输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
本题不考虑输入电压或电压差超过220V的情况。

本题只考虑串联的形式，所以所有测试用例的所有连接信息都只包含两个引脚

本题电路中除了开关可能出现多个，其他电路设备均只出现一次。
电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

家居电路模拟系列所有题目的默认规则：

1、当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2、所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。

3、连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4、对于调速器，其输入端只会直连VCC，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。

家居电路模拟系列1-4题目后续迭代设计：

1、电路结构变化：

迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系

电路结构变化示意图见图1。

2、输入信息的变化

串联线路信息：用于记录一段串联电路的元件与连接信息。

例如： #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]
并联线路信息：用于记录一段并联电路所包含的所有串联电路信息。

例如：#M1:[T1 T2 T3]
以上格式仅做参考，格式细节可能会调整，以具体发布的为准。

3、计算方式的变化

迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。

4、电路元件的变化

每次迭代会增加1-2个新的电路元件。

3）第六次作业

智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。以下题目介绍中加粗的部分为本次迭代在“家居强电电路模拟程序-1”的基础上增加的功能要求。

1、控制设备

本题模拟的控制设备包括：开关、分档调速器、连续调速器。

开关：包括0和1两种状态。

开关有两个引脚，任意一个引脚都可以是输入引脚，而另一个则是输出引脚。开关状态为0时，无论输入电位是多少，输出引脚电位为0。当开关状态为1时，输出引脚电位等于输入电位。
分档调速器

按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器

没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚，一个固定的输入（引脚编号为1）、一个输出引脚（引脚编号为2）。当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。

所有控制设备的初始状态/档位为0。

控制设备的输入引脚编号为1，输出引脚编号为2。
所有开关的电阻为 0。

2、受控设备

本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。

灯有两种工作状态：亮、灭。在亮的状态下，有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态：停止、转动。风扇的转速会因引脚间电位差的不同而有区别。
本次迭代模拟两种灯具。

白炽灯：

亮度在0~200lux（流明）之间。
电位差为0-9V时亮度为0,其他电位差按比例，电位差10V对应50ux，220V对应200lux，其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯：

亮度为180lux。
只有两种状态，电位差为0时，亮度为0，电位差不为0，亮度为180。
本次迭代模拟一种吊扇。

工作电压区间为80V-150V，对应转速区间为80-360转/分钟。80V对应转速为80转/分钟，150V对应转速为360转/分钟，超过150V转速为360转/分钟（本次迭代暂不考虑电压超标的异常情况）。其他电压值与转速成正比，输入输出电位差小于80V时转速为0。
本次迭代模拟一种落地扇。

工作电压区间为 [80V,150V]，对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分钟，[100-120)V 区间对应转速为 160 转/分钟，[120-140)V 区间对应转速为 260 转/分钟，超过 140V 转速为 360 转/分钟（本次迭代暂不考虑电压超标的异常情况）输入信息：
本次迭代考虑电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落地扇的电阻为 20

3、输入信息

1）输入设备信息

分别用设备标识符K、F、L、B、R、D、A分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇。

设备标识用标识符+编号表示，如K1、F3、L2等。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。

三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件：

不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入，包含在连接信息中。

2）输入连接信息

一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。

格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。
约束条件：

不考虑调速器串联到其他调速器的情况。
不考虑调速器串联到其他调速器的情况。
考虑各类设备的并联接入。例如，K1 的输出接到 L2 的输入，L2 的输出再接其他设备属于串联接线。K1 的输出接到 L2 的输出，同时 K1 的输入接到 L2 的输入，这种情况属于并联。
本次迭代的连接信息不单独输入，包含在线路信息中。

3）输入控制设备调节信息

开关调节信息格式：

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

分档调速器的调节信息格式：

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

连续调速器的调节信息格式：

+设备标识L+设备编号+":" +数值代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

4）电源接地标识：

VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。

5）输入串联电路信息

一条串联电路占一行，串联电路由按从靠电源端到接地端顺序依次输入的 n 个连接信息组成，连接信息之间用英文空格" "分隔。

串联电路信息格式：

"#T"+电路编号+":"+连接信息+" "+连接信息+...+" "+连接信息
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一个串联电路的第一个引脚是 IN，代表起始端，靠电源。最后一个引脚是 OUT，代表结尾端，靠接地。
约束条件：

不同的串联电路信息编号不同。
输入的最后一条电路信息必定是总电路信息，总电路信息的起始引脚是 VCC，结束引脚是 GND。
连接信息中的引脚可能是一条串联或并联电路的 IN 或者 OUT。例如：

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

6）输入并联电路信息

一条并联电路占一行，并联电路由其包含的几条串联电路组成，串联电路标识之间用英文空格" "分隔。

格式：

"#M"+电路编号+":"+”[”+串联电路信息+" "+....+" "+串联电路信息+”]”
例如：#M1:[T1 T2 T3]
该例声明了一个并联电路，由 T1、T2、T3 三条串联电路并联而成，三条串联电路的 IN 短接在一起构成 M1 的 IN，三条串联电路的 OUT 短接在一起构成 M1 的 OUT。
约束条件：

本次迭代不考虑并联电路中包含并联电路的情况，也不考虑多个并联电路串联的情况。
本题不考虑输入电压或电压差超过220V的情况。

输入信息以end为结束标志，忽略end之后的输入信息。

本题中的并联信息所包含的串联电路的信息都在并联信息之前输入，不考虑乱序输入的情况。
只要不造成短路而产生无穷大的电流烧坏电路，都是合理情况，在测试点的考虑范围之内。本次大作业不考虑短路的情况，测试点中不包括短路的电路。

本题不考虑一条串联电路中包含其他串联电路的情况。例如：

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2两条串联电路实际是T3的一个部分，本题不考虑这种类型的输入，而是当将T1\T2的所有连接信息直接包含在T3中定义。
下次迭代中需要考虑这种类型的输入。
4、输出信息：

按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。

输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
5、家居电路模拟系列所有题目的默认规则：

1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。

6、家居电路模拟系列1-4题目后续迭代设计：

1）电路结构变化：

迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系

电路结构变化示意图见图1。

2）计算方式的变化

迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。

3）电路元件的变化

每次迭代会增加1-2个新的电路元件。

2.设计与分析
1）对输入数据进行分析：
第四题：
i.新增多选题类MoreAnswerQuestion用来储存多选题的信息
ii.新增单选题类SummaryQuestion用来储存单选题的信息

第五题：
i.需要各种类的数组来储存每个元件的对象（好处：每次改变某个元件信息时，可以直接对其储存对象更改）例如：Switch[] Switchs=new Switch[100]
ii.需要容器储存主干的元件（使用链表allDevices）

第六题：
i.增加hashMap来储存并联信息（优点：hashMap可以无序储存所需信息，在这里采用String-ArrayList键值储存）
ii.增加链表resistance来储存并联电路电阻用于之后求电阻分压

注意：
i.一定要注意代码的逻辑性，一次性写复杂的代码偶尔会手忙脚乱
ii.必要的注释要写，不然迭代的时候连代码都看不清楚逻辑性
2)分析题目
1.分析第四题
i.相对第三题增加多选题类和填空题类
ii.增加对多选题类和填空题类匹配和分割的方法体
iii.增加输出的方式，输出多选题的全对和半对
样例：
输入：

输出：

输入：

输出：

2.分析第五题
i.按题目意思，设计控制类，电器类，包括继承和多态
ii.采用分割的方式，分割储存输入数据，储存方式采用类的数组
iii.要注意输出的时候要按顺序输出，每种元件内部也要按顺序从小到大输出，需要排序类
iiii.给定电压值，每次通过元件就更新电压值
样例：
输入：

输出：

输入：

输出：

3.分析第六题
i.增加落地扇类，增加该类数组储存
ii.利用hashMap储存并联信息T，利用hashMap储存并联节点
iii.排序方法增加落地扇的储存和排序
iiii.增加链表储存并联和主干的电阻分布，便于计算阻值
样例：
输入：

输出：

输入：

输出：

3.我的代码
1）第四题代码：

点击查看代码

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.LinkedList;
class QuestionMessage{
private int num;
private String message;
private String standardAnswer;
public QuestionMessage(){

}
public void setNum(int num){
    this.num=num;
}
public void setMessage(String message){
    this.message=message;
}
public void setStandardAnswer(String standardAnswer){
    this.standardAnswer=standardAnswer;
}
public int getNum(){
    return num;
}
public String getMessage(){
    return message;
}
public String getStandardAnswer(){
    return standardAnswer;
}
public boolean judge(String answer){
    if(this.standardAnswer==answer)
        return true;
    else
        return false;
}
public QuestionMessage(int num,String message,String standardAnswer){
    this.num=num;
    this.message=message;
    this.standardAnswer=standardAnswer;
}

}//一道题目的内容
class TextPaper{
public QuestionMessage[] quest=new QuestionMessage[100];
public MoreAnswerQuestion[] moreAnswerQuestions=new MoreAnswerQuestion[100];
public SummaryQuestion[] summaryQuestions=new SummaryQuestion[100];
private int[] questionState=new int[100];
public int[] getQuestionState() {
return questionState;
}
public void setQuestionState(int[] questionState) {
this.questionState = questionState;
}
public void textPaper(String questions){
if(questions.startsWith("#N:")) {
questions = questions.replaceAll("#N|#Q|#A", "");
String[] question = questions.split("😊;
String trim1 = null;
String trim2 = null;
String trim3 = null;
int stand = 0;
trim1 = question[1].trim();
trim2 = question[2].trim();
if (question.length < 4) {
trim3 = "";
} else {
trim3 = question[3].trim();
}
quest[Integer.valueOf(trim1)] = new QuestionMessage(Integer.valueOf(trim1), trim2, trim3);
questionState[Integer.valueOf(trim1)]=1;
}
if(questions.startsWith("#Z:")) {
questions = questions.replaceAll("#Z|#Q|#A", "");
String[] question = questions.split("😊;
String trim1 = null;
String trim2 = null;
String trim3 = null;
int stand = 0;
trim1 = question[1].trim();
trim2 = question[2].trim();
if (question.length < 4) {
trim3 = "";
} else {
trim3 = question[3].trim();
}
moreAnswerQuestions[Integer.valueOf(trim1)] = new MoreAnswerQuestion(Integer.valueOf(trim1), trim2, trim3);
questionState[Integer.valueOf(trim1)]=2;
}
if(questions.startsWith("#K:")) {
questions = questions.replaceAll("#K|#Q|#A", "");
String[] question = questions.split("😊;
String trim1 = null;
String trim2 = null;
String trim3 = null;
trim1 = question[1].trim();
trim2 = question[2].trim();
if (question.length < 4) {
trim3 = "";
} else {
trim3 = question[3].trim();
}
summaryQuestions[Integer.valueOf(trim1)] = new SummaryQuestion(Integer.valueOf(trim1), trim2, trim3);
questionState[Integer.valueOf(trim1)]=3;
}
}
public boolean checkQuestionN(int number){
if(questionState[number]1){
return true;
}
return false;
}
public boolean checkQuestionZ(int number){
if(questionState[number]2){
return true;
}
return false;
}
public boolean checkQuestionK(int number){
if(questionState[number]3){
return true;
}
return false;
}
public int judgeAnswer(String answer1,int number1){
if(checkQuestionN(number1)){
if(answer1.equals(quest[number1].getStandardAnswer())){
return 1;
}
else{
return 0;
}
}
if(checkQuestionZ(number1)){
if(answer1.equals(moreAnswerQuestions[number1].getStandardAnswer())){
return 2;
}
else{
String[] answer=moreAnswerQuestions[number1].getStandardAnswer().split("\s+");
String[] Answer=answer1.split("\s+");
int num=0;
for(int a=0;a<Answer.length;a++){
int right=0;
for(int b=0;b<answer.length;b++){
if(Answer[a].equals(answer[b])){
right=1;
num++;
break;
}
}
if(right0){
return -1;
}
if(numanswer.length&&aAnswer.length-1){
return 2;
}
if(num<answer.length&&a==Answer.length-1&&num>0){
return 3;
}

            }
        }
    }
    if(checkQuestionK(number1)){
        if(answer1.trim().equals(summaryQuestions[number1].getStandardAnswer())){
            return 4;
        }
        if(summaryQuestions[number1].getStandardAnswer().contains(answer1.trim())){
            return  5;
        }
        else{
            return -2;
        }
    }
    return 0;
}

}
class AnswerPaper{
private int sum=0;
private int[] score=new int[100];
public TextPaper text=new TextPaper();
public int[] judgements=new int[100];
public AnswerQuestion[] Answers=new AnswerQuestion[100];
public AnswerPaper(){

}
public void addQuestion(int num){
    Answers[num]=new AnswerQuestion();
}
public void setAnswers(String answers, int num,int num1){
    Answers[num1].setAnswers(answers,num);
}
public String getAnswers(int num4,int num){
    return Answers[num].getAnswers(num4);
}
public void setStudentID(int studentID,int num){
    Answers[num].setStudentID(studentID);
}
public void setScore(int num,int sorce){
    this.score[num]=sorce;
}
public int getScore(int num){
    return score[num];
}
public void addSum(int sum){
    this.sum+=sum;
}
public void setSum(int score){
    this.sum=score;
}
public int getSum(){
    return sum;
}
public int getAllScore(){
    return sum;
}
public boolean checkQuestion(LinkedList<String> questions,int q){
    String trim1;
    for(int a=0;a<questions.size();a++){
        String question=questions.get(a);
        String quest=question.replaceAll("#N|#Z|#K|#A|#Q","");
        String[] quests=quest.split(":");
        trim1=quests[1].trim();
        if(Integer.valueOf(trim1)==q){
            return true;
        }
    }
    return false;
}
public void ifRight(int num1,int num2,int num3){
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==1){
        this.judgements[num2]=1;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==0){
        this.judgements[num2]=0;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==2){
        this.judgements[num2]=2;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==3){
        this.judgements[num2]=3;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==4){
        this.judgements[num2]=4;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==5){
        this.judgements[num2]=5;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==-1){
        this.judgements[num2]=-1;
    }
    if(text.judgeAnswer(Answers[num3].getAnswers(num2),num1)==-2){
        this.judgements[num2]=-2;
    }
}

}
class AnswerQuestion{
private int studentID;
private String[] answers=new String[100];
public AnswerQuestion(){

}
public void setAnswers(String answers, int num){
    this.answers[num]=answers;
}
public void setStudentID(int studentID) {
    this.studentID = studentID;
}
public void setAnswers(String[] answers) {
    this.answers = answers;
}
public String getAnswers(int num4){
    return answers[num4];
}

}
class Students{
private String ID;
private String name;
public Students(String ID,String name){
this.ID=ID;
this.name=name;
}
public String getID() {
return ID;
}
public String getName(){
return name;
}
public void setID(String ID){
this.ID=ID;
}
public void setName(String name){
this.name=name;
}
}
class Process{
public int num=0;
private LinkedList T=new LinkedList();
private LinkedList S=new LinkedList();
private LinkedList student=new LinkedList();
private LinkedList D=new LinkedList();
private LinkedList question=new LinkedList();
public Process(){

}
public LinkedList<String> getQuestion(){
    return question;
}
public LinkedList<String> getT(){
    for(int a=0;a<T.size();a++){
        T.set(a,T.get(a).replaceAll("#T:(\\s*)",""));
    }
    return T;
}
public LinkedList<String> getS(){
    for(int a=0;a<S.size();a++){
        for(int b=0;b<S.size()-1;b++){
            String summary=S.get(b);
            String summary1=S.get(b+1);
            String summary2=summary.replaceAll("#S:","");
            String summary12=summary1.replaceAll("#S:","");
            String[] Summary=summary2.split("\\s+");
            String[] Summary1=summary12.split("\\s+");
            if(Integer.valueOf(Summary[0])>Integer.valueOf(Summary1[0])){
                S.set(b,summary1);
                S.set(b+1,summary);
            }
        }
    }
    for(int a=0;a<S.size();a++){
        for(int b=0;b<S.size()-1;b++){
            String summary=S.get(b);
            String summary1=S.get(b+1);
            String summary2=summary.replaceAll("#S:","");
            String summary12=summary1.replaceAll("#S:","");
            String[] Summary=summary2.split("\\s+");
            String[] Summary1=summary12.split("\\s+");
            if(Integer.valueOf(Summary[1])>Integer.valueOf(Summary1[1])){
                S.set(b,summary1);
                S.set(b+1,summary);
            }
        }
    }
    return S;
}
public LinkedList<String> getStudent(){
    for(int a=0;a<student.size();a++){
        student.set(a,student.get(a).replaceAll("#X:(\\s*)",""));
    }
    return student;
}
public LinkedList<String> getD(){
    for(int a=0;a<D.size();a++){
        D.set(a,D.get(a).replaceAll("#D:(\\s*)N(\\s*)-",""));
    }
    return D;
}
public void sortS(LinkedList<String> s){
    for(int a=0;a<=s.size();a++){
        for(int b=0;b<s.size();b++){
            String summary=s.get(b);
            String summary1=s.get(b+1);
            String[] Summary=summary.split("\\s+");
            String[] Summary1=summary1.split("\\s+");
            if(Integer.valueOf(Summary[1])>Integer.valueOf(Summary1[1])){
                s.set(b,summary1);
                s.set(b+1,summary);
            }
        }
    }
    for(int a=0;a<=s.size();a++){
        for(int b=0;b<s.size();b++){
            String summary=s.get(b);
            String summary1=s.get(b+1);
            summary=summary.replaceAll("#S:","");
            summary1=summary1.replaceAll("#S:","");
            String[] Summary=summary.split("\\s+");
            String[] Summary1=summary1.split("\\s+");
            if(Integer.valueOf(Summary[0])>Integer.valueOf(Summary1[0])){
                s.set(b,summary1);
                s.set(b+1,summary);
            }
        }
    }
}
public void formatJudge(String message){
    int check=0;
    Pattern pattern=Pattern.compile("(^#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*($|\\n))");
    Pattern pattern1=Pattern.compile("^#T:\\s*(\\d+)(\\s*\\d+\\s*\\-\\s*\\d+\\s*)*$");
    Pattern pattern2=Pattern.compile("^#X:(\\s*(\\d+)\\s*((\\w+)|[\u4e00-\u9fa5]+)\\s*(\\-)*\\s*)*");
    Pattern pattern3=Pattern.compile("^#S:(\\d+)\\s*(\\d+)\\s*(#A:\\s*(\\d+)\\s*\\-\\s*(.*?)\\s*(?=#A:|\\n|$))*");
    Pattern pattern4=Pattern.compile("^#D:\\s*N\\s*\\-\\s*(\\d+)$");
    Pattern pattern5=Pattern.compile("(^#Z:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*($|\\n))");
    Pattern pattern6=Pattern.compile("(^#K:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*($|\\n))");
    Matcher matcher5=pattern5.matcher(message);
    while(matcher5.find()){
        question.add(message);
        num++;
        check=1;
    }
    Matcher matcher6=pattern6.matcher(message);
    while(matcher6.find()){
        question.add(message);
        num++;
        check=1;
    }
    Matcher matcher=pattern.matcher(message);
    while(matcher.find()){
        question.add(message);
        num++;
        check=1;
    }
    Matcher matcher1=pattern1.matcher(message);
    while(matcher1.find()){
        T.add(message);
        check=1;
    }
    Matcher matcher2=pattern3.matcher(message);
    while(matcher2.find()){
        S.add(message);
        check=1;
    }
    Matcher matcher3=pattern2.matcher(message);
    while(matcher3.find()){
        student.add(message);
        check=1;
    }
    Matcher matcher4=pattern4.matcher(message);
    while(matcher4.find()){
        D.add(message);
        check=1;
    }
    if(check==0){
        System.out.println("wrong format:"+message);
    }
}

}
class MoreAnswerQuestion extends QuestionMessage{
public MoreAnswerQuestion(int num,String question,String standerAnswer){
this.setNum(num);
this.setMessage(question);
this.setStandardAnswer(standerAnswer);
}
}
class SummaryQuestion extends QuestionMessage{
public SummaryQuestion(int num,String question,String standerAnswer){
this.setNum(num);
this.setMessage(question);
this.setStandardAnswer(standerAnswer);
}
}
public class Main {
public static void main(String[]args){
Scanner s=new Scanner(System.in);
Process process=new Process();
for(int a=0;;a++){
String message=s.nextLine();
if(message.equals("end")){
break;
}
process.formatJudge(message);
}

    String[] S1=new String[100];
    String[] T1=new String[100];
    AnswerPaper[] ans=new AnswerPaper[100];
    for(int a=0;a<process.getT().size();a++){
        T1=process.getT().get(a).split("\\s+");
        ans[Integer.valueOf(T1[0])]=new AnswerPaper();
        for(int d=0;d<process.getQuestion().size();d++){
            ans[Integer.valueOf(T1[0])].text.textPaper(process.getQuestion().get(d));
        }
        for(int b=1;b<T1.length;b++){
            String[] T2=T1[b].split("-");
            int check=0;
            for(int c=0;c<process.getD().size();c++){
                if(Integer.valueOf(process.getD().get(c).trim())==Integer.valueOf(T2[0])){
                    check=1;
                }
            }
            if (check == 1&&ans[Integer.valueOf(T1[0])].checkQuestion(process.getQuestion(),Integer.valueOf(T2[0]))) {
                ans[Integer.valueOf(T1[0])].setScore(b,0);
                ans[Integer.valueOf(T1[0])].addSum(0);
            }
            else if(check == 0&&ans[Integer.valueOf(T1[0])].checkQuestion(process.getQuestion(),Integer.valueOf(T2[0]))){
                ans[Integer.valueOf(T1[0])].setScore(b,Integer.valueOf(T2[1]));
                ans[Integer.valueOf(T1[0])].addSum(Integer.valueOf(T2[1]));
            }
        }
    }
    String[] S3=new String[100];
    String[] S4=new String[100];
    for(int e=0;e<process.getT().size();e++){
        String[] T=process.getT().get(e).split("\\s+");
        for(int c=0;c<process.getS().size();c++){
            String question=process.getS().get(c).replaceAll("#S:|#A:","");
            String[] Question=question.split("\\s+");
            if(T[0].equals(Question[0])){
                ans[Integer.valueOf(Question[0])].addQuestion(c);
            }
        }
        int[] answerNum=new int[100];
        for(int a=0;a<process.getS().size();a++) {
            String question=process.getS().get(a).replaceAll("#S:|#A:","");
            String[] Question=question.split("\\s+");
            if(T[0].equals(Question[0])){
                S1 = process.getS().get(a).split("#");
                for (int b = 0; b < S1.length; b++) {
                    if(S1[b].startsWith("S:")){
                        S1[b] = S1[b].replaceAll("S:(\\s*)", "");
                        S3=S1[b].split(" ");
                    }
                    if(S1[b].startsWith("A:")){
                        S1[b] = S1[b].replaceAll("A:(\\s*)", "");
                        if(S1[b].length()>0){
                            S4=S1[b].split("-");
                            answerNum[Integer.valueOf(S4[0])]=Integer.valueOf(S4[0]);
                            if(S4.length<2){
                                ans[Integer.valueOf(S3[0])].setAnswers("",Integer.valueOf(S4[0]),a);
                            }
                            else{
                                S4[1]=S4[1].replaceAll("(\\s*)$","");
                                ans[Integer.valueOf(S3[0])].setAnswers(S4[1],Integer.valueOf(S4[0]),a);
                            }
                        }
                    }
                }
            }

        }
    }

    int studentNum=0;
    Students[] students=new Students[100];
    for(int a=0;a<process.getStudent().size();a++){
        process.getStudent().set(a,process.getStudent().get(a).replaceAll("#X:",""));
        String[] student1=process.getStudent().get(a).split("-");
        for(int b=0;b<student1.length;b++){
            String[] student2=student1[b].split("\\s+");
            students[b]=new Students(student2[0],student2[1]);
            studentNum++;
        }
    }
    int[] check = new int[100];
    int[] number2=new int[100];
    //System.out.println(process.getT().size());
    if(process.getT().size()!=0){
        int Max=Integer.valueOf(T1[0]);
        for (int b = 0; b < process.getT().size(); b++){
            T1=process.getT().get(b).split("\\s+");
            if (ans[Integer.valueOf(T1[0])].getAllScore() != 100) {
                number2[Integer.valueOf(T1[0])]=1;
                if(Max<Integer.valueOf(T1[0])){
                    Max=Integer.valueOf(T1[0]);
                }
            }
        }
        for (int b = 1; b <= Max; b++){
            if(number2[b]==1){
                System.out.println("alert: full score of test paper" + b + " is not 100 points");
            }
        }
    }
    for (int a = 0; a < process.getS().size(); a++) {
            S1 = process.getS().get(a).split("(\\s*)#");
            for(int d=0;d<S1.length;d++) {
                if (S1[d].startsWith("S:")) {
                    S1[d] = S1[d].replaceAll("S:(\\s*)", "");
                    S3 = S1[d].split(" ");
                }
                if (S1[d].startsWith("A:")) {
                    S1[d] = S1[d].replaceAll("A:(\\s*)", "");
                    S4 = S1[d].split("-");
                }
            }
            for(int b=0;b<process.getT().size();b++){
                T1=process.getT().get(b).split("\\s+");
                if(Integer.valueOf(S3[0])==Integer.valueOf(T1[0])){
                    break;
                }
            }
            String[] T4=new String[100];
            check[a] = Integer.valueOf(S3[0]);
                int check1 = 0;
                if(process.getT().size()!=0){
                    if (Integer.valueOf(S3[0]) == Integer.valueOf(T1[0])) {
                        check1 = 1;
                    }
                }
                if (check1 == 0) {
                    System.out.println("The test paper number does not exist");
                    continue;
                }
                if (a > 1) {
                    check[a] = check[a - 1];
                }
            for(int d=0;d<process.getT().size();d++) {
                if (Integer.valueOf(T1[0]) == Integer.valueOf(S3[0])) {
                    break;
                }
            }
            for(int b=0;b<T1.length-1;b++){
                String[] T2=T1[b+1].split("-");
                T4[b]=T2[0];
            }
            int num=1;
            for (int b=1;b<T1.length;b++) {
                S1 = process.getS().get(a).split("(\\s*)#");
                String[] T3 = T1[b].split("-");
                for(int c=0;c<S1.length;c++){
                    if(S1[c].startsWith("S:")){
                        S1[c] = S1[c].replaceAll("S:(\\s*)", "");
                        S3=S1[c].split(" ");
                    }
                    if(S1[c].startsWith("A:")) {
                        S1[c] = S1[c].replaceAll("A:(\\s*)", "");
                            if(S1[c].length()>0){
                                S4 = S1[c].split("-");
                                if(b==Integer.valueOf(S4[0])){
                                    if (ans[Integer.valueOf(S3[0])].checkQuestion(process.getQuestion(), Integer.valueOf(T3[0]))) {
                                        ans[Integer.valueOf(S3[0])].ifRight(Integer.valueOf(T4[b-1]), Integer.valueOf(S4[0]),a);
                                    }
                                }
                            }
                    }
                }
                String question=process.getS().get(a).replaceAll("#S:|#A:","");
                String[] Question=question.split("\\s+");

                    if(ans[Integer.valueOf(S3[0])].getAnswers(b,a)==null){
                        System.out.println("answer is null");
                    }
                    else{
                        if(ans[Integer.valueOf(S3[0])].checkQuestion(process.getQuestion(),Integer.valueOf(T3[0]))){
                            if(ans[Integer.valueOf(S3[0])].getScore(Integer.valueOf(b))==0){
                                System.out.println("the question "+T3[0]+" invalid~0");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 1) {
                                System.out.println(ans[Integer.valueOf(S3[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "true");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 2){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.moreAnswerQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "true");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 3){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.moreAnswerQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "partially correct");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 4){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.summaryQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "true");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 5){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.summaryQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "partially correct");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == -1){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.moreAnswerQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "false");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == -2){
                                System.out.println(ans[Integer.valueOf(S3[0])].text.summaryQuestions[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "false");
                            }
                            else if (ans[Integer.valueOf(S3[0])].judgements[b] == 0) {
                                System.out.println(ans[Integer.valueOf(S3[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b,a) + "~" + "false");
                            }
                        }
                        else{
                            System.out.println("non-existent question~0");
                        }
                    }


            }
            int sum = 0;
            int check2=0;
            for (int b = 0; b < studentNum; b++){
                if(students[b].getID().equals(S3[1])){
                    check2=1;
                    break;
                }
            }
            if(check2==1){
                int number1=0;
                for(int c=0;c<students.length;c++){
                    if(students[c].getID().equals(S3[1])){
                        number1=c;
                        break;
                    }
                }
                System.out.printf("%s %s: ",students[number1].getID(),students[number1].getName());
                for (int b = 1; b < T1.length; b++) {
                    String[] T3 = T1[b].split("-");
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 1 && b + 1 != T1.length) {
                        System.out.printf("%d ", ans[Integer.valueOf(T1[0])].getScore(b));
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 0 && b + 1 != T1.length) {
                        System.out.printf("0 ");
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 2 && b + 1 != T1.length) {
                        System.out.printf("%d ", ans[Integer.valueOf(T1[0])].getScore(b));
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 3 && b + 1 != T1.length) {
                        System.out.printf("%d ", ans[Integer.valueOf(T1[0])].getScore(b)/2);
                        sum += ans[Integer.valueOf(T1[0])].getScore(b)/2;
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == -1 && b + 1 != T1.length) {
                        System.out.printf("0 ");
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 4 && b + 1 != T1.length) {
                        System.out.printf("%d ", ans[Integer.valueOf(T1[0])].getScore(b));
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 5 && b + 1 != T1.length) {
                        System.out.printf("%d ", ans[Integer.valueOf(T1[0])].getScore(b)/2);
                        sum += ans[Integer.valueOf(T1[0])].getScore(b)/2;
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == -2 && b + 1 != T1.length) {
                        System.out.printf("0 ");
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 1 && b + 1 == T1.length) {
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                        System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].getScore(b), sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 0 && b + 1 == T1.length) {
                        System.out.printf("0~%d\n", sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 2 && b + 1 == T1.length) {
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                        System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].getScore(b), sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 3 && b + 1 == T1.length) {
                        sum += ans[Integer.valueOf(T1[0])].getScore(b)/2;
                        System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].getScore(b)/2, sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == -1 && b + 1 == T1.length) {
                        System.out.printf("0~%d\n", sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 4 && b + 1 == T1.length) {
                        sum += ans[Integer.valueOf(T1[0])].getScore(b);
                        System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].getScore(b), sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == 5 && b + 1 == T1.length) {
                        sum += ans[Integer.valueOf(T1[0])].getScore(b)/2;
                        System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].getScore(b)/2, sum);
                    }
                    if (ans[Integer.valueOf(T1[0])].judgements[b] == -2 && b + 1 == T1.length) {
                        System.out.printf("0~%d\n", sum);
                    }
                }
            }
            else{
                System.out.println(S3[1]+" not found");
            }


    }
}

}

**2）第五次代码：**

点击查看代码

import java.util.;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.LinkedList;
abstract class ControlDevice{
protected double Pin1=0;
protected double Pin2=0;
public double getInPin1() {
return Pin1;
}
public void setPin1(double Pin1) {
this.Pin1 = Pin1;
}
public double getPin2() {
return Pin2;
}
public void setPin2(double Pin2) {
this.Pin2 = Pin2;
}
}
class Switch extends ControlDevice{
private int state=0;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
public double getPin2(){
if(state0){
return 0;
}
else {
return Pin1;
}
}
public void exchange(){
if(state0){
state=1;
}
else {
state=0;
}
}
}
class Governor extends ControlDevice{
protected double inputPin=0;
protected double outputPin=0;
}
class ConstantGovernor extends Governor{
private double parameter=0;
public double getParameter() {
return parameter;
}
public void setParameter(double parameter) {
this.parameter = parameter;
}
public double getInputPin() {
return inputPin;
}
public void setInputPin(double inputPin) {
this.inputPin = inputPin;
}
public double getOutputPin() {
return inputPinparameter;
}

**3）第六次代码：**

点击查看代码

}
class GradGovernor extends Governor{
private int gear=0;
public int getGear() {
return gear;
}
public void setGear(int gear) {
this.gear = gear;
}
public double getInputPin() {
return inputPin;
}
public void setInputPin(double inputPin) {
this.inputPin = inputPin;
}
public double getOutputPin() {
if(this.gear0){
return 0;
}
else if(this.gear1){
return inputPin0.3;
}
else if(this.gear==2){
return inputPin0.6;
}
else{
return inputPin0.9;
}
}
public void upGear(){
if(gear<3){
gear++;
}
}
public void downGear(){
if(gear>0){
gear--;
}
}
}
abstract class ControlledDevice{
protected int resistance;
protected double Pin1=0;
protected double Pin2=0;
public double getPin1() {
return Pin1;
}
public void setPin1(double pin1) {
Pin1 = pin1;
}
public double getPin2() {
return Pin2;
}
public void setPin2(double pin2) {
Pin2 = pin2;
}
}
class Light extends ControlledDevice{
protected int brightness=0;
}
class IncandescentLamp extends Light{
public IncandescentLamp(){
super.resistance=10;
}
public int getBrightness(){
if(Math.abs(Pin1-Pin2)>=0&&Math.abs(Pin1-Pin2)<9){
return 0;
}
else if(Math.abs(Pin1-Pin2)220){
return 200;
}
else if(Math.abs(Pin1-Pin2)10){
return 50;
}
else{
return (int)((Math.abs(Pin1-Pin2)-10)(150.0/210.0)+50);
}
}
}
class FluorescentLamp extends ControlledDevice{
public FluorescentLamp(){
super.resistance=5;
}
public int getBrightness(){
if(Math.abs(Pin1-Pin2)0){
return 0;
}
else{
return 180;
}
}
}
class Fan extends ControlledDevice{
private int speed;
public Fan(){
super.resistance=20;
}
public int getSpeed() {
if(Math.abs(Pin1-Pin2)<80){
return 0;
}
else if(Math.abs(Pin1-Pin2)80){
return 80;
}
else if(Math.abs(Pin1-Pin2)150){
return 360;
}
else if(Math.abs(Pin1-Pin2)>150){
return 360;
}
else {
return (int)((Math.abs(Pin1-Pin2)-80)(280/70)+80);
}
}
public void setSpeed(int speed) {
this.speed = speed;
}
}
class FloorFan extends ControlledDevice{
private int speed;
public FloorFan(){
super.resistance=20;
}
public int getSpeed() {
if(Math.abs(Pin1-Pin2)<80){
return 0;
}
else if(Math.abs(Pin1-Pin2)>=80&&Math.abs(Pin1-Pin2)<100){
return 80;
}
else if(Math.abs(Pin1-Pin2)>=100&&Math.abs(Pin1-Pin2)<120){
return 160;
}
else if(Math.abs(Pin1-Pin2)>=120&&Math.abs(Pin1-Pin2)<140){
return 260;
}
else {
return 360;
}
}
public void setSpeed(int speed) {
this.speed = speed;
}
}
class Power{
private int power;
public double getPower() {
return 220;
}
}
class Agent{
private Map<String,LinkedList> T=new HashMap<>();
private Map<String,ArrayList> Map=new HashMap<>();
LinkedList allDevices=new LinkedList<>();
private Switch[] Switchs=new Switch[100];
private GradGovernor[] gradGovernors=new GradGovernor[100];
private ConstantGovernor[] constantGovernors=new ConstantGovernor[100];
private IncandescentLamp[] incandescentLamps=new IncandescentLamp[100];
private FluorescentLamp[] fluorescentLamps=new FluorescentLamp[100];
private Fan[] fans=new Fan[100];
private FloorFan[] floorFans=new FloorFan[100];
private Power power=new Power();
public void process(String s){
if(s.startsWith("#T")){
s=s.replaceAll("#","");
String[] S=s.split("😊;
S[1]=S[1].replaceAll("[\[\]]","");
String[] components=S[1].split("\s+");
if(S[1].startsWith("IN")){
LinkedList allDevices=new LinkedList<>();
for(int a=0;a<components.length;a++){
String det=components[a].replaceAll("-\d+","");
String[] number=det.split("[KFLBRDA]");
if(components[a].equals("IN")){
allDevices.add(det);
}
else if(components[a].startsWith("K")){
Switchs[Integer.valueOf(number[1])]=new Switch();
allDevices.add(det);
}
else if(components[a].startsWith("F")){
gradGovernors[Integer.valueOf(number[1])]=new GradGovernor();
allDevices.add(det);
}
else if(components[a].startsWith("L")){
constantGovernors[Integer.valueOf(number[1])]=new ConstantGovernor();
allDevices.add(det);
}
else if(components[a].startsWith("B")){
incandescentLamps[Integer.valueOf(number[1])]=new IncandescentLamp();
allDevices.add(det);
}
else if(components[a].startsWith("R")){
fluorescentLamps[Integer.valueOf(number[1])]=new FluorescentLamp();
allDevices.add(det);
}
else if(components[a].startsWith("D")){
fans[Integer.valueOf(number[1])]=new Fan();
allDevices.add(det);
}
else if(components[a].startsWith("A")){
floorFans[Integer.valueOf(number[1])]=new FloorFan();
allDevices.add(det);
}
}
T.put(S[0],allDevices);
}
if(S[1].startsWith("VCC")){
for(int a=0;a<components.length;a++){
String det=components[a].replaceAll("-\d+|-IN|-OUT","");
String[] number=det.split("[KFLBRDA]");
if(components[a].equals("VCC")){
allDevices.add(det);
}
else if(components[a].startsWith("K")){
Switchs[Integer.valueOf(number[1])]=new Switch();
allDevices.add(det);
}
else if(components[a].startsWith("F")){
gradGovernors[Integer.valueOf(number[1])]=new GradGovernor();
allDevices.add(det);
}
else if(components[a].startsWith("L")){
constantGovernors[Integer.valueOf(number[1])]=new ConstantGovernor();
allDevices.add(det);
}
else if(components[a].startsWith("B")){
incandescentLamps[Integer.valueOf(number[1])]=new IncandescentLamp();
allDevices.add(det);
}
else if(components[a].startsWith("R")){
fluorescentLamps[Integer.valueOf(number[1])]=new FluorescentLamp();
allDevices.add(det);
}
else if(components[a].startsWith("D")){
fans[Integer.valueOf(number[1])]=new Fan();
allDevices.add(det);
}
else if(components[a].startsWith("M")){
allDevices.add(det);
}
else if(components[a].startsWith("A")){
floorFans[Integer.valueOf(number[1])]=new FloorFan();
allDevices.add(det);
}
}
}
}
if(s.startsWith("#M")){
ArrayList M=new ArrayList<>();
s=s.replaceAll("#","");
String[] S=s.split("😊;
S[1]=S[1].replaceAll("[\[\]]","");
String[] components=S[1].split("\s+");
for(int a=0;a<components.length;a++){
M.add(components[a]);
}
Map.put(S[0],M);
}
else{
String[] number=s.split("[KFLBRDA]");
if(s.startsWith("#K")){
Switchs[Integer.parseInt(number[1])].exchange();
}
if(s.startsWith("#F")){
String[] upDown=number[1].split("\d+");
String num=number[1].replaceAll("[+\-]","");
if(Objects.equals(upDown[1], "+")){
gradGovernors[Integer.parseInt(num)].upGear();
}
else {
gradGovernors[Integer.parseInt(num)].downGear();
}
}
if(s.startsWith("#L")){
String[] apart=number[1].split("😊;
constantGovernors[Integer.parseInt(apart[0])].setParameter(Double.valueOf(apart[1]));
}
}
}
public void outPut(){
LinkedList K=new LinkedList<>();
LinkedList F=new LinkedList<>();
LinkedList L=new LinkedList<>();
LinkedList B=new LinkedList<>();
LinkedList R=new LinkedList<>();
LinkedList D=new LinkedList<>();
LinkedList A=new LinkedList<>();
LinkedList resistance=new LinkedList<>();
Map<String,ArrayList> branchResistance=new HashMap<>();
int position=0;
double allResistance=0;
double outPower=power.getPower();
for(int a=1;a<allDevices.size();a+=2) {
String[] number = allDevices.get(a).split("[KFLBRDA]");
if(allDevices.get(a).startsWith("B")){
resistance.add(10.0);
}
if(allDevices.get(a).startsWith("R")){
resistance.add(5.0);
}
if(allDevices.get(a).startsWith("D")||allDevices.get(a).startsWith("A")){
resistance.add(20.0);
}
if (allDevices.get(a).startsWith("K") && Switchs[Integer.valueOf(number[1])].getState() == 0) {
outPower = 0;
}
if (allDevices.get(a).startsWith("M")) {
int KDepart = 0;
double allOuMu=0;
double allOuMu1=0;
for (int c = 0; c < Map.get(allDevices.get(a)).size(); c++) {
ArrayList OuMu=new ArrayList<>();
boolean switchOK=true;
for(int d=1;d<T.get(Map.get(allDevices.get(a)).get(c)).size();d+=2){
String[] number2 = T.get(Map.get(allDevices.get(a)).get(c)).get(d).split("[KFLBRDA]");
if(T.get(Map.get(allDevices.get(a)).get(c)).get(d).startsWith("K")&& Switchs[Integer.valueOf(number2[1])].getState() == 0){
switchOK=false;
break;
}
}
if(switchOK){
for (int b = 1; b < T.get(Map.get(allDevices.get(a)).get(c)).size(); b+=2) {
String[] number1 = T.get(Map.get(allDevices.get(a)).get(c)).get(b).split("[KFLBRDA]");
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("B")){
OuMu.add(10.0);
allOuMu+=10;
}
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("R")){
OuMu.add(5.0);
allOuMu+=5;
}
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("D")||T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("A")){
OuMu.add(20.0);
allOuMu+=20;
}
if (T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("K") && Switchs[Integer.valueOf(number1[1])].getState() == 0) {
KDepart++;
}
}
branchResistance.put(Map.get(allDevices.get(a)).get(c),OuMu);
allOuMu1+=Math.pow(allOuMu,-1);
allOuMu=0;
}
else {
for (int b = 1; b < T.get(Map.get(allDevices.get(a)).get(c)).size(); b+=2) {
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("B")){
OuMu.add(10.0);
}
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("R")){
OuMu.add(5.0);
}
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("D")||T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("A")){
OuMu.add(20.0);
}
}
branchResistance.put(Map.get(allDevices.get(a)).get(c),OuMu);
}
}
allOuMu1=Math.pow(allOuMu1,-1);
resistance.add(allOuMu1);
if (KDepart == Map.get(allDevices.get(a)).size()) {
outPower = 0;
}
}
}
for(int a=0;a<resistance.size();a++){
allResistance+=resistance.get(a);
}
for(int a=1;a<allDevices.size();a+=2){
String[] number=allDevices.get(a).split("[KFLBRDA]");
if(allDevices.get(a).startsWith("F")){
gradGovernors[Integer.valueOf(number[1])].setInputPin(outPower);
outPower=gradGovernors[Integer.valueOf(number[1])].getOutputPin();
F.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("L")){
constantGovernors[Integer.valueOf(number[1])].setInputPin(outPower);
outPower=constantGovernors[Integer.valueOf(number[1])].getOutputPin();
L.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("K")){
Switchs[Integer.valueOf(number[1])].setPin1(outPower);
outPower=Switchs[Integer.valueOf(number[1])].getPin2();
K.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("B")){
incandescentLamps[Integer.valueOf(number[1])].setPin1(outPower(resistance.get(position)/allResistance));
position++;
B.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("R")){
fluorescentLamps[Integer.valueOf(number[1])].setPin1(outPower(resistance.get(position)/allResistance));
position++;
R.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("A")){
floorFans[Integer.valueOf(number[1])].setPin1(outPower(resistance.get(position)/allResistance));
position++;
A.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("D")){
fans[Integer.valueOf(number[1])].setPin1(outPower(resistance.get(position)/allResistance));
position++;
D.add(allDevices.get(a));
}
else if(allDevices.get(a).startsWith("M")){
for (int c = 0; c < Map.get(allDevices.get(a)).size(); c++){
double outPower1=outPower(resistance.get(position)/allResistance);
double allResistance1=0;
int location=0;
for(int d=0;d<branchResistance.get(Map.get(allDevices.get(a)).get(c)).size();d++){
allResistance1+=branchResistance.get(Map.get(allDevices.get(a)).get(c)).get(d);
}
for(int b=1;b<T.get(Map.get(allDevices.get(a)).get(c)).size();b+=2){
String[] number1 = T.get(Map.get(allDevices.get(a)).get(c)).get(b).split("[KFLBRDA]");
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("K")&&Switchs[Integer.valueOf(number1[1])].getState() == 0){
outPower1=0;
}
}
for(int b=1;b<T.get(Map.get(allDevices.get(a)).get(c)).size();b+=2){
String[] number1 = T.get(Map.get(allDevices.get(a)).get(c)).get(b).split("[KFLBRDA]");
if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("K")){
Switchs[Integer.valueOf(number1[1])].setPin1(outPower1);
outPower1=Switchs[Integer.valueOf(number1[1])].getPin2();
K.add(T.get(Map.get(allDevices.get(a)).get(c)).get(b));
}
else if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("B")){
incandescentLamps[Integer.valueOf(number1[1])].setPin1(outPower1(branchResistance.get(Map.get(allDevices.get(a)).get(c)).get(location)/allResistance1));
location++;
B.add(T.get(Map.get(allDevices.get(a)).get(c)).get(b));
}
else if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("R")){
fluorescentLamps[Integer.valueOf(number1[1])].setPin1(outPower1(branchResistance.get(Map.get(allDevices.get(a)).get(c)).get(location)/allResistance1));
location++;
R.add(T.get(Map.get(allDevices.get(a)).get(c)).get(b));
}
else if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("A")){
floorFans[Integer.valueOf(number1[1])].setPin1(outPower1(branchResistance.get(Map.get(allDevices.get(a)).get(c)).get(location)/allResistance1));
location++;
A.add(T.get(Map.get(allDevices.get(a)).get(c)).get(b));
}
else if(T.get(Map.get(allDevices.get(a)).get(c)).get(b).startsWith("D")){
fans[Integer.valueOf(number1[1])].setPin1(outPower1(branchResistance.get(Map.get(allDevices.get(a)).get(c)).get(location)/allResistance1));
location++;
D.add(T.get(Map.get(allDevices.get(a)).get(c)).get(b));
}
}
}
position++;
}
}
Sort(K);
Sort(F);
Sort(L);
Sort(B);
Sort(R);
Sort(D);
Sort(A);
if(!K.isEmpty()){
for(int a=0;a<K.size();a++){
String[] number=K.get(a).split("[KFLBRDA]");
if(Switchs[Integer.valueOf(number[1])].getState()0){
System.out.println("@"+K.get(a)+":turned on");
}
else{
System.out.println("@"+K.get(a)+":closed");
}
}
}
if(!F.isEmpty()){
for(int a=0;a<F.size();a++){
String[] number=F.get(a).split("[KFLBRDA]");
System.out.println("@"+F.get(a)+":"+gradGovernors[Integer.valueOf(number[1])].getGear());
}
}
if(!L.isEmpty()){
for(int a=0;a<L.size();a++){
String[] number=L.get(a).split("[KFLBRDA]");
System.out.printf("@%s:%.2f\n",L.get(a),constantGovernors[Integer.valueOf(number[1])].getParameter());
}
}
if(!B.isEmpty()){
for(int a=0;a<B.size();a++){
String[] number=B.get(a).split("[KFLBRDA]");
System.out.printf("@%s:%d\n",B.get(a),incandescentLamps[Integer.valueOf(number[1])].getBrightness());
}
}
if(!R.isEmpty()){
for(int a=0;a<R.size();a++){
String[] number=R.get(a).split("[KFLBRDA]");
System.out.printf("@%s:%d\n",R.get(a),fluorescentLamps[Integer.valueOf(number[1])].getBrightness());
}
}
if(!D.isEmpty()){
for(int a=0;a<D.size();a++){
String[] number=D.get(a).split("[KFLBRDA]");
System.out.printf("@%s:%d\n",D.get(a),fans[Integer.valueOf(number[1])].getSpeed());
}
}
if(!A.isEmpty()){
for(int a=0;a<A.size();a++){
String[] number=A.get(a).split("[KFLBRDA]");
System.out.printf("@%s:%d\n",A.get(a),floorFans[Integer.valueOf(number[1])].getSpeed());
}
}
}
public void Sort(LinkedList n){
for(int a=0;a<n.size();a++){
for(int b=0;b<n.size()-1;b++){
String[] number=n.get(b).split("[KFLBRDA]");
String[] number1=n.get(b+1).split("[KFLBRDA]");
int first=Integer.valueOf(number[1]);
int late=Integer.valueOf(number1[1]);
String first1=n.get(b);
String late1=n.get(b+1);
if(first>late){
n.set(b,late1);
n.set(b+1,first1);
}
}
}
}
}
public class Main {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
Agent agent=new Agent();
for(int a=0;;a++){
String message=input.nextLine();
if(message.equals("end")){
break;
}
agent.process(message);
}
agent.outPut();
}
}

**4.改进建议** 新的pta相比上一次的进步是肯定的，类的设计在一定程度上要高于算法带来的便利，对以后的代码改进提供了方便建议： i.还是老毛病了，第五次作业不明显，写hardcoding还是改不了的毛病 ii.建议将Agent类里面的方法在拆开来，分成更细的方法，这样就可以重复使用某一个方法，提高复用性 **5.总结** i.在这三次pta作业中可以明显感觉到类设计的重要性 ii.我进一步学习到了继承和多态 iii.进一步学习了如何处理类间关系

学习永无止境，期待未来的我们

posted on 2024-06-02 21:09 HEAT-APCR 阅读(17) 评论(0) 编辑收藏举报

对java面向程序设计的pta 4,5,6次作业的总结

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

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103 #A:1-4

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103

Z:2 #Q:宋代书法有苏黄米蔡四家，分别是： #A:苏轼 黄庭坚 米芾 蔡襄

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

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-瑶琴

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-古筝

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:瑶琴或七弦琴

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

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]

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

搜索

常用链接

随笔档案

阅读排行榜

Z:2 #Q:宋代书法有苏黄米蔡四家，分别是： #A:苏轼黄庭坚米芾蔡襄

+设备标识L+设备编号+":" +数值代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

+设备标识L+设备编号+":" +数值代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。