1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Раздел 3] [по-малко удобни]

2
00:00:03,000 --> 00:00:05,000
>> [Нейт Hardison] [Харвардския университет]

3
00:00:05,000 --> 00:00:08,000
>> [Това е CS50. [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Добре, нека да започнем.

5
00:00:10,000 --> 00:00:13,000
Добре дошли в 4-та седмица на CS50.

6
00:00:13,000 --> 00:00:19,000
Ако вие отворите уеб браузър и отворете pset 3,

7
00:00:19,000 --> 00:00:23,000
Катеря с CS50, отиваме да почне да ходи

8
00:00:23,000 --> 00:00:26,000
чрез секцията на въпросите там.

9
00:00:26,000 --> 00:00:32,000
Също като миналата седмица, ние ще се работи в CS50 пространства,

10
00:00:32,000 --> 00:00:35,000
ако ще дръпнете, че, както и,

11
00:00:35,000 --> 00:00:43,000
и ако отидете напред и да посетите тази връзка, че имам тук на върха.

12
00:00:43,000 --> 00:00:45,000
Това е време, за да започнете.

13
00:00:45,000 --> 00:00:51,000
Имаме малка програма хай тук. Нищо луд.

14
00:00:51,000 --> 00:00:55,000
Едно от първите неща, които искам да направя с вас днес е да отидете в продължение на няколко решения

15
00:00:55,000 --> 00:00:58,000
Проблем Set 1, вид например решения,

16
00:00:58,000 --> 00:01:03,000
само така можете да получите усещане за това какви на код персонал е писмено,

17
00:01:03,000 --> 00:01:07,000
какви код другите ученици пишете,

18
00:01:07,000 --> 00:01:10,000
и трябва да погледнете в него, защото знам, че е странно

19
00:01:10,000 --> 00:01:14,000
когато представи решение за проблем и да получите коментари

20
00:01:14,000 --> 00:01:18,000
собствената си версия, но понякога е полезно да се види как други хора го правеха,

21
00:01:18,000 --> 00:01:22,000
особено тези, които са приятни търсите.

22
00:01:22,000 --> 00:01:27,000
За по-голямата си част, аз бях наистина впечатлен с решения, че вие, момчета, произведени.

23
00:01:27,000 --> 00:01:31,000
Все още не съм започнаха да търсят най-Проблем Задайте своите 2s, но ако те са нещо като първи,

24
00:01:31,000 --> 00:01:34,000
това не означава нищо друго освен добри неща.

25
00:01:34,000 --> 00:01:40,000
>> Ако се вгледате в моите ревизии, нека започнем по целия път надолу към Ревизия 1,

26
00:01:40,000 --> 00:01:47,000
и ние ще хвърлим един бърз поглед на решение Марио.

27
00:01:47,000 --> 00:01:54,000
Ако се справим с това до тези програми, които отиваме да представи са верни.

28
00:01:54,000 --> 00:01:56,000
Не бяха проблеми с вярност на тези проблеми, но по-скоро,

29
00:01:56,000 --> 00:01:59,000
искаме да поговорим малко за различните въпроси на проектирането

30
00:01:59,000 --> 00:02:03,000
, които се използват тук.

31
00:02:03,000 --> 00:02:08,000
Едно от нещата, които беше интересно за решение

32
00:02:08,000 --> 00:02:11,000
е, че той използва тази нова конструкция, наречена паунд определи,

33
00:02:11,000 --> 00:02:15,000
понякога посочен като хеш определят.

34
00:02:15,000 --> 00:02:18,000
Позволете ми да се фокусирам върху него тук.

35
00:02:18,000 --> 00:02:24,000
A # определят ви позволява да дава имена на тези номера в програмата си.

36
00:02:24,000 --> 00:02:28,000
В този случай максималната височина на пирамида в Марио

37
00:02:28,000 --> 00:02:34,000
е 23, отколкото да сложат 23 в моя код

38
00:02:34,000 --> 00:02:37,000
ние ще се отнасят до това толкова трудно кодиране 23 -

39
00:02:37,000 --> 00:02:43,000
вместо това дава името MAX_HEIGHT на този номер,

40
00:02:43,000 --> 00:02:48,000
така че тук ми направи линия, докато

41
00:02:48,000 --> 00:02:51,000
всъщност може да се отнася до MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
вместо да постави номер 23.

43
00:02:55,000 --> 00:02:57,000
Студентски] Какво е предимството на това?

44
00:02:57,000 --> 00:02:59,000
Това е чудесен въпрос.

45
00:02:59,000 --> 00:03:03,000
Един от тях е четивността.

46
00:03:03,000 --> 00:03:08,000
Едно от предимствата на използването на този # определят четливост.

47
00:03:08,000 --> 00:03:11,000
Когато чета този код, не мога да видя какво става.

48
00:03:11,000 --> 00:03:15,000
>> Мога да видя в това състояние, че ние тестваме

49
00:03:15,000 --> 00:03:19,000
за височината е <0, което бихме могли да се определя също така

50
00:03:19,000 --> 00:03:22,000
да бъде минимална височина или височина мин.

51
00:03:22,000 --> 00:03:25,000
Другото предимство е, че може да прочетете останалата част от линията, за да се види

52
00:03:25,000 --> 00:03:30,000
че ние сме също така проверка за да се уверите, че височината не е по-голяма от максимална височина,

53
00:03:30,000 --> 00:03:35,000
защото ние ще продължим, докато височината е по-голяма от максимална височина.

54
00:03:35,000 --> 00:03:40,000
Другото предимство е, ако намалите малко тук

55
00:03:40,000 --> 00:03:49,000
ако стартирате тази програма и аз го стартирате, да речем, с 23 сега,

56
00:03:49,000 --> 00:03:52,000
той ще отпечата всички 23 реда просто ей така.

57
00:03:52,000 --> 00:03:54,000
Но да кажа, че искаше да промени максимална височина,

58
00:03:54,000 --> 00:03:57,000
и сега искам да се ограничи максималната височина на пирамидите

59
00:03:57,000 --> 00:04:06,000
да само да кажа, човече, това беше фънки.

60
00:04:06,000 --> 00:04:14,000
# Включват <stdio.h>, # определят MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
и да кажем, че ние искахме тя да е равна на 10.

62
00:04:18,000 --> 00:04:22,000
Сега, в този момент, всичко, което трябваше да направя, е да го промените на това място.

63
00:04:22,000 --> 00:04:27,000
Мога да компилирате код, и сега ако се опитам и въведете 12,

64
00:04:27,000 --> 00:04:30,000
ще ме подкани отново.

65
00:04:30,000 --> 00:04:33,000
В този случай, ние сме само с помощта на MAX_HEIGHT веднъж.

66
00:04:33,000 --> 00:04:37,000
Не е толкова голяма караница да отида в

67
00:04:37,000 --> 00:04:40,000
и да я промените в линия, докато, ако имате нужда да.

68
00:04:40,000 --> 00:04:44,000
Но в програми, където сте се позовават на същия брой магия

69
00:04:44,000 --> 00:04:47,000
отново и отново, това # определят механизъм е много удобен

70
00:04:47,000 --> 00:04:52,000
защото просто го смените едно и също време в началото на файла - това е обикновено, където можете да ги

71
00:04:52,000 --> 00:04:57,000
и промяна прониква през останалата част от файла.

72
00:04:57,000 --> 00:05:02,000
>> Други неща, които исках да се отбележи в тази задача, че мислех, че изглеждаше много хубаво,

73
00:05:02,000 --> 00:05:05,000
един е именуване на променливите.

74
00:05:05,000 --> 00:05:14,000
Вие виждате, че тук имаме целочислени променливи, наречени ред и призова височина.

75
00:05:14,000 --> 00:05:20,000
Пространства, хешове, тя помага на кода малко по-разбираеми,

76
00:05:20,000 --> 00:05:25,000
прави малко по-разбираемо какво всъщност става.

77
00:05:25,000 --> 00:05:31,000
Това е в контраст с помощта, да речем, произволни букви

78
00:05:31,000 --> 00:05:35,000
или просто бръщолевене напълно.

79
00:05:35,000 --> 00:05:39,000
Окончателното нещо, което ще се отбележи, е, че за вериги,

80
00:05:39,000 --> 00:05:45,000
често тези итератор променливи, тези броячи, които се използват за вериги,

81
00:05:45,000 --> 00:05:51,000
Това е стандартна и конвенционално към тях започват или със и след това J и след това к

82
00:05:51,000 --> 00:05:54,000
и става от там, ако имате нужда от повече променливи,

83
00:05:54,000 --> 00:05:56,000
и това е само конвенция.

84
00:05:56,000 --> 00:05:58,000
Има много спогодби.

85
00:05:58,000 --> 00:06:00,000
Това зависи от език за програмиране, който използвате.

86
00:06:00,000 --> 00:06:04,000
Но в C, ние обикновено започват с аз.

87
00:06:04,000 --> 00:06:08,000
То няма смисъл да се използва, да речем, или б

88
00:06:08,000 --> 00:06:13,000
в зависимост от ситуацията.

89
00:06:13,000 --> 00:06:15,000
Това е за това.

90
00:06:15,000 --> 00:06:25,000
Ако сега издърпайте нагоре Преработка 2, ще видите друга Марио,

91
00:06:25,000 --> 00:06:29,000
и това е подобно на другия, че току-що видяхме,

92
00:06:29,000 --> 00:06:32,000
но го прави нещо готино.

93
00:06:32,000 --> 00:06:38,000
Ако се вгледаме в този раздел тук във вътрешния контур

94
00:06:38,000 --> 00:06:44,000
те използват някои луди тук синтаксиса точно в този ред.

95
00:06:44,000 --> 00:06:47,000
Това се нарича третичния оператор.

96
00:06:47,000 --> 00:06:53,000
Това е ако друго изявление, сбива в един ред.

97
00:06:53,000 --> 00:06:57,000
Условието е тази част в скоби.

98
00:06:57,000 --> 00:07:05,000
Това е равностойно да се каже, ако J <височина - I - 1.

99
00:07:05,000 --> 00:07:10,000
И тогава какво е съдържанието на това, ако блок ще бъде пространството

100
00:07:10,000 --> 00:07:16,000
и след това съдържанието на какво друго би било #.

101
00:07:16,000 --> 00:07:20,000
Това е по същество пространство, за да се възложи тази променлива.

102
00:07:20,000 --> 00:07:24,000
Това е пространство, в съдържанието на блока променлива,

103
00:07:24,000 --> 00:07:29,000
Ако това условие е изпълнено, и ако условието не е изпълнено,

104
00:07:29,000 --> 00:07:32,000
блок променлива получава #.

105
00:07:32,000 --> 00:07:37,000
И тогава, разбира се, вместо изграждане на целия низ

106
00:07:37,000 --> 00:07:43,000
и отпечатване на всичко в края на това решение го отпечатва един символ в даден момент.

107
00:07:43,000 --> 00:07:48,000
Много готино.

108
00:07:48,000 --> 00:07:53,000
>> Още няколко неща за гледане. Ние ще преминем към алчен.

109
00:07:53,000 --> 00:07:58,000
Сега, ако погледнем алчен, това първото решение

110
00:07:58,000 --> 00:08:00,000
използва тези # определя доста.

111
00:08:00,000 --> 00:08:06,000
Имаме една константа, определени за всяка от различни номера в тази програма.

112
00:08:06,000 --> 00:08:12,000
Имаме един цента за долар, една за четвърти, Dimes, Nickels и стотинките,

113
00:08:12,000 --> 00:08:15,000
и сега, ако ние превъртете надолу и прочетете кода,

114
00:08:15,000 --> 00:08:22,000
можем да видим обикновено трябва да направите, докато всичко печат контур.

115
00:08:22,000 --> 00:08:25,000
Вид на същността на този проблем е да осъзнават, че

116
00:08:25,000 --> 00:08:29,000
ви е необходимо да конвертирате поплавъка, че сте прочели от потребителя до цяло число

117
00:08:29,000 --> 00:08:32,000
точно да направите по математика, и това е така, защото

118
00:08:32,000 --> 00:08:36,000
с числа с плаваща запетая, като говорихме за лекция накратко,

119
00:08:36,000 --> 00:08:41,000
не е възможно точно да представлява всяка една стойност на броя линия

120
00:08:41,000 --> 00:08:47,000
защото има безкрайно много стойности между 3 и, да речем, 3.1 дори.

121
00:08:47,000 --> 00:08:54,000
Можете да имате 3,01 и 3,001 и 3,0001, и можеш да продължиш напред.

122
00:08:54,000 --> 00:09:00,000
Оказва се, че всеки път, когато работите с пари, вие често искате да го конвертирате

123
00:09:00,000 --> 00:09:05,000
в целочислен формат, така че да не губим пари и от този род неща.

124
00:09:05,000 --> 00:09:09,000
Правейки това и закръгляване е от ключово значение.

125
00:09:09,000 --> 00:09:14,000
Това решение използва съвършено ясно, голяма алгоритъм,

126
00:09:14,000 --> 00:09:17,000
които декрементирани броя на останалите цента, първо по тримесечия,

127
00:09:17,000 --> 00:09:19,000
след това от Dimes, а след това от петачета, след това от пари,

128
00:09:19,000 --> 00:09:24,000
и добавяне на броя на монети всеки път.

129
00:09:24,000 --> 00:09:31,000
>> Друго решение, което ще видим, както аз я увеличите и отидете на Преглед на четири,

130
00:09:31,000 --> 00:09:40,000
имаше много сходни началото, но вместо това е използвало дивизия и Министерството на отбраната

131
00:09:40,000 --> 00:09:44,000
точно тук, за да се изчисли броят на цента.

132
00:09:44,000 --> 00:09:50,000
Това, на броя на тримесечията е равен на броя на разделени от 25 цента,

133
00:09:50,000 --> 00:09:53,000
и причината това работи е така, защото правим целочислено деление,

134
00:09:53,000 --> 00:09:58,000
така че се изхвърля остатъка.

135
00:09:58,000 --> 00:10:02,000
[Student] Трябва ли да коментирате търсене?

136
00:10:02,000 --> 00:10:05,000
Това наистина зависи.

137
00:10:05,000 --> 00:10:08,000
Студентски Вие коментира повече от код тук.

138
00:10:08,000 --> 00:10:16,000
Да, и така има един куп различни философии за това.

139
00:10:16,000 --> 00:10:21,000
Моята лична философия е, че кодът е наистина истината,

140
00:10:21,000 --> 00:10:24,000
като код е какво всъщност се изпълнява на компютъра,

141
00:10:24,000 --> 00:10:29,000
и така вашия код трябва да се чете като е възможно да не налагат най-много коментари.

142
00:10:29,000 --> 00:10:33,000
Това каза, когато правите неща, които са вид на сложен математически

143
00:10:33,000 --> 00:10:38,000
или алгоритмично, че е добре да се коментира, така че можете да

144
00:10:38,000 --> 00:10:43,000
добавите допълнително измерение, допълнителен слой на всеки, който чете кода си.

145
00:10:43,000 --> 00:10:49,000
В тези решения, често те са коментирани по-силно само защото

146
00:10:49,000 --> 00:10:52,000
искаме да бъдем в състояние да ги разпространява и има хора, които ги вземете

147
00:10:52,000 --> 00:10:56,000
и да ги четат доста лесно.

148
00:10:56,000 --> 00:11:05,000
Но определено, бих се съгласил, че това е тежък.

149
00:11:05,000 --> 00:11:07,000
[Student] Но когато се съмнявате, отидете по-тежки?

150
00:11:07,000 --> 00:11:10,000
Когато се съмнявате, отидете по-тежки.

151
00:11:10,000 --> 00:11:17,000
Някои хора ще казват понякога връщането на 0 или нещо подобно.

152
00:11:17,000 --> 00:11:20,000
Мисля, че е смешен коментар.

153
00:11:20,000 --> 00:11:22,000
Ясно е, че това, което се случва.

154
00:11:22,000 --> 00:11:25,000
Нямам нужда от английски, за да ми каже, че.

155
00:11:25,000 --> 00:11:28,000
Понякога хората ще пишат неща като "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Това е вид сладък, но също така не-

157
00:11:32,000 --> 00:11:35,000
, който не прави разлика между коментиране точки или не.

158
00:11:35,000 --> 00:11:41,000
Тези коментари са просто ха, ха.

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

160
00:11:43,000 --> 00:11:48,000
>> В този момент, нека да започнем да работим по проблема 3 раздел от въпроси.

161
00:11:48,000 --> 00:11:52,000
Ако вие го направим отново,

162
00:11:52,000 --> 00:11:55,000
с миналата седмица, ние не отиваме да гледате късометражни филми в този раздел.

163
00:11:55,000 --> 00:12:00,000
Ще оставим вие направите това по собствения си път и се говори за въпросите.

164
00:12:00,000 --> 00:12:05,000
Но сега в този раздел отиваме да прекарат малко повече време

165
00:12:05,000 --> 00:12:11,000
говорим за по-малко от кодиране основите

166
00:12:11,000 --> 00:12:15,000
както направихме миналата седмица, и вместо това, ние отиваме да се съсредоточи повече върху

167
00:12:15,000 --> 00:12:22,000
малко повече на теорията, така че говорим за двоично търсене и след това сортиране.

168
00:12:22,000 --> 00:12:27,000
От тези от вас, които са били заедно с лекцията,

169
00:12:27,000 --> 00:12:30,000
Може ли някой да ми даде една рекапитулация на каква е разликата

170
00:12:30,000 --> 00:12:35,000
между двоично търсене и линейни търсене?

171
00:12:35,000 --> 00:12:37,000
Какво става? - Разбира се.

172
00:12:37,000 --> 00:12:42,000
Линейни търсения чрез всеки елемент в сортиран списък

173
00:12:42,000 --> 00:12:45,000
един по един по един по един по един,

174
00:12:45,000 --> 00:12:50,000
двоично търсене разделя списък в две групи,

175
00:12:50,000 --> 00:12:57,000
Проверява дали стойността на клавишите, че търсите е по-голямо или по-малко от стойността на средата

176
00:12:57,000 --> 00:13:00,000
че просто намери, и ако това е по-малко, то върви с долната списък

177
00:13:00,000 --> 00:13:03,000
и после разделя отново, същата функция

178
00:13:03,000 --> 00:13:07,000
по целия път надолу, докато се намери средата, за да бъде равна на самата стойност.

179
00:13:07,000 --> 00:13:10,000
Точно така.

180
00:13:10,000 --> 00:13:12,000
>> Защо ни е грижа?

181
00:13:12,000 --> 00:13:20,000
Защо говорим за двоично търсене в сравнение с линейна търсене?

182
00:13:20,000 --> 00:13:22,000
Да.

183
00:13:22,000 --> 00:13:24,000
Binary е много по-бързо, така че ако удвои размера на проблема

184
00:13:24,000 --> 00:13:27,000
е необходимо още една стъпка, а не два пъти повече.

185
00:13:27,000 --> 00:13:29,000
Точно така.

186
00:13:29,000 --> 00:13:31,000
Това е чудесен отговор.

187
00:13:31,000 --> 00:13:36,000
Linear търсене е много проверка на един елемент в даден момент,

188
00:13:36,000 --> 00:13:39,000
и както видяхме още в първия ден на лекцията

189
00:13:39,000 --> 00:13:42,000
когато Дейвид премина през неговия пример телефонния указател

190
00:13:42,000 --> 00:13:45,000
и изтръгна една страница от телефонния указател в даден момент

191
00:13:45,000 --> 00:13:47,000
и това, че отново и отново и отново,

192
00:13:47,000 --> 00:13:51,000
, че ще му отнеме много дълго време, за да се намери някой в ​​телефонния указател,

193
00:13:51,000 --> 00:13:55,000
освен ако, разбира се, той е търсил някой в ​​самото начало на азбуката.

194
00:13:55,000 --> 00:14:00,000
С двоично търсене, можете да отидете много по-бързо,

195
00:14:00,000 --> 00:14:05,000
и това не е само два пъти по-бързо, или три пъти по-бързо или четири пъти по-бързо.

196
00:14:05,000 --> 00:14:13,000
Но проблемът става по-малък и по-малки и по-малки много по-бързо.

197
00:14:13,000 --> 00:14:17,000
За да се убедите в това, ние ще започнем да говорим за това какво става

198
00:14:17,000 --> 00:14:21,000
когато пишем двоично търсене.

199
00:14:21,000 --> 00:14:27,000
Проблемът на ръка е, че ако имам масив от числа,

200
00:14:27,000 --> 00:14:40,000
да речем, 1, 2, 3, 5, 7, 23, 45, 78, 12,323,

201
00:14:40,000 --> 00:14:47,000
и след това 9 с тон на 0s след него,

202
00:14:47,000 --> 00:14:52,000
искаме да бъдем в състояние да разбера наистина бързо, което е в

203
00:14:52,000 --> 00:14:57,000
този масив от числа.

204
00:14:57,000 --> 00:15:00,000
Знам, че това изглежда малко глупаво и малко измислен,

205
00:15:00,000 --> 00:15:02,000
защото точно сега.

206
00:15:02,000 --> 00:15:05,000
Имаме масив, който не разполага с много елементи в нея,

207
00:15:05,000 --> 00:15:08,000
и ако питам някой от вас да разбера дали или не

208
00:15:08,000 --> 00:15:11,000
23 е в масива, можете да направите това доста бързо

209
00:15:11,000 --> 00:15:16,000
само като погледна и ми казва "да" или "не".

210
00:15:16,000 --> 00:15:20,000
Аналоговият е да се помисли, представете си, ако това беше, да речем,

211
00:15:20,000 --> 00:15:27,000
електронна таблица на Excel с 10 000 реда, 20 хиляди редове.

212
00:15:27,000 --> 00:15:31,000
Разбира се, можете да направите командата F или F и да потърсите нещо.

213
00:15:31,000 --> 00:15:33,000
Можете също да използвате филтри за търсене и неща,

214
00:15:33,000 --> 00:15:37,000
но ако трябваше да се търсят чрез този файл ред по ред по ред,

215
00:15:37,000 --> 00:15:40,000
това ще ви отнеме много време, за да го намерите.

216
00:15:40,000 --> 00:15:42,000
Това е нещо като в примера за телефонния указател, твърде, където

217
00:15:42,000 --> 00:15:44,000
никой не гледа през телефон Книга първа страница в даден момент.

218
00:15:44,000 --> 00:15:47,000
Обикновено те не го отворите в средата,

219
00:15:47,000 --> 00:15:50,000
или в случай на много телефонни книги и речници, където

220
00:15:50,000 --> 00:15:54,000
всъщност са го въвели В първото писмо,

221
00:15:54,000 --> 00:16:01,000
флип, че първото писмо и да се открие и да започне да минава през там.

222
00:16:01,000 --> 00:16:03,000
>> Напомни ми на името си отново. >> Сам.

223
00:16:03,000 --> 00:16:05,000
Сам.

224
00:16:05,000 --> 00:16:11,000
Като Сам каза, че линеен процес на търсене ще бъде много бавен,

225
00:16:11,000 --> 00:16:15,000
и вместо с двоично търсене, начина, по който това работи е, че

226
00:16:15,000 --> 00:16:21,000
всеки път, когато отидете чрез повторение на нашия алгоритъм на търсене,

227
00:16:21,000 --> 00:16:27,000
отиваме да се разделят списъка на половина, по същество,

228
00:16:27,000 --> 00:16:33,000
в две по-малки списъци.

229
00:16:33,000 --> 00:16:39,000
И тогава на следващата итерация на цикъла, ние ще го разделят отново

230
00:16:39,000 --> 00:16:44,000
в други по-малки списъци.

231
00:16:44,000 --> 00:16:48,000
Както можете да видите, проблемът продължава все по-малък и по-малък

232
00:16:48,000 --> 00:16:55,000
защото пазим изхвърля половината от списъка всеки един момент.

233
00:16:55,000 --> 00:16:59,000
Как става това изхвърлете работа?

234
00:16:59,000 --> 00:17:05,000
Просто като напомняне, това, което ние отиваме да направите, ако бяхме компютър

235
00:17:05,000 --> 00:17:11,000
и ние бяхме, да речем, търсене на числото 5 в този списък

236
00:17:11,000 --> 00:17:15,000
е, че ние ще вземем редица в средата.

237
00:17:15,000 --> 00:17:26,000
В средата на този списък, защото има 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 номера,

238
00:17:26,000 --> 00:17:32,000
щяхме да изберете номер или на 4 или на 5-та позиция,

239
00:17:32,000 --> 00:17:38,000
и ние ще се обади, че в средата на нашия списък.

240
00:17:38,000 --> 00:17:42,000
Трансфер номер в средата.

241
00:17:42,000 --> 00:17:51,000
Тогава, точно както каза Сам, ние ще тестваме да се види, ако този брой е равен

242
00:17:51,000 --> 00:17:59,000
номера, на който искате да получите или нашите желания номер.

243
00:17:59,000 --> 00:18:06,000
Ако е еднакъв, то ние сме го намерили. Ние печелим.

244
00:18:06,000 --> 00:18:12,000
Ако не е равен, след това има няколко случаи.

245
00:18:12,000 --> 00:18:15,000
Двата случая са или номерът трябва да бъде по-голям от броя търсим,

246
00:18:15,000 --> 00:18:19,000
или това е по-малко от.

247
00:18:19,000 --> 00:18:25,000
Ако тя е по-голяма, ние се движат в дясно.

248
00:18:25,000 --> 00:18:33,000
И ако това е по-малко, ние се движат наляво.

249
00:18:33,000 --> 00:18:41,000
И тогава ние повторите целия процес отново

250
00:18:41,000 --> 00:18:48,000
или дясната половина или лявата половина на списъка.

251
00:18:48,000 --> 00:18:51,000
>> Първият проблем в раздел днес е да разбера

252
00:18:51,000 --> 00:18:55,000
как всъщност можем да започне да изразя това в C код.

253
00:18:55,000 --> 00:18:58,000
Имаме pseudocode тук.

254
00:18:58,000 --> 00:19:04,000
Какво ще започнете да правите е, че ще дръпне един чисто ново пространство,

255
00:19:04,000 --> 00:19:09,000
освен това преразглеждане, така че имаме тези бележки за по-късно,

256
00:19:09,000 --> 00:19:20,000
ще изтриете всичко това, и след това да копирате и поставяте от проблема,

257
00:19:20,000 --> 00:19:26,000
тази информация в нашите пространства, и да се надяваме, че това не се е разпаднала.

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

259
00:19:28,000 --> 00:19:33,000
Ако вие направите това, копирате и поставите този код в новия си пространство,

260
00:19:33,000 --> 00:19:43,000
в празен.

261
00:19:43,000 --> 00:19:47,000
Нека се опитаме Даниел. Ако вие компилирате и стартирате тази програма, не работят?

262
00:19:47,000 --> 00:19:49,000
No. >> Какво говориш?

263
00:19:49,000 --> 00:19:53,000
Той казва, контрол достигне края на нищожно функция.

264
00:19:53,000 --> 00:19:55,000
Да, така че нека се опитам да я пуснете.

265
00:19:55,000 --> 00:19:59,000
Сте виждали преди? Знаете ли какво означава това?

266
00:19:59,000 --> 00:20:01,000
Добре, нека да изясним това малко.

267
00:20:01,000 --> 00:20:10,000
Той казва в file.c на линия 9, колона 1 имаме грешка, точно както ти каза,

268
00:20:10,000 --> 00:20:16,000
и то се казва, че това е, произтичащи от грешка предупреждение и предупреждение за връщане тип.

269
00:20:16,000 --> 00:20:18,000
Тя изглежда като нещо, което се случва с типът на връщане, което има смисъл.

270
00:20:18,000 --> 00:20:21,000
Имаме нищожно функция, което означава, че имаме функция

271
00:20:21,000 --> 00:20:24,000
, който не се връща невалидни.

272
00:20:24,000 --> 00:20:27,000
Празнота функция е тази, която изглежда по този начин:

273
00:20:27,000 --> 00:20:35,000
невалидни Foo (), и това е нищожно, защото типът на връщане е невалиден,

274
00:20:35,000 --> 00:20:38,000
което означава, че ако имахме нещо тук

275
00:20:38,000 --> 00:20:45,000
като връщане 1, щяхме да се получи грешка за това.

276
00:20:45,000 --> 00:20:49,000
Въпреки това, ние имаме нищожно функция.

277
00:20:49,000 --> 00:20:51,000
Нашата нищожно функция в този случай е нашата функция за търсене

278
00:20:51,000 --> 00:20:56,000
, защото има връщане тип булев.

279
00:20:56,000 --> 00:20:59,000
Когато се казва, че контролът достигне края на нищожно функция,

280
00:20:59,000 --> 00:21:02,000
това е, защото търсенето не да правят изявление за връщане.

281
00:21:02,000 --> 00:21:04,000
Това не е връщане нищо от тип булев.

282
00:21:04,000 --> 00:21:09,000
>> Ние можем да поправим това, и какво вие мислите

283
00:21:09,000 --> 00:21:13,000
търсене трябва да се върне по подразбиране?

284
00:21:13,000 --> 00:21:16,000
Каква трябва да бъде на стойност по подразбиране за връщане на търсенето?

285
00:21:16,000 --> 00:21:19,000
Защото това е, което ние можем да поставим в края.

286
00:21:19,000 --> 00:21:21,000
Шарлот, имаш ли?

287
00:21:21,000 --> 00:21:23,000
Вярно или невярно? >> Вярно или невярно.

288
00:21:23,000 --> 00:21:26,000
Кой?

289
00:21:26,000 --> 00:21:28,000
False. Не знам.

290
00:21:28,000 --> 00:21:30,000
False? Нека да опитаме.

291
00:21:30,000 --> 00:21:32,000
Защо бихте казали връщане фалшиви? Това е голяма интуиция.

292
00:21:32,000 --> 00:21:35,000
Шарлот] Не знам.

