对于第一次电梯作业：
题目：
7-5 NCHU_单部电梯调度程序
设计一个电梯类，具体包含电梯的最大楼层数、最小楼层数（默认为1层）当前楼层、运行方向、运行状态，以及电梯内部乘客的请求队列和电梯外部楼层乘客的请求队列，其中，电梯外部请求队列需要区分上行和下行。
电梯运行规则如下：电梯默认停留在1层，状态为静止，当有乘客对电梯发起请求时（各楼层电梯外部乘客按下上行或者下行按钮或者电梯内部乘客按下想要到达的楼层数字按钮），电梯开始移动，当电梯向某个方向移动时，优先处理同方向的请求，当同方向的请求均被处理完毕然后再处理相反方向的请求。电梯运行过程中的状态包括停止、移动中、开门、关门等状态。当电梯停止时，如果有新的请求，就根据请求的方向或位置决定移动方向。电梯在运行到某一楼层时，检查当前是否有请求（访问电梯内请求队列和电梯外请求队列），然后据此决定移动方向。每次移动一个楼层，检查是否有需要停靠的请求，如果有，则开门，处理该楼层的请求，然后关门继续移动。
使用键盘模拟输入乘客的请求，此时要注意处理无效请求情况，例如无效楼层请求，比如超过大楼的最高或最低楼层。还需要考虑电梯的空闲状态，当没有请求时，电梯停留在当前楼层。
请编写一个Java程序，设计一个电梯类，包含状态管理、请求队列管理以及调度算法，并使用一些测试用例，模拟不同的请求顺序，观察电梯的行为是否符合预期，比如是否优先处理同方向的请求，是否在移动过程中处理顺路的请求等。为了降低编程难度，不考虑同时有多个乘客请求同时发生的情况，即采用串行处理乘客的请求方式（电梯只按照规则响应请求队列中当前的乘客请求，响应结束后再响应下一个请求），具体运行规则详见输入输出样例。

输入格式:
第一行输入最小电梯楼层数。
第二行输入最大电梯楼层数。
从第三行开始每行输入代表一个乘客请求。

电梯内乘客请求格式：<楼层数>
电梯外乘客请求格式：<乘客所在楼层数,乘梯方向>，其中，乘梯方向用UP代表上行，用DOWN代表下行（UP、DOWN必须大写）。
当输入“end”时代表输入结束（end不区分大小写）。
输出格式:
模拟电梯的运行过程，输出方式如下：

运行到某一楼层（不需要停留开门），输出一行文本：
Current Floor: 楼层数 Direction: 方向
运行到某一楼层（需要停留开门）输出两行文本：
Open Door # Floor 楼层数
Close Door
输入样例:
在这里给出一组输入。例如：

1
20
< 3,UP>
<5>
<6,DOWN>
<7>
<3>
end
输出样例:
在这里给出相应的输出。例如：

Current Floor: 1 Direction: UP
Current Floor: 2 Direction: UP
Current Floor: 3 Direction: UP
Open Door # Floor 3
Close Door
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Open Door # Floor 5
Close Door
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Open Door # Floor 7
Close Door
Current Floor: 6 Direction: DOWN
Open Door # Floor 6
Close Door
Current Floor: 5 Direction: DOWN
Current Floor: 4 Direction: DOWN
Current Floor: 3 Direction: DOWN
Open Door # Floor 3
Close Door

