1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Problema Sección Set 2: Edición 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ón, eu son Rob. Eu son un Senior en Kirkland. Este é o meu terceiro ano TFing CS50.

5
00:00:15,770 --> 00:00:22,220
É a primeira vez que estamos a cambiar a partir da sección tradicional charla de estilo,

6
00:00:22,220 --> 00:00:25,610
onde só tipo de revisar o que ocorreu na clase e despois vostedes fan preguntas,

7
00:00:25,610 --> 00:00:32,250
agora a ser moito máis baseada en problemas, onde usamos os espazos, e -

8
00:00:32,250 --> 00:00:37,410
Ah, entón a idea é ir ao enlace que lle enviei e entón vai estar no meu espazo.

9
00:00:37,410 --> 00:00:42,410
Será que ninguén ten un portátil? Okay.

10
00:00:42,410 --> 00:00:47,050
Entón nós imos estar usando iso, e nós imos estar facendo problemas vivir sección

11
00:00:47,050 --> 00:00:50,740
e discutir-los e descubrir o que está mal

12
00:00:50,740 --> 00:00:56,390
e eu podería tirar un pouco do seu código, e eu podería discutir as súas ideas.

13
00:00:56,390 --> 00:01:02,140
Entón, ten alguén tiña dificultade?

14
00:01:02,140 --> 00:01:07,000
Podes falar sobre o lado, non sei se imos ter razón para iso.

15
00:01:07,000 --> 00:01:12,270
Agora, como o supersection anterior, se estaba na clase, vostede sabe do que se trata.

16
00:01:12,270 --> 00:01:19,200
En todos os conxuntos P non vai ser esas seccións.

17
00:01:19,200 --> 00:01:22,550
Así, a P-2 set, especificacións, eu creo que viu na P-1 conxunto xa.

18
00:01:22,550 --> 00:01:27,400
Pero podemos ollar para a P-2 set para o que nós imos estar pasando por riba hoxe.

19
00:01:27,400 --> 00:01:29,460
E vai ver unha sección de preguntas.

20
00:01:29,460 --> 00:01:37,530
Entón, iso vai ser en todos os P-sets, haberá unha sección de preguntas.

21
00:01:37,530 --> 00:01:41,340
Ata agora, dixo, "Considero que unha oportunidade de practicar."

22
00:01:41,340 --> 00:01:44,940
Non será convidado a presentar este programa.

23
00:01:44,940 --> 00:01:48,480
A idea é que estas se destinan a especie de axudar a comezar co conxunto de problemas.

24
00:01:48,480 --> 00:01:53,220
Eu creo que na edición Hacker, moitos deles son supostos ser só cousas novas e interesantes para aprender.

25
00:01:53,220 --> 00:01:58,590
Poden non ser directamente aplicable ao conxunto de problemas.

26
00:01:58,590 --> 00:02:01,810
E agora nós non estamos tendo que envialos, pero, en teoría,

27
00:02:01,810 --> 00:02:07,480
para conxuntos de problemas posteriores, pode envialos e, así, pode vir a sección

28
00:02:07,480 --> 00:02:10,380
ou asistir a sección para obter as respostas, ou pode simplemente levalos no seu propio país

29
00:02:10,380 --> 00:02:16,350
se non sentir como gozar da miña presenza.

30
00:02:16,350 --> 00:02:21,010
Así, o - Eu creo que esta é a primeira.

31
00:02:21,010 --> 00:02:29,280
Oh Ademais, nestas seccións de preguntas tamén temos que facer preguntas sobre os shorts.

32
00:02:29,280 --> 00:02:33,440
Entón eu creo que, en teoría, debería prestar atención a estes antes de chegar a sección,

33
00:02:33,440 --> 00:02:38,550
pero todo ben se non fai, nós imos pasar por riba deles de calquera maneira.

34
00:02:38,550 --> 00:02:42,590
Así, podemos comezar con estas: "Como é que un loop while difiren dun loop do-tempo?

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

36
00:02:46,210 --> 00:02:49,390
Entón, alguén ten algunha -?

37
00:02:49,390 --> 00:02:52,730
[Alumno] O do-while sempre executado polo menos unha vez.

38
00:02:52,730 --> 00:03:02,950
Si Entón esa é a diferencia. Un loop while - eu só fago iso aquí - mentres loop, temos a condición

39
00:03:02,950 --> 00:03:19,760
aquí, mentres que un do-tempo, non ten unha condición ata chegar aquí.

40
00:03:19,760 --> 00:03:24,130
E así, cando o programa está en execución, e queda para o loop while,

41
00:03:24,130 --> 00:03:26,380
inmediatamente para saber se esta condición é verdadeira.

42
00:03:26,380 --> 00:03:30,710
Se esta condición non é verdade, ela só vai saltar o ciclo completo.

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

44
00:03:34,390 --> 00:03:37,920
Nada acontece neste momento, só segue executando.

45
00:03:37,920 --> 00:03:42,690
Entón, cando chega o "tempo", a condición é verdadeira, vai loop de volta e facelo de novo

46
00:03:42,690 --> 00:03:46,730
e de novo e de novo ata que a condición non é verdade e, a continuación, só a través de caídas.

47
00:03:46,730 --> 00:03:50,600
Así, a diferenza é que pode saltar desde o inicio.

48
00:03:50,600 --> 00:03:56,770
Isto necesariamente executa unha vez e entón pode executar máis veces a condición aínda é verdade.

49
00:03:56,770 --> 00:04:03,720
Así, o loop while ha facelo só unha vez, ou - o loop while - non pode ter facelo en todo,

50
00:04:03,720 --> 00:04:07,900
dende logo que chegar a el, a condición é falsa, imos saltar sobre el.

51
00:04:07,900 --> 00:04:11,770
Considerándose mentres loop, imos executa-lo unha vez, necesariamente.

52
00:04:11,770 --> 00:04:14,560
Despois, cando chegamos á condición, imos comprobar se é certa ou falsa.

53
00:04:14,560 --> 00:04:19,790
Se é verdade, nós imos facelo de novo, se é falso, imos seguir indo.

54
00:04:19,790 --> 00:04:24,680
Entón, cando é o último especialmente útil?

55
00:04:24,680 --> 00:04:31,190
Entón eu podo dicir que no conxunto dos 4 anos, 3 anos, calquera que sexa,

56
00:04:31,190 --> 00:04:38,780
que eu teño programado, eu usei iso, como, menos de 10 veces.

57
00:04:38,780 --> 00:04:43,140
E, probabelmente, cinco deles están en CS50 cando estamos introducindo facer mentres-loops.

58
00:04:43,140 --> 00:04:47,510
Entón, cando usou loops do-while?

59
00:04:47,510 --> 00:04:49,510
Cando é o - si?

60
00:04:49,510 --> 00:04:53,180
[Estudante] Cando está intentando obter a entrada do usuario, ou algo que quere comprobar -

61
00:04:53,180 --> 00:04:59,700
Si Entón faga-while, a entrada do usuario é un dos grandes.

62
00:04:59,700 --> 00:05:03,160
É por iso que os conxuntos de problemas primeiro par, cando quere preguntar ao usuario, como,

63
00:05:03,160 --> 00:05:08,520
"Deixa-me unha corda," non pode seguir ata chegar esa cadea.

64
00:05:08,520 --> 00:05:12,980
E para que, necesariamente, ten que preguntar para a cadea polo menos unha vez.

65
00:05:12,980 --> 00:05:16,950
Pero entón, se responden algo malo, entón precisas para facer un loop para atrás e preguntar de novo.

66
00:05:16,950 --> 00:05:20,810
Pero diferente do que a entrada do usuario, é moi raro que eu encontro un caso

67
00:05:20,810 --> 00:05:27,170
onde quero loop "polo menos unha vez", pero posiblemente máis.

68
00:05:27,170 --> 00:05:33,370
Preguntas ou -? Alguén xa usou un do-while noutro lugar?

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

70
00:05:36,780 --> 00:05:43,310
xeralmente indican se emitido polo bumbum? "

71
00:05:43,310 --> 00:05:47,380
Entón, que tipo de código que eu podería escribir para 'identificador non declarado?

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

73
00:05:49,550 --> 00:05:52,650
Así, podemos só probalo aquí, x = 2.

74
00:05:52,650 --> 00:06:04,830
Imos facer iso - oh, eu non prema nel. Entón aquí temos - todos os dereitos.

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

76
00:06:07,100 --> 00:06:11,610
Entón ese é o identificador non declarado, unha variable.

77
00:06:11,610 --> 00:06:13,910
El vai con frecuencia chamar un identificador dunha variable.

78
00:06:13,910 --> 00:06:17,300
Por iso, quizais non sabe é realmente unha variable, que non sabe o que é.

79
00:06:17,300 --> 00:06:19,380
Entón, é un identificador.

80
00:06:19,380 --> 00:06:26,060
Entón por que non é declarado? Si

81
00:06:26,060 --> 00:06:32,190
Entón, para ser claro sobre a terminoloxía, a declaración dunha variable

82
00:06:32,190 --> 00:06:37,360
é cando di "int x" ou "y", secuencia que sexa.

83
00:06:37,360 --> 00:06:41,910
A inicialización da variábel, ou a asignación de variable,

84
00:06:41,910 --> 00:06:44,510
sempre que di "x = 2".

85
00:06:44,510 --> 00:06:52,950
Así, podemos facelo en etapas separadas, int x, x = 2, e ata - podemos ter unha morea de cousas aquí dentro -

86
00:06:52,950 --> 00:07:00,350
pero ata esta liña acontece, x aínda é inicializar, pero foi declarado.

87
00:07:00,350 --> 00:07:06,760
E así podemos, por suposto, facelo nunha liña, e agora estamos declarando e inicializando.

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

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

