oop第二次博客作业
前言
本月的学习在进一步熟悉Java的语法外,还了解了程序设计的几种模式。这三次pta主要考察的是继承,多态的使用。部分设计模式也可使用。
学习的知识点
1.会使用简单的继承与多态。
2.学习了一些重要的设计模式,对设计有了更深的认识。
3.会使用简单的接口。
自我改进的方面
1.对结构的设计要考虑后面的迭代。
2.类实现单一职责。
设计分析
第一次PTA大作业:
1)题目要求
7-1 答题判题程序-4
分数 82
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序,模拟一个小型的测试,要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息,根据输入题目信息中的标准答案判断答题的结果。本题在答题判题程序-3基础上新增的内容统一附加在输出格式说明之后,用粗体标明。
输入格式:
程序输入信息分五种,信息可能会打乱顺序混合输入。
1、题目信息
题目信息为独行输入,一行为一道题,多道题可分多行输入。
格式:"#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束:
1、题目的输入顺序与题号不相关,不一定按题号顺序从小到大输入。
2、允许题目编号有缺失,例如:所有输入的题号为1、2、5,缺少其中的3号题。此种情况视为正常。
样例:#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
试卷信息为独行输入,一行为一张试卷,多张卷可分多行输入数据。 \
格式:"#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束:
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例:#T:1 3-5 4-8 5-2
3、学生信息
学生信息只输入一行,一行中包括所有学生的信息,每个学生的信息包括学号和姓名,格式如下。
格式:"#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束:
答案数量可以不等于试卷信息中题目的数量,没有答案的题目计0分,多余的答案直接忽略,答案之间以英文空格分隔。
样例:
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息
答卷信息按行输入,每一行为一张答卷的答案,每组答案包含某个试卷信息中的题目的解题答案,答案的顺序号与试 卷信息中的题目顺序相对应。答卷中:
格式:"#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束:
答案数量可以不等于试卷信息中题目的数量,没有答案的题目计0分,多余的答案直接忽略,答案之间以英文空格分隔。
答案内容可以为空,即””。
答案内容中如果首尾有多余的空格,应去除后再进行判断。
答卷信息中仅包含试卷号、学号,而没有后续内容的,视为一张空白卷,为有效信息,不做格式错误处理。
样例:
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号,5是试卷第2题的答案,即T中3-2的答案
6-4中的6是试卷中顺序号,4是试卷第6题的答案,即T中7-3的答案
注意:不要混淆顺序号与题号
5、删除题目信息
删除题目信息为独行输入,每一行为一条删除信息,多条删除信息可分多行输入。该信息用于删除一道题目信息,题目被删除之后,引用该题目的试卷依然有效,但被删除的题目将以0分计,同时在输出答案时,题目内容与答案改为一条失效提示,例如:”the question 2 invalid~0”
格式:"#D:N-"+题目号
格式约束:
题目号与第一项”题目信息”中的题号相对应,不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例:
N:1 #Q:1+1= #A:2
N:2 #Q:2+2= #A:4
T:1 1-5 2-8
X:20201103 Tom-20201104 Jack
S:1 20201103 #A:1-5 #A:2-4
D:N-2
end
输出:
alert: full score of test paper1 is not 100 points
1+1=5false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束,"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用,试卷依然属于正常试卷,可用于后面的答题。如果总分等于100 分,该部分忽略,不输出。
格式:"alert: full score of test paper"+试卷号+" is not 100 points"
约束:有多张试卷时,按输入信息的先后顺序输出警示。
样例:alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息,根据试卷的题目的数量输出多行数据。
格式:题目内容+""+答案++""+判题结果(true/false)
约束:如果输入的答案信息少于试卷的题目数量,每一个缺失答案的题目都要输出"answer is null" 。
样例:
answer is null
3+2=~5~true
4+6=~22~false.
answer is null
3、判分信息
判分信息为一行数据,是一条答题记录所对应试卷的每道小题的计分以及总分,计分输出的先后顺序与题目题号相对应。
格式:学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束:
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例:20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、被删除的题目提示信息
当某题目被试卷引用,同时被删除时,答案中输出提示信息。样例见第5种输入信息“删除题目信息”。
5、题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题,在输出学生答案时,提示”non-existent question~”加答案。例如:
输入:
N:1 #Q:1+1= #A:2
T:1 3-8
X:20201103 Tom-20201104 Jack-20201105 Www
S:1 20201103 #A:1-4
end
输出:
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时,一道题目同时出现答案不存在、引用错误题号、题目被删除,只提示一种信息,答案不存在的优先级最高,例如:
输入:
N:1 #Q:1+1= #A:2
T:1 3-8
X:20201103 Tom-20201104 Jack-20201105 Www
S:1 20201103
end
输出:
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息
输入信息只要不符合格式要求,均输出”wrong format:”+信息内容。
例如:wrong format:2 #Q:2+2= #4
7、试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到,则输出”the test paper number does not exist”,答卷中的答案不用输出,参见样例8。
8、学号引用错误提示信息
如果答卷中的学号信息不在学生列表中,答案照常输出,判分时提示错误。参见样例9。
本次作业新增内容:
1、输入选择题题目信息
题目信息为独行输入,一行为一道题,多道题可分多行输入。
格式:"#Z:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
新增约束:标准答案中如果包含多个正确答案(多选题),正确答案之间用英文空格分隔。
例如:
Z:2 #Q:宋代书法有苏黄米蔡四家,分别是: #A:苏轼 黄庭坚 米芾 蔡襄
多选题输出:
输出格式与一般答卷题目的输出一致,判断结果除了true、false,增加一项”partially correct”表示部分正确。
多选题给分方式:
答案包含所有正确答案且不含错误答案给满分;包含一个错误答案或完全没有答案给0分;包含部分正确答案且不含错误答案给一半分,如果一半分值为小数,按截尾规则只保留整数部分。
例如:
N:1 #Q:1+1= #A:2
Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D
T:1 1-5 2-9
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-A C
end
输出:
alert: full score of test paper1 is not 100 points
1+1=5false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
2、输入填空题题目信息
题目信息为独行输入,一行为一道题,多道题可分多行输入。
格式:"#K:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
例如:#K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
填空题输出:
输出格式与一般答卷题目的输出一致,判断结果除了true、false,增加一项”partially correct”表示部分正确。
填空题给分方式:
答案与标准答案内容完全匹配给满分,包含一个错误字符或完全没有答案给0分,包含部分正确答案且不含错误字符给一半分,如果一半分值为小数,按截尾规则只保留整数部分。
例如:
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
T:1 1-5 2-10
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-瑶琴
end
输出:
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被称为:瑶琴partially correct
20201103 Tom: 0 5~5
3、输出顺序变化
只要是正确格式的信息,可以以任意的先后顺序输入各类不同的信息。比如试卷可以出现在题目之前,删除题目的信息可以出现在题目之前等。
例如:
T:1 1-5 2-10
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-古筝
end
输出:
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被称为:古筝false
20201103 Tom: 0 0~0
4、多张试卷信息
本题考虑多个同学有多张不同试卷的答卷的情况。输出顺序优先级为学号、试卷号,按从小到大的顺序先按学号排序,再按试卷号。
例如:
T:1 1-5 2-10
T:2 1-8 2-21
N:1 #Q:1+1= #A:2
S:2 20201103 #A:1-2 #A:2-古筝
S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴
S:1 20201104 #A:1-2 #A:2-瑟
S:2 20201104 #A:1-5 #A:2-七弦琴
X:20201103 Tom-20201104 Jack
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
end
输出:
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=5false
古琴在古代被称为:瑶琴或七弦琴true
20201103 Tom: 0 10~10
1+1=2true
古琴在古代被称为:古筝false
20201103 Tom: 8 0~8
1+1=2true
古琴在古代被称为:瑟false
20201104 Jack: 5 0~5
1+1=5false
古琴在古代被称为:七弦琴partially correct
20201104 Jack: 0 10~10
新增的题目异常情况的处理与一般题目相同,具体样例参考上一次大作业的样例说明:
答题判题程序-3题面.pdf
输入样例1:
多选题测试,不含删除。例如:
N:1 #Q:1+1= #A:2
Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D
T:1 1-5 2-9
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-A C
end
输出样例1:
在这里给出相应的输出。例如:
alert: full score of test paper1 is not 100 points
1+1=5false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
输入样例2:
填空题测试,不含删除。例如:
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
T:1 1-5 2-10
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-瑶琴
end
输出样例2:
在这里给出相应的输出。例如:
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被称为:瑶琴partially correct
20201103 Tom: 0 5~5
输入样例3:
乱序测试,不含删除。例如:
T:1 1-5 2-10
N:1 #Q:1+1= #A:2
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
X:20201103 Tom
S:1 20201103 #A:1-5 #A:2-古筝
end
输出样例3:
在这里给出相应的输出。例如:
alert: full score of test paper1 is not 100 points
1+1=5false
古琴在古代被称为:古筝false
20201103 Tom: 0 0~0
输入样例4:
两个同学多张不同试卷的答卷,不含删除。例如:
T:1 1-5 2-10
T:2 1-8 2-21
N:1 #Q:1+1= #A:2
S:2 20201103 #A:1-2 #A:2-古筝
S:1 20201104 #A:1-2 #A:2-瑟
S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴
S:2 20201104 #A:1-5 #A:2-七弦琴
X:20201103 Tom-20201104 Jack
K:2 #Q:古琴在古代被称为: #A:瑶琴或七弦琴
end
输出样例4:
在这里给出相应的输出。例如:
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=5false
古琴在古代被称为:瑶琴或七弦琴true
20201103 Tom: 0 10~10
1+1=2true
古琴在古代被称为:古筝false
20201103 Tom: 8 0~8
1+1=2true
古琴在古代被称为:瑟false
20201104 Jack: 5 0~5
1+1=5false
古琴在古代被称为:七弦琴partially correct
20201104 Jack: 0 10~10
2)个人设计
本次作业的设计针对上次进行了较大的修改
针对题目,设计了题目父类exercise
其中包含了题目编号,题目内容,正确答案,是否删除四个属性。除构造方法等存取类方法外,还有判断对错的方法。
class exercise{
private int NO;//题目编号
private String Content;//题目内容
private String standardAnswer;//正确答案
private boolean Valid = true;//题目是否被删除
ArrayList
public exercise(int NO, String content, String standardAnswer) {
this.NO = NO;
Content = content;
this.standardAnswer = standardAnswer;
}
public int getNO() {
return NO;
}
public void setNO(int NO) {
this.NO = NO;
}
public String getContent() {
return Content;
}
public void setContent(String content) {
Content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
//判断对错
public int judge(String answer){
return -1;
}
public void disabled () {
this.Valid = false;
} //删除题目
public void answers_Put(Answer An) {
answers.add(An);
}
public boolean getValid() {
return Valid;
}
public ArrayList<Answer> getAnswers() {
return answers;
}
public boolean isValid() {
return Valid;
}
}
对于选择题,设计了choice_exercise类,它为exercise子类
它没有父类之外的属性。有用于判断对错的方法 public int judge(String answer)。
class choice_exercise extends exercise {//选择题
public choice_exercise(int NO, String content, String standardAnswer) {
super(NO, content, standardAnswer);
}
@Override
public int judge(String answer) {//-1全错,0半错,1全对
String StAnswer = super.getStandardAnswer().replaceAll(" ","");
String theAnswer = answer.replaceAll(" ","");
if(StAnswer.length() == theAnswer.length()) {
for(int i = 0;i < StAnswer.length() - 1;i ++) {
if(!StAnswer.contains(theAnswer.charAt(i) + "")) {
return -1;
}
}
return 1;
} else if(StAnswer.length() < theAnswer.length()) {
return -1;
} else {
for(int i = 0;i < theAnswer.length();i ++) {
if(!StAnswer.contains(theAnswer.charAt(i) + "")) {
return -1;
}
}
return 0;
}
}
}
对于填空题,设计了类gap_exercise类,它为exercise的子类。
它没有父类之外的属性。有用于判断对错的方法 public int judge(String answer)。
class gap_exercise extends exercise {//填空题
public gap_exercise(int NO, String content, String standardAnswer) {
super(NO, content, standardAnswer);
}
@Override
public int judge(String answer) {//-1全错,0半对,1全对
if(super.getStandardAnswer().equals(answer)) {
return 1;
} else if(super.getStandardAnswer().contains(answer)) {
return 0;
} else {
return -1;
}
}
}
对于解答题,设计了free_exercise类,它为exercise的子类。
它没有父类之外的属性。有用于判断对错的方法 public int judge(String answer)。
class free_exercise extends exercise {//解答题
public free_exercise(int NO, String content, String standardAnswer) {
super(NO, content, standardAnswer);
}
@Override
public int judge(String answer) {//只存在对错,1对-1错
if(super.getStandardAnswer().equals(answer)) {
return 1;
} else {
return -1;
}
}
}
对于试卷中的题目,设计了exercise_Paper类。
它有试卷中题目顺序序号,试卷中题目序号,题目类实例,题目分数四个属性。除构造方法等存取方法外,有判断得分的方法public int judge_markAnswer(String Answer)。
class exercise_paper {
private int thisOrder;//试卷中题目的顺序号,从1开始!!!
private int thisNO;//试卷中题目的序号
private exercise thisExe;//题目类实例
private int thisScore;//题目的分数
public exercise_paper(int thisNO,int thisOrder,int thisScore) {
this.thisNO = thisNO;
this.thisOrder = thisOrder;
this.thisScore = thisScore;
}
public int judge_markAnswer(String Answer) {//判断得分
if(thisExe.judge(Answer) == 1) {
return thisOrder;
} else {
return 0;
}
}
public void addEXE(exercise EXE) {
this.thisExe = EXE;
}
public int getThisOrder() {
return thisOrder;
}
public int getThisNO() {
return thisNO;
}
public exercise getThisExe() {
return thisExe;
}
public int getThisScore() {
return thisScore;
}
}
针对试卷,设计了Paper类。
它有试卷编号,题目数量,题目顺序号与题目实例组成的HashMap,试卷总分,试卷所有题目编号的ArrayList五个属性。只有构造方法等存取方法。
class paper {
public static int getNoPaper() {
return NoPaper;
}
private static int NoPaper;//试卷编号
private int exerciseNum = 0;//题目数量
private HashMap<Integer, exercise_paper> SumExe;// key为题目顺序号,value为题目实例
private int SumGrade = 0;//试卷总分
private ArrayList<Integer> exercise_NO = new ArrayList<>();//试卷所有题目序号
public paper(int noPaper) {
NoPaper = noPaper;
SumExe = new HashMap<>(); // 初始化SumExe
}
public int getSumGrade() {
return SumGrade;
}
public void addSumGrade(int i) {
this.SumGrade = this.SumGrade + i;
}
public void SumExe_Put(int n, exercise_paper E) {
SumExe.put(n,E);
exerciseNum ++;
}
public int getExerciseNum() {
return exerciseNum;
}
public HashMap<Integer, exercise_paper> getSumExe() {
return SumExe;
}
public void addexercise_NO(int i) {
exercise_NO.add(i);
}
public ArrayList<Integer> getExercise_NO() {
return exercise_NO;
}
}
针对回答,设计了Answer类。
它有回答内容,对错判断信息,得分,答案顺序号,答案题目编号五个属性。只有构造方法等存取方法。
class Answer {
private String answer;//回答内容
private int mark;//对判题信息
private int score = 0;//得分
private int order;//答案顺序号
private int NO;//答案的题目编号
public Answer(int order, String answer) {
this.answer = answer;
this.order = order;
}
public void disable() {
}
public String getAnswer() {
return answer;
}
public int getMark() {
return mark;
}
public int getScore() {
return score;
}
public int getOrder() {
return order;
}
public int getNO() {
return NO;
}
public void setMark(int mark) {
this.mark = mark;
}
public void setScore(int score) {
this.score = score;
}
public void setNO(int NO) {
this.NO = NO;
}
}
针对答卷,设计了AnswerPaper类。
它有试卷信息,答案顺序与答案实例组成的HashMap,存每题答案信息的ArrayList,存每题对错信息的ArrayList,答卷编号,学生学号,存答案顺序的ArrayList七个属性。只有存取方法。
class AnswerPaper {
private paper thispaper;//试卷信息
private HashMap<Integer,Answer> Sumanswer = new HashMap<>();//key为答卷顺序,value为答卷
private ArrayList
private ArrayList
private int _NoPaper;//答卷编号
private int AnswerStuID;//学生学号
private ArrayList
public AnswerPaper(int _NoPaper) {
this._NoPaper = _NoPaper;
}
public void addAnswer(String Answer) {
answers.add(Answer);
}
public int get_NoPaper() {
return _NoPaper;
}
public void set_NoPaper(int _NoPaper) {
this._NoPaper = _NoPaper;
}
public int getAnswerStuID() {
return AnswerStuID;
}
public void setAnswerStuID(int answerStuID) {
AnswerStuID = answerStuID;
}
public void printE_A(int num) {//输出第num题的题目和答案,非标准答案
}
public void addSumanswer(int order,Answer An) {
Sumanswer.put(order,An);
}
public int getJudeg(int num) {//获得第num题的对错,num为题目顺序
return Sumanswer.get(num).getMark();
}
public paper getThispaper() {
return thispaper;
}
public HashMap<Integer, Answer> getSumanswer() {
return Sumanswer;
}
public ArrayList<String> getAnswers() {
return answers;
}
public ArrayList<Integer> getMarkSum() {
return markSum;
}
public void addOrder(int i) {
Order.add(i);
}
public ArrayList<Integer> getOrder() {
return Order;
}
public void setThispaper(paper thispaper) {
this.thispaper = thispaper;
}
public void setAnswers() {//将回答存在回答列表中
for (int i = 0;i < Order.size();i ++) {
answers.add(Sumanswer.get(Order.get(i)).getAnswer());
}
}
public void setMarkSum() {
for (int i = 0;i < Order.size();i ++) {
markSum.add(Sumanswer.get(Order.get(i)).getMark());
}
}
}
针对学生,设计了student类。
它有学生号,学生名字,试卷号与其对应答卷组成的HashMap,存试卷号的ArrayList四个属性。只有存取方法。
class student {
private int studentID;
private String name;
private HashMap<Integer,AnswerPaper> AnswerPaperOfStudent = new HashMap<>();//key为答卷的试卷号
private ArrayList
public student(int studentID, String name) {
this.studentID = studentID;
this.name = name;
}
public student() {
}
public int getStudentID() {
return studentID;
}
public void setStudentID(int studentID) {
this.studentID = studentID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void Add_APOS(int key,AnswerPaper An) {
AnswerPaperOfStudent.put(key,An);
}
public void Add_AP_O(int NO) {
AnPaper_Order.add(NO);
Collections.sort(AnPaper_Order);
}
public HashMap<Integer, AnswerPaper> getAnswerPaperOfStudent() {
return AnswerPaperOfStudent;
}
public ArrayList<Integer> getAnPaper_Order() {
return AnPaper_Order;
}
}
针对删除的题目,设计了exerciseBeDeleted类
只有题目编号一个属性。只有存取方法。
class student {
private int studentID;
private String name;
private HashMap<Integer,AnswerPaper> AnswerPaperOfStudent = new HashMap<>();//key为答卷的试卷号
private ArrayList
public student(int studentID, String name) {
this.studentID = studentID;
this.name = name;
}
public student() {
}
public int getStudentID() {
return studentID;
}
public void setStudentID(int studentID) {
this.studentID = studentID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void Add_APOS(int key,AnswerPaper An) {
AnswerPaperOfStudent.put(key,An);
}
public void Add_AP_O(int NO) {
AnPaper_Order.add(NO);
Collections.sort(AnPaper_Order);
}
public HashMap<Integer, AnswerPaper> getAnswerPaperOfStudent() {
return AnswerPaperOfStudent;
}
public ArrayList<Integer> getAnPaper_Order() {
return AnPaper_Order;
}
}
设计了判断输入有效性的类judgevalid。
只有要判断的字符一个属性。除存取方法外有判断解答题输入是否有效的方法public boolean free_exerciseValid(),判断填空题输入是否有效的方法public boolean gap_exerciseValid(),判断选择题输入是否有效的方法public boolean choice_exerciseValid(),判断试卷输入是否有效的方法public boolean paperValid(),判断学生信息输入是否有效的方法public boolean studentValid(),判断答卷信息输入是否有效的方法public boolean answerPaperValid(),判断删除信息是否有效的方法public boolean delExeValid()。
class exerciseBeDeleted {
int delNO;
public exerciseBeDeleted(int delNO) {
this.delNO = delNO;
}
public int getDelNO() {
return delNO;
}
public void setDelNO(int delNO) {
this.delNO = delNO;
}
}
class judgevalid {
private String input;
public judgevalid(String input) {
this.input = input;
}
public String getInput() {
return input;
}
public boolean free_exerciseValid() {
String regex = "^#N:\\d+ #Q:.* #A:.*$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
public boolean gap_exerciseValid() {
String regex = "^#K:\\d+ #Q:.* #A:.*$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
public boolean choice_exerciseValid() {
String regex = "^#Z:\\d+ #Q:.* #A:.*$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
public boolean paperValid() {
String regex = "^#T:\\d+(( \\d+-\\d+)+)$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
public boolean studentValid() {
String regex = "^#X:((\\d+) ((\\w+)-(\\d+))+ (\\w+))";//-(\\\\d+) (\\\\w+)(?:-\\\\d+ \\\\w+)*";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return true;
//return matcher.matches();
}
public boolean answerPaperValid() {
String regex = "^#S:\\d*+ \\d* +(#A:\\d*-[\\S* ]*)*";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
public boolean delExeValid() {
String regex = "#D:N-\\d+$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
return matcher.matches();
}
}
3)设计分析:
1.本次作业大致按照老师给出的建议进行设计。
2.部分类的属性出现的重叠,没有进行精简。如答卷类中每题的答案信息和对错信息设计多余了。
第二次PTA大作业
1)题目要求
7-1 家居强电电路模拟程序-1
分数 75
作者 蔡轲
单位 南昌航空大学
智能家居是在当下家庭中越来越流行的一种配置方案,它通过物联网技术将家中的各种设备(如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等)连接到一起,提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比,智能家居不仅具有传统的居住功能,兼备建筑、网络通信、信息家电、设备自动化,提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。
1、控制设备模拟
本题模拟的控制设备包括:开关、分档调速器、连续调速器。
开关:包括0和1两种状态。
开关有两个引脚,任意一个引脚都可以是输入引脚,而另一个则是输出引脚。开关状态为0时,无论输入电位是多少,输出引脚电位为0。当开关状态为1时,输出引脚电位等于输入电位。
分档调速器
按档位调整,常见的有3档、4档、5档调速器,档位值从0档-2(3/4)档变化。本次迭代模拟4档调速器,每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器
没有固定档位,按位置比例得到档位参数,数值范围在[0.00-1.00]之间,含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚,一个固定的输入(引脚编号为1)、一个输出引脚(引脚编号为2)。当输入电位为0时,输出引脚输出的电位固定为0,不受各类开关调节的影响。
所有控制设备的初始状态/档位为0。
控制设备的输入引脚编号为1,输出引脚编号为2。
2、受控设备模拟
本题模拟的受控设备包括:灯、风扇。两种设备都有两根引脚,通过两根引脚电压的电压差驱动设备工作。
灯有两种工作状态:亮、灭。在亮的状态下,有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态:停止、转动。风扇的转速会因引脚的电位差的不同而有区别。
本次迭代模拟两种灯具。
白炽灯:
亮度在0~200lux(流明)之间。
电位差为0-9V时亮度为0,其他电位差按比例,电位差10V对应50ux,220V对应200lux,其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯:
亮度为180lux。
只有两种状态,电位差为0时,亮度为0,电位差不为0,亮度为180。
本次迭代模拟一种吊扇。
工作电压区间为80V-150V,对应转速区间为80-360转/分钟。80V对应转速为80转/分钟,150V对应转速为360转/分钟,超过150V转速为360转/分钟(本次迭代暂不考虑电压超标的异常情况)。其他电压值与转速成正比,输入输出电位差小于80V时转速为0。
输入信息:
1、设备信息
分别用设备标识符K、F、L、B、R、D分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇。
设备标识用标识符+编号表示,如K1、F3、L2等。
引脚格式:设备标识-引脚编号,例如:K1-1标识编号为1的开关的输入引脚。
三种控制开关的输入引脚编号为1,输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件:
不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入,包含在连接信息中。
2、连接信息
一条连接信息占一行,用[]表示一组连接在一起的设备引脚,引脚与引脚之间用英文空格" "分隔。
格式:"["+引脚号+" "+...+" "+引脚号+"]"
例如:[K1-1 K3-2 D5-1]表示K1的输入引脚,K3的输出引脚,D5的1号引脚连接在一起。
约束条件:
本次迭代不考虑两个输出引脚短接的情况
考虑调速器输出串联到其他控制设备(开关)的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如,K1的输出接到L2的输入,L2的输出再接其他设备属于串联接线。K1的输出接到L2的输出,同时K1的输入接到L2的输入,这种情况属于并联。K1的输出接到L2的输入,K1的输入接到L2的输出,属于反馈接线。
3、控制设备调节信息
开关调节信息格式:
+设备标识K+设备编号,例如:#K2,代表切换K2开关的状态。
分档调速器的调节信息格式:
+设备标识F+设备编号+"+" 代表加一档,例如:#F3+,代表F3输出加一档。
+设备标识F+设备编号+"-" 代表减一档,例如:#F1-,代表F1输出减一档。
连续调速器的调节信息格式:
+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值,例如:#L3:0.6,代表L3输出档位参数0.6。
4、电源接地标识:VCC,电压220V,GND,电压0V。没有接线的引脚默认接地,电压为0V。
输入信息以end为结束标志,忽略end之后的输入信息。
输出信息:
按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。
输出格式:@设备标识+设备编号+":" +设备参数值(控制开关的档位或状态、灯的亮度、风扇的转速,只输出值,不输出单位)
连续调速器的档位信息保留两位小数,即使小数为0,依然显示两位小数.00。
开关状态为0(打开)时显示turned on,状态为1(合上)时显示closed
如:
@K1:turned on
@B1:190
@L1:0.60
本题不考虑输入电压或电压差超过220V的情况。
本题只考虑串联的形式,所以所有测试用例的所有连接信息都只包含两个引脚
本题电路中除了开关可能出现多个,其他电路设备均只出现一次。
电源VCC一定是第一个连接的第一项,接地GND一定是最后一个连接的后一项。
家居电路模拟系列所有题目的默认规则:
1、当计算电压值等数值的过程中,最终结果出现小数时,用截尾规则去掉小数部分,只保留整数部分。为避免精度的误差,所有有可能出现小数的数值用double类型保存并计算,不要作下转型数据类型转换,例如电压、转速、亮度等,只有在最后输出时再把计算结果按截尾规则,舍弃尾数,保留整数输出。
2、所有连接信息按电路从电源到接地的顺序依次输入,不会出现错位的情况。
3、连接信息如果只包含两个引脚,靠电源端的引脚在前,靠接地端的在后。
4、对于调速器,其输入端只会直连VCC,不会接其他设备。整个电路中最多只有一个调速器,且连接在电源上。
家居电路模拟系列1-4题目后续迭代设计:
1、电路结构变化:
迭代1:只有一条线路,所有元件串联
迭代2:线路中包含一个并联电路
迭代3:线路中包含多个串联起来的并联电路
迭代4:并联电路之间可能出现包含关系
电路结构变化示意图见图1。
2、输入信息的变化
串联线路信息:用于记录一段串联电路的元件与连接信息。
例如: #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]
并联线路信息:用于记录一段并联电路所包含的所有串联电路信息。
例如:#M1:[T1 T2 T3]
以上格式仅做参考,格式细节可能会调整,以具体发布的为准。
3、计算方式的变化
迭代1只包含1个受控元件,不用计算电流,之后的电路计算要包含电流、电阻等电路参数。
4、电路元件的变化
每次迭代会增加1-2个新的电路元件。
image.png
图1:电路结构示意图
设计建议:
1、电路设备类:描述所有电路设备的公共特征。
2、受控设备类、控制设备类:对应受控、控制设备
3、串联电路类:一条由多个电路设备构成的串联电路,也看成是一个独立的电路设备
其他类以及类的属性、方法自行设计。
image.png
图2:建议设计类图
输入样例1:
在这里给出一组输入。例如:
[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]
K1
end
输出样例1:
在这里给出相应的输出。例如:
@K1:closed
@D2:360
输入样例2:
在这里给出一组输入。例如:
[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]
K1
K1
end
输出样例2:
在这里给出相应的输出。例如:
@K1:turned on
@D2:0
输入样例3:
在这里给出一组输入。例如:
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
end
输出样例3:
在这里给出相应的输出。例如:
@F1:1
@D2:0
输入样例4:
在这里给出一组输入。例如:
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
F1+
end
输出样例4:
在这里给出相应的输出。例如:
@F1:2
@D2:288
输入样例5:
在这里给出一组输入。例如:
[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]
F1+
F1+
F1+
end
输出样例5:
在这里给出相应的输出。例如:
@F1:3
@D2:360
输入样例6:
在这里给出一组输入。例如:
[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]
L1:1.00
end
输出样例6:
在这里给出相应的输出。例如:
@L1:1.00
@D2:360
输入样例7:
在这里给出一组输入。例如:
[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]
L1:0.68
end
输出样例7:
在这里给出相应的输出。例如:
@L1:0.68
@D2:358
输入样例8:
在这里给出一组输入。例如:
[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]
L1:0.68
end
输出样例8:
在这里给出相应的输出。例如:
@L1:0.68
@B2:149
输入样例9:
在这里给出一组输入。例如:
[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]
L1:1.00
end
输出样例9:
在这里给出相应的输出。例如:
@L1:1.00
@B2:200
输入样例10:
在这里给出一组输入。例如:
[VCC L1-1]
[L1-2 R2-1]
[R2-2 GND]
L1:1.00
end
输出样例10:
在这里给出相应的输出。例如:
@L1:1.00
@R2:180
2)个人设计
针对全部电路设备,设计了Circuit类。
它有两个引脚,名字三个属性。除构造方法与基本的存取方法外,还有展示信息的抽象方法public abstract void show()。
abstract class Circuit { //电路设备
protected int pin1 = 0;//引脚
protected int pin2 = 0;
protected String name;
public int getPin1() {
return pin1;
}
public void setPin1(int pin1) {
this.pin1 = pin1;
}
public int getPin2() {
return pin2;
}
public void setPin2(int pin2) {
this.pin2 = pin2;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void show();
}
针对开关,设计了On_Off类,它为电路设备子类。
它有开关状态一个属性。除构造方法等存取方法外,还有改变开关状态的public void change_On_Off()方法和重写的public void show()方法。
class On_Off extends Circuit {//开关
private int on_off = 0;//0为关1为开
public On_Off() {
}
public int getOn_off() {
return on_off;
}
public void setOn_off(int on_off) {
this.on_off = on_off;
}
public void change_On_Off() {
if (on_off == 0) {
on_off = 1;
} else {
on_off = 0;
}
}
@Override
public void show() {
System.out.printf("@%s:",name);
if (on_off == 0) {
System.out.printf("turned on\n");
} else {
System.out.printf("closed\n");
}
}
}
针对全部调速器,设计了Control类。
它有挡位,实际效果两个属性。除构造方法等存取方法外,还有改变挡位的方法public void change_Gear(String str)。
abstract class Control extends Circuit {//调速器
protected double gear = 0;
protected double effect = 0;
public double getGear() {
return gear;
}
public void setGear(double gear) {
this.gear = gear;
}
public void change_Gear(String str) {
}
@Override
public void show() {
}
public double getEffect() {
return effect;
}
public void setEffect(double effect) {
this.effect = effect;
}
}
针对分档调速器,设计了Step_Control类。它为Control类的子类。
它重写的改变挡位的方法public void change_Gear(String str)。和展示的方法public void show()。
class Step_Control extends Control {//分档调速器
@Override
public void change_Gear(String str) {
if (str.contains("+")) {
if(gear < 3) {
gear++;
effect = gear * 0.3;
}
} else if (str.contains("-")) {
if(gear > 0) {
gear--;
effect = gear * 0.3;
}
}
}
@Override
public void show() {
System.out.printf("@%s:%d\n",name,(int)gear);
}
public double getEffect() {
effect = gear * 0.3;
return effect;
}
}
针对连续调速器,设计了Continue_Control类。它为Control的子类。
它重写了改变挡位的方法public void change_Gear(String str)和展示的方法public void show()
class Continue_Control extends Control{//连续调速器
public void changeGear(double n) {
if(n >= 0 && n <= 1) {
gear = n;
effect = gear;
}
}
@Override
public void change_Gear(String str) {
gear = Double.parseDouble(str);
effect = gear;
}
@Override
public void show() {
System.out.printf("@%s:%.2f\n",name,gear);
}
public double getEffect() {
effect = gear;
return gear;
}
}
针对受控设备,设计了Device类。它为Circuit类的子类。
它有电压一个属性。只有存取方法。
abstract class Device extends Circuit {//受控设备
protected double Vol;//电压
public double getVol() {
return Vol;
}
public void setVol(double vol) {
Vol = vol;
}
}
针对电灯,设计了Light类。它为Device类的子类。
它有亮度一个属性。只有一个获取亮度的抽象方法public abstract double getLum()。
abstract class Light extends Device {//电灯
protected double Lum;//亮度
public abstract double getLum();
}
针对风扇,设计了Fan类。它为Device类的子类。
它有转速一个属性。只有一个获取转速的抽象方法public abstract double getRotate()。
abstract class Fan extends Device {//风扇
protected double rotate;//转速
public abstract double getRotate();
}
针对白炽灯,设计了incandescent_Light类。它为Light类的子类。
它重写了展示方法public void show()和获取亮度的方法public double getLum()。
class incandescent_Light extends Light {//白炽灯
@Override
public void show() {
Lum = getLum();
System.out.printf("@%s:%d",name,(int)Lum);
}
@Override
public double getLum() {
if (Vol >=0 && Vol <= 9) {
Lum = 0;
return Lum;
} else if (Vol >=10 && Vol <=220) {
Lum = (50 + (150.0 / 210) * (Vol - 10));
return Lum;
} else {
return -1;
}
}
}
针对日光灯,设计了fluorescent_Light类。它为Light的子类。
它重写了展示方法public void show()和获取亮度的方法public double getLum()。
class fluorescent_Light extends Light {//日光灯
@Override
public void show() {
Lum = getLum();
System.out.printf("@%s:%d",name,(int)Lum);
}
@Override
public double getLum() {
if (Vol == 0) {
Lum = 0;
return Lum;
} else {
Lum = 180;
return Lum;
}
}
}
针对吊扇,设计了ceiling_Fan类。它是Fan的子类。
它重写了获取转速的方法public double getRotate()和展示的方法public void show()。
class ceiling_Fan extends Fan{//吊扇
@Override
public void show() {
rotate = getRotate();
System.out.printf("@%s:%.0f",name,rotate);
}
@Override
public double getRotate() {
if (Vol >=0 && Vol < 80) {
rotate = 0;
return rotate;
} else if (Vol >= 80 && Vol <= 150) {
rotate = 80 + 280 / 70 * (Vol - 80);
return rotate;
} else {
rotate = 360;
return 360;
}
}
}
针对串联电路,设计了Series_Circuit类。它是Circuit类的子类。
它有一个用于保存电路中全部设备的ArrayList。
class Series_Circuit extends Circuit {//串联电路类
private ArrayList
@Override
public void show() {
}
}
3)设计分析
1.本次作业大致按照老师给出的建议进行设计。
2.串联电路类未使用,而是简单得将设备存在全部电路设备中。导致下次作业需要改动较多内容。
3.在输入存储数据时合理得使用了有关设计模式的知识,根据不同字符串的特点获得不同的数据。有效得避免了代码的重复。
第三次PTA大作业
1)题目要求
7-1 家居强电电路模拟程序-2
分数 100
作者 蔡轲
单位 南昌航空大学
智能家居是在当下家庭中越来越流行的一种配置方案,它通过物联网技术将家中的各种设备(如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等)连接到一起,提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比,智能家居不仅具有传统的居住功能,兼备建筑、网络通信、信息家电、设备自动化,提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。以下题目介绍中加粗的部分为本次迭代在“家居强电电路模拟程序-1”的基础上增加的功能要求。
1、控制设备
本题模拟的控制设备包括:开关、分档调速器、连续调速器。
开关:包括0和1两种状态。
开关有两个引脚,任意一个引脚都可以是输入引脚,而另一个则是输出引脚。开关状态为0时,无论输入电位是多少,输出引脚电位为0。当开关状态为1时,输出引脚电位等于输入电位。
分档调速器
按档位调整,常见的有3档、4档、5档调速器,档位值从0档-2(3/4)档变化。本次迭代模拟4档调速器,每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器
没有固定档位,按位置比例得到档位参数,数值范围在[0.00-1.00]之间,含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚,一个固定的输入(引脚编号为1)、一个输出引脚(引脚编号为2)。当输入电位为0时,输出引脚输出的电位固定为0,不受各类开关调节的影响。
所有控制设备的初始状态/档位为0。
控制设备的输入引脚编号为1,输出引脚编号为2。
所有开关的电阻为 0。
2、受控设备
本题模拟的受控设备包括:灯、风扇。两种设备都有两根引脚,通过两根引脚电压的电压差驱动设备工作。
灯有两种工作状态:亮、灭。在亮的状态下,有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态:停止、转动。风扇的转速会因引脚间电位差的不同而有区别。
本次迭代模拟两种灯具。
白炽灯:
亮度在0~200lux(流明)之间。
电位差为0-9V时亮度为0,其他电位差按比例,电位差10V对应50ux,220V对应200lux,其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯:
亮度为180lux。
只有两种状态,电位差为0时,亮度为0,电位差不为0,亮度为180。
本次迭代模拟一种吊扇。
工作电压区间为80V-150V,对应转速区间为80-360转/分钟。80V对应转速为80转/分钟,150V对应转速为360转/分钟,超过150V转速为360转/分钟(本次迭代暂不考虑电压超标的异常情况)。其他电压值与转速成正比,输入输出电位差小于80V时转速为0。
本次迭代模拟一种落地扇。
工作电压区间为 [80V,150V],对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分 钟,[100-120)V 区间对应转速为 160 转/分钟,[120-140)V 区间对应转速为 260 转/分钟,超过 140V 转速 为 360 转/分钟(本次迭代暂不考虑电压超标的异常情况)输入信息:
本次迭代考虑电阻:白炽灯的电阻为 10,日光灯的电阻为 5,吊扇的电阻为 20,落 地扇的电阻为 20
3、输入信息
1)输入设备信息
分别用设备标识符K、F、L、B、R、D、A分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇。
设备标识用标识符+编号表示,如K1、F3、L2等。
引脚格式:设备标识-引脚编号,例如:K1-1标识编号为1的开关的输入引脚。
三种控制开关的输入引脚编号为1,输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件:
不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入,包含在连接信息中。
2)输入连接信息
一条连接信息占一行,用[]表示一组连接在一起的设备引脚,引脚与引脚之间用英文空格" "分隔。
格式:"["+引脚号+" "+...+" "+引脚号+"]"
例如:[K1-1 K3-2 D5-1]表示K1的输入引脚,K3的输出引脚,D5的1号引脚连接在一起。
约束条件:
不考虑调速器串联到其他调速器的情况。
不考虑调速器串联到其他调速器的情况。
考虑各类设备的并联接入。例如,K1 的输出接到 L2 的输入,L2 的输出再接其他设备属于串联接线。K1 的输出接到 L2 的输出,同时 K1 的输入接到 L2 的输入,这种情况属于并联。
本次迭代的连接信息不单独输入,包含在线路信息中。
3)输入控制设备调节信息
开关调节信息格式:
+设备标识K+设备编号,例如:#K2,代表切换K2开关的状态。
分档调速器的调节信息格式:
+设备标识F+设备编号+"+" 代表加一档,例如:#F3+,代表F3输出加一档。
+设备标识F+设备编号+"-" 代表减一档,例如:#F1-,代表F1输出减一档。
连续调速器的调节信息格式:
+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值,例如:#L3:0.6,代表L3输出档位参数0.6。
4)电源接地标识:
VCC,电压220V,GND,电压0V。没有接线的引脚默认接地,电压为0V。
5)输入串联电路信息
一条串联电路占一行,串联电路由按从靠电源端到接地端顺序依次输入的 n 个连接 信息组成,连接信息之间用英文空格" "分隔。
串联电路信息格式:
"#T"+电路编号+":"+连接信息+" "+连接信息+...+" "+连接信息
例如:#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一个串联电路的第一个引脚是 IN,代表起始端,靠电源。最后一个引脚是 OUT,代表结尾端, 靠接地。
约束条件:
不同的串联电路信息编号不同。
输入的最后一条电路信息必定是总电路信息,总电路信息的起始引脚是 VCC,结束引脚是 GND。
连接信息中的引脚可能是一条串联或并联电路的 IN 或者 OUT。例如:
T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]
T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]
6)输入并联电路信息
一条并联电路占一行,并联电路由其包含的几条串联电路组成,串联电路标识之间用英文空格" "分隔。
格式:
"#M"+电路编号+":"+”[”+串联电路信息+" "+....+" "+串联电路信息+”]”
例如:#M1:[T1 T2 T3]
该例声明了一个并联电路,由 T1、T2、T3 三条串联电路并联而成,三条串联电路的 IN 短 接在一起构成 M1 的 IN,三条串联电路的 OUT 短接在一起构成 M1 的 OUT。
约束条件:
本次迭代不考虑并联电路中包含并联电路的情况,也不考虑多个并联电路串联的情况。
本题不考虑输入电压或电压差超过220V的情况。
输入信息以end为结束标志,忽略end之后的输入信息。
本题中的并联信息所包含的串联电路的信息都在并联信息之前输入,不考虑乱序输入的情况。
电路中的短路如果不会在电路中产生无穷大的电流烧坏电路,都是合理情况,在本题测试点的考虑范围之内。
本题不考虑一条串联电路中包含其他串联电路的情况。例如:
T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]
本例中T1\T2两条串联电路实际是T3的一个部分,本题不考虑这种类型的输入,而是当将T1\T2的所有连接信息直接包含在T3中定义。
下次迭代中需要考虑这种类型的输入。
4、输出信息:
按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。
输出格式:@设备标识+设备编号+":" +设备参数值(控制开关的档位或状态、灯的亮度、风扇的转速,只输出值,不输出单位)
连续调速器的档位信息保留两位小数,即使小数为0,依然显示两位小数.00。
开关状态为0(打开)时显示turned on,状态为1(合上)时显示closed
如:
@K1:turned on
@B1:190
@L1:0.60
5、家居电路模拟系列所有题目的默认规则:
1)当计算电压值等数值的过程中,最终结果出现小数时,用截尾规则去掉小数部分,只保留整数部分。为避免精度的误差,所有有可能出现小数的数值用double类型保存并计算,不要作下转型数据类型转换,例如电压、转速、亮度等,只有在最后输出时再把计算结果按截尾规则,舍弃尾数,保留整数输出。
2)所有连接信息按电路从电源到接地的顺序依次输入,不会出现错位的情况。电源VCC一定是第一个连接的第一项,接地GND一定是最后一个连接的后一项。
3)连接信息如果只包含两个引脚,靠电源端的引脚在前,靠接地端的在后。
4)调速器的输入端只会直连VCC,不会接其他设备。整个电路最多只有连接在电源上的一个调速器,且不包含在并联单路中。
6、家居电路模拟系列1-4题目后续迭代设计:
1)电路结构变化:
迭代1:只有一条线路,所有元件串联
迭代2:线路中包含一个并联电路
迭代3:线路中包含多个串联起来的并联电路
迭代4:并联电路之间可能出现包含关系
电路结构变化示意图见图1。
2)计算方式的变化
迭代1只包含1个受控元件,不用计算电流,之后的电路计算要包含电流、电阻等电路参数。
3)电路元件的变化
每次迭代会增加1-2个新的电路元件。
image.png
图1:电路结构示意图
设计建议:
1、电路设备类:描述所有电路设备的公共特征。
2、受控设备类、控制设备类:对应受控、控制设备
3、串联电路类:一条由多个电路设备构成的串联电路,也看成是一个独立的电路设备
4、并联电路类:继承电路设备类,也看成是一个独立的电路设备
其他类以及类的属性、方法自行设计。
image.png
图2:建议设计类图
输入格式:
请在这里写输入格式。例如:输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
请在这里描述输出格式。例如:对每一组输入,在一行中输出A+B的值。
输入样例1:
在这里给出一组输入。例如:
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
end
输出样例1:
在这里给出相应的输出。例如:
@K1:closed
@K2:turned on
@L1:0.00
@D1:0
@D2:0
@D3:0
输入样例2:
在这里给出一组输入。例如:
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
L1:1.00
end
输出样例2:
在这里给出相应的输出。例如:
@K1:closed
@K2:turned on
@L1:1.00
@D1:0
@D2:200
@D3:200
输入样例3:
在这里给出一组输入。例如:
T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]
M1:[T1 T2]
T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]
K1
K2
L1:1.00
end
输出样例3:
在这里给出相应的输出。例如:
@K1:closed
@K2:closed
@L1:1.00
@D1:0
@D2:0
@D3:346
2)个人设计
在电路设备中新增电阻,电压两个属性。
abstract class Circuit { //电路设备
protected int pin1 = 0;//引脚
protected int pin2 = 0;
protected String name;
protected double resistance;//电阻
protected double Vol;
public int getPin1() {
return pin1;
}
public void setPin1(int pin1) {
this.pin1 = pin1;
}
public int getPin2() {
return pin2;
}
public void setPin2(int pin2) {
this.pin2 = pin2;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void show();
public double getResistance() {
return resistance;
}
public void setResistance(double resistance) {
this.resistance = resistance;
}
public double getVol() {
return Vol;
}
public void setVol(double vol) {
Vol = vol;
}
}
为更好分辩,将分档调速器重命名为F_Control,连续调速器重命名为L_Control,白炽灯重命名为B_Light,日光灯重命名为R_Light,串联电路重命名为T_Circuit,吊扇重命名为D_Fan。
由于电路设备中存在电压属性,自然要去除受控设备中的电压属性。
abstract class Device extends Circuit {//受控设备
public double getVol() {
return Vol;
}
public void setVol(double vol) {
Vol = vol;
}
}
各电路设备新增电阻属性和获得编号的方法。
class B_Light extends Light {//白炽灯
public B_Light() {
resistance = 10;
}
@Override
public void show() {
Lum = getLum();
System.out.printf("@%s:%d\n",name,(int)Lum);
}
@Override
public double getLum() {
if (Vol >=0 && Vol <= 9) {
Lum = 0;
return Lum;
} else if (Vol >=10 && Vol <=220) {
Lum = (50 + (150.0 / 210) * (Vol - 10));
return Lum;
} else {
return -1;
}
}
public int getNO() {
return Integer.parseInt(name.replace("B",""));
}
}
class R_Light extends Light {//日光灯
public R_Light() {
resistance = 5;
}
@Override
public void show() {
Lum = getLum();
System.out.printf("@%s:%d\n",name,(int)Lum);
}
@Override
public double getLum() {
if (Vol == 0) {
Lum = 0;
return Lum;
} else {
Lum = 180;
return Lum;
}
}
public int getNO() {
return Integer.parseInt(name.replace("R",""));
}
}
class D_Fan extends Fan{//吊扇
public D_Fan() {
resistance = 20;
}
@Override
public void show() {
rotate = getRotate();
System.out.printf("@%s:%d\n",name,(int)(rotate));
}
@Override
public double getRotate() {
if (Vol >=0 && Vol < 80) {
rotate = 0;
} else if (Vol >= 80 && Vol <= 150) {
rotate = 80 + 280 / 70 * (Vol - 80);
} else {
rotate = 360;
}
return rotate;
}
public int getNO() {
return Integer.parseInt(name.replace("D",""));
}
}
新增落地扇类。
class A_Fan extends Fan {//落地扇
public A_Fan() {
resistance = 20;
}
@Override
public void show() {
rotate = getRotate();
System.out.printf("@%s:%d\n",name,(int)rotate);
}
@Override
public double getRotate() {
if (Vol >=80 && Vol <=99) {
rotate = 80;
} else if (Vol >= 100 && Vol <=119) {
rotate = 160;
} else if (Vol >= 120 && Vol <=139) {
rotate = 260;
} else if (Vol >= 140 && Vol <=150) {
rotate = 360;
} else {
rotate = 0;
}
return rotate;
}
public int getNO() {
return Integer.parseInt(name.replace("A",""));
}
}
新增电路类Circuit_Line。它为Circuit的子类。
它有记录电路设备的ArrayList一个属性和判断电路是否通路的方法。
class Circuit_Line extends Circuit{//串联父类
protected ArrayList
public ArrayList
return CircuitList;
}
@Override
public void show() {
}
public int Access() {
for (int i = 0;i < CircuitList.size();i ++) {
if (CircuitList.get(i) instanceof On_Off) {
if (((On_Off) CircuitList.get(i)).getOn_off() == 0) {
return -1;
}
}
}
return 0;
}
}
串联电路类更改为电路类的子类,新增分配电压的方法public void Cal_V()和获得总电阻的方法public double getResistance()。
class T_Circuit extends Circuit_Line {//串联电路类
@Override
public void show() {
}
public void addCircuit(Circuit c) {
CircuitList.add(c);
}
@Override
public double getResistance() {
double r = 0;
for (int i = 0; i < CircuitList.size(); i++) {
r = r + CircuitList.get(i).getResistance();
}
resistance = r;
return resistance;
}
public void Cal_V() {
if (this.Access() != -1) {
double r = 0;//总电阻
for (int i = 0; i < CircuitList.size(); i++) {
r = r + CircuitList.get(i).getResistance();
}
for (int i = 0; i < CircuitList.size(); i++) {
double V = Vol / r * CircuitList.get(i).getResistance();
CircuitList.get(i).setVol(V);
}
} else {
for (int i = 0;i < CircuitList.size();i ++) {
CircuitList.get(i).setVol(0);
}
}
}
}
新增并联电路类,它为Circuit_Line的子类。
它属性和方法与串联电路类相似。
class M_Circuit extends Circuit_Line {
@Override
public void show() {
}
public void addCircuit(Circuit c) {
CircuitList.add(c);
}
@Override
public int Access() {//并联是否正常
int count = 0;
for (int i = 0 ;i < CircuitList.size();i ++) {
if (((T_Circuit)CircuitList.get(i)).Access() != -1) {
count++;
}
}
if (count == 0) {
return -1;//断路
} else if (count == CircuitList.size()) {
return 0;//正常并联
} else {
return 1;//单连接
}
}
@Override
public double getResistance() {
if (this.Access() != -1) {
double r = 0;
for (int i = 0; i < CircuitList.size(); i++) {
r = 1.0 / CircuitList.get(i).getResistance() + r;
}
resistance = 1.0 / r;
} else {
for (int i = 0;i < CircuitList.size();i++) {
if (((T_Circuit)CircuitList.get(i)).Access() != -1) {
resistance = CircuitList.get(i).getResistance();
}
}
}
return resistance;
}
public void Cal_V() {
if (this.Access() != -1) {
for (int i = 0; i < CircuitList.size(); i++) {
CircuitList.get(i).setVol(Vol);
}
} else {
for (int i = 0;i < CircuitList.size();i ++) {
if (((T_Circuit)CircuitList.get(i)).Access() != -1) {
CircuitList.get(i).setVol(Vol);
}
}
}
}
}
新增总电路类,它为Circuit_Line的子类。
它只有简单的存取方法。
class Line extends Circuit_Line{
public void addCircuit(Circuit c) {
for (int i = 0;i < CircuitList.size();i ++) {
for (int j = 0; j < ((Circuit_Line) c).getCircuitList().size(); j ++) {
if (CircuitList.size() >= 1) {
if (CircuitList.get(i).equals(((Circuit_Line) c).getCircuitList().get(j))) {
CircuitList.remove(i);
}
}
}
}
CircuitList.add(c);
}
public void Cal_V(double effect) {//计算电压
double r = 0;//总电阻
for (int i = 0 ;i < CircuitList.size();i ++) {
r = r + CircuitList.get(i).getResistance();
}
for (int i = 0;i < CircuitList.size();i ++) {
double V = effect * 220 / r * CircuitList.get(i).getResistance();
CircuitList.get(i).setVol(V);
}
}
public ArrayList<Circuit> getCircuitList() {
return CircuitList;
}
}
3)设计分析
1.在上次作业基础上进行了较大更改,结构更合理的同时也更好分辨。
2.Main类中存有大量数据,未合理使用设计模式进行处理。
踩坑心得
1.第二次作业依旧没有对结构进行很好的设计。未意识到串并联电路也可以视作单个用电器。日后需要注意。
2.应该合理得使用设计模式。三次大作业的数据都直接写在Main中,过于冗长。
改进建议
1.新建数据类用于存储数据。以下内容不要写在Main里。
public static ArrayList<Circuit> Sum_Circuit = new ArrayList<>();//电路设备(全部的设备)
public static HashMap<String,Circuit> Sum_CircuitMap = new HashMap<>();//电路设备
public static ArrayList<T_Circuit> t_CircuitList = new ArrayList<>();//串联电路
public static HashMap<String,Circuit> Series_CircuitMap = new HashMap<>();
public static ArrayList<M_Circuit> m_CircuitList = new ArrayList<>();//并联电路
public static HashMap<String,Circuit> Multiple_CircuitMap = new HashMap<>();
public static HashMap<Integer, On_Off> On_OffMap = new HashMap<>();//开关
public static ArrayList<On_Off> On_OffList = new ArrayList<>();//开关
public static Control control = null;//控制设备(调速器)
public static ArrayList<Device> DeviceList = new ArrayList<>();//受控设备(用电器)
public static HashMap<String,Device> DeviceMap = new HashMap<>();//受控设备
public static HashMap<Integer, B_Light> B_LightMap = new HashMap<>();//白炽灯
public static HashMap<Integer,R_Light> R_LightMap = new HashMap<>();//日光灯
public static HashMap<Integer,D_Fan> D_FanMap = new HashMap<>();//吊扇
public static HashMap<Integer,A_Fan> A_FanMap = new HashMap<>();//落地扇
public static ArrayList<B_Light> B_LightList = new ArrayList<>();
public static ArrayList<R_Light> R_LightList = new ArrayList<>();
public static ArrayList<D_Fan> D_FanList = new ArrayList<>();
public static ArrayList<A_Fan> A_FanList = new ArrayList<>();
public static Line Line_Circuit = new Line();
2.以下部分可以写成方法
while (!Str.equals("end")) {
//串联电路
if (Str.contains("#T")) {
String parts[] = Str.split("\] \[| |:\[");
String name = parts[0].replace("#","");
T_Circuit s_c = new T_Circuit();
s_c.setName(name);
for (int i = 2;i < parts.length - 1;i = i + 2) {
if (parts[i].contains("M")) {
String part[] = parts[i].split("-");
s_c.addCircuit(Multiple_CircuitMap.get(part[0]));
} else if (parts[i].contains("T")) {
String part[] = parts[i].split("-");
s_c.addCircuit(Series_CircuitMap.get(part[0]));
} else if (!parts[i].contains("T") || parts[i].contains("M")) {
Save(parts[i], s_c);
}
}
t_CircuitList.add(s_c);
Series_CircuitMap.put(name,s_c);
Line_Circuit.addCircuit(s_c);
//并联电路
} else if (Str.contains("#M")) {
String parts[] = Str.split("\\[|\\]| |:");
String name = parts[0].replace("#","");
M_Circuit m_c = new M_Circuit();
m_c.setName(name);
for (int i = 2;i < parts.length;i ++) {
m_c.addCircuit(Series_CircuitMap.get(parts[i]));
}
m_CircuitList.add(m_c);
Multiple_CircuitMap.put(name,m_c);
Line_Circuit.addCircuit(m_c);
//控制开关
} else if (Str.contains("#K")) {
int NO = Integer.parseInt(Str.replace("#K",""));
String name = Str.replace("#","");
On_OffMap.get(NO).change_On_Off();
//控制分档调速器
} else if (Str.contains("#F")) {
String name = Str.replace("#","").replace("+","");
control.change_Gear(Str);
//控制连续调速器
} else if (Str.contains("#L")) {
String parts[] = Str.split(":");
String name = parts[0].replace("#","");
control.change_Gear(parts[1]);
}
Str = sc.nextLine();
}