1
00:00:00,000 --> 00:00:13,070

2
00:00:13,070 --> 00:00:13,715
>> ROB BOWDEN：你好。

3
00:00:13,715 --> 00:00:17,800
我抢，我希望你
游戏游戏15。

4
00:00:17,800 --> 00:00:22,040
现在，有你需要的四大功能
这项计划实施 - 初始化，

5
00:00:22,040 --> 00:00:24,650
绘制，移动，赢了。

6
00:00:24,650 --> 00:00:27,230
那么，让我们来看看初始化。

7
00:00:27,230 --> 00:00:32,930
>> 在这里，我们看到我们的第一件事
要做的是声明一个变量

8
00:00:32,930 --> 00:00:34,600
所谓的计数器。

9
00:00:34,600 --> 00:00:37,620
这将被初始化
至d次·d减1。

10
00:00:37,620 --> 00:00:40,200
请记住，d为维
我们的董事会。

11
00:00:40,200 --> 00:00:43,840
如何初始化是去工作的是它会
遍历整个板

12
00:00:43,840 --> 00:00:46,050
我们要开始
在左上角。

13
00:00:46,050 --> 00:00:48,570
>> 并让我们只说我们
有一个4×4板。

14
00:00:48,570 --> 00:00:51,220
所以左上角我们
接下来要说的是15。

15
00:00:51,220 --> 00:00:53,960
然后，我们只是要算
通过板，说15，14，13，

16
00:00:53,960 --> 00:00:58,510
12，11，10，9,8，7，
6,5，4，等等。

17
00:00:58,510 --> 00:01:03,780
所以左上方，我们预期将d次
ð减去1，这在4乘4

18
00:01:03,780 --> 00:01:08,290
案件将是零下16
1，这是正确的15。

19
00:01:08,290 --> 00:01:10,885
>> 现在这里就是我们要去
遍历整个董事会。

20
00:01:10,885 --> 00:01:14,720
而我们要设定每个位置
董事会的当前值

21
00:01:14,720 --> 00:01:19,090
我们的计数器，然后计数器是怎么回事
递减，从而使下一个

22
00:01:19,090 --> 00:01:22,300
我们到达的位置，都将有
计数器大于1小于

23
00:01:22,300 --> 00:01:23,690
以前的位置。

24
00:01:23,690 --> 00:01:26,970
因此，我们最初有15和
递减计数器。

25
00:01:26,970 --> 00:01:30,065
这样的话，我们要分配14到
下一个位置，递减计数器，

26
00:01:30,065 --> 00:01:33,710
而我们要指定
13，依此类推。

27
00:01:33,710 --> 00:01:37,620
>> 最后，我们需要处理的那个角落
情况下，如果董事会有偶数

28
00:01:37,620 --> 00:01:44,450
尺寸，那么就做15，14，13，
12，一路下滑到3，2，1，是

29
00:01:44,450 --> 00:01:46,780
要离开我们
一个无法解决的板。

30
00:01:46,780 --> 00:01:49,390
我们必须交换1和2。

31
00:01:49,390 --> 00:01:52,930
因此，当d MOD 2等于0，这是
我们要如何检查

32
00:01:52,930 --> 00:01:54,410
来看看它是否均匀。

33
00:01:54,410 --> 00:01:59,810
若d模2等于0，则在D行减
1，这是最底行，并且

34
00:01:59,810 --> 00:02:05,430
位置d减2或D列减
2，我们要设置为2，

35
00:02:05,430 --> 00:02:07,860
d栏零下3我们
要设置为1。

36
00:02:07,860 --> 00:02:12,170
所以，这只是其中倒车
在1和2目前是。

37
00:02:12,170 --> 00:02:16,270
>> 最后，我们要设置很
右下等于空白，其中

38
00:02:16,270 --> 00:02:20,700
空白已经被定义哈希
在顶部为0。

39
00:02:20,700 --> 00:02:26,785
所以，这是不是绝对必要的，
因为这个for循环都将有

40
00:02:26,785 --> 00:02:30,610
设置右下角为0，因为
反自然会达到0。

41
00:02:30,610 --> 00:02:34,610
但是，这依赖于我们知道
空白被散列找到一个0。

42
00:02:34,610 --> 00:02:38,280
如果我进入这个程序，后来
更改上方的空白为100，它

43
00:02:38,280 --> 00:02:39,770
应该仍然工作。

