1
00:00:00,000 --> 00:00:02,904
[MÚSICA DE FONDO]

2
00:00:02,904 --> 00:00:10,180


3
00:00:10,180 --> 00:00:11,200
DAVID: Muy bien.

4
00:00:11,200 --> 00:00:15,880
Esto es CS50, y esta es la lección dos,
nuestra continuación de C.

5
00:00:15,880 --> 00:00:18,380
Y para las siguientes semanas,
continuaremos usando C.

6
00:00:18,380 --> 00:00:21,635
Pero nos enfocaremos menos en el
lenguaje y la sintaxis, en los cuales

7
00:00:21,635 --> 00:00:24,010
con el tiempo conseguiremos experiencia
mediante la resolución de problemas,

8
00:00:24,010 --> 00:00:26,676
y más y más sobre las ideas,
y más y más sobre los problemas

9
00:00:26,676 --> 00:00:27,670
que podremos resolver.

10
00:00:27,670 --> 00:00:29,710
Pero antes de que sigamos
adelante con algo nuevo,

11
00:00:29,710 --> 00:00:32,080
echemos un vistazo rápido
a dónde nos quedamos

12
00:00:32,080 --> 00:00:34,840
y lo que hoy asumiremos
como un nivel de comodidad

13
00:00:34,840 --> 00:00:37,010
y pregunten cualquier
duda que surja en el camino.

14
00:00:37,010 --> 00:00:40,360
Antes, para programar
necesitábamos una herramienta,

15
00:00:40,360 --> 00:00:42,605
y esa herramienta
era esta, CS50 IDE.

16
00:00:42,605 --> 00:00:45,730
Si aún no la conocen, probablemente
lo harán este fin de semana con la serie

17
00:00:45,730 --> 00:00:46,420
de problemas uno.

18
00:00:46,420 --> 00:00:49,000
Este será un entorno
de programación basado en la web

19
00:00:49,000 --> 00:00:51,250
que tiene todas las
herramientas que se necesitan para

20
00:00:51,250 --> 00:00:55,210
escribir un código, compilarlo y después,
a partir de hoy, iniciar su depuración

21
00:00:55,210 --> 00:00:57,550
o encontrar errores en él.

22
00:00:57,550 --> 00:01:01,975
Pero esto es un requisito porque no
es suficiente con solo escribirlo.

23
00:01:01,975 --> 00:01:04,769
¿Qué nombre le damos,
generalmente hablando?

24
00:01:04,769 --> 00:01:06,010
Sí, es el código fuente.

25
00:01:06,010 --> 00:01:06,880
Entonces, esto es código.

26
00:01:06,880 --> 00:01:09,550
Cuando alguien dice, escribo un código,
en realidad escriben cosas como esta.

27
00:01:09,550 --> 00:01:12,400
Y este es, en particular, un
lenguaje llamado C. Desde luego,

28
00:01:12,400 --> 00:01:15,580
las computadoras no hablan C,
tampoco hablan Java,

29
00:01:15,580 --> 00:01:18,660
y no hablan Python o C++, o cualquiera
de los lenguajes con los que

30
00:01:18,660 --> 00:01:19,540
estén familiarizados.

31
00:01:19,540 --> 00:01:21,539
Al final del día, ¿qué es lo
único que entienden?

32
00:01:21,539 --> 00:01:22,930
Sí, el binario.

33
00:01:22,930 --> 00:01:25,300
Los números binarios son
ceros y unos, que también son conocidos

34
00:01:25,300 --> 00:01:29,520
como código máquina, en este
contexto, en la medida que sea un código.

35
00:01:29,520 --> 00:01:33,029
Son instrucciones que se implementan
para resolver algunos problemas.

36
00:01:33,029 --> 00:01:35,320
Pero las computadoras
solo entienden ceros y unos.

37
00:01:35,320 --> 00:01:39,723
Necesitábamos una herramienta para llegar
desde A hasta B, ¿la cual se llama?

38
00:01:39,723 --> 00:01:41,410
Sí, un compilador.

39
00:01:41,410 --> 00:01:43,960
Así que un compilador,
hace esto por nosotros.

40
00:01:43,960 --> 00:01:45,520
El código fuente es la entrada.

41
00:01:45,520 --> 00:01:49,020
El compilador es el programa,
o en realidad es el algoritmo,

42
00:01:49,020 --> 00:01:50,770
no obstante en la forma
de una pieza de software.

43
00:01:50,770 --> 00:01:53,557
Así que, la salida es el código
máquina de ceros y unos.

44
00:01:53,557 --> 00:01:56,890
Y para nuestros fines, no nos
ocuparemos en cómo llegar del paso A al B

45
00:01:56,890 --> 00:01:57,520
per se.

46
00:01:57,520 --> 00:01:58,780
Queremos usar la herramienta.

47
00:01:58,780 --> 00:02:01,270
Pero esta es otra área
en las ciencias de la computación.

48
00:02:01,270 --> 00:02:03,310
Si quieren entender cómo
funcionan los compiladores,

49
00:02:03,310 --> 00:02:06,820
y cómo los humanos obtenemos
ceros y unos de algo llamado código

50
00:02:06,820 --> 00:02:10,539
ensamblador para lenguajes de alto nivel,
al que daremos un vistazo en CS50.

51
00:02:10,539 --> 00:02:14,500
En sí mismo es un campo completo
que al final podría resultar de interés,

52
00:02:14,500 --> 00:02:16,820
pero, de manera mecánica,
es así cómo compilamos el código.

53
00:02:16,820 --> 00:02:17,770
Clang es un compilador,

54
00:02:17,770 --> 00:02:19,480
admitido para el lenguaje C.

55
00:02:19,480 --> 00:02:22,076
Es un software que algunos
humanos escribieron hace años

56
00:02:22,076 --> 00:02:23,200
aunque existen alternativas

57
00:02:23,200 --> 00:02:26,110
si alguna vez han utilizado
Visual Studio en el mundo de Windows,

58
00:02:26,110 --> 00:02:29,710
o GCC en el mundo de Linux y Unix,
existe un grupo de otros compiladores.

59
00:02:29,710 --> 00:02:32,890
Simplemente usamos clang
porque es bastante popular.

60
00:02:32,890 --> 00:02:35,440
Y luego ese segundo
comando es aún más extraño,

61
00:02:35,440 --> 00:02:38,230
¿pero representa
el acto de hacer qué?

62
00:02:38,230 --> 00:02:39,430
./a.out.

63
00:02:39,430 --> 00:02:40,900
Sí, ¿por aquí?

64
00:02:40,900 --> 00:02:42,010
Sí, ejecuta el programa.

65
00:02:42,010 --> 00:02:42,509
Exacto.

66
00:02:42,509 --> 00:02:44,894
Así que ./a.out es una forma
compleja de ejecutar un programa,

67
00:02:44,894 --> 00:02:47,560
es el equivalente en texto
de un icono de doble clic.

68
00:02:47,560 --> 00:02:49,660
Y a.out es el nombre
predeterminado que obtenemos

69
00:02:49,660 --> 00:02:54,830
de la salida del ensamblador al compilar
un programa sin nombre específico.

70
00:02:54,830 --> 00:02:56,560
Pero pudimos
especificar un nombre.

71
00:02:56,560 --> 00:03:00,250
Si introducimos una técnica llamada
argumentos de línea de comandos,

72
00:03:00,250 --> 00:03:02,440
podemos ser un poco más precisos.

73
00:03:02,440 --> 00:03:05,944
clang -o, para la salida de
cualquier palabra que deseen.

74
00:03:05,944 --> 00:03:07,360
En este caso se me ocurrió hello.

75
00:03:07,360 --> 00:03:11,110
Luego el nombre del programa o
el archivo que deseamos compilar.

76
00:03:11,110 --> 00:03:13,060
Pero, desde luego,
es bastante tedioso.

77
00:03:13,060 --> 00:03:15,080
De hecho nos falta un paso.

78
00:03:15,080 --> 00:03:18,070
A veces cuando queremos
escribir un programa,

79
00:03:18,070 --> 00:03:21,267
basta con compilar
exactamente eso.

80
00:03:21,267 --> 00:03:22,600
Ahora hagamos esto.

81
00:03:22,600 --> 00:03:26,350
Voy a entrar al
CS50 IDE y luego

82
00:03:26,350 --> 00:03:28,450
brevemente haré lo siguiente.

83
00:03:28,450 --> 00:03:29,670
File, New.

84
00:03:29,670 --> 00:03:32,005
Luego guardaré
esto como hello.c.

85
00:03:32,005 --> 00:03:35,710
Y de memoria recrearé
este programa rápidamente.

86
00:03:35,710 --> 00:03:40,697
int main(void), y después
printf ("hello, world"),

87
00:03:40,697 --> 00:03:43,030
y luego, por si acaso,
\ n, que significa

88
00:03:43,030 --> 00:03:44,930
mueve el cursor a la siguiente línea.

89
00:03:44,930 --> 00:03:46,900
Y a continuación lo guardaré.

90
00:03:46,900 --> 00:03:52,300
Si ahora ejecutamos
clang hello.c, vemos que luce bien.

91
00:03:52,300 --> 00:03:54,310
Y ./a.out

92
00:03:54,310 --> 00:03:55,450
también luce bien.

93
00:03:55,450 --> 00:03:58,690
Pero recuerden que introdujimos
algunas otras funciones el otro día,

94
00:03:58,690 --> 00:04:00,400
como get_string y get_int,

95
00:04:00,400 --> 00:04:02,650
y veremos muchas más dentro de poco.

96
00:04:02,650 --> 00:04:06,290
Si hago eso, noto que tengo
que añadir un par de cosas.

97
00:04:06,290 --> 00:04:12,250
Así que si quiero usar
algo como string name = get string

98
00:04:12,250 --> 00:04:14,530
y abro y cierro comillas
("Name: "), para apuntar al usuario,

99
00:04:14,530 --> 00:04:17,635
recuerden que el lado
izquierdo dice, hey, computadora,

100
00:04:17,635 --> 00:04:19,510
dame una variable que
se almacene en la cadena

101
00:04:19,510 --> 00:04:20,241
que se llame name.

102
00:04:20,241 --> 00:04:21,490
Puede llamarse de cualquier forma,

103
00:04:21,490 --> 00:04:23,290
pude llamarla s.

104
00:04:23,290 --> 00:04:26,440
¿Por qué es mucho mejor llamar
a mi variable name en vez de

105
00:04:26,440 --> 00:04:28,547
string o s?

106
00:04:28,547 --> 00:04:29,046
¿Sí?

107
00:04:29,046 --> 00:04:29,850
PÚBLICO: Porque es más claro.

108
00:04:29,850 --> 00:04:30,820
DAVID: Porque es más claro, ¿cierto?

109
00:04:30,820 --> 00:04:33,114
Puede parecer bastante
quisquilloso ese pequeño detalle,

110
00:04:33,114 --> 00:04:34,030
pero es más claro.

111
00:04:34,030 --> 00:04:35,590
Y cuando nuestros programas
se vuelven más grandes, es mejor

112
00:04:35,590 --> 00:04:37,673
ser capaces de leer palabras y
comprender implícitamente

113
00:04:37,673 --> 00:04:40,420
su significado sin tener que
pensar por qué x, y, o s,

114
00:04:40,420 --> 00:04:41,860
o lo que sea.

115
00:04:41,860 --> 00:04:45,174
En el lado derecho, mientras tanto,
tenemos esta función get_string,

116
00:04:45,174 --> 00:04:47,590
cuyo propósito en la vida es
obtener una cadena desde el

117
00:04:47,590 --> 00:04:51,460
teclado del usuario, que
apunte a una palabra como name,

118
00:04:51,460 --> 00:04:54,520
y luego la devuelva, como Sam
cuando me devolvió un pedazo de papel

119
00:04:54,520 --> 00:04:56,380
con un nombre.

120
00:04:56,380 --> 00:04:57,730
Pero aquí hay una trampa,

121
00:04:57,730 --> 00:05:03,560
ya que no es suficiente solo adaptar
mi código a este nuevo enfoque.

122
00:05:03,560 --> 00:05:05,840
Tuve que cambiar una vez
más esa segunda línea,

123
00:05:05,840 --> 00:05:08,036
y tuve que dar un marcador
de posición, el cual es %s.

124
00:05:08,036 --> 00:05:11,160
Parece un poco enigmático,
pensarlo como un Mad Lib,

125
00:05:11,160 --> 00:05:12,910
si están familiarizados
con ellos, donde solo hay que

126
00:05:12,910 --> 00:05:14,540
llenar un espacio en blanco.

127
00:05:14,540 --> 00:05:17,200
La instrucción que da %s es:
pon una palabra allí.

128
00:05:17,200 --> 00:05:18,070
¿Cuál palabra?

129
00:05:18,070 --> 00:05:22,270
La que sea que venga después de la coma,
cualquier variable o valor que esté allí.

130
00:05:22,270 --> 00:05:24,790
Así que eso es bueno,

131
00:05:24,790 --> 00:05:26,620
Pero hay un par de cosas
que pueden salir mal

132
00:05:26,620 --> 00:05:28,990
Y voy a señalarlas
porque tal vez así ustedes

133
00:05:28,990 --> 00:05:30,890
no se tropezarán con ellas
cuando lo hagan por su cuenta.

134
00:05:30,890 --> 00:05:35,200
Voy a proseguir con "clang hello.c"
ahora que apliqué estos cambios

135
00:05:35,200 --> 00:05:36,239
y los guardé.

136
00:05:36,239 --> 00:05:38,530
De repente hay muchos
errores en todo, aunque no

137
00:05:38,530 --> 00:05:39,820
cambié tanto este código.

138
00:05:39,820 --> 00:05:41,570
Una vez más, la regla de oro
de la última vez decía,

139
00:05:41,570 --> 00:05:44,890
si hay muchos mensajes
de error, revisa siempre el primero

140
00:05:44,890 --> 00:05:48,880
porque el resto podría ser
el resultado de una cascada de errores,

141
00:05:48,880 --> 00:05:51,190
de los cuales solo uno
es importante, ya que es el primero.

142
00:05:51,190 --> 00:05:54,580
Ahora, dice uso de cadena
identificadora no declarada.

143
00:05:54,580 --> 00:05:57,610
¿Quisiste decir stdin?, lo cual es
algo completamente diferente.

144
00:05:57,610 --> 00:05:58,300
No lo hice.

145
00:05:58,300 --> 00:05:59,330
Quise decir "string".

146
00:05:59,330 --> 00:06:02,604
Resulta que la cadena es una función
de la llamada biblioteca CS50.

147
00:06:02,604 --> 00:06:05,770
Esto es una rueda de entrenamiento
que usaremos durante algunas semanas

148
00:06:05,770 --> 00:06:08,440
hasta que nos adentremos
también en el mundo de las cadenas.

149
00:06:08,440 --> 00:06:13,516
Pero, para usar cualquier cosa de CS50,
¿qué necesito agregar también a mi código?

150
00:06:13,516 --> 00:06:14,450
PÚBLICO: El código fuente.

151
00:06:14,450 --> 00:06:15,700
DAVID: El código fuente, sí.

152
00:06:15,700 --> 00:06:16,974
Pero, ¿qué más?

153
00:06:16,974 --> 00:06:17,890
PÚBLICO: La biblioteca.

154
00:06:17,890 --> 00:06:18,931
DAVID: La biblioteca.

155
00:06:18,931 --> 00:06:20,607
Y la biblioteca fue la biblioteca CS50.

156
00:06:20,607 --> 00:06:23,440
Eso significa que hay un archivo en
algún lugar de la computadora, en el IDE,

157
00:06:23,440 --> 00:06:27,470
llamado cs50.h, conocido como archivo
de encabezado, ya veremos más sobre eso.

158
00:06:27,470 --> 00:06:28,990
Entonces, me olvidé de ese detalle.

159
00:06:28,990 --> 00:06:31,362
Supongamos que ustedes
tampoco recuerdan eso,

160
00:06:31,362 --> 00:06:33,820
Bueno, quizás recuerden, de una
de nuestras sesiones de orientación,

161
00:06:33,820 --> 00:06:36,434
que CS50 también tiene herramientas
que los ayudarán con esto.

162
00:06:36,434 --> 00:06:39,100
No tienen que recurrir a este
foro de discusión en línea del curso.

163
00:06:39,100 --> 00:06:40,750
No necesariamente
tienen que trabajar horas extra

164
00:06:40,750 --> 00:06:42,010
por mensajes de error como este.

165
00:06:42,010 --> 00:06:45,160
Si no tienen idea
de lo que está sucediendo,

166
00:06:45,160 --> 00:06:46,660
hagan lo siguiente.

167
00:06:46,660 --> 00:06:49,570
En lugar de solo ejecutar
clang hello.c, pondremos algo

168
00:06:49,570 --> 00:06:53,680
como help50 clang hello.c,
donde help50 es

169
00:06:53,680 --> 00:06:57,350
un comando específico del CS50,
una especie de ayudante virtual.

170
00:06:57,350 --> 00:07:00,640
Si reconocemos nuestros mensajes
de error, en amarillo en la parte inferior,

171
00:07:00,640 --> 00:07:02,229
resaltaremos el primero.

172
00:07:02,229 --> 00:07:05,020
Luego les daremos consejos
de cómo pueden obtenerlos.

173
00:07:05,020 --> 00:07:07,330
Entonces, en" identificador
no declarado" clang identificó

174
00:07:07,330 --> 00:07:10,090
que usamos un
name, string, en la línea 5

175
00:07:10,090 --> 00:07:12,820
de hello.c, que no fueron definidos.

176
00:07:12,820 --> 00:07:16,115
¿Olvidamos incluir cs50.h,
en donde la cadena de nuestro

177
00:07:16,115 --> 00:07:16,782
archivo está definida?

178
00:07:16,782 --> 00:07:19,573
Generalmente intentaremos
inducir preguntas retóricas que,

179
00:07:19,573 --> 00:07:22,640
con suerte, nos conducirán
hacia la solución correcta.

180
00:07:22,640 --> 00:07:26,140
Muy bien, al menos eso refrescó mi
memoria, pero aún no estoy 100 %

181
00:07:26,140 --> 00:07:29,230
cómodo con
lo que hacen estas líneas.

182
00:07:29,230 --> 00:07:31,330
Y hoy definiremos
un poco más todo esto,

183
00:07:31,330 --> 00:07:34,060
siento que estoy tratando de hacerlo,

184
00:07:34,060 --> 00:07:40,120
pero resulta que hay otro,
aquí lo tengo, clang hello.c, Enter.

185
00:07:40,120 --> 00:07:40,950
Diablos.

186
00:07:40,950 --> 00:07:43,170
Bueno, de hecho esto es
un positivo neto, ¿cierto?

187
00:07:43,170 --> 00:07:44,830
Parece que hay
menos mensajes de error,

188
00:07:44,830 --> 00:07:47,680
pero ahora hay uno
que no vimos el otro día...

189
00:07:47,680 --> 00:07:50,080
undefined reference to 'get_string'

190
00:07:50,080 --> 00:07:52,000
Así que es muy parecido,

191
00:07:52,000 --> 00:07:53,470
pero algo no se entiende.

192
00:07:53,470 --> 00:07:55,120
Sin duda es una redacción diferente

193
00:07:55,120 --> 00:07:56,890
y no estoy muy
seguro de lo que significa.

194
00:07:56,890 --> 00:07:59,140
Pero resulta que no basta

195
00:07:59,140 --> 00:08:04,390
con usar la mayoría de las bibliotecas
que incluyen a cs50.h u otro archivo

196
00:08:04,390 --> 00:08:06,070
de encabezado,
como finalmente veremos.

197
00:08:06,070 --> 00:08:09,610
Eso solo le enseña
al compilador que algo existe.

198
00:08:09,610 --> 00:08:12,280
Eso como la última vez,
cuando hablamos de prototipos,

199
00:08:12,280 --> 00:08:14,740
donde pusimos una pequeña
frase que solo decía, por cierto,

200
00:08:14,740 --> 00:08:16,370
esta función
existirá en algún momento.

201
00:08:16,370 --> 00:08:17,870
Eso es lo que hace el
archivo de encabezado.

202
00:08:17,870 --> 00:08:20,340
Es como una promesa a
clang de que esto existirá.

203
00:08:20,340 --> 00:08:21,910
Pero existe un segundo paso.

204
00:08:21,910 --> 00:08:25,720
Tenemos que alimentar a
clang de los ceros y unos que

205
00:08:25,720 --> 00:08:29,500
implementa la biblioteca CS50 que, desde
luego, nosotros mismos no creamos

206
00:08:29,500 --> 00:08:31,720
pero que preinstalamos en el IDE.

207
00:08:31,720 --> 00:08:33,850
Existe una manera
de hacerlo por separado,

208
00:08:33,850 --> 00:08:37,210
en lugar de solo escribir
clang hello.c, tenemos que

209
00:08:37,210 --> 00:08:40,294
hacer lo que se denomina vincular
nuestro código con esa biblioteca,

210
00:08:40,294 --> 00:08:43,419
al menos si es una biblioteca de
terceros que no viene con la computadora,

211
00:08:43,419 --> 00:08:45,070
vino de humanos como nosotros.

212
00:08:45,070 --> 00:08:49,180
Entonces ahora esto dice, hey clang,
compila hello.c, pero vincúlalo

213
00:08:49,180 --> 00:08:52,300
con la biblioteca CS50, eso
significa que tomo mis ceros y unos,

214
00:08:52,300 --> 00:08:55,810
tome los ceros y unos de CS50,
los combine y luego me de

215
00:08:55,810 --> 00:08:58,339
mi programa para ejecutarlo.

216
00:08:58,339 --> 00:09:00,130
Eso será un
ingrediente clave

217
00:09:00,130 --> 00:09:02,129
y help50 podría
guiarnos hacia esa solución.

218
00:09:02,129 --> 00:09:04,570
Si ahora presiono Enter,
parece que compila.

219
00:09:04,570 --> 00:09:06,520
./a.out.

220
00:09:06,520 --> 00:09:07,900
Mi nombre debe ser David.

221
00:09:07,900 --> 00:09:08,770
Enter.

222
00:09:08,770 --> 00:09:10,060
Y dice, "hello, David".

223
00:09:10,060 --> 00:09:12,893
Nuevamente, no se obsesionen
ni trabajen horas extra para arreglar

224
00:09:12,893 --> 00:09:14,230
este tipo de errores.

225
00:09:14,230 --> 00:09:16,540
Así sortearán este tipo de
obstáculos desde el primer momento.

226
00:09:16,540 --> 00:09:19,150
Pero fíjense,
busquen palabras familiares,

227
00:09:19,150 --> 00:09:20,260
usen cosas como help50,

228
00:09:20,260 --> 00:09:21,552
accedan al curso en línea

229
00:09:21,552 --> 00:09:24,135
y superen estos obstáculos
porque, a fin de cuentas,

230
00:09:24,135 --> 00:09:26,170
lo más interesante será la lógica

231
00:09:26,170 --> 00:09:29,480
de los programas y los
problemas que tratamos de resolver.

232
00:09:29,480 --> 00:09:33,190
Entonces, ¿qué está
ocurriendo por debajo del agua?

233
00:09:33,190 --> 00:09:35,516
Y francamente, esto
se está volviendo tedioso.

234
00:09:35,516 --> 00:09:37,390
Entonces, ¿cómo automatizo
algunos de estos procesos?

235
00:09:37,390 --> 00:09:39,580
Porque esto es muy fácil
de olvidar y es muy aburrido

236
00:09:39,580 --> 00:09:41,562
seguir escribiendo tantos comandos.

237
00:09:41,562 --> 00:09:43,270
Bueno, recuerden
que había un atajo del que

238
00:09:43,270 --> 00:09:46,900
hablé el otro día, en donde
se esconden todos estos detalles.

239
00:09:46,900 --> 00:09:48,190
No necesitamos recordar -o.

240
00:09:48,190 --> 00:09:51,182
No necesitamos recordar -lcs50.

241
00:09:51,182 --> 00:09:52,890
¿Qué hacemos en vez
de usar "make" en un programa?

242
00:09:52,890 --> 00:09:54,130
¿Sí?

243
00:09:54,130 --> 00:09:56,620
Sí, así que háganlo, eso
no es un compilador en sí mismo,

244
00:09:56,620 --> 00:09:59,980
es un tipo de programa que
nos ayuda a ejecutar un compilador.

245
00:09:59,980 --> 00:10:03,400
Así que la estrategia
más sencilla es poner, make hello.

246
00:10:03,400 --> 00:10:06,340
Y la razón por la que produce muchas
más palabras es porque lo tenemos,

247
00:10:06,340 --> 00:10:08,550
anticipándonos a las enseñanzas
del semestre, lo tenemos

248
00:10:08,550 --> 00:10:12,112
preconfigurado con líneas de comandos
argumentos, palabras adicionales,

249
00:10:12,112 --> 00:10:14,070
que esperamos
necesitar en algún momento.

250
00:10:14,070 --> 00:10:17,010
Esto nos ahorra la molestia de
andar dándole vueltas al manual

251
00:10:17,010 --> 00:10:18,090
para resolver ese tipo de cosas.

252
00:10:18,090 --> 00:10:19,380
Esa es la razón
por la que parece complejo,

253
00:10:19,380 --> 00:10:21,505
pero noten que esta es
la palabra más importante,

254
00:10:21,505 --> 00:10:24,340
hello seguido de hello.c,

255
00:10:24,340 --> 00:10:26,290
esos son sus dos ingredientes.

256
00:10:26,290 --> 00:10:26,790
Muy bien.

257
00:10:26,790 --> 00:10:30,400
Entonces, ¿qué está
pasando debajo del agua?

258
00:10:30,400 --> 00:10:33,750
Resulta que, aunque podemos
simplificar la estructura de comando,

259
00:10:33,750 --> 00:10:35,640
en realidad hace bastante por nosotros.

260
00:10:35,640 --> 00:10:37,470
Y es el proceso de compilación.

261
00:10:37,470 --> 00:10:41,310
Pero fue una especie de
simplificación excesiva, o asignarle más

262
00:10:41,310 --> 00:10:42,999
inteligencia, como una abstracción.

263
00:10:42,999 --> 00:10:46,290
De hecho tenemos algunos
pasos bajo la manga, por ejemplo,

264
00:10:46,290 --> 00:10:50,100
el procesamiento previo, la compilación,
el ensamblaje y la vinculación.

265
00:10:50,100 --> 00:10:52,002
Así que, adentrémonos rápido,

266
00:10:52,002 --> 00:10:54,960
pero vamos a abstraernos
para ver lo que está pasando.

267
00:10:54,960 --> 00:10:58,690
De ahora en adelante, podemos dar
por hecho que todo esto está sucediendo.

268
00:10:58,690 --> 00:11:01,500
Así que aquí está el código fuente,
el mismo programa con la versión

269
00:11:01,500 --> 00:11:03,060
más sencilla que teníamos
hace un momento.

270
00:11:03,060 --> 00:11:05,370
Y finalmente, necesito
obtener esto para el código máquina.

271
00:11:05,370 --> 00:11:09,150
Veamos si podemos visualizar
cómo llegamos del punto A al B

272
00:11:09,150 --> 00:11:12,600
sin abstraerlo por completo
con solo esas grandes flechas.

273
00:11:12,600 --> 00:11:14,300
Este es mi código fuente.

274
00:11:14,300 --> 00:11:17,100
Y resulta que
el primer paso

275
00:11:17,100 --> 00:11:21,690
de convertir el código fuente en
código de máquina en el mundo de C,

276
00:11:21,690 --> 00:11:23,760
lo ejecutar primero lo que
llamamos preprocesador.

277
00:11:23,760 --> 00:11:25,509
No haremos esto
explícitamente, aunque

278
00:11:25,509 --> 00:11:28,260
podríamos si tuviéramos un
nivel bajo y estuviéramos interesados.

279
00:11:28,260 --> 00:11:30,690
Esencialmente, lo que
el preprocesador hace

280
00:11:30,690 --> 00:11:35,010
es que al comenzar cualquier línea
de código lo hace con un signo de libra,

281
00:11:35,010 --> 00:11:39,540
o un hashtag actualmente, el cual
es un comando especial que será

282
00:11:39,540 --> 00:11:42,420
reemplazado con el contenido del
archivo, al menos en este caso.

283
00:11:42,420 --> 00:11:46,860
En algún sitio hay un
archivo llamado stdio.h.

284
00:11:46,860 --> 00:11:52,900
Entonces, #include significa obtener
ese archivo, copiarlo y pegarlo ahí.

285
00:11:52,900 --> 00:11:55,320
Así, cuando preprocesamos
nuestro código, esta línea amarilla

286
00:11:55,320 --> 00:11:57,570
se convierte en algo como esto.

287
00:11:57,570 --> 00:11:58,830
Y pongo "..."

288
00:11:58,830 --> 00:12:01,080
Tiene docenas, si no es que
cientos, de líneas de largo.

289
00:12:01,080 --> 00:12:04,230
Pero hay una línea especial
que es la pequeña pista de

290
00:12:04,230 --> 00:12:07,630
clang de que printf existe.

291
00:12:07,630 --> 00:12:09,540
Y es por eso que necesitamos stdio.h

292
00:12:09,540 --> 00:12:12,750
para nuestros propósitos de
todo lo que hace el preprocesador.

293
00:12:12,750 --> 00:12:15,514
Hace este tipo de hallazgo
y reemplaza operaciones de estilo

294
00:12:15,514 --> 00:12:17,430
para que ahora nuestro
archivo, sin que lo supiéramos,

295
00:12:17,430 --> 00:12:20,096
de repente se hiciera mucho más grande,
porque se añadieron otras líneas de código

296
00:12:20,096 --> 00:12:21,330
que alguien más escribió.

297
00:12:21,330 --> 00:12:24,870
Y nuestro código
permanece como era antes.

298
00:12:24,870 --> 00:12:31,290
El siguiente paso después de preprocesar
es la denominada autocompilación,

299
00:12:31,290 --> 00:12:34,410
en la que técnicamente
el compilador, si queremos

300
00:12:34,410 --> 00:12:36,720
ser quisquillosos y lo
vemos en su definición formal,

