1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Bagian 3] [Kurang Nyaman]

2
00:00:03,000 --> 00:00:05,000
>> [Nate Hardison] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Ini adalah CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Baiklah, mari kita mulai.

5
00:00:10,000 --> 00:00:13,000
Selamat Datang Minggu 4 dari CS50.

6
00:00:13,000 --> 00:00:19,000
Jika kalian membuka web browser dan membuka pset 3,

7
00:00:19,000 --> 00:00:23,000
Perebutan dengan CS50, kita akan mulai terjadi

8
00:00:23,000 --> 00:00:26,000
melalui bagian dari pertanyaan di sana.

9
00:00:26,000 --> 00:00:32,000
Sama seperti minggu lalu, kita akan bekerja di CS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
jika Anda juga akan menarik bahwa sampai juga,

11
00:00:35,000 --> 00:00:43,000
dan jika Anda pergi ke depan dan kunjungi link yang saya punya di sini di bagian atas.

12
00:00:43,000 --> 00:00:45,000
Sudah waktunya untuk memulai.

13
00:00:45,000 --> 00:00:51,000
Kami punya hi kecil kami program di sini. Gila apa-apa.

14
00:00:51,000 --> 00:00:55,000
Salah satu hal pertama yang saya ingin lakukan dengan kalian hari ini adalah pergi ke beberapa solusi

15
00:00:55,000 --> 00:00:58,000
untuk Set, Soal 1 jenis solusi misalnya,

16
00:00:58,000 --> 00:01:03,000
saja sehingga Anda bisa mendapatkan merasakan apa jenis staf kode menulis,

17
00:01:03,000 --> 00:01:07,000
apa jenis siswa kode lain menulis,

18
00:01:07,000 --> 00:01:10,000
dan memiliki Anda mengambil melihat hal itu karena saya tahu itu aneh

19
00:01:10,000 --> 00:01:14,000
ketika Anda mengirimkan solusi untuk sejumlah masalah dan mendapatkan komentar

20
00:01:14,000 --> 00:01:18,000
pada versi Anda sendiri, tapi kadang-kadang sangat membantu untuk melihat bagaimana orang lain melakukannya,

21
00:01:18,000 --> 00:01:22,000
terutama yang nice looking.

22
00:01:22,000 --> 00:01:27,000
Untuk sebagian besar, saya benar-benar terkesan dengan solusi yang kalian dihasilkan.

23
00:01:27,000 --> 00:01:31,000
Saya belum mulai melihat 2s Set Anda Soal, tetapi jika mereka sesuatu seperti yang pertama,

24
00:01:31,000 --> 00:01:34,000
itu berarti apa-apa selain hal-hal baik.

25
00:01:34,000 --> 00:01:40,000
>> Jika Anda melihat revisi saya, mari kita mulai sepanjang jalan turun di Revisi 1,

26
00:01:40,000 --> 00:01:47,000
dan kita akan mengambil cepat melihat solusi Mario.

27
00:01:47,000 --> 00:01:54,000
Jika Anda menarik ini, program-program yang kita akan hadir adalah benar.

28
00:01:54,000 --> 00:01:56,000
Tidak ada masalah dengan benar masalah ini, melainkan,

29
00:01:56,000 --> 00:01:59,000
kami ingin berbicara sedikit tentang masalah desain yang berbeda

30
00:01:59,000 --> 00:02:03,000
yang sedang digunakan di sini.

31
00:02:03,000 --> 00:02:08,000
Salah satu hal yang menarik tentang solusi

32
00:02:08,000 --> 00:02:11,000
adalah bahwa hal itu digunakan ini membangun baru yang disebut pon mendefinisikan,

33
00:02:11,000 --> 00:02:15,000
kadang-kadang juga disebut sebagai hash menentukan.

34
00:02:15,000 --> 00:02:18,000
Biarkan aku memperbesar di sini.

35
00:02:18,000 --> 00:02:24,000
Sebuah # define memungkinkan Anda untuk memberikan nama ke nomor tersebut dalam program Anda.

36
00:02:24,000 --> 00:02:28,000
Dalam kasus ini, ketinggian maksimum piramida di Mario

37
00:02:28,000 --> 00:02:34,000
adalah 23 dan bukannya menempatkan 23 di saya kode-

38
00:02:34,000 --> 00:02:37,000
kita akan lihat bahwa sebagai hard coding 23 -

39
00:02:37,000 --> 00:02:43,000
bukannya ini memberikan MAX_HEIGHT nama ke nomor tersebut,

40
00:02:43,000 --> 00:02:48,000
sehingga di sini dalam do-while loop saya

41
00:02:48,000 --> 00:02:51,000
Anda benar-benar dapat merujuk ke MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
bukannya menempatkan nomor 23 masuk

43
00:02:55,000 --> 00:02:57,000
[Mahasiswa] Apa keuntungan dari melakukan hal itu?

44
00:02:57,000 --> 00:02:59,000
Itu pertanyaan yang bagus.

45
00:02:59,000 --> 00:03:03,000
Salah satunya adalah pembacaan.

46
00:03:03,000 --> 00:03:08,000
Keuntungan menggunakan # define adalah pembacaan.

47
00:03:08,000 --> 00:03:11,000
Ketika saya membaca kode ini, saya bisa melihat apa yang terjadi.

48
00:03:11,000 --> 00:03:15,000
>> Aku bisa melihat di sini bahwa kondisi ini kita sedang menguji

49
00:03:15,000 --> 00:03:19,000
dari ketinggian menjadi <0, yang kita bisa juga didefinisikan

50
00:03:19,000 --> 00:03:22,000
menjadi ketinggian minimum atau ketinggian min.

51
00:03:22,000 --> 00:03:25,000
Keuntungan lainnya adalah bahwa saya kemudian dapat membaca seluruh baris untuk melihat

52
00:03:25,000 --> 00:03:30,000
bahwa kita juga memeriksa untuk memastikan bahwa ketinggian tidak lebih besar dari ketinggian max,

53
00:03:30,000 --> 00:03:35,000
karena kita akan terus sementara tingginya lebih besar dari ketinggian maks.

54
00:03:35,000 --> 00:03:40,000
Keuntungan lainnya adalah-jika saya zoom out sedikit di sini-

55
00:03:40,000 --> 00:03:49,000
jika saya menjalankan program ini dan saya menjalankannya, mengatakan, dengan 23 sekarang,

56
00:03:49,000 --> 00:03:52,000
akan mencetak semua 23 baris begitu saja.

57
00:03:52,000 --> 00:03:54,000
Tapi mengatakan bahwa saya ingin mengubah ketinggian max,

58
00:03:54,000 --> 00:03:57,000
dan sekarang saya ingin membatasi ketinggian maksimum piramida

59
00:03:57,000 --> 00:04:06,000
menjadi hanya mengatakan-man, yang funky.

60
00:04:06,000 --> 00:04:14,000
# Include, # define MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
dan katakanlah kita ingin mengatur itu sama dengan 10.

62
00:04:18,000 --> 00:04:22,000
Sekarang pada titik ini, semua saya harus lakukan adalah mengubahnya dalam satu lokasi.

63
00:04:22,000 --> 00:04:27,000
Saya bisa mengkompilasi ulang kode, dan sekarang jika saya mencoba dan ketik 12,

64
00:04:27,000 --> 00:04:30,000
ia akan meminta lagi.

65
00:04:30,000 --> 00:04:33,000
Dalam kasus ini, kita hanya menggunakan MAX_HEIGHT sekali.

66
00:04:33,000 --> 00:04:37,000
Ini tidak begitu besar dari kerumitan untuk pergi dalam

67
00:04:37,000 --> 00:04:40,000
dan mengubahnya dalam loop sementara jika Anda perlu.

68
00:04:40,000 --> 00:04:44,000
Namun dalam program di mana Anda referensi angka ajaib yang sama

69
00:04:44,000 --> 00:04:47,000
berulang-ulang, hal ini # define mekanisme benar-benar berguna

70
00:04:47,000 --> 00:04:52,000
karena Anda hanya mengubah satu kali di bagian atas dari file-itu biasanya di mana Anda menempatkan mereka-

71
00:04:52,000 --> 00:04:57,000
dan perubahan merembes melalui sisa file.

72
00:04:57,000 --> 00:05:02,000
>> Hal-hal lain saya ingin untuk dicatat dalam tugas ini yang saya pikir tampak sangat bagus,

73
00:05:02,000 --> 00:05:05,000
salah satu adalah penamaan variabel.

74
00:05:05,000 --> 00:05:14,000
Anda lihat di sini bahwa kita punya variabel integer disebut baris dan disebut tinggi.

75
00:05:14,000 --> 00:05:20,000
Spasi, hash, ia membantu membuat kode sedikit lebih mudah dibaca,

76
00:05:20,000 --> 00:05:25,000
membuatnya sedikit lebih dimengerti apa yang sebenarnya terjadi.

77
00:05:25,000 --> 00:05:31,000
Hal ini berbeda untuk menggunakan, katakanlah, huruf acak

78
00:05:31,000 --> 00:05:35,000
atau hanya omong kosong sama sekali.

79
00:05:35,000 --> 00:05:39,000
Suatu hal terakhir yang saya akan menunjukkan adalah bahwa dalam untuk loop,

80
00:05:39,000 --> 00:05:45,000
sering kali ini iterator variabel, loket ini yang Anda gunakan dalam Anda untuk loop,

81
00:05:45,000 --> 00:05:51,000
itu standar dan konvensional untuk memulai mereka dengan baik i dan j kemudian dan kemudian k

82
00:05:51,000 --> 00:05:54,000
dan pergi dari sana jika Anda membutuhkan lebih banyak variabel,

83
00:05:54,000 --> 00:05:56,000
dan ini hanya sebuah konvensi.

84
00:05:56,000 --> 00:05:58,000
Ada banyak konvensi.

85
00:05:58,000 --> 00:06:00,000
Hal ini tergantung pada bahasa pemrograman yang Anda gunakan.

86
00:06:00,000 --> 00:06:04,000
Tapi di C, kita biasanya mulai dengan i.

87
00:06:04,000 --> 00:06:08,000
Ini tidak masuk akal untuk menggunakan, katakanlah, atau b

88
00:06:08,000 --> 00:06:13,000
tergantung pada situasi.

89
00:06:13,000 --> 00:06:15,000
Itu saja untuk yang satu ini.

90
00:06:15,000 --> 00:06:25,000
Jika Anda sekarang menarik Revisi 2, Anda akan melihat lain Mario,

91
00:06:25,000 --> 00:06:29,000
dan yang satu ini mirip dengan yang lain yang baru saja kita lihat,

92
00:06:29,000 --> 00:06:32,000
tetapi tidak sesuatu yang baik dari dingin.

93
00:06:32,000 --> 00:06:38,000
Jika kita melihat pada bagian ini di sini di dalam batin untuk loop,

94
00:06:38,000 --> 00:06:44,000
mereka menggunakan beberapa sintaks mencari gila di sini tepat di baris ini.

95
00:06:44,000 --> 00:06:47,000
Ini disebut ternary operator.

96
00:06:47,000 --> 00:06:53,000
Ini adalah sebuah pernyataan jika lain diringkas menjadi satu baris.

97
00:06:53,000 --> 00:06:57,000
Kondisi ini ini bagian dalam tanda kurung.

98
00:06:57,000 --> 00:07:05,000
Ini setara dengan mengatakan jika j <tinggi - i - 1.

99
00:07:05,000 --> 00:07:10,000
Dan kemudian apa isi dari bahwa jika blok yang akan ruang

100
00:07:10,000 --> 00:07:16,000
dan kemudian isi apa lagi yang akan yang ini #.

101
00:07:16,000 --> 00:07:20,000
Ini dasarnya menetapkan ruang untuk variabel ini.

102
00:07:20,000 --> 00:07:24,000
Ini menempatkan ruang dalam isi dari variabel blok,

103
00:07:24,000 --> 00:07:29,000
jika kondisi ini terpenuhi, dan jika kondisi ini tidak terpenuhi,

104
00:07:29,000 --> 00:07:32,000
maka variabel blok ini mendapatkan #.

105
00:07:32,000 --> 00:07:37,000
Dan kemudian, tentu saja, bukan membangun sebuah string seluruh

106
00:07:37,000 --> 00:07:43,000
dan mencetak segala sesuatu pada akhirnya solusi ini mencetaknya keluar satu karakter pada satu waktu.

107
00:07:43,000 --> 00:07:48,000
Pretty cool.

108
00:07:48,000 --> 00:07:53,000
>> Lain beberapa hal untuk melihat. Kami akan pindah ke serakah.

109
00:07:53,000 --> 00:07:58,000
Sekarang jika kita melihat serakah, ini solusi pertama

110
00:07:58,000 --> 00:08:00,000
menggunakan ini # mendefinisikan cukup sedikit.

111
00:08:00,000 --> 00:08:06,000
Kami punya satu konstan yang didefinisikan untuk masing-masing nomor yang berbeda dalam program ini.

112
00:08:06,000 --> 00:08:12,000
Kami punya satu untuk sen per dolar, satu untuk tempat, dime, sen, dan uang,

113
00:08:12,000 --> 00:08:15,000
dan sekarang jika kita scroll ke bawah dan membaca kode,

114
00:08:15,000 --> 00:08:22,000
kita bisa melihat semua yang dilakukan-while pencetakan standar keluar.

115
00:08:22,000 --> 00:08:25,000
Jenis inti dari masalah ini menyadari bahwa

116
00:08:25,000 --> 00:08:29,000
Anda perlu mengkonversi pelampung yang Anda baca dalam dari pengguna ke integer

117
00:08:29,000 --> 00:08:32,000
untuk secara akurat melakukan matematika, dan ini adalah karena

118
00:08:32,000 --> 00:08:36,000
dengan angka floating point, seperti kita bicarakan dalam ceramah singkat,

119
00:08:36,000 --> 00:08:41,000
itu tidak mungkin untuk secara akurat mewakili setiap nilai tunggal pada garis bilangan

120
00:08:41,000 --> 00:08:47,000
karena ada nilai-nilai tak terhingga banyaknya antara 3 dan, katakanlah, bahkan 3,1.

121
00:08:47,000 --> 00:08:54,000
Anda dapat memiliki 3,01 dan 3,001 dan 3,0001, dan Anda dapat terus berjalan.

122
00:08:54,000 --> 00:09:00,000
Ternyata setiap kali Anda bekerja dengan uang, Anda sering ingin mengubahnya

