1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Problema Seção Set 2: Edição Hacker

2
00:00:02,670 --> 00:00:04,910
Rob Bowden, Universidade de Harvard

3
00:00:04,910 --> 00:00:07,410
Este é CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Então, eu sou Rob. Eu sou um sênior em Kirkland. Este é o meu terceiro ano TFing CS50.

5
00:00:15,770 --> 00:00:22,220
É a primeira vez que estamos a mudar a partir da seção tradicional palestra de estilo,

6
00:00:22,220 --> 00:00:25,610
onde só tipo de rever o que aconteceu na aula e depois vocês fazem perguntas,

7
00:00:25,610 --> 00:00:32,250
agora a ser muito mais baseada em problemas, onde usamos os espaços, e -

8
00:00:32,250 --> 00:00:37,410
Ah, então a idéia é ir para o link que lhe enviei e então você vai estar no meu espaço.

9
00:00:37,410 --> 00:00:42,410
Será que ninguém tem um laptop? Okay.

10
00:00:42,410 --> 00:00:47,050
Então nós vamos estar usando isso, e nós vamos estar fazendo problemas viver em seção

11
00:00:47,050 --> 00:00:50,740
e discuti-los e descobrir o que está errado

12
00:00:50,740 --> 00:00:56,390
e eu poderia puxar um pouco do seu código, e eu poderia discutir suas idéias.

13
00:00:56,390 --> 00:01:02,140
Então, tem alguém tinha dificuldade?

14
00:01:02,140 --> 00:01:07,000
Você pode conversar sobre o lado, eu não sei se nós vamos ter razão para isso.

15
00:01:07,000 --> 00:01:12,270
Agora, como o supersection anterior, se você estava na classe, você sabe do que se trata.

16
00:01:12,270 --> 00:01:19,200
Em todos os conjuntos P não vai ser essas seções.

17
00:01:19,200 --> 00:01:22,550
Assim, a P-2 set, especificações, eu acho que você viu na P-1 conjunto já.

18
00:01:22,550 --> 00:01:27,400
Mas podemos olhar para a P-2 set para o que nós vamos estar passando por cima hoje.

19
00:01:27,400 --> 00:01:29,460
E você vai ver uma seção de perguntas.

20
00:01:29,460 --> 00:01:37,530
Então, isso vai ser em todos os P-sets, haverá uma seção de perguntas.

21
00:01:37,530 --> 00:01:41,340
Até agora, disse, "Considere isso uma oportunidade de praticar."

22
00:01:41,340 --> 00:01:44,940
Você não será convidado a apresentar este programa.

23
00:01:44,940 --> 00:01:48,480
A idéia é que estas se destinam a espécie de ajudar você a começar com o conjunto de problemas.

24
00:01:48,480 --> 00:01:53,220
Eu acho que na edição Hacker, muitos deles são supostos ser apenas coisas novas e interessantes para aprender.

25
00:01:53,220 --> 00:01:58,590
Eles podem não ser diretamente aplicável ao conjunto de problemas.

26
00:01:58,590 --> 00:02:01,810
E agora nós não estamos tendo de enviá-los, mas, em teoria,

27
00:02:01,810 --> 00:02:07,480
para conjuntos de problemas posteriores, você pode enviá-los e, assim, você pode vir a seção

28
00:02:07,480 --> 00:02:10,380
ou assistir a seção para obter as respostas, ou você pode simplesmente levá-los em seu próprio país

29
00:02:10,380 --> 00:02:16,350
se você não se sentir como desfrutar da minha presença.

30
00:02:16,350 --> 00:02:21,010
Assim, o - Eu acho que essa é a primeira.

31
00:02:21,010 --> 00:02:29,280
Oh. Além disso, nestas seções de perguntas também temos que fazer perguntas sobre os shorts.

32
00:02:29,280 --> 00:02:33,440
Então eu acho que, em teoria, você deveria prestar atenção a estes antes de chegar a seção,

33
00:02:33,440 --> 00:02:38,550
mas tudo bem se você não faz, nós vamos passar por cima deles de qualquer maneira.

34
00:02:38,550 --> 00:02:42,590
Assim, podemos começar com estas: "Como é que um loop while diferem de um loop do-tempo?

35
00:02:42,590 --> 00:02:46,210
Quando é o último particularmente útil? "

36
00:02:46,210 --> 00:02:49,390
Então, alguém tem alguma -?

37
00:02:49,390 --> 00:02:52,730
[Aluno] O do-while sempre executado pelo menos uma vez.

38
00:02:52,730 --> 00:03:02,950
Sim. Então essa é a diferença. Um loop while - eu só faço isso aqui - enquanto loop, temos a condição

39
00:03:02,950 --> 00:03:19,760
aqui, enquanto que um do-tempo, você não tem uma condição até chegarmos aqui.

40
00:03:19,760 --> 00:03:24,130
E assim, quando o programa está em execução, e fica para o loop while,

41
00:03:24,130 --> 00:03:26,380
imediatamente verifica se esta condição for verdadeira.

42
00:03:26,380 --> 00:03:30,710
Se essa condição não é verdade, ela só vai pular o ciclo completo.

43
00:03:30,710 --> 00:03:34,390
Do-while, como o programa é executado, ele chega ao "fazer".

44
00:03:34,390 --> 00:03:37,920
Nada acontece neste momento, apenas continua executando.

45
00:03:37,920 --> 00:03:42,690
Então, quando ele atinge o "tempo", se a condição for verdadeira, vai loop de volta e fazê-lo de novo

46
00:03:42,690 --> 00:03:46,730
e de novo e de novo até que a condição não é verdade e, em seguida, apenas através de quedas.

47
00:03:46,730 --> 00:03:50,600
Assim, a diferença é que este pode pular desde o início.

48
00:03:50,600 --> 00:03:56,770
Isto necessariamente executa uma vez e então poderá executar mais vezes se a condição ainda é verdade.

49
00:03:56,770 --> 00:04:03,720
Assim, o loop while irá fazê-lo apenas uma vez, ou - o loop while - não pode precisar fazê-lo em tudo,

50
00:04:03,720 --> 00:04:07,900
desde logo que chegar a ele, se a condição for falsa, vamos pular sobre ele.

51
00:04:07,900 --> 00:04:11,770
Considerando-enquanto loop, vamos executá-lo uma vez, necessariamente.

52
00:04:11,770 --> 00:04:14,560
Depois, quando chegarmos à condição, vamos verificar se é verdadeira ou falsa.

53
00:04:14,560 --> 00:04:19,790
Se é verdade, nós vamos fazer isso de novo, se ele é falso, vamos continuar indo.

54
00:04:19,790 --> 00:04:24,680
Então, quando é o último particularmente útil?

55
00:04:24,680 --> 00:04:31,190
Então eu posso dizer que no conjunto dos 4 anos, 3 anos, qualquer que seja,

56
00:04:31,190 --> 00:04:38,780
que eu tenho programado, eu usei isso, como, menos de 10 vezes.

57
00:04:38,780 --> 00:04:43,140
E, provavelmente, cinco deles estão em CS50 quando estamos introduzindo fazer enquanto-loops.

58
00:04:43,140 --> 00:04:47,510
Então, quando você usou loops do-while?

59
00:04:47,510 --> 00:04:49,510
Quando é o - sim?

60
00:04:49,510 --> 00:04:53,180
[Estudante] Quando você está tentando obter a entrada do usuário, ou algo que você deseja verificar -

61
00:04:53,180 --> 00:04:59,700
Sim. Então faça-while, a entrada do usuário é um dos grandes.

62
00:04:59,700 --> 00:05:03,160
É por isso que os conjuntos de problemas primeiro par, quando você quer perguntar ao usuário, como,

63
00:05:03,160 --> 00:05:08,520
"Dê-me uma corda," você não pode continuar até chegar essa cadeia.

64
00:05:08,520 --> 00:05:12,980
E para que você, necessariamente, precisa perguntar para a cadeia pelo menos uma vez.

65
00:05:12,980 --> 00:05:16,950
Mas então, se eles respondem algo ruim, então você precisa para fazer um loop para trás e perguntar novamente.

66
00:05:16,950 --> 00:05:20,810
Mas diferente do que a entrada do usuário, é muito raro que eu encontro um caso

67
00:05:20,810 --> 00:05:27,170
onde eu quero loop "pelo menos uma vez", mas possivelmente mais.

68
00:05:27,170 --> 00:05:33,370
Perguntas ou -? Alguém já usou um do-while em outro lugar?

69
00:05:33,370 --> 00:05:36,780
Okay. Então o próximo é: "O que não declarado identificador

70
00:05:36,780 --> 00:05:43,310
geralmente indicam se emitido pelo bumbum? "

71
00:05:43,310 --> 00:05:47,380
Então, que tipo de código que eu poderia escrever para obter 'identificador não declarado?

72
00:05:47,380 --> 00:05:49,550
[Estudante] que x = 2?

73
00:05:49,550 --> 00:05:52,650
Assim, podemos apenas experimentá-lo aqui, x = 2.

74
00:05:52,650 --> 00:06:04,830
Vamos fazer isso - oh, eu não clique nele. Então aqui nós temos - todos os direitos.

75
00:06:04,830 --> 00:06:07,100
"O uso de x identificador não declarado".

76
00:06:07,100 --> 00:06:11,610
Então esse é o identificador não declarado, uma variável.

77
00:06:11,610 --> 00:06:13,910
Ele vai com freqüência chamar um identificador de uma variável.

78
00:06:13,910 --> 00:06:17,300
Por isso, talvez não saiba é realmente uma variável, que não sabe o que é.

79
00:06:17,300 --> 00:06:19,380
Então, é um identificador.

80
00:06:19,380 --> 00:06:26,060
Então por que é não declarado? Sim.

81
00:06:26,060 --> 00:06:32,190
Então, para ser claro sobre a terminologia, a declaração de uma variável

82
00:06:32,190 --> 00:06:37,360
é quando você diz "int x" ou "y", seqüência que seja.

83
00:06:37,360 --> 00:06:41,910
A inicialização da variável, ou a atribuição de variável,

84
00:06:41,910 --> 00:06:44,510
é sempre que você diz "x = 2".

85
00:06:44,510 --> 00:06:52,950
Assim, podemos fazer isso em etapas separadas, int x, x = 2, e até - nós podemos ter um monte de coisas aqui dentro -

86
00:06:52,950 --> 00:07:00,350
mas até esta linha acontece, x ainda é inicializado, mas ele foi declarado.

87
00:07:00,350 --> 00:07:06,760
E assim podemos, obviamente, fazê-lo em uma linha, e agora estamos declarando e inicializando.

88
00:07:06,760 --> 00:07:10,730
Perguntas?

89
00:07:10,730 --> 00:07:18,390
E, finalmente, "Por que não é a cifra de César muito seguro?"

90
00:07:18,390 --> 00:07:23,830
Então, primeiro, que alguém quer dizer que a cifra de César é?

