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

2
00:00:13,070 --> 00:00:13,715
>> ROB Bowden: Hi.

3
00:00:13,715 --> 00:00:17,800
Aku Rob, dan saya berharap Anda
game untuk permainan 15.

4
00:00:17,800 --> 00:00:22,040
Sekarang, ada empat fungsi yang Anda butuhkan
untuk melaksanakan program ini - init,

5
00:00:22,040 --> 00:00:24,650
menggambar, bergerak, dan menang.

6
00:00:24,650 --> 00:00:27,230
Jadi, mari kita lihat init.

7
00:00:27,230 --> 00:00:32,930
>> Di sini, kita melihat hal pertama yang kita
akan lakukan adalah mendeklarasikan variabel

8
00:00:32,930 --> 00:00:34,600
disebut counter.

9
00:00:34,600 --> 00:00:37,620
Ini akan diinisialisasi
untuk d kali d dikurangi 1.

10
00:00:37,620 --> 00:00:40,200
Ingat bahwa d adalah dimensi
papan kami.

11
00:00:40,200 --> 00:00:43,840
Bagaimana init akan bekerja itu akan
untuk iterate atas seluruh papan

12
00:00:43,840 --> 00:00:46,050
dan kita akan mulai
di bagian kiri atas.

13
00:00:46,050 --> 00:00:48,570
>> Dan mari kita katakan saja kita
memiliki 4 oleh 4 papan.

14
00:00:48,570 --> 00:00:51,220
Jadi kiri atas kami
akan katakan adalah 15.

15
00:00:51,220 --> 00:00:53,960
Dan kemudian kita hanya akan menghitung
melalui papan, mengatakan 15, 14, 13,

16
00:00:53,960 --> 00:00:58,510
12, 11, 10, 9, 8, 7,
6, 5, 4, dan seterusnya.

17
00:00:58,510 --> 00:01:03,780
Jadi kiri atas, kami berharap untuk menjadi d kali
d dikurangi 1, yang dalam 4 oleh 4

18
00:01:03,780 --> 00:01:08,290
kasus akan menjadi 16 dikurangi
1, yang benar 15.

19
00:01:08,290 --> 00:01:10,885
>> Dan sekarang di sinilah kita akan
iterate atas seluruh papan.

20
00:01:10,885 --> 00:01:14,720
Dan kita akan mengatur posisi masing-masing di
dewan dengan nilai saat ini

21
00:01:14,720 --> 00:01:19,090
counter kami, dan kemudian counter akan
untuk pengurangan, sehingga selanjutnya

22
00:01:19,090 --> 00:01:22,300
Posisi kita mencapai akan memiliki
kontra menjadi salah satu kurang dari

23
00:01:22,300 --> 00:01:23,690
posisi sebelumnya.

24
00:01:23,690 --> 00:01:26,970
Jadi kami awalnya memiliki 15 dan
pengurangan counter.

25
00:01:26,970 --> 00:01:30,065
Jadi kita akan menetapkan 14 ke
Posisi berikutnya, pengurangan counter,

26
00:01:30,065 --> 00:01:33,710
dan kita akan ditugaskan
13, dan seterusnya.

27
00:01:33,710 --> 00:01:37,620
>> Akhirnya, kita perlu untuk menangani sudut yang
kasus di mana, jika dewan memiliki bahkan

28
00:01:37,620 --> 00:01:44,450
dimensi, maka hanya melakukan 15, 14, 13,
12, semua jalan ke 3, 2, 1, adalah

29
00:01:44,450 --> 00:01:46,780
akan meninggalkan kami dengan
papan terpecahkan.

30
00:01:46,780 --> 00:01:49,390
Dan kita harus swap 1 dan 2.

31
00:01:49,390 --> 00:01:52,930
Jadi, jika d mod 2 sama dengan 0, itu
bagaimana kita akan memeriksa

32
00:01:52,930 --> 00:01:54,410
untuk melihat apakah itu bahkan.

33
00:01:54,410 --> 00:01:59,810
Jika d mod 2 sama dengan 0, maka berturut-turut d dikurangi
1, yang merupakan baris bawah, dan

34
00:01:59,810 --> 00:02:05,430
posisi d minus 2, atau kolom d dikurangi
2, kita akan menetapkan bahwa untuk 2, dan

