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, Universidad de Harvard

3
00:00:04,910 --> 00:00:07,410
Esto es CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Por lo tanto, soy Rob. Soy estudiante de último año en Kirkland. Este es mi tercer año TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Es la primera vez que estamos cambiando de la sección tradicional conferencia-estilo,

6
00:00:22,220 --> 00:00:25,610
donde sólo un poco de lo que sucedió en opinión conferencia y luego ustedes hacer preguntas,

7
00:00:25,610 --> 00:00:32,250
ahora a ser mucho más basado en problemas, donde utilizamos los espacios, y -

8
00:00:32,250 --> 00:00:37,410
Oh, así que la idea es ir al enlace que te envié y luego vas a estar en mi espacio.

9
00:00:37,410 --> 00:00:42,410
¿Nadie tiene una computadora portátil? Bien.

10
00:00:42,410 --> 00:00:47,050
Así que vamos a usar esto, y vamos a estar haciendo los problemas de vivir en la sección

11
00:00:47,050 --> 00:00:50,740
y discutirlas y averiguar lo que está mal

12
00:00:50,740 --> 00:00:56,390
y yo podría tirar un poco de su código, y yo podría hablar de sus ideas.

13
00:00:56,390 --> 00:01:02,140
Entonces, ¿alguien ha tenido problemas?

14
00:01:02,140 --> 00:01:07,000
Puedes chatear en el lado, yo no sé si tendremos razón para ello.

15
00:01:07,000 --> 00:01:12,270
Ahora, como el supersección anterior, si estuviera en esa clase, ya sabes de qué se trata.

16
00:01:12,270 --> 00:01:19,200
En todos los conjuntos P que va a ser estas secciones.

17
00:01:19,200 --> 00:01:22,550
Entonces P-set 2, pliego de condiciones, supongo que lo vi en P-1 juego ya.

18
00:01:22,550 --> 00:01:27,400
Pero podemos ver P-set 2 para lo que vamos a ir sobre la actualidad.

19
00:01:27,400 --> 00:01:29,460
Y verás una sección de preguntas.

20
00:01:29,460 --> 00:01:37,530
Así que esto va a ser en todos los P-series, habrá una sección de preguntas.

21
00:01:37,530 --> 00:01:41,340
Hasta ahora hemos dicho: "Considere esto una oportunidad para practicar".

22
00:01:41,340 --> 00:01:44,940
No se le pidió que presentara este programa.

23
00:01:44,940 --> 00:01:48,480
La idea es que estos se supone que el tipo de ayuda a empezar con el conjunto de problemas.

24
00:01:48,480 --> 00:01:53,220
Supongo que en la edición de Hacker, muchos de ellos se supone que son sólo cosas nuevas e interesantes que aprender.

25
00:01:53,220 --> 00:01:58,590
Puede que no sean directamente aplicables al conjunto de problemas.

26
00:01:58,590 --> 00:02:01,810
Y en este momento no vamos a tener que someterlos, pero en teoría,

27
00:02:01,810 --> 00:02:07,480
para conjuntos de problemas posteriores, es posible que los presente, y por lo tanto usted puede venir a la sección

28
00:02:07,480 --> 00:02:10,380
o mirar la sección para obtener las respuestas, o simplemente puedes conseguirlos por su cuenta

29
00:02:10,380 --> 00:02:16,350
si usted no tiene ganas de disfrutar de mi presencia.

30
00:02:16,350 --> 00:02:21,010
Así que el - Creo que esta es la primera.

31
00:02:21,010 --> 00:02:29,280
Oh. Además, en estas secciones de preguntas ya os hemos hará preguntas acerca de los pantalones cortos.

32
00:02:29,280 --> 00:02:33,440
Así que supongo que, en teoría, se supone que debes ver esto antes de llegar a la sección,

33
00:02:33,440 --> 00:02:38,550
pero está bien si no lo hace, vamos a ir sobre ellos de todos modos.

34
00:02:38,550 --> 00:02:42,590
Así que podemos comenzar con éstas: "¿Cómo un bucle while difieren de un bucle do-while?

35
00:02:42,590 --> 00:02:46,210
¿Cuándo es el último particularmente útil? "

36
00:02:46,210 --> 00:02:49,390
Así que alguien tiene alguna -

37
00:02:49,390 --> 00:02:52,730
[Estudiante] El do-while siempre se ejecutará al menos una vez.

38
00:02:52,730 --> 00:03:02,950
Sí. Así que esa es la diferencia. Un bucle while - I'Ll hazlo aquí - bucle while, tenemos la condición

39
00:03:02,950 --> 00:03:19,760
aquí mismo, mientras que un do-while, usted no tiene una condición hasta que lleguemos hasta aquí.

40
00:03:19,760 --> 00:03:24,130
Y así, cuando el programa se ejecuta, y se pone al bucle while,

41
00:03:24,130 --> 00:03:26,380
inmediatamente se comprueba si se cumple esta condición.

42
00:03:26,380 --> 00:03:30,710
Si esa condición no es cierto, se acaba de saltar el bucle completo.

43
00:03:30,710 --> 00:03:34,390
Do-while, ya que el programa se está ejecutando, se pone al "hacer".

44
00:03:34,390 --> 00:03:37,920
Nada sucede en este momento, sólo continúa ejecutando.

45
00:03:37,920 --> 00:03:42,690
Luego cuando llega el "tiempo", si la condición es verdadera, que va a tejer por atrás y hacerlo de nuevo

46
00:03:42,690 --> 00:03:46,730
y una y otra vez hasta que la condición no es verdadera y entonces sólo se concreta.

47
00:03:46,730 --> 00:03:50,600
Por lo tanto, la diferencia es, que esto puede pasar directamente desde el principio.

48
00:03:50,600 --> 00:03:56,770
Esto necesariamente se ejecuta una vez y luego puede ejecutar más veces si la condición sigue siendo cierto.

49
00:03:56,770 --> 00:04:03,720
De modo que el bucle mientras que sólo lo hará una vez, o - el bucle while - no tenga que hacerlo en absoluto,

50
00:04:03,720 --> 00:04:07,900
ya que en cuanto lleguemos a él, si la condición es falsa, sólo tendremos que pasar directamente sobre él.

51
00:04:07,900 --> 00:04:11,770
Considerando que el do-while, lo vamos a ejecutar una vez, necesariamente.

52
00:04:11,770 --> 00:04:14,560
Entonces, cuando llegamos a la condición, comprobamos si es cierto o falso.

53
00:04:14,560 --> 00:04:19,790
Si es cierto, vamos a hacerlo de nuevo, y si es falso, sólo tendremos que seguir adelante.

54
00:04:19,790 --> 00:04:24,680
Por eso, cuando es este último particularmente útil?

55
00:04:24,680 --> 00:04:31,190
Así que puedo decir que en la totalidad de los 4 años, 3 años, lo que sea,

56
00:04:31,190 --> 00:04:38,780
que he estado programando, he utilizado este, al igual que, menos de 10 veces.

57
00:04:38,780 --> 00:04:43,140
Y, probablemente, cinco de ellos están en CS50 cuando estamos introduciendo do-while.

58
00:04:43,140 --> 00:04:47,510
Así que cuando usted utiliza do-while?

59
00:04:47,510 --> 00:04:49,510
¿Cuándo es el - sí?

60
00:04:49,510 --> 00:04:53,180
[Estudiante] Cuando usted está tratando de obtener la entrada del usuario, o algo que desee comprobar -

61
00:04:53,180 --> 00:04:59,700
Si. Así que do-while bucles, entrada de usuario es el grande.

62
00:04:59,700 --> 00:05:03,160
Es por eso que en los conjuntos de problemas primero de un par, cuando quieras hacer al usuario, como,

63
00:05:03,160 --> 00:05:08,520
"Dame una cadena," no se puede continuar hasta que llegue esa cadena.

64
00:05:08,520 --> 00:05:12,980
Y por lo que, necesariamente, tienen que pedir la cadena de por lo menos una vez.

65
00:05:12,980 --> 00:05:16,950
Pero si contestan algo malo, entonces usted necesita para tejer por atrás y volver a preguntar.

66
00:05:16,950 --> 00:05:20,810
Pero más allá de la entrada del usuario, es muy raro que me encuentro con un caso

67
00:05:20,810 --> 00:05:27,170
donde quiero bucle "al menos una vez", pero posiblemente más.

68
00:05:27,170 --> 00:05:33,370
Preguntas o -? ¿Alguien ha utilizado un bucle do-while en otro sitio?

69
00:05:33,370 --> 00:05:36,780
Bien. Así que el siguiente es: "¿Qué identificador no declarado

70
00:05:36,780 --> 00:05:43,310
suelen indicar si emitida por sonido metálico? "

71
00:05:43,310 --> 00:05:47,380
Entonces, ¿qué tipo de código podría escribir para obtener 'identificador no declarado?

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

73
00:05:49,550 --> 00:05:52,650
Así que sólo puedo intentar aquí, x = 2.

74
00:05:52,650 --> 00:06:04,830
Vamos a ejecutar este - ¡oh, no haga clic en él. Así que aquí tenemos - todos los derechos.

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

76
00:06:07,100 --> 00:06:11,610
Así que ese es el identificador no declarado, una variable.

77
00:06:11,610 --> 00:06:13,910
A menudo se llama una variable de un identificador.

78
00:06:13,910 --> 00:06:17,300
Así que tal vez no sabe que es en realidad una variable, y no sabe lo que es.

79
00:06:17,300 --> 00:06:19,380
Así que es un identificador.

80
00:06:19,380 --> 00:06:26,060
Entonces, ¿por qué está declarado? Si.

81
00:06:26,060 --> 00:06:32,190
Así que para ser claros sobre la terminología, la declaración de una variable

82
00:06:32,190 --> 00:06:37,360
es cuando usted dice "x int" o "S String", lo que sea.

83
00:06:37,360 --> 00:06:41,910
La inicialización de la variable, o la asignación de la variable,

84
00:06:41,910 --> 00:06:44,510
es cuando usted dice "x = 2".

85
00:06:44,510 --> 00:06:52,950
Así que podemos hacer esto en pasos separados, int x, x = 2, y hasta que - podemos tener un montón de cosas aquí -

86
00:06:52,950 --> 00:07:00,350
pero hasta esta línea pasa, x sigue sin inicializar, pero ha sido declarado.

87
00:07:00,350 --> 00:07:06,760
Y, entonces, obviamente, puede hacerlo en una línea, y ahora estamos declarando y la inicialización.

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

89
00:07:10,730 --> 00:07:18,390
Y finalmente, "¿Por qué no es el cifrado César muy seguro?"

90
00:07:18,390 --> 00:07:23,830
Así que primero, ¿alguien quiere decir lo que el cifrado César es?