301
00:12:36,720 --> 00:12:41,400
al tomar estas líneas amarillas,
nuestro código fuente, y quizás el de

302
00:12:41,400 --> 00:12:44,820
alguien más se convierte en
algo llamado lenguaje ensamblador.

303
00:12:44,820 --> 00:12:47,640
Este es un tipo de lenguaje que
los seres humanos todavía utilizan,

304
00:12:47,640 --> 00:12:50,820
pero de vuelta al tema,
programaban con él.

305
00:12:50,820 --> 00:12:54,510
Si tienen una computadora con un
CPU Intel, un cerebro hecho por Intel,

306
00:12:54,510 --> 00:13:00,360
dentro de su computadora había,
y aún hay, un gran manual de usuario

307
00:13:00,360 --> 00:13:04,080
que le dice a los programadores de todo
el mundo que este CPU Intel entiende

308
00:13:04,080 --> 00:13:07,650
las siguientes instrucciones:
sumar, restar, multiplicar, dividir,

309
00:13:07,650 --> 00:13:11,250
todo lo básico, y luego cosas
como mover números de aquí a acá,

310
00:13:11,250 --> 00:13:13,950
leer los números desde aquí hasta
aquí, solo cambian las cosas de sitio

311
00:13:13,950 --> 00:13:15,430
en la memoria de la computadora.

312
00:13:15,430 --> 00:13:17,850
Y así, aun cuando esto
parece misterioso, incluso

313
00:13:17,850 --> 00:13:21,460
para mí, ya que no soy ningún
experto en lenguaje ensamblador,

314
00:13:21,460 --> 00:13:24,510
sin duda, todos estos años después,
aún podemos ver palabras con un sonido

315
00:13:24,510 --> 00:13:29,910
familiar, como "mov" que sugiere
mover un valor de una ubicación a otra,

316
00:13:29,910 --> 00:13:33,406
sub se refiere a la sustracción,
es decir, restar un número a otro.

317
00:13:33,406 --> 00:13:35,530
Y si no se piensa
en esto cuidadosamente,

318
00:13:35,530 --> 00:13:37,630
aún no estoy muy
seguro de lo que pasará.

319
00:13:37,630 --> 00:13:40,680
Pero veo una palabra
familiar allá abajo llamada printf.

320
00:13:40,680 --> 00:13:44,040
Esto se resume en que una
computadora o compilador específico

321
00:13:44,040 --> 00:13:48,090
tomó a mi más amigable
código C y lo convirtió

322
00:13:48,090 --> 00:13:51,000
en algo un poco más cercano
a lo que una máquina entiende.

323
00:13:51,000 --> 00:13:52,590
Pero eso no es todo,
porque las máquinas solo

324
00:13:52,590 --> 00:13:53,714
entienden ceros y unos.

325
00:13:53,714 --> 00:13:56,240
Así que hay otro
paso llamado ensamblado.

326
00:13:56,240 --> 00:13:59,190
Y el proceso de ensamblado
toma el lenguaje ensamblador

327
00:13:59,190 --> 00:14:00,720
y lo convierte en ceros y unos.

328
00:14:00,720 --> 00:14:02,880
Ahora se redujeron a ceros y unos.

329
00:14:02,880 --> 00:14:07,020
Y lo que es increíble, si
desde el principio es interesante,

330
00:14:07,020 --> 00:14:10,422
cuando se ejecuta clang y se presiona
Enter, todo esto sucede al instante.

331
00:14:10,422 --> 00:14:12,630
y obtenemos estos
ceros y unos, esta salida.

332
00:14:12,630 --> 00:14:15,630
Pero dejé espacio del otro lado,
porque todo lo que hicimos

333
00:14:15,630 --> 00:14:21,000
fue convertir mi código, del código fuente
al código ensamblador, al código máquina.

334
00:14:21,000 --> 00:14:28,140
¿Qué necesitamos fusionar, por así
decirlo, para ese programa "Hello, world"?

335
00:14:28,140 --> 00:14:32,432
Sí, aún necesitamos algo como stdio, la
biblioteca I/O estándar que tiene a printf.

336
00:14:32,432 --> 00:14:34,890
El siguiente paso es
tomar muchos ceros y unos

337
00:14:34,890 --> 00:14:37,290
desde otro lugar en
el sistema y combinarlos

338
00:14:37,290 --> 00:14:41,490
hasta que este sea el archivo
que contenga a a.out o hello,

339
00:14:41,490 --> 00:14:42,900
como sea que hayamos
nombrado al programa.

340
00:14:42,900 --> 00:14:47,230
Eso, en definitiva, es lo que
la computadora entiende.

341
00:14:47,230 --> 00:14:49,560
Es un detalle de bajo nivel.

342
00:14:49,560 --> 00:14:52,119
Afortunadamente,
aprendimos en la primera lección

343
00:14:52,119 --> 00:14:55,410
esta noción de abstracción, es decir,
incluso mientras nos adentramos

344
00:14:55,410 --> 00:14:57,510
y entendemos
cómo se construye.

345
00:14:57,510 --> 00:15:01,680
A partir de ahora, cada minuto
en lo sucesivo, todo ese trabalenguas

346
00:15:01,680 --> 00:15:03,030
se convierte en compilación.

347
00:15:03,030 --> 00:15:05,760
Eso es lo que la mayoría de las personas
en el negocio de la programación

348
00:15:05,760 --> 00:15:07,990
conoce como compilación,
son todos esos pasos.

349
00:15:07,990 --> 00:15:09,323
Pero eso es todo lo que sucede.

350
00:15:09,323 --> 00:15:12,420
Se siente mágico, pero
paso a paso

351
00:15:12,420 --> 00:15:14,400
para acercamos a nuestro objetivo.

352
00:15:14,400 --> 00:15:17,046


353
00:15:17,046 --> 00:15:18,465
¿Preguntas?

354
00:15:18,465 --> 00:15:20,320
Se trata del nivel más bajo que veremos.

355
00:15:20,320 --> 00:15:22,024
¿Sí?

356
00:15:22,024 --> 00:15:26,892
PÚBLICO: ¿Por qué se tiene que
pasar del lenguaje ensamblador al 

357
00:15:26,892 --> 00:15:27,392
código máquina?

358
00:15:27,392 --> 00:15:28,860
¿Por qué no solo vamos
directo al código máquina?

359
00:15:28,860 --> 00:15:29,400
DAVID: Buena pregunta.

360
00:15:29,400 --> 00:15:32,220
¿Por qué tenemos que ir paso a paso, desde
el código fuente pasando por el lenguaje

361
00:15:32,220 --> 00:15:33,803
ensamblador y al final el código máquina?

362
00:15:33,803 --> 00:15:34,950
Nosotros definitivamente podríamos.

363
00:15:34,950 --> 00:15:38,310
Simplemente sucede que hay
muchos humanos en el mundo

364
00:15:38,310 --> 00:15:40,410
y mucha gente que trabaja
en diferentes proyectos.

365
00:15:40,410 --> 00:15:42,600
Y esta noción de
poner capas en el software

366
00:15:42,600 --> 00:15:45,420
por encima del otra persona,
y del de los demás, nos permite

367
00:15:45,420 --> 00:15:51,571
construir sistemas más complejos
mucho más limpios, por así decirlo.

368
00:15:51,571 --> 00:15:53,820
Existen diferentes tipos
de computadoras en el mundo.

369
00:15:53,820 --> 00:15:54,540
Hay Macs,

370
00:15:54,540 --> 00:15:56,100
Hay PCs que
incluso en estos días,

371
00:15:56,100 --> 00:15:58,058
son mucho más
parecidas internamente

372
00:15:58,058 --> 00:16:01,140
que las que existían en aquellos
tiempos, son diferentes CPU.

373
00:16:01,140 --> 00:16:03,360
Hay teléfonos que cuentan
con CPU muy diferentes.

374
00:16:03,360 --> 00:16:07,290
¿No sería genial si pudiera
escribir mis programas en un lenguaje

375
00:16:07,290 --> 00:16:11,550
y compilarlos en ceros y unos
que funcionaran en una Mac, en una PC,

376
00:16:11,550 --> 00:16:13,870
en un teléfono Android,
en un iPhone y en otros dispositivos?

377
00:16:13,870 --> 00:16:16,230
Y es por eso que al tener
estos tipo de capas diferentes,

378
00:16:16,230 --> 00:16:20,202
una persona o un grupo pueden
implementar el proceso de conversión de C

379
00:16:20,202 --> 00:16:20,910
al lenguaje ensamblador

380
00:16:20,910 --> 00:16:23,940
y alguien más puede tomar los
ceros y unos, en cierto sentido.


381
00:16:23,940 --> 00:16:26,070
O incluso, pueden
existir pasos intermedios.

382
00:16:26,070 --> 00:16:29,109
Los compiladores cuentan con front
ends, back ends y toda esta complejidad.

383
00:16:29,109 --> 00:16:30,900
Pero nos da ventajas
porque eso significa que

384
00:16:30,900 --> 00:16:34,920
podemos decidir cuáles son los tipos de
hardware que los soportan más fácilmente.

385
00:16:34,920 --> 00:16:36,750
Muy buena pregunta.

386
00:16:36,750 --> 00:16:38,501
¿Alguna otra pregunta?

387
00:16:38,501 --> 00:16:39,000
Ok.

388
00:16:39,000 --> 00:16:42,780
Después de esto,
consideraremos cualquier número

389
00:16:42,780 --> 00:16:45,580
de maneras en que
las cosas pueden salir mal.

390
00:16:45,580 --> 00:16:48,234
Sin duda para mí es
sencillo escribir hello, world,

391
00:16:48,234 --> 00:16:49,650
y hacer funcionar todo esto.

392
00:16:49,650 --> 00:16:51,941
E incluso cuando no sea así,
sé cómo solucionarlo rápidamente.

393
00:16:51,941 --> 00:16:53,821
Esto proviene de la
experiencia y la práctica.

394
00:16:53,821 --> 00:16:56,820
Proseguiré con un adelanto de
help50 y de otras dos herramientas

395
00:16:56,820 --> 00:17:00,420
que veremos para las series
de problemas, y que no necesariamente

396
00:17:00,420 --> 00:17:03,680
les enseñaran a escribir un
buen código, un código bueno y eficiente.

397
00:17:03,680 --> 00:17:06,930
Ahí es donde entran humanos,
compañeros, retroalimentaciones, secciones

398
00:17:06,930 --> 00:17:08,140
horas de trabajo extra y más,

399
00:17:08,140 --> 00:17:10,890
pero al menos escribiremos correctamente
un código según nuestras especificaciones,

400
00:17:10,890 --> 00:17:12,970
que esté bien diseñado
y que al menos se vea bien.

401
00:17:12,970 --> 00:17:18,599
Recuerden que el tercer ingrediente,
además de la veracidad y el estilo,

402
00:17:18,599 --> 00:17:20,550
será el diseño, que es algo que

403
00:17:20,550 --> 00:17:23,040
aprenderemos con
la práctica y los ejemplos.

404
00:17:23,040 --> 00:17:26,160
Recuerden que Check50 es
una herramienta que está en

405
00:17:26,160 --> 00:17:30,990
CS50 IDE, sé que no están familiarizados
y es lo que me permite hacer esto.

406
00:17:30,990 --> 00:17:33,360
Dejen reduzco esto
para volver a mi programa

407
00:17:33,360 --> 00:17:35,250
programa similar a hello, world.

408
00:17:35,250 --> 00:17:37,440
Ya no necesito la biblioteca CS50.

409
00:17:37,440 --> 00:17:39,090
Puedo ejecutar make hello.

410
00:17:39,090 --> 00:17:39,859
Parece que funciona.

411
00:17:39,859 --> 00:17:42,150
¿Cómo van a comprobar
sus programas si escriben

412
00:17:42,150 --> 00:17:43,520
esto para una serie de problemas?

413
00:17:43,520 --> 00:17:45,936
Bueno, la forma más
fácil y directa, por supuesto,

414
00:17:45,936 --> 00:17:47,820
 es ejecutarlo.

415
00:17:47,820 --> 00:17:49,350
Parece que es correcto,

416
00:17:49,350 --> 00:17:50,042
y lo es.

417
00:17:50,042 --> 00:17:52,500
No hay mucho que pueda
salir mal en este programa.

418
00:17:52,500 --> 00:17:54,249
Pronto verán, en la
serie de problemas uno

419
00:17:54,249 --> 00:17:56,100
y en las siguientes, que siempre
que comiencen a recibir información

420
00:17:56,100 --> 00:17:58,680
de un usuario, este tiene
que escribir su nombre o un

421
00:17:58,680 --> 00:18:02,310
número u otras cosas con los
que podamos inventar escenarios

422
00:18:02,310 --> 00:18:03,600
cuando algo salga mal.

423
00:18:03,600 --> 00:18:07,750
Si ejecutamos un comando, en este caso
check50, podremos hacer lo siguiente.

424
00:18:07,750 --> 00:18:11,760
Primero crearé
un directorio llamado...

425
00:18:11,760 --> 00:18:15,200
A continuación
voy a escribir mkdir

426
00:18:15,200 --> 00:18:16,530
para crear el directorio, hello.

427
00:18:16,530 --> 00:18:18,280
No vimos
esto el otro día,

428
00:18:18,280 --> 00:18:20,529
pero lo veremos en las
excelentes secciones de hoy,

429
00:18:20,529 --> 00:18:22,980
o en las secciones de todas
las clases, que también serán filmadas.

430
00:18:22,980 --> 00:18:25,910
Solo moveré este archivo
a un directorio llamado hello.

431
00:18:25,910 --> 00:18:28,410
Eso es como en una Mac o PC,
simplemente arrastran y sueltan,

432
00:18:28,410 --> 00:18:30,000
pero esta vez
lo hago con mi teclado.

433
00:18:30,000 --> 00:18:33,360
¿Cuál es el comando para
cambiar a otro directorio? cd.

434
00:18:33,360 --> 00:18:35,430
Es como hacer doble
clic en un directorio,

435
00:18:35,430 --> 00:18:37,560
aunque desde mi teclado.

436
00:18:37,560 --> 00:18:41,040
A continuación ejecutaré esto.

437
00:18:41,040 --> 00:18:43,020
Puedo ejecutar de nuevo make hello

438
00:18:43,020 --> 00:18:43,830
y parece que funciona.

439
00:18:43,830 --> 00:18:45,630
Y puedo ejecutar ./hello,

440
00:18:45,630 --> 00:18:46,330
y parece que funciona.

441
00:18:46,330 --> 00:18:48,450
Ahora veamos si
CS50 está de acuerdo,

442
00:18:48,450 --> 00:18:49,800
así que escribo check50,

443
00:18:49,800 --> 00:18:54,240
después escribiré
cs50/2017/fall/hello,

444
00:18:54,240 --> 00:18:56,940
lo cual parecen muchas
carpetas, pero no lo son,

445
00:18:56,940 --> 00:19:00,060
es solo un identificador único
que tiene algún tipo de jerarquía.

446
00:19:00,060 --> 00:19:03,240
Solo sabríamos escribirlo
al leer la serie de problemas

447
00:19:03,240 --> 00:19:05,160
que se especifican en línea,

448
00:19:05,160 --> 00:19:07,740
Y lo que esto hará,
si no lo han visto antes,

449
00:19:07,740 --> 00:19:10,510
es conectarse al servidor de CS50.

450
00:19:10,510 --> 00:19:12,810
Nos autenticará,
si aún no lo han hecho.

451
00:19:12,810 --> 00:19:18,090
Luego iniciaré
sesión como student50

452
00:19:18,090 --> 00:19:20,104
y de ahora en adelante 
recordará mi contraseña,

453
00:19:20,104 --> 00:19:22,020
al menos por un
tiempo no tendremos

454
00:19:22,020 --> 00:19:23,730
que escribirla
cada vez que entremos.

455
00:19:23,730 --> 00:19:25,080
Se está preparando,

456
00:19:25,080 --> 00:19:26,100
está cargando.

457
00:19:26,100 --> 00:19:28,230
Y lo que sucede ahora
es que mi archivo hello.c,

458
00:19:28,230 --> 00:19:30,510
está en algún lugar de la nube,
en los servidores de CS50.

459
00:19:30,510 --> 00:19:33,360
Ejecutamos los checks, las
pruebas que el personal escribió.

460
00:19:33,360 --> 00:19:37,097
Y con suerte veré muchas
caras verdes sonrientes

461
00:19:37,097 --> 00:19:38,930
que lucen un poco
amarillas en este proyector,

462
00:19:38,930 --> 00:19:40,740
pero que son, de hecho,
caras verdes sonrientes

463
00:19:40,740 --> 00:19:43,990
en vez de caras con el ceño fruncido,
que sugerirían que algo está mal,

464
00:19:43,990 --> 00:19:44,820
por lo tanto está bien.

465
00:19:44,820 --> 00:19:47,280
No se desanimen si ven
algunas caras con el ceño fruncido,

466
00:19:47,280 --> 00:19:50,700
o algunas caras sin expresión o confusas
que denotan que algo más está mal.

467
00:19:50,700 --> 00:19:52,890
Pero style50 hace algo diferente,

468
00:19:52,890 --> 00:19:55,080
en este momento,
el estilo de mi código luce

469
00:19:55,080 --> 00:19:58,740
bastante bien porque es difícil
equivocarse cuando es algo tan corto.

470
00:19:58,740 --> 00:19:59,820
Pero ya lo veremos.

471
00:19:59,820 --> 00:20:03,960
Y si ejecuto style50 hello.c,
que es el nombre del archivo que deseo

472
00:20:03,960 --> 00:20:04,560
verificar,

473
00:20:04,560 --> 00:20:06,750
se ve bien, pero veremos
si agrega más comentarios.

474
00:20:06,750 --> 00:20:09,875
Es bastante convincente
porque no hay en este momento,

475
00:20:09,875 --> 00:20:12,000
entonces, ¿qué tipo de
comentarios les gustaría agregar?

476
00:20:12,000 --> 00:20:19,500
Bueno, en este programa no es
obligatorio agregar muchos comentarios

477
00:20:19,500 --> 00:20:23,190
porque la realidad es que el programa es
tan corto que probablemente me lleve

478
00:20:23,190 --> 00:20:25,116
menos tiempo leer
el código que los comentarios.

479
00:20:25,116 --> 00:20:27,240
Pero es muy común,
como verán en los ejemplos

480
00:20:27,240 --> 00:20:30,150
de la lección,
hacer algo como esto,

481
00:20:30,150 --> 00:20:33,752
"Di hola al usuario", es solo un
resumen rápido de una línea para que

482
00:20:33,752 --> 00:20:36,460
cuando echen un vistazo al archivo o
miren el código digan, Ok, lo tengo,

483
00:20:36,460 --> 00:20:37,376
sé lo que hace esto.

484
00:20:37,376 --> 00:20:40,379
Y si me interesa saber cómo
funciona, entonces puedo leer el código.

485
00:20:40,379 --> 00:20:41,670
Eso sería un comentario.

486
00:20:41,670 --> 00:20:46,410
Y eso probablemente hará
feliz, en este caso, a style50.

487
00:20:46,410 --> 00:20:49,230
Pero ¿y si me estoy
volviendo un poco descuidado?

488
00:20:49,230 --> 00:20:53,750
Recuerdo vagamente que tenía el hábito
de golpear la Tab o la tecla espaciadora

489
00:20:53,750 --> 00:20:54,270
en la lección.

490
00:20:54,270 --> 00:20:57,441
Pero no me molestaba en hacerlo cuando
trabajaba en mis series de problemas.

491
00:20:57,441 --> 00:20:59,190
Solo quería que
esa cosa funcionara.

492
00:20:59,190 --> 00:21:02,880
No es raro que el
código comience a verse así,

493
00:21:02,880 --> 00:21:04,890
a pesar de que el
programa es muy sencillo.

494
00:21:04,890 --> 00:21:07,950
El buen estilo, como lo verán
y lo aprenderán en la práctica,

495
00:21:07,950 --> 00:21:11,220
dicta que solo en Scratch dónde
había esas piezas de rompecabezas

496
00:21:11,220 --> 00:21:14,910
amarillas que abrazaban
al código como si fueran llaves,

497
00:21:14,910 --> 00:21:16,890
deberían verse sangrías.

498
00:21:16,890 --> 00:21:22,065
A continuación, olvidaré eso
y ejecutaré style50 en hello.c,

499
00:21:22,065 --> 00:21:25,440
veré que mi código envía
la salida a la ventana de

500
00:21:25,440 --> 00:21:27,150
terminal, en la parte inferior
de la pantalla.

501
00:21:27,150 --> 00:21:31,750
El verde sugiere hey, programador,
agrega los siguientes caracteres,

502
00:21:31,750 --> 00:21:33,670
entonces, el verde
sugiere agregarlos aquí.

503
00:21:33,670 --> 00:21:36,510
Ahora pondré una
sangría golpeando la tecla

504
00:21:36,510 --> 00:21:39,960
tab, específicamente cuatro espacios,
lo cual es una convención humana,

505
00:21:39,960 --> 00:21:41,280
que de nuevo debería hacerlo feliz.

506
00:21:41,280 --> 00:21:43,071
Sin embargo podemos
ir en la dirección opuesta.

507
00:21:43,071 --> 00:21:46,010
supongamos que estoy un poco
confundido en cuanto a lo que

508
00:21:46,010 --> 00:21:47,760
debería poner sangría,
e incluso podrían consultarlo

509
00:21:47,760 --> 00:21:49,551
en los libros de texto y
en algunos recursos en línea,

510
00:21:49,551 --> 00:21:51,900
algunas personas escriben su código así.

511
00:21:51,900 --> 00:21:54,922
Ahora, ejecutaré style50 en esto

512
00:21:54,922 --> 00:21:56,130
y se imprimirá mi código,

513
00:21:56,130 --> 00:21:59,190
y en este caso, el color rojo indica
que eliminemos esos caracteres

514
00:21:59,190 --> 00:22:00,635
que de otra manera
podríamos no ver.

515
00:22:00,635 --> 00:22:02,260
Por lo tanto,
no siempre será perfecto.

516
00:22:02,260 --> 00:22:03,810
Especialmente cuando
los programas son largos,

517
00:22:03,810 --> 00:22:06,220
podría no ser tan obvio notar
qué cambios se tienen que hacer.

518
00:22:06,220 --> 00:22:08,530
Pero al igual que con los mensajes
de error comiencen en la parte superior.

519
00:22:08,530 --> 00:22:10,230
Hagan uno o pocos cambios,

520
00:22:10,230 --> 00:22:13,386
guárdenlos, vuelvan a ejecutarlos, y
vean cuál es el consejo actualizado.

521
00:22:13,386 --> 00:22:16,010
No puedo enfatizar esto lo suficiente,
en especial con la serie de problemas uno

522
00:22:16,010 --> 00:22:18,510
y en cualquier serie de
problemas posteriores, no adquieran

523
00:22:18,510 --> 00:22:20,820
el hábito de
sentarse y tratar de

524
00:22:20,820 --> 00:22:23,020
abarcar la totalidad un problema.

525
00:22:23,020 --> 00:22:26,400
Posiblemente con Scratch no nos
sentamos y escribimos algo completamente

526
00:22:26,400 --> 00:22:30,720
sin jugar con él una vez,
probarlo o agregarle funciones.

527
00:22:30,720 --> 00:22:35,490
Entonces, no adquieran ese
hábito en C, y vayamos paso a paso

528
00:22:35,490 --> 00:22:39,240
como lo hemos hecho
hasta ahora con los ejemplos.

529
00:22:39,240 --> 00:22:39,880
Muy bien.

530
00:22:39,880 --> 00:22:42,770
¿Alguna pregunta
sobre esas herramientas?

531
00:22:42,770 --> 00:22:45,900
En un momento regresaremos
con unas técnicas de depuración

532
00:22:45,900 --> 00:22:47,261
más sofisticadas.

533
00:22:47,261 --> 00:22:47,760
Bien.

534
00:22:47,760 --> 00:22:52,770
Uno de los problemas con los que
nos distrajimos anteriormente

535
00:22:52,770 --> 00:22:54,810
son los juegos antiguos
como Súper Mario Bros.

536
00:22:54,810 --> 00:22:59,850
en donde un personaje como este
salta bastante por la pantalla.

537
00:22:59,850 --> 00:23:01,887
Es uno de los primeros
juegos de Nintendo, en donde

538
00:23:01,887 --> 00:23:05,220
existen muchos obstáculos en el camino
de Mario, mientras corre de un lado a otro

539
00:23:05,220 --> 00:23:06,030
y salta.

540
00:23:06,030 --> 00:23:08,010
Algunos de estos obstáculos
pueden ser representados

541
00:23:08,010 --> 00:23:12,420
con estructuras bastante sencillas,
como ladrillos, en un mundo colorido.

542
00:23:12,420 --> 00:23:15,810
Y podemos acercarnos a esto
al usar caracteres en nuestras

543
00:23:15,810 --> 00:23:16,560
pantallas.

544
00:23:16,560 --> 00:23:19,200
De hecho estuve curioseando
demasiado tiempo anoche

545
00:23:19,200 --> 00:23:21,960
viendo los viejos mapas de Súper
Mario Bros., como si los tuviera

546
00:23:21,960 --> 00:23:24,900
en la década de 1980, lo que habría hecho
mucho más fácil jugar Súper Mario Bros.

547
00:23:24,900 --> 00:23:28,200
La gente ha capturado todas
las imágenes de este juego.

548
00:23:28,200 --> 00:23:31,734
Y una imagen de este juego
era una pantalla como esta.

549
00:23:31,734 --> 00:23:33,900
Se supone que al final
Mario debe cruzar por aquí.

550
00:23:33,900 --> 00:23:36,566
Se supone que debe chocar con su
cabeza los signos de interrogación,

551
00:23:36,566 --> 00:23:37,870
obtener monedas
y cosas por el estilo.

552
00:23:37,870 --> 00:23:41,100
Por ahora voy a simplificar
realmente esto y mi propósito

553
00:23:41,100 --> 00:23:43,500
es cuidar el buen
camino de la discusión

554
00:23:43,500 --> 00:23:45,840
y concentrarme en los
signos de interrogación.

555
00:23:45,840 --> 00:23:49,290
¿Cómo haría en un programa de
computadora, ya sea Súper Mario Bros.

556
00:23:49,290 --> 00:23:53,670
o aquí en Sanders, para que imprimiera
una línea de signos de interrogación

557
00:23:53,670 --> 00:23:55,350
en una fila como esta?

558
00:23:55,350 --> 00:24:00,590
Bueno, ahora abriré CS50 IDE,

559
00:24:00,590 --> 00:24:03,570
luego crearé
aquí un nuevo archivo

560
00:24:03,570 --> 00:24:07,770
y después llamaré
a esto, digamos, mario0.c

561
00:24:07,770 --> 00:24:11,310
porque es el primero o la
versión cero de este programa.

562
00:24:11,310 --> 00:24:13,590
Y solo quiero imprimir
cuatro signos de interrogación.

563
00:24:13,590 --> 00:24:15,090
Probaré primero esto.

564
00:24:15,090 --> 00:24:21,042
#include stdio.h, ¿cuál
es el creo que necesito?

565
00:24:21,042 --> 00:24:21,930
PÚBLICO: ¿Printf?

566
00:24:21,930 --> 00:24:22,860
DAVID: Sí, necesito printf.

567
00:24:22,860 --> 00:24:24,568
Necesito ser capaz de
imprimir el carácter.

568
00:24:24,568 --> 00:24:26,470
Entonces, int main(void) es lo que sigue.

569
00:24:26,470 --> 00:24:28,950
Desde hoy por esa razón
comenzaremos a separar.

570
00:24:28,950 --> 00:24:31,080
Y ahora voy a
imprimir ????

571
00:24:31,080 --> 00:24:33,720


572
00:24:33,720 --> 00:24:34,731
después punto y coma.

573
00:24:34,731 --> 00:24:35,230
Muy bien.

574
00:24:35,230 --> 00:24:38,165
Ahora ejecutaré make mario0.

575
00:24:38,165 --> 00:24:39,630
./mario0.

576
00:24:39,630 --> 00:24:43,560
Tengo una especie de
representación textual muy fea

577
00:24:43,560 --> 00:24:46,530
de un juego que, al menos
al estilo de los ochenta, era divertido.

578
00:24:46,530 --> 00:24:48,060
Hay un pequeño error estético,

579
00:24:48,060 --> 00:24:49,851
y cometí este
mismo error el otro día.

580
00:24:49,851 --> 00:24:52,840
¿Cómo muevo mi cursor
a la siguiente línea?

581
00:24:52,840 --> 00:24:54,630
Sí, con \ n.

582
00:24:54,630 --> 00:24:58,344
La diagonal invertida es la que vamos a
escribir, y la diagonal derecha o diagonal

583
00:24:58,344 --> 00:25:00,610
es lo que la gente
llamaría la otra dirección.

584
00:25:00,610 --> 00:25:02,050
Esta es una \ n,

585
00:25:02,050 --> 00:25:05,880
y ese es un carácter especial
de escape, por así decirlo.

586
00:25:05,880 --> 00:25:09,430
Por ahora, solo sé que esto
comienza a confundir a la computadora,

587
00:25:09,430 --> 00:25:11,530
si simplemente presionamos Enter.

588
00:25:11,530 --> 00:25:13,570
Ahora, nuestro código está en dos
líneas, cuando en realidad es

589
00:25:13,570 --> 00:25:15,590
solo una idea o una función.

590
00:25:15,590 --> 00:25:19,311
Los humanos decidieron hace un tiempo
que representarían ese carácter especial

591
00:25:19,311 --> 00:25:21,310
que ahora ustedes
solo presionan en el teclado.

592
00:25:21,310 --> 00:25:23,960
Ahora, si vuelvo a ejecutar make mario0.

593
00:25:23,960 --> 00:25:25,450
./mario0.

594
00:25:25,450 --> 00:25:27,250
Ok, ahora luce un poco mejor.

595
00:25:27,250 --> 00:25:30,907
Sabemos desde el inicio que no solo
necesitamos más de un signo de interrogación,

596
00:25:30,907 --> 00:25:32,740
interrogación,
interrogación, interrogación,

