OOP4-6次作业
OOP4-6次作业
一.前言：
1.第四次PTA:
①题目理解：
延续前面的四次PTA，只不过在此基础上进行更全面的处理，新增了其他的一些点。例如增加了多选题，的输入方式，这样，也就增加了多选题的输出方式。增加了一些填空题，对其部分正确的判断变成了一个难点，也增加了其输出的难度和种类。
②知识点：
1·正则表达式去匹配一个字符串，如何去分组获得其内容；
2·Arroys.copyOf()函数的使用，获取下一次的时候应当在new一个对象，否则会将部分数据覆盖，或者其先扩增一个单位在进行复制；
3·trim（）函数的使用
4·去除匹配字符串数组的的null
5·相关的逻辑
6·如何去重写一个函数toString（）
③题量：
正常；
④难度：
正常；
2.第五次PTA:
①题目理解：
第五次PTA，是家居强电路模拟装置程序，通过电路的开闭，和各种用电其，和电路控制设备，会产生多种情况，和不同的输出内容和方式会将题目变得复杂许多，但是按要求实现即可。
②知识点：
1.抽象类的如何使用。
2.接口的如何使用。
3.正则表达式去匹配一个字符串，如何去分组获得其内容；
4.Arroys.copyOf()函数的使用，获取下一次的时候应当在new一个对象，否则会将部分数据覆盖，或者其先扩增一个单位在进行复制；
③题量：
正常；
④难度：
正常；
3.第六次PTA:
①题目理解：
增加了串联和并联电路，这样就存在了串联电路短路的情况，同时也增加了题目的难度。并且此次增加了电压和电阻的加入，这样如何计算电阻分配电压成为一个难题，如何用电压去分配成了一个难题。
②知识点：
1.正则表达式去匹配一个字符串，如何去分组获得其内容；
2.Arroys.copyOf()函数的使用，获取下一次的时候应当在new一个对象，否则会将部分数据覆盖，或者其先扩增一个单位在进行复制；
3.逻辑关系中的联系。
4.他的输出是按照从小到大的一定顺序进行排序的。
③题量：
正常；
④难度：
正常；
二.内容:
1.第四次PTA：
①题目简介：
- 程序输入信息分五种，信息可能会打乱顺序混合输入。解释：这就要求我们要根据#前面的符号进行判断。
- 试卷信息为独 行输入，一行为一张试卷，多张卷可分多行输入数据。解释：存在多张试卷的情况，这就要循环找到这是哪几张试卷。
- 答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。解释：这就要求我们根据学号，找到试卷好，根据试卷号，找到标准答案，再根据试卷号的题目判断判断正确与否，和算其得分。
- 还存在删除题目信息的输出信息提示，例如：”the question 2 invalid~0”。还有试卷总分的警示。
②内容实现：
1.对于//#S:1 20201103 #A:1-5 #A:2-4这样的情况的时候；
if(a.charAt(1)=='S'){
String[] s_s=null;
//#S:1 20201103 #A:1-5 #A:2-4
//if () 这里还需要排除，#A:#A:这种示例 [\u4e00-\u9fa5A-Z0-9\s]
String pattern5="#S:\\d+\\s+\\d+\\s+(\\s*#A:\\s*\\d+\\s*-\\s*[\\u4e00-\\u9fa5A-Z0-9\\s]*\\s*)*$";
Pattern p5 = Pattern.compile(pattern5);
Matcher m5 = p5.matcher(a);
- 他这里面有对于数字的匹配[\u4e00-\u9fa5A-Z0-9\s]这样的情况；
- 这里面可能还会存在多个空格，至少有一个，而且#A的前面一定是要有空格的所以应当先写个\\s+的判断，而且这还要重复多次判断，这就要在整个需要重复的片段加*；
2.对于/#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴这种填空题。
if(a.charAt(1) == 'K'){
//填空题，就是说我的类还要再改
//#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
String pattern1 = "#K:(\\s*[1-9]\\d*\\s*)\\s+#Q:(.*)\\s+#A:(.*)";
Pattern p1 = Pattern.compile(pattern1);
Matcher m2 = p1.matcher(a);
- 你不仅要判断他是否正确，还要判断他是否半对，和错误的情况
- 这个正则表达式就巧妙的用.*去匹配了所有的#Q和#A中的内容
3.重要函数的实现：
1·通过int sccz=0；的这个标记来实现如果未找到这个试卷，就输出不存在。
for (int i = 0; i < answerpaper.length - 1; i++) { //#S:1 20201103 #A:1-5 #A:2-4 answerpaper
int sccz = 0;//这个是用来判断是否存在这个试卷
for (int k = 0; k < answerfens.length - 1; k++) { //#T:1 1-5
if (answerfens[k].numberPaper.equals(answerpaper[i].textNumber)) {
if (sccz == 0) {
System.out.println("The test paper number does not exist");
}
}
}
}
2·我们如果存在试卷则去找对应的学生，写的试卷答案，然后我们用flag=0；去标记是否找到
sccz = 1;
int flag = 0;
//
int a[] = new int[1];
int numm = 0;
int gg = 0;
int sum = 0;
//
for (int l = 0; l < student.studentNumber.length; l++) {
if (answerpaper[i].studentNumber.equals(student.studentNumber[l])) {
flag = 1;
3·接着我们要判断是否这个答案是否是被删除的，用flag2=0；来标记。顺便去输出这个题目是否是被删除的
for (int p = 0; p < answerfens[k].number.length; p++) {
int flag3 = 0;//每次循环都要赋值为零
for (int q = 0; q < answerpaper[i].titleNumber.length; q++) {
if (answerpaper[i].titleNumber[q].equals(String.valueOf(p + 1))) {
flag3 = 1;
//去判断这个题目是否被删
int flag2 = 0;
if (deleteNumber != null) {
for (int r = 0; r < deleteNumber.titlenumber.length; r++) {
if (deleteNumber.titlenumber[r].equals(answerfens[k].number[p])) {
flag2 = 1;
System.out.println("the question " + answerfens[k].number[p] + " invalid~0");
//判断得分的
a[numm] = 0;
a = Arrays.copyOf(a, a.length + 1);
numm++;
}
}
}
4·接着我们找到这个题目，且不是被删除的，我们就分三种情况，普通的单选题，填空题，多选题，然后我们再去对应的类的数组中去找是否存在这样的题目
一.单选
for (int u = 0; u < pttitles.length - 1; u++) {
if (answerfens[k].number[p].equals(pttitles[u].number)) {
flag4 = 1;
if (answerpaper[i].titleAnswer[q].equals(pttitles[u].pt_standardAnswer)) {
System.out.println(pttitles[u].content + "~" + answerpaper[i].titleAnswer[q] + "~true");
a[numm] = Integer.valueOf(answerfens[k].score[p]);
a = Arrays.copyOf(a, a.length + 1);
numm++;
} else {
System.out.println(pttitles[u].content + "~" + answerpaper[i].titleAnswer[q] + "~false");
a[numm] = 0;
a = Arrays.copyOf(a, a.length + 1);
numm++;
}
}
}
二.填空题
for (int z = 0; z < tktitles.length - 1; z++) {
if (answerfens[k].number[p].equals(tktitles[z].number)) {
flag4 = 1;
//这里是找到题号
int ccd = tkpd(tktitles[z].tk_standardAnswer, answerpaper[i].titleAnswer[q]);
if (ccd == 1) {
System.out.println(tktitles[z].content + "~" + answerpaper[i].titleAnswer[q] + "~true");
//判断分数
a[numm] = Integer.valueOf(answerfens[k].score[p]);
a = Arrays.copyOf(a, a.length + 1);
numm++;
} else if (ccd == 0) {
System.out.println(tktitles[z].content + "~" + answerpaper[i].titleAnswer[q] + "~partially correct");
//判断分数
a[numm] = (int) (Integer.valueOf(answerfens[k].score[p]) * 0.5);
a = Arrays.copyOf(a, a.length + 1);
numm++;
} else if (ccd == -1) {
System.out.println(tktitles[z].content + "~" + answerpaper[i].titleAnswer[q] + "~false");
//判断分数
a[numm] = 0;
a = Arrays.copyOf(a, a.length + 1);
numm++;
}
}
}
三.多选题
for (int w = 0; w < dxtitles.length - 1; w++) {
if (answerfens[k].number[p].equals(dxtitles[w].number)) {
flag4 = 1;//标记说明有这个试卷
int ccd2 = dxpd(dxtitles[w].dx_standardAnswer, answerpaper[i].titleAnswer[q]);
if (ccd2 == 1) {
System.out.println(dxtitles[w].content + "~" + answerpaper[i].titleAnswer[q] + "~true");
//判断分数，正确得全分
a[numm] = Integer.valueOf(answerfens[k].score[p]);
a = Arrays.copyOf(a, a.length + 1);
numm++;
} else if (ccd2 == 0) {
System.out.println(dxtitles[w].content + "~" + answerpaper[i].titleAnswer[q] + "~partially correct");
//判断分数，半对就得一半分
a[numm] = (int) (Integer.valueOf(answerfens[k].score[p]) * 0.5);
a = Arrays.copyOf(a, a.length + 1);
numm++;
} else if (ccd2 == -1) {
System.out.println(dxtitles[w].content + "~" + answerpaper[i].titleAnswer[q] + "~false");
//判断分数，全错就得零分
a[numm] = 0;
a = Arrays.copyOf(a, a.length + 1);
numm++;
}
}
}
③踩坑心得：
-
一开始我都没注意到这个点就是必须有一个空格，然后存在多个空格然后可以去除空格，我们可以在输入的时候就把空格全去掉。
-
if(Integer.parseInt(answerPapers[k].studentNumber)== Integer.parseInt(answerPapers[k+1].studentNumber)){ if(Integer.parseInt(answerPapers[k].textNumber)> Integer.parseInt(answerPapers[k+1].textNumber)){ AnswerPaper temp2=answerPapers[k]; answerPapers[k]=answerPapers[k+1]; answerPapers[k+1]=temp2; } }我们存进去的名字是String的转成int 用Integer.parseInt()函数，一开始直接比了然后报错，找不到，之后看了保存的是Stirng。
④改进建议：
判断好其中的逻辑关系，然后注意他的测试点过的条件，然后不然有点太难找了。
2.第五次PTA：
①题目简介：
控制设备模拟：开关，分档调速器，连续调速器
受控设备模拟：灯，电风扇
本次迭代只存在串联的情况，然后并且他并没有电压和电阻的模拟，所以只需要通过开关来判断是否是通路，当然我们也可已没有开关，这就默认是通路。
②内容实现：
一.声明受控设备类，和控制设备类，五种电器去继承他，我们这一次只有一个串联电路然后我们在电路设备类中进行判断
二.接受对应控制设备的状态更改条件，然后可以对相应控制设备进行更改
if(a.charAt(1)=='K'){
String ggg = String.valueOf(a.charAt(2));
for(int i=0;i<deviceControlings.length-1;i++){
if(deviceControlings[i] instanceof Switch){
if(((Switch) deviceControlings[i]).name==Integer.parseInt(ggg)){
((Switch) deviceControlings[i]).setState();
}
}
}
// switch1.setState();
}else if(a.charAt(1)=='F'){
if(a.charAt(a.length()-1)=='+'){
governorBinning1.setGrears("+");
}else if(a.charAt(a.length()-1)=='-'){
governorBinning1.setGrears("-");
}
}else if(a.charAt(1)=='L'){
String[] get2=a.split(":");
governorContinuous1.setMagnification(Double.parseDouble(get2[1]));
}
}
三.当我们将所有的输入都输入完成，然后我们在电路设备中进行判断，也是我们的主要函数。
1.判断我们是否存在开关断开
int number2=0;
for(int i=0;i<s.length-1;i++){
s[i].show(); //输出按开关的名称编号
if(s[i].state==1){// 判断存在了开关闭合的情况
number2++;
}
}
if(number2!=number){ //存在了开关断开的情况
for (int k = 0; k < deviceControlleds.length-1; k++) {
deviceControlleds[k].setPd(0);
deviceControlleds[k].show();
}
2.然后去输出获得对应的电压赋值
if(number2==number){
for (int i = 0; i < deviceControlings.length; i++) {
if(deviceControlings[i] instanceof governorBinning){
((governorBinning) deviceControlings[i]).show();
((governorBinning) deviceControlings[i]).setV(220);
for(int k=0;k<deviceControlleds.length-1;k++){
deviceControlleds[k].setPd(((governorBinning) deviceControlings[i]).getV());
deviceControlleds[k].show();
}
break;
}
else if(deviceControlings[i] instanceof governorContinuous) {
((governorContinuous) deviceControlings[i]).show();
((governorContinuous) deviceControlings[i]).setV(220);
for (int k = 0; k < deviceControlleds.length - 1; k++) {
deviceControlleds[k].setPd(((governorContinuous) deviceControlings[i]).getV());
deviceControlleds[k].show();
}
break;
}else if(deviceControlings[i] instanceof Switch){
for (int k = 0; k < deviceControlleds.length - 1; k++) {
deviceControlleds[k].setPd(220);
deviceControlleds[k].show();
}
break;
}
else {
for (int k = 0; k < deviceControlleds.length - 1; k++) {
deviceControlleds[k].setPd(220);
deviceControlleds[k].show();
}
}
}
}
③踩坑心得：
多种条件去进行排序输出，我们可以转换成找到一类设备，然后再按照条件去排序。
④改进建议：
题目要求说我们要按照设备的顺序，并且同种设备需要根据设备名称的大小进行排序
Switch[] s=new Switch[1];
//看排序，把Switch放到另一个数组Switch数组里，然后进行冒泡排序
int num_s=0;
int number=0; //保存着有多少个开关
for (int i = 0; i < deviceControlings.length; i++) {
if (deviceControlings[i] instanceof Switch) {
number++;
s[num_s]=(Switch) deviceControlings[i];
s= Arrays.copyOf(s,s.length+1);
num_s++;
}
}
for(int i=0;i<s.length-1-1;i++){
for(int k=0;k<s.length-i-1-1;k++){
if (s[k].name>s[k+1].name){
Switch temp=s[k];
s[k]=s[k+1];
s[k+1]=temp;
}
}
}
int number2 = 0;
for (int i = 0; i < s.length - 1; i++) {
s[i].show(); //输出按开关的名称编号
if (s[i].state == 1) {// 判断存在了开关闭合的情况
number2++;
}
}
if (number2 != number) { //存在了开关断开的情况
for (int k = 0; k < deviceControlleds.length - 1; k++) {
deviceControlleds[k].setPd(0);
deviceControlleds[k].show();
}
3.第六次PTA：
①题目简介：
相较上一次，多了一种吊扇为落地扇，并且灯具多了白炽灯和日光灯
并且增加了并联的设备但是并联的线路在这里只有一条
电路计算要包含电流、电阻等电路参数。
但是不用计算引脚的位置。
②内容实现：
1·重新写了一个排序针对所有的设备，通过instanceof的函数把找到的同类设备放入一个新的数组中然后排序去输出，然后同理可得复制代码。
public void show(){
//按照先排序
Switch[] s=new Switch[1];
//看排序，把Switch放到另一个数组Switch数组里，然后进行冒泡排序
int num_s=0;
for (int i = 0; i < deviceControlings.length-1; i++) {
if (deviceControlings[i] instanceof Switch) {
s[num_s]=(Switch) deviceControlings[i];
s= Arrays.copyOf(s,s.length+1);
num_s++;
}
}
for(int i=0;i<s.length-1-1;i++){
for(int k=0;k<s.length-i-1-1;k++){
if (s[k].name>s[k+1].name){
Switch temp=s[k];
s[k]=s[k+1];
s[k+1]=temp;
}
}
}
for(int i=0;i<s.length-1;i++){
s[i].show();
}
//同理
governorBinning[] gB=new governorBinning[1];
int num_gB=0;
for (int i = 0; i < deviceControlings.length-1; i++) {
if (deviceControlings[i] instanceof governorBinning) {
gB[num_gB]=(governorBinning) deviceControlings[i];
gB= Arrays.copyOf(gB,gB.length+1);
num_gB++;
}
}
for(int i=0;i<gB.length-1-1;i++){
for(int k=0;k<gB.length-i-1-1;k++){
if (gB[k].name>gB[k+1].name){
governorBinning temp=gB[k];
gB[k]=gB[k+1];
gB[k+1]=temp;
}
}
}
for(int i=0;i<gB.length-1;i++){
gB[i].show();
}
//同理
governorContinuous[] gC=new governorContinuous[1];
int num_gC=0;
for (int i = 0; i < deviceControlings.length-1; i++) {
if (deviceControlings[i] instanceof governorContinuous) {
gC[num_gC]=(governorContinuous) deviceControlings[i];
gC= Arrays.copyOf(gC,gC.length+1);
num_gC++;
}
}
for(int i=0;i<gC.length-1-1;i++){
for(int k=0;k<gC.length-i-1-1;k++){
if (gC[k].name>gC[k+1].name){
governorContinuous temp=gC[k];
gC[k]=gC[k+1];
gC[k+1]=temp;
}
}
}
for(int i=0;i<gC.length-1;i++){
gC[i].show();
}
//同理
incandescnetLamp[] iL=new incandescnetLamp[1];
int num_iL=0;
for (int i = 0; i < deviceControlleds.length-1; i++) {
if (deviceControlleds[i] instanceof incandescnetLamp) {
iL[num_iL]=(incandescnetLamp) deviceControlleds[i];
iL= Arrays.copyOf(iL,iL.length+1);
num_iL++;
}
}
for(int i=0;i<iL.length-1-1;i++){
for(int k=0;k<iL.length-i-1-1;k++){
if (iL[k].name>iL[k+1].name){
incandescnetLamp temp=iL[k];
iL[k]=iL[k+1];
iL[k+1]=temp;
}
}
}
for(int i=0;i<iL.length-1;i++){
iL[i].show();
}
//同理
fluorescentLamp[] fL=new fluorescentLamp[1];
int num_fL=0;
for (int i = 0; i < deviceControlleds.length-1; i++) {
if (deviceControlleds[i] instanceof fluorescentLamp) {
fL[num_fL]=(fluorescentLamp) deviceControlleds[i];
fL= Arrays.copyOf(fL,fL.length+1);
num_fL++;
}
}
for(int i=0;i<fL.length-1-1;i++){
for(int k=0;k<fL.length-i-1-1;k++){
if (fL[k].name>fL[k+1].name){
fluorescentLamp temp=fL[k];
fL[k]=fL[k+1];
fL[k+1]=temp;
}
}
}
for(int i=0;i<fL.length-1;i++){
fL[i].show();
}
//同理
ceilingFan[] cF=new ceilingFan[1];
int num_cF=0;
for (int i = 0; i < deviceControlleds.length-1; i++) {
if (deviceControlleds[i] instanceof ceilingFan) {
cF[num_cF]=(ceilingFan) deviceControlleds[i];
cF= Arrays.copyOf(cF,cF.length+1);
num_cF++;
}
}
for(int i=0;i<cF.length-1-1;i++){
for(int k=0;k<cF.length-i-1-1;k++){
if (cF[k].name>cF[k+1].name){
ceilingFan temp=cF[k];
cF[k]=cF[k+1];
cF[k+1]=temp;
}
}
}
for(int i=0;i<cF.length-1;i++){
cF[i].show();
}
//同理
FloorFan[] fF=new FloorFan[1];
int num_fF=0;
for (int i = 0; i < deviceControlleds.length-1; i++) {
if (deviceControlleds[i] instanceof FloorFan) {
fF[num_fF]=(FloorFan) deviceControlleds[i];
fF= Arrays.copyOf(fF,fF.length+1);
num_fF++;
}
}
for(int i=0;i<fF.length-1-1;i++){
for(int k=0;k<fF.length-i-1-1;k++){
if (fF[k].name>fF[k+1].name){
FloorFan temp=fF[k];
fF[k]=fF[k+1];
fF[k+1]=temp;
}
}
}
for(int i=0;i<fF.length-1;i++){
fF[i].show();
}
2·然后对于如何实现电路的电阻和电压的赋值在每个串联电路和每个并联电路都设置电阻，把并联电路看作是一个用电器，然后每个串联电路都有设置总电阻，然后串联电路和并联电路都有设置总电压的函数，当我们把干路上赋值完之后，我们可以设置每个用电器的电压和电阻。
public void setsetVoltageAll(){
//先给并联赋电阻值
//2.再给各个串联电路赋电阻值
if(parallelDevice!=null){
parallelDevice.setResistanceAll();
}
for(int i=0;i<tandemDevices.length-1;i++){
tandemDevices[i].setResistanceAll();
}
tandemDevices[tandemDevices.length-1-1].setVoltageAll(220);
tandemDevices[tandemDevices.length-1-1].setVoltageApart();
if(parallelDevice!=null){
parallelDevice.setVoltageApart();
for(int i=0;i<parallelDevice.tandemDevices.length-1;i++){
// parallelDevice.tandemDevices[i].setVoltageAll(parallelDevice.voltageAll);
parallelDevice.tandemDevices[i].setVoltageApart();
}
}
3·对于并联我们要有特殊判断，因为并联电路上的一条支链如果全是开关闭合，那么并联电路就被短路了。
//先判断并联支路短路的情况
int target = 0;
for (int i = 0; i < tandemDevices.length - 1; i++) {
int num = 0;
if (tandemDevices[i].deviceControlings != null) { //查看控制设备开关的开闭
for (int j = 0; j < tandemDevices[i].deviceControlings.length - 1; j++) {
//存在用电器为零个，开关闭合，形成短路
if (tandemDevices[i].deviceControlings[j] instanceof Switch && ((Switch) tandemDevices[i].deviceControlings[j]).state == 1) {
num = 1;
} else if (tandemDevices[i].deviceControlings[j] instanceof Switch && ((Switch) tandemDevices[i].deviceControlings[j]).state == 0) {
num = 0;
break;
}
}
}
if (num == 1 && tandemDevices[i].deviceControlleds == null) { //开关都闭合，无用电器器
target = 1;
break;
}
}
if (target == 1) {
this.resistanceAll = 0;
}
③踩坑心得：
1·要考虑到多种情况，比如说并联的的短路情况
2·我们还要考虑到是否在这次情况中有并联和串联的电路，所以要加特判。
if(parallelDevice!=null){
parallelDevice.setVoltageApart();
for(int i=0;i<parallelDevice.tandemDevices.length-1;i++){
// parallelDevice.tandemDevices[i].setVoltageAll(parallelDevice.voltageAll);
parallelDevice.tandemDevices[i].setVoltageApart();
}
}
3·我们动态增加数组我们也要加特判如果开始时空则声明，之后用Arrays.copyOf函数去动态增加。
public void setTandemDevices(TandemDevice tandemDevices) {
if (this.tandemDevices == null) {
this.tandemDevices = new TandemDevice[1];
}
this.tandemDevices[i] = tandemDevices;
i++;
this.tandemDevices = Arrays.copyOf(this.tandemDevices, this.tandemDevices.length + 1);
}
④改进建议：
1·使用动态数组去增加长度时，要防止你多次去声明，把数据覆盖掉；
2·从总压到分压，要注意其误差。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步