1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Hola, soy Rob Bowden,
y vamos a hablar de quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Por lo tanto, la primera pregunta.

5
00:00:14,545 --> 00:00:17,750
Esta es la pregunta donde
que necesitabas para codificar el número

6
00:00:17,750 --> 00:00:21,270
127 en los bulbos binarios.

7
00:00:21,270 --> 00:00:23,550
Si quisieras, podrías
hacer la conversión normal

8
00:00:23,550 --> 00:00:25,950
desde bi-- o, de decimal a binario.

9
00:00:25,950 --> 00:00:28,300
Pero eso probablemente va
que tomar un montón de tiempo.

10
00:00:28,300 --> 00:00:31,750
Quiero decir, usted podría darse cuenta de que,
Aceptar, 1 es de allí, 2 es allí,

11
00:00:31,750 --> 00:00:33,650
4 es ahí, 8 es en allí.

12
00:00:33,650 --> 00:00:39,280
Manera más fácil, 127 es 128 menos uno.

13
00:00:39,280 --> 00:00:42,013
Esa bombilla más a la izquierda es la de 128 bits.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Así que 127 es realmente todo
de las otras bombillas,

16
00:00:47,860 --> 00:00:51,420
ya que es el más a la izquierda
bombilla menos 1.

17
00:00:51,420 --> 00:00:52,800
Eso es todo por esta pregunta.

18
00:00:52,800 --> 00:00:54,060
>> Pregunta uno.

19
00:00:54,060 --> 00:00:56,710
Así que con 3 bits que pueda
representar 8 valores distintos.

20
00:00:56,710 --> 00:01:01,000
¿Por qué, entonces, es la más grande de 7 no negativo
entero decimal se puede representar?

21
00:01:01,000 --> 00:01:04,050
Bueno, si sólo podemos
representar 8 valores distintos,

22
00:01:04,050 --> 00:01:07,430
entonces lo que vamos a ser
que representa es de 0 a 7.

23
00:01:07,430 --> 00:01:08,745
0 ocupa uno de los valores.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Pregunta dos.

26
00:01:11,190 --> 00:01:14,610
Con n bits, ¿cuántos distinta
valores pueden representarlo?

27
00:01:14,610 --> 00:01:19,080
Así, con n bits, tiene 2
los valores posibles para cada bit.

28
00:01:19,080 --> 00:01:22,300
Así que tenemos dos valores posibles para
el primer bit, 2 valores posibles

29
00:01:22,300 --> 00:01:24,450
para el segundo, 2
posible para la tercera.

30
00:01:24,450 --> 00:01:28,730
Y por lo que es 2 veces 2 veces 2, y
en última instancia, la respuesta es 2 a la n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> Pregunta tres.

33
00:01:31,100 --> 00:01:33,450
¿Qué es 0x50 en binario?

34
00:01:33,450 --> 00:01:39,490
Así que recuerde que tiene una muy hexadecimal
conversión directa a binario.

35
00:01:39,490 --> 00:01:43,180
Así que aquí, sólo tenemos que mirar
el 5 y el 0 independiente.

36
00:01:43,180 --> 00:01:45,110
Así que lo que es 5 en binario?

37
00:01:45,110 --> 00:01:48,400
0101, que es el bit 1 y el 4 bits.

38
00:01:48,400 --> 00:01:49,900
Lo que es 0 en binario?

39
00:01:49,900 --> 00:01:50,520
No es complicado.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Así que sólo hay que poner juntos, y
ese es el número completo en binario.

42
00:01:54,970 --> 00:01:57,640
01.010.000.

43
00:01:57,640 --> 00:02:00,439
Y si quisieras podrías
despegue que más a la izquierda de cero.

44
00:02:00,439 --> 00:02:01,105
Es irrelevante.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> Así que, alternativamente,
lo que es 0x50 en decimal?

47
00:02:05,733 --> 00:02:08,649
Si usted quisiera, usted could-- si estás
más cómodo con el binario,

48
00:02:08,649 --> 00:02:11,340
usted podría tomar esa respuesta binaria
y convertir eso en decimal.

49
00:02:11,340 --> 00:02:13,870
O podríamos recordar
que hexadecimal.

50
00:02:13,870 --> 00:02:21,140
Así que 0 está en el lugar 0 º, y
el 5 es en el 16 al primer lugar.

51
00:02:21,140 --> 00:02:25,990
Así que aquí, tenemos 5 veces 16 a la
primero, plus 0 veces 16 a la cero,

52
00:02:25,990 --> 00:02:27,520
es 80.

53
00:02:27,520 --> 00:02:29,710
Y si uno mira en la
el título de la pregunta,

54
00:02:29,710 --> 00:02:32,920
era CS 80, que era una especie de
alusión a la respuesta a este problema.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Pregunta cinco.

57
00:02:35,420 --> 00:02:40,320
Tenemos este script Scratch, que es
repetir 4 veces la mantequilla de maní jalea.

58
00:02:40,320 --> 00:02:42,800
Entonces, ¿cómo ahora el código que en C?

59
00:02:42,800 --> 00:02:47,730
Bueno, tenemos aquí-- la parte en negrita
es la única parte que había que poner en práctica.

60
00:02:47,730 --> 00:02:51,950
Así que tenemos un bucle de 4 que está en bucle 4
veces, la mantequilla de maní jalea ing-printf,

61
00:02:51,950 --> 00:02:53,910
con la nueva línea que el problema pide.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Pregunta seis, otro problema de Scratch.

64
00:02:57,490 --> 00:03:00,210
Vemos que estamos en un bucle para siempre.

65
00:03:00,210 --> 00:03:05,000
Estamos diciendo que la variable i
y luego incrementar i en 1.

66
00:03:05,000 --> 00:03:09,580
Ahora queremos hacer que en C. Hay
múltiples formas en las que podríamos haber hecho esto.