91
00:07:23,830 --> 00:07:28,100
[Estudiante] Caesar Cipher es justo que asigne, puede cambiar cada letra,

92
00:07:28,100 --> 00:07:34,420
un cierto número de cartas repasar y volver otra vez, y no es muy seguro, ya que

93
00:07:34,420 --> 00:07:42,260
sólo hay 26 opciones posibles y sólo hay que probar cada uno de ellos hasta que lo consigas.

94
00:07:42,260 --> 00:07:45,470
Oh. Por lo tanto, debo repetirlo?

95
00:07:45,470 --> 00:07:51,600
El cifrado César, es - Es decir, se le trata con él sobre los problemas que usted -

96
00:07:51,600 --> 00:07:56,110
o supongo que la edición estándar del conjunto de problemas que no está en la edición hacker.

97
00:07:56,110 --> 00:08:01,550
Así que en la edición estándar para el conjunto de problemas, se obtiene un mensaje como: "Hola, mundo"

98
00:08:01,550 --> 00:08:08,410
y también tiene un número como 6, y se toma ese mensaje, y cada personaje individual,

99
00:08:08,410 --> 00:08:11,310
lo gira por seis posiciones en el alfabeto.

100
00:08:11,310 --> 00:08:16,560
Así que la 'h' se convertiría en hola h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Así que la primera letra será n. Hacemos lo mismo con el correo.

102
00:08:19,600 --> 00:08:23,530
Si tenemos una, digamos, z o algo así, entonces nos envuelva la vuelta a 'A'.

103
00:08:23,530 --> 00:08:29,280
Pero cada personaje tiene un ciclo de 6 caracteres más adelante en el alfabeto, y no es muy seguro

104
00:08:29,280 --> 00:08:35,440
ya que sólo hay 26 posibilidades de cuántas maneras se puede envolver una sola letra.

105
00:08:35,440 --> 00:08:42,919
Así que usted puede probar todo 26 de ellos y, presumiblemente, de un mensaje bastante largo,

106
00:08:42,919 --> 00:08:46,860
sólo 1 de los 26 posibles cosas va a ser legible,

107
00:08:46,860 --> 00:08:50,300
y el legible va a ser el mensaje original.

108
00:08:50,300 --> 00:08:56,240
Así que no es una muy buena manera de encriptar cualquier cosa.

109
00:08:56,240 --> 00:08:59,070
Sin relación con esos pantalones cortos, "¿Qué es una función?"

110
00:08:59,070 --> 00:09:03,370
Entonces, ¿qué es una función? Sí.

111
00:09:03,370 --> 00:09:11,640
[Estudiante] Es como un pedazo de código que se puede llamar para ir a través y luego obtener el valor de retorno de lo que sea.

112
00:09:11,640 --> 00:09:18,160
Si. Así que voy a contestar también responder a la siguiente - o por repetición también acaba de responder a la siguiente.

113
00:09:18,160 --> 00:09:22,410
Puede utilizar las funciones en lugar de simplemente copiar y pegar el código una y otra vez.

114
00:09:22,410 --> 00:09:27,200
Basta con echar ese código, lo puso en una succion, y entonces se podría simplemente llamar a la función

115
00:09:27,200 --> 00:09:29,870
en todo cuanto has estado copiando y pegando.

116
00:09:29,870 --> 00:09:33,350
Así funciones son útiles.

117
00:09:33,350 --> 00:09:35,860
Así que ahora vamos a resolver problemas reales.

118
00:09:35,860 --> 00:09:46,490
La primera de ellas. Así que la idea de la primera es, se le pasa una cadena, ya pesar de la -

119
00:09:46,490 --> 00:09:52,060
o es lo que dice todo en minúsculas? No dice en minúsculas.

120
00:09:52,060 --> 00:09:57,730
De modo que el mensaje puede ser cualquier cosa, y - oh no. Lo hace.

121
00:09:57,730 --> 00:10:01,610
"Para simplificar, se puede suponer que el usuario sólo va a introducir letras minúsculas y espacios."

122
00:10:01,610 --> 00:10:08,180
Así que le pase un mensaje con sólo letras minúsculas y luego alternar

123
00:10:08,180 --> 00:10:15,450
entre el capital y minúsculas - Podemos cambiar la cadena a ser capital y minúsculas, alternando.

124
00:10:15,450 --> 00:10:22,920
Así que antes de darle un segundo para bucear incluso en el problema,

125
00:10:22,920 --> 00:10:32,420
¿qué es lo primero que tenemos que hacer?

126
00:10:32,420 --> 00:10:36,900
Oh, ¿qué acabo de hacer clic en? Oh, me acaba de hacer clic en un e-mail aquí.

127
00:10:36,900 --> 00:10:42,870
Así que lo primero que tenemos que hacer - estoy buscando a la persona equivocada?

128
00:10:42,870 --> 00:10:49,320
¿Es esto parte de éste?

129
00:10:49,320 --> 00:10:51,320
No, esos son todavía allí, sin embargo.

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

131
00:10:55,160 --> 00:11:03,160
Ahora no podemos asumir -? Sí. Aquí no podemos suponer que es sólo minúsculas y espacios.

132
00:11:03,160 --> 00:11:07,770
Así que ahora tenemos que lidiar con el hecho de que las cartas pueden ser lo que queramos que sean.

133
00:11:07,770 --> 00:11:11,910
Así que lo primero que queremos hacer es entender el mensaje.

134
00:11:11,910 --> 00:11:19,790
Sólo tenemos que conseguir una cadena, string s = GetString, está bien.

135
00:11:19,790 --> 00:11:24,890
Ahora bien, este problema, hay un par de formas de hacerlo.

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

137
00:11:29,840 --> 00:11:35,280
¿Hay personas que no se encontraban en el supersección,

138
00:11:35,280 --> 00:11:37,480
o algo, y no sé lo que son operadores bit a bit?

139
00:11:37,480 --> 00:11:41,710
O cómo se relacionan con ASCII de alguna manera?

140
00:11:41,710 --> 00:11:45,650
[Estudiante] yo no estaba en la supersección, pero sé lo que son operadores bit a bit.

141
00:11:45,650 --> 00:11:49,560
Bien. Así que no tengo que ir a través de los fundamentos de ellos, pero te lo explico

142
00:11:49,560 --> 00:11:51,830
lo que vamos a querer utilizar aquí.

143
00:11:51,830 --> 00:11:59,680
Así que 'A': Representación binaria del capital A, el número es 65.

144
00:11:59,680 --> 00:12:07,560
Yo sólo voy a mirar - 41 va a ser 01000001.

145
00:12:07,560 --> 00:12:14,170
Así que debe ser del 65 en decimal, por lo que esta es la representación binaria del carácter de capital A.

146
00:12:14,170 --> 00:12:19,440
Ahora, la representación binaria de la minúscula 'a'

147
00:12:19,440 --> 00:12:33,350
va a ser lo mismo, casi. ¿Es eso - 6, sí. Esto es correcto.

148
00:12:33,350 --> 00:12:37,670
Así el capital binario Un minúsculas, binario 'a'.

149
00:12:37,670 --> 00:12:43,940
Así que notar que la diferencia entre A y A 'a' es este único bit.

150
00:12:43,940 --> 00:12:49,440
Y esto pasa a ser el bit 32, el bit que representa el número 32.

151
00:12:49,440 --> 00:12:53,910
Y eso tiene sentido puesto que A es 65; 'a' es 97.

152
00:12:53,910 --> 00:12:56,610
La diferencia entre ellos es de 32.

153
00:12:56,610 --> 00:13:03,770
Así que ahora que sabemos que podemos pasar de la A a la 'a' mediante la adopción de un

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

155
00:13:09,710 --> 00:13:20,900
Este es un O-lógico, con 00100000, y que va a darnos 'a'.

156
00:13:20,900 --> 00:13:26,850
Y que podemos obtener de la 'a' a la A, bit a bit AND

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

158
00:13:33,700 --> 00:13:43,840
Así que esto, entonces nos dará exactamente lo que 'a' era, pero se anulan este bit individual,

159
00:13:43,840 --> 00:13:50,070
por lo que tendremos 01000001, yo no sé si he contado bien.

160
00:13:50,070 --> 00:13:56,750
Pero esta técnica de bit a bit ORing llegar desde la capital a minúsculas,

161
00:13:56,750 --> 00:14:02,080
y bit a bit AND para obtener de minúsculas a capital no es exclusiva de A.

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

163
00:14:06,510 --> 00:14:10,080
todos ellos son sólo va a diferir en este único bit.

164
00:14:10,080 --> 00:14:16,290
Y para que pueda usar esto para cambiar de cualquier letra minúscula a cualquier letra mayúscula y viceversa.

165
00:14:16,290 --> 00:14:26,670
Bien. Así que una manera fácil de conseguir de esto - así que en vez de tener que

166
00:14:26,670 --> 00:14:32,170
escribir cualquier cosa 1011111 es - una manera fácil de representar este número, y esto no es una

167
00:14:32,170 --> 00:14:39,710
que fui en el supersección, pero tilde (~) es otro operador bit a bit.

168
00:14:39,710 --> 00:14:42,520
Lo que ~ hace es que analiza la representación de bits.

169
00:14:42,520 --> 00:14:45,630
Tomemos cualquier número.

170
00:14:45,630 --> 00:14:53,130
Esto es sólo un número binario, y lo ~ hace es que sólo invierte todos los bits.

171
00:14:53,130 --> 00:15:00,630
Así que este fue un 1, ahora un 0, esto es un 0, ahora un 1, 010100.

172
00:15:00,630 --> 00:15:08,320
Así que eso es todo ~ no. Así que 32 va a ser el número - deshacerse de eso -

173
00:15:08,320 --> 00:15:23,320
así que 32 va a ser el número 00100000, y así de esta ~ va a ser

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

175
00:15:29,980 --> 00:15:35,600
¿Todo el mundo ve eso? Esto es bastante común, como cuando se quiere averiguar

176
00:15:35,600 --> 00:15:40,740
por las cosas que más tarde podríamos estar viendo, cuando queremos ver si -

177
00:15:40,740 --> 00:15:44,710
o queremos que todo, cada bit individual excepto por 1

178
00:15:44,710 --> 00:15:47,910
se tiende a hacer ~ de la parte que nosotros no queremos establecer.

179
00:15:47,910 --> 00:15:53,090
Así que no queremos que el conjunto de 32 bits, por lo que es de ~ 32.

180
00:15:53,090 --> 00:15:57,790
Bien. Así que podemos usar todos los que están aquí.

181
00:15:57,790 --> 00:16:03,000
Muy bien, así que está bien si no estás hecho, que poco a poco se acerco juntos,