597
00:25:32,740 --> 00:25:36,290
especialmente si quiero tener aún
más monedas disponibles en la pantalla.

598
00:25:36,290 --> 00:25:39,180
¿Cuál es la construcción de programación
correcta que me da más de esto?

599
00:25:39,180 --> 00:25:39,980
PÚBLICO: Un bucle for.

600
00:25:39,980 --> 00:25:41,730
DAVID: Sí, algo como
un bucle for, ¿verdad?

601
00:25:41,730 --> 00:25:44,410
A continuación
ajustaré esto un poco.

602
00:25:44,410 --> 00:25:48,910
Y luego pondré,
digamos, mario1.c,

603
00:25:48,910 --> 00:25:52,210
entonces, en vez de mario1.c,
pondré lo siguiente

604
00:25:52,210 --> 00:25:55,600
Así que, for int,
para que me dé un entero,

605
00:25:55,600 --> 00:25:59,650
i = 0; de manera predeterminada,
aunque podría ser 1,

606
00:25:59,650 --> 00:26:02,176
pero los programadores
tienden a usar 0,

607
00:26:02,176 --> 00:26:04,615
i menor que...

608
00:26:04,615 --> 00:26:07,240
no estoy seguro, así que pongamos una
gran línea en blanco por un momento,

609
00:26:07,240 --> 00:26:09,860
y luego i++, porque recuerdo
que es la manera de sumar.

610
00:26:09,860 --> 00:26:15,280
Después, dentro
de este bucle, pondré printf ("?")

611
00:26:15,280 --> 00:26:16,900
punto y coma.

612
00:26:16,900 --> 00:26:18,910
Ahora respondamos esta pregunta,

613
00:26:18,910 --> 00:26:22,660
si este bucle, el cual tiene
un proceso muy metódico,

614
00:26:22,660 --> 00:26:27,550
inicializa, verifica
la condición, hace algo,

615
00:26:27,550 --> 00:26:31,210
incrementa, verifica
la condición, repite una y otra vez.

616
00:26:31,210 --> 00:26:34,303
¿Qué número debo poner
sobre la línea en blanco?

617
00:26:34,303 --> 00:26:35,110
PÚBLICO: Cuatro.

618
00:26:35,110 --> 00:26:35,984
DAVID: Entonces cuatro.

619
00:26:35,984 --> 00:26:40,720
Pero si estoy contando de 0 a 4,
parece como si fueran cinco números.

620
00:26:40,720 --> 00:26:44,050
Así que, tres podrían quedarme
más cerca, pero hay un menor que.

621
00:26:44,050 --> 00:26:45,880
Tenemos este operador relacional,

622
00:26:45,880 --> 00:26:48,430
menor que, pudo ser
mayor que en otros contextos.

623
00:26:48,430 --> 00:26:50,680
Menor que en realidad nos salva.

624
00:26:50,680 --> 00:26:55,090
Si tengo for aquí, piensen
lógicamente lo que está sucediendo.

625
00:26:55,090 --> 00:26:57,640
Inicializamos en
0 por primera vez.

626
00:26:57,640 --> 00:26:59,470
Obtenemos un signo de
interrogación impreso.

627
00:26:59,470 --> 00:27:03,610
Entonces obtiene ++, y se
convierte en 1, que es menor que 4.

628
00:27:03,610 --> 00:27:07,040
Esa es la primera vez que
imprimí un signo de interrogación.

629
00:27:07,040 --> 00:27:08,800
Entonces i se convierte en 1, después

630
00:27:08,800 --> 00:27:10,490
imprimo otro,

631
00:27:10,490 --> 00:27:13,600
i ahora es 1.

632
00:27:13,600 --> 00:27:14,770
Añado otro

633
00:27:14,770 --> 00:27:15,560
i ahora es 2.

634
00:27:15,560 --> 00:27:16,690
Añado otro,

635
00:27:16,690 --> 00:27:19,510
i ahora es tres, lo cual no es
consistente con la cantidad de dedos

636
00:27:19,510 --> 00:27:21,550
Lo sostengo porque comencé en 0.

637
00:27:21,550 --> 00:27:26,830
Una vez que i llega a 3, y por lo tanto
ya imprimí mis cuatro interrogaciones,

638
00:27:26,830 --> 00:27:30,340
el siguiente valor que i
tomará es el mismo 4.

639
00:27:30,340 --> 00:27:32,210
¿4 es menor que 4?

640
00:27:32,210 --> 00:27:34,930
No, entonces ya no puedo
imprimir otro signo de interrogación,

641
00:27:34,930 --> 00:27:36,490
ni de levantar otro dedo.

642
00:27:36,490 --> 00:27:39,670
Sinceramente, es un
desperdicio de capacidad intelectual

643
00:27:39,670 --> 00:27:42,220
pensar, Ok, ¿cuántos
números están entre 0 y 4?

644
00:27:42,220 --> 00:27:45,370
Podríamos tener, como la
mayoría de los que están aquí piensa,

645
00:27:45,370 --> 00:27:48,640
podríamos hacer
que i sea menor o igual a 4,

646
00:27:48,640 --> 00:27:50,410
y habría funcionado.

647
00:27:50,410 --> 00:27:51,910
Tal vez esto es aún más claro,

648
00:27:51,910 --> 00:27:56,140
porque comenzamos en 1
y contamos hasta el número 4.

649
00:27:56,140 --> 00:27:58,330
Y eso también me
dará cuatro dedos.

650
00:27:58,330 --> 00:27:59,920
¿Por qué empezamos a contar en 0?

651
00:27:59,920 --> 00:28:02,230
Es solo porque,
técnicamente, es más sencillo

652
00:28:02,230 --> 00:28:06,790
comenzar a contar con todos los
bits en 0, desde nuestra primera lección.

653
00:28:06,790 --> 00:28:07,780
Así que, es solo un hábito.

654
00:28:07,780 --> 00:28:09,910
Y está bien, si se sienten
más cómodos de esta manera.

655
00:28:09,910 --> 00:28:12,400
En poco tiempo,
esto se vuelve un hábito

656
00:28:12,400 --> 00:28:15,250
porque todos los demás
lo hacen de esta manera.

657
00:28:15,250 --> 00:28:17,740
OK, a continuación
imprimiré esto.

658
00:28:17,740 --> 00:28:20,570
make mario1.

659
00:28:20,570 --> 00:28:22,630
./mario1.

660
00:28:22,630 --> 00:28:25,480
Ah, todavía está ese error.

661
00:28:25,480 --> 00:28:28,810
OK, ¿esto lo arreglará?

662
00:28:28,810 --> 00:28:29,320
¿Por qué no?

663
00:28:29,320 --> 00:28:31,840


664
00:28:31,840 --> 00:28:34,930
Sí, eso pondrá interrogación,
nueva línea, interrogación, nueva línea.

665
00:28:34,930 --> 00:28:35,710
No está bien.

666
00:28:35,710 --> 00:28:39,340
¿En cuál número de línea
debería ir realmente la \ n?

667
00:28:39,340 --> 00:28:41,261
PÚBLICO: Debería
ir fuera del bucle for.

668
00:28:41,261 --> 00:28:43,510
DAVID: OK, entonces
debería ir fuera del bucle for.

669
00:28:43,510 --> 00:28:45,030
Vi una mano
atrás en específico,

670
00:28:45,030 --> 00:28:45,940
¿En cuál número de línea?

671
00:28:45,940 --> 00:28:46,440
Sí.

672
00:28:46,440 --> 00:28:47,120
PÚBLICO: ¿Ocho y nueve?

673
00:28:47,120 --> 00:28:48,760
DAVID: Sí, entre la
ocho y la nueve.

674
00:28:48,760 --> 00:28:49,930
En este momento no hay espacio,

675
00:28:49,930 --> 00:28:50,770
pero no hay problema.

676
00:28:50,770 --> 00:28:52,360
Presionaremos Enter, printf.

677
00:28:52,360 --> 00:28:54,899
Y puedo, ciertamente,
poner una simple \ n,

678
00:28:54,899 --> 00:28:56,440
incluso sin poner
palabras a la izquierda.

679
00:28:56,440 --> 00:28:57,490
Esto está bien.

680
00:28:57,490 --> 00:28:58,480
Voy a recompilar esto,

681
00:28:58,480 --> 00:29:01,450
si les aburre escribir de nuevo
los mismos comandos,

682
00:29:01,450 --> 00:29:04,110
también pueden usar su
teclado para subir y bajar

683
00:29:04,110 --> 00:29:06,290
y esto les mostrará
su historial, por así decirlo.

684
00:29:06,290 --> 00:29:08,510
Y con el paso de los días
comenzarán a ahorrar tiempo.

685
00:29:08,510 --> 00:29:10,080
Así que tenemos make mario1.

686
00:29:10,080 --> 00:29:10,750
Enter.

687
00:29:10,750 --> 00:29:15,354
./mario1, o me desplazo
hacia atrás, como lo hice antes.

688
00:29:15,354 --> 00:29:17,020
Ahora obtengo esos cuatro
signos de interrogación.

689
00:29:17,020 --> 00:29:20,930
Haré esto un poco más
interesante, de la siguiente manera.

690
00:29:20,930 --> 00:29:24,070
Ahora continuaré solamente y no solo
aplicaré el hardcode 4 en este programa.

691
00:29:24,070 --> 00:29:28,390
Seguiré con una versión más
de Mario, a la que llamé mario2.c,

692
00:29:28,390 --> 00:29:30,820
que esta vez obtiene
alguna entrada del usuario.

693
00:29:30,820 --> 00:29:34,420
Qué tal si pongo int n,
porque es como un número

694
00:29:34,420 --> 00:29:36,910
y es una convención
bastante común llamarlo así.

695
00:29:36,910 --> 00:29:41,890
y luego podemos poner
get_int("Number: ");

696
00:29:41,890 --> 00:29:44,560
y luego, en vez de aplicar un
hardcoding 4, ¿por qué no pongo n?

697
00:29:44,560 --> 00:29:46,930
lo cual puedo hacer,
sin duda alguna.

698
00:29:46,930 --> 00:29:50,110
Ahora ejecutaré make mario2.

699
00:29:50,110 --> 00:29:52,210
Oh, oh.

700
00:29:52,210 --> 00:29:53,780
Error.

701
00:29:53,780 --> 00:29:56,740
Sí, se me olvidó cs50.h.

702
00:29:56,740 --> 00:29:58,300
Tengo que volver arriba.

703
00:29:58,300 --> 00:30:02,991
Solo haré una copia rápida, pegaré,
y luego cambiaré la palabra cs50.h.

704
00:30:02,991 --> 00:30:04,240
Ahora limpiaré mi pantalla.

705
00:30:04,240 --> 00:30:06,239
Y para limpiarla, podemos
presionar Control+l,

706
00:30:06,239 --> 00:30:09,580
por ejemplo, eso dejará menos
caracteres en nuestra pantalla.

707
00:30:09,580 --> 00:30:10,530
make mario2.

708
00:30:10,530 --> 00:30:11,110
Funcionó.

709
00:30:11,110 --> 00:30:14,915
No necesité preocuparme por -lcs50 
porque, una vez más, make hace eso por mí,

710
00:30:14,915 --> 00:30:16,040
es una de sus características.

711
00:30:16,040 --> 00:30:18,070
Y ahora puedo
ejecutar make mario2.

712
00:30:18,070 --> 00:30:18,580
Number:

713
00:30:18,580 --> 00:30:20,039
¿Cuántos signos de
interrogación queremos?

714
00:30:20,039 --> 00:30:20,704
PÚBLICO: Siete.

715
00:30:20,704 --> 00:30:22,120
DAVID: Escuché primero siete

716
00:30:22,120 --> 00:30:23,830
y ahora tenemos siete
signos de interrogación.

717
00:30:23,830 --> 00:30:25,871
Y no necesariamente
se va a ver súper bonito.

718
00:30:25,871 --> 00:30:28,390
Si pongo 700,
obtendré muchísimos.

719
00:30:28,390 --> 00:30:30,580
Pero miren lo rápido
que lo hizo para mí.

720
00:30:30,580 --> 00:30:32,870
Ahora tenemos
este poder de los bucles.

721
00:30:32,870 --> 00:30:36,940
Eso está bien pero,
¿saben qué?

722
00:30:36,940 --> 00:30:38,330
Veamos, ¿qué pasa con esto?

723
00:30:38,330 --> 00:30:43,210
¿Qué pasa si es negativo y hay
-50 signos de interrogación?

724
00:30:43,210 --> 00:30:44,540
¿El 50 negativo es un int?

725
00:30:44,540 --> 00:30:45,359
PÚBLICO: Sí.

726
00:30:45,359 --> 00:30:46,150
DAVID: Sí, lo es.

727
00:30:46,150 --> 00:30:50,980
entonces, los obtendremos
por medio de la función get_int,

728
00:30:50,980 --> 00:30:52,510
realmente no es
lógico lo que queremos,

729
00:30:52,510 --> 00:30:53,260
así que piensen en ello.

730
00:30:53,260 --> 00:31:00,744
En la línea 7, si n es igual a -50,
¿cuántas veces se ejecutará el bucle?

731
00:31:00,744 --> 00:31:02,360
PÚBLICO: Ninguna.

732
00:31:02,360 --> 00:31:04,102
DAVID: ¿Por qué ninguna?

733
00:31:04,102 --> 00:31:05,560
PÚBLICO: Porque
el 0 es mayor.

734
00:31:05,560 --> 00:31:08,960
DAVID: Sí, porque en este
caso 0 es mayor que -50.

735
00:31:08,960 --> 00:31:12,640
Entonces esa condición nunca permitirá
que el bucle se ejecute lógicamente.

736
00:31:12,640 --> 00:31:14,430
Entonces, Ok,

737
00:31:14,430 --> 00:31:15,430
Parece que nada ocurre,

738
00:31:15,430 --> 00:31:17,230
solo obtengo esta
horrible línea en blanco.

739
00:31:17,230 --> 00:31:18,880
Posiblemente sea un error,

740
00:31:18,880 --> 00:31:22,510
pero al menos no congeló la
computadora e imprimió cosas

741
00:31:22,510 --> 00:31:25,750
un infinito número de veces,
como en realidad podría pasar.

742
00:31:25,750 --> 00:31:29,500
Ahora voy a arriesgarme

743
00:31:29,500 --> 00:31:33,850
a perder el control de mi
computadora y cambiaremos la lógica.

744
00:31:33,850 --> 00:31:36,470
Supongamos que cambio
el menor que por un mayor que,

745
00:31:36,470 --> 00:31:38,800
e iniciamos n en -50.

746
00:31:38,800 --> 00:31:42,370
Ahora, ¿0 es mayor que -50?

747
00:31:42,370 --> 00:31:43,012
PÚBLICO: Sí.

748
00:31:43,012 --> 00:31:43,720
DAVID: Sí.

749
00:31:43,720 --> 00:31:47,620
Y lo más probable es que
sea así por mucho tiempo,

750
00:31:47,620 --> 00:31:49,120
incluso si lo incrementamos.

751
00:31:49,120 --> 00:31:54,580
Ahora ejecutaré make mario2
y aguantaré la respiración,

752
00:31:54,580 --> 00:31:57,280
pongo -50.

753
00:31:57,280 --> 00:32:00,337
Pero incluso las computadoras y el
Internet no se actualizan constantemente.

754
00:32:00,337 --> 00:32:02,920
Esa es la razón de que
veamos una ráfaga como esta.

755
00:32:02,920 --> 00:32:06,370
Estamos enviando miles, decenas
de miles, y a la larga, millones

756
00:32:06,370 --> 00:32:07,870
de signos de interrogación
a través de la pantalla.

757
00:32:07,870 --> 00:32:09,760
Y esto también podría
pasarnos por error.

758
00:32:09,760 --> 00:32:13,630
Y como yo, pueden usar la combinación
secreta que casi siempre funciona,

759
00:32:13,630 --> 00:32:15,700
la cual es Control-C para cancelar.

760
00:32:15,700 --> 00:32:18,471
Eso detendrá la ejecución
de un programa en la ventana.

761
00:32:18,471 --> 00:32:18,970
Muy bien.

762
00:32:18,970 --> 00:32:20,980
De modo que me he
adelantado e implementé

763
00:32:20,980 --> 00:32:23,470
una aproximación
muy débil de esto.

764
00:32:23,470 --> 00:32:24,220
Lo cual es genial.

765
00:32:24,220 --> 00:32:27,669
Ahora, demos un paso adelante
y no solo examinemos este constructo,

766
00:32:27,669 --> 00:32:30,460
más bien avancemos rápidamente
en el juego, a esta parte de la pantalla,

767
00:32:30,460 --> 00:32:32,360
ahora tal vez tengamos
también un bloque vertical.

768
00:32:32,360 --> 00:32:34,690
Y pensemos por un momento,
¿qué pasa si necesito modificar

769
00:32:34,690 --> 00:32:40,720
mi código? ¿si deseo que ponga tres o
cualquier número de bloques verticales?

770
00:32:40,720 --> 00:32:44,215
Básicamente, ¿cómo
quiero que cambie el código?

771
00:32:44,215 --> 00:32:45,590
¿Cómo quiero
que cambie el código?

772
00:32:45,590 --> 00:32:46,090
Sí.

773
00:32:46,090 --> 00:32:47,050
PÚBLICO: [INAUDIBLE]

774
00:32:47,050 --> 00:32:50,216
DAVID: Sí, solo necesito un salto
de línea donde por error casi lo puse

775
00:32:50,216 --> 00:32:50,770
antes.

776
00:32:50,770 --> 00:32:52,561
Pero en este caso,
sería algo bueno.

777
00:32:52,561 --> 00:32:55,640
Después ejecutaré
rápidamente make mario3

778
00:32:55,640 --> 00:32:56,890
comenzando
desde el mismo punto.

779
00:32:56,890 --> 00:32:59,080
Entonces, mario3.c.

780
00:32:59,080 --> 00:33:03,154
Luego iré aquí y cambiaré
esto de la siguiente manera.

781
00:33:03,154 --> 00:33:06,070
Hagamos que i sea menor que n,
como se supone que debe ser,

782
00:33:06,070 --> 00:33:09,040
de modo que no lo olvidemos,
si lo cargamos más tarde.

783
00:33:09,040 --> 00:33:12,130
Y ahora pondré solo un #,
porque se parece más a un ladrillo.

784
00:33:12,130 --> 00:33:13,960
No es una de esas
cosas con monedas.

785
00:33:13,960 --> 00:33:15,280
Y luego hago esto aquí.

786
00:33:15,280 --> 00:33:17,780
Creo que ya no necesitaré esto.

787
00:33:17,780 --> 00:33:21,100
Ahora lo guardaré
y ejecutaré make mario3

788
00:33:21,100 --> 00:33:26,809
Parece estar bien y que se compila
sabiamente, ./mario3, Number: 3

789
00:33:26,809 --> 00:33:27,850
Y consigo tres de esos.

790
00:33:27,850 --> 00:33:29,590
Ahora tal vez podría
hacer que fueran cinco.

791
00:33:29,590 --> 00:33:31,340
Eso funciona y así sucesivamente.

792
00:33:31,340 --> 00:33:34,990
Todavía hay una
oportunidad para mejorarlo,

793
00:33:34,990 --> 00:33:40,630
en caso de que quiera molestar
al usuario para que coopere,

794
00:33:40,630 --> 00:33:44,044
de modo que si escribe en -50,
no quiero que simplemente renuncie.

795
00:33:44,044 --> 00:33:46,210
Quiero gritarle, o de alguna
manera darle retroalimentación,

796
00:33:46,210 --> 00:33:48,880
y decirle, dame lo que te pedí.

797
00:33:48,880 --> 00:33:51,940
¿Cómo molesto a
un usuario una y otra

798
00:33:51,940 --> 00:33:55,481
y otra vez hasta que me
dé el valor que quiero?

799
00:33:55,481 --> 00:33:55,980
¿Perdón?

800
00:33:55,980 --> 00:33:56,969
PÚBLICO: Con while.

801
00:33:56,969 --> 00:33:57,760
DAVID: Con while.

802
00:33:57,760 --> 00:33:59,450
Entonces hay diferentes
construcciones de bucle

803
00:33:59,450 --> 00:34:02,890
como while, y parece que
podríamos usar while, incluso for

804
00:34:02,890 --> 00:34:04,580
o también existe otro.

805
00:34:04,580 --> 00:34:06,350
Analicemos cómo puede hacerse.

806
00:34:06,350 --> 00:34:09,909
Resulta que si queremos obtener
la entrada de un usuario, de alguien,

807
00:34:09,909 --> 00:34:11,170
podemos utilizar for

808
00:34:11,170 --> 00:34:12,326
o también while.

809
00:34:12,326 --> 00:34:15,159
Pero descubriremos que es un poco
fastidioso usar esas construcciones.

810
00:34:15,159 --> 00:34:19,630
Primero veremos la mejor
manera y luego veremos otra.

811
00:34:19,630 --> 00:34:24,310
Si queremos que un programa
haga algo al menos una vez,

812
00:34:24,310 --> 00:34:28,150
o tal vez más veces,
podríamos utilizar for o while.

813
00:34:28,150 --> 00:34:32,830
Pero en realidad es un poco
más sencillo si ponemos

814
00:34:32,830 --> 00:34:37,120
while (_______); algo sea cierto.

815
00:34:37,120 --> 00:34:38,650
Ahora, esto solo es solo
un marcador de posición.

816
00:34:38,650 --> 00:34:40,580
Ahora comenzaré
a llenarlo con cierta lógica.

817
00:34:40,580 --> 00:34:46,449
Entonces quiero decir,
haz lo siguiente mientras ¿qué?

818
00:34:46,449 --> 00:34:49,870
Si el usuario no me
da un número positivo,

819
00:34:49,870 --> 00:34:52,210
quiero inducirlo nuevamente.

820
00:34:52,210 --> 00:34:56,440
Por el momento las llaves en las líneas
siete y nueve indican exactamente eso.

821
00:34:56,440 --> 00:35:02,590
Haz esto, haz esto, haz esto,
mientras la línea 10 sea verdadera.

822
00:35:02,590 --> 00:35:06,670
¿cuál expresión booleana, por así
decirlo, escribiría en los paréntesis

823
00:35:06,670 --> 00:35:11,790
de la línea 10 para pedir
que siga haciendo lo mismo

824
00:35:11,790 --> 00:35:13,231
hasta que el número sea positivo?

825
00:35:13,231 --> 00:35:13,730
¿Sí?

826
00:35:13,730 --> 00:35:15,690
PÚBLICO: Mientras n
sea mayor que 0.

827
00:35:15,690 --> 00:35:21,680
DAVID: Eso sería:
while (n > 0), sigue haciendo...

828
00:35:21,680 --> 00:35:22,180
¿Cuál?

829
00:35:22,180 --> 00:35:23,130
PÚBLICO: Menor que.

830
00:35:23,130 --> 00:35:24,421
DAVID: Escuché menor que.

831
00:35:24,421 --> 00:35:25,680
OK, vamos a
reconsiderarlo.

832
00:35:25,680 --> 00:35:30,627
While (n < 0); pídele
un número al usuario,

833
00:35:30,627 --> 00:35:31,710
pídele un número al usuario,

834
00:35:31,710 --> 00:35:32,640
pídele un número al usuario.

835
00:35:32,640 --> 00:35:33,310
Pero ¿saben algo?

836
00:35:33,310 --> 00:35:35,435
Esto solo va
a enredarlo todo.

837
00:35:35,435 --> 00:35:37,440
Seamos aún más
claros en nuestra petición.

838
00:35:37,440 --> 00:35:38,970
Dame un número positivo,

839
00:35:38,970 --> 00:35:42,880
y sigue pidiéndoselo hasta que
obtengamos un número positivo.

840
00:35:42,880 --> 00:35:46,026
Ahora, si nos ponemos realmente
quisquillosos, tampoco es menor que.

841
00:35:46,026 --> 00:35:46,650
Estamos muy cerca.

842
00:35:46,650 --> 00:35:47,700
PÚBLICO: Menor o igual.

843
00:35:47,700 --> 00:35:49,366
DAVID: Es menor o igual.

844
00:35:49,366 --> 00:35:52,620
Desafortunadamente, no recuerdo
que mi teclado tenga esa tecla,

845
00:35:52,620 --> 00:35:55,260
algo como un paréntesis en
ángulo y una línea debajo de él,

846
00:35:55,260 --> 00:35:56,880
como el que escribía
en la clase de matemáticas.

847
00:35:56,880 --> 00:35:59,370
Pero hay una forma de
hacerlo en nuestro teclado.

848
00:35:59,370 --> 00:36:01,420
De hecho, los escribo
uno al lado del otro, <=-, así.

849
00:36:01,420 --> 00:36:03,360
Esto, (n <= 0), es menor o igual a,

850
00:36:03,360 --> 00:36:05,159
Esto, (n >= 0), sería igual o mayor a.

851
00:36:05,159 --> 00:36:07,950
Ahora nos sentiremos cómodos
leyendo esto de izquierda a derecha,

852
00:36:07,950 --> 00:36:10,620
no hay un símbolo especial, como
los que hay en un libro de matemáticas

853
00:36:10,620 --> 00:36:11,726
o en una tarea impresa.

854
00:36:11,726 --> 00:36:13,350
Entonces, creo que
esto dice lo correcto,

855
00:36:13,350 --> 00:36:20,190
Haz esto mientras n sea menor o igual a
cero, lo cual desde luego, no es positivo.

856
00:36:20,190 --> 00:36:24,070
Y luego, abajo, el resto de mi
código puede permanecer igual.

857
00:36:24,070 --> 00:36:26,730
Ahora solo tengo un bloque de
código que está haciendo algo,

858
00:36:26,730 --> 00:36:27,480
pero saben, ¿qué?

859
00:36:27,480 --> 00:36:30,390
Aquí es donde los comentarios
comienzan a ser útiles.

860
00:36:30,390 --> 00:36:35,130
Pide al usuario un número positivo.

861
00:36:35,130 --> 00:36:40,830
Aquí abajo, imprime
tantos bloques.

862
00:36:40,830 --> 00:36:44,730
Es muy claro, si leemos en el
código lo que acabo de decir.

863
00:36:44,730 --> 00:36:47,310
Pero esto nos ayuda si 
nos dormimos y al despertar

864
00:36:47,310 --> 00:36:48,480
queremos recordar,
¿por qué hice esto?

865
00:36:48,480 --> 00:36:49,140
¿Por qué hice aquello?

866
00:36:49,140 --> 00:36:51,300
También le ayuda al lector de nuestro
código, un colega, un compañero de clase,

867
00:36:51,300 --> 00:36:51,930
etcétera.

868
00:36:51,930 --> 00:36:54,640
De este modo, le agregamos
comentarios al código.

869
00:36:54,640 --> 00:36:57,060
Lamentablemente, hay un error
y estamos a punto de llegar a él.

870
00:36:57,060 --> 00:36:58,260
Déjenme intentarlo.

871
00:36:58,260 --> 00:37:01,590
A continuación,
ejecutaré make mario3.

872
00:37:01,590 --> 00:37:02,820
Oh, ¡Dios mío!

873
00:37:02,820 --> 00:37:05,190
Parece que tengo más
errores, que líneas de código,

874
00:37:05,190 --> 00:37:06,750
esto es extraño.

875
00:37:06,750 --> 00:37:09,660
Error, variable n no utilizada.

876
00:37:09,660 --> 00:37:11,952
Ahora, profundizaré en
estos mensajes de error

877
00:37:11,952 --> 00:37:13,660
para que comencemos
a notar pequeñas pistas.

878
00:37:13,660 --> 00:37:16,830
Aquí a la izquierda está, por
supuesto, el nombre del archivo,

879
00:37:16,830 --> 00:37:18,960
como habrán
notado es mario3.c.

880
00:37:18,960 --> 00:37:22,020
Hay dos puntos, un número, dos
puntos y otro número: mario3.c:9:13.

881
00:37:22,020 --> 00:37:27,000
Esta es una forma muy breve,
para decir que en mario3.c

882
00:37:27,000 --> 00:37:32,250
en la línea nueve, del carácter o
columna, de izquierda a derecha, 13,

883
00:37:32,250 --> 00:37:34,710
tenemos un problema,
o al menos eso piensa el compilador.

884
00:37:34,710 --> 00:37:36,630
En general, el carácter
es bastante útil.

885
00:37:36,630 --> 00:37:39,671
El número de línea atrae
nuestra atención al lugar correcto.

886
00:37:39,671 --> 00:37:42,360
Por alguna razón,
esto tiene errores.

887
00:37:42,360 --> 00:37:46,740
Y específicamente, el 
error es "unused variable n".

888
00:37:46,740 --> 00:37:52,940
E inexplicablemente, en la
línea 11 tengo un "use of... n".

889
00:37:52,940 --> 00:37:54,840
Entonces, no se usó
aquí, pero se usó acá.

890
00:37:54,840 --> 00:37:58,890
Y por alguna razón a la
computadora no le gusta esto.

891
00:37:58,890 --> 00:38:01,450
¿Por qué ocurre eso?

892
00:38:01,450 --> 00:38:02,154
Sí

893
00:38:02,154 --> 00:38:04,972
PÚBLICO: [INAUDIBLE]

894
00:38:04,972 --> 00:38:06,680
DAVID: sí, allí está el truco.

895
00:38:06,680 --> 00:38:09,420
Es un poco diferente de Scratch,
pues cuando crean una variable

896
00:38:09,420 --> 00:38:11,003
pueden usarla donde quieran.

897
00:38:11,003 --> 00:38:13,820
En C y en otros lenguajes,
las variables solamente

898
00:38:13,820 --> 00:38:16,070
existen en lo que llamamos
un determinado ámbito.

899
00:38:16,070 --> 00:38:19,040
Y pueden pensar en
un ámbito como las llaves

900
00:38:19,040 --> 00:38:22,080
de apertura y cierre
utilizadas más recientemente.

901
00:38:22,080 --> 00:38:24,170
¿Qué es lo que implica eso?

902
00:38:24,170 --> 00:38:28,100
En la línea nueve del lado izquierdo,
estoy declarando una variable.

903
00:38:28,100 --> 00:38:30,110
Oye computadora, dame
una variable llamada n,