91
00:07:23,830 --> 00:07:28,100
[Estudante] Caesar Cipher apenas é que você mapear, você muda cada letra,

92
00:07:28,100 --> 00:07:34,420
um determinado número de letras passar por cima, e passar por cima, e não é muito seguro porque

93
00:07:34,420 --> 00:07:42,260
há apenas 26 opções possíveis e você só tem que tentar cada uma das pessoas, até você conseguir.

94
00:07:42,260 --> 00:07:45,470
Oh. Então, eu devo repetir?

95
00:07:45,470 --> 00:07:51,600
A cifra de César, é - Quero dizer, você estará lidando com ele sobre os problemas que você -

96
00:07:51,600 --> 00:07:56,110
ou eu acho que a edição padrão do conjunto de problemas que não está na edição hacker.

97
00:07:56,110 --> 00:08:01,550
Então, na edição padrão para o conjunto de problemas, você receberá uma mensagem do tipo: "Olá, mundo",

98
00:08:01,550 --> 00:08:08,410
e você também tem um número como 6, e você levar essa mensagem, e cada personagem individualmente,

99
00:08:08,410 --> 00:08:11,310
você girá-lo por seis posições no alfabeto.

100
00:08:11,310 --> 00:08:16,560
Assim, a 'h' em Olá ficaria h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Então, a primeira letra seria n. Nós fazemos a mesma coisa com e.

102
00:08:19,600 --> 00:08:23,530
Se temos um, como, z ou algo assim, então nós envolvemos a volta a 'um'.

103
00:08:23,530 --> 00:08:29,280
Mas cada personagem recebe ciclo 6 caracteres no final do alfabeto, e não é muito seguro

104
00:08:29,280 --> 00:08:35,440
uma vez que existem apenas 26 possibilidades de quantas maneiras você poderia envolver uma única letra.

105
00:08:35,440 --> 00:08:42,919
Então você pode apenas tentar todas as 26 deles e, presumivelmente, de uma mensagem suficientemente longo,

106
00:08:42,919 --> 00:08:46,860
apenas um desses possíveis 26 coisas vai ser legíveis,

107
00:08:46,860 --> 00:08:50,300
eo legível vai ser a mensagem original.

108
00:08:50,300 --> 00:08:56,240
Portanto, não é uma boa forma de criptografar nada.

109
00:08:56,240 --> 00:08:59,070
Alheios a essas shorts, "O que é uma função?"

110
00:08:59,070 --> 00:09:03,370
Então, o que é uma função? Sim.

111
00:09:03,370 --> 00:09:11,640
[Estudante] É como se um pedaço de código que você pode chamar para passar e, em seguida, obter o valor de retorno de qualquer coisa.

112
00:09:11,640 --> 00:09:18,160
Sim. Então, eu vou responder por também responder a seguinte - ou a repetição por também apenas responder a próxima.

113
00:09:18,160 --> 00:09:22,410
Você pode usar funções em vez de apenas copiar e colar o código uma e outra vez.

114
00:09:22,410 --> 00:09:27,200
Basta ter o código, coloque-o em um fuction, e então você pode apenas chamar a função

115
00:09:27,200 --> 00:09:29,870
onde quer que tenha sido copiar e colar.

116
00:09:29,870 --> 00:09:33,350
Assim, as funções são úteis.

117
00:09:33,350 --> 00:09:35,860
Então agora nós vamos fazer problemas reais.

118
00:09:35,860 --> 00:09:46,490
O primeiro. Assim, a idéia de que a primeira é, você passa uma string, e independentemente da -

119
00:09:46,490 --> 00:09:52,060
ou que ele diz em letras minúsculas? Ela não diz que todas as letras minúsculas.

120
00:09:52,060 --> 00:09:57,730
Portanto, a mensagem pode ser qualquer coisa, e - oh não. Ele faz.

121
00:09:57,730 --> 00:10:01,610
"Para simplificar, você pode assumir que o usuário apenas a entrada letras minúsculas e espaços."

122
00:10:01,610 --> 00:10:08,180
Então nós passar uma mensagem com apenas letras minúsculas e então alternar

123
00:10:08,180 --> 00:10:15,450
entre capital e minúsculas - que alterar a seqüência de ser capital e minúsculas, alternando.

124
00:10:15,450 --> 00:10:22,920
Então, antes de dar-lhe um segundo para até mergulhar no problema,

125
00:10:22,920 --> 00:10:32,420
qual é a primeira coisa que temos de fazer?

126
00:10:32,420 --> 00:10:36,900
Oh, o que eu basta clicar em? Oh, eu só clicou em um e-mail aqui.

127
00:10:36,900 --> 00:10:42,870
Então a primeira coisa que precisamos fazer - estou a olhar para a pessoa errada?

128
00:10:42,870 --> 00:10:49,320
Isso é parte de um presente?

129
00:10:49,320 --> 00:10:51,320
Não, essas são ainda está lá, no entanto.

130
00:10:51,320 --> 00:10:55,160
Ok, ainda está aqui.

131
00:10:55,160 --> 00:11:03,160
Agora não podemos assumir -? Sim. Aqui não podemos assumir que é apenas minúsculas e espaços.

132
00:11:03,160 --> 00:11:07,770
Então, agora temos que lidar com o fato de que as cartas pode ser o que nós queremos que eles sejam.

133
00:11:07,770 --> 00:11:11,910
E assim, a primeira coisa que queremos fazer é apenas receber a mensagem.

134
00:11:11,910 --> 00:11:19,790
Nós apenas precisamos de ter uma string, string s = GetString, ok.

135
00:11:19,790 --> 00:11:24,890
Agora este problema, existem algumas maneiras de fazê-lo.

136
00:11:24,890 --> 00:11:29,840
Mas vamos querer usar operadores bit a bit aqui.

137
00:11:29,840 --> 00:11:35,280
Há pessoas que ou não estavam no supersection,

138
00:11:35,280 --> 00:11:37,480
ou algo assim, e não sei o que são operadores bit a bit?

139
00:11:37,480 --> 00:11:41,710
Ou como eles se relacionam com ASCII de alguma forma?

140
00:11:41,710 --> 00:11:45,650
[Estudante] Eu não estava no supersection, mas eu sei o que os operadores bit a bit são.

141
00:11:45,650 --> 00:11:49,560
Okay. Então eu não tenho que passar por cima dos princípios deles, mas eu vou explicar

142
00:11:49,560 --> 00:11:51,830
o que vamos querer usar aqui.

143
00:11:51,830 --> 00:11:59,680
Então 'A': Representação binária de capital A, o número é de 65.

144
00:11:59,680 --> 00:12:07,560
Eu só vou olhar - 41 vai ser 01000001.

145
00:12:07,560 --> 00:12:14,170
De modo que deve ser de 65 em decimal, pelo que esta é a representação binária do caráter de capital A.

146
00:12:14,170 --> 00:12:19,440
Agora, a representação binária do personagem minúsculas 'a'

147
00:12:19,440 --> 00:12:33,350
vai ser a mesma coisa, ou quase. É que - 6, sim. Isso é certo.

148
00:12:33,350 --> 00:12:37,670
A capital de modo binário minúsculas, binário 'um'.

149
00:12:37,670 --> 00:12:43,940
Então, observe que a diferença entre A e 'a' é este único bit.

150
00:12:43,940 --> 00:12:49,440
E esta passa a ser a de 32 bits, o bit que representa o número 32.

151
00:12:49,440 --> 00:12:53,910
E isso faz sentido, já que A é de 65; 'a' é 97.

152
00:12:53,910 --> 00:12:56,610
A diferença entre eles é 32.

153
00:12:56,610 --> 00:13:03,770
Portanto, agora sabemos que podemos converter de A a 'a', tomando um

154
00:13:03,770 --> 00:13:09,710
e bit a bit ORing-lo, com - que se parece com um 1.

155
00:13:09,710 --> 00:13:20,900
Este é um OR bit a bit, com 00100000, e que vai nos dar "um".

156
00:13:20,900 --> 00:13:26,850
E podemos começar a partir de 'a' a A por bitwise AND

157
00:13:26,850 --> 00:13:33,700
com 11, 0 naquele lugar, 11111.

158
00:13:33,700 --> 00:13:43,840
Então, isso vai então dar-nos exatamente o que 'a', mas cancelar este bit individual,

159
00:13:43,840 --> 00:13:50,070
por isso vamos ter 01000001, eu não sei se eu contei direito.

160
00:13:50,070 --> 00:13:56,750
Mas esta técnica de bit a bit ORing para começar a partir de capital para minúsculas,

161
00:13:56,750 --> 00:14:02,080
e bit a bit AND para começar a partir de minúsculas para o capital não é exclusivo para A.

162
00:14:02,080 --> 00:14:06,510
Todas as letras, K vs k, Z vs z,

163
00:14:06,510 --> 00:14:10,080
todos eles estão indo só para variar por este único bit.

164
00:14:10,080 --> 00:14:16,290
E assim você pode usar isso para mudar de qualquer letra minúscula para qualquer letra maiúscula e vice-versa.

165
00:14:16,290 --> 00:14:26,670
Okay. Assim, uma maneira fácil de obter a partir deste - assim, em vez de ter que

166
00:14:26,670 --> 00:14:32,170
escrever o que quer que 1011111 é - uma maneira fácil de representar este número, e isso não é uma

167
00:14:32,170 --> 00:14:39,710
que eu fui no supersection, mas til (~) é outro operador bit a bit.

168
00:14:39,710 --> 00:14:42,520
O que faz é ~ olha para a representação de bits.

169
00:14:42,520 --> 00:14:45,630
Vamos dar qualquer número.

170
00:14:45,630 --> 00:14:53,130
Este é apenas um número binário, e que ~ não é apenas inverte todos os bits.

171
00:14:53,130 --> 00:15:00,630
Portanto, esta foi a 1, agora a 0, isto é um 0, agora um 1, 010,100.

172
00:15:00,630 --> 00:15:08,320
Então isso é tudo ~ faz. Então, 32, vai ser o número - livrar-se de que -

173
00:15:08,320 --> 00:15:23,320
32 de modo que vai ser o número 00100000, e assim por ~ de esta vai ser

174
00:15:23,320 --> 00:15:29,980
este número até aqui que eu ANDed 'a' com.

175
00:15:29,980 --> 00:15:35,600
Será que todo mundo vê isso? Isso é muito comum, como quando você quer descobrir

176
00:15:35,600 --> 00:15:40,740
para coisas mais recentes que poderíamos estar vendo, quando queremos ver se -

177
00:15:40,740 --> 00:15:44,710
ou queremos tudo, cada conjunto único bit, exceto para um

178
00:15:44,710 --> 00:15:47,910
você tende a se ~ do pouco que nós não queremos definir.

179
00:15:47,910 --> 00:15:53,090
Então, não queremos que o conjunto de 32 bits, para que não ~ de 32.