123
00:09:00,000 --> 00:09:05,000
dalam format integer sehingga Anda tidak kehilangan uang dan hal semacam itu.

124
00:09:05,000 --> 00:09:09,000
Melakukan itu dan pembulatan adalah kunci.

125
00:09:09,000 --> 00:09:14,000
Solusi ini menggunakan algoritma, sempurna langsung besar,

126
00:09:14,000 --> 00:09:17,000
yang decremented jumlah sen tersisa, pertama oleh kuartal,

127
00:09:17,000 --> 00:09:19,000
kemudian oleh dimes, maka dengan uang receh, maka dengan uang,

128
00:09:19,000 --> 00:09:24,000
dan menambah jumlah koin setiap kali.

129
00:09:24,000 --> 00:09:31,000
>> Solusi lain yang akan kita lihat, karena saya zoom out dan pergi ke Revisi 4,

130
00:09:31,000 --> 00:09:40,000
memiliki awal yang sangat mirip, tetapi malah digunakan div dan mod

131
00:09:40,000 --> 00:09:44,000
tepat di sini untuk menghitung jumlah sen.

132
00:09:44,000 --> 00:09:50,000
Ini, jumlah perempat adalah sama dengan jumlah sen dibagi dengan 25,

133
00:09:50,000 --> 00:09:53,000
dan alasan ini bekerja adalah karena kita sedang melakukan pembagian integer,

134
00:09:53,000 --> 00:09:58,000
jadi membuang sisa.

135
00:09:58,000 --> 00:10:02,000
[Mahasiswa] Apakah kita harus komentar pencarian?

136
00:10:02,000 --> 00:10:05,000
Ini benar-benar tergantung.

137
00:10:05,000 --> 00:10:08,000
[Mahasiswa] Kau komentar lebih dari kode di sini.

138
00:10:08,000 --> 00:10:16,000
Ya, dan jadi ada sekelompok dari berbagai filosofi ini.

139
00:10:16,000 --> 00:10:21,000
Filosofi pribadi saya adalah bahwa kode Anda benar-benar kebenaran,

140
00:10:21,000 --> 00:10:24,000
seperti kode Anda adalah apa yang benar-benar melaksanakan pada komputer,

141
00:10:24,000 --> 00:10:29,000
sehingga kode Anda harus sebagai dibaca mungkin untuk tidak memerlukan banyak komentar.

142
00:10:29,000 --> 00:10:33,000
Yang mengatakan, ketika Anda melakukan hal-hal yang agak sulit matematis

143
00:10:33,000 --> 00:10:38,000
atau algorithmically, ada baiknya untuk komentar mereka sehingga Anda dapat

144
00:10:38,000 --> 00:10:43,000
menambah dimensi ekstra, lapisan tambahan untuk siapa pun yang membaca kode Anda.

145
00:10:43,000 --> 00:10:49,000
Dalam solusi ini, sering kali mereka berkomentar lebih banyak hanya karena

146
00:10:49,000 --> 00:10:52,000
kami ingin dapat mendistribusikan mereka dan memiliki orang-orang menjemput mereka

147
00:10:52,000 --> 00:10:56,000
dan membacanya dengan mudah.

148
00:10:56,000 --> 00:11:05,000
Tapi yang pasti, saya akan setuju bahwa ini adalah berat.

149
00:11:05,000 --> 00:11:07,000
[Mahasiswa] Tapi ketika dalam keraguan, pergi lebih berat?

150
00:11:07,000 --> 00:11:10,000
Jika ragu, pergi lebih berat.

151
00:11:10,000 --> 00:11:17,000
Beberapa orang kadang akan mengatakan 0 kembali atau sesuatu seperti itu.

152
00:11:17,000 --> 00:11:20,000
Saya pikir itu konyol komentar.

153
00:11:20,000 --> 00:11:22,000
Jelas itulah yang terjadi.

154
00:11:22,000 --> 00:11:25,000
Saya tidak perlu bahasa Inggris untuk memberitahu saya bahwa.

155
00:11:25,000 --> 00:11:28,000
Kadang-kadang orang akan menulis hal-hal seperti "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Itu agak lucu tapi juga tidak-

157
00:11:32,000 --> 00:11:35,000
itu tidak membuat perbedaan antara titik komentar atau tidak.

158
00:11:35,000 --> 00:11:41,000
Mereka jenis komentar hanya ha, ha.

159
00:11:41,000 --> 00:11:43,000
Cool.

160
00:11:43,000 --> 00:11:48,000
>> Pada titik ini, mari kita mulai bekerja pada Masalah Set 3 bagian pertanyaan.

161
00:11:48,000 --> 00:11:52,000
Jika kalian menarik ini lagi,

162
00:11:52,000 --> 00:11:55,000
seperti minggu lalu, kita tidak akan menonton celana pendek di bagian ini.

163
00:11:55,000 --> 00:12:00,000
Kami akan membiarkan kalian melakukan itu pada waktu Anda sendiri dan berbicara tentang pertanyaan.

164
00:12:00,000 --> 00:12:05,000
Tapi sekarang dalam bagian ini kita akan menghabiskan waktu sedikit lebih

165
00:12:05,000 --> 00:12:11,000
berbicara tentang kurang dari dasar-dasar pengkodean

166
00:12:11,000 --> 00:12:15,000
seperti yang kami lakukan pekan lalu, dan sebagai gantinya, kita akan lebih fokus pada

167
00:12:15,000 --> 00:12:22,000
sedikit lebih dari teori, sehingga berbicara tentang pencarian biner dan kemudian menyortir.

168
00:12:22,000 --> 00:12:27,000
Dari anda yang telah mengikuti bersama dengan kuliah,

169
00:12:27,000 --> 00:12:30,000
bisa seseorang memberi saya rekap dari apa perbedaannya

170
00:12:30,000 --> 00:12:35,000
antara pencarian biner dan pencarian linier?

171
00:12:35,000 --> 00:12:37,000
Apa yang terjadi? Tentu.

172
00:12:37,000 --> 00:12:42,000
Linear pencarian pencarian melalui setiap elemen dalam daftar diurutkan

173
00:12:42,000 --> 00:12:45,000
satu per satu per satu oleh satu per satu,

174
00:12:45,000 --> 00:12:50,000
dan pencarian biner membagi daftar menjadi 2 kelompok,

175
00:12:50,000 --> 00:12:57,000
memeriksa apakah nilai kunci yang Anda cari lebih besar atau lebih kecil dari nilai titik tengah

176
00:12:57,000 --> 00:13:00,000
bahwa Anda hanya menemukan, dan jika kurang dari, ia pergi dengan daftar yang lebih rendah

177
00:13:00,000 --> 00:13:03,000
dan kemudian membagi itu lagi, apakah fungsi yang sama

178
00:13:03,000 --> 00:13:07,000
semua jalan ke bawah sampai menemukan titik tengah untuk menjadi sama dengan nilai itu sendiri.

179
00:13:07,000 --> 00:13:10,000
Benar.

180
00:13:10,000 --> 00:13:12,000
>> Mengapa kita peduli?

181
00:13:12,000 --> 00:13:20,000
Mengapa kita berbicara tentang pencarian biner dibandingkan pencarian linear?

182
00:13:20,000 --> 00:13:22,000
Ya.

183
00:13:22,000 --> 00:13:24,000
Biner adalah jauh lebih cepat, jadi jika Anda dua kali lipat ukuran masalah

184
00:13:24,000 --> 00:13:27,000
dibutuhkan satu langkah lagi lebih dari dua kali lebih banyak.

185
00:13:27,000 --> 00:13:29,000
Tepat.

186
00:13:29,000 --> 00:13:31,000
Itu jawaban yang bagus.

187
00:13:31,000 --> 00:13:36,000
Pencarian linear sangat banyak memeriksa satu elemen pada suatu waktu,

188
00:13:36,000 --> 00:13:39,000
dan seperti yang kita lihat pada hari pertama kuliah

189
00:13:39,000 --> 00:13:42,000
Ketika Daud pergi melalui contoh bukunya telepon

190
00:13:42,000 --> 00:13:45,000
dan merobek satu halaman dari buku telepon pada suatu waktu

191
00:13:45,000 --> 00:13:47,000
dan terus melakukan hal itu berulang-ulang,

192
00:13:47,000 --> 00:13:51,000
itu akan membawanya waktu yang sangat lama untuk menemukan siapa pun di buku telepon,

193
00:13:51,000 --> 00:13:55,000
kecuali, tentu saja, ia sedang mencari seseorang di awal alfabet.

194
00:13:55,000 --> 00:14:00,000
Dengan pencarian biner, Anda dapat pergi jauh lebih cepat,

195
00:14:00,000 --> 00:14:05,000
dan itu bukan hanya dua kali lebih cepat atau 3 kali lebih cepat atau 4 kali lebih cepat.

196
00:14:05,000 --> 00:14:13,000
Tapi masalahnya semakin kecil dan lebih kecil dan lebih kecil lebih cepat.

197
00:14:13,000 --> 00:14:17,000
Untuk menggambarkan hal ini, kita akan mulai berbicara tentang apa yang terjadi

198
00:14:17,000 --> 00:14:21,000
ketika kita menulis pencarian biner.

199
00:14:21,000 --> 00:14:27,000
Masalah yang dihadapi adalah bahwa jika saya memiliki sebuah array angka,

200
00:14:27,000 --> 00:14:40,000
katakanlah, 1, 2, 3, 5, 7, 23, 45, 78, 12323,

201
00:14:40,000 --> 00:14:47,000
dan kemudian dengan 9 ton 0s setelah itu,

202
00:14:47,000 --> 00:14:52,000
kami ingin dapat mengetahui dengan sangat cepat apa yang ada di

203
00:14:52,000 --> 00:14:57,000
ini array angka.

204
00:14:57,000 --> 00:15:00,000
Saya tahu ini tampaknya sedikit konyol dan sedikit dibikin,

205
00:15:00,000 --> 00:15:02,000
karena sekarang itu.

206
00:15:02,000 --> 00:15:05,000
Kami memiliki sebuah array yang tidak memiliki unsur-unsur yang sangat banyak di dalamnya,

207
00:15:05,000 --> 00:15:08,000
dan jika saya meminta salah satu dari Anda untuk mengetahui apakah atau tidak

208
00:15:08,000 --> 00:15:11,000
23 adalah dalam array, Anda dapat melakukannya cukup cepat

209
00:15:11,000 --> 00:15:16,000
hanya dengan melirik hal ini dan mengatakan ya atau tidak.

210
00:15:16,000 --> 00:15:20,000
Analog yang perlu dipertimbangkan adalah bayangkan jika ini adalah, katakanlah,

211
00:15:20,000 --> 00:15:27,000
Excel spreadsheet dengan 10.000 baris, 20.000 baris.

212
00:15:27,000 --> 00:15:31,000
Tentu saja, Anda dapat melakukan perintah F atau F kontrol dan melihat sesuatu.

213
00:15:31,000 --> 00:15:33,000
Anda juga dapat menggunakan filter dan hal-hal pencarian,

214
00:15:33,000 --> 00:15:37,000
tetapi jika Anda harus melihat melalui itu file baris demi baris demi baris,

215
00:15:37,000 --> 00:15:40,000
itu akan membawa Anda waktu lama untuk menemukannya.

216
00:15:40,000 --> 00:15:42,000
Ini semacam seperti dalam contoh buku telepon, juga, di mana

217
00:15:42,000 --> 00:15:44,000
tidak ada yang terlihat melalui halaman buku telepon satu per satu.

218
00:15:44,000 --> 00:15:47,000
Biasanya, mereka membukanya ke tengah,

219
00:15:47,000 --> 00:15:50,000
atau dalam kasus banyak buku telepon dan kamus mana

220
00:15:50,000 --> 00:15:54,000
Anda benar-benar memilikinya mengetik pada huruf pertama,

221
00:15:54,000 --> 00:16:01,000
Anda flip untuk surat pertama dan membuka dan mulai pergi lewat sana.

222
00:16:01,000 --> 00:16:03,000
>> Ingatkan saya nama Anda lagi. >> Sam.

223
00:16:03,000 --> 00:16:05,000
Sam.

224
00:16:05,000 --> 00:16:11,000
Seperti Sam mengatakan, bahwa proses pencarian linear akan menjadi sangat lambat,

225
00:16:11,000 --> 00:16:15,000
dan bukannya dengan pencarian biner, cara ini bekerja adalah bahwa

226
00:16:15,000 --> 00:16:21,000
setiap kali kita pergi melalui iterasi algoritma pencarian kami,

227
00:16:21,000 --> 00:16:27,000
kita akan membagi daftar dua, pada dasarnya,

228
00:16:27,000 --> 00:16:33,000
menjadi dua daftar yang lebih kecil.

229
00:16:33,000 --> 00:16:39,000
Dan kemudian pada iterasi berikutnya dari loop, kami akan membaginya lagi

230
00:16:39,000 --> 00:16:44,000
menjadi daftar yang lebih kecil lainnya.

231
00:16:44,000 --> 00:16:48,000
Seperti yang Anda lihat, masalah terus menjadi lebih kecil dan lebih kecil

232
00:16:48,000 --> 00:16:55,000
karena kita tetap membuang setengah dari daftar setiap saat.

233
00:16:55,000 --> 00:16:59,000
Bagaimana ini bekerja membuang?

234
00:16:59,000 --> 00:17:05,000
Hanya sebagai pengingat, apa yang akan kita lakukan jika kita komputer

235
00:17:05,000 --> 00:17:11,000
dan kami, katakanlah, mencari nomor 5 dalam daftar ini

236
00:17:11,000 --> 00:17:15,000
adalah bahwa kita akan memilih nomor di tengah.

237
00:17:15,000 --> 00:17:26,000
Di tengah-tengah daftar ini, karena ada 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 angka,

238
00:17:26,000 --> 00:17:32,000
kita akan memilih nomor baik di posisi ke-4 atau di posisi ke-5,

239
00:17:32,000 --> 00:17:38,000
dan kami akan menelepon bahwa tengah daftar kami.

240
00:17:38,000 --> 00:17:42,000
Pilih nomor di tengah.

241
00:17:42,000 --> 00:17:51,000
Kemudian, seperti Sam mengatakan, kami akan menguji untuk melihat apakah nomor yang sama

242
00:17:51,000 --> 00:17:59,000
ke nomor yang kita ingin mendapatkan atau nomor yang kita inginkan.

243
00:17:59,000 --> 00:18:06,000
Jika itu sama, maka kita telah menemukan itu. Kami menang.