35
00:02:05,430 --> 00:02:07,860
kolom d minus 3 kami
akan diatur ke 1.

36
00:02:07,860 --> 00:02:12,170
Jadi itu hanya membalikkan mana
1 dan 2 saat ini berada.

37
00:02:12,170 --> 00:02:16,270
>> Akhirnya, kita akan mengatur sangat
kanan bawah sama dengan kosong, di mana

38
00:02:16,270 --> 00:02:20,700
kosong telah hash didefinisikan telah
di bagian atas sebagai 0.

39
00:02:20,700 --> 00:02:26,785
Jadi, itu tidak benar-benar diperlukan,
karena ini untuk loop akan memiliki

40
00:02:26,785 --> 00:02:30,610
mengatur kanan bawah ke 0, karena
kontra secara alami akan mencapai 0.

41
00:02:30,610 --> 00:02:34,610
Tapi itu bergantung pada kita mengetahui bahwa
blanko hash untuk menemukan 0.

42
00:02:34,610 --> 00:02:38,280
Jika saya pergi ke program ini dan kemudian
mengubah kosong di bagian atas untuk 100, itu

43
00:02:38,280 --> 00:02:39,770
masih harus bekerja.

44
00:02:39,770 --> 00:02:43,180
>> Jadi ini hanya memastikan bahwa
kanan bawah sebenarnya sama dengan kami

45
00:02:43,180 --> 00:02:44,870
nilai kosong.

46
00:02:44,870 --> 00:02:50,270
Akhirnya, kita memiliki dua variabel global,
jadi kosong i dan j kosong, dan kita lihat

47
00:02:50,270 --> 00:02:53,360
yang dinyatakan di atas.

48
00:02:53,360 --> 00:02:56,270
Dan kita akan menggunakan dua dunia
variabel untuk melacak

49
00:02:56,270 --> 00:02:59,040
posisi kosong, sehingga kita tidak
perlu untuk melihat melalui seluruh yang

50
00:02:59,040 --> 00:03:03,890
board untuk menemukan kosong setiap satu
kali kita mencoba untuk bergerak.

51
00:03:03,890 --> 00:03:08,450
Jadi posisi kosong selalu adalah
akan mulai di bagian kanan bawah.

52
00:03:08,450 --> 00:03:13,270
Jadi kanan bawah diberikan oleh
indeks d dikurangi 1, d dikurangi 1.

53
00:03:13,270 --> 00:03:14,880
Jadi, itu init.

54
00:03:14,880 --> 00:03:17,040
>> Sekarang kita beralih ke menggambar.

55
00:03:17,040 --> 00:03:19,370
Jadi, hasil imbang akan menjadi serupa
di mana kita akan iterate

56
00:03:19,370 --> 00:03:20,970
atas seluruh papan.

57
00:03:20,970 --> 00:03:25,400
Dan kami hanya ingin mencetak nilai
yang ada di setiap posisi papan.

58
00:03:25,400 --> 00:03:29,580
Jadi di sini, kita mencetak nilai yang
di setiap posisi papan.

59
00:03:29,580 --> 00:03:32,280
Dan melihat bahwa yang kita lakukan -.

60
00:03:32,280 --> 00:03:37,410
Dan itu hanya mengatakan bahwa printf
terlepas dari apakah itu adalah satu digit atau

61
00:03:37,410 --> 00:03:42,010
nomor dua digit, kita masih ingin
mengambil dua kolom di print out,

62
00:03:42,010 --> 00:03:46,290
sehingga jika kita memiliki dua digit dan satu
digit angka di papan yang sama, kami

63
00:03:46,290 --> 00:03:49,450
Dewan akan tetap terlihat bagus dan persegi.

64
00:03:49,450 --> 00:03:54,190
>> Jadi kami ingin melakukan itu untuk setiap nilai
di papan, kecuali kosong.

65
00:03:54,190 --> 00:03:58,260
Jadi, jika posisi di papan sama
kosong, maka kami secara khusus

66
00:03:58,260 --> 00:04:01,730
ingin mencetak hanya garis bawah
untuk mewakili kosong, bukannya

67
00:04:01,730 --> 00:04:05,150
apapun nilai
kosong sebenarnya.