90
00:07:18,390 --> 00:07:23,830
Entón, primeiro, que alguén quere dicir que a cifra de César é?

91
00:07:23,830 --> 00:07:28,100
[Estudante] Caesar Cipher só é que mapear, cambia cada letra,

92
00:07:28,100 --> 00:07:34,420
un determinado número de letras pasar por riba, e pasar por riba, e non é moi seguro porque

93
00:07:34,420 --> 00:07:42,260
hai só 26 opcións posibles e só tes que tentar cada unha das persoas, ata lograr.

94
00:07:42,260 --> 00:07:45,470
Oh Entón, eu teño que repetir?

95
00:07:45,470 --> 00:07:51,600
A cifra de César, é - Quero dicir, está lidando con el sobre os problemas que -

96
00:07:51,600 --> 00:07:56,110
ou eu creo que a edición estándar do conxunto de problemas que non está na edición hacker.

97
00:07:56,110 --> 00:08:01,550
Entón, na edición estándar para o conxunto de problemas, recibirá unha mensaxe do tipo: "Ola, mundo",

98
00:08:01,550 --> 00:08:08,410
e tamén ten un número como 6, e levar esa mensaxe, e cada personaxe individual,

99
00:08:08,410 --> 00:08:11,310
vostede xira-lo por seis posicións no alfabeto.

100
00:08:11,310 --> 00:08:16,560
Así, a 'h' Ola quedaría h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Entón, a primeira letra sería n. Nós facemos o mesmo con e.

102
00:08:19,600 --> 00:08:23,530
Se temos un, como, z ou algo así, entón nós implicados a volta a 'un'.

103
00:08:23,530 --> 00:08:29,280
Pero cada personaxe recibe ciclo 6 caracteres ao final do alfabeto, e non é moi seguro

104
00:08:29,280 --> 00:08:35,440
unha vez que existen só 26 posibilidades de cantas maneiras podería implicar unha única letra.

105
00:08:35,440 --> 00:08:42,919
Entón pode só tentar tódalas 26 deles e, presumiblemente, unha mensaxe suficientemente longo,

106
00:08:42,919 --> 00:08:46,860
só un deses posibles 26 cousas vai ser lexibles,

107
00:08:46,860 --> 00:08:50,300
eo lexible vai ser a mensaxe orixinal.

108
00:08:50,300 --> 00:08:56,240
Polo tanto, non é unha boa forma de cifrar nada.

109
00:08:56,240 --> 00:08:59,070
Alleos a esas shorts, "¿Que é unha función?"

110
00:08:59,070 --> 00:09:03,370
Entón, o que é unha función? Si

111
00:09:03,370 --> 00:09:11,640
[Estudante] É coma se unha peza de código que pode chamar para pasar e, a continuación, obter o valor de retorno de calquera cousa.

112
00:09:11,640 --> 00:09:18,160
Si Entón, eu vou responder por tamén responder a seguinte - ou a repetición por tamén só responder á seguinte.

113
00:09:18,160 --> 00:09:22,410
Pode utilizar funcións en vez de só copiar e pegar o código unha e outra vez.

114
00:09:22,410 --> 00:09:27,200
Só ten que ter o código, coloque o nun fuction, e entón podes só chamar a función

115
00:09:27,200 --> 00:09:29,870
onde queira que fose copiar e pegar.

116
00:09:29,870 --> 00:09:33,350
Así, as funcións son útiles.

117
00:09:33,350 --> 00:09:35,860
Entón agora imos facer problemas reais.

118
00:09:35,860 --> 00:09:46,490
O primeiro. Así, a idea de que a primeira é, pasa unha cadea, e independentemente da -

119
00:09:46,490 --> 00:09:52,060
ou que di en letras minúsculas? Ela non di que todas as letras minúsculas.

120
00:09:52,060 --> 00:09:57,730
Polo tanto, a mensaxe pode ser calquera cousa, e - Oh non. Fai.

121
00:09:57,730 --> 00:10:01,610
"Para simplificar, pode asumir que o usuario só a entrada letras minúsculas e espazos."

122
00:10:01,610 --> 00:10:08,180
Entón nós pasar unha mensaxe con só letras minúsculas e entón cambiar

123
00:10:08,180 --> 00:10:15,450
entre capital e minúsculas - que cambiar a secuencia de ser capital e minúsculas, alternando.

124
00:10:15,450 --> 00:10:22,920
Entón, antes de darlle un segundo para ata mergullo no problema,

125
00:10:22,920 --> 00:10:32,420
cal é o primeiro que temos que facer?

126
00:10:32,420 --> 00:10:36,900
Oh, que eu basta con premer en? Oh, eu só clic en un correo-e aquí.

127
00:10:36,900 --> 00:10:42,870
Entón o primeiro que cómpre facer - estou a ollar para a persoa errada?

128
00:10:42,870 --> 00:10:49,320
Isto é parte dun presente?

129
00:10:49,320 --> 00:10:51,320
Non, estas son aínda está alí, no entanto.

130
00:10:51,320 --> 00:10:55,160
Ok, aínda está aquí.

131
00:10:55,160 --> 00:11:03,160
Agora non podemos asumir -? Si Aquí non podemos asumir que é só minúsculas e espazos.

132
00:11:03,160 --> 00:11:07,770
Entón, agora temos que xestionar o feito de que as cartas pode ser o que queremos que eles sexan.

133
00:11:07,770 --> 00:11:11,910
E así, o primeiro que queremos facer é só recibir a mensaxe.

134
00:11:11,910 --> 00:11:19,790
Nós só necesitamos ter unha cadea, cadea s = GetString, ok.

135
00:11:19,790 --> 00:11:24,890
Agora este problema, existen algunhas formas de facelo.

136
00:11:24,890 --> 00:11:29,840
Pero imos querer usar operadores bit a bit aquí.

137
00:11:29,840 --> 00:11:35,280
Hai persoas que ou non estaban no supersection,

138
00:11:35,280 --> 00:11:37,480
ou algo así, e non sei o que son operadores bit a bit?

139
00:11:37,480 --> 00:11:41,710
Ou como se relacionan con ASCII de algunha maneira?

140
00:11:41,710 --> 00:11:45,650
[Estudante] Eu non estaba no supersection, pero eu sei que os operadores bit a bit son.

141
00:11:45,650 --> 00:11:49,560
Okay. Entón eu non teño que pasar por riba dos principios deles, pero eu vou explicar

142
00:11:49,560 --> 00:11:51,830
o que imos querer usar aquí.

143
00:11:51,830 --> 00:11:59,680
Entón 'A': Representación binaria de capital A, o número é de 65.

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

145
00:12:07,560 --> 00:12:14,170
De xeito que debe ser de 65 en decimal, polo que esta é a representación binaria do carácter de capital A.

146
00:12:14,170 --> 00:12:19,440
Agora, a representación binaria do personaxe minúsculas 'a'

147
00:12:19,440 --> 00:12:33,350
vai ser o mesmo, ou case. É que - 6, si. Isto é correcto.

148
00:12:33,350 --> 00:12:37,670
A capital de modo binario minúsculas, binario 'un'.

149
00:12:37,670 --> 00:12:43,940
Entón, observe que a diferenza entre A e 'a' é este único bit.

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

151
00:12:49,440 --> 00:12:53,910
E iso ten sentido, xa que A é de 65; 'a' e 97.

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

153
00:12:56,610 --> 00:13:03,770
Polo tanto, agora sabemos que podemos converter da a 'a', tomando un

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

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

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

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

158
00:13:33,700 --> 00:13:43,840
Entón, iso vai entón darnos exactamente o que 'a', pero cancela este bit individual,

159
00:13:43,840 --> 00:13:50,070
por iso imos ter 01000001, eu non sei se eu contei dereito.

160
00:13:50,070 --> 00:13:56,750
Pero esta técnica de bit a bit ORing para comezar a partir de capital en minúscula

161
00:13:56,750 --> 00:14:02,080
e bits a bit AND para comezar a partir de minúsculas para o capital non é 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án indo só para variar por este único bit.

164
00:14:10,080 --> 00:14:16,290
E así pode usar isto para cambiar de calquera letra minúscula para calquera letra maiúscula e viceversa.

165
00:14:16,290 --> 00:14:26,670
Okay. Así, un xeito doado de obter a partir deste - así, en vez de ter que

166
00:14:26,670 --> 00:14:32,170
escribir o que quere que 1011111 é - un xeito doado de representar este número, e iso non é unha

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

168
00:14:39,710 --> 00:14:42,520
O que fai é ~ mira para a representación de bits.

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

170
00:14:45,630 --> 00:14:53,130
Este é só un número binario, e que ~ non é só cambia todos os bits.

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

172
00:15:00,630 --> 00:15:08,320
Entón iso é todo ~ fai. Entón, 32, vai ser o número - librar-se de que -

173
00:15:08,320 --> 00:15:23,320
32 de xeito que vai ser o número 00100000, e así por ~ desta vai ser

174
00:15:23,320 --> 00:15:29,980
este número ata aquí que eu ANDed 'a' con.

175
00:15:29,980 --> 00:15:35,600
Será que todo o mundo ve isto? Isto é moi común, como cando quere descubrir

176
00:15:35,600 --> 00:15:40,740
para cousas máis recentes que poderiamos estar vendo, cando queremos ver se -

177
00:15:40,740 --> 00:15:44,710
ou queremos todo, cada conxunto único bit, excepto para un

178
00:15:44,710 --> 00:15:47,910
tende a ~ o pouco que nós non queremos definir.

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

180
00:15:53,090 --> 00:15:57,790
Okay. Así, podemos usar todos os aquí.