附录：
电梯运行过程详解（LOOK算法）
输入：
1
20
< 3,UP>
<5>
<6,DOWN>
<7>
<3>
end
楼层最小值：1
楼层最大值：20
电梯外：3楼向上请求
电梯内：去5楼
电梯外：6楼向下请求
电梯内：去7楼
电梯内：去3楼
输入结束标志
输出：
Current Floor: 1 Direction: UP
Current Floor: 2 Direction: UP
Current Floor: 3 Direction: UP
Open Door # Floor 3
Close Door
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Open Door # Floor 5
Close Door
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Open Door # Floor 7
Close Door
Current Floor: 6 Direction: DOWN
Open Door # Floor 6
Close Door
Current Floor: 5 Direction: DOWN
Current Floor: 4 Direction: DOWN
Current Floor: 3 Direction: DOWN
Open Door # Floor 3
Close Door
当前楼层：1，方向：向上
当前楼层：2，方向：向上
当前楼层：3，方向：向上
当前楼层：3，开门
关门
当前楼层：4，方向：向上
当前楼层：5，方向：向上
当前楼层：5，开门
关门
当前楼层：6，方向：向上
当前楼层：7，方向：向上
当前楼层：7，开门
关门
当前楼层：6，方向：向下
当前楼层：6，开门
关门
当前楼层：5，方向：向下
当前楼层：4，方向：向下
当前楼层：3，方向：向下
当前楼当前楼层：3，开门
关门
按照题目说明，乘客请求为一次性输入，乘客请求分为电梯内和电梯外两个队列，分别为：
电梯内：
InnerQueue <5> <7> <3>
电梯外：
OuterQueue < 3,UP> <6,DOWN>
电梯运行过程如下：
1.电梯默认值停留在1层，状态为Stopped（停止），方向为IDLE（无方向）
2.程序开始运行，检测IQ（InnerQueue）和OQ（OutQueue）两个队列排在最前面的请求，
如果任意不为空，则代表有乘客请求，应该运行，检测结果为队列不为空，开始运行
3. 首先判断运行方向，离电梯当前层（1层）最近的为OQ内的第一个元素的请求楼层3,3>1，
则向上然后电梯开始向上运行，状态为Moving（移动），方向为UP（向上），输出：“当
前楼层：1，方向：向上”，
4. 运行到第2层，判断该楼层是否应该停下来处理请求，判断后应继续移动（请求是3），
输出“当前楼层：2，方向：向上”
5. 运行到第3层，判断该楼层是否应该停下来处理请求，判断后应停止处理请求（请求是
3，当前楼层是3），状态变为Stopped，输出“Open Door # Floor 3回车Close Door”，此
时将IQ和OQ两个队列中的队头的3层请求全部出队（删除）
6. 关门后电梯状态为“Stopped”，继续检测两个队列的队头请求，分别是<5>和<6,DOWN>，
取同向且离得近的请求，即<5>，得出电梯运行方向应维持UP
7. 继续向上运行，运行到第4层，判断该楼层是否应该停下来处理请求，判断后应继续移
动（请求是5），输出“当前楼层：4，方向：向上”
8. 继续向上运行，运行到第5层，判断该楼层是否应该停下来处理请求，判断后应处理请
求（请求是5，且方向为UP，与电梯同向），状态变为Stopped，输出“Open Door # Floor
5 回车Close Door”，此时将IQ和OQ两个队列中的队头的5层请求全部出队（删除）
9. 关门后电梯状态为“Stopped”，继续检测两个队列的队头请求，分别是<7>和<6,DOWN>，
取同向且离得近的请求，即<7>，得出电梯运行方向应维持UP
10. 继续向上运行，运行到第6层，判断该楼层是否应该停下来处理请求，判断后应继续移
动（请求是7），输出“当前楼层：6，方向：向上”
11. 继续向上运行，运行到第7层，判断该楼层是否应该停下来处理请求，判断后应处理请
求（请求是7，且方向为UP，与电梯同向），状态变为Stopped，输出“Open Door # Floor
7 回车Close Door”，此时将IQ和OQ两个队列中的队头的7层请求全部出队（删除）
12. 关门后电梯状态为“Stopped”，继续检测两个队列的队头请求，分别是<3>和<6,DOWN>，
取同向且离得近的请求，结果为空，此时可判定当前电梯向上方向的请求已经全部处理完毕，
此时方向应转向，即从UP到DOWN，此时取同向离得最近的请求，即<6,DOWN>，得出电
梯运行方向应向下
13. 继续向下运行，运行到第6层，判断该楼层是否应该停下来处理请求，判断后应处理请
求（请求是6，且方向为DOWN，与电梯同向），状态变为Stopped，输出“OpenDoor#Floor
6 回车Close Door”，此时将IQ和OQ两个队列中的队头的6层请求全部出队（删除）
14. 关门后电梯状态为“Stopped”，继续检测两个队列的队头请求，只剩下是<3>，取同向
且离得近的请求，即<3>，得出电梯运行方向应维持DOWN
15. 运行到第5层，判断该楼层是否应该停下来处理请求，判断后应继续移动（请求是3），
输出“当前楼层：5，方向：向下”
16. 运行到第4层，判断该楼层是否应该停下来处理请求，判断后应继续移动（请求是3），
输出“当前楼层：5，方向：向下”
17. 运行到第3层，判断该楼层是否应该停下来处理请求，判断后应处理请求（请求是3），
状态变为Stopped，输出“Open Door # Floor 3回车Close Door”，此时将IQ和OQ两个队
列中的队头的3层请求全部出队（删除）
18. 关门后电梯状态为“Stopped”，继续检测两个队列的队头请求，结果为空，此时电梯运
行结束，状态为“Stopped”，方向变为“IDEL”，电梯停留在3