182
00:16:03,000 --> 00:16:11,870
o caminar sobre esto, así que - a través de esto. Caminar a través de esto.

183
00:16:11,870 --> 00:16:20,790
Así que tenemos nuestra cadena, y queremos un bucle sobre cada personaje en esa cadena y hacer algo con ella.

184
00:16:20,790 --> 00:16:26,710
Entonces, ¿cómo hacemos un bucle sobre una cuerda? ¿Qué debemos usar?

185
00:16:26,710 --> 00:16:30,980
Yo no lo voy a hacer aquí. Si.

186
00:16:30,980 --> 00:16:42,940
Así que tengo mi iterador, y él lo dijo, pero ¿cómo puedo saber cuántos caracteres se encuentran en la cuerda?

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

188
00:16:47,030 --> 00:16:49,860
Así que lo que hemos hecho aquí no es la mejor manera de hacer las cosas.

189
00:16:49,860 --> 00:16:51,860
¿Alguien sabe por qué?

190
00:16:51,860 --> 00:16:55,290
Debido a que usted está comprobando el idioma de la cadena cada vez.

191
00:16:55,290 --> 00:17:06,859
Así que vamos a querer mover strlen, podría decir aquí, int longitud = strlen (s),

192
00:17:06,859 --> 00:17:11,900
y luego hacer i <longitud, y en caso de que no lo han visto antes,

193
00:17:11,900 --> 00:17:20,410
Yo también podría hacer int i = 0, longitud = strlen (s).

194
00:17:20,410 --> 00:17:25,010
Y esto es algo preferible, ya que ahora me he limitado el alcance

195
00:17:25,010 --> 00:17:29,150
de la longitud variable que sólo esta 'para' bucle, en lugar de declararlo antes

196
00:17:29,150 --> 00:17:34,990
y que siempre existe, y en caso de que no entendió por qué eso es malo,

197
00:17:34,990 --> 00:17:39,410
o por qué el original era mala, es - comienzan en el bucle for.

198
00:17:39,410 --> 00:17:43,380
Revisé la condición. Es i <la longitud de s?

199
00:17:43,380 --> 00:17:46,790
Así que la longitud de s, vamos a trabajar con un "hola" todo el tiempo.

200
00:17:46,790 --> 00:17:49,670
Así la longitud de s, h-e-l-l-o. La longitud es de 5.

201
00:17:49,670 --> 00:17:57,580
Entonces, i = 0, la longitud es de 5, así que no es de <5, por lo que el ciclo continúa.

202
00:17:57,580 --> 00:18:02,750
Entonces vamos de nuevo. Comprobamos el estado. Es i <la longitud de hola?

203
00:18:02,750 --> 00:18:08,390
Así que vamos a comprobar la longitud de hello. H-e-l-l-o. Eso es 5; i no es <5, por lo que continuamos de nuevo.

204
00:18:08,390 --> 00:18:13,330
Así que estamos calculando, contamos hola, para cada iteración del bucle,

205
00:18:13,330 --> 00:18:17,380
incluso pensó que nunca va a cambiar, sino que siempre va a ser 5.

206
00:18:17,380 --> 00:18:22,530
Así que sólo recuerda 5 en la delantera, y ahora todo está mejor.

207
00:18:22,530 --> 00:18:24,990
Así que iterar sobre toda la cadena.

208
00:18:24,990 --> 00:18:31,470
¿Qué es lo que queremos hacer para cada carácter de la cadena?

209
00:18:31,470 --> 00:18:38,510
[Estudiante hablando, ininteligible]

210
00:18:38,510 --> 00:18:47,000
Si. Por lo tanto, si el personaje no es alfabético, a continuación, sólo queremos pasar por encima.

211
00:18:47,000 --> 00:18:52,300
Debido a que sólo se preocupan por las letras del alfabeto, no podemos sacar un número.

212
00:18:52,300 --> 00:19:10,850
Entonces, ¿cómo podemos hacer esto? Así que nuestra condición, por lo que si queremos algo - comprobar si es alfabético.

213
00:19:10,850 --> 00:19:14,060
Entonces, ¿cómo comprobarlo?

214
00:19:14,060 --> 00:19:18,720
[Estudiante] Usted sólo puede usar la función es alfa.

215
00:19:18,720 --> 00:19:23,160
Es que en una u otra de estas, o cualquier incluir como, char.h o algo así?

216
00:19:23,160 --> 00:19:32,710
No vamos a utilizar es la función alfa, y utilizar el explícito - por lo que tenemos que s [i],

217
00:19:32,710 --> 00:19:40,460
que es el octavo carácter de s, recuerde que una cadena es una serie de caracteres,

218
00:19:40,460 --> 00:19:43,180
por lo que el octavo carácter de s.

219
00:19:43,180 --> 00:19:49,280
Ahora, si se trata de una letra mayúscula, sabemos que tiene que estar en un rango específico.

220
00:19:49,280 --> 00:19:54,370
¿Y cuál es ese rango?

221
00:19:54,370 --> 00:20:07,860
Si. Así que si s [i] es ≥ 65, y s [i] es ≤ 90, ¿qué debo hacer entonces?

222
00:20:07,860 --> 00:20:18,470
Si. Así que usted nunca debe absolutamente siquiera necesita saber los valores ASCII de cualquier cosa nunca.

223
00:20:18,470 --> 00:20:25,640
Nunca pienso en los números 65, 90, 97 y 102, o lo que sea.

224
00:20:25,640 --> 00:20:32,470
No es necesario - 112 - usted no necesita saber los de todos. Eso está mal también.

225
00:20:32,470 --> 00:20:41,940
Utilice sólo los caracteres de comillas simples, constantes comillas simples. Así que 'A' y 90 menos de lo que es 'Z'

226
00:20:41,940 --> 00:20:47,930
Y esto es mucho mejor - no sabría de la parte superior de mi cabeza que Z es 90.

227
00:20:47,930 --> 00:20:52,690
Yo sé de la parte superior de mi cabeza que 'Z' es la capital de Z.

228
00:20:52,690 --> 00:21:02,100
Así que, mientras este está en el rango de capital de la A a la Z de capital, o podemos buscar en minúsculas,

229
00:21:02,100 --> 00:21:17,010
O si está en el rango de ≥ 'a' y ≤ z.

230
00:21:17,010 --> 00:21:19,010
Así que esa es nuestra condición.

231
00:21:19,010 --> 00:21:22,520
El estilo de dónde poner estas cosas varía.

232
00:21:22,520 --> 00:21:29,520
Yo lo haré así.

233
00:21:29,520 --> 00:21:31,520
Ahora, ¿qué es lo que queremos hacer?

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

235
00:21:39,530 --> 00:21:46,270
Así que tenemos que alternar entre si esto ahora debe ser una letra mayúscula o una letra minúscula.

236
00:21:46,270 --> 00:21:48,820
¿Cómo podemos mantener un registro de los que queremos que sea?

237
00:21:48,820 --> 00:21:55,520
[Voces estudiantiles, ininteligible]

238
00:21:55,520 --> 00:21:59,150
Así que sí, pero déjame ver.

239
00:21:59,150 --> 00:22:04,910
Módulo 0-2 se decía, era una sugerencia expulsado, y estoy de acuerdo con eso.

240
00:22:04,910 --> 00:22:11,780
Salvo aviso de que, al igual que - ¿es este el caso? Si.

241
00:22:11,780 --> 00:22:18,270
Es cada otro, pero no podemos módulo 2 de i o i mod 2, ya que

242
00:22:18,270 --> 00:22:22,950
cuenta de que E es la capital y la 'a' minúscula es? Pero hay un espacio que los separa?

243
00:22:22,950 --> 00:22:27,150
Así que vamos a ser el mismo mod 2, pero son casos diferentes.

244
00:22:27,150 --> 00:22:29,150
[Pregunta Estudiante, ininteligible]

245
00:22:29,150 --> 00:22:34,690
Si. Así que sólo vamos a mantener una cuenta.

246
00:22:34,690 --> 00:22:38,730
También podríamos hacer eso aquí si queríamos, eso podría ser un poco difícil de manejar

247
00:22:38,730 --> 00:22:41,300
en el de las declaraciones de bucle, me voy a poner aquí.

248
00:22:41,300 --> 00:22:48,840
Así int count = comienza en 0.

249
00:22:48,840 --> 00:22:54,070
Y ahora, te voy a contar el número de caracteres alfabéticos que hemos tenido.

250
00:22:54,070 --> 00:22:59,550
Así que estamos inevitablemente va a contar + + ya que nos encontramos con otro carácter alfabético.

251
00:22:59,550 --> 00:23:09,130
Pero, por lo que ahora estás diciendo que si mod cuenta 2.

252
00:23:09,130 --> 00:23:12,590
Entonces, ¿qué si el recuento mod 2? Oh. Haré == 0 por ahora.

253
00:23:12,590 --> 00:23:21,740
También vamos a ir sobre eso. Así que si mod cuenta 2 == 0, entonces qué?

254
00:23:21,740 --> 00:23:27,830
[Los estudiantes de respuesta, ininteligible]

255
00:23:27,830 --> 00:23:32,750
Así que quiero que termine para arriba en mayúsculas.

256
00:23:32,750 --> 00:23:37,520
Hay 2 casos; mayúsculas y minúsculas son los 2 casos.

257
00:23:37,520 --> 00:23:40,990
Así que si estamos en minúsculas tenemos que hacer lo mayúsculas.

258
00:23:40,990 --> 00:23:43,710
Si se trata de mayúsculas no necesitamos hacer nada.

259
00:23:43,710 --> 00:23:50,760
Pero, ¿hay alguna manera - ¿no debería haber volteado -

260
00:23:50,760 --> 00:23:54,800
que ni siquiera es necesario para comprobar si se trata de mayúsculas o minúsculas?

261
00:23:54,800 --> 00:24:02,240
¿Qué podemos hacer para que siempre seguros de que siempre terminan en mayúsculas?

262
00:24:02,240 --> 00:24:07,830
Así que darse cuenta de lo que hicimos por minúscula 'a'; ¿y si lo hicimos exactamente lo mismo a mayúsculas A?

263
00:24:07,830 --> 00:24:11,900
¿Tiene mayúsculas A cambio, o el cambio de valor?

264
00:24:11,900 --> 00:24:23,100
Si. Así que cualquier letra mayúscula bit a bit AND con ~ 32 va a ser ese mismo carácter en mayúsculas

265
00:24:23,100 --> 00:24:29,220
porque para cualquier carácter en mayúscula el bit 32 no está establecida.

266
00:24:29,220 --> 00:24:40,920
Así que si queremos traer el carácter s [i], queremos que se convierta en minúscula o mayúscula.

267
00:24:40,920 --> 00:24:46,890
Así que si era minúscula, ahora es mayúscula, si era mayúscula, sigue siendo mayúscula, y eso es todo.