44
00:02:39,770 --> 00:02:43,180
>> 所以这只是在确保
右下实际上等于我们

45
00:02:43,180 --> 00:02:44,870
空白值。

46
00:02:44,870 --> 00:02:50,270
最后，我们有两个全局变量，
所以我的空白和空白j和我们看到的

47
00:02:50,270 --> 00:02:53,360
在上面这些声明。

48
00:02:53,360 --> 00:02:56,270
我们要使用这两个全球
变量来跟踪的

49
00:02:56,270 --> 00:02:59,040
空白的位置，使我们不
需要看整个

50
00:02:59,040 --> 00:03:03,890
板找空白的每一个
一次我们试图做出的举动。

51
00:03:03,890 --> 00:03:08,450
因此，坯件的位置始终是
将开始于右下方。

52
00:03:08,450 --> 00:03:13,270
所以右下角由下式给出
指数Ð减1，D减1。

53
00:03:13,270 --> 00:03:14,880
所以，这是初始化。

54
00:03:14,880 --> 00:03:17,040
>> 现在，我们继续绘制。

55
00:03:17,040 --> 00:03:19,370
所以，拉伸将是类似
我们要去的地方进行迭代

56
00:03:19,370 --> 00:03:20,970
在整个电路板。

57
00:03:20,970 --> 00:03:25,400
我们只是要打印的值
这是在板的每个位置。

58
00:03:25,400 --> 00:03:29,580
所以在这里，我们要打印的值是
在棋盘的每个位置。

59
00:03:29,580 --> 00:03:32,280
并请注意，我们正在做的 - 。

60
00:03:32,280 --> 00:03:37,410
而这只是告诉printf的那
不论它是一个数字或

61
00:03:37,410 --> 00:03:42,010
两位数字，我们仍然希望它
占用两列在打印出来，

62
00:03:42,010 --> 00:03:46,290
所以，如果我们有2位和1
在同一块板上位数，我们的

63
00:03:46,290 --> 00:03:49,450
板仍然会好看和广场。

64
00:03:49,450 --> 00:03:54,190
>> 所以我们想要做的，对于每一个值
中板，除空白。

65
00:03:54,190 --> 00:03:58,260
所以，如果在电路板上的位置等于
空白的，那么我们的专

66
00:03:58,260 --> 00:04:01,730
想打印出只是一个下划线
以表示为空白，而不是

67
00:04:01,730 --> 00:04:05,150
的任何值
空白实际上是。

68
00:04:05,150 --> 00:04:08,500
>> 最后，我们要打印
出一个新行。

69
00:04:08,500 --> 00:04:11,970
请注意，这仍然是内
外循环，但外面

70
00:04:11,970 --> 00:04:13,200
内循环。

71
00:04:13,200 --> 00:04:17,930
由于这种外部for循环遍历
在所有的行，所以这是printf的

72
00:04:17,930 --> 00:04:22,130
将只打印一个新行，所以我们
移动到打印出的下一行。

73
00:04:22,130 --> 00:04:23,910
这就是它的平局。

74
00:04:23,910 --> 00:04:27,770
>> 所以，现在让我们继续前进移动。

75
00:04:27,770 --> 00:04:32,590
现在，我们通过招，瓷砖的
用户将被输入到游戏 - 它们

76
00:04:32,590 --> 00:04:36,360
进入他们想要移动的瓷砖 - 和
你应该返回一个布尔值，所以

77
00:04:36,360 --> 00:04:39,300
true或false，这取决于
这一举动是否竟是

78
00:04:39,300 --> 00:04:43,360
有效的 - 那瓦能否
搬进空白。

79
00:04:43,360 --> 00:04:48,340
>> 所以在这里，我们声明一个局部变量，
tile_1和tile_j，这要

80
00:04:48,340 --> 00:04:52,150
类似blank_i和blank_j，
除了它要跟踪的

81
00:04:52,150 --> 00:04:54,910
瓷砖的位置。

82
00:04:54,910 --> 00:05:00,370
现在，在这里，我们将使用blank_i
和blank_j说没事，所以

83
00:05:00,370 --> 00:05:01,930
这里的电路板上的空白。

84
00:05:01,930 --> 00:05:04,420
>> 现在，上面是空白的瓷砖？

85
00:05:04,420 --> 00:05:06,210
是平铺到空白的左？

