1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Часть 3] [менее комфортно]

2
00:00:03,000 --> 00:00:05,000
>> [Nate Хардисон] [Harvard University]

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
# Определяем позволяет давать имена этих цифр в вашей программе.

36
00:02:24,000 --> 00:02:28,000
В этом случае максимальная высота пирамиды в Mario

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 и K

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
У нас есть один для центов за доллар, по одной для помещений, десять центов, никель и копейки,

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
то по десять центов, то никель, то копейки,

128
00:09:19,000 --> 00:09:24,000
и добавив к числу монет каждый раз.

129
00:09:24,000 --> 00:09:31,000
>> Другое решение, что мы будем видеть, как я масштаб и перейти к пересмотру 4,

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
[Студент] Есть ли у нас на комментарий поиск?

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
[Студент] Но если вы сомневаетесь, идти тяжелее?

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
>> На данный момент, давайте начнем работать над проблемой Set 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
и бинарный поиск делит список на 2 группы,

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
Двоичные намного быстрее, так что если вы удвоить размер проблемы

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
Линейный поиск очень проверки одного элемента за один раз,

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
и это не только в два раза быстрее или 3 раза быстрее, или в 4 раза быстрее.

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, 12323,

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 с 10000 строк, 20.000 строк.

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
У нас есть псевдокод здесь.

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
Номер >> Что он говорит?

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
потому что она имеет возвращаемого типа BOOL.

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
Это не возвращается ничего типа BOOL.

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
Ложь? Давайте попробуем.

291
00:21:30,000 --> 00:21:32,000
Почему бы вам сказать возвращение ложным? Это отличная интуиция.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] я не знаю.

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
Мы говорили о алгоритм в псевдокоде немного назад.

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
[Студент] 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
Струнный массивы, массивы символов.

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
[Студент] 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
[Студент] 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
[Студент] Есть эквивалентно одному для конечной точки, как Int L или что-то?

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
[Студент] Вы можете добавить \ 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
и разделите его на 2, и что даст нам точку.

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
[Студент неразборчиво]

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
[Лейла] Так же размера / 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
Там мы идем. Awesome.

407
00:29:28,000 --> 00:29:30,000
>> Как, будет ли это скомпилировать?

408
00:29:30,000 --> 00:29:32,000
[Лейла] Нет, она должна быть выше.

409
00:29:32,000 --> 00:29:34,000
[Nate] Да, так что же нам нужно сделать?

410
00:29:34,000 --> 00:29:36,000
[Лейла] Как Int середине или что-то.

411
00:29:36,000 --> 00:29:41,000
Awesome. Да, давайте сделаем это, внутр середину = размер.

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
[Студент] Printf ли вы его нашли.

444
00:31:42,000 --> 00:31:51,000
[Nate] Е ("Мы обнаружили, что \ п");

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
если мы посмотрим на этот массив сюда, которое имеет 8 элементов в нем,

458
00:32:35,000 --> 00:32:39,000
, что является значением середины собирается быть в этой функции?

459
00:32:39,000 --> 00:32:41,000
[Студент] 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
Мы нашли его, но мы не получить эту Printf да.

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
[Студент] Мы хотели бы ввести символ или что-то?

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
доступ к го символа в строке, если это имеет смысл.

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
[Студент] Проверьте, если оно больше или меньше, а затем решить, в какую сторону двигаться.

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
[Charlotte] Извините, я имел в виду середина - 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
[Студент] я получаю, как сделать больше и меньше, чем часть.

536
00:37:36,000 --> 00:37:41,000
Я просто не был уверен, что печатать, если вы обнаружите, что это меньше, чем стоге сена середине или больше.

537
00:37:41,000 --> 00:37:43,000
Здесь я могу спасти то, что ДИСК-

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
[Студент] Тогда вы посмотрите на правую половину.

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
[Студент] Можем ли мы делать-пока петля и он это сделать и то при

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
Вы сказали, что давайте использовать DO-цикла.

576
00:40:23,000 --> 00:40:26,000
Где сделать старт?

577
00:40:26,000 --> 00:40:33,000
[Студент] Сразу после размера / 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
[Студент] Не мы хотим сделать все то, что мы имеем в случае часть?

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
Красивая.

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
Я взял скриншот одного из подобных, когда мы делали псевдокод для него,

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
Середина это максимальный и минимальный идея.

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
Мы знаем, что начало на 4 прямо здесь,

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
[Студент] Как именно компьютер переключения конца?

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
[Студент], который будет конвертировать в 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
На конец массива Шарлотта принесла этом чуть раньше.

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
[Charlotte] Размер - 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
[Студент] Как получилось, что вы можете использовать заглавные размер?

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
и мы на правильном пути с нашим DO-цикла.

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
Мы знаем, что мы не собираемся держать повторной инициализации как начинать и заканчивать

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
Это Б-О-Р-У-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
[Jerry] Вы имеете в виду, как вы хотите, чтобы все вещи после того, как в-?

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
[Студент] Вам нужно перевернуть его.

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
Мы можем начать plopping вещи прямо в середину нашего цикла.

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] Отлично, вы совершенно правы.

818
00:58:00,000 --> 00:58:03,000
Мы не должны делать - 1, потому что это - 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
[Студент] в конце.

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
[Студент] Нужно ли нам скобки?

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
[Студент] Почему она не закончится + начать?

847
01:00:15,000 --> 01:00:17,000
Почему она не закончится + начать?

848
01:00:17,000 --> 01:00:19,000
[Студент] Почему это не так?

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
[Студент] Потому что это средняя?

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
[Студент] Он также будет работать, если вы сделали конца - начинать / 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, получаем 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
[Студент] Нужно ли нам, чтобы заботиться о обертывания?

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
[Студент] Но тогда это проблематично, потому что если у вас есть массив из 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
[Студент] Потому что, если у вас есть 7 элементов, то 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
[Студент] Вы только что установили начинают мидпойнте + 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
[Студент] Зачем вам нужен - и + 1с?

959
01:06:43,000 --> 01:06:47,000
Это отличает наш массив, чтобы быть наша новая левая половина и правая половина.

960
01:06:47,000 --> 01:06:51,000
[Студент] Но почему ты не мог сделать это без - 1 и + 1с?

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
[Студент] Я начал 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]