67
00:03:09,580 --> 00:03:12,840
Aquí pasamos a codificar el
para siempre como un bucle while (true).

68
00:03:12,840 --> 00:03:16,600
Así que declaramos la variable i, sólo
como teníamos i variable en scratch.

69
00:03:16,600 --> 00:03:21,950
Declare la variable i, y para siempre
while (true), decimos que la variable i.

70
00:03:21,950 --> 00:03:25,260
Así printf% yo-- o que podría haber utilizado% d.

71
00:03:25,260 --> 00:03:27,985
Nosotros decimos que la variable, y
luego incrementarlo, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Pregunta siete.

74
00:03:30,830 --> 00:03:35,560
Ahora queremos hacer algo muy similar
Mario punto c del problema planteado uno.

75
00:03:35,560 --> 00:03:39,110
Queremos imprimir estos hashtags,
queremos imprimir un cinco

76
00:03:39,110 --> 00:03:40,700
por tres rectángulo de estos hashes.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Entonces, ¿cómo vamos a hacer eso?

79
00:03:43,162 --> 00:03:45,370
Bueno, te damos un todo
montón de código, y que acaba de

80
00:03:45,370 --> 00:03:47,560
tiene que llenar en la función de impresión de cuadrícula.

81
00:03:47,560 --> 00:03:49,540
>> Así que lo que se ve como PrintGrid?

82
00:03:49,540 --> 00:03:51,480
Pues estás más allá de la
anchura y la altura.

83
00:03:51,480 --> 00:03:53,520
Así que tenemos un exterior 4
lazo, eso es un bucle

84
00:03:53,520 --> 00:03:57,650
sobre todo de las filas de este
cuadrícula que queremos imprimir.

85
00:03:57,650 --> 00:04:01,250
Luego tenemos el bucle anidado entre 4,
esa es la impresión sobre cada columna.

86
00:04:01,250 --> 00:04:06,210
Así que para cada fila, imprimimos para
cada columna, un solo hash.

87
00:04:06,210 --> 00:04:10,045
Luego, al final de la fila es la impresión de un
línea de nuevo sencillo para ir a la siguiente fila.

88
00:04:10,045 --> 00:04:11,420
Y eso es todo por toda la red.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Pregunta ocho.

91
00:04:13,675 --> 00:04:17,170
Una función como PrintGrid se dice que
tener un efecto secundario, pero no un retorno

92
00:04:17,170 --> 00:04:17,670
valor.

93
00:04:17,670 --> 00:04:19,209
Explicar la distinción.

94
00:04:19,209 --> 00:04:23,080
Así que esto se basa en que recordar
lo que es un efecto secundario es.

95
00:04:23,080 --> 00:04:25,180
Bueno, un retorno value--
sabemos PrintGrid no lo hace

96
00:04:25,180 --> 00:04:28,180
tienen valor de retorno, ya que
aquí se dice sin efecto.

97
00:04:28,180 --> 00:04:31,150
Así que cualquier cosa que devuelve void
en realidad no devolver nada.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Entonces, ¿cuál es el efecto secundario?

100
00:04:33,620 --> 00:04:36,620
Bueno, un efecto secundario es
nada ese tipo de persiste

101
00:04:36,620 --> 00:04:39,500
después de los extremos de la función
que no era acabamos de volver,

102
00:04:39,500 --> 00:04:41,340
y que no era sólo de los insumos.

103
00:04:41,340 --> 00:04:44,970
>> Así, por ejemplo, podríamos
cambiar una variable global.

104
00:04:44,970 --> 00:04:46,590
Eso sería un efecto secundario.

105
00:04:46,590 --> 00:04:49,000
En este caso particular, un
efecto secundario muy importante

106
00:04:49,000 --> 00:04:51,070
se imprime en la pantalla.

107
00:04:51,070 --> 00:04:53,110
Así que es un efecto secundario
que tiene PrintGrid.

108
00:04:53,110 --> 00:04:54,980
Imprimimos estas cosas a la pantalla.

109
00:04:54,980 --> 00:04:56,370
Y usted puede pensar en
que como un efecto secundario,

110
00:04:56,370 --> 00:04:58,690
ya que eso es algo que
persiste después de que termine esta función.

111
00:04:58,690 --> 00:05:01,481
Eso es algo que está fuera del alcance
de esta función que en última instancia

112
00:05:01,481 --> 00:05:03,380
está siendo cambiado, la
contenido de la pantalla.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Pregunta nueve.

115
00:05:05,839 --> 00:05:07,880
Considere el siguiente programa,
a la que los números de línea

116
00:05:07,880 --> 00:05:09,740
se han añadido para
En aras de la discusión.

117
00:05:09,740 --> 00:05:13,480
Así que en este programa sólo somos
llamando GetString, almacenándolo

118
00:05:13,480 --> 00:05:16,220
en esta variable s, y luego
la impresión de que la variable s.

119
00:05:16,220 --> 00:05:16,720
Okay.

120
00:05:16,720 --> 00:05:19,090
Así que explicar por qué la línea uno está presente.

121
00:05:19,090 --> 00:05:20,920
#include punto CS50 h.

122
00:05:20,920 --> 00:05:23,820
¿Por qué necesitamos a #include CS50 punto h?

123
00:05:23,820 --> 00:05:26,180
Bueno estamos llamando a la
Función GetString,

124
00:05:26,180 --> 00:05:28,840
y GetString se define
en la biblioteca CS50.

125
00:05:28,840 --> 00:05:31,600
Así que si no teníamos
#include punto CS50 h,

126
00:05:31,600 --> 00:05:35,760
que iba a conseguir que la declaración implícita
de la función de error GetString

127
00:05:35,760 --> 00:05:36,840
del compilador.