244
00:18:06,000 --> 00:18:12,000
Jika tidak sama, maka ada beberapa kasus.

245
00:18:12,000 --> 00:18:15,000
Dua kasus yang baik jumlahnya harus lebih banyak daripada jumlah yang kita sedang melihat,

246
00:18:15,000 --> 00:18:19,000
atau kurang dari.

247
00:18:19,000 --> 00:18:25,000
Jika itu lebih besar, kita bergerak ke kanan.

248
00:18:25,000 --> 00:18:33,000
Dan jika itu kurang, kita bergerak ke kiri.

249
00:18:33,000 --> 00:18:41,000
Dan kemudian kita ulangi seluruh proses lagi

250
00:18:41,000 --> 00:18:48,000
di kedua setengah kanan atau kiri setengah dari daftar.

251
00:18:48,000 --> 00:18:51,000
>> Masalah pertama dalam bagian hari ini adalah untuk mengetahui

252
00:18:51,000 --> 00:18:55,000
bagaimana kita benar-benar dapat mulai mengungkapkan hal ini dalam kode C.

253
00:18:55,000 --> 00:18:58,000
Kami punya pseudocode di sini.

254
00:18:58,000 --> 00:19:04,000
Apa yang kita akan mulai lakukan adalah saya akan menarik sebuah ruang baru,

255
00:19:04,000 --> 00:19:09,000
menyimpan revisi ini sehingga kita memiliki catatan untuk nanti,

256
00:19:09,000 --> 00:19:20,000
kita akan menghapus semua ini, dan kemudian copy dan paste dari sejumlah masalah

257
00:19:20,000 --> 00:19:26,000
informasi ini ke ruang kami, dan mudah-mudahan ini tidak pecah.

258
00:19:26,000 --> 00:19:28,000
Sempurna.

259
00:19:28,000 --> 00:19:33,000
Jika kalian semua melakukan itu, copy dan paste kode ini ke ruang baru,

260
00:19:33,000 --> 00:19:43,000
menjadi satu kosong.

261
00:19:43,000 --> 00:19:47,000
Mari kita coba Daniel. Jika Anda mengkompilasi dan menjalankan program ini, cara kerjanya?

262
00:19:47,000 --> 00:19:49,000
>> No Apa itu katakan?

263
00:19:49,000 --> 00:19:53,000
Ia mengatakan kontrol mencapai akhir non-void fungsi.

264
00:19:53,000 --> 00:19:55,000
Ya, jadi saya mencoba menjalankannya.

265
00:19:55,000 --> 00:19:59,000
Pernahkah kalian melihat ini sebelumnya? Apakah Anda tahu apa artinya ini?

266
00:19:59,000 --> 00:20:01,000
Oke, mari kita membedah ini sedikit.

267
00:20:01,000 --> 00:20:10,000
Ini mengatakan di file.c on line 9, kolom 1 kita memiliki kesalahan, seperti yang Anda katakan,

268
00:20:10,000 --> 00:20:16,000
dan mengatakan bahwa itu berasal dari peringatan kesalahan dan peringatan tipe kembali.

269
00:20:16,000 --> 00:20:18,000
Sepertinya ada sesuatu yang terjadi dengan jenis kembali, yang masuk akal.

270
00:20:18,000 --> 00:20:21,000
Kami punya fungsi non-void, yang berarti bahwa kita punya fungsi

271
00:20:21,000 --> 00:20:24,000
yang tidak mengembalikan batal.

272
00:20:24,000 --> 00:20:27,000
Sebuah fungsi void adalah salah satu yang terlihat seperti ini:

273
00:20:27,000 --> 00:20:35,000
void foo (), dan itu batal karena tipe kembali adalah tidak sah,

274
00:20:35,000 --> 00:20:38,000
yang berarti bahwa jika kita memiliki sesuatu di sini

275
00:20:38,000 --> 00:20:45,000
seperti return 1, kita akan mendapatkan kesalahan kompilator untuk ini.

276
00:20:45,000 --> 00:20:49,000
Namun, kami memiliki fungsi non-void.

277
00:20:49,000 --> 00:20:51,000
Non-void fungsi kita dalam hal ini adalah fungsi pencarian kami

278
00:20:51,000 --> 00:20:56,000
karena memiliki jenis kembalinya bool.

279
00:20:56,000 --> 00:20:59,000
Ketika itu mengatakan bahwa kontrol mencapai akhir dari fungsi non-void,

280
00:20:59,000 --> 00:21:02,000
itu karena pencarian tidak memiliki pernyataan kembali.

281
00:21:02,000 --> 00:21:04,000
Ini tidak mengembalikan apa-apa tipe bool.

282
00:21:04,000 --> 00:21:09,000
>> Kita bisa memperbaikinya, dan apa yang kalian pikirkan

283
00:21:09,000 --> 00:21:13,000
pencarian harus kembali secara default?

284
00:21:13,000 --> 00:21:16,000
Apa yang harus menjadi pengembalian nilai default pencarian?

285
00:21:16,000 --> 00:21:19,000
Karena itulah apa yang kita dapat menempatkan di akhir.

286
00:21:19,000 --> 00:21:21,000
Charlotte, apakah Anda punya-?

287
00:21:21,000 --> 00:21:23,000
Benar atau salah >> Benar atau salah?.

288
00:21:23,000 --> 00:21:26,000
Yang mana?

289
00:21:26,000 --> 00:21:28,000
False. Saya tidak tahu.

290
00:21:28,000 --> 00:21:30,000
Salah? Mari kita coba.

291
00:21:30,000 --> 00:21:32,000
Mengapa Anda katakan return false? Itulah intuisi yang besar.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Saya tidak tahu.

293
00:21:35,000 --> 00:21:39,000
Kita akan kembali palsu dalam kasus ini karena ini akan menjadi default kita

294
00:21:39,000 --> 00:21:44,000
jika karena alasan tertentu daftar kosong atau jarum

295
00:21:44,000 --> 00:21:46,000
yang kita cari tidak ada.

296
00:21:46,000 --> 00:21:50,000
Kemudian di akhir, jika kita tidak kembali benar sebelumnya dalam fungsi ini,

297
00:21:50,000 --> 00:21:55,000
kita selalu tahu bahwa fungsi ini akan mengatakan nope, itu tidak dalam array.

298
00:21:55,000 --> 00:21:58,000
Hal ini tidak di tumpukan jerami.

299
00:21:58,000 --> 00:22:03,000
Sekarang jika kita mengkompilasi dan menjalankannya-biarkan aku menyimpan ini sehingga kita bisa tarik ke atas.

300
00:22:03,000 --> 00:22:08,000
Sekarang jika kita mengkompilasi dan menjalankan program kami, itu membangun.

301
00:22:08,000 --> 00:22:12,000
Kami mendapatkan prompt kecil kami.

302
00:22:12,000 --> 00:22:20,000
Jika saya memukul 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Ini tidak mencetak apa pun. Sepertinya semuanya berakhir baik-baik saja.

304
00:22:25,000 --> 00:22:35,000
Kita harus mengisi masuk

305
00:22:35,000 --> 00:22:39,000
Kami berbicara tentang algoritma dalam pseudocode sedikit lalu.

306
00:22:39,000 --> 00:22:44,000
Biarkan aku melihat, menyimpan,

307
00:22:44,000 --> 00:22:49,000
dan Aku akan menarik algoritma yang kembali lagi.

308
00:22:49,000 --> 00:22:51,000
Mari kita memukul orang ini. Nope.

309
00:22:51,000 --> 00:22:58,000
Ada itu.

310
00:22:58,000 --> 00:23:03,000
Bagaimana kita melakukan ini?

311
00:23:03,000 --> 00:23:11,000
Apa yang akan menjadi strategi yang baik untuk memulai off kode ini?

312
00:23:11,000 --> 00:23:16,000
Anda harus memilih nomor di tengah.

313
00:23:16,000 --> 00:23:23,000
Bagaimana kita memilih nomor di tengah array?

314
00:23:23,000 --> 00:23:25,000
Ada saran?

315
00:23:25,000 --> 00:23:27,000
[Mahasiswa] Strlen dibagi 2.

316
00:23:27,000 --> 00:23:32,000
Strlen dibagi 2. Itu salah besar.

317
00:23:32,000 --> 00:23:35,000
Strlen bekerja dengan jenis khusus dari array.

318
00:23:35,000 --> 00:23:38,000
Apa jenis array?

319
00:23:38,000 --> 00:23:44,000
String array, array karakter.

320
00:23:44,000 --> 00:23:48,000
Ini semacam sama konsep yang kita ingin menerapkan,

321
00:23:48,000 --> 00:23:52,000
tapi kami tidak dapat menggunakan strlen karena kita tidak memiliki sebuah array karakter.

322
00:23:52,000 --> 00:23:55,000
Kami memiliki sebuah array ints.

323
00:23:55,000 --> 00:23:58,000
Tapi apa strlen mendapatkan bagi kita?

324
00:23:58,000 --> 00:24:01,000
Apakah Anda tahu apa itu akan bagi kita?

325
00:24:01,000 --> 00:24:03,000
[Mahasiswa] Strlen membuat kita panjang.

326
00:24:03,000 --> 00:24:05,000
Tepat, itu membuat kita panjang.

327
00:24:05,000 --> 00:24:09,000
Strlen mendapatkan panjang dari array bagi kita.

328
00:24:09,000 --> 00:24:14,000
>> Bagaimana kita mendapatkan bahwa dalam program pencarian kami biner?

329
00:24:14,000 --> 00:24:18,000
Bagaimana Anda mendapatkan panjang array?

330
00:24:18,000 --> 00:24:20,000
[Mahasiswa] Strlen?

331
00:24:20,000 --> 00:24:25,000
Anda bisa mendapatkan panjang array C diformat dengan benar string dengan strlen.

332
00:24:25,000 --> 00:24:31,000
Masalahnya, meskipun, adalah bahwa kita tidak memiliki sebuah array string.

333
00:24:31,000 --> 00:24:36,000
Jika kita melihat kembali kode ini, kita memiliki array integer.

334
00:24:36,000 --> 00:24:38,000
Bagaimana kita tahu berapa lama itu?

335
00:24:38,000 --> 00:24:44,000
[Mahasiswa] Apakah ada yang setara untuk titik akhir, seperti l int atau sesuatu?

336
00:24:44,000 --> 00:24:49,000
Ternyata ada sebenarnya tidak, sehingga dengan cara, ini adalah

337
00:24:49,000 --> 00:24:52,000
salah satu dari hal-hal yang hanya baik untuk tahu tentang C,

338
00:24:52,000 --> 00:24:57,000
bahwa tidak ada cara untuk mendapatkan panjang array

339
00:24:57,000 --> 00:24:59,000
jika semua saya berikan Anda adalah array.

340
00:24:59,000 --> 00:25:02,000
Alasan bekerja dengan string, alasan strlen karya,

341
00:25:02,000 --> 00:25:06,000
karena jika string diformat dengan benar,

342
00:25:06,000 --> 00:25:12,000
itu akan memiliki \ istimewa 0 karakter di akhir.

343
00:25:12,000 --> 00:25:16,000
>> Anda juga dapat bayangkan jika Anda memiliki sebuah string tidak benar diformat

344
00:25:16,000 --> 00:25:20,000
dan tidak ada \ 0 karakter di sana, maka semuanya tidak bekerja.

345
00:25:20,000 --> 00:25:22,000
[Siswa] Dapatkah Anda menambahkan \ 0?

346
00:25:22,000 --> 00:25:24,000
Kita bisa dalam kasus ini.

347
00:25:24,000 --> 00:25:29,000
Kita bisa menambahkan beberapa jenis \ 0

348
00:25:29,000 --> 00:25:33,000
atau semacam menandakan karakter dan kemudian menggunakannya.

349
00:25:33,000 --> 00:25:36,000
Tapi itu tidak cukup akan bekerja

350
00:25:36,000 --> 00:25:40,000
karena 0 \ adalah untuk tipe char,

351
00:25:40,000 --> 00:25:43,000
dan di sini kita punya ints.

352
00:25:43,000 --> 00:25:46,000
Hal lain adalah jika kita menggunakan nilai khusus

353
00:25:46,000 --> 00:25:49,000
seperti -1 untuk menandai akhir array

354
00:25:49,000 --> 00:25:54,000
maka kita tidak pernah bisa menyimpan -1 dalam array bilangan bulat kita.

355
00:25:54,000 --> 00:25:56,000
Kami akan terjebak.

356
00:25:56,000 --> 00:26:00,000
Ternyata bahwa satu-satunya cara untuk mendapatkan panjang

357
00:26:00,000 --> 00:26:03,000
dari array di C adalah untuk benar-benar mengingatnya

358
00:26:03,000 --> 00:26:08,000
ketika Anda mengaturnya dan kemudian menyebarkannya sekitar dengan array

359
00:26:08,000 --> 00:26:14,000
sehingga setiap kali saya memiliki fungsi yang akan melakukan beberapa pekerjaan

360
00:26:14,000 --> 00:26:18,000
pada sebuah array bilangan bulat atau mengapung atau ganda atau apa pun,

361
00:26:18,000 --> 00:26:22,000
Saya juga harus memberikan fungsi panjang array,

362
00:26:22,000 --> 00:26:26,000
dan itulah apa yang kami lakukan di sini di fungsi pencarian.

363
00:26:26,000 --> 00:26:30,000
Jika Anda melihat, apa yang kami lakukan ketika kami melewati dalam array kita di sini,

364
00:26:30,000 --> 00:26:36,000
kami juga lulus dalam panjang, ukuran.

365
00:26:36,000 --> 00:26:41,000
Ini terjadi begitu saja bahwa kita telah disebut variabel ini di sini,

366
00:26:41,000 --> 00:26:43,000
ini parameter atau argumen.

367
00:26:43,000 --> 00:26:46,000
Ini disebut daftar argumen fungsi atau daftar parameter,

368
00:26:46,000 --> 00:26:51,000
dan ini juga disebut argumen atau parameter.

369
00:26:51,000 --> 00:26:53,000
Orang-orang menggunakan istilah yang berbeda pada waktu yang berbeda.

370
00:26:53,000 --> 00:26:55,000
Saya kadang-kadang interchange mereka sendiri.

371
00:26:55,000 --> 00:27:00,000
Kebetulan bahwa variabel di sini adalah bernama sama

372
00:27:00,000 --> 00:27:03,000
ini # define di sini.

373
00:27:03,000 --> 00:27:06,000
Tapi mereka tidak sama.

