【笔记】Stanford OpenCourse—CS106A：Programming Methodology—002
Problem solving in Karel
Decomposition
The Idea of an algorithm
1. 翻山越岭的Karl
Karl爬山，不管是百步梯还是千步梯，类似图1
图 1
这个范例主要学习将问题分解成一个个简单的模块，化繁为简，逐步求精。
思路：
1> Karel来到山脚下（爬山当然要先到山边，没有自驾车，没有景区bus，没有。。。，只有2条腿；）。
2> 开始爬山，就是上楼梯，下楼梯；
3> 离开（爬山结束，该干嘛干嘛去，反正不能堵了山门干收费的勾当）。
1>和3>好说，Karel够单一，认准一个方向（east）直走，碰到墙就停下。
2>应该可以再分为3步：上山、登顶、下山。
上山：只要前面有楼梯（墙）就上，也就是左转 –> 移动 –> 右转 –> 移动；如此循环，就登顶了。
登顶：好不容易爬上来，会当临决定，总要做些啥，不管是插旗还是撒尿都可以表达到此一游，Karel只能放个方块表示。
下山：应该类似上山，只要前面为空（悬崖，别抬杠），就前进 –> 右转 –> 前进 –> 左转，如此循环，直到下到山脚。
分析到这里，似乎一切都ok，敲代码验证就完事儿了。但是，假设山是名山，修得特标准，上下都是一级级的台阶，但人就不同了，形形色色，四面八方，借问Karel一句：施主从何而来，又向何而去？ Karel当然说：俺从西边来，向东边去。至于来有多近，去有多远。Karel就不操心了，按照指令走就是。这时，在看看上面的算法，似乎都ok，对应图1，下山也没问题，但要是环境变为11格，希望Karel走的更远，Karel就会撞地上了。悲催！
所以，下山的步骤就需要修改下：前面的问题就在于Karel不晓得自己是否已下到山脚，所以下山的条件是脚下是空的才能下，
下山：前进 –> 脚下是否为空（是 –> 右转 –> 前进 –> 左转 –> 看前面还有路否？（是 –> 前进）） 如此循环。
代码：
1
/*
2
* File: MountainKarel7.java
3
* -------------------------
4
* The MountainKarel7 subclass gets Karel to climb a simple
5
* mountain, plant a flag, and descend to the ground. This
6
* version generalizes the program so that it can climb a
7
* stair-step mountain of any size.
8
*/
9
10
import
stanford.karel.
*
;
11
12
/*
Main program
*/
13
14
public
class
MountainKarel7
extends
SuperKarel {
15
16
/**
17
* Runs the program.
18
*/
19
public
void
run() {
20
moveToWall();
21
climbMountain();
22
moveToWall();
23
}
24
25
/**
26
* Purports to climb up and down a stair-step mountain of
27
* any size. This code is considerably better than the
28
* last attempt, but still has a small bug.
29
*/
30
private
void
climbMountain() {
31
while
(frontIsBlocked()) {
32
stepUp();
33
}
34
putBeeper();
35
move();
36
while
(rightIsClear()) {
37
dropDown();
38
}
39
}
40
41
/**
42
* Send Karel up the step ahead of it.
43
*/
44
private
void
stepUp() {
45
turnLeft();
46
move();
47
turnRight();
48
move();
49
}
50
51
/**
52
* Drops down from the midair position just past a
53
* descending step.
54
*/
55
private
void
dropDown() {
56
turnRight();
57
move();
58
turnLeft();
59
if
(frontIsClear()) {
60
move();
61
}
62
}
63
64
/**
65
* Moves Karel forward until it is blocked by a wall.
66
*/
67
private
void
moveToWall() {
68
while
(frontIsClear()) {
69
move();
70
}
71
}
72
}
2. “种树”的Karel
春寒料峭，Stanford校园里的树都光秃秃的（啥，怎没有冬青树），Karel从西向东闲逛。路见秃树，就想把其装饰下，装饰前后的效果如图2、3.
图 2
图 3
Karel不知道树有多高，多远。只确定有足够的方块装饰每棵树。
算法分析：
Karel要做的就是找到树，装饰它。
找树简单，就好比碰到墙就停下。
装饰树：爬树 –> 放树叶 –> 下树。
爬树：左转 –> 只要右边有树（墙）就前进 –> 右转。
放树叶：按图3所示放4个方块 –> 前进 –> 右转。
放4个方块：放1个方块 –> 前进 –> 左转 （循环4次）。
下树：类似上树，只要没碰到地就一直前进。
代码：
1
/*
2
* File: BanishWinter.java
3
* -----------------------
4
* The BanishWinter subclass gets Karel adorn a series
5
* of trees with a cluster of beeper leaves.
6
*/
7
8
import
stanford.karel.
*
;
9
10
public
class
BanishWinter
extends
SuperKarel {
11
12
/*
Main program
*/
13
14
public
void
run() {
15
while
(beepersInBag()) {
16
findTree();
17
addLeavesToTree();
18
}
19
moveToWall();
20
21
}
22
23
/*
24
* Moves Karel up to the next tree.
25
*
26
* Programming style note: Since a tree is simply a wall,
27
* this method can simply call moveToWall. You could
28
* therefore replace the findTree call in the main program
29
* with moveToWall, but the program might then be harder to
30
* read because it violates the "tree" metaphor used at the
31
* level of the main program.
32
*/
33
private
void
findTree() {
34
moveToWall();
35
}
36
37
/*
38
* Adorns a single tree with a cluster of leaves. The
39
* precondition is that Karel must be immediately
40
* west of the tree, facing east; the postcondition is
41
* that Karel is at the bottom of the other side of the
42
* tree, facing east.
43
*/
44
private
void
addLeavesToTree() {
45
turnLeft();
46
climbTree();
47
addLeaves();
48
descendToGround();
49
turnLeft();
50
}
51
52
/*
53
* Climbs to the top of the tree.
54
*/
55
private
void
climbTree() {
56
while
(rightIsBlocked()) {
57
move();
58
}
59
}
60
61
/*
62
* Moves Karel back to the ground. Both the pre- and
63
* postconditions have Karel facing south.
64
*/
65
private
void
descendToGround() {
66
moveToWall();
67
}
68
69
/*
70
* Creates the cluster of leaves at the top of a tree.
71
* The precondition is that Karel must be facing north at
72
* the top of the tree; the postcondition is that Karel
73
* is still at the top, but on the other side of the
74
* trunk, facing south.
75
*/
76
private
void
addLeaves() {
77
turnRight();
78
createBeeperSquare();
79
move();
80
turnRight();
81
}
82
83
/*
84
* Moves Karel forward until it is blocked by a wall.
85
*/
86
private
void
moveToWall() {
87
while
(frontIsClear()) {
88
move();
89
}
90
}
91
92
/*
93
* Creates a square of four beepers, leaving Karel in its
94
* original orientation. The resulting square is positioned
95
* ahead and to the left of Karel's starting position.
96
*/
97
private
void
createBeeperSquare() {
98
for
(
int
i
=
0
; i
<
4
; i
++
) {
99
putBeeper();
100
move();
101
turnLeft();
102
}
103
}
104
105
}
106
107
PS：这个代码里假定只有4棵树，所以Karel的包里有20个方块，如果编辑方块的数量多于20，就会出错，因为Karel不能区别墙和树。
3. 闯迷宫的Karel
无它，右手法则，盲人摸象般，贴着右手的墙走，不通就左转。
代码：
1
public
class
karelMazeSolver extens SuperKarel {
2
public
void
run() {
3
while
(noBeepersPresent()) {
4
if
(rightIsClear()) {
5
turnRight();
6
}
else
{
7
while
(frontIsBlocked()) {
8
turnLeft();
9
}
10
}
11
move();
12
}
13
}
14
}