128
00:05:36,840 --> 00:05:40,110
Así que tenemos que incluir la library--
tenemos que incluir el archivo de cabecera,

129
00:05:40,110 --> 00:05:42,870
o de lo contrario el compilador no lo hará
reconocen que existe GetString.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Explique por qué la línea dos está presente.

132
00:05:46,140 --> 00:05:47,890
Así estándar punto h io.

133
00:05:47,890 --> 00:05:50,430
Es exactamente la misma
como el problema anterior,

134
00:05:50,430 --> 00:05:53,310
excepto que en lugar de tratar con
GetString, estamos hablando de printf.

135
00:05:53,310 --> 00:05:56,654
Así que si no decimos lo que necesitamos
para incluir estándar de punto io h,

136
00:05:56,654 --> 00:05:58,820
entonces nosotros no podríamos
utilizar la función printf,

137
00:05:58,820 --> 00:06:00,653
porque el compilador
no saberlo.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Qué-- cuál es el significado
de pleno derecho en la línea de cuatro?

140
00:06:05,260 --> 00:06:08,010
Así que aquí tenemos int main (void).

141
00:06:08,010 --> 00:06:10,600
Eso es justo decir que
no están recibiendo ninguna línea de comandos

142
00:06:10,600 --> 00:06:12,280
argumentos a principal.

143
00:06:12,280 --> 00:06:17,390
Recuerde que nosotros podríamos decir int
principales soportes de cadena argv argc int.

144
00:06:17,390 --> 00:06:20,400
Así que aquí nos limitamos a decir nula decir que
están haciendo caso omiso de los argumentos de línea de comandos.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Explicar, con respecto a la memoria, exactamente
lo GetString en línea de seis vueltas.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString está volviendo un bloque de
memoria, una gran variedad de personajes.

149
00:06:31,640 --> 00:06:34,870
Es realmente un regreso
puntero al primer carácter.

150
00:06:34,870 --> 00:06:37,170
Recuerde que una cadena es una estrella de carbón.

151
00:06:37,170 --> 00:06:41,360
Así que s es un puntero a la primera
personaje en cualquiera que sea la cadena es

152
00:06:41,360 --> 00:06:43,510
que el usuario entró en el teclado.

153
00:06:43,510 --> 00:06:47,070
Y que la memoria pasa a ser malloced,
por lo que la memoria está en el montón.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Pregunta 13.

156
00:06:50,450 --> 00:06:51,960
Considere el siguiente programa.

157
00:06:51,960 --> 00:06:55,579
Así que todo este programa está haciendo
se printf-ing 1 dividido por 10.

158
00:06:55,579 --> 00:06:57,370
Así que cuando se compila y
ejecutado, este programa

159
00:06:57,370 --> 00:07:01,170
salidas 0.0, a pesar de que
1 dividido por 10 es 0,1.

160
00:07:01,170 --> 00:07:02,970
Así que ¿por qué es 0.0?

161
00:07:02,970 --> 00:07:05,510
Bueno, esto se debe a
de la división entera.

162
00:07:05,510 --> 00:07:08,580
Así que es un número entero 1, 10 es un número entero.

163
00:07:08,580 --> 00:07:11,980
Así que 1 dividido por 10, todo
se trata como números enteros,

164
00:07:11,980 --> 00:07:16,380
y en C, cuando hacemos la división entera,
truncamos cualquier punto decimal.

165
00:07:16,380 --> 00:07:19,590
Así que 1 dividido por 10 se
0, y entonces estamos tratando

166
00:07:19,590 --> 00:07:24,410
para imprimir que como un flotador, por lo
cero impresa como un flotador es 0.0.

167
00:07:24,410 --> 00:07:27,400
Y es por eso que obtenemos 0.0.

168
00:07:27,400 --> 00:07:28,940
>> Considere el siguiente programa.

169
00:07:28,940 --> 00:07:31,280
Ahora estamos imprimiendo 0.1.

170
00:07:31,280 --> 00:07:34,280
Así que no hay división entera,
sólo estamos imprimiendo 0,1,

171
00:07:34,280 --> 00:07:37,100
pero estamos imprimirlo
a 28 cifras decimales.

172
00:07:37,100 --> 00:07:41,810
Y obtenemos este 0,1000, un montón
de ceros, 5 5 5, bla, bla, bla.

173
00:07:41,810 --> 00:07:45,495
Así que la pregunta aquí es ¿por qué lo hace
imprimir que, en lugar de exactamente 0,1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> Así que la razón aquí es ahora
punto imprecisión flotante.

176
00:07:49,640 --> 00:07:53,410
Recuerde que un flotador está a sólo 32 bits.

177
00:07:53,410 --> 00:07:57,540
Así que sólo podemos representar un número finito
de valores de punto flotante con los 32

178
00:07:57,540 --> 00:07:58,560
Bits.

179
00:07:58,560 --> 00:08:01,760
Bueno, hay, en última instancia infinitamente
muchos de los valores de punto flotante,

180
00:08:01,760 --> 00:08:04,940
y hay infinitamente muchos flotante
los valores de punto de entre 0 y 1,

181
00:08:04,940 --> 00:08:07,860
y estamos obviamente capaz de
representar incluso más valores que eso.

182
00:08:07,860 --> 00:08:13,230
Así que tenemos que hacer sacrificios para
ser capaz de representar a la mayoría de los valores.

183
00:08:13,230 --> 00:08:16,960
>> Así como un valor de 0,1, al parecer,
no podemos representar eso exactamente.

184
00:08:16,960 --> 00:08:22,500
Así que en lugar de representar el 0,1 hacemos la
Lo mejor que podemos representar este 0.100000 5 5

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
Y eso es bastante estrecha, pero
para una gran cantidad de aplicaciones