以下是对我提交的源码进行的分析：

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory E:\java\Main\src
Project Name 1
Checkpoint Name Baseline
File Name Main.java
Lines 339
Statements 241
Percent Branch Statements 23.2
Method Call Statements 71
Percent Lines with Comments 0.6
Classes and Interfaces 4
Methods per Class 3.75
Average Statements per Method 14.07
Line Number of Most Complex Method 5
Name of Most Complex Method Main.main()
Maximum Complexity 52
Line Number of Deepest Block 61
Maximum Block Depth 9+
Average Block Depth 4.80
Average Complexity 5.67

Most Complex Methods in 4 Class(es): Complexity, Statements, Max Depth, Calls

Dtn.Dtn() 1, 2, 2, 0
Dtn.Dtn() 1, 1, 2, 0
Dtn.getData2() 1, 1, 2, 0
Dtn.getHead2() 1, 1, 2, 0
Dtn.sc2() 5, 14, 4, 2
Dtn.wc2() 4, 8, 4, 0
Dtw.Dtw() 1, 2, 2, 0
Dtw.Dtw() 1, 1, 2, 0
Dtw.getData1() 1, 1, 2, 0
Dtw.getHead1() 1, 1, 2, 0
Dtw.sc1() 5, 14, 4, 2
Dtw.wc1() 4, 8, 4, 0
Main.main() 52, 141, 10, 64
sf.getFloor() 6, 14, 4, 3
sf.sf() 1, 2, 2, 0

Block Depth Statements

0 7

1 23

2 53

3 34

4 21

5 15

6 4

7 4

8 6

9+ 74

当我刚摸到这道题目时，感觉到无从下手，原因时该电梯使用了LOOK算法，但是我并不知道LOOK算法的逻辑与原理，并且写这道题时我也才刚刚接触正则表达式和ArrrayList不久，对于很多东西都不明白，所以就像无头苍蝇一样，不知道怎么做，但是后面在老师不断的提示讲解下，以及同学的帮助下，我也是在快要截止的时候完成了该作业。
思路讲解：先使用正则表达式将请求中的分为两个队列，然后使用链表将对列储存下来，然后比较队列中的信息，再根据LOOK算法，将正确的信息展现出来，其中有一个难点就是电梯向上运行时，如果现在忽然变成向下，而在电梯楼层上方的一个人，按下了向下的按钮，则电梯应该先向上在向下。

对于第二次电梯作业：
题目：
对之前电梯调度程序进行迭代性设计，目的为解决电梯类职责过多的问题，类设计要求遵循单一职责原则（SRP），要求必须包含但不限于设计电梯类、乘客请求类、队列类以及控制类，具体设计可参考如下类图。

电梯运行规则与前阶段单类设计相同，但要处理如下情况：

乘客请求楼层数有误，具体为高于最高楼层数或低于最低楼层数，处理方法：程序自动忽略此类输入，继续执行
乘客请求不合理，具体为输入时出现连续的相同请求，例如<3><3><3>或者<5,DOWN><5,DOWN>，处理方法：程序自动忽略相同的多余输入，继续执行，例如<3><3><3>过滤为<3>
注意：本次作业类设计必须符合如上要求（包含但不限于乘客请求类、电梯类、请求队列类及控制类，其中控制类专门负责电梯调度过程），凡是不符合类设计要求此题不得分，另外，PTA得分代码界定为第一次提交的最高分代码（因此千万不要把第一次电梯程序提交到本次题目中测试）。

输入格式:
第一行输入最小电梯楼层数。
第二行输入最大电梯楼层数。
从第三行开始每行输入代表一个乘客请求。