374
00:27:06,000 --> 00:27:11,000
Kapitalisasi itu penting.

375
00:27:11,000 --> 00:27:14,000
>> Jika Anda melihat apa yang terjadi di sini, kami menyatakan

376
00:27:14,000 --> 00:27:18,000
kami int array, yang kita sudah menelepon nomor.

377
00:27:18,000 --> 00:27:23,000
Kami telah memberikannya ukuran kami, yang sesuai dengan kita # define di paling atas.

378
00:27:23,000 --> 00:27:27,000
Ini akan menjadi 8.

379
00:27:27,000 --> 00:27:35,000
Dan kemudian ketika kita kemudian memanggil fungsi pencarian kami di bawah,

380
00:27:35,000 --> 00:27:40,000
kita lulus dalam nomor kita ingin mencari, yang kami telah diminta,

381
00:27:40,000 --> 00:27:43,000
didapat dari pengguna.

382
00:27:43,000 --> 00:27:46,000
Kami melewati dalam array, ini angka,

383
00:27:46,000 --> 00:27:51,000
dan kemudian kita juga harus lulus dalam ukuran array,

384
00:27:51,000 --> 00:27:57,000
dan kemudian nilai ukuran 8 akan disimpan

385
00:27:57,000 --> 00:28:01,000
atau diteruskan ke ukuran ini disebut integer variabel.

386
00:28:01,000 --> 00:28:08,000
Kami memiliki ukuran array.

387
00:28:08,000 --> 00:28:11,000
Sekarang jika kita kembali ke apa yang kita bicarakan sebelumnya,

388
00:28:11,000 --> 00:28:14,000
Saya pikir Missy dibesarkan titik bahwa apa yang perlu kita lakukan adalah mendapatkan panjang array

389
00:28:14,000 --> 00:28:20,000
dan dibagi oleh 2, dan itu akan memberi kita titik tengah.

390
00:28:20,000 --> 00:28:22,000
Mari kita lihat.

391
00:28:22,000 --> 00:28:25,000
Dapatkah saya memiliki seseorang menulis ini dan menyimpannya dalam ruang mereka?

392
00:28:25,000 --> 00:28:27,000
Bagaimana Leila?

393
00:28:27,000 --> 00:28:31,000
Dapatkah saya memiliki Anda menulis dalam hal ini?

394
00:28:31,000 --> 00:28:35,000
Tuliskan baris pertama di mana Anda mengambil panjang array dan mendapatkan titik tengah

395
00:28:35,000 --> 00:28:41,000
dan menyimpannya dalam variabel baru.

396
00:28:41,000 --> 00:28:44,000
Saya akan memberi Anda beberapa detik. Apakah Anda siap?

397
00:28:44,000 --> 00:28:46,000
[Mahasiswa terdengar]

398
00:28:46,000 --> 00:28:50,000
Tentu, aku bisa Anda menghitung titik tengah

399
00:28:50,000 --> 00:28:55,000
dari array tumpukan jerami dalam fungsi pencarian

400
00:28:55,000 --> 00:29:03,000
menggunakan panjang dari array tumpukan jerami, yang merupakan variabel ukuran?

401
00:29:03,000 --> 00:29:08,000
Rumit apa di sini.

402
00:29:08,000 --> 00:29:12,000
[Leila] Hanya ukuran / 2 dan hanya-

403
00:29:12,000 --> 00:29:17,000
Dan menyimpannya, dan tekan tombol Simpan di sini di atas,

404
00:29:17,000 --> 00:29:19,000
dan kami akan tarik ke atas.

405
00:29:19,000 --> 00:29:22,000
Sempurna.

406
00:29:22,000 --> 00:29:28,000
Di sana kami pergi. Mengagumkan.

407
00:29:28,000 --> 00:29:30,000
>> Seperti, ini akan mengkompilasi?

408
00:29:30,000 --> 00:29:32,000
[Leila] Tidak, itu harus lebih tinggi.

409
00:29:32,000 --> 00:29:34,000
[Nate] Ya, jadi apa yang kita perlu lakukan?

410
00:29:34,000 --> 00:29:36,000
[Leila] Seperti titik tengah int atau sesuatu.

411
00:29:36,000 --> 00:29:41,000
Mengagumkan. Ya, mari kita lakukan itu, int titik tengah = ukuran.

412
00:29:41,000 --> 00:29:44,000
Ini akan mengkompilasi?

413
00:29:44,000 --> 00:29:47,000
Mari kita menghapus komentar ini dan mendapatkannya keluar dari jalan.

414
00:29:47,000 --> 00:29:50,000
Apa yang tidak akan mengkompilasi tentang hal ini?

415
00:29:50,000 --> 00:29:52,000
Kami tidak melakukan apa-apa dengan bilangan bulat,

416
00:29:52,000 --> 00:29:55,000
jadi kita perlu untuk mencetak atau sesuatu seperti itu.

417
00:29:55,000 --> 00:29:58,000
Ya, tepatnya.

418
00:29:58,000 --> 00:30:00,000
Kita akan mendapatkan variabel yang tidak terpakai.

419
00:30:00,000 --> 00:30:02,000
Apa lagi tidak akan bekerja tentang hal ini?

420
00:30:02,000 --> 00:30:06,000
Saya pikir Anda mengatakan sesuatu, Sam. Titik koma.

421
00:30:06,000 --> 00:30:08,000
Ya, aku kehilangan orang-titik koma.

422
00:30:08,000 --> 00:30:14,000
Ini akan menjadi hal yang konstan sepanjang perjalanan istilah.

423
00:30:14,000 --> 00:30:17,000
Hal terakhir yang saya akan lakukan adalah saya akan menaruh beberapa ruang putih di kedua sisi

424
00:30:17,000 --> 00:30:23,000
dari operator ini di sini, karena itu biasanya bagaimana kita melakukannya

425
00:30:23,000 --> 00:30:26,000
sesuai dengan panduan gaya kami.

426
00:30:26,000 --> 00:30:29,000
Kami punya titik tengah dari array kita.

427
00:30:29,000 --> 00:30:32,000
Sekarang jika kita ingat kembali ke algoritma kami,

428
00:30:32,000 --> 00:30:37,000
apa langkah kedua yang kita harus lakukan setelah kita memiliki titik tengah?

429
00:30:37,000 --> 00:30:42,000
[Mahasiswa] Jika lebih besar [tak terdengar].

430
00:30:42,000 --> 00:30:48,000
Ya, jadi kita harus melakukan semacam perbandingan, dan apa yang kita membandingkan di sini?

431
00:30:48,000 --> 00:30:53,000
Kau bilang jika lebih besar dari. Apa dalam kalimat maksud?

432
00:30:53,000 --> 00:30:57,000
Jumlah yang muncul, jika itu lebih besar dari titik tengah, kemudian pergi ke array?

433
00:30:57,000 --> 00:31:05,000
Tepat, sehingga jumlah yang muncul ketika kita-

434
00:31:05,000 --> 00:31:10,000
Jarum, jadi kita membandingkan dengan jarum,

435
00:31:10,000 --> 00:31:12,000
dan apa yang kita membandingkan terhadap jarum?

436
00:31:12,000 --> 00:31:15,000
Karena jarum adalah apa yang kita cari.

437
00:31:15,000 --> 00:31:18,000
Kita membandingkannya untuk sampai ke titik tengah.

438
00:31:18,000 --> 00:31:21,000
>> Tapi apakah masuk akal untuk memeriksa untuk melihat

439
00:31:21,000 --> 00:31:27,000
jika jarum titik tengah =?

440
00:31:27,000 --> 00:31:32,000
Apakah itu masuk akal?

441
00:31:32,000 --> 00:31:35,000
Apakah ada yang tidak setuju?

442
00:31:35,000 --> 00:31:40,000
Mari kita mencobanya, jika (jarum == titik tengah).

443
00:31:40,000 --> 00:31:42,000
[Mahasiswa] Apakah printf Anda menemukannya.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("Kami menemukan itu \ n");

445
00:31:51,000 --> 00:31:56,000
Jika tidak-aku akan mulai melakukan sesuatu yang berbeda di sini.

446
00:31:56,000 --> 00:32:00,000
Aku akan mulai menempatkan kawat gigi sekitar jika pernyataan sepanjang waktu

447
00:32:00,000 --> 00:32:05,000
hanya karena jika kita menambahkan lebih banyak barang, maka

448
00:32:05,000 --> 00:32:07,000
kita tidak mendapatkan kompiler.

449
00:32:07,000 --> 00:32:09,000
Ya, Sam. Anda punya titik.

450
00:32:09,000 --> 00:32:12,000
Masalahnya adalah bahwa titik tengah merupakan posisi dalam array,

451
00:32:12,000 --> 00:32:15,000
tapi Anda bisa mendapatkannya untuk mewakili nilai dalam posisi array.

452
00:32:15,000 --> 00:32:17,000
Itu poin yang bagus.

453
00:32:17,000 --> 00:32:19,000
Apakah semua orang mendengar apa yang dikatakan Sam?

454
00:32:19,000 --> 00:32:22,000
Dia mengatakan bahwa titik tengah seperti

455
00:32:22,000 --> 00:32:28,000
hanya mewakili posisi dalam array, tapi itu bukan elemen yang sebenarnya dalam array.

456
00:32:28,000 --> 00:32:30,000
Jika Anda berpikir tentang kode seperti yang tertulis sekarang,

457
00:32:30,000 --> 00:32:35,000
jika kita melihat array ini di sini, yang memiliki 8 elemen di dalamnya,

458
00:32:35,000 --> 00:32:39,000
berapakah nilai dari titik tengah akan berada di fungsi ini?

459
00:32:39,000 --> 00:32:41,000
[Mahasiswa] 4.

460
00:32:41,000 --> 00:32:45,000
[Nate] 4.

461
00:32:45,000 --> 00:32:51,000
Jika kita mencari nomor 4 -

462
00:32:51,000 --> 00:32:54,000
dan kita hanya bisa menjalankan kode ini dan menempatkan wajah sedih sedikit di sini

463
00:32:54,000 --> 00:32:58,000
karena kami tidak menemukan itu-jika kita menjalankan kode ini

464
00:32:58,000 --> 00:33:04,000
seperti sekarang, meng-upload, bangunan, biarkan aku gulir ke bawah,

465
00:33:04,000 --> 00:33:09,000
dan jika kita mencari nomor 4,

466
00:33:09,000 --> 00:33:18,000
kami menemukan itu, tapi kami tidak mendapatkan ini untuk printf ya.

467
00:33:18,000 --> 00:33:23,000
Salah satu alasannya adalah bahwa kita tidak kembali benar,

468
00:33:23,000 --> 00:33:26,000
tapi apakah kita benar-benar menemukan nomor 4?

469
00:33:26,000 --> 00:33:28,000
Dan Sam mengatakan tidak.

470
00:33:28,000 --> 00:33:31,000
Apa yang kita temukan?

471
00:33:31,000 --> 00:33:35,000
Kami benar-benar menemukan titik tengah, yang jika kita melihat array di sini,

472
00:33:35,000 --> 00:33:38,000
itu akan menjadi elemen pada indeks 4 yang kita sedang melihat,

473
00:33:38,000 --> 00:33:42,000
yaitu 23.

474
00:33:42,000 --> 00:33:46,000
>> Bagaimana kita benar-benar mendapatkan elemen pada titik tengah

475
00:33:46,000 --> 00:33:48,000
dan bukan hanya titik tengah itu sendiri?

476
00:33:48,000 --> 00:33:52,000
[Siswa] Kami akan masuk ke char atau sesuatu?

477
00:33:52,000 --> 00:33:55,000
Apa yang akan lakukan, hanya karena ingin tahu?

478
00:33:55,000 --> 00:33:57,000
Dapatkah Anda menguraikan lebih sedikit?

479
00:33:57,000 --> 00:34:02,000
Anda harus mengubah posisi menjadi nomor,

480
00:34:02,000 --> 00:34:05,000
jadi Anda harus membuat beberapa koneksi-saya pikir itu char, tapi tidak mungkin.

481
00:34:05,000 --> 00:34:07,000
Ya, itu adalah titik yang baik.

482
00:34:07,000 --> 00:34:12,000
Kami telah melakukan banyak hal ini posisi mengkonversi menjadi karakter, karakter ini,

483
00:34:12,000 --> 00:34:14,000
di dua set pertama masalah.

484
00:34:14,000 --> 00:34:18,000
Ternyata bahwa di sini, ini hampir mirip dengan

485
00:34:18,000 --> 00:34:24,000
mengakses karakter engan dalam string, jika itu masuk akal.

486
00:34:24,000 --> 00:34:30,000
Di sini kita ingin mengakses elemen titik tengah.

487
00:34:30,000 --> 00:34:34,000
Bagaimana kita melakukan itu?

488
00:34:34,000 --> 00:34:39,000
Kevin, apakah Anda punya saran bagaimana kita bisa melakukan itu?

489
00:34:39,000 --> 00:34:44,000
Anda bisa melakukan tumpukan jerami, braket terbuka, pertengahan, ditutup braket.

490
00:34:44,000 --> 00:34:46,000
Dapatkah Anda menulis bahwa bagi kita?

491
00:34:46,000 --> 00:34:51,000
Simpan di sini, dan kami akan menarik itu.

492
00:34:51,000 --> 00:34:56,000
Kami sedang melihat ini jalur 9,

493
00:34:56,000 --> 00:34:59,000
dan kami menyadari bahwa kami tidak ingin membandingkan jarum ke titik tengah,

494
00:34:59,000 --> 00:35:03,000
tetapi sebaliknya, kita ingin membandingkan jarum

495
00:35:03,000 --> 00:35:07,000
ke elemen pada titik tengah posisi dalam array tumpukan jerami kami.

496
00:35:07,000 --> 00:35:10,000
Cool.

497
00:35:10,000 --> 00:35:12,000
Di sana kami pergi.

498
00:35:12,000 --> 00:35:15,000
Ya, yang terlihat cukup bagus, jika (jarum == tumpukan jerami [titik tengah]).

499
00:35:15,000 --> 00:35:18,000
Kami menemukan itu.

500
00:35:18,000 --> 00:35:22,000
Sekarang jika kita jalankan kembali kode-kita naik sedikit sedikit-

501
00:35:22,000 --> 00:35:26,000
itu mengkompilasi, berjalan, dan sekarang jika kita mencari 4,

502
00:35:26,000 --> 00:35:30,000
kami tidak menemukannya karena sekarang kita benar-benar mendapatkan nomor 23.