187
00:08:26,306 --> 00:08:28,430
usted tiene que preocuparse acerca de
punto imprecisión flotante,

188
00:08:28,430 --> 00:08:30,930
porque simplemente no podemos representar
todos flotante puntos exactamente.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Pregunta 15.

191
00:08:33,380 --> 00:08:34,679
Considere el código de abajo.

192
00:08:34,679 --> 00:08:36,630
Estamos imprimiendo 1 más 1.

193
00:08:36,630 --> 00:08:38,289
Así que no hay truco aquí.

194
00:08:38,289 --> 00:08:41,780
1 más 1 evalúa a 2, y
entonces estamos imprimiendo eso.

195
00:08:41,780 --> 00:08:42,789
Esto sólo imprime 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Pregunta 16.

198
00:08:44,700 --> 00:08:49,450
Ahora estamos imprimiendo el carácter
1 más el carácter 1.

199
00:08:49,450 --> 00:08:52,110
Así que ¿por qué esto no
imprimir la misma cosa?

200
00:08:52,110 --> 00:08:57,680
Bueno, el personaje 1 más el carácter
1, el personaje tiene un valor ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Así que esto realmente está diciendo 49, más 49, y
en última instancia, esto va a imprimir 98.

202
00:09:04,840 --> 00:09:06,130
Así que esto no imprime 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Pregunta 17.

205
00:09:09,271 --> 00:09:11,520
Completar la aplicación
de impar a continuación de tal manera

206
00:09:11,520 --> 00:09:14,615
que la función devuelve verdadero si
n es impar y false si n es par.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
Este es un gran propósito
para el operador mod.

209
00:09:19,330 --> 00:09:24,530
Así que nos tomamos nuestro argumento n,
si n mod 2 es igual a 1, así

210
00:09:24,530 --> 00:09:28,030
eso significa que n divide
por 2 tenía un resto.

211
00:09:28,030 --> 00:09:33,270
Si n dividido por 2 tenía un resto, que
significa que n es impar, por lo que volver realidad.

212
00:09:33,270 --> 00:09:34,910
Otras ventas volvemos falsa.

213
00:09:34,910 --> 00:09:39,070
También podría haber hecho n mod 2 iguales
cero, return false, de lo contrario devuelve true.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Considere la función recursiva a continuación.

216
00:09:43,640 --> 00:09:46,920
Así que si n es menor que o
igual a 1, devuelve 1,

217
00:09:46,920 --> 00:09:50,430
o regrese n veces f de n menos 1.

218
00:09:50,430 --> 00:09:52,556
Entonces, ¿qué es esta función?

219
00:09:52,556 --> 00:09:54,305
Bueno, esto es sólo el
función factorial.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
Esto está muy bien representado
como n factorial.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Así que ahora la pregunta 19, queremos
aprovechar esta función recursiva.

224
00:10:02,310 --> 00:10:04,530
Queremos que sea iterativo.

225
00:10:04,530 --> 00:10:05,874
Entonces, ¿cómo hacemos eso?

226
00:10:05,874 --> 00:10:07,790
Bueno para el personal
solución, y de nuevo no es

227
00:10:07,790 --> 00:10:11,090
múltiples formas en las que podría haber hecho
que, comenzamos con este producto int

228
00:10:11,090 --> 00:10:11,812
es igual a 1.

229
00:10:11,812 --> 00:10:13,520
Y en todo este
bucle for, vamos

230
00:10:13,520 --> 00:10:17,590
multiplicarse producto a última instancia
terminar con el factorial completo.

231
00:10:17,590 --> 00:10:21,870
Así que para int i es igual a 2, i es
menos de o igual a n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Tal vez se pregunte por qué i es igual a 2.

233
00:10:24,130 --> 00:10:28,380
Bueno, recuerde que aquí tenemos que
asegurarse de que nuestro caso base es correcta.

234
00:10:28,380 --> 00:10:32,180
Así que si n es menor que o igual
a 1, sólo estamos volviendo 1.

235
00:10:32,180 --> 00:10:34,830
Así que aquí, empezamos a i es igual a 2.

236
00:10:34,830 --> 00:10:39,090
Bueno, si yo fuera 1, entonces el-- o
si n era 1, entonces el bucle for

237
00:10:39,090 --> 00:10:40,600
no ejecutar en absoluto.

238
00:10:40,600 --> 00:10:43,190
Y así lo haríamos sólo
producto de vuelta, que es 1.

239
00:10:43,190 --> 00:10:45,920
Del mismo modo, si n eran
nada menos que 1--

240
00:10:45,920 --> 00:10:49,290
si fuera 0, 1 negativo, whatever--
todavía estaríamos regresando 1,

241
00:10:49,290 --> 00:10:52,260
que es exactamente lo que el
versión recursiva está haciendo.

242
00:10:52,260 --> 00:10:54,660
>> Ahora, si n es mayor
que 1, entonces vamos

243
00:10:54,660 --> 00:10:56,550
hacer al menos un
iteración de este bucle.

244
00:10:56,550 --> 00:11:00,630
Así que digamos que n es 5, entonces estamos
va a hacer veces de productos es igual a 2.

245
00:11:00,630 --> 00:11:02,165
Así que ahora el producto es de 2.

246
00:11:02,165 --> 00:11:04,040
Ahora vamos a hacer
veces de productos es igual a 3.

247
00:11:04,040 --> 00:11:04,690
Ahora es el 6.

248
00:11:04,690 --> 00:11:07,500
Tiempos de producto es igual a 4, ahora es el 24.

249
00:11:07,500 --> 00:11:10,420
Tiempos de producto es igual a 5, ahora es el 120.

250
00:11:10,420 --> 00:11:16,730
Así que, en última instancia, estamos volviendo
120, que es correctamente 5 factorial.

251
00:11:16,730 --> 00:11:17,510
>> Pregunta 20.