86
00:05:06,210 --> 00:05:07,420
是平铺到空白的吧？

87
00:05:07,420 --> 00:05:08,970
下面是空白的瓷砖？

88
00:05:08,970 --> 00:05:13,330
所以，如果瓦片是在任何这些
位置，那么我们知道，瓷砖

89
00:05:13,330 --> 00:05:16,390
可以移动到空白点和
坯料可以被移动到那里的

90
00:05:16,390 --> 00:05:18,240
瓷砖目前是。

91
00:05:18,240 --> 00:05:26,400
>> 所以在这里，我们说，如果董事会在位置
blank_i减1 blank_j。

92
00:05:26,400 --> 00:05:31,120
因此，这说的是瓷砖
高于目前的空白？

93
00:05:31,120 --> 00:05:34,350
如果是这样，我们要记住
即在瓷砖的位置。

94
00:05:34,350 --> 00:05:37,870
瓷砖在位置blank_i
减1和blank_j。

95
00:05:37,870 --> 00:05:40,660
现在开始，我们也有这个检查
就在这里，所以blank_i是

96
00:05:40,660 --> 00:05:41,760
大于0。

97
00:05:41,760 --> 00:05:43,410
>> 我们为什么要那么做？

98
00:05:43,410 --> 00:05:47,290
那么，如果是空白的最上面一行
董事会的，那么我们不希望

99
00:05:47,290 --> 00:05:51,240
看看上面因为空白的瓷砖
没有什么高于顶

100
00:05:51,240 --> 00:05:52,430
排板。

101
00:05:52,430 --> 00:05:55,950
这就是你可能最终得到
像段故障或

102
00:05:55,950 --> 00:05:59,030
你的程序可能只是工作
以意想不到的方式。

103
00:05:59,030 --> 00:06:04,310
所以，这是确保我们不
看在无效的地方。

104
00:06:04,310 --> 00:06:08,470
>> 现在，我们要做同样的事情
所有其它可能的组合。

105
00:06:08,470 --> 00:06:13,250
所以在这里，我们期待下面的空白
看看如果是这样的瓷砖。

106
00:06:13,250 --> 00:06:16,950
而且我们还必须确保我们
不是在最后一行，否则我们

107
00:06:16,950 --> 00:06:18,910
不该看的瓷砖。

108
00:06:18,910 --> 00:06:25,040
在这里，我们将看向左边
空白，看它是否是瓷砖。

109
00:06:25,040 --> 00:06:27,860
我们不应该向左边看
如果我们是在最左边的列。

110
00:06:27,860 --> 00:06:30,100
在这里，我们要去看看的
右侧的空白，我们不应该

111
00:06:30,100 --> 00:06:33,340
向右边看，如果我们
在最右边的列中。

112
00:06:33,340 --> 00:06:37,820
>> 所以，如果没有这些东西都是真实的，
这意味着该瓦片不相邻

113
00:06:37,820 --> 00:06:39,640
到空白，我们可以返回false。

114
00:06:39,640 --> 00:06:41,230
此举是无效的。

115
00:06:41,230 --> 00:06:47,010
但是，如果其中的一个是真的，那么在
这一点，我们知道，tile_i和

116
00:06:47,010 --> 00:06:50,540
tile_j是等于
瓷砖的位置。

117
00:06:50,540 --> 00:06:55,210
因此，我们可以在更新主板
位置tile_i和tile_j。

118
00:06:55,210 --> 00:06:59,820
我们知道，新的值将是空
并且，该位置blank_i

119
00:06:59,820 --> 00:07:02,950
blank_j，这是原来的
空白 - 我们知道瓷砖是要

120
00:07:02,950 --> 00:07:04,030
搬到那里。

121
00:07:04,030 --> 00:07:07,610
>> 请注意，我们实际上并不需要做一个
这里真正的交换，因为我们知道

122
00:07:07,610 --> 00:07:09,850
需要被插入的值
到这些位置。

123
00:07:09,850 --> 00:07:13,780
我们不需要一个临时
变量各地。

124
00:07:13,780 --> 00:07:16,920
>> 最后，我们必须记住，我们
有我们的是全局变量

125
00:07:16,920 --> 00:07:18,980
跟踪的位置的
空白的。

126
00:07:18,980 --> 00:07:22,780
因此，我们要更新的位置
空白是平铺在那里