503
00:35:30,000 --> 00:35:33,000
Kami mendapatkan nilai 23, dan itulah apa yang kita membandingkan dengan jarum kami.

504
00:35:33,000 --> 00:35:35,000
Tapi itu bagus. Itu adalah langkah ke arah yang benar.

505
00:35:35,000 --> 00:35:37,000
>> Itulah yang kami coba lakukan.

506
00:35:37,000 --> 00:35:40,000
Kami tidak mencoba untuk membandingkan jarum terhadap posisi dalam array

507
00:35:40,000 --> 00:35:44,000
melainkan terhadap unsur-unsur yang sebenarnya dalam array.

508
00:35:44,000 --> 00:35:49,000
Jika kita melihat ke belakang lagi sekarang di langkah berikutnya dalam algoritma kami,

509
00:35:49,000 --> 00:35:51,000
apa langkah selanjutnya?

510
00:35:51,000 --> 00:35:57,000
Leila sudah disebutkan secara singkat.

511
00:35:57,000 --> 00:36:00,000
[Mahasiswa] Periksa untuk melihat apakah itu lebih besar dari atau kurang dari dan kemudian memutuskan ke mana harus bergerak.

512
00:36:00,000 --> 00:36:03,000
[Nate] Ya, jadi bagaimana kita melakukannya?

513
00:36:03,000 --> 00:36:07,000
Dapatkah Anda dimasukkan ke dalam beberapa-aku akan menyimpan revisi ini,

514
00:36:07,000 --> 00:36:13,000
dan kemudian jika Anda masukkan ke dalam beberapa baris yang akan melakukan itu.

515
00:36:13,000 --> 00:36:15,000
Ya, Charlotte >> Saya punya pertanyaan..

516
00:36:15,000 --> 00:36:19,000
Bukankah seharusnya titik tengah - 1 karena hal pertama adalah

517
00:36:19,000 --> 00:36:26,000
itu 0 diindeks, jadi jika kita menempatkan 4, itu tidak benar-benar karakter yang kita cari?

518
00:36:26,000 --> 00:36:30,000
Ya, dan masalah lainnya dengan itu adalah-

519
00:36:30,000 --> 00:36:35,000
itu menangkap besar, karena apa yang akan terjadi mungkin berakhir

520
00:36:35,000 --> 00:36:42,000
jika kita terus bergerak dan kita tidak pernah menyesuaikan awalnya?

521
00:36:42,000 --> 00:36:46,000
Saya kira apa yang kita mungkin berakhir lakukan adalah mencoba untuk mengakses

522
00:36:46,000 --> 00:36:49,000
elemen di posisi 8 dari array,

523
00:36:49,000 --> 00:36:53,000
yang dalam hal ini tidak ada.

524
00:36:53,000 --> 00:36:56,000
Kami akan ingin melakukan semacam akuntansi untuk fakta

525
00:36:56,000 --> 00:36:59,000
bahwa kita memiliki beberapa pengindeksan nol.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Maaf, saya berarti titik tengah - 1 dalam kurung kotak.

527
00:37:05,000 --> 00:37:08,000
Kita bisa melakukan itu.

528
00:37:08,000 --> 00:37:10,000
Kami akan kembali ke masalah ini hanya dalam sedikit.

529
00:37:10,000 --> 00:37:13,000
Setelah kita mulai untuk sampai ke perulangan yang sebenarnya,

530
00:37:13,000 --> 00:37:16,000
saat itulah kita benar-benar akan melihat ini datang ke dalam bermain.

531
00:37:16,000 --> 00:37:21,000
Untuk saat ini, kita bisa melakukan ini, tapi kau benar-benar benar.

532
00:37:21,000 --> 00:37:28,000
Bahwa pengindeksan nol akan memiliki efek yang kita perlu menjelaskan.

533
00:37:28,000 --> 00:37:30,000
Mari kita lihat.

534
00:37:30,000 --> 00:37:34,000
>> Bagaimana adalah lebih besar dari dan kurang dari-?

535
00:37:34,000 --> 00:37:36,000
[Mahasiswa] saya mendapatkan bagaimana melakukan lebih dari dan kurang dari bagian.

536
00:37:36,000 --> 00:37:41,000
Saya hanya tidak yakin apa yang harus mencetak jika Anda menemukan bahwa itu adalah kurang dari titik tengah tumpukan jerami atau lebih besar dari.

537
00:37:41,000 --> 00:37:43,000
Di sini saya dapat menyimpan apa yang aku pernah-

538
00:37:43,000 --> 00:37:47,000
[Nate] Ya, jika Anda menyimpan apa yang Anda miliki, dan kami akan tarik ke atas.

539
00:37:47,000 --> 00:37:49,000
Di sana kami pergi.

540
00:37:49,000 --> 00:37:51,000
[Mahasiswa] Dan saya menempatkan tanda tanya untuk apa yang saya tidak tahu.

541
00:37:51,000 --> 00:37:54,000
[Nate] Itu tampak hebat.

542
00:37:54,000 --> 00:37:58,000
Di sini kita punya tanda tanya karena kita masih tidak tahu

543
00:37:58,000 --> 00:38:06,000
apa yang akan kita lakukan cukup belum.

544
00:38:06,000 --> 00:38:12,000
Apa yang kita ingin lakukan-oops, kami punya beberapa kawat gigi semua funky pada kita.

545
00:38:12,000 --> 00:38:15,000
Kita akan memperbaiki ini kawat gigi.

546
00:38:15,000 --> 00:38:19,000
Di sana kami pergi.

547
00:38:19,000 --> 00:38:22,000
Dan jadi apa yang ingin kita lakukan, menurut algoritma kami,

548
00:38:22,000 --> 00:38:27,000
jika kita tidak menemukan jarum?

549
00:38:27,000 --> 00:38:32,000
Katakanlah dalam hal bahwa jarum kurang dari apa yang kita melihat. Kevin.

550
00:38:32,000 --> 00:38:34,000
Hanya melihat kiri setengah.

551
00:38:34,000 --> 00:38:40,000
Benar, jadi kita akan memasang komentar di sini yang mengatakan "melihat kiri setengah."

552
00:38:40,000 --> 00:38:46,000
Dan jika jarum lebih besar dari tumpukan jerami pada titik tengah, apa yang ingin kita lakukan?

553
00:38:46,000 --> 00:38:48,000
[Siswa] Kemudian Anda melihat di bagian kanan setengah.

554
00:38:48,000 --> 00:38:53,000
Lihatlah kanan setengah, "lihat bagian kanan."

555
00:38:53,000 --> 00:38:58,000
Tidak terlalu buruk.

556
00:38:58,000 --> 00:39:05,000
Oke, jadi pada titik ini, hal-hal yang tampak cukup bagus.

557
00:39:05,000 --> 00:39:13,000
Masalah dengan kode seperti yang tertulis adalah apa?

558
00:39:13,000 --> 00:39:15,000
[Siswa] Anda tidak memiliki titik akhir untuk bagian.

559
00:39:15,000 --> 00:39:18,000
Benar, kita tidak memiliki titik akhir untuk bagian.

560
00:39:18,000 --> 00:39:20,000
Kami juga hanya akan pergi melalui ini sekali.

561
00:39:20,000 --> 00:39:23,000
Kita hanya akan melihat satu titik tengah.

562
00:39:23,000 --> 00:39:27,000
Entah elemen yang ada, atau tidak.

563
00:39:27,000 --> 00:39:34,000
Dalam rangka untuk menyelesaikan ini, kita harus melakukan semacam pengulangan.

564
00:39:34,000 --> 00:39:39,000
Kita perlu terus mengulangi sampai kita menemukan bahwa

565
00:39:39,000 --> 00:39:43,000
baik elemen ini di sana karena kita sudah dipersempit dan akhirnya menemukannya,

566
00:39:43,000 --> 00:39:46,000
atau itu tidak di sana karena kami telah melihat melalui semua hal

567
00:39:46,000 --> 00:39:52,000
di bagian yang tepat dari array dan menemukan bahwa tidak ada di sana.

568
00:39:52,000 --> 00:39:56,000
>> Setiap kali kita sudah mendapat pengulangan ini terjadi, apa yang akan kita gunakan?

569
00:39:56,000 --> 00:39:58,000
[Siswa] Sebuah lingkaran.

570
00:39:58,000 --> 00:40:00,000
Semacam lingkaran. Ya.

571
00:40:00,000 --> 00:40:03,000
[Mahasiswa] Bisakah kita melakukan loop do-while dan memilikinya melakukan itu dan kemudian sementara

572
00:40:03,000 --> 00:40:10,000
jarum tidak sama-aku tidak yakin di mana aku akan dengan itu.

573
00:40:10,000 --> 00:40:18,000
Namun jenis seperti melakukan itu selama itu tidak sama dengan nilai yang input pengguna.

574
00:40:18,000 --> 00:40:21,000
Ya, jadi mari kita lihat, bagaimana mungkin ini menulis sendiri?

575
00:40:21,000 --> 00:40:23,000
Kau bilang mari kita menggunakan loop do-while.

576
00:40:23,000 --> 00:40:26,000
Darimana melakukan start?

577
00:40:26,000 --> 00:40:33,000
[Mahasiswa] Tepat setelah ukuran / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Oke, dan apa yang akan kita lakukan?

579
00:40:42,000 --> 00:40:44,000
Kami akan mengisi sementara nanti.

580
00:40:44,000 --> 00:40:46,000
Apa yang akan kita lakukan?

581
00:40:46,000 --> 00:40:49,000
[Mahasiswa] Bukankah kita ingin melakukan semua hal yang kita miliki dalam porsi jika?

582
00:40:49,000 --> 00:40:52,000
[Nate] Apakah semua hal ini, yang besar.

583
00:40:52,000 --> 00:40:55,000
Copy dan paste.

584
00:40:55,000 --> 00:40:59,000
Oh, man.

585
00:40:59,000 --> 00:41:03,000
Mari kita lihat apakah ini bekerja, jika kita bisa tab selama ini.

586
00:41:03,000 --> 00:41:08,000
Indah.

587
00:41:08,000 --> 00:41:16,000
Oke, dan kami menyimpan sehingga kalian memilikinya.

588
00:41:16,000 --> 00:41:21,000
Baiklah, dan kami akan melakukan ini pada saat-

589
00:41:21,000 --> 00:41:25,000
apa kondisi saat Anda setelah?

590
00:41:25,000 --> 00:41:31,000
[Mahasiswa] Sementara jarum tidak sama, sehingga seperti tanda seru.

591
00:41:31,000 --> 00:41:37,000
Tapi aku tidak tahu persis apa yang belum.

592
00:41:37,000 --> 00:41:39,000
[Nate] Ya, ini adalah salah satu cara untuk melakukannya.

593
00:41:39,000 --> 00:41:41,000
Sam, apakah Anda memiliki komentar?

594
00:41:41,000 --> 00:41:43,000
[Sam] Saya ingat ketika saya melihat video,

595
00:41:43,000 --> 00:41:48,000
Aku mengambil screenshot dari salah satu-seperti ketika kita melakukan pseudocode untuk itu,

596
00:41:48,000 --> 00:41:52,000
ada beberapa hubungan antara max dan min.

597
00:41:52,000 --> 00:41:58,000
Saya pikir itu adalah sesuatu seperti jika max yang pernah kurang dari min.

598
00:41:58,000 --> 00:42:00,000
Got it.

599
00:42:00,000 --> 00:42:04,000
[Sam] Atau seperti jika max tidak kurang dari menit atau sesuatu seperti itu,

600
00:42:04,000 --> 00:42:06,000
karena itu berarti bahwa Anda telah mencari segalanya.

601
00:42:06,000 --> 00:42:13,000
>> Ya, jadi apa terdengar seperti max dan min yang mengacu pada?

602
00:42:13,000 --> 00:42:16,000
[Sam] Nilai yang-bilangan bulat yang akan mengubah

603
00:42:16,000 --> 00:42:18,000
relatif terhadap mana kita meletakkan titik tengah.

604
00:42:18,000 --> 00:42:20,000
Tepat.

605
00:42:20,000 --> 00:42:24,000
[Sam] Pada saat itu, itu akan [tak terdengar] menghitung max dan min.

606
00:42:24,000 --> 00:42:29,000
Midpoint ini max dan min ide.

607
00:42:29,000 --> 00:42:35,000
Apakah itu masuk akal untuk orang-orang?

608
00:42:35,000 --> 00:42:39,000
Jika kita mulai melihat bagaimana kita akan melakukan iterasi ini,

609
00:42:39,000 --> 00:42:43,000
Anda benar-benar benar bahwa kita ingin menggunakan semacam do-while loop.

610
00:42:43,000 --> 00:42:49,000
Tapi saya kira jika kita ingat apa yang terjadi di tempat array ini

611
00:42:49,000 --> 00:42:53,000
dan apa yang sebenarnya terjadi-aku akan menulis di sini-

612
00:42:53,000 --> 00:42:58,000
pada iterasi pertama dari pencarian biner, kita memiliki-

613
00:42:58,000 --> 00:43:05,000
Aku akan menggunakan b dan e untuk menunjukkan awal.

614
00:43:05,000 --> 00:43:10,000
Dan kemudian akhir dari array kita.

615
00:43:10,000 --> 00:43:14,000
Kita tahu bahwa awal adalah pada 4 tepat di sini,

616
00:43:14,000 --> 00:43:18,000
dan kita tahu bahwa akhir berada pada 108.

617
00:43:18,000 --> 00:43:23,000
Katakanlah kita sedang mencari nomor 15.

618
00:43:23,000 --> 00:43:27,000
Pertama kali kita melakukan ini, seperti yang kita lihat sebelumnya,

619
00:43:27,000 --> 00:43:30,000
titik tengah yang baik akan menjadi 16 atau 23

620
00:43:30,000 --> 00:43:34,000
tergantung pada bagaimana kita menghitung hal-hal keluar.

621
00:43:34,000 --> 00:43:37,000
Sejak merata membagi di tengah akan memberi kita ruang ini

622
00:43:37,000 --> 00:43:42,000
antara 16 dan 23, kita tidak bisa merata membaginya

623
00:43:42,000 --> 00:43:47,000
atau membagi dan mendapatkan di titik tengah yang benar.

624
00:43:47,000 --> 00:43:49,000
Kita akan melihat 16.

625
00:43:49,000 --> 00:43:55,000
Kita akan menyadari "Hei, 16> 15 yang kita cari."