293
00:21:35,000 --> 00:21:39,000
Отиваме да се върне фалшиви в този случай, защото това ще бъде нашето подразбиране

294
00:21:39,000 --> 00:21:44,000
ако по някаква причина списъкът е празен или иглата

295
00:21:44,000 --> 00:21:46,000
че търсим не съществува.

296
00:21:46,000 --> 00:21:50,000
След това, в самия край, ако ние не се връщат вярно по-рано в тази функция,

297
00:21:50,000 --> 00:21:55,000
ние винаги знаем, че тази функция ще кажа Не, това не е в масива.

298
00:21:55,000 --> 00:21:58,000
Това не е в купа сено.

299
00:21:58,000 --> 00:22:03,000
Сега, ако се съставя и го пуснете да ме спаси това, за да можем да го издърпайте нагоре.

300
00:22:03,000 --> 00:22:08,000
Сега, ако си компилирате и изпълнявате нашата програма, то се натрупва.

301
00:22:08,000 --> 00:22:12,000
Ще ни малко ред.

302
00:22:12,000 --> 00:22:20,000
Ако ми излезе 4-ъ-ъ-о.

303
00:22:20,000 --> 00:22:25,000
Не се отпечата нищо. Изглежда, че всичко свърши добре.

304
00:22:25,000 --> 00:22:35,000
Трябва да се запълни тази инча