181
00:15:57,790 --> 00:16:03,000
Todo ben, por iso é bo se non está preparado, imos andar lentamente ao longo xuntos,

182
00:16:03,000 --> 00:16:11,870
ou camiñar sobre iso, entón - por iso. Camiño por iso.

183
00:16:11,870 --> 00:16:20,790
Polo tanto, temos a nosa cadea, e queremos loop sobre cada personaxe que secuencia e facer algo para el.

184
00:16:20,790 --> 00:16:26,710
Entón, como imos varrer unha cadea? O que debemos usar?

185
00:16:26,710 --> 00:16:30,980
Eu non vou facer iso aquí. Si

186
00:16:30,980 --> 00:16:42,940
Entón, eu teño o meu iterador, e el dixo iso, pero como sei cantos caracteres están na cadea?

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

188
00:16:47,030 --> 00:16:49,860
Entón o que eu fixen aquí non é a mellor forma de facer as cousas.

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

190
00:16:51,860 --> 00:16:55,290
Porque está comprobando a linguaxe da cadea de cada vez.

191
00:16:55,290 --> 00:17:06,859
Entón, nós imos querer mover strlen, eu podería dicir-se aquí, int tamaño = strlen (s),

192
00:17:06,859 --> 00:17:11,900
e, entón, i <lonxitude, e no caso de non ter visto iso antes,

193
00:17:11,900 --> 00:17:20,410
Eu tamén podería facer int i = 0, lonxitude = strlen (s).

194
00:17:20,410 --> 00:17:25,010
E así, este é un pouco preferible, xa que agora restrinxiu o ámbito

195
00:17:25,010 --> 00:17:29,150
da lonxitude variable para só este lazo 'for' no canto de declarar isto antes

196
00:17:29,150 --> 00:17:34,990
e que sempre hai, e no caso de que vostede non colleu por que iso é malo,

197
00:17:34,990 --> 00:17:39,410
ou porque o orixinal era malo, é - para comezar o loop.

198
00:17:39,410 --> 00:17:43,380
Eu verifiquei a condición. É i <lonxitude de s?

199
00:17:43,380 --> 00:17:46,790
Así, a lonxitude s, imos traballar con "Ola" en todo momento.

200
00:17:46,790 --> 00:17:49,670
Así lonxitude s, h-e-l-l-o. A lonxitude é 5.

201
00:17:49,670 --> 00:17:57,580
Entón, i = 0 lonxitude, é de 5, entón eu non se <5, entón o ciclo continúa.

202
00:17:57,580 --> 00:18:02,750
Entón imos de novo. Nós consideramos a condición. É i <a lonxitude do Ola?

203
00:18:02,750 --> 00:18:08,390
Entón, imos comprobar a lonxitude da Olá H-e-l-l-o. Isto é 5; i non é <5, entón seguimos de novo.

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

205
00:18:13,330 --> 00:18:17,380
ata pensei que nunca vai cambiar, pero sempre vai ser 5.

206
00:18:17,380 --> 00:18:22,530
Entón, lembre-se 5 na fronte, e agora todo está mellor.

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

208
00:18:24,990 --> 00:18:31,470
O que queremos facer cada carácter da cadea?

209
00:18:31,470 --> 00:18:38,510
[Falando Estudante, inintelixible]

210
00:18:38,510 --> 00:18:47,000
Si Entón, se o personaxe é non alfabéticos, entón nós só queremos ir sobre el.

211
00:18:47,000 --> 00:18:52,300
Porque só se preocupan con letras do alfabeto, non podemos capitalizar un número.

212
00:18:52,300 --> 00:19:10,850
Entón, como podemos facer iso? Polo tanto, a nosa condición, por iso, se queremos algo - comprobar se é alfabética.

213
00:19:10,850 --> 00:19:14,060
Entón, como podemos comprobar iso?

214
00:19:14,060 --> 00:19:18,720
[Estudante] Pode só usar a función é alfa.

215
00:19:18,720 --> 00:19:23,160
É que incluídos en calquera destes, ou calquera inclúen char.h, como ou algo así?

216
00:19:23,160 --> 00:19:32,710
Non imos utilizar a función é alfa, e usar o explícito - por iso temos s [i],

217
00:19:32,710 --> 00:19:40,460
que é o personaxe do oitavo s, lembre que unha cadea é unha matriz de caracteres,

218
00:19:40,460 --> 00:19:43,180
así que o carácter oitavo de s.

219
00:19:43,180 --> 00:19:49,280
Agora, se é unha letra maiúscula, sabemos que ten que estar en unha franxa específica.

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

221
00:19:54,370 --> 00:20:07,860
Si Entón, se s [i] é ≥ 65 e s [i] é ≤ 90, o que debo facer en vez diso?

222
00:20:07,860 --> 00:20:18,470
Si Entón, vostede non debe absolutamente precisa aínda de saber os valores ASCII de calquera cousa sempre.

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

224
00:20:25,640 --> 00:20:32,470
Non precisa - 112 - non precisa saber a todos. Isto é malo tamén.

225
00:20:32,470 --> 00:20:41,940
Só usar os caracteres single-quote, constantes comiñas. Así, "A" e menos de 90 é 'Z.'

226
00:20:41,940 --> 00:20:47,930
E este é significativamente mellor - eu non sei por riba da miña cabeza que Z é 90.

227
00:20:47,930 --> 00:20:52,690
Sei enriba da miña cabeza que 'Z' é a capital Z.

228
00:20:52,690 --> 00:21:02,100
Entón, mentres este está na franxa de capital dun a capital Z, ou podemos comprobar minúsculas,

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

230
00:21:17,010 --> 00:21:19,010
Entón esta é a nosa condición.

231
00:21:19,010 --> 00:21:22,520
O estilo de onde poñer isto varía.

232
00:21:22,520 --> 00:21:29,520
Vou facelo así.

233
00:21:29,520 --> 00:21:31,520
Agora, o que queremos facer?

234
00:21:31,520 --> 00:21:39,530
Sabemos que esta carta é un personaxe, un carácter alfabético.

235
00:21:39,530 --> 00:21:46,270
Polo tanto, temos que cambiar entre esta agora debe ser unha letra maiúscula ou unha letra minúscula.

236
00:21:46,270 --> 00:21:48,820
Como podemos seguir o que que quere que sexa?

237
00:21:48,820 --> 00:21:55,520
[Voces estudantís, inintelixible]

238
00:21:55,520 --> 00:21:59,150
Entón, si, pero deixe-me comprobar.

239
00:21:59,150 --> 00:22:04,910
Módulo 0-2 foi dito, foi unha suxestión xogado fóra, e eu estou de acordo con iso.

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

241
00:22:11,780 --> 00:22:18,270
E cada un dos outros, pero non podemos módulo 2 do i ou i mod 2, pois

242
00:22:18,270 --> 00:22:22,950
E entender que é capital e 'a' é minúscula? Pero hai un espazo que os separa?

243
00:22:22,950 --> 00:22:27,150
Entón, eles van ser o mesmo mod 2, pero son casos distintos.

244
00:22:27,150 --> 00:22:29,150
[Pregunta do estudante, inintelixible]

245
00:22:29,150 --> 00:22:34,690
Si Entón, nós estamos indo só para manter unha conta.

246
00:22:34,690 --> 00:22:38,730
Tamén podería facelo aquí, se quixésemos, que pode ter un pouco pesado

247
00:22:38,730 --> 00:22:41,300
no de declaracións de lazo, eu vou poñelas aquí.

248
00:22:41,300 --> 00:22:48,840
Entón, int count = comeza en 0.

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

250
00:22:54,070 --> 00:22:59,550
Entón, nós estamos, inevitablemente, vai contar + +, unha vez que atopou outro carácter alfabético.

251
00:22:59,550 --> 00:23:09,130
Pero, ata agora está dicindo que se mod conta de 2.

252
00:23:09,130 --> 00:23:12,590
Entón, o que se conta mod 2? Oh Vou facer == 0 por agora.

253
00:23:12,590 --> 00:23:21,740
Tamén imos pasar por riba diso. Entón, se a conta de mod 2 == 0, entón o que?

254
00:23:21,740 --> 00:23:27,830
[Os alumnos de resposta, inintelixible]

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

256
00:23:32,750 --> 00:23:37,520
Hai dous casos; maiúsculas e minúsculas son os dous problemas.

257
00:23:37,520 --> 00:23:40,990
Entón, se estamos en minúsculas necesitamos facelo maiúsculas.

258
00:23:40,990 --> 00:23:43,710
Se é maiúscula, non precisamos facer nada.

259
00:23:43,710 --> 00:23:50,760
Pero hai unha forma - non deben ter virado -

260
00:23:50,760 --> 00:23:54,800
que non precisa aínda de comprobar se é maiúscula ou minúscula?

261
00:23:54,800 --> 00:24:02,240
O que podemos facer para sempre asegurarse de que sempre acaban en maiúscula?

262
00:24:02,240 --> 00:24:07,830
Entón, observe o que fixemos en minúscula 'a', o que se fixo a mesma cousa exacta para maiúsculas A?

263
00:24:07,830 --> 00:24:11,900
Un cambio fai maiúsculas, ou a modificación de valor?

264
00:24:11,900 --> 00:24:23,100
Si Así, calquera letra maiúscula bitwise ANDed con ~ 32 vai ser ese personaxe maiúscula mesmo

265
00:24:23,100 --> 00:24:29,220
porque para calquera carácter maiúsculo o bit 32 non está definido.

266
00:24:29,220 --> 00:24:40,920
Entón, se queremos levar o personaxe s [i] queremos que sexa minúscula ou maiúscula.

267
00:24:40,920 --> 00:24:46,890
Entón, se era minúscula, agora é maiúscula, se era maiúscula, aínda é maiúscula, e que é iso.