626
00:43:55,000 --> 00:43:59,000
Untuk kemudian melihat kiri setengah dari array

627
00:43:59,000 --> 00:44:03,000
apa yang kita akan berakhir lakukan adalah membuang

628
00:44:03,000 --> 00:44:07,000
ini bagian atas keseluruhan

629
00:44:07,000 --> 00:44:16,000
dan berkata, "Oke, sekarang endpoint kami akan berada di sini."

630
00:44:16,000 --> 00:44:22,000
Iterasi berikutnya dari loop kita, kita sekarang melihat array ini,

631
00:44:22,000 --> 00:44:25,000
efektif setelah dibuang bagian ini karena sekarang

632
00:44:25,000 --> 00:44:30,000
jika kita mengambil titik tengah untuk menjadi perbedaan antara awal dan akhir,

633
00:44:30,000 --> 00:44:34,000
kita menemukan titik tengah kita menjadi 8,

634
00:44:34,000 --> 00:44:40,000
yang kemudian kita dapat menguji 8 untuk melihat di mana itu dalam kaitannya dengan jumlah yang kita cari,

635
00:44:40,000 --> 00:44:44,000
15, menemukan bahwa 15 lebih besar,

636
00:44:44,000 --> 00:44:49,000
jadi kami harus pindah ke bagian kanan dari daftar,

637
00:44:49,000 --> 00:44:51,000
yang kita tahu karena kita manusia, dan kita bisa melihatnya.

638
00:44:51,000 --> 00:44:54,000
Kita tahu bahwa bagian kanan akan berada di tempat kita menemukannya,

639
00:44:54,000 --> 00:45:01,000
tetapi komputer tidak tahu itu, jadi apa yang akan kita lakukan adalah kita akan benar-benar

640
00:45:01,000 --> 00:45:04,000
telah ini naik, dan sekarang awal dan akhir

641
00:45:04,000 --> 00:45:11,000
adalah tempat yang sama, sehingga titik tengah menjadi satu-satunya nomor dalam daftar pada saat itu,

642
00:45:11,000 --> 00:45:16,000
yang 15, dan kami telah menemukan itu.

643
00:45:16,000 --> 00:45:21,000
Apakah itu titik terang di mana ini max utuh dan notasi min akan,

644
00:45:21,000 --> 00:45:24,000
melacak endpoint dari array untuk mengetahui

645
00:45:24,000 --> 00:45:35,000
bagaimana mempersempit segalanya?

646
00:45:35,000 --> 00:45:42,000
>> Apa yang akan terjadi jika hal ini tidak sama dengan 15 sekarang?

647
00:45:42,000 --> 00:45:52,000
Bagaimana jika kita sedang mencari 15 dan, sebaliknya, angka ini juga 16?

648
00:45:52,000 --> 00:45:54,000
Kami akan mengatakan, "Oh, itu lebih besar.

649
00:45:54,000 --> 00:45:57,000
Kami ingin kembali ke kiri. "

650
00:45:57,000 --> 00:46:01,000
Dan kami akan pindah e kami ke kanan,

651
00:46:01,000 --> 00:46:06,000
di mana titik kita memiliki titik akhir yang akan bertentangan.

652
00:46:06,000 --> 00:46:09,000
Ini tidak akan mampu untuk mencari elemen lagi

653
00:46:09,000 --> 00:46:13,000
karena sekarang kita memiliki titik akhir dan titik awal kami,

654
00:46:13,000 --> 00:46:16,000
max dan min kami, sekarang membalik.

655
00:46:16,000 --> 00:46:23,000
Kami mencari melalui seluruh array. Kita tidak bisa menemukan apa-apa.

656
00:46:23,000 --> 00:46:27,000
Itulah titik di mana kita akan ingin mengatakan, "Oke, kita akan menghentikan algoritma ini.

657
00:46:27,000 --> 00:46:34,000
Kami tidak menemukan apa pun. Kami tahu itu tidak di sini. "

658
00:46:34,000 --> 00:46:36,000
Bagaimana ini terjadi?

659
00:46:36,000 --> 00:46:40,000
[Mahasiswa] Bagaimana tepatnya komputer beralih akhir?

660
00:46:40,000 --> 00:46:45,000
Bagaimana akhirnya berakhir sebelum awal?

661
00:46:45,000 --> 00:46:48,000
Akhirnya berakhir sebelum awal

662
00:46:48,000 --> 00:46:54,000
karena matematika yang akan kita lakukan setiap kali kita melakukan ini.

663
00:46:54,000 --> 00:47:00,000
Cara kita bertukar adalah jika Anda melihat pertama kalinya kami melakukan swap ini

664
00:47:00,000 --> 00:47:03,000
di mana kita memiliki awal pada 4 dan akhir

665
00:47:03,000 --> 00:47:13,000
semua jalan di 108 dan titik tengah kami, mengatakan, pada 16 -

666
00:47:13,000 --> 00:47:20,000
Aku akan me-reset kembali ini untuk 15-jika kita sedang mencari 15,

667
00:47:20,000 --> 00:47:25,000
kita tahu bahwa apa yang kita lakukan ketika kami memeriksa 16 dan melihat bahwa itu lebih besar

668
00:47:25,000 --> 00:47:28,000
dan ingin membuang bagian kanan seluruh daftar,

669
00:47:28,000 --> 00:47:36,000
kita melihat bahwa apa yang kita ingin lakukan adalah memindahkan e ini di sini.

670
00:47:36,000 --> 00:47:44,000
Efektif, e mendapat pindah ke salah satu sebelum titik tengah.

671
00:47:44,000 --> 00:47:48,000
Demikian juga, ketika kita melakukan ini iterasi dari algoritma

672
00:47:48,000 --> 00:47:51,000
dan titik tengah berada di 8,

673
00:47:51,000 --> 00:47:55,000
kami menemukan bahwa 8 <15, jadi kami ingin pindah b

674
00:47:55,000 --> 00:48:00,000
salah satu masa lalu titik tengah.

675
00:48:00,000 --> 00:48:07,000
Sekarang, awal dan akhir keduanya bersama-sama ini 15.

676
00:48:07,000 --> 00:48:10,000
>> Jika kita sudah terjadi untuk mencari beberapa nilai lainnya, bukan 15,

677
00:48:10,000 --> 00:48:14,000
atau jika 15 ini sudah bukan menjadi 16,

678
00:48:14,000 --> 00:48:20,000
kita akan menemukan bahwa e kita ingin memindahkan satu sebelum titik tengah.

679
00:48:20,000 --> 00:48:33,000
Sekarang e akan berada di sana membalik kurang dari b.

680
00:48:33,000 --> 00:48:39,000
Mari kita berjalan melalui bagaimana kita benar-benar berakhir coding algoritma ini.

681
00:48:39,000 --> 00:48:44,000
Kita tahu bahwa kita ingin memiliki perhitungan titik tengah.

682
00:48:44,000 --> 00:48:48,000
Kita juga tahu bahwa kita ingin melacak awal dan akhir array

683
00:48:48,000 --> 00:48:51,000
dari array saat kita sehingga kita dapat mengetahui

684
00:48:51,000 --> 00:48:56,000
dimana kiri setengah dari daftar dan di mana kanan setengah dari daftar adalah.

685
00:48:56,000 --> 00:49:03,000
Kami melakukannya dengan baik mulai dan akhir,

686
00:49:03,000 --> 00:49:07,000
atau kita bisa menyebutnya min dan max.

687
00:49:07,000 --> 00:49:10,000
Saya akan menggunakan memulai dan mengakhiri waktu ini.

688
00:49:10,000 --> 00:49:15,000
Ketika kita mulai, jika kita melihat kembali contoh kita di sini,

689
00:49:15,000 --> 00:49:20,000
awal kami didirikan pada awal dari array, seperti alam.

690
00:49:20,000 --> 00:49:25,000
Apa indeks ini? Apa yang kami harus mulai bisa?

691
00:49:25,000 --> 00:49:27,000
Daniel.

692
00:49:27,000 --> 00:49:30,000
[Daniel] Haystack [0].

693
00:49:30,000 --> 00:49:37,000
[Nate] Ya, jadi kita bisa mengaturnya sama dengan tumpukan jerami [0].

694
00:49:37,000 --> 00:49:40,000
Masalahnya, meskipun, adalah bahwa ini memberi kita bukan posisi dari elemen pertama.

695
00:49:40,000 --> 00:49:45,000
Ini memberi kita indeks dari elemen pertama atau nilai aktual pada saat itu posisi pertama.

696
00:49:45,000 --> 00:49:47,000
[Mahasiswa] Itu akan mengkonversi ke .20?

697
00:49:47,000 --> 00:49:52,000
[Nate] Apa ini akan lakukan adalah-baik, tidak akan melakukan converting apapun.

698
00:49:52,000 --> 00:49:56,000
Apa yang akan dilakukannya itu akan menyimpan 4 di mulai,

699
00:49:56,000 --> 00:49:59,000
dan kemudian akan sulit untuk membuat perbandingan terhadap mulai

700
00:49:59,000 --> 00:50:03,000
karena begin akan memegang nilai 4,

701
00:50:03,000 --> 00:50:06,000
yang merupakan awal dari array kita,

702
00:50:06,000 --> 00:50:08,000
tapi kami ingin melacak indeks dalam array

703
00:50:08,000 --> 00:50:11,000
yang bertentangan dengan nilai-nilai.

704
00:50:11,000 --> 00:50:17,000
Kami benar-benar akan menggunakan 0, seperti itu.

705
00:50:17,000 --> 00:50:20,000
Untuk akhir dari array-Charlotte dibesarkan ini sedikit lebih awal.

706
00:50:20,000 --> 00:50:23,000
Ini adalah di mana kita akan memperhitungkan pengindeksan nol.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, apa akhir dari array?

708
00:50:25,000 --> 00:50:28,000
Apa indeks akhir?

709
00:50:28,000 --> 00:50:30,000
[Charlotte] Ukuran - 1.

710
00:50:30,000 --> 00:50:32,000
Ya, dan yang ukuran yang harus kita gunakan?

711
00:50:32,000 --> 00:50:35,000
Haruskah kita menggunakan ukuran modal atau ukuran huruf kecil?

712
00:50:35,000 --> 00:50:37,000
Modal ukuran.

713
00:50:37,000 --> 00:50:42,000
Dalam kasus ini, kita bisa menggunakan ukuran modal.

714
00:50:42,000 --> 00:50:45,000
Jika kita ingin fungsi ini menjadi portabel

715
00:50:45,000 --> 00:50:48,000
dan menggunakan fungsi ini dalam program lain,

716
00:50:48,000 --> 00:50:50,000
kita benar-benar bisa menggunakan ukuran huruf kecil.

717
00:50:50,000 --> 00:50:52,000
Ini baik juga.

718
00:50:52,000 --> 00:51:01,000
Tapi Charlotte benar-benar tepat bahwa kita ingin memiliki ukuran - 1.

719
00:51:01,000 --> 00:51:03,000
Pada titik ini-

720
00:51:03,000 --> 00:51:05,000
[Mahasiswa] Bagaimana mungkin Anda dapat menggunakan ukuran huruf besar?

721
00:51:05,000 --> 00:51:07,000
Bagaimana kita bisa menggunakan ukuran huruf besar?

722
00:51:07,000 --> 00:51:13,000
Ternyata bahwa # mendefinisikan benar-benar,

723
00:51:13,000 --> 00:51:19,000
di bawah tenda, sebuah teks seperti mencari dan mengganti, jika itu masuk akal.

724
00:51:19,000 --> 00:51:24,000
Ketika Anda mengkompilasi kode Anda, tahap preprocessing

725
00:51:24,000 --> 00:51:27,000
dari compiler melewati file,

726
00:51:27,000 --> 00:51:31,000
dan mencari di mana-mana bahwa Anda telah menulis ukuran modal,

727
00:51:31,000 --> 00:51:39,000
dan menggantikan teks yang harfiah dengan 8, begitu saja.

728
00:51:39,000 --> 00:51:42,000
Dalam hal ini, ini sangat berbeda dari variabel.

729
00:51:42,000 --> 00:51:45,000
Ini tidak mengambil setiap ruang memori.

730
00:51:45,000 --> 00:51:52,000
Ini adalah trik mengganti teks sederhana.

731
00:51:52,000 --> 00:51:57,000
Dalam kasus ini, kita akan menggunakan ukuran.

732
00:51:57,000 --> 00:52:01,000
Dari sini kita ingin melakukan semacam pengulangan,

733
00:52:01,000 --> 00:52:03,000
dan kami berada di jalur yang benar dengan do-while loop kami.

734
00:52:03,000 --> 00:52:08,000
Kami ingin melakukan sesuatu sampai kondisi tidak tahan lagi,

735
00:52:08,000 --> 00:52:12,000
dan seperti yang kita lihat sebelumnya, kita melihat bahwa kondisi yang

736
00:52:12,000 --> 00:52:19,000
memang kita tidak ingin akhir

737
00:52:19,000 --> 00:52:24,000
menjadi kurang dari mulai.

738
00:52:24,000 --> 00:52:26,000
>> Ini adalah kondisi kita berhenti.

739
00:52:26,000 --> 00:52:35,000
Jika hal ini terjadi, kita ingin menghentikan dan menyatakan seperti, "Hei, kami tidak menemukan apa pun."

740
00:52:35,000 --> 00:52:43,000
Untuk mengungkapkan hal ini, kita ingin menggunakan beberapa jenis loop.

741
00:52:43,000 --> 00:52:49,000
Dalam kasus ini, itu akan loop do-while, untuk loop, loop sementara?

742
00:52:49,000 --> 00:52:51,000
Kami memiliki loop do-sementara di sini.

743
00:52:51,000 --> 00:52:53,000
Apakah kalian seperti pendekatan itu?

744
00:52:53,000 --> 00:52:59,000
Apakah Anda pikir kita harus mencoba pendekatan yang berbeda?

745
00:52:59,000 --> 00:53:01,000
Kevin, setiap pikiran?

746
00:53:01,000 --> 00:53:06,000
Kita bisa memiliki loop sementara karena kita tahu maksimal

747
00:53:06,000 --> 00:53:11,000
akan lebih besar dari menit pada anyways awal.

748
00:53:11,000 --> 00:53:14,000
Ya, jadi tidak ada inisialisasi yang perlu terjadi.

749
00:53:14,000 --> 00:53:17,000
Mereka do-while loop yang besar ketika Anda harus menginisialisasi sesuatu

750
00:53:17,000 --> 00:53:21,000
sebelum kemudian pengujian, sedangkan di sini