904
00:38:30,110 --> 00:38:31,380
y almacenará un entero.

905
00:38:31,380 --> 00:38:32,780
Esa es la historia que contamos.

906
00:38:32,780 --> 00:38:37,880
Pero, el problema es lo que hago
entre las llaves de las líneas 8 y 10.

907
00:38:37,880 --> 00:38:39,890
Hoy afirmé que
eso significa, que

908
00:38:39,890 --> 00:38:43,909
en Scratch las piezas se
rodean, y en C las variables

909
00:38:43,909 --> 00:38:45,200
se tratan un poco diferente.

910
00:38:45,200 --> 00:38:48,590
Si declaramos una variable
aquí, ésta solo existe aquí,

911
00:38:48,590 --> 00:38:51,435
y no la podemos utilizar
aquí abajo, en nuestro código.

912
00:38:51,435 --> 00:38:54,270
Esto parece ser
un círculo vicioso.

913
00:38:54,270 --> 00:38:55,970
Necesito una variable,

914
00:38:55,970 --> 00:38:57,470
y entonces puedo declararla.

915
00:38:57,470 --> 00:39:01,360
Pero no puedo declarar la variable
allí, si la quiero usar más tarde.

916
00:39:01,360 --> 00:39:04,200
En realidad, no parece
una buena situación.

917
00:39:04,200 --> 00:39:06,980
Lógicamente, incluso si
nunca programaron antes,

918
00:39:06,980 --> 00:39:10,430
si el mayor problema es
que ésta variable solo existe

919
00:39:10,430 --> 00:39:14,790
en el campo entre las llaves, de manera
intuitiva, ¿cómo lo resolveríamos?

920
00:39:14,790 --> 00:39:15,928
Sí

921
00:39:15,928 --> 00:39:17,260
PÚBLICO: ¿Se mueven las llaves?

922
00:39:17,260 --> 00:39:18,770
DAVID: Quitar las llav...

923
00:39:18,770 --> 00:39:19,990
¡oh, se mueven las llaves!

924
00:39:19,990 --> 00:39:23,290
Sí, podríamos mover las llaves,
básicamente esa es la idea.

925
00:39:23,290 --> 00:39:25,780
La trampa está en el bucle
do-while, porque las necesita.

926
00:39:25,780 --> 00:39:28,720
En casos generales
necesitamos esas llaves.

927
00:39:28,720 --> 00:39:30,760
Pero saben, ¿qué?

928
00:39:30,760 --> 00:39:32,650
Ha pasado un tiempo desde que los escribí.

929
00:39:32,650 --> 00:39:35,740
Pero, tengo
otro par de llaves,

930
00:39:35,740 --> 00:39:40,340
que están por fuera, por así
decirlo, son mis llaves internas.

931
00:39:40,340 --> 00:39:42,460
Así que, tengo otro
campo aquí, el cual es

932
00:39:42,460 --> 00:39:44,680
la función completa,
llamada main.

933
00:39:44,680 --> 00:39:47,410
Pero, ¿qué pasa si, de algún modo,
declaro mi variable fuera de aquí?

934
00:39:47,410 --> 00:39:49,182
Y de hecho, puedo.

935
00:39:49,182 --> 00:39:51,140
Puedo ir a la línea siete,
o incluso a una más arriba,

936
00:39:51,140 --> 00:39:52,630
pero en general, queremos
mantenernos lo más cerca posible

937
00:39:52,630 --> 00:39:54,340
de lo que nos importa.

938
00:39:54,340 --> 00:39:56,290
Puedo escribir: int n.

939
00:39:56,290 --> 00:39:59,075
Y no creo que quiera
indicar al usuario aquí,

940
00:39:59,075 --> 00:40:02,200
porque crearía el mismo
problema que antes, cuando solo

941
00:40:02,200 --> 00:40:04,030
lo indicamos una vez.

942
00:40:04,030 --> 00:40:07,600
Quiero esa indicación en un bucle, una,
otra y otra vez, de manera exponencial.

943
00:40:07,600 --> 00:40:08,340
Así que, está bien.

944
00:40:08,340 --> 00:40:11,050
No hemos visto esto antes, pero
podemos declarar una variable,

945
00:40:11,050 --> 00:40:12,880
y después no hacer nada con ella.

946
00:40:12,880 --> 00:40:14,901
Solo decimos, oye
computadora, dame una variable,

947
00:40:14,901 --> 00:40:16,900
Me ocuparé de ella después,
al igual que en Scratch,

948
00:40:16,900 --> 00:40:18,858
Si declaramos
una variable,

949
00:40:18,858 --> 00:40:20,700
lidiaremos con ella
después, como queramos.

950
00:40:20,700 --> 00:40:22,750
Ahora, esto todavía es un error.

951
00:40:22,750 --> 00:40:25,270
No puedo decir, oye computadora,
dame una variable n,

952
00:40:25,270 --> 00:40:28,330
y después, oh por cierto,
dame otra variable n.

953
00:40:28,330 --> 00:40:32,410
Lo único que debo hacer para
solucionarlo, es no volver a declararla,

954
00:40:32,410 --> 00:40:34,330
solo usarla.

955
00:40:34,330 --> 00:40:37,180
La línea siete dice, oye computadora,
dame una variable llamada

956
00:40:37,180 --> 00:40:38,860
n, que almacenará un entero.

957
00:40:38,860 --> 00:40:42,850
En la línea 10, la misma historia
de siempre, pero un poco más corta.

958
00:40:42,850 --> 00:40:45,220
En el lado izquierdo esto
dice: aquí está mi variable.

959
00:40:45,220 --> 00:40:47,880
El lado derecho dice: este
valor lo obtenemos del usuario.

960
00:40:47,880 --> 00:40:50,390
Ponlo de derecha a izquierda.

961
00:40:50,390 --> 00:40:55,150
Y ahora, porque n se declara
o crea en la línea siete,

962
00:40:55,150 --> 00:40:58,860
ésta existe en el campo
de estas llaves más externas.

963
00:40:58,860 --> 00:41:00,970
Y ahora, puedo usarla en
cualquier lugar que quiera,

964
00:41:00,970 --> 00:41:06,700
incluso en la línea 12, lo que es genial
y lo más importante, en la línea 15.

965
00:41:06,700 --> 00:41:11,050
Ahora guardaré esto, ejecutaré
make mario3 y contendré la respiración.

966
00:41:11,050 --> 00:41:13,840
Bien, funcionó, ./mario3.

967
00:41:13,840 --> 00:41:14,670
Numero positivo.

968
00:41:14,670 --> 00:41:15,190
No...

969
00:41:15,190 --> 00:41:16,881
Le daremos -1

970
00:41:16,881 --> 00:41:17,380
OK.

971
00:41:17,380 --> 00:41:18,664
Le daremos cero.

972
00:41:18,664 --> 00:41:19,330
Bien, muy bien.

973
00:41:19,330 --> 00:41:20,530
Le daremos 3.

974
00:41:20,530 --> 00:41:22,360
Ahora realmente coopera.

975
00:41:22,360 --> 00:41:24,880
La construcción do-while
todavía es un bucle,

976
00:41:24,880 --> 00:41:27,130
y Scratch no tiene
un análogo de esto.

977
00:41:27,130 --> 00:41:31,390
El bucle do-while todavía es un bucle,
pero hace algo al menos una vez.

978
00:41:31,390 --> 00:41:34,570
La diferencia, fundamentalmente,
sin embargo, es esta,

979
00:41:34,570 --> 00:41:41,080
si hiciera algo
como while (n <= 0),

980
00:41:41,080 --> 00:41:45,420
y si cambiara esto a un bucle while,
el cual vimos brevemente el otro día,

981
00:41:45,420 --> 00:41:51,970
que es similar al bloque
eterno en Scratch, si hago esto,

982
00:41:51,970 --> 00:41:53,860
hay un problema lógico,

983
00:41:53,860 --> 00:41:55,790
n fue declarada en la línea siete,

984
00:41:55,790 --> 00:41:59,230
y así evitamos el problema
del campo, desde el inicio.

985
00:41:59,230 --> 00:42:02,590
Pero la línea ocho dice: while (n <= 0)

986
00:42:02,590 --> 00:42:05,230
Pero, ¿qué es n en este punto?

987
00:42:05,230 --> 00:42:06,612
Aún no está definida.

988
00:42:06,612 --> 00:42:08,320
Como pronto
veremos en el curso,

989
00:42:08,320 --> 00:42:11,230
tiene algún valor basura,
algún valor desconocido,

990
00:42:11,230 --> 00:42:15,200
restos de lo que la computadora usó, esa
memoria RAM o memoria, en el pasado.

991
00:42:15,200 --> 00:42:18,422
Así que, este es un comportamiento
indefinido, al parecer.

992
00:42:18,422 --> 00:42:20,380
No sé si el bucle
se ejecutará o no

993
00:42:20,380 --> 00:42:21,910
porque no sé lo que hay en n,

994
00:42:21,910 --> 00:42:23,830
Podríamos hackear
esto, por así decirlo.

995
00:42:23,830 --> 00:42:26,650
Generalmente, hackear algo
es una forma de encontrar

996
00:42:26,650 --> 00:42:28,990
la solución, que tal vez no sea
la más limpia, a un problema.

997
00:42:28,990 --> 00:42:32,440
Y OK, iniciaré esto
en, -1,000 porque

998
00:42:32,440 --> 00:42:34,900
sé que es menor o igual a cero,

999
00:42:34,900 --> 00:42:38,785
Entonces, hackear esto soluciona
el problema lógico porque ahora

1000
00:42:38,785 --> 00:42:43,160
sobre la línea ocho, ¿-1,000
es menor o igual a 0?

1001
00:42:43,160 --> 00:42:43,660
Lo es.

1002
00:42:43,660 --> 00:42:45,550
Así que ahora, mi bucle se
ejecutará al menos una vez

1003
00:42:45,550 --> 00:42:47,350
y entonces cambiará el valor de n.

1004
00:42:47,350 --> 00:42:50,140
Pero ¿de dónde diablos viene ése -1,000?

1005
00:42:50,140 --> 00:42:54,440
Esta solución poco elegante ya
que es un horrible, horrible diseño,

1006
00:42:54,440 --> 00:42:57,640
a pesar de que trabaja de
manera lógica y es correcta,

1007
00:42:57,640 --> 00:42:58,780
es un mal, mal diseño.

1008
00:42:58,780 --> 00:43:02,225
Por eso comenzamos con un
diseño mejor, un bucle do-while,

1009
00:43:02,225 --> 00:43:04,600
pero sabemos que hay muchas
maneras diferentes de hacer las cosas.

1010
00:43:04,600 --> 00:43:06,433
Y podría ser que no, en
una serie de problemas,

1011
00:43:06,433 --> 00:43:09,460
una o dos cosas no se hagan bien
o de la manera correcta, la primera vez.

1012
00:43:09,460 --> 00:43:11,680
Eso está bien porque
con práctica y experiencia,

1013
00:43:11,680 --> 00:43:14,530
comenzaremos a ver
patrones, con los cuales

1014
00:43:14,530 --> 00:43:17,370
podremos resolver los
mismos tipos de problemas.

1015
00:43:17,370 --> 00:43:21,790
¿Alguna pregunta sobre
estas aproximaciones de Mario?

1016
00:43:21,790 --> 00:43:24,370
Bien, permítanme hacer
una última, una última

1017
00:43:24,370 --> 00:43:26,590
relacionada con Mario y algo como esto.

1018
00:43:26,590 --> 00:43:29,290
Pasé demasiado tiempo
buscando por las piezas de Mario

1019
00:43:29,290 --> 00:43:30,790
que describieran estas imágenes.

1020
00:43:30,790 --> 00:43:35,320
Y encontré esto, estos bloques 
subterráneos extra en el nivel de fuego.

1021
00:43:35,320 --> 00:43:38,650
Supongamos que quisiera
imprimir un cubo de hashtags,

1022
00:43:38,650 --> 00:43:42,100
no solo una línea horizontal,
ni una línea vertical,

1023
00:43:42,100 --> 00:43:43,954
sino juntar ambos tipos.

1024
00:43:43,954 --> 00:43:46,370
De hecho, podemos pensar en
estos bloques exactamente como eso.

1025
00:43:46,370 --> 00:43:49,660
Que son: hashtag, hashtag, hashtag,
hashtag, hashtag, hashtag, hashtag,

1026
00:43:49,660 --> 00:43:52,330
hashtag y así sucesivamente,
como una máquina de escribir vieja,

1027
00:43:52,330 --> 00:43:54,070
que imprime una línea a la vez.

1028
00:43:54,070 --> 00:43:56,050
Si aún recordamos
las máquinas de escribir,

1029
00:43:56,050 --> 00:43:59,520
pensemos que las computadoras y
printf se comportan de manera muy similar.

1030
00:43:59,520 --> 00:44:02,020
Podemos imprimir algo y
poner diagonal invertida n (\ n).

1031
00:44:02,020 --> 00:44:04,180
Imprimir algo más y poner
la diagonal invertida n (\ n).

1032
00:44:04,180 --> 00:44:06,832
Entonces, ¿cómo se hace un
cuadrado como el de la pantalla?

1033
00:44:06,832 --> 00:44:09,040
El proceso es
como si pintáramos

1034
00:44:09,040 --> 00:44:11,710
la pantalla, de izquierda a
derecha, moverse hacia abajo,

1035
00:44:11,710 --> 00:44:13,270
de izquierda a
derecha y luego hacia abajo.

1036
00:44:13,270 --> 00:44:15,230
¿Cómo hacemos esto?

1037
00:44:15,230 --> 00:44:18,740
¿Cuál fue el tipo
de código que usamos

1038
00:44:18,740 --> 00:44:22,129
para hacer algo una
y otra y otra vez?

1039
00:44:22,129 --> 00:44:23,420
El primero fue el bucle for,

1040
00:44:23,420 --> 00:44:26,390
Podríamos usar otras construcciones,
pero utilizaré el bucle for

1041
00:44:26,390 --> 00:44:26,889
de nuevo.

1042
00:44:26,889 --> 00:44:31,130
Guardaré esto como mario4,
nuestro cuarto y último ejemplo.

1043
00:44:31,130 --> 00:44:33,200
Mantendré este código
aquí, porque todavía

1044
00:44:33,200 --> 00:44:37,395
quiero indicarle al usuario una cantidad
de bloques, en el número positivo de ahí.

1045
00:44:37,395 --> 00:44:40,520
No quiero simplemente hacer
esto, pero veré dónde lo dejé.

1046
00:44:40,520 --> 00:44:42,900
A continuación,
ejecutaré make mario4.

1047
00:44:42,900 --> 00:44:44,290
./mario4

1048
00:44:44,290 --> 00:44:46,520
Hagamos un bloque de 5 por 5.

1049
00:44:46,520 --> 00:44:47,150
OK, así no es,

1050
00:44:47,150 --> 00:44:48,740
esa es solo una columna.

1051
00:44:48,740 --> 00:44:50,690
Parece que debo hacer algo más.

1052
00:44:50,690 --> 00:44:52,880
Bien, al igual
que en Scratch,

1053
00:44:52,880 --> 00:44:55,940
puedo tomar una idea y
anidarla dentro de otra,

1054
00:44:55,940 --> 00:44:57,650
A continuación, haré esto.

1055
00:44:57,650 --> 00:45:02,000
¿Qué tal si dentro de mi
bucle for que va de i hasta n,

1056
00:45:02,000 --> 00:45:05,630
hago otro 
for int? Pero no

1057
00:45:05,630 --> 00:45:08,532
quiero reutilizar i, porque
siento que si la uso en dos lugares,

1058
00:45:08,532 --> 00:45:09,990
algo se desordenará.

1059
00:45:09,990 --> 00:45:12,156
Iré con el siguiente
alfabéticamente, j,

1060
00:45:12,156 --> 00:45:13,560
lo cual es bastante común.

1061
00:45:13,560 --> 00:45:15,610
Entonces: (int j = 0;

1062
00:45:15,610 --> 00:45:17,300
j < n;

1063
00:45:17,300 --> 00:45:18,920
 j++)

1064
00:45:18,920 --> 00:45:22,610
Ahora, pondré
este bloque aquí,

1065
00:45:22,610 --> 00:45:25,310
creo que necesito
deshacerme de esto de aquí,

1066
00:45:25,310 --> 00:45:26,630
y ahora veamos qué sucede.

1067
00:45:26,630 --> 00:45:28,850
Tengo un bucle for
dentro de un bucle for,

1068
00:45:28,850 --> 00:45:33,690
si continúo y ejecuto mario4,
Enter, el código es compilable,

1069
00:45:33,690 --> 00:45:35,560
./mario4

1070
00:45:35,560 --> 00:45:37,986
Escribamos 5.

1071
00:45:37,986 --> 00:45:39,680
Mmm

1072
00:45:39,680 --> 00:45:42,939
Creo que si los cuento
esos en realidad son como 25,

1073
00:45:42,939 --> 00:45:43,980
eso no es lo que quería.

1074
00:45:43,980 --> 00:45:44,729
Yo quería un cuadrado.

1075
00:45:44,729 --> 00:45:47,020
Pero estéticamente, ¿qué
es lo que obviamente falta?

1076
00:45:47,020 --> 00:45:47,720
Una línea nueva.

1077
00:45:47,720 --> 00:45:51,080
Pero pensé que esa,
\ n, no iba aquí, ¿cierto?

1078
00:45:51,080 --> 00:45:53,330
Porque si hago esto,
avanzará muy rápido.

1079
00:45:53,330 --> 00:45:56,460
Si ejecuto de nuevo Mario4
después de hacer ese cambio,

1080
00:45:56,460 --> 00:45:59,540
ahora hice el problema opuesto.

1081
00:45:59,540 --> 00:46:00,780
Entonces, ¿qué debemos cambiar?

1082
00:46:00,780 --> 00:46:01,280
Sí

1083
00:46:01,280 --> 00:46:02,280
Ohh, ¿solo rascarnos?

1084
00:46:02,280 --> 00:46:02,780
OK.

1085
00:46:02,780 --> 00:46:04,174
¿Qué debemos cambiar?

1086
00:46:04,174 --> 00:46:04,840
Sí, por acá.

1087
00:46:04,840 --> 00:46:08,607
PÚBLICO: Otra línea con un
printf y una diagonal inversa n.

1088
00:46:08,607 --> 00:46:10,690
DAVID: Sí, ¿y cuál línea propondrían

1089
00:46:10,690 --> 00:46:13,708
para el printf con la diagonal inversa n?

1090
00:46:13,708 --> 00:46:14,569
PÚBLICO: ¿21?

1091
00:46:14,569 --> 00:46:15,360
DAVID: ¿Perdón?

1092
00:46:15,360 --> 00:46:16,440
PÚBLICO: 21

1093
00:46:16,440 --> 00:46:17,400
DAVID: 21

1094
00:46:17,400 --> 00:46:19,754
La ponemos ¿arriba o abajo de ella?

1095
00:46:19,754 --> 00:46:20,700
PÚBLICO: Arriba.

1096
00:46:20,700 --> 00:46:21,140
DAVID: Arriba de ella.

1097
00:46:21,140 --> 00:46:22,300
OK, voy para allá.

1098
00:46:22,300 --> 00:46:26,160
Proseguiré con printf ( "\ n");

1099
00:46:26,160 --> 00:46:27,120
Veamos ahora.

1100
00:46:27,120 --> 00:46:29,050
Entonces, make mario4

1101
00:46:29,050 --> 00:46:30,780
./mario4, Enter.

1102
00:46:30,780 --> 00:46:31,540
5

1103
00:46:31,540 --> 00:46:32,550
Hermoso, es hermoso.

1104
00:46:32,550 --> 00:46:35,010
En la pantalla, no se ven exactamente
como un cuadrado porque los hashtag son

1105
00:46:35,010 --> 00:46:36,600
un poco más verticales que horizontales.

1106
00:46:36,600 --> 00:46:37,350
Pero, está bien.

1107
00:46:37,350 --> 00:46:39,990
También, construimos una
aproximación de ese nivel.

1108
00:46:39,990 --> 00:46:43,090
Ahora, solo por si
acaso, pensaré sobre

1109
00:46:43,090 --> 00:46:46,290
esta especie de simplificación
excesiva, el imprimir tantos bloques.

1110
00:46:46,290 --> 00:46:52,500
¿Imprima esta cantidad de
filas o columnas en el exterior?

1111
00:46:52,500 --> 00:46:56,970
Y luego , ¿a dónde vamos
con esto? Print out this many ____

1112
00:46:56,970 --> 00:47:02,220
¿Cuál debería ser mi
comentario aquí arriba?

1113
00:47:02,220 --> 00:47:04,110
¿Acá arriba son filas?

1114
00:47:04,110 --> 00:47:07,170
Y aquí abajo, estas
deberían ser columnas.

1115
00:47:07,170 --> 00:47:11,250
Esto es porque en el bucle
más externo tenemos a i,

1116
00:47:11,250 --> 00:47:13,590
Este comienza en 0
y al final irá hasta 5.

1117
00:47:13,590 --> 00:47:16,140
Siempre que i sea
igual a 0, en el principio, es

1118
00:47:16,140 --> 00:47:19,762
como si el cursor se predeterminara a
la parte superior izquierda de la pantalla.


1119
00:47:19,762 --> 00:47:22,470
Luego tenemos este bucle
anidado, que dice: oh, por cierto,

1120
00:47:22,470 --> 00:47:24,210
haz lo siguiente cinco veces.

1121
00:47:24,210 --> 00:47:25,680
¿Qué haremos 5 veces?

1122
00:47:25,680 --> 00:47:28,440
Hashtag, hashtag,
hashtag, hashtag, hashtag,

1123
00:47:28,440 --> 00:47:29,620
Entonces, una línea nueva,

1124
00:47:29,620 --> 00:47:32,370
después, i se convierte en 1,

1125
00:47:32,370 --> 00:47:35,490
esto es como moverse sobre,

1126
00:47:35,490 --> 00:47:36,630
lo siento.

1127
00:47:36,630 --> 00:47:40,200
Entonces, i se convierte en 1, lo cual
significa que estamos en la segunda fila

1128
00:47:40,200 --> 00:47:42,880
porque imprimimos uno de
esos caracteres en una línea nueva.

1129
00:47:42,880 --> 00:47:45,220
Aquí también, es donde los
comentarios serían útiles porque

1130
00:47:45,220 --> 00:47:46,370
incluso yo tuve que pensar en eso.

1131
00:47:46,370 --> 00:47:47,580
Y no queremos perder
el tiempo pensando

1132
00:47:47,580 --> 00:47:48,996
en el código que ya hemos escrito.

1133
00:47:48,996 --> 00:47:52,500
solo queremos la respuesta
porque tomamos ciertas decisiones

1134
00:47:52,500 --> 00:47:54,690
en un caso como este.

1135
00:47:54,690 --> 00:47:55,230
Muy bien.

1136
00:47:55,230 --> 00:47:56,820
Supongamos que algo sale mal.

1137
00:47:56,820 --> 00:47:59,430
De hecho, ya resolvimos el
problema de cómo muchos hashtags

1138
00:47:59,430 --> 00:48:01,480
nos llevarán de esta manera
y muchos hashtags hacia esta otra.

1139
00:48:01,480 --> 00:48:04,290
Pero supongamos que queremos
entender lo que nuestro código está

1140
00:48:04,290 --> 00:48:04,890
haciendo.


1141
00:48:04,890 --> 00:48:07,950
Tenemos otras dos
herramientas que podemos usar,

1142
00:48:07,950 --> 00:48:10,680
ya que en la biblioteca CS50
tenemos una función que es casi

1143
00:48:10,680 --> 00:48:15,810
idéntica a printf, excepto que la llamamos
eprintf, es como un error en printf

1144
00:48:15,810 --> 00:48:19,450
que nos ayuda a ver qué
ocurre dentro del código.

1145
00:48:19,450 --> 00:48:21,730
y debemos utilizarla
de la siguiente manera.

1146
00:48:21,730 --> 00:48:24,480
Si deseamos entender
más claramente lo que

1147
00:48:24,480 --> 00:48:27,540
nuestro código hace, o
hasta un ejemplo para el curso

1148
00:48:27,540 --> 00:48:30,480
que descargamos, desde luego,
podemos añadirle nuestras propias líneas

1149
00:48:30,480 --> 00:48:32,870
de este, por ejemplo: "Hello there

1150
00:48:32,870 --> 00:48:38,490
I'm at home playing with this
code" o algo por el estilo, ¿cierto?

1151
00:48:38,490 --> 00:48:40,620
Parece algo absurdo,
pero al menos ahora

1152
00:48:40,620 --> 00:48:44,610
cuando veamos esa frase en la
pantalla, sabremos en qué línea

1153
00:48:44,610 --> 00:48:46,810
se estaba ejecutando
nuestro programa.

1154
00:48:46,810 --> 00:48:48,930
Podemos ser más
metódicos respecto a esto.

1155
00:48:48,930 --> 00:48:51,610
Notemos las cosas que
podemos hacer con eprintf,

1156
00:48:51,610 --> 00:48:54,716
Cambiaré esto a
eprintf y funcionará igual.

1157
00:48:54,716 --> 00:48:56,340
También añadiré esto,

1158
00:48:56,340 --> 00:48:59,850
"about to prompt user for a number"

1159
00:48:59,850 --> 00:49:04,530
Solamente quiero proporcionarme
una nota explícita y temporal

1160
00:49:04,530 --> 00:49:06,287
acerca de lo que está pasando aquí.

1161
00:49:06,287 --> 00:49:07,620
Veamos ahora lo que sucede

1162
00:49:07,620 --> 00:49:10,230
si ejecuto make mario4.

1163
00:49:10,230 --> 00:49:12,930
OK ./mario4

1164
00:49:12,930 --> 00:49:13,812
¡Ah!

1165
00:49:13,812 --> 00:49:16,020
Obtuve una salida un poco
fea, pero solo es un diagnóstico,

1166
00:49:16,020 --> 00:49:16,680
es algo temporal.

1167
00:49:16,680 --> 00:49:21,150
Dice que mario4.c en la línea
10 tiene el siguiente mensaje:

1168
00:49:21,150 --> 00:49:23,220
"about to prompt user for a number"

1169
00:49:23,220 --> 00:49:27,030
Es una nota para mí, para que me
sienta cómodo al comprender el flujo

1170
00:49:27,030 --> 00:49:28,900
o la estructura de mi programa,

1171
00:49:28,900 --> 00:49:30,300
todavía puedo interactuar con él.

1172
00:49:30,300 --> 00:49:32,490
Escribiré aquí algo como -1.

1173
00:49:32,490 --> 00:49:36,625
Si escribo -1 ¿qué debería
ver después en la pantalla?

1174
00:49:36,625 --> 00:49:37,500
Sí, otra indicación,

1175
00:49:37,500 --> 00:49:38,970
"About to prompt user for number"

1176
00:49:38,970 --> 00:49:40,710
Es algo así como
un examen médico,

1177
00:49:40,710 --> 00:49:43,410
si creemos que algo puede suceder,
preguntémonos a nosotros mismos

1178
00:49:43,410 --> 00:49:46,797
si debería estar en el código y debemos
asegurarnos de que vemos lo que esperamos.

1179
00:49:46,797 --> 00:49:48,630
y cuando estemos seguros
de que el código está bien,

1180
00:49:48,630 --> 00:49:50,790
no debemos enviarlo con
esta nota, porque no es

1181
00:49:50,790 --> 00:49:52,620
correcto por la especificación.

1182
00:49:52,620 --> 00:49:54,840
En este punto podemos
deshacernos de esto.

1183
00:49:54,840 --> 00:49:56,800
Pero eso se vuelve
tedioso muy rápidamente.

1184
00:49:56,800 --> 00:50:00,660
Ah, y ¿cómo puedo eliminar a mi
programa si ya no quiero seguir jugando?

1185
00:50:00,660 --> 00:50:02,657
El comando Control-C
finalizará el programa.

1186
00:50:02,657 --> 00:50:04,740
Existe otra herramienta, que
quizás sea la más poderosa.

1187
00:50:04,740 --> 00:50:06,570
Y no puedo enfatizar sobre la
importancia de esto, lo suficiente,

1188
00:50:06,570 --> 00:50:09,720
de adquirir el hábito de usarlo,
cuando sea necesario, desde el principio.

1189
00:50:09,720 --> 00:50:12,700
Aún si nos toma 10 minutos extra,
o inclusive media hora practicarlo,

1190
00:50:12,700 --> 00:50:16,230
posiblemente nos ahorrará
horas durante el semestre.

1191
00:50:16,230 --> 00:50:18,480
Se trata de un programa
llamado el depurador.

1192
00:50:18,480 --> 00:50:20,310
Entonces, un depurador es
un programa que nos ayuda

1193
00:50:20,310 --> 00:50:22,650
a eliminar los errores de un programa.

1194
00:50:22,650 --> 00:50:24,310
Y funciona de la siguiente manera.

1195
00:50:24,310 --> 00:50:27,030
Voy a compilar de nuevo mario4.

1196
00:50:27,030 --> 00:50:31,320
Y lo más normal sería que lo
ejecutara, desde luego, con ./mario4.

1197
00:50:31,320 --> 00:50:34,541
Pero supongamos que tengo un error
y quiero entender lo que está pasando.

1198
00:50:34,541 --> 00:50:35,790
Haré lo siguiente.

1199
00:50:35,790 --> 00:50:37,706
Notarán que todos los
ejemplos que les he mostrado

1200
00:50:37,706 --> 00:50:41,320
tienen números de línea del lado izquierdo,
en el margen interno del programa,

1201
00:50:41,320 --> 00:50:44,700
y podemos hacer clic a la izquierda
de estos números, en algo como

1202
00:50:44,700 --> 00:50:46,140
este punto de aquí.

1203
00:50:46,140 --> 00:50:47,580
Y podemos poner un punto rojo,

1204
00:50:47,580 --> 00:50:50,070
éste será conocido como
un punto de interrupción,

1205
00:50:50,070 --> 00:50:53,290
es como una pequeña señal de
alto, solo para nosotros, que dice