268
00:24:46,890 --> 00:24:54,290
Eu dixen iso no supersection: Pode usar 32 se quere, pero eu tenden a preferir facer 'a' - A,

269
00:24:54,290 --> 00:25:01,150
no canto de só 32 liso, porque pode ser calquera outro bit.

270
00:25:01,150 --> 00:25:03,610
Tras o bit 32, que pode ser calquera destes, ou non teriamos 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ón, se incorporarse o de 32 bits, que podería ser o de 64 bits, que podería ser a de 128 bits.

273
00:25:09,110 --> 00:25:13,990
Calquera deses bits pode ser o pouco que fai a distinción entre maiúsculas e minúsculas.

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

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

276
00:25:27,130 --> 00:25:33,000
sen necesidade de contar co número máxico que é 32.

277
00:25:33,000 --> 00:25:38,770
E agora, máis contar era estraño, e entón o que quero facer?

278
00:25:38,770 --> 00:25:43,920
[Respostas dos alumnos, inintelixible]

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

280
00:25:45,920 --> 00:25:49,850
Vou facelo en un segundo.

281
00:25:49,850 --> 00:25:55,690
Entón, agora, se eu queira - quero estar seguro de que o personaxe é agora minúsculas,

282
00:25:55,690 --> 00:26:04,140
e así podo ou por 32, 32 e significado 'a' - A.

283
00:26:04,140 --> 00:26:06,510
Pero aviso, o mesmo razoamento que o anterior, que se

284
00:26:06,510 --> 00:26:11,670
letra xa era minúscula, seguida por 32 ORing só mantén minúsculas.

285
00:26:11,670 --> 00:26:16,220
Non cambiou o carácter orixinal.

286
00:26:16,220 --> 00:26:19,910
Pero agora eu non teño que evitar dicir: "Se é minúscula, só esquece-lo,

287
00:26:19,910 --> 00:26:23,650
se é maiúscula, entón cambia-lo. "

288
00:26:23,650 --> 00:26:26,900
É moito máis cómodo para facer isto.

289
00:26:26,900 --> 00:26:33,190
[Estudante] Será que a estratexia da subtracción do maiúsculas de minúsculas o traballo se non fose 32?

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

291
00:26:35,330 --> 00:26:41,840
Entón, ten que saber que a diferenza entre os dous é -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Pode ser máis que 1 bit, sempre que todos os bits a continuación desta posición son as mesmas.

293
00:26:49,840 --> 00:26:58,500
Entón, necesitamos polo menos 26 caracteres - ou, existen 26 caracteres.

294
00:26:58,500 --> 00:27:04,590
Entón, necesitamos polo menos 26 números para representar a diferenza -

295
00:27:04,590 --> 00:27:07,650
A diferenza entre A e 'a' ten que ser de polo menos 26,

296
00:27:07,650 --> 00:27:10,760
ou ben non representaría todos os números de capitais.

297
00:27:10,760 --> 00:27:18,630
Isto significa que a si comezarmos a 1, que vai utilizar todos eses bits,

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

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

300
00:27:32,170 --> 00:27:40,930
Isto é porque, na táboa ASCII, hai cinco símbolos que separan maiúsculas de minúsculas.

301
00:27:40,930 --> 00:27:49,050
Dende que estes son os símbolos, o 5 extra que trae a 32 sendo a diferenza entre eles.

302
00:27:49,050 --> 00:27:51,840
[Estudante] Entón, nós poderíamos facer iso, porque ASCII é designado desa forma.

303
00:27:51,840 --> 00:27:57,280
Si Pero ASCII - a diferenza podía tamén ser ambos destes bits.

304
00:27:57,280 --> 00:28:12,040
Como, se un era 10000001, e 'a' 11100001 - me esqueza, o que sexa.

305
00:28:12,040 --> 00:28:18,100
Pero se fose iso, entón aínda pode usar 'a' - A.

306
00:28:18,100 --> 00:28:22,650
É só agora a diferencia entre A e 'a' é aínda estes dous bits.

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

308
00:28:32,240 --> 00:28:40,160
Sería aínda 2 bits; cada personaxe, como, Z e Z, K e K,

309
00:28:40,160 --> 00:28:45,160
aínda terían os mesmos bits exactas definidas excepto para os dous bits.

310
00:28:45,160 --> 00:28:48,870
Entón, mentres iso é sempre certo, independentemente de se estamos usando ASCII ou algún outro sistema,

311
00:28:48,870 --> 00:28:53,050
mentres que hai só un determinado número de bits que son diferentes para cada personaxe,

312
00:28:53,050 --> 00:28:55,050
a continuación, que funciona ben.

313
00:28:55,050 --> 00:29:06,110
É que 32 foi creado porque é o primeiro que podería usar. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Eu tenden a preferir, se non viu, o bloque é só unha soa liña,

315
00:29:14,520 --> 00:29:24,280
pode se librar das claves, de modo que tenden a preferir facelo.

316
00:29:24,280 --> 00:29:34,010
Ademais, vostede sabe como podemos facer cousas como s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Tamén pode facer 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
Ademais, contan mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Entón lembre que - eu non vou gravala-lo - calquera valor distinto de cero é certo, e 0 é falso.

321
00:30:00,900 --> 00:30:07,880
Así, "a conta mod 2 == 0" é o mesmo que dicir "si non contar mod 2".

322
00:30:07,880 --> 00:30:11,580
Eu probablemente tería só inverteu as liñas e dixo: "se a conta mod 2,

323
00:30:11,580 --> 00:30:15,350
que o OR 1, máis que o AND 1 ", para que eu non precisaba do" non ".

324
00:30:15,350 --> 00:30:18,650
Pero iso funciona tan ben.

325
00:30:18,650 --> 00:30:25,660
E o que máis podo facer aquí?

326
00:30:25,660 --> 00:30:29,060
Pode combina-los con ternário se quería, pero, entón, que acabara de facer as cousas máis confusas

327
00:30:29,060 --> 00:30:33,770
e probablemente máis difícil de ler, por iso non imos facelo.

328
00:30:33,770 --> 00:30:37,330
Alguén ten algunha suxestión?

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ón, se librar destas liñas baleiras, agora imos imprimir f,% s sexa o único para cordas,

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

332
00:30:56,620 --> 00:30:59,330
Agora imos executalo. Eu fixen algo mal?

333
00:30:59,330 --> 00:31:03,200
Isto é un \ ", quero un n.

334
00:31:03,200 --> 00:31:07,840
Okay. Agora imos executalo. El probablemente vai berrar comigo.

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

336
00:31:11,250 --> 00:31:14,290
Polo tanto, esta é a cousa agradable sobre Clang é mostra o que está,

337
00:31:14,290 --> 00:31:19,140
ao contrario do GCC, que só di: "Ei, esqueceu algo, eu non sei o que era."

338
00:31:19,140 --> 00:31:29,220
Pero iso me vai dicir: "Vostede debe incluir string.h".

339
00:31:29,220 --> 00:31:32,130
Entón eu non pedir nada, por iso non está dicindo nada.

340
00:31:32,130 --> 00:31:42,540
Pero imos facer o seu exemplo, "Grazas 4 Engada o".

341
00:31:42,540 --> 00:31:47,880
Isto parece correcto. Hooray.

342
00:31:47,880 --> 00:31:52,370
Entón, volver para o seu inicio, eu case nunca o fan.

343
00:31:52,370 --> 00:31:57,110
É opcional. E principal é a única función para o que é opcional.

344
00:31:57,110 --> 00:32:07,140
Se non voltar nada da principal, é asumido que pretendía volver 0.

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

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

347
00:32:20,980 --> 00:32:24,810
"Teña en conta que da segunda charla dúas semanas de que o troco de valores 2 variables, pasando

348
00:32:24,810 --> 00:32:30,780
estas dúas variables para unha función (aínda que chamado de intercambio) non é exactamente o traballo, polo menos non sen 'punteiro' ".

349
00:32:30,780 --> 00:32:37,020
E ignorar os punteiros ata chegar a eles.

350
00:32:37,020 --> 00:32:40,070
Queremos cambiar dúas variables; non estamos a usar unha función para facer iso.

351
00:32:40,070 --> 00:32:43,410
Aínda imos facelo principal como el di.

352
00:32:43,410 --> 00:32:48,360
Pero, para usar esas dúas variables, non queremos usar unha variable temporal.

353
00:32:48,360 --> 00:32:50,770
Hai dúas formas de facelo.

354
00:32:50,770 --> 00:32:56,310
Podes facelo usando os seus operadores binarios tradicionais.

355
00:32:56,310 --> 00:33:00,180
Entón, alguén sabe unha maneira rápida e sucia de facelo?

356
00:33:00,180 --> 00:33:07,650
Pode realmente ter un minuto de pensar. Se eu tivera -

357
00:33:07,650 --> 00:33:12,130
Vou definir o problema como se piden. Entón, se eu tivera dúas variables, A, que é só un enteiro

358
00:33:12,130 --> 00:33:17,800
que me dan, e B suma variable, que é un outro número enteiro que eu son dado.

359
00:33:17,800 --> 00:33:22,700
Entón, se eu teño esas dúas variables, agora quero trocalos.

360
00:33:22,700 --> 00:33:31,550
O tradicional, usando os seus operadores binarios estándar, é dicir, como +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Nin os operadores bitwise que actúan sobre binario.

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

363
00:33:39,600 --> 00:33:52,980
Poderiamos cambiar, facendo algo así como a = a + b, b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Entón, comprobación de sanidade, e despois imos ver por que isto funciona.

365
00:34:04,260 --> 00:34:13,320
Imos dicir que a = 7, b = 3, entón a + b que vai ser 10.

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