68
00:04:05,150 --> 00:04:08,500
>> Akhirnya, kita ingin mencetak
sebuah baris baru.

69
00:04:08,500 --> 00:04:11,970
Perhatikan bahwa ini masih dalam
luar untuk loop, tetapi di luar

70
00:04:11,970 --> 00:04:13,200
batin untuk loop.

71
00:04:13,200 --> 00:04:17,930
Karena outer ini untuk loop iterasi
atas semua baris, dan sebagainya printf ini

72
00:04:17,930 --> 00:04:22,130
akan hanya mencetak baris baru, jadi kami
melanjutkan untuk mencetak baris berikutnya.

73
00:04:22,130 --> 00:04:23,910
Dan itu saja untuk menarik.

74
00:04:23,910 --> 00:04:27,770
>> Jadi, sekarang mari kita lanjutkan untuk bergerak.

75
00:04:27,770 --> 00:04:32,590
Sekarang, kami melewati langkah, genteng bahwa
pengguna dimasukkan dalam permainan - mereka

76
00:04:32,590 --> 00:04:36,360
masukkan ubin mereka ingin pindah - dan
Anda seharusnya mengembalikan bool, jadi

77
00:04:36,360 --> 00:04:39,300
benar atau salah, tergantung pada
apakah tindakan itu benar-benar

78
00:04:39,300 --> 00:04:43,360
valid - apakah genteng yang dapat
pindah ke ruang kosong.

79
00:04:43,360 --> 00:04:48,340
>> Jadi di sini, kita mendeklarasikan variabel lokal,
tile_1 dan tile_j, yang akan

80
00:04:48,340 --> 00:04:52,150
mirip dengan blank_i dan blank_j,
kecuali itu akan melacak

81
00:04:52,150 --> 00:04:54,910
posisi ubin.

82
00:04:54,910 --> 00:05:00,370
Sekarang di sini, kita akan menggunakan blank_i
dan blank_j dan berkata baik-baik saja, jadi

83
00:05:00,370 --> 00:05:01,930
inilah kosong di papan tulis.

84
00:05:01,930 --> 00:05:04,420
>> Sekarang, adalah genteng di atas kosong?

85
00:05:04,420 --> 00:05:06,210
Apakah ubin di sebelah kiri kosong?

86
00:05:06,210 --> 00:05:07,420
Apakah ubin di sebelah kanan kosong?

87
00:05:07,420 --> 00:05:08,970
Apakah ubin di bawah kosong?

88
00:05:08,970 --> 00:05:13,330
Jadi, jika ubin ini di salah satu dari mereka
posisi, maka kita tahu bahwa ubin

89
00:05:13,330 --> 00:05:16,390
dapat dipindahkan ke tempat yang kosong dan
kosong dapat dipindahkan ke mana

90
00:05:16,390 --> 00:05:18,240
ubin saat ini.

91
00:05:18,240 --> 00:05:26,400
>> Jadi di sini, kita katakan jika papan di posisi
blank_i dikurangi 1 blank_j.

92
00:05:26,400 --> 00:05:31,120
Jadi ini katakan adalah ubin
di atas kosong saat ini?

93
00:05:31,120 --> 00:05:34,350
Dan jika demikian, kita akan ingat
itu adalah posisi dari ubin.

94
00:05:34,350 --> 00:05:37,870
Ubin berada di posisi blank_i
dikurangi 1 dan blank_j.

95
00:05:37,870 --> 00:05:40,660
sekarang pertama, kami juga memiliki cek ini
di sini, jadi blank_i adalah

96
00:05:40,660 --> 00:05:41,760
lebih besar dari 0.

97
00:05:41,760 --> 00:05:43,410
>> Mengapa kita ingin melakukan itu?

98
00:05:43,410 --> 00:05:47,290
Nah, jika kosong adalah di baris atas
dewan, maka kita tidak ingin

99
00:05:47,290 --> 00:05:51,240
lihat di atas sisipan untuk ubin sejak
tidak ada di atas atas

100
00:05:51,240 --> 00:05:52,430
deretan papan.

101
00:05:52,430 --> 00:05:55,950
Ini adalah bagaimana Anda mungkin akhirnya mendapatkan
sesuatu seperti kesalahan segmentasi atau