180
00:15:53,090 --> 00:15:57,790
Okay. Assim, podemos usar todos aqueles aqui.

181
00:15:57,790 --> 00:16:03,000
Tudo bem, por isso é bom se você não estiver pronto, vamos andar lentamente ao longo juntos,

182
00:16:03,000 --> 00:16:11,870
ou andar sobre isso, então - por isso. Caminhe por isso.

183
00:16:11,870 --> 00:16:20,790
Portanto, temos nossa string, e queremos loop sobre cada personagem em que seqüência e fazer alguma coisa para ele.

184
00:16:20,790 --> 00:16:26,710
Então, como vamos varrer uma string? O que devemos usar?

185
00:16:26,710 --> 00:16:30,980
Eu não vou fazer isso aqui. Sim.

186
00:16:30,980 --> 00:16:42,940
Então, eu tenho o meu iterador, e ele disse isso, mas como eu sei quantos caracteres estão na cadeia?

187
00:16:42,940 --> 00:16:47,030
Strlen (s), então i + +.

188
00:16:47,030 --> 00:16:49,860
Então o que eu fiz aqui não é a melhor maneira de fazer as coisas.

189
00:16:49,860 --> 00:16:51,860
Alguém sabe por que?

190
00:16:51,860 --> 00:16:55,290
Porque você está verificando a linguagem da cadeia de cada vez.

191
00:16:55,290 --> 00:17:06,859
Então, nós vamos querer mover strlen, eu poderia dizer-se aqui, int tamanho = strlen (s),

192
00:17:06,859 --> 00:17:11,900
e, então, i <comprimento, e no caso de você não ter visto isso antes,

193
00:17:11,900 --> 00:17:20,410
Eu também poderia fazer int i = 0, comprimento = strlen (s).

194
00:17:20,410 --> 00:17:25,010
E assim, este é um pouco preferível, já que agora eu restringiu o âmbito

195
00:17:25,010 --> 00:17:29,150
do comprimento variável para apenas este laço 'for', em vez de declarar isso antes

196
00:17:29,150 --> 00:17:34,990
e que sempre existe, e no caso de você não pegou por que isso é ruim,

197
00:17:34,990 --> 00:17:39,410
ou porque o original era ruim, é - para começar no loop.

198
00:17:39,410 --> 00:17:43,380
Eu verifiquei a condição. É i <o comprimento de s?

199
00:17:43,380 --> 00:17:46,790
Assim, o comprimento de s, vamos trabalhar com "Olá" o tempo todo.

200
00:17:46,790 --> 00:17:49,670
Assim comprimento de s, h-e-l-l-o. O comprimento é 5.

201
00:17:49,670 --> 00:17:57,580
Então, i = 0 comprimento, é de 5, então eu não for <5, então o ciclo continua.

202
00:17:57,580 --> 00:18:02,750
Então vamos de novo. Nós verificamos a condição. É i <o comprimento do Olá?

203
00:18:02,750 --> 00:18:08,390
Então, vamos verificar o comprimento da Olá. H-e-l-l-o. Isso é 5; i não é <5, então continuamos novamente.

204
00:18:08,390 --> 00:18:13,330
Então, nós estamos calculando, contamos Olá, para cada iteração do loop,

205
00:18:13,330 --> 00:18:17,380
até pensei que nunca vai mudar, mas sempre vai ser 5.

206
00:18:17,380 --> 00:18:22,530
Então, lembre-se 5 na frente, e agora tudo está melhor.

207
00:18:22,530 --> 00:18:24,990
Então iteração sobre toda a cadeia.

208
00:18:24,990 --> 00:18:31,470
O que nós queremos fazer para cada caractere da cadeia?

209
00:18:31,470 --> 00:18:38,510
[Falando Estudante, ininteligível]

210
00:18:38,510 --> 00:18:47,000
Sim. Então, se o personagem é não-alfabéticos, então nós só queremos pular sobre ele.

211
00:18:47,000 --> 00:18:52,300
Porque nós só se preocupam com letras do alfabeto, não podemos capitalizar um número.

212
00:18:52,300 --> 00:19:10,850
Então, como podemos fazer isso? Portanto, a nossa condição, por isso, se queremos algo - verificar se é alfabética.

213
00:19:10,850 --> 00:19:14,060
Então, como podemos verificar isso?

214
00:19:14,060 --> 00:19:18,720
[Estudante] Você pode apenas usar a função é alfa.

215
00:19:18,720 --> 00:19:23,160
É que incluídos em qualquer um destes, ou qualquer incluem char.h, como ou algo assim?

216
00:19:23,160 --> 00:19:32,710
Não vamos usar a função é alfa, e usar o explícito - por isso temos s [i],

217
00:19:32,710 --> 00:19:40,460
que é o personagem do oitavo s, lembre-se que uma string é uma matriz de caracteres,

218
00:19:40,460 --> 00:19:43,180
assim que o caráter oitavo de s.

219
00:19:43,180 --> 00:19:49,280
Agora, se é uma letra maiúscula, sabemos que ele tem que estar em uma faixa específica.

220
00:19:49,280 --> 00:19:54,370
E o que é que vão?

221
00:19:54,370 --> 00:20:07,860
Sim. Então, se s [i] é ≥ 65, e s [i] é ≤ 90, o que devo fazer em vez disso?

222
00:20:07,860 --> 00:20:18,470
Sim. Então, você nunca deve absolutamente precisa mesmo de saber os valores ASCII de qualquer coisa sempre.

223
00:20:18,470 --> 00:20:25,640
Nunca pense que dos 65 números, 90, 97 e 102, ou seja o que for.

224
00:20:25,640 --> 00:20:32,470
Você não precisa - 112 - você não precisa saber os a todos. Isso é errado também.

225
00:20:32,470 --> 00:20:41,940
Só usar os caracteres single-quote, constantes aspas simples. Assim, "A" e menos de 90 é 'Z.'

226
00:20:41,940 --> 00:20:47,930
E este é significativamente melhor - eu não sei em cima da minha cabeça que Z é 90.

227
00:20:47,930 --> 00:20:52,690
Eu sei em cima da minha cabeça que 'Z' é a capital Z.

228
00:20:52,690 --> 00:21:02,100
Então, enquanto este está na faixa de capital de um para o capital Z, ou podemos verificar minúsculas,

229
00:21:02,100 --> 00:21:17,010
Ou se é na faixa de ≥ 'a' e ≤ z.

230
00:21:17,010 --> 00:21:19,010
Então essa é a nossa condição.

231
00:21:19,010 --> 00:21:22,520
O estilo de onde colocar essas coisas varia.

232
00:21:22,520 --> 00:21:29,520
Eu vou fazer isso assim.

233
00:21:29,520 --> 00:21:31,520
Agora, o que nós queremos fazer?

234
00:21:31,520 --> 00:21:39,530
Sabemos que esta carta é um personagem, um caractere alfabético.

235
00:21:39,530 --> 00:21:46,270
Portanto, temos de alternar entre se esta agora deve ser uma letra maiúscula ou uma letra minúscula.

236
00:21:46,270 --> 00:21:48,820
Como podemos acompanhar o que que quer que seja?

237
00:21:48,820 --> 00:21:55,520
[Vozes estudantis, ininteligível]

238
00:21:55,520 --> 00:21:59,150
Então, sim, mas deixe-me verificar.

239
00:21:59,150 --> 00:22:04,910
Módulo 0-2 foi dito, foi uma sugestão jogado fora, e eu concordo com isso.

240
00:22:04,910 --> 00:22:11,780
Exceto aviso de que, como - é este o caso? Sim.

241
00:22:11,780 --> 00:22:18,270
É cada um dos outros, mas não podemos módulo 2 do i, ou i mod 2, pois

242
00:22:18,270 --> 00:22:22,950
E perceber que é capital e 'a' é minúscula? Mas há um espaço que os separa?

243
00:22:22,950 --> 00:22:27,150
Então, eles vão ser o mesmo mod 2, mas são casos diferentes.

244
00:22:27,150 --> 00:22:29,150
[Pergunta do estudante, ininteligível]

245
00:22:29,150 --> 00:22:34,690
Sim. Então, nós estamos indo só para manter uma contagem.

246
00:22:34,690 --> 00:22:38,730
Nós também poderia fazer isso aqui, se quiséssemos, que pode ter um pouco pesado

247
00:22:38,730 --> 00:22:41,300
no de declarações de laço, eu vou colocá-lo aqui.

248
00:22:41,300 --> 00:22:48,840
Então, int count = começa em 0.

249
00:22:48,840 --> 00:22:54,070
E agora, eu vou contar quantos caracteres alfabéticos que tivemos.

250
00:22:54,070 --> 00:22:59,550
Então, nós estamos, inevitavelmente, vai contar + +, uma vez que encontrou um outro caractere alfabético.

251
00:22:59,550 --> 00:23:09,130
Mas, até agora você está dizendo que se mod contagem de 2.

252
00:23:09,130 --> 00:23:12,590
Então, o que se contagem mod 2? Oh. Eu vou fazer == 0 para agora.

253
00:23:12,590 --> 00:23:21,740
Também vamos passar por cima disso. Então, se a contagem de mod 2 == 0, então o que?

254
00:23:21,740 --> 00:23:27,830
[Os alunos de resposta, ininteligível]

255
00:23:27,830 --> 00:23:32,750
Então, nós queremos que ele acabe maiúsculas.

256
00:23:32,750 --> 00:23:37,520
Há dois casos; maiúsculas e minúsculas são os dois casos.

257
00:23:37,520 --> 00:23:40,990
Então, se estamos em minúsculas precisamos torná-lo maiúsculas.

258
00:23:40,990 --> 00:23:43,710
Se é maiúsculo, não precisamos fazer nada.

259
00:23:43,710 --> 00:23:50,760
Mas, há uma maneira - não devem ter virado -

260
00:23:50,760 --> 00:23:54,800
que não precisa mesmo de verificar se é maiúscula ou minúscula?

261
00:23:54,800 --> 00:24:02,240
O que podemos fazer para sempre certificar-se de que sempre acabam em maiúscula?

262
00:24:02,240 --> 00:24:07,830
Então, observe o que fizemos para minúsculas 'a', o que se fez a mesma coisa exata para maiúsculas A?

263
00:24:07,830 --> 00:24:11,900
Uma mudança faz maiúsculas, ou a alteração de valor?

264
00:24:11,900 --> 00:24:23,100
Sim. Assim, qualquer letra maiúscula bitwise ANDed com ~ 32 vai ser esse personagem maiúsculo mesmo

265
00:24:23,100 --> 00:24:29,220
porque para qualquer caractere maiúsculo o bit 32 não está definido.

266
00:24:29,220 --> 00:24:40,920
Então, se nós queremos trazer o personagem s [i], queremos que ele se torne minúscula ou maiúscula.