367
00:34:18,820 --> 00:34:30,250
Entón, nós estamos facendo b = a - b, que vai ser 7, e b = a - b, de novo,

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

369
00:34:38,650 --> 00:34:44,850
Entón, agora, correctamente, 'a' foi de 7, b foi de 3, e agora b é 7 e 'a' e 3.

370
00:34:44,850 --> 00:34:48,679
De modo que o tipo de sentido, 'a' é a combinación dos dous números.

371
00:34:48,679 --> 00:34:53,000
Neste punto, 'a' é a combinación, e entón nós estamos restando ab orixinal,

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

373
00:34:56,860 --> 00:35:01,150
Pero iso non funciona para todos os números.

374
00:35:01,150 --> 00:35:08,880
Para ver isto, imos considerar un sistema, de xeito que adoitamos pensar en números enteiros como 32 bits.

375
00:35:08,880 --> 00:35:13,050
Imos traballar en algo que é só como 4 bits.

376
00:35:13,050 --> 00:35:15,450
Espero que eu veña con un bo exemplo agora.

377
00:35:15,450 --> 00:35:18,680
Entón, sei, iso vai ser doado.

378
00:35:18,680 --> 00:35:26,720
Imos dicir que os nosos dous números son 1111, e 1111, de xeito que estamos en binario agora.

379
00:35:26,720 --> 00:35:34,630
En decimais reais, se quere pensar desa forma, a. = 15 e b = 15

380
00:35:34,630 --> 00:35:37,630
E entón esperamos que, despois de troca-los - eles non ten sequera a ser os mesmos números,

381
00:35:37,630 --> 00:35:41,140
pero eu fixen iso desa maneira.

382
00:35:41,140 --> 00:35:47,100
Imos facer non lles os mesmos números. Imos facer 1111 e 0001.

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

384
00:35:51,860 --> 00:35:57,670
Despois de que troca-los, esperamos que 'a' para ser 1 e B para ser 15.

385
00:35:57,670 --> 00:36:01,780
Entón, o noso primeiro paso é a = a + b.

386
00:36:01,780 --> 00:36:08,770
Os nosos números son só 4 bits de ancho, entón 'un', que é 1111, + B, que é de 0001,

387
00:36:08,770 --> 00:36:16,780
vai acabar sendo 10.000, pero temos só 4 bits.

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

389
00:36:22,540 --> 00:36:34,080
E agora queremos establecer b = a - b - na verdade, iso aínda funciona perfectamente.

390
00:36:34,080 --> 00:36:39,630
a = a - imos ver se isto funciona perfectamente - b.

391
00:36:39,630 --> 00:36:53,720
Entón, a continuación, b = 0 - 1, o que aínda sería 15, e, a continuación, a = a - b, o que sería un.

392
00:36:53,720 --> 00:36:56,210
Quizais iso non funciona.

393
00:36:56,210 --> 00:36:59,020
Eu sinto que hai unha razón para non funciona con estándar.

394
00:36:59,020 --> 00:37:06,400
Ok, entón a traballar coa suposición de que non funciona coas operacións de binarios regulares,

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

396
00:37:15,040 --> 00:37:23,490
Entón, nós queremos facelo usando os operadores bit a bit, ea pista aquí é XOR.

397
00:37:23,490 --> 00:37:28,780
Así, a introdución de XOR (^) se non viu aínda.

398
00:37:28,780 --> 00:37:34,610
É, unha vez máis, un operador bit a bit polo que actúa aos poucos, e é -

399
00:37:34,610 --> 00:37:39,910
Se ten os bits 0 e 1, entón este será un.

400
00:37:39,910 --> 00:37:45,230
Se ten os bits 1 e 0, vai ser un, ten os bits 0 e 0 que vai ser 0,

401
00:37:45,230 --> 00:37:47,640
e se ten os bits 1 e un vai ser 0.

402
00:37:47,640 --> 00:37:56,180
Entón, é como OR. Se calquera dos bits son certos, é dicir, 1, pero a diferenza OR, non pode ser os dous bits que son certas.

403
00:37:56,180 --> 00:37:59,320
Ou tería esta ser 1, XOR tería este ser 0.

404
00:37:59,320 --> 00:38:02,250
Entón nós imos querer usar XOR aquí.

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

406
00:38:09,960 --> 00:38:16,230
Ben, non pode ler isto, eu estou actualmente na páxina algoritmo XOR intercambio.

407
00:38:16,230 --> 00:38:21,340
Esperemos que isto ha explicar por que eu non podo -

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

409
00:38:34,190 --> 00:38:37,330
Eu aínda non sei por que - debo ter só escolleu un mal exemplo,

410
00:38:37,330 --> 00:38:44,940
pero neste caso, onde 'a' ocorreu para facer 0, despois de chegar ao 5 bits, polo que agora 'a' é 0,

411
00:38:44,940 --> 00:38:48,730
que é o que se chama "estourido de enteiro."

412
00:38:48,730 --> 00:38:54,370
Segundo a Wikipedia, "Ao contrario do intercambio de XOR, esta variación esixe que usa algúns métodos

413
00:38:54,370 --> 00:38:59,780
a garantía de que x + y non causa un exceso de número enteiro ".

414
00:38:59,780 --> 00:39:08,350
Polo tanto, este non ten problemas, o que foi exceso de número enteiro, pero eu fixen algo mal.

415
00:39:08,350 --> 00:39:10,520
Non estou seguro. Vou tentar chegar a un outro.

416
00:39:10,520 --> 00:39:13,640
[Estudante] Ben, non é exceso de número enteiro cando está tentando poñer un número no que

417
00:39:13,640 --> 00:39:16,640
maior que a cantidade de bits que recibe?

418
00:39:16,640 --> 00:39:23,730
Si Temos 4 bits. Isto - que tivo 4 bits, que intente engadir un para ela, entón imos acabar con 5 bits.

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

420
00:39:26,690 --> 00:39:28,970
Pode, de feito -

421
00:39:28,970 --> 00:39:33,010
[Estudante] Será que xogue un erro, ou fai iso - tería que publicar un erro?

422
00:39:33,010 --> 00:39:40,720
Non entón non hai erro. Cando chegar ao nivel da montaxe, un pouco especial

423
00:39:40,720 --> 00:39:47,020
en algún lugar está definido que dixo que houbo un estourido, pero en C que medio que simplemente non tratar con isto.

424
00:39:47,020 --> 00:39:55,160
Realmente non pode tratar con isto, a menos que use instrucións de montaxe especiais en C.

425
00:39:55,160 --> 00:39:58,110
Imos pensar sobre XOR cambio.

426
00:39:58,110 --> 00:40:02,220
E eu creo que o artigo da Wikipedia tamén pode vir a dicir que -

427
00:40:02,220 --> 00:40:07,310
Por iso, tamén trouxeron aritmética modular, entón eu creo que era, en teoría, a aritmética modular

428
00:40:07,310 --> 00:40:11,160
cando dixo que 0-1 é de 15 novo.

429
00:40:11,160 --> 00:40:15,410
Para que poida, de feito - un procesador estándar que fai 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Dende que acabar en 0, restar 1, así el só enrola de volta en torno a 1111.

431
00:40:20,430 --> 00:40:28,930
Polo tanto, este algoritmo pode realmente funciona, a a + b, a - b, b - a, que pode ser óptimo.

432
00:40:28,930 --> 00:40:34,030
Pero hai algúns procesadores que non facelo, e por iso non quedaría ben en aqueles específicos.

433
00:40:34,030 --> 00:40:39,880
Cambio de XOR funcionará en calquera procesador. Okay.

434
00:40:39,880 --> 00:40:42,280
A idea é que el debería ser o mesmo, con todo.

435
00:40:42,280 --> 00:40:50,120
Onde estamos usando XOR dalgunha forma obter a información de ambos nunha das variables,

436
00:40:50,120 --> 00:40:54,120
e, a continuación, elimina a información das variables individuais de novo.

437
00:40:54,120 --> 00:41:04,330
Entón, alguén ten ideas / a resposta?

438
00:41:04,330 --> 00:41:14,540
[Responder Estudante, inintelixible]

439
00:41:14,540 --> 00:41:22,220
Polo tanto, este debe funcionar, e tamén, XOR é conmutativa.

440
00:41:22,220 --> 00:41:27,620
Independentemente de cal orde estes dous números que ser ata aquí,

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

442
00:41:30,100 --> 00:41:35,800
Entón a ^ b e b ^ a.

443
00:41:35,800 --> 00:41:51,860
Tamén podes ver este escrito como un ^ = b, b ^ = a, a ^ = b novo.

444
00:41:51,860 --> 00:42:00,200
Entón, iso é certo, e ver por que isto funciona, creo que dos bits.

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

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

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

448
00:42:15,540 --> 00:42:22,380
Nós imos estar definindo "a" = a XOR destas dúas cousas.

449
00:42:22,380 --> 00:42:32,920
Entón, 1 ^ 0 e 1, 1 ^ 1 e 0, 0 ^ 1 e 1, e 0 ^ 0 0, 1 ^ 0 e 1.

450
00:42:32,920 --> 00:42:37,380
So 'unha', se ollar o número decimal, que vai ser -

451
00:42:37,380 --> 00:42:41,160
non vai ver moito dunha relación entre o orixinal 'a' eo novo 'a',

452
00:42:41,160 --> 00:42:45,600
pero mirando para os bits, 'a' agora como unha malla de información

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

454
00:42:49,970 --> 00:42:57,930
Entón, se tomamos b ^ a, vemos que imos terminar no orixinal 'un'.

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

456
00:43:08,910 --> 00:43:18,380
Entón, (a ^ b) ^ b = orixinal 'a'.

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