751
00:53:21,000 --> 00:53:26,000
kita tahu bahwa kita tidak akan terus inisialisasi ulang baik mulai dan berakhir

752
00:53:26,000 --> 00:53:28,000
setiap putaran loop.

753
00:53:28,000 --> 00:53:32,000
Kita tahu bahwa kita ingin menginisialisasi mereka, kemudian memeriksa kondisi kita.

754
00:53:32,000 --> 00:53:38,000
Dalam kasus ini, saya benar-benar akan pergi dengan loop sementara sederhana.

755
00:53:38,000 --> 00:53:44,000
Ternyata bahwa do-while loop yang digunakan cukup jarang.

756
00:53:44,000 --> 00:53:49,000
Banyak tempat bahkan tidak mengajarkan lakukan sementara loop.

757
00:53:49,000 --> 00:53:53,000
Mereka baik untuk menangani input pengguna, jadi kami telah melihat banyak dari mereka sejauh ini.

758
00:53:53,000 --> 00:53:59,000
Tapi normal untuk dan sementara loop yang jauh lebih umum.

759
00:53:59,000 --> 00:54:03,000
Ternyata kondisi ini seperti yang tertulis

760
00:54:03,000 --> 00:54:09,000
tidak akan benar-benar melakukan kita banyak yang baik, dan mengapa demikian?

761
00:54:09,000 --> 00:54:11,000
Maafkan aku, aku tidak tahu nama Anda.

762
00:54:11,000 --> 00:54:13,000
Saya Jerry. >> Maaf?

763
00:54:13,000 --> 00:54:15,000
Ini B-O-R-U-I.

764
00:54:15,000 --> 00:54:18,000
Oh, oke.

765
00:54:18,000 --> 00:54:23,000
Saya tidak melihat Anda dalam daftar saya.

766
00:54:23,000 --> 00:54:26,000
Oh, itu karena-oh, itu masuk akal.

767
00:54:26,000 --> 00:54:31,000
Apakah Anda memiliki gagasan tentang mengapa ini while loop mungkin tidak bekerja sebagaimana dimaksud,

768
00:54:31,000 --> 00:54:38,000
seperti yang tertulis dengan kondisi?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Maksudmu seperti Anda ingin semua hal setelah ke-?

770
00:54:43,000 --> 00:54:46,000
Ya, jadi itu satu.

771
00:54:46,000 --> 00:54:49,000
Kita mungkin harus meletakkan semua barang-barang ini ke dalam while loop, yang benar-benar benar.

772
00:54:49,000 --> 00:54:55,000
Hal lain yang sedikit lebih bermasalah, meskipun, adalah bahwa kondisi ini tidak bekerja.

773
00:54:55,000 --> 00:54:57,000
[Siswa] Anda perlu flip itu.

774
00:54:57,000 --> 00:55:04,000
Benar, sehingga kondisi ini tidak akan pernah menjadi kenyataan awalnya cara kita berbicara tentang hal itu.

775
00:55:04,000 --> 00:55:08,000
Kami ingin melakukan sesuatu sampai <akhir dimulai,

776
00:55:08,000 --> 00:55:13,000
tapi kami ingin melakukan sesuatu sementara

777
00:55:13,000 --> 00:55:21,000
mulai akhir ≤.

778
00:55:21,000 --> 00:55:24,000
>> Ada yang pembalikan logika di sana.

779
00:55:24,000 --> 00:55:27,000
Aku bersalah karena membuat kesalahan-kesalahan sepanjang waktu.

780
00:55:27,000 --> 00:55:31,000
[Mahasiswa] Mengapa harus kurang dari atau sama dengan?

781
00:55:31,000 --> 00:55:33,000
Karena Anda ingat kasus bahwa kita harus

782
00:55:33,000 --> 00:55:36,000
di mana hanya ada satu elemen, dan kami turun,

783
00:55:36,000 --> 00:55:43,000
dan kami melihat hanya 15 dalam array kita?

784
00:55:43,000 --> 00:55:47,000
Dan awal dan akhir kami adalah unsur yang sama.

785
00:55:47,000 --> 00:55:50,000
Kami ingin memastikan bahwa kami menangani kasus itu.

786
00:55:50,000 --> 00:55:54,000
Jika kita melakukan lurus kurang dari,

787
00:55:54,000 --> 00:55:58,000
kita hanya akan mampu untuk turun ke array 2-elemen.

788
00:55:58,000 --> 00:56:06,000
Setelah kami turun dengan elemen terakhir, jika itu elemen kami, kami tidak akan pernah menemukannya.

789
00:56:06,000 --> 00:56:10,000
Sekarang di sini, kita bisa melakukan persis seperti yang Anda katakan.

790
00:56:10,000 --> 00:56:15,000
Kita bisa mulai plopping hal tepat ke tengah-tengah loop sementara kami.

791
00:56:15,000 --> 00:56:20,000
Kita bisa plop di titik tengah kami.

792
00:56:20,000 --> 00:56:24,000
Kita bisa mengambil semua jika pernyataan,

793
00:56:24,000 --> 00:56:30,000
menarik mereka keluar dari lingkaran do-while,

794
00:56:30,000 --> 00:56:34,000
celepuk mereka,

795
00:56:34,000 --> 00:56:39,000
membersihkan hal-hal sedikit,

796
00:56:39,000 --> 00:56:48,000
dan aku akan pergi ke depan dan menyimpan revisi ini.

797
00:56:48,000 --> 00:56:53,000
Dan pada titik ini, kita sudah cukup dekat.

798
00:56:53,000 --> 00:56:55,000
Sam.

799
00:56:55,000 --> 00:56:58,000
Saya pikir Anda juga harus memiliki titik tengah int size = - 1/2.

800
00:56:58,000 --> 00:57:01,000
Got it, ukuran - 1/2.

801
00:57:01,000 --> 00:57:05,000
Apakah ada hal lain yang perlu kita mengubah tentang garis itu?

802
00:57:05,000 --> 00:57:10,000
Itu tangkapan yang baik.

803
00:57:10,000 --> 00:57:14,000
>> Apa ukuran berapa? Apakah kita pernah mengubah ukuran?

804
00:57:14,000 --> 00:57:17,000
Dalam rangka menjaga garis seperti ini, kita harus mengubah ukuran.

805
00:57:17,000 --> 00:57:21,000
Kami harus mengubah ukuran setiap kali kita pergi sekitar untuk loop.

806
00:57:21,000 --> 00:57:25,000
Tapi ingat ketika kita akan melalui contoh kita hanya sedikit lebih awal,

807
00:57:25,000 --> 00:57:30,000
dan kami memiliki awal pada 4

808
00:57:30,000 --> 00:57:33,000
dan akhirnya semua cara di atas pada 108?

809
00:57:33,000 --> 00:57:35,000
Bagaimana kita menghitung titik tengah?

810
00:57:35,000 --> 00:57:38,000
Apakah kita menggunakan ukuran?

811
00:57:38,000 --> 00:57:40,000
Atau kita gunakan mulai dan berakhir sebagai gantinya?

812
00:57:40,000 --> 00:57:42,000
Inilah perbedaan antara akhir dan awal.

813
00:57:42,000 --> 00:57:50,000
Tepat, dan bagaimana tepatnya saya harus menulis itu, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Hanya berakhir - dimulai.

815
00:57:52,000 --> 00:57:55,000
Anda tidak perlu melakukan - 1

816
00:57:55,000 --> 00:57:58,000
karena - 1 telah dimasukkan di akhir dan mulai sudah.

817
00:57:58,000 --> 00:58:00,000
[Nate] besar, Anda benar-benar benar.

818
00:58:00,000 --> 00:58:03,000
Kami tidak harus melakukan - 1 karena - 1 telah dimasukkan

819
00:58:03,000 --> 00:58:08,000
dan menyumbang ketika kita menginisialisasi variabel akhir.

820
00:58:08,000 --> 00:58:11,000
>> Apakah ada hal lain yang perlu saya lakukan sintaksis untuk memiliki baris ini masuk akal?

821
00:58:11,000 --> 00:58:13,000
[Mahasiswa] Ditambah mulai >> Plus. Dimulai?

822
00:58:13,000 --> 00:58:15,000
[Mahasiswa] Pada akhir.

823
00:58:15,000 --> 00:58:20,000
Karena itu hanya dihitung setengah panjang.

824
00:58:20,000 --> 00:58:26,000
Anda perlu menambahkan mulai.

825
00:58:26,000 --> 00:58:31,000
[Nate] Apa yang akan menghitung ini bagi kita?

826
00:58:31,000 --> 00:58:35,000
Jika kita berpikir tentang akhir pada iterasi pertama dari loop,

827
00:58:35,000 --> 00:58:40,000
akhirnya akan berada dalam posisi indeks 7.

828
00:58:40,000 --> 00:58:43,000
Mulailah berada di posisi 0.

829
00:58:43,000 --> 00:58:47,000
Ingat, kita sedang mencari baik

830
00:58:47,000 --> 00:58:52,000
posisi 3 atau posisi 4.

831
00:58:52,000 --> 00:58:56,000
Jika kita melihat matematika ini, hanya untuk membuatnya sedikit lebih nyata,

832
00:58:56,000 --> 00:59:02,000
menaruh beberapa angka di sini, kami memiliki 7, 0,

833
00:59:02,000 --> 00:59:10,000
jadi 7 - 0, dan kemudian / 2

834
00:59:10,000 --> 00:59:19,000
adalah 3 di pembagian integer, yaitu.

835
00:59:19,000 --> 00:59:26,000
Kemudian kita perlu kemudian menambahkan kembali kita mulai?

836
00:59:26,000 --> 00:59:28,000
Kami tidak dalam kasus ini.

837
00:59:28,000 --> 00:59:31,000
Pada iterasi pertama, itu akan baik-baik saja karena begin adalah 0.

838
00:59:31,000 --> 00:59:36,000
Tapi seperti yang kita kemajuan, kita lakukan benar-benar semua hanya perlu

839
00:59:36,000 --> 00:59:42,000
end - mulai / 2.

840
00:59:42,000 --> 00:59:46,000
Ada satu trik lain di sini, dan itu adalah salah satu dari prioritas yaitu.

841
00:59:46,000 --> 00:59:49,000
[Mahasiswa] Apakah kita perlu kurung?

842
00:59:49,000 --> 00:59:53,000
[Nate] Tepat, dan itu karena jika kita tidak menempatkan tanda kurung,

843
00:59:53,000 --> 00:59:58,000
maka baris ini akan ditafsirkan sebagai gantinya

844
00:59:58,000 --> 01:00:09,000
sebagai (end) - (mulai / 2), yang kita pasti tidak ingin.

845
01:00:09,000 --> 01:00:11,000
Watch out bagi mereka aturan didahulukan.

846
01:00:11,000 --> 01:00:15,000
[Mahasiswa] Mengapa bukan akhir + dimulai?

847
01:00:15,000 --> 01:00:17,000
Mengapa tidak berakhir + dimulai?

848
01:00:17,000 --> 01:00:19,000
[Mahasiswa] Mengapa tidak?

849
01:00:19,000 --> 01:00:24,000
Mengapa itu +?

850
01:00:24,000 --> 01:00:26,000
Saya pikir kau benar.

851
01:00:26,000 --> 01:00:28,000
[Mahasiswa] Karena itu rata-rata?

852
01:00:28,000 --> 01:00:31,000
[Nate] Akhir + dimulai, Anda benar-benar benar.

853
01:00:31,000 --> 01:00:34,000
Wow, aku benar-benar melakukan kesalahan. Kau benar.

854
01:00:34,000 --> 01:00:39,000
Jika kita melakukan minus, kita akan ingin menambahkan mulai kembali masuk

855
01:00:39,000 --> 01:00:43,000
Dalam hal ini, Anda sangat benar bahwa kita ingin mengambil rata-rata dari dua,

856
01:00:43,000 --> 01:00:45,000
jadi kami ingin menambahkannya, sebagai lawan untuk mengurangi mereka.

857
01:00:45,000 --> 01:00:49,000
[Mahasiswa] Hal ini juga akan bekerja jika Anda melakukan end - mulai / 2 + dimulai.

858
01:00:49,000 --> 01:00:55,000
Ini akan jika kita lakukan-saya percaya begitu.

859
01:00:55,000 --> 01:01:00,000
>> Sebagai contoh, jika kita melihat mulai,

860
01:01:00,000 --> 01:01:04,000
dan kita bergeser ke sini

861
01:01:04,000 --> 01:01:08,000
ke 15.

862
01:01:08,000 --> 01:01:12,000
Sekarang mulai berada pada posisi 2.

863
01:01:12,000 --> 01:01:15,000
Akhir berada pada posisi 7.

864
01:01:15,000 --> 01:01:21,000
Jika kita kurangi mereka, kita mendapatkan 5.

865
01:01:21,000 --> 01:01:24,000
Membagi bahwa dengan 2, kita mendapatkan 2.

866
01:01:24,000 --> 01:01:27,000
Dan kemudian kita tambahkan 2 kembali,

867
01:01:27,000 --> 01:01:30,000
dan yang membuat kita ke posisi ke-4,

868
01:01:30,000 --> 01:01:33,000
yang ada di sini, yang merupakan titik tengah.

869
01:01:33,000 --> 01:01:36,000
[Mahasiswa] Apakah kita perlu untuk mengurus pembungkus?

870
01:01:36,000 --> 01:01:39,000
Dalam arti apa yang kita butuhkan untuk mengurus pembungkus?

871
01:01:39,000 --> 01:01:43,000
Jika jumlah atau perbedaan antara

872
01:01:43,000 --> 01:01:45,000
tergantung pada bagaimana kita melakukannya bukan bilangan genap.

873
01:01:45,000 --> 01:01:49,000
Kemudian komputer akan bingung apakah ketika itu 2,5;

874
01:01:49,000 --> 01:01:52,000
Anda bergerak ke kiri atau ke kanan untuk menentukan yang merupakan titik tengah?

875
01:01:52,000 --> 01:01:54,000
Got it.

876
01:01:54,000 --> 01:01:56,000
Ternyata bahwa dengan pembagian integer,

877
01:01:56,000 --> 01:01:59,000
kita tidak pernah mendapatkan angka-angka floating point.

878
01:01:59,000 --> 01:02:01,000
Kami tidak pernah mendapatkan desimal.

879
01:02:01,000 --> 01:02:04,000
Ini benar-benar dibuang.