268
00:24:46,890 --> 00:24:54,290
Lo dije en el supersección: Puede utilizar 32 si quieres, pero yo tiendo a preferir hacerlo 'a' - A,

269
00:24:54,290 --> 00:25:01,150
en lugar de simplemente 32, ya que puede ser cualquier otro bit.

270
00:25:01,150 --> 00:25:03,610
Después de que el bit 32, que puede ser cualquiera de estos, o que no tendría suficiente

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

272
00:25:05,840 --> 00:25:09,110
Así que si tienes la de 32 bits, que podría ser la de 64 bits, que podría ser el de 128 bits.

273
00:25:09,110 --> 00:25:13,990
Cualquiera de esos bits podría ser el bit que distingue entre mayúsculas y minúsculas.

274
00:25:13,990 --> 00:25:18,350
Yo no debería tener que saber que es el de 32 bits.

275
00:25:18,350 --> 00:25:27,130
Puedo usar esta 'a' - A para obtener la parte que difiere entre los dos

276
00:25:27,130 --> 00:25:33,000
sin necesidad de confiar en el número mágico que es 32.

277
00:25:33,000 --> 00:25:38,770
Y ahora, de lo contrario contar era extraño, ¿y qué es lo que quiero hacer?

278
00:25:38,770 --> 00:25:43,920
[Respuestas de los estudiantes, ininteligible]

279
00:25:43,920 --> 00:25:45,920
[Estudiante] ¿Qué es eso?

280
00:25:45,920 --> 00:25:49,850
Lo haré en 1 segundo.

281
00:25:49,850 --> 00:25:55,690
Así que ahora si quiero - Quiero para asegurarse de que el personaje está ahora en minúsculas,

282
00:25:55,690 --> 00:26:04,140
y por lo que puedo o por 32, y 32 significa "un" - A.

283
00:26:04,140 --> 00:26:06,510
Pero aviso, por el mismo razonamiento que el anterior, que si

284
00:26:06,510 --> 00:26:11,670
la carta ya estaba en minúsculas, a continuación, en un 32 ORing sólo mantiene minúsculas.

285
00:26:11,670 --> 00:26:16,220
No ha cambiado el carácter original.

286
00:26:16,220 --> 00:26:19,910
Pero ahora no tiene que evitar decir: "Si es minúscula, olvídate de él,

287
00:26:19,910 --> 00:26:23,650
si se trata de mayúsculas, luego de cambiarlo ".

288
00:26:23,650 --> 00:26:26,900
Es mucho más conveniente de hacerlo.

289
00:26:26,900 --> 00:26:33,190
[Estudiante] Ojalá que la estrategia de restar las mayúsculas de minúsculas si el trabajo no fuera 32?

290
00:26:33,190 --> 00:26:35,330
Si lo fuera, como, 34 o algo así?

291
00:26:35,330 --> 00:26:41,840
Por lo tanto, es necesario saber que la diferencia entre los dos es - >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Podría ser más de 1 bit, siempre y cuando todos los bits de debajo de esta posición son los mismos.

293
00:26:49,840 --> 00:26:58,500
Así que necesitamos por lo menos 26 caracteres - o, hay 26 caracteres.

294
00:26:58,500 --> 00:27:04,590
Así que necesitamos por lo menos 26 números para representar la diferencia -

295
00:27:04,590 --> 00:27:07,650
La diferencia entre A y, 'a' tiene que ser de al menos 26

296
00:27:07,650 --> 00:27:10,760
o de lo contrario no habría representado todos los números de capital.

297
00:27:10,760 --> 00:27:18,630
Esto significa que A, si empezamos a 1, que va a utilizar todos estos bits,

298
00:27:18,630 --> 00:27:23,900
todos estos primeros 5 bits para representar todo a la Z.

299
00:27:23,900 --> 00:27:32,170
Es por eso que el siguiente bit o bit de esto, el siguiente bit es el que ha optado por distinguir entre A y A '.'

300
00:27:32,170 --> 00:27:40,930
Por eso también, en la tabla ASCII, hay 5 símbolos que separan las letras mayúsculas de las minúsculas.

301
00:27:40,930 --> 00:27:49,050
Dado que esos son los símbolos, el extra 5 que trae a colación el 32 es la diferencia entre ellos.

302
00:27:49,050 --> 00:27:51,840
[Estudiante] Así que podemos hacerlo, porque ASCII está diseñado de esa manera.

303
00:27:51,840 --> 00:27:57,280
Sí. Pero ASCII - la diferencia también podría ser tanto de estos bits.

304
00:27:57,280 --> 00:28:12,040
Al igual que, si A fuera 10000001, y 'a' es 11100001 - me olvide, lo que sea.

305
00:28:12,040 --> 00:28:18,100
Pero si fuera así, entonces podría usar 'a' - A.

306
00:28:18,100 --> 00:28:22,650
Es que ahora la diferencia entre A y A 'a' es todavía estos 2 bits.

307
00:28:22,650 --> 00:28:32,240
Creo que ha escrito 48. ¿Es 32 + 64? Yo creo que es?

308
00:28:32,240 --> 00:28:40,160
Todavía sería 2 bits de cada carácter;, como, Z y Z, K y k,

309
00:28:40,160 --> 00:28:45,160
todavía tendrían los mismos bits exactos establecidos excepción de los 2 bits.

310
00:28:45,160 --> 00:28:48,870
Así que, mientras que siempre es cierto, independientemente de si estamos usando ASCII o algún otro sistema,

311
00:28:48,870 --> 00:28:53,050
mientras que sólo hay un número fijo de bits que son diferentes para cada personaje,

312
00:28:53,050 --> 00:28:55,050
luego de que funciona bien.

313
00:28:55,050 --> 00:29:06,110
Es sólo que el 32 se creó porque es el primero que podríamos utilizar. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Yo tiendo a preferir, en caso de que no hemos visto, si el bloque es más que una sola línea,

315
00:29:14,520 --> 00:29:24,280
usted puede deshacerse de las llaves, así que tiendo a preferir hacerlo.

316
00:29:24,280 --> 00:29:34,010
Además, usted sabe lo que puede hacer cosas como s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
También puede hacer s [i] = 32 AND bit a bit.

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

319
00:29:46,400 --> 00:29:51,490
Además, cuentan mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Así que recuerde que - no lo voy a escribir - cualquier valor distinto de cero es verdadero y 0 es falso.

321
00:30:00,900 --> 00:30:07,880
Así que "si mod cuenta 2 == 0" es lo mismo que decir "si no cuentan mod 2".

322
00:30:07,880 --> 00:30:11,580
Probablemente me acaba de invertir las líneas y le dijo: "si el recuento mod 2,

323
00:30:11,580 --> 00:30:15,350
realizar las OR 1, más se la AND 1 ", por lo que no necesitaba el" no ".

324
00:30:15,350 --> 00:30:18,650
Pero esto funciona igual de bien.

325
00:30:18,650 --> 00:30:25,660
¿Y qué otra cosa puedo hacer aquí?

326
00:30:25,660 --> 00:30:29,060
Se les puede combinar con ternario si quería, pero después de que acabara de hacer las cosas más desordenado

327
00:30:29,060 --> 00:30:33,770
y probablemente más difícil de leer, así que no vamos a hacer eso.

328
00:30:33,770 --> 00:30:37,330
Alguien tiene alguna sugerencia?

329
00:30:37,330 --> 00:30:41,580
¿Eso es todo el problema pedí? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Así que deshacerse de estas líneas vacías, ahora vamos a imprimir f,% s es el de las cadenas,

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

332
00:30:56,620 --> 00:30:59,330
Ahora vamos a ejecutarlo. ¿He hecho algo mal?

333
00:30:59,330 --> 00:31:03,200
Eso es un \ ", quiero un n.

334
00:31:03,200 --> 00:31:07,840
Bien. Ahora vamos a ejecutarlo. Probablemente voy a gritar a mí.

335
00:31:07,840 --> 00:31:11,250
Strlen está en string.h.

336
00:31:11,250 --> 00:31:14,290
Así que esto es lo bueno de Clang es que le dice lo que se encuentra,

337
00:31:14,290 --> 00:31:19,140
en lugar de GCC que sólo dice: "Oye, te olvidaste de algo, no sé lo que era."

338
00:31:19,140 --> 00:31:29,220
Pero esto me va a decir: "Vosotros pensasteis que incluya string.h".

339
00:31:29,220 --> 00:31:32,130
Así que no me pedirá nada, por lo que no está diciendo nada.

340
00:31:32,130 --> 00:31:42,540
Pero vamos a hacer con su ejemplo, "thanks 4 the add".

341
00:31:42,540 --> 00:31:47,880
Esto se ve muy bien. ¡Hurra.

342
00:31:47,880 --> 00:31:52,370
Así que volviendo a su principal, yo casi nunca lo hacen.

343
00:31:52,370 --> 00:31:57,110
Es opcional. Y principal es la única función para la que es opcional.

344
00:31:57,110 --> 00:32:07,140
Si usted no devuelve nada de principal, se supone que la intención de devolver 0.

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

346
00:32:13,070 --> 00:32:20,980
Bien. Así que ahora el segundo problema.

347
00:32:20,980 --> 00:32:24,810
"Recuerde que en la segunda conferencia 2 semanas de intercambio de valores que las variables de 2 'al pasar

348
00:32:24,810 --> 00:32:30,780
esos dos variables a una función (aunque haya sido convocada swap) no es exactamente funciona, al menos no sin 'punteros' ".

349
00:32:30,780 --> 00:32:37,020
Y hacer caso omiso de los punteros hasta que lleguemos a ellos.

350
00:32:37,020 --> 00:32:40,070
Queremos intercambiar dos variables; no estamos usando una función para hacerlo.

351
00:32:40,070 --> 00:32:43,410
Todavía vamos a hacerlo en principal como se dice.

352
00:32:43,410 --> 00:32:48,360
Pero para usar esos 2 variables, no queremos usar una variable temporal.

353
00:32:48,360 --> 00:32:50,770
Hay dos maneras de hacer esto.

354
00:32:50,770 --> 00:32:56,310
Se puede hacer uso de sus operadores binarios tradicionales.

355
00:32:56,310 --> 00:33:00,180
Así que ¿alguien sabe una manera rápida y sucia de hacer eso?

356
00:33:00,180 --> 00:33:07,650
En realidad, puede tardar un minuto de pensar. Si tengo -

357
00:33:07,650 --> 00:33:12,130
Voy a poner el problema arriba como se lo preguntan. Así que si tengo dos variables, A, que es simplemente un entero

358
00:33:12,130 --> 00:33:17,800
que me dan, y B suma variable, que es otro número entero que me dan.