458
00:43:27,910 --> 00:43:37,010
Non hai - outra forma de ver isto é XOR nada en si é sempre 0.

459
00:43:37,010 --> 00:43:45,020
Así, 1101 ^ 1101, todos os bits van ser os mesmos.

460
00:43:45,020 --> 00:43:47,920
Entón non vai ser un caso en que un é un 0 eo outro é un.

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

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

463
00:43:57,240 --> 00:44:03,680
(B ^ b) será 0; a ^ 0 é só vai ser 'a', xa que todos os bits son 0.

464
00:44:03,680 --> 00:44:08,050
Así, os únicos que están indo para estar onde 'a' era orixinalmente un 1 - tiña uns.

465
00:44:08,050 --> 00:44:12,070
E a mesma idea aquí, eu estou seguro que el tamén é conmutativa.

466
00:44:12,070 --> 00:44:17,590
Si Eu dixen antes que era conmutativa.

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

468
00:44:24,680 --> 00:44:28,970
E podemos facer b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
E entón, de novo, temos a b orixinal.

470
00:44:31,540 --> 00:44:37,120
Así, 'a' é agora a combinación de 'a' e b en conxunto.

471
00:44:37,120 --> 00:44:49,660
Usando a nosa nova combinación 'a' dicimos b = combinación 'a' ^ b do orixinal, temos o orixinal 'a'.

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

473
00:45:05,170 --> 00:45:13,620
Iso é caso aquí. Este é = b, b idade.

474
00:45:13,620 --> 00:45:16,550
Entón agora todo está de volta na orde trocada.

475
00:45:16,550 --> 00:45:22,960
Se realmente mirou para os bits, b = a ^ b, vai XOR estes dous,

476
00:45:22,960 --> 00:45:33,920
ea resposta vai ser iso, e entón a = a ^ b é XORing estes dous ea resposta é esta.

477
00:45:33,920 --> 00:45:41,090
Preguntas? Okay. Así, o último é un pouco significativamente máis difícil.

478
00:45:41,090 --> 00:45:43,180
[Estudante] Coido que ten unha pregunta sobre iso. >> Oh, desculpe.

479
00:45:43,180 --> 00:45:49,380
[Alumno] O que é realmente máis rápido? Se usar este XOR, ou se se declara unha nova variable?

480
00:45:49,380 --> 00:45:55,190
Entón, o que é realmente máis rápido, declarando unha nova variable ou usando XOR para intercambiar?

481
00:45:55,190 --> 00:45:59,600
A resposta é, con toda probabilidade, dunha variable temporal.

482
00:45:59,600 --> 00:46:05,780
E iso porque unha vez que está feita para abaixo - así no nivel da montaxe,

483
00:46:05,780 --> 00:46:12,320
non hai tal cousa como variables locais ou calquera variables temporais ou calquera destas cousas.

484
00:46:12,320 --> 00:46:16,060
Son como - non hai memoria, e existen rexistros.

485
00:46:16,060 --> 00:46:20,920
Os rexistros son onde as cousas están a ocorrer activamente.

486
00:46:20,920 --> 00:46:24,750
Non engadir dúas cousas na memoria, engade dúas cousas en rexistros.

487
00:46:24,750 --> 00:46:28,160
E levar as cousas de memoria para os rexistros despois engadila los,

488
00:46:28,160 --> 00:46:33,180
e entón pode poñer-los de volta na memoria, pero toda a acción ocorre en rexistros.

489
00:46:33,180 --> 00:46:38,750
Entón, cando está usando o achegamento temporal variable, xeralmente o que pasa é

490
00:46:38,750 --> 00:46:42,810
eses dous números xa están en rexistros.

491
00:46:42,810 --> 00:46:46,570
E entón, a partir dese punto, despois de trocar eles,

492
00:46:46,570 --> 00:46:51,540
el só vai comezar a usar o outro rexistro.

493
00:46:51,540 --> 00:46:56,510
En calquera lugar que estaba usando b, el só vai usar o rexistro que xa estaba almacenando 'a'.

494
00:46:56,510 --> 00:47:02,180
Por iso, non é preciso facer nada para realmente facer o intercambio. Si?

495
00:47:02,180 --> 00:47:05,690
[Estudante] Pero tamén ten máis memoria, non?

496
00:47:05,690 --> 00:47:10,280
Só vai ter máis memoria, se precisa para almacenar a variable temporal.

497
00:47:10,280 --> 00:47:14,830
Como se usa máis tarde que a variable temporal de novo en algún lugar,

498
00:47:14,830 --> 00:47:18,920
entón - ou atribúe algo para esa variable temporal.

499
00:47:18,920 --> 00:47:24,630
Así, en calquera punto no tempo "a," b tempo teñen valores diferentes ou algo así,

500
00:47:24,630 --> 00:47:30,680
a continuación, que vai ter locais distinguidos na memoria, pero é certo que

501
00:47:30,680 --> 00:47:34,800
hai moitas variables locais, que só existen en rexistros.

502
00:47:34,800 --> 00:47:44,370
Neste caso, nunca é colocada na memoria, e así nunca está perdendo a memoria.

503
00:47:44,370 --> 00:47:58,620
Okay. Última pregunta é un pouco máis.

504
00:47:58,620 --> 00:48:04,850
Entón, aquí, neste aparello CS50, hai un dicionario.

505
00:48:04,850 --> 00:48:12,390
E a razón para iso é porque [? B66] é un corrector ortográfico onde vai escribir

506
00:48:12,390 --> 00:48:15,780
o uso de táboas de hash ou intenta ou algunha estrutura de datos.

507
00:48:15,780 --> 00:48:22,660
Vai estar escribindo un corrector ortográfico, e vai estar usando este dicionario para facelo.

508
00:48:22,660 --> 00:48:28,280
Pero a este problema, imos só ollar para arriba para ver se é unha soa palabra no dicionario.

509
00:48:28,280 --> 00:48:31,250
Entón, en vez de almacenar dicionario enteiro nalgunha estrutura de datos

510
00:48:31,250 --> 00:48:35,180
e, a continuación, ollando para un documento enteiro para ver se algo está incorrecto,

511
00:48:35,180 --> 00:48:38,490
só queremos atopar unha palabra. Así, podemos só dixitalizar sobre o dicionario enteiro

512
00:48:38,490 --> 00:48:44,300
e nunca atopamos a palabra no dicionario enteiro, entón el non estaba alí.

513
00:48:44,300 --> 00:48:52,150
Se a pescudas sobre o dicionario enteiro e non ver a palabra, entón estamos ben, nós o atopamos.

514
00:48:52,150 --> 00:48:56,580
Di aquí que queremos comezar a ollar para a función C de manipulación de arquivos,

515
00:48:56,580 --> 00:48:59,930
xa que queremos ler o dicionario,

516
00:48:59,930 --> 00:49:07,680
pero vou dar a información aquí, como para as funcións que ten que pensar.

517
00:49:07,680 --> 00:49:11,510
Vou escribir-los espazos.

518
00:49:11,510 --> 00:49:20,490
Así, os principais que vai querer ollar para f son abertos e, entón, inevitablemente, f pechada,

519
00:49:20,490 --> 00:49:26,540
que vai ao final do seu programa, e f f dixitalización.

520
00:49:26,540 --> 00:49:31,060
Tamén pode usar f ler, pero probablemente non quere

521
00:49:31,060 --> 00:49:34,200
porque iso - non acabar precisando diso.

522
00:49:34,200 --> 00:49:41,880
F f varrido é o que vai empregar para dixitalizar sobre o dicionario.

523
00:49:41,880 --> 00:49:46,370
E para que non precisa codificar a solución, só tentar e como pseudo-código o seu camiño

524
00:49:46,370 --> 00:50:05,200
a unha solución, e despois imos discutir iso.

525
00:50:05,200 --> 00:50:14,110
E, de feito, sempre que eu xa che dei estes, se vostede poñerse en calquera terminal ou shell do seu dispositivo,

526
00:50:14,110 --> 00:50:18,250
Eu - Eu normalmente - se aínda non viu, eu non sei se fixo en clase,

527
00:50:18,250 --> 00:50:23,490
pero o home, de xeito que as páxinas do manual, son bastante útiles para ollar para practicamente calquera función.

528
00:50:23,490 --> 00:50:27,330
Entón eu podo facer, como, f home, dixitalización f.

529
00:50:27,330 --> 00:50:32,300
Esta é agora a información sobre a familia f varrido de funcións.

530
00:50:32,300 --> 00:50:37,070
Eu tamén podería facer f home, abertos, e que me vai dar máis detalles do que iso.

531
00:50:37,070 --> 00:50:40,750
Entón, se sabe cal é a función que está a usar, ou estás lendo código

532
00:50:40,750 --> 00:50:43,000
e ve algunha función e pensa, "O que iso fai?"

533
00:50:43,000 --> 00:50:45,280
Só un home nome da función que.

534
00:50:45,280 --> 00:50:47,340
Hai un par de exemplos estraños, onde pode ter que dicir

535
00:50:47,340 --> 00:50:51,620
gusto. home 2, que o nome da función, ou o home que 3 nome da función,

536
00:50:51,620 --> 00:50:58,230
pero só tes que facelo o nome de función de home non acontecer a traballar por primeira vez.

537
00:50:58,230 --> 00:51:03,010
[Estudante] Entón, eu estou lendo a páxina man para abrir, pero aínda estou confuso sobre como usalo eo programa.

538
00:51:03,010 --> 00:51:06,170
Okay. Unha morea de páxinas de manual son menos que útil.

539
00:51:06,170 --> 00:51:08,470
Son máis útiles se xa sabe o que facer

540
00:51:08,470 --> 00:51:12,670
e entón só precisa lembrar da orde dos argumentos ou algo así.