102
00:05:55,950 --> 00:05:59,030
program Anda hanya bisa bekerja
dalam cara yang tak terduga.

103
00:05:59,030 --> 00:06:04,310
Jadi, ini adalah memastikan bahwa kita tidak
lihat di tempat-tempat yang tidak valid.

104
00:06:04,310 --> 00:06:08,470
>> Sekarang kita akan melakukan hal yang sama untuk
semua kombinasi lain yang mungkin.

105
00:06:08,470 --> 00:06:13,250
Jadi di sini, kami sedang mencari di bawah kosong
untuk melihat apakah itu ubin.

106
00:06:13,250 --> 00:06:16,950
Dan kami juga harus memastikan kami
tidak di baris paling bawah, atau kita

107
00:06:16,950 --> 00:06:18,910
tidak harus mencari ubin.

108
00:06:18,910 --> 00:06:25,040
Di sini, kita akan melihat ke kiri
kosong untuk melihat apakah itu ubin.

109
00:06:25,040 --> 00:06:27,860
Dan kita tidak harus melihat ke kiri
jika kita berada di kolom paling kiri.

110
00:06:27,860 --> 00:06:30,100
Dan di sini kita akan melihat ke
kanan kosong, dan kita tidak boleh

111
00:06:30,100 --> 00:06:33,340
melihat ke kanan jika kita
di kolom paling kanan.

112
00:06:33,340 --> 00:06:37,820
>> Jadi, jika tidak ada hal-hal yang benar,
itu berarti ubin tidak berdekatan

113
00:06:37,820 --> 00:06:39,640
ke kosong dan kita bisa kembali palsu.

114
00:06:39,640 --> 00:06:41,230
Langkah itu tidak valid.

115
00:06:41,230 --> 00:06:47,010
Tapi, jika salah satu dari mereka itu benar, maka pada
titik ini, kita tahu bahwa tile_i dan

116
00:06:47,010 --> 00:06:50,540
tile_j adalah sama dengan
posisi ubin.

117
00:06:50,540 --> 00:06:55,210
Jadi, kita dapat memperbarui papan di
posisi tile_i dan tile_j.

118
00:06:55,210 --> 00:06:59,820
Kita tahu nilai baru akan kosong
dan bahwa blank_i posisi

119
00:06:59,820 --> 00:07:02,950
blank_j, yang asli
kosong - kita tahu ubin akan

120
00:07:02,950 --> 00:07:04,030
pindah ke sana.

121
00:07:04,030 --> 00:07:07,610
>> Perhatikan kita tidak benar-benar harus melakukan
swap yang nyata di sini, karena kita tahu

122
00:07:07,610 --> 00:07:09,850
nilai-nilai yang perlu dimasukkan
ke posisi tersebut.

123
00:07:09,850 --> 00:07:13,780
Kita tidak perlu sementara
variabel sekitar.

124
00:07:13,780 --> 00:07:16,920
>> Akhirnya, kita harus ingat bahwa kita
memiliki variabel global kami yang

125
00:07:16,920 --> 00:07:18,980
melacak posisi
dari kosong.

126
00:07:18,980 --> 00:07:22,780
Jadi kita ingin memperbarui posisi
kosong untuk berada di tempat ubin

127
00:07:22,780 --> 00:07:24,190
awalnya.

128
00:07:24,190 --> 00:07:27,680
Akhirnya, kita kembali benar karena
langkah itu berhasil.

129
00:07:27,680 --> 00:07:31,110
Kami berhasil swap
kosong dengan ubin.

130
00:07:31,110 --> 00:07:34,890
>> Baiklah, kita jadi terakhir
perlu memeriksa won.

131
00:07:34,890 --> 00:07:39,900
Jadi, menang sama mengembalikan bool mana
benar akan menunjukkan bahwa

132
00:07:39,900 --> 00:07:41,460
pengguna telah memenangkan pertandingan.

133
00:07:41,460 --> 00:07:43,780
Dan palsu menunjukkan bahwa
game ini masih berlangsung.

134
00:07:43,780 --> 00:07:46,340
Pengguna belum menang.

135
00:07:46,340 --> 00:07:52,100
Jadi, ini akan menjadi cukup banyak
kebalikan dari init, di mana init,