359
00:33:17,800 --> 00:33:22,700
Así que si tengo estas 2 variables, ahora quiero intercambiarlas.

360
00:33:22,700 --> 00:33:31,550
El tradicional, usando sus operadores binarios regulares, es decir, como +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
No bitwise operadores que actúan en binario.

362
00:33:36,630 --> 00:33:39,600
Así que usando -, +, ÷, y todos esos.

363
00:33:39,600 --> 00:33:52,980
Podríamos cambiar haciendo algo como a = a + b, y b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Por lo tanto, la cordura cheque, y luego vamos a ver por qué funciona.

365
00:34:04,260 --> 00:34:13,320
Digamos que a = 7, b = 3, entonces a + b va a ser 10.

366
00:34:13,320 --> 00:34:18,820
Así que ahora estamos estableciendo a = 10, y luego hacemos b = a - b.

367
00:34:18,820 --> 00:34:30,250
Así que estamos haciendo b = a - b, que va a ser 7, y b = a - b de nuevo,

368
00:34:30,250 --> 00:34:38,650
o a = a - b. Que va a ser de 10 - 7, que es 3.

369
00:34:38,650 --> 00:34:44,850
Así que ahora, con razón, era "un '7, b tenía 3 años, y ahora es de 7 y b' a 'es 3.

370
00:34:44,850 --> 00:34:48,679
Para que tipo de sentido, 'a' es la combinación de los números 2.

371
00:34:48,679 --> 00:34:53,000
En este momento, "a" es la combinación, y entonces estamos restando el b original,

372
00:34:53,000 --> 00:34:56,860
y entonces estamos restando lo que fue el original "a."

373
00:34:56,860 --> 00:35:01,150
Pero esto no funciona para todos los números.

374
00:35:01,150 --> 00:35:08,880
Para ver esto, consideremos un sistema, por lo que normalmente ocurre enteros como 32 bits.

375
00:35:08,880 --> 00:35:13,050
Vamos a trabajar en algo que es sólo como 4 bits.

376
00:35:13,050 --> 00:35:15,450
Espero llegar a un buen ejemplo en estos momentos.

377
00:35:15,450 --> 00:35:18,680
Así que, lo sé, esto será fácil.

378
00:35:18,680 --> 00:35:26,720
Digamos que nuestros 2 números son 1111 y 1111, por lo que estamos en binario en estos momentos.

379
00:35:26,720 --> 00:35:34,630
En décimas reales, si usted quiere pensar de esa manera, a. = 15 y b = 15

380
00:35:34,630 --> 00:35:37,630
Y lo que esperamos, después de que los swap - que ni siquiera tienen que ser los mismos números,

381
00:35:37,630 --> 00:35:41,140
pero lo hice de esta manera.

382
00:35:41,140 --> 00:35:47,100
Hagamos que ellos no los mismos números. Vamos a hacer 1111 y 0001.

383
00:35:47,100 --> 00:35:51,860
Así que a = 15 y b = 1.

384
00:35:51,860 --> 00:35:57,670
Después de cambiarlos, esperamos que 'a' igual a 1 y b para ser 15.

385
00:35:57,670 --> 00:36:01,780
Por lo tanto el primer paso es a = a + b.

386
00:36:01,780 --> 00:36:08,770
Nuestros números son sólo 4 bits de ancho, por lo que 'un', que es 1111, + b, que es 0001,

387
00:36:08,770 --> 00:36:16,780
va a terminar siendo 10000, pero sólo tenemos 4 bits.

388
00:36:16,780 --> 00:36:22,540
Así que ahora a = 0.

389
00:36:22,540 --> 00:36:34,080
Y ahora queremos fijar b = a - b - de hecho, sigue funcionando a la perfección.

390
00:36:34,080 --> 00:36:39,630
a = a - vamos a ver si esto funciona perfectamente - b.

391
00:36:39,630 --> 00:36:53,720
Así entonces b = 0 - 1, que todavía sería 15, y entonces a = a - b, que sería 1.

392
00:36:53,720 --> 00:36:56,210
Tal vez esto funciona.

393
00:36:56,210 --> 00:36:59,020
Siento que hay una razón que no funciona con regularidad.

394
00:36:59,020 --> 00:37:06,400
De acuerdo, por lo que trabajar en el supuesto de que no funciona con operaciones binarias regulares,

395
00:37:06,400 --> 00:37:15,040
y voy a buscar - Voy a buscar en Google para ver si eso es cierto.

396
00:37:15,040 --> 00:37:23,490
Por eso queremos hacerlo mediante operadores bit a bit, y la clave aquí es XOR.

397
00:37:23,490 --> 00:37:28,780
Por lo tanto, la introducción de XOR (^) si usted no lo ha visto todavía.

398
00:37:28,780 --> 00:37:34,610
Es, de nuevo, un operador bit a bit por lo que actúa poco a poco, y es -

399
00:37:34,610 --> 00:37:39,910
Si usted tiene los bits 0 y 1, entonces esto va a ser 1.

400
00:37:39,910 --> 00:37:45,230
Si usted tiene los bits 1 y 0, que va a ser 1, tiene los bits 0 y 0 será 0,

401
00:37:45,230 --> 00:37:47,640
y si usted tiene los bits 1 y 1 será 0.

402
00:37:47,640 --> 00:37:56,180
Así que es como OR. Si cualquiera de los bits son verdaderas, es 1, pero a diferencia de O, no pueden ser los dos bits que son verdaderas.

403
00:37:56,180 --> 00:37:59,320
O habría este ser 1, XOR tendría este ser 0.

404
00:37:59,320 --> 00:38:02,250
Así que vamos a querer utilizar XOR aquí.

405
00:38:02,250 --> 00:38:09,960
Piense en esto por un minuto, voy a Google.

406
00:38:09,960 --> 00:38:16,230
Bueno, no se puede leer que, estoy actualmente en la página XOR algoritmo de intercambio.

407
00:38:16,230 --> 00:38:21,340
Esperemos que esto explica por qué No puedo -

408
00:38:21,340 --> 00:38:34,190
Este es exactamente el algoritmo que acabamos de hacer.

409
00:38:34,190 --> 00:38:37,330
Sigo sin ver por qué - Tengo que acaba de recoger un mal ejemplo,

410
00:38:37,330 --> 00:38:44,940
pero este caso donde 'a' pasó a convertirse en 0, después de llegar a 5 bits, por lo que ahora 'a' es 0,

411
00:38:44,940 --> 00:38:48,730
eso es lo que se llama "desbordamiento entero".

412
00:38:48,730 --> 00:38:54,370
Según Wikipedia, "A diferencia de la permuta XOR, esta modificación requiere que usa algunos métodos

413
00:38:54,370 --> 00:38:59,780
para garantizar que x + y no causa un desbordamiento de entero. "

414
00:38:59,780 --> 00:39:08,350
Así que este tiene problemas, lo que fue desbordamiento de entero, pero hice algo mal.

415
00:39:08,350 --> 00:39:10,520
No estoy seguro. Voy a tratar de llegar a otro.

416
00:39:10,520 --> 00:39:13,640
[Estudiante] Bueno, no es de desbordamiento de enteros cuando usted está tratando de poner un número en allí

417
00:39:13,640 --> 00:39:16,640
más grande que la cantidad de bits que se han asignado?

418
00:39:16,640 --> 00:39:23,730
Si. Disponemos de 4 bits. Eso es - teníamos 4 bits, que a continuación, intenta agregar 1 a la misma, por lo que terminamos con 5 bits.

419
00:39:23,730 --> 00:39:26,690
Pero el quinto bit sólo se corta, sí.

420
00:39:26,690 --> 00:39:28,970
En realidad, might -

421
00:39:28,970 --> 00:39:33,010
[Estudiante] ¿Esto te generará un error, o tiene que - que arrojaría un error?

422
00:39:33,010 --> 00:39:40,720
No. Así que no hay error. Al llegar al nivel de ensamblado, un poco especial

423
00:39:40,720 --> 00:39:47,020
en alguna parte se establece que decía que había un exceso de capacidad, pero en C que tipo de sólo no se ocupan de eso.

424
00:39:47,020 --> 00:39:55,160
Usted realmente no puede ocuparse de ella a menos que utilice las instrucciones especiales de montaje en C.

425
00:39:55,160 --> 00:39:58,110
Pensemos intercambio XOR.

426
00:39:58,110 --> 00:40:02,220
Y creo que el artículo de Wikipedia también podría haber estado diciendo que -

427
00:40:02,220 --> 00:40:07,310
Por lo tanto, también planteó la aritmética modular, así que supongo que era, en teoría, hacer aritmética modular

428
00:40:07,310 --> 00:40:11,160
cuando dije que el 0 - 1 es 15 otra vez.

429
00:40:11,160 --> 00:40:15,410
Así que en realidad podría - en un procesador regular que hace 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Ya que terminan en 0, se resta 1, por lo que entonces, sólo se envuelve de nuevo hacia 1111.

431
00:40:20,430 --> 00:40:28,930
Así que este algoritmo podría funcionar, el a + b, el a - b, b - a, que podría estar bien.

432
00:40:28,930 --> 00:40:34,030
Pero hay algunos procesadores que no lo hacen, por lo que no estaría bien en aquellos específicos.

433
00:40:34,030 --> 00:40:39,880
Intercambio XOR funciona en cualquier procesador. Bien.

434
00:40:39,880 --> 00:40:42,280
La idea es que se supone que debe ser el mismo, sin embargo.

435
00:40:42,280 --> 00:40:50,120
Dónde estamos utilizando XOR para conseguir de alguna manera la información de ambos en 1 de las variables,

436
00:40:50,120 --> 00:40:54,120
y luego extraer la información de las variables individuales de nuevo.

437
00:40:54,120 --> 00:41:04,330
Así que ¿alguien tiene ideas / respuesta?

438
00:41:04,330 --> 00:41:14,540
[Respuesta Estudiantil, ininteligible]

439
00:41:14,540 --> 00:41:22,220
Así que esto debería funcionar, y también, XOR es conmutativa.

440
00:41:22,220 --> 00:41:27,620
Independientemente de qué orden estos 2 números resultan ser en aquí,

441
00:41:27,620 --> 00:41:30,100
Este resultado va a ser el mismo.

442
00:41:30,100 --> 00:41:35,800
Así que a ^ b es b ^ a.

443
00:41:35,800 --> 00:41:51,860
Usted también puede ver este escrito como una ^ = b, b = a ^, a ^ = b de nuevo.

444
00:41:51,860 --> 00:42:00,200
Así que esto es lo correcto, y ver por qué esto funciona, piense en los bits.

445
00:42:00,200 --> 00:42:10,400
El uso de un número más bien pequeño, digamos 11001, y 01100.