305
00:22:35,000 --> 00:22:39,000
Ние говорихме за алгоритъм в pseudocode преди малко.

306
00:22:39,000 --> 00:22:44,000
Нека видим, освен това,

307
00:22:44,000 --> 00:22:49,000
и аз ще дръпнете, че алгоритъм обратно отново.

308
00:22:49,000 --> 00:22:51,000
Нека да удари този човек. Не.

309
00:22:51,000 --> 00:22:58,000
Това е то.

310
00:22:58,000 --> 00:23:03,000
Как да постигнем това?

311
00:23:03,000 --> 00:23:11,000
Каква би била една добра стратегия за започване на този код?

312
00:23:11,000 --> 00:23:16,000
Вие трябва да изберете номер в средата.

313
00:23:16,000 --> 00:23:23,000
Как да вземем редица в средата на масива?

314
00:23:23,000 --> 00:23:25,000
Някакви предложения?

315
00:23:25,000 --> 00:23:27,000
[Student] Strlen разделена на 2.

316
00:23:27,000 --> 00:23:32,000
Strlen разделена на 2. Това е страхотно.

317
00:23:32,000 --> 00:23:35,000
Strlen работи със специални видове масиви.

318
00:23:35,000 --> 00:23:38,000
Какви масиви?

319
00:23:38,000 --> 00:23:44,000
String масиви, характер масиви.

320
00:23:44,000 --> 00:23:48,000
Това е, че един и същи вид на концепцията, че ние искаме да се прилагат,

321
00:23:48,000 --> 00:23:52,000
но не можем да използваме strlen, защото ние нямаме за масив от знаци.

322
00:23:52,000 --> 00:23:55,000
Ние имаме масив от цели числа.

323
00:23:55,000 --> 00:23:58,000
Но какво означава strlen за нас?

324
00:23:58,000 --> 00:24:01,000
Знаете ли какво става за нас?

325
00:24:01,000 --> 00:24:03,000
[Student] Strlen ни получава дължина.

326
00:24:03,000 --> 00:24:05,000
Точно така, това ни получава дължина.

327
00:24:05,000 --> 00:24:09,000
Strlen получава дължината на масива за нас.

328
00:24:09,000 --> 00:24:14,000
>> Как да стигнем до тази в нашата програма за двоично търсене?

329
00:24:14,000 --> 00:24:18,000
Как ще получите дължината на масив?

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

331
00:24:20,000 --> 00:24:25,000
Можете да получите дължината на правилно форматиран низ C масив с strlen.

332
00:24:25,000 --> 00:24:31,000
Проблемът, обаче е, че ние нямаме масив низ.

333
00:24:31,000 --> 00:24:36,000
Ако погледнем назад в този кодекс, имаме цяло число масив.

334
00:24:36,000 --> 00:24:38,000
Откъде знаем колко време е?

335
00:24:38,000 --> 00:24:44,000
[Student] Има ли еквивалент на една крайна точка, като Int л или нещо?

336
00:24:44,000 --> 00:24:49,000
Оказва се, че всъщност не е, и така в известен смисъл, това е

337
00:24:49,000 --> 00:24:52,000
едно от тези неща, които е добре да се знае за C,

338
00:24:52,000 --> 00:24:57,000
, че няма начин да се получи дължината на масива

339
00:24:57,000 --> 00:24:59,000
ако всичко ти дам е масив.

340
00:24:59,000 --> 00:25:02,000
Причината за това работи със струни, причината strlen работи,

341
00:25:02,000 --> 00:25:06,000
е така, защото, ако е правилно форматиран низ,

342
00:25:06,000 --> 00:25:12,000
това, че ще има специална \ 0 характер в самия край.

343
00:25:12,000 --> 00:25:16,000
>> Можете също така да си представите, ако имате неправилно форматиран низ

344
00:25:16,000 --> 00:25:20,000
и там не \ 0 характер, а след това цялото нещо не работи.

345
00:25:20,000 --> 00:25:22,000
[Student] Може ли да добавите \ 0?

346
00:25:22,000 --> 00:25:24,000
Бихме могли в този случай.

347
00:25:24,000 --> 00:25:29,000
Можем да добавим някаква \ 0

348
00:25:29,000 --> 00:25:33,000
или някакъв вид показваше характер и след това да го използвате.

349
00:25:33,000 --> 00:25:36,000
Но това не е съвсем ще работи

350
00:25:36,000 --> 00:25:40,000
защото е знак тип \ 0,

351
00:25:40,000 --> 00:25:43,000
и тук имаме цели числа.

352
00:25:43,000 --> 00:25:46,000
Другото нещо е, ако бяхме да се използва специален стойност

353
00:25:46,000 --> 00:25:49,000
като -1, за да отбележат края на масива

354
00:25:49,000 --> 00:25:54,000
тогава ние никога не може да се съхранява -1 в нашите целочислени масиви.

355
00:25:54,000 --> 00:25:56,000
Бихме се залепи.

356
00:25:56,000 --> 00:26:00,000
Оказва се, че единственият начин да получите дължината

357
00:26:00,000 --> 00:26:03,000
на масив в C е всъщност да го помня

358
00:26:03,000 --> 00:26:08,000
когато сте задали и след това преминават около масива

359
00:26:08,000 --> 00:26:14,000
така че всеки път, когато имат функция, която ще да свърша някаква работа

360
00:26:14,000 --> 00:26:18,000
на масив от цели числа или салове или удвоява или какво ли,

361
00:26:18,000 --> 00:26:22,000
Аз също трябва да даде функцията дължината на масива,

362
00:26:22,000 --> 00:26:26,000
и това е точно това, което сме направили тук, в функцията за търсене.

363
00:26:26,000 --> 00:26:30,000
Ако погледнете, какво сме направили, когато преминем в нашия масив,

364
00:26:30,000 --> 00:26:36,000
ние също преминават в дължината, размера.

365
00:26:36,000 --> 00:26:41,000
Тя просто се случва, че ние нарекохме тази променлива,

366
00:26:41,000 --> 00:26:43,000
този параметър или аргумент.

367
00:26:43,000 --> 00:26:46,000
Това се нарича списъкът с аргументите на функцията или списък параметър,

368
00:26:46,000 --> 00:26:51,000
и те са също така наречени аргументи и параметри.

369
00:26:51,000 --> 00:26:53,000
Хората използват различни термини по различно време.

370
00:26:53,000 --> 00:26:55,000
Понякога ги себе си разменете.

371
00:26:55,000 --> 00:27:00,000
Просто така се случи, че тази променлива тук се нарича по същия начин

372
00:27:00,000 --> 00:27:03,000
тази # дефинирате до тук.