267
00:24:40,920 --> 00:24:46,890
Então, se era minúscula, agora é maiúscula, se era maiúscula, ainda é maiúsculo, e que é isso.

268
00:24:46,890 --> 00:24:54,290
Eu disse isso no supersection: Você pode usar 32 se você quiser, mas eu tendem a preferir fazer 'a' - A,

269
00:24:54,290 --> 00:25:01,150
em vez de apenas 32 liso, porque pode ser qualquer outro bit.

270
00:25:01,150 --> 00:25:03,610
Após o bit 32, que pode ser qualquer um destes, ou não teríamos suficiente

271
00:25:03,610 --> 00:25:05,840
números para representar todos os caracteres.

272
00:25:05,840 --> 00:25:09,110
Então, se você pegar o de 32 bits, que poderia ser o de 64 bits, que poderia ser a de 128 bits.

273
00:25:09,110 --> 00:25:13,990
Qualquer desses bits pode ser o pouco que faz a distinção entre maiúsculas e minúsculas.

274
00:25:13,990 --> 00:25:18,350
Eu não precisa saber que é o de 32 bits.

275
00:25:18,350 --> 00:25:27,130
I Pode utilizar esta 'a' - A para obter o bit que é diferente entre os dois

276
00:25:27,130 --> 00:25:33,000
sem a necessidade de contar com o número mágico que é 32.

277
00:25:33,000 --> 00:25:38,770
E agora, mais contar era estranho, e então o que eu quero fazer?

278
00:25:38,770 --> 00:25:43,920
[Respostas dos alunos, ininteligível]

279
00:25:43,920 --> 00:25:45,920
[Estudante] O que é isso?

280
00:25:45,920 --> 00:25:49,850
Vou fazê-lo em um segundo.

281
00:25:49,850 --> 00:25:55,690
Então, agora, se eu quiser - eu quero ter certeza que o personagem é agora minúsculas,

282
00:25:55,690 --> 00:26:04,140
e assim eu posso ou por 32, 32 e significado 'a' - A.

283
00:26:04,140 --> 00:26:06,510
Mas aviso, o mesmo raciocínio que o anterior, que se

284
00:26:06,510 --> 00:26:11,670
a letra já era minúscula, seguida por 32 ORing apenas mantém minúsculas.

285
00:26:11,670 --> 00:26:16,220
Ele não mudou o caráter original.

286
00:26:16,220 --> 00:26:19,910
Mas agora eu não tenho que evitar dizer: "Se é minúscula, apenas esquecê-lo,

287
00:26:19,910 --> 00:26:23,650
se é maiúscula, então alterá-lo. "

288
00:26:23,650 --> 00:26:26,900
É muito mais conveniente para fazer isso.

289
00:26:26,900 --> 00:26:33,190
[Estudante] Será que a estratégia da subtração do maiúsculas de minúsculas o trabalho se não fosse 32?

290
00:26:33,190 --> 00:26:35,330
Se era, tipo, 34 ou algo assim?

291
00:26:35,330 --> 00:26:41,840
Então, você precisa saber que a diferença entre os dois é -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Pode ser mais do que 1 bit, desde que todos os bits abaixo desta posição são as mesmas.

293
00:26:49,840 --> 00:26:58,500
Então, precisamos de pelo menos 26 caracteres - ou, existem 26 caracteres.

294
00:26:58,500 --> 00:27:04,590
Então, precisamos de pelo menos 26 números para representar a diferença -

295
00:27:04,590 --> 00:27:07,650
A diferença entre A e 'a' tem que ser de pelo menos 26,

296
00:27:07,650 --> 00:27:10,760
ou então não teria representado todos os números de capitais.

297
00:27:10,760 --> 00:27:18,630
Isso significa que A, se começarmos a 1, que vai usar todos esses bits,

298
00:27:18,630 --> 00:27:23,900
todos estes primeiros 5 bits, para representar tudo a Z.

299
00:27:23,900 --> 00:27:32,170
É por isso que o próximo bit, ou este bit, a próxima é a que escolheu para distinguir entre um e 'um'.

300
00:27:32,170 --> 00:27:40,930
Isso é também porque, na tabela ASCII, há cinco símbolos que separam letras maiúsculas de minúsculas.

301
00:27:40,930 --> 00:27:49,050
Desde que esses são os símbolos, o 5 extra que traz a 32 sendo a diferença entre eles.

302
00:27:49,050 --> 00:27:51,840
[Estudante] Então, nós poderíamos fazer isso, porque ASCII é projetado dessa forma.

303
00:27:51,840 --> 00:27:57,280
Sim. Mas ASCII - a diferença podia também ser ambos destes bits.

304
00:27:57,280 --> 00:28:12,040
Como, se um era 10000001, e 'a' 11100001 - eu me esqueça, o que for.

305
00:28:12,040 --> 00:28:18,100
Mas se fosse isso, então nós ainda poderia usar 'a' - A.

306
00:28:18,100 --> 00:28:22,650
É apenas agora a diferença entre A e 'a' é ainda estes dois bits.

307
00:28:22,650 --> 00:28:32,240
Eu acho que está escrito 48. É 32 + 64? Eu acho que é?

308
00:28:32,240 --> 00:28:40,160
Seria ainda 2 bits; cada personagem, como, Z e Z, K e K,

309
00:28:40,160 --> 00:28:45,160
eles ainda teriam os mesmos bits exatas definidas exceto para os dois bits.

310
00:28:45,160 --> 00:28:48,870
Então, enquanto isso é sempre verdade, independentemente de se estamos usando ASCII ou algum outro sistema,

311
00:28:48,870 --> 00:28:53,050
enquanto há apenas um determinado número de bits que são diferentes para cada personagem,

312
00:28:53,050 --> 00:28:55,050
em seguida, que funciona bem.

313
00:28:55,050 --> 00:29:06,110
É que 32 foi criado porque é o primeiro que poderia usar. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Eu tendem a preferir, caso você não tenha visto, se o bloco é somente uma única linha,

315
00:29:14,520 --> 00:29:24,280
você pode se livrar das chaves, de modo que tendem a preferir fazer isso.

316
00:29:24,280 --> 00:29:34,010
Além disso, você sabe como podemos fazer coisas como s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Você também pode fazer s [i] bitwise E = 32.

318
00:29:41,090 --> 00:29:46,400
E bit a bit OR = 32.

319
00:29:46,400 --> 00:29:51,490
Além disso, contam mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Então lembre-se que - eu não vou escrevê-lo - qualquer valor diferente de zero é verdadeiro, e 0 é falso.

321
00:30:00,900 --> 00:30:07,880
Assim, "se a contagem mod 2 == 0" é o mesmo que dizer "se não contar mod 2".

322
00:30:07,880 --> 00:30:11,580
Eu provavelmente teria apenas inverteu as linhas e disse: "se a contagem mod 2,

323
00:30:11,580 --> 00:30:15,350
que o OR 1, mais que o AND 1 ", de modo que eu não precisava do" não ".

324
00:30:15,350 --> 00:30:18,650
Mas isso funciona tão bem.

325
00:30:18,650 --> 00:30:25,660
E o que mais eu posso fazer aqui?

326
00:30:25,660 --> 00:30:29,060
Você pode combiná-los com ternário se você queria, mas, então, que tinha acabado de fazer as coisas mais confusas

327
00:30:29,060 --> 00:30:33,770
e provavelmente mais difícil de ler, por isso não vamos fazer isso.

328
00:30:33,770 --> 00:30:37,330
Alguém tem alguma sugestão?

329
00:30:37,330 --> 00:30:41,580
É que todo o problema pediu? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Então, se livrar dessas linhas vazias, agora vamos imprimir f,% s ser o único para cordas,

331
00:30:51,070 --> 00:30:56,620
Vamos imprimir f, s.

332
00:30:56,620 --> 00:30:59,330
Agora vamos executá-lo. Eu fiz algo de errado?

333
00:30:59,330 --> 00:31:03,200
Isso é um \ ", eu quero um n.

334
00:31:03,200 --> 00:31:07,840
Okay. Agora vamos executá-lo. Ele provavelmente vai gritar comigo.

335
00:31:07,840 --> 00:31:11,250
Strlen é string.h.

336
00:31:11,250 --> 00:31:14,290
Portanto, esta é a coisa agradável sobre Clang é mostra o que ele está,

337
00:31:14,290 --> 00:31:19,140
ao invés do GCC, que apenas diz: "Ei, você esqueceu algo, eu não sei o que era."

338
00:31:19,140 --> 00:31:29,220
Mas isso vai me dizer: "Você deve incluir string.h".

339
00:31:29,220 --> 00:31:32,130
Então eu não pedir nada, por isso não está dizendo nada.

340
00:31:32,130 --> 00:31:42,540
Mas vamos fazer o seu exemplo, "Obrigado 4 Adicione o".

341
00:31:42,540 --> 00:31:47,880
Isso parece certo. Hooray.

342
00:31:47,880 --> 00:31:52,370
Então, voltar para o seu principal, eu quase nunca fazem isso.

343
00:31:52,370 --> 00:31:57,110
É opcional. E principal é a única função para o qual é opcional.

344
00:31:57,110 --> 00:32:07,140
Se não retornar nada da principal, é assumido que você pretendia retornar 0.

345
00:32:07,140 --> 00:32:13,070
Perguntas?

346
00:32:13,070 --> 00:32:20,980
Okay. Portanto, agora o segundo problema.

347
00:32:20,980 --> 00:32:24,810
"Lembre-se da segunda palestra duas semanas de que a troca de valores 2 variáveis, passando

348
00:32:24,810 --> 00:32:30,780
essas duas variáveis ​​para uma função (mesmo se chamado swap) não é exatamente o trabalho, pelo menos não sem 'ponteiros' ".

349
00:32:30,780 --> 00:32:37,020
E ignorar os ponteiros até chegar a eles.

350
00:32:37,020 --> 00:32:40,070
Queremos trocar duas variáveis; nós não estamos usando uma função para fazer isso.

351
00:32:40,070 --> 00:32:43,410
Nós ainda vamos fazê-lo em principal como ele diz.

352
00:32:43,410 --> 00:32:48,360
Mas, para usar essas duas variáveis, não queremos usar uma variável temporária.

353
00:32:48,360 --> 00:32:50,770
Há duas maneiras de fazer isso.

354
00:32:50,770 --> 00:32:56,310
Você pode fazer isso usando seus operadores binários tradicionais.

355
00:32:56,310 --> 00:33:00,180
Então, alguém sabe uma maneira rápida e suja de fazer isso?

356
00:33:00,180 --> 00:33:07,650
Ele pode realmente ter um minuto de pensar. Se eu tiver -

357
00:33:07,650 --> 00:33:12,130
Vou definir o problema como se eles pedirem. Então, se eu tiver duas variáveis, A, que é apenas um inteiro