541
00:51:12,670 --> 00:51:17,640
Ou poden dar unha visión xeral, pero algúns deles son moi grande.

542
00:51:17,640 --> 00:51:22,220
Como f varrido f, tamén. El lle dá a información para todas estas funcións,

543
00:51:22,220 --> 00:51:28,120
e unha liña de baixo aquí acontece a dicir, "F varrido f le dende o punto de corda ou cadea."

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

545
00:51:32,360 --> 00:51:38,470
A idea dun programa que precisa facer ficheiro I / O é que

546
00:51:38,470 --> 00:51:45,070
primeiro ten que abrir o arquivo que quere facer as cousas con e, inevitablemente,

547
00:51:45,070 --> 00:51:51,220
ler cousas dese ficheiro e facer cousas con eles.

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

549
00:51:55,350 --> 00:52:04,190
O único que volver, entón o arquivo que queremos abrir, dános a -

550
00:52:04,190 --> 00:52:11,970
aquí el di que "usuario / / share Dict / / palabras".

551
00:52:11,970 --> 00:52:16,740
Este é o ficheiro que quere abrir, e queremos abrilo -

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

553
00:52:21,440 --> 00:52:26,490
Hai un par de combinacións e outras cousas, pero queremos abrir este para lectura.

554
00:52:26,490 --> 00:52:29,380
Queremos ler desde o ficheiro.

555
00:52:29,380 --> 00:52:34,290
Así que este retorno? El retorna un arquivo de estrela (*),

556
00:52:34,290 --> 00:52:37,260
e eu vou amosar todo na variable f, entón *,

557
00:52:37,260 --> 00:52:40,840
de novo, é un punteiro, pero non queren tratar con punteiros.

558
00:52:40,840 --> 00:52:46,470
Podes pensar en f como f agora é a variable que vai empregar para representar o arquivo.

559
00:52:46,470 --> 00:52:49,850
Entón, se quere ler o ficheiro, le a partir de f.

560
00:52:49,850 --> 00:52:54,820
Se queres pechar o ficheiro, pecha f.

561
00:52:54,820 --> 00:53:00,350
Así, a finais do programa, cando inevitablemente quere pechar o ficheiro, o que temos que facer?

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

563
00:53:06,750 --> 00:53:12,600
Entón, agora a función de último arquivo que imos querer usar é varrido f, f f dixitalización.

564
00:53:12,600 --> 00:53:20,930
E o que iso fai é que varreu sobre o arquivo buscando un patrón para responder.

565
00:53:20,930 --> 00:53:39,100
Mirando á páxina home aquí vemos int f f dixitalización, ignorar o valor de retorno para agora.

566
00:53:39,100 --> 00:53:45,230
O primeiro argumento é o fluxo de ficheiro *, de xeito que o primeiro argumento que imos querer pasar é f.

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

568
00:53:47,900 --> 00:53:53,680
O segundo argumento é unha secuencia de formato.

569
00:53:53,680 --> 00:53:58,310
Vou dar-lle unha secuencia de formato agora.

570
00:53:58,310 --> 00:54:05,180
Creo que acontecer que dicir, 127s \ n, unha morea de que é necesario.

571
00:54:05,180 --> 00:54:12,490
A idea de que esa secuencia de formato, é que pode pensar de f dixitalización como o oposto de f impresión.

572
00:54:12,490 --> 00:54:17,160
Entón f impresión, impresión f tamén usan este tipo de parámetro formato,

573
00:54:17,160 --> 00:54:25,000
pero en f impresión que estamos facendo é - imos ollar para un equivalente.

574
00:54:25,000 --> 00:54:32,550
Así imprimir f, e non hai, en realidade tamén f impresión f, onde o primeiro argumento será f.

575
00:54:32,550 --> 00:54:40,980
Ao imprimir f, poderiamos dicir algo así como, "print 127s \ n" e despois pasar algunha corda,

576
00:54:40,980 --> 00:54:44,050
que vai imprimir esa cadea e logo unha nova liña.

577
00:54:44,050 --> 00:54:49,690
O que 127 significa, eu estou seguro, pero eu nunca me restrinxido a el,

578
00:54:49,690 --> 00:54:52,470
Non é preciso nin dicir '127 'en f impresión,

579
00:54:52,470 --> 00:54:57,090
pero o que significa imprimir os primeiros 127 carácteres.

580
00:54:57,090 --> 00:54:59,350
Entón, eu estou seguro que é o caso. Podes Google para iso.

581
00:54:59,350 --> 00:55:03,000
Pero o próximo que eu teño case seguro que significa iso.

582
00:55:03,000 --> 00:55:08,880
Polo tanto, esta é imprimir os primeiros 127 carácteres, seguido por unha nova liña.

583
00:55:08,880 --> 00:55:14,680
F varrido f agora, en vez de ollar a unha variable e imprimir lo,

584
00:55:14,680 --> 00:55:22,620
vai mirar para algunhas cordas, e almacenar o estándar para a variable.

585
00:55:22,620 --> 00:55:26,360
Imos realmente usar f verificación nun exemplo diferente.

586
00:55:26,360 --> 00:55:31,670
Entón, imos dicir que tivemos algúns int, x = 4,

587
00:55:31,670 --> 00:55:41,110
e queriamos crear unha cadea de feitos - quería crear a cadea

588
00:55:41,110 --> 00:55:44,250
que era como este vai aparecer moito máis tarde,

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

590
00:55:49,020 --> 00:55:51,870
Polo tanto, este pode ser un programa onde terá contador de suma,

591
00:55:51,870 --> 00:55:56,420
Resumindo combater i, e quere gardar unha chea de imaxes.

592
00:55:56,420 --> 00:56:02,430
Entón quere gardar i.jpg, onde i é algunha iteração do loop.

593
00:56:02,430 --> 00:56:05,500
Entón, como imos facer esa secuencia para que o JPEG?

594
00:56:05,500 --> 00:56:11,720
Se queres imprimir 4.jpg, podemos só dicir f impresión, d.jpg%

595
00:56:11,720 --> 00:56:14,410
e entón el vai imprimir para que o JPEG.

596
00:56:14,410 --> 00:56:20,050
Pero, se queremos salvar o 4.jpg cadea, usan f dixitalización.

597
00:56:20,050 --> 00:56:30,860
Así cadea s - na verdade, non podo - personaxe, char s, imos 100.

598
00:56:30,860 --> 00:56:35,400
Entón, eu só dixo algunha matriz de 100 caracteres,

599
00:56:35,400 --> 00:56:39,830
e iso é o que nós estamos, inevitablemente, vai estar almacenando que JPEG dentro

600
00:56:39,830 --> 00:56:47,920
Entón, nós estamos indo a usar f, dixitalización e do formato, como diriamos d.jpg%

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

602
00:56:54,980 --> 00:57:04,020
Así, o formato é d.jpg%, o que queremos para substituír d% con é x,

603
00:57:04,020 --> 00:57:06,590
e agora necesitamos almacenar esa cadea en algún lugar.

604
00:57:06,590 --> 00:57:12,500
E onde estamos indo para almacenar esta cadea está na matriz s.

605
00:57:12,500 --> 00:57:21,640
Entón, despois de esta liña de código, s, se imprimir f% s, da variable 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ón f varrido f é o mesmo que f varrido, só que agora está a mirar para este ficheiro

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

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

610
00:57:46,160 --> 00:57:54,170
Queremos gravar - "familia f dixitalización de exames de funcións tanto no acordo co formato como intentou a continuación.

611
00:57:54,170 --> 00:58:02,450
Se o son almacenados nos puntos de localización pode volver - "

612
00:58:02,450 --> 00:58:12,910
Non pode ser bo. Deixe-me pensar por un segundo.

613
00:58:12,910 --> 00:58:26,350
Entón varrido f non fai - o que diaños é a función que fai iso?

614
00:58:26,350 --> 00:58:31,650
Entón varrido f non vai levar un enteiro e facer punto jpg.

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

616
00:58:43,490 --> 00:58:49,360
Salva variable int en cadea int C.

617
00:58:49,360 --> 00:58:55,940
¿Que é esta variable, ou o que é esta función chamada?

618
00:58:55,940 --> 00:59:04,950
Si Isto - si. Entón, o que eu estaba definindo a vostede antes era s f de impresión,

619
00:59:04,950 --> 00:59:09,820
que - que fai moito máis sentido, por iso que eu dixo que era moito máis como f impresión.

620
00:59:09,820 --> 00:59:14,700
Dixitalización f aínda é tipo como de f impresión, pero s f impresión vai examina-lo máis de

621
00:59:14,700 --> 00:59:17,510
e substituír as variables e, agora, almacena-lo nunha corda.

622
00:59:17,510 --> 00:59:19,620
En vez de imprimir, el almacena en unha cadea.

623
00:59:19,620 --> 00:59:25,070
Así, ignorar que enteiramente. Aínda pode pensar en como o especificador de formato semellante ao f impresión.

624
00:59:25,070 --> 00:59:34,510
Entón, agora, se quixésemos facer as cousas 4.jpg, fariamos s f impresión, x iso.

625
00:59:34,510 --> 00:59:38,520
Entón, o que está facendo pescudas f - Cal foi a súa pregunta vai ser?

626
00:59:38,520 --> 00:59:40,820
[Estudante] Eu só estou confuso sobre o que estamos intentando facer aquí

627
00:59:40,820 --> 00:59:43,450
que o JPEG. Podes explicar que un tempo máis?

628
00:59:43,450 --> 00:59:52,710
Polo tanto, este foi - é menos relevent para f varrido f agora, espero, vai amarre de volta en algún tipo de camiño.