446
00:42:10,400 --> 00:42:12,790
Así que esto es 'a', lo que es b.

447
00:42:12,790 --> 00:42:15,540
Así que a ^ = b.

448
00:42:15,540 --> 00:42:22,380
Vamos a ser la creación 'a' = a la XOR de estas 2 cosas.

449
00:42:22,380 --> 00:42:32,920
Así 1 ^ 0 es 1; 1 ^ 1 es 0; 0 ^ 1 es 1, y 0 ^ 0 es 0; 1 ^ 0 es 1.

450
00:42:32,920 --> 00:42:37,380
Así que 'a,' si nos fijamos en el número decimal, que va a ser -

451
00:42:37,380 --> 00:42:41,160
no vas a ver mucho de la relación entre el original 'a' y el nuevo 'a,'

452
00:42:41,160 --> 00:42:45,600
pero mirando a los bits, 'a' es ahora como una malla de la información

453
00:42:45,600 --> 00:42:49,970
tanto de la original 'a' y b del original.

454
00:42:49,970 --> 00:42:57,930
Así que si tomamos b ^ a, vemos que vamos a terminar en el original 'a'.

455
00:42:57,930 --> 00:43:08,910
Y si tomamos el original 'a' ^ el nuevo 'a,' vemos que terminamos en el b original.

456
00:43:08,910 --> 00:43:18,380
Así que (a ^ b) ^ b = el original 'a.'

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

458
00:43:27,910 --> 00:43:37,010
No es - otra forma de ver esto es algo en sí XOR es siempre 0.

459
00:43:37,010 --> 00:43:45,020
Así 1101 ^ 1101, todos los bits se va a ser el mismo.

460
00:43:45,020 --> 00:43:47,920
Así que nunca va a ser un caso en que 1 es un 0 y el otro es 1.

461
00:43:47,920 --> 00:43:51,080
Así que esto es 0000.

462
00:43:51,080 --> 00:43:57,240
El mismo con esto. (A ^ b) ^ b es como un ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) va a ser 0, a ^ 0 es sólo va a ser "a", puesto que todos los bits son 0.

464
00:44:03,680 --> 00:44:08,050
Así que los únicos que van a estar donde 'a' fue originalmente un 1 - tenía unos.

465
00:44:08,050 --> 00:44:12,070
Y la misma idea aquí, yo estoy bastante seguro de que es también conmutativa.

466
00:44:12,070 --> 00:44:17,590
Si. Yo he dicho antes que era conmutativa.

467
00:44:17,590 --> 00:44:24,680
El ^ 'a,' y es asociativa, así que ahora (b ^ a) ^ a.

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

469
00:44:28,970 --> 00:44:31,540
Y así, una vez más, obtenemos el b original.

470
00:44:31,540 --> 00:44:37,120
Así que 'a' es ahora la combinación de 'A' y B juntos.

471
00:44:37,120 --> 00:44:49,660
Con nuestro nuevo combo 'a' decimos b = combo 'a' ^ b el original, obtenemos la original 'a.'

472
00:44:49,660 --> 00:45:05,170
Y ahora un combo = 'a' ^ b del nuevo, que era la original - o lo que es ahora lo que era 'a' o b.

473
00:45:05,170 --> 00:45:13,620
Ese es el caso aquí. Esto es = b, b edad.

474
00:45:13,620 --> 00:45:16,550
Así que ahora todo está en el orden cambiado.

475
00:45:16,550 --> 00:45:22,960
Si en realidad se veía en los bits, b = a ^ b, va a XOR estos 2,

476
00:45:22,960 --> 00:45:33,920
y la respuesta va a ser esto, y entonces a = a ^ b se XORing estos 2 y la respuesta es la siguiente.

477
00:45:33,920 --> 00:45:41,090
¿Preguntas? Bien. Así que el último es algo mucho más difícil.

478
00:45:41,090 --> 00:45:43,180
[Estudiante] Creo que tiene una duda al respecto. >> Oh, lo siento.

479
00:45:43,180 --> 00:45:49,380
[Estudiante] ¿Qué es realmente más rápido? Si utiliza este XOR, o es si se declara una nueva variable?

480
00:45:49,380 --> 00:45:55,190
Entonces, ¿qué es más rápido, se declara una nueva variable o usar XOR a cambiar?

481
00:45:55,190 --> 00:45:59,600
La respuesta es, con toda probabilidad, una variable temporal.

482
00:45:59,600 --> 00:46:05,780
Y es que una vez que se compila abajo - por lo que en el nivel de ensamblado,

483
00:46:05,780 --> 00:46:12,320
no hay tal cosa como variables locales o cualesquiera variables temporales o de cualquiera de estas cosas.

484
00:46:12,320 --> 00:46:16,060
Son como - no hay memoria, y hay registros.

485
00:46:16,060 --> 00:46:20,920
Los registros son donde las cosas están ocurriendo activamente.

486
00:46:20,920 --> 00:46:24,750
No agregue 2 cosas en la memoria, agregar 2 cosas en los registros.

487
00:46:24,750 --> 00:46:28,160
Y traer cosas de la memoria en los registros para luego añadir,

488
00:46:28,160 --> 00:46:33,180
y entonces usted puede volver a ponerlos en la memoria, pero toda la acción sucede en los registros.

489
00:46:33,180 --> 00:46:38,750
Así que cuando usted está utilizando el enfoque variable temporal, por lo general lo que sucede es

490
00:46:38,750 --> 00:46:42,810
estos 2 números ya están en los registros.

491
00:46:42,810 --> 00:46:46,570
Y luego, a partir de ese momento, después de haberlos cambiado,

492
00:46:46,570 --> 00:46:51,540
sólo voy a empezar a usar el otro registro.

493
00:46:51,540 --> 00:46:56,510
En cualquier lugar donde había estado utilizando b, sólo se usará el registro que ya estaba almacenando 'a'.

494
00:46:56,510 --> 00:47:02,180
Por lo tanto, no necesita hacer nada para hacer realidad el intercambio. ¿Sí?

495
00:47:02,180 --> 00:47:05,690
[Estudiante] Pero también requiere más memoria, ¿no?

496
00:47:05,690 --> 00:47:10,280
Sólo serán más memoria si se necesita almacenar dicha variable temporal.

497
00:47:10,280 --> 00:47:14,830
Como si luego usa esa variable temporal de nuevo en alguna parte,

498
00:47:14,830 --> 00:47:18,920
entonces - o se asigna algo a esa variable temporal.

499
00:47:18,920 --> 00:47:24,630
Así que si en algún momento en el tiempo 'a,' b en temperatura tienen valores distintos o algo así,

500
00:47:24,630 --> 00:47:30,680
entonces va a tener posiciones distintas en la memoria, pero es cierto que

501
00:47:30,680 --> 00:47:34,800
hay muchas variables locales que sólo existen en registros.

502
00:47:34,800 --> 00:47:44,370
En cuyo caso, nunca se ha puesto en la memoria, y por lo que nunca está perdiendo la memoria.

503
00:47:44,370 --> 00:47:58,620
Bien. La última pregunta es un poco más.

504
00:47:58,620 --> 00:48:04,850
Así que aquí, en este aparato CS50, existe un diccionario.

505
00:48:04,850 --> 00:48:12,390
Y la razón de esto es porque [? B66] es un corrector ortográfico en el que estará escribiendo

506
00:48:12,390 --> 00:48:15,780
utilizando tablas hash o trata o alguna estructura de datos.

507
00:48:15,780 --> 00:48:22,660
Usted va a estar escribiendo un corrector ortográfico, y usted va a estar usando este diccionario para hacerlo.

508
00:48:22,660 --> 00:48:28,280
Pero para este problema, sólo vamos a mirar hacia arriba para ver si una palabra está en el diccionario.

509
00:48:28,280 --> 00:48:31,250
Así que en lugar de almacenar todo el diccionario de alguna estructura de datos

510
00:48:31,250 --> 00:48:35,180
y mirando por encima de todo un documento para ver si algo está mal escrito,

511
00:48:35,180 --> 00:48:38,490
sólo queremos encontrar una palabra. Así que sólo puede escanear a través de todo el diccionario

512
00:48:38,490 --> 00:48:44,300
y si no se encuentra la palabra en el diccionario entero, entonces no estaba allí.

513
00:48:44,300 --> 00:48:52,150
Si escanear a través de todo el diccionario y veo la palabra, entonces estamos bien, que lo encontramos.

514
00:48:52,150 --> 00:48:56,580
Aquí dice que queremos empezar a buscar en C de manejo de archivos de función,

515
00:48:56,580 --> 00:48:59,930
ya que queremos leer el diccionario,

516
00:48:59,930 --> 00:49:07,680
pero voy a dar la receta aquí en cuanto a las funciones que debe pensar.

517
00:49:07,680 --> 00:49:11,510
Voy a escribir sobre Spaces.

518
00:49:11,510 --> 00:49:20,490
Así que los principales que podría querer mirar f se abre y luego, inevitablemente, f cerrado,

519
00:49:20,490 --> 00:49:26,540
que irá al final de su programa, y ​​f f exploración.

520
00:49:26,540 --> 00:49:31,060
También puede utilizar f leer, pero es probable que no desee

521
00:49:31,060 --> 00:49:34,200
ya que - usted no termine encima de necesitar eso.

522
00:49:34,200 --> 00:49:41,880
F exploración f es lo que vas a utilizar para escanear en el diccionario.

523
00:49:41,880 --> 00:49:46,370
Y lo que no es necesario codificar la solución, sólo trato y como pseudo-código de la forma

524
00:49:46,370 --> 00:50:05,200
a una solución, y luego vamos a hablar de ello.

525
00:50:05,200 --> 00:50:14,110
Y, de hecho, puesto que ya te dio estos, si vas a cualquier terminal o shell de su aparato,

526
00:50:14,110 --> 00:50:18,250
Yo - Yo suelo - si usted no ha visto todavía, no sé si lo has hecho en clase,

527
00:50:18,250 --> 00:50:23,490
pero el hombre, por lo que las páginas de manual, son muy útiles para observar casi cualquier función.

528
00:50:23,490 --> 00:50:27,330
Así que puedo hacer, como, f hombre, escaneo f.

529
00:50:27,330 --> 00:50:32,300
Esta es ahora la información sobre la familia f exploración de las funciones.

530
00:50:32,300 --> 00:50:37,070
Yo también podría hacer f hombre, abierto, y que me dará los detalles de eso.

531
00:50:37,070 --> 00:50:40,750
Así que si usted sabe cuál es la función que está usando, o que usted está leyendo el código

532
00:50:40,750 --> 00:50:43,000
y ves alguna función y usted es como, "¿Qué hace esto?"

533
00:50:43,000 --> 00:50:45,280
Sólo el hombre que la función de nombre.