运行到某一楼层（不需要停留开门），输出一行文本：
Current Floor: 楼层数 Direction: 方向
运行到某一楼层（需要停留开门）输出两行文本：
Open Door # Floor 楼层数
Close Door
输入样例1:
在这里给出一组输入。例如：

1
20
< 3,UP>
<5>
<6,DOWN>
<7>
<3>
end
输出样例1:
在这里给出相应的输出。例如：

1
20
< 3,UP>
< 3,UP>
<5>
<5>
<5>
<6,DOWN>
<7>
<7>
<3>
<22,DOWN>
<5,DOWN>
<30>
END
输出样例2:
在这里给出相应的输出。例如：

Current Floor: 1 Direction: UP
Current Floor: 2 Direction: UP
Current Floor: 3 Direction: UP
Open Door # Floor 3
Close Door
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Open Door # Floor 5
Close Door
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Open Door # Floor 7
Close Door
Current Floor: 6 Direction: DOWN
Open Door # Floor 6
Close Door
Current Floor: 5 Direction: DOWN
Open Door # Floor 5
Close Door
Current Floor: 4 Direction: DOWN
Current Floor: 3 Direction: DOWN
Open Door # Floor 3
Close Door

以下是对我提交的源码进行的分析：

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory E:\java\Main\src
Project Name 2
Checkpoint Name Baseline
File Name Main.java
Lines 407
Statements 247
Percent Branch Statements 23.5
Method Call Statements 115
Percent Lines with Comments 15.7
Classes and Interfaces 3
Methods per Class 11.00
Average Statements per Method 7.18
Line Number of Most Complex Method 338
Name of Most Complex Method Main.main()
Maximum Complexity 16
Line Number of Deepest Block 363
Maximum Block Depth 6
Average Block Depth 2.34
Average Complexity 2.22

Most Complex Methods in 5 Class(es): Complexity, Statements, Max Depth, Calls

Controller.Controller() 1, 2, 3, 0
Controller.Controller() 1, 1, 3, 0
Controller.getElevator() 1, 1, 3, 0
Controller.getQueue() 1, 1, 3, 0
Controller.processRequests() 2, 7, 4, 7
Controller.setElevator() 1, 1, 3, 0
Controller.setQueue() 1, 1, 3, 0
getState().determineDirection() 4, 7, 3, 4
getState().move() 3, 8, 3, 6
getState().setState() 3, 1, 3, 1
getState().shouldStop() 3, 5, 3, 1
isValidFloor().setCurrentFloor() 2, 2, 5, 1
Main.main() 16, 34, 6, 23
setState().addExternalRequest() 1, 1, 3, 1
setState().addInternalRequest() 1, 1, 3, 1
setState().getExternalRequests() 1, 1, 3, 0
setState().getInternalRequests() 1, 1, 3, 0
setState().getMaxFloor() 1, 1, 3, 0
setState().getMinFloor() 1, 1, 3, 0
setState().isValidFloor() 3, 2, 5, 1
setState().RequestQueue() 1, 0, 0, 0
setState().setExternalRequests() 1, 1, 3, 0
setState().setInternalRequests() 1, 1, 3, 0

Block Depth Statements

0 31

1 40

2 65

3 58

4 35

5 14

6 4

7 0

8 0

9+ 0

因为在第一次的基础下我已经弄清楚LOOK算法的逻辑，按理来说，写这个应该会更快，但是题目却做出了很多的更改，如让我们使用类图中的类方法去写出代码，并且类图中使用了ArrayList的方法，而我第一次在作业中使用的是链表方法，所以其中的偏差还是挺大，所以我不得不上网去搜索一下，ArrayList的使用发法，如add方法，remove方法等等，这也让我发现动态数组的便捷性。对于这一题的思路，和上一题相同，只是多了一个处理连续相同的请求的要求，就是在正则表达式分队列的时候，添加一个数据用来储存上一个数据，，然后比较，然后忽视该要求，根据类图来写代码后因为我的代码中有很多无用代码，所以代码长度较长，如果删减一下，和第一次的行数差不多，并且使用类图可以更好的发现错误，而不是一错而全身动。

第三次电梯作业：
题目：
对之前电梯调度程序再次进行迭代性设计，加入乘客类（Passenger），取消乘客请求类，类设计要求遵循单一职责原则（SRP），要求必须包含但不限于设计电梯类、乘客类、队列类以及控制类，具体设计可参考如下类图。