127
00:07:22,780 --> 00:07:24,190
原来是。

128
00:07:24,190 --> 00:07:27,680
最后，我们回到真正的自
此举是成功的。

129
00:07:27,680 --> 00:07:31,110
我们成功地交换
与瓷砖空白。

130
00:07:31,110 --> 00:07:34,890
>> 好吧，所以最后我们
需要检查韩元。

131
00:07:34,890 --> 00:07:39,900
所以，同样赢得了返回一个布尔值，其中
真正是要表明

132
00:07:39,900 --> 00:07:41,460
赢得了用户的游戏。

133
00:07:41,460 --> 00:07:43,780
和假的，表明
比赛仍在继续。

134
00:07:43,780 --> 00:07:46,340
该用户还没有赢得。

135
00:07:46,340 --> 00:07:52,100
所以，这将是相当多
初始化的对面，这里的init，

136
00:07:52,100 --> 00:07:56,920
请记住，我们初始化板
15，14，13，12，等等。

137
00:07:56,920 --> 00:08:03,000
虽然赢了，我们要检查
板是1，2，3，4，5，等等。

138
00:08:03,000 --> 00:08:06,600
>> 所以，我们要初始化我们
计数器为1，因为这顶一下

139
00:08:06,600 --> 00:08:08,400
电路板的左边应该是。

140
00:08:08,400 --> 00:08:10,860
然后我们要循环
在整个电路板。

141
00:08:10,860 --> 00:08:13,690
让我们忽略这个条件
一秒钟。

142
00:08:13,690 --> 00:08:18,410
而这个情况也只是要
检查董事会在此位置

143
00:08:18,410 --> 00:08:20,790
等于当前的计数？

144
00:08:20,790 --> 00:08:27,040
如果是这样，递增计数，以使
我们来看看下一个位置是高

145
00:08:27,040 --> 00:08:29,690
比我们在现在的位置上。

146
00:08:29,690 --> 00:08:32,700
>> 所以这就是我们如何获得
左上角应为1。

147
00:08:32,700 --> 00:08:33,950
递增计数为2。

148
00:08:33,950 --> 00:08:35,010
看看下一个位置。

149
00:08:35,010 --> 00:08:35,690
这是2？

150
00:08:35,690 --> 00:08:37,659
如果是这样，递增计数为3。

151
00:08:37,659 --> 00:08:39,179
下一个位置，这是3？

152
00:08:39,179 --> 00:08:42,440
如果是这样，递增计数
到4，等等。

153
00:08:42,440 --> 00:08:49,190
所以，如果有在任何位置
板，不等于我们的数量，

154
00:08:49,190 --> 00:08:52,640
然后我们要返回自认为假
意味着有一些瓷砖是

155
00:08:52,640 --> 00:08:55,490
不是在正确的位置上。

156
00:08:55,490 --> 00:08:58,810
>> 所以在这里，这是什么情况在做什么？

157
00:08:58,810 --> 00:09:02,170
好了，记住，是空白
应该去在右下角。

158
00:09:02,170 --> 00:09:06,180
和空白的值可能不是
不一定等于的值

159
00:09:06,180 --> 00:09:11,080
反驳说，将要达到
在右下角。

160
00:09:11,080 --> 00:09:15,760
因此，我们特别要检查，如果我
等于等于ð减1和j等于

161
00:09:15,760 --> 00:09:19,470
等于Ð零下1  - 这是说，如果我们
在看的右下

162
00:09:19,470 --> 00:09:22,050
主板 - 那么我们就
要继续。

163
00:09:22,050 --> 00:09:26,200
我们想跳过这个特殊的
迭代的for循环。

164
00:09:26,200 --> 00:09:31,250
>> 因此，如果我们能够熬过这
嵌套的for循环中，这意味着

165
00:09:31,250 --> 00:09:34,690
没有瓷砖，这是在
不正确的位置。

166
00:09:34,690 --> 00:09:38,900
我们跳出循环，来
在这里，在这里我们可以返回true。

167
00:09:38,900 --> 00:09:41,800
所有切片都在正确的位置
这意味着用户具有

168
00:09:41,800 --> 00:09:43,230
赢得了比赛。

169
00:09:43,230 --> 00:09:44,460
就是这样。

170
00:09:44,460 --> 00:09:46,550
我的名字是罗布·鲍登，这是15。

171
00:09:46,550 --> 00:09:52,726