373
00:27:03,000 --> 00:27:06,000
Но те не са едно и също нещо.

374
00:27:06,000 --> 00:27:11,000
Капитализация е от значение.

375
00:27:11,000 --> 00:27:14,000
>> Ако погледнем какво се случва тук, ние заявяваме

376
00:27:14,000 --> 00:27:18,000
INT масив, който сме призовани номера.

377
00:27:18,000 --> 00:27:23,000
Съм го дал размера, който съответства на нашата # определят най-отгоре.

378
00:27:23,000 --> 00:27:27,000
Ще бъде 8.

379
00:27:27,000 --> 00:27:35,000
И тогава, когато ние след това се свържете с нашата функция за търсене по-долу,

380
00:27:35,000 --> 00:27:40,000
минаваме в числото, което ще искате да търсите, за които сме подканени,

381
00:27:40,000 --> 00:27:43,000
придобили от потребителя.

382
00:27:43,000 --> 00:27:46,000
Минаваме в масива, тези номера,

383
00:27:46,000 --> 00:27:51,000
и след това ние също трябва да премине в размер на масива,

384
00:27:51,000 --> 00:27:57,000
и след това се записва стойността на размер 8

385
00:27:57,000 --> 00:28:01,000
или предава тази целочислена променлива наречена размер.

386
00:28:01,000 --> 00:28:08,000
Имаме размера на масива.

387
00:28:08,000 --> 00:28:11,000
Сега, ако се върнем към това, което се говори за по-рано,

388
00:28:11,000 --> 00:28:14,000
Мисля, Missy до точката, че това, което трябва да направим, е да получите дължината на масива

389
00:28:14,000 --> 00:28:20,000
и го разделете на две, и това ще ни даде средата.

390
00:28:20,000 --> 00:28:22,000
Да видим.

391
00:28:22,000 --> 00:28:25,000
Мога ли има някой, пиша това и да го запишете в тяхното пространство?

392
00:28:25,000 --> 00:28:27,000
Какво ще кажете за Лейла?

393
00:28:27,000 --> 00:28:31,000
Мога ли да ти пиша това?

394
00:28:31,000 --> 00:28:35,000
Напишете първия ред, където можете да вземете дължината на масива и да получите средата

395
00:28:35,000 --> 00:28:41,000
и да го съхранява в нова променлива.

396
00:28:41,000 --> 00:28:44,000
Ще ви дам няколко секунди. Готови ли сте?

397
00:28:44,000 --> 00:28:46,000
[Student чува]

398
00:28:46,000 --> 00:28:50,000
Разбира се, може да съм се изчисли средната точка

399
00:28:50,000 --> 00:28:55,000
на купа сено масив във вътрешността на функцията за търсене

400
00:28:55,000 --> 00:29:03,000
използвайки дължината на купа сено масив, който е размерът променлива?

401
00:29:03,000 --> 00:29:08,000
Нищо сложно тук.

402
00:29:08,000 --> 00:29:12,000
[Leila] Размерът / 2 и току-що

403
00:29:12,000 --> 00:29:17,000
И да го запишете, и натиснете бутона Save тук на върха,

404
00:29:17,000 --> 00:29:19,000
и ние ще го издърпайте нагоре.

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

406
00:29:22,000 --> 00:29:28,000
Точно така. Страхотно.

407
00:29:28,000 --> 00:29:30,000
>> Както е, това ще компилирам?

408
00:29:30,000 --> 00:29:32,000
[Leila] Не, тя трябва да бъде по-висока.

409
00:29:32,000 --> 00:29:34,000
[Nate] Да, така, какво трябва да направим?

410
00:29:34,000 --> 00:29:36,000
[Leila като INT средата или нещо такова.

411
00:29:36,000 --> 00:29:41,000
Страхотно. Да, нека да го направим, вътр средата = размер.

412
00:29:41,000 --> 00:29:44,000
Това ще компилирам?

413
00:29:44,000 --> 00:29:47,000
Нека да изтриете този коментар и да го измъкнем от пътя.

414
00:29:47,000 --> 00:29:50,000
Това, което не ще се съставят за това?

415
00:29:50,000 --> 00:29:52,000
Ние не правим нищо с цяло число,

416
00:29:52,000 --> 00:29:55,000
така че ние трябва да го отпечатате или нещо подобно.

417
00:29:55,000 --> 00:29:58,000
Да, точно така.

418
00:29:58,000 --> 00:30:00,000
Ще получите неизползван променлива.

419
00:30:00,000 --> 00:30:02,000
Какво друго не ще да работи за това?

420
00:30:02,000 --> 00:30:06,000
Мисля, че каза нещо, Сам. Точка и запетая.

421
00:30:06,000 --> 00:30:08,000
Да, аз съм липсват тези точка и запетая.

422
00:30:08,000 --> 00:30:14,000
Тя ще бъде постоянно нещо по време на курса на срока.

423
00:30:14,000 --> 00:30:17,000
Последното нещо, което ще направя е Ще сложа някои празно пространство от двете страни

424
00:30:17,000 --> 00:30:23,000
на този оператор тук, тъй като това е обикновено как го правим

425
00:30:23,000 --> 00:30:26,000
според нашия стил на ръководство.

426
00:30:26,000 --> 00:30:29,000
Имаме средата на нашия масив.

427
00:30:29,000 --> 00:30:32,000
Сега, ако ние си спомняме обратно към нашия алгоритъм,

428
00:30:32,000 --> 00:30:37,000
това, което е втората стъпка, която ние трябваше да направим, след като имаме средата?

429
00:30:37,000 --> 00:30:42,000
[Студентски] Ако тя е по-голяма чува.

430
00:30:42,000 --> 00:30:48,000
Да, така трябва да направим някакво сравнение, и това, което се сравняват тук?

431
00:30:48,000 --> 00:30:53,000
Ти каза, че ако е по-голямо. Какво е това в това изречение, отнасящи се до?

432
00:30:53,000 --> 00:30:57,000
Броят, който идва, ако това е по-голяма от средната точка, след това отидете до масива?

433
00:30:57,000 --> 00:31:05,000
Точно така, така че броят, който идва, когато ние

434
00:31:05,000 --> 00:31:10,000
Игла, така че ние сме в сравнение с иглата,

435
00:31:10,000 --> 00:31:12,000
и какво се сравняват срещу иглата?

436
00:31:12,000 --> 00:31:15,000
Тъй като иглата е това, което търсим.

437
00:31:15,000 --> 00:31:18,000
Ние сме в сравнение с стигнем до средната точка.

438
00:31:18,000 --> 00:31:21,000
>> Но има ли смисъл да се провери, за да видите

439
00:31:21,000 --> 00:31:27,000
ако игла = средата?

440
00:31:27,000 --> 00:31:32,000
Това прави ли смисъл?

441
00:31:32,000 --> 00:31:35,000
Дали някой не?

442
00:31:35,000 --> 00:31:40,000
Нека да го пробвам, ако (игла == средата).

443
00:31:40,000 --> 00:31:42,000
[Student] ФОРМАТ го намери.

444
00:31:42,000 --> 00:31:51,000
[Nate] ФОРМАТ ("Открихме го \ N");

445
00:31:51,000 --> 00:31:56,000
В противен случай съм да започнем да правим нещо по-различно тук.

446
00:31:56,000 --> 00:32:00,000
Отивам да започне поставянето на скоби наоколо, ако отчети през цялото време

447
00:32:00,000 --> 00:32:05,000
просто защото, ако ние добавяме повече неща, а след това

448
00:32:05,000 --> 00:32:07,000
ние не се съставителите.

449
00:32:07,000 --> 00:32:09,000
Да, Сам. Имаш една точка.

450
00:32:09,000 --> 00:32:12,000
Проблемът е, че средата представлява позиция в масива,

451
00:32:12,000 --> 00:32:15,000
но можете да получите да представляват стойността в това положение на масива.

452
00:32:15,000 --> 00:32:17,000
Това е страхотна точка.

453
00:32:17,000 --> 00:32:19,000
Знаете всички чуя какво каза Сам?

454
00:32:19,000 --> 00:32:22,000
Той каза, че средата е

455
00:32:22,000 --> 00:32:28,000
представлява само една позиция в масива, но това не е действителната елемент в масива.

456
00:32:28,000 --> 00:32:30,000
Ако смятате, че за код, както е написано точно сега,

457
00:32:30,000 --> 00:32:35,000
ако се вгледаме в този масив, който има осем елементи в нея,

458
00:32:35,000 --> 00:32:39,000
каква е стойността на средата ще бъде в тази функция?

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

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

461
00:32:45,000 --> 00:32:51,000
Ако търсим номер 4 -

462
00:32:51,000 --> 00:32:54,000
и ние можем само да изпълните този код и сложи малко тъжно лице тук

463
00:32:54,000 --> 00:32:58,000
, защото не можахме да намерим - ако ни свърши този код

464
00:32:58,000 --> 00:33:04,000
както е сега, да го качите, изграждане, позволете ми да превъртите надолу,

465
00:33:04,000 --> 00:33:09,000
и ако търсим номер 4,

466
00:33:09,000 --> 00:33:18,000
ние го намерихме, но ние не се получи това, за да ФОРМАТ да.

467
00:33:18,000 --> 00:33:23,000
Една от причините е, че ние не се върне вярно,

468
00:33:23,000 --> 00:33:26,000
но ние наистина номер 4?

469
00:33:26,000 --> 00:33:28,000
И Сам казва не.

470
00:33:28,000 --> 00:33:31,000
Какво открихте?

471
00:33:31,000 --> 00:33:35,000
Ние наистина се намери средата, която ако се вгледаме в масива тук,

472
00:33:35,000 --> 00:33:38,000
ще бъде елемент при индекс 4, че ние не търсим на

473
00:33:38,000 --> 00:33:42,000
, което е 23.

474
00:33:42,000 --> 00:33:46,000
>> Как да се получи в действителност този елемент в средата

475
00:33:46,000 --> 00:33:48,000
а не само на средата?

476
00:33:48,000 --> 00:33:52,000
[Student] ще влезе Чар или нещо?

477
00:33:52,000 --> 00:33:55,000
Какво ще направите, просто от любопитство?

478
00:33:55,000 --> 00:33:57,000
Мога ли казали малко повече?

479
00:33:57,000 --> 00:34:02,000
Трябва да се трансформира позиция в брой,

480
00:34:02,000 --> 00:34:05,000
така че трябва да се направи някаква връзка мисля, че е Чар, но тя не може да бъде.

481
00:34:05,000 --> 00:34:07,000
Да, това е добра отправна точка.

482
00:34:07,000 --> 00:34:12,000
Ние сме били прави много на този конвертиращия позиции в символа, тези символи,

483
00:34:12,000 --> 00:34:14,000
през първите две проблемни комплекти.

484
00:34:14,000 --> 00:34:18,000
Оказва се, че тук, това е почти подобен на

485
00:34:18,000 --> 00:34:24,000
достъп до ItH знак в низ, ако това има смисъл.

486
00:34:24,000 --> 00:34:30,000
Тук искаме за достъп до елемент на средата.

487
00:34:30,000 --> 00:34:34,000
Как да го направим?

488
00:34:34,000 --> 00:34:39,000
Кевин, имате ли някакви предложения как бихме могли да направим, че?

489
00:34:39,000 --> 00:34:44,000
Можете да направите купа сено, отворена скоба, по средата, затворена скоба.

490
00:34:44,000 --> 00:34:46,000
Можеш ли да напишеш, че за нас?

491
00:34:46,000 --> 00:34:51,000
Запишете го тук, и ние ще се дръпне, че до.

492
00:34:51,000 --> 00:34:56,000
Търсим по тази линия 9,

493
00:34:56,000 --> 00:34:59,000
и ние сме осъзнавайки, че ние не искаме да се сравни иглата на средата,

494
00:34:59,000 --> 00:35:03,000
но вместо това, ние искаме да се сравни иглата

495
00:35:03,000 --> 00:35:07,000
за елемент на позиция средата в рамките на нашата купа сено масив.

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

497
00:35:10,000 --> 00:35:12,000
Точно така.

498
00:35:12,000 --> 00:35:15,000
Да, това изглежда доста добре, ако (игла == купа сено средата).

499
00:35:15,000 --> 00:35:18,000
Ние го намерихме.

500
00:35:18,000 --> 00:35:22,000
Сега, ако бягаме код ние ще резервен малко

501
00:35:22,000 --> 00:35:26,000
съставя, той работи и сега, ако ние с нетърпение за 4

502
00:35:26,000 --> 00:35:30,000
ние не го намери, защото сега сме всъщност да е номер 23.

503
00:35:30,000 --> 00:35:33,000
Ние сме получаване на стойност 23, и това е, което ние сме в сравнение с нашата игла.

504
00:35:33,000 --> 00:35:35,000
Но това е добре. Това е стъпка в правилната посока.

505
00:35:35,000 --> 00:35:37,000
>> Това е, което ние се опитваме да направим.

506
00:35:37,000 --> 00:35:40,000
Ние не се опитваме да се сравни игла срещу позиции в масива

507
00:35:40,000 --> 00:35:44,000
, а по-скоро срещу действителните елементи в масива.

508
00:35:44,000 --> 00:35:49,000
Ако се върнем отново в следващата стъпка в нашия алгоритъм,

509
00:35:49,000 --> 00:35:51,000
каква е следващата стъпка?

510
00:35:51,000 --> 00:35:57,000
Лейла вече го споменах за кратко.

511
00:35:57,000 --> 00:36:00,000
[Student], за да видите, ако това е по-голямо или по-малко и тогава да реши по какъв начин да се движат.

512
00:36:00,000 --> 00:36:03,000
[Nate] Да, така че как ще правим това?

513
00:36:03,000 --> 00:36:07,000
Може ли да поставите в някои Ще спаси тази ревизия,

514
00:36:07,000 --> 00:36:13,000
и тогава, ако в някои линии, които ще направите това.

515
00:36:13,000 --> 00:36:15,000
Да, Шарлот. >> Аз имам един въпрос.

516
00:36:15,000 --> 00:36:19,000
Ако не е средата - 1, защото първото нещо, което е

517
00:36:19,000 --> 00:36:26,000
е 0 индексирани, така че ако сложим 4, това не е всъщност характер търсим?

518
00:36:26,000 --> 00:36:30,000
Да, и друг проблем с това е

519
00:36:30,000 --> 00:36:35,000
че е страхотен улов, защото какво ще се случва вероятно

520
00:36:35,000 --> 00:36:42,000
ако ние продължим да се движим и ние никога не коригира първоначално?

521
00:36:42,000 --> 00:36:46,000
Предполагам, че това, което може да свърши това се опитва да получи достъп

522
00:36:46,000 --> 00:36:49,000
елемента в 8-ма позиция на масива,

523
00:36:49,000 --> 00:36:53,000
което в този случай не съществува.

524
00:36:53,000 --> 00:36:56,000
Ние ще искате да направите някаква на отчитане на факта,

525
00:36:56,000 --> 00:36:59,000
че имаме някои нула индексиране.

526
00:36:59,000 --> 00:37:05,000
Шарлот За съжаление, имах предвид средната точка - 1 в квадратните скоби.

527
00:37:05,000 --> 00:37:08,000
Ние можем да направим това.

528
00:37:08,000 --> 00:37:10,000
Ще се върнем на този въпрос само за малко.

529
00:37:10,000 --> 00:37:13,000
След като започнете да стигнем до действителната примка,

530
00:37:13,000 --> 00:37:16,000
това е, когато ние наистина ще видите това влезе в игра.

531
00:37:16,000 --> 00:37:21,000
За момента можем да направим това, но вие сте напълно прав.

532
00:37:21,000 --> 00:37:28,000
Това нула индексирането ще имат ефект, който ние трябва да се отчита.

533
00:37:28,000 --> 00:37:30,000
Да видим.

534
00:37:30,000 --> 00:37:34,000
>> Как е по-голяма от по-малко от?

535
00:37:34,000 --> 00:37:36,000
[Student] се как да се направи по-голяма от и по-малко, отколкото част.

536
00:37:36,000 --> 00:37:41,000
Просто не бях сигурен какво да отпечатате, ако откриете, че тя е по-от купа сено средата или по-голяма от.

537
00:37:41,000 --> 00:37:43,000
Тук мога да спася това, което I've-

538
00:37:43,000 --> 00:37:47,000
[Nate] Да, ако освен това, което имаш, и ние ще го издърпайте нагоре.

539
00:37:47,000 --> 00:37:49,000
Точно така.

540
00:37:49,000 --> 00:37:51,000
Студентски] И аз въпросителни знаци за това, което аз не знаех.