358
00:33:12,130 --> 00:33:17,800
que eles me dão, e B soma variável, que é um outro número inteiro que eu sou dado.

359
00:33:17,800 --> 00:33:22,700
Então, se eu tenho essas duas variáveis, agora eu quero trocá-los.

360
00:33:22,700 --> 00:33:31,550
O tradicional, usando seus operadores binários regulares, quer dizer, como +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Nem os operadores bitwise que atuam sobre binário.

362
00:33:36,630 --> 00:33:39,600
Então, usando -, +, ÷, e todos aqueles.

363
00:33:39,600 --> 00:33:52,980
Poderíamos trocar, fazendo algo como a = a + b, e b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Então, verificação de sanidade, e depois vamos ver por que isso funciona.

365
00:34:04,260 --> 00:34:13,320
Vamos dizer que a = 7, b = 3, então a + b que vai ser 10.

366
00:34:13,320 --> 00:34:18,820
Então, nós estamos agora definindo a = 10, e então nós estamos fazendo b = a - b.

367
00:34:18,820 --> 00:34:30,250
Então, nós estamos fazendo b = a - b, que vai ser 7, e b = a - b, novamente,

368
00:34:30,250 --> 00:34:38,650
ou a = a - b. Que vai ser 10-7 que é 3.

369
00:34:38,650 --> 00:34:44,850
Então, agora, corretamente, 'a' foi de 7, b foi de 3, e agora b é 7 e 'a' é 3.

370
00:34:44,850 --> 00:34:48,679
De modo que o tipo de faz sentido, 'a' é a combinação dos dois números.

371
00:34:48,679 --> 00:34:53,000
Neste ponto, 'a' é a combinação, e então nós estamos subtraindo a b original,

372
00:34:53,000 --> 00:34:56,860
e então nós estamos subtraindo o que era o original 'a'.

373
00:34:56,860 --> 00:35:01,150
Mas isso não funciona para todos os números.

374
00:35:01,150 --> 00:35:08,880
Para ver isto, vamos considerar um sistema, de modo que costumamos pensar em números inteiros como 32 bits.

375
00:35:08,880 --> 00:35:13,050
Vamos trabalhar em algo que é apenas como 4 bits.

376
00:35:13,050 --> 00:35:15,450
Espero que eu venha com um bom exemplo agora.

377
00:35:15,450 --> 00:35:18,680
Então, eu sei, isso vai ser fácil.

378
00:35:18,680 --> 00:35:26,720
Vamos dizer que os nossos dois números são 1111, e 1111, de modo que estamos em binário agora.

379
00:35:26,720 --> 00:35:34,630
Em decimais reais, se você quer pensar dessa forma, a. = 15 e b = 15

380
00:35:34,630 --> 00:35:37,630
E então nós esperamos que, depois de trocá-los - eles não tem sequer a ser os mesmos números,

381
00:35:37,630 --> 00:35:41,140
mas eu fiz isso dessa maneira.

382
00:35:41,140 --> 00:35:47,100
Vamos fazer não lhes os mesmos números. Vamos fazer 1111 e 0001.

383
00:35:47,100 --> 00:35:51,860
Então, a = 15 e b = 1.

384
00:35:51,860 --> 00:35:57,670
Depois que trocá-los, esperamos que 'a' para ser 1 e b para ser 15.

385
00:35:57,670 --> 00:36:01,780
Então, nosso primeiro passo é a = a + b.

386
00:36:01,780 --> 00:36:08,770
Nossos números são apenas 4 bits de largura, então 'um', que é 1111, + b, que é de 0001,

387
00:36:08,770 --> 00:36:16,780
vai acabar sendo 10.000, mas temos apenas 4 bits.

388
00:36:16,780 --> 00:36:22,540
Então, agora a = 0.

389
00:36:22,540 --> 00:36:34,080
E agora queremos definir b = a - b - na verdade, isso ainda funciona perfeitamente.

390
00:36:34,080 --> 00:36:39,630
a = a - vamos ver se isso funciona perfeitamente - b.

391
00:36:39,630 --> 00:36:53,720
Então, em seguida, b = 0 - 1, o que ainda seria 15, e, em seguida, a = a - b, o que seria um.

392
00:36:53,720 --> 00:36:56,210
Talvez isso não funciona.

393
00:36:56,210 --> 00:36:59,020
Eu sinto que há uma razão para ele não funciona com regular.

394
00:36:59,020 --> 00:37:06,400
Ok, então trabalhando com a suposição de que ele não funciona com as operações de binários regulares,

395
00:37:06,400 --> 00:37:15,040
e eu vou procurar - Eu Google para ver se isso é verdade.

396
00:37:15,040 --> 00:37:23,490
Então, nós queremos fazê-lo usando os operadores bit a bit, ea pista aqui é XOR.

397
00:37:23,490 --> 00:37:28,780
Assim, a introdução de XOR (^) se você não viu ainda.

398
00:37:28,780 --> 00:37:34,610
É, mais uma vez, um operador bit a bit por isso age pouco a pouco, e é -

399
00:37:34,610 --> 00:37:39,910
Se você tem os bits 0 e 1, então este será um.

400
00:37:39,910 --> 00:37:45,230
Se você tem os bits 1 e 0, vai ser um, você tem os bits 0 e 0 que vai ser 0,

401
00:37:45,230 --> 00:37:47,640
e se você tem os bits 1 e um vai ser 0.

402
00:37:47,640 --> 00:37:56,180
Então, é como OR. Se qualquer um dos bits forem verdadeiros, isto é, 1, mas ao contrário de OR, ele não pode ser os dois bits que são verdadeiras.

403
00:37:56,180 --> 00:37:59,320
Ou teria esta ser de 1, XOR teria este ser 0.

404
00:37:59,320 --> 00:38:02,250
Então nós vamos querer usar XOR aqui.

405
00:38:02,250 --> 00:38:09,960
Pense nisso por um minuto, eu vou ao Google.

406
00:38:09,960 --> 00:38:16,230
Bem, você não pode ler isso, eu estou atualmente na página algoritmo XOR swap.

407
00:38:16,230 --> 00:38:21,340
Esperemos que isto irá explicar por que eu não posso -

408
00:38:21,340 --> 00:38:34,190
Este é exatamente o algoritmo que acabamos de fazer.

409
00:38:34,190 --> 00:38:37,330
Eu ainda não sei por que - eu devo ter apenas escolheu um mau exemplo,

410
00:38:37,330 --> 00:38:44,940
mas neste caso, onde 'a' aconteceu para se tornar 0, depois de chegar ao 5 bits, por isso agora 'a' é 0,

411
00:38:44,940 --> 00:38:48,730
que é o que é chamado de "estouro de inteiro."

412
00:38:48,730 --> 00:38:54,370
Segundo a Wikipedia, "Ao contrário da troca de XOR, esta variação exige que ele usa alguns métodos

413
00:38:54,370 --> 00:38:59,780
a garantia de que x + y não causa um excesso de número inteiro ".

414
00:38:59,780 --> 00:39:08,350
Portanto, este não tem problemas, o que foi excesso de número inteiro, mas eu fiz algo errado.

415
00:39:08,350 --> 00:39:10,520
Não tenho a certeza. Vou tentar chegar a um outro.

416
00:39:10,520 --> 00:39:13,640
[Estudante] Bem, não é excesso de número inteiro quando você está tentando colocar um número em que

417
00:39:13,640 --> 00:39:16,640
maior do que a quantidade de bits que você recebe?

418
00:39:16,640 --> 00:39:23,730
Sim. Nós temos 4 bits. Isto - que teve 4 bits, que tente adicionar um para ela, então vamos acabar com 5 bits.

419
00:39:23,730 --> 00:39:26,690
Mas o quinto bit só é cortada, sim.

420
00:39:26,690 --> 00:39:28,970
Ele pode, na verdade -

421
00:39:28,970 --> 00:39:33,010
[Estudante] Será que você jogue um erro, ou faz isso - teria que lançar um erro?

422
00:39:33,010 --> 00:39:40,720
Não. Então não há erro. Quando você chegar ao nível da montagem, um pouco especial

423
00:39:40,720 --> 00:39:47,020
em algum lugar está definido que disse que houve um estouro, mas em C você meio que simplesmente não lidar com isso.

424
00:39:47,020 --> 00:39:55,160
Você realmente não pode lidar com isso, a menos que você use instruções de montagem especiais em C.

425
00:39:55,160 --> 00:39:58,110
Vamos pensar sobre XOR troca.

426
00:39:58,110 --> 00:40:02,220
E eu acho que o artigo da Wikipedia também pode ter vindo a dizer que -

427
00:40:02,220 --> 00:40:07,310
Por isso, também trouxeram aritmética modular, então eu acho que era, em teoria, a aritmética modular

428
00:40:07,310 --> 00:40:11,160
quando eu disse que 0-1 é de 15 novamente.

429
00:40:11,160 --> 00:40:15,410
Para que possa, na verdade - em um processador regular que faz 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Desde que acabar em 0, subtrair 1, assim então ele só enrola de volta em torno de 1111.

431
00:40:20,430 --> 00:40:28,930
Portanto, este algoritmo pode realmente funcionar, a a + b, a - b, b - a, que pode ser ótimo.

432
00:40:28,930 --> 00:40:34,030
Mas há alguns processadores que não fazer isso, e por isso não ficaria bem em aqueles específicos.

433
00:40:34,030 --> 00:40:39,880
Troca de XOR irá funcionar em qualquer processador. Okay.

434
00:40:39,880 --> 00:40:42,280
A idéia é que ele deveria ser o mesmo, no entanto.

435
00:40:42,280 --> 00:40:50,120
Onde estamos usando XOR de alguma forma obter as informações de ambos em uma das variáveis,

436
00:40:50,120 --> 00:40:54,120
e, em seguida, retirar as informações das variáveis ​​individuais novamente.

437
00:40:54,120 --> 00:41:04,330
Então, alguém tem idéias / a resposta?

438
00:41:04,330 --> 00:41:14,540
[Responder Estudante, ininteligível]

439
00:41:14,540 --> 00:41:22,220
Portanto, este deve funcionar, e também, XOR é comutativo.

440
00:41:22,220 --> 00:41:27,620
Independentemente de qual ordem estes dois números que ser em até aqui,

441
00:41:27,620 --> 00:41:30,100
este resultado será o mesmo.

442
00:41:30,100 --> 00:41:35,800
Então a ^ b é b ^ a.

443
00:41:35,800 --> 00:41:51,860
Você também pode ver este escrito como um ^ = b, b ^ = a, a ^ = b novamente.

444
00:41:51,860 --> 00:42:00,200
Então, isso é certo, e ver por que isso funciona, acho que dos bits.

445
00:42:00,200 --> 00:42:10,400
Usando um número pequeno, digamos 11001, e 01100.

446
00:42:10,400 --> 00:42:12,790
Portanto, esta é 'a', o que é b.

447
00:42:12,790 --> 00:42:15,540
Então a ^ = b.

