1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Semana 6]

2
00:00:02,000 --> 00:00:04,000
[David J. Malan] [Harvard University]

3
00:00:04,000 --> 00:00:08,000
[Esta es CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Esto es CS50, y este es el comienzo de la Semana 6,

5
00:00:12,000 --> 00:00:16,000
así que un par de nuevas herramientas ya están disponibles para que usted pueda aprovechar,

6
00:00:16,000 --> 00:00:19,000
el primero de los cuales se llama CS50 estilo.

7
00:00:19,000 --> 00:00:22,000
Lo más probable es que si eres como yo o cualquiera de los compañeros docentes,

8
00:00:22,000 --> 00:00:26,000
de lo que has visto un programa cuyo estilo se parece un poco algo como esto.

9
00:00:26,000 --> 00:00:30,000
Tal vez usted comience a cortar algunas esquinas a altas horas de la noche, o va a lidiar con él más tarde,

10
00:00:30,000 --> 00:00:32,000
y luego un TF o CA viene en horario de oficina.

11
00:00:32,000 --> 00:00:34,000
Entonces es difícil para nosotros leer.

12
00:00:34,000 --> 00:00:38,000
Pues bien, este código es sintácticamente correcta, y compilarlo voluntad, y se ejecutará en realidad.

13
00:00:38,000 --> 00:00:40,000
Pero definitivamente no es un 5 por estilo.

14
00:00:40,000 --> 00:00:45,000
>> Pero ahora, si nos adentramos en este directorio here-

15
00:00:45,000 --> 00:00:48,000
y note que tengo conditions2.c-

16
00:00:48,000 --> 00:00:55,000
y me encuentro con este nuevo comando, style50, en esta conditions2.c archivo, Intro,

17
00:00:55,000 --> 00:00:57,000
cuenta de que me ha informado de que ha sido estilizada.

18
00:00:57,000 --> 00:01:00,000
Gedit cuenta de que el archivo ha sido cambiado en el disco,

19
00:01:00,000 --> 00:01:08,000
y si hago clic en recargar, todos sus problemas se han automatizado.

20
00:01:08,000 --> 00:01:15,000
[Aplauso]

21
00:01:15,000 --> 00:01:17,000
Esa es una de las cosas que hicimos este fin de semana.

22
00:01:17,000 --> 00:01:20,000
Reconocemos que es imperfecto, porque hay algo de código

23
00:01:20,000 --> 00:01:23,000
que simplemente no será capaz de estilizar perfectamente,

24
00:01:23,000 --> 00:01:26,000
pero se dan cuenta esto es ahora una herramienta que puede aprovechar

25
00:01:26,000 --> 00:01:33,000
aunque sólo sea para poner en orden algunos de los aparatos más equivocadamente colocado llaves y similares.

26
00:01:33,000 --> 00:01:36,000
>> Pero ahora es más convincente CS50 Check.

27
00:01:36,000 --> 00:01:39,000
Con CS50 cheque, usted puede realizar las pruebas de regularidad mismos

28
00:01:39,000 --> 00:01:42,000
en su propio código que los becarios de enseñanza son capaces de hacerlo.

29
00:01:42,000 --> 00:01:44,000
Esta es una utilidad de línea de comandos que viene ahora en el aparato

30
00:01:44,000 --> 00:01:46,000
tan pronto como lo hace un update50 como por

31
00:01:46,000 --> 00:01:49,000
pset 4 especificaciones, y lo utiliza esencialmente como este.

32
00:01:49,000 --> 00:01:51,000
Ejecuta el comando check50.

33
00:01:51,000 --> 00:01:56,000
Luego se pasa un argumento de línea de comandos, o más generalmente conocido como un interruptor o una bandera.

34
00:01:56,000 --> 00:01:58,000
En general, las cosas que tienen guiones se llama un interruptor

35
00:01:58,000 --> 00:02:02,000
a un programa de línea de comandos, por lo que-c especifica

36
00:02:02,000 --> 00:02:04,000
los cheques que desea ejecutar.

37
00:02:04,000 --> 00:02:07,000
>> Las pruebas que desea ejecutar se identifican individualmente por esta cadena,

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
En otras palabras, eso es sólo una cadena arbitraria pero única

40
00:02:13,000 --> 00:02:18,000
que utilizamos para identificar de forma exclusiva las pruebas 4 pset de corrección.

41
00:02:18,000 --> 00:02:21,000
Y entonces se especifica una lista separada por espacios de los archivos que desea cargar

42
00:02:21,000 --> 00:02:24,000
para CS50 Check para su análisis.

43
00:02:24,000 --> 00:02:29,000
Por ejemplo, si entro en mi solución aquí para resize.c-

44
00:02:29,000 --> 00:02:31,000
permítanme abrir un terminal más grande de ventana

45
00:02:31,000 --> 00:02:42,000
y sigo adelante y ejecutar digamos check50-c 2012/pset4/resize,

46
00:02:42,000 --> 00:02:46,000
y luego seguir adelante y especificar los nombres de los archivos,

47
00:02:46,000 --> 00:02:49,000
resize.c, a continuación, pulse la tecla Enter, se comprime,

48
00:02:49,000 --> 00:02:53,000
que se carga, se comprueba, y me acaba de fallar un montón de pruebas.

49
00:02:53,000 --> 00:02:59,000
El que está en rojo en la parte superior izquierda que dice resize.c y bmp existir.

50
00:02:59,000 --> 00:03:01,000
Esa era la prueba. Esa fue la pregunta que nos hacíamos.

51
00:03:01,000 --> 00:03:04,000
Y es triste porque la respuesta era falsa.

52
00:03:04,000 --> 00:03:08,000
El texto en blanco debajo de ella dice espera bmp.h de existir, y eso es simplemente mi culpa.

53
00:03:08,000 --> 00:03:11,000
Me olvidé de subir, así que tengo que subir ambos archivos,

54
00:03:11,000 --> 00:03:14,000
resize.c y bmp.h.

55
00:03:14,000 --> 00:03:17,000
Pero ahora noten todas las otras pruebas son de color amarillo porque no se han ejecutado,

56
00:03:17,000 --> 00:03:21,000
por lo que la cara sonriente es vertical porque no es ni alegre ni triste,

57
00:03:21,000 --> 00:03:25,000
pero tenemos que corregir ese problema en rojo antes de que esos otros controles se ejecutará.

58
00:03:25,000 --> 00:03:27,000
>> Vamos a arreglar esto.

59
00:03:27,000 --> 00:03:30,000
Permítanme hacer un zoom hacia fuera y volver a ejecutar esta, esta vez con bmp.h también

60
00:03:30,000 --> 00:03:34,000
en la línea de comandos, escriba, y ahora, si todo va bien,

61
00:03:34,000 --> 00:03:38,000
que va a revisar y volver a consecuencia de aguantar la respiración-

62
00:03:38,000 --> 00:03:42,000
todo verde, lo que significa que estoy haciendo realmente bien en pset 4 hasta el momento.

63
00:03:42,000 --> 00:03:44,000
Usted puede ver y deducir del texto descriptivo aquí

64
00:03:44,000 --> 00:03:47,000
exactamente qué es lo que probamos.

65
00:03:47,000 --> 00:03:49,000
Probamos primero qué los archivos existen?

66
00:03:49,000 --> 00:03:51,000
Hemos probado entonces se compila resize.c?

67
00:03:51,000 --> 00:03:58,000
Luego probamos no cambiar su tamaño un BMP de 1x1 píxeles cuando n, el factor de cambio de tamaño, es 1.

68
00:03:58,000 --> 00:04:01,000
Ahora, si usted no tiene idea de lo que n es que una vez que exploramos pset 4,

69
00:04:01,000 --> 00:04:04,000
sino que simplemente es un simple control para asegurarse de que usted no es el cambio de tamaño

70
00:04:04,000 --> 00:04:08,000
una imagen en absoluto si el factor de cambio de tamaño 1.

71
00:04:08,000 --> 00:04:14,000
Si, por el contrario, cambia el tamaño de un píxel de 1x1 para un 1x1 2x2 píxeles a BMP correctamente

72
00:04:14,000 --> 00:04:19,000
cuando n es 2, entonces similarmente, mina de forma consiguiente.

73
00:04:19,000 --> 00:04:22,000
>> En definitiva, se pretende, uno, tomar el cruce los dedos

74
00:04:22,000 --> 00:04:25,000
fuera de la ecuación adecuada para usted antes de presentar su conjunto de procesadores.

75
00:04:25,000 --> 00:04:28,000
Usted sabrá exactamente lo que su TF pronto sabrá

76
00:04:28,000 --> 00:04:30,000
cuando usted va sobre la presentación de algunos de estos conjuntos de problemas,

77
00:04:30,000 --> 00:04:34,000
y también la motivación pedagógica es realmente poner

78
00:04:34,000 --> 00:04:37,000
la oportunidad delante de ti para que cuando se conoce a priori

79
00:04:37,000 --> 00:04:39,000
que no hay errores en el código y pruebas que no se pasan,

80
00:04:39,000 --> 00:04:43,000
usted puede poner en más tiempo efectivo por adelantado para resolver esos problemas

81
00:04:43,000 --> 00:04:45,000
en lugar de perder puntos, obtener retroalimentación de su TF,

82
00:04:45,000 --> 00:04:48,000
y luego, "Ahh," como yo debería haber imaginado.

83
00:04:48,000 --> 00:04:50,000
Ahora por lo menos hay una herramienta para ayudarle a encontrar eso.

84
00:04:50,000 --> 00:04:52,000
No va a señalar que el error es, pero le dirá

85
00:04:52,000 --> 00:04:54,000
lo que es un síntoma de la misma.

86
00:04:54,000 --> 00:04:57,000
>> Ahora se dan cuenta que las pruebas no son necesariamente exhaustivas.

87
00:04:57,000 --> 00:04:59,000
El hecho de que usted recibe una pantalla llena de caras sonrientes verde

88
00:04:59,000 --> 00:05:02,000
no significa que su código es perfecto, pero significa

89
00:05:02,000 --> 00:05:06,000
que ha pasado ciertas pruebas prescritas por la especificación.

90
00:05:06,000 --> 00:05:08,000
A veces no nos dará a conocer los cheques.

91
00:05:08,000 --> 00:05:10,000
Por ejemplo, whodunit, uno de los aspectos del conjunto de procesadores 4,

92
00:05:10,000 --> 00:05:15,000
es un poco decepcionante si le damos

93
00:05:15,000 --> 00:05:18,000
la respuesta en cuanto a lo que es, y hay un número de maneras de revelar

94
00:05:18,000 --> 00:05:21,000
que la persona está en que el ruido rojo.

95
00:05:21,000 --> 00:05:24,000
La especificación siempre se especificarán en el futuro para pset 5 en adelante

96
00:05:24,000 --> 00:05:26,000
qué controles existen para ti.

97
00:05:26,000 --> 00:05:28,000
Se dará cuenta de que hay esta URL blanco en la parte inferior.

98
00:05:28,000 --> 00:05:30,000
Por ahora, esto es sólo la salida de diagnóstico.

99
00:05:30,000 --> 00:05:33,000
Si vas a visitar esa URL, tendrás un montón de mensajes crípticos locos,

100
00:05:33,000 --> 00:05:36,000
que le invitamos a mirar a través, pero es sobre todo para el personal

101
00:05:36,000 --> 00:05:41,000
para que podamos diagnosticar y depurar errores en check50 sí mismo.

102
00:05:41,000 --> 00:05:46,000
>> Sin preámbulos, vamos a pasar a donde lo dejamos.

103
00:05:46,000 --> 00:05:48,000
CS50 biblioteca tomamos por sentado durante algunas semanas,

104
00:05:48,000 --> 00:05:52,000
pero la semana pasada, empezamos quitando una de las capas de la misma.

105
00:05:52,000 --> 00:05:55,000
Empezamos poniendo a un lado cadena en favor de lo que en su lugar?

106
00:05:55,000 --> 00:05:57,000
[Los estudiantes] Char.

107
00:05:57,000 --> 00:05:59,000
* Char, que ha sido un char * todo este tiempo,

108
00:05:59,000 --> 00:06:03,000
pero ahora no tenemos que fingir que es una cadena de datos actual tipo.

109
00:06:03,000 --> 00:06:06,000
Más bien, ha sido un sinónimo de tipo de char *,

110
00:06:06,000 --> 00:06:09,000
y una cadena es una secuencia de caracteres,

111
00:06:09,000 --> 00:06:14,000
¿por qué tiene sentido para representar cadenas como char * s?

112
00:06:14,000 --> 00:06:20,000
¿Qué hace un char * representan en el contexto de este concepto de una cadena?

113
00:06:20,000 --> 00:06:23,000
Si. >> [Estudiante] El primer carácter.

114
00:06:23,000 --> 00:06:25,000
Bueno, el primer carácter, pero no es el primer carácter.

115
00:06:25,000 --> 00:06:27,000
Son los-[Los estudiantes] Dirección.

116
00:06:27,000 --> 00:06:29,000
Bien, la dirección del primer carácter.

117
00:06:29,000 --> 00:06:33,000
Todo lo que es necesario para representar una cadena en la memoria de una computadora

118
00:06:33,000 --> 00:06:36,000
es sólo la dirección única de su byte muy primero.

119
00:06:36,000 --> 00:06:38,000
Usted ni siquiera tiene que saber cuánto tiempo es

120
00:06:38,000 --> 00:06:42,000
porque ¿cómo puede usted darse cuenta de eso dinámicamente?

121
00:06:42,000 --> 00:06:44,000
[Estudiante] longitud de cadena.

122
00:06:44,000 --> 00:06:48,000
Usted puede llamar longitud de la cadena, excelente, pero ¿cómo funciona la cadena de longitud?

123
00:06:48,000 --> 00:06:50,000
¿Qué hacer? Si.

124
00:06:50,000 --> 00:06:52,000
[Estudiante] Sigue adelante hasta que llegue el carácter nulo.

125
00:06:52,000 --> 00:06:54,000
Sí, exacto, simplemente itera con un bucle for, while,

126
00:06:54,000 --> 00:06:57,000
lo de * hasta el final, y el final está representado

127
00:06:57,000 --> 00:07:01,000
por \ 0, el carácter nul llamada, nul,

128
00:07:01,000 --> 00:07:05,000
que no debe confundirse con un valor nulo, que es un puntero,

129
00:07:05,000 --> 00:07:07,000
que entrará en la conversación de nuevo hoy.

130
00:07:07,000 --> 00:07:11,000
>> Nos desprendió una capa de getInt, y luego echó un vistazo a GetString,

131
00:07:11,000 --> 00:07:14,000
y recordar que esas dos funciones, o en realidad,

132
00:07:14,000 --> 00:07:18,000
GetString, utilizaba una determinada función

133
00:07:18,000 --> 00:07:21,000
para analizar en realidad, es decir, leer y analizar, la entrada del usuario.

134
00:07:21,000 --> 00:07:25,000
¿Y cuál era esa nueva función?

135
00:07:25,000 --> 00:07:27,000
Scanf o sscanf. En realidad, viene en sabores diferentes.

136
00:07:27,000 --> 00:07:31,000
Hay scanf, hay sscanf, hay fscanf.

137
00:07:31,000 --> 00:07:35,000
Por ahora, sin embargo, vamos a centrarnos en la más fácilmente ilustrado,

138
00:07:35,000 --> 00:07:38,000
y déjame seguir adelante y abrir el aparato

139
00:07:38,000 --> 00:07:41,000
un archivo de este tipo, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
Este es un programa super simple,

141
00:07:43,000 --> 00:07:46,000
sino que hace algo que nunca hemos hecho

142
00:07:46,000 --> 00:07:48,000
sin la ayuda de la biblioteca CS50.

143
00:07:48,000 --> 00:07:51,000
Esto consigue un int de un usuario. ¿Cómo funciona?

144
00:07:51,000 --> 00:07:53,000
Pues bien, en la línea 16 allí,

145
00:07:53,000 --> 00:07:56,000
cuenta de que declaramos una x int llamado, y en este momento de la historia,

146
00:07:56,000 --> 00:07:58,000
¿cuál es el valor de x?

147
00:07:58,000 --> 00:08:00,000
[Respuesta de los estudiantes inaudible]

148
00:08:00,000 --> 00:08:02,000
[David M.] Claro, quién sabe, algún valor potencialmente basura, por lo que en el 17, que acabamos de indicar al usuario

149
00:08:02,000 --> 00:08:06,000
dame un número, por favor, y el paso 18 es donde se pone interesante.

150
00:08:06,000 --> 00:08:11,000
Scanf parece pedir prestada una idea de printf en que utiliza estos códigos de formato entre comillas.

151
00:08:11,000 --> 00:08:13,000
D% es por supuesto un número decimal.

152
00:08:13,000 --> 00:08:21,000
Pero ¿por qué estoy pasando & x en lugar de x sólo?

153
00:08:21,000 --> 00:08:24,000
El primero es la correcta. Si.

154
00:08:24,000 --> 00:08:26,000
[Respuesta de los estudiantes inaudible]

155
00:08:26,000 --> 00:08:31,000
Exactamente, si el objetivo de este programa, al igual que el getInt función en sí misma,

156
00:08:31,000 --> 00:08:34,000
es conseguir un int por parte del usuario que puede pasar funciones

157
00:08:34,000 --> 00:08:38,000
todas las variables que quiero, pero si no pasarlos por referencia

158
00:08:38,000 --> 00:08:41,000
o por dirección o puntero, todos sinónimos para los propósitos actuales,

159
00:08:41,000 --> 00:08:46,000
luego de que la función no tiene la capacidad de cambiar el contenido de esa variable.

160
00:08:46,000 --> 00:08:49,000
Esto pasaría en una copia al igual que la versión con errores de swap

161
00:08:49,000 --> 00:08:51,000
que ya hemos hablado un par de veces ahora.

162
00:08:51,000 --> 00:08:54,000
>> Pero en cambio, al hacer & x, estoy literalmente pasando en qué?

163
00:08:54,000 --> 00:08:57,000
[Estudiante] La dirección. >> La dirección de x.

164
00:08:57,000 --> 00:09:01,000
Es como dibujar un mapa para la función llamada scanf y diciendo aquí,

165
00:09:01,000 --> 00:09:04,000
estas son indicaciones de cómo un trozo de memoria en el ordenador

166
00:09:04,000 --> 00:09:07,000
que se puede ir almacenar algún entero pulg

167
00:09:07,000 --> 00:09:10,000
Para sscanf hacer ahora que

168
00:09:10,000 --> 00:09:13,000
qué operador, qué pedazo de sintaxis se va a tener que usar

169
00:09:13,000 --> 00:09:19,000
aunque no podemos verlo porque alguien escribió esta función?

170
00:09:19,000 --> 00:09:21,000
En otras palabras - ¿qué es eso?

171
00:09:21,000 --> 00:09:23,000
[Estudiante] X leer.

172
00:09:23,000 --> 00:09:27,000
Va a ser un poco de lectura, pero sólo con respecto a x aquí.

173
00:09:27,000 --> 00:09:30,000
Si scanf se está pasando la dirección de x,

174
00:09:30,000 --> 00:09:35,000
sintácticamente, qué operador está obligado a existir en alguna parte

175
00:09:35,000 --> 00:09:38,000
dentro de la aplicación, de manera que scanf scanf

176
00:09:38,000 --> 00:09:42,000
en realidad se puede escribir un número de 2 a esa dirección?

177
00:09:42,000 --> 00:09:44,000
Sí, así que el archivo *.

178
00:09:44,000 --> 00:09:47,000
Recordemos que el * es nuestro operador para deshacer referencias, que esencialmente significa ir allí.

179
00:09:47,000 --> 00:09:50,000
>> Una vez que haya sido entregada una dirección, como es el caso aquí,

180
00:09:50,000 --> 00:09:53,000
scanf es, probablemente-si en realidad se veía alrededor de su código fuente-

181
00:09:53,000 --> 00:09:59,000
hace * x o el equivalente de ir realmente a esa dirección y poner algo de valor allí.

182
00:09:59,000 --> 00:10:02,000
Ahora, en cuanto a cómo scanf tiene entrada desde el teclado,

183
00:10:02,000 --> 00:10:04,000
vamos a agitar nuestras manos para hoy.

184
00:10:04,000 --> 00:10:07,000
Simplemente asume que el sistema operativo permite hablar sscanf

185
00:10:07,000 --> 00:10:11,000
para el teclado del usuario, pero en este punto ahora en línea 19,

186
00:10:11,000 --> 00:10:14,000
cuando simplemente imprimir x, que parece ser el caso

187
00:10:14,000 --> 00:10:17,000
scanf que ha puesto en int x.

188
00:10:17,000 --> 00:10:19,000
Así es exactamente como funciona scanf, y recordar la semana pasada

189
00:10:19,000 --> 00:10:25,000
así es exactamente como GetString y getInt y su otra familia de funciones

190
00:10:25,000 --> 00:10:28,000
en última instancia, funciona, aunque con una ligera variación como sscanf,

191
00:10:28,000 --> 00:10:31,000
lo que significa escanear una cadena en lugar del teclado.

192
00:10:31,000 --> 00:10:33,000
Pero echemos un vistazo a una variación poco de esto.

193
00:10:33,000 --> 00:10:37,000
En scanf2, realmente jodido.

194
00:10:37,000 --> 00:10:42,000
Lo que está mal, y yo voy a ocultar el comentario que explica tanto-

195
00:10:42,000 --> 00:10:47,000
lo que está mal con este programa, la versión 2?

196
00:10:47,000 --> 00:10:55,000
Sea lo más técnica posible este momento.

197
00:10:55,000 --> 00:10:57,000
Se ve bastante bien.

198
00:10:57,000 --> 00:11:03,000
Está muy bien marcada, pero-

199
00:11:03,000 --> 00:11:07,000
bien, ¿qué vamos a podar hasta más cortas preguntas?

200
00:11:07,000 --> 00:11:17,000
Línea 16. ¿Cuál es la línea 16 hace en Inglés precisa pero técnica?

201
00:11:17,000 --> 00:11:20,000
Conseguir un poco incómodo. Sí, Michael.

202
00:11:20,000 --> 00:11:25,000
[Estudiante] Se señala a la primera letra de una cadena.

203
00:11:25,000 --> 00:11:27,000
>> Bueno, cerca. Permítanme que ajustar un poco.

204
00:11:27,000 --> 00:11:33,000
Refiriéndose a la primera letra de una cadena, se declara una variable llamada búfer

205
00:11:33,000 --> 00:11:36,000
que apunte a la dirección primera de una cadena,

206
00:11:36,000 --> 00:11:39,000
o más bien, que se señalan más específicamente a un char.

207
00:11:39,000 --> 00:11:42,000
Tenga en cuenta que no es en realidad apunta a ninguna parte porque no hay ningún operador de asignación.

208
00:11:42,000 --> 00:11:46,000
No hay ningún signo de igual, así que todo lo que estamos haciendo es asignar el búfer llamado variable.

209
00:11:46,000 --> 00:11:49,000
Le pasa a ser de 32 bits, ya que es un puntero,

210
00:11:49,000 --> 00:11:52,000
y el contenido del buffer presumiblemente eventualmente

211
00:11:52,000 --> 00:11:57,000
contendrá la dirección de un char, pero por ahora, lo que contiene buffer?

212
00:11:57,000 --> 00:11:59,000
Sólo un poco falso, quién sabe, un poco de basura valor,

213
00:11:59,000 --> 00:12:03,000
porque no se ha inicializado explícitamente, por lo que no se debe asumir nada.

214
00:12:03,000 --> 00:12:06,000
Bien, ahora la línea 17 es-¿qué significa hacer la línea 17?

215
00:12:06,000 --> 00:12:08,000
Tal vez eso se calentará esto.

216
00:12:08,000 --> 00:12:10,000
Se imprime una cadena, ¿no?

217
00:12:10,000 --> 00:12:12,000
Imprime cadena por favor.

218
00:12:12,000 --> 00:12:15,000
>> La línea 18 es una especie de familiar ahora en que acabamos de ver una variación de esta

219
00:12:15,000 --> 00:12:18,000
pero con un código de formato diferente, por lo que en la línea 18,

220
00:12:18,000 --> 00:12:23,000
le estamos diciendo aquí scanf es la dirección de un trozo de memoria.

221
00:12:23,000 --> 00:12:27,000
Quiero que suene en una cadena, como se deduce de% s,

222
00:12:27,000 --> 00:12:32,000
pero el problema es que no hemos hecho un par de cosas aquí.

223
00:12:32,000 --> 00:12:35,000
¿Cuál es uno de los problemas?

224
00:12:35,000 --> 00:12:38,000
[Estudiante] Está tratando de eliminar la referencia a un puntero nulo.

225
00:12:38,000 --> 00:12:41,000
Bueno, punteros nulos o simplemente desconoce lo contrario.

226
00:12:41,000 --> 00:12:45,000
Estás entregando scanf una dirección, pero que acaba de decir hace un momento

227
00:12:45,000 --> 00:12:49,000
que esa dirección es un valor basura porque en realidad no nos asignarla a nada,

228
00:12:49,000 --> 00:12:53,000
y por lo que estamos diciendo scanf disponible nos puso una cuerda aquí,

229
00:12:53,000 --> 00:12:56,000
pero no sabemos dónde está aquí todavía,

230
00:12:56,000 --> 00:12:59,000
por lo que no se han asignado para la memoria buffer.

231
00:12:59,000 --> 00:13:03,000
Por otra parte, lo que tampoco son aún contando scanf?

232
00:13:03,000 --> 00:13:06,000
Supongamos que se trataba de un trozo de memoria, y no era un valor basura,

233
00:13:06,000 --> 00:13:09,000
pero todavía no estás diciendo scanf algo importante.

234
00:13:09,000 --> 00:13:12,000
[Estudiante] Cuando en realidad, el símbolo de unión.

235
00:13:12,000 --> 00:13:15,000
Ampersand, por lo que en este caso, está bien.

236
00:13:15,000 --> 00:13:18,000
Debido a tope ya se ha declarado como un apuntador

237
00:13:18,000 --> 00:13:22,000
con la pieza * de sintaxis, no es necesario utilizar ampersand

238
00:13:22,000 --> 00:13:25,000
porque ya es una dirección, pero creo que lo escucharon aquí.

239
00:13:25,000 --> 00:13:27,000
[Estudiante] ¿Cómo es de grande?

240
00:13:27,000 --> 00:13:29,000
Bueno, no estamos diciendo scanf lo grande que es este tampón,

241
00:13:29,000 --> 00:13:32,000
lo que significa que incluso si tampón eran un puntero,

242
00:13:32,000 --> 00:13:35,000
estamos diciendo scanf, poner una cadena aquí,

243
00:13:35,000 --> 00:13:38,000
pero aquí podría ser 2 bytes, que puede ser de 10 bytes, que podría ser un megabyte.

244
00:13:38,000 --> 00:13:41,000
Scanf tiene ni idea, y porque se trata de un trozo de memoria

245
00:13:41,000 --> 00:13:43,000
presumiblemente, no es una cadena aún.

246
00:13:43,000 --> 00:13:48,000
No es más que una cadena una vez que escribir caracteres y un 0 \ a que buena parte de la memoria.

247
00:13:48,000 --> 00:13:51,000
Ahora es sólo un poco de buena parte de la memoria.

248
00:13:51,000 --> 00:13:55,000
Scanf no se sabe cuando dejar de escribir a esa dirección.

249
00:13:55,000 --> 00:13:59,000
>> Si usted recuerda algunos ejemplos en el pasado en el que se escriben al azar en el teclado

250
00:13:59,000 --> 00:14:03,000
tratando de desbordar un buffer, y hablamos el viernes sobre exactamente eso.

251
00:14:03,000 --> 00:14:07,000
Si un adversario de alguna manera inyecta en su programa una palabra mucho más grande

252
00:14:07,000 --> 00:14:10,000
u oración o frase luego que esperabas puede invadir

253
00:14:10,000 --> 00:14:13,000
un trozo de memoria, que puede tener consecuencias negativas,

254
00:14:13,000 --> 00:14:15,000
como hacerse cargo de todo el programa en sí.

255
00:14:15,000 --> 00:14:17,000
Tenemos que arreglar esto de alguna manera.

256
00:14:17,000 --> 00:14:20,000
Permítanme hacer un zoom hacia fuera y entrar en la versión 3 de este programa.

257
00:14:20,000 --> 00:14:22,000
Eso es un poco mejor.

258
00:14:22,000 --> 00:14:24,000
En esta versión, notará la diferencia.

259
00:14:24,000 --> 00:14:27,000
En la línea 16, estoy otra vez que se declara una variable llamada búfer,

260
00:14:27,000 --> 00:14:29,000
pero ¿qué pasa ahora?

261
00:14:29,000 --> 00:14:33,000
Es un conjunto de 16 caracteres.

262
00:14:33,000 --> 00:14:36,000
Esto es bueno porque significa que ahora puedo decir scanf

263
00:14:36,000 --> 00:14:39,000
aquí es un pedazo real de memoria.

264
00:14:39,000 --> 00:14:42,000
Casi se puede pensar en arrays como punteros ahora,

265
00:14:42,000 --> 00:14:44,000
a pesar de que no son realmente equivalentes.

266
00:14:44,000 --> 00:14:47,000
Ellos se comportan de manera diferente en diferentes contextos.

267
00:14:47,000 --> 00:14:50,000
Pero es cierto que búfer hace referencia

268
00:14:50,000 --> 00:14:53,000
16 caracteres contiguos porque eso es lo que una matriz es

269
00:14:53,000 --> 00:14:55,000
y ha sido durante algunas semanas.

270
00:14:55,000 --> 00:14:59,000
>> He aquí, yo estoy diciendo scanf aquí hay un trozo de memoria.

271
00:14:59,000 --> 00:15:01,000
Esta vez, es en realidad una parte de la memoria,

272
00:15:01,000 --> 00:15:07,000
pero ¿por qué es este programa todavía explotable?

273
00:15:07,000 --> 00:15:11,000
¿Qué hay de malo todavía?

274
00:15:11,000 --> 00:15:14,000
Lo he dicho dame 16 bytes pero-

275
00:15:14,000 --> 00:15:16,000
[Estudiante] ¿Y si se escribe en más de 16?

276
00:15:16,000 --> 00:15:20,000
Exactamente, ¿qué pasa si el usuario escribe en 17 caracteres o caracteres 1700?

277
00:15:20,000 --> 00:15:23,000
De hecho, vamos a ver si no se tropiece con este error ahora.

278
00:15:23,000 --> 00:15:25,000
Es mejor, pero no es perfecto.

279
00:15:25,000 --> 00:15:28,000
Déjenme seguir adelante y hacer funcionar scanf3 para compilar este programa.

280
00:15:28,000 --> 00:15:34,000
Déjame correr scanf3, String por favor: hola, y parece que estamos bien.

281
00:15:34,000 --> 00:15:37,000
Voy a tratar uno ligeramente más largo, hola.

282
00:15:37,000 --> 00:15:42,000
Bueno, vamos a hacerlo hola ¿cómo estás hoy, Enter.

283
00:15:42,000 --> 00:15:54,000
Conseguir tipo de suerte aquí, vamos a decir hola cómo estás.

284
00:15:54,000 --> 00:15:56,000
Maldita sea.

285
00:15:56,000 --> 00:16:03,000
Muy bien, así que tuvimos suerte. Vamos a ver si podemos arreglar esto.

286
00:16:03,000 --> 00:16:06,000
No, no va a dejar que me copia.

287
00:16:06,000 --> 00:16:09,000
Vamos a intentarlo de nuevo.

288
00:16:09,000 --> 00:16:12,000
De acuerdo, espera.

289
00:16:12,000 --> 00:16:20,000
Vamos a ver cuánto tiempo puede pretender concentrar sin dejar de hacer esto.

290
00:16:20,000 --> 00:16:23,000
Maldita sea. Eso es bastante apropiado, en realidad.

291
00:16:23,000 --> 00:16:26,000
Ahí vamos.

292
00:16:26,000 --> 00:16:30,000
Punto de hecho.

293
00:16:30,000 --> 00:16:34,000
>> Esto, embarazoso aunque también es, también es una de las fuentes de gran confusión

294
00:16:34,000 --> 00:16:38,000
al escribir programas que tienen errores, ya que se manifiestan

295
00:16:38,000 --> 00:16:40,000
sólo de vez en cuando a veces.

296
00:16:40,000 --> 00:16:43,000
La realidad es que incluso si el código está completamente roto,

297
00:16:43,000 --> 00:16:46,000
sólo podría ser completamente roto de vez en cuando

298
00:16:46,000 --> 00:16:49,000
porque a veces, lo que pasa es esencialmente el sistema operativo asigna

299
00:16:49,000 --> 00:16:52,000
un poco más de memoria de lo que realmente necesita por cualquier razón,

300
00:16:52,000 --> 00:16:57,000
y para que nadie más está usando la memoria inmediatamente después de su trozo de 16 caracteres,

301
00:16:57,000 --> 00:17:01,000
así que si vas a 17, 18, 19, lo que sea, no es una gran cosa.

302
00:17:01,000 --> 00:17:04,000
Ahora, el equipo, incluso si no choque en ese punto,

303
00:17:04,000 --> 00:17:09,000
eventualmente podría utilizar el byte número 17 o 18 o 19 años para otra cosa,

304
00:17:09,000 --> 00:17:14,000
momento en el que los datos que usted puso en su lugar, aunque sea excesivamente largo,

305
00:17:14,000 --> 00:17:18,000
va a ser sobrescrito potencialmente por alguna otra función.

306
00:17:18,000 --> 00:17:21,000
No necesariamente va a permanecer intacta,

307
00:17:21,000 --> 00:17:23,000
pero no necesariamente causará un fallo seg.

308
00:17:23,000 --> 00:17:26,000
Pero en este caso, finalmente me proporcionó suficientes caracteres

309
00:17:26,000 --> 00:17:29,000
que esencialmente superado mi segmento de la memoria, y bam,

310
00:17:29,000 --> 00:17:33,000
el sistema operativo, dijo: "Lo siento, eso no es culpa bueno, segmentación".

311
00:17:33,000 --> 00:17:38,000
>> Y ahora vamos a ver si lo que queda aquí en mi directorio

312
00:17:38,000 --> 00:17:40,000
cuenta de que tengo este archivo aquí, el núcleo.

313
00:17:40,000 --> 00:17:42,000
Tenga en cuenta que esto se volvió a pedir un volcado de memoria.

314
00:17:42,000 --> 00:17:46,000
Básicamente se trata de un archivo que contiene el contenido de la memoria del programa

315
00:17:46,000 --> 00:17:48,000
en el punto en el que se estrelló,

316
00:17:48,000 --> 00:17:51,000
y sólo para probar un pequeño ejemplo aquí déjame entrar aquí

317
00:17:51,000 --> 00:17:57,000
y ejecutar gdb en scanf3 y especifique un tercer argumento llamado núcleo,

318
00:17:57,000 --> 00:18:01,000
y notar aquí que si la lista de códigos,

319
00:18:01,000 --> 00:18:06,000
vamos a ser capaces, como de costumbre con gdb para empezar a caminar a través de este programa,

320
00:18:06,000 --> 00:18:10,000
y puedo correr y tan pronto como me golpeó, como paso con el comando en gdb-

321
00:18:10,000 --> 00:18:13,000
tan pronto como llegué a la línea potencialmente con errores después de escribir en una cadena enorme,

322
00:18:13,000 --> 00:18:16,000
Voy a ser capaz de identificar realmente aquí.

323
00:18:16,000 --> 00:18:19,000
Más sobre esto, sin embargo, en la sección en términos de volcados de memoria

324
00:18:19,000 --> 00:18:22,000
y similar, de manera que en realidad se puede hurgar en el interior del volcado de memoria

325
00:18:22,000 --> 00:18:27,000
y ver en qué línea del programa que falló.

326
00:18:27,000 --> 00:18:32,000
Cualquier pregunta entonces sobre indicadores y sobre las direcciones?

327
00:18:32,000 --> 00:18:36,000
Porque hoy en adelante, vamos a empezar a dar por sentado que estas cosas existen

328
00:18:36,000 --> 00:18:40,000
y sabemos exactamente lo que son.

329
00:18:40,000 --> 00:18:42,000
Sí.

330
00:18:42,000 --> 00:18:46,000
>> [Estudiante] ¿Cómo es que usted no tiene que poner un signo al lado de la parte-

331
00:18:46,000 --> 00:18:48,000
Buena pregunta.

332
00:18:48,000 --> 00:18:51,000
¿Cómo llego no tenía que poner un signo al lado de la matriz de caracteres como lo hice anteriormente

333
00:18:51,000 --> 00:18:53,000
con la mayoría de nuestros ejemplos?

334
00:18:53,000 --> 00:18:55,000
La respuesta corta es arrays son un poco especial.

335
00:18:55,000 --> 00:18:59,000
Casi se puede pensar como un amortiguador en realidad ser una dirección,

336
00:18:59,000 --> 00:19:03,000
y da la casualidad de ser el caso que la notación de corchetes

337
00:19:03,000 --> 00:19:06,000
es una conveniencia para que podamos entrar en soporte 0, soporte 1,

338
00:19:06,000 --> 00:19:10,000
soporte 2, sin tener que utilizar la notación *.

339
00:19:10,000 --> 00:19:13,000
Eso es un poco de una mentira piadosa porque arrays y punteros

340
00:19:13,000 --> 00:19:17,000
son, de hecho, un poco diferente, pero pueden a menudo, pero no siempre se usan de forma intercambiable.

341
00:19:17,000 --> 00:19:21,000
En resumen, cuando una función espera un puntero a un bloque de memoria,

342
00:19:21,000 --> 00:19:24,000
usted puede pasar una dirección que fue devuelto por malloc,

343
00:19:24,000 --> 00:19:29,000
y vamos a ver malloc nuevo antes de tiempo, o puede pasar el nombre de una matriz.

344
00:19:29,000 --> 00:19:32,000
Usted no tiene que hacer arreglos con ampersand porque ya están

345
00:19:32,000 --> 00:19:34,000
esencialmente como direcciones.

346
00:19:34,000 --> 00:19:36,000
Esa es la única excepción.

347
00:19:36,000 --> 00:19:39,000
Los corchetes hacen especiales.

348
00:19:39,000 --> 00:19:41,000
>> ¿Podría poner un signo al lado del buffer?

349
00:19:41,000 --> 00:19:43,000
No en este caso.

350
00:19:43,000 --> 00:19:46,000
Eso no funcionaría porque, de nuevo, este caso de esquina

351
00:19:46,000 --> 00:19:49,000
donde las matrices no son realmente muy direcciones.

352
00:19:49,000 --> 00:19:54,000
Pero tal vez volveremos a que en poco tiempo con otros ejemplos.

353
00:19:54,000 --> 00:19:56,000
Vamos a tratar de resolver un problema.

354
00:19:56,000 --> 00:20:00,000
Tenemos una estructura de datos que hemos estado utilizando desde hace algún tiempo se conoce como una matriz.

355
00:20:00,000 --> 00:20:02,000
El caso en cuestión, eso es lo que acabamos de tener.

356
00:20:02,000 --> 00:20:04,000
Pero matrices tienen algunos upsides y desventajas.

357
00:20:04,000 --> 00:20:06,000
Las matrices son agradables por qué?

358
00:20:06,000 --> 00:20:11,000
¿Qué es una cosa que se quiere-en la medida en que te gusta matrices-acerca de las matrices?

359
00:20:11,000 --> 00:20:13,000
¿Qué es conveniente acerca de ellos? ¿Qué es convincente?

360
00:20:13,000 --> 00:20:18,000
¿Por qué los introducimos en el primer lugar?

361
00:20:18,000 --> 00:20:20,000
Si.

362
00:20:20,000 --> 00:20:27,000
[Estudiante] Se puede almacenar una gran cantidad de datos, y usted no tiene que usar una cosa entera.

363
00:20:27,000 --> 00:20:29,000
Puede utilizar una sección.

364
00:20:29,000 --> 00:20:32,000
Bueno, con un arsenal que puede almacenar una gran cantidad de datos,

365
00:20:32,000 --> 00:20:35,000
y no necesariamente tiene que utilizar todo eso, así que usted puede overallocate,

366
00:20:35,000 --> 00:20:39,000
que podría ser conveniente si usted no sabe de antemano cuántos de algo que esperar.

367
00:20:39,000 --> 00:20:41,000
>> GetString es un ejemplo perfecto.

368
00:20:41,000 --> 00:20:44,000
GetString, escrito por nosotros, no tiene idea de cómo chars que cabe esperar,

369
00:20:44,000 --> 00:20:48,000
por lo que el hecho de que se puede asignar trozos de memoria contigua es bueno.

370
00:20:48,000 --> 00:20:51,000
Las matrices también resolver un problema que vimos un par de semanas ahora

371
00:20:51,000 --> 00:20:54,000
donde el código empieza a delegar en algo muy mal diseñado.

372
00:20:54,000 --> 00:20:57,000
Recordemos que he creado una estructura estudiante llamado David,

373
00:20:57,000 --> 00:21:00,000
y entonces que era en realidad una alternativa, sin embargo,

374
00:21:00,000 --> 00:21:04,000
a tener un nombre de variable llamada y otra variable llamada, creo, casa,

375
00:21:04,000 --> 00:21:08,000
y otra variable llamada identificación porque en esa historia que entonces quería introducir algo más

376
00:21:08,000 --> 00:21:11,000
Al igual que Rob en el programa, por lo que luego decidí esperar un minuto,

377
00:21:11,000 --> 00:21:13,000
Tengo que cambiar el nombre de estas variables.

378
00:21:13,000 --> 00:21:16,000
Vamos a llamar a la mía nombre1, ID1, house1.

379
00:21:16,000 --> 00:21:20,000
Vamos a llamar a Rob nombre2, casa2, ID2.

380
00:21:20,000 --> 00:21:22,000
Pero espera un momento, ¿qué pasa con Tommy?

381
00:21:22,000 --> 00:21:24,000
Luego tuvimos tres variables más.

382
00:21:24,000 --> 00:21:27,000
Hemos introducido algún otro, cuatro conjuntos de variables.

383
00:21:27,000 --> 00:21:30,000
El mundo comenzó a causar problemas muy rápidamente,

384
00:21:30,000 --> 00:21:33,000
por lo que introdujo las estructuras, y lo que es atractivo en una estructura?

385
00:21:33,000 --> 00:21:39,000
¿Qué hace un struct C permiten hacer?

386
00:21:39,000 --> 00:21:42,000
Es muy difícil hoy en día.

387
00:21:42,000 --> 00:21:44,000
¿Qué? >> [Respuesta de los estudiantes inaudible]

388
00:21:44,000 --> 00:21:47,000
Sí, en concreto, typedef permite crear un nuevo tipo de datos,

389
00:21:47,000 --> 00:21:51,000
y estructura, la palabra clave struct, le permite encapsular

390
00:21:51,000 --> 00:21:54,000
piezas relacionadas conceptualmente de datos, junto

391
00:21:54,000 --> 00:21:56,000
y después de eso los llaman algo así como un estudiante.

392
00:21:56,000 --> 00:21:58,000
>> Eso fue bueno, porque ahora podemos modelar

393
00:21:58,000 --> 00:22:03,000
especie mucho más conceptualmente coherente la noción de un estudiante en una variable

394
00:22:03,000 --> 00:22:07,000
en lugar de tener una forma arbitraria para una cadena, una para un ID, y así sucesivamente.

395
00:22:07,000 --> 00:22:10,000
Las matrices son agradables porque nos permite comenzar a limpiar nuestro código.

396
00:22:10,000 --> 00:22:13,000
Pero lo que es un inconveniente ahora de una matriz?

397
00:22:13,000 --> 00:22:15,000
Lo que no puede hacer? Si.

398
00:22:15,000 --> 00:22:17,000
[Estudiante] Usted tiene que saber lo grande que es.

399
00:22:17,000 --> 00:22:19,000
Usted tiene que saber lo grande que es, así que es un tipo de dolor.

400
00:22:19,000 --> 00:22:21,000
Aquellos de ustedes que tienen experiencia previa en programación saben que en una gran cantidad de idiomas,

401
00:22:21,000 --> 00:22:24,000
como Java, usted puede pedir un trozo de memoria, en concreto una matriz,

402
00:22:24,000 --> 00:22:28,000
lo grande que eres, con una longitud, posición económica, por así decirlo, y eso es muy conveniente.

403
00:22:28,000 --> 00:22:32,000
En C, ni siquiera se puede llamar strlen en una matriz genérica

404
00:22:32,000 --> 00:22:35,000
porque strlen, como la palabra lo indica, es sólo para cuerdas,

405
00:22:35,000 --> 00:22:39,000
y se puede calcular la longitud de una cadena a causa de esta convención humana

406
00:22:39,000 --> 00:22:43,000
de tener un 0 \, sino una matriz, más genéricamente, es sólo una parte de la memoria.

407
00:22:43,000 --> 00:22:46,000
Si se trata de una matriz de enteros, no va a ser algo de carácter especial

408
00:22:46,000 --> 00:22:48,000
al final te espera.

409
00:22:48,000 --> 00:22:50,000
Hay que recordar la longitud de una matriz.

410
00:22:50,000 --> 00:22:54,000
Otro aspecto negativo de una matriz levantado la cabeza en GetString sí mismo.

411
00:22:54,000 --> 00:22:59,000
¿Cuál es otra desventaja de una matriz?

412
00:22:59,000 --> 00:23:01,000
Señor, sólo tú y yo hoy.

413
00:23:01,000 --> 00:23:04,000
[Respuesta de los estudiantes inaudible] >> ¿Es qué?

414
00:23:04,000 --> 00:23:06,000
Ha declarado en la pila.

415
00:23:06,000 --> 00:23:09,000
De acuerdo, declaró en la pila. ¿Por qué no te gusta?

416
00:23:09,000 --> 00:23:13,000
[Estudiante] Debido a que se reutilizan.

417
00:23:13,000 --> 00:23:15,000
Se reutilizan.

418
00:23:15,000 --> 00:23:18,000
Bueno, si se utiliza una matriz para asignar memoria,

419
00:23:18,000 --> 00:23:21,000
no se puede, por ejemplo, volver porque está en la pila.

420
00:23:21,000 --> 00:23:23,000
Bueno, eso es una desventaja.

421
00:23:23,000 --> 00:23:25,000
¿Y otra con una matriz?

422
00:23:25,000 --> 00:23:28,000
Una vez que lo asigne, eres un poco jodido si necesita más espacio

423
00:23:28,000 --> 00:23:30,000
que la matriz tiene.

424
00:23:30,000 --> 00:23:34,000
>> A continuación presentamos, recordar, malloc, que nos dio la capacidad de asignar dinámicamente la memoria.

425
00:23:34,000 --> 00:23:37,000
Pero ¿y si intentamos un mundo totalmente diferente?

426
00:23:37,000 --> 00:23:40,000
¿Qué pasa si queremos resolver un par de esos problemas

427
00:23:40,000 --> 00:23:45,000
así que en vez, mi pluma se ha dormido aquí-

428
00:23:45,000 --> 00:23:51,000
¿Y si en vez quería crear esencialmente un mundo que ya no es así?

429
00:23:51,000 --> 00:23:56,000
Esta es una matriz, y, por supuesto, este tipo de se deteriora una vez que se pulsa el final de la matriz,

430
00:23:56,000 --> 00:24:00,000
y ahora ya no tiene espacio para otro número entero u otro carácter.

431
00:24:00,000 --> 00:24:03,000
¿Qué pasaría si una especie de forma preventiva decir así, ¿por qué no relajarse

432
00:24:03,000 --> 00:24:07,000
Este requisito de que todos estos pedazos de memoria sean contiguos espalda con espalda,

433
00:24:07,000 --> 00:24:10,000
y por qué no, cuando necesito un int o char a,

434
00:24:10,000 --> 00:24:12,000
me acaba de dar espacio para una de ellas?

435
00:24:12,000 --> 00:24:14,000
Y cuando necesito otro, dame otro espacio,

436
00:24:14,000 --> 00:24:16,000
y cuando necesito otro, dame otro espacio.

437
00:24:16,000 --> 00:24:19,000
La ventaja de que ahora es que si alguien más

438
00:24:19,000 --> 00:24:21,000
toma la memoria por aquí, nada del otro mundo.

439
00:24:21,000 --> 00:24:25,000
Me quedo con este trozo adicional de memoria aquí y después de éste.

440
00:24:25,000 --> 00:24:28,000
>> Ahora, el único problema aquí es que este casi se siente como si tuviera

441
00:24:28,000 --> 00:24:30,000
un montón de diferentes variables.

442
00:24:30,000 --> 00:24:33,000
Esto se siente como cinco diferentes variables potencialmente.

443
00:24:33,000 --> 00:24:36,000
Pero ¿y si nos roban una idea de las cadenas

444
00:24:36,000 --> 00:24:41,000
de alguna manera en que podamos vincular estas cosas conceptualmente, y lo que si me hizo esto?

445
00:24:41,000 --> 00:24:44,000
Este es mi flecha muy mal dibujado.

446
00:24:44,000 --> 00:24:46,000
Pero supongamos que cada uno de estos trozos de la memoria

447
00:24:46,000 --> 00:24:52,000
señaló a la otra, y este chico, que no tiene hermanos, a su derecha,

448
00:24:52,000 --> 00:24:54,000
no tiene ninguna flecha tales.

449
00:24:54,000 --> 00:24:56,000
Esto es de hecho lo que se llama una lista enlazada.

450
00:24:56,000 --> 00:25:00,000
Esta es una nueva estructura de datos que nos permite asignar un bloque de memoria,

451
00:25:00,000 --> 00:25:03,000
luego otro, luego otro, luego otro, cada vez que queramos

452
00:25:03,000 --> 00:25:07,000
durante un programa, y ​​recordamos que todos están de alguna manera relacionados con

453
00:25:07,000 --> 00:25:11,000
literalmente encadenar juntos, y lo hicimos aquí gráficamente con una flecha.

454
00:25:11,000 --> 00:25:15,000
Pero en el código, ¿cuál sería el mecanismo a través del cual usted puede conectar de alguna manera,

455
00:25:15,000 --> 00:25:20,000
casi como Scratch, un fragmento a otro pedazo?

456
00:25:20,000 --> 00:25:22,000
Podríamos utilizar un puntero, ¿verdad?

457
00:25:22,000 --> 00:25:25,000
Porque, en realidad la flecha que va desde la plaza superior izquierda,

458
00:25:25,000 --> 00:25:31,000
este tipo aquí a esta, podría contener dentro de este cuadrado

459
00:25:31,000 --> 00:25:34,000
no sólo algunos enteros, no sólo algunos char, pero lo que si realmente asignados

460
00:25:34,000 --> 00:25:37,000
un poco más de espacio para que ahora,

461
00:25:37,000 --> 00:25:41,000
cada uno de mis pedazos de la memoria, a pesar de que esto va a costar,

462
00:25:41,000 --> 00:25:45,000
ahora se ve un poco más rectangular donde uno de los trozos de memoria

463
00:25:45,000 --> 00:25:47,000
se utiliza para un número, como el número 1,

464
00:25:47,000 --> 00:25:50,000
y luego, si este chico almacena el número 2,

465
00:25:50,000 --> 00:25:52,000
este fragmento otro de memoria se utiliza para una flecha,

466
00:25:52,000 --> 00:25:54,000
o más concretamente, un puntero.

467
00:25:54,000 --> 00:25:59,000
Y supongo que guardar el número 3 por aquí mientras yo uso esto para apuntar a ese tipo,

468
00:25:59,000 --> 00:26:02,000
y ahora este tipo, vamos a suponer que sólo quiere tres pedazos tales de la memoria.

469
00:26:02,000 --> 00:26:05,000
Voy a dibujar una línea a través de eso, lo que indica nulo.

470
00:26:05,000 --> 00:26:07,000
No hay un carácter adicional.

471
00:26:07,000 --> 00:26:10,000
>> De hecho, así es como podemos ir sobre la aplicación

472
00:26:10,000 --> 00:26:12,000
algo que se llama una lista enlazada.

473
00:26:12,000 --> 00:26:18,000
Una lista enlazada es una estructura de datos nueva, y es un paso adelante hacia

474
00:26:18,000 --> 00:26:21,000
mucho más elegantes estructuras de datos que comienzan a resolver problemas

475
00:26:21,000 --> 00:26:23,000
a lo largo de las líneas de los problemas de tipo Facebook y Google problemas de tipo

476
00:26:23,000 --> 00:26:26,000
donde hay enormes conjuntos de datos, y ya no se corta

477
00:26:26,000 --> 00:26:29,000
para almacenar todo contigua y usar algo como búsqueda lineal

478
00:26:29,000 --> 00:26:31,000
o incluso algo como búsqueda binaria.

479
00:26:31,000 --> 00:26:33,000
¿Quieres aún mejores tiempos de carrera.

480
00:26:33,000 --> 00:26:37,000
De hecho, uno de los santos griales hablaremos más adelante esta semana o la próxima

481
00:26:37,000 --> 00:26:41,000
es un algoritmo cuyo tiempo de ejecución es constante.

482
00:26:41,000 --> 00:26:44,000
En otras palabras, siempre se toma la misma cantidad de tiempo, sin importar

483
00:26:44,000 --> 00:26:47,000
lo grande que es la entrada, y que de hecho sería convincente,

484
00:26:47,000 --> 00:26:49,000
incluso más que algo logarítmica.

485
00:26:49,000 --> 00:26:51,000
¿Qué es esto en la pantalla aquí?

486
00:26:51,000 --> 00:26:55,000
Cada uno de los rectángulos es exactamente lo que acaba de dibujar a mano.

487
00:26:55,000 --> 00:26:59,000
Pero lo que todo el camino de la izquierda es una variable especial.

488
00:26:59,000 --> 00:27:02,000
Va a ser un único puntero porque el gotcha una

489
00:27:02,000 --> 00:27:04,000
con una lista enlazada, como se llaman estas cosas,

490
00:27:04,000 --> 00:27:09,000
es que usted tiene que colgar en un extremo de la lista enlazada.

491
00:27:09,000 --> 00:27:13,000
>> Al igual que con una cadena, usted tiene que saber la dirección del primer carácter.

492
00:27:13,000 --> 00:27:15,000
Mismo trato para las listas enlazadas.

493
00:27:15,000 --> 00:27:19,000
Usted tiene que saber la dirección del primer fragmento de memoria

494
00:27:19,000 --> 00:27:25,000
porque a partir de allí, se puede llegar a cualquier otro.

495
00:27:25,000 --> 00:27:27,000
Lo malo.

496
00:27:27,000 --> 00:27:30,000
¿Qué precio estamos pagando por esta versatilidad de tener una dinámica

497
00:27:30,000 --> 00:27:34,000
estructura de datos importante que si alguna vez necesita más memoria, está bien,

498
00:27:34,000 --> 00:27:37,000
sólo asignar un pedazo más y dibujar un puntero de

499
00:27:37,000 --> 00:27:39,000
la vieja a la nueva cola de la lista?

500
00:27:39,000 --> 00:27:41,000
Si.

501
00:27:41,000 --> 00:27:43,000
[Estudiante] Se necesita espacio de aproximadamente dos veces más.

502
00:27:43,000 --> 00:27:45,000
Se necesita espacio doble, así que eso es definitivamente una desventaja, ya que hemos visto este

503
00:27:45,000 --> 00:27:48,000
equilibrio entre antes de tiempo y espacio y flexibilidad

504
00:27:48,000 --> 00:27:51,000
donde por ahora, no necesitamos 32 bits para cada uno de estos números.

505
00:27:51,000 --> 00:27:57,000
Realmente necesitamos 64, 32 para el número y 32 para el puntero.

506
00:27:57,000 --> 00:27:59,000
Pero bueno, tengo 2 GB de RAM.

507
00:27:59,000 --> 00:28:02,000
Un aumento de 32 bits aquí y aquí no parece tan grande de un acuerdo.

508
00:28:02,000 --> 00:28:05,000
Sin embargo, para los conjuntos de datos de gran tamaño, que sin duda se suma a, literalmente, el doble.

509
00:28:05,000 --> 00:28:09,000
¿Cuál es otra desventaja ahora, o qué función le damos para arriba,

510
00:28:09,000 --> 00:28:12,000
si representamos listas de cosas con una lista enlazada y no una matriz?

511
00:28:12,000 --> 00:28:14,000
[Estudiante] No se puede recorrer hacia atrás.

512
00:28:14,000 --> 00:28:16,000
No se puede recorrer hacia atrás, así que eres un poco jodidos si tu te vas

513
00:28:16,000 --> 00:28:19,000
de izquierda a derecha utilizando un bucle o un bucle while

514
00:28:19,000 --> 00:28:21,000
y entonces te das cuenta, "Oh, yo quiero ir de nuevo al principio de la lista."

515
00:28:21,000 --> 00:28:26,000
No es posible porque estos punteros sólo van de izquierda a derecha, como indican las flechas.

516
00:28:26,000 --> 00:28:29,000
>> Ahora, usted puede recordar el principio de la lista con otra variable,

517
00:28:29,000 --> 00:28:31,000
pero eso es una complejidad a tener en cuenta.

518
00:28:31,000 --> 00:28:35,000
Una matriz, no importa lo lejos que vaya, siempre puede hacer menos, menos, menos, menos

519
00:28:35,000 --> 00:28:37,000
y vuelve de donde viniste.

520
00:28:37,000 --> 00:28:40,000
¿Cuál es otra desventaja aquí? Si.

521
00:28:40,000 --> 00:28:43,000
[Pregunta estudiante inaudible]

522
00:28:43,000 --> 00:28:47,000
Podría, por lo que ha hecho que acaba de proponer una estructura de datos llamada lista doblemente enlazada,

523
00:28:47,000 --> 00:28:50,000
y, de hecho, debería agregar otro puntero a cada uno de estos rectángulos

524
00:28:50,000 --> 00:28:53,000
que va la otra dirección, la ventaja de que

525
00:28:53,000 --> 00:28:55,000
Ahora se puede recorrer de ida y vuelta,

526
00:28:55,000 --> 00:28:59,000
la desventaja de que ahora se está utilizando tres veces más memoria que usamos para

527
00:28:59,000 --> 00:29:04,000
y también añadir complejidad en términos del código que tiene que escribir para hacerlo bien.

528
00:29:04,000 --> 00:29:08,000
Pero todos estos son quizás las compensaciones razonables, si la inversión es más importante.

529
00:29:08,000 --> 00:29:10,000
Si.

530
00:29:10,000 --> 00:29:12,000
[Estudiante] Tampoco se puede tener una lista enlazada 2D.

531
00:29:12,000 --> 00:29:16,000
Bueno, realmente no se puede tener una lista 2D vinculado.

532
00:29:16,000 --> 00:29:18,000
Podrías. No es tan fácil como una matriz.

533
00:29:18,000 --> 00:29:21,000
Al igual que una matriz, hacer corchete abierto, soporte cerrado, soporte abierto, cerrado soporte,

534
00:29:21,000 --> 00:29:23,000
y se obtiene una estructura de 2 dimensiones.

535
00:29:23,000 --> 00:29:26,000
Se podría implementar una lista de 2 dimensiones vinculadas

536
00:29:26,000 --> 00:29:29,000
Si lo hace, como usted propone-un tercer indicador para cada una de estas cosas,

537
00:29:29,000 --> 00:29:34,000
y si piensas en otra lista que le llega estilo 3D

538
00:29:34,000 --> 00:29:40,000
de la pantalla para todos nosotros, que es otra cadena de algún tipo.

539
00:29:40,000 --> 00:29:45,000
Podríamos hacerlo, pero no es tan simple como escribir apertura de corchetes, corchetes. Si.

540
00:29:45,000 --> 00:29:48,000
[Pregunta estudiante inaudible]

541
00:29:48,000 --> 00:29:50,000
Bien, así que esto es un truco real.

542
00:29:50,000 --> 00:29:54,000
>> Estos algoritmos que hemos suspirado otra vez, como oh, búsqueda binaria,

543
00:29:54,000 --> 00:29:57,000
usted puede buscar en una matriz de números en el tablero

544
00:29:57,000 --> 00:30:01,000
o una libreta de teléfonos mucho más rápidamente si utiliza divide y vencerás

545
00:30:01,000 --> 00:30:05,000
y un algoritmo de búsqueda binaria, pero la búsqueda binario requiere dos supuestos.

546
00:30:05,000 --> 00:30:09,000
Uno de ellos, que los datos fueron ordenados.

547
00:30:09,000 --> 00:30:11,000
Ahora, probablemente pueda mantener esta resuelto,

548
00:30:11,000 --> 00:30:14,000
así que tal vez eso no es una preocupación, pero también supone la búsqueda binaria

549
00:30:14,000 --> 00:30:18,000
que tenía acceso aleatorio a la lista de números,

550
00:30:18,000 --> 00:30:21,000
y una gran variedad le permite tener acceso al azar, y por el acceso aleatorio,

551
00:30:21,000 --> 00:30:24,000
Quiero decir que si te dan una serie, ¿cuánto tiempo le toma

552
00:30:24,000 --> 00:30:26,000
para llegar al soporte de 0?

553
00:30:26,000 --> 00:30:29,000
Una operación, usted sólo tiene que utilizar [0] y ya está ahí.

554
00:30:29,000 --> 00:30:33,000
¿Cuántos pasos se necesitan para llegar a la ubicación 10?

555
00:30:33,000 --> 00:30:36,000
Un paso, usted sólo tiene que ir a [10] y que estás ahí.

556
00:30:36,000 --> 00:30:40,000
Por el contrario, ¿cómo se consigue que el entero 10 en una lista enlazada?

557
00:30:40,000 --> 00:30:42,000
Hay que empezar por el principio, ya que sólo está recordando

558
00:30:42,000 --> 00:30:45,000
el comienzo de una lista enlazada, al igual que una cadena se recuerda

559
00:30:45,000 --> 00:30:48,000
por la dirección de su primer carácter, y al ver que int 10a

560
00:30:48,000 --> 00:30:53,000
o que el carácter 10 º en una cadena, usted tiene que buscar toda la maldita cosa.

561
00:30:53,000 --> 00:30:55,000
>> Una vez más, no vamos a resolver todos nuestros problemas.

562
00:30:55,000 --> 00:31:00,000
Estamos introduciendo otros nuevos, pero realmente depende de lo que estés tratando de diseñar para.

563
00:31:00,000 --> 00:31:04,000
En cuanto a la aplicación de la presente, se puede pedir prestada una idea de que la estructura de los estudiantes.

564
00:31:04,000 --> 00:31:07,000
La sintaxis es muy similar, excepto que ahora, la idea es un poco más abstracto

565
00:31:07,000 --> 00:31:09,000
que la casa y el nombre y DNI.

566
00:31:09,000 --> 00:31:13,000
Pero yo propongo que podría tener una estructura de datos en C

567
00:31:13,000 --> 00:31:17,000
que se llama nodo, como la última palabra en la diapositiva indica,

568
00:31:17,000 --> 00:31:21,000
dentro de un nodo, y un nodo es un contenedor genérico en ciencias de la computación.

569
00:31:21,000 --> 00:31:25,000
Por lo general se dibuja como un círculo o un cuadrado o un rectángulo como lo hemos hecho.

570
00:31:25,000 --> 00:31:27,000
Y en esta estructura de datos, tenemos un entero, n,

571
00:31:27,000 --> 00:31:29,000
por lo que es el número que desea almacenar.

572
00:31:29,000 --> 00:31:36,000
Pero ¿qué es esta segunda línea, struct nodo * siguiente?

573
00:31:36,000 --> 00:31:40,000
¿Por qué es correcto o qué papel desempeña esa cosa,

574
00:31:40,000 --> 00:31:42,000
aunque es un poco críptico, a primera vista?

575
00:31:42,000 --> 00:31:44,000
Si.

576
00:31:44,000 --> 00:31:46,000
[Respuesta de los estudiantes inaudible]

577
00:31:46,000 --> 00:31:50,000
Exactamente, por lo que el tipo de botín * que es un puntero de algún tipo.

578
00:31:50,000 --> 00:31:53,000
El nombre de este puntero es arbitrariamente próximo,

579
00:31:53,000 --> 00:32:00,000
pero nos podría haber llamado cualquier cosa que queramos, pero ¿qué tiene esto puntero a punto?

580
00:32:00,000 --> 00:32:03,000
[Estudiante] Otro nodo. >> Exactamente, apunta a otro nodo tal.

581
00:32:03,000 --> 00:32:05,000
>> Ahora, esto es una especie de curiosidad de C.

582
00:32:05,000 --> 00:32:09,000
Recordemos que C es leído por un compilador arriba a abajo, de izquierda a derecha,

583
00:32:09,000 --> 00:32:13,000
lo que significa que si, esto es un poco diferente de lo que hemos hecho con el estudiante.

584
00:32:13,000 --> 00:32:16,000
Cuando definimos un estudiante, que en realidad no puso una palabra allí.

585
00:32:16,000 --> 00:32:18,000
Simplemente dijo typedef.

586
00:32:18,000 --> 00:32:20,000
Luego tuvimos id int nombre, cadena, cadena de casa,

587
00:32:20,000 --> 00:32:23,000
y luego estudiante en la parte inferior de la estructura.

588
00:32:23,000 --> 00:32:26,000
Esta declaración es un poco diferente, ya que,

589
00:32:26,000 --> 00:32:28,000
de nuevo, el compilador de C es un poco tonto.

590
00:32:28,000 --> 00:32:30,000
Es sólo va a leer de arriba a abajo,

591
00:32:30,000 --> 00:32:33,000
así que si llega a la 2 ª línea aquí

592
00:32:33,000 --> 00:32:37,000
donde se declara próximo y lo ve, oh, aquí está una variable llamada siguiente.

593
00:32:37,000 --> 00:32:39,000
Es un puntero a un nodo de estructura.

594
00:32:39,000 --> 00:32:42,000
El compilador se va a dar cuenta lo que es un nodo de estructura?

595
00:32:42,000 --> 00:32:44,000
Nunca he oído hablar de esto antes,

596
00:32:44,000 --> 00:32:47,000
porque el nodo de palabra de otro modo no podría aparecer

597
00:32:47,000 --> 00:32:49,000
hasta la parte inferior, por lo que es esta redundancia.

598
00:32:49,000 --> 00:32:53,000
Tienes que decir struct nodo aquí, que luego se puede acortar más tarde

599
00:32:53,000 --> 00:32:56,000
gracias a typedef aquí abajo, pero es porque

600
00:32:56,000 --> 00:33:02,000
estamos haciendo referencia a la estructura en sí misma en el interior de la estructura.

601
00:33:02,000 --> 00:33:05,000
Ese es el gotcha nadie allí.

602
00:33:05,000 --> 00:33:07,000
>> Algunos problemas interesantes van a surgir.

603
00:33:07,000 --> 00:33:09,000
Tenemos una lista de números. ¿Cómo insertar en ella?

604
00:33:09,000 --> 00:33:11,000
¿Cómo podemos buscarla? ¿Cómo borrar de ella?

605
00:33:11,000 --> 00:33:13,000
Sobre todo ahora que tenemos que manejar todos estos consejos.

606
00:33:13,000 --> 00:33:15,000
Usted pensó que eran punteros especie de alucinante

607
00:33:15,000 --> 00:33:17,000
cuando tenía uno de ellos tratando de leer un int a ella.

608
00:33:17,000 --> 00:33:20,000
Ahora tenemos que manipular la pena una lista entera.

609
00:33:20,000 --> 00:33:22,000
¿Por qué no nos tomamos nuestro hijo de 5 minutos de descanso aquí, y luego voy a traer

610
00:33:22,000 --> 00:33:34,000
algunas personas al escenario para hacer exactamente eso.

611
00:33:34,000 --> 00:33:36,000
>> C es mucho más divertido cuando es representada.

612
00:33:36,000 --> 00:33:39,000
Que literalmente quiere ser el primero?

613
00:33:39,000 --> 00:33:41,000
Muy bien, vamos arriba. Usted está en primer lugar.

614
00:33:41,000 --> 00:33:44,000
¿Quién quiere ser 9? Bueno, 9.

615
00:33:44,000 --> 00:33:46,000
¿Qué hay de 9? 17?

616
00:33:46,000 --> 00:33:51,000
Una camarilla poco aquí. 22 y 26 en la fila delantera.

617
00:33:51,000 --> 00:33:53,000
Y entonces ¿qué hay alguien por ahí que se la mira.

618
00:33:53,000 --> 00:33:57,000
Usted es 34. Bueno, de 34 años, vamos arriba.

619
00:33:57,000 --> 00:33:59,000
En primer lugar está allá. Bueno, los cuatro de ustedes.

620
00:33:59,000 --> 00:34:01,000
¿Y quién le decimos a 9?

621
00:34:01,000 --> 00:34:04,000
¿Quién es nuestro 9?

622
00:34:04,000 --> 00:34:07,000
¿Quién realmente quiere ser 9? Muy bien, vamos, a las 9.

623
00:34:07,000 --> 00:34:10,000
Aquí vamos.

624
00:34:10,000 --> 00:34:13,000
34, nos encontraremos allí.

625
00:34:13,000 --> 00:34:17,000
La primera parte es haceros ver así.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, bueno.

627
00:34:21,000 --> 00:34:25,000
Si puedes soportar a un lado, porque nos vamos a malloc en un momento.

628
00:34:25,000 --> 00:34:29,000
>> Bueno, bueno.

629
00:34:29,000 --> 00:34:32,000
Está bien, excelente, así que vamos a hacerle un par de preguntas.

630
00:34:32,000 --> 00:34:34,000
Y en realidad, ¿cuál es tu nombre? >> Anita.

631
00:34:34,000 --> 00:34:37,000
Anita, está bien, ven aquí.

632
00:34:37,000 --> 00:34:41,000
Anita va a ayudarnos a resolver un tipo de pregunta bastante simple en principio,

633
00:34:41,000 --> 00:34:44,000
que es ¿cómo encontrar si un valor está en la lista?

634
00:34:44,000 --> 00:34:48,000
Ahora, noten que la primera, representada aquí por Lucas,

635
00:34:48,000 --> 00:34:52,000
es un poco diferente, por lo que su papel es deliberadamente de lado

636
00:34:52,000 --> 00:34:55,000
porque no es tan alto y no ocupa tantos bits,

637
00:34:55,000 --> 00:34:58,000
a pesar de que técnicamente tiene el mismo tamaño de papel que acaba de girar.

638
00:34:58,000 --> 00:35:01,000
Pero es un poco diferente, ya que tiene sólo 32 bits para un puntero,

639
00:35:01,000 --> 00:35:05,000
y todos estos chicos son de 64 bits, la mitad de los cuales es el número, la mitad de los cuales es un puntero.

640
00:35:05,000 --> 00:35:08,000
Sin embargo, el puntero no se representa, por lo tanto si ustedes podrían torpemente

641
00:35:08,000 --> 00:35:12,000
use la mano izquierda para apuntar a la persona a tu lado.

642
00:35:12,000 --> 00:35:14,000
Y tú eres el número 34. ¿Cuál es tu nombre?

643
00:35:14,000 --> 00:35:16,000
Ari.

644
00:35:16,000 --> 00:35:19,000
Ari, por lo que en realidad, mantenga el papel en la mano derecha y la mano izquierda va hacia abajo.

645
00:35:19,000 --> 00:35:21,000
Usted declara nula la izquierda.

646
00:35:21,000 --> 00:35:24,000
>> Ahora nuestra imagen humana es muy consistente.

647
00:35:24,000 --> 00:35:26,000
Esto es realmente cómo funcionan los punteros.

648
00:35:26,000 --> 00:35:29,000
Y si se puede arrugar un poco esta manera así que no estoy en tu camino.

649
00:35:29,000 --> 00:35:34,000
Anita aquí, me encontrará el número 22,

650
00:35:34,000 --> 00:35:40,000
pero suponen una restricción de los seres humanos no soporta hojas de papel,

651
00:35:40,000 --> 00:35:43,000
pero esta es una lista, y sólo tiene Lucas para empezar

652
00:35:43,000 --> 00:35:46,000
porque es, literalmente, el primer indicador.

653
00:35:46,000 --> 00:35:51,000
Supongamos que usted mismo es un puntero, y por lo que también tienen la capacidad de apuntar a algo.

654
00:35:51,000 --> 00:35:56,000
¿Por qué no empezar por señalar exactamente lo que Lucas está señalando?

655
00:35:56,000 --> 00:35:58,000
Bueno, y déjame promulgar esto por aquí.

656
00:35:58,000 --> 00:36:04,000
Sólo por el bien de la discusión, deja que tire hacia arriba una página en blanco aquí.

657
00:36:04,000 --> 00:36:06,000
¿Cómo se escribe tu nombre? >> Anita.

658
00:36:06,000 --> 00:36:08,000
Bueno, Anita.

659
00:36:08,000 --> 00:36:18,000
Digamos nodo * anita = lucas.

660
00:36:18,000 --> 00:36:22,000
Bueno, no os llama lucas. Deberíamos llamar a usted primero.

661
00:36:22,000 --> 00:36:25,000
¿Por qué es de hecho compatible con la realidad aquí?

662
00:36:25,000 --> 00:36:27,000
Uno, en primer lugar ya existe.

663
00:36:27,000 --> 00:36:30,000
En primer lugar se ha asignado presumiblemente en algún lugar por aquí.

664
00:36:30,000 --> 00:36:35,000
Nodo * primero, y se ha asignado una lista de alguna manera.

665
00:36:35,000 --> 00:36:37,000
No sé cómo sucedió. Eso ocurrió antes de que empezara la clase.

666
00:36:37,000 --> 00:36:40,000
Esta lista vinculada de los seres humanos ha sido creada.

667
00:36:40,000 --> 00:36:44,000
Y ahora, en este momento de la historia, todo esto sucede en Facebook, aparentemente después-

668
00:36:44,000 --> 00:36:49,000
en este punto de la historia, Anita se ha inicializado a ser igual al primero,

669
00:36:49,000 --> 00:36:51,000
lo que no significa que los puntos de Anita en Lucas.

670
00:36:51,000 --> 00:36:53,000
Más bien, apunta a lo que apunta a

671
00:36:53,000 --> 00:36:57,000
porque la misma dirección que está dentro de los 32 bits - Lucas 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
es ahora también en el interior de Anita 32 bits - 1, 2, 3.

673
00:37:01,000 --> 00:37:05,000
>> Encuentre ahora 22. ¿Cómo haría usted para hacer esto?

674
00:37:05,000 --> 00:37:07,000
¿Qué es ese punto? >> Para lo que sea.

675
00:37:07,000 --> 00:37:11,000
Señale lo que sea, así que adelante y representarlo lo mejor que puedes aquí.

676
00:37:11,000 --> 00:37:15,000
Bien, bien, y ahora usted está señalando, ¿cuál es tu nombre con 22?

677
00:37:15,000 --> 00:37:18,000
Ramon. >> Ramón, por lo que Ramón es la celebración de 22.

678
00:37:18,000 --> 00:37:20,000
Ahora ha hecho un cheque.

679
00:37:20,000 --> 00:37:24,000
¿Tiene Ramon == 22, y si es así, por ejemplo, se puede volver realidad.

680
00:37:24,000 --> 00:37:26,000
Permítanme, mientras estos chicos están aquí algo torpemente-

681
00:37:26,000 --> 00:37:32,000
déjame hacer algo rápidamente como bool encontrar.

682
00:37:32,000 --> 00:37:37,000
Voy a seguir adelante y decir (lista de nodos *, int n).

683
00:37:37,000 --> 00:37:39,000
Estaré de vuelta con ustedes. Sólo tengo que escribir algo de código.

684
00:37:39,000 --> 00:37:45,000
Y ahora voy a seguir adelante y hacer esto, el nodo * anita list =.

685
00:37:45,000 --> 00:37:51,000
Y voy a seguir adelante y decir while (anita! = NULL).

686
00:37:51,000 --> 00:37:57,000
>> La metáfora aquí es conseguir un poco estirado, pero al mismo tiempo (anita! = NULL), ¿qué es lo que quiero hacer?

687
00:37:57,000 --> 00:38:03,000
Necesito alguna manera de hacer referencia a

688
00:38:03,000 --> 00:38:05,000
el entero que Anita está señalando.

689
00:38:05,000 --> 00:38:08,000
En el pasado, cuando tuvimos estructuras, que es un nodo,

690
00:38:08,000 --> 00:38:11,000
hemos utilizado la notación de puntos, y nos diría algo así como

691
00:38:11,000 --> 00:38:15,000
anita.n, pero el problema aquí es que Anita no es una estructura en sí.

692
00:38:15,000 --> 00:38:17,000
¿Qué es?

693
00:38:17,000 --> 00:38:21,000
Ella es un puntero, así que realmente, si queremos usar esta notación punto-

694
00:38:21,000 --> 00:38:23,000
y esto va a parecer un poco críptico deliberadamente-

695
00:38:23,000 --> 00:38:28,000
tenemos que hacer algo como ir a mano izquierda lo que Anita está apuntando a

696
00:38:28,000 --> 00:38:31,000
y luego el campo llamado n.

697
00:38:31,000 --> 00:38:35,000
Anita es un puntero, pero lo que es * anita?

698
00:38:35,000 --> 00:38:38,000
¿Qué encuentras cuando vas a lo que Anita está señalando?

699
00:38:38,000 --> 00:38:42,000
Una estructura, un nodo, y una retirada nodo,, tiene un campo llamado n

700
00:38:42,000 --> 00:38:47,000
porque ha, recuerdan, estos dos campos, próximos y N,

701
00:38:47,000 --> 00:38:50,000
que vimos hace un momento aquí.

702
00:38:50,000 --> 00:38:53,000
>> Para imitar este hecho en el código,

703
00:38:53,000 --> 00:39:02,000
podríamos hacer esto y decir if ((* anita). == n n), la n que yo estoy buscando.

704
00:39:02,000 --> 00:39:04,000
Observe que la función se aprobó en el número que me importa.

705
00:39:04,000 --> 00:39:10,000
Entonces puedo seguir adelante y hacer algo como verdadero retorno.

706
00:39:10,000 --> 00:39:12,000
Si no, si ese no es el caso, ¿qué es lo que quiero hacer?

707
00:39:12,000 --> 00:39:19,000
¿Cómo traduzco para codificar lo que Anita hizo intuitivamente a pie a través de la lista?

708
00:39:19,000 --> 00:39:26,000
¿Qué debo hacer aquí para simular Anita dar ese paso a la izquierda, ese paso hacia la izquierda?

709
00:39:26,000 --> 00:39:28,000
[Respuesta de los estudiantes inaudible] >> ¿Qué es eso?

710
00:39:28,000 --> 00:39:30,000
[Respuesta de los estudiantes inaudible]

711
00:39:30,000 --> 00:39:34,000
Bueno, no es una mala idea, pero en el pasado, cuando hayamos hecho esto, hemos hecho anita + +

712
00:39:34,000 --> 00:39:37,000
porque eso aumentaría el número 1 a Anita,

713
00:39:37,000 --> 00:39:40,000
que normalmente apuntar a la siguiente persona, al igual que Ramón,

714
00:39:40,000 --> 00:39:44,000
o la persona a su lado, o la persona a su lado de la línea.

715
00:39:44,000 --> 00:39:49,000
Pero eso no es muy bueno, porque lo que aquí está esta cosa parece en la memoria?

716
00:39:49,000 --> 00:39:54,000
No es eso. Tenemos que desactivar eso.

717
00:39:54,000 --> 00:40:00,000
Parece que este en la memoria, y aunque he dibujado 1 y 2 y 3 cerca uno del otro,

718
00:40:00,000 --> 00:40:03,000
si realmente simular que esta-can chicos, sin dejar de apuntar a la misma gente,

719
00:40:03,000 --> 00:40:07,000
Puede que algunos de ustedes dar un paso atrás al azar, algunos de ustedes un paso adelante al azar?

720
00:40:07,000 --> 00:40:10,000
>> Este desorden es todavía una lista enlazada,

721
00:40:10,000 --> 00:40:13,000
pero estos chicos pueden estar en cualquier lugar en la memoria,

722
00:40:13,000 --> 00:40:15,000
así anita + + no va a funcionar eso?

723
00:40:15,000 --> 00:40:19,000
Lo que está en posición anita + +?

724
00:40:19,000 --> 00:40:21,000
Quién sabe.

725
00:40:21,000 --> 00:40:24,000
Es otro valor que el que pasa es que se interpone

726
00:40:24,000 --> 00:40:28,000
entre todos estos nodos de azar porque no estamos usando una matriz.

727
00:40:28,000 --> 00:40:30,000
Hemos asignado cada uno de estos nodos de forma individual.

728
00:40:30,000 --> 00:40:32,000
Bueno, si ustedes mismos pueden limpiar de nuevo.

729
00:40:32,000 --> 00:40:37,000
Permítanme proponer que en lugar de anita + +, que en vez hacer anita se-

730
00:40:37,000 --> 00:40:42,000
bien, ¿por qué no nos vamos a lo que Anita está señalando y luego hacer. después?

731
00:40:42,000 --> 00:40:45,000
En otras palabras, vamos a Ramón, que está sosteniendo el número 22,

732
00:40:45,000 --> 00:40:51,000
y entonces. siguiente es como si Anita se copia el puntero izquierdo.

733
00:40:51,000 --> 00:40:54,000
Pero ella no quiso ir más allá de Ramón porque encontramos 22.

734
00:40:54,000 --> 00:40:56,000
Pero esa sería la idea. Ahora, esto es un lío espantoso.

735
00:40:56,000 --> 00:40:59,000
Honestamente, nadie va a recordar esta sintaxis, y por suerte,

736
00:40:59,000 --> 00:41:04,000
en realidad es un poco deliberada-oh, no vio lo que escribí.

737
00:41:04,000 --> 00:41:08,000
Esto sería más convincente si pudiera. Voila!

738
00:41:08,000 --> 00:41:10,000
>> Detrás de las escenas, estaba resolviendo el problema de esta manera.

739
00:41:10,000 --> 00:41:14,000
Anita, para dar el paso a la izquierda,

740
00:41:14,000 --> 00:41:18,000
en primer lugar, que te vayas a la dirección que Anita está apuntando a

741
00:41:18,000 --> 00:41:23,000
y en la que se encuentra no sólo n, que acaba de comprobar para efectos de comparación,

742
00:41:23,000 --> 00:41:25,000
pero también se encuentra próximo - en este caso,

743
00:41:25,000 --> 00:41:28,000
Ramon mano izquierda apuntando al siguiente nodo en la lista.

744
00:41:28,000 --> 00:41:32,000
Pero este es el lío espantoso al que me he referido antes,

745
00:41:32,000 --> 00:41:34,000
pero resulta que C nos permite simplificar esto.

746
00:41:34,000 --> 00:41:40,000
En lugar de escribir (* anita), se puede en lugar de simplemente escribir anita-> n,

747
00:41:40,000 --> 00:41:45,000
y es exactamente lo mismo funcionalmente, pero es mucho más intuitivo,

748
00:41:45,000 --> 00:41:48,000
y es mucho más coherente con la imagen que hemos venido señalando

749
00:41:48,000 --> 00:41:50,000
todo este tiempo utilizando flechas.

750
00:41:50,000 --> 00:41:57,000
>> Por último, ¿qué es lo que tenemos que hacer al final de este programa?

751
00:41:57,000 --> 00:42:00,000
Hay una línea de código restante.

752
00:42:00,000 --> 00:42:02,000
Volver ¿qué?

753
00:42:02,000 --> 00:42:05,000
Falso, porque si llegamos a través de todo el ciclo while

754
00:42:05,000 --> 00:42:10,000
y Anita es, de hecho, null, eso significa que ella fue todo el camino hasta el final de la lista

755
00:42:10,000 --> 00:42:12,000
donde ella señalaba, ¿cuál es tu nombre?

756
00:42:12,000 --> 00:42:15,000
Mano izquierda Ari. >> Ari, que es nulo.

757
00:42:15,000 --> 00:42:18,000
Anita es ahora nula, y me doy cuenta de que usted está aquí de pie con torpeza en el limbo

758
00:42:18,000 --> 00:42:21,000
porque me estoy yendo por un monólogo aquí,

759
00:42:21,000 --> 00:42:23,000
pero te involucran de nuevo en un momento.

760
00:42:23,000 --> 00:42:27,000
Anita es nulo en ese punto de la historia, por lo que el bucle while termina,

761
00:42:27,000 --> 00:42:30,000
y tenemos que volver falsa, porque si ella tiene todo el camino a puntero nulo Ari

762
00:42:30,000 --> 00:42:34,000
entonces no había un número que buscó en la lista.

763
00:42:34,000 --> 00:42:39,000
Podemos limpiar esto también, pero esta es una aplicación muy buena entonces

764
00:42:39,000 --> 00:42:43,000
de una función de recorrido, una función para encontrar una lista enlazada.

765
00:42:43,000 --> 00:42:48,000
Aún búsqueda lineal, pero no es tan simple como un puntero + +

766
00:42:48,000 --> 00:42:52,000
+ + o una variable i porque ahora no podemos adivinar

767
00:42:52,000 --> 00:42:54,000
donde cada uno de estos nodos están en la memoria.

768
00:42:54,000 --> 00:42:57,000
Tenemos que seguir literalmente el rastro de migas de pan o, más específicamente,

769
00:42:57,000 --> 00:43:00,000
punteros, para ir de un nodo a otro.

770
00:43:00,000 --> 00:43:02,000
>> Ahora vamos a probar con la otra. Anita, ¿quieres volver aquí?

771
00:43:02,000 --> 00:43:06,000
¿Por qué no seguir adelante y asignar a otra persona de la audiencia?

772
00:43:06,000 --> 00:43:08,000
Malloc-¿cómo te llamas? >> Rebecca.

773
00:43:08,000 --> 00:43:10,000
Rebecca. Rebecca ha sido malloced de la audiencia,

774
00:43:10,000 --> 00:43:13,000
y ella está almacenando el número 55.

775
00:43:13,000 --> 00:43:17,000
Y el objetivo que nos ocupa ahora es que Anita para insertar

776
00:43:17,000 --> 00:43:22,000
Rebecca a la lista enlazada aquí en su lugar apropiado.

777
00:43:22,000 --> 00:43:24,000
Ven aquí un momento.

778
00:43:24,000 --> 00:43:28,000
Yo he hecho algo como esto.

779
00:43:28,000 --> 00:43:32,000
He hecho * nodo. ¿Y cuál es tu nombre?

780
00:43:32,000 --> 00:43:34,000
Rebecca. >> Rebecca, está bien.

781
00:43:34,000 --> 00:43:41,000
Rebecca se malloc (sizeof (nodo)).

782
00:43:41,000 --> 00:43:44,000
Al igual que hemos destinado cosas como los estudiantes y otras cosas en el pasado,

783
00:43:44,000 --> 00:43:46,000
necesitamos el tamaño del nodo, por lo que Rebecca ahora

784
00:43:46,000 --> 00:43:49,000
está señalando en qué?

785
00:43:49,000 --> 00:43:52,000
Rebecca tiene dos campos dentro de ella, uno de los cuales es 55.

786
00:43:52,000 --> 00:43:55,000
Vamos a hacer lo que, rebecca-> = 55.

787
00:43:55,000 --> 00:44:00,000
Pero entonces rebecca-> siguiente debe ser-como ahora, con la mano es una especie de ¿quién sabe?

788
00:44:00,000 --> 00:44:03,000
Está apuntando a un cierto valor basura, así que ¿por qué no hacer una buena medida

789
00:44:03,000 --> 00:44:07,000
que por lo menos hacer esto para que la mano izquierda está ahora a su lado.

790
00:44:07,000 --> 00:44:09,000
Ahora Anita, a partir de aquí.

791
00:44:09,000 --> 00:44:11,000
Hay que Rebecca se le hayan asignado.

792
00:44:11,000 --> 00:44:20,000
Seguir adelante y encontrar dónde debemos poner Rebecca.

793
00:44:20,000 --> 00:44:25,000
Bien, muy bien.

794
00:44:25,000 --> 00:44:28,000
Bueno, bueno, y ahora necesitamos que nos proporcione un poco de dirección,

795
00:44:28,000 --> 00:44:30,000
por lo que ha llegado a Ari.

796
00:44:30,000 --> 00:44:33,000
Su mano izquierda es nulo, pero Rebecca pertenece claramente a la derecha,

797
00:44:33,000 --> 00:44:36,000
así que ¿cómo hemos de modificar esta lista enlazada

798
00:44:36,000 --> 00:44:38,000
con el fin de insertar Rebecca en el lugar apropiado?

799
00:44:38,000 --> 00:44:42,000
Si usted puede literalmente mover las manos de la gente de izquierda en torno a como sea necesario,

800
00:44:42,000 --> 00:44:48,000
vamos a arreglar el problema de esa manera.

801
00:44:48,000 --> 00:44:52,000
Bueno, bueno, y mientras tanto, la mano izquierda de Rebecca es ahora a su lado.

802
00:44:52,000 --> 00:44:54,000
>> Eso fue demasiado fácil.

803
00:44:54,000 --> 00:44:57,000
Vamos a tratar de asignar-estamos casi listos, 20.

804
00:44:57,000 --> 00:44:59,000
Muy bien, vamos arriba.

805
00:44:59,000 --> 00:45:04,000
20 ha sido asignado, así que voy a seguir adelante y decir otra vez aquí

806
00:45:04,000 --> 00:45:07,000
que acabamos de hacer saad nodo *.

807
00:45:07,000 --> 00:45:11,000
Tenemos malloc (sizeof (nodo)).

808
00:45:11,000 --> 00:45:16,000
A continuación, hacer la misma sintaxis exacta como lo hicimos antes para 20,

809
00:45:16,000 --> 00:45:20,000
y yo haré lo siguiente = NULL, y ahora le toca a Anita

810
00:45:20,000 --> 00:45:23,000
que se inserta en la lista enlazada, si pudieras jugar ese mismo papel exacto.

811
00:45:23,000 --> 00:45:30,000
Ejecutar.

812
00:45:30,000 --> 00:45:32,000
Bien, bien.

813
00:45:32,000 --> 00:45:38,000
Ahora piensa detenidamente antes de empezar a mover las manos izquierda alrededor.

814
00:45:38,000 --> 00:45:46,000
Usted tiene, con mucho, el papel más difícil hoy en día.

815
00:45:46,000 --> 00:45:59,000
Cuya mano se movió por primera vez?

816
00:45:59,000 --> 00:46:02,000
Bueno, espera, estoy escuchando algunos no.

817
00:46:02,000 --> 00:46:07,000
Si algunas personas cortésmente le gustaría ayudar a resolver una situación difícil aquí.

818
00:46:07,000 --> 00:46:11,000
Cuya mano izquierda debe ser actualizado primero, tal vez? Si.

819
00:46:11,000 --> 00:46:13,000
[Estudiante] Saad.

820
00:46:13,000 --> 00:46:15,000
Bueno, Saad, ¿por qué, entonces?

821
00:46:15,000 --> 00:46:17,000
[Respuesta de los estudiantes inaudible]

822
00:46:17,000 --> 00:46:19,000
Bien, porque si nos movemos, ¿cuál es tu nombre? >> Marshall.

823
00:46:19,000 --> 00:46:22,000
Marshall, si movemos la mano primero y diez en null,

824
00:46:22,000 --> 00:46:25,000
ahora hemos literalmente huérfanos a cuatro personas en esta lista

825
00:46:25,000 --> 00:46:29,000
porque era lo único que señala en el Ramón y todo el mundo a la izquierda,

826
00:46:29,000 --> 00:46:31,000
por lo que la actualización primer indicador era malo.

827
00:46:31,000 --> 00:46:33,000
Vamos a deshacer eso.

828
00:46:33,000 --> 00:46:37,000
Bueno, y ahora seguir adelante y mover la mano izquierda apuntando al adecuado Ramon.

829
00:46:37,000 --> 00:46:39,000
Esto se siente un poco redundante.

830
00:46:39,000 --> 00:46:41,000
Ahora hay dos personas apuntando a Ramón, pero eso está bien

831
00:46:41,000 --> 00:46:43,000
porque ahora qué otra manera podemos actualizar la lista?

832
00:46:43,000 --> 00:46:48,000
Lo que por otra parte se tiene que mover?

833
00:46:48,000 --> 00:46:53,000
Muy bien, ahora hemos perdido la memoria?

834
00:46:53,000 --> 00:46:57,000
No, todo va bien, vamos a ver si no podemos romper una vez más.

835
00:46:57,000 --> 00:47:00,000
>> Mallocing por última vez, el número 5.

836
00:47:00,000 --> 00:47:04,000
Todo el camino de vuelta, vamos hacia abajo.

837
00:47:04,000 --> 00:47:08,000
Es muy emocionante.

838
00:47:08,000 --> 00:47:15,000
[Aplauso]

839
00:47:15,000 --> 00:47:17,000
¿Cuál es tu nombre? >> Ron.

840
00:47:17,000 --> 00:47:19,000
Ron, está bien, está malloced como el número 5.

841
00:47:19,000 --> 00:47:23,000
Acabamos de ejecutar código que es casi idéntica a estos

842
00:47:23,000 --> 00:47:26,000
con un nombre diferente.

843
00:47:26,000 --> 00:47:28,000
Excelente.

844
00:47:28,000 --> 00:47:38,000
Ahora, Anita, buena suerte insertar el número 5 en la lista ahora.

845
00:47:38,000 --> 00:47:43,000
Bueno, ¿y?

846
00:47:43,000 --> 00:47:47,000
Muy bien, así que esto es realmente el tercero de los tres casos totales.

847
00:47:47,000 --> 00:47:49,000
Primero tuvimos a alguien en la final, Rebecca.

848
00:47:49,000 --> 00:47:51,000
Luego tuvimos a alguien en el medio.

849
00:47:51,000 --> 00:47:53,000
Ahora tenemos a alguien en el comienzo, y en este ejemplo,

850
00:47:53,000 --> 00:47:56,000
que ahora tenía que actualizar Lucas por primera vez

851
00:47:56,000 --> 00:48:00,000
porque el primer elemento en la lista ahora tiene que apuntar a un nuevo nodo,

852
00:48:00,000 --> 00:48:03,000
que, a su vez, se señala en el número de nodo 9.

853
00:48:03,000 --> 00:48:06,000
>> Esta fue una demostración enormemente difícil, estoy seguro,

854
00:48:06,000 --> 00:48:08,000
por lo que un gran aplauso para estos chicos si pudieras.

855
00:48:08,000 --> 00:48:11,000
Muy bien hecho.

856
00:48:11,000 --> 00:48:17,000
Eso es todo. Usted puede guardar sus trozos de papel como un poco de memoria.

857
00:48:17,000 --> 00:48:22,000
Resulta que haciendo esto en el código

858
00:48:22,000 --> 00:48:26,000
no es tan simple como mover las manos en torno a

859
00:48:26,000 --> 00:48:28,000
y apuntando los punteros en diferentes cosas.

860
00:48:28,000 --> 00:48:31,000
Pero darse cuenta de que cuando llegue el momento de poner en práctica algo así como

861
00:48:31,000 --> 00:48:34,000
una lista enlazada o una variante del mismo, si te centras en realidad

862
00:48:34,000 --> 00:48:38,000
estos fundamentos básicos, los problemas de tamaño de un bocado que tengo que averiguar,

863
00:48:38,000 --> 00:48:43,000
¿es esta mano o la mano de esto, darse cuenta de que lo que es un programa bastante complejo

864
00:48:43,000 --> 00:48:47,000
puede, de hecho, ser reducido a elementos básicos bastante simples como este.

865
00:48:47,000 --> 00:48:51,000
>> Vamos a tomar las cosas en una dirección más sofisticado aún.

866
00:48:51,000 --> 00:48:53,000
Ahora tenemos la noción de la lista enlazada.

867
00:48:53,000 --> 00:48:57,000
También tenemos, gracias a la sugerencia de volver allí, una lista doblemente enlazada,

868
00:48:57,000 --> 00:49:01,000
que se ve casi lo mismo, pero ahora tenemos dos punteros dentro de la estructura

869
00:49:01,000 --> 00:49:05,000
en vez de uno, y probablemente podríamos llamar los punteros anterior y siguiente

870
00:49:05,000 --> 00:49:08,000
o hacia la izquierda o hacia la derecha, pero, de hecho, la necesidad de dos de ellos.

871
00:49:08,000 --> 00:49:10,000
El código debería ser un poco más complicado.

872
00:49:10,000 --> 00:49:12,000
Anita habría tenido que hacer más trabajo aquí en el escenario.

873
00:49:12,000 --> 00:49:15,000
Pero sin duda podríamos poner en práctica ese tipo de estructura.

874
00:49:15,000 --> 00:49:19,000
En términos de tiempo de ejecución, sin embargo, ¿cuál sería el tiempo de ejecución

875
00:49:19,000 --> 00:49:24,000
para Anita de encontrar un número n en una lista enlazada ahora?

876
00:49:24,000 --> 00:49:27,000
Aún así gran O de n, así que no es mejor que la búsqueda lineal.

877
00:49:27,000 --> 00:49:29,000
No podemos hacer una búsqueda binaria, aunque, de nuevo.

878
00:49:29,000 --> 00:49:34,000
¿Por qué fue así? No se puede saltar alrededor.

879
00:49:34,000 --> 00:49:36,000
A pesar de que, obviamente, ver todos los humanos en el escenario,

880
00:49:36,000 --> 00:49:39,000
y Anita podría haberlo eyeballed y dijo: "Aquí está la mitad de la lista,"

881
00:49:39,000 --> 00:49:42,000
ella no sabe que si ella fuera el programa de ordenador

882
00:49:42,000 --> 00:49:47,000
porque lo único que tenía que aferrarse a al comienzo del escenario

883
00:49:47,000 --> 00:49:50,000
fue Lucas, que fue el primer indicador.

884
00:49:50,000 --> 00:49:53,000
Ella necesariamente tendría que seguir esos vínculos,

885
00:49:53,000 --> 00:49:56,000
contando su camino hasta que encontró aproximadamente la mitad,

886
00:49:56,000 --> 00:49:58,000
y aun así, ella no va a saber cuando ella llegó a la mitad

887
00:49:58,000 --> 00:50:01,000
a menos que ella va todo el camino hasta el final para saber cuántos son,

888
00:50:01,000 --> 00:50:05,000
luego da marcha atrás, y eso también sería difícil a menos que usted tenía

889
00:50:05,000 --> 00:50:07,000
una lista doblemente enlazada de algún tipo.

890
00:50:07,000 --> 00:50:10,000
>> Solución de problemas hoy, pero introduciendo otros.

891
00:50:10,000 --> 00:50:12,000
¿Qué pasa con una estructura de datos completamente diferente?

892
00:50:12,000 --> 00:50:15,000
Esta es una fotografía de las bandejas en Mather House,

893
00:50:15,000 --> 00:50:19,000
y en este caso, tenemos una estructura de datos también hemos de tipo ya se ha hablando.

894
00:50:19,000 --> 00:50:22,000
Hablamos de una pila en el contexto de la memoria,

895
00:50:22,000 --> 00:50:26,000
y que es una especie de llamado porque deliberadamente una pila en los términos de la memoria

896
00:50:26,000 --> 00:50:31,000
es efectivamente una estructura de datos que tiene más cosas y más capas en la parte superior de la misma.

897
00:50:31,000 --> 00:50:35,000
Pero lo interesante de una pila, como es el caso en la realidad,

898
00:50:35,000 --> 00:50:38,000
es que es un tipo especial de estructura de datos.

899
00:50:38,000 --> 00:50:42,000
Es una estructura de datos mediante el cual el primer elemento de

900
00:50:42,000 --> 00:50:46,000
es el último elemento fuera.

901
00:50:46,000 --> 00:50:50,000
Si es la primera bandeja que se pone en la pila,

902
00:50:50,000 --> 00:50:53,000
que va a ser desgraciadamente la última bandeja a ser retirado de la pila,

903
00:50:53,000 --> 00:50:55,000
y eso no es necesariamente algo bueno.

904
00:50:55,000 --> 00:50:58,000
Por el contrario, se puede pensar que al revés,

905
00:50:58,000 --> 00:51:02,000
es el último de los primeros en salir.

906
00:51:02,000 --> 00:51:05,000
>> Ahora, ¿algún escenario vienen a la mente las que tener una pila

907
00:51:05,000 --> 00:51:08,000
estructura de datos donde se tiene que la propiedad

908
00:51:08,000 --> 00:51:13,000
el último en entrar, primero en salir, es realmente convincente?

909
00:51:13,000 --> 00:51:16,000
¿Eso es bueno? ¿Eso es malo?

910
00:51:16,000 --> 00:51:19,000
Es definitivamente algo malo si las bandejas no eran todos idénticos

911
00:51:19,000 --> 00:51:21,000
y todos eran diferentes colores especiales o lo que sea,

912
00:51:21,000 --> 00:51:24,000
y el color que quiero es todo el camino en la parte inferior.

913
00:51:24,000 --> 00:51:26,000
Por supuesto, usted no puede conseguir que, sin gran esfuerzo.

914
00:51:26,000 --> 00:51:28,000
Hay que empezar por la parte superior y trabaje hacia abajo.

915
00:51:28,000 --> 00:51:31,000
Del mismo modo, ¿qué pasaría si usted fuera uno de esos chicos del ventilador

916
00:51:31,000 --> 00:51:34,000
que espera toda la noche tratando de conseguir un iPhone y comarca

917
00:51:34,000 --> 00:51:36,000
en un lugar como este?

918
00:51:36,000 --> 00:51:40,000
¿No sería agradable si la tienda de Apple

919
00:51:40,000 --> 00:51:42,000
eran una estructura de datos de la pila?

920
00:51:42,000 --> 00:51:44,000
Yay? Nay?

921
00:51:44,000 --> 00:51:47,000
Sólo es bueno para las personas que aparecen en el último minuto

922
00:51:47,000 --> 00:51:50,000
y luego se sacó de la cola.

923
00:51:50,000 --> 00:51:52,000
Y de hecho, el hecho de que estaba inclinado de manera que decir cola

924
00:51:52,000 --> 00:51:56,000
en realidad es consistente con lo que podríamos llamar este tipo de estructura de datos,

925
00:51:56,000 --> 00:51:59,000
una realidad en donde el orden no importa,

926
00:51:59,000 --> 00:52:02,000
y desea que el primero en ser el primero en salir

927
00:52:02,000 --> 00:52:04,000
aunque sólo sea por el bien de la justicia humana.

928
00:52:04,000 --> 00:52:07,000
Por lo general, voy a llamar a eso una estructura de datos cola.

929
00:52:07,000 --> 00:52:11,000
>> Resulta que además de las listas enlazadas, podemos empezar a usar estas mismas ideas básicas

930
00:52:11,000 --> 00:52:15,000
y empezar a crear nuevos y diferentes tipos de soluciones a los problemas.

931
00:52:15,000 --> 00:52:19,000
Por ejemplo, en el caso de una pila, que podría representar una pila

932
00:52:19,000 --> 00:52:22,000
utilizando una estructura de datos como este, me gustaría proponer.

933
00:52:22,000 --> 00:52:26,000
En este caso, he declarado una estructura, y lo he dicho en el interior de esta estructura

934
00:52:26,000 --> 00:52:30,000
es una matriz de números y después una variable llamada,

935
00:52:30,000 --> 00:52:33,000
y yo voy a llamar a esto una pila.

936
00:52:33,000 --> 00:52:35,000
Ahora, ¿por qué esta realidad?

937
00:52:35,000 --> 00:52:43,000
En el caso de una pila, podría sacar esto de manera efectiva en la pantalla como una matriz.

938
00:52:43,000 --> 00:52:47,000
Aquí está mi stack. Esos son mis números.

939
00:52:47,000 --> 00:52:50,000
Y vamos a dibujar como esto, esto, esto, esto, esto.

940
00:52:50,000 --> 00:52:53,000
Y luego tengo algún miembro de datos distinto aquí,

941
00:52:53,000 --> 00:52:58,000
que se denomina tamaño, por lo que este es el tamaño, y esto es números,

942
00:52:58,000 --> 00:53:02,000
y colectivamente, el iPad entero aquí representa una estructura de pila.

943
00:53:02,000 --> 00:53:07,000
Ahora, por defecto, el tamaño presumiblemente tiene que ser inicializado a 0,

944
00:53:07,000 --> 00:53:11,000
y lo que hay dentro de la matriz de números inicialmente

945
00:53:11,000 --> 00:53:14,000
cuando por primera vez asignar una matriz?

946
00:53:14,000 --> 00:53:16,000
Garbage. ¿Quién sabe? Y en realidad no importa.

947
00:53:16,000 --> 00:53:20,000
No importa si es 1, 2, 3, 4, 5, completamente al azar

948
00:53:20,000 --> 00:53:25,000
por la mala suerte almacenada en la estructura de mi porque mientras yo sé que el tamaño de la pila

949
00:53:25,000 --> 00:53:29,000
es 0, entonces sé programación, no se ven en ninguno de los elementos de la matriz.

950
00:53:29,000 --> 00:53:31,000
No importa lo que hay.

951
00:53:31,000 --> 00:53:34,000
No mires a ellos, como sería la implicación de un tamaño de 0.

952
00:53:34,000 --> 00:53:38,000
>> Pero supongamos ahora sigo adelante e inserte algo en la pila.

953
00:53:38,000 --> 00:53:42,000
Quiero insertar el número 5, por lo que poner aquí el número 5,

954
00:53:42,000 --> 00:53:45,000
y luego lo pongo aquí abajo?

955
00:53:45,000 --> 00:53:48,000
Ahora realmente poner 1 para el tamaño,

956
00:53:48,000 --> 00:53:50,000
y ahora la pila es de tamaño 1.

957
00:53:50,000 --> 00:53:53,000
¿Qué pasa si sigo adelante y añadir el número, digamos, 7 después?

958
00:53:53,000 --> 00:53:57,000
Esto luego se actualiza a 2, y luego haremos 9,

959
00:53:57,000 --> 00:54:02,000
y luego esta se actualiza a 3.

960
00:54:02,000 --> 00:54:05,000
Pero ahora la característica interesante de esta pila es que

961
00:54:05,000 --> 00:54:09,000
Se supone que debo quitar el elemento que si quiero hacer estallar

962
00:54:09,000 --> 00:54:12,000
algo fuera de la pila, por así decirlo?

963
00:54:12,000 --> 00:54:14,000
9 sería lo primero que debe ir.

964
00:54:14,000 --> 00:54:18,000
¿Cómo debe cambiar la imagen si quiero sacar un elemento de la pila,

965
00:54:18,000 --> 00:54:20,000
Al igual que una bandeja en Mather?

966
00:54:20,000 --> 00:54:22,000
Si. >> [Estudiante] Fijar el tamaño a 2.

967
00:54:22,000 --> 00:54:27,000
Exactamente, lo único que hacer es ajustar el tamaño a 2, y lo hago con la matriz?

968
00:54:27,000 --> 00:54:29,000
Yo no tengo que hacer nada.

969
00:54:29,000 --> 00:54:32,000
Podría, sólo para ser anal, poner un 0 o -1 allí o algo para significar

970
00:54:32,000 --> 00:54:34,000
que este no es un valor de fiar, pero eso no importa porque

971
00:54:34,000 --> 00:54:37,000
Puedo grabar fuera de la propia matriz cuánto tiempo es

972
00:54:37,000 --> 00:54:41,000
para que yo sepa solo se ve en los dos primeros elementos de esta matriz.

973
00:54:41,000 --> 00:54:47,000
Ahora, si me voy y agregar el número 8 de esta serie, ¿cómo cambiar la imagen a continuación?

974
00:54:47,000 --> 00:54:50,000
Esto se convierte en 8, y esto se convierte en 3.

975
00:54:50,000 --> 00:54:52,000
Voy a cortar algunas esquinas aquí.

976
00:54:52,000 --> 00:54:56,000
Ahora tenemos 5, 7, 8, y estamos de vuelta a un tamaño de 3.

977
00:54:56,000 --> 00:54:58,000
Esto es bastante fácil de implementar,

978
00:54:58,000 --> 00:55:06,000
pero ¿cuándo vamos a lamentar esta decisión de diseño?

979
00:55:06,000 --> 00:55:09,000
¿Cuando las cosas empiezan a ir mal, muy mal? Si.

980
00:55:09,000 --> 00:55:11,000
[Respuesta de los estudiantes inaudible]

981
00:55:11,000 --> 00:55:13,000
Cuando desee volver atrás y obtener el primer elemento que usted pone adentro

982
00:55:13,000 --> 00:55:18,000
>> Resulta aquí a pesar de que una pila es una matriz debajo de la capucha,

983
00:55:18,000 --> 00:55:21,000
estas estructuras de datos que hemos comenzado hablando también se conoce generalmente como

984
00:55:21,000 --> 00:55:25,000
estructuras abstractas de datos por lo que la forma en que se implementen

985
00:55:25,000 --> 00:55:27,000
es completamente en este punto.

986
00:55:27,000 --> 00:55:31,000
Una estructura de datos como una pila que se supone para añadir soporte

987
00:55:31,000 --> 00:55:35,000
operaciones como de empuje, que empuja una bandeja en la pila,

988
00:55:35,000 --> 00:55:39,000
y el pop, que elimina un elemento de la pila, y eso es todo.

989
00:55:39,000 --> 00:55:43,000
Si se va a descargar código de otra persona que ya ha implementado

990
00:55:43,000 --> 00:55:46,000
eso que se llama una pila, esa persona habría escrito

991
00:55:46,000 --> 00:55:49,000
sólo dos funciones para usted, empuje y pop, cuyo único propósito en la vida

992
00:55:49,000 --> 00:55:51,000
sería hacer exactamente eso.

993
00:55:51,000 --> 00:55:54,000
Usted o él o ella quien implementó este programa

994
00:55:54,000 --> 00:55:58,000
habría sido enteramente el que decide cómo implementar

995
00:55:58,000 --> 00:56:00,000
la semántica de empujar y hacer estallar debajo de la capucha

996
00:56:00,000 --> 00:56:03,000
o la funcionalidad de empujar y hacer estallar.

997
00:56:03,000 --> 00:56:07,000
Y he tomado una decisión un tanto miope aquí

998
00:56:07,000 --> 00:56:10,000
mediante la implementación de mi stack con esta estructura de datos simple ¿por qué?

999
00:56:10,000 --> 00:56:12,000
Cuando se hace esta ruptura estructura de datos?

1000
00:56:12,000 --> 00:56:18,000
¿En qué momento tengo que devolver un error cuando el usuario llama a push, por ejemplo?

1001
00:56:18,000 --> 00:56:20,000
[Estudiante] Si no hay más espacio.

1002
00:56:20,000 --> 00:56:23,000
Exactamente, si hay espacio no más, si me he excedido la capacidad,

1003
00:56:23,000 --> 00:56:27,000
que es todo en mayúsculas, ya que sugiere que se trata de una especie de constante global.

1004
00:56:27,000 --> 00:56:30,000
Bueno, entonces me voy a tener que decir: "Lo siento, no puedo empujar otro valor

1005
00:56:30,000 --> 00:56:32,000
en la pila ", al igual que en Mather.

1006
00:56:32,000 --> 00:56:36,000
>> En algún momento, van a llegar a la parte superior de ese armario pequeño.

1007
00:56:36,000 --> 00:56:39,000
No hay más espacio o la capacidad de la pila, momento en el que hay algún tipo de error.

1008
00:56:39,000 --> 00:56:42,000
Tienen que poner el elemento en otro lugar, la bandeja en otro lugar,

1009
00:56:42,000 --> 00:56:44,000
o nada en absoluto.

1010
00:56:44,000 --> 00:56:47,000
Ahora, con una cola, podríamos aplicar un poco diferente.

1011
00:56:47,000 --> 00:56:50,000
Una cola es un poco diferente en que debajo de la campana, se puede implementar

1012
00:56:50,000 --> 00:56:54,000
como una matriz, pero ¿por qué, en este caso, estoy proponiendo

1013
00:56:54,000 --> 00:56:59,000
tener también un elemento de cabeza que representa la cabeza de la lista,

1014
00:56:59,000 --> 00:57:06,000
al frente de la lista, la primera persona en la fila en la tienda de Apple, además de tamaño?

1015
00:57:06,000 --> 00:57:14,000
¿Por qué necesito una pieza adicional de los datos en esta lista?

1016
00:57:14,000 --> 00:57:16,000
Piense en lo que los números se

1017
00:57:16,000 --> 00:57:18,000
si he elaborado la siguiente manera.

1018
00:57:18,000 --> 00:57:21,000
Supongamos que esta es ahora una cola en lugar de una pila,

1019
00:57:21,000 --> 00:57:24,000
con la diferencia-al igual que la tienda de Apple-cola es justo.

1020
00:57:24,000 --> 00:57:27,000
La primera persona en línea al comienzo de la lista, el número 5 en este caso,

1021
00:57:27,000 --> 00:57:30,000
él o ella se va a dejar en la primera tienda.

1022
00:57:30,000 --> 00:57:32,000
Vamos a hacer eso.

1023
00:57:32,000 --> 00:57:35,000
Supongamos que este es el estado de mi cola en este momento en el tiempo, y ahora la tienda de Apple

1024
00:57:35,000 --> 00:57:39,000
se abre y la primera persona, número 5, es conducido a la tienda.

1025
00:57:39,000 --> 00:57:43,000
¿Cómo puedo cambiar la imagen ahora que he de-cola la primera persona

1026
00:57:43,000 --> 00:57:47,000
en la parte delantera de la línea?

1027
00:57:47,000 --> 00:57:50,000
¿Qué es eso? >> [Estudiante] Cambie la cola.

1028
00:57:50,000 --> 00:57:52,000
Cambie la cabeza, así que 5 desaparece.

1029
00:57:52,000 --> 00:57:56,000
En realidad, es como si-la mejor manera de hacer esto?

1030
00:57:56,000 --> 00:58:00,000
En realidad, es como si este hombre desaparece.

1031
00:58:00,000 --> 00:58:03,000
¿Cuál sería el número 7 en hacer una tienda real?

1032
00:58:03,000 --> 00:58:05,000
Se daría un paso adelante muy importante.

1033
00:58:05,000 --> 00:58:08,000
>> Pero ¿qué hemos llegado a apreciar lo que se refiere a las matrices

1034
00:58:08,000 --> 00:58:10,000
y moviendo cosas de sitio?

1035
00:58:10,000 --> 00:58:12,000
Eso es un poco de una pérdida de tiempo, ¿verdad?

1036
00:58:12,000 --> 00:58:16,000
¿Por qué tienes que ser tan anal como para tener la primera persona

1037
00:58:16,000 --> 00:58:21,000
en el inicio de la línea en físicamente el inicio de la porción de la memoria?

1038
00:58:21,000 --> 00:58:23,000
Eso es completamente innecesario. ¿Por qué?

1039
00:58:23,000 --> 00:58:26,000
¿Qué podría yo recuerde en su lugar? >> [Inaudible respuesta de los estudiantes]

1040
00:58:26,000 --> 00:58:30,000
Exactamente, yo sólo podía recordar con esta cabeza de miembro de datos adicional

1041
00:58:30,000 --> 00:58:34,000
que ahora la cabeza de la lista ya no es 0, lo que era hace un momento.

1042
00:58:34,000 --> 00:58:39,000
Ahora en realidad es el número 1. De esta manera, consigo una optimización leve.

1043
00:58:39,000 --> 00:58:44,000
El hecho de que he de-cola a alguien de línea al inicio de la línea en la tienda de Apple

1044
00:58:44,000 --> 00:58:47,000
no significa que todo el mundo tiene que cambiar, lo que recuerdo es una operación lineal.

1045
00:58:47,000 --> 00:58:50,000
Yo en cambio constante pueden pasar tiempo solo

1046
00:58:50,000 --> 00:58:53,000
y lograr entonces una respuesta mucho más rápida.

1047
00:58:53,000 --> 00:58:56,000
Pero el precio que estoy pagando es lo que ganar que el rendimiento adicional

1048
00:58:56,000 --> 00:58:58,000
y no tener que cambiar todo el mundo?

1049
00:58:58,000 --> 00:59:01,000
Si. >> [Inaudible respuesta de los estudiantes]

1050
00:59:01,000 --> 00:59:04,000
Puede agregar más personas, bueno, ese problema es ortogonal

1051
00:59:04,000 --> 00:59:07,000
al hecho de que no estamos cambiando la gente a su alrededor.

1052
00:59:07,000 --> 00:59:11,000
Todavía es una matriz, por lo que si no cambiamos todos o no-

1053
00:59:11,000 --> 00:59:13,000
Oh, ya veo lo que quieres decir, está bien.

1054
00:59:13,000 --> 00:59:16,000
En realidad, estoy de acuerdo con lo que dices en que es casi como si

1055
00:59:16,000 --> 00:59:19,000
estamos ahora nunca va a utilizar el inicio de esta serie ya

1056
00:59:19,000 --> 00:59:22,000
porque si me quito 5, entonces me quito 7.

1057
00:59:22,000 --> 00:59:24,000
Pero yo sólo poner a la gente a la derecha.

1058
00:59:24,000 --> 00:59:28,000
>> Se siente como que estoy perdiendo el espacio, y con el tiempo mi cola se desintegra en la nada,

1059
00:59:28,000 --> 00:59:31,000
por lo que sólo podría tener envolvente personas,

1060
00:59:31,000 --> 00:59:35,000
y podríamos pensar en esta serie realmente como una especie de estructura circular,

1061
00:59:35,000 --> 00:59:38,000
pero lo usamos operador en C para hacer ese tipo de envolvente?

1062
00:59:38,000 --> 00:59:40,000
[Respuesta de los estudiantes inaudible] >> El operador de módulo.

1063
00:59:40,000 --> 00:59:43,000
Sería un poco molesto para pensar en cómo se hace la envolvente,

1064
00:59:43,000 --> 00:59:46,000
pero podríamos hacerlo, y podríamos empezar a poner a las personas en lo que fue el frente de la línea,

1065
00:59:46,000 --> 00:59:52,000
pero sólo recuerda con esta variable cabeza que la cabeza real de la línea es en realidad.

1066
00:59:52,000 --> 00:59:57,000
¿Y si, por el contrario, nuestro objetivo en última instancia, sin embargo,

1067
00:59:57,000 --> 01:00:00,000
fue a buscar números, como lo hicimos aquí en el escenario con Anita,

1068
01:00:00,000 --> 01:00:02,000
pero realmente quieren lo mejor de todos estos mundos?

1069
01:00:02,000 --> 01:00:05,000
Queremos más sofisticación que permite array

1070
01:00:05,000 --> 01:00:09,000
porque queremos que la capacidad de crecer de forma dinámica la estructura de datos.

1071
01:00:09,000 --> 01:00:12,000
Pero no quiero tener que recurrir a algo que hemos señalado

1072
01:00:12,000 --> 01:00:15,000
en la primera conferencia no fue un algoritmo óptimo,

1073
01:00:15,000 --> 01:00:17,000
que de búsqueda lineal.

1074
01:00:17,000 --> 01:00:21,000
Resulta que se puede, de hecho, lograr

1075
01:00:21,000 --> 01:00:24,000
o al menos cerca de la constante de tiempo, por lo que alguien como Anita,

1076
01:00:24,000 --> 01:00:27,000
si se configura la estructura de datos para no ser una lista enlazada,

1077
01:00:27,000 --> 01:00:30,000
de no ser una pila, para no ser una cola, podría, de hecho,

1078
01:00:30,000 --> 01:00:33,000
llegar a una estructura de datos que le permite mirar las cosas,

1079
01:00:33,000 --> 01:00:37,000
incluso palabras, no sólo números, en lo que llamaremos constante de tiempo.

1080
01:00:37,000 --> 01:00:40,000
>> Y de hecho, mirando hacia adelante, uno de los conjuntos de procesadores de esta clase es casi siempre

1081
01:00:40,000 --> 01:00:43,000
una implementación de un comprobador de ortografía, mediante el cual

1082
01:00:43,000 --> 01:00:46,000
te damos otra vez algunas palabras inglesas 150.000 y el objetivo es

1083
01:00:46,000 --> 01:00:51,000
cargar en la memoria de aquellos y rápidamente ser capaces de responder a las preguntas de la forma

1084
01:00:51,000 --> 01:00:54,000
esta palabra se escribe correctamente?

1085
01:00:54,000 --> 01:00:58,000
Y realmente sería un asco si tiene que recorrer los 150.000 palabras para contestar a eso.

1086
01:00:58,000 --> 01:01:02,000
Pero, de hecho, veremos que podemos hacer en un tiempo muy, muy rápido.

1087
01:01:02,000 --> 01:01:06,000
Y va a implicar algo aplicación llamada tabla hash,

1088
01:01:06,000 --> 01:01:09,000
y aunque a primera vista esta cosa llamada tabla hash se va a

1089
01:01:09,000 --> 01:01:12,000
vamos a alcanzar estos tiempos súper rápidos de respuesta,

1090
01:01:12,000 --> 01:01:18,000
resulta que existe de hecho un problema.

1091
01:01:18,000 --> 01:01:23,000
Cuando llega el momento de poner en práctica esta cosa llamada de nuevo, lo estoy haciendo de nuevo.

1092
01:01:23,000 --> 01:01:25,000
Yo soy el único aquí.

1093
01:01:25,000 --> 01:01:28,000
Cuando llega el momento de la aplicación de esta cosa llamada tabla hash,

1094
01:01:28,000 --> 01:01:30,000
vamos a tener que tomar una decisión.

1095
01:01:30,000 --> 01:01:32,000
¿Qué tan grande debe ser esa cosa en realidad?

1096
01:01:32,000 --> 01:01:36,000
Y cuando empezamos a insertar números en esta tabla hash,

1097
01:01:36,000 --> 01:01:38,000
¿cómo vamos a guardarlos de forma

1098
01:01:38,000 --> 01:01:42,000
que podamos volver a salir tan rápido como nos las dieron en?

1099
01:01:42,000 --> 01:01:45,000
Pero ya veremos dentro de poco, que esta cuestión de

1100
01:01:45,000 --> 01:01:48,000
cuando es el cumpleaños de todos en la clase será muy afín.

1101
01:01:48,000 --> 01:01:51,000
Resulta que en esta sala, tenemos unos pocos cientos de personas,

1102
01:01:51,000 --> 01:01:56,000
así que las probabilidades de que dos de nosotros tenemos el mismo cumpleaños es probablemente bastante alto.

1103
01:01:56,000 --> 01:01:58,000
¿Qué pasa si sólo había 40 de nosotros en esta sala?

1104
01:01:58,000 --> 01:02:02,000
¿Cuáles son las probabilidades de que dos personas tengan el mismo cumpleaños?

1105
01:02:02,000 --> 01:02:04,000
[Los estudiantes] Más del 50%.

1106
01:02:04,000 --> 01:02:06,000
Si, más de 50%. De hecho, hasta me trajo una carta.

1107
01:02:06,000 --> 01:02:08,000
Resulta que-y esto es realmente sólo un adelanto de vista previa

1108
01:02:08,000 --> 01:02:12,000
si sólo hay 58 de nosotros en esta sala, la probabilidad de que 2 de nosotros

1109
01:02:12,000 --> 01:02:16,000
tengan el mismo cumpleaños es enormemente alto, casi el 100%,

1110
01:02:16,000 --> 01:02:20,000
y eso va a causar una gran cantidad de daño para nosotros el miércoles.

1111
01:02:20,000 --> 01:02:24,000
>> Dicho esto, vamos a levantar la sesión aquí. Nos vemos el miércoles.

1112
01:02:24,000 --> 01:02:28,000
[Aplauso]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]