电梯运行规则与前阶段相同，但有如下变动情况：

乘客请求输入变动情况：外部请求由之前的<请求楼层数,请求方向>修改为<请求源楼层，请求目的楼层>
对于外部请求，当电梯处理该请求之后（该请求出队），要将<请求源楼层，请求目的楼层>中的请求目的楼层加入到请求内部队列(加到队尾）
注意：本次作业类设计必须符合如上要求（包含但不限于设计电梯类、乘客类、队列类以及控制类），凡是不符合类设计要求此题不得分，另外，PTA得分代码界定为第一次提交的最高分代码（因此千万不要把第一次及第二次电梯程序提交到本次题目中测试）。

输入格式:
第一行输入最小电梯楼层数。
第二行输入最大电梯楼层数。
从第三行开始每行输入代表一个乘客请求。

电梯内乘客请求格式：<楼层数>
电梯外乘客请求格式：<请求源楼层，请求目的楼层>，其中，请求源楼层表示乘客发起请求所在的楼层，请求目的楼层表示乘客想要到达的楼层。
当输入“end”时代表输入结束（end不区分大小写）。
输出格式:
模拟电梯的运行过程，输出方式如下：

1
20
<5,4>
<5>
<7>
end
输出样例1:
在这里给出相应的输出。例如：

1
20
<5,9>
<8>
<9,3>
<4>
<2>
end
输出样例2:
在这里给出相应的输出。例如：

Current Floor: 1 Direction: UP
Current Floor: 2 Direction: UP
Current Floor: 3 Direction: UP
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Open Door # Floor 5
Close Door
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Current Floor: 8 Direction: UP
Open Door # Floor 8
Close Door
Current Floor: 9 Direction: UP
Open Door # Floor 9
Close Door
Current Floor: 8 Direction: DOWN
Current Floor: 7 Direction: DOWN
Current Floor: 6 Direction: DOWN
Current Floor: 5 Direction: DOWN
Current Floor: 4 Direction: DOWN
Open Door # Floor 4
Close Door
Current Floor: 3 Direction: DOWN
Current Floor: 2 Direction: DOWN
Open Door # Floor 2
Close Door
Current Floor: 3 Direction: UP
Current Floor: 4 Direction: UP
Current Floor: 5 Direction: UP
Current Floor: 6 Direction: UP
Current Floor: 7 Direction: UP
Current Floor: 8 Direction: UP
Current Floor: 9 Direction: UP
Open Door # Floor 9
Close Door
Current Floor: 8 Direction: DOWN
Current Floor: 7 Direction: DOWN
Current Floor: 6 Direction: DOWN
Current Floor: 5 Direction: DOWN
Current Floor: 4 Direction: DOWN
Current Floor: 3 Direction: DOWN
Open Door # Floor 3
Close Door

以下是对我提交的源码进行的分析：

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory E:\java\Main\src
Project Name Test
Checkpoint Name Baseline
File Name Main.java
Lines 359
Statements 231
Percent Branch Statements 26.0
Method Call Statements 118
Percent Lines with Comments 16.4
Classes and Interfaces 4
Methods per Class 5.75
Average Statements per Method 9.61
Line Number of Most Complex Method 296
Name of Most Complex Method Main.main()
Maximum Complexity 14
Line Number of Deepest Block 331
Maximum Block Depth 7
Average Block Depth 1.93
Average Complexity 3.25

Most Complex Methods in 4 Class(es): Complexity, Statements, Max Depth, Calls

Controller.Controller() 1, 2, 2, 0
Controller.processRequests() 2, 7, 3, 7
isValidFloor().setCurrentFloor() 2, 2, 3, 1
Main.main() 14, 33, 7, 25
Passenger.getDestinationFloor() 1, 1, 2, 0
Passenger.getDirection() 4, 6, 3, 0
Passenger.getSourceFloor() 1, 1, 2, 0
Passenger.Passenger() 1, 2, 2, 0

Block Depth Statements

0 43

1 55

2 61

3 35

4 28

5 4

6 3

7 2

8 0

9+ 0

基于前两次基础，LOOK算法已经不是问题，第三次和第二次很相似第三次只需要更改一个类，然后稍作修改，在添加一个对于队列请求的添加功能，已及外部队列的分析功能，这样在第二次代码的前提下很快就能写出来了。第三次作业就相当于前两次作业的总结，能够很好的复习已学知识。
思路讲解：在外部对列中添加一个比较楼层方法，通过比较楼层，然后写出UP还是DOWN，然后就和第二次的差不多了，当处理外部请求时，将外部请求中后面的楼层，放到内部请求的尾部，其余不变。

遇到的问题：
1.算法认知与应用困境：首次接触 LOOK 算法时，因缺乏相关知识储备，难以理解其逻辑与原理，导致代码编写无从下手。在不熟悉算法的情况下盲目编码，出现代码结构混乱、逻辑错误等问题，增加调试难度。

2.类设计转型挑战：从第一次单一类设计过渡到后续遵循单一职责原则的多类设计时，需重新划分代码结构与功能。第二次作业中，从链表存储请求队列转为使用 ArrayList，不仅要学习新的数据结构操作方法，还需适应新类图设计，易造成类职责划分不清、方法调用混乱。

3.输入处理复杂多样：作业中输入处理涉及多种特殊情况，如无效楼层请求（超出最高或最低楼层）、连续相同请求等。处理过程中易遗漏边界条件，无法正确过滤异常输入，干扰电梯调度逻辑的准确性。

4.代码复用与优化不足：每次作业迭代时，由于代码结构设计不合理，导致代码复用性差，只能大量重写或修改。且代码中存在较多无用代码，使代码冗长，增加维护和调试成本。

5.需求变更适应困难：作业迭代中需求频繁变更，如第二次作业新增处理连续相同请求的要求，第三次作业修改外部请求格式并调整请求处理逻辑。这些变更增加了开发难度，若不能及时理解和调整代码，易导致程序出错。

踩坑心得：
1.算法学习的重要性：缺乏对算法的深入理解，直接影响解题效率和代码质量。在不了解算法原理时强行编码，会陷入反复试错的困境，耗费大量时间和精力，最终可能仍无法实现预期功能。

2.类设计原则的实践难度：虽然理解单一职责原则等设计原则，但在实际应用中，准确划分类的职责、设计合理的类关系存在挑战。尤其是在面对复杂业务逻辑和需求变更时，容易出现类功能混杂、依赖关系混乱的情况。

3.代码质量意识的薄弱：初期编程时，往往只关注功能实现，忽视代码的可复用性、可读性和可维护性。随着作业迭代，代码问题逐渐暴露，意识到高质量代码对于长期开发和维护的重要性。

4.需求变更的应对不足：面对需求变更时，未能及时调整开发思路和代码结构，导致在修改代码过程中引入新的错误，增加写题时间。

改进建议：
1.加强算法学习与实践：在学习编程过程中，提前学习常见的算法和数据结构知识，通过练习相关算法题目，加深对算法原理和应用场景的理解。在遇到涉及算法的题目时，先深入分析算法逻辑，绘制流程图或伪代码，再进行代码编写，提高代码的逻辑性和可读性。

2.注重代码优化与复用：编写代码时，养成良好的代码习惯，及时删除无用代码，简化代码逻辑。对于多次使用的功能模块，封装成独立的方法或类，提高代码的复用性。在每次作业迭代时，分析代码中可以复用的部分，进行合理重构，减少代码长度，提高开发效率。

总结：
通过三次电梯调度程序作业的实践，逐步掌握了 LOOK 算法的应用，深入理解了面向对象编程中类的设计原则和方法，以及输入处理和代码优化的重要性。从最初对算法和类设计的迷茫，到逐渐能够根据题目要求合理设计代码结构、处理复杂逻辑，编程能力得到了显著提升。在这个过程中，认识到学习编程不仅要掌握基础知识，还要注重实践和总结，不断改进代码质量和编程思维。每次作业的迭代都是对知识的巩固和拓展，为后续学习更复杂的编程项目奠定了坚实的基础，希望老师能多给几个测试点，让我能更加迅速的了解算法问题。

posted on 2025-04-20 11:36 辣辣辣辣辣阅读(26) 评论(0) 收藏举报

刷新页面返回顶部

导航

Metrics Details For File 'Main.java'

Metrics Details For File 'Main.java'

Metrics Details For File 'Main.java'