448
00:42:15,540 --> 00:42:22,380
Nós vamos estar definindo "a" = a XOR destas duas coisas.

449
00:42:22,380 --> 00:42:32,920
Então, 1 ^ 0 é 1, 1 ^ 1 é 0, 0 ^ 1 é 1, e 0 ^ 0 é 0, 1 ^ 0 é 1.

450
00:42:32,920 --> 00:42:37,380
So 'uma', se você olhar o número decimal, que vai ser -

451
00:42:37,380 --> 00:42:41,160
você não vai ver muito de uma relação entre o original 'a' eo novo 'a',

452
00:42:41,160 --> 00:42:45,600
mas olhando para os bits, 'a' é agora como uma malha de informações

453
00:42:45,600 --> 00:42:49,970
de tanto o original 'a' e b original.

454
00:42:49,970 --> 00:42:57,930
Então, se tomarmos b ^ a, vemos que nós vamos acabar no original 'um'.

455
00:42:57,930 --> 00:43:08,910
E se tomarmos o original 'a' ^ o novo 'a', vemos que acabar no b original.

456
00:43:08,910 --> 00:43:18,380
Então, (a ^ b) ^ b = o original 'a'.

457
00:43:18,380 --> 00:43:27,910
E (a ^ b) ^ a = b original.

458
00:43:27,910 --> 00:43:37,010
Não há - outra forma de ver isso é XOR nada em si é sempre 0.

459
00:43:37,010 --> 00:43:45,020
Assim, 1101 ^ 1101, todos os bits vão ser os mesmos.

460
00:43:45,020 --> 00:43:47,920
Então nunca vai ser um caso em que um é um 0 eo outro é um.

461
00:43:47,920 --> 00:43:51,080
Portanto, este é 0000.

462
00:43:51,080 --> 00:43:57,240
O mesmo com este. (A ^ b) ^ b é como a ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) vai ser 0; a ^ 0 é apenas vai ser 'a', uma vez que todos os bits são 0.

464
00:44:03,680 --> 00:44:08,050
Assim, os únicos que estão indo para estar onde 'a' era originalmente um 1 - tinha uns.

465
00:44:08,050 --> 00:44:12,070
E a mesma idéia aqui, eu tenho certeza que ele também é comutativa.

466
00:44:12,070 --> 00:44:17,590
Sim. Eu disse antes que era comutativa.

467
00:44:17,590 --> 00:44:24,680
O ^ 'a,' e é associativa, por isso agora (b ^ a) ^ a.

468
00:44:24,680 --> 00:44:28,970
E nós podemos fazer b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
E então, novamente, nós temos a b original.

470
00:44:31,540 --> 00:44:37,120
Assim, 'a' é agora a combinação de 'a' e b em conjunto.

471
00:44:37,120 --> 00:44:49,660
Usando a nossa nova combinação 'a' dizemos b = combinação 'a' ^ b do original, nós temos o original 'a'.

472
00:44:49,660 --> 00:45:05,170
E agora um combo = 'a' ^ a b novo, que era o original - ou o que é agora o que era 'a' ou b.

473
00:45:05,170 --> 00:45:13,620
Isso é caso aqui. Este é = b, b idade.

474
00:45:13,620 --> 00:45:16,550
Então agora tudo está de volta na ordem trocada.

475
00:45:16,550 --> 00:45:22,960
Se nós realmente olhou para os bits, b = a ^ b, vai XOR estes dois,

476
00:45:22,960 --> 00:45:33,920
ea resposta vai ser isso, e então a = a ^ b é XORing estes dois ea resposta é esta.

477
00:45:33,920 --> 00:45:41,090
Perguntas? Okay. Assim, o último é um pouco significativamente mais difícil.

478
00:45:41,090 --> 00:45:43,180
[Estudante] Eu acho que ele tem uma pergunta sobre isso. >> Oh, desculpe.

479
00:45:43,180 --> 00:45:49,380
[Aluno] O que é realmente mais rápido? Se você usar este XOR, ou é se você declarar uma nova variável?

480
00:45:49,380 --> 00:45:55,190
Então, o que é realmente mais rápido, declarando uma nova variável ou usando XOR para trocar?

481
00:45:55,190 --> 00:45:59,600
A resposta é, com toda a probabilidade, uma variável temporária.

482
00:45:59,600 --> 00:46:05,780
E isso porque uma vez que é compilado para baixo - assim no nível da montagem,

483
00:46:05,780 --> 00:46:12,320
não há tal coisa como variáveis ​​locais ou quaisquer variáveis ​​temporárias ou qualquer dessas coisas.

484
00:46:12,320 --> 00:46:16,060
Eles são como - não há memória, e existem registros.

485
00:46:16,060 --> 00:46:20,920
Os registros são onde as coisas estão acontecendo ativamente.

486
00:46:20,920 --> 00:46:24,750
Você não adicionar duas coisas na memória, você adiciona duas coisas em registos.

487
00:46:24,750 --> 00:46:28,160
E você levar as coisas da memória para registros para depois adicioná-los,

488
00:46:28,160 --> 00:46:33,180
e então você pode colocá-los de volta na memória, mas toda a ação acontece em registros.

489
00:46:33,180 --> 00:46:38,750
Então, quando você estiver usando a abordagem temporária variável, geralmente o que acontece é

490
00:46:38,750 --> 00:46:42,810
esses dois números já estão em registros.

491
00:46:42,810 --> 00:46:46,570
E então, a partir desse ponto, depois de ter trocado eles,

492
00:46:46,570 --> 00:46:51,540
ele só vai começar a usar o outro registo.

493
00:46:51,540 --> 00:46:56,510
Em qualquer lugar que você estava usando b, ele só vai utilizar o registo que já estava armazenando 'a'.

494
00:46:56,510 --> 00:47:02,180
Por isso, não precisa fazer nada para realmente fazer a troca. Sim?

495
00:47:02,180 --> 00:47:05,690
[Estudante] Mas ele também tem mais memória, certo?

496
00:47:05,690 --> 00:47:10,280
Só vai ter mais memória, se ele precisa para armazenar a variável temporária.

497
00:47:10,280 --> 00:47:14,830
Como se você usar mais tarde que a variável temporária de novo em algum lugar,

498
00:47:14,830 --> 00:47:18,920
então - ou você atribui alguma coisa para essa variável temporária.

499
00:47:18,920 --> 00:47:24,630
Assim, se em qualquer ponto no tempo "a, 'b em temp têm valores distintos ou algo assim,

500
00:47:24,630 --> 00:47:30,680
em seguida, ele vai ter locais distintos na memória, mas é verdade que

501
00:47:30,680 --> 00:47:34,800
há muitas variáveis ​​locais, que só existem em registros.

502
00:47:34,800 --> 00:47:44,370
Nesse caso, ela nunca é colocada na memória, e assim você nunca está perdendo a memória.

503
00:47:44,370 --> 00:47:58,620
Okay. Última pergunta é um pouco mais.

504
00:47:58,620 --> 00:48:04,850
Então, aqui, neste aparelho CS50, há um dicionário.

505
00:48:04,850 --> 00:48:12,390
E a razão para isso é porque [? B66] é um corretor ortográfico onde você vai escrever

506
00:48:12,390 --> 00:48:15,780
o uso de tabelas de hash ou tenta ou alguma estrutura de dados.

507
00:48:15,780 --> 00:48:22,660
Você vai estar escrevendo um corretor ortográfico, e você vai estar usando este dicionário para fazer isso.

508
00:48:22,660 --> 00:48:28,280
Mas, para este problema, vamos apenas olhar para cima para ver se é uma única palavra no dicionário.

509
00:48:28,280 --> 00:48:31,250
Então, em vez de armazenar o dicionário inteiro em alguma estrutura de dados

510
00:48:31,250 --> 00:48:35,180
e, em seguida, olhando para um documento inteiro para ver se algo está incorreto,

511
00:48:35,180 --> 00:48:38,490
só queremos encontrar uma palavra. Assim, podemos apenas digitalizar sobre o dicionário inteiro

512
00:48:38,490 --> 00:48:44,300
e se nunca encontramos a palavra no dicionário inteiro, então ele não estava lá.

513
00:48:44,300 --> 00:48:52,150
Se a varredura sobre o dicionário inteiro e não ver a palavra, então estamos bem, nós o encontramos.

514
00:48:52,150 --> 00:48:56,580
Diz aqui que queremos começar a olhar para a função C de manipulação de arquivos,

515
00:48:56,580 --> 00:48:59,930
já que queremos ler o dicionário,

516
00:48:59,930 --> 00:49:07,680
mas vou dar a dica aqui, como para as funções que você deve pensar.

517
00:49:07,680 --> 00:49:11,510
Vou escrevê-los em espaços.

518
00:49:11,510 --> 00:49:20,490
Assim, os principais que você vai querer olhar para f são abertos e, então, inevitavelmente, f fechada,

519
00:49:20,490 --> 00:49:26,540
que vai no final de seu programa, e f f digitalização.

520
00:49:26,540 --> 00:49:31,060
Você também pode usar f ler, mas você provavelmente não quer

521
00:49:31,060 --> 00:49:34,200
porque isso - você não acabar precisando disso.

522
00:49:34,200 --> 00:49:41,880
F f varredura é o que você vai usar para digitalizar sobre o dicionário.

523
00:49:41,880 --> 00:49:46,370
E para que você não precisa codificar a solução, apenas tentar e como pseudo-código o seu caminho

524
00:49:46,370 --> 00:50:05,200
a uma solução, e depois nós vamos discutir isso.

525
00:50:05,200 --> 00:50:14,110
E, na verdade, desde que eu já te dei estes, se você entrar em qualquer terminal ou shell do seu aparelho,

526
00:50:14,110 --> 00:50:18,250
Eu - Eu normalmente - se você ainda não viu, eu não sei se você fez em classe,

527
00:50:18,250 --> 00:50:23,490
mas o homem, de modo que as páginas do manual, são bastante úteis para olhar para praticamente qualquer função.

528
00:50:23,490 --> 00:50:27,330
Então eu posso fazer, como, f homem, digitalização f.

529
00:50:27,330 --> 00:50:32,300
Esta é agora a informação sobre a família f varredura de funções.

530
00:50:32,300 --> 00:50:37,070
Eu também poderia fazer f homem, abertos, e que vai me dar mais detalhes do que isso.

531
00:50:37,070 --> 00:50:40,750
Então, se você sabe qual a função que você está usando, ou você está lendo código

532
00:50:40,750 --> 00:50:43,000
e você vê alguma função e você pensa, "O que isso faz?"

533
00:50:43,000 --> 00:50:45,280
Apenas um homem nome da função que.

534
00:50:45,280 --> 00:50:47,340
Há um par de exemplos estranhos, onde você pode ter a dizer

535
00:50:47,340 --> 00:50:51,620
gosto. homem 2, que o nome da função, ou o homem que 3 nome da função,