534
00:50:45,280 --> 00:50:47,340
Hay un par de ejemplos raros donde es posible que tenga que decir

535
00:50:47,340 --> 00:50:51,620
gusta. man 2 que el nombre de la función, o man 3 que el nombre de la función,

536
00:50:51,620 --> 00:50:58,230
pero sólo tienes que hacer que el hombre si el nombre de la función no le suceda a trabajar por primera vez.

537
00:50:58,230 --> 00:51:03,010
[Estudiante] Así que me estoy leyendo la página de manual para abrir, pero todavía estoy confundido sobre cómo usarlo y el programa.

538
00:51:03,010 --> 00:51:06,170
Bien. Muchas de las páginas del manual son menos que útiles.

539
00:51:06,170 --> 00:51:08,470
Son más útiles si ya saben lo que hacen

540
00:51:08,470 --> 00:51:12,670
y luego sólo tiene que recordar el orden de los argumentos o algo así.

541
00:51:12,670 --> 00:51:17,640
O se le puede dar un panorama general, pero algunos de ellos son muy abrumador.

542
00:51:17,640 --> 00:51:22,220
Como f exploración f, también. Te da la información para todas estas funciones,

543
00:51:22,220 --> 00:51:28,120
y una línea que pasa por aquí para decir, "F exploración f lee desde el punto cadena o un arroyo."

544
00:51:28,120 --> 00:51:32,360
Pero f abrirla. Así que, ¿cómo usamos f abierto?

545
00:51:32,360 --> 00:51:38,470
La idea de un programa que tiene que hacer el archivo de E / S que

546
00:51:38,470 --> 00:51:45,070
primero tiene que abrir el archivo que queremos hacer las cosas con, e inevitablemente,

547
00:51:45,070 --> 00:51:51,220
leer cosas de ese archivo y hacer cosas con ellos.

548
00:51:51,220 --> 00:51:55,350
F abierto es lo que usamos para abrir el archivo.

549
00:51:55,350 --> 00:52:04,190
Lo que volvamos, ¿y qué archivo queremos abrir, nos da la -

550
00:52:04,190 --> 00:52:11,970
aquí se dice "/ user / share / dict / words".

551
00:52:11,970 --> 00:52:16,740
Este es el archivo que desea abrir, y queremos abrirlo -

552
00:52:16,740 --> 00:52:21,440
tenemos que especificar explícitamente si queremos abrir para leer o si queremos abrirlo a escribir.

553
00:52:21,440 --> 00:52:26,490
Hay un par de combinaciones y esas cosas, pero queremos abrir este para la lectura.

554
00:52:26,490 --> 00:52:29,380
Queremos leer desde el archivo.

555
00:52:29,380 --> 00:52:34,290
Entonces, ¿qué hace este cambio? Se devuelve un archivo de estrella (*),

556
00:52:34,290 --> 00:52:37,260
y sólo voy a mostrar todo en la variable f, de modo *,

557
00:52:37,260 --> 00:52:40,840
de nuevo, es un puntero, pero no queremos hacer frente a los punteros.

558
00:52:40,840 --> 00:52:46,470
Usted puede pensar en como f, f es ahora la variable que se va a utilizar para representar el archivo.

559
00:52:46,470 --> 00:52:49,850
Así que si usted quiere leer el archivo, lee de f.

560
00:52:49,850 --> 00:52:54,820
Si desea cerrar el archivo, cierra f.

561
00:52:54,820 --> 00:53:00,350
Así que al final del programa, cuando inevitablemente quiere cerrar el archivo, ¿qué debemos hacer?

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

563
00:53:06,750 --> 00:53:12,600
Así que ahora la función de último archivo que vamos a querer utilizar es el escaneo f, f f exploración.

564
00:53:12,600 --> 00:53:20,930
Y lo que hace es que analiza el archivo en busca de un patrón que corresponda.

565
00:53:20,930 --> 00:53:39,100
En cuanto a la página del manual aquí, vemos que f int f exploración, ignorar el valor devuelto por el momento.

566
00:53:39,100 --> 00:53:45,230
El primer argumento es la corriente * archivo, por lo que el primer argumento que vamos a querer pasar es f.

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

568
00:53:47,900 --> 00:53:53,680
El segundo argumento es una cadena de formato.

569
00:53:53,680 --> 00:53:58,310
Te daré una cadena de formato en estos momentos.

570
00:53:58,310 --> 00:54:05,180
Creo que nos pasó a decir: 127S \ n, que mucho de eso es innecesario.

571
00:54:05,180 --> 00:54:12,490
La idea de lo que esa cadena de formato es, es que se pueda imaginar f exploración como lo opuesto a la f impresión.

572
00:54:12,490 --> 00:54:17,160
Así impresión f, f impresión que también utilizan este tipo de parámetro de formato,

573
00:54:17,160 --> 00:54:25,000
pero en f impresión de lo que estamos haciendo es - echemos un vistazo a un equivalente.

574
00:54:25,000 --> 00:54:32,550
Así imprimir f, y de hecho hay también f impresión f, donde el primer argumento va a ser f.

575
00:54:32,550 --> 00:54:40,980
Cuando se imprime f, podríamos decir algo como, "print 127S \ n" y luego, si le pasamos un poco de cuerda,

576
00:54:40,980 --> 00:54:44,050
que va a imprimir esta cadena y luego una nueva línea.

577
00:54:44,050 --> 00:54:49,690
¿Qué significa 127, estoy bastante seguro, pero nunca me he limitado a ella,

578
00:54:49,690 --> 00:54:52,470
Ni siquiera tendría que decir '127 'en el f impresión,

579
00:54:52,470 --> 00:54:57,090
pero lo que significa es imprimir los primeros 127 caracteres.

580
00:54:57,090 --> 00:54:59,350
Así que estoy bastante seguro de que es así. Usted puede buscar en Google para eso.

581
00:54:59,350 --> 00:55:03,000
Pero en la siguiente estoy casi seguro de que significa eso.

582
00:55:03,000 --> 00:55:08,880
Así que esto es imprimir los primeros 127 caracteres, seguido de una nueva línea.

583
00:55:08,880 --> 00:55:14,680
F exploración f ahora, en vez de mirar a una variable y de imprimirlo,

584
00:55:14,680 --> 00:55:22,620
que va a ver un poco de cuerda, y almacenar el patrón en la variable.

585
00:55:22,620 --> 00:55:26,360
Vamos a utilizar realmente f exploración en un ejemplo diferente.

586
00:55:26,360 --> 00:55:31,670
Así que vamos a decir que tuvimos algún tipo int x = 4,

587
00:55:31,670 --> 00:55:41,110
y queríamos crear una cadena hecha de - quiso crear la cadena

588
00:55:41,110 --> 00:55:44,250
que era como, este vendrá mucho más tarde,

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

590
00:55:49,020 --> 00:55:51,870
Así que esto podría ser un programa donde tendrá contador suma,

591
00:55:51,870 --> 00:55:56,420
Resumiendo contrarrestar i, y desea ahorrar un montón de imágenes.

592
00:55:56,420 --> 00:56:02,430
Así que usted quiere ahorrar i.jpg, donde i es un poco iteración del bucle.

593
00:56:02,430 --> 00:56:05,500
Entonces, ¿cómo hacemos para que esta cadena JPEG?

594
00:56:05,500 --> 00:56:11,720
Si quieres imprimir 4.jpg, podríamos decir f impresión, d.jpg%,

595
00:56:11,720 --> 00:56:14,410
y entonces se imprime para que JPEG.

596
00:56:14,410 --> 00:56:20,050
Pero si queremos salvar el 4.jpg cadena, utilizamos f exploración.

597
00:56:20,050 --> 00:56:30,860
Así que la cadena s - en realidad nos puedo - carácter, char s, vamos a ir 100.

598
00:56:30,860 --> 00:56:35,400
Así que me acaba de declarar algún arreglo de 100 caracteres,

599
00:56:35,400 --> 00:56:39,830
y eso es lo que estamos inevitablemente va a almacenar esa JPEG pulg

600
00:56:39,830 --> 00:56:47,920
Así que vamos a usar f escaneado y el formato, cómo diríamos d.jpg%

601
00:56:47,920 --> 00:56:54,980
con el fin de imprimir 4.jpg, el formato de este va a ser d.jpg%.

602
00:56:54,980 --> 00:57:04,020
Así que el formato es d.jpg%, lo que quiere reemplazar con% d es x,

603
00:57:04,020 --> 00:57:06,590
y ahora tenemos que guardar esa cadena en alguna parte.

604
00:57:06,590 --> 00:57:12,500
Y donde vamos a almacenar esta cadena está en el array s.

605
00:57:12,500 --> 00:57:21,640
Así que después de esta línea de código, s, si imprimimos f, s% s de la variable,

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

607
00:57:26,280 --> 00:57:38,930
Entonces f exploración f es la misma que scan f, excepto que ahora ve hacia el archivo

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

609
00:57:43,600 --> 00:57:46,160
Eso es lo que el último argumento va a ser.

610
00:57:46,160 --> 00:57:54,170
Queremos guardar - "familia f Scan de exploraciones funciones en tanto de acuerdo al formato que trató a continuación.

611
00:57:54,170 --> 00:58:02,450
Si se almacenan en los puntos de ubicación podría regresar - "

612
00:58:02,450 --> 00:58:12,910
No, puede ser bueno. Déjame pensar por un segundo.

613
00:58:12,910 --> 00:58:26,350
Así exploración f no lo hace - ¿qué diablos es la función que hace eso?

614
00:58:26,350 --> 00:58:31,650
Así exploración f no se va a tomar un entero y hacer punto jpg.

615
00:58:31,650 --> 00:58:43,490
Va a [murmura].

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

617
00:58:49,360 --> 00:58:55,940
¿Qué es esta variable, o lo que es esta función se llama?

618
00:58:55,940 --> 00:59:04,950
Sí. Eso es - sí. Así que lo que se define a usted antes era s f impresión,

619
00:59:04,950 --> 00:59:09,820
que - que tiene mucho más sentido, ¿por qué me dijo que era mucho más parecido f impresión.

620
00:59:09,820 --> 00:59:14,700
Scan f es todavía una especie de f impresión, pero f s de impresión se va a escanear a través de

621
00:59:14,700 --> 00:59:17,510
y sustituya las variables y ahora se almacenan en una cadena.

622
00:59:17,510 --> 00:59:19,620
En lugar de imprimirlo, lo almacena en una cadena.

623
00:59:19,620 --> 00:59:25,070
Así que ignora que por completo. Usted todavía puede pensar en el especificador de formato como el de f impresión.

624
00:59:25,070 --> 00:59:34,510
Así que ahora, si queríamos hacer lo 4.jpg, haríamos f s de impresión, x de esto.

