1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Seção 3] [menos confortável]

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

3
00:00:05,000 --> 00:00:08,000
>> [Esta é CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Tudo bem, vamos começar.

5
00:00:10,000 --> 00:00:13,000
Bem-vindo à Semana 4 da CS50.

6
00:00:13,000 --> 00:00:19,000
Se vocês abrir um navegador e abrir pset 3,

7
00:00:19,000 --> 00:00:23,000
Scramble com CS50, vamos começar a ir

8
00:00:23,000 --> 00:00:26,000
através da seção de perguntas lá.

9
00:00:26,000 --> 00:00:32,000
Assim como na semana passada, nós estaremos trabalhando no CS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
se você também vai puxar que até bem,

11
00:00:35,000 --> 00:00:43,000
e se você vá em frente e visite este link que eu tenho aqui em cima no topo.

12
00:00:43,000 --> 00:00:45,000
É hora de começar.

13
00:00:45,000 --> 00:00:51,000
Nós temos o nosso programa oi pouco aqui. Nada louco.

14
00:00:51,000 --> 00:00:55,000
Uma das primeiras coisas que eu quero fazer com vocês hoje é passar por cima de algumas soluções

15
00:00:55,000 --> 00:00:58,000
ao Conjunto de Problemas 1, espécie de exemplos de soluções,

16
00:00:58,000 --> 00:01:03,000
só assim você pode ter uma idéia de que tipo de equipe código é escrito,

17
00:01:03,000 --> 00:01:07,000
que tipos de estudantes de código outros estão escrevendo,

18
00:01:07,000 --> 00:01:10,000
e ter que dar uma olhada nisso, porque eu sei que é estranho

19
00:01:10,000 --> 00:01:14,000
quando você enviar uma solução para um conjunto de problemas e obter comentários

20
00:01:14,000 --> 00:01:18,000
em sua própria versão, mas às vezes é útil para ver como as outras pessoas o fez,

21
00:01:18,000 --> 00:01:22,000
especialmente aqueles que são agradável.

22
00:01:22,000 --> 00:01:27,000
Para a maior parte, eu fiquei realmente impressionado com as soluções que vocês produziram.

23
00:01:27,000 --> 00:01:31,000
Eu ainda não comecei a olhar para os seus 2s conjunto de problemas, mas se for qualquer coisa como o primeiro,

24
00:01:31,000 --> 00:01:34,000
isso não significa nada além de coisas boas.

25
00:01:34,000 --> 00:01:40,000
>> Se você olhar para minhas revisões, vamos começar todo o caminho de Revisão 1,

26
00:01:40,000 --> 00:01:47,000
e vamos dar uma olhada rápida em uma solução Mario.

27
00:01:47,000 --> 00:01:54,000
Se você puxar isto, estes programas que vamos apresentar são corretas.

28
00:01:54,000 --> 00:01:56,000
Não houve problemas de regularidade com esses problemas, mas sim,

29
00:01:56,000 --> 00:01:59,000
queremos falar um pouco sobre as questões de design diferentes

30
00:01:59,000 --> 00:02:03,000
que estavam a ser usados ​​aqui.

31
00:02:03,000 --> 00:02:08,000
Uma das coisas que era interessante sobre a solução

32
00:02:08,000 --> 00:02:11,000
é que ele usou este novo conceito chamado de libra definir,

33
00:02:11,000 --> 00:02:15,000
por vezes também referido como um hash definir.

34
00:02:15,000 --> 00:02:18,000
Deixe-me ampliar-lo aqui.

35
00:02:18,000 --> 00:02:24,000
A # definir permite dar nomes a esses números em seu programa.

36
00:02:24,000 --> 00:02:28,000
Neste caso, a altura máxima de uma pirâmide em Mario

37
00:02:28,000 --> 00:02:34,000
foi de 23 e em vez de colocar 23 no meu código-

38
00:02:34,000 --> 00:02:37,000
que se referem a isso como codificação dura 23 -

39
00:02:37,000 --> 00:02:43,000
vez o que dá o nome max_height a esse número,

40
00:02:43,000 --> 00:02:48,000
de modo que aqui no meu loop do-while

41
00:02:48,000 --> 00:02:51,000
você pode realmente se referir a max_height

42
00:02:51,000 --> 00:02:55,000
em vez de colocar o número 23 polegadas

43
00:02:55,000 --> 00:02:57,000
[Estudante] Qual é a vantagem de fazer isso?

44
00:02:57,000 --> 00:02:59,000
Essa é uma grande questão.

45
00:02:59,000 --> 00:03:03,000
Uma delas é a legibilidade.

46
00:03:03,000 --> 00:03:08,000
Uma vantagem de usar este # define é a legibilidade.

47
00:03:08,000 --> 00:03:11,000
Quando eu estou lendo esse código, eu posso ver o que está acontecendo.

48
00:03:11,000 --> 00:03:15,000
>> Eu posso ver nessa condição aqui que estamos testando

49
00:03:15,000 --> 00:03:19,000
para a altura de ser <0, o que poderíamos ter definido também

50
00:03:19,000 --> 00:03:22,000
para ser de uma altura mínima ou uma altura min.

51
00:03:22,000 --> 00:03:25,000
A outra vantagem é que eu posso então ler o resto da linha para ver

52
00:03:25,000 --> 00:03:30,000
que está também a verificação para certificar-se que a altura não é maior do que a altura máxima,

53
00:03:30,000 --> 00:03:35,000
porque nós vamos continuar enquanto que a altura é maior que a altura máxima.

54
00:03:35,000 --> 00:03:40,000
A outra vantagem é, se eu diminuir o zoom um pouco aqui-

55
00:03:40,000 --> 00:03:49,000
se eu executar este programa e executá-lo, digamos, com 23, agora,

56
00:03:49,000 --> 00:03:52,000
ele irá imprimir todos os 23 linhas apenas como aquele.

57
00:03:52,000 --> 00:03:54,000
Mas dizer que eu queria mudar a altura máxima,

58
00:03:54,000 --> 00:03:57,000
e agora eu quero limitar a altura máxima das pirâmides

59
00:03:57,000 --> 00:04:06,000
para ser apenas dizer-homem, que foi descolados.

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

61
00:04:14,000 --> 00:04:18,000
e vamos dizer que queria defini-lo igual a 10.

62
00:04:18,000 --> 00:04:22,000
Agora, neste momento, tudo o que eu tinha a fazer era mudar isso neste local um.

63
00:04:22,000 --> 00:04:27,000
Eu posso recompilar o código, e agora se eu tentar digitar 12,

64
00:04:27,000 --> 00:04:30,000
ele vai me perguntar novamente.

65
00:04:30,000 --> 00:04:33,000
Neste caso, estamos apenas usando max_height uma vez.

66
00:04:33,000 --> 00:04:37,000
Não é que de um grande aborrecimento para ir em

67
00:04:37,000 --> 00:04:40,000
e alterá-lo no loop while se você precisar.

68
00:04:40,000 --> 00:04:44,000
Mas em programas onde você está referenciando o mesmo número mágico

69
00:04:44,000 --> 00:04:47,000
uma e outra vez, este # define mecanismo é realmente útil

70
00:04:47,000 --> 00:04:52,000
porque você simplesmente mudá-lo uma vez no topo do arquivo que é geralmente onde você colocá-los-

71
00:04:52,000 --> 00:04:57,000
e a mudança se infiltra através do resto do ficheiro.

72
00:04:57,000 --> 00:05:02,000
>> Outras coisas que eu queria observar nesta tarefa que eu achava que parecia muito bom,

73
00:05:02,000 --> 00:05:05,000
um era o nome das variáveis.

74
00:05:05,000 --> 00:05:14,000
Você vê aqui que temos variáveis ​​inteiras chamadas de linha e chamada altura.

75
00:05:14,000 --> 00:05:20,000
Espaços, hashes, que ajuda a tornar o código um pouco mais legível,

76
00:05:20,000 --> 00:05:25,000
torna um pouco mais compreensível o que está realmente acontecendo.

77
00:05:25,000 --> 00:05:31,000
Isto está em contraste com o uso, por exemplo, letras aleatórias

78
00:05:31,000 --> 00:05:35,000
ou apenas gobbledygook completamente.

79
00:05:35,000 --> 00:05:39,000
A última coisa que eu vou apontar é que, em loops,

80
00:05:39,000 --> 00:05:45,000
muitas vezes essas variáveis ​​iterador, estes contadores que você usa em seu loops,

81
00:05:45,000 --> 00:05:51,000
é padrão e convencionais para os iniciar com qualquer i e j em seguida, e, em seguida, k

82
00:05:51,000 --> 00:05:54,000
e ir de lá, se você precisa mais variáveis,

83
00:05:54,000 --> 00:05:56,000
e isso é apenas uma convenção.

84
00:05:56,000 --> 00:05:58,000
Há muitas convenções.

85
00:05:58,000 --> 00:06:00,000
Ele depende da linguagem de programação que você está usando.

86
00:06:00,000 --> 00:06:04,000
Mas em C, que normalmente começam com i.

87
00:06:04,000 --> 00:06:08,000
Não faz sentido usar, por exemplo, a ou b

88
00:06:08,000 --> 00:06:13,000
, dependendo da situação.

89
00:06:13,000 --> 00:06:15,000
Isso é tudo para este.

90
00:06:15,000 --> 00:06:25,000
Se agora você puxar para cima Revisão 2, você verá um outro Mario,

91
00:06:25,000 --> 00:06:29,000
e este é semelhante a outra que acabamos de ver,

92
00:06:29,000 --> 00:06:32,000
mas ele faz algo do tipo legal.

93
00:06:32,000 --> 00:06:38,000
Se olharmos para esta seção aqui no interior do interior para o laço,

94
00:06:38,000 --> 00:06:44,000
eles estão usando alguma sintaxe louco procurando aqui bem nesta linha.

95
00:06:44,000 --> 00:06:47,000
Isto é chamado um operador ternário.

96
00:06:47,000 --> 00:06:53,000
É uma declaração se mais condensada em uma linha.

97
00:06:53,000 --> 00:06:57,000
A condição é essa parte entre parênteses.

98
00:06:57,000 --> 00:07:05,000
É equivalente a dizer se j altura <- i - 1.

99
00:07:05,000 --> 00:07:10,000
E, em seguida, o que o conteúdo do bloco que se seriam são o espaço

100
00:07:10,000 --> 00:07:16,000
e, em seguida, o conteúdo do que a outra coisa seria se esse #.

101
00:07:16,000 --> 00:07:20,000
É, essencialmente, a atribuição de um espaço para essa variável.

102
00:07:20,000 --> 00:07:24,000
É colocar um espaço no conteúdo do bloco variável,

103
00:07:24,000 --> 00:07:29,000
Se esta condição for atendida, e se a condição não for atendida,

104
00:07:29,000 --> 00:07:32,000
então a variável bloco recebe este #.

105
00:07:32,000 --> 00:07:37,000
E depois, é claro, em vez de construir uma cadeia inteira

106
00:07:37,000 --> 00:07:43,000
e impressão de tudo no final essa solução imprime-o um personagem de cada vez.

107
00:07:43,000 --> 00:07:48,000
Muito legal.

108
00:07:48,000 --> 00:07:53,000
>> Outro par de coisas para olhar. Nós vamos passar para gananciosos.

109
00:07:53,000 --> 00:07:58,000
Agora, se olharmos para gananciosos, solução esta primeira

110
00:07:58,000 --> 00:08:00,000
usa esses # define um pouco.

111
00:08:00,000 --> 00:08:06,000
Temos uma constante definida para cada um dos diferentes números neste programa.

112
00:08:06,000 --> 00:08:12,000
Temos uma de centavos por dólar, uma para quartos, moedas, moedas e centavos,

113
00:08:12,000 --> 00:08:15,000
e agora, se desloque para baixo e ler o código,

114
00:08:15,000 --> 00:08:22,000
podemos ver um padrão-enquanto tudo impressão loop out.

115
00:08:22,000 --> 00:08:25,000
Tipo do cerne do problema foi perceber que

116
00:08:25,000 --> 00:08:29,000
você necessário para converter a bóia que você lê na do usuário para um número inteiro

117
00:08:29,000 --> 00:08:32,000
com precisão fazer a matemática, e isso é porque

118
00:08:32,000 --> 00:08:36,000
com números de ponto flutuante, como falamos na aula brevemente,

119
00:08:36,000 --> 00:08:41,000
não é possível representar com precisão cada valor único na linha de número

120
00:08:41,000 --> 00:08:47,000
porque há valores infinitos entre 3 e, digamos, 3,1 mesmo.

121
00:08:47,000 --> 00:08:54,000
Você pode ter 3,01 e 3,001 e 3,0001, e você pode continuar.

122
00:08:54,000 --> 00:09:00,000
Acontece sempre que você está trabalhando com o dinheiro, muitas vezes você quer convertê-lo

123
00:09:00,000 --> 00:09:05,000
em formato inteiro, de modo que você não está perdendo alguns centavos e esse tipo de coisa.

124
00:09:05,000 --> 00:09:09,000
Fazer isso e arredondamento foi fundamental.

125
00:09:09,000 --> 00:09:14,000
Esta solução utilizada perfeitamente simples algoritmo, grande,

126
00:09:14,000 --> 00:09:17,000
que diminua o número de centavos restantes, primeiro por trimestres,

127
00:09:17,000 --> 00:09:19,000
em seguida, por moedas, em seguida, por níqueis, em seguida, por tostões,

128
00:09:19,000 --> 00:09:24,000
e aumentando o número de moedas de cada vez.

129
00:09:24,000 --> 00:09:31,000
>> Outra solução que nós vamos ver, como eu diminuir o zoom e vá para a Revisão 4,

130
00:09:31,000 --> 00:09:40,000
teve um início muito semelhante, mas em vez utilizado div e mod

131
00:09:40,000 --> 00:09:44,000
bem aqui para calcular o número de centavos.

132
00:09:44,000 --> 00:09:50,000
Isso, o número de alojamentos é igual ao número de centavos divididos por 25,

133
00:09:50,000 --> 00:09:53,000
ea razão que isto funciona é porque estamos fazendo uma divisão inteira,

134
00:09:53,000 --> 00:09:58,000
por isso é descartar qualquer restante.

135
00:09:58,000 --> 00:10:02,000
[Estudante] Nós temos que comentar a pesquisa?

136
00:10:02,000 --> 00:10:05,000
Ela realmente depende.

137
00:10:05,000 --> 00:10:08,000
[Estudante] Você está comentando mais do que o código aqui.

138
00:10:08,000 --> 00:10:16,000
Sim, e por isso há um monte de diferentes filosofias sobre isso.

139
00:10:16,000 --> 00:10:21,000
Minha filosofia pessoal é que seu código é realmente a verdade,

140
00:10:21,000 --> 00:10:24,000
como seu código é o que está realmente em execução no computador,

141
00:10:24,000 --> 00:10:29,000
e para que o seu código deve ser legível possível para não necessitar de muitos comentários.

142
00:10:29,000 --> 00:10:33,000
Dito isso, quando você está fazendo coisas que são meio complicado matematicamente

143
00:10:33,000 --> 00:10:38,000
ou através de algoritmos, é bom para comentar os para que você possa

144
00:10:38,000 --> 00:10:43,000
adicionar uma dimensão extra, uma camada extra para quem está lendo o seu código.

145
00:10:43,000 --> 00:10:49,000
Nessas soluções, muitas vezes eles são comentados mais fortemente apenas porque

146
00:10:49,000 --> 00:10:52,000
nós queremos ser capazes de distribuí-los e ter pessoas buscá-las

147
00:10:52,000 --> 00:10:56,000
e lê-los muito facilmente.

148
00:10:56,000 --> 00:11:05,000
Mas, definitivamente, eu concordaria que este é pesado.

149
00:11:05,000 --> 00:11:07,000
[Estudante] Mas, quando em dúvida, vá mais pesado?

150
00:11:07,000 --> 00:11:10,000
Quando em dúvida, vá mais pesado.

151
00:11:10,000 --> 00:11:17,000
Algumas pessoas às vezes dizem 0 retorno ou algo assim.

152
00:11:17,000 --> 00:11:20,000
Eu acho que é um comentário ridículo.

153
00:11:20,000 --> 00:11:22,000
Claramente que é o que está acontecendo.

154
00:11:22,000 --> 00:11:25,000
Eu não preciso de Inglês para me dizer isso.

155
00:11:25,000 --> 00:11:28,000
Às vezes as pessoas escrevem coisas como "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Esse é um tipo de bonito, mas também não-

157
00:11:32,000 --> 00:11:35,000
que não está fazendo a diferença entre os pontos comentando ou não.

158
00:11:35,000 --> 00:11:41,000
Esses tipos de comentários são apenas ha, ha.

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

160
00:11:43,000 --> 00:11:48,000
>> Neste ponto, vamos começar a trabalhar no Conjunto de Problemas 3 seção de perguntas.

161
00:11:48,000 --> 00:11:52,000
Se vocês puxar isso de novo,

162
00:11:52,000 --> 00:11:55,000
como na semana passada, não estamos indo para assistir os curtas nesta seção.

163
00:11:55,000 --> 00:12:00,000
Nós vamos deixar vocês fazer isso em seu próprio tempo e falar sobre as perguntas.

164
00:12:00,000 --> 00:12:05,000
Mas agora nesta seção vamos gastar um pouco mais

165
00:12:05,000 --> 00:12:11,000
falando menos o básico de codificação

166
00:12:11,000 --> 00:12:15,000
como fizemos na semana passada, e em vez disso, vamos focar mais em

167
00:12:15,000 --> 00:12:22,000
um pouco mais da teoria, portanto, falar sobre a busca binária e de classificação.

168
00:12:22,000 --> 00:12:27,000
Desde aqueles de vocês que têm vindo a seguir, juntamente com a palestra,

169
00:12:27,000 --> 00:12:30,000
alguém pode me dar um resumo do que a diferença é

170
00:12:30,000 --> 00:12:35,000
entre busca binária e de busca linear?

171
00:12:35,000 --> 00:12:37,000
O que está acontecendo? Claro.

172
00:12:37,000 --> 00:12:42,000
Lineares pesquisas através de cada elemento na lista ordenada

173
00:12:42,000 --> 00:12:45,000
um por um por um por um por um,

174
00:12:45,000 --> 00:12:50,000
e busca binária divide a lista em dois grupos,

175
00:12:50,000 --> 00:12:57,000
Verifica se o valor teclas que você está procurando é maior ou menor que o valor do ponto médio

176
00:12:57,000 --> 00:13:00,000
que você acabou de encontrar, e se for menor, ele vai com a lista inferior

177
00:13:00,000 --> 00:13:03,000
e depois divide de novo, faz a mesma função

178
00:13:03,000 --> 00:13:07,000
todo o caminho até encontrar o ponto médio para ser igual ao valor propriamente dito.

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

180
00:13:10,000 --> 00:13:12,000
>> Por que nos importamos?

181
00:13:12,000 --> 00:13:20,000
Por que falamos de busca binária contra pesquisa linear?

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

183
00:13:22,000 --> 00:13:24,000
Binário é muito mais rápido, então se você dobrar o tamanho do problema

184
00:13:24,000 --> 00:13:27,000
ele dá mais um passo em vez de o dobro.

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

186
00:13:29,000 --> 00:13:31,000
Isso é uma grande resposta.

187
00:13:31,000 --> 00:13:36,000
Pesquisa linear é muito verificando um elemento de cada vez,

188
00:13:36,000 --> 00:13:39,000
e, como vimos no primeiro dia de aula

189
00:13:39,000 --> 00:13:42,000
Davi passou por seu exemplo livro de telefone

190
00:13:42,000 --> 00:13:45,000
e arrancou uma página do livro de telefone de cada vez

191
00:13:45,000 --> 00:13:47,000
e continuei a fazer isso mais e mais e outra vez,

192
00:13:47,000 --> 00:13:51,000
que vai levá-lo muito tempo para encontrar alguém no livro de telefone,

193
00:13:51,000 --> 00:13:55,000
a menos, claro, que ele estava procurando alguém no começo do alfabeto.

194
00:13:55,000 --> 00:14:00,000
Com busca binária, você pode ir muito mais rápido,

195
00:14:00,000 --> 00:14:05,000
e não é apenas duas vezes mais rápido ou 3 vezes mais rápido ou 4 vezes mais rápido.

196
00:14:05,000 --> 00:14:13,000
Mas o problema torna-se menor e menor e menor muito mais rápido.

197
00:14:13,000 --> 00:14:17,000
Para ilustrar isso, vamos começar a falar sobre o que está acontecendo

198
00:14:17,000 --> 00:14:21,000
quando escrevemos busca binária.

199
00:14:21,000 --> 00:14:27,000
O problema em questão é que se eu tiver uma matriz de números,

200
00:14:27,000 --> 00:14:40,000
por exemplo, 1, 2, 3, 5, 7, 23, 45, 78, 12,323,

201
00:14:40,000 --> 00:14:47,000
e 9 com uma tonelada de 0s depois,

202
00:14:47,000 --> 00:14:52,000
nós queremos ser capazes de descobrir muito rapidamente o que está em

203
00:14:52,000 --> 00:14:57,000
esse conjunto de números.

204
00:14:57,000 --> 00:15:00,000
Eu sei que isso parece um pouco bobo e um pouco artificial,

205
00:15:00,000 --> 00:15:02,000
porque agora ele é.

206
00:15:02,000 --> 00:15:05,000
Nós temos uma matriz que não tem elementos muito diversos em que,

207
00:15:05,000 --> 00:15:08,000
e se eu pedir um de vocês para descobrir se ou não

208
00:15:08,000 --> 00:15:11,000
23 é na matriz, você pode fazer isso muito rapidamente

209
00:15:11,000 --> 00:15:16,000
apenas olhando para isso e me dizer sim ou não.

210
00:15:16,000 --> 00:15:20,000
O análogo a considerar é imaginar se isso fosse, digamos,

211
00:15:20,000 --> 00:15:27,000
uma planilha Excel com 10.000 linhas, 20.000 linhas.

212
00:15:27,000 --> 00:15:31,000
Claro, você pode fazer o comando F ou o F e controle de procurar alguma coisa.

213
00:15:31,000 --> 00:15:33,000
Você também pode usar os filtros e as coisas de busca,

214
00:15:33,000 --> 00:15:37,000
mas se você tinha que olhar através desse arquivo linha por linha por linha,

215
00:15:37,000 --> 00:15:40,000
que levaria muito tempo para encontrá-lo.

216
00:15:40,000 --> 00:15:42,000
É tipo como no exemplo do livro de telefone, também, onde

217
00:15:42,000 --> 00:15:44,000
ninguém olha através de uma página de um livro de telefone de cada vez.

218
00:15:44,000 --> 00:15:47,000
Normalmente, eles não abri-lo ao meio,

219
00:15:47,000 --> 00:15:50,000
ou, no caso de uma série de livros de telefone e dicionários onde

220
00:15:50,000 --> 00:15:54,000
você realmente tê-lo introduzido na primeira letra,

221
00:15:54,000 --> 00:16:01,000
você virar a primeira carta, abrir e começar a passar por lá.

222
00:16:01,000 --> 00:16:03,000
>> Me lembrar do seu nome novamente. >> Sam.

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

224
00:16:05,000 --> 00:16:11,000
Como disse Sam, que o processo de busca linear vai ser muito lento,

225
00:16:11,000 --> 00:16:15,000
e, em vez de busca binária, a forma como isto funciona é que

226
00:16:15,000 --> 00:16:21,000
cada vez que passar por uma iteração do nosso algoritmo de busca,

227
00:16:21,000 --> 00:16:27,000
vamos dividir a lista ao meio, essencialmente,

228
00:16:27,000 --> 00:16:33,000
em duas listas menores.

229
00:16:33,000 --> 00:16:39,000
E, em seguida, a próxima iteração do loop, vamos dividi-lo novamente

230
00:16:39,000 --> 00:16:44,000
em outras listas menores.

231
00:16:44,000 --> 00:16:48,000
Como você pode ver, o problema continua ficando menor e menor

232
00:16:48,000 --> 00:16:55,000
porque guardamos descartando metade da lista de cada vez.

233
00:16:55,000 --> 00:16:59,000
Como funciona esse descarte?

234
00:16:59,000 --> 00:17:05,000
Apenas como lembrete, o que vamos fazer, se fosse um computador

235
00:17:05,000 --> 00:17:11,000
e nós foram, digamos, procurando o número 5 na lista

236
00:17:11,000 --> 00:17:15,000
é que se escolher um número no meio.

237
00:17:15,000 --> 00:17:26,000
No meio da lista, porque não são 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 números,

238
00:17:26,000 --> 00:17:32,000
nós escolher o número, quer na posição de quarto ou na posição 5,

239
00:17:32,000 --> 00:17:38,000
e diria que o meio de nossa lista.

240
00:17:38,000 --> 00:17:42,000
Escolha número no meio.

241
00:17:42,000 --> 00:17:51,000
Então, assim como Sam disse, vamos testar para ver se esse número é igual

242
00:17:51,000 --> 00:17:59,000
para o número que queremos chegar ou o nosso número desejado.

243
00:17:59,000 --> 00:18:06,000
Se for igual, então nós encontramos isso. Nós ganhamos.

244
00:18:06,000 --> 00:18:12,000
Se não é igual, então há um par de casos.

245
00:18:12,000 --> 00:18:15,000
Os dois casos são ou o número tem de ser maior do que o número que estamos olhando,

246
00:18:15,000 --> 00:18:19,000
ou é menor que.

247
00:18:19,000 --> 00:18:25,000
Se for maior, vamos passar para a direita.

248
00:18:25,000 --> 00:18:33,000
E se é menos, nós nos movemos para a esquerda.

249
00:18:33,000 --> 00:18:41,000
E, então, repetir todo o processo novamente

250
00:18:41,000 --> 00:18:48,000
em cada metade da direita ou da metade esquerda da lista.

251
00:18:48,000 --> 00:18:51,000
>> O primeiro problema na seção de hoje é descobrir

252
00:18:51,000 --> 00:18:55,000
como podemos realmente começar a expressar isso no código C.

253
00:18:55,000 --> 00:18:58,000
Nós temos o pseudocódigo aqui.

254
00:18:58,000 --> 00:19:04,000
O que nós vamos começar a fazer é que eu vou puxar-se um novo espaço,

255
00:19:04,000 --> 00:19:09,000
salvar esta revisão para que tenhamos essas notas para mais tarde,

256
00:19:09,000 --> 00:19:20,000
vamos apagar tudo isso, e em seguida, copiar e colar a partir do conjunto de problemas

257
00:19:20,000 --> 00:19:26,000
esta informação em nossos espaços, e espero que isso não quebra.

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

259
00:19:28,000 --> 00:19:33,000
Se vocês todos fazem isso, copie e cole este código em seu novo espaço,

260
00:19:33,000 --> 00:19:43,000
em um em branco.

261
00:19:43,000 --> 00:19:47,000
Vamos tentar Daniel. Se você compilar e executar este programa, é que funciona?

262
00:19:47,000 --> 00:19:49,000
>> Não. O que está dizendo?

263
00:19:49,000 --> 00:19:53,000
Ele diz que o controle atinge final de não-void função.

264
00:19:53,000 --> 00:19:55,000
Sim, então deixe-me tentar executá-lo.

265
00:19:55,000 --> 00:19:59,000
Vocês já viram isso antes? Você sabe o que isso significa?

266
00:19:59,000 --> 00:20:01,000
Ok, vamos dissecar isso um pouco.

267
00:20:01,000 --> 00:20:10,000
Ele está dizendo, file.c na linha 9, coluna 1, temos um erro, como você disse,

268
00:20:10,000 --> 00:20:16,000
e ele diz que ele é decorrente do aviso de erro eo aviso tipo de retorno.

269
00:20:16,000 --> 00:20:18,000
Parece que alguma coisa está acontecendo com o tipo de retorno, o que faz sentido.

270
00:20:18,000 --> 00:20:21,000
Nós temos uma função não-nula, o que significa que temos uma função

271
00:20:21,000 --> 00:20:24,000
que não volta vazia.

272
00:20:24,000 --> 00:20:27,000
Uma função de vazio é um que se parece com esta:

273
00:20:27,000 --> 00:20:35,000
void foo (), e é nula, porque o tipo de retorno é nulo,

274
00:20:35,000 --> 00:20:38,000
o que significa que se nós tivéssemos alguma coisa aqui

275
00:20:38,000 --> 00:20:45,000
como um retorno, teríamos um erro do compilador para isso.

276
00:20:45,000 --> 00:20:49,000
No entanto, temos uma função não-nula.

277
00:20:49,000 --> 00:20:51,000
Nossa função não-nula neste caso é a nossa função de pesquisa

278
00:20:51,000 --> 00:20:56,000
porque tem um tipo de retorno de bool.

279
00:20:56,000 --> 00:20:59,000
Quando é dizendo que o controlo atinge o fim de uma função não nula,

280
00:20:59,000 --> 00:21:02,000
é porque a pesquisa não tem uma instrução de retorno.

281
00:21:02,000 --> 00:21:04,000
Ele não está retornando nada do tipo bool.

282
00:21:04,000 --> 00:21:09,000
>> Nós podemos consertar isso, eo que é que vocês pensam

283
00:21:09,000 --> 00:21:13,000
pesquisa deverá retornar por padrão?

284
00:21:13,000 --> 00:21:16,000
Qual deve ser o valor de retorno padrão de busca?

285
00:21:16,000 --> 00:21:19,000
Porque é o que podemos colocar no final.

286
00:21:19,000 --> 00:21:21,000
Charlotte, você tem alguma-?

287
00:21:21,000 --> 00:21:23,000
Verdadeiro ou falso? >> Verdadeiro ou falso.

288
00:21:23,000 --> 00:21:26,000
Qual?

289
00:21:26,000 --> 00:21:28,000
Falso. Eu não sei.

290
00:21:28,000 --> 00:21:30,000
Falso? Vamos tentar.

291
00:21:30,000 --> 00:21:32,000
Por que você diz return false? Isso é grande intuição.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Eu não sei.

293
00:21:35,000 --> 00:21:39,000
Nós vamos retornar false neste caso, porque este será o nosso padrão

294
00:21:39,000 --> 00:21:44,000
se por algum motivo a lista está vazia ou a agulha

295
00:21:44,000 --> 00:21:46,000
que está procurando não existe.

296
00:21:46,000 --> 00:21:50,000
Então, no final, se não retornar verdadeiro anteriormente nesta função,

297
00:21:50,000 --> 00:21:55,000
nós sempre sabemos que esta função vai dizer Não, não é na matriz.

298
00:21:55,000 --> 00:21:58,000
Não é no palheiro.

299
00:21:58,000 --> 00:22:03,000
Agora, se compilar e executar, deixe-me guardar este para que possamos puxar para cima.

300
00:22:03,000 --> 00:22:08,000
Agora, se compilar e executar o nosso programa, que constrói.

301
00:22:08,000 --> 00:22:12,000
Nós temos nosso prompt pouco.

302
00:22:12,000 --> 00:22:20,000
Se eu acertar 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Ele não imprimir nada. Parece que tudo terminou bem.

304
00:22:25,000 --> 00:22:35,000
Nós temos que preencher este polegadas

305
00:22:35,000 --> 00:22:39,000
Nós conversamos sobre o algoritmo em pseudocódigo um pouco atrás.

306
00:22:39,000 --> 00:22:44,000
Deixe-me ver, senão este,

307
00:22:44,000 --> 00:22:49,000
e eu vou puxar o algoritmo de volta novamente.

308
00:22:49,000 --> 00:22:51,000
Vamos bater esse cara. Nope.

309
00:22:51,000 --> 00:22:58,000
Não é.

310
00:22:58,000 --> 00:23:03,000
Como podemos fazer isso?

311
00:23:03,000 --> 00:23:11,000
O que seria uma boa estratégia para o arranque esse código?

312
00:23:11,000 --> 00:23:16,000
Você tem que escolher um número no meio.

313
00:23:16,000 --> 00:23:23,000
Como é que vamos escolher um número no meio de uma matriz?

314
00:23:23,000 --> 00:23:25,000
Alguma sugestão?

315
00:23:25,000 --> 00:23:27,000
[Estudante] strlen dividido por 2.

316
00:23:27,000 --> 00:23:32,000
Strlen dividido por 2. Isso é um grande.

317
00:23:32,000 --> 00:23:35,000
Strlen trabalha com tipos especiais de matrizes.

318
00:23:35,000 --> 00:23:38,000
Que tipos de matrizes?

319
00:23:38,000 --> 00:23:44,000
Matrizes String, arrays de caracteres.

320
00:23:44,000 --> 00:23:48,000
É que mesmo tipo de conceito que queremos aplicar,

321
00:23:48,000 --> 00:23:52,000
mas não podemos usar strlen porque não temos uma matriz de caracteres.

322
00:23:52,000 --> 00:23:55,000
Nós temos uma matriz de inteiros.

323
00:23:55,000 --> 00:23:58,000
Mas o que strlen começar por nós?

324
00:23:58,000 --> 00:24:01,000
Você sabe o que fica para nós?

325
00:24:01,000 --> 00:24:03,000
[Estudante] strlen fica-nos o comprimento.

326
00:24:03,000 --> 00:24:05,000
Exatamente, fica-nos o comprimento.

327
00:24:05,000 --> 00:24:09,000
Strlen recebe o comprimento da matriz para nós.

328
00:24:09,000 --> 00:24:14,000
>> Como é que vamos conseguir isso em nosso programa de busca binária?

329
00:24:14,000 --> 00:24:18,000
Como você obter o comprimento de uma matriz?

330
00:24:18,000 --> 00:24:20,000
[Estudante] strlen?

331
00:24:20,000 --> 00:24:25,000
Você pode obter o comprimento de uma matriz formatada corretamente seqüência C com strlen.

332
00:24:25,000 --> 00:24:31,000
O problema, porém, é que não temos uma matriz de cadeia.

333
00:24:31,000 --> 00:24:36,000
Se olharmos para trás, neste código, temos essa matriz inteiro.

334
00:24:36,000 --> 00:24:38,000
Como sabemos quanto tempo é?

335
00:24:38,000 --> 00:24:44,000
[Estudante] Existe um equivalente para um ponto final, como int l ou algo assim?

336
00:24:44,000 --> 00:24:49,000
Acontece que há, na verdade, não é, e isso de certa forma, isso é

337
00:24:49,000 --> 00:24:52,000
uma daquelas coisas que é bom saber sobre C,

338
00:24:52,000 --> 00:24:57,000
que não há nenhuma maneira de obter o comprimento de uma matriz

339
00:24:57,000 --> 00:24:59,000
se tudo o que eu te dar é a matriz.

340
00:24:59,000 --> 00:25:02,000
A razão trabalha com cordas, a razão strlen obras,

341
00:25:02,000 --> 00:25:06,000
é porque se uma string está formatado corretamente,

342
00:25:06,000 --> 00:25:12,000
ele terá que especial caracter \ 0 no final.

343
00:25:12,000 --> 00:25:16,000
>> Você também pode imaginar se você tem uma string formatada incorretamente

344
00:25:16,000 --> 00:25:20,000
e não há nenhum caracter \ 0 lá, então a coisa toda não funciona.

345
00:25:20,000 --> 00:25:22,000
[Estudante] Você pode adicionar o \ 0?

346
00:25:22,000 --> 00:25:24,000
Poderíamos neste caso.

347
00:25:24,000 --> 00:25:29,000
Poderíamos acrescentar algum tipo de \ 0

348
00:25:29,000 --> 00:25:33,000
ou algum tipo de significar personagem e então usar isso.

349
00:25:33,000 --> 00:25:36,000
Mas isso não é muito de ir trabalhar

350
00:25:36,000 --> 00:25:40,000
porque o 0 \ é para um tipo char,

351
00:25:40,000 --> 00:25:43,000
e aqui temos ints.

352
00:25:43,000 --> 00:25:46,000
A outra coisa é que, se fosse para usar um valor especial

353
00:25:46,000 --> 00:25:49,000
como -1 a marcar o final de uma matriz

354
00:25:49,000 --> 00:25:54,000
então nunca poderia armazenar um -1 em nossas matrizes inteiros.

355
00:25:54,000 --> 00:25:56,000
Nós estaríamos presos.

356
00:25:56,000 --> 00:26:00,000
Acontece que a única maneira de obter o comprimento

357
00:26:00,000 --> 00:26:03,000
de uma matriz em C é, na verdade, lembre-se que

358
00:26:03,000 --> 00:26:08,000
quando você configurá-lo e passá-lo ao redor com a matriz

359
00:26:08,000 --> 00:26:14,000
de modo que sempre que eu tenho uma função que vai fazer algum trabalho

360
00:26:14,000 --> 00:26:18,000
em um array de inteiros ou flutua ou duplica ou o que você tem,

361
00:26:18,000 --> 00:26:22,000
Eu também preciso dar a função comprimento da matriz,

362
00:26:22,000 --> 00:26:26,000
e isso é exatamente o que temos feito aqui na função de pesquisa.

363
00:26:26,000 --> 00:26:30,000
Se você olhar, o que fizemos quando passamos em nossa matriz aqui,

364
00:26:30,000 --> 00:26:36,000
que também passam no comprimento, o tamanho.

365
00:26:36,000 --> 00:26:41,000
Acontece que nós chamamos esta variável aqui,

366
00:26:41,000 --> 00:26:43,000
este parâmetro ou argumento.

367
00:26:43,000 --> 00:26:46,000
Isso é chamado de lista de argumentos da função ou lista de parâmetros,

368
00:26:46,000 --> 00:26:51,000
e estes são também chamados de argumentos ou parâmetros.

369
00:26:51,000 --> 00:26:53,000
As pessoas usam termos diferentes em momentos diferentes.

370
00:26:53,000 --> 00:26:55,000
Eu às vezes trocar-los pessoalmente.

371
00:26:55,000 --> 00:27:00,000
O que acontece é que esta variável aqui é um nome semelhante

372
00:27:00,000 --> 00:27:03,000
a esta # define-se aqui.

373
00:27:03,000 --> 00:27:06,000
Mas eles não são a mesma coisa.

374
00:27:06,000 --> 00:27:11,000
A capitalização não importa.

375
00:27:11,000 --> 00:27:14,000
>> Se você olhar para o que acontece aqui, nós declaramos

376
00:27:14,000 --> 00:27:18,000
nossa matriz int, o que nós chamamos de números.

377
00:27:18,000 --> 00:27:23,000
Nós demos o nosso tamanho, o que corresponde ao nosso # define-se no topo.

378
00:27:23,000 --> 00:27:27,000
Vai ser 8.

379
00:27:27,000 --> 00:27:35,000
E então, quando nós então chamar nossa função de pesquisa, logo abaixo,

380
00:27:35,000 --> 00:27:40,000
passamos o número que deseja pesquisar, o que temos solicitado,

381
00:27:40,000 --> 00:27:43,000
obtido a partir do usuário.

382
00:27:43,000 --> 00:27:46,000
Passamos na matriz, este números,

383
00:27:46,000 --> 00:27:51,000
e, depois, também têm de passar no tamanho da matriz,

384
00:27:51,000 --> 00:27:57,000
e, em seguida, o valor de tamanho 8 fica armazenado

385
00:27:57,000 --> 00:28:01,000
ou passados ​​para essa variável tamanho inteiro chamado.

386
00:28:01,000 --> 00:28:08,000
Temos o tamanho da matriz.

387
00:28:08,000 --> 00:28:11,000
Agora, se voltar para o que estávamos falando antes,

388
00:28:11,000 --> 00:28:14,000
Eu acho que Missy trouxe o ponto de que o que precisávamos fazer é obter o comprimento da matriz

389
00:28:14,000 --> 00:28:20,000
e dividir por dois, e que vai nos dar o ponto médio.

390
00:28:20,000 --> 00:28:22,000
Vamos ver.

391
00:28:22,000 --> 00:28:25,000
Posso ter alguém escrever esse e salvá-lo em seu espaço?

392
00:28:25,000 --> 00:28:27,000
Como cerca de Leila?

393
00:28:27,000 --> 00:28:31,000
Posso ter você escrever isso em?

394
00:28:31,000 --> 00:28:35,000
Escrever a primeira linha onde você toma o comprimento da matriz e obter o ponto médio

395
00:28:35,000 --> 00:28:41,000
e armazená-lo em uma nova variável.

396
00:28:41,000 --> 00:28:44,000
Vou te dar alguns segundos. Você está pronto?

397
00:28:44,000 --> 00:28:46,000
[Estudante inaudível]

398
00:28:46,000 --> 00:28:50,000
Claro, eu poderia ter você a calcular o ponto médio

399
00:28:50,000 --> 00:28:55,000
da matriz palheiro dentro da função de pesquisa

400
00:28:55,000 --> 00:29:03,000
utilizando o comprimento da matriz palheiro, que é a variável de tamanho?

401
00:29:03,000 --> 00:29:08,000
Nada complicado aqui.

402
00:29:08,000 --> 00:29:12,000
[Leila] tamanho Just / 2 e just-

403
00:29:12,000 --> 00:29:17,000
E salvá-lo, e aperte o botão Salvar-se aqui em cima,

404
00:29:17,000 --> 00:29:19,000
e vamos arrancá-la.

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

406
00:29:22,000 --> 00:29:28,000
Lá vamos nós. Impressionante.

407
00:29:28,000 --> 00:29:30,000
>> Como é, este vai compilar?

408
00:29:30,000 --> 00:29:32,000
[Leila] Não, ele precisa ser maior.

409
00:29:32,000 --> 00:29:34,000
[Nate] Sim, então o que precisamos fazer?

410
00:29:34,000 --> 00:29:36,000
[Leila] Como ponto médio int ou algo assim.

411
00:29:36,000 --> 00:29:41,000
Impressionante. Sim, vamos fazer isso, int size = ponto médio.

412
00:29:41,000 --> 00:29:44,000
Será que isto vai compilar?

413
00:29:44,000 --> 00:29:47,000
Vamos apagar este comentário e tirá-lo do caminho.

414
00:29:47,000 --> 00:29:50,000
O que não será compilado sobre isso?

415
00:29:50,000 --> 00:29:52,000
Nós não estamos fazendo nada com inteiro,

416
00:29:52,000 --> 00:29:55,000
por isso precisamos de imprimi-lo ou algo assim.

417
00:29:55,000 --> 00:29:58,000
Sim, exatamente.

418
00:29:58,000 --> 00:30:00,000
Nós vamos ter uma variável não utilizada.

419
00:30:00,000 --> 00:30:02,000
O que mais não vai trabalhar sobre isso?

420
00:30:02,000 --> 00:30:06,000
Eu acho que você disse alguma coisa, Sam. Ponto e vírgula.

421
00:30:06,000 --> 00:30:08,000
Sim, eu estou perdendo os pontos e vírgulas.

422
00:30:08,000 --> 00:30:14,000
Vai ser uma constante ao longo de todo o período.

423
00:30:14,000 --> 00:30:17,000
A última coisa que vou fazer é que eu vou colocar algum espaço em branco em ambos os lados

424
00:30:17,000 --> 00:30:23,000
deste operador aqui, já que é normalmente como fazemos

425
00:30:23,000 --> 00:30:26,000
de acordo com o nosso guia de estilo.

426
00:30:26,000 --> 00:30:29,000
Nós temos o ponto médio da nossa matriz.

427
00:30:29,000 --> 00:30:32,000
Agora, se nos lembrarmos de volta ao nosso algoritmo,

428
00:30:32,000 --> 00:30:37,000
qual foi o segundo passo que nós tivemos que fazer uma vez que temos o ponto médio?

429
00:30:37,000 --> 00:30:42,000
[Estudante] Se for maior [inaudível].

430
00:30:42,000 --> 00:30:48,000
Sim, por isso temos de fazer algum tipo de comparação, eo que estamos comparando aqui?

431
00:30:48,000 --> 00:30:53,000
Você disse que se ele é maior que. O que há em que a sentença se refere?

432
00:30:53,000 --> 00:30:57,000
O número que aparece, se é maior do que o ponto médio, então vá até a matriz?

433
00:30:57,000 --> 00:31:05,000
Exatamente, por isso o número que aparece quando nós-

434
00:31:05,000 --> 00:31:10,000
A agulha, por isso estamos comparando com a agulha,

435
00:31:10,000 --> 00:31:12,000
eo que estamos comparando contra a agulha?

436
00:31:12,000 --> 00:31:15,000
Porque a agulha é o que estamos procurando.

437
00:31:15,000 --> 00:31:18,000
Estamos comparando-o a chegar ao ponto médio.

438
00:31:18,000 --> 00:31:21,000
>> Mas será que faz sentido para verificar

439
00:31:21,000 --> 00:31:27,000
se ponto médio = agulha?

440
00:31:27,000 --> 00:31:32,000
Isso faz sentido?

441
00:31:32,000 --> 00:31:35,000
Alguém discorda?

442
00:31:35,000 --> 00:31:40,000
Vamos tentar, se (ponto médio agulha ==).

443
00:31:40,000 --> 00:31:42,000
[Estudante] Não printf você o encontrou.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("Nós descobrimos que \ n");

445
00:31:51,000 --> 00:31:56,000
Caso contrário! Vou começar a fazer algo diferente aqui.

446
00:31:56,000 --> 00:32:00,000
Eu vou começar a colocar cintas em torno de se as declarações o tempo todo

447
00:32:00,000 --> 00:32:05,000
apenas porque se nós adicionamos mais coisas, então

448
00:32:05,000 --> 00:32:07,000
nós não temos os compiladores.

449
00:32:07,000 --> 00:32:09,000
Sim, Sam. Você tem um ponto.

450
00:32:09,000 --> 00:32:12,000
O problema é que o ponto central representa uma posição na matriz,

451
00:32:12,000 --> 00:32:15,000
mas você pode obtê-lo para representar o valor em que a posição da matriz.

452
00:32:15,000 --> 00:32:17,000
Isso é um grande ponto.

453
00:32:17,000 --> 00:32:19,000
Será que toda a gente ouvir o que Sam disse?

454
00:32:19,000 --> 00:32:22,000
Ele disse que como é ponto médio

455
00:32:22,000 --> 00:32:28,000
representa apenas uma posição na matriz, mas não é o elemento real na matriz.

456
00:32:28,000 --> 00:32:30,000
Se você pensar sobre o código como escrito agora,

457
00:32:30,000 --> 00:32:35,000
se olharmos para esta matriz aqui em baixo, que tem 8 elementos em que,

458
00:32:35,000 --> 00:32:39,000
o que é o valor do ponto médio vai ser nesta função?

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

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

461
00:32:45,000 --> 00:32:51,000
Se olharmos para o número 4 -

462
00:32:51,000 --> 00:32:54,000
e nós podemos apenas executar esse código e colocar um rosto pouco triste aqui

463
00:32:54,000 --> 00:32:58,000
porque não achou-se executar esse código

464
00:32:58,000 --> 00:33:04,000
como é agora, carregando-o, construção, deixe-me rolar para baixo,

465
00:33:04,000 --> 00:33:09,000
e se olharmos para o número 4,

466
00:33:09,000 --> 00:33:18,000
que encontramos, mas não chegar a este printf sim.

467
00:33:18,000 --> 00:33:23,000
Uma razão é que nós não retornar true,

468
00:33:23,000 --> 00:33:26,000
mas nós realmente encontrar o número 4?

469
00:33:26,000 --> 00:33:28,000
E Sam é dizer não.

470
00:33:28,000 --> 00:33:31,000
O que nós encontramos?

471
00:33:31,000 --> 00:33:35,000
Nós realmente encontramos o ponto médio, que se olharmos para a matriz para cá,

472
00:33:35,000 --> 00:33:38,000
ele vai ser o elemento no índice 4 que estamos olhando,

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

474
00:33:42,000 --> 00:33:46,000
>> Como é que vamos realmente ter esse elemento no ponto médio

475
00:33:46,000 --> 00:33:48,000
e não apenas o ponto médio em si?

476
00:33:48,000 --> 00:33:52,000
[Estudante] Nós entraria char ou algo assim?

477
00:33:52,000 --> 00:33:55,000
O que teria que fazer, só por curiosidade?

478
00:33:55,000 --> 00:33:57,000
Você pode elaborar um pouco mais?

479
00:33:57,000 --> 00:34:02,000
Tens de transformar a posição para o número,

480
00:34:02,000 --> 00:34:05,000
assim que você tem que fazer alguma ligação, eu acho que é char, mas pode não ser.

481
00:34:05,000 --> 00:34:07,000
Sim, isso é um bom ponto.

482
00:34:07,000 --> 00:34:12,000
Estamos fazendo um monte de posições esta convertendo em caracteres, esses personagens,

483
00:34:12,000 --> 00:34:14,000
durante os dois primeiros conjuntos de problemas.

484
00:34:14,000 --> 00:34:18,000
Acontece que aqui, isso é quase semelhante ao

485
00:34:18,000 --> 00:34:24,000
acessando o caráter om dentro de uma cadeia, se isso faz sentido.

486
00:34:24,000 --> 00:34:30,000
Aqui queremos acessar o elemento ponto médio.

487
00:34:30,000 --> 00:34:34,000
Como podemos fazer isso?

488
00:34:34,000 --> 00:34:39,000
Kevin, você tem alguma sugestão de como podemos fazer isso?

489
00:34:39,000 --> 00:34:44,000
Você poderia fazer palheiro, suporte aberto, médio, fechou suporte.

490
00:34:44,000 --> 00:34:46,000
Você pode escrever isso por nós?

491
00:34:46,000 --> 00:34:51,000
Salvá-lo aqui, e nós vamos puxar isso.

492
00:34:51,000 --> 00:34:56,000
Nós estamos olhando para essa linha 9,

493
00:34:56,000 --> 00:34:59,000
e nós estamos percebendo que nós não queremos comparar a agulha para o ponto médio,

494
00:34:59,000 --> 00:35:03,000
mas em vez disso, queremos comparar a agulha

495
00:35:03,000 --> 00:35:07,000
para o elemento no ponto médio posição dentro de nossa matriz palheiro.

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

497
00:35:10,000 --> 00:35:12,000
Lá vamos nós.

498
00:35:12,000 --> 00:35:15,000
Sim, isso parece muito bom, se (== agulha palheiro [ponto médio]).

499
00:35:15,000 --> 00:35:18,000
Nós encontramos.

500
00:35:18,000 --> 00:35:22,000
Agora, se executar o código de volta we'll-se um pouco-bit

501
00:35:22,000 --> 00:35:26,000
ele compila, ele é executado, e agora se olharmos para 4,

502
00:35:26,000 --> 00:35:30,000
não encontramos, porque agora estamos realmente começando a número 23.

503
00:35:30,000 --> 00:35:33,000
Nós estamos recebendo o valor de 23, e é isso que estamos comparando a nossa agulha.

504
00:35:33,000 --> 00:35:35,000
Mas isso é bom. Esse é um passo na direção certa.

505
00:35:35,000 --> 00:35:37,000
>> Isso é o que estamos tentando fazer.

506
00:35:37,000 --> 00:35:40,000
Nós não estamos tentando comparar a agulha contra posições na matriz

507
00:35:40,000 --> 00:35:44,000
mas sim contra os elementos reais da matriz.

508
00:35:44,000 --> 00:35:49,000
Se olharmos para trás novamente, agora na próxima etapa em nosso algoritmo,

509
00:35:49,000 --> 00:35:51,000
qual é o próximo passo?

510
00:35:51,000 --> 00:35:57,000
Leila já mencionado brevemente.

511
00:35:57,000 --> 00:36:00,000
[Estudante] Verifique se é maior ou menor do que e, em seguida, decidir qual o caminho a se mover.

512
00:36:00,000 --> 00:36:03,000
[Nate] Sim, então como é que vamos fazer isso?

513
00:36:03,000 --> 00:36:07,000
Você pode colocar em algum eu vou-salvar esta revisão,

514
00:36:07,000 --> 00:36:13,000
e, em seguida, se você colocar em algumas linhas que vai fazer isso.

515
00:36:13,000 --> 00:36:15,000
Sim, Charlotte. >> Eu tenho uma pergunta.

516
00:36:15,000 --> 00:36:19,000
Caso não seja ponto médio - 1, porque a primeira coisa é

517
00:36:19,000 --> 00:36:26,000
é 0 indexados, por isso, se nós colocamos 4, que não é realmente o personagem que está procurando?

518
00:36:26,000 --> 00:36:30,000
Sim, e o outro problema com que se-

519
00:36:30,000 --> 00:36:35,000
isso é uma grande captura, porque o que vai acabar acontecendo, possivelmente,

520
00:36:35,000 --> 00:36:42,000
se manter em movimento e nós nunca ajustar inicialmente?

521
00:36:42,000 --> 00:36:46,000
Eu acho que o que pode acabar fazendo é tentando acessar

522
00:36:46,000 --> 00:36:49,000
o elemento na posição 8 da matriz,

523
00:36:49,000 --> 00:36:53,000
que neste caso não existe.

524
00:36:53,000 --> 00:36:56,000
Vamos querer fazer algum tipo de contabilidade para o fato de

525
00:36:56,000 --> 00:36:59,000
que temos uma indexação zero.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Desculpe, eu quis dizer ponto médio - 1 entre colchetes.

527
00:37:05,000 --> 00:37:08,000
Nós podemos fazer isso.

528
00:37:08,000 --> 00:37:10,000
Voltaremos a esta questão em um pouco.

529
00:37:10,000 --> 00:37:13,000
Uma vez que começam a chegar ao looping real,

530
00:37:13,000 --> 00:37:16,000
que é quando nós vamos realmente ver isso entrar em jogo.

531
00:37:16,000 --> 00:37:21,000
Por enquanto, não podemos fazer isso, mas você está totalmente certo.

532
00:37:21,000 --> 00:37:28,000
Que a indexação zero terá um efeito que é preciso explicar.

533
00:37:28,000 --> 00:37:30,000
Vamos ver.

534
00:37:30,000 --> 00:37:34,000
>> Como é a maior e menor do que-?

535
00:37:34,000 --> 00:37:36,000
[Estudante] eu chegar a fazer o maior e menor do que a parte.

536
00:37:36,000 --> 00:37:41,000
Eu só não tinha certeza do que imprimir, se você achar que é menos do que o ponto médio palheiro ou superior.

537
00:37:41,000 --> 00:37:43,000
Aqui eu posso salvar o que I've-

538
00:37:43,000 --> 00:37:47,000
[Nate] Sim, se você salvar o que você tem, e nós vamos puxá-lo para cima.

539
00:37:47,000 --> 00:37:49,000
Lá vamos nós.

540
00:37:49,000 --> 00:37:51,000
[Estudante] E eu colocar pontos de interrogação para o que eu não sabia.

541
00:37:51,000 --> 00:37:54,000
[Nate] que parece ótimo.

542
00:37:54,000 --> 00:37:58,000
Aqui nós temos pontos de interrogação, porque ainda não sei

543
00:37:58,000 --> 00:38:06,000
o que nós vamos fazer muito ainda.

544
00:38:06,000 --> 00:38:12,000
O que nós queremos fazer-oops, temos algumas chaves tudo funky em nós.

545
00:38:12,000 --> 00:38:15,000
Vamos corrigir essas chaves.

546
00:38:15,000 --> 00:38:19,000
Lá vamos nós.

547
00:38:19,000 --> 00:38:22,000
E então o que nós queremos fazer, de acordo com o nosso algoritmo,

548
00:38:22,000 --> 00:38:27,000
se não encontrar a agulha?

549
00:38:27,000 --> 00:38:32,000
Dizer no caso em que a agulha é menor do que o que estamos olhando. Kevin.

550
00:38:32,000 --> 00:38:34,000
Só olhar para a meia esquerda.

551
00:38:34,000 --> 00:38:40,000
Certo, então vamos colocar um comentário aqui que diz "olhe para meia esquerda."

552
00:38:40,000 --> 00:38:46,000
E se a agulha é maior do que o palheiro no ponto médio, o que nós queremos fazer?

553
00:38:46,000 --> 00:38:48,000
[Estudante] Então você olha para o lado direito.

554
00:38:48,000 --> 00:38:53,000
Olhe para o lado direito, "olhar para a metade direita."

555
00:38:53,000 --> 00:38:58,000
Nada mal.

556
00:38:58,000 --> 00:39:05,000
Ok, então, neste momento, as coisas estão muito bem.

557
00:39:05,000 --> 00:39:13,000
O problema com o código como está escrito é o que?

558
00:39:13,000 --> 00:39:15,000
[Estudante] Você não tem parâmetros para as metades.

559
00:39:15,000 --> 00:39:18,000
Certo, que não têm pontos de extremidade para as duas metades.

560
00:39:18,000 --> 00:39:20,000
Também está indo só para passar por isso uma vez.

561
00:39:20,000 --> 00:39:23,000
Só vamos olhar para um ponto médio.

562
00:39:23,000 --> 00:39:27,000
Ou o elemento está lá, ou não é.

563
00:39:27,000 --> 00:39:34,000
A fim de completar isso, vamos precisar fazer algum tipo de repetição.

564
00:39:34,000 --> 00:39:39,000
Precisamos manter repetindo até descobrimos que

565
00:39:39,000 --> 00:39:43,000
ou o elemento está lá porque nós reduzimos e, finalmente, encontrou,

566
00:39:43,000 --> 00:39:46,000
ou não está lá porque nós olhamos através de todas as coisas

567
00:39:46,000 --> 00:39:52,000
nas metades apropriadas da matriz e descobriu que nada está lá.

568
00:39:52,000 --> 00:39:56,000
>> Sempre que tenho essa repetição acontecendo, o que é que vamos usar?

569
00:39:56,000 --> 00:39:58,000
[Estudante] Um loop.

570
00:39:58,000 --> 00:40:00,000
Algum tipo de laço. Sim.

571
00:40:00,000 --> 00:40:03,000
[Estudante] Podemos fazer um loop do-while e tê-lo fazer isso e, enquanto

572
00:40:03,000 --> 00:40:10,000
a agulha não não é igual-Estou certo de onde eu estava indo com isso.

573
00:40:10,000 --> 00:40:18,000
Mas tipo como fazer isso, desde que não valoriza o igual que a entrada do usuário.

574
00:40:18,000 --> 00:40:21,000
Sim, então vamos ver, como isso pode escrever-se?

575
00:40:21,000 --> 00:40:23,000
Você disse que vamos usar um laço do-while.

576
00:40:23,000 --> 00:40:26,000
Onde é que o fazer de início?

577
00:40:26,000 --> 00:40:33,000
[Estudante] Logo após o tamanho / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Ok, eo que é que vamos fazer?

579
00:40:42,000 --> 00:40:44,000
Vamos preencher o tempo depois.

580
00:40:44,000 --> 00:40:46,000
O que vamos fazer?

581
00:40:46,000 --> 00:40:49,000
[Estudante] Não queremos fazer tudo o que temos na parte de se?

582
00:40:49,000 --> 00:40:52,000
[Nate] fazer tudo isso, ótimo.

583
00:40:52,000 --> 00:40:55,000
Copiar e colar.

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

585
00:40:59,000 --> 00:41:03,000
Vamos ver se isso funciona, se pudermos guia sobre isso.

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

587
00:41:08,000 --> 00:41:16,000
Ok, e salvar este para que vocês têm.

588
00:41:16,000 --> 00:41:21,000
Tudo bem, e nós vamos fazer isso enquanto-

589
00:41:21,000 --> 00:41:25,000
Qual era a condição, enquanto você estava depois?

590
00:41:25,000 --> 00:41:31,000
[Estudante] Enquanto a agulha não é igual, então como o ponto de exclamação.

591
00:41:31,000 --> 00:41:37,000
Mas eu não sei exatamente o que é ainda.

592
00:41:37,000 --> 00:41:39,000
[Nate] Sim, esta é uma maneira de fazê-lo.

593
00:41:39,000 --> 00:41:41,000
Sam, você tem um comentário?

594
00:41:41,000 --> 00:41:43,000
[Sam] me lembrei quando eu olhei para os vídeos,

595
00:41:43,000 --> 00:41:48,000
Eu tomei uma imagem de um dos o-como quando fizemos o pseudocódigo para ele,

596
00:41:48,000 --> 00:41:52,000
havia alguma relação entre max e min.

597
00:41:52,000 --> 00:41:58,000
Acho que foi algo como se o máximo é sempre menos de min.

598
00:41:58,000 --> 00:42:00,000
Entendi.

599
00:42:00,000 --> 00:42:04,000
[Sam] Ou como se Max não é inferior a min ou algo assim,

600
00:42:04,000 --> 00:42:06,000
porque isso significa que você pesquisou tudo.

601
00:42:06,000 --> 00:42:13,000
>> Sim, então o que é que soa como máximo e mínimo estavam se referindo?

602
00:42:13,000 --> 00:42:16,000
[Sam] valores que inteiros que vão mudar

603
00:42:16,000 --> 00:42:18,000
em relação a onde vamos colocar o ponto médio.

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

605
00:42:20,000 --> 00:42:24,000
[Sam] Nesse ponto, ele vai [inaudível] calcular o máximo e mínimo.

606
00:42:24,000 --> 00:42:29,000
Ponto médio é esta idéia de Max e min.

607
00:42:29,000 --> 00:42:35,000
Isso faz sentido para as pessoas?

608
00:42:35,000 --> 00:42:39,000
Se tivéssemos que começar a olhar para como nós vamos fazer essa iteração,

609
00:42:39,000 --> 00:42:43,000
você está totalmente certo que queremos usar algum tipo de do-while.

610
00:42:43,000 --> 00:42:49,000
Mas eu acho que, se lembrarmos o que está acontecendo no local dessa matriz

611
00:42:49,000 --> 00:42:53,000
eo que está realmente acontecendo! Vou escrever aqui-

612
00:42:53,000 --> 00:42:58,000
na primeira iteração de pesquisa binária, temos-

613
00:42:58,000 --> 00:43:05,000
Eu vou usar b e e para denotar o início.

614
00:43:05,000 --> 00:43:10,000
E então, o fim da nossa matriz.

615
00:43:10,000 --> 00:43:14,000
Sabemos que o começo é a 4 bem aqui,

616
00:43:14,000 --> 00:43:18,000
e nós sabemos que o fim está em 108.

617
00:43:18,000 --> 00:43:23,000
Dizer que estamos procurando o número 15.

618
00:43:23,000 --> 00:43:27,000
A primeira vez que fazemos isso, como vimos anteriormente,

619
00:43:27,000 --> 00:43:30,000
o ponto médio é ou vai ser 16 ou 23

620
00:43:30,000 --> 00:43:34,000
dependendo de como calcular as coisas.

621
00:43:34,000 --> 00:43:37,000
Desde uniformemente dividindo no meio nos daria este espaço

622
00:43:37,000 --> 00:43:42,000
entre 16 e 23, não é possível dividi-lo uniformemente

623
00:43:42,000 --> 00:43:47,000
ou dividi-lo e chegar a um ponto médio verdadeiro.

624
00:43:47,000 --> 00:43:49,000
Nós vamos olhar para 16.

625
00:43:49,000 --> 00:43:55,000
Nós vamos realizar "Ei, 16> 15, que estamos procurando."

626
00:43:55,000 --> 00:43:59,000
Para, em seguida, olhar para a metade esquerda da matriz

627
00:43:59,000 --> 00:44:03,000
o que vai acabar fazendo está descartando

628
00:44:03,000 --> 00:44:07,000
esta porção superior inteira

629
00:44:07,000 --> 00:44:16,000
e dizendo: "Ok, agora o nosso ponto final vai ser aqui."

630
00:44:16,000 --> 00:44:22,000
A próxima iteração do nosso circuito, agora estamos olhando para essa matriz,

631
00:44:22,000 --> 00:44:25,000
ter eliminado eficazmente esta porção, porque agora

632
00:44:25,000 --> 00:44:30,000
se estiver a tomar o ponto médio como sendo a diferença entre o início e o fim,

633
00:44:30,000 --> 00:44:34,000
encontramos nosso ponto médio para ser de 8,

634
00:44:34,000 --> 00:44:40,000
que pode então testar 8 para ver onde é em relação ao número que estamos procurando,

635
00:44:40,000 --> 00:44:44,000
15, acho que 15 é maior,

636
00:44:44,000 --> 00:44:49,000
por isso temos de passar para a parte direita da lista,

637
00:44:49,000 --> 00:44:51,000
que sabemos porque somos seres humanos, e podemos ver isso.

638
00:44:51,000 --> 00:44:54,000
Sabemos que a parte direita vai ser onde encontrá-lo,

639
00:44:54,000 --> 00:45:01,000
mas o computador não sabe que, assim que nós vamos fazer é que vai realmente

640
00:45:01,000 --> 00:45:04,000
ter este ir para cima, e agora o começo eo fim

641
00:45:04,000 --> 00:45:11,000
são o mesmo ponto, de modo que o ponto central torna-se o único número da lista, nesse ponto,

642
00:45:11,000 --> 00:45:16,000
que é de 15, e encontrou-o.

643
00:45:16,000 --> 00:45:21,000
Será que lançar alguma luz sobre onde este máximo toda e notação min vai,

644
00:45:21,000 --> 00:45:24,000
manter o controle dos pontos finais da matriz, a fim de descobrir

645
00:45:24,000 --> 00:45:35,000
como estreitar as coisas?

646
00:45:35,000 --> 00:45:42,000
>> O que aconteceria se não fosse igual a 15 agora?

647
00:45:42,000 --> 00:45:52,000
O que se estivéssemos olhando para 15 e, em vez disso, este número também foram 16?

648
00:45:52,000 --> 00:45:54,000
Nós diríamos, "Oh, é maior.

649
00:45:54,000 --> 00:45:57,000
Queremos voltar para a esquerda. "

650
00:45:57,000 --> 00:46:01,000
E nós mover a nossa e para a direita,

651
00:46:01,000 --> 00:46:06,000
em que ponto temos um terminal que seria conflitante.

652
00:46:06,000 --> 00:46:09,000
Não seria capaz de procurar qualquer mais elementos

653
00:46:09,000 --> 00:46:13,000
porque agora temos o nosso ponto final e nosso ponto de partida,

654
00:46:13,000 --> 00:46:16,000
o nosso máximo eo nosso min, estão agora viradas.

655
00:46:16,000 --> 00:46:23,000
Buscamos através de toda a matriz. Não consigo encontrar nada.

656
00:46:23,000 --> 00:46:27,000
Esse é o ponto em que nós queremos dizer: "Ok, vamos parar este algoritmo.

657
00:46:27,000 --> 00:46:34,000
Não encontramos nada. Nós sabemos que não está aqui. "

658
00:46:34,000 --> 00:46:36,000
Como é que isso vai?

659
00:46:36,000 --> 00:46:40,000
[Estudante] Como exatamente o computador mudar o final?

660
00:46:40,000 --> 00:46:45,000
Como o final acabar antes do início?

661
00:46:45,000 --> 00:46:48,000
O final acaba antes do início

662
00:46:48,000 --> 00:46:54,000
por causa da matemática que vamos fazer a cada vez que fazemos isso.

663
00:46:54,000 --> 00:47:00,000
A nossa forma de trocar é que se você olhar para a primeira vez que fazemos este swap

664
00:47:00,000 --> 00:47:03,000
em que tem início a 4 e a extremidade

665
00:47:03,000 --> 00:47:13,000
todo o caminho até a 108 e nosso ponto médio, digamos, em 16 -

666
00:47:13,000 --> 00:47:20,000
Eu estou indo para repor isso de volta para 15 se nós estamos olhando para o 15,

667
00:47:20,000 --> 00:47:25,000
sabíamos que o que fizemos quando fez a 16 e viu que era maior

668
00:47:25,000 --> 00:47:28,000
e queria descartar toda a parte direita da lista,

669
00:47:28,000 --> 00:47:36,000
vimos que o que nós queríamos fazer é mover este e aqui.

670
00:47:36,000 --> 00:47:44,000
Efetivamente, o e foi movido para um antes do ponto médio.

671
00:47:44,000 --> 00:47:48,000
Da mesma forma, quando fizemos esta iteração do algoritmo

672
00:47:48,000 --> 00:47:51,000
e o ponto médio era de 8,

673
00:47:51,000 --> 00:47:55,000
verificou-se que 8 <15, então nós queríamos para mover o b

674
00:47:55,000 --> 00:48:00,000
um passado do ponto médio.

675
00:48:00,000 --> 00:48:07,000
Agora, no início e no fim são os dois juntos no 15.

676
00:48:07,000 --> 00:48:10,000
>> Se tivéssemos sido acontecendo para procurar algum outro valor, e não 15,

677
00:48:10,000 --> 00:48:14,000
ou se este 15 tinha sido uma vez 16,

678
00:48:14,000 --> 00:48:20,000
teríamos encontrado que o e queremos passar uma antes do ponto médio.

679
00:48:20,000 --> 00:48:33,000
Agora o e estaria lá capotou menos do que o b.

680
00:48:33,000 --> 00:48:39,000
Vamos examinar como podemos realmente acabar este algoritmo de codificação.

681
00:48:39,000 --> 00:48:44,000
Nós sabemos que nós queremos ter esse cálculo ponto médio.

682
00:48:44,000 --> 00:48:48,000
Sabemos também que pretende controlar o início e o fim da matriz

683
00:48:48,000 --> 00:48:51,000
de nossa matriz atual, para que possamos descobrir

684
00:48:51,000 --> 00:48:56,000
onde esta metade esquerda da lista é e onde a metade direita da lista é.

685
00:48:56,000 --> 00:49:03,000
Nós fazemos isso com um início e fim,

686
00:49:03,000 --> 00:49:07,000
ou podemos chamá-los de mínimo e máximo.

687
00:49:07,000 --> 00:49:10,000
Vou usar começar e terminar este tempo.

688
00:49:10,000 --> 00:49:15,000
Quando começamos, se olharmos para o nosso exemplo aqui,

689
00:49:15,000 --> 00:49:20,000
nosso começo foi definida para o início da matriz, como natural.

690
00:49:20,000 --> 00:49:25,000
O índice foi isso? O que deve ser a nossa começar?

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

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

693
00:49:30,000 --> 00:49:37,000
[Nate] Sim, então nós poderíamos defini-lo igual ao palheiro [0].

694
00:49:37,000 --> 00:49:40,000
O problema, no entanto, é que esta não nos dá a posição do primeiro elemento.

695
00:49:40,000 --> 00:49:45,000
Isso dá-nos o índice do primeiro elemento ou o valor real em que a primeira posição.

696
00:49:45,000 --> 00:49:47,000
[Estudante] Isso irá converter para 0,20?

697
00:49:47,000 --> 00:49:52,000
[Nate] O que isto vai fazer é, bem, ele não vai fazer qualquer conversão.

698
00:49:52,000 --> 00:49:56,000
O que ele vai fazer é que vai armazenar um 4 em começar,

699
00:49:56,000 --> 00:49:59,000
e depois será difícil fazer comparações contra começar

700
00:49:59,000 --> 00:50:03,000
porque begin vai realizar o valor de 4,

701
00:50:03,000 --> 00:50:06,000
que é o início de nossa matriz,

702
00:50:06,000 --> 00:50:08,000
mas queremos acompanhar os índices na matriz

703
00:50:08,000 --> 00:50:11,000
ao contrário dos valores.

704
00:50:11,000 --> 00:50:17,000
Nós vamos realmente usar a 0, assim.

705
00:50:17,000 --> 00:50:20,000
Para o final da matriz-Charlotte trouxe esta um pouco mais cedo.

706
00:50:20,000 --> 00:50:23,000
Este é o lugar onde nós vamos levar em conta a indexação zero.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, que é o final da matriz?

708
00:50:25,000 --> 00:50:28,000
O que é o índice da extremidade?

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

710
00:50:30,000 --> 00:50:32,000
Sim, e qual o tamanho que devemos usar?

711
00:50:32,000 --> 00:50:35,000
Devemos usar o tamanho de capital ou tamanho minúsculo?

712
00:50:35,000 --> 00:50:37,000
Tamanho Capital.

713
00:50:37,000 --> 00:50:42,000
Neste caso, poderíamos usar o tamanho de capital.

714
00:50:42,000 --> 00:50:45,000
Se quiséssemos esta função para ser portátil

715
00:50:45,000 --> 00:50:48,000
e use esta função em outros programas,

716
00:50:48,000 --> 00:50:50,000
nós podemos realmente usar o tamanho minúsculo.

717
00:50:50,000 --> 00:50:52,000
É bom também.

718
00:50:52,000 --> 00:51:01,000
Mas Charlotte é totalmente certo que queremos ter tamanho - 1.

719
00:51:01,000 --> 00:51:03,000
Neste ponto

720
00:51:03,000 --> 00:51:05,000
[Estudante] Como é que você pode usar o tamanho maiúscula?

721
00:51:05,000 --> 00:51:07,000
Como é que nós poderíamos usar tamanho maiúscula?

722
00:51:07,000 --> 00:51:13,000
Acontece que estes # define são realmente,

723
00:51:13,000 --> 00:51:19,000
sob o capô, um texto como localizar e substituir, se isso faz sentido.

724
00:51:19,000 --> 00:51:24,000
Quando você compilar o código, a fase de pré-processamento

725
00:51:24,000 --> 00:51:27,000
do compilador passa o arquivo,

726
00:51:27,000 --> 00:51:31,000
e olha para todos os lugares que você escreveu tamanho capital,

727
00:51:31,000 --> 00:51:39,000
e substitui o texto, literalmente, com um 8, apenas como aquele.

728
00:51:39,000 --> 00:51:42,000
Nesse sentido, isso é muito diferente de uma variável.

729
00:51:42,000 --> 00:51:45,000
Ele não ocupa espaço na memória.

730
00:51:45,000 --> 00:51:52,000
É um truque simples substituição de texto.

731
00:51:52,000 --> 00:51:57,000
Neste caso, vamos usar o tamanho.

732
00:51:57,000 --> 00:52:01,000
A partir daqui, quero fazer algum tipo de repetição,

733
00:52:01,000 --> 00:52:03,000
e que estamos no caminho certo com nosso laço do-while.

734
00:52:03,000 --> 00:52:08,000
Queremos fazer algo até que uma condição não mais se,

735
00:52:08,000 --> 00:52:12,000
e como vimos anteriormente, vimos que essa condição

736
00:52:12,000 --> 00:52:19,000
era de fato que nós não queremos o fim

737
00:52:19,000 --> 00:52:24,000
ser menor do que a começar.

738
00:52:24,000 --> 00:52:26,000
>> Esta é a nossa condição de parada.

739
00:52:26,000 --> 00:52:35,000
Se isso ocorrer, nós queremos parar e declarar como "Ei, mas não encontramos nada."

740
00:52:35,000 --> 00:52:43,000
Para expressar isso, nós queremos usar algum tipo de laço.

741
00:52:43,000 --> 00:52:49,000
Neste caso, seria um loop do-while, um loop, loop de um tempo?

742
00:52:49,000 --> 00:52:51,000
Nós temos um laço do-while aqui.

743
00:52:51,000 --> 00:52:53,000
Você caras como essa abordagem?

744
00:52:53,000 --> 00:52:59,000
Você acha que devemos tentar uma abordagem diferente?

745
00:52:59,000 --> 00:53:01,000
Kevin, todos os pensamentos?

746
00:53:01,000 --> 00:53:06,000
Nós poderíamos ter um loop while porque sabemos máximo

747
00:53:06,000 --> 00:53:11,000
seria maior do que a de qualquer maneira min iniciais.

748
00:53:11,000 --> 00:53:14,000
Sim, por isso não há inicialização que precisa acontecer.

749
00:53:14,000 --> 00:53:17,000
Aqueles laços fazer enquanto-são grandes quando você tem algo para inicializar

750
00:53:17,000 --> 00:53:21,000
antes depois testar, enquanto aqui

751
00:53:21,000 --> 00:53:26,000
sabemos que não vamos manter reinitializing tanto começar e terminar

752
00:53:26,000 --> 00:53:28,000
cada volta do loop.

753
00:53:28,000 --> 00:53:32,000
Nós sabemos que nós queremos para inicializá-los, em seguida, verificar a nossa condição.

754
00:53:32,000 --> 00:53:38,000
Neste caso, eu realmente ir com um loop while simples.

755
00:53:38,000 --> 00:53:44,000
Acontece que fazer enquanto loops são usados ​​bastante raro.

756
00:53:44,000 --> 00:53:49,000
Um monte de lugares nem mesmo ensinam que enquanto loops.

757
00:53:49,000 --> 00:53:53,000
Eles são bons para lidar com a entrada do usuário, de modo que temos visto muitos deles até agora.

758
00:53:53,000 --> 00:53:59,000
Mas normal para e enquanto laços são muito mais comuns.

759
00:53:59,000 --> 00:54:03,000
Acontece que essa condição como escrito

760
00:54:03,000 --> 00:54:09,000
não vai realmente fazer-nos muito bem, e por que isso?

761
00:54:09,000 --> 00:54:11,000
Sinto muito, eu não sei o seu nome.

762
00:54:11,000 --> 00:54:13,000
Estou Jerry. >> Desculpa?

763
00:54:13,000 --> 00:54:15,000
B é-O-R-L-I.

764
00:54:15,000 --> 00:54:18,000
Ah, ok.

765
00:54:18,000 --> 00:54:23,000
Eu não vejo você na minha lista.

766
00:54:23,000 --> 00:54:26,000
Ah, é porque, oh, isso faz sentido.

767
00:54:26,000 --> 00:54:31,000
Você tem uma idéia de por que isso loop while pode não funcionar como pretendido,

768
00:54:31,000 --> 00:54:38,000
como escrito com a condição?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Quer dizer, como você quer todo o material depois de no-?

770
00:54:43,000 --> 00:54:46,000
Sim, então essa é uma.

771
00:54:46,000 --> 00:54:49,000
Talvez tenhamos de colocar todas essas coisas para o loop while, o que é totalmente verdade.

772
00:54:49,000 --> 00:54:55,000
A outra coisa que é um pouco mais problemático, porém, é que esta condição não funciona.

773
00:54:55,000 --> 00:54:57,000
[Estudante] Você precisa lançá-lo.

774
00:54:57,000 --> 00:55:04,000
Certo, então esta condição não será sempre verdade, inicialmente a maneira que nós conversamos sobre isso.

775
00:55:04,000 --> 00:55:08,000
Queremos fazer algo até <final começar,

776
00:55:08,000 --> 00:55:13,000
mas nós queremos fazer algo enquanto

777
00:55:13,000 --> 00:55:21,000
começar no fim ≤.

778
00:55:21,000 --> 00:55:24,000
>> Há que a inversão da lógica de lá.

779
00:55:24,000 --> 00:55:27,000
Eu sou culpado de cometer esses erros o tempo todo.

780
00:55:27,000 --> 00:55:31,000
[Student] Por que tem de ser menor ou igual a?

781
00:55:31,000 --> 00:55:33,000
Porque você se lembra do caso que temos que

782
00:55:33,000 --> 00:55:36,000
onde havia apenas um elemento, e fomos para baixo,

783
00:55:36,000 --> 00:55:43,000
e nós estávamos olhando apenas o 15 em nossa matriz?

784
00:55:43,000 --> 00:55:47,000
E o nosso começo e nosso fim fosse o mesmo elemento.

785
00:55:47,000 --> 00:55:50,000
Nós queremos ter certeza de que lidamos com esse caso.

786
00:55:50,000 --> 00:55:54,000
Se fizéssemos uma reta menor que,

787
00:55:54,000 --> 00:55:58,000
que só seria capaz de descer a uma matriz de dois elementos.

788
00:55:58,000 --> 00:56:06,000
Assim que desceu para último elemento que, se fosse esse o nosso elemento, nós nunca encontrá-lo.

789
00:56:06,000 --> 00:56:10,000
Agora, aqui, podemos fazer exatamente o que você estava dizendo.

790
00:56:10,000 --> 00:56:15,000
Podemos começar plopping coisas bem no meio do nosso loop while.

791
00:56:15,000 --> 00:56:20,000
Podemos plop no nosso ponto médio.

792
00:56:20,000 --> 00:56:24,000
Podemos tomar todas estas declarações se,

793
00:56:24,000 --> 00:56:30,000
retirá-los deste laço do-while,

794
00:56:30,000 --> 00:56:34,000
plop-los,

795
00:56:34,000 --> 00:56:39,000
limpar as coisas um pouco,

796
00:56:39,000 --> 00:56:48,000
e eu vou em frente e salvar esta revisão.

797
00:56:48,000 --> 00:56:53,000
E, neste ponto, estamos ficando muito perto.

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

799
00:56:55,000 --> 00:56:58,000
Eu acho que você também tem que ter ponto médio int = tamanho - 1/2.

800
00:56:58,000 --> 00:57:01,000
Peguei tamanho - 1/2.

801
00:57:01,000 --> 00:57:05,000
Há mais alguma coisa que precisamos mudar sobre essa linha?

802
00:57:05,000 --> 00:57:10,000
Isso foi uma boa captura.

803
00:57:10,000 --> 00:57:14,000
>> O que o tamanho faz? Estamos sempre mudando de tamanho?

804
00:57:14,000 --> 00:57:17,000
A fim de manter a linha como este, temos que mudar o tamanho.

805
00:57:17,000 --> 00:57:21,000
Temos que mudar o tamanho cada vez que volta para o laço.

806
00:57:21,000 --> 00:57:25,000
Mas lembre-se, quando estávamos passando por nosso exemplo um pouco mais cedo,

807
00:57:25,000 --> 00:57:30,000
e tivemos o início a 4

808
00:57:30,000 --> 00:57:33,000
e no final todo o caminho em 108?

809
00:57:33,000 --> 00:57:35,000
Como calculamos o ponto médio?

810
00:57:35,000 --> 00:57:38,000
Estávamos usando o tamanho?

811
00:57:38,000 --> 00:57:40,000
Ou estávamos usando começam e terminam em vez disso?

812
00:57:40,000 --> 00:57:42,000
É a diferença entre a extremidade e o início.

813
00:57:42,000 --> 00:57:50,000
Exatamente, e exatamente como eu deveria escrever que, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Basta finalizar - começar.

815
00:57:52,000 --> 00:57:55,000
Você não precisa fazer a - 1

816
00:57:55,000 --> 00:57:58,000
porque a - 1, foi incluída no final e a começar já.

817
00:57:58,000 --> 00:58:00,000
[Nate] Ótimo, você está totalmente certo.

818
00:58:00,000 --> 00:58:03,000
Nós não temos que fazer o - um porque - uma foi incluído

819
00:58:03,000 --> 00:58:08,000
e contabilizados quando inicializar a variável final.

820
00:58:08,000 --> 00:58:11,000
>> Há mais alguma coisa que eu preciso fazer para ter sintaticamente esta linha faz sentido?

821
00:58:11,000 --> 00:58:13,000
[Estudante] Além disso começar. >> Além disso começar?

822
00:58:13,000 --> 00:58:15,000
[Estudante] No final.

823
00:58:15,000 --> 00:58:20,000
Porque é calculado apenas metade do comprimento.

824
00:58:20,000 --> 00:58:26,000
Você precisa adicionar a começar.

825
00:58:26,000 --> 00:58:31,000
[Nate] O que este cálculo para nós?

826
00:58:31,000 --> 00:58:35,000
Se pensarmos sobre o fim desta primeira iteração do loop,

827
00:58:35,000 --> 00:58:40,000
final vai ser no índice de posição 7.

828
00:58:40,000 --> 00:58:43,000
Comece está na posição 0.

829
00:58:43,000 --> 00:58:47,000
Lembre-se, nós estamos olhando para qualquer

830
00:58:47,000 --> 00:58:52,000
posição 3 ou da posição 4.

831
00:58:52,000 --> 00:58:56,000
Se olharmos para essa matemática, apenas para torná-lo um pouco mais tangível,

832
00:58:56,000 --> 00:59:02,000
colocar alguns números aqui, temos 7, 0,

833
00:59:02,000 --> 00:59:10,000
para 7-0, e depois / 2

834
00:59:10,000 --> 00:59:19,000
é 3 na divisão inteira, o que é.

835
00:59:19,000 --> 00:59:26,000
Então precisamos então adicionar de volta o nosso começar?

836
00:59:26,000 --> 00:59:28,000
Nós não fazer neste caso.

837
00:59:28,000 --> 00:59:31,000
Na primeira iteração, ele vai ficar bem, porque começar é 0.

838
00:59:31,000 --> 00:59:36,000
Mas à medida que avançamos, nós realmente só precisa de todos

839
00:59:36,000 --> 00:59:42,000
final - comece / 2.

840
00:59:42,000 --> 00:59:46,000
Há um outro truque aqui, e que é um saber de precedência.

841
00:59:46,000 --> 00:59:49,000
[Estudante] Precisamos de parênteses?

842
00:59:49,000 --> 00:59:53,000
[Nate] Exatamente, e isso é porque se não colocar esses parênteses,

843
00:59:53,000 --> 00:59:58,000
a seguir esta linha será interpretado em vez

844
00:59:58,000 --> 01:00:09,000
como (final) - (início / 2), que definitivamente não quer.

845
01:00:09,000 --> 01:00:11,000
Cuidado com as regras de precedência.

846
01:00:11,000 --> 01:00:15,000
[Estudante] Por que não é acabar + começar?

847
01:00:15,000 --> 01:00:17,000
Por que não é acabar + começar?

848
01:00:17,000 --> 01:00:19,000
[Estudante] Por que não é isso?

849
01:00:19,000 --> 01:00:24,000
Por que seria +?

850
01:00:24,000 --> 01:00:26,000
Eu acho que você está certo.

851
01:00:26,000 --> 01:00:28,000
[Estudante] Porque é a média?

852
01:00:28,000 --> 01:00:31,000
[Nate] + End começar, você está totalmente certo.

853
01:00:31,000 --> 01:00:34,000
Uau, eu totalmente gozado. Você está certo.

854
01:00:34,000 --> 01:00:39,000
Se estivéssemos fazendo o menos, gostaríamos de acrescentar a começar para trás dentro

855
01:00:39,000 --> 01:00:43,000
Neste caso, você é muito certo que queremos tomar a média dos dois,

856
01:00:43,000 --> 01:00:45,000
assim que nós queremos para adicioná-los, ao invés de subtrair-los.

857
01:00:45,000 --> 01:00:49,000
[Estudante] Isso também funciona se você fez final - começar / 2 + começar.

858
01:00:49,000 --> 01:00:55,000
Seria se não fizermos-Acredito que sim.

859
01:00:55,000 --> 01:01:00,000
>> Por exemplo, se estivéssemos olhando para começar,

860
01:01:00,000 --> 01:01:04,000
e mudamos isso aqui

861
01:01:04,000 --> 01:01:08,000
ao 15.

862
01:01:08,000 --> 01:01:12,000
Agora é começar na posição 2.

863
01:01:12,000 --> 01:01:15,000
Final é na posição 7.

864
01:01:15,000 --> 01:01:21,000
Se subtrair-los, temos 5.

865
01:01:21,000 --> 01:01:24,000
Divida isso por dois, temos 2.

866
01:01:24,000 --> 01:01:27,000
E, então, adicionar 2 de volta,

867
01:01:27,000 --> 01:01:30,000
e que nos leva para a posição 4,

868
01:01:30,000 --> 01:01:33,000
que está aqui, que é o ponto médio.

869
01:01:33,000 --> 01:01:36,000
[Estudante] Precisamos cuidar de embrulho?

870
01:01:36,000 --> 01:01:39,000
Em que sentido é que precisamos cuidar de embrulho?

871
01:01:39,000 --> 01:01:43,000
Se a soma ou a diferença entre

872
01:01:43,000 --> 01:01:45,000
dependendo da forma como o fazemos não é um número par.

873
01:01:45,000 --> 01:01:49,000
Em seguida, o computador fica confuso se quando é 2,5;

874
01:01:49,000 --> 01:01:52,000
se você se mover para a esquerda ou para a direita para determinar qual é o ponto médio?

875
01:01:52,000 --> 01:01:54,000
Entendi.

876
01:01:54,000 --> 01:01:56,000
Acontece que com a divisão inteira,

877
01:01:56,000 --> 01:01:59,000
nós nunca obter esses números de ponto flutuante.

878
01:01:59,000 --> 01:02:01,000
Nós nunca obter o decimal.

879
01:02:01,000 --> 01:02:04,000
É totalmente descartada.

880
01:02:04,000 --> 01:02:08,000
Se você tem um computador dividir duas variáveis ​​int

881
01:02:08,000 --> 01:02:11,000
e uma é 7, e o outro é 2,

882
01:02:11,000 --> 01:02:13,000
você não vai ter como resultado 3,5.

883
01:02:13,000 --> 01:02:16,000
Ele vai ficar 3.

884
01:02:16,000 --> 01:02:19,000
O restante será descartado, por isso é efetivamente arredondamento

885
01:02:19,000 --> 01:02:24,000
Nem um, mas sim um chão, se vocês estão familiarizados com que, em matemática,

886
01:02:24,000 --> 01:02:27,000
onde descartar completamente a decimal,

887
01:02:27,000 --> 01:02:31,000
e por isso você está, essencialmente, truncando-lo para o mais próximo

888
01:02:31,000 --> 01:02:33,000
posições, para o número inteiro mais próximo.

889
01:02:33,000 --> 01:02:38,000
[Estudante] Mas então isso é problemático porque se você tem um conjunto de sete elementos

890
01:02:38,000 --> 01:02:43,000
em seguida, que assume automaticamente o elemento 3 para fora do ponto central, em vez do 4.

891
01:02:43,000 --> 01:02:46,000
Como lidar com isso?

892
01:02:46,000 --> 01:02:49,000
É problemático porque se tivéssemos uma matriz de 7,

893
01:02:49,000 --> 01:02:54,000
ele iria pegar o terceiro lugar do quarto.

894
01:02:54,000 --> 01:02:56,000
Poderia explicar um pouco mais?

895
01:02:56,000 --> 01:02:59,000
[Estudante] Porque se você tem 7 elementos, então o elemento 4

896
01:02:59,000 --> 01:03:04,000
seria o ponto médio, certo?

897
01:03:04,000 --> 01:03:07,000
Lembre-se seu comentário sobre ser zero indexados, no entanto.

898
01:03:07,000 --> 01:03:10,000
[Estudante] Sim, então na posição 3. Esse seria o ponto médio.

899
01:03:10,000 --> 01:03:12,000
Sim.

900
01:03:12,000 --> 01:03:16,000
Ah, ok. Eu vejo o que você quer dizer.

901
01:03:16,000 --> 01:03:19,000
É meio estranho, como se acostumar com esta noção de

902
01:03:19,000 --> 01:03:22,000
livrar-se de casas decimais.

903
01:03:22,000 --> 01:03:26,000
Isso é um grande ponto.

904
01:03:26,000 --> 01:03:30,000
Vamos acabar com isso.

905
01:03:30,000 --> 01:03:32,000
Nós calculamos o ponto médio.

906
01:03:32,000 --> 01:03:37,000
>> Estamos testando para ver se a nossa agulha é igual ao valor médio.

907
01:03:37,000 --> 01:03:41,000
Estamos imprimindo que encontramos, mas realmente, o que nós queremos fazer nesta situação?

908
01:03:41,000 --> 01:03:46,000
Descobrimos que, por isso queremos que o chamador saiba que nós encontramos.

909
01:03:46,000 --> 01:03:49,000
Nós temos uma função que é uma função booleana digitado.

910
01:03:49,000 --> 01:03:54,000
A nossa forma de sinalizar para o chamador de nossa função de que estamos prontos para ir

911
01:03:54,000 --> 01:03:58,000
é que dizemos: "Ei, isso é verdade."

912
01:03:58,000 --> 01:04:00,000
Como poderíamos fazer isso, Kevin?

913
01:04:00,000 --> 01:04:02,000
Você está acenando com a cabeça. >> [Kevin] retorno Adicionar verdade.

914
01:04:02,000 --> 01:04:06,000
[Nate] Exatamente, retornar true.

915
01:04:06,000 --> 01:04:12,000
Agora, se não é igual, como é que olhamos para o lado esquerdo?

916
01:04:12,000 --> 01:04:16,000
Alguma idéia?

917
01:04:16,000 --> 01:04:18,000
Stella, alguma idéia?

918
01:04:18,000 --> 01:04:21,000
Você precisa definir uma nova posição para o final.

919
01:04:21,000 --> 01:04:23,000
Sim.

920
01:04:23,000 --> 01:04:29,000
Então, nós temos que fazer a posição de ponto médio - o fim.

921
01:04:29,000 --> 01:04:33,000
Grande.

922
01:04:33,000 --> 01:04:36,000
Precisamos definir uma nova posição para o final

923
01:04:36,000 --> 01:04:38,000
olhar para a metade esquerda.

924
01:04:38,000 --> 01:04:41,000
Isso foi o que falamos antes, onde

925
01:04:41,000 --> 01:04:44,000
Eu continuo voltando para este exemplo.

926
01:04:44,000 --> 01:04:50,000
Tenho a começar aqui, e então eu tenho o fim de tudo até aqui.

927
01:04:50,000 --> 01:04:53,000
>> Mais uma vez, se nós estamos olhando para 15, e nosso ponto médio é de 16 anos,

928
01:04:53,000 --> 01:04:56,000
e percebemos, "Oops, 16 é maior.

929
01:04:56,000 --> 01:04:59,000
Queremos passar para a meia esquerda. "

930
01:04:59,000 --> 01:05:02,000
Nós, então, passar o fim do 15,

931
01:05:02,000 --> 01:05:06,000
e fazemos isso tomando um longe do ponto médio

932
01:05:06,000 --> 01:05:09,000
e da definição que o nosso novo fim.

933
01:05:09,000 --> 01:05:12,000
Da mesma forma, se quisermos olhar para a metade direita, como é que vamos fazer isso?

934
01:05:12,000 --> 01:05:14,000
Você tem uma idéia?

935
01:05:14,000 --> 01:05:22,000
[Estudante] Você acabou de começar a definir ponto médio + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Grande.

937
01:05:24,000 --> 01:05:29,000
E agora no caso que nós não encontrar nada,

938
01:05:29,000 --> 01:05:32,000
não que ficar resolvido por nós?

939
01:05:32,000 --> 01:05:36,000
Daniel, isso se levados em conta, de para nós?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Não.

941
01:05:38,000 --> 01:05:40,000
[Nate] Se fizermos isso através da matriz inteira e não encontrar nada,

942
01:05:40,000 --> 01:05:42,000
onde teria que ser cuidado, ou devemos cuidar dela?

943
01:05:42,000 --> 01:05:44,000
[Daniel] A condição enquanto.

944
01:05:44,000 --> 01:05:48,000
[Nate] Sim, a condição de tempo, exatamente.

945
01:05:48,000 --> 01:05:51,000
Ele vai cuidar de passar por toda a matriz se não encontrar nada.

946
01:05:51,000 --> 01:05:53,000
Este loop while vai acabar.

947
01:05:53,000 --> 01:05:56,000
Nós nunca terá encontrado esta condição,

948
01:05:56,000 --> 01:06:03,000
e podemos retornar falso.

949
01:06:03,000 --> 01:06:10,000
Nós também pode deixar isso se aqui como esta

950
01:06:10,000 --> 01:06:14,000
porque se esta afirmação é verdadeira se,

951
01:06:14,000 --> 01:06:16,000
e nossa função vai voltar,

952
01:06:16,000 --> 01:06:21,000
e assim nós vamos essencialmente abortar esta função neste momento

953
01:06:21,000 --> 01:06:24,000
quando retornar true.

954
01:06:24,000 --> 01:06:28,000
Mas o que acontece com esta estrutura aqui?

955
01:06:28,000 --> 01:06:34,000
Será que isto vai funcionar totalmente, ou se há alguma falha lógica aí?

956
01:06:34,000 --> 01:06:37,000
>> Há alguma falha lógica lá, com a forma como ele é criado.

957
01:06:37,000 --> 01:06:40,000
O que pode ser?

958
01:06:40,000 --> 01:06:43,000
[Estudante] Por que você precisa - e + 1s?

959
01:06:43,000 --> 01:06:47,000
Que define a nossa matriz para ser nosso novo meia esquerda e meia direita.

960
01:06:47,000 --> 01:06:51,000
[Estudante] Mas por que você não poderia fazê-lo sem o - 1s e 1s +?

961
01:06:51,000 --> 01:06:53,000
[Nate] Nós podemos defini-lo igual ao ponto médio?

962
01:06:53,000 --> 01:07:04,000
O que pode ser problemático nisso?

963
01:07:04,000 --> 01:07:08,000
[Estudante] Eu acho que é ineficiente porque você está verificando um valor que já foi verificado.

964
01:07:08,000 --> 01:07:11,000
[Nate] Exatamente, por isso Sam é totalmente certo.

965
01:07:11,000 --> 01:07:15,000
Se você definir o fim eo início igual ao ponto médio

966
01:07:15,000 --> 01:07:18,000
em vez de - 1 e + 1 reflexivamente,

967
01:07:18,000 --> 01:07:22,000
em algum momento, no futuro, vai acabar verificar o ponto médio novamente.

968
01:07:22,000 --> 01:07:26,000
[Estudante] eu comecei a pset, e então eu tive algo parecido

969
01:07:26,000 --> 01:07:30,000
onde eu esqueci o 1 +, e ele ficou preso em um loop infinito.

970
01:07:30,000 --> 01:07:34,000
Certo, porque em algum momento você nunca vai se começar e terminar

971
01:07:34,000 --> 01:07:39,000
que realmente se sobrepõem.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Há mais uma falha lógica, e isso é que este deve ser definitivamente

974
01:07:44,000 --> 01:07:48,000
uma pessoa se.

975
01:07:48,000 --> 01:07:55,000
Por que poderia ser?

976
01:07:55,000 --> 01:07:59,000
>> A razão é que não é uma pessoa se-você viu isso, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Sim, porque você está mudando o ponto final.

978
01:08:02,000 --> 01:08:05,000
[Nate] Exatamente.

979
01:08:05,000 --> 01:08:07,000
Estamos mudando o ponto final,

980
01:08:07,000 --> 01:08:12,000
e se for escrito assim we'll-criar espaços entre-

981
01:08:12,000 --> 01:08:14,000
ele irá verificar este caso.

982
01:08:14,000 --> 01:08:18,000
Neste caso, se for bem sucedido, irá abortar fora da função.

983
01:08:18,000 --> 01:08:21,000
Em seguida, ele irá verificar este caso seguinte,

984
01:08:21,000 --> 01:08:24,000
e se esta for bem sucedida, irá ajustar o ponto final,

985
01:08:24,000 --> 01:08:28,000
e depois continuará e verifique neste caso.

986
01:08:28,000 --> 01:08:31,000
Mas neste momento, não quer que ele continue a verificar.

987
01:08:31,000 --> 01:08:35,000
Felizmente, não temos redefinir o ponto central aqui,

988
01:08:35,000 --> 01:08:39,000
e sabemos que este caso não terá sucesso.

989
01:08:39,000 --> 01:08:44,000
Mas nós definitivamente queremos colocar o outro se lá

990
01:08:44,000 --> 01:08:48,000
apesar de que poderia em caso esta

991
01:08:48,000 --> 01:08:52,000
uma vez que não está ajustando o ponto médio, teria que fazer a diferença?

992
01:08:52,000 --> 01:08:54,000
Não, porque todos estes casos são exclusivas.

993
01:08:54,000 --> 01:08:58,000
Mais uma vez, foi mal.

994
01:08:58,000 --> 01:09:01,000
Não, eu acho, preciso disso mais se.

995
01:09:01,000 --> 01:09:05,000
Nós podemos dar-lhe uma tentativa e executá-lo e ver o que acontece.

996
01:09:05,000 --> 01:09:08,000
Edifício, um erro ocorreu.

997
01:09:08,000 --> 01:09:12,000
Provavelmente é porque eu deixei estes de b e e, em aqui.

998
01:09:12,000 --> 01:09:14,000
Eu tenho mais daqueles no topo?

999
01:09:14,000 --> 01:09:16,000
Ele não se parece com ele.

1000
01:09:16,000 --> 01:09:20,000
Nós zoom out, construir,

1001
01:09:20,000 --> 01:09:24,000
lá vai, agora se procurar 15,

1002
01:09:24,000 --> 01:09:28,000
Sim.

1003
01:09:28,000 --> 01:09:30,000
Deixe-me fazer zoom in

1004
01:09:30,000 --> 01:09:33,000
15, sim. Nós podemos executá-lo novamente.

1005
01:09:33,000 --> 01:09:36,000
Upload de código-fonte, a construção, em execução.

1006
01:09:36,000 --> 01:09:41,000
Podemos procurar por algo como 13,

1007
01:09:41,000 --> 01:09:45,000
e nós não temos nada de imprimir, por isso não está descobrindo que para nós.

1008
01:09:45,000 --> 01:09:51,000
Isso é ótimo, porque ele não está em nossa lista.

1009
01:09:51,000 --> 01:09:53,000
>> Estamos agora fora do tempo.

1010
01:09:53,000 --> 01:09:55,000
Isso vai ser ele para esta semana.

1011
01:09:55,000 --> 01:10:00,000
Obrigado por se juntar, e vê-lo mais tarde.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]