1206
00:50:53,290 --> 00:50:57,450
oye computadora, haz una pausa o
detén totalmente mi programa aquí,

1207
00:50:57,450 --> 00:50:59,670
como una señal de alto temporal.

1208
00:50:59,670 --> 00:51:02,250
Entonces, el humano hace las
cosas a una velocidad humana,

1209
00:51:02,250 --> 00:51:04,890
no a una velocidad de miles de
millones de cosas por segundo

1210
00:51:04,890 --> 00:51:07,000
y con esto, me refiero a lo siguiente.

1211
00:51:07,000 --> 00:51:12,510
Ahora, no ejecutaré mario4,
sino debug50 ./mario4, el cual

1212
00:51:12,510 --> 00:51:16,400
es un programa que
escribimos, que llama o inicia

1213
00:51:16,400 --> 00:51:18,290
el depurador interno del IDE.

1214
00:51:18,290 --> 00:51:21,290
Noten que, como por arte de magia,
acaba de aparecer este panel derecho

1215
00:51:21,290 --> 00:51:22,950
y en realidad siempre ha estado ahí.

1216
00:51:22,950 --> 00:51:26,330
Esto siempre dijo "depurador" y 
acaba de abrir esa ventana para mí

1217
00:51:26,330 --> 00:51:26,960
automáticamente.

1218
00:51:26,960 --> 00:51:28,410
Veamos lo que ocurre.

1219
00:51:28,410 --> 00:51:32,510
Hay un montón de palabras, pero
ya conocemos muchas de ellas.

1220
00:51:32,510 --> 00:51:35,870
Observen que aquí abajo
tenemos las palabras Local Variables,

1221
00:51:35,870 --> 00:51:37,510
Y luego aquí, hay una especie de tabla,

1222
00:51:37,510 --> 00:51:40,070
que no es muy grande
porque solo hay una variable local.

1223
00:51:40,070 --> 00:51:44,240
Y en este punto de la historia,
resulta que con mi variable n,

1224
00:51:44,240 --> 00:51:45,140
tengo suerte,

1225
00:51:45,140 --> 00:51:47,960
al parecer tiene un valor
predeterminado de 0.

1226
00:51:47,960 --> 00:51:49,530
No debería confiar en eso.

1227
00:51:49,530 --> 00:51:53,010
Pero como mi programa no está
tan desarrollado parece seguro,

1228
00:51:53,010 --> 00:51:55,010
ah más bien, mi programa
está tan poco desarrollado que

1229
00:51:55,010 --> 00:51:58,410
tengo el valor 0 en esto,
para nuestros objetivos de hoy.

1230
00:51:58,410 --> 00:51:59,510
Y es de tipo int.

1231
00:51:59,510 --> 00:52:01,560
Pero lo más genial es lo que sigue.

1232
00:52:01,560 --> 00:52:05,810
Observen que mi programa
está pausado en la línea siete,

1233
00:52:05,810 --> 00:52:08,450
o específicamente en la línea 10,
la cual es la primera línea interesante.

1234
00:52:08,450 --> 00:52:10,220
Por eso está resaltada en amarillo.

1235
00:52:10,220 --> 00:52:11,930
Pero lo genial aquí es esto,

1236
00:52:11,930 --> 00:52:15,680
arriba en la parte superior derecha,
hay un botón de reproducción que indica

1237
00:52:15,680 --> 00:52:16,850
reproduce la siguiente
parte de mi programa.

1238
00:52:16,850 --> 00:52:19,010
Reprodúcelo sin pausas.

1239
00:52:19,010 --> 00:52:21,920
O, si ponemos el cursor en
Step over this line, pasaremos

1240
00:52:21,920 --> 00:52:25,580
sobre esta línea, lo que significa,
oye computadora, reprodúcela

1241
00:52:25,580 --> 00:52:28,727
pero a mi ritmo humano,
solo una línea del código a la vez.

1242
00:52:28,727 --> 00:52:31,310
Si fuéramos curiosos, podríamos
entrar en esa línea del código,

1243
00:52:31,310 --> 00:52:33,061
pero veremos más
sobre eso en un momento.

1244
00:52:33,061 --> 00:52:36,060
Mientras tanto, nos hemos adentrado
más en este, que es el paso de salida

1245
00:52:36,060 --> 00:52:38,360
¿Y qué quiero
decir con todo esto?

1246
00:52:38,360 --> 00:52:40,970
En este momento tengo una
pausa en la línea 10, la cual

1247
00:52:40,970 --> 00:52:43,520
fue la primera línea
interesante en mi programa,

1248
00:52:43,520 --> 00:52:45,200
en lo que respecta al depurador.

1249
00:52:45,200 --> 00:52:47,180
Continuaré en la parte
superior derecha

1250
00:52:47,180 --> 00:52:50,010
y haré clic en Step Over.

1251
00:52:50,010 --> 00:52:53,060
Observen que mi ventana de
terminal me pide un número.

1252
00:52:53,060 --> 00:52:53,690
¿Por qué?

1253
00:52:53,690 --> 00:52:57,620
Bien, porque pasé por encima de la
línea get int, que significa ejecutarlo.

1254
00:52:57,620 --> 00:53:00,020
A continuación,
escribiré ese número.

1255
00:53:00,020 --> 00:53:04,190
Escribiré -50, Enter.

1256
00:53:04,190 --> 00:53:08,760
Y estaré atento a la
variable del lado derecho.

1257
00:53:08,760 --> 00:53:13,490
Observemos que en el depurador,
aún sin imprimirlo con printf o eprintf,

1258
00:53:13,490 --> 00:53:16,067
Puedo ver que n tiene un valor de -50.

1259
00:53:16,067 --> 00:53:17,650
Es como un examen
médico, por así decirlo.

1260
00:53:17,650 --> 00:53:21,150
Puedo ver lo que es, para asegurarme de
que es consistente con mis expectativas.

1261
00:53:21,150 --> 00:53:21,650
Muy bien.

1262
00:53:21,650 --> 00:53:24,360
Eso no es correcto así
que daré un paso más,

1263
00:53:24,360 --> 00:53:26,840
noten que la línea amarilla se
movió porque está en un bucle,

1264
00:53:26,840 --> 00:53:29,150
pueden ver que lo sigo 
haciendo con mi mano.

1265
00:53:29,150 --> 00:53:30,000
Permítanme hacerlo de nuevo,

1266
00:53:30,000 --> 00:53:30,876
OK, positive number,

1267
00:53:30,876 --> 00:53:32,250
esta vez voy a cooperar,

1268
00:53:32,250 --> 00:53:34,280
42, Enter.

1269
00:53:34,280 --> 00:53:38,360
Observen que en el lado
derecho, el valor de n es 42

1270
00:53:38,360 --> 00:53:40,970
y noten que si continúo
pasando, la línea amarilla

1271
00:53:40,970 --> 00:53:43,770
está por saltar a la siguiente
línea interesante del código.

1272
00:53:43,770 --> 00:53:46,340
Y si continúo haciendo esto,
continúo haciendo esto,

1273
00:53:46,340 --> 00:53:49,640
miren lo que va a suceder en la parte
inferior de la ventana de terminal azul.

1274
00:53:49,640 --> 00:53:51,920
Aquí está el primer hashtag,

1275
00:53:51,920 --> 00:53:53,540
aquí está el segundo hashtag,

1276
00:53:53,540 --> 00:53:57,050
es el tipo de animación falsa que
hice el otro día con mis diapositivas

1277
00:53:57,050 --> 00:53:59,990
y lo que trato de hacer verbalmente,
y con mi mano de atrás hacia adelante,

1278
00:53:59,990 --> 00:54:02,030
ahora lo podemos ver
más cuidadosamente.

1279
00:54:02,030 --> 00:54:05,150
Incluso si escribimos un
programa simple o solo un código,

1280
00:54:05,150 --> 00:54:08,690
podemos ver paso a paso lo que
nuestro programa está haciendo.

1281
00:54:08,690 --> 00:54:10,730
Puede que no esté
haciendo lo que esperamos,

1282
00:54:10,730 --> 00:54:13,610
pero lo veremos visualmente.

1283
00:54:13,610 --> 00:54:14,110
Muy bien.

1284
00:54:14,110 --> 00:54:16,620
Para continuar diré: OK,
imprime el resto del programa

1285
00:54:16,620 --> 00:54:17,480
y presiono reproducir.

1286
00:54:17,480 --> 00:54:20,660
Veremos que el depurador
GDB o GNU sale del servidor,

1287
00:54:20,660 --> 00:54:21,560
se está cerrando.

1288
00:54:21,560 --> 00:54:24,360
Ahora estoy de nuevo en mi
línea y el depurador desaparece.

1289
00:54:24,360 --> 00:54:28,250
Por lo que no menosprecien
esas herramientas especiales.

1290
00:54:28,250 --> 00:54:33,892
Antes de continuar, creo que
debería presentarles a Abhishek,

1291
00:54:33,892 --> 00:54:36,600
tal vez lo vieron en 
internet hace un par meses,

1292
00:54:36,600 --> 00:54:37,516
se volvió algo viral.

1293
00:54:37,516 --> 00:54:39,050
Es un recién graduado de
la Universidad de Nueva York,

1294
00:54:39,050 --> 00:54:40,640
e hizo esta cosa extraordinaria.

1295
00:54:40,640 --> 00:54:45,230
Tomó el llamado Microsoft Hololens,
el cual es un dispositivo de realidad

1296
00:54:45,230 --> 00:54:48,380
aumentada que pone una especie
de pantalla ridícula frente a los ojos.

1297
00:54:48,380 --> 00:54:50,507
Pero entonces, proyecta las
imágenes frente a nuestros ojos

1298
00:54:50,507 --> 00:54:53,340
y actualmente es tan genial como
un teléfono Android o un iPhone,

1299
00:54:53,340 --> 00:54:58,012
el aparato sabe dónde estamos,
en un espacio tridimensional.

1300
00:54:58,012 --> 00:55:01,220
Pero lo que Abhishek hizo fue que
entró a un espacio muy tridimensional,

1301
00:55:01,220 --> 00:55:02,990
el Central Park en Manhattan.

1302
00:55:02,990 --> 00:55:07,220
Ya había pasado días
recreando a "Súper Mario Bros.".

1303
00:55:07,220 --> 00:55:11,090
en realidad aumentada al
producir uno de esos mapas a los que

1304
00:55:11,090 --> 00:55:12,080
me referí anteriormente.

1305
00:55:12,080 --> 00:55:13,970
Le daremos solo un
vistazo al resultado final

1306
00:55:13,970 --> 00:55:17,120
y lo pondremos en el sitio web del curso
para que lo vean a detalle más adelante,

1307
00:55:17,120 --> 00:55:20,960
fue este, que fue bastante alucinante y
una aplicación maravillosa de las ciencias

1308
00:55:20,960 --> 00:55:23,034
de la computación en el mundo real.

1309
00:55:23,034 --> 00:55:23,700
[REPRODUCCIÓN DE VIDEO]

1310
00:55:23,700 --> 00:55:23,990
Hola,

1311
00:55:23,990 --> 00:55:24,680
soy Abhishek

1312
00:55:24,680 --> 00:55:28,040
Y recreé el emblemático
primer nivel de "Súper Mario Bros"

1313
00:55:28,040 --> 00:55:30,950
en un juego de realidad aumentada,
en primera persona y de tamaño natural

1314
00:55:30,950 --> 00:55:32,480
que ahora voy a jugar como Mario.

1315
00:55:32,480 --> 00:55:46,368