625
00:59:34,510 --> 00:59:38,520
Entonces, ¿qué está haciendo exploración f - ¿Cuál era tu pregunta va a ser?

626
00:59:38,520 --> 00:59:40,820
[Estudiante] Estoy confundido sobre lo que estamos tratando de hacer aquí

627
00:59:40,820 --> 00:59:43,450
con que JPEG. ¿Se puede explicar que una vez más?

628
00:59:43,450 --> 00:59:52,710
Así que esta fue - es menos relevent de exploración f f ahora, con suerte, se unirá de nuevo en algún tipo de camino.

629
00:59:52,710 --> 01:00:02,240
Pero lo que inicialmente tenía la intención de mostrar era - es en realidad directamente relacionados con éstos [? F5]

630
01:00:02,240 --> 01:00:08,520
Vas a estar usando f s de impresión, donde, digamos que tenemos 100 imágenes,

631
01:00:08,520 --> 01:00:13,630
y quieres leer la imagen 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Así que para hacer eso, tiene que f abierto, y entonces usted tiene que pasar en la cadena que desea abrir.

633
01:00:21,520 --> 01:00:30,020
Así que nos gustaría abrir 1.jpg, con el fin de crear la cadena que es 1.jpg,

634
01:00:30,020 --> 01:00:37,660
hacemos s f impresión de% d.jpg--no lo hicimos para int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Así impresión% s f d.jpg de i.

637
01:00:51,130 --> 01:00:56,320
Así que después de esta línea, ahora la variable o el arreglo s va a 1.jpg.

638
01:00:56,320 --> 01:01:10,610
O 0.jpg, 1.jpg, 2.jpg. Por esto se puede abrir, a su vez, cada imagen para leer.

639
01:01:10,610 --> 01:01:19,550
Así que eso es lo que s imprimir f hace. ¿Ves lo que s imprimir f está haciendo ahora?

640
01:01:19,550 --> 01:01:25,720
[Estudiante] Bueno, por lo que está tomando - crea una cadena, something.jpg, a continuación, lo guarda.

641
01:01:25,720 --> 01:01:30,360
Sí. Crea - esta es otra cadena de formato, al igual que f f escaneo y de impresión,

642
01:01:30,360 --> 01:01:37,530
donde se inserta todas las variables en el segundo argumento, podría ser s en lugar de i.

643
01:01:37,530 --> 01:01:42,280
Tal vez - quiero decir, ese es el caso. Pero cualquiera que sea el orden de los argumentos es.

644
01:01:42,280 --> 01:01:45,440
Se va a introducir todas las variables en la cadena de formato

645
01:01:45,440 --> 01:01:52,250
y luego almacenar en nuestro buffer, lo llamamos un buffer, que es donde se está almacenando la cadena.

646
01:01:52,250 --> 01:02:00,750
Así que estamos almacenando dentro de la cadena s con el formato correcto,% d de haber sido sustituido por 4.

647
01:02:00,750 --> 01:02:08,080
[Estudiante] Así que si hacemos esto, es la variable f sólo va a ser reasignado?

648
01:02:08,080 --> 01:02:18,110
Sí. Así que debemos cerrar la f original antes de hacer esto.

649
01:02:18,110 --> 01:02:22,810
Pero - y luego también, si no hubiera un f abrir aquí, entonces tendríamos que decir -

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

651
01:02:29,280 --> 01:02:37,360
[Estudiante] Pero no sería capaz de acceder o - Está bien.

652
01:02:37,360 --> 01:02:44,230
Bien. Así exploración f, f exploración f, es una especie de la misma idea,

653
01:02:44,230 --> 01:02:53,610
pero en vez de, en lugar de almacenarla en una cadena, es más como estás ahora

654
01:02:53,610 --> 01:03:02,420
repasando un pinchazo y una coincidencia de patrones en contra de esta cadena y almacenar los resultados en variables.

655
01:03:02,420 --> 01:03:11,290
Usted puede utilizar f exploración para analizar por algo así 4.jpg y almacenar el número entero en 4 x int suma.

656
01:03:11,290 --> 01:03:13,430
Eso es lo que se puede utilizar para exploración f.

657
01:03:13,430 --> 01:03:16,300
F f exploración va a hacer que en la línea de comandos.

658
01:03:16,300 --> 01:03:19,200
En realidad estoy bastante seguro de que esto es lo que la biblioteca CS50 hace.

659
01:03:19,200 --> 01:03:29,050
Así que cuando usted dice, "get int," es escaneado f-ing sobre - f exploración es la forma en que recibe la entrada del usuario.

660
01:03:29,050 --> 01:03:34,670
F f exploración que va a hacer lo mismo pero usando un archivo a escanear de nuevo.

661
01:03:34,670 --> 01:03:41,090
Así que aquí estamos explorando sobre este archivo.

662
01:03:41,090 --> 01:03:45,460
El patrón que estamos tratando de coincidir con alguna cadena que es de 127 caracteres de longitud

663
01:03:45,460 --> 01:03:48,100
seguido de una nueva línea

664
01:03:48,100 --> 01:03:54,770
Así que estoy bastante seguro de que podríamos incluso a decir "match s", ya que en el diccionario

665
01:03:54,770 --> 01:03:57,770
sucede que tenemos, no está garantizado que la palabra es larga,

666
01:03:57,770 --> 01:04:03,310
y f f exploración, creo, no se detendrá ante la nueva línea no importa qué.

667
01:04:03,310 --> 01:04:06,970
Pero vamos a incluir la nueva línea en el partido, y -

668
01:04:06,970 --> 01:04:13,960
[Estudiante] Si no incluimos la nueva línea, no lo encontraría partes de una palabra?

669
01:04:13,960 --> 01:04:22,900
It - cada una - ver el diccionario -

670
01:04:22,900 --> 01:04:26,200
Así, en el diccionario, se trata de todas nuestras palabras.

671
01:04:26,200 --> 01:04:30,500
Cada uno está en una nueva línea.

672
01:04:30,500 --> 01:04:32,510
F El análisis se va a recoger esta palabra.

673
01:04:32,510 --> 01:04:38,750
Si no incluimos la nueva línea, entonces es posible que la siguiente exploración f sólo leerá la nueva línea.

674
01:04:38,750 --> 01:04:44,180
Pero incluso entonces sólo nueva línea pasará por alto la nueva línea.

675
01:04:44,180 --> 01:04:49,440
Pero nunca vamos a obtener parte de una palabra, ya que siempre estamos leyendo a una nueva línea, no importa lo que pase.

676
01:04:49,440 --> 01:04:54,530
[Estudiante] Pero lo que si usted busca la palabra "cissa," como cissa.

677
01:04:54,530 --> 01:04:57,380
Va a encontrar eso, y decir que es una coincidencia?

678
01:04:57,380 --> 01:05:05,110
Así que aquí estamos - se lee en - esto es realmente un buen punto.

679
01:05:05,110 --> 01:05:10,660
Nunca estamos usando la corriente - la palabra que estamos buscando es el argumento de comando de primera línea.

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

681
01:05:16,460 --> 01:05:20,020
Así que la cadena que estamos buscando es argv 1.

682
01:05:20,020 --> 01:05:23,290
No estamos buscando una palabra en absoluto en nuestra f exploración.

683
01:05:23,290 --> 01:05:28,030
Lo que estábamos haciendo con la exploración f está consiguiendo cada palabra en el diccionario,

684
01:05:28,030 --> 01:05:34,320
y luego una vez que tengamos esa palabra que vamos a usar strcmp para compararlos.

685
01:05:34,320 --> 01:05:39,210
Vamos a comparar nuestra palabra y lo que acabamos de leer pulg

686
01:05:39,210 --> 01:05:45,110
Por lo tanto, inevitablemente, vamos a terminar haciendo un montón de exploración fs

687
01:05:45,110 --> 01:05:52,130
hasta que da la casualidad de que f exploración volverá -

688
01:05:52,130 --> 01:05:54,800
ha de devolver uno, el tiempo que ha coincidido con una nueva palabra,

689
01:05:54,800 --> 01:06:01,360
y volverá otra cosa tan pronto como se han logrado alcanzar la palabra.

690
01:06:01,360 --> 01:06:08,440
Estamos leyendo el diccionario entero, almacenar línea a línea cada palabra en la variable s.

691
01:06:08,440 --> 01:06:17,240
Entonces estamos comparando palabra con s, y si la comparación == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp pasa a traer 0 si un partido se hizo.

693
01:06:21,650 --> 01:06:31,510
Así que si lo fue de 0, entonces podemos imprimir f, emparejado,

694
01:06:31,510 --> 01:06:35,370
o palabra en el diccionario, o lo que usted desee imprimir f.

695
01:06:35,370 --> 01:06:41,450
Y entonces - que no quieren f cerrar una y otra vez.

696
01:06:41,450 --> 01:06:50,410
Este es el tipo de cosas que queremos hacer, y no estamos sólo en busca de la palabra en el diccionario.

697
01:06:50,410 --> 01:06:56,660
Así que podríamos hacer eso, si quisiéramos buscar su patrón, Cissa, como dijiste antes,

698
01:06:56,660 --> 01:07:00,260
si quisiéramos buscar ese patrón, entonces sería fallar en el caso

699
01:07:00,260 --> 01:07:08,010
porque eso no es realmente una palabra, sino una de las palabras en el diccionario que pasa a tener en ella.

700
01:07:08,010 --> 01:07:13,560
Por lo que se correspondería con esta palabra, pero este subconjunto de la palabra no es una palabra en sí.

701
01:07:13,560 --> 01:07:17,250
Pero esa no es la forma en que se esté usando, estamos leyendo en cada palabra

702
01:07:17,250 --> 01:07:19,740
y luego comparar la palabra que tenemos con esa palabra.

703
01:07:19,740 --> 01:07:25,780
Así que siempre estamos comparando palabras completas.

704
01:07:25,780 --> 01:07:29,620
Me pueden enviar las soluciones finalizadas después.

705
01:07:29,620 --> 01:07:32,050
Esta es una especie de cerca la respuesta correcta, creo.

706
01:07:32,050 --> 01:07:34,720
[Comentario Estudiante, ininteligible]

707
01:07:34,720 --> 01:07:40,870
Oh, ¿puedo deshacerme de eso antes? Char s, creo que dijo 127 - se me olvida lo que es el más grande.

708
01:07:40,870 --> 01:07:44,100
Vamos a hacer 128, por lo que ahora s es lo suficientemente largo.

709
01:07:44,100 --> 01:07:46,570
No es necesario imprimir nada.

710
01:07:46,570 --> 01:07:56,440
También vamos a querer tener cerca a nuestro archivo, y que debe ser sobre la respuesta correcta.

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