536
00:50:51,620 --> 00:50:58,230
mas você só tem que fazer isso se o nome de função de homem não acontecer a trabalhar pela primeira vez.

537
00:50:58,230 --> 00:51:03,010
[Estudante] Então, eu estou lendo a página man para aberto, mas ainda estou confuso sobre como usá-lo eo programa.

538
00:51:03,010 --> 00:51:06,170
Okay. Um monte de páginas de manual são menos do que útil.

539
00:51:06,170 --> 00:51:08,470
Eles são mais úteis se você já sabe o que fazer

540
00:51:08,470 --> 00:51:12,670
e então você só precisa se lembrar da ordem dos argumentos ou algo assim.

541
00:51:12,670 --> 00:51:17,640
Ou eles podem lhe dar uma visão geral, mas alguns deles são muito grande.

542
00:51:17,640 --> 00:51:22,220
Como f varredura f, também. Ele lhe dá a informação para todas estas funções,

543
00:51:22,220 --> 00:51:28,120
e uma linha de baixo aqui acontece a dizer, "F varredura f lê a partir do ponto de corda ou corrente."

544
00:51:28,120 --> 00:51:32,360
Mas f abrir. Então, como é que nós usamos f aberta?

545
00:51:32,360 --> 00:51:38,470
A idéia de um programa que precisa de fazer arquivo I / O é que

546
00:51:38,470 --> 00:51:45,070
primeiro você precisa abrir o arquivo que você quer fazer as coisas com e, inevitavelmente,

547
00:51:45,070 --> 00:51:51,220
ler coisas desse arquivo e fazer coisas com eles.

548
00:51:51,220 --> 00:51:55,350
F aberto é o que usamos para abrir o arquivo.

549
00:51:55,350 --> 00:52:04,190
A única coisa que voltar, então o arquivo que queremos abrir, dá-nos a -

550
00:52:04,190 --> 00:52:11,970
aqui ele diz que "usuário / / share dict / / palavras".

551
00:52:11,970 --> 00:52:16,740
Este é o arquivo que deseja abrir, e nós queremos abri-lo -

552
00:52:16,740 --> 00:52:21,440
temos que especificar explicitamente se queremos abri-lo para ler ou se queremos abri-lo a escrever.

553
00:52:21,440 --> 00:52:26,490
Há um par de combinações e outras coisas, mas queremos abrir este para leitura.

554
00:52:26,490 --> 00:52:29,380
Queremos ler a partir do arquivo.

555
00:52:29,380 --> 00:52:34,290
Assim que este retorno? Ele retorna um arquivo de estrela (*),

556
00:52:34,290 --> 00:52:37,260
e eu vou mostrar tudo na variável f, então *,

557
00:52:37,260 --> 00:52:40,840
novamente, é um ponteiro, mas não querem lidar com ponteiros.

558
00:52:40,840 --> 00:52:46,470
Você pode pensar em f como, f agora é a variável que você vai usar para representar o arquivo.

559
00:52:46,470 --> 00:52:49,850
Então, se você quiser ler o arquivo, você lê a partir de f.

560
00:52:49,850 --> 00:52:54,820
Se você quiser fechar o arquivo, você fecha f.

561
00:52:54,820 --> 00:53:00,350
Assim, no final do programa, quando nós inevitavelmente quer fechar o arquivo, o que devemos fazer?

562
00:53:00,350 --> 00:53:06,750
Queremos fechar f.

563
00:53:06,750 --> 00:53:12,600
Então, agora a função de último arquivo que vamos querer usar é varredura f, f f digitalização.

564
00:53:12,600 --> 00:53:20,930
E o que isso faz é que varre sobre o arquivo procurando um padrão para corresponder.

565
00:53:20,930 --> 00:53:39,100
Olhando para a página homem aqui, vemos int f f digitalização, ignorar o valor de retorno para agora.

566
00:53:39,100 --> 00:53:45,230
O primeiro argumento é o fluxo de arquivo *, de modo que o primeiro argumento que vamos querer passar é f.

567
00:53:45,230 --> 00:53:47,900
Estamos varredura sobre f.

568
00:53:47,900 --> 00:53:53,680
O segundo argumento é uma seqüência de formato.

569
00:53:53,680 --> 00:53:58,310
Eu vou dar-lhe uma seqüência de formato agora.

570
00:53:58,310 --> 00:54:05,180
Acho que acontecer a dizer, 127s \ n, um monte de que é desnecessário.

571
00:54:05,180 --> 00:54:12,490
A idéia de que essa seqüência de formato é, é que você pode pensar de f digitalização como o oposto de f impressão.

572
00:54:12,490 --> 00:54:17,160
Então f impressão, impressão f também usamos esse tipo de parâmetro formato,

573
00:54:17,160 --> 00:54:25,000
mas em f impressão que nós estamos fazendo é - vamos olhar para um equivalente.

574
00:54:25,000 --> 00:54:32,550
Assim imprimir f, e não há, na verdade também f impressão f, onde o primeiro argumento vai ser f.

575
00:54:32,550 --> 00:54:40,980
Ao imprimir f, poderíamos dizer algo como, "print 127s \ n" e depois se passar alguma corda,

576
00:54:40,980 --> 00:54:44,050
que vai imprimir essa string e então uma nova linha.

577
00:54:44,050 --> 00:54:49,690
O que 127 significa, eu tenho certeza, mas eu nunca me restrito a ele,

578
00:54:49,690 --> 00:54:52,470
Você não precisa nem dizer '127 'na f impressão,

579
00:54:52,470 --> 00:54:57,090
mas o que significa é imprimir os primeiros 127 caracteres.

580
00:54:57,090 --> 00:54:59,350
Então, eu tenho certeza que é o caso. Você pode Google para isso.

581
00:54:59,350 --> 00:55:03,000
Mas no próximo que eu tenho quase certeza que significa isso.

582
00:55:03,000 --> 00:55:08,880
Portanto, esta é imprimir os primeiros 127 caracteres, seguido por uma nova linha.

583
00:55:08,880 --> 00:55:14,680
F varredura f agora, em vez de olhar para uma variável e imprimi-lo,

584
00:55:14,680 --> 00:55:22,620
ele vai olhar para algumas cordas, e armazenar o padrão para a variável.

585
00:55:22,620 --> 00:55:26,360
Vamos realmente usar f verificação em um exemplo diferente.

586
00:55:26,360 --> 00:55:31,670
Então, vamos dizer que tivemos alguns int, x = 4,

587
00:55:31,670 --> 00:55:41,110
e queríamos criar uma cadeia de feitos - queria criar a cadeia

588
00:55:41,110 --> 00:55:44,250
que era como, este vai aparecer muito mais tarde,

589
00:55:44,250 --> 00:55:49,020
algo que é como 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Portanto, este pode ser um programa onde você terá contador de soma,

591
00:55:51,870 --> 00:55:56,420
Resumindo combater i, e você deseja salvar um monte de imagens.

592
00:55:56,420 --> 00:56:02,430
Então você quer salvar i.jpg, onde i é alguma iteração do seu loop.

593
00:56:02,430 --> 00:56:05,500
Então, como vamos fazer essa seqüência para que o JPEG?

594
00:56:05,500 --> 00:56:11,720
Se você quiser imprimir 4.jpg, podemos apenas dizer f impressão, D.jpg%,

595
00:56:11,720 --> 00:56:14,410
e então ele iria imprimir para que o JPEG.

596
00:56:14,410 --> 00:56:20,050
Mas, se queremos salvar o 4.jpg string, usamos f digitalização.

597
00:56:20,050 --> 00:56:30,860
Assim string s - na verdade, nós não posso - personagem, char s, vamos 100.

598
00:56:30,860 --> 00:56:35,400
Então, eu só declarou alguma matriz de 100 caracteres,

599
00:56:35,400 --> 00:56:39,830
e é isso que nós estamos, inevitavelmente, vai estar armazenando que JPEG dentro

600
00:56:39,830 --> 00:56:47,920
Então, nós estamos indo para usar f, digitalização e do formato, como diríamos D.jpg%

601
00:56:47,920 --> 00:56:54,980
para imprimir 4.jpg, o formato deste vai ser D.jpg%.

602
00:56:54,980 --> 00:57:04,020
Assim, o formato é D.jpg%, o que queremos para substituir d% com é x,

603
00:57:04,020 --> 00:57:06,590
e agora precisamos armazenar essa string em algum lugar.

604
00:57:06,590 --> 00:57:12,500
E para onde estamos indo para armazenar esta string é na matriz s.

605
00:57:12,500 --> 00:57:21,640
Então, depois de esta linha de código, s, se imprimir f% s, de a variável s,

606
00:57:21,640 --> 00:57:26,280
que vai imprimir 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Então f varredura f é o mesmo que f varredura, só que agora ele está a olhar para este arquivo

608
00:57:38,930 --> 00:57:43,600
para o que para armazenar em s.

609
00:57:43,600 --> 00:57:46,160
Isso é o que o último argumento é que vai ser.

610
00:57:46,160 --> 00:57:54,170
Nós queremos gravar - "família f digitalização de exames de funções tanto no acordo com o formato como tentou abaixo.

611
00:57:54,170 --> 00:58:02,450
Se qualquer são armazenados nos pontos de localização você pode retornar - "

612
00:58:02,450 --> 00:58:12,910
Não, pode ser bom. Deixe-me pensar por um segundo.

613
00:58:12,910 --> 00:58:26,350
Então varredura f não faz - o que diabos é a função que faz isso?

614
00:58:26,350 --> 00:58:31,650
Então varredura f não vai levar um inteiro e fazer ponto jpg.

615
00:58:31,650 --> 00:58:43,490
Vai [resmunga].

616
00:58:43,490 --> 00:58:49,360
Salve variável int em string int C.

617
00:58:49,360 --> 00:58:55,940
O que é esta variável, ou o que é esta função chamada?

618
00:58:55,940 --> 00:59:04,950
Sim. Isto - sim. Então, o que eu estava definindo a você antes era s f de impressão,

619
00:59:04,950 --> 00:59:09,820
que - que faz muito mais sentido, por isso que eu disse que era muito mais como f impressão.

620
00:59:09,820 --> 00:59:14,700
Digitalização f ainda é tipo como de f impressão, mas s f impressão vai examiná-lo mais de

621
00:59:14,700 --> 00:59:17,510
e substituir as variáveis ​​e, agora, armazená-lo em uma corda.

622
00:59:17,510 --> 00:59:19,620
Em vez de imprimir, ele armazena em uma string.

623
00:59:19,620 --> 00:59:25,070
Assim, ignorar que inteiramente. Você ainda pode pensar em como o especificador de formato semelhante ao de f impressão.

624
00:59:25,070 --> 00:59:34,510
Então, agora, se quiséssemos fazer a coisa 4.jpg, faríamos s f impressão, x isso.