880
01:02:04,000 --> 01:02:08,000
Jika Anda memiliki komputer membagi dua variabel int,

881
01:02:08,000 --> 01:02:11,000
dan satu adalah 7, dan yang lainnya adalah 2,

882
01:02:11,000 --> 01:02:13,000
Anda tidak akan mendapatkan 3,5 sebagai hasilnya.

883
01:02:13,000 --> 01:02:16,000
Ini akan mendapatkan 3.

884
01:02:16,000 --> 01:02:19,000
Sisanya akan dibuang, sehingga efektif pembulatan-

885
01:02:19,000 --> 01:02:24,000
tidak bulat melainkan lantai, jika kalian sudah familiar dengan itu dalam matematika,

886
01:02:24,000 --> 01:02:27,000
di mana Anda benar-benar membuang desimal,

887
01:02:27,000 --> 01:02:31,000
dan sehingga Anda pada dasarnya truncating itu ke terdekat

888
01:02:31,000 --> 01:02:33,000
Seluruh posisi, ke bilangan bulat terdekat.

889
01:02:33,000 --> 01:02:38,000
[Mahasiswa] Tapi kemudian itu bermasalah karena jika Anda memiliki sebuah array dari 7 elemen

890
01:02:38,000 --> 01:02:43,000
maka secara otomatis mengambil elemen ke-3 keluar dari titik tengah bukan 4.

891
01:02:43,000 --> 01:02:46,000
Bagaimana kita berurusan dengan itu?

892
01:02:46,000 --> 01:02:49,000
Ini bermasalah karena jika kita memiliki sebuah array dari 7,

893
01:02:49,000 --> 01:02:54,000
itu akan memilih 3 bukan 4.

894
01:02:54,000 --> 01:02:56,000
Bisakah Anda menjelaskan sedikit lebih?

895
01:02:56,000 --> 01:02:59,000
[Mahasiswa] Karena jika Anda memiliki 7 elemen maka unsur ke-4

896
01:02:59,000 --> 01:03:04,000
akan menjadi titik tengah, kan?

897
01:03:04,000 --> 01:03:07,000
Ingat komentar Anda tentang menjadi nol diindeks, meskipun.

898
01:03:07,000 --> 01:03:10,000
[Mahasiswa] Ya, jadi di posisi 3. Itu akan menjadi titik tengah.

899
01:03:10,000 --> 01:03:12,000
Ya.

900
01:03:12,000 --> 01:03:16,000
Oh, oke. Saya melihat apa yang Anda maksud.

901
01:03:16,000 --> 01:03:19,000
Ini agak aneh, karena kami terbiasa dengan gagasan seluruh

902
01:03:19,000 --> 01:03:22,000
menyingkirkan desimal.

903
01:03:22,000 --> 01:03:26,000
Itu poin yang bagus.

904
01:03:26,000 --> 01:03:30,000
Mari kita selesaikan ini.

905
01:03:30,000 --> 01:03:32,000
Kami telah menghitung titik tengah kami.

906
01:03:32,000 --> 01:03:37,000
>> Kami sedang menguji untuk melihat apakah jarum kami adalah sama dengan nilai tengah.

907
01:03:37,000 --> 01:03:41,000
Kami mencetak bahwa kami menemukan itu, tapi benar-benar, apa yang ingin kita lakukan dalam situasi ini?

908
01:03:41,000 --> 01:03:46,000
Kami telah menemukan itu, jadi kami ingin membiarkan pemanggil tahu bahwa kami menemukan itu.

909
01:03:46,000 --> 01:03:49,000
Kami punya fungsi yang diketik fungsi boolean.

910
01:03:49,000 --> 01:03:54,000
Cara kita sinyal ke pemanggil fungsi kita bahwa kita siap untuk pergi

911
01:03:54,000 --> 01:03:58,000
yang kita katakan, "Hei, ini benar."

912
01:03:58,000 --> 01:04:00,000
Bagaimana kita melakukan itu, Kevin?

913
01:04:00,000 --> 01:04:02,000
Anda menganggukkan kepala Anda. >> [Kevin] Tambah return true.

914
01:04:02,000 --> 01:04:06,000
[Nate] Tepat, kembali benar.

915
01:04:06,000 --> 01:04:12,000
Sekarang, jika tidak sama, bagaimana kita melihat kiri setengah?

916
01:04:12,000 --> 01:04:16,000
Ada gagasan?

917
01:04:16,000 --> 01:04:18,000
Stella, ide?

918
01:04:18,000 --> 01:04:21,000
Anda perlu menetapkan posisi baru untuk akhir.

919
01:04:21,000 --> 01:04:23,000
Ya.

920
01:04:23,000 --> 01:04:29,000
Jadi kita harus melakukan posisi titik tengah - akhir.

921
01:04:29,000 --> 01:04:33,000
Besar.

922
01:04:33,000 --> 01:04:36,000
Kita perlu menetapkan posisi baru untuk akhir

923
01:04:36,000 --> 01:04:38,000
untuk melihat kiri setengah.

924
01:04:38,000 --> 01:04:41,000
Ini adalah apa yang kita bicarakan sebelumnya di mana

925
01:04:41,000 --> 01:04:44,000
Aku tetap akan kembali ke contoh ini.

926
01:04:44,000 --> 01:04:50,000
Saya telah mulai di sini, dan kemudian saya memiliki akhir semua cara di atas sini.

927
01:04:50,000 --> 01:04:53,000
>> Sekali lagi, jika kita sedang mencari 15, dan titik tengah kami adalah pada 16,

928
01:04:53,000 --> 01:04:56,000
dan kita menyadari, "Ups, 16 lebih besar.

929
01:04:56,000 --> 01:04:59,000
Kami ingin pindah ke kiri setengah. "

930
01:04:59,000 --> 01:05:02,000
Kami kemudian akan memindahkan ujung ke 15,

931
01:05:02,000 --> 01:05:06,000
dan kami melakukannya dengan mengambil satu jauh dari titik tengah

932
01:05:06,000 --> 01:05:09,000
dan menetapkan bahwa sebagai akhir baru kami.

933
01:05:09,000 --> 01:05:12,000
Demikian juga, jika kita ingin melihat kanan setengah, bagaimana kita melakukannya?

934
01:05:12,000 --> 01:05:14,000
Apakah Anda punya ide?

935
01:05:14,000 --> 01:05:22,000
[Siswa] Anda hanya mengatur mulai titik tengah + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Besar.

937
01:05:24,000 --> 01:05:29,000
Dan sekarang dalam hal bahwa kita tidak menemukan apa-apa,

938
01:05:29,000 --> 01:05:32,000
apakah itu mendapatkan perawatan yang diambil dari bagi kita?

939
01:05:32,000 --> 01:05:36,000
Daniel, apakah yang bisa diambil dari perawatan bagi kita?

940
01:05:36,000 --> 01:05:38,000
[Daniel] No

941
01:05:38,000 --> 01:05:40,000
[Nate] Jika kita membuatnya melalui seluruh array dan kita tidak menemukan apa-apa,

942
01:05:40,000 --> 01:05:42,000
mana yang akan diperhatikan, atau harus kita mengurusnya?

943
01:05:42,000 --> 01:05:44,000
[Daniel] Kondisi saat.

944
01:05:44,000 --> 01:05:48,000
[Nate] Ya, kondisi saat, tepatnya.

945
01:05:48,000 --> 01:05:51,000
Ini akan mengurus melalui seluruh array jika kita tidak menemukan apa-apa.

946
01:05:51,000 --> 01:05:53,000
Ini while loop akan berakhir.

947
01:05:53,000 --> 01:05:56,000
Kami tidak pernah akan jumpai kondisi ini,

948
01:05:56,000 --> 01:06:03,000
dan kita bisa kembali palsu.

949
01:06:03,000 --> 01:06:10,000
Kami juga dapat meninggalkan ini jika di sini seperti ini

950
01:06:10,000 --> 01:06:14,000
karena jika ini jika pernyataan benar,

951
01:06:14,000 --> 01:06:16,000
dan fungsi kita akan kembali,

952
01:06:16,000 --> 01:06:21,000
dan jadi kami pada dasarnya akan batalkan fungsi ini pada saat ini

953
01:06:21,000 --> 01:06:24,000
ketika kita kembali benar.

954
01:06:24,000 --> 01:06:28,000
Tapi apa yang terjadi dengan struktur ini di sini?

955
01:06:28,000 --> 01:06:34,000
Ini akan bekerja sepenuhnya, atau apakah ada kesalahan logis di sana?

956
01:06:34,000 --> 01:06:37,000
>> Ada beberapa kesalahan logis di sana, dengan cara itu diatur.

957
01:06:37,000 --> 01:06:40,000
Apa mungkin itu?

958
01:06:40,000 --> 01:06:43,000
[Siswa] Mengapa Anda perlu - dan + 1s?

959
01:06:43,000 --> 01:06:47,000
Yang menetapkan array kita sampai menjadi setengah baru kami kiri dan bagian kanan.

960
01:06:47,000 --> 01:06:51,000
[Mahasiswa] Tapi mengapa tidak bisa Anda melakukannya tanpa - 1s dan + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Kita bisa mengaturnya sama dengan titik tengah?

962
01:06:53,000 --> 01:07:04,000
Apa yang mungkin bermasalah tentang hal itu?

963
01:07:04,000 --> 01:07:08,000
[Mahasiswa] Saya kira itu tidak efisien karena Anda sedang memeriksa nilai yang sudah diperiksa.

964
01:07:08,000 --> 01:07:11,000
[Nate] Tepat, sehingga Sam benar-benar tepat.

965
01:07:11,000 --> 01:07:15,000
Jika Anda mengatur akhir dan mulai sama dengan titik tengah

966
01:07:15,000 --> 01:07:18,000
bukannya - 1 dan + 1 reflektif,

967
01:07:18,000 --> 01:07:22,000
di beberapa titik di masa depan kita akan berakhir memeriksa titik tengah lagi.

968
01:07:22,000 --> 01:07:26,000
[Mahasiswa] saya mulai pset, dan kemudian aku punya sesuatu seperti itu

969
01:07:26,000 --> 01:07:30,000
di mana saya lupa + 1, dan itu terjebak dalam infinite loop.

970
01:07:30,000 --> 01:07:34,000
Benar, karena pada titik tertentu Anda tidak akan pernah mendapatkan memulai dan mengakhiri

971
01:07:34,000 --> 01:07:39,000
untuk benar-benar tumpang tindih.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Ada satu kelemahan logis lebih, dan itu adalah bahwa ini pasti harus

974
01:07:44,000 --> 01:07:48,000
lain jika.

975
01:07:48,000 --> 01:07:55,000
Mengapa itu terjadi?

976
01:07:55,000 --> 01:07:59,000
>> Alasannya adalah jika itu bukan lagi jika-kau melihatnya, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Ya, karena Anda mengubah titik akhir.

978
01:08:02,000 --> 01:08:05,000
[Nate] Tepat.

979
01:08:05,000 --> 01:08:07,000
Kami mengubah titik akhir,

980
01:08:07,000 --> 01:08:12,000
dan jika itu ditulis seperti ini-kita membuat spasi antara-

981
01:08:12,000 --> 01:08:14,000
itu akan memeriksa kasus ini.

982
01:08:14,000 --> 01:08:18,000
Kasus ini, jika berhasil, akan membatalkan keluar dari fungsi.

983
01:08:18,000 --> 01:08:21,000
Kemudian akan memeriksa kasus ini selanjutnya,

984
01:08:21,000 --> 01:08:24,000
dan jika ini berhasil, maka akan menyesuaikan titik akhir,

985
01:08:24,000 --> 01:08:28,000
dan kemudian akan melanjutkan dan memeriksa kasus ini.

986
01:08:28,000 --> 01:08:31,000
Tapi pada saat ini, kita tidak ingin untuk melanjutkan pemeriksaan.

987
01:08:31,000 --> 01:08:35,000
Untungnya, kami belum me-reset titik tengah di sini,

988
01:08:35,000 --> 01:08:39,000
dan kita tahu bahwa kasus ini tidak akan berhasil.

989
01:08:39,000 --> 01:08:44,000
Tapi kita pasti ingin menempatkan lagi jika di sana

990
01:08:44,000 --> 01:08:48,000
meskipun itu mungkin-dalam hal ini

991
01:08:48,000 --> 01:08:52,000
karena kita tidak menyesuaikan titik tengah, yang akan membuat perbedaan?

992
01:08:52,000 --> 01:08:54,000
Tidak, karena kasus-kasus ini semua eksklusif.

993
01:08:54,000 --> 01:08:58,000
Sekali lagi, saya buruk.

994
01:08:58,000 --> 01:09:01,000
Kami tidak, saya pikir, perlu lagi ini jika.

995
01:09:01,000 --> 01:09:05,000
Kita bisa mencobanya dan menjalankannya dan melihat apa yang terjadi.

996
01:09:05,000 --> 01:09:08,000
Bangunan, terjadi kesalahan.

997
01:09:08,000 --> 01:09:12,000
Ini mungkin karena aku meninggalkan ini b dan e di sini.

998
01:09:12,000 --> 01:09:14,000
Apakah saya harus lagi sampai mereka di atas?

999
01:09:14,000 --> 01:09:16,000
Ini tidak terlihat seperti itu.

1000
01:09:16,000 --> 01:09:20,000
Kami zoom out, membangun,

1001
01:09:20,000 --> 01:09:24,000
ada kelanjutannya, jadi sekarang jika kita mencari 15,

1002
01:09:24,000 --> 01:09:28,000
ya.

1003
01:09:28,000 --> 01:09:30,000
Biarkan aku zoom in

1004
01:09:30,000 --> 01:09:33,000
15, ya. Kita bisa jalankan lagi.

1005
01:09:33,000 --> 01:09:36,000
Meng-upload kode sumber, membangun, menjalankan.

1006
01:09:36,000 --> 01:09:41,000
Kita dapat mencari sesuatu seperti 13,

1007
01:09:41,000 --> 01:09:45,000
dan kita tidak mendapatkan apa-apa mencetak, sehingga tidak menemukan bahwa bagi kita.

1008
01:09:45,000 --> 01:09:51,000
Itu bagus, karena itu tidak ada dalam daftar kami.

1009
01:09:51,000 --> 01:09:53,000
>> Kita sekarang kehabisan waktu.

1010
01:09:53,000 --> 01:09:55,000
Itu akan baik untuk minggu ini.

1011
01:09:55,000 --> 01:10:00,000
Terima kasih untuk bergabung, dan lihat nanti.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]