252
00:11:17,510 --> 00:11:22,480
Esto es en la que usted tiene que llenar
en esta tabla con cualquier algoritmo dado,

253
00:11:22,480 --> 00:11:25,735
nada de lo que hemos visto, que
encaja estos algorítmica plazo

254
00:11:25,735 --> 00:11:28,060
veces estos tiempos de ejecución asintótica.

255
00:11:28,060 --> 00:11:33,270
Entonces, ¿qué es un algoritmo que
es el omega de 1, pero gran O de n?

256
00:11:33,270 --> 00:11:35,970
Así que podría ser infinitamente
muchas respuestas aquí.

257
00:11:35,970 --> 00:11:39,790
La que hemos visto probablemente más
con frecuencia es sólo búsqueda lineal.

258
00:11:39,790 --> 00:11:42,050
>> Así, en el mejor de los casos
escenario, el tema que estamos

259
00:11:42,050 --> 00:11:44,050
buscando está en el
principio de la lista

260
00:11:44,050 --> 00:11:47,400
y así en omega de pasos de 1,
lo primero que comprobamos,

261
00:11:47,400 --> 00:11:49,740
acabamos de regresar de inmediato
que encontramos el artículo.

262
00:11:49,740 --> 00:11:52,189
En el peor de los casos,
el artículo está en el extremo,

263
00:11:52,189 --> 00:11:53,730
o el artículo no está en la lista en absoluto.

264
00:11:53,730 --> 00:11:56,700
Así que tenemos que buscar
toda la lista, todos los n

265
00:11:56,700 --> 00:11:58,480
elementos, y es por eso que es o de n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> Así que ahora es algo que a la vez
omega de n log n, y gran O de n log n.

268
00:12:04,880 --> 00:12:08,650
Bueno, la cosa más relevante
que hemos visto aquí es fusionar especie.

269
00:12:08,650 --> 00:12:12,950
Así fusionar especie, recordar,
es en última instancia, Theta

270
00:12:12,950 --> 00:12:16,920
de n log n, donde se define theta
si ambos omega y grande O son los mismos.

271
00:12:16,920 --> 00:12:17,580
Tanto n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> ¿Qué es algo que es omega
de N, y O del cuadrado n?

274
00:12:21,970 --> 00:12:23,990
Bueno, de nuevo hay
múltiples respuestas posibles.

275
00:12:23,990 --> 00:12:26,440
Aquí nos toca decir burbuja especie.

276
00:12:26,440 --> 00:12:28,840
Inserción especie también trabajaría aquí.

277
00:12:28,840 --> 00:12:31,400
Recuerde que la burbuja de tipo
tiene que la optimización donde,

278
00:12:31,400 --> 00:12:34,630
si usted es capaz de obtener
a través de toda la lista

279
00:12:34,630 --> 00:12:37,402
sin necesidad de hacer
cualquier swaps, entonces, bueno,

280
00:12:37,402 --> 00:12:40,110
podemos volver inmediatamente que
la lista se solucionó para empezar.

281
00:12:40,110 --> 00:12:43,185
Así que en el mejor de los casos,
es sólo el omega de n.

282
00:12:43,185 --> 00:12:45,960
Si no se trata sólo de un bien
lista para empezar ordenados,

283
00:12:45,960 --> 00:12:48,270
entonces tenemos O de n al cuadrado swaps.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
Y por último, tenemos la selección especie
para n al cuadrado, tanto omega y gran O.

286
00:12:55,610 --> 00:12:56,850
>> Pregunta 21.

287
00:12:56,850 --> 00:12:58,870
¿Qué hay desbordamiento de entero?

288
00:12:58,870 --> 00:13:02,160
Bien de nuevo, similar a la anterior,
sólo tenemos un número finito de bits de

289
00:13:02,160 --> 00:13:04,255
para representar un número entero,
por lo que tal vez 32 bits.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Digamos que tenemos un entero con signo.

292
00:13:09,180 --> 00:13:12,800
A continuación, en última instancia, el más alto
número positivo podemos representar

293
00:13:12,800 --> 00:13:15,910
es 2 a la 31 menos 1.

294
00:13:15,910 --> 00:13:19,370
Entonces, ¿qué sucede si tratamos de
a continuación, incrementar ese entero?

295
00:13:19,370 --> 00:13:25,320
Bueno, vamos a ir de 2 a la 31
menos 1, todo el camino hasta negativo 2

296
00:13:25,320 --> 00:13:26,490
a la 31.

297
00:13:26,490 --> 00:13:29,470
Así que este desbordamiento de enteros es
cuando sigues incrementando,

298
00:13:29,470 --> 00:13:32,330
y en última instancia, no se puede
conseguir más arriba y que sólo

299
00:13:32,330 --> 00:13:34,520
envuelve todo el camino de vuelta
alrededor a un valor negativo.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> ¿Qué pasa con un desbordamiento de búfer?

302
00:13:37,779 --> 00:13:39,820
Así un tampón overflow--
recuerda lo que un buffer es.

303
00:13:39,820 --> 00:13:41,000
Es sólo una parte de la memoria.

304
00:13:41,000 --> 00:13:43,350
Algo así como una matriz es un tampón.

305
00:13:43,350 --> 00:13:46,120
Así que un desbordamiento de búfer es cuando
intenta acceder a memoria

306
00:13:46,120 --> 00:13:47,880
más allá del final de la matriz.

307
00:13:47,880 --> 00:13:50,410
Así que si usted tiene una
matriz de tamaño 5 y usted

308
00:13:50,410 --> 00:13:53,700
tratar de acceder a soporte de matriz
5 o 6 el soporte o el soporte 7,

309
00:13:53,700 --> 00:13:56,610
o cualquier cosa más allá de la
extremo, o incluso nada