625
00:59:34,510 --> 00:59:38,520
Então, o que está fazendo varredura f - Qual foi a sua questão vai ser?

626
00:59:38,520 --> 00:59:40,820
[Estudante] Eu só estou confuso sobre o que estamos tentando fazer aqui

627
00:59:40,820 --> 00:59:43,450
com que o JPEG. Você pode explicar que um tempo mais?

628
00:59:43,450 --> 00:59:52,710
Portanto, este foi - é menos relevent para f varredura f agora, espero, vai amarrar de volta em algum tipo de caminho.

629
00:59:52,710 --> 01:00:02,240
Mas o que eu inicialmente tinha a intenção de mostrar era - esta é, na verdade, diretamente relevante para estes [? F5]

630
01:00:02,240 --> 01:00:08,520
Você vai estar usando s f de impressão, onde, dizer que temos 100 imagens,

631
01:00:08,520 --> 01:00:13,630
e você quer ler a imagem 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Portanto, a fim de fazer isso, você precisa f aberta, e então você tem que passar a seqüência que você deseja abrir.

633
01:00:21,520 --> 01:00:30,020
Então, gostaria de abrir 1.jpg;, a fim de criar a cadeia que é 1.jpg,

634
01:00:30,020 --> 01:00:37,660
fazemos s f impressão de% D.jpg-não fizemos por int i = 0.

635
01:00:37,660 --> 01:00:46,580
i <40, i + +.

636
01:00:46,580 --> 01:00:51,130
Então s% f D.jpg impressão de i.

637
01:00:51,130 --> 01:00:56,320
Então, depois desta linha, agora a variável ou matriz s vai 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Ou, 0.jpg, 1.jpg, 2.jpg. E assim podemos abrir, por sua vez, cada imagem para leitura.

639
01:01:10,610 --> 01:01:19,550
Então é isso que s imprimir f faz. Você vê o que s imprimir f está fazendo agora?

640
01:01:19,550 --> 01:01:25,720
[Estudante] Ok, então ele está tomando - ele cria uma string, something.jpg, e depois armazena.

641
01:01:25,720 --> 01:01:30,360
Sim. Ele cria - esta é uma outra seqüência de formato, assim como varredura F e F de impressão,

642
01:01:30,360 --> 01:01:37,530
onde se insere todas as variáveis ​​para o segundo argumento, pode ser s em oposição ao i.

643
01:01:37,530 --> 01:01:42,280
Talvez - eu quero dizer, esse é o caso. Mas qualquer que seja a ordem dos argumentos é.

644
01:01:42,280 --> 01:01:45,440
Vai para inserir todas as variáveis ​​para a cadeia de formato

645
01:01:45,440 --> 01:01:52,250
e depois armazenar em nosso buffer; chamamos isso de um buffer, que é onde estamos armazenando a string.

646
01:01:52,250 --> 01:02:00,750
Então, nós estamos armazenando dentro de s a string formatado corretamente, d%, tendo sido substituído por 4.

647
01:02:00,750 --> 01:02:08,080
[Estudante] Então, se fizéssemos isso, é a variável f apenas vai ser transferido?

648
01:02:08,080 --> 01:02:18,110
Sim. Assim, devemos fechar o original f antes de fazer isso.

649
01:02:18,110 --> 01:02:22,810
Mas - e então, também, se não houvesse um f abrir aqui, então seria preciso dizer -

650
01:02:22,810 --> 01:02:29,280
Sim. Mas seria abrir uma centena de arquivos diferentes.

651
01:02:29,280 --> 01:02:37,360
[Estudante] Mas não seria capaz de acessar ou - ok.

652
01:02:37,360 --> 01:02:44,230
Okay. Então varredura f, f varredura f, é uma espécie da mesma idéia,

653
01:02:44,230 --> 01:02:53,610
mas em vez de, em vez de armazená-lo em uma corda, é mais como você está agora

654
01:02:53,610 --> 01:03:02,420
passando por uma picada e casamento de padrões contra essa seqüência e armazenar os resultados em variáveis.

655
01:03:02,420 --> 01:03:11,290
Você pode usar f varredura para analisar sobre algo como 4.jpg, e armazenar a 4 inteiro em int x soma.

656
01:03:11,290 --> 01:03:13,430
Isso é o que podemos usar para f varredura.

657
01:03:13,430 --> 01:03:16,300
F varredura f vai fazer isso na linha de comando.

658
01:03:16,300 --> 01:03:19,200
Eu estou realmente certeza que isso é o que a biblioteca CS50 faz.

659
01:03:19,200 --> 01:03:29,050
Então, quando você diz, "obter int," é exame f-ing mais - f verificação é a maneira que você obter entrada do usuário.

660
01:03:29,050 --> 01:03:34,670
F varredura f vai fazer a mesma coisa, mas usando um arquivo de digitalizar mais.

661
01:03:34,670 --> 01:03:41,090
Então, aqui, estamos varredura sobre este arquivo.

662
01:03:41,090 --> 01:03:45,460
O padrão que estamos tentando combinar alguma string que é de 127 caracteres

663
01:03:45,460 --> 01:03:48,100
seguido por uma nova linha

664
01:03:48,100 --> 01:03:54,770
Então, eu tenho certeza que nós poderíamos mesmo dizer "corresponder s", já que no dicionário

665
01:03:54,770 --> 01:03:57,770
acontece que temos, estamos garantidos nenhuma palavra é muito tempo,

666
01:03:57,770 --> 01:04:03,310
e também f f scan, eu acho, vai parar na linha de novo, não importa o quê.

667
01:04:03,310 --> 01:04:06,970
Mas vamos incluir a linha nova no jogo, e -

668
01:04:06,970 --> 01:04:13,960
[Estudante] Se não incluir a nova linha, não seria encontrar partes de uma palavra?

669
01:04:13,960 --> 01:04:22,900
Ele - cada um - olhando para o dicionário -

670
01:04:22,900 --> 01:04:26,200
Assim, no dicionário, estas são todas as nossas palavras.

671
01:04:26,200 --> 01:04:30,500
Cada um está em uma nova linha.

672
01:04:30,500 --> 01:04:32,510
O f varredura vai pegar essa palavra.

673
01:04:32,510 --> 01:04:38,750
Se não incluir a linha nova, então é possível que o f próxima varredura só vai ler a nova linha.

674
01:04:38,750 --> 01:04:44,180
Mas incluindo nova linha então simplesmente ignorar a nova linha.

675
01:04:44,180 --> 01:04:49,440
Mas nós nunca vamos obter parte de uma palavra, uma vez que estamos sempre lendo-se para uma nova linha, não importa o quê.

676
01:04:49,440 --> 01:04:54,530
[Estudante] Mas e se você procurar a palavra "Cissa", como Cissa.

677
01:04:54,530 --> 01:04:57,380
Será que vai encontrar isso, e dizer que é um jogo?

678
01:04:57,380 --> 01:05:05,110
Então aqui estamos nós - ele irá ler a - este é realmente um bom ponto.

679
01:05:05,110 --> 01:05:10,660
Nós nunca está usando o atual - a palavra que estamos procurando é o primeiro argumento da linha de comando.

680
01:05:10,660 --> 01:05:16,460
Assim a palavra de corda, argv = 1.

681
01:05:16,460 --> 01:05:20,020
Assim que a corda que estamos procurando é uma argv.

682
01:05:20,020 --> 01:05:23,290
Não estamos à procura de uma palavra em tudo na nossa f digitalização.

683
01:05:23,290 --> 01:05:28,030
O que estávamos fazendo com varredura f está ficando cada palavra no dicionário,

684
01:05:28,030 --> 01:05:34,320
e, em seguida, uma vez que temos que palavra vamos usar strcmp para compará-los.

685
01:05:34,320 --> 01:05:39,210
Vamos comparar a nossa palavra eo que acabamos de ler dentro

686
01:05:39,210 --> 01:05:45,110
Então, inevitavelmente, nós vamos acabar fazendo um monte de varredura fs

687
01:05:45,110 --> 01:05:52,130
até que isso só acontece que f digitalização vai voltar -

688
01:05:52,130 --> 01:05:54,800
ela retorne um, desde que igualou uma nova palavra,

689
01:05:54,800 --> 01:06:01,360
e retornará algo mais, logo que falhou para coincidir com a palavra.

690
01:06:01,360 --> 01:06:08,440
Estamos lendo todo o dicionário, armazenar linha por linha em cada palavra variável s.

691
01:06:08,440 --> 01:06:17,240
Em seguida, nós estamos comparando com a palavra s e, se a comparação == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp acontece para trazer 0 se um jogo foi feito.

693
01:06:21,650 --> 01:06:31,510
Então, se ele for 0, então podemos imprimir f, combinado,

694
01:06:31,510 --> 01:06:35,370
ou palavra é no dicionário, ou o que você deseja imprimir f.

695
01:06:35,370 --> 01:06:41,450
E então - nós não queremos f fechar uma e outra vez.

696
01:06:41,450 --> 01:06:50,410
Este é o tipo de coisa que nós queremos fazer, e não estamos apenas à procura de palavra no dicionário.

697
01:06:50,410 --> 01:06:56,660
Então, nós poderíamos fazer isso, se quisermos olhar para o seu padrão, Cissa, como você disse antes,

698
01:06:56,660 --> 01:07:00,260
se queria olhar para esse padrão, então ele iria falhar no caso

699
01:07:00,260 --> 01:07:08,010
porque isso não é realmente uma palavra, mas uma das palavras no dicionário acontece de ter que nele.

700
01:07:08,010 --> 01:07:13,560
Portanto, seria combinar essa palavra, mas este subconjunto da palavra não é uma palavra em si.

701
01:07:13,560 --> 01:07:17,250
Mas não é assim que estamos a usá-lo, estamos lendo cada palavra

702
01:07:17,250 --> 01:07:19,740
e depois comparando a palavra que temos com essa palavra.

703
01:07:19,740 --> 01:07:25,780
Então, nós estamos sempre comparando palavras completas.

704
01:07:25,780 --> 01:07:29,620
Eu posso enviar as soluções finalizados depois.

705
01:07:29,620 --> 01:07:32,050
Este é o tipo de quase a resposta certa, eu acho.

706
01:07:32,050 --> 01:07:34,720
[Comentário do estudante, ininteligível]

707
01:07:34,720 --> 01:07:40,870
Ah, eu se livrar do que antes? Char s, acho que disse 127 - eu esqueço o que o maior é.

708
01:07:40,870 --> 01:07:44,100
Nós vamos apenas fazer 128; agora s é o tempo suficiente.

709
01:07:44,100 --> 01:07:46,570
Nós não precisar imprimir nada.

710
01:07:46,570 --> 01:07:56,440
Nós também vamos querer ter que fechar o nosso arquivo, e que deve ser sobre a resposta certa.

711
01:07:56,440 --> 01:07:59,440
CS50.TV