541
00:37:51,000 --> 00:37:54,000
[Nate] Това изглежда страхотно.

542
00:37:54,000 --> 00:37:58,000
Тук имаме въпросителни знаци, защото ние все още не знаем

543
00:37:58,000 --> 00:38:06,000
какво ще да направи доста още.

544
00:38:06,000 --> 00:38:12,000
Какво бихме искали да направи Опа, ние имаме някои скоби фънки върху нас.

545
00:38:12,000 --> 00:38:15,000
Ние ще коригира тези скоби.

546
00:38:15,000 --> 00:38:19,000
Точно така.

547
00:38:19,000 --> 00:38:22,000
И така, какво искаме да направим, според нашия алгоритъм,

548
00:38:22,000 --> 00:38:27,000
ако ние не намерим иглата?

549
00:38:27,000 --> 00:38:32,000
Кажете в случай, че иглата е по-малко от това, което търсим в. Кевин.

550
00:38:32,000 --> 00:38:34,000
Само погледнете в лявата половина.

551
00:38:34,000 --> 00:38:40,000
Добре, така че ние ще сложи коментар тук, който казва: "погледнете в лявата половина."

552
00:38:40,000 --> 00:38:46,000
И ако иглата е по-голяма от купа сено в средата, какво искаме да направим?

553
00:38:46,000 --> 00:38:48,000
[Student] Тогава търсите в дясната половина.

554
00:38:48,000 --> 00:38:53,000
Погледнете в дясната половина ", в дясната половина."

555
00:38:53,000 --> 00:38:58,000
Не е твърде занемарено.

556
00:38:58,000 --> 00:39:05,000
Добре, така че в този момент, нещата са доста добре.

557
00:39:05,000 --> 00:39:13,000
Проблемът с кода, както е написано, е какво?

558
00:39:13,000 --> 00:39:15,000
Студентски] не са крайни точки за двете половини.

559
00:39:15,000 --> 00:39:18,000
Точно така, ние нямаме крайни точки за двете половини.

560
00:39:18,000 --> 00:39:20,000
Ние също така само ще да мине през този път.

561
00:39:20,000 --> 00:39:23,000
Ние само ще изглежда в един средата.

562
00:39:23,000 --> 00:39:27,000
Или елемент е там, или не е така.

563
00:39:27,000 --> 00:39:34,000
За да се завърши това, ние ще трябва да направите някакво повторение.

564
00:39:34,000 --> 00:39:39,000
Трябва да продължим да повтарят, докато не открием, че

565
00:39:39,000 --> 00:39:43,000
или елемент е там, защото сме свива и най-накрая го намерих,

566
00:39:43,000 --> 00:39:46,000
или не там, защото сме погледна през всички неща,

567
00:39:46,000 --> 00:39:52,000
в съответните половинки на масива и е установено, че нищо не е там.

568
00:39:52,000 --> 00:39:56,000
>> Когато имаме това повторение става, какво ще да се използва?

569
00:39:56,000 --> 00:39:58,000
Студентски] контур.

570
00:39:58,000 --> 00:40:00,000
Някакъв вид на линията. Да.

571
00:40:00,000 --> 00:40:03,000
[Student] Може ли да се направи направи линия, докато и да го направи това и след това, докато

572
00:40:03,000 --> 00:40:10,000
иглата не не е равно съм сигурен къде отивам с това.

573
00:40:10,000 --> 00:40:18,000
Но нещо като, че толкова дълго, тъй като не е равно на стойността, която приноса на потребителите.

574
00:40:18,000 --> 00:40:21,000
Да, така че нека видим, как това може да се пишат?

575
00:40:21,000 --> 00:40:23,000
Ти каза, че нека използваме направи линия, докато.

576
00:40:23,000 --> 00:40:26,000
Къде трябва да започнете?

577
00:40:26,000 --> 00:40:33,000
[Student] Веднага след размера / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Добре, и какво ще правим?

579
00:40:42,000 --> 00:40:44,000
Ние ще попълним, докато по-късно.

580
00:40:44,000 --> 00:40:46,000
Какво ще правим сега?

581
00:40:46,000 --> 00:40:49,000
[Student] Не искаме да направим всички неща, които имаме, ако част?

582
00:40:49,000 --> 00:40:52,000
[Nate] направи всички тези неща, чудесно.

583
00:40:52,000 --> 00:40:55,000
Копиране и поставяне.

584
00:40:55,000 --> 00:40:59,000
О, човече.

585
00:40:59,000 --> 00:41:03,000
Да видим дали това работи, ако можем раздела това отново.

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

587
00:41:08,000 --> 00:41:16,000
Добре, и освен това, така че вие ​​го.

588
00:41:16,000 --> 00:41:21,000
Добре, а ние ще направим това, докато-

589
00:41:21,000 --> 00:41:25,000
какво е състояние, докато сте били след?

590
00:41:25,000 --> 00:41:31,000
Студентски] Докато иглата не е равно, така че като удивителен знак.

591
00:41:31,000 --> 00:41:37,000
Но аз не съм сигурен точно какво е това все още.

592
00:41:37,000 --> 00:41:39,000
[Nate] Да, това е един от начините да го направя.

593
00:41:39,000 --> 00:41:41,000
Сам, имате ли коментар?