310
00:13:56,610 --> 00:14:00,790
soporte de serie aquí a continuación, negativo 1--
todos esos son desbordamientos de búfer.

311
00:14:00,790 --> 00:14:02,810
Estás tocando de memoria en los malos caminos.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Pregunta 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Así que en éste lo que necesita
para implementar strlen.

316
00:14:09,100 --> 00:14:11,630
Y les decimos que se puede
asumen s no será nulo,

317
00:14:11,630 --> 00:14:13,790
por lo que no tiene que
hacer cualquier cheque por nulo.

318
00:14:13,790 --> 00:14:16,190
Y hay varias maneras
que podría haber hecho esto.

319
00:14:16,190 --> 00:14:18,440
Aquí sólo tomamos el sencillo.

320
00:14:18,440 --> 00:14:21,780
Empezamos con un contador, n. n es
contando el número de caracteres que hay.

321
00:14:21,780 --> 00:14:25,560
Así que empezamos a 0, y luego
iterar sobre la lista completa.

322
00:14:25,560 --> 00:14:29,092
>> Es s igual a 0 soporte de la
carácter terminador nulo?

323
00:14:29,092 --> 00:14:31,425
Recuerden que estamos buscando
el carácter terminador nulo

324
00:14:31,425 --> 00:14:33,360
para determinar cuánto tiempo nuestra cadena es.

325
00:14:33,360 --> 00:14:35,890
Eso va a terminar
cualquier cadena correspondiente.

326
00:14:35,890 --> 00:14:39,400
Así que es soporte de s 0 igual
para el terminador nulo?

327
00:14:39,400 --> 00:14:42,850
Si no es así, entonces vamos a
mirar s soporte 1, s 2 soporte.

328
00:14:42,850 --> 00:14:45,050
Seguimos camino hasta que
encontrar el terminador nulo.

329
00:14:45,050 --> 00:14:48,580
Una vez que hemos encontrado, entonces n contiene
la longitud total de la cadena,

330
00:14:48,580 --> 00:14:49,942
y sólo podemos devolver ese.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Pregunta 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Así que este es el uno en el que
tener que hacer la compensación.

335
00:14:56,050 --> 00:14:59,810
Así que una cosa es buena en uno
manera, pero ¿de qué manera es malo?

336
00:14:59,810 --> 00:15:02,980
Así que aquí, fusionar especie tiende a
ser más rápido que la burbuja especie.

337
00:15:02,980 --> 00:15:06,530
Habiendo dicho que-- así, hay
son múltiples respuestas aquí.

338
00:15:06,530 --> 00:15:12,930
Pero la principal es que la burbuja especie
es omega de n para una lista ordenada.

339
00:15:12,930 --> 00:15:14,950
>> Recuerde que la tabla que acabamos de ver antes.

340
00:15:14,950 --> 00:15:17,600
Así burbuja ordena omega de
n, el mejor de los casos

341
00:15:17,600 --> 00:15:20,010
es que es capaz de ir más
la lista una vez, determinar

342
00:15:20,010 --> 00:15:22,270
bueno esto ya es
ordenados, y retorno.

343
00:15:22,270 --> 00:15:25,960
Ordenamiento por mezcla, sin importar lo que
usted lo hace, es el omega de n log n.

344
00:15:25,960 --> 00:15:29,200
Así que para la lista ordenada, burbuja
especie que va a ser más rápido.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Ahora ¿qué pasa vinculada listas?

347
00:15:32,430 --> 00:15:36,070
Así que una lista enlazada puede crecer y encoger
para adaptarse a tantos elementos como sea necesario.

348
00:15:36,070 --> 00:15:38,489
Dicho así que--
por lo general la comparación directa

349
00:15:38,489 --> 00:15:40,280
va a ser un vinculado
una lista con una matriz.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Así que a pesar de que las matrices pueden
aumentar y reducir fácilmente

352
00:15:44,050 --> 00:15:47,130
para adaptarse a tantos elementos
según sea necesario, una lista enlazada

353
00:15:47,130 --> 00:15:49,600
en comparación con un un array--
matriz tiene acceso aleatorio.

354
00:15:49,600 --> 00:15:52,960
Nos puede indexar en cualquier
en particular elemento de la matriz.

355
00:15:52,960 --> 00:15:56,430
>> Así que para una lista enlazada, no podemos
sólo tiene que ir al quinto elemento,

356
00:15:56,430 --> 00:16:00,260
tenemos que recorrer desde el principio
hasta llegar al quinto elemento.

357
00:16:00,260 --> 00:16:03,990
Y eso va a impedirnos
hacer algo como búsqueda binaria.

358
00:16:03,990 --> 00:16:08,150
Hablando de búsqueda binaria, búsqueda binaria
tiende a ser más rápida que la búsqueda lineal.

359
00:16:08,150 --> 00:16:11,120
Habiendo dicho que--
así, una cosa posible

360
00:16:11,120 --> 00:16:13,380
es que no se puede hacer binario
buscar en listas enlazadas,

361
00:16:13,380 --> 00:16:14,730
sólo puede hacerlo en matrices.

362
00:16:14,730 --> 00:16:18,030
Pero, probablemente, lo más importante,
no se puede hacer la búsqueda binaria

363
00:16:18,030 --> 00:16:20,690
en una matriz que no está ordenada.

364
00:16:20,690 --> 00:16:23,990
Upfront puede que tenga que ordenar
la matriz, y sólo entonces puede

365
00:16:23,990 --> 00:16:25,370
que haces de búsqueda binaria.

366
00:16:25,370 --> 00:16:27,660
Así que si lo tuyo no es
ordenada, para empezar,

367
00:16:27,660 --> 00:16:29,250
entonces la búsqueda lineal podría ser más rápido.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Pregunta 27.