629
00:59:52,710 --> 01:00:02,240
Pero o que eu inicialmente tiña a intención de amosar era - esta é, en realidade, directamente relevante para estes [? F5]

630
01:00:02,240 --> 01:00:08,520
Vai estar usando s f de impresión, onde, dicir que temos 100 imaxes,

631
01:00:08,520 --> 01:00:13,630
e quere ler a imaxe 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Polo tanto, a fin de facelo, ten que f aberta, e entón ten que pasar a secuencia que quere abrir.

633
01:00:21,520 --> 01:00:30,020
Entón, quere abrir 1.jpg;, a fin de crear a cadea que é 1.jpg,

634
01:00:30,020 --> 01:00:37,660
facemos s f impresión de% d.jpg-non fixemos 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ón s% f d.jpg impresión de i.

637
01:00:51,130 --> 01:00:56,320
Entón, despois desta liña, agora a variable ou matriz s vai 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Ou, 0.jpg, 1.jpg, 2.jpg. E así podemos abrir, á súa vez, cada imaxe para ler.

639
01:01:10,610 --> 01:01:19,550
Entón é iso que s imprimir f fai. Vostede ve o que s imprimir f está facendo agora?

640
01:01:19,550 --> 01:01:25,720
[Estudante] Ok, entón está tomando - el crea unha cadea, something.jpg, e despois almacena.

641
01:01:25,720 --> 01:01:30,360
Si El crea - esta é outra secuencia de formato, así como pescudas F e F de impresión,

642
01:01:30,360 --> 01:01:37,530
onde se insere todas as variables para o segundo argumento, pode s en oposición ao i.

643
01:01:37,530 --> 01:01:42,280
Quizais - quero dicir, este é o caso. Pero calquera que sexa a orde dos argumentos é.

644
01:01:42,280 --> 01:01:45,440
Vai para introducir todas as variables para a cadea de formato

645
01:01:45,440 --> 01:01:52,250
e despois gardar no noso buffer; chamamos iso de un buffer, que é onde estamos almacenando a cadea.

646
01:01:52,250 --> 01:02:00,750
Entón, nós estamos almacenando dentro s a cadea formato correctamente, d%, sendo substituído por 4.

647
01:02:00,750 --> 01:02:08,080
[Estudante] Entón, se fixésemos iso, é a variable f só vai ser trasladado?

648
01:02:08,080 --> 01:02:18,110
Si Así, debemos pechar o orixinal f antes de facelo.

649
01:02:18,110 --> 01:02:22,810
Pero - e entón, tamén, se non houbese un f abrir aquí, entón sería preciso dicir -

650
01:02:22,810 --> 01:02:29,280
Si Pero sería abrir un centenar de arquivos diferentes.

651
01:02:29,280 --> 01:02:37,360
[Estudante] Mais non sería capaz de acceder ou - ok.

652
01:02:37,360 --> 01:02:44,230
Okay. Entón varrido f, f varrido f, é unha especie da mesma idea,

653
01:02:44,230 --> 01:02:53,610
pero en vez de, en vez de almacena-lo nunha corda, é máis como está agora

654
01:02:53,610 --> 01:03:02,420
pasando por unha picada e matrimonio de estándares contra esa secuencia e almacenar os resultados variables.

655
01:03:02,420 --> 01:03:11,290
Podes empregar f varrido para analizar sobre algo 4.jpg, e almacenar a 4 enteiro int x suma.

656
01:03:11,290 --> 01:03:13,430
Isto é o que podemos utilizar para f pescudas.

657
01:03:13,430 --> 01:03:16,300
F varrido f vai facer na liña de comandos.

658
01:03:16,300 --> 01:03:19,200
Eu estou realmente seguro de que isto é o que a biblioteca CS50 fai.

659
01:03:19,200 --> 01:03:29,050
Entón, cando di, "obter int," e exame f-ing máis - f verificación é o xeito que obter entrada do usuario.

660
01:03:29,050 --> 01:03:34,670
F varrido f vai facer a mesma cousa, pero usando un arquivo de dixitalizar máis.

661
01:03:34,670 --> 01:03:41,090
Entón, aquí estamos pescudas sobre este ficheiro.

662
01:03:41,090 --> 01:03:45,460
O estándar que estamos intentando combinar algunha cadea que é de 127 caracteres

663
01:03:45,460 --> 01:03:48,100
seguido por unha nova liña

664
01:03:48,100 --> 01:03:54,770
Entón, eu estou seguro que nós poderíamos mesmo dicir "corresponder s", xa que no dicionario

665
01:03:54,770 --> 01:03:57,770
acontece que temos, estamos garantir ningunha palabra é moito tempo,

666
01:03:57,770 --> 01:04:03,310
e tamén f f Scania, eu creo, vai parar na liña de novo, non importa o que.

667
01:04:03,310 --> 01:04:06,970
Pero imos incluír a liña nova no xogo, e -

668
01:04:06,970 --> 01:04:13,960
[Estudante] Se non incluír a nova liña, non sería atopar partes dunha palabra?

669
01:04:13,960 --> 01:04:22,900
El - cada un - ollando para o dicionario -

670
01:04:22,900 --> 01:04:26,200
Así, no dicionario, estas son todas as nosas palabras.

671
01:04:26,200 --> 01:04:30,500
Cada un está nunha nova liña.

672
01:04:30,500 --> 01:04:32,510
O f varrido vai pegar esa palabra.

673
01:04:32,510 --> 01:04:38,750
Se non incluir a liña nova, entón é posible que o f próxima pescudas só vai ler a nova liña.

674
01:04:38,750 --> 01:04:44,180
Pero incluíndo nova liña entón simplemente ignorar a nova liña.

675
01:04:44,180 --> 01:04:49,440
Pero nós nunca imos conseguir parte dunha palabra, unha vez que estamos sempre lendo-se a unha nova liña, non importa o que.

676
01:04:49,440 --> 01:04:54,530
[Estudante] Pero e se buscar a palabra "Cissa", como Cissa.

677
01:04:54,530 --> 01:04:57,380
Será que vai atopar iso, e dicir que é un xogo?

678
01:04:57,380 --> 01:05:05,110
Entón aquí estamos nós - el ha ler a - este é realmente un bo punto.

679
01:05:05,110 --> 01:05:10,660
Nós nunca está usando o actual - a palabra que estamos a buscar é o primeiro argumento da liña de comandos.

680
01:05:10,660 --> 01:05:16,460
Así a palabra de corda, argv = 1.

681
01:05:16,460 --> 01:05:20,020
Así que a corda que estamos a buscar é unha argv.

682
01:05:20,020 --> 01:05:23,290
Non estamos á procura dunha palabra en todo na nosa f dixitalización.

683
01:05:23,290 --> 01:05:28,030
O que estabamos facendo pescudas f está quedando cada palabra no dicionario,

684
01:05:28,030 --> 01:05:34,320
e, a continuación, unha vez que temos que palabra imos usar strcmp para comparalos-los.

685
01:05:34,320 --> 01:05:39,210
Imos comparar a nosa palabra eo que acabamos de ler dentro

686
01:05:39,210 --> 01:05:45,110
Entón, inevitablemente, imos acabar facendo unha morea de varrido FS

687
01:05:45,110 --> 01:05:52,130
ata que iso só acontece que f dixitalización vai volver -

688
01:05:52,130 --> 01:05:54,800
ela retorne un, sempre que igualou unha nova palabra,

689
01:05:54,800 --> 01:06:01,360
e volverá algo máis, logo que fallou para coincidir coa palabra.

690
01:06:01,360 --> 01:06:08,440
Estamos lendo todo o dicionario, almacenar liña por liña en cada palabra variable s.

691
01:06:08,440 --> 01:06:17,240
A continuación, nós estamos comparando coa palabra s, e se a comparación == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp pasa para traer 0 un xogo foi feito.

693
01:06:21,650 --> 01:06:31,510
Entón, se é 0, entón podemos imprimir f, combinados,

694
01:06:31,510 --> 01:06:35,370
ou palabra no dicionario, ou o que quere imprimir f.

695
01:06:35,370 --> 01:06:41,450
E entón - non queremos f pechar unha e outra vez.

696
01:06:41,450 --> 01:06:50,410
Este é o tipo de cousas que queremos facer, e non estamos só á procura de palabra no dicionario.

697
01:06:50,410 --> 01:06:56,660
Entón, nós poderíamos facer isto, se queremos mirar para o seu estándar, Cissa, como dixen antes,

698
01:06:56,660 --> 01:07:00,260
se quería mirar para este estándar, entón ía fallar no caso

699
01:07:00,260 --> 01:07:08,010
porque iso non é realmente unha palabra, pero unha das palabras no dicionario pasa de ter que nel.

700
01:07:08,010 --> 01:07:13,560
Polo tanto, sería combinar esa palabra, pero este subconxunto da palabra non é unha palabra en si.

701
01:07:13,560 --> 01:07:17,250
Pero non é así que estamos a usalo, estamos lendo cada palabra

702
01:07:17,250 --> 01:07:19,740
e despois comparando a palabra que temos con esa palabra.

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

704
01:07:25,780 --> 01:07:29,620
Podo enviar as solucións finalizados despois.

705
01:07:29,620 --> 01:07:32,050
Este é o tipo de case a resposta correcta, eu creo.

706
01:07:32,050 --> 01:07:34,720
[Comentario do estudante, inintelixible]

707
01:07:34,720 --> 01:07:40,870
Ah, eu se librar do que antes? Char s, creo que dixo 127 - eu esquezo o que o maior é.

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

709
01:07:44,100 --> 01:07:46,570
Non precisa imprimir nada.

710
01:07:46,570 --> 01:07:56,440
Tamén imos querer ter que pechar o seu arquivo, e que debe ser sobre a resposta correcta.

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