136
00:07:52,100 --> 00:07:56,920
ingat, kita menginisialisasi papan
15, 14, 13, 12, seterusnya.

137
00:07:56,920 --> 00:08:03,000
Sedangkan menang, kita ingin memeriksa apakah
papan 1, 2, 3, 4, 5, dan seterusnya.

138
00:08:03,000 --> 00:08:06,600
>> Jadi, kita akan menginisialisasi kami
counter untuk 1 karena itu adalah apa atas

139
00:08:06,600 --> 00:08:08,400
kiri dewan harus.

140
00:08:08,400 --> 00:08:10,860
Dan kemudian kita akan lingkaran
atas seluruh papan.

141
00:08:10,860 --> 00:08:13,690
Mari kita mengabaikan kondisi ini
untuk kedua.

142
00:08:13,690 --> 00:08:18,410
Dan kondisi ini hanya akan
cek adalah papan pada posisi ini

143
00:08:18,410 --> 00:08:20,790
sama dengan jumlah saat ini?

144
00:08:20,790 --> 00:08:27,040
Jika demikian, kenaikan jumlah sehingga
Posisi berikutnya kita melihat satu lebih tinggi

145
00:08:27,040 --> 00:08:29,690
dari posisi kita berada di sekarang.

146
00:08:29,690 --> 00:08:32,700
>> Jadi itulah bagaimana kita mendapatkan
kiri atas harus 1.

147
00:08:32,700 --> 00:08:33,950
Kenaikan hitungan ke 2.

148
00:08:33,950 --> 00:08:35,010
Lihatlah posisi berikutnya.

149
00:08:35,010 --> 00:08:35,690
Apakah ini 2?

150
00:08:35,690 --> 00:08:37,659
Jika demikian, kenaikan hitungan ke 3.

151
00:08:37,659 --> 00:08:39,179
Posisi berikutnya, adalah 3 ini?

152
00:08:39,179 --> 00:08:42,440
Jika demikian, kenaikan menghitung
sampai 4, dan seterusnya.

153
00:08:42,440 --> 00:08:49,190
Jadi, jika ada posisi apapun pada
papan yang tidak sama jumlah kami,

154
00:08:49,190 --> 00:08:52,640
maka kita ingin kembali palsu karena itu
berarti ada beberapa ubin yang

155
00:08:52,640 --> 00:08:55,490
tidak dalam posisi yang benar.

156
00:08:55,490 --> 00:08:58,810
>> Jadi di sini, apa yang kondisi ini lakukan?

157
00:08:58,810 --> 00:09:02,170
Nah, ingat bahwa kosong adalah
seharusnya pergi di kanan bawah.

158
00:09:02,170 --> 00:09:06,180
Dan nilai kosong yang tidak mungkin
tentu sama dengan nilai

159
00:09:06,180 --> 00:09:11,080
counter yang akan dicapai
di bagian kanan bawah.

160
00:09:11,080 --> 00:09:15,760
Jadi kami secara khusus ingin memeriksa apakah i
sama sama d dikurangi 1 dan j equals

161
00:09:15,760 --> 00:09:19,470
sama d dikurangi 1 - yang mengatakan jika kita
cari di bagian kanan bawah

162
00:09:19,470 --> 00:09:22,050
papan - maka kita hanya
ingin melanjutkan.

163
00:09:22,050 --> 00:09:26,200
Kami ingin melewatkan ini khusus
iterasi untuk loop.

164
00:09:26,200 --> 00:09:31,250
>> Jadi, jika kita berhasil melewati ini
bersarang untuk loop, yang berarti bahwa

165
00:09:31,250 --> 00:09:34,690
tidak ada ubin yang berada di
posisi yang salah.

166
00:09:34,690 --> 00:09:38,900
Dan kami keluar dari loop dan datang
di sini, di mana kita bisa kembali benar.

167
00:09:38,900 --> 00:09:41,800
Semua ubin berada di posisi yang benar
dan itu berarti pengguna memiliki

168
00:09:41,800 --> 00:09:43,230
memenangkan pertandingan.

169
00:09:43,230 --> 00:09:44,460
Dan itu saja.

170
00:09:44,460 --> 00:09:46,550
Nama saya Rob Bowden, dan ini adalah 15.

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