370
00:16:31,740 --> 00:16:34,770
Así que considere el programa a continuación,
que estarán en la siguiente diapositiva.

371
00:16:34,770 --> 00:16:37,790
Y esto es en la que estamos
va a querer declarar explícitamente

372
00:16:37,790 --> 00:16:39,980
los valores para distintas variables.

373
00:16:39,980 --> 00:16:41,990
Así que echemos un vistazo a eso.

374
00:16:41,990 --> 00:16:43,160
>> Así que la línea uno.

375
00:16:43,160 --> 00:16:45,457
Tenemos int x es igual a 1.

376
00:16:45,457 --> 00:16:47,040
Esa es la única cosa que ha pasado.

377
00:16:47,040 --> 00:16:50,440
Así que en la línea uno, que vemos en nuestra
mesa, y que, a, b, y tmp son todos

378
00:16:50,440 --> 00:16:51,540
tachado.

379
00:16:51,540 --> 00:16:52,280
Entonces, ¿qué es x?

380
00:16:52,280 --> 00:16:53,860
Bueno apenas fijamos que igual a 1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
Y a continuación, la línea dos, bueno,
vemos que y se establece en 2,

383
00:16:58,770 --> 00:17:00,550
y la tabla ya está
cumplimentado para nosotros.

384
00:17:00,550 --> 00:17:03,040
Así que x es 1 ey es 2.

385
00:17:03,040 --> 00:17:05,890
>> Ahora, la línea de tres, ahora estamos
dentro de la función de intercambio.

386
00:17:05,890 --> 00:17:07,560
¿Qué hicimos pasar a intercambiar?

387
00:17:07,560 --> 00:17:11,609
Pasamos signo x para
una, y símbolo de unión y de b.

388
00:17:11,609 --> 00:17:15,160
Cuando el problema anterior
declaró que la dirección de x

389
00:17:15,160 --> 00:17:17,520
es 0x10, y la dirección de y es 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Así que a y b son iguales a
0x10 y 0x14, respectivamente.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Ahora en línea de tres, ¿cuáles son xey?

394
00:17:26,250 --> 00:17:28,554
Bueno, nada ha cambiado
acerca de x e y en este punto.

395
00:17:28,554 --> 00:17:30,470
A pesar de que son
dentro de un marco principal de pila,

396
00:17:30,470 --> 00:17:32,469
todavía tienen la misma
los valores que tenían antes.

397
00:17:32,469 --> 00:17:34,030
No hemos modificado ninguna memoria.

398
00:17:34,030 --> 00:17:35,710
Así que x es 1, y es 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
Bien.

401
00:17:37,050 --> 00:17:40,300
Así que ahora hemos dicho int tmp igual a protagonizar una.

402
00:17:40,300 --> 00:17:44,410
Así que en la línea de cuatro, todo
es el mismo excepto por tmp.

403
00:17:44,410 --> 00:17:47,130
No hemos cambiado ningún valor
de nada, excepto para tmp.

404
00:17:47,130 --> 00:17:49,230
Estamos estableciendo tmp igual a protagonizar una.

405
00:17:49,230 --> 00:17:50,620
¿Qué es una estrella?

406
00:17:50,620 --> 00:17:56,240
Bueno, unos puntos a X, por lo protagonizan un
va a igualdad de x, que es 1.

407
00:17:56,240 --> 00:18:00,080
Así que todo se copia
abajo, y tmp se establece en 1.

408
00:18:00,080 --> 00:18:01,110
>> Ahora la siguiente línea.

409
00:18:01,110 --> 00:18:03,380
Estrella es igual a una estrella b.

410
00:18:03,380 --> 00:18:10,000
Así por línea five-- bien de nuevo, todo
que es lo mismo, excepto que sea una estrella es.

411
00:18:10,000 --> 00:18:10,830
¿Qué es una estrella?

412
00:18:10,830 --> 00:18:13,720
Bueno, acabamos de decir una estrella es x.

413
00:18:13,720 --> 00:18:16,400
Así que estamos cambiando x a la igualdad de estrellas b.

414
00:18:16,400 --> 00:18:18,960
¿Cuál es la estrella b? y. b puntos a y.

415
00:18:18,960 --> 00:18:21,030
Así estrella b es y.

416
00:18:21,030 --> 00:18:25,140
Así que estamos estableciendo x igual a y,
y todo lo demás es igual.

417
00:18:25,140 --> 00:18:29,130
Así que nos vemos en la siguiente fila que x es ahora
2, y el resto son simplemente copió.

418
00:18:29,130 --> 00:18:31,120
>> Ahora, en la siguiente línea, estrella b es igual a tmp.

419
00:18:31,120 --> 00:18:34,740
Bueno, acabamos de decir estrella b es y,
por lo que estamos estableciendo y igual a tmp.

420
00:18:34,740 --> 00:18:37,450
Todo lo demás es lo mismo,
así que todo se copia abajo.

421
00:18:37,450 --> 00:18:42,050
Estamos estableciendo y igual a TMP, que es
uno, y todo lo demás es igual.

422
00:18:42,050 --> 00:18:43,210
>> Ahora, por fin, la línea siete.

423
00:18:43,210 --> 00:18:44,700
Estamos de vuelta en la función principal.

424
00:18:44,700 --> 00:18:46,350
Estamos después de swap se terminó.

425
00:18:46,350 --> 00:18:48,972
Hemos perdido a, b, y
tmp, pero en última instancia, nos

426
00:18:48,972 --> 00:18:51,180
no se cambia ningún valor
de nada en este momento,

427
00:18:51,180 --> 00:18:52,800
que acabamos de copiar x e y hacia abajo.

428
00:18:52,800 --> 00:18:56,490
Y vemos que x e y son
ahora 2 y 1 en lugar de 1 y 2.