594
00:41:41,000 --> 00:41:43,000
[Сам си спомних, когато гледах клипове,

595
00:41:43,000 --> 00:41:48,000
Взех една снимка на един на подобно, когато направихме pseudocode за него,

596
00:41:48,000 --> 00:41:52,000
имаше някаква връзка между максимална и минимална.

597
00:41:52,000 --> 00:41:58,000
Мисля, че беше нещо подобно ако максимумът е все по-малко, отколкото мин.

598
00:41:58,000 --> 00:42:00,000
Ясно.

599
00:42:00,000 --> 00:42:04,000
[Сам или подобни, ако Макс не е по-малко от мин. или нещо подобно,

600
00:42:04,000 --> 00:42:06,000
защото това би означавало, че сте търсили всичко.

601
00:42:06,000 --> 00:42:13,000
>> Да, така че това, което се звучи като максимум и минимум, отнасящи се до?

602
00:42:13,000 --> 00:42:16,000
[Сам] Стойности, които числа, които ще се променят

603
00:42:16,000 --> 00:42:18,000
в сравнение с където поставяме на средата.

604
00:42:18,000 --> 00:42:20,000
Точно така.

605
00:42:20,000 --> 00:42:24,000
[Сам В този момент, тя ще [се чува изчисляване на макс и мин.

606
00:42:24,000 --> 00:42:29,000
Midpoint това е макс и идеята мин.

607
00:42:29,000 --> 00:42:35,000
Това прави ли смисъл хора?

608
00:42:35,000 --> 00:42:39,000
Ако бяхме да започнем да гледаме как ние ще направим тази итерация,

609
00:42:39,000 --> 00:42:43,000
сте напълно прав, че ние искаме да използваме някакъв направи линия, докато.

610
00:42:43,000 --> 00:42:49,000
Но предполагам, че ако си припомним какво се случва на мястото на този масив

611
00:42:49,000 --> 00:42:53,000
и какво всъщност се случва Тръгвам да пиша тук

612
00:42:53,000 --> 00:42:58,000
в първата итерация на двоично търсене, имаме

613
00:42:58,000 --> 00:43:05,000
Отивам да използвате Б и Д за да се обозначи началото.

614
00:43:05,000 --> 00:43:10,000
И след края на нашия масив.

615
00:43:10,000 --> 00:43:14,000
Ние знаем, че началото е в четири право тук,

616
00:43:14,000 --> 00:43:18,000
и ние знаем, че краят е 108.

617
00:43:18,000 --> 00:43:23,000
Кажем, че сме за номер 15.

618
00:43:23,000 --> 00:43:27,000
Първи път правим това, както видяхме по-рано,

619
00:43:27,000 --> 00:43:30,000
средата или ще бъде 16 или 23

620
00:43:30,000 --> 00:43:34,000
в зависимост от това как ще се изчисли нещата.

621
00:43:34,000 --> 00:43:37,000
Тъй като равномерно се раздели в средата ще ни даде това място

622
00:43:37,000 --> 00:43:42,000
между 16 и 23, ние не може равномерно, тя се разделя

623
00:43:42,000 --> 00:43:47,000
или да го разделите и получите в истински средата.

624
00:43:47,000 --> 00:43:49,000
Ние ще разгледаме 16.

625
00:43:49,000 --> 00:43:55,000
Ще осъзнаете, "Хей, 16> 15 търсим."

626
00:43:55,000 --> 00:43:59,000
За след това погледнете в лявата половина на масива

627
00:43:59,000 --> 00:44:03,000
какво ще свърши това е изхвърлянето

628
00:44:03,000 --> 00:44:07,000
тази цялата горна част

629
00:44:07,000 --> 00:44:16,000
и каза: "Добре, сега нашата крайна точка ще бъде тук."

630
00:44:16,000 --> 00:44:22,000
Следващата итерация на нашата линия, ние сме вече в този масив,

631
00:44:22,000 --> 00:44:25,000
ефективно изхвърли тази част, защото сега

632
00:44:25,000 --> 00:44:30,000
ако ние сме като средната точка да бъде разликата между началото и края,

633
00:44:30,000 --> 00:44:34,000
ние намираме нашата средата да бъде 8,

634
00:44:34,000 --> 00:44:40,000
тогава ще можем да тествате 8, за да видите къде е по отношение на броя търсим,

635
00:44:40,000 --> 00:44:44,000
15, ще разберете, че 15 е по-голяма,

636
00:44:44,000 --> 00:44:49,000
така че ние трябва да се премести в дясната част на списъка,

637
00:44:49,000 --> 00:44:51,000
което знаем, защото ние сме хора и можем да го видим.

638
00:44:51,000 --> 00:44:54,000
Ние знаем, че дясната част ще бъде, когато го намерим,

639
00:44:54,000 --> 00:45:01,000
но компютърът не знае това, така че това, което ние ще направим, е, че ние действително ще

640
00:45:01,000 --> 00:45:04,000
са това, и сега в началото и края

641
00:45:04,000 --> 00:45:11,000
са на същото място, така че средата става само номер в списъка, в този момент,

642
00:45:11,000 --> 00:45:16,000
което е с 15, а ние сме го намерили.

643
00:45:16,000 --> 00:45:21,000
Ли това, че хвърли малко повече светлина върху това, когато цялата тази макс и обозначения мин. ще

644
00:45:21,000 --> 00:45:24,000
следене на крайните точки на масива, за да разбера

645
00:45:24,000 --> 00:45:35,000
как да се стесни нещата?

646
00:45:35,000 --> 00:45:42,000
>> Какво би се случило, ако това не е равно на 15?

647
00:45:42,000 --> 00:45:52,000
Какво ще стане, ако търсим за 15, а вместо това, тази цифра също бяха 16?

648
00:45:52,000 --> 00:45:54,000
Бихме казали: "О, това е по-голяма.

649
00:45:54,000 --> 00:45:57,000
Ние искаме да се върнем в ляво ".

650
00:45:57,000 --> 00:46:01,000
И ние бихме се движи нашата надясно,

651
00:46:01,000 --> 00:46:06,000
в който момент имаме крайна точка, това би било противоречива.

652
00:46:06,000 --> 00:46:09,000
Тя не би могла да се търси повече елементи

653
00:46:09,000 --> 00:46:13,000
защото сега имаме нашата крайна точка и точка началото

654
00:46:13,000 --> 00:46:16,000
нашата макс и мин, сега се обърна.

655
00:46:16,000 --> 00:46:23,000
Ние търсим през целия масив. Не можем да намерим нищо.

656
00:46:23,000 --> 00:46:27,000
Това е точката, в която ние бихме искам да кажа: "Добре, отиваме да се спре този алгоритъм.

657
00:46:27,000 --> 00:46:34,000
Не намерихме нищо. Знаем, че не е тук. "

658
00:46:34,000 --> 00:46:36,000
Как ще?

659
00:46:36,000 --> 00:46:40,000
[Student] Как точно компютъра да превключите в края?

660
00:46:40,000 --> 00:46:45,000
Как края преди началото?

661
00:46:45,000 --> 00:46:48,000
Края завършва преди началото на

662
00:46:48,000 --> 00:46:54,000
поради по математика, че ние ще направим всеки път, когато правим това.

663
00:46:54,000 --> 00:47:00,000
Начинът, по който суап е, ако се вгледате в първи път правим това суап

664
00:47:00,000 --> 00:47:03,000
където имаме началото на 4 и в края

665
00:47:03,000 --> 00:47:13,000
по целия път надолу към 108 и средата, да речем, на 16 -

666
00:47:13,000 --> 00:47:20,000
Отивам да се върнете обратно към 15-ако ние не търсим за 15,

667
00:47:20,000 --> 00:47:25,000
ние знаехме, че това, което направихме, когато ние проверихме 16 и видях, че тя е по-голяма

668
00:47:25,000 --> 00:47:28,000
и искаше да изхвърли цялата дясна част на списъка,

669
00:47:28,000 --> 00:47:36,000
видяхме, че това, което искахме да направим е да преместите тази електронна тук.

670
00:47:36,000 --> 00:47:44,000
Ефективно, електронна започна да се преди средата.

671
00:47:44,000 --> 00:47:48,000
По същия начин, когато ние направихме тази итерация на алгоритъма

672
00:47:48,000 --> 00:47:51,000
и средната точка е на 8,

673
00:47:51,000 --> 00:47:55,000
ние открихме, че 8 <15, така че ние искахме да се движат б

674
00:47:55,000 --> 00:48:00,000
един миналото средата.

675
00:48:00,000 --> 00:48:07,000
Сега, в началото и края са и двете заедно в този 15.

676
00:48:07,000 --> 00:48:10,000
>> Ако бяхме се случва да се търси някаква друга стойност, а не 15,

677
00:48:10,000 --> 00:48:14,000
или, ако това 15 вместо 16,

678
00:48:14,000 --> 00:48:20,000
щяхме да установи, че д искаме да се движи един преди средата.

679
00:48:20,000 --> 00:48:33,000
Сега д ще бъде там обърна по-малко от б.

680
00:48:33,000 --> 00:48:39,000
Нека разгледаме как всъщност стигаме до кодиране този алгоритъм.

681
00:48:39,000 --> 00:48:44,000
Ние знаем, че искаме да имаме това изчисление средата.

682
00:48:44,000 --> 00:48:48,000
Знаем също, че искаме да следите в началото и края на масива

683
00:48:48,000 --> 00:48:51,000
на текущата масив, за да можем да разберем

684
00:48:51,000 --> 00:48:56,000
когато това лявата половина на списъка е и когато дясната половина на списъка.

685
00:48:56,000 --> 00:49:03,000
Ние правим това с начало и край,

686
00:49:03,000 --> 00:49:07,000
или можем да ги наречем мин. и макс.

687
00:49:07,000 --> 00:49:10,000
Ще започне и да завърши този път.

688
00:49:10,000 --> 00:49:15,000
Когато започнем, ако погледнем назад към нашия пример тук,

689
00:49:15,000 --> 00:49:20,000
нашата Началото бе поставено в самото начало на масива, като естествена.

690
00:49:20,000 --> 00:49:25,000
Какво индекс е това? Какво трябва да ни започне да се?

691
00:49:25,000 --> 00:49:27,000
Даниел.

692
00:49:27,000 --> 00:49:30,000
Даниел] Haystack [0].

693
00:49:30,000 --> 00:49:37,000
[Nate] Да, така бихме могли да го настроите равна на купа сено [0].

694
00:49:37,000 --> 00:49:40,000
Проблемът, обаче, е, че това дава не ни позицията на първия елемент.

695
00:49:40,000 --> 00:49:45,000
Това ни дава индекса на първия елемент или действителната стойност в тази първа позиция.

696
00:49:45,000 --> 00:49:47,000
[Student] Това ще се превърнат в 0.20?

697
00:49:47,000 --> 00:49:52,000
[Nate] Какво ще направите, е добре, че няма да направи никакво конвертиране.

698
00:49:52,000 --> 00:49:56,000
Това, което ще направим, е, че ще съхранява 4 започне,

699
00:49:56,000 --> 00:49:59,000
и след това ще бъде трудно да се правят сравнения срещу започне

700
00:49:59,000 --> 00:50:03,000
защото започваме ще се проведе на стойност от 4

701
00:50:03,000 --> 00:50:06,000
който е началото на нашата масив,

702
00:50:06,000 --> 00:50:08,000
но ние искаме да следите индексите в масива

703
00:50:08,000 --> 00:50:11,000
за разлика от стойностите.

704
00:50:11,000 --> 00:50:17,000
Ние всъщност ще се използва 0, нещо такова.

705
00:50:17,000 --> 00:50:20,000
За края на масива-Charlotte доведе до малко по-рано.

706
00:50:20,000 --> 00:50:23,000
Това е мястото, където ще се вземе предвид нула индексиране.

707
00:50:23,000 --> 00:50:25,000
>> Шарлот, какъв е края на масива?

708
00:50:25,000 --> 00:50:28,000
Какъв е индексът на края?

709
00:50:28,000 --> 00:50:30,000
Шарлот] Размер - 1.

710
00:50:30,000 --> 00:50:32,000
Да, и кой размер трябва да се използват?

711
00:50:32,000 --> 00:50:35,000
Трябва да използваме капитала размера или малки размери?

712
00:50:35,000 --> 00:50:37,000
Капитал размер.

713
00:50:37,000 --> 00:50:42,000
В този случай, можем да използваме размера на капитала.

714
00:50:42,000 --> 00:50:45,000
Ако искахме тази функция, за да бъдат преносими

715
00:50:45,000 --> 00:50:48,000
и използвате тази функция в други програми,

716
00:50:48,000 --> 00:50:50,000
ние всъщност може да използвате малки размер.

717
00:50:50,000 --> 00:50:52,000
Всичко е наред.

718
00:50:52,000 --> 00:51:01,000
Но Шарлот е напълно прав, че искаме да имаме размер - 1.

719
00:51:01,000 --> 00:51:03,000
В този момент-

720
00:51:03,000 --> 00:51:05,000
[Student] Как е, че можете да използвате главни размер?

721
00:51:05,000 --> 00:51:07,000
Как е, че бихме могли да използваме главна размер?

722
00:51:07,000 --> 00:51:13,000
Оказва се, че тези # определя наистина,

723
00:51:13,000 --> 00:51:19,000
под капака, текст, като намери и замени, ако това има смисъл.

724
00:51:19,000 --> 00:51:24,000
Когато вие компилирате кода си, предварителна обработка фаза

725
00:51:24,000 --> 00:51:27,000
на компилатора отива във файла,

726
00:51:27,000 --> 00:51:31,000
и да го търси навсякъде, където сте написали капитал размер,

727
00:51:31,000 --> 00:51:39,000
и го заменя този текст буквално с 8, просто ей така.

728
00:51:39,000 --> 00:51:42,000
В този смисъл, това е много по-различен от променлива.

729
00:51:42,000 --> 00:51:45,000
Не заемат място в паметта.

730
00:51:45,000 --> 00:51:52,000
Това е един прост трик за подмяна на текст.

731
00:51:52,000 --> 00:51:57,000
В този случай, ние ще използваме размер.

732
00:51:57,000 --> 00:52:01,000
От тук искам да правя някакво повторение,

733
00:52:01,000 --> 00:52:03,000
и ние сме на прав път с нашата направи линия, докато

734
00:52:03,000 --> 00:52:08,000
Искаме да направим нещо, докато състояние не притежава повече,

735
00:52:08,000 --> 00:52:12,000
и както видяхме по-рано, видяхме, че това условие

736
00:52:12,000 --> 00:52:19,000
наистина е, че ние не искаме в края

737
00:52:19,000 --> 00:52:24,000
да бъде по-малко от началото.

738
00:52:24,000 --> 00:52:26,000
>> Това е ни спиране състояние.

739
00:52:26,000 --> 00:52:35,000
Ако това се случи, ние искаме да се спре и да се декларира като: "Хей, не сме намерили нищо."

740
00:52:35,000 --> 00:52:43,000
За да изрази това, ние искаме да използва някакъв вид на линия.

741
00:52:43,000 --> 00:52:49,000
В този случай, ще го направи линия, докато, цикъл, цикъл, докато?

742
00:52:49,000 --> 00:52:51,000
Имаме направи линия, докато тук.

743
00:52:51,000 --> 00:52:53,000
Мислите ли, хора като този подход?

744
00:52:53,000 --> 00:52:59,000
Мислите ли, че трябва да се опитаме различен подход?

745
00:52:59,000 --> 00:53:01,000
Кевин, някакви мисли?

746
00:53:01,000 --> 00:53:06,000
Бихме могли да имат цикъл, докато, защото знаем, максимум

747
00:53:06,000 --> 00:53:11,000
ще бъде по-голяма от мин. В началото все пак.

748
00:53:11,000 --> 00:53:14,000
Да, така че не е инициализация, че трябва да се случи.

749
00:53:14,000 --> 00:53:17,000
Тези направи докато вериги са страхотни, когато трябва да се инициализира нещо

750
00:53:17,000 --> 00:53:21,000
преди това тестване, докато тук

751
00:53:21,000 --> 00:53:26,000
ние знаем, че ние няма да запази reinitializing както започват и завършват

752
00:53:26,000 --> 00:53:28,000
всеки кръг от веригата.

753
00:53:28,000 --> 00:53:32,000
Ние знаем, че искаме да ги инициализира, тогава вижте нашето състояние.

754
00:53:32,000 --> 00:53:38,000
В този случай, аз ще отида с един прост цикъл, докато.

755
00:53:38,000 --> 00:53:44,000
Оказва се, че направи, докато се използват затворени контури доста рядко.

756
00:53:44,000 --> 00:53:49,000
На много места, дори не се научи да докато цикли.

757
00:53:49,000 --> 00:53:53,000
Те са добри за работа с приноса на потребителите, така че съм виждал много от тях до този момент.

758
00:53:53,000 --> 00:53:59,000
Но нормално и вериги са много по-често.

759
00:53:59,000 --> 00:54:03,000
Оказва се, че това състояние, както е записано

760
00:54:03,000 --> 00:54:09,000
не наистина ще ни направи много добре, и защо е така?

761
00:54:09,000 --> 00:54:11,000
Съжалявам, аз не знам името ти.

762
00:54:11,000 --> 00:54:13,000
Аз съм Джери. >> Съжаляваме?

763
00:54:13,000 --> 00:54:15,000
Това е B-O-R-U-I.

764
00:54:15,000 --> 00:54:18,000
О, добре.

765
00:54:18,000 --> 00:54:23,000
Не виждаш ли в моя списък.

766
00:54:23,000 --> 00:54:26,000
О, това е, защото-о, това има смисъл.

767
00:54:26,000 --> 00:54:31,000
Имате ли представа защо този цикъл, докато не може да работи, както е предвидено,

768
00:54:31,000 --> 00:54:38,000
както е написано с условието?

769
00:54:38,000 --> 00:54:43,000
[Джери] Искаш да кажеш, че искаш всички неща, след това в най-?

770
00:54:43,000 --> 00:54:46,000
Да, така че това е един.

771
00:54:46,000 --> 00:54:49,000
Може би трябва да постави всички тези неща в линия, докато, което е напълно вярно.

772
00:54:49,000 --> 00:54:55,000
Другото нещо, което е малко по-проблематично, обаче, е, че това условие не работи.

773
00:54:55,000 --> 00:54:57,000
[Student] Трябва да го обърнете.

774
00:54:57,000 --> 00:55:04,000
Надясно, така че това условие не никога няма да бъде вярно първоначално начина, по който ние говорихме за това.

775
00:55:04,000 --> 00:55:08,000
Искаме да направим нещо до края на <започне,

776
00:55:08,000 --> 00:55:13,000
но искаме да направим нещо, докато

777
00:55:13,000 --> 00:55:21,000
да започне ≤ края.

778
00:55:21,000 --> 00:55:24,000
>> Е, че обратното на логиката.

779
00:55:24,000 --> 00:55:27,000
Аз съм виновен за извършването на тези грешки през цялото време.

780
00:55:27,000 --> 00:55:31,000
Студентски Защо това трябва да бъде по-малка или равна на?

781
00:55:31,000 --> 00:55:33,000
Защото помните ли случай, че ние трябва да се

782
00:55:33,000 --> 00:55:36,000
където имаше само един елемент, и ние бяхме,

783
00:55:36,000 --> 00:55:43,000
и ние търсехме точно в 15 в нашия масив?

784
00:55:43,000 --> 00:55:47,000
И нашият началото и краят ни бяха на един и същ елемент.

785
00:55:47,000 --> 00:55:50,000
Ние искаме да сме сигурни, че ние се справят с този случай.

786
00:55:50,000 --> 00:55:54,000
Ако ние направихме направо по-малко от

787
00:55:54,000 --> 00:55:58,000
ние само ще бъде в състояние да стигнете до 2-елемент на масива.

788
00:55:58,000 --> 00:56:06,000
След като слезе на последния елемент, ако това беше нашата елемент, ние никога няма да го намерите.

789
00:56:06,000 --> 00:56:10,000
Сега тук, можем да направим точно като теб казваха.

790
00:56:10,000 --> 00:56:15,000
Можем да започнем цопване неща точно в средата на нашата линия, докато.

791
00:56:15,000 --> 00:56:20,000
Ние можем да цоп в нашия средата.

792
00:56:20,000 --> 00:56:24,000
Ние можем да вземем всички от тях, ако отчети,

793
00:56:24,000 --> 00:56:30,000
да ги измъкне от това направи линия, докато,

794
00:56:30,000 --> 00:56:34,000
цоп в тях

795
00:56:34,000 --> 00:56:39,000
почистване нещата малко,

796
00:56:39,000 --> 00:56:48,000
а аз ще отида напред и спести тази ревизия.

797
00:56:48,000 --> 00:56:53,000
И в този момент, ние сме доста близо.

798
00:56:53,000 --> 00:56:55,000
Сам.

799
00:56:55,000 --> 00:56:58,000
Аз мисля, че също трябва да имат INT средата = размер - 1/2.

800
00:56:58,000 --> 00:57:01,000
Взех го, размер - 1/2.

801
00:57:01,000 --> 00:57:05,000
Има ли нещо друго, което трябва да се промени за тази реплика?

802
00:57:05,000 --> 00:57:10,000
Това беше добър улов.

803
00:57:10,000 --> 00:57:14,000
>> Какво означава размер направя? Ние непрекъснато променящите се размер?

804
00:57:14,000 --> 00:57:17,000
За да се запази линията по този начин, ние трябва да промените размера.

805
00:57:17,000 --> 00:57:21,000
Ние трябва да промените размера всеки път, когато обикалят за цикъл.

806
00:57:21,000 --> 00:57:25,000
Но не забравяйте, когато бяхме става чрез нашия пример само малко по-рано,

807
00:57:25,000 --> 00:57:30,000
и имахме началото на 4

808
00:57:30,000 --> 00:57:33,000
и края начина, по който в продължение на 108?

809
00:57:33,000 --> 00:57:35,000
Как да се изчисли средната точка?

810
00:57:35,000 --> 00:57:38,000
Ние използваме размер?

811
00:57:38,000 --> 00:57:40,000
Или сме използвали започне и да свърши вместо?

812
00:57:40,000 --> 00:57:42,000
Това е разликата между края и началото.

813
00:57:42,000 --> 00:57:50,000
Точно така, и как точно трябва да пиша, че Шарлот?

814
00:57:50,000 --> 00:57:52,000
Само крайните започне.

815
00:57:52,000 --> 00:57:55,000
Може би не трябва да направите - 1

816
00:57:55,000 --> 00:57:58,000
защото 1 е включен в края и началото вече.

817
00:57:58,000 --> 00:58:00,000
[Nate] Great, вие сте напълно прав.

818
00:58:00,000 --> 00:58:03,000
Ние не трябва да направите - 1, защото това един е включен

819
00:58:03,000 --> 00:58:08,000
и да се отчита, когато се инициализира променлива края.

820
00:58:08,000 --> 00:58:11,000
>> Има ли нещо друго, което трябва да направите, синтактично да има тази линия да има смисъл?

821
00:58:11,000 --> 00:58:13,000
[Студентски] Plus започне. >> Plus започнем?

822
00:58:13,000 --> 00:58:15,000
[Student] В края.

823
00:58:15,000 --> 00:58:20,000
Тъй като се изчислява само на половината от дължината.

824
00:58:20,000 --> 00:58:26,000
Вие трябва да добавите началото.

825
00:58:26,000 --> 00:58:31,000
[Nate] Какво ще се изчисли за нас?

826
00:58:31,000 --> 00:58:35,000
Ако мислим за края на тази първа итерация на цикъла,

827
00:58:35,000 --> 00:58:40,000
края ще бъде в състояние индекс 7.

828
00:58:40,000 --> 00:58:43,000
Започнете да е в позиция 0.

829
00:58:43,000 --> 00:58:47,000
Не забравяйте, че ние не търсим или

830
00:58:47,000 --> 00:58:52,000
позиция 3 или позиция 4.

831
00:58:52,000 --> 00:58:56,000
Ако погледнем на този по математика, просто за да бъде малко по-осезаема,

832
00:58:56,000 --> 00:59:02,000
постави някои цифри тук имаме 7, 0,

833
00:59:02,000 --> 00:59:10,000
така 7 - 0, и след това / 2

834
00:59:10,000 --> 00:59:19,000
е 3 целочислено деление.

835
00:59:19,000 --> 00:59:26,000
Тогава ще се наложи след това да добавите обратно започне?

836
00:59:26,000 --> 00:59:28,000
Ние не правим в този случай.

837
00:59:28,000 --> 00:59:31,000
На първата итерация, ще бъде добре, защото започнете е 0.

838
00:59:31,000 --> 00:59:36,000
Но докато напредваме, ние правим наистина всичко, просто трябва

839
00:59:36,000 --> 00:59:42,000
края Начало / 2.

840
00:59:42,000 --> 00:59:46,000
Има един друг трик тук, и това е именно една от предимство.

841
00:59:46,000 --> 00:59:49,000
[Student] Имаме ли нужда от скоби?

842
00:59:49,000 --> 00:59:53,000
[Nate] Точно така, и това е така, защото ако ние не използваме тези скоби,

843
00:59:53,000 --> 00:59:58,000
тогава тази линия ще се тълкува вместо

844
00:59:58,000 --> 01:00:09,000
(край) - (начало / 2), която определено не искам.

845
01:00:09,000 --> 01:00:11,000
Внимавай за тези правила за предимство.

846
01:00:11,000 --> 01:00:15,000
[Student] Защо не е края + започнем?

847
01:00:15,000 --> 01:00:17,000
Защо не е края + започнем?

848
01:00:17,000 --> 01:00:19,000
[Student] Защо да не е?

849
01:00:19,000 --> 01:00:24,000
Защо да е +?

850
01:00:24,000 --> 01:00:26,000
Мисля, че си прав.

851
01:00:26,000 --> 01:00:28,000
[Student] Защото това е средно?

852
01:00:28,000 --> 01:00:31,000
[Nate] End + започне, вие сте напълно прав.

853
01:00:31,000 --> 01:00:34,000
Уау, аз напълно goofed. Прав си.

854
01:00:34,000 --> 01:00:39,000
Ако правим минус, ние ще искате да добавите започне отново.

855
01:00:39,000 --> 01:00:43,000
В този случай, вие сте много прав, че ние искаме да се средната стойност на двете,

856
01:00:43,000 --> 01:00:45,000
така че ние искаме да ги добавите, за разлика от тях се изважда.

857
01:00:45,000 --> 01:00:49,000
[Student] Тя също така ще работи, ако свърши - започва / 2 + започне.

858
01:00:49,000 --> 01:00:55,000
Би било, ако правим така мисля.

859
01:00:55,000 --> 01:01:00,000
>> Например, ако търсим най започне,

860
01:01:00,000 --> 01:01:04,000
и ние го премести тук

861
01:01:04,000 --> 01:01:08,000
до 15.

862
01:01:08,000 --> 01:01:12,000
Сега започнете е на позиция 2.

863
01:01:12,000 --> 01:01:15,000
Енд е на позиция 7.

864
01:01:15,000 --> 01:01:21,000
Ако успеем да ги изваждате, ще получите 5.

865
01:01:21,000 --> 01:01:24,000
Разделете на две, ще получите 2.

866
01:01:24,000 --> 01:01:27,000
И след това се прибавят 2 обратно,

867
01:01:27,000 --> 01:01:30,000
и това ни получава на 4-то място,

868
01:01:30,000 --> 01:01:33,000
което е точно тук, което е средата.

869
01:01:33,000 --> 01:01:36,000
[Student] Трябва ли да се грижи за опаковане?

870
01:01:36,000 --> 01:01:39,000
В какъв смисъл трябва да се грижи за опаковане?

871
01:01:39,000 --> 01:01:43,000
Ако сумата или разликата между

872
01:01:43,000 --> 01:01:45,000
в зависимост от това как го правим не е четно число.

873
01:01:45,000 --> 01:01:49,000
След това компютърът се обърква дали, когато е 2,5;

874
01:01:49,000 --> 01:01:52,000
да се движите на ляво или на правото да се определи коя е средата?

875
01:01:52,000 --> 01:01:54,000
Ясно.

876
01:01:54,000 --> 01:01:56,000
Оказва се, че с целочислено деление,

877
01:01:56,000 --> 01:01:59,000
ние никога не получите тези числа с плаваща запетая.

878
01:01:59,000 --> 01:02:01,000
Ние никога няма да получите знак след десетичната запетая.

879
01:02:01,000 --> 01:02:04,000
Напълно изхвърли.

880
01:02:04,000 --> 01:02:08,000
Ако имате компютър разделя две INT променливи,

881
01:02:08,000 --> 01:02:11,000
и един е 7, а другата е 2,

882
01:02:11,000 --> 01:02:13,000
вие няма да получите 3.5 като резултат.

883
01:02:13,000 --> 01:02:16,000
Тя ще получат 3.

884
01:02:16,000 --> 01:02:19,000
Останалата част ще бъде изхвърлен, така че е ефективно закръгляне

885
01:02:19,000 --> 01:02:24,000
не е кръгла, а по-скоро етаж, ако вие сте запознати с тази по математика,

886
01:02:24,000 --> 01:02:27,000
, където можете напълно да изхвърли знак след десетичната запетая,

887
01:02:27,000 --> 01:02:31,000
и така сте по същество тя съкращаване до най-близкото

888
01:02:31,000 --> 01:02:33,000
цялата позиция, до най-близкото цяло число.

889
01:02:33,000 --> 01:02:38,000
[Student Но след това, че е проблематично, защото, ако имате масив от 7 елемента

890
01:02:38,000 --> 01:02:43,000
това автоматично прави 3-ти елемент на средата вместо на 4-ти.

891
01:02:43,000 --> 01:02:46,000
Как да се справим с това?

892
01:02:46,000 --> 01:02:49,000
Това е проблематично, тъй като, ако имахме масив от 7

893
01:02:49,000 --> 01:02:54,000
, че ще вземете 3-та вместо на 4-та.

894
01:02:54,000 --> 01:02:56,000
Бихте ли обяснили малко повече?

895
01:02:56,000 --> 01:02:59,000
[Студентски] Защото, ако има седем елементи и след това на 4-ти елемент

896
01:02:59,000 --> 01:03:04,000
ще бъде средата, нали?

897
01:03:04,000 --> 01:03:07,000
Спомни си коментар за е нулева индексира.

898
01:03:07,000 --> 01:03:10,000
[Студентски Да, така в позиция 3. Това би било средата.

899
01:03:10,000 --> 01:03:12,000
Да.

900
01:03:12,000 --> 01:03:16,000
О, добре. Виждам, какво искаш да кажеш.

901
01:03:16,000 --> 01:03:19,000
Това е доста странно, тъй като ние свикне с това цялата идея за

902
01:03:19,000 --> 01:03:22,000
да се отървете от знака след десетичната запетая.

903
01:03:22,000 --> 01:03:26,000
Това е страхотна точка.

904
01:03:26,000 --> 01:03:30,000
Да приключваме нещата.

905
01:03:30,000 --> 01:03:32,000
Изчислили сме, средата ни.

906
01:03:32,000 --> 01:03:37,000
>> В момента тестваме за да видите дали нашата иглата е равна на средната стойност.

907
01:03:37,000 --> 01:03:41,000
Ние сме печат, че ние го намерихме, но наистина, какво искаме да направим в тази ситуация?

908
01:03:41,000 --> 01:03:46,000
Сме го намерили, така че ние искаме да позволи на повикващия знаят, че ние го намерихме.

909
01:03:46,000 --> 01:03:49,000
Имаме функция, която е булев въвели функция.

910
01:03:49,000 --> 01:03:54,000
Начинът, по който сигнализира на обаждащия се на нашата функция, че ние сме готови да отидете

911
01:03:54,000 --> 01:03:58,000
ние казваме: "Хей, това е вярно."

912
01:03:58,000 --> 01:04:00,000
Как ще го направим, Кевин?

913
01:04:00,000 --> 01:04:02,000
Вие кимна главата си. >> Кевин] Добави връщане вярно.

914
01:04:02,000 --> 01:04:06,000
[Nate] Точно така, върнете вярно.

915
01:04:06,000 --> 01:04:12,000
Сега, ако това не е равен, как ще търсим в лявата половина?

916
01:04:12,000 --> 01:04:16,000
Някакви идеи?

917
01:04:16,000 --> 01:04:18,000
Стела, някакви идеи?

918
01:04:18,000 --> 01:04:21,000
Трябва да се създаде нова позиция за края.

919
01:04:21,000 --> 01:04:23,000
Да.

920
01:04:23,000 --> 01:04:29,000
Така че ние трябва да направим позицията на средата - края.

921
01:04:29,000 --> 01:04:33,000
Велики.

922
01:04:33,000 --> 01:04:36,000
Трябва да зададете нова позиция за края

923
01:04:36,000 --> 01:04:38,000
да погледнете в лявата половина.

924
01:04:38,000 --> 01:04:41,000
Това е това, което говорихме преди, когато

925
01:04:41,000 --> 01:04:44,000
Продължавам да се връщам на този пример.

926
01:04:44,000 --> 01:04:50,000
Имам започват от тук, а след това имам до края целия път тук.

927
01:04:50,000 --> 01:04:53,000
>> Отново, ако търсим 15 и средата ни е на 16,

928
01:04:53,000 --> 01:04:56,000
и ние осъзнаваме, "Oops, 16 е по-голяма.

929
01:04:56,000 --> 01:04:59,000
Искаме да се премести в лявата половина. "

930
01:04:59,000 --> 01:05:02,000
Ние тогава ще се движат в края на 15,

931
01:05:02,000 --> 01:05:06,000
и ние го правим от един от средата

932
01:05:06,000 --> 01:05:09,000
и настройка, че като нова нашия край.

933
01:05:09,000 --> 01:05:12,000
По същия начин, ако искаме да изглеждаме в дясната половина, как ще правим това?

934
01:05:12,000 --> 01:05:14,000
Имате ли някаква идея?

935
01:05:14,000 --> 01:05:22,000
[Student] Трябва само да зададете започне до средата + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Велики.

937
01:05:24,000 --> 01:05:29,000
И сега, в случай, че не намери нищо,

938
01:05:29,000 --> 01:05:32,000
това да се грижи за нас?

939
01:05:32,000 --> 01:05:36,000
Даниел, не че да се грижи за нас?

940
01:05:36,000 --> 01:05:38,000
Даниел] Не

941
01:05:38,000 --> 01:05:40,000
[Nate] Ако го направят чрез целия масив и ние не откриваме нищо,

942
01:05:40,000 --> 01:05:42,000
къде ще се вземат грижи, или трябва да се грижи за него?

943
01:05:42,000 --> 01:05:44,000
Даниел] а състояние.

944
01:05:44,000 --> 01:05:48,000
[Nate] Да, а състояние, точно така.

945
01:05:48,000 --> 01:05:51,000
Тя ще се грижи през целия масив, ако ние не откриваме нищо.

946
01:05:51,000 --> 01:05:53,000
Този цикъл, докато ще приключи.

947
01:05:53,000 --> 01:05:56,000
Ние никога няма да са се натъкнали на това условие,

948
01:05:56,000 --> 01:06:03,000
и можем да се върнем фалшива.

949
01:06:03,000 --> 01:06:10,000
Можем също така да оставите това, ако тук по този начин

950
01:06:10,000 --> 01:06:14,000
защото ако това, ако твърдение е вярно,

951
01:06:14,000 --> 01:06:16,000
а функцията ще се върне

952
01:06:16,000 --> 01:06:21,000
и така ние ще същество прекратите тази функция в този момент

953
01:06:21,000 --> 01:06:24,000
когато се върнем вярно.

954
01:06:24,000 --> 01:06:28,000
Но какво се случва с тази структура?

955
01:06:28,000 --> 01:06:34,000
Това ще работи изцяло, или има някаква логическа недостатък там?

956
01:06:34,000 --> 01:06:37,000
>> Има някои логически недостатък там, с начина, по който тя е създадена.

957
01:06:37,000 --> 01:06:40,000
Какво би могло да бъде?

958
01:06:40,000 --> 01:06:43,000
[Student] Защо ви е необходимо - и + 1s?

959
01:06:43,000 --> 01:06:47,000
Това определя нашата масив да бъде нашият нов лявата половина и дясната половина.

960
01:06:47,000 --> 01:06:51,000
[Student] Но защо не можа да го направиш без - 1s и + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Бихме могли да я определя като равна на средната точка?

962
01:06:53,000 --> 01:07:04,000
Какво може да бъде проблематично за това?

963
01:07:04,000 --> 01:07:08,000
[Студентски] Предполагам, че е неефективен, защото сте проверка стойност, която вече е била проверена.

964
01:07:08,000 --> 01:07:11,000
[Nate] Точно така, така че Сам е напълно прав.

965
01:07:11,000 --> 01:07:15,000
Ако зададете края и започват равна на средната точка

966
01:07:15,000 --> 01:07:18,000
вместо на 1 и + 1 замислено,

967
01:07:18,000 --> 01:07:22,000
в някакъв момент в бъдеще ще се окажете отново проверка на средата.

968
01:07:22,000 --> 01:07:26,000
[Student започнах pset, а след това имах нещо подобно

969
01:07:26,000 --> 01:07:30,000
Забравих + 1, и се заби в безкраен цикъл.

970
01:07:30,000 --> 01:07:34,000
Точно така, защото в един момент никога не започваш да се започне и да свърши

971
01:07:34,000 --> 01:07:39,000
действително да се припокриват.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Има един по-логично недостатък и това е, че това определено трябва да бъде

974
01:07:44,000 --> 01:07:48,000
на друго, ако.

975
01:07:48,000 --> 01:07:55,000
Каква може да е причината за това?

976
01:07:55,000 --> 01:07:59,000
>> Причината е, ако това не е друго, ако видя, Кевин?

977
01:07:59,000 --> 01:08:02,000
[Кевин Да, защото си променя крайната точка.

978
01:08:02,000 --> 01:08:05,000
[Nate] Точно така.

979
01:08:05,000 --> 01:08:07,000
Ние сме променят крайната точка,

980
01:08:07,000 --> 01:08:12,000
и ако е написана така Ще пространства между-

981
01:08:12,000 --> 01:08:14,000
той ще провери този случай.

982
01:08:14,000 --> 01:08:18,000
Този случай, ако успее, ще се откажем от функцията.

983
01:08:18,000 --> 01:08:21,000
След това ще провери следващия случай,

984
01:08:21,000 --> 01:08:24,000
и ако това успее, тя ще коригира крайната точка,

985
01:08:24,000 --> 01:08:28,000
и след това ще продължи и проверете този случай.

986
01:08:28,000 --> 01:08:31,000
Но в този момент, ние не искате да продължите проверката.

987
01:08:31,000 --> 01:08:35,000
За щастие, ние не сме нулиране на средата,

988
01:08:35,000 --> 01:08:39,000
и ние знаем, че този случай няма да успее.

989
01:08:39,000 --> 01:08:44,000
Но ние определено искаме да се постави друг, ако там

990
01:08:44,000 --> 01:08:48,000
въпреки че мощ в този случай

991
01:08:48,000 --> 01:08:52,000
тъй като ние не сме за адаптиране на средата, че ще направи разликата?

992
01:08:52,000 --> 01:08:54,000
Не, защото тези случаи са изключителни.

993
01:08:54,000 --> 01:08:58,000
Отново ми е зле.

994
01:08:58,000 --> 01:09:01,000
Не, мисля, че се нуждаят от този друг, ако.

995
01:09:01,000 --> 01:09:05,000
Ние можем да го пробвам и да го стартирате и да видим какво ще се случи.

996
01:09:05,000 --> 01:09:08,000
Сграда, но е станала грешка.

997
01:09:08,000 --> 01:09:12,000
Това е може би, защото съм оставил тези б и д тук.

998
01:09:12,000 --> 01:09:14,000
Трябва ли повече от тези на на върха?

999
01:09:14,000 --> 01:09:16,000
Това не изглежда като него.

1000
01:09:16,000 --> 01:09:20,000
Отдалечаване, изграждане,

1001
01:09:20,000 --> 01:09:24,000
там тя отива, така че сега, ако търсим за 15,

1002
01:09:24,000 --> 01:09:28,000
Да.

1003
01:09:28,000 --> 01:09:30,000
Нека я увеличите инча

1004
01:09:30,000 --> 01:09:33,000
15, да. Ние можем да се кандидатира отново.

1005
01:09:33,000 --> 01:09:36,000
Качване на изходния код, изграждане, работи.

1006
01:09:36,000 --> 01:09:41,000
Можем да търсим нещо като 13,

1007
01:09:41,000 --> 01:09:45,000
и ние не получите нищо печат, така че не е намирането на това за нас.

1008
01:09:45,000 --> 01:09:51,000
Това е страхотно, защото това не е в нашия списък.

1009
01:09:51,000 --> 01:09:53,000
>> Ние сме сега от време.

1010
01:09:53,000 --> 01:09:55,000
Това ще бъде за тази седмица.

1011
01:09:55,000 --> 01:10:00,000
Благодаря за присъединяване, и ще се видим по-късно.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]