1316
00:55:46,368 --> 00:55:48,348
[MÚSICA, TEMA DE "SÚPER MARIO

1317
00:55:48,348 --> 00:55:48,848
BROS"]

1318
00:55:48,848 --> 00:56:18,027


1319
00:56:18,027 --> 00:56:18,610
[FINALIZA LA REPRODUCCIÓN]

1320
00:56:18,610 --> 00:56:21,480
DAVID: Abhishek dio una charla en CS50
sobre tecnología, un par de meses atrás.

1321
00:56:21,480 --> 00:56:23,840
Y la parte más divertida, si miramos
detenidamente y estamos en Manhattan,

1322
00:56:23,840 --> 00:56:24,964
es que algunas personas lo miran.

1323
00:56:24,964 --> 00:56:28,309
Pero muchos neoyorquinos ni siquiera
miran dos veces lo que él hace.

1324
00:56:28,309 --> 00:56:30,350
A continuación, tomaremos
un descanso de cinco minutos

1325
00:56:30,350 --> 00:56:34,650
y cuando regresemos, comenzaremos
a ver el mundo de la criptografía.

1326
00:56:34,650 --> 00:56:35,480
Estamos de vuelta.

1327
00:56:35,480 --> 00:56:38,750
Desde luego, existen
más funciones que printf.

1328
00:56:38,750 --> 00:56:41,420
Y les dimos un vistazo con
ayuda de la biblioteca de CS50,

1329
00:56:41,420 --> 00:56:43,760
también hay muchos, muchos, muchos,
muchos más que vienen incluidos en C

1330
00:56:43,760 --> 00:56:46,610
y que personas en todo el mundo,
han escrito a lo largo de los años.

1331
00:56:46,610 --> 00:56:50,010
Pero implícitas en cada una
de estas funciones de CS50,

1332
00:56:50,010 --> 00:56:53,470
noten a estas palabras
clave como string, int y float,

1333
00:56:53,470 --> 00:56:55,220
de las cuales
también ya hablamos,

1334
00:56:55,220 --> 00:57:00,950
long, long, long y double,
como también vimos antes.

1335
00:57:00,950 --> 00:57:04,970
Entonces el lenguaje C, tiene
lo que llamamos tipos de datos

1336
00:57:04,970 --> 00:57:06,590
y los descubrimos el otro día.

1337
00:57:06,590 --> 00:57:10,054
Estos especifican qué tipo de datos
podemos poner dentro de una variable.

1338
00:57:10,054 --> 00:57:11,970
Y esta también es
la diferencia con Scratch.

1339
00:57:11,970 --> 00:57:14,300
En C y en otros lenguajes también tenemos

1340
00:57:14,300 --> 00:57:16,910
que decidir previamente, como
programadores, qué tipo de datos

1341
00:57:16,910 --> 00:57:19,460
pondremos en esta variable,
de modo que la computadora

1342
00:57:19,460 --> 00:57:21,140
o en realidad el compilador lo sepa,

1343
00:57:21,140 --> 00:57:23,900
así el compilador sabrá como
lidiar con eso para nosotros.

1344
00:57:23,900 --> 00:57:27,080
Bueno, si deseamos
imprimir estas cosas,

1345
00:57:27,080 --> 00:57:29,910
printf también viene
con ciertos códigos de formato.

1346
00:57:29,910 --> 00:57:32,882
Hemos visto %s para cadenas
y %i para los números enteros.

1347
00:57:32,882 --> 00:57:34,340
Aunque también existen muchos otros.

1348
00:57:34,340 --> 00:57:37,298
Quizás los más comunes serían
estos y seguramente los han visto,

1349
00:57:37,298 --> 00:57:38,180
%f para float,

1350
00:57:38,180 --> 00:57:39,410
lo vimos el otro día.

1351
00:57:39,410 --> 00:57:42,610
%lld para un número
decimal muy muy grande.

1352
00:57:42,610 --> 00:57:44,360
Ese es uno de los que a menudo
tengo que buscar yo mismo.

1353
00:57:44,360 --> 00:57:46,070
E incluso existen muchos
más de estos, demasiados.

1354
00:57:46,070 --> 00:57:48,590
Noten que mientras recibimos
la información de los usuarios,

1355
00:57:48,590 --> 00:57:50,930
ya sea para series de problemas
o con cualquier otro propósito,

1356
00:57:50,930 --> 00:57:54,500
algunas veces debemos revisar
el manual o la documentación,

1357
00:57:54,500 --> 00:57:59,030
por así decirlo, para las
funciones que utilizamos.

1358
00:57:59,030 --> 00:58:01,610
Y de modo que sepamos a dónde
acudir para ese tipo de cosas,

1359
00:58:01,610 --> 00:58:03,410
permítanme presentarles algo rápidamente.

1360
00:58:03,410 --> 00:58:06,620
Verán más de esto en apartados
adicionales, secciones y más.

1361
00:58:06,620 --> 00:58:10,010
Si, por ejemplo, olvidamos
cómo funcionan ciertas funciones,

1362
00:58:10,010 --> 00:58:14,600
podemos escribir
lo siguiente, "man get_string"

1363
00:58:14,600 --> 00:58:16,310
donde man representa el manual.

1364
00:58:16,310 --> 00:58:19,910
Este es un viejo comando de
las computadoras Unix y Linux,

1365
00:58:19,910 --> 00:58:22,650
que tiene un entorno
de teclado basado en texto.

1366
00:58:22,650 --> 00:58:26,840
Verán un manual del usuario
mucho más estándar y más estructurado

1367
00:58:26,840 --> 00:58:28,794
para la función que les interese.

1368
00:58:28,794 --> 00:58:30,710
De modo que, si olvidan
lo que hablamos en la clase

1369
00:58:30,710 --> 00:58:32,844
o no están seguros de
cómo podrían utilizarlo

1370
00:58:32,844 --> 00:58:34,760
y la función es
algo como get_string,

1371
00:58:34,760 --> 00:58:36,680
aquí pueden leer sobre ella.

1372
00:58:36,680 --> 00:58:39,650
Pero algunas veces, esto
parecerá un poco anticuado,

1373
00:58:39,650 --> 00:58:43,700
es decir, aún no hablamos del significado
de algunos de estos símbolos, la..

1374
00:58:43,700 --> 00:58:47,360
la palabra const, el asterisco
que he resaltado en la pantalla.

1375
00:58:47,360 --> 00:58:50,400
Algunas veces encontrarán que las
páginas man, como se le conoce

1376
00:58:50,400 --> 00:58:51,380
a las páginas del manual,

1377
00:58:51,380 --> 00:58:54,830
son confusas entre sí, lo cual
es una situación desagradable.

1378
00:58:54,830 --> 00:58:57,710
Si estamos confundidos y la
documentación no nos sirve de ayuda,

1379
00:58:57,710 --> 00:58:59,840
necesitaremos de una tercera opción.

1380
00:58:59,840 --> 00:59:02,330
De hecho, si van a la
página web de CS50,

1381
00:59:02,330 --> 00:59:06,050
encontrarán un
enlace a una herramienta

1382
00:59:06,050 --> 00:59:09,170
que el equipo ha creado en estos
años, llamado CS50 Reference.

1383
00:59:09,170 --> 00:59:12,051
Es una versión más fácil de
utilizar de esas mismas páginas

1384
00:59:12,051 --> 00:59:14,300
man, donde revisamos y traducimos

1385
00:59:14,300 --> 00:59:18,270
el inglés anticuado, a uno
menos cómodo, por así decirlo.

1386
00:59:18,270 --> 00:59:21,830
Entonces, si por aquí me
desplazo hacia, digamos, printf

1387
00:59:21,830 --> 00:59:23,600
o en vez de eso,
simplemente lo busco,

1388
00:59:23,600 --> 00:59:25,040
puedo ver aquí a printf,

1389
00:59:25,040 --> 00:59:28,550
está dentro del encabezado de este
archivo, este archivo de h del sistema

1390
00:59:28,550 --> 00:59:30,770
y ahora puedo
leer sobre esto aquí.

1391
00:59:30,770 --> 00:59:33,860
Observen la parte superior derecha,
está marcada la casilla Less Comfortable,

1392
00:59:33,860 --> 00:59:37,280
lo que significa, oye, muéstrame
el lenguaje que el TFS generó en lugar

1393
00:59:37,280 --> 00:59:38,450
del lenguaje predeterminado.

1394
00:59:38,450 --> 00:59:40,325
Pero, esto también es una
rueda de entrenamiento.

1395
00:59:40,325 --> 00:59:42,380
Y cuando estemos
listos para aprender

1396
00:59:42,380 --> 00:59:44,671
algunas de estas simplificaciones,
podemos desmarcar la casilla

1397
00:59:44,671 --> 00:59:46,884
y ver una versión
técnica mucho más detallada

1398
00:59:46,884 --> 00:59:48,800
de la que encontraríamos en el mundo real.

1399
00:59:48,800 --> 00:59:51,380
Debemos tener esto
en cuenta, en especial

1400
00:59:51,380 --> 00:59:53,690
si sentimos que avanzamos
muy rápido en la clase,

1401
00:59:53,690 --> 00:59:58,410
lo cual, de hecho, hacemos y deben apoyarse
en algo confiable de aquí en adelante.

1402
00:59:58,410 --> 01:00:02,780
Pero averigüemos
lo que es una cadena.

1403
01:00:02,780 --> 01:00:06,650
Comenzaré aquí con Stelios.

1404
01:00:06,650 --> 01:00:10,880
Así que Stelios, uno de nuestros jefes
de TAs en New Haven, tiene este nombre.

1405
01:00:10,880 --> 01:00:14,690
Y lo escribí como una
cadena, S-T-E-L-I-O-S.

1406
01:00:14,690 --> 01:00:16,910
Pero dibujé las casillas a propósito

1407
01:00:16,910 --> 01:00:21,620
alrededor de su nombre, para resaltar
que esta cosa que llamamos cadena,

1408
01:00:21,620 --> 01:00:26,540
como "Stelios" no solo es una cadena,

1409
01:00:26,540 --> 01:00:29,150
en realidad es una abstracción para algo

1410
01:00:29,150 --> 01:00:32,450
pequeño de nivel inferior, es decir,
un carácter después de un carácter

1411
01:00:32,450 --> 01:00:34,400
después de un carácter
y así sucesivamente.

1412
01:00:34,400 --> 01:00:36,750
Aquí también vemos un
ejemplo de una abstracción.

1413
01:00:36,750 --> 01:00:41,690
No es tan divertido llamar a Stelios,
S-T-E-L-I-O-S. Lo llamamos Stelios.

1414
01:00:41,690 --> 01:00:46,447
Pero en lenguajes como C, a esa
construcción la llamaríamos una cadena

1415
01:00:46,447 --> 01:00:48,030
o más técnicamente,
una secuencia de caracteres.

1416
01:00:48,030 --> 01:00:48,779
Pero es una cadena,

1417
01:00:48,779 --> 01:00:49,830
es una buena abstracción

1418
01:00:49,830 --> 01:00:51,317
y una buena simplificación.

1419
01:00:51,317 --> 01:00:53,150
Ahora, aquí tenemos una oportunidad

1420
01:00:53,150 --> 01:00:57,470
para ver la relación entre los caracteres
y los números en una computadora,

1421
01:00:57,470 --> 01:01:01,040
y lo poderosos que son los programas
y el software que nosotros mismos

1422
01:01:01,040 --> 01:01:01,730
podemos escribir.

1423
01:01:01,730 --> 01:01:04,970
Pero primero, ¿cómo introducimos
cada uno de los caracteres de un nombre?

1424
01:01:04,970 --> 01:01:08,960
Con la función get_string, como vimos,
puedo tener fácilmente el nombre Stelios,

1425
01:01:08,960 --> 01:01:11,540
al igual que lo hizo Sam
con el público el otro día.

1426
01:01:11,540 --> 01:01:14,840
Pero, ¿cómo puedo
obtener la S, la T o la E?

1427
01:01:14,840 --> 01:01:18,230
O si él hace un error tipográfico
o no lo escribe cuidadosamente,

1428
01:01:18,230 --> 01:01:21,170
¿cómo puedo capitalizar su
nombre o limpiar su entrada de usuario

1429
01:01:21,170 --> 01:01:23,420
como los sitios web actuales,
que lo hacen muy a menudo?

1430
01:01:23,420 --> 01:01:28,040
Bien, para continuar
abriré de nuevo el IDE de CS50

1431
01:01:28,040 --> 01:01:32,370
y haré un ejemplo bastante
simple, que esta vez involucra cadenas.

1432
01:01:32,370 --> 01:01:33,985
Crearé un nuevo archivo,

1433
01:01:33,985 --> 01:01:37,550


1434
01:01:37,550 --> 01:01:42,070
lo llamaré string0.c.

1435
01:01:42,070 --> 01:01:45,970
Ahora voy a escribir
un programa corto,

1436
01:01:45,970 --> 01:01:51,030
vamos! una vez que he perdido el
control sobre mi ventana de terminal,

1437
01:01:51,030 --> 01:01:55,420
ahora he perdido
el control de mi menú.

1438
01:01:55,420 --> 01:01:56,860
Esto es culpa mía por..

1439
01:01:56,860 --> 01:01:59,149
oh, aquí vamos.

1440
01:01:59,149 --> 01:02:00,440
Bueno, esto se verá genial.

1441
01:02:00,440 --> 01:02:03,342
Esto es muy inspirador.

1442
01:02:03,342 --> 01:02:04,288
¿A dónde se fue?

1443
01:02:04,288 --> 01:02:07,610


1444
01:02:07,610 --> 01:02:08,260
Oh, oh.

1445
01:02:08,260 --> 01:02:09,250
Aquí está.

1446
01:02:09,250 --> 01:02:09,940
OK.

1447
01:02:09,940 --> 01:02:13,010
Este es un ejemplo de un mal
diseño, de modo que lo arreglaremos.

1448
01:02:13,010 --> 01:02:15,235
Y ahora veo que escribí
mal string, lo puse como strig,

1449
01:02:15,235 --> 01:02:16,110
Así que solo vamos a,

1450
01:02:16,110 --> 01:02:18,651
nadie en internet sabrá
nunca, que esto sucedió.

1451
01:02:18,651 --> 01:02:21,650
OK, string0, voilà!

1452
01:02:21,650 --> 01:02:22,600
Aquí vamos.

1453
01:02:22,600 --> 01:02:23,110
Muy bien.

1454
01:02:23,110 --> 01:02:26,730
Así, string0.c y prepararé
rápidamente un programa como sigue.

1455
01:02:26,730 --> 01:02:28,930
Entonces, int main(void)

1456
01:02:28,930 --> 01:02:31,840
y ahora string s = get_string

1457
01:02:31,840 --> 01:02:34,810
pediré la entrada del usuario
así: string s = get_string("input: ");

1458
01:02:34,810 --> 01:02:37,180
Continuaré con printf.

1459
01:02:37,180 --> 01:02:40,810
¿Qué tal si ponemos la palabra
output aquí? printf("output");

1460
01:02:40,810 --> 01:02:43,450
Solo para que sea agradable
y ordenado, pondré un par de espacios

1461
01:02:43,450 --> 01:02:44,860
con anticipación aquí.

1462
01:02:44,860 --> 01:02:47,440
Sobre la línea 5 haré lo siguiente,

1463
01:02:47,440 --> 01:02:49,840
mi intención es obtener
el nombre de Stelios de él

1464
01:02:49,840 --> 01:02:51,370
o de quien sea que
esté jugando este juego.

1465
01:02:51,370 --> 01:02:54,160
Pero no solamente
quiero imprimir algo como

1466
01:02:54,160 --> 01:02:58,490
"hello Stelios" e introducir
su valor s, el cual hicimos antes.

1467
01:02:58,490 --> 01:03:00,340
Quiero hacer este
carácter al mismo tiempo.

1468
01:03:00,340 --> 01:03:03,010
Pero hacer algo "una vez al
mismo tiempo", sugiere un bucle.

1469
01:03:03,010 --> 01:03:04,130
Y de hecho, puedo hacer uno.

1470
01:03:04,130 --> 01:03:10,150
Así que haré for (int i = 0; i < however

1471
01:03:10,150 --> 01:03:14,590
for (int i = 0; i < however long his name is; i++)

1472
01:03:14,590 --> 01:03:17,020
Ahora les presentaré
otro truco al que

1473
01:03:17,020 --> 01:03:20,170
pueden darle un vistazo muy rápido
desde la pantalla que tenía antes.

1474
01:03:20,170 --> 01:03:23,620
Resulta que %c es el marcador
de posición para un carácter,

1475
01:03:23,620 --> 01:03:24,670
quizás esto no les sorprenda,

1476
01:03:24,670 --> 01:03:29,400
pero el truco es que solo tengo
acceso a s, a la cadena completa de s.

1477
01:03:29,400 --> 01:03:31,810
Aunque parece que hay una
nueva pieza de sintaxis aquí

1478
01:03:31,810 --> 01:03:34,690
y en cierto modo implica
el que usáramos casillas

1479
01:03:34,690 --> 01:03:37,930
para rodear las letras
del nombre de Stelios aquí

1480
01:03:37,930 --> 01:03:41,320
y parece que el equivalente en C,
es muy parecido a hacer esto,

1481
01:03:41,320 --> 01:03:44,560
hacer una casilla de caracteres con los
corchetes, los cuales es posible que no

1482
01:03:44,560 --> 01:03:45,700
utilicen con frecuencia en su teclado.

1483
01:03:45,700 --> 01:03:48,340
En un teclado estadounidense,
a menudo están encima de la tecla Enter.

1484
01:03:48,340 --> 01:03:52,120
Para continuar, escribo s[i]

1485
01:03:52,120 --> 01:03:57,740
Y por así decirlo,
se imprimirá el carácter i,

1486
01:03:57,740 --> 01:03:58,700
del nombre de Stelios.

1487
01:03:58,700 --> 01:04:00,339
De modo que la i comenzará en 0

1488
01:04:00,339 --> 01:04:02,380
y continúo haciendo más,
más, más, más, más, más,

1489
01:04:02,380 --> 01:04:04,504
y usando la notación
del corchete, por así decirlo,

1490
01:04:04,504 --> 01:04:08,930
en este caso puedo profundizar en
cada una de las letras de su nombre.

1491
01:04:08,930 --> 01:04:12,520
Por lo tanto, cuando ejecuto
esto, ¿cuál va a ser el resultado?

1492
01:04:12,520 --> 01:04:15,160
A continuación,
ejecutaré make string0.

1493
01:04:15,160 --> 01:04:16,060
Ajá.

1494
01:04:16,060 --> 01:04:19,140
OK, eso no es un código válido en C,
sin importar cuan largo sea su nombre.

1495
01:04:19,140 --> 01:04:21,220
Así que tengo un
problema que resolver aquí.

1496
01:04:21,220 --> 01:04:23,110
¿Cómo obtengo la
longitud de su nombre?

1497
01:04:23,110 --> 01:04:25,060
Bien, puedo hacer
una especie de trampa.

1498
01:04:25,060 --> 01:04:28,551
OK, así que uno, dos, tres,
cuatro, cinco, seis, siete.

1499
01:04:28,551 --> 01:04:29,050
Muy bien.

1500
01:04:29,050 --> 01:04:32,010
Podemos escribir este
programa como sigue,

1501
01:04:32,010 --> 01:04:33,047
7

1502
01:04:33,047 --> 01:04:34,630
Pero esto nos llevaría
por el camino equivocado.

1503
01:04:34,630 --> 01:04:36,860
¿Por qué esta no es una
buena solución al problema?

1504
01:04:36,860 --> 01:04:37,360
¿Sí?

1505
01:04:37,360 --> 01:04:40,085
PÚBLICO: Porque no es intercambiable.

1506
01:04:40,085 --> 01:04:40,960
DAVID: Exactamente,

1507
01:04:40,960 --> 01:04:41,793
no es intercambiable.

1508
01:04:41,793 --> 01:04:44,440
Tengo este dinamismo en
get_string para obtener nombre de Stelios.

1509
01:04:44,440 --> 01:04:48,100
Pero siete no será verdadero para todas
las personas que usen este programa.

1510
01:04:48,100 --> 01:04:49,360
Necesito algo dinámico.

1511
01:04:49,360 --> 01:04:51,700
Bueno, existe una función para eso,

1512
01:04:51,700 --> 01:04:56,830
La puedo llamar strlen por
string length pass in as input

1513
01:04:56,830 --> 01:04:58,930
la variable cuya longitud
quiero obtener y que

1514
01:04:58,930 --> 01:05:02,892
me devolverá un número,
que en este caso sería el 7.

1515
01:05:02,892 --> 01:05:04,100
Pero será dinámica,

1516
01:05:04,100 --> 01:05:06,970
de modo que si escribo algo como
David, con suerte, nos devolvería 5

1517
01:05:06,970 --> 01:05:10,720
y cualquier número, para cualquier
cantidad de personas que participen así.

1518
01:05:10,720 --> 01:05:12,460
Lo intentaré nuevamente,

1519
01:05:12,460 --> 01:05:14,840
make string0

1520
01:05:14,840 --> 01:05:16,450
un montón de errores

1521
01:05:16,450 --> 01:05:18,837
y "use of undeclared
identifier string"

1522
01:05:18,837 --> 01:05:19,420
esperen un momento,

1523
01:05:19,420 --> 01:05:21,100
ya hemos visto esto antes.

1524
01:05:21,100 --> 01:05:22,400
¿Cómo lo resolví la última vez?

1525
01:05:22,400 --> 01:05:22,900
¿Sí?

1526
01:05:22,900 --> 01:05:24,490
¿Qué falta aquí arriba?

1527
01:05:24,490 --> 01:05:25,660
PÚBLICO: Las bibliotecas.

1528
01:05:25,660 --> 01:05:27,040
DAVID: Sí, las bibliotecas o el encabezado

1529
01:05:27,040 --> 01:05:28,623
de los archivos, por así
decirlo, para las bibliotecas.

1530
01:05:28,623 --> 01:05:34,030
Así que necesito #include y estoy
muy seguro de <stdio.h> para printf.

1531
01:05:34,030 --> 01:05:39,370
Necesito #include <cs50.h> para get_string

1532
01:05:39,370 --> 01:05:40,390
Ya casi lo logramos.

1533
01:05:40,390 --> 01:05:41,556
Veamos si eso es suficiente.

1534
01:05:41,556 --> 01:05:42,190
make string0.

1535
01:05:42,190 --> 01:05:46,480
Oh, Implicitly declaring library
function 'strlen' with type..

1536
01:05:46,480 --> 01:05:48,490
Realmente no sé qué esto,

1537
01:05:48,490 --> 01:05:51,250
pero allí nos insinúa
una especie de respuesta

1538
01:05:51,250 --> 01:05:54,470
include the header string.h,
entre otras cosas

1539
01:05:54,470 --> 01:05:56,094
Así que parece que esto es verdad

1540
01:05:56,094 --> 01:05:57,760
y existen diferentes
maneras de comprobarlo.

1541
01:05:57,760 --> 01:06:03,430
Si regreso a
reference.cs50.net y busco strlen,

1542
01:06:03,430 --> 01:06:04,869
aquí está esa función.

1543
01:06:04,869 --> 01:06:06,910
Permítanme volver
a la menos cómoda, wups!

1544
01:06:06,910 --> 01:06:08,680
a la versión menos cómoda.

1545
01:06:08,680 --> 01:06:13,180
Observen que debajo de la sinopsis de
una página man o de reference.cs50.net

1546
01:06:13,180 --> 01:06:15,100
siempre hay un breve
resumen de cómo usarla.

1547
01:06:15,100 --> 01:06:17,110
Así, el prototipo de la función que

1548
01:06:17,110 --> 01:06:20,470
nos da una idea de lo que es,
size_t, básicamente equivale a un int,

1549
01:06:20,470 --> 01:06:22,450
que lo único que nos indica
es el tamaño de algo, como un número,

1550
01:06:22,450 --> 01:06:25,420
pero incluye a string.h,
que es el ingrediente que quería.

1551
01:06:25,420 --> 01:06:27,130
Así que copiaré esto.

1552
01:06:27,130 --> 01:06:28,570
Permítanme regresar al IDE.

1553
01:06:28,570 --> 01:06:30,460
Me pondré un poco quisquilloso

1554
01:06:30,460 --> 01:06:31,970
y mantendré acá
arriba un orden alfabético,

1555
01:06:31,970 --> 01:06:33,386
aunque no es estrictamente necesario,

1556
01:06:33,386 --> 01:06:36,290
pero nos facilitará echarle un vistazo
después, cuando la lista se alargue.

1557
01:06:36,290 --> 01:06:37,580
make string0.

1558
01:06:37,580 --> 01:06:40,460
Parece buena idea
continuar ./string0

1559
01:06:40,460 --> 01:06:41,070
Input.

1560
01:06:41,070 --> 01:06:43,640
Escribiré el nombre de Stelios.

1561
01:06:43,640 --> 01:06:45,354
Y me dio también su salida.

1562
01:06:45,354 --> 01:06:47,770
Imprimir su nombre fue
mucho trabajo innecesario.

1563
01:06:47,770 --> 01:06:49,550
Simplemente podría
haber utilizado %s.

1564
01:06:49,550 --> 01:06:51,320
Pero ahora puedo hacer modificaciones.

1565
01:06:51,320 --> 01:06:54,200
¿Y si quisiera imprimir uno por línea?

1566
01:06:54,200 --> 01:06:55,820
Puedo añadir eso.

1567
01:06:55,820 --> 01:06:59,750
Puedo poner el programa otra vez,
volverlo a ejecutar y escribir su nombre,

1568
01:06:59,750 --> 01:07:01,119
y ahora me da uno por línea.

1569
01:07:01,119 --> 01:07:01,910
Se ve un poco feo.

1570
01:07:01,910 --> 01:07:03,230
Ahora tiene s como salida,

1571
01:07:03,230 --> 01:07:04,820
pero solo es un error estético.

1572
01:07:04,820 --> 01:07:06,170
podría volver y arreglarlo,

1573
01:07:06,170 --> 01:07:09,110
pero ahora tengo el control
de los caracteres individuales

1574
01:07:09,110 --> 01:07:10,670
en su nombre.

1575
01:07:10,670 --> 01:07:13,140
Parece que de alguna
forma hemos progresado,

1576
01:07:13,140 --> 01:07:15,690
pero si ahora tengo acceso
a las letras individuales,

1577
01:07:15,690 --> 01:07:19,280
podemos volver en círculo
a la primera lección, en donde

1578
01:07:19,280 --> 01:07:21,980
hablamos sobre los ceros,
los unos, y después los números

1579
01:07:21,980 --> 01:07:26,030
y las letras, y ahora, a su vez, de las
palabras, también conocidas como cadenas,

1580
01:07:26,030 --> 01:07:27,824
con ayuda de un tema
llamado conversión de tipos.

1581
01:07:27,824 --> 01:07:30,740
Los tipos, por supuesto, son los tipos
de variables de los que hemos hablado.

1582
01:07:30,740 --> 01:07:33,600
Conversión significa
convertir de uno a otro.

1583
01:07:33,600 --> 01:07:35,720
Y si lo recuerdan
de nuestra primera lección,

1584
01:07:35,720 --> 01:07:39,410
esa A mayúscula era el número
que en decimales conocemos como 65,

1585
01:07:39,410 --> 01:07:41,540
y cualquier patrón
de ceros y unos que tenga.

1586
01:07:41,540 --> 01:07:44,430
La B mayúscula es
el 66, y así sucesivamente.

1587
01:07:44,430 --> 01:07:46,910
Ahora, ¿puedo verlo por primera vez ?

1588
01:07:46,910 --> 01:07:48,230
Bueno, resulta que sí puedo.

1589
01:07:48,230 --> 01:07:50,270
Regresaré al IDE

1590
01:07:50,270 --> 01:07:55,940
y crearé un nuevo
programa llamado ascii0.c.

1591
01:07:55,940 --> 01:07:57,590
y ASCII, nuevamente, solo es el estándar.

1592
01:07:57,590 --> 01:08:00,423
Es el acrónimo de American Standard
Code for Information Interchange,

1593
01:08:00,423 --> 01:08:04,136
el cual asigna números
a letras y letras a números.

1594
01:08:04,136 --> 01:08:06,260
A continuación, escribiré 
un programa rápidamente.

1595
01:08:06,260 --> 01:08:09,740
#Include stdio.h, para printf.

1596
01:08:09,740 --> 01:08:11,840
int main(void).

1597
01:08:11,840 --> 01:08:14,797
Y luego aquí haré lo siguiente.

1598
01:08:14,797 --> 01:08:15,380
¿Saben algo?

1599
01:08:15,380 --> 01:08:22,040
Imprimiré, digamos,
string s = get_string("Name: ");

1600
01:08:22,040 --> 01:08:24,080
Vamos a preguntarle
el nombre de alguien.

1601
01:08:24,080 --> 01:08:27,870
A continuación escribiré: for (int i = 0;

1602
01:08:27,870 --> 01:08:30,560
i es menor que la
longitud de esa cadena,

1603
01:08:30,560 --> 01:08:31,990
de acuerdo con lo que
vimos la otra vez,

1604
01:08:31,990 --> 01:08:33,170
i++.

1605
01:08:33,170 --> 01:08:35,490
Y esto va a iterar
sobre la cadena entera.

1606
01:08:35,490 --> 01:08:36,990
Ahora quiero hacer esto,

1607
01:08:36,990 --> 01:08:40,109
quiero imprimir lo siguiente,

1608
01:08:40,109 --> 01:08:45,630
imprimiré el mismo
carácter y luego un espacio,

1609
01:08:45,630 --> 01:08:48,354
y después, qué tal un
número entero, y una nueva línea.

1610
01:08:48,354 --> 01:08:50,270
En un momento
veremos qué es lo que hace.

1611
01:08:50,270 --> 01:08:52,269
Quiero conectar los valores
para estos marcadores de posición.

1612
01:08:52,269 --> 01:08:57,520
Pero, ¿cómo puedo obtener el primer
carácter del nombre, si la cadena se llama s?

1613
01:08:57,520 --> 01:09:01,340
Sí, entonces s[i]
para el carácter de i.

1614
01:09:01,340 --> 01:09:05,450
Y esto conectará a S-T-E-L,
si Stelios es el que participa

1615
01:09:05,450 --> 01:09:06,300
en el juego.

1616
01:09:06,300 --> 01:09:09,319
Pero ahora pongo una coma para
conectar un segundo marcador de posición.

1617
01:09:09,319 --> 01:09:11,000
Y %i, ¿saben
lo que voy a hacer?

1618
01:09:11,000 --> 01:09:16,670
Pondré un (int),
en paréntesis, y s[i];

1619
01:09:16,670 --> 01:09:18,229
Esto se ve un poco enigmático,

1620
01:09:18,229 --> 01:09:20,729
pero eliminaré por un
momento esta parte.

1621
01:09:20,729 --> 01:09:23,090
Se trata de lo mismo,
pero escrito dos veces,

1622
01:09:23,090 --> 01:09:25,970
imprime el carácter i del nombre,
el carácter i del nombre.

1623
01:09:25,970 --> 01:09:28,760
Pero hago entre paréntesis,
lo que se llama conversión de tipos.

1624
01:09:28,760 --> 01:09:32,390
Tomo cualquier cosa que sea,
es decir un char o un carácter.

1625
01:09:32,390 --> 01:09:35,990
Y digo entre paréntesis, haz que
en vez de aquello se vuelva un int.

1626
01:09:35,990 --> 01:09:38,029
Entonces, si es una
A mayúscula, se convertirá en 65,

1627
01:09:38,029 --> 01:09:40,439
la B mayúscula se convertirá
en 66 y así sucesivamente.

1628
01:09:40,439 --> 01:09:45,050
Y si ahora compilo este programa
después de arreglar, de manera preventiva,

1629
01:09:45,050 --> 01:09:48,200
lo que habría sido un error
y agrego el encabezado,

1630
01:09:48,200 --> 01:09:52,149
make ascii0.c,
¡ups!, perdón.

1631
01:09:52,149 --> 01:09:53,559
¡Oh! es un error común.

1632
01:09:53,559 --> 01:09:54,350
Nada que hacerle.

1633
01:09:54,350 --> 01:09:55,680
Estoy bastante seguro
de que falta hacer algo.

1634
01:09:55,680 --> 01:09:56,555
Necesito compilarlo.

1635
01:09:56,555 --> 01:09:58,640
¿Qué hice mal?

1636
01:09:58,640 --> 01:09:59,610
Sí, no debo poner el .c,

1637
01:09:59,610 --> 01:10:02,443
Es algo contraintuitivo, pero cuando
queremos hacer un programa,

1638
01:10:02,443 --> 01:10:05,080
escribimos el nombre
del programa, no el nombre del archivo.

1639
01:10:05,080 --> 01:10:06,200
Ahora, en...
¡Oh, diablos!

1640
01:10:06,200 --> 01:10:08,300
Nunca aprendo de mis errores.

1641
01:10:08,300 --> 01:10:09,339
¿Qué me falta ahora?

1642
01:10:09,339 --> 01:10:10,130
PÚBLICO: El string.h.

1643
01:10:10,130 --> 01:10:12,050
DAVID: Sí, el string.h.

1644
01:10:12,050 --> 01:10:13,220
Muy bien.

1645
01:10:13,220 --> 01:10:18,020
include string.h.

1646
01:10:18,020 --> 01:10:19,280
Lo guardo.

1647
01:10:19,280 --> 01:10:21,020
OK, ahora ejecutaré make ascii0.

1648
01:10:21,020 --> 01:10:22,970
Muy bien, ./ascii0.

1649
01:10:22,970 --> 01:10:25,550
Y ahora, Stelios, Enter.

1650
01:10:25,550 --> 01:10:28,760
Ahora vemos los códigos
ASCII o los números que

1651
01:10:28,760 --> 01:10:30,966
corresponden a las letras de su nombre.

1652
01:10:30,966 --> 01:10:32,090
Son números muy grandes,

1653
01:10:32,090 --> 01:10:33,330
ahora están en los cientos.

1654
01:10:33,330 --> 01:10:35,054
Y eso se debe a que son minúsculas.

1655
01:10:35,054 --> 01:10:37,970
Ya hablamos antes de la A mayúscula,
la B mayúscula y así sucesivamente.

1656
01:10:37,970 --> 01:10:40,100
Pero las letras
minúsculas también

1657
01:10:40,100 --> 01:10:44,900
tienen valores asociados a ellas,
como algunos de los que vemos aquí.

1658
01:10:44,900 --> 01:10:47,420
Y ahora que sé esto,
ahora que lo conozco,

1659
01:10:47,420 --> 01:10:50,809
puedo hacer las cosas de bajo nivel que
damos por hecho en nuestros teléfonos

1660
01:10:50,809 --> 01:10:53,600
y en los sitios web, como cuando escriben
su nombre en puras letras minúsculas

1661
01:10:53,600 --> 01:10:56,420
y el sitio web lo corrige,
o si escriben su número de teléfono

1662
01:10:56,420 --> 01:10:59,450
con paréntesis, sin paréntesis,
con guiones, o sin ellos,

1663
01:10:59,450 --> 01:11:03,110
el sitio web simplemente lo corrige
y lo pone en algún formato más limpio.

1664
01:11:03,110 --> 01:11:05,750
Ahora tenemos una especie
de control a bajo nivel para hacerlo.

1665
01:11:05,750 --> 01:11:08,690
No lo escribiré manualmente,
porque es un poco largo,

1666
01:11:08,690 --> 01:11:10,100
más bien lo abriré para continuar.

1667
01:11:10,100 --> 01:11:15,530
Y entre los ejemplos que veremos hoy
en source2, que es el sitio web del curso,

1668
01:11:15,530 --> 01:11:17,420
está este ejemplo,

1669
01:11:17,420 --> 01:11:19,019
capitalize0.

1670
01:11:19,019 --> 01:11:20,810
Haré un poco más
de espacio para esto,

1671
01:11:20,810 --> 01:11:21,750
ya que es un poco largo.

1672
01:11:21,750 --> 01:11:24,470
Vamos a enfocarnos
en un par de líneas a la vez.

1673
01:11:24,470 --> 01:11:26,920
Aquí está el inicio
de mi programa, main,

1674
01:11:26,920 --> 01:11:29,480
aquí está la línea de código que
corresponde a get_string, before,

1675
01:11:29,480 --> 01:11:31,190
solo digo, dame la cadena before.

1676
01:11:31,190 --> 01:11:35,354
Y digo, imprime la cadena after,
luego de que se le hagan algunos cambios.

1677
01:11:35,354 --> 01:11:36,270
¿Y qué haré ahora?

1678
01:11:36,270 --> 01:11:40,170
Parece que en la línea 11
utilice algunas de las mismas ideas,

1679
01:11:40,170 --> 01:11:42,630
pero con un cambio.

1680
01:11:42,630 --> 01:11:44,700
Hice algo diferente.

1681
01:11:44,700 --> 01:11:47,490
La línea 11 es muy similar
a lo que apliqué para iterar

1682
01:11:47,490 --> 01:11:49,260
los caracteres de una cadena.

1683
01:11:49,260 --> 01:11:53,240
Pero hice algo
diferente, ¿qué fue?

1684
01:11:53,240 --> 01:11:56,695
¿Qué se ve diferente en comparación
con lo que había antes en la pantalla?

1685
01:11:56,695 --> 01:11:59,672


1686
01:11:59,672 --> 01:12:01,350
¿Alguien que esté
un poco más atrás?

1687
01:12:01,350 --> 01:12:02,072
Sí.

1688
01:12:02,072 --> 01:12:03,960
PÚBLICO: [INAUDIBLE]

1689
01:12:03,960 --> 01:12:07,080
DAVID: Sí, al parecer
declaro dos variables

1690
01:12:07,080 --> 01:12:08,970
al mismo tiempo, por así decirlo.

1691
01:12:08,970 --> 01:12:12,190
Tengo mi (int i = 0) y hemos
hecho esto muchas veces.

1692
01:12:12,190 --> 01:12:15,030
Pero ahora, por primera vez, 
tengo una coma aquí.

1693
01:12:15,030 --> 01:12:17,089
n = strlen(s).

1694
01:12:17,089 --> 01:12:19,380
Pero si creen que estos
componentes básicos son...

1695
01:12:19,380 --> 01:12:23,760
OK, la coma es nueva, pero n está a la
izquierda, entonces es una variable.

1696
01:12:23,760 --> 01:12:26,880
Probablemente es un int,
porque la palabra int vino antes.

1697
01:12:26,880 --> 01:12:29,070
El signo igual es una
asignación de derecha a izquierda.

1698
01:12:29,070 --> 01:12:31,750
strlen es una función que
devuelve la longitud de una cadena.

1699
01:12:31,750 --> 01:12:37,310
Y para que quede claro, esto parece
almacenar, ¿cuál número en n?

1700
01:12:37,310 --> 01:12:39,060
Sí, el número de
caracteres en cualquier

1701
01:12:39,060 --> 01:12:41,470
cadena en la que el usuario
haya escrito, "Stelios", "David",

1702
01:12:41,470 --> 01:12:42,900
o cualquiera que sea el nombre.

1703
01:12:42,900 --> 01:12:44,820
Entonces tengo mi condición.

1704
01:12:44,820 --> 01:12:46,920
Después está el punto
y coma, que ya hemos visto.

1705
01:12:46,920 --> 01:12:48,720
Y luego está el ++.

1706
01:12:48,720 --> 01:12:53,760
Yo opino que este tiene
un mejor diseño en cierto sentido,

1707
01:12:53,760 --> 01:12:55,374
es un poco más complicado,

1708
01:12:55,374 --> 01:12:56,790
ya que escribí más caracteres

1709
01:12:56,790 --> 01:12:58,350
y añadí otra variable.

1710
01:12:58,350 --> 01:13:01,800
Pero ¿por qué es
inteligente y es buen diseño

1711
01:13:01,800 --> 01:13:05,610
utilizar una variable adicional
y usar más espacio para guardar

1712
01:13:05,610 --> 01:13:09,700
un número, simplemente
para comparar i con n?

1713
01:13:09,700 --> 01:13:13,890


1714
01:13:13,890 --> 01:13:15,480
¿Por qué salté a través de estos aros?

1715
01:13:15,480 --> 01:13:16,020
¿Qué es lo que piensan?

1716
01:13:16,020 --> 01:13:18,269
PÚBLICO: Porque entonces
no tiene que comprobar

1717
01:13:18,269 --> 01:13:20,190
qué es n cada vez
que pasa por el bucle.

1718
01:13:20,190 --> 01:13:21,065
DAVID: Exacto.

1719
01:13:21,065 --> 01:13:22,259
PÚBLICO: [INAUDIBLE]

1720
01:13:22,259 --> 01:13:25,050
DAVID: No tiene que comprobar
cuál es la longitud de la cadena

1721
01:13:25,050 --> 01:13:28,920
en cada iteración porque, al final, una vez
que Stelios o cualquier cosa que escriba

1722
01:13:28,920 --> 01:13:31,030
en su nombre,
no cambiará,

1723
01:13:31,030 --> 01:13:34,800
ya sea el nombre de D-A-V-I-D o Stelios
o María o quienquiera que esté jugando

1724
01:13:34,800 --> 01:13:35,430
este juego.

1725
01:13:35,430 --> 01:13:37,800
Pero, ¿por qué seguimos
llamando a una función repitiendo... oh,

1726
01:13:37,800 --> 01:13:38,760
por cierto, ¿cuál es la longitud?

1727
01:13:38,760 --> 01:13:39,660
¿cuál es la longitud?

1728
01:13:39,660 --> 01:13:40,410
¿cuál es la longitud?

1729
01:13:40,410 --> 01:13:44,100
Recuérdenlo a la primera vez, porque
es probable que tome algo de tiempo

1730
01:13:44,100 --> 01:13:47,400
hacer ese cómputo
y averiguar la longitud.

1731
01:13:47,400 --> 01:13:50,370
Simplemente mantenemos
esa respuesta alrededor de n

1732
01:13:50,370 --> 01:13:51,960
y podemos comparar dos variables.

1733
01:13:51,960 --> 01:13:55,509
Mientras tanto, aquí tenemos
una gran construcción: if-else.

1734
01:13:55,509 --> 01:13:58,675
Pero si lo partimos en pedazos,
hará algo relativamente sencillo.

1735
01:13:58,675 --> 01:14:06,990
En la línea 13 pregunto
si el carácter i de s es mayor

1736
01:14:06,990 --> 01:14:11,140
o igual a una A minúscula, entonces
&&, un símbolo que no vimos antes,

1737
01:14:11,140 --> 01:14:13,410
lógicamente significa y.

1738
01:14:13,410 --> 01:14:20,970
Entonces, si es mayor
o igual a "a" y menor o igual a z,

1739
01:14:20,970 --> 01:14:24,120
dicho de otro modo,
si está entre a y z, incluso

1740
01:14:24,120 --> 01:14:28,450
en minúsculas, ¿qué estoy haciendo
en la línea 15, la cual se ve súper rara?

1741
01:14:28,450 --> 01:14:31,460


1742
01:14:31,460 --> 01:14:35,780
En primer lugar imprimo %c,
el cual es mi marcador de posición,

1743
01:14:35,780 --> 01:14:43,430
Pero después imprimo el resultado
de s[i] menos cualquier minúscula A, menos

1744
01:14:43,430 --> 01:14:44,420
la A mayúscula.

1745
01:14:44,420 --> 01:14:46,070
Es decir, esto es muy extraño.

1746
01:14:46,070 --> 01:14:48,860
Pero les puedo dar una pista.

1747
01:14:48,860 --> 01:14:50,360
Resulta que aquí hay un patrón

1748
01:14:50,360 --> 01:14:52,580
y los seres humanos lo
hicieron deliberadamente.

1749
01:14:52,580 --> 01:14:55,040
Si pueden hacer el cálculo
rápidamente, ¿qué tan lejos

1750
01:14:55,040 --> 01:14:58,820
está la A minúscula
de la A mayúscula?

1751
01:14:58,820 --> 01:14:59,809
Es 32, ¿cierto?

1752
01:14:59,809 --> 01:15:01,100
Y podríamos calcular

1753
01:15:01,100 --> 01:15:03,170
97 menos 65, oh, es 32.

1754
01:15:03,170 --> 01:15:05,555
¿Qué tal la B mayúscula
contra la B minúscula?

1755
01:15:05,555 --> 01:15:06,360
Es 32.

1756
01:15:06,360 --> 01:15:06,860
32.

1757
01:15:06,860 --> 01:15:07,880
De modo que sigue este patrón,

1758
01:15:07,880 --> 01:15:10,550
por así decirlo, y es una especie de
demostración mediante un ejemplo.

1759
01:15:10,550 --> 01:15:13,010
Aún no vemos todo el camino
hasta la Z, pero créanme.

1760
01:15:13,010 --> 01:15:15,770
el 32 es invariable para
todas las letras del alfabeto.

1761
01:15:15,770 --> 01:15:17,300
Siempre están
a una distancia de 32.

1762
01:15:17,300 --> 01:15:20,510
Y apliqué un hardcode a 32,
pero luce poco elegante.

1763
01:15:20,510 --> 01:15:22,700
En vez de eso, por qué no
solo digo aritméticamente,

1764
01:15:22,700 --> 01:15:26,130
cualquiera que sea la diferencia
entre la A minúscula y la A mayúscula,

1765
01:15:26,130 --> 01:15:28,530
y eso es lo que digo
aquí entre paréntesis.

1766
01:15:28,530 --> 01:15:32,390
Cualquiera que sea la diferencia numérica
en la representación computacional

1767
01:15:32,390 --> 01:15:37,380
de mis números, resta esa
diferencia del carácter i.

1768
01:15:37,380 --> 01:15:40,610
Ahora, lo bonito es que
primero debería hacer esto,

1769
01:15:40,610 --> 01:15:43,082
debería proyectar
el carácter hacia un int.

1770
01:15:43,082 --> 01:15:44,540
Pero no necesito ser tan explícito.

1771
01:15:44,540 --> 01:15:46,915
La computadora sabe que
los caracteres son números enteros,

1772
01:15:46,915 --> 01:15:49,040
y sabe que los números
enteros son caracteres.

1773
01:15:49,040 --> 01:15:50,081
Existe esta equivalencia.

1774
01:15:50,081 --> 01:15:52,340
No necesito dar
tantos detalles al respecto.

1775
01:15:52,340 --> 01:15:54,980
Basta con dejar que
la computadora averigüe,

1776
01:15:54,980 --> 01:15:58,130
implícitamente, que en este contexto,
hago cálculos con los números,

1777
01:15:58,130 --> 01:16:02,086
y luego, en el contexto de printf,
muestro ese número como caracteres.

1778
01:16:02,086 --> 01:16:02,960
Como no pasa nada,

1779
01:16:02,960 --> 01:16:06,170
le estamos diciendo
al compilador el contexto

1780
01:16:06,170 --> 01:16:09,170
en el que debe tratar estos
valores numéricos o caracteres.

1781
01:16:09,170 --> 01:16:14,330
Para abreviar la historia, ¿qué efecto
tienen estas cuatro líneas de código

1782
01:16:14,330 --> 01:16:18,014
en los caracteres
de la entrada del usuario?

1783
01:16:18,014 --> 01:16:18,680
¿Qué hace?

1784
01:16:18,680 --> 01:16:20,030
PÚBLICO: [INAUDIBLE]

1785
01:16:20,030 --> 01:16:21,322
DAVID: Los vuelven mayúsculas.

1786
01:16:21,322 --> 01:16:21,821
¿Cierto?

1787
01:16:21,821 --> 01:16:22,610
Los vuelven mayúsculas.

1788
01:16:22,610 --> 01:16:25,850
Y por el nombre del archivo, tiene
implicaciones, en la información completa.

1789
01:16:25,850 --> 01:16:29,840
Pero así es como resolvemos
el problema con el uso de las mayúsculas.

1790
01:16:29,840 --> 01:16:30,770
Aquí está la cadena.

1791
01:16:30,770 --> 01:16:32,810
Enfoquémonos en los
caracteres individuales.

1792
01:16:32,810 --> 01:16:36,000
Averigüemos si están dentro
del rango que deseamos manejar.

1793
01:16:36,000 --> 01:16:40,250
Y si es así, apliquemos algún tipo
de mutación para cambiar de un valor

1794
01:16:40,250 --> 01:16:41,060
al otro.

1795
01:16:41,060 --> 01:16:42,650
Podía haberlo hecho
de un modo horrible.

1796
01:16:42,650 --> 01:16:45,080
Podría haber tenido algo
como if-else-if-else-if-else,

1797
01:16:45,080 --> 01:16:49,070
Podría haber tenido como 26 condiciones
para comprobar, ¿es el carácter A?

1798
01:16:49,070 --> 01:16:49,800
¿es el B?

1799
01:16:49,800 --> 01:16:50,300
¿es el C?

1800
01:16:50,300 --> 01:16:52,700
Y si es así, conviértelos en
A mayúscula, B mayúscula, C mayúscula.

1801
01:16:52,700 --> 01:16:55,220
Pero ese código sería tanto
o incluso más grande que este.

1802
01:16:55,220 --> 01:16:59,270
Esta es una forma más algorítmica
para resolver el mismo problema.

1803
01:16:59,270 --> 01:17:02,390
Y si no es una letra
minúscula entre A y Z, imprímela.

1804
01:17:02,390 --> 01:17:04,890
No hay nada más que hacer.

1805
01:17:04,890 --> 01:17:08,240
Ahora, tal como lo vimos,
no tiene que ser tan detallado.

1806
01:17:08,240 --> 01:17:12,890
En capitalize1.c, el cual está disponible
también en el sitio web del curso,

1807
01:17:12,890 --> 01:17:15,050
mejoré un poco
el diseño de mi código.

1808
01:17:15,050 --> 01:17:17,240
No estoy reinventando la rueda,

1809
01:17:17,240 --> 01:17:20,060
solo me apoyo en los hombros
de programadores más inteligentes.

1810
01:17:20,060 --> 01:17:22,850
Y por lo menos cambié una cosa.

1811
01:17:22,850 --> 01:17:26,990
En vez de hacer manualmente este
proceso de comparación con la A minúscula

1812
01:17:26,990 --> 01:17:30,710
y la Z minúscula,
solo tomo impulso y utilizo

1813
01:17:30,710 --> 01:17:33,500
una función que, maravillosamente,
se llama islower, la cual

1814
01:17:33,500 --> 01:17:35,180
responde a esa pregunta.

1815
01:17:35,180 --> 01:17:37,940
Porque los otros tipos
de datos en C, no solo son

1816
01:17:37,940 --> 01:17:42,380
int, char, float y string
de la biblioteca de CS50,

1817
01:17:42,380 --> 01:17:44,330
sino que también hay algo
que se llama valor booleano.

1818
01:17:44,330 --> 01:17:47,450
Un valor booleano, se llama así
en honor a Boole y es similar en esencia

1819
01:17:47,450 --> 01:17:49,370
a una expresión
booleana verdadera o falsa.

1820
01:17:49,370 --> 01:17:54,890
Pero una variable booleana
solamente es la idea de verdadero o falso.

1821
01:17:54,890 --> 01:17:58,470
Y pensaríamos que islower
devolverá un valor booleano.

1822
01:17:58,470 --> 01:18:00,719
Devuelve verdadero o falso, sí o no

1823
01:18:00,719 --> 01:18:03,260
y el nombre de esta función,
por lo tanto, es muy apropiado.

1824
01:18:03,260 --> 01:18:04,140
¿Islower?

1825
01:18:04,140 --> 01:18:06,080
Esa es una pregunta de
sí o no, verdadero o falso.

1826
01:18:06,080 --> 01:18:07,580
No sé cómo se implementó.

1827
01:18:07,580 --> 01:18:12,200
Si realmente me importara,
podría consultar la referencia de CS50

1828
01:18:12,200 --> 01:18:14,750
o podría usar el comando man en el IDE

1829
01:18:14,750 --> 01:18:16,820
y comprobar realmente
cómo funciona esta cosa.

1830
01:18:16,820 --> 01:18:18,500
Pero necesito una conclusión.

1831
01:18:18,500 --> 01:18:21,039
Para utilizar esto, necesito
utilizar la biblioteca de ctype.

1832
01:18:21,039 --> 01:18:24,080
Hay otras bibliotecas en las que
por el momento solo arañamos la superficie

1833
01:18:24,080 --> 01:18:27,170
y solo sabríamos que existen
al leer una documentación como esta.

1834
01:18:27,170 --> 01:18:27,920
¿Pero saben algo?

1835
01:18:27,920 --> 01:18:29,900
Puedo ir más allá.

1836
01:18:29,900 --> 01:18:30,530
¿Saben algo?

1837
01:18:30,530 --> 01:18:34,180
Si hace años un humano escribió una
función para ver si algo está en minúscula,

1838
01:18:34,180 --> 01:18:38,462
¿qué fue lo que probablemente,
también hizo para mí?

1839
01:18:38,462 --> 01:18:39,860
PÚBLICO: ¿Las mayúsculas?

1840
01:18:39,860 --> 01:18:42,480
DAVID: Sí, también existe isupper.

1841
01:18:42,480 --> 01:18:42,980
Sí.

1842
01:18:42,980 --> 01:18:43,760
Haré un spoiler aquí.

1843
01:18:43,760 --> 01:18:45,750
Existe isupper.

1844
01:18:45,750 --> 01:18:50,390
Pero se arriesgaron al comprobar
si es mayúscula o minúscula.

1845
01:18:50,390 --> 01:18:51,721
¿toupper?

1846
01:18:51,721 --> 01:18:52,220
Sí.

1847
01:18:52,220 --> 01:18:54,650
Resulta que hay una
función llamada toupper

1848
01:18:54,650 --> 01:18:56,990
que convierte una
letra en mayúsculas.

1849
01:18:56,990 --> 01:19:00,170
De hecho, puedo aprovecharla
en mi tercera versión del programa

1850
01:19:00,170 --> 01:19:01,130
como sigue.

1851
01:19:01,130 --> 01:19:06,200
capitalize2.c tiene un
mejor diseño, por así decirlo.

1852
01:19:06,200 --> 01:19:09,590
es incluso más corto, tiene menos
líneas de código, es más fácil de leer

1853
01:19:09,590 --> 01:19:11,300
y hay menos oportunidades
para cometer errores.

1854
01:19:11,300 --> 01:19:12,377
¿Ahora cómo lo resuelvo?

1855
01:19:12,377 --> 01:19:14,210
Aún hago iteraciones sobre
cada uno de los caracteres,

1856
01:19:14,210 --> 01:19:19,550
pero a ciegas designo toupper, toupper,
toupper sobre cada uno de los caracteres

1857
01:19:19,550 --> 01:19:21,200
porque leí la documentación.

1858
01:19:21,200 --> 01:19:24,064
Si pasamos por toupper
un carácter que ya está en mayúscula,

1859
01:19:24,064 --> 01:19:24,980
simplemente lo imprime,

1860
01:19:24,980 --> 01:19:25,760
no lo cambia.

1861
01:19:25,760 --> 01:19:28,680
Si pasamos un símbolo
de puntuación, solo lo atraviesa,

1862
01:19:28,680 --> 01:19:32,100
pero lo pasamos por una letra
minúscula, la vuelve mayúscula.

1863
01:19:32,100 --> 01:19:33,630
Y así, ahora puedo implementarlo

1864
01:19:33,630 --> 01:19:36,584
puedo apoyarme en quien
implementó eso antes que yo,

1865
01:19:36,584 --> 01:19:37,500
podría haber sido yo,

1866
01:19:37,500 --> 01:19:39,170
podría haber escrito
mi propia función toupper,

1867
01:19:39,170 --> 01:19:41,503
pero no necesité hacerlo, porque
en el mundo de la programación,

1868
01:19:41,503 --> 01:19:46,040
existen bibliotecas de códigos que
otras personas escribieron para nosotros

1869
01:19:46,040 --> 01:19:47,880
y que podemos aprovechar.

1870
01:19:47,880 --> 01:19:49,880
¿Tienen alguna pregunta al respecto?

1871
01:19:49,880 --> 01:19:50,642
Sí.

1872
01:19:50,642 --> 01:19:54,585
PÚBLICO: Entonces este método
no se podría [INAUDIBLE].

1873
01:19:54,585 --> 01:19:56,460
DAVID: Serían todos, sí.

1874
01:19:56,460 --> 01:20:00,470
Si en Stelios quisiera convertir
en mayúscula el primer...

1875
01:20:00,470 --> 01:20:04,730
la primera letra de su nombre,
probablemente no querría el bucle.

1876
01:20:04,730 --> 01:20:09,120
Probablemente solo volvería
mayúscula el [0] específico de las letras.

1877
01:20:09,120 --> 01:20:13,030
Pero me aseguraría de que su nombre
tuviera al menos un carácter de longitud

1878
01:20:13,030 --> 01:20:15,860
por si acaso se le diera Enter
de forma accidental o maliciosa.

1879
01:20:15,860 --> 01:20:17,360
Completamente.

1880
01:20:17,360 --> 01:20:21,270
Ahora vamos a sumergirnos
en otro detalle de la forma siguiente.

1881
01:20:21,270 --> 01:20:25,550
Supongamos que quiero saber
cuál es la longitud de una cadena.

1882
01:20:25,550 --> 01:20:28,610
Sé que existe esta
función llamada strlen.

1883
01:20:28,610 --> 01:20:31,880
Pero resulta que también puedo averiguar
la longitud de las cadenas por mí mismo.

1884
01:20:31,880 --> 01:20:35,210
Para continuar, escribiré un
programa que se llame strlen,

1885
01:20:35,210 --> 01:20:38,970
pero en este ejemplo no se me
permitirá utilizar la longitud de la cadena.

1886
01:20:38,970 --> 01:20:41,430
Incluiré la biblioteca de CS50,

1887
01:20:41,430 --> 01:20:44,150
también incluiré stdio.h,

1888
01:20:44,150 --> 01:20:47,600
aquí pondré int main(void)

1889
01:20:47,600 --> 01:20:50,980
y en esta parte escribiré string...

1890
01:20:50,980 --> 01:20:54,440
mal formato,
string s = get_string("Name: "),

1891
01:20:54,440 --> 01:20:55,700
"Name:  ".

1892
01:20:55,700 --> 01:20:59,330
y a continuación pondré
int n = 0.

1893
01:20:59,330 --> 01:21:02,600
Dame una variable
llamada n que sea igual a cero

1894
01:21:02,600 --> 01:21:10,580
y después pongo,
while (I'm not at the end of the string),

1895
01:21:10,580 --> 01:21:12,380
también el código que no sea válido,

1896
01:21:12,380 --> 01:21:13,550
n++;

1897
01:21:13,550 --> 01:21:17,090
puedo utilizar el truco del ++
que ya vimos antes para i++.

1898
01:21:17,090 --> 01:21:21,680
Luego imprimiré cualquiera
que sea el valor de este contador

1899
01:21:21,680 --> 01:21:23,780
porque quiero
que mi bucle cuente

1900
01:21:23,780 --> 01:21:26,120
el número de caracteres
que hay en el nombre de Stelios

1901
01:21:26,120 --> 01:21:28,110
o en el de cualquiera
que ejecute el programa.

1902
01:21:28,110 --> 01:21:30,890
Como aclaración, esto es lo que
se conoce como azúcar sintáctico,

1903
01:21:30,890 --> 01:21:35,240
es una forma muy sexy para decir
que esto es una notación abreviada,

1904
01:21:35,240 --> 01:21:38,090
lo cual se ve más aburrido.

1905
01:21:38,090 --> 01:21:39,600
Hace exactamente lo mismo,

1906
01:21:39,600 --> 01:21:41,350
simplemente es una
manera más breve de hacerlo.

1907
01:21:41,350 --> 01:21:43,190
Y verán pocas características
en los lenguajes como esta

1908
01:21:43,190 --> 01:21:44,960
para salvar a los humanos
de presionar más teclas.

1909
01:21:44,960 --> 01:21:47,279
Por supuesto, esto no es
una solución a un problema.

1910
01:21:47,279 --> 01:21:49,070
¿Cómo sé que estoy
al final de la cadena?

1911
01:21:49,070 --> 01:21:52,130
Bueno, tenemos que romper
la capa de abstracción, por así decirlo,

1912
01:21:52,130 --> 01:21:54,410
de cadenas, solo un poco.

1913
01:21:54,410 --> 01:21:58,050
Pero en la computadora
tenemos esta pieza de hardware,

1914
01:21:58,050 --> 01:21:58,550
la RAM,

1915
01:21:58,550 --> 01:21:59,630
la cual vimos el otro día.

1916
01:21:59,630 --> 01:22:01,820
Y hablamos un poco sobre
las limitaciones de las computadoras

1917
01:22:01,820 --> 01:22:03,837
y la cantidad finita
de memoria que tienen.

1918
01:22:03,837 --> 01:22:06,170
Y si pensamos en todos los
chips que hay en este dispositivo,

1919
01:22:06,170 --> 01:22:07,940
por el momento
no importa cómo funcionan,

1920
01:22:07,940 --> 01:22:10,700
pero sabemos que hay montones
y montones de bytes que pueden

1921
01:22:10,700 --> 01:22:12,800
almacenarse en
la memoria de la computadora,

1922
01:22:12,800 --> 01:22:17,420
tal vez mil millones de bytes, 1 gigabyte,
dos mil millones de bytes, 2 gigabytes.

1923
01:22:17,420 --> 01:22:21,650
Pero para nuestros fines, solo piensen
en la RAM dentro de la computadora

1924
01:22:21,650 --> 01:22:25,940
como una larga lista de bytes
disponibles, muchos bits, ceros y unos,

1925
01:22:25,940 --> 01:22:27,430
a los que les podemos
cambiar los valores.

1926
01:22:27,430 --> 01:22:29,721
Tal vez es una especie de
cuadrícula, así que hay muchos bytes

1927
01:22:29,721 --> 01:22:31,490
horizontales y verticales.

1928
01:22:31,490 --> 01:22:34,730
Podemos clasificarlos a todos,
así, un byte será el 0,

1929
01:22:34,730 --> 01:22:37,880
y aquel que está en la parte más inferior
sería el byte número 2 mil millonésimo.

1930
01:22:37,880 --> 01:22:41,570
Supongan que podemos numerar todos
los bytes en la memoria de una computadora,

1931
01:22:41,570 --> 01:22:44,810
Bueno, entonces cuando
escribimos el nombre de Stelios

1932
01:22:44,810 --> 01:22:49,630
termina con una S, pero tal vez
sería una decisión tonta buscar una S

1933
01:22:49,630 --> 01:22:51,946
al calcular la longitud
del nombre de alguien

1934
01:22:51,946 --> 01:22:53,570
porque no va a
funcionar en mi nombre,

1935
01:22:53,570 --> 01:22:57,600
no funcionará con el de María ni con
el de otras personas que están en la sala.

1936
01:22:57,600 --> 01:23:00,470
Así que aún no sabemos
bien lo que está pasando

1937
01:23:00,470 --> 01:23:03,260
dentro de la memoria
de la computadora.

1938
01:23:03,260 --> 01:23:07,130
Si pensamos en la cuadrícula
como la RAM de una computadora,

1939
01:23:07,130 --> 01:23:09,042
tal vez la esquina superior
izquierda sea el byte cero,

1940
01:23:09,042 --> 01:23:11,750
la siguiente será el byte uno,
luego el byte dos, luego el...

1941
01:23:11,750 --> 01:23:12,820
byte dos mil millones.

1942
01:23:12,820 --> 01:23:18,110
La estoy representando arbitrariamente
como una cuadrícula bidimensional.

1943
01:23:18,110 --> 01:23:21,200
Necesitamos saber que
existe este carácter especial.

1944
01:23:21,200 --> 01:23:24,980
Lo que C hace por nosotros,
incluso sin que le digamos que lo haga,

1945
01:23:24,980 --> 01:23:29,240
es poner un número secreto al final de
cualquier cadena que los humanos escriban.

1946
01:23:29,240 --> 01:23:32,030
Se representa específicamente como \0

1947
01:23:32,030 --> 01:23:34,100
y es la manera especial,
al igual que la \n,

1948
01:23:34,100 --> 01:23:37,930
para decir que hay
ocho bits cero juntos.

1949
01:23:37,930 --> 01:23:40,100
Es un valor especial 0.

1950
01:23:40,100 --> 01:23:44,360
Y ahora que tenemos
este valor llamado centinela,

1951
01:23:44,360 --> 01:23:47,090
el valor centinela
significa que es especial.

1952
01:23:47,090 --> 01:23:48,650
El humano no puede escribirlo,

1953
01:23:48,650 --> 01:23:52,010
al igual que no puedo escribir
todos los bits cero en mi teclado,

1954
01:23:52,010 --> 01:23:55,610
porque, aunque presione
el número cero, técnicamente

1955
01:23:55,610 --> 01:24:00,080
es el carácter 0, porque
los números en el teclado

1956
01:24:00,080 --> 01:24:01,760
asignan números
enteros diferentes.

1957
01:24:01,760 --> 01:24:03,020
Pero hablaremos
de eso en otro momento.

1958
01:24:03,020 --> 01:24:09,330
Entonces 00000000 son
bits o lo que sea eso.

1959
01:24:09,330 --> 01:24:12,470
Y si escribo un programa
que llame a get_string varias veces,

1960
01:24:12,470 --> 01:24:14,720
y Stelios es el primero
en escribir su nombre,

1961
01:24:14,720 --> 01:24:16,790
podría terminar
viéndose así en la memoria.

1962
01:24:16,790 --> 01:24:19,582
Pero supongamos que otra persona
escribe su nombre, por ejemplo María.

1963
01:24:19,582 --> 01:24:22,040
Su nombre cabrá en la
siguiente memoria disponible,

1964
01:24:22,040 --> 01:24:24,530
pero también terminaría
en nulo, por así decirlo.

1965
01:24:24,530 --> 01:24:28,520
Al valor centinela también se le llama
nulo, N-U-L, pero solo tiene ceros.

1966
01:24:28,520 --> 01:24:30,770
Y luego, si alguien
más escribe su nombre,

1967
01:24:30,770 --> 01:24:32,145
también encajará allí.

1968
01:24:32,145 --> 01:24:33,499
Por ejemplo, Zamyla,

1969
01:24:33,499 --> 01:24:36,290
se envuelve pero, una vez más, es
una interpretación artística arbitraria

1970
01:24:36,290 --> 01:24:37,560
de la memoria de mi computadora.

1971
01:24:37,560 --> 01:24:40,970
Z-A-M-Y-L-A, \0.

1972
01:24:40,970 --> 01:24:44,420
Y puedo seguir escribiendo nombres
hasta que me quede sin memoria.

1973
01:24:44,420 --> 01:24:46,530
En ese punto, el programa colapsará,

1974
01:24:46,530 --> 01:24:49,700
o tendré una condición if que dice
demasiadas cosas en la memoria.

1975
01:24:49,700 --> 01:24:52,550
Algo tendrá que
detenerse en ese punto.

1976
01:24:52,550 --> 01:24:54,490
Entonces, ¿qué es lo que esto
significa para mi implementación?

1977
01:24:54,490 --> 01:24:56,500
Básicamente es lo siguiente.

1978
01:24:56,500 --> 01:25:02,080
Para continuar puedo cambiar
este tonto inglés a lo siguiente.

1979
01:25:02,080 --> 01:25:11,920
while (s[n] !=

1980
01:25:11,920 --> 01:25:14,590
while (s[n] != '\0')

1981
01:25:14,590 --> 01:25:18,070
Y uso comillas simples
esta vez porque, recuerden

1982
01:25:18,070 --> 01:25:21,370
que usamos comillas simples cada vez
que hablamos de caracteres individuales.

1983
01:25:21,370 --> 01:25:24,370
Usamos comillas dobles
cada vez que hablamos de cadenas.

1984
01:25:24,370 --> 01:25:29,920
Y aunque s es una cadena, s[n] es
el n-ésimo o el i-ésimo, no importa cuál

1985
01:25:29,920 --> 01:25:31,614
letra utilicemos,
el n-ésimo carácter.

1986
01:25:31,614 --> 01:25:32,530
Entonces es un carácter.

1987
01:25:32,530 --> 01:25:34,640
Y ahora tenemos
que usar comillas simples.

1988
01:25:34,640 --> 01:25:38,217
Entonces lo que hace
es lo siguiente, inicializa n en 0

1989
01:25:38,217 --> 01:25:39,550
y luego busca en la memoria.

1990
01:25:39,550 --> 01:25:41,590
Y dice, ¿esta barra invertida es 0?

1991
01:25:41,590 --> 01:25:43,660
Si no, increméntalo n en 1.

1992
01:25:43,660 --> 01:25:44,740
¿Esta barra invertida es 0?

1993
01:25:44,740 --> 01:25:45,450
No.

1994
01:25:45,450 --> 01:25:46,110
No.

1995
01:25:46,110 --> 01:25:46,720
No.

1996
01:25:46,720 --> 01:25:47,220
No.

1997
01:25:47,220 --> 01:25:48,490
Diablos.

1998
01:25:48,490 --> 01:25:49,480
No.

1999
01:25:49,480 --> 01:25:50,520
No.

2000
01:25:50,520 --> 01:25:51,500
Sí.

2001
01:25:51,500 --> 01:25:55,960
Y en este punto tengo 7 dedos arriba
o n está almacenando el valor 7.

2002
01:25:55,960 --> 01:25:58,090
Eso es lo que mi
programa imprimirá.

2003
01:25:58,090 --> 01:26:01,690
Entonces ahora tenemos
un programa completo que cuenta

2004
01:26:01,690 --> 01:26:03,310
el número de
caracteres de una cadena.

2005
01:26:03,310 --> 01:26:06,880
No necesito este programa
porque strlen existe como una función,

2006
01:26:06,880 --> 01:26:13,090
pero ahora es una
capacidad a la que tengo acceso.

2007
01:26:13,090 --> 01:26:15,850
Alguna pregunta entonces,
sobre ¿cuál cadena

2008
01:26:15,850 --> 01:26:19,120
tiene bajo la manga
esta secuencia de caracteres

2009
01:26:19,120 --> 01:26:21,880
con un carácter
especial nulo al final?

2010
01:26:21,880 --> 01:26:23,016
Sí.

2011
01:26:23,016 --> 01:26:31,099
PÚBLICO: [INAUDIBLE]

2012
01:26:31,099 --> 01:26:32,390
DAVID: Ah, buena pregunta.

2013
01:26:32,390 --> 01:26:35,860
¿Qué pasa con otros tipos de datos,
si puedo reformularlos como ints y floats?

2014
01:26:35,860 --> 01:26:36,610
y así sucesivamente?

2015
01:26:36,610 --> 01:26:38,230
De hecho, las cadenas son especiales.

2016
01:26:38,230 --> 01:26:42,610
Si me desplazo de nuevo a la
lista de tipos de datos que tiene C,

2017
01:26:42,610 --> 01:26:46,230
por ejemplo, la mayoría
de estos son de longitud fija

2018
01:26:46,230 --> 01:26:47,980
y esta es la razón por la cual
el compilador necesita saber

2019
01:26:47,980 --> 01:26:51,021
lo que está poniendo en ellos,
porque el compilador y la computadora

2020
01:26:51,021 --> 01:26:52,414
necesitan saber si es un byte,

2021
01:26:52,414 --> 01:26:53,080
si son dos bytes,

2022
01:26:53,080 --> 01:26:53,860
si son cuatro,

2023
01:26:53,860 --> 01:26:54,490
si son ocho.

2024
01:26:54,490 --> 01:26:55,870
¿Cuántos bytes debería ver?

2025
01:26:55,870 --> 01:26:58,601
Las cadenas no tienen una
longitud predeterminada porque

2026
01:26:58,601 --> 01:27:00,600
no sabemos quién
escribirá su nombre.

2027
01:27:00,600 --> 01:27:03,520
Pero en la mayoría
de los sistemas un int siempre

2028
01:27:03,520 --> 01:27:07,480
será de 32 bits, de 64 bits,
o, de manera equivalente,

2029
01:27:07,480 --> 01:27:11,290
de cuatro bytes u ocho bytes, porque
hay una proporción de uno a ocho.

2030
01:27:11,290 --> 01:27:13,362
Un bool a menudo es un byte.

2031
01:27:13,362 --> 01:27:14,320
Es un desperdicio.

2032
01:27:14,320 --> 01:27:15,670
Aunque técnicamente
se necesita un bit,

2033
01:27:15,670 --> 01:27:18,130
es más fácil lidiar con
incrementos de ocho bits.

2034
01:27:18,130 --> 01:27:21,640
Los caracteres son, por definición,
de ocho bits o de un byte.

2035
01:27:21,640 --> 01:27:24,050
Entonces, casi todos los tipos
de datos tienen una longitud fija

2036
01:27:24,050 --> 01:27:26,920
y no se necesitará tener
un carácter especial nulo,

2037
01:27:26,920 --> 01:27:28,060
sino las cadenas que hacemos.

2038
01:27:28,060 --> 01:27:29,830
Las cadenas son especiales.

2039
01:27:29,830 --> 01:27:31,791
¿Alguna otra pregunta?

2040
01:27:31,791 --> 01:27:32,290
Muy bien.

2041
01:27:32,290 --> 01:27:35,250
Entonces, ¿qué podemos hacer con esto?

2042
01:27:35,250 --> 01:27:39,730
Bueno, esta idea
de pensar en cosas que son

2043
01:27:39,730 --> 01:27:45,490
consecutivas como
accesibles individualmente

2044
01:27:45,490 --> 01:27:46,447
es una idea muy poderosa.

2045
01:27:46,447 --> 01:27:49,030
Porque hasta ahora solo hemos
tenido esta lista de tipos de datos

2046
01:27:49,030 --> 01:27:50,640
bool, float, char e int.

2047
01:27:50,640 --> 01:27:53,740
Es una especie de lista corta
de cosas muy primitivas.

2048
01:27:53,740 --> 01:27:56,470
Pero si quieren escribir
un programa que no solo

2049
01:27:56,470 --> 01:28:00,550
siga pidiendo un nombre, sino que pida
los nombres de dos o de diez personas

2050
01:28:00,550 --> 01:28:03,571
o que pida, como lo pidieron antes,
el nombre o tal vez su casa

2051
01:28:03,571 --> 01:28:06,070
o su dormitorio o su número de teléfono
o su dirección de correo electrónico,

2052
01:28:06,070 --> 01:28:07,900
un montón de valores diferentes,

2053
01:28:07,900 --> 01:28:11,230
Sería bueno poder
almacenar varias cosas juntas.

2054
01:28:11,230 --> 01:28:17,050
Y una manera de almacenar varias
cadenas es llamar a una cadena s,

2055
01:28:17,050 --> 01:28:18,554
llamar a la siguiente cadena t,

2056
01:28:18,554 --> 01:28:21,220
llamar a la siguiente cadena
lo que sea, solo que venga

2057
01:28:21,220 --> 01:28:23,082
con nombres arbitrarios para las cadenas.

2058
01:28:23,082 --> 01:28:24,790
Pero eso evolucionará
muy rápidamente.

2059
01:28:24,790 --> 01:28:27,730
Imaginen lo que el secretario
de admisiones usa aquí o en Yale

2060
01:28:27,730 --> 01:28:29,350
para hacer un
seguimiento de los estudiantes.

2061
01:28:29,350 --> 01:28:33,790
No tiene un programa de
computadora con miles de variables dentro.

2062
01:28:33,790 --> 01:28:35,980
Probablemente tenga un
programa de computadora para guardar

2063
01:28:35,980 --> 01:28:40,120
los registros de los cursos con
al menos una variable llamada estudiantes.

2064
01:28:40,120 --> 01:28:43,390
Y dentro de esa variable de estudiantes
el secretario de admisiones puede

2065
01:28:43,390 --> 01:28:46,450
adaptarse a un estudiante,
10 estudiantes o miles de estudiantes.

2066
01:28:46,450 --> 01:28:50,410
Puede crecer para completar el número
de valores que realmente nos importa.

2067
01:28:50,410 --> 01:28:52,540
Y C no es tan poderoso como eso.

2068
01:28:52,540 --> 01:28:56,470
Necesitaremos otro lenguaje como
Python o JavaScript para obtener dinamismo.

2069
01:28:56,470 --> 01:29:00,550
Pero por ahora, tenemos la capacidad
de C para representar varias cosas

2070
01:29:00,550 --> 01:29:02,710
consecutivas, consecutivas,
consecutivas, en la memoria.

2071
01:29:02,710 --> 01:29:05,150
Entonces no solo
los caracteres en cadenas,

2072
01:29:05,150 --> 01:29:08,740
podemos tomar prestada esa idea de las
cadenas y el almacenamiento, si queremos,

2073
01:29:08,740 --> 01:29:12,520
estudiante, estudiante, estudiante,
estudiante como múltiples cadenas

2074
01:29:12,520 --> 01:29:15,250
consecutivas en vez de
solamente caracteres individuales.

2075
01:29:15,250 --> 01:29:18,480
Y a esa idea se le llama arreglo.

2076
01:29:18,480 --> 01:29:21,700
Un arreglo es un
fragmento contiguo de memoria,

2077
01:29:21,700 --> 01:29:24,280
algo consecutivo físicamente

2078
01:29:24,280 --> 01:29:28,270
próximo entre sí, generalmente en la RAM,
que hemos presentado como hardware,

2079
01:29:28,270 --> 01:29:30,597
pero que no son solo
caracteres, caracteres, caracteres.

2080
01:29:30,597 --> 01:29:33,430
Tal vez sea int, int, int, int, int
o cadena, cadena, cadena, cadena,

2081
01:29:33,430 --> 01:29:36,430
o, más generalmente, estudiante,
estudiante, estudiante, estudiante,

2082
01:29:36,430 --> 01:29:38,230
varias cosas consecutivas, consecutivas.

2083
01:29:38,230 --> 01:29:40,330
Y ahora podemos dar un vistazo

2084
01:29:40,330 --> 01:29:45,010
de lo que esta cosa
sigue escribiendo con fe.

2085
01:29:45,010 --> 01:29:48,790
Int main(void) dice que
los programas principales

2086
01:29:48,790 --> 01:29:51,580
que empezaremos a escribir
para pset uno y más allá

2087
01:29:51,580 --> 01:29:55,180
devolverán un int, incluso si
no lo hacemos nosotros mismos.

2088
01:29:55,180 --> 01:29:57,330
Devolverán 0 de
manera predeterminada

2089
01:29:57,330 --> 01:30:01,660
Y veremos en breve por qué
es útil para una función main

2090
01:30:01,660 --> 01:30:05,479
devolver un valor, a pesar de que los
humanos rara vez veremos ese valor.

2091
01:30:05,479 --> 01:30:07,270
Pero es interesante notar que main

2092
01:30:07,270 --> 01:30:12,880
toma una entrada, y no la entrada en
el sentido de get_int, get_string y demás.

2093
01:30:12,880 --> 01:30:15,280
Realmente puede
darle la entrada al programa

2094
01:30:15,280 --> 01:30:17,200
en la llamada línea de comandos.

2095
01:30:17,200 --> 01:30:21,490
Todo este tiempo
escribí ./mario0, ./mario1,

2096
01:30:21,490 --> 01:30:23,170
y no hay palabras después de eso.

2097
01:30:23,170 --> 01:30:26,410
Y sin embargo ya hemos
mostrado clang, el compilador,

2098
01:30:26,410 --> 01:30:29,770
que puede tomar,
por ejemplo -o y - lcs50,

2099
01:30:29,770 --> 01:30:33,689
esas palabras clave adicionales que de
algún modo influyen en su comportamiento.

2100
01:30:33,689 --> 01:30:35,980
Entonces, ¿no sería bueno si
pudiera escribir un programa

2101
01:30:35,980 --> 01:30:38,680
que no le pida su nombre al usuario?

2102
01:30:38,680 --> 01:30:41,350
Les dejaré escribir su nombre
en la línea de comandos

2103
01:30:41,350 --> 01:30:44,380
y presionar Enter una vez
para terminar con eso, así como clang

2104
01:30:44,380 --> 01:30:46,480
es solo un comando
largo y se termina.

2105
01:30:46,480 --> 01:30:47,770
No hay indicaciones.

2106
01:30:47,770 --> 01:30:51,500
Bueno, podemos hacerlo
si cambiamos void a esto.

2107
01:30:51,500 --> 01:30:55,690
Y es un trabalenguas, pero hay
una versión alternativa de main

2108
01:30:55,690 --> 01:30:57,400
que no solo toma cero argumentos.

2109
01:30:57,400 --> 01:30:59,650
Eso es lo que ha significado
la palabra clave void todo este tiempo.

2110
01:30:59,650 --> 01:31:01,960
Solo significa, main no toma ninguna
entrada de modo predeterminado.

2111
01:31:01,960 --> 01:31:05,510
Debe avisar al usuario explícitamente
con get_int o get_string o lo que sea.

2112
01:31:05,510 --> 01:31:09,400
Pero hay una segunda versión
alternativa de main en C

2113
01:31:09,400 --> 01:31:11,800
que toma dos entradas

2114
01:31:11,800 --> 01:31:13,960
y no tiene que
proporcionarlas explícitamente.

2115
01:31:13,960 --> 01:31:15,940
En un momento veremos cómo usarla.

2116
01:31:15,940 --> 01:31:17,920
Main también puede
recibir dos entradas.

2117
01:31:17,920 --> 01:31:22,660
Una es un int, y otra
un arreglo de cadenas.

2118
01:31:22,660 --> 01:31:25,210
El int es el número total
de palabras que el humano

2119
01:31:25,210 --> 01:31:27,820
ha escrito en su teclado.

2120
01:31:27,820 --> 01:31:30,380
El argv o argumento
del vector, por convención,

2121
01:31:30,380 --> 01:31:34,580
aunque podríamos llamarlo como
queramos, eso es un arreglo de palabras

2122
01:31:34,580 --> 01:31:38,660
que el usuario escribió
en el cursor antes de presionar Enter

2123
01:31:38,660 --> 01:31:41,910
y esto es útil de la siguiente manera.

2124
01:31:41,910 --> 01:31:45,960
A continuación, en el código fuente
de hoy, abriré un ejemplo llamado

2125
01:31:45,960 --> 01:31:47,510
argv, por argumento del vector,

2126
01:31:47,510 --> 01:31:51,170
0, como sigue.

2127
01:31:51,170 --> 01:31:54,890
En argv0, no está pasando mucho.

2128
01:31:54,890 --> 01:31:57,680
Y si al menos tenemos fe
en este concepto de aquí,

2129
01:31:57,680 --> 01:31:59,360
tal vez se pueda inferir
lo que está sucediendo.

2130
01:31:59,360 --> 01:32:02,840
Cambié el aspecto principal
de la línea seis, la firma de main,

2131
01:32:02,840 --> 01:32:03,990
por así decirlo,

2132
01:32:03,990 --> 01:32:05,330
y entonces le hago una pregunta.

2133
01:32:05,330 --> 01:32:10,700
If (argc == 2),
entonces printf ("hello... algo.

2134
01:32:10,700 --> 01:32:13,940
De lo contrario, simplemente
imprime el harcoded hello, world.

2135
01:32:13,940 --> 01:32:18,860
Parece que argv[1] está recibiendo
el mismo tratamiento que le dimos

2136
01:32:18,860 --> 01:32:20,150
a las cadenas
hace un momento.

2137
01:32:20,150 --> 01:32:22,640
Pero esta es la
nueva sintaxis especial.

2138
01:32:22,640 --> 01:32:25,130
Si utilizamos corchetes
como lo que utilicé,

2139
01:32:25,130 --> 01:32:28,460
sin números en su interior,
es como si dijéramos, hey, computadora,

2140
01:32:28,460 --> 01:32:33,440
esta variable argv será un arreglo
con algunas longitudes de cadenas.

2141
01:32:33,440 --> 01:32:34,040
¿Por qué cadenas?

2142
01:32:34,040 --> 01:32:36,873
Porque la cadena es la palabra que está
inmediatamente a la izquierda, string [] argv0.

2143
01:32:36,873 --> 01:32:38,686


2144
01:32:38,686 --> 01:32:41,060
Ahora, no sé cómo
van a llegar las cadenas allí,

2145
01:32:41,060 --> 01:32:42,810
la computadora lo hará por mí,

2146
01:32:42,810 --> 01:32:44,180
pero me da esta capacidad.

2147
01:32:44,180 --> 01:32:49,240
A continuación compilaré este programa
de la siguiente forma, make argv0.

2148
01:32:49,240 --> 01:32:52,160
./argv0.

2149
01:32:52,160 --> 01:32:52,880
hello, world.

2150
01:32:52,880 --> 01:32:54,200
Nada interesante.

2151
01:32:54,200 --> 01:32:59,092
Pero si escribo mi nombre en el cursor
y presiono Enter, se vuelve dinámico.

2152
01:32:59,092 --> 01:33:00,050
Entonces, ¿qué significa esto?

2153
01:33:00,050 --> 01:33:02,180
Aunque la sintaxis
es un poco nueva, podemos

2154
01:33:02,180 --> 01:33:04,420
inferir ahora
lo que debe estar haciendo.

2155
01:33:04,420 --> 01:33:07,040
Argc pasa por cuenta de la discusión.

2156
01:33:07,040 --> 01:33:10,967
Así que argc igual a 2 al parecer implica
que el humano escribió dos palabras

2157
01:33:10,967 --> 01:33:14,300
en el cursor, el nombre del programa
y cualquier cosa que haya escrito.

2158
01:33:14,300 --> 01:33:16,850
Mientras tanto, argv,
el argumento del vector

2159
01:33:16,850 --> 01:33:20,317
es la variable que podemos utilizar para ir
a buscar la primera o la segunda palabra

2160
01:33:20,317 --> 01:33:22,400
o, si hay más,
la tercera y cuarta palabras.

2161
01:33:22,400 --> 01:33:27,410
De hecho, si cambio esto
de forma manual, ¿que debería ser,

2162
01:33:27,410 --> 01:33:30,508
siguiendo esa lógica,
en argv[0]?

2163
01:33:30,508 --> 01:33:31,467
PÚBLICO: [INAUDIBLE]

2164
01:33:31,467 --> 01:33:33,550
DAVID MALAN: Sí, el nombre
del programa, ¿cierto?

2165
01:33:33,550 --> 01:33:34,280
Entonces, veamos.

2166
01:33:34,280 --> 01:33:35,220
make argv0

2167
01:33:35,220 --> 01:33:37,870


2168
01:33:37,870 --> 01:33:41,180
./argv0 David

2169
01:33:41,180 --> 01:33:41,970
Hello... OK.

2170
01:33:41,970 --> 01:33:44,750
Quiero decir, se ve algo tonto
pero que es lo que estoy haciendo.

2171
01:33:44,750 --> 01:33:49,670
¿Podría ser atrevido y decir lo que está
en la centésima ubicación de este arreglo

2172
01:33:49,670 --> 01:33:51,980
o lista, como también podrían verla?

2173
01:33:51,980 --> 01:33:53,640
make argv0

2174
01:33:53,640 --> 01:33:54,930
./david.

2175
01:33:54,930 --> 01:33:56,870
¡Huy!

2176
01:33:56,870 --> 01:33:57,710
Eso es malo.

2177
01:33:57,710 --> 01:34:01,040
Acostúmbrense a esto porque
sucederá con mayor frecuencia.

2178
01:34:01,040 --> 01:34:05,840
El fallo de segmentación es la forma
de decir que tocamos la memoria RAM,

2179
01:34:05,840 --> 01:34:07,070
lo cual no deberíamos hacer.

2180
01:34:07,070 --> 01:34:08,945
Piensen en lo que esto significa.

2181
01:34:08,945 --> 01:34:14,360
Si argv[0]... dejen saco
mi imagen de un arreglo.

2182
01:34:14,360 --> 01:34:20,300
Si mi arreglo se ve así y argv[0]
está aquí, y es seguro imprimirlo,

2183
01:34:20,300 --> 01:34:21,134
argv[1] está aquí,

2184
01:34:21,134 --> 01:34:22,091
es seguro imprimirlo,

2185
01:34:22,091 --> 01:34:22,730
es mi nombre

2186
01:34:22,730 --> 01:34:23,900
Y argv, que hice,

2187
01:34:23,900 --> 01:34:26,630
100, está como por aquí,

2188
01:34:26,630 --> 01:34:27,980
No sé qué hay aquí.

2189
01:34:27,980 --> 01:34:31,040
Y de hecho, tocar
esa memoria fue muy malo.

2190
01:34:31,040 --> 01:34:32,450
El programa se bloqueó.

2191
01:34:32,450 --> 01:34:35,869
Y el fallo de segmentación alude a cómo
las computadoras distribuyen la memoria.

2192
01:34:35,869 --> 01:34:38,660
Se tiene un segmento de memoria
aquí, un segmento de memoria acá,

2193
01:34:38,660 --> 01:34:39,701
un segmento de memoria allá.

2194
01:34:39,701 --> 01:34:42,290
Fallo de segmentación significa
que se tocó un fragmento de memoria

2195
01:34:42,290 --> 01:34:46,310
que no podíamos utilizar,
cambiar o incluso ver.

2196
01:34:46,310 --> 01:34:48,620
Así que tuve suerte, aunque...
bueno, no tuve suerte.

2197
01:34:48,620 --> 01:34:50,180
A veces podría ver valores basura.

2198
01:34:50,180 --> 01:34:51,721
Seré un poco más conservador.

2199
01:34:51,721 --> 01:34:54,770
Me deja poner [2], que solo es
uno más de lo que he escrito.

2200
01:34:54,770 --> 01:34:56,910
A veces tiene
un comportamiento indefinido.

2201
01:34:56,910 --> 01:34:58,670
No sé lo que me va a dar.

2202
01:34:58,670 --> 01:34:59,240
Nulo.

2203
01:34:59,240 --> 01:35:02,110
Así que hay algunos
caracteres apestosos o ceros por allí.

2204
01:35:02,110 --> 01:35:04,760
Pero ahora estamos
jugando con fuego, por así decirlo.

2205
01:35:04,760 --> 01:35:07,130
Estos son errores lógicos en mi programa.

2206
01:35:07,130 --> 01:35:11,990
Pero está bien para comprobar si
if argc == 2, entonces

2207
01:35:11,990 --> 01:35:16,370
está bien observar al 0 y al 1,
dos cosas y solo dos cosas.

2208
01:35:16,370 --> 01:35:18,910
¿Tienen alguna pregunta al respecto?

2209
01:35:18,910 --> 01:35:19,410
Muy bien.

2210
01:35:19,410 --> 01:35:22,850
Entonces, ¿dónde, en qué dominio
son útiles este tipo de cosas?

2211
01:35:22,850 --> 01:35:26,270
Hay un par de ejemplos más
de argv que pueden ver en línea.

2212
01:35:26,270 --> 01:35:29,300
Ocurre que en el
mundo de la criptografía,

2213
01:35:29,300 --> 01:35:31,250
esto comienza
a ponerse interesante.

2214
01:35:31,250 --> 01:35:34,081
Entonces, en el mundo de la criptografía
se trata de codificar la información.

2215
01:35:34,081 --> 01:35:35,830
Tal vez en la escuela primaria

2216
01:35:35,830 --> 01:35:38,870
le pasaron notas a un amigo
o enamorado que tenían en el aula.

2217
01:35:38,870 --> 01:35:41,870
Y si eran realmente inteligentes
o si el maestro era conflictivo,

2218
01:35:41,870 --> 01:35:45,350
es posible que codificaran
su mensaje, así que no solo escribían

2219
01:35:45,350 --> 01:35:46,940
"te amo" o lo que fuera.

2220
01:35:46,940 --> 01:35:50,090
En vez de ello
cambiaban todas las A por B

2221
01:35:50,090 --> 01:35:53,510
y las B por C, o tal vez
por algo más complejo

2222
01:35:53,510 --> 01:35:57,050
para que el maestro no pudiera
cambiar las B por A y las C por B.

2223
01:35:57,050 --> 01:35:58,910
Pero en cierto modo
revolvían las palabras.

2224
01:35:58,910 --> 01:36:03,020
Revolvían las palabras de tal manera

2225
01:36:03,020 --> 01:36:07,070
que fueran reversibles
para el receptor, el receptor

2226
01:36:07,070 --> 01:36:08,480
de su mensaje encriptado.

2227
01:36:08,480 --> 01:36:13,100
Entonces, encriptar información
significa convertirla a otro formato,

2228
01:36:13,100 --> 01:36:17,540
de lo que se llama texto plano
a texto cifrado, lo cual suena genial,

2229
01:36:17,540 --> 01:36:19,740
y es solo la versión codificada.

2230
01:36:19,740 --> 01:36:20,850
Pero no es aleatorio.

2231
01:36:20,850 --> 01:36:22,724
Debe seguir un patrón
o, si lo prefieren,

2232
01:36:22,724 --> 01:36:26,480
un algoritmo, así la persona que está al
otro extremo puede invertir el algoritmo

2233
01:36:26,480 --> 01:36:27,380
y descifrarlo.

2234
01:36:27,380 --> 01:36:29,720
Ahora, en el ejemplo simple
que propuse, A se convierte en B,

2235
01:36:29,720 --> 01:36:33,810
B se convierte en C. ¿Cuál es el secreto
que ustedes y su enamorado conocen?

2236
01:36:33,810 --> 01:36:35,540
Probablemente solo es el número uno.

2237
01:36:35,540 --> 01:36:38,740
Esa persona debe saber
que si le sumaron 1 a las letras,

2238
01:36:38,740 --> 01:36:40,589
entonces debe
restar 1 a las letras

2239
01:36:40,589 --> 01:36:43,880
y con suerte sabrá
que si es Z, debe regresar a la A

2240
01:36:43,880 --> 01:36:46,379
y no seguir una
puntuación rara o algo así.

2241
01:36:46,379 --> 01:36:48,750
Entonces pueden tener
un algoritmo tan simple como ese.

2242
01:36:48,750 --> 01:36:52,550
Así que podemos ver la criptografía como
un ejemplo de resolución de problemas.

2243
01:36:52,550 --> 01:36:56,030
Desean enviar un
mensaje de alguien, ustedes,

2244
01:36:56,030 --> 01:36:58,479
a alguien más, tal vez por medio
de un método muy inseguro

2245
01:36:58,479 --> 01:37:00,020
como pasar una nota a través del salón,

2246
01:37:00,020 --> 01:37:02,790
y desean que solo una persona
sepa cómo acceder a él.

2247
01:37:02,790 --> 01:37:05,060
Es similar a que ustedes proporcionen
entradas y obtengan salidas,

2248
01:37:05,060 --> 01:37:07,220
su texto plano y su texto cifrado,
de modo que nadie

2249
01:37:07,220 --> 01:37:09,320
pueda entenderlo,
excepto ustedes y el destinatario.

2250
01:37:09,320 --> 01:37:11,131
Entonces, la criptografía

2251
01:37:11,131 --> 01:37:14,130
tiene diferentes formas, pero
tal vez la más simple se parece a esto.

2252
01:37:14,130 --> 01:37:17,930
Hay dos entradas, el texto plano
y el mensaje que deseamos enviar,

2253
01:37:17,930 --> 01:37:22,119
y luego la clave, que puede ser
un número como 1, 2, 25 o 26.

2254
01:37:22,119 --> 01:37:24,410
Tener un número más grande
que ese sería algo tonto porque

2255
01:37:24,410 --> 01:37:26,790
solo le daría la vuelta
al alfabeto, por así decirlo.

2256
01:37:26,790 --> 01:37:29,960
Pero la salida será
algo que se llama texto cifrado.

2257
01:37:29,960 --> 01:37:31,880
Y cuando sus enamorados
reciban el mensaje,

2258
01:37:31,880 --> 01:37:34,520
solo necesitan revertir el proceso.

2259
01:37:34,520 --> 01:37:35,669
Deben conocer la clave,

2260
01:37:35,669 --> 01:37:38,960
de lo contrario, se la pasarían
todo el día adivinando lo que decía

2261
01:37:38,960 --> 01:37:39,560
el mensaje.

2262
01:37:39,560 --> 01:37:42,920
Pero siempre y cuando
conozcan el secreto, podrán descifrarlo.

2263
01:37:42,920 --> 01:37:44,480
Ahora, por supuesto
que hay una trampa.

2264
01:37:44,480 --> 01:37:47,750
Tienen que hablar en los mismos términos
que la persona a la que están enamorando,

2265
01:37:47,750 --> 01:37:51,660
ya que debe conocer
la clave por adelantado,

2266
01:37:51,660 --> 01:37:54,420
de lo contrario, solo estarían
enviando valores sin sentido.

2267
01:37:54,420 --> 01:37:56,570
Así que también es
una especie de círculo vicioso.

2268
01:37:56,570 --> 01:38:00,080
Para enviar un mensaje secreto de A a B,

2269
01:38:00,080 --> 01:38:04,231
A y B deben deliberar y acordar
con anticipación dicho secreto.

2270
01:38:04,231 --> 01:38:06,230
Pero si necesitan ponerse
de acuerdo por adelantado,

2271
01:38:06,230 --> 01:38:09,660
¿por qué no utilizan ese tiempo para
dar el mensaje directamente a la persona?

2272
01:38:09,660 --> 01:38:10,160
¿Verdad?

2273
01:38:10,160 --> 01:38:11,210
Entonces hay una desconexión.

2274
01:38:11,210 --> 01:38:13,670
Y volveremos a esto muy pronto
porque la mayoría de nosotros

2275
01:38:13,670 --> 01:38:16,487
probablemente no conoce a alguien
que trabaja en amazon.com.

2276
01:38:16,487 --> 01:38:18,320
Pero, cuando compro
algo en Amazon,

2277
01:38:18,320 --> 01:38:20,570
todos estos años
me han dicho que es seguro,

2278
01:38:20,570 --> 01:38:21,440
que está encriptado.

2279
01:38:21,440 --> 01:38:23,750
Mi tarjeta de crédito, mi nombre
y todo eso, de alguna manera están

2280
01:38:23,750 --> 01:38:27,440
encriptados entre Amazon y yo, en Seattle
o donde sea que estén sus servidores.

2281
01:38:27,440 --> 01:38:29,030
Pero no conozco a nadie allí.

2282
01:38:29,030 --> 01:38:30,880
Y sin embargo, de alguna manera,
la criptografía también funciona.

2283
01:38:30,880 --> 01:38:34,910
Este tipo de cartografía es conocida
como criptografía de clave secreta.

2284
01:38:34,910 --> 01:38:37,500
Pero también hay criptografía
de clave pública y otras más.

2285
01:38:37,500 --> 01:38:40,040
Y entonces, lo que encontrarán
de particular en la serie de problemas dos

2286
01:38:40,040 --> 01:38:42,264
es que tendrán la oportunidad
de explorar este mundo

2287
01:38:42,264 --> 01:38:44,930
en el cual escribirán un software
que encripte y luego, con suerte,

2288
01:38:44,930 --> 01:38:48,680
descifra la información e incluso,
si usted está entre los más cómodos,

2289
01:38:48,680 --> 01:38:51,470
una oportunidad para
tratar de escribir software

2290
01:38:51,470 --> 01:38:53,900
que maneje contraseñas cifradas,

2291
01:38:53,900 --> 01:38:55,760
o dicho más precisamente, encriptadas.

2292
01:38:55,760 --> 01:38:57,020
Más aún, tarde o temprano,

2293
01:38:57,020 --> 01:39:00,440
tratarán de romper
las contraseñas, es decir, descifrar

2294
01:39:00,440 --> 01:39:02,720
cuáles eran las contraseñas.

2295
01:39:02,720 --> 01:39:06,020
Y al final todo se reduce,
en el contexto de C,

2296
01:39:06,020 --> 01:39:09,300
a tomar un mensaje
como entrada, un texto plano,

2297
01:39:09,300 --> 01:39:11,750
y de alguna manera convertirlo
en texto cifrado, manipulando

2298
01:39:11,750 --> 01:39:15,480
sus caracteres individuales,
o a la inversa, si eres el destinatario.

2299
01:39:15,480 --> 01:39:18,860
Y me gustaría mostrar un clip
de una película que pueden ver

2300
01:39:18,860 --> 01:39:22,580
cada hora en punto durante la
época decembrina, "Una historia

2301
01:39:22,580 --> 01:39:25,581
de Navidad", porque contiene
un ejemplo sencillo sobre la criptografía.

2302
01:39:25,581 --> 01:39:27,705
Si nunca han visto esta película,
él es el pequeño Ralphie,

2303
01:39:27,705 --> 01:39:30,080
y está muy emocionado
porque durante meses o algo así

2304
01:39:30,080 --> 01:39:32,900
junta y envía todas esas como...

2305
01:39:32,900 --> 01:39:34,730
etiquetas que vienen
en las cajas de cereales, o algo así,

2306
01:39:34,730 --> 01:39:37,850
y consigue por fin
este anillo decodificador secreto.

2307
01:39:37,850 --> 01:39:40,610
Y el anillo decodificador secreto
es una especie de simpático modelo mental

2308
01:39:40,610 --> 01:39:43,350
para ilustrar el tipo de criptografía
que estoy proponiendo aquí,

2309
01:39:43,350 --> 01:39:44,930
este tipo de idea sobre la rotación,

2310
01:39:44,930 --> 01:39:47,630
A se convierte B, B se convierte en C.
Porque si se imaginan

2311
01:39:47,630 --> 01:39:50,000
un anillo que tiene
otro anillo en el exterior,

2312
01:39:50,000 --> 01:39:53,679
pueden alinear las A y las Z,
por así decirlo, de manera diferente.

2313
01:39:53,679 --> 01:39:55,220
Y eso es para lo que estaba ahorrando.

2314
01:39:55,220 --> 01:39:57,595
Así que pensé que debíamos
dedicar un momento para ver este clip

2315
01:39:57,595 --> 01:39:59,464
e inspirar uno de los problemas
que tenemos por delante.

2316
01:39:59,464 --> 01:40:00,130
[REPRODUCCIÓN DE VIDEO]

2317
01:40:00,130 --> 01:40:03,390
-Sea conocido por todos que Ralphie Parker

2318
01:40:03,390 --> 01:40:05,862
ha sido nombrado miembro
del Club Secreto de Anita la Huerfanita

2319
01:40:05,862 --> 01:40:08,570
y goza de todos
sus honores y beneficios.

2320
01:40:08,570 --> 01:40:09,642
también

2321
01:40:09,642 --> 01:40:12,200
-¡Firma: Anita la Huerfanita!

2322
01:40:12,200 --> 01:40:14,890
¡Contrafirma: Pierre André!

2323
01:40:14,890 --> 01:40:16,340
¡En tinta!

2324
01:40:16,340 --> 01:40:18,920
¡Honores y beneficios
a los nueve años de edad!

2325
01:40:18,920 --> 01:40:22,364


2326
01:40:22,364 --> 01:40:25,711
-¡No exageremos!

2327
01:40:25,711 --> 01:40:26,210
-Vamos,

2328
01:40:26,210 --> 01:40:27,200
continuemos 
con el programa.

2329
01:40:27,200 --> 01:40:31,172
No necesito todo eso
de contrabandistas y piratas.

2330
01:40:31,172 --> 01:40:33,590
-Escuchen mañana por la noche 
la aventura final de

2331
01:40:33,590 --> 01:40:35,840
"El barco pirata negro".

2332
01:40:35,840 --> 01:40:41,810
Ha llegado la hora del mensaje
secreto para los miembros del club.

2333
01:40:41,810 --> 01:40:45,530
Recuerden que solo
los miembros del club secreto

2334
01:40:45,530 --> 01:40:48,160
pueden descifrar
el mensaje secreto de Anita.

2335
01:40:48,160 --> 01:40:52,080
Recuerden que Anita
cuenta con ustedes.

2336
01:40:52,080 --> 01:40:54,860
Coloquen sus
plumas en la clave B2.

2337
01:40:54,860 --> 01:40:56,892
He aquí el mensaje.

2338
01:40:56,892 --> 01:40:58,390
12... 11...

2339
01:40:58,390 --> 01:40:59,600
-Estoy dentro.

2340
01:40:59,600 --> 01:41:01,570
Es mi primera reunión secreta.

2341
01:41:01,570 --> 01:41:05,300
...14... 11... 18... 16...

2342
01:41:05,300 --> 01:41:07,730
-Oh, Pierre estuvo muy bien anoche.

2343
01:41:07,730 --> 01:41:10,820
Yo sabía que el mensaje
iba a ser importante.

2344
01:41:10,820 --> 01:41:12,680
...3... 25...

2345
01:41:12,680 --> 01:41:14,720
Es un mensaje de la propia Anita.

2346
01:41:14,720 --> 01:41:15,960
Recuerden, no se lo digan a nadie.

2347
01:41:15,960 --> 01:41:20,780


2348
01:41:20,780 --> 01:41:24,870
90 segundos después me traslade al
único cuarto donde un niño de nueve años

2349
01:41:24,870 --> 01:41:29,050
podía sentarse y descifrar a solas.

2350
01:41:29,050 --> 01:41:29,740
¡Ajá!

2351
01:41:29,740 --> 01:41:31,490
¡B!

2352
01:41:31,490 --> 01:41:33,340
Pasé al siguiente.

2353
01:41:33,340 --> 01:41:36,596
¡E! ¡La primera palabra es "be"!

2354
01:41:36,596 --> 01:41:38,880
S, cada vez era más fácil.

2355
01:41:38,880 --> 01:41:40,614
U.

2356
01:41:40,614 --> 01:41:42,542
-¡Oh, vamos, Ralphie!

2357
01:41:42,542 --> 01:41:43,988
¡Tengo que irme!

2358
01:41:43,988 --> 01:41:46,398
-¡Salgo enseguida, mamá!

2359
01:41:46,398 --> 01:41:47,362
Recórcholis.

2360
01:41:47,362 --> 01:41:50,254


2361
01:41:50,254 --> 01:41:53,510
-¡T, O!

2362
01:41:53,510 --> 01:41:55,900
"No olvides"... ¿No olvides qué?

2363
01:41:55,900 --> 01:41:57,870
¿Qué trataba de decir Anita?

2364
01:41:57,870 --> 01:41:58,670
"No olvides", ¿qué?

2365
01:41:58,670 --> 01:42:00,070
-Ralphie, Randy tiene que irse.

2366
01:42:00,070 --> 01:42:01,504
¿Quieres salir, por favor?

2367
01:42:01,504 --> 01:42:02,810
-¡Sí, mamá!

2368
01:42:02,810 --> 01:42:04,910
¡Ya voy!

2369
01:42:04,910 --> 01:42:06,740
-Ya estaba cerca

2370
01:42:06,740 --> 01:42:08,150
Qué terrible tensión.

2371
01:42:08,150 --> 01:42:09,652
¿Qué era eso?

2372
01:42:09,652 --> 01:42:11,610
El destino del planeta
podía estar en juego.

2373
01:42:11,610 --> 01:42:12,110
[TOQUIDOS]

2374
01:42:12,110 --> 01:42:15,450
-¡Ralph! ¡Randy tiene que irse!

2375
01:42:15,450 --> 01:42:18,330
-¡Saldría para gritarlo!

2376
01:42:18,330 --> 01:42:20,013
DAVID: ¡Ya casi!
¡Casi lo tenía!

2377
01:42:20,013 --> 01:42:21,220
Mis dedos volaron.

2378
01:42:21,220 --> 01:42:22,940
Mi mente era una trampa de acero.

2379
01:42:22,940 --> 01:42:24,650
Cada poro vibraba.

2380
01:42:24,650 --> 01:42:26,744
Era casi claro.

2381
01:42:26,744 --> 01:42:27,244
¡Sí!

2382
01:42:27,244 --> 01:42:27,721
¡Sí!

2383
01:42:27,721 --> 01:42:28,221
¡Sí!

2384
01:42:28,221 --> 01:42:29,152
¡Sí!

2385
01:42:29,152 --> 01:42:34,890
-"Asegúrate de tomar
tu chocolate Ovamaltina"

2386
01:42:34,890 --> 01:42:35,520
¿Ovamaltina?

2387
01:42:35,520 --> 01:42:39,532


2388
01:42:39,532 --> 01:42:41,380
¿Es un miserable comercial?

2389
01:42:41,380 --> 01:42:44,158


2390
01:42:44,158 --> 01:42:45,445
¡Hijos de p...!

2391
01:42:45,445 --> 01:42:46,740
[FINALIZA LA REPRODUCCIÓN]

2392
01:42:46,740 --> 01:42:48,190
DAVID: Esto fue CS50.

2393
01:42:48,190 --> 01:42:49,600
¡Hasta la próxima!

2394
01:42:49,600 --> 01:42:52,350
[APLAUSOS]