429
00:18:56,490 --> 00:18:58,160
El canje se ha ejecutado con éxito.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Pregunta 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Supongamos que te encuentras
los mensajes de error

434
00:19:03,100 --> 00:19:06,790
a continuación en horario de oficina
el año que viene como una CA o TF.

435
00:19:06,790 --> 00:19:08,930
Asesorar cómo solucionar cada uno de estos errores.

436
00:19:08,930 --> 00:19:11,160
Así referencia indefinida a GetString.

437
00:19:11,160 --> 00:19:12,540
¿Por qué puede usted ver esto?

438
00:19:12,540 --> 00:19:15,380
Bueno, si un estudiante está usando
GetString en su código,

439
00:19:15,380 --> 00:19:20,310
se han incluido correctamente hash CS50
punto h para incluir la biblioteca CS50.

440
00:19:20,310 --> 00:19:22,380
>> Bueno, ¿qué es lo que
que tenga que corregir este error?

441
00:19:22,380 --> 00:19:26,810
Tienen que hacer un guión al lcs50
línea de comandos cuando se está compilando.

442
00:19:26,810 --> 00:19:29,501
Así que si no pasan
lcs50 guión sonido metálico, que son

443
00:19:29,501 --> 00:19:32,000
no va a tener la real
código que implementa GetString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Pregunta 29.

446
00:19:34,170 --> 00:19:36,190
Implícitamente declarar
función de biblioteca strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
Bueno esto ahora, que no tiene
hecho el hash apropiado incluir.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
En este caso particular, el archivo de cabecera
que necesitan para incluir es la cadena de puntos h,

451
00:19:45,410 --> 00:19:48,710
e incluyendo cadena dot h, ahora
la student-- ahora el compilador

452
00:19:48,710 --> 00:19:51,750
tiene acceso a la
declaraciones de strlen,

453
00:19:51,750 --> 00:19:54,120
y se sabe que su código
está usando strlen correctamente.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Pregunta 30.

456
00:19:56,580 --> 00:20:00,240
Más por ciento de las conversiones
que los argumentos de datos.

457
00:20:00,240 --> 00:20:01,540
Entonces, ¿qué es esto?

458
00:20:01,540 --> 00:20:06,470
Bueno recordar que estos ciento
signs-- cómo son relevantes para printf.

459
00:20:06,470 --> 00:20:08,890
Así que en printf podríamos ciento--
podríamos imprimir algo

460
00:20:08,890 --> 00:20:11,380
como ciento i barra invertida n.

461
00:20:11,380 --> 00:20:15,310
O podemos imprimir como ciento i,
espacio, i por ciento, el espacio, i por ciento.

462
00:20:15,310 --> 00:20:18,950
Así que para cada uno de los
signos de porcentaje, que necesitan

463
00:20:18,950 --> 00:20:21,560
pasar una variable al final de printf.

464
00:20:21,560 --> 00:20:26,980
>> Así que si decimos que paren printf ciento
i barra invertida n cerca paren,

465
00:20:26,980 --> 00:20:30,270
así, decimos que estamos
va a imprimir un número entero,

466
00:20:30,270 --> 00:20:33,970
pero entonces no pasamos printf
un entero para imprimir en realidad.

467
00:20:33,970 --> 00:20:37,182
Así que aquí más por ciento
conversiones que los argumentos de datos?

468
00:20:37,182 --> 00:20:39,390
Eso es mucho decir que tenemos
un montón de porcentajes,

469
00:20:39,390 --> 00:20:42,445
y no tenemos suficientes variables
para llenar realmente en esos porcentajes.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> Y entonces, sin duda, para la pregunta 31,
definitivamente perdido 40 bytes en un bloques.

472
00:20:50,010 --> 00:20:52,350
Así que esto es un error de Valgrind.

473
00:20:52,350 --> 00:20:54,720
Esto es decir que
en algún lugar de su código,

474
00:20:54,720 --> 00:20:59,010
usted tiene una asignación que es 40
bytes grande, así que malloced 40 bytes,

475
00:20:59,010 --> 00:21:00,515
y nunca se liberó.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Lo más probable es que usted sólo tiene
encontrar alguna pérdida de memoria,

478
00:21:05,140 --> 00:21:07,650
y encontrar donde usted necesita
liberar este bloque de memoria.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> Y la pregunta 32,
escritura no válida de tamaño 4.

481
00:21:11,910 --> 00:21:13,250
Una vez más se trata de un error de Valgrind.

482
00:21:13,250 --> 00:21:15,440
Esto no tiene que ver
con pérdidas de memoria ahora.

483
00:21:15,440 --> 00:21:20,750
Esto es, más likely-- Quiero decir, es
algún tipo de derechos de memoria no válida.

484
00:21:20,750 --> 00:21:23,270
Y lo más probable es que esto es cierto
tipo de desbordamiento de búfer.

485
00:21:23,270 --> 00:21:26,560
Cuando usted tiene una matriz, tal vez
una matriz de enteros, y vamos a

486
00:21:26,560 --> 00:21:30,115
dicen que es de tamaño 5, y usted
tratar de tocar matriz soporte 5.

487
00:21:30,115 --> 00:21:34,150
Así que si se intenta escribir en esa
valor, eso no es un pedazo de la memoria

488
00:21:34,150 --> 00:21:37,440
que en realidad se tiene acceso a, y
por lo que vamos a conseguir este error,

489
00:21:37,440 --> 00:21:39,272
diciendo escritura no válida de tamaño 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind va a reconocer que eres
tratando de tocar la memoria de forma inapropiada.

491
00:21:42,480 --> 00:21:43,980
>> Y eso es todo por quiz0.

492
00:21:43,980 --> 00:21:47,065
Estoy Rob Bowden, y esto es CS50.

493
00:21:47,065 --> 00:21:51,104