Upload via hfc (batch)

Uploaded using hfc tool

.gitattributes

@@ -105,3 +105,16 @@ subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Inge
 subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/04-Archivos[[:space:]]y[[:space:]]estructuras[[:space:]]de[[:space:]]datos/03-Videos[[:space:]]contenedores[[:space:]]codecs[[:space:]]y[[:space:]]protocolos.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/04-Archivos[[:space:]]y[[:space:]]estructuras[[:space:]]de[[:space:]]datos/04-Cómo[[:space:]]Funciona[[:space:]]un[[:space:]]zip.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/05-Introducción[[:space:]]a[[:space:]]Blockchain[[:space:]]e[[:space:]]Inteligencia[[:space:]]Artificial/01-Arquitectura[[:space:]]y[[:space:]]funcionamiento[[:space:]]interno[[:space:]]de[[:space:]]Blockchain.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/05-Introducción[[:space:]]a[[:space:]]Blockchain[[:space:]]e[[:space:]]Inteligencia[[:space:]]Artificial/02-Qué[[:space:]]es[[:space:]]una[[:space:]]red[[:space:]]neuronal.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/05-Introducción[[:space:]]a[[:space:]]Blockchain[[:space:]]e[[:space:]]Inteligencia[[:space:]]Artificial/03-Cómo[[:space:]]funcionan[[:space:]]los[[:space:]]LLMs.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/01-Bienvenida/01-Control[[:space:]]de[[:space:]]Flujo[[:space:]]y[[:space:]]Arrays[[:space:]]en[[:space:]]C[[:space:]]IF[[:space:]]WHILE[[:space:]]FOR[[:space:]]y[[:space:]]más.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/02-Toma[[:space:]]de[[:space:]]decisiones/01-Uso[[:space:]]del[[:space:]]Condicional[[:space:]]IF[[:space:]]en[[:space:]]Lenguaje[[:space:]]C[[:space:]]para[[:space:]]Decisiones[[:space:]]Lógicas.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/02-Toma[[:space:]]de[[:space:]]decisiones/02-Manejo[[:space:]]de[[:space:]]Condicionales[[:space:]]IfElse[[:space:]]en[[:space:]]Lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/02-Toma[[:space:]]de[[:space:]]decisiones/03-If[[:space:]]anidados[[:space:]]en[[:space:]]C[[:space:]]Creación[[:space:]]de[[:space:]]menús[[:space:]]interactivos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/02-Toma[[:space:]]de[[:space:]]decisiones/04-Estructura[[:space:]]y[[:space:]]uso[[:space:]]del[[:space:]]switch[[:space:]]en[[:space:]]programación[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/03-Control[[:space:]]de[[:space:]]Bucles[[:space:]]en[[:space:]]C/01-Bucle[[:space:]]While[[:space:]]en[[:space:]]C[[:space:]]Implementación[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/03-Control[[:space:]]de[[:space:]]Bucles[[:space:]]en[[:space:]]C/02-Ciclos[[:space:]]WHILE[[:space:]]y[[:space:]]DOWHILE[[:space:]]en[[:space:]]Programación.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/03-Control[[:space:]]de[[:space:]]Bucles[[:space:]]en[[:space:]]C/03-Uso[[:space:]]del[[:space:]]Ciclo[[:space:]]FOR[[:space:]]en[[:space:]]Programación[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/01-Uso[[:space:]]de[[:space:]]la[[:space:]]Instrucción[[:space:]]Break[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/02-Uso[[:space:]]del[[:space:]]Continue[[:space:]]en[[:space:]]Bucles[[:space:]]de[[:space:]]Programación.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/03-Uso[[:space:]]seguro[[:space:]]de[[:space:]]GOTO[[:space:]]en[[:space:]]manejo[[:space:]]de[[:space:]]errores[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso de Control de Flujo en C/01-Bienvenida/01-Control de Flujo y Arrays en C IF WHILE FOR y más.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d66aa5b8a2552176103ed5d92ef993f31160595373ad88b46ea4472087f16d66
+size 26753376

subir/Curso de Control de Flujo en C/01-Bienvenida/01-Control de Flujo y Arrays en C IF WHILE FOR y más.vtt

@@ -0,0 +1,200 @@
+WEBVTT
+
+00:03.320 --> 00:07.000
+¡Hey! Bienvenida o bienvenido
+al curso de programación en C.
+
+00:07.000 --> 00:09.200
+Si estás aquí es porque ya viste
+el curso anterior
+
+00:09.200 --> 00:12.000
+en donde te enseñaba las bases,
+tipos de datos,
+
+00:12.000 --> 00:14.000
+cómo ejecutar un programa en C,
+
+00:14.000 --> 00:17.700
+cómo instalarlo en tu computadora Windows
+o de sistema UNIX.
+
+00:17.700 --> 00:20.300
+También te enseñé cómo podríamos
+
+00:20.300 --> 00:22.400
+nosotros trabajar la estructura general
+de un programa
+
+00:22.400 --> 00:25.800
+y cómo utilizar las funciones más
+importantes de C,
+
+00:25.800 --> 00:28.800
+una de las funciones
+más importantes como es Print.
+
+00:28.800 --> 00:30.800
+Luego, en este curso ya vamos a entrar
+
+00:30.800 --> 00:33.000
+en la carne del lenguaje de programación.
+
+00:33.000 --> 00:35.600
+Ya estás preparada o preparado
+para entender
+
+00:35.600 --> 00:38.000
+cómo se maneja el flujo en un programa,
+
+00:38.000 --> 00:40.700
+cómo se maneja
+la toma de decisiones en un programa,
+
+00:40.700 --> 00:42.500
+por ejemplo, con la instrucción IF,
+
+00:42.500 --> 00:46.600
+cómo se manejan los bucles o loops en C
+
+00:46.600 --> 00:48.800
+con la instrucción WHILE,
+con la instrucción DO WHILE,
+
+00:48.800 --> 00:50.300
+con las instrucciones FOR.
+
+00:50.300 --> 00:54.000
+Vamos a aprender también a detalle
+cómo utilizar el BREAK
+
+00:54.000 --> 00:57.400
+para que sepas en dónde entra
+este importantísimo
+
+00:57.400 --> 01:00.500
+comando de control de flujo
+en tu programa.
+
+01:00.500 --> 01:03.400
+También vamos a ver 
+una de las estructuras de datos
+
+01:03.400 --> 01:05.900
+más utilizadas en C, que es el Array.
+
+01:05.900 --> 01:07.900
+Vamos a aprender
+a almacenar datos en Array,
+
+01:07.900 --> 01:09.900
+leer datos en un Array y más.
+
+01:09.900 --> 01:11.900
+Y luego, bueno, ya sabes,
+
+01:11.900 --> 01:14.600
+estamos dividiendo todos los cursos
+de lenguajes de programación
+
+01:14.600 --> 01:16.500
+porque un lenguaje de programación
+
+01:16.500 --> 01:18.700
+no cabe en un solo curso
+y queremos que tengas
+
+01:18.700 --> 01:22.200
+la facilidad de irlos consultando
+poco a poco,
+
+01:22.200 --> 01:25.400
+paso a paso
+y aprendiéndolos curso a curso.
+
+01:25.400 --> 01:27.900
+Por eso tendremos más de dos cursos de C.
+
+01:27.900 --> 01:30.200
+La idea es sacar cuatro inicialmente,
+
+01:30.200 --> 01:32.400
+en donde el siguiente serían
+funcionalidades
+
+01:32.400 --> 01:33.800
+más avanzadas del lenguaje
+
+01:33.800 --> 01:37.300
+y luego llegaríamos a la parte de manejo
+de memoria,
+
+01:37.300 --> 01:39.300
+todo lo que tiene que ver con punteros
+
+01:39.300 --> 01:41.700
+o manejo dinámico de la memoria
+
+01:41.700 --> 01:44.000
+en programas en el lenguaje C.
+
+01:45.000 --> 01:47.300
+Con esto dicho, quiero aprovechar
+a presentarme.
+
+01:47.300 --> 01:50.300
+Yo soy Ricardo Celis,
+soy profesor en Platzi,
+
+01:50.300 --> 01:53.500
+soy también miembro
+de todo lo que tiene que ver
+
+01:53.500 --> 01:56.000
+con la ejecución y planeación de cursos.
+
+01:56.000 --> 01:58.400
+Estoy dirigiendo la ejecución
+y planeación de cursos
+
+01:58.400 --> 01:59.900
+de desarrollo de software
+
+01:59.900 --> 02:01.900
+y todo lo que tiene que ver en esta área.
+
+02:01.900 --> 02:04.500
+Así que, bueno, estoy muy feliz de estar
+aquí contigo.
+
+02:04.500 --> 02:06.300
+Por favor, si tienes alguna duda,
+
+02:06.300 --> 02:09.400
+escríbeme a mi Twitter, es @celismx.
+
+02:09.400 --> 02:11.600
+Cuéntame, profe, empecé su curso de C,
+
+02:11.600 --> 02:13.500
+estoy emocionada, estoy emocionado.
+
+02:13.500 --> 02:15.200
+Y ahí yo estaré muy pendiente de darte
+
+02:15.200 --> 02:17.200
+el seguimiento que te mereces.
+
+02:17.200 --> 02:19.300
+Todas tus dudas
+me las puedes mandar por ahí.
+
+02:19.300 --> 02:22.100
+Y sin más,
+quiero darte la bienvenida
+
+02:22.100 --> 02:23.900
+y gracias por estar aquí en este curso.
+
+02:23.900 --> 02:29.900
+Nos vemos en la próxima clase.

subir/Curso de Control de Flujo en C/01-Bienvenida/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/clases/lenguaje-c/

subir/Curso de Control de Flujo en C/02-Toma de decisiones/01-Uso del Condicional IF en Lenguaje C para Decisiones Lógicas.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8cde56be962660871a214868be340af537938873157058e62bc0d961c2e4ff0
+size 63090949

subir/Curso de Control de Flujo en C/02-Toma de decisiones/01-Uso del Condicional IF en Lenguaje C para Decisiones Lógicas.vtt

@@ -0,0 +1,401 @@
+WEBVTT
+
+00:03.193 --> 00:06.899
+En esta clase te voy a enseñar
+cómo utilizar el condicional IF
+
+00:07.025 --> 00:09.320
+para tomar decisiones en tu código.
+
+00:09.836 --> 00:12.642
+Nos vamos, lo primero, igual,
+antes de entrar directamente en IF,
+
+00:12.768 --> 00:15.129
+es que quiero dejarte claro qué es
+
+00:15.254 --> 00:18.320
+un statement en C
+y qué es un bloque de código.
+
+00:18.625 --> 00:23.640
+Un statement es, por ejemplo, cuando
+nosotros declaramos una simple variable,
+
+00:23.640 --> 00:26.167
+o cuando nosotros imprimimos algo.
+
+00:26.413 --> 00:29.390
+Digamos printf, hello world, esta línea,
+
+00:30.690 --> 00:34.501
+a esta sola línea de código
+que se encarga de imprimir algo,
+
+00:34.627 --> 00:39.560
+se le conoce como statement
+o una línea de código.
+
+00:39.560 --> 00:42.007
+Veámoslo como la unidad de código en C.
+
+00:42.133 --> 00:45.000
+Una línea que cierra con punto y coma.
+
+00:45.303 --> 00:47.160
+Por eso es tan importante el punto y coma,
+
+00:47.160 --> 00:53.665
+es la instrucción que es el caracter
+que cierra o termina statements.
+
+00:53.885 --> 00:56.960
+Mira, aquí en nuestros programas nosotros
+tenemos muchísimos statements.
+
+00:56.960 --> 00:59.591
+Por ejemplo, aquí hay uno, aquí hay otro.
+
+00:59.717 --> 01:04.200
+Vamos a ponerlos acá para el ejemplo
+de lo que es un statement.
+
+01:04.773 --> 01:06.760
+Todo esto es un statement.
+
+01:07.424 --> 01:11.320
+Pero en C no solo vamos a tener líneas
+de código individuales,
+
+01:11.320 --> 01:16.000
+también podemos tener bloques
+o grupos de statements y o declaraciones.
+
+01:16.379 --> 01:21.440
+Estos grupos siempre van a estar definidos
+por estas llaves y serían así.
+
+01:23.055 --> 01:29.440
+Podemos copiar este código que tenemos
+arriba y pegarlo aquí adentro.
+
+01:30.507 --> 01:32.421
+Muy bien, todo bonito.
+
+01:32.864 --> 01:37.043
+Vamos a identar, ya sabes, contabulador
+identas, para que se vea bien.
+
+01:37.169 --> 01:39.918
+Y con esto lo que estamos diciendo
+
+01:40.043 --> 01:43.400
+es que estas tres líneas de código
+o estos tres statements
+
+01:43.400 --> 01:46.840
+se juntan para formar un bloque de código.
+
+01:47.535 --> 01:51.139
+Entonces tenemos statements,
+que son las líneas de código individuales,
+
+01:51.265 --> 01:56.401
+y bloques que van a estar contenidos
+por nuestros bracers o corchetes.
+
+01:57.194 --> 02:02.120
+Con esto ya sabes que vamos a tener
+statements o vamos a tener bloques.
+
+02:02.508 --> 02:05.132
+Los statements son
+simples unidadesde código,
+
+02:05.258 --> 02:06.669
+la unidad básica de código,
+
+02:06.795 --> 02:10.920
+y los bloques son conjuntos de statements.
+
+02:10.920 --> 02:13.520
+Pueden tener dos o más, idealmente.
+
+02:13.520 --> 02:16.567
+No tiene sentido que hagas un bloque
+para una sola línea de código.
+
+02:16.693 --> 02:19.560
+Entonces vamos a tener dos
+o más statements aquí dentro.
+
+02:19.686 --> 02:23.869
+Y sintácticamente,
+para nuestro compilador,
+
+02:23.995 --> 02:27.101
+esto se tomaría como una unidad de código.
+
+02:27.227 --> 02:31.036
+O sea, cuando entra aquí, no se va a salir
+
+02:31.162 --> 02:34.306
+a menos que se lo pidamos explícitamente.
+
+02:34.432 --> 02:38.449
+Pero eso lo veremos más adelante cuando
+estudiemos el comando break.
+
+02:38.589 --> 02:43.046
+Con esto dicho, vámonos a la explicación
+de nuestro if.
+
+02:44.729 --> 02:47.007
+Lo primero que quiero
+que veas es que tengo aquí
+
+02:47.133 --> 02:49.200
+una pequeña estructura
+ya previamente escrita.
+
+02:49.200 --> 02:51.503
+No te preocupes,
+el código lo haremos en vivo.
+
+02:51.629 --> 02:54.560
+Pero quiero explicarte cómo funciona
+rápidamente esto.
+
+02:55.067 --> 02:58.023
+El if funciona a través de expresiones.
+
+02:58.149 --> 03:02.633
+Vamos a tener que, si esta expresión
+es verdadera,
+
+03:02.759 --> 03:08.040
+entonces debemos ejecutar todo el código
+que tengamos en nuestro bloque.
+
+03:08.707 --> 03:13.207
+Si, además, si no es verdadero esto,
+
+03:13.967 --> 03:17.006
+o si esta expresión sí es verdadera,
+
+03:17.132 --> 03:21.196
+entonces ejecutamos este código,
+que serían otros statements.
+
+03:21.616 --> 03:25.493
+Y por último, si ninguna de las opciones
+es verdadera,
+
+03:25.759 --> 03:28.680
+entonces ejecutamos esta línea de código.
+
+03:28.909 --> 03:32.882
+Y aquí quiero dejarte la primera buena
+práctica del lenguaje C.
+
+03:33.008 --> 03:39.640
+Cuando tú tengas un solo statement,
+no necesitas escribir nuestras llaves.
+
+03:39.922 --> 03:42.319
+No necesitas escribir esas llaves.
+
+03:42.452 --> 03:44.925
+Simple y sencillamente puedes dejarlo así.
+
+03:46.312 --> 03:48.978
+Y con esto el compilador sabe
+
+03:49.103 --> 03:53.852
+que la primera instrucción
+después de un if
+
+03:53.978 --> 03:57.520
+va a ser perteneciente
+a ese if por default.
+
+03:57.661 --> 04:02.200
+Eso quiere decir que para una sola línea
+de código no necesitamos crear bloques.
+
+04:02.609 --> 04:05.680
+Esto está correcto y no deberías tener
+miedo al escribirlo.
+
+04:05.680 --> 04:06.972
+Simplemente hazlo.
+
+04:07.098 --> 04:08.683
+Yo te cuento aquí una pequeña anécdota,
+
+04:08.722 --> 04:11.413
+que cuando yo empecé a programar
+en el lenguaje C,
+
+04:11.539 --> 04:14.480
+a mí me daba miedo
+que no tuviera las llaves.
+
+04:14.480 --> 04:18.127
+Y que entonces el compilador no lo fuera
+a detectar como que pertenecía a ese if.
+
+04:18.253 --> 04:20.040
+Y no me arriesgaba y le ponía las llaves.
+
+04:20.166 --> 04:22.520
+Obviamente luego
+uno aprende el estándar de C.
+
+04:22.520 --> 04:24.545
+Y eso que yo hacía estaba muy mal,
+
+04:24.671 --> 04:27.331
+porque estaba escribiendo
+líneas de código innecesarias.
+
+04:27.457 --> 04:32.080
+Ahora, esto entonces es correcto si tienes
+dos o más instrucciones o statements.
+
+04:32.080 --> 04:35.680
+Y esto es correcto para cuando tienes
+una sola instrucción.
+
+04:36.116 --> 04:40.393
+Aquí tenemos ya nuestra construcción
+que sería el if, su else y un else if.
+
+04:40.519 --> 04:43.440
+Los else if tú puedes poner tantos
+como quieras.
+
+04:44.385 --> 04:48.046
+Quiero que te quede súper claro que puedes
+usar tantos else if
+
+04:48.172 --> 04:50.080
+como lo necesites en tu código,
+
+04:50.206 --> 04:54.000
+para cada una de las situaciones
+que se van a presentar en tu programa.
+
+04:54.532 --> 04:57.369
+Lo primero entonces sería simplemente
+dejar esto claro.
+
+04:57.495 --> 05:01.640
+Sería expression3, expression4
+y expression5 o statement5.
+
+05:02.252 --> 05:06.343
+Aquí podemos poner tantos else if
+como tu situación lo requiera.
+
+05:06.469 --> 05:10.847
+Toma en cuenta que igual el primero
+en donde se cumpla la expresión
+
+05:10.873 --> 05:12.060
+es donde va a entrar.
+
+05:12.086 --> 05:13.429
+Y eso es bien importante.
+
+05:13.555 --> 05:17.130
+Si tú tienes aquí una expresión
+que ya se cumple en este,
+
+05:17.256 --> 05:20.047
+tu código nunca va a llegar al statement4.
+
+05:20.173 --> 05:21.993
+Nunca en la vida va a llegar,
+
+05:22.119 --> 05:23.305
+porque esto se es...
+
+05:23.431 --> 05:26.080
+Recuerda que estamos hablando
+de programación estructurada
+
+05:26.206 --> 05:29.218
+y se ejecuta
+de la primera línea a la última.
+
+05:29.344 --> 05:32.552
+Entonces, si esta expresión
+fuera verdadera,
+
+05:32.678 --> 05:36.323
+en todos los casos que son similares
+a tus otros else if,
+
+05:36.449 --> 05:39.885
+entonces nunca entraría
+a estas condiciones.
+
+05:40.011 --> 05:43.920
+Tienes que tener mucho cuidado en pensar
+cómo estructuras esto.
+
+05:44.144 --> 05:46.800
+Justo vamos a ver ese ejemplo
+en la siguiente clase.
+
+05:47.547 --> 05:50.886
+Con esto dicho, ya nada más te quiero
+decir que esto else if
+
+05:51.012 --> 05:54.283
+es una construcción que no tiene límites
+
+05:54.409 --> 05:56.483
+en cuestión de cuántos else if
+puedes tener,
+
+05:56.609 --> 06:01.334
+y que la instrucción if básica es esta,
+un if y un else.
+
+06:01.460 --> 06:05.445
+Esta es la más así utilizada
+para tomar simplemente
+
+06:05.571 --> 06:08.960
+si esto se está cumpliendo, lo ejecutas,
+y si no, el programa sigue.
+
+06:09.212 --> 06:11.040
+O, y si no, ejecutas esto u otro.
+
+06:11.376 --> 06:14.122
+Esa es la instrucción más básica
+que existe en C.
+
+06:14.248 --> 06:16.881
+Siempre tienes que usarla de esta manera,
+if else,
+
+06:17.007 --> 06:20.376
+y la última sería if, else if,
+
+06:20.502 --> 06:22.720
+esa ya se conoce como una construcción.
+
+06:23.166 --> 06:25.359
+Con esto dicho,
+nos vemos en la próxima clase,
+
+06:25.485 --> 06:29.360
+en donde haremos un ejemplo
+de cómo utilizar estas sentencias.
+
+06:29.766 --> 06:35.360
+Nos vemos allá.

subir/Curso de Control de Flujo en C/02-Toma de decisiones/01-if_c58ef3ef-a775-44e3-a585-fbd6c1932976.c

@@ -0,0 +1,9 @@
+if (expresion){
+    statement1
+    statement1.1
+    statement1.2
+    }
+    else if (expresion)
+    statement2
+else 
+    statement5

subir/Curso de Control de Flujo en C/02-Toma de decisiones/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://en.cppreference.com/w/c/language/operator_logical

subir/Curso de Control de Flujo en C/02-Toma de decisiones/02-Manejo de Condicionales IfElse en Lenguaje C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5426504d2d0f76c85823002a6a2883c411cb5488949cf6981eb31e780e17ff26
+size 119910789

subir/Curso de Control de Flujo en C/02-Toma de decisiones/02-Manejo de Condicionales IfElse en Lenguaje C.vtt

@@ -0,0 +1,753 @@
+WEBVTT
+
+00:03.226 --> 00:07.400
+Bueno, vamos a nuestro editor de código
+y comencemos a escribir nuestro ejemplo.
+
+00:07.400 --> 00:12.960
+Lo primero que vamos a hacer es guardar
+este archivo como demoif.c.
+
+00:12.960 --> 00:15.440
+Ya lo tenemos todo listo.
+
+00:15.440 --> 00:19.720
+Tú sabes, tenemos que incluir
+nuestra bellísima librería de print,
+
+00:19.720 --> 00:21.920
+que nos sirve muchísimo para los ejemplos.
+
+00:21.920 --> 00:23.280
+Vamos a ponerle...
+
+00:23.280 --> 00:28.360
+Vamos a ponerle standard.io,
+que es la librería en donde está el print.
+
+00:28.360 --> 00:30.360
+Vamos a poner include.
+
+00:30.360 --> 00:36.040
+Vamos a llamar stdio.h, que es set
+de nuestras librerías estándares.
+
+00:36.040 --> 00:37.040
+Muy bien.
+
+00:37.040 --> 00:39.040
+Ahora, ¿qué más vamos a necesitar?
+
+00:39.040 --> 00:42.360
+Recuerda nuestro boilerplate
+o nuestro demo de C.
+
+00:42.360 --> 00:46.360
+Vamos a necesitar el main,
+así que lo voy a copiar de aquí.
+
+00:46.360 --> 00:50.360
+Y vamos a nuestro demoif.
+
+00:50.360 --> 00:51.360
+Eso es todo.
+
+00:51.360 --> 00:54.298
+Ahora, lo primero
+que quiero hacer es enseñarte
+
+00:54.423 --> 00:57.360
+un poquito sobre
+los operadores de comparación.
+
+00:57.360 --> 01:01.360
+Vamos a tener que if,
+esta es nuestra instrucción principal,
+
+01:01.360 --> 01:03.360
+pero luego entra la expresión.
+
+01:03.360 --> 01:08.360
+Vamos a decirle si n de número
+es mayor que 10,
+
+01:08.360 --> 01:10.360
+entonces imprima...
+
+01:12.360 --> 01:15.360
+Entonces imprima, vamos a decir,
+
+01:16.360 --> 01:17.360
+el número...
+
+01:20.360 --> 01:21.360
+el número...
+
+01:21.360 --> 01:26.360
+el número es mayor que 10.
+
+01:27.360 --> 01:36.360
+Pero que si n es igual a 10,
+
+01:36.360 --> 01:38.360
+entonces imprima...
+
+01:40.360 --> 01:42.360
+vamos a imprimir...
+
+01:43.360 --> 01:46.360
+el número es 10.
+
+01:48.360 --> 01:50.360
+Perfecto. Bellísimo.
+
+01:50.360 --> 01:53.360
+Y luego vamos a tener otro else if,
+
+01:54.360 --> 01:57.360
+que diga si el número...
+
+01:59.360 --> 02:02.360
+es mayor que 20.
+
+02:05.360 --> 02:07.360
+Ah, no, pero esto es
+lo que voy a imprimir.
+
+02:07.360 --> 02:09.360
+Bueno, vamos con nuestra expresión.
+
+02:09.360 --> 02:12.360
+Igual aprovecho y le dejo su print,
+todo bello.
+
+02:12.360 --> 02:13.360
+Punto y coma.
+
+02:13.360 --> 02:20.360
+Vamos aquí arriba y ponemos sencillamente
+n mayor que 20.
+
+02:20.360 --> 02:21.360
+Muy bien.
+
+02:22.360 --> 02:25.360
+Y por último, else if,
+
+02:27.360 --> 02:34.360
+vamos a ponerle aquí un n es menor que 10.
+
+02:34.360 --> 02:47.360
+El número, vamos a imprimir,
+el número es menor que 10.
+
+02:47.360 --> 02:48.360
+Excelente.
+
+02:48.360 --> 02:52.360
+Ahora, obviamente,
+tenemos que declarar el famoso número,
+
+02:52.360 --> 02:55.360
+y para esto vamos a crear
+una variable que se llame n.
+
+02:55.360 --> 02:58.360
+Vamos a declarar nuestra variable,
+
+02:59.360 --> 03:01.360
+va a ser de tipo entero, n,
+
+03:01.360 --> 03:06.360
+y vamos a inicializarla primero en, no sé,
+
+03:06.360 --> 03:08.360
+vamos a ponerle 11.
+
+03:08.360 --> 03:09.360
+Muy bien.
+
+03:09.360 --> 03:10.360
+Punto y coma.
+
+03:11.360 --> 03:12.360
+Y guardamos.
+
+03:13.360 --> 03:14.360
+Vamos a ejecutar nuestro código.
+
+03:14.360 --> 03:17.360
+Recuerda que para ejecutar el código...
+
+03:17.360 --> 03:19.360
+Ah, nos falta un else.
+
+03:20.360 --> 03:21.360
+Else, error.
+
+03:23.360 --> 03:25.360
+No hay número.
+
+03:26.360 --> 03:28.360
+Else, entonces vamos a print.
+
+03:28.360 --> 03:29.360
+Error.
+
+03:31.360 --> 03:34.360
+Error, no hay número.
+
+03:34.360 --> 03:35.360
+Muy bien.
+
+03:35.360 --> 03:37.360
+Ahora sí tenemos todo listísimo.
+
+03:38.360 --> 03:39.360
+Vamos a guardar nuestro código,
+
+03:39.360 --> 03:40.360
+control s,
+
+03:40.360 --> 03:43.360
+y recuerda que con f6
+compilamos nuestro programa.
+
+03:44.360 --> 03:46.360
+Si tú estás trabajando en una laptop,
+
+03:46.360 --> 03:48.360
+lo más probable es que tengas
+que presionar function,
+
+03:48.360 --> 03:51.360
+que es el botoncito fn, y luego f6.
+
+03:51.360 --> 03:53.360
+Esperamos a que esto termine de cargar.
+
+03:54.360 --> 03:55.360
+Se está demorando un poco.
+
+03:55.360 --> 03:58.360
+Vamos a ver si sí se presionó f6.
+
+04:06.360 --> 04:07.360
+Ah, ok.
+
+04:07.360 --> 04:08.360
+Y aquí tenemos un error.
+
+04:08.360 --> 04:10.360
+Dice que esperaba un punto y coma.
+
+04:10.360 --> 04:12.360
+Recuerda que yo ya te enseñé
+cómo debuguear.
+
+04:12.360 --> 04:15.360
+Vámonos a la línea de código
+que nos está indicando.
+
+04:15.360 --> 04:17.360
+Y nos dice, oye, el error está en el else.
+
+04:17.360 --> 04:18.360
+Y yo ya te di el tip.
+
+04:18.360 --> 04:20.360
+Siempre el error está un punto y coma.
+
+04:20.360 --> 04:22.360
+Y nos dice, oye, el error está en el else.
+
+04:22.360 --> 04:26.360
+Y yo ya te di el tip, siempre el error
+está una instrucción antes
+
+04:26.360 --> 04:29.360
+a la que te marca el debugger,
+el compilador.
+
+04:29.360 --> 04:31.360
+Entonces vamos a poner aquí punto y coma,
+
+04:31.360 --> 04:36.360
+guardamos,
+y vamos a presionar function, f6,
+
+04:36.360 --> 04:37.360
+si estás en un laptop,
+
+04:37.360 --> 04:40.360
+y si no, simplemente
+f6 para correr el código.
+
+04:41.360 --> 04:44.360
+Ya, 11 dice, el número es mayor que 10.
+
+04:44.360 --> 04:46.360
+Excelente. Esto está muy bien.
+
+04:46.360 --> 04:49.360
+Ahora veamos qué pasa cuando
+nuestro número es 10.
+
+04:49.360 --> 04:52.360
+Mira que voy a ir checando instrucción
+por instrucción,
+
+04:52.360 --> 04:55.360
+expresión por expresión
+que se esté cumpliendo.
+
+04:55.360 --> 04:58.360
+Y todo, obviamente, porque te quiero
+enseñar algo bien importante aquí.
+
+04:58.360 --> 05:01.360
+Vamos a poner otra vez a compilar
+nuestro programa
+
+05:01.360 --> 05:03.360
+y vamos a esperar su salida.
+
+05:03.360 --> 05:06.360
+Excelente. Nos dice, el número es 10.
+
+05:06.360 --> 05:08.360
+Entonces todo está funcionando.
+
+05:08.360 --> 05:11.360
+Ahora, si n es mayor que 20.
+
+05:11.360 --> 05:13.360
+Bellísimo. Entonces pongamos 21.
+
+05:14.360 --> 05:17.360
+21. Como mi edad.
+
+05:17.360 --> 05:20.360
+Control S y luego compilamos el programa.
+
+05:20.360 --> 05:23.360
+Fnf6. Vamos a ver qué pasa.
+
+05:25.360 --> 05:27.360
+Uy, uy, uy. Esto está grave.
+
+05:27.360 --> 05:29.360
+Dice, el número es mayor que 10.
+
+05:29.360 --> 05:30.360
+¿Qué está pasando?
+
+05:30.360 --> 05:34.360
+Ah, bueno, quería que vieras
+lo que te comenté en la clase anterior.
+
+05:34.360 --> 05:38.360
+Las instrucciones tienen
+que estar bien pensadas.
+
+05:38.360 --> 05:41.360
+Entonces nosotros podemos,
+si te das cuenta aquí dice,
+
+05:41.360 --> 05:45.360
+si n es mayor que 10, pues obvio,
+el número es mayor que 10.
+
+05:45.360 --> 05:48.360
+Pero 21 sigue siendo mayor que 10.
+
+05:48.360 --> 05:53.360
+Así que se está cumpliendo
+y no cae en n mayor que 20.
+
+05:53.360 --> 05:58.360
+Si por alguna razón en tu código
+necesitaras crear rangos numéricos
+
+05:58.360 --> 06:00.360
+para que de 10 a 20 haga algo
+
+06:00.360 --> 06:02.360
+y de 20 a 30 haga otra cosa,
+
+06:02.360 --> 06:04.360
+de 30 a 40 haga otra cosa,
+
+06:04.360 --> 06:06.360
+lo tienes que especificar.
+
+06:06.360 --> 06:10.360
+Entonces, para esto vamos
+a auxiliarnos del comando am.
+
+06:12.360 --> 06:14.360
+Lo que sería de la siguiente forma.
+
+06:14.360 --> 06:21.360
+amf n es menor que 20.
+
+06:21.360 --> 06:23.360
+Por ejemplo, guardemos.
+
+06:23.360 --> 06:24.360
+¿Aquí qué estoy diciendo?
+
+06:24.360 --> 06:29.360
+Si n es mayor que 10 y n es menor que 20,
+
+06:29.360 --> 06:32.360
+¡ah! Ya estamos haciendo un rango.
+
+06:32.360 --> 06:37.360
+Es mayor que 10, pero menor que 20.
+
+06:37.360 --> 06:40.360
+Vamos a guardar, vamos a compilar
+y vamos a ver qué pasa.
+
+06:40.360 --> 06:45.360
+El código es mucho de probar
+y experimentar qué ocurre.
+
+06:45.360 --> 06:49.360
+Y mira que ahora sí funcionó
+de forma excelente.
+
+06:49.360 --> 06:51.360
+El número es mayor que 20.
+¿Por qué?
+
+06:51.360 --> 06:56.360
+Porque 21 sí es mayor que 10,
+pero es menor que 20.
+
+06:56.360 --> 06:59.360
+Y mira que tú puedes jugar
+con las instrucciones.
+
+06:59.360 --> 07:03.360
+Así como tenemos el and, que se describe
+con doble signo de ampersand,
+
+07:03.360 --> 07:07.360
+esto significa si esta instrucción
+es verdadera
+
+07:07.360 --> 07:10.360
+y esta instrucción es verdadera,
+
+07:10.360 --> 07:13.360
+eso quiere decir que las dos instrucciones
+que estamos comparando
+
+07:13.360 --> 07:15.360
+deben de ser verdaderas.
+
+07:15.360 --> 07:17.360
+La otra forma de hacerlo es con un or.
+
+07:17.360 --> 07:19.360
+Pero para este caso no nos sirve un or.
+
+07:19.360 --> 07:20.360
+¿Por qué?
+
+07:20.360 --> 07:23.360
+El or, cualquiera de las instrucciones
+que se cumpla,
+
+07:23.360 --> 07:26.360
+va a hacer que el código se ejecute.
+
+07:26.360 --> 07:29.360
+Mira, esto se conoce como or.
+
+07:29.360 --> 07:35.360
+Entonces, si n es mayor que 10
+o n es mayor que 20, se va a cumplir.
+
+07:35.360 --> 07:39.360
+Mira cuál sería la salida de nuestro
+código una vez guardamos y ejecutamos.
+
+07:42.360 --> 07:46.360
+Y nos dice el número es mayor que 10,
+pero menor que 20.
+
+07:46.360 --> 07:49.360
+Eso no era cierto, el número es 21.
+
+07:49.360 --> 07:50.360
+¿Por qué?
+
+07:50.360 --> 07:55.360
+Porque o se cumple esta instrucción
+o se cumple esta otra instrucción.
+
+07:55.360 --> 07:57.360
+Cualquiera de las dos que se cumpla,
+
+07:57.360 --> 08:01.360
+la expresión se da como verdadera
+y se ejecuta este código.
+
+08:01.360 --> 08:04.360
+Entonces, en este caso
+nos sirve el ampersand.
+
+08:04.360 --> 08:06.360
+Ya para ir cerrando esta clase,
+
+08:06.360 --> 08:10.360
+lo que aprendimos es a utilizar
+la sentencia, la instrucción if,
+
+08:10.360 --> 08:13.360
+la instrucción else if
+y la instrucción else.
+
+08:13.360 --> 08:18.360
+Pero no se ha cumplido un caso en donde
+tengamos un número todavía menor que 10.
+
+08:18.360 --> 08:21.360
+Vamos a asegurarnos de que esto ocurra.
+
+08:21.360 --> 08:23.360
+Vamos a poner 9.
+
+08:24.360 --> 08:26.360
+Y vamos a compilar.
+
+08:27.360 --> 08:28.360
+F6.
+
+08:30.360 --> 08:31.360
+El número es menor que 10.
+
+08:31.360 --> 08:32.360
+Todo excelente.
+
+08:32.360 --> 08:33.360
+Esto se cumple.
+
+08:33.360 --> 08:34.360
+¿Cómo se debería cumplir?
+
+08:34.360 --> 08:36.360
+Y luego, error, no hay número.
+
+08:36.360 --> 08:43.360
+¿Qué pasa si yo digo
+que esto va a ser igual a B?
+
+08:46.360 --> 08:48.360
+Ok, veamos qué ocurre.
+
+08:48.360 --> 08:49.360
+Compilemos.
+
+08:51.360 --> 08:54.360
+Y nos da B, un declared.
+
+08:54.360 --> 08:57.360
+Claro, porque estamos diciendo
+que esto va a ser un entero.
+
+08:57.360 --> 09:00.360
+Entonces, nunca nos va a pasar este error
+de que no hay número
+
+09:00.360 --> 09:02.360
+porque el compilador nos lo prevendría.
+
+09:02.360 --> 09:05.360
+Pero, ¿qué pasa si yo pongo
+un número negativo?
+
+09:05.360 --> 09:08.360
+Eso sí que podría ser un error
+porque a lo mejor nuestro programa
+
+09:08.360 --> 09:12.360
+no debería recibir números negativos.
+
+09:12.360 --> 09:16.360
+Entonces, este rango ya no recibe
+números negativos.
+
+09:16.360 --> 09:18.360
+Este rango no recibe números negativos.
+
+09:18.360 --> 09:19.360
+Este tampoco.
+
+09:19.360 --> 09:20.360
+Este sí.
+
+09:20.360 --> 09:22.360
+Aquí podríamos agregar otro ampersand.
+
+09:22.360 --> 09:31.360
+Sí, n es menor que 10, pero, y además
+es mayor que n, es mayor que 0.
+
+09:31.360 --> 09:36.360
+Con esto nos aseguramos de que vamos
+a recibir únicamente números positivos
+
+09:36.360 --> 09:40.360
+y de hecho vamos a utilizar otra
+instrucción que sería mayor o igual.
+
+09:40.360 --> 09:41.360
+Muy bien.
+
+09:41.360 --> 09:46.360
+Esto quiere decir que n va a ser mayor
+que o igual que 0.
+
+09:46.360 --> 09:47.360
+Perfecto.
+
+09:47.360 --> 09:54.360
+El número es menor que 10,
+pero, es 0 o más.
+
+09:56.360 --> 09:58.360
+Ok, no, no tiene caso ese pero.
+
+09:58.360 --> 10:04.360
+El número es 0 o más, 0 o 9.
+
+10:04.360 --> 10:09.360
+El número está en el rango de 0 al 9.
+
+10:09.360 --> 10:10.360
+Excelente.
+
+10:10.360 --> 10:13.360
+Matemáticamente correcto amigos y amigas.
+
+10:13.360 --> 10:17.360
+Y bueno, este último error sería
+el número es positivo.
+
+10:17.360 --> 10:22.360
+Error, no quiero números negativos.
+
+10:22.360 --> 10:24.360
+Digámosle no a la negatividad hoy.
+
+10:24.360 --> 10:27.360
+Vamos a, y este, eso sería todo.
+
+10:27.360 --> 10:31.360
+Entonces ya con esto, en teoría,
+ahorita lo vamos a comprobar.
+
+10:31.360 --> 10:35.360
+Si nosotros ponemos menos 1
+nos debería decir error,
+
+10:35.360 --> 10:37.360
+no quiero números negativos.
+
+10:37.360 --> 10:39.360
+Vamos a limpiar nuestra terminal.
+
+10:41.360 --> 10:42.360
+Uy.
+
+10:43.360 --> 10:45.360
+Vamos acá a nuestra terminal.
+
+10:45.360 --> 10:46.360
+Muy bien.
+
+10:46.360 --> 10:48.360
+Y ejecutemos nuestro código.
+
+10:48.360 --> 10:52.360
+Voy a limpiarla con Clear para que lo veas
+todo bien, todo clarito.
+
+10:52.360 --> 10:57.360
+Asegúrate de guardar
+y asegúrate de ejecutar tu código.
+
+10:57.360 --> 10:59.360
+Vamos a esperar el resultado.
+
+11:00.360 --> 11:01.360
+Excelente.
+
+11:01.360 --> 11:03.360
+Error, no quiero números negativos.
+
+11:03.360 --> 11:06.360
+Y con esto ya aprendiste
+cómo puedes hacerle
+
+11:06.360 --> 11:10.360
+para asegurarte de recibir todas
+las instrucciones que necesites.
+
+11:11.360 --> 11:12.360
+Muy bien.
+
+11:12.360 --> 11:15.360
+Ya aprendimos a utilizar if,
+else, if, else.
+
+11:15.360 --> 11:18.360
+Es una instrucción súper útil
+en tus programas en C.
+
+11:18.360 --> 11:21.360
+Y recuerda que conforme vayamos viendo
+cosas más avanzadas
+
+11:21.360 --> 11:25.360
+en el curso, obviamente lo vamos a ir
+utilizando mucho más.
+
+11:25.360 --> 11:30.360
+Pero quería que te quedara clarísima
+la estructura básica de esta sintaxis,
+
+11:30.360 --> 11:32.360
+de cómo se escribe, de cómo se utiliza,
+
+11:32.360 --> 11:34.360
+de cómo puedes meter los operadores.
+
+11:34.360 --> 11:37.360
+Te voy a dejar en la sección
+de enlaces un link
+
+11:37.360 --> 11:39.360
+para que veas todos los operadores
+del lenguaje C.
+
+11:39.360 --> 11:42.360
+Esto es algo que está como una lectura
+en nuestro curso pasado.
+
+11:42.360 --> 11:44.360
+Así que no te preocupes en absoluto.
+
+11:44.360 --> 11:47.360
+Si tienes dudas de qué otros operadores
+puedes utilizar,
+
+11:47.360 --> 11:49.360
+te voy a dejar el enlace a esa lectura.
+
+11:49.360 --> 11:52.360
+Y sin más, nos vemos en la próxima clase.

subir/Curso de Control de Flujo en C/02-Toma de decisiones/02-demoif_72993f29-e31b-4df7-8b00-add49844084a.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+int n = -1;
+
+int main()
+{
+    if(n > 10 && n < 20)
+    printf("el numero es mayor que diez, pero menor que 20");
+    else if (n == 10)
+    printf("el numero es diez");
+    else if  (n > 20)
+    printf("el numero es mayor que veinte");
+    else if(n < 10 && n >= 0)
+    printf("el numero esta en el rango de 0 al 9");
+    else
+    printf("error no quiero numeros negativos");
+    return 0;
+}

subir/Curso de Control de Flujo en C/02-Toma de decisiones/03-If anidados en C Creación de menús interactivos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f257800fdc1a427d44f9f70ccda02e7f5de020eda76c4f51001ed291c22f493
+size 126391773

subir/Curso de Control de Flujo en C/02-Toma de decisiones/03-If anidados en C Creación de menús interactivos.vtt

@@ -0,0 +1,713 @@
+WEBVTT
+
+00:03.220 --> 00:05.928
+Otro concepto muy importante
+en el lenguaje C
+
+00:06.053 --> 00:08.760
+son los if-anidados,
+es decir, que tú puedes
+
+00:08.760 --> 00:11.969
+tener un decisional
+adentro de otro decisional.
+
+00:12.094 --> 00:15.160
+Eso es algo cool, la verdad es que lo vas
+
+00:15.160 --> 00:17.564
+a utilizar en algunas ocasiones,
+en otras no.
+
+00:17.689 --> 00:20.680
+Quizás tienes un sistema
+en donde debas de crear
+
+00:20.806 --> 00:23.178
+un sistema de submenús, por ejemplo.
+
+00:23.303 --> 00:25.988
+De hecho, eso es lo que te voy
+a mostrar cómo hacer ahorita.
+
+00:26.114 --> 00:29.218
+Así que vamos a nuestro editor de código,
+
+00:29.343 --> 00:33.579
+control-n o command-n,
+para crear una nueva tabsita,
+
+00:33.705 --> 00:35.793
+un nuevo archivo y lo vamos a guardar
+
+00:35.919 --> 00:42.868
+con control-s como nested-if.c.
+Excelente. Ahora,
+
+00:42.994 --> 00:46.155
+¿qué voy a hacer aquí?
+Pues lo mismo de todas las veces,
+
+00:46.281 --> 00:49.296
+que no es tratar de dominar
+el mundo ni conquistarlo,
+
+00:49.422 --> 00:51.396
+es crear nuestro primer boilerplate,
+
+00:51.522 --> 00:54.023
+nuestra plantilla por decirlo así.
+
+00:54.190 --> 00:57.131
+Vamos a borrar esta variable,
+no quiero traer nada
+
+00:57.257 --> 01:00.640
+del otro lado y vamos
+a crear nuestras llaves.
+
+01:01.055 --> 01:03.267
+Muy bien, y ahora tú ya
+sabes que esto que estoy
+
+01:03.392 --> 01:06.251
+haciendo aquí es definir que todo
+este código es un bloque,
+
+01:06.377 --> 01:09.539
+es un gran bloque que pertenece
+
+01:09.665 --> 01:12.160
+a nuestra función main.
+¿Ves? Es importante
+
+01:12.160 --> 01:15.755
+que poquito a poquito vamos
+desglosando este grandioso
+
+01:15.880 --> 01:17.578
+lenguaje que es C.
+
+01:17.703 --> 01:20.098
+Grandioso porque es mi lenguaje favorito,
+
+01:20.224 --> 01:21.439
+pero además porque todavía
+
+01:21.565 --> 01:25.326
+se ocupa y es un lenguaje
+que lanzaron en 1972.
+
+01:25.452 --> 01:28.238
+Imagínate eso. Muy bien,
+¿cuántos años son?
+
+01:28.363 --> 01:31.788
+Bueno, muchos años. Vamos a
+crear todo nuestro programa,
+
+01:31.914 --> 01:35.369
+vamos a empezar y aquí
+quiero que pensemos
+
+01:35.495 --> 01:37.920
+qué es el algoritmo que
+vamos a desarrollar.
+
+01:37.920 --> 01:41.147
+Voy a crear un comentario.
+Este programa genera menús,
+
+01:42.829 --> 01:47.179
+menús según lo que el usuario elija.
+
+01:47.366 --> 01:52.881
+Ok, vamos a hacer un simple programa
+que imprime diferentes menús
+
+01:53.007 --> 01:55.416
+y vamos a crear dos variables.
+
+01:59.315 --> 02:04.455
+Ok, opción 1 va a ser igual a,
+opción 1, voy a escribir
+
+02:04.581 --> 02:06.207
+todo en inglés
+porque es la mejor práctica,
+
+02:06.333 --> 02:10.344
+opción 1 va a ser igual
+a cualquier número,
+
+02:10.470 --> 02:13.188
+vamos a inicializar todo
+en cero, punto y coma,
+
+02:14.090 --> 02:19.730
+opción 2 va a ser igual
+a cero, punto y coma.
+
+02:20.003 --> 02:24.701
+Excelente. Y ahora vamos
+a declarar una serie de ifs, else ifs.
+
+02:27.135 --> 02:29.738
+If option 1 es igual,
+
+02:29.864 --> 02:33.252
+este es el operador de comparación,
+
+02:33.378 --> 02:37.777
+recuerda, si option 1 es igual a
+cero, entonces
+
+02:39.957 --> 02:42.840
+lo que voy a escribir yo va a ser,
+y aquí quiero que veas
+
+02:42.840 --> 02:46.753
+que hay dos grandes
+formas de escribir nuestras llaves,
+
+02:46.879 --> 02:49.009
+ya sea que pones tus llaves así,
+
+02:49.235 --> 02:53.369
+una al lado y otra donde cierras,
+o las dos llaves abajo.
+
+02:53.495 --> 02:56.179
+Esto se suele manejar
+al gusto del programador,
+
+02:56.305 --> 02:58.337
+yo siempre lo manejo de esta forma.
+
+02:58.463 --> 03:01.783
+Lo que no es al gusto del programador
+es la indentación.
+
+03:01.909 --> 03:05.029
+Tenemos que todo el código
+siempre va indentado a un nivel,
+
+03:05.155 --> 03:08.653
+un nivel, todo, por ejemplo,
+este if está adentro de este main,
+
+03:08.779 --> 03:10.201
+por eso está indentado a un nivel,
+
+03:10.327 --> 03:12.240
+y todo lo que yo escriba perteneciente
+
+03:12.240 --> 03:14.941
+a este if va a estar
+indentado a un nivel.
+
+03:15.168 --> 03:17.732
+Entonces vamos a escribir
+nuestro primer print.
+
+03:21.882 --> 03:26.975
+Si usted eligió la opción cero,
+
+03:27.398 --> 03:32.191
+verá nuestro menú de bebidas.
+
+03:32.681 --> 03:39.219
+Elija una. Y aquí vamos
+a poner otros if anidados.
+
+03:45.678 --> 03:48.630
+Entonces si option 2 es igual a cero,
+
+03:49.050 --> 03:51.215
+eso sería nuestra primer bebida.
+
+03:51.582 --> 03:53.212
+Vamos a poner un print
+
+03:56.199 --> 03:58.086
+y vamos a poner usted.
+
+03:58.522 --> 04:03.600
+Si te das cuenta aquí no
+necesito estas llaves
+
+04:03.600 --> 04:06.705
+que el editor me autocompletó,
+muy desafortunadamente
+
+04:06.831 --> 04:08.906
+el autocomplete no siempre es buena idea,
+
+04:09.032 --> 04:15.000
+al menos yo no soy el más fan de él.
+Usted eligió, en lenguajes como C,
+
+04:15.000 --> 04:19.634
+no, en lenguajes como JavaScript yo amo el
+autocomplete, todo depende del lenguaje.
+
+04:20.020 --> 04:26.258
+Ok, usted eligió una Coca-Cola,
+una Platzi-Cola, cero.
+
+04:30.637 --> 04:33.240
+Mmm, rico. Hay que hacer copy
+
+04:33.240 --> 04:37.802
+porque esto es marketing, ¿no?
+Muy bien, punto y coma y punto y coma.
+
+04:38.188 --> 04:42.614
+Aquí si te das cuenta estamos anidando
+nuestro decisional.
+
+04:42.740 --> 04:44.447
+Obviamente no tendríamos
+
+04:44.573 --> 04:47.274
+solamente Coca-Colas,
+así que pondríamos else if,
+
+04:47.727 --> 04:54.250
+opt 2, igual a 1 y aquí sería print.
+
+04:55.963 --> 04:59.775
+Y voy a copiar esta sintaxis
+para no tener que escribir tanto.
+
+05:01.245 --> 05:03.769
+Un programador
+exitoso escribe menos código.
+
+05:04.789 --> 05:07.984
+Vamos a poner,
+usted eligió una Platzi-Cola
+
+05:10.487 --> 05:15.475
+con mucha azúcar. Azúcar, muy bien.
+
+05:15.963 --> 05:19.421
+Imaginemos que tiene tilde.
+Excelente. Y por último,
+
+05:19.547 --> 05:25.970
+else if y sería option 2, igual a 2
+
+05:26.817 --> 05:30.040
+y acá pondríamos 
+esta misma línea de código.
+
+05:32.179 --> 05:38.103
+Uy, control C, control V,
+la indentamos bien.
+
+05:41.468 --> 05:47.951
+Usted eligió una Platzi-Piña colada.
+
+05:48.638 --> 05:51.840
+Muy bien, listo. Con esto ya y por último,
+
+05:51.840 --> 05:56.455
+else up y imprimiríamos
+
+05:59.759 --> 06:02.878
+opción inválida.
+
+06:04.395 --> 06:06.976
+Bellísimo. Punto y coma para cerrar.
+
+06:08.966 --> 06:12.304
+Aquí, si te das cuenta,
+nosotros ya creamos una primera
+
+06:12.430 --> 06:16.150
+toma de decisiones.
+La primera toma de decisiones,
+
+06:16.276 --> 06:19.658
+si es cero, es bebidas,
+así que hay que darle la bienvenida.
+
+06:19.784 --> 06:21.741
+Usted eligió nuestra opción cero,
+
+06:21.867 --> 06:24.295
+verá nuestro menú de bebidas. Elija una.
+
+06:24.475 --> 06:27.080
+Y aquí hay que escribir algo más.
+Entonces voy a crear
+
+06:27.080 --> 06:30.434
+un salto de línea que se hace
+con diagonal invertida N
+
+06:30.699 --> 06:32.845
+y vamos a imprimir nuestro menú,
+
+06:32.971 --> 06:36.206
+bien, bien lindo. Voy a utilizar otro
+
+06:36.332 --> 06:40.227
+print para que se vea bien.
+Ya tenemos acá, elija una bebida.
+
+06:40.353 --> 06:46.675
+El siguiente paso sería,
+presione cero o ingrese opción cero.
+
+06:48.741 --> 06:54.538
+Cero para Coca-Cola Platzi-Cola. Cero.
+
+06:55.592 --> 06:59.845
+Vamos a dejar aquí un salto
+de línea, diagonal invertida N.
+
+07:02.717 --> 07:06.749
+Voy a copiar esto para
+replicarlo y que sea súper veloz
+
+07:07.135 --> 07:09.346
+el desarrollo de nuestro programa.
+
+07:09.513 --> 07:12.642
+Y lo voy a copiar aquí también.
+Excelente.
+
+07:13.605 --> 07:15.808
+Opción cero para Platzi-Cola cero.
+
+07:16.758 --> 07:21.685
+Opción uno para Platzi-Cola normal.
+
+07:22.643 --> 07:27.856
+Opción dos para Platzi-Colada.
+
+07:30.036 --> 07:35.421
+Platzi-Pina-Colada. Muy bien.
+Hay que ponerle punto y coma,
+
+07:35.547 --> 07:38.125
+punto y coma.
+Verifiquemos que todo está excelente.
+
+07:38.251 --> 07:40.975
+Y ya, si te das cuenta,
+hicimos unpequeñísimo menú.
+
+07:41.101 --> 07:44.696
+Obviamente vamos aquí a falsear
+nuestras opciones.
+
+07:44.822 --> 07:46.440
+Simplemente imprimamos ahora
+
+07:46.440 --> 07:49.314
+qué ocurre con el código
+tal como lo tenemos.
+
+07:49.562 --> 07:54.344
+Vamos a F6 para compilar.
+Recuerda que si no sabes
+
+07:54.470 --> 07:57.459
+cómo configurar mi entorno,
+tienes que ir a nuestro primer curso.
+
+07:57.585 --> 07:59.000
+Y mira, aquí está.
+
+07:59.000 --> 08:02.071
+Ok, usted eligió la opción cero.
+Verá nuestro menú de bebidas.
+
+08:02.197 --> 08:04.932
+Elija una. Opción cero
+para Platzi-Cola cero.
+
+08:05.058 --> 08:08.220
+Opción uno para Platzi-Cola normal.
+
+08:08.346 --> 08:12.263
+Opción dos para  Platzi-Pina-Colada.
+Usted eligió una Platzi-Cola cero.
+
+08:12.389 --> 08:15.796
+Rico. Muy bien. Ahora nos falta
+aquí un primer menú.
+
+08:15.922 --> 08:17.837
+Entonces hay que copiar esto.
+
+08:19.801 --> 08:22.389
+Vamos a copiar este código.
+Vamos a ponerlo
+
+08:22.515 --> 08:25.359
+en nuestro main
+y vamos a traerlo por acá.
+
+08:25.526 --> 08:28.780
+Recuerda que debe estar
+indentado solo una, un nivel.
+
+08:29.176 --> 08:31.158
+Vamos a decirle,
+
+08:33.555 --> 08:37.518
+eh, bienvenido a Platzi Store.
+
+08:39.474 --> 08:42.803
+Opción cero para Platzi-Bebidas.
+
+08:44.263 --> 08:47.926
+Opción uno para Platzi-Comidas.
+
+08:48.445 --> 08:51.712
+Y opción dos para Platzi-Postres.
+
+08:51.853 --> 08:55.293
+Opción excelente.
+Ya tenemos aquí nuestro primer menú.
+
+08:55.419 --> 08:58.160
+Ahora te voy a dejar un primer reto.
+
+08:58.160 --> 09:00.949
+Quiero que tú acompletes,
+si te das cuenta, yo solo programé
+
+09:01.075 --> 09:02.518
+la opción cero de nuestro menú.
+
+09:02.644 --> 09:05.816
+Yo quiero que tú programes la opción uno,
+que va a ser para alimentos,
+
+09:05.942 --> 09:08.662
+y la opción dos,
+que va a ser para postres.
+
+09:08.788 --> 09:10.759
+Aquí tienes la estructura
+que debes de seguir.
+
+09:10.885 --> 09:13.232
+Te voy a dar el,
+te voy a dejar esto listo.
+
+09:13.358 --> 09:15.694
+Vamos a poner aquí el else if
+
+09:16.831 --> 09:20.807
+y vamos a usar nuestro operador,
+nuestra variable opción uno.
+
+09:21.000 --> 09:26.579
+Y si esto es igual a uno,
+entonces aquí, aquí va a ir,
+
+09:26.705 --> 09:28.953
+vamos a, te voy a dejar
+hasta un comentario.
+
+09:29.079 --> 09:36.039
+Aquí va el código de, 
+el menú de alimentos.
+
+09:36.965 --> 09:39.307
+Y vamos a copiar este else if
+
+09:42.294 --> 09:44.084
+para el menú de postres.
+
+09:44.210 --> 09:49.716
+Aquí va el menú de postres.
+Hay que identar esto bien.
+
+09:51.106 --> 09:56.161
+Y por último, else y aquí sería opción,
+
+10:00.412 --> 10:04.876
+mensaje de manejo de opción inválida.
+
+10:05.277 --> 10:08.962
+Aquí es donde tú le dices al usuario, oye,
+Dude, eso que me pediste no existe.
+
+10:09.088 --> 10:12.575
+No vendo todavía la opción cuatro,
+cinco, seis, por ejemplo.
+
+10:12.701 --> 10:15.800
+Ya con esto tú,
+tú debes de preparar tu código.
+
+10:15.926 --> 10:18.597
+Ok. Debes de terminar el código y dejarme,
+
+10:18.723 --> 10:20.480
+ya sea, la impresión de cómo
+
+10:20.480 --> 10:22.904
+queda tu menú en la terminal.
+
+10:23.030 --> 10:27.183
+Ahora, ¿qué pasa si tú, por ejemplo,
+quisieras elegir la opción 0,2?
+
+10:27.309 --> 10:29.600
+Pues simplemente la pones aquí arriba.
+
+10:29.726 --> 10:31.840
+¿Vale? De momento no hemos
+aprendido a manejar inputs,
+
+10:31.840 --> 10:34.439
+así que no te preocupes.
+Todo lo estamos manejando
+
+10:34.564 --> 10:37.294
+por inputs aquí arriba
+en nuestro programita.
+
+10:37.420 --> 10:42.166
+Guardamos, compilamos.
+Vamos a esperar a que termine.
+
+10:42.292 --> 10:45.193
+Y ¡uy! Nos marca un error. Todo mal.
+
+10:47.710 --> 10:51.960
+Vamos a ver por qué. Dice main.
+
+10:53.546 --> 10:58.440
+Ah, claro, al escribir todo esto 
+se me borró el return.
+
+10:58.440 --> 11:02.213
+Entonces hay que componerlo.
+Vamos a ver qué está pasando.
+
+11:02.339 --> 11:05.401
+Ah, ok. Y todo se me anidó
+dentro de este primer if.
+
+11:05.527 --> 11:08.238
+Eso está mal. Aquí hay que saber separar
+
+11:08.364 --> 11:11.470
+en dónde terminan las cosas.
+Entonces te voy a enseñar justo eso.
+
+11:12.016 --> 11:14.507
+Vamos a cerrar una llave acá.
+
+11:14.633 --> 11:17.103
+Esta llave cierra nuestro primer if.
+
+11:17.229 --> 11:20.950
+Este else if se cierra con su llave acá.
+Veamos. Sí.
+
+11:21.076 --> 11:24.906
+Este else if se cierra con su llave.
+Este else se cierra con su llave.
+
+11:25.032 --> 11:28.034
+Y este estaría cerrando nuestro main.
+
+11:28.160 --> 11:33.022
+Así que vamos a ponerle return.
+Cero, punto y coma.
+
+11:33.148 --> 11:35.919
+Recuerda que esa es la instrucción
+de salida que vamos a tener.
+
+11:36.045 --> 11:37.902
+Vamos a, se me olvidó guardar.
+
+11:38.028 --> 11:44.627
+Vamos a guardar.
+Control S y vamos a nuestro terminal.
+
+11:44.907 --> 11:49.172
+Vamos a darle F6. Muy bien.
+
+11:49.298 --> 11:52.165
+Y ya una vez compila
+y se ejecuta nuestro programa.
+
+11:52.291 --> 11:55.552
+Nos dice, usted eligió la opción cero.
+Verá nuestro menú de bebidas.
+
+11:55.859 --> 11:58.974
+Ah, ok. Opción cero para Coca-Cola cero,
+
+11:59.100 --> 12:01.484
+para Coca-Cola normal y para piña colada.
+
+12:01.610 --> 12:04.438
+Mira, usted eligió
+una piña colada con azúcar.
+
+12:04.563 --> 12:07.680
+Mmm, rico. Excelente.
+Aquí tenemos un typo.
+
+12:07.680 --> 12:11.877
+Lo guardamos y eso es todo.
+Aquí ya aprendiste cómo
+
+12:12.003 --> 12:15.040
+utilizar if anidados.
+Es un ejemplo súper básico,
+
+12:15.040 --> 12:16.397
+pero quiero que tú lo termines
+
+12:16.523 --> 12:19.057
+para que te quede
+bien clarita la información.
+
+12:19.183 --> 12:20.363
+Velo como un ejercicio.
+
+12:20.489 --> 12:23.902
+Crea un menú desde cero,
+por favor, y muéstramelo
+
+12:24.028 --> 12:26.079
+en la sección de comentarios.
+Termina este menú,
+
+12:26.205 --> 12:28.826
+crea tu propio menú y con eso
+ya habrás aprendido
+
+12:28.952 --> 12:33.368
+a escribir if anidados.
+No te confíes en pensar
+
+12:33.494 --> 12:35.758
+que esto es muy simple.
+No lo necesito practicar.
+
+12:35.884 --> 12:38.434
+Si no lo practicas,
+se te va a olvidar en una hora
+
+12:38.560 --> 12:40.300
+o dos después
+de que hayas visto esta clase
+
+12:40.426 --> 12:46.426
+y no queremos eso.
+Nos vemos en la próxima.

subir/Curso de Control de Flujo en C/02-Toma de decisiones/03-nestedif_e6d6f354-6111-4e0b-9802-2aa3a6d9a99e.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+int opt1 = 0;
+int opt2 = 2;
+
+int main(){
+    printf("bienvenid a platzi store :\n");
+    printf("opcion 0 para platzi bebidas \n");
+    printf("opcion 1 para platzi comidas \n");
+    printf("opcion 2 para platzi postres \n");
+
+    // este programa genera menus segun lo que el usuario elija
+    if(opt1 == 0){
+        printf("usted eligio la opcion 0, vera nuestro menu de bebidas elija una:\n");
+        printf("opcion 0 para platzi cola cero \n");
+        printf("opcion 1 para platzi cola normal \n");
+        printf("opcion 2 para platzi pina colada \n");
+
+        if (opt2 == 0)
+            printf("usted eligio una platzi cola cero, mmm rico");
+        else if (opt2 == 1)
+            printf("usted eligio una platzi cola cpn azucar, mmm rico");
+        else if (opt2 == 2)
+            printf("usted eligio una platzi pina colada con azucar, mmm rico");
+        else 
+            printf("opcion invalida");
+    }
+    else if(opt1 ==1){
+        //aqui va el menu de alimentos
+    }
+    else if(opt1 ==2){
+        //aqui va el menu de postres
+    }
+    else {
+        // mensaje de manejo de opcion invalida
+    }
+
+    return 0;
+}

subir/Curso de Control de Flujo en C/02-Toma de decisiones/04-Estructura y uso del switch en programación en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b69af0b554bee155d47b994eed87dd5c060cb6d30e2644f18d9c71c96e937b6
+size 129525828

subir/Curso de Control de Flujo en C/02-Toma de decisiones/04-Estructura y uso del switch en programación en C.vtt

@@ -0,0 +1,866 @@
+WEBVTT
+
+00:03.200 --> 00:05.800
+En esta clase vamos
+a aprender otra estructura
+
+00:05.926 --> 00:08.346
+para el control de flujo
+de nuestro programa,
+
+00:08.472 --> 00:12.878
+principalmente para decidir
+qué es el código que vamos a ejecutar.
+
+00:13.004 --> 00:14.817
+Y esta es la instrucción switch.
+
+00:15.077 --> 00:18.483
+Vamos a crearuna nueva tab aquí
+en nuestro Visual Studio Code.
+
+00:18.609 --> 00:20.869
+Vamos a guardarla, tú sabes, control S.
+
+00:20.995 --> 00:27.036
+Vamos a crear un nuevo archivo
+que se llame switch.c.
+
+00:30.012 --> 00:31.059
+Y listo.
+
+00:31.318 --> 00:34.045
+Ahora te quiero contar un poquito
+sobre esta estructura.
+
+00:34.385 --> 00:37.551
+La declaración switch
+es una estructura múltiple
+
+00:37.677 --> 00:39.926
+que nos va a servir para tomar decisiones,
+
+00:40.052 --> 00:42.403
+es decir, vamos a tener varios casos
+
+00:42.529 --> 00:44.898
+en donde puede entrar y en muchos casos
+
+00:45.023 --> 00:48.419
+de hecho se utiliza justo
+para no tener que crear
+
+00:48.545 --> 00:50.435
+muchos else ifs específicos.
+
+00:50.630 --> 00:55.710
+Ojo, que el switch funciona con valores
+constantes, es decir,
+
+00:55.836 --> 00:58.577
+cada una de las ramas
+que vamos a tener no va a tener
+
+00:58.703 --> 01:01.280
+tanto así una expresión como en el if,
+
+01:01.280 --> 01:04.718
+sino que vamos a tener solamente
+algún valor constante,
+
+01:04.843 --> 01:07.779
+por ejemplo, un número o una string,
+
+01:07.905 --> 01:09.176
+una cadena de caracteres
+
+01:09.302 --> 01:13.267
+o algo que vaya a ser permanente
+y fijo o constante.
+
+01:13.693 --> 01:15.428
+Luego esto lo vamos a comparar
+
+01:15.554 --> 01:19.717
+con una variable de control
+y esta va a ir entrando en cada una.
+
+01:19.843 --> 01:23.557
+Ves como que creamos este cubo de formas
+con los que juegan los bebés,
+
+01:23.841 --> 01:26.803
+en donde si la forma se match,
+entonces entra ahí,
+
+01:26.929 --> 01:30.133
+ah bueno, exactamente
+esa es la estructura switch.
+
+01:30.259 --> 01:33.676
+Uno de sus principales
+usos es crear máquinas de estado,
+
+01:33.802 --> 01:36.478
+es decir, sistemas en donde tu código
+
+01:36.603 --> 01:39.960
+se va a ir comportando 
+de forma predefinida
+
+01:39.960 --> 01:44.220
+y conforme vaya en cada uno de los pasos
+del switch va a ir ejecutando algo.
+
+01:44.346 --> 01:45.800
+Un caso de ejemplo clarísimo
+
+01:45.800 --> 01:48.951
+de una máquina de estado
+sería un robot vigilante,
+
+01:49.076 --> 01:52.255
+en donde el primer
+estado sería, ah ok, estado,
+
+01:52.381 --> 01:54.925
+alerta o detección, búsqueda de intrusos.
+
+01:55.218 --> 01:57.800
+Ese sería el primer estado
+y el robot se mantendría ahí
+
+01:57.800 --> 02:00.262
+por toda la vida hasta
+que detecta un intruso.
+
+02:00.387 --> 02:02.541
+Se cumpla todo el código de detección
+
+02:02.667 --> 02:07.044
+y pase al siguiente estado de alerta
+o dispersión de intrusos,
+
+02:07.170 --> 02:09.828
+por ejemplo, que ahí
+ya el robot lo perseguiría,
+
+02:09.954 --> 02:12.078
+activaría una alarma y hasta le dispararía
+
+02:12.203 --> 02:14.117
+con una pistola si lo programamos así.
+
+02:14.243 --> 02:16.194
+Ojalá que no,
+porque la violencia está mal.
+
+02:16.376 --> 02:21.723
+Luego, eso sería el estado de dispersión
+de intrusos y un tercer estado
+
+02:21.849 --> 02:23.839
+sería verificación de dispersión
+
+02:23.965 --> 02:29.569
+y un cuarto estado sería
+reseteo de estado o guardar
+
+02:29.695 --> 02:32.506
+la información de que ya
+detectamos un intruso, bla bla bla,
+
+02:32.632 --> 02:35.000
+pasó esto, se genera un block y después
+
+02:35.000 --> 02:38.042
+regresaríamos al estado 1,
+que sería el estado de alerta
+
+02:38.168 --> 02:40.117
+y búsqueda o detección de intrusos,
+
+02:40.243 --> 02:42.594
+en donde el robot pasaría
+la mayoría de su tiempo.
+
+02:42.720 --> 02:44.219
+Esto se puede crear con un switch.
+
+02:44.345 --> 02:49.188
+Veamos cómo sería una base
+o una estructura inicial
+
+02:49.314 --> 02:50.318
+de un código switch.
+
+02:50.655 --> 02:54.386
+Lo primero es declarar la expresión
+mentse, que es switch.
+
+02:54.532 --> 02:56.372
+Aquí nos lo autocompleta
+
+02:56.498 --> 02:59.200
+y está muy bien escrito de hecho.
+
+02:59.200 --> 03:02.298
+Entonces tenemos que nuestro switch
+va a verificar una expresión
+
+03:02.423 --> 03:06.456
+tal como lo hacía el if
+y vamos a tener nuestros casos.
+
+03:06.582 --> 03:08.849
+Aquí es donde yo te digo que vamos a tener
+
+03:08.974 --> 03:13.116
+nuestras expresiones constantes,
+el código de cada caso,
+
+03:13.242 --> 03:15.551
+y nosotros vamos a tener tantos casos
+
+03:15.677 --> 03:17.227
+como nosotros querramos.
+
+03:17.493 --> 03:19.653
+Entonces los casos pueden ser numéricos
+
+03:19.779 --> 03:21.951
+o pueden ser por cadenas de caracteres.
+
+03:22.077 --> 03:24.214
+Vamos a hacerlo con casos numéricos.
+
+03:25.747 --> 03:32.614
+Vamos a decirle que mi caso 1, el código
+sería detección de intrusos, ¿no?
+
+03:34.778 --> 03:39.086
+De intrusos y un break.
+El break es la instrucción
+
+03:39.212 --> 03:42.280
+o la sentencia que nos
+indica que ya se cumplió todo
+
+03:42.280 --> 03:46.701
+el código que teníamos
+aquí, entonces que se salga.
+
+03:47.915 --> 03:49.880
+Obviamente dentro de este caso
+
+03:49.880 --> 03:51.504
+podríamos tener instrucciones if,
+
+03:51.630 --> 03:53.489
+podríamos tener instrucciones if else,
+
+03:53.615 --> 03:55.916
+podemos tener todo el código C
+que querramos,
+
+03:56.103 --> 03:58.600
+todo lo que se necesite ejecutar
+en el caso 1.
+
+03:58.800 --> 04:00.601
+Luego tendríamos nuestrocaso 2.
+
+04:01.477 --> 04:03.903
+Y aquí sería lo mismo, por ejemplo,
+
+04:04.029 --> 04:07.440
+en el ejemplo ficticio
+que estábamos pensando,
+
+04:07.566 --> 04:11.348
+aquí sería espantar o dispersar,
+
+04:13.395 --> 04:17.265
+correr a los intrusos, ¿no?
+
+04:21.247 --> 04:23.781
+Luego tendríamos nuestro case 5.
+
+04:26.660 --> 04:31.276
+Y así sucesivamente en cada una
+de las instrucciones de nuestro switch.
+
+04:31.760 --> 04:33.698
+Ahora, hagamos esto en un ejemplo.
+
+04:33.824 --> 04:37.031
+Ya te enseñé la sintaxis.
+Vamos a tener tantos cases
+
+04:37.157 --> 04:40.041
+como necesitemos
+y vamos a tener un default.
+
+04:40.167 --> 04:42.195
+El default lo puedes ver como el else.
+
+04:42.399 --> 04:47.047
+Si ninguno de los casos se cumple,
+entonces vamos a ir a nuestro default.
+
+04:47.181 --> 04:48.792
+Por default vamos a hacer
+
+04:48.918 --> 04:51.035
+esta instrucción y hacemos un break
+
+04:51.196 --> 04:53.956
+que nos removería del código.
+
+04:54.923 --> 04:57.574
+Ahora, ¿qué sería la expresión a validar?
+
+04:57.700 --> 04:59.298
+Nuestra expresión muchas veces
+
+04:59.572 --> 05:01.708
+va a ser simple
+y sencillamente una variable
+
+05:01.834 --> 05:04.538
+que nosotros vamos a declarar.
+Por ejemplo,
+
+05:04.663 --> 05:07.957
+variable y si esta variable vale 1,
+entra 1,
+
+05:08.083 --> 05:11.348
+si esta variable vale 2, entra 2,
+si llega a valer 5, entra 5,
+
+05:11.474 --> 05:13.205
+si no tenemos ninguno de los valores
+
+05:13.331 --> 05:15.718
+sería el default y haríamos el código
+
+05:15.843 --> 05:17.985
+que tengamos en nuestro default.
+
+05:18.247 --> 05:21.844
+Con esto dicho, veamos un ejemplo
+en código ya más práctico.
+
+05:21.970 --> 05:23.440
+Creemos nuestro menú.
+
+05:26.898 --> 05:30.918
+Para esto, a nuestra estructura inicial
+voy a declararle lo de siempre.
+
+05:31.044 --> 05:33.008
+Necesito mi STDIO,
+
+05:33.134 --> 05:35.408
+vamos a, ya sabes, numeral include.
+
+05:36.170 --> 05:42.848
+Vamos a importar nuestra librería
+STDIO.h. Muy bien.
+
+05:42.974 --> 05:45.032
+Luego vamos a declarar nuestro main.
+
+05:45.412 --> 05:49.640
+Aquí está perfecto. Y en main
+vamos a poner nuestro switch.
+
+05:49.640 --> 05:52.378
+Recuerda que no necesitamos
+nada de esto por acá.
+
+05:52.899 --> 05:55.507
+Vamos a poner todo esto
+que ya teníamos escrito
+
+05:56.081 --> 05:58.758
+y vamos a asegurarnos
+de eliminar esta llavecita
+
+05:58.884 --> 06:02.587
+que teníamos ahí porque
+sólo nos va a estorbar en un futuro.
+
+06:02.747 --> 06:04.685
+Ahora hay que hacer
+la identación correcta.
+
+06:06.751 --> 06:09.008
+Vamos a poner
+nuestro break también ahí.
+
+06:09.134 --> 06:12.104
+La identación de verdad,
+no me canso de decir
+
+06:12.284 --> 06:15.049
+lo importante que es
+porque es la que nos define el orden
+
+06:15.175 --> 06:17.498
+y hace que el código
+sea más legible para nosotros.
+
+06:17.845 --> 06:21.227
+Al compilador en C
+no le importa la identación,
+
+06:21.353 --> 06:22.991
+de verdad,
+no le importa en absoluto.
+
+06:23.117 --> 06:26.661
+A quien le debe de importar
+es a ti porque si no identas,
+
+06:26.787 --> 06:28.798
+todo va a estar
+muy mal en tu código
+
+06:28.923 --> 06:32.836
+y va a ser un caos en
+cuestión de legibilidad.
+
+06:33.469 --> 06:37.195
+Vamos a ponerle su break.
+Vamos a ponerle punto y coma.
+
+06:38.182 --> 06:42.938
+Ya nada más nos falta jalarnos
+el default y el break.
+
+06:43.064 --> 06:45.415
+Y aquí quiero que comparemos
+esta instrucción
+
+06:45.541 --> 06:47.868
+con la instrucción que ya habíamos visto
+
+06:47.994 --> 06:53.506
+que era la de nuestros if anidados.
+
+06:53.632 --> 06:56.931
+Entonces yo quiero que hagamos
+un menú utilizando nuestros casos.
+
+06:57.271 --> 07:00.023
+Vamos a decirle que este programa,
+
+07:00.149 --> 07:05.658
+bienvenido, primf, y de hecho
+me voy a traer el menú
+
+07:05.784 --> 07:07.042
+de nuestros nested if.
+
+07:07.275 --> 07:10.172
+Vamos a copiarnos directamente esto.
+
+07:11.012 --> 07:15.922
+Perfectísimo. Por aquí
+y lo copiamos con control C
+
+07:16.048 --> 07:19.118
+y lo pegamos acá en donde pertenece.
+
+07:20.845 --> 07:23.824
+Dice bienvenido a Platzi Store.
+Mira que se nos identó mal.
+
+07:23.950 --> 07:26.994
+Vamos a identarlo bien. No pasa nada.
+
+07:27.120 --> 07:29.651
+Solo voy a darle uno más
+al switch y ya está todo bello.
+
+07:30.097 --> 07:32.156
+Vamos a decirle bienvenido a Platzi Store.
+
+07:32.282 --> 07:36.862
+Opción 0 para platzi bebidas,
+opción 1 para platzi comidas
+
+07:36.988 --> 07:38.858
+y opción 2 para platzi postres.
+
+07:39.132 --> 07:42.480
+Vamos a escribir acá nuestra
+variable de tipo entero
+
+07:42.480 --> 07:49.032
+que va a ser int opcion 1
+y vamos a inicializarla
+
+07:49.158 --> 07:53.055
+en 0 punto y coma. Excelente.
+Tenemos ya nuestro menú
+
+07:53.181 --> 07:56.258
+y la variable que vamos
+a estar leyendo va a ser
+
+07:56.383 --> 07:59.257
+igual a opción 1. No se me puso el 1 bien.
+
+07:59.473 --> 08:01.326
+Ahora sí, guardo.
+
+08:02.399 --> 08:05.872
+Y el caso no va a empezar en 1
+sino que voy a empezar en 0.
+
+08:06.710 --> 08:11.331
+1, control copy
+
+08:13.303 --> 08:16.076
+y por último caso 2.
+
+08:17.289 --> 08:18.798
+Vamos para el caso 0.
+
+08:19.113 --> 08:21.768
+Vamos a traernos este código
+que ya había escrito aquí.
+
+08:22.813 --> 08:25.262
+Vamos a imprimirlo en nuestro case.
+
+08:26.966 --> 08:29.055
+Vamos a identar un poco esto.
+
+08:31.461 --> 08:33.888
+Hago mucho énfasis en identación
+porque de verdad
+
+08:34.014 --> 08:35.279
+es muy, muy importante.
+
+08:35.405 --> 08:39.437
+Es de lo mejor que pueden hacer
+que su código sea legible y bonito.
+
+08:39.830 --> 08:42.795
+Y aquí ya podemos
+nosotros poner otro switch
+
+08:43.540 --> 08:46.317
+o podríamos poner directamente un if,
+
+08:46.443 --> 08:48.734
+lo que ustedes quieran, uno o varios if.
+
+08:48.967 --> 08:51.318
+Estas instrucciones se pueden
+combinar entre ellas,
+
+08:51.444 --> 08:56.203
+pero de momento solo les estoy enseñando
+el switch, así que voy a usar un switch.
+
+08:57.509 --> 09:00.361
+Vamos a declarar nuestra
+variable opción 2, int
+
+09:00.696 --> 09:06.453
+opción 2 igual a 0, 
+0 punto y coma y listo.
+
+09:09.065 --> 09:13.036
+Vamos a tener switch opción 2
+y vamos a copiar nuestros casos.
+
+09:13.256 --> 09:16.299
+El primer caso va a ser el caso 0
+
+09:17.820 --> 09:23.253
+y en el caso 0 yo pondría
+que nos compraron una Platzi Cola.
+
+09:23.819 --> 09:27.332
+Si se acuerdan
+hablábamos de la Platzi Cola 0.
+
+09:29.200 --> 09:31.488
+Perfecto. Control copy,
+vamos a nuestro switch
+
+09:31.614 --> 09:35.800
+y ponemos nuestro código.
+Con esto ya podemos
+
+09:35.800 --> 09:38.619
+verificar si está funcionando todo bien,
+
+09:38.922 --> 09:43.314
+así que hagamos justamente eso.
+Default break, default break
+
+09:43.440 --> 09:46.037
+y default y sub break. Excelente.
+
+09:46.617 --> 09:51.012
+Vamos a poner 0, 0 para ver si entramos
+a la opción 0 que es Platzi Cola 0
+
+09:51.138 --> 09:53.802
+y luego entramos a la opción que es,
+
+09:53.928 --> 09:56.699
+y luego se imprime
+en nuestro menú de bebidas,
+
+09:56.825 --> 09:59.878
+que es este, y luego
+entramos a la opción Platzi Cola 0.
+
+10:00.004 --> 10:02.888
+Muy bien. Vamos a dejar todo
+así como está.
+
+10:03.014 --> 10:07.039
+Control S y compilamos
+y ejecutamos nuestro código.
+
+10:07.766 --> 10:10.961
+Y nos marca un error,
+dice expected declaration
+
+10:11.087 --> 10:13.371
+or statement y el error está
+en la función main.
+
+10:13.497 --> 10:16.080
+Lo que está pasando, ah no mira,
+
+10:16.080 --> 10:20.458
+dice switch bla bla bla,
+esto está muy raro,
+
+10:20.583 --> 10:24.960
+dice línea 37,1. Vamos a la
+línea 37 y veamos qué pasa
+
+10:24.960 --> 10:27.142
+con esta llave que tenemos acá.
+
+10:27.363 --> 10:31.342
+Uy, y claro, lo que está pasando
+es que esta llave cierra a este switch
+
+10:31.468 --> 10:34.554
+y deberíamos cerrar nuestro main,
+pues corrijamos eso.
+
+10:34.874 --> 10:37.371
+Entonces vamos a poner otra llave
+
+10:37.497 --> 10:41.054
+antes del return que debería de cerrar
+a nuestro switch grande,
+
+10:41.194 --> 10:45.271
+a nuestro switch 1,
+que es el gran el gran switch
+
+10:45.397 --> 10:46.977
+que controla el estado
+de nuestro programa,
+
+10:47.103 --> 10:48.967
+en donde estamos en este momento.
+
+10:49.093 --> 10:51.007
+Vamos a guardar
+y vamos a identar bien todo.
+
+10:51.132 --> 10:53.891
+Mira que aquí está bien,
+entramos a nuestro primer switch,
+
+10:54.017 --> 10:56.828
+tenemos nuestro key 0,
+luego entramos a nuestro segundo switch
+
+10:56.954 --> 10:58.978
+y aquí este key 0 no está bien identado.
+
+10:59.104 --> 11:00.997
+Vamos a ponerlo y todo esto debería
+
+11:01.123 --> 11:02.984
+estar un nivel adentro más.
+
+11:04.131 --> 11:05.229
+El default también.
+
+11:05.355 --> 11:08.817
+Y ya con eso yo sé que esto
+pertenece a este switch
+
+11:08.943 --> 11:11.240
+que tenemos acá.
+Date cuenta de cómo todo
+
+11:11.240 --> 11:14.269
+se va volviendo más legible
+conforme tenemos cuidado
+
+11:14.395 --> 11:17.512
+de escribir las cosas
+de la mejor forma posible.
+
+11:18.052 --> 11:21.391
+Es por eso importantísimo.
+Luego, luego de esto,
+
+11:21.517 --> 11:24.868
+ya simple y sencillamente
+vamos a poner los breaks bien.
+
+11:24.994 --> 11:28.727
+Los breaks, yo los pongo
+un nivel adentro de mi case
+
+11:30.053 --> 11:32.066
+y de mi default también, por supuesto.
+
+11:32.192 --> 11:35.479
+Tenemos nuestra llave
+y tenemos nuestro return 0.
+
+11:35.605 --> 11:37.375
+Control S, compilamos.
+
+11:39.730 --> 11:42.369
+Vamos a esperar que ocurre y ya.
+
+11:42.529 --> 11:45.777
+Bellísimo, todo funcionó.
+Bienvenido a Platzi Store.
+
+11:45.977 --> 11:49.412
+Opción 0 para platzi bebidas,
+opción 1 para platzi comidas.
+
+11:49.538 --> 11:50.999
+Usted eligió la opción 0,
+
+11:51.124 --> 11:53.114
+verá nuestro menú de bebidas, elija una.
+
+11:53.240 --> 11:56.696
+Opción 0 para platzi cola,
+para platzi cola normal
+
+11:56.822 --> 12:00.144
+y para platzi pina colada.
+Luego usted eligió una platzi cola 0.
+
+12:00.289 --> 12:04.014
+Rico, excelente. Con esto
+ya viste cómo podemos
+
+12:04.140 --> 12:06.520
+usar el switch para crear
+este tipo de menús.
+
+12:06.520 --> 12:08.901
+Yo quiero aquí que te quede
+un aprendizaje y esto
+
+12:09.027 --> 12:12.200
+es una buena práctica.
+Nosotros solemos utilizar
+
+12:12.200 --> 12:15.138
+switch principalmente
+para máquinas de estado,
+
+12:15.263 --> 12:19.363
+para control a gran escala
+del flujo de nuestro programa.
+
+12:19.489 --> 12:22.555
+Cada uno de los cases podría tener
+mucho código adentro.
+
+12:22.982 --> 12:26.207
+Se vuelve muy complejo usar switch
+dentro de switches.
+
+12:26.387 --> 12:28.167
+Ya ahí dentro de cada case
+
+12:28.293 --> 12:30.600
+tú debes de crear una lógica
+normal de C que conforme
+
+12:30.600 --> 12:34.018
+vayamos aprendiendo a
+hacer cosas más complejas
+
+12:34.183 --> 12:37.938
+te va a quedar súper clara.
+Pero de momento, por favor,
+
+12:38.064 --> 12:39.978
+quiero que solamente
+te quedes con la estructura
+
+12:40.103 --> 12:41.884
+y que recuerdes, el switch es bueno
+
+12:42.010 --> 12:43.764
+en grandes estructuras en C.
+
+12:43.922 --> 12:46.773
+Es donde lo solemos utilizar
+en máquinas de estado.
+
+12:46.899 --> 12:48.000
+Es mejor que una máquina
+
+12:48.000 --> 12:50.958
+de estados esté hecha
+con switches versus Eaves
+
+12:51.083 --> 12:54.040
+porque simplemente
+tienes una gran estructura
+
+12:54.040 --> 12:56.701
+general en donde tienes tus declaraciones.
+
+12:56.827 --> 12:59.851
+Y aquí quiero que veas el código.
+Tenemos nuestros valores constantes
+
+12:59.977 --> 13:03.215
+que son case 0, tenemos nuestro case 1,
+
+13:03.341 --> 13:05.920
+nuestro case 2 y ahí
+vas a poner cada parte
+
+13:05.920 --> 13:07.930
+de tu código que necesites que se ejecute
+
+13:08.056 --> 13:12.700
+de forma específica 
+en un código C más grande.
+
+13:12.826 --> 13:18.360
+Con esto dicho, pues nos vemos
+en la siguiente clase.

subir/Curso de Control de Flujo en C/02-Toma de decisiones/04-switch_26ee0200-c773-4d19-a0d9-ba7fc5b5f686.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+int opt1 = 0;
+int opt2 = 0;
+
+int main()
+{
+    printf("bienvenid a platzi store :\n");
+    printf("opcion 0 para platzi bebidas \n");
+    printf("opcion 1 para platzi comidas \n");
+    printf("opcion 2 para platzi postres \n");
+    switch (opt1 ){
+
+        case 0:
+            printf("usted eligio la opcion 0, vera nuestro menu de bebidas elija una:\n");
+            printf("opcion 0 para platzi cola cero \n");
+            printf("opcion 1 para platzi cola normal \n");
+            printf("opcion 2 para platzi pina colada \n");
+            switch (opt2)
+            {
+                case 0:
+                    printf("usted eligio una platzi cola cero, mmm rico");
+                    break;
+            
+                default:
+                    break;
+            }
+                break;
+        case 1:
+           /* Dispersar, correr a los intrusos */
+            break;
+        case 2:
+           /* Dispersar, correr a los intrusos */
+            break;
+        default:
+            break;
+    }
+    return 0;
+}
+
+

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/01-Bucle While en C Implementación y Ejemplos Prácticos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89dff8bddf4192a6f4d218201b047581a0ffc8d589414a995794414f85ac03c3
+size 66311251

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/01-Bucle While en C Implementación y Ejemplos Prácticos.vtt

@@ -0,0 +1,500 @@
+WEBVTT
+
+00:03.313 --> 00:08.561
+Bueno, llegó el momento de hablar
+de los bucles o ciclos en C.
+
+00:08.921 --> 00:12.244
+Tú, cuando tienes un programa, muchas
+veces vas a necesitar
+
+00:12.370 --> 00:16.040
+que alguna parte de tu código se repita
+bastante tiempo.
+
+00:16.218 --> 00:17.920
+Regresando al ejemplo de nuestro robot,
+
+00:17.920 --> 00:19.969
+sentinela o guardia de seguridad,
+
+00:20.095 --> 00:23.453
+el bucle donde el robot
+va a estar siempre,
+
+00:23.579 --> 00:29.202
+siempre escaneando o buscando un ladrón
+
+00:29.328 --> 00:31.032
+o alguien que está, algún intruso,
+
+00:31.158 --> 00:33.160
+bueno, esto pues va a ser un bucle
+
+00:33.160 --> 00:36.393
+porque el robot va a estar repitiendo
+la misma acción
+
+00:36.519 --> 00:40.134
+de encontrar un enemigo
+hasta que lo encuentre.
+
+00:40.260 --> 00:41.320
+Y una vez lo
+encuentre,
+
+00:41.507 --> 00:43.944
+no necesitaríamos
+que se siga repitiendo eso
+
+00:44.070 --> 00:46.475
+porque nos saldríamos de ese bucle
+infinito
+
+00:46.601 --> 00:49.172
+y nos iríamos a otra parte
+
+00:49.298 --> 00:52.515
+que sería ya la parte de correr al ladrón
+de la zona,
+
+00:52.641 --> 00:54.668
+sonar la alarma, etcétera, etcétera.
+
+00:54.794 --> 00:58.014
+Con esto dicho,
+veamos el bucle while y do while
+
+00:58.140 --> 01:00.280
+que nos van a servir
+exactamente para esto.
+
+01:00.408 --> 01:02.885
+Y te explico cómo funciona
+en el lenguaje C.
+
+01:03.011 --> 01:05.136
+En el lenguaje C, el bucle while
+
+01:05.262 --> 01:08.270
+simple y sencillamente
+evalúa una expresión, ¿ok?
+
+01:08.693 --> 01:12.471
+Y evalúa la expresión siempre
+y cuando la expresión sea true,
+
+01:12.597 --> 01:17.481
+sea 1, el bucle se va a repetir y va a
+reevaluar la expresión.
+
+01:17.607 --> 01:21.091
+Si la expresión sigue siendo 1,
+vuelve a repetir
+
+01:21.217 --> 01:23.080
+y entonces evalúa otra vez la expresión.
+
+01:23.336 --> 01:25.339
+Cuando la expresión sea 0,
+
+01:25.465 --> 01:29.568
+es cuando se sale del bucle
+y continúa la ejecución del programa
+
+01:29.694 --> 01:33.032
+después de todo el bloque
+que tengamos en nuestro while.
+
+01:33.158 --> 01:35.824
+Ya estamos aquí en nuestra terminal
+de Visual Studio Code,
+
+01:35.950 --> 01:38.330
+vamos a abrir una nueva tab
+
+01:38.637 --> 01:42.684
+y te voy a enseñar cómo funciona
+a grandes rasgos el while.
+
+01:43.898 --> 01:45.080
+Lo primero que hay que hacer, ya sabes,
+
+01:45.080 --> 01:46.974
+control N para abrir una nueva pestaña,
+
+01:47.100 --> 01:50.422
+control S para guardar,
+vamos a ponerle while. c.
+
+01:50.548 --> 01:52.440
+While se podría traducir como mientras,
+
+01:52.440 --> 01:56.729
+así que mientras la condición se cumpla,
+
+01:56.855 --> 01:59.195
+se va a ejecutar todo el bloque de código.
+
+01:59.455 --> 02:02.963
+Cuando la condición se deja de cumplir,
+
+02:03.089 --> 02:05.627
+entonces este bloque de código
+se deja de ejecutar
+
+02:05.753 --> 02:08.160
+y se retoma la ejecución
+al final de este bloque,
+
+02:08.160 --> 02:10.400
+o sea, aquí, todo lo que tengamos abajo.
+
+02:10.893 --> 02:14.720
+¿Qué es lo más importante que quiero
+que tengas claro desde este momento?
+
+02:15.283 --> 02:17.520
+Tú eres quien controla el while,
+
+02:17.760 --> 02:20.824
+entonces dentro del while
+tú debes de asegurarte
+
+02:20.950 --> 02:25.080
+cuál es la instrucción que va a cambiar
+para que nuestro while se salga.
+
+02:25.080 --> 02:25.956
+¿Ok?
+
+02:25.982 --> 02:29.106
+Eso es lo más importante que debes
+de tener en cuenta.
+
+02:29.232 --> 02:31.950
+Si tú no le das una opción al while
+de que se salga,
+
+02:32.076 --> 02:33.570
+entonces nunca se va a salir
+
+02:33.696 --> 02:36.991
+y entonces estaríamos
+en un problema grave,
+
+02:37.117 --> 02:40.400
+porque tu código se quedaría atorado
+ahí de forma infinita
+
+02:40.400 --> 02:43.200
+y simple y sencillamente
+no haría nada más.
+
+02:43.510 --> 02:46.105
+Veamos ya un ejemplo en código,
+el while es súper simple.
+
+02:46.545 --> 02:48.840
+Vamos a crear la estructura de siempre,
+
+02:48.840 --> 02:53.770
+vamos a importar,
+incluir nuestra librería
+
+02:54.383 --> 02:57.607
+standard de input output main.
+
+02:59.706 --> 03:00.706
+Perfecto.
+
+03:01.580 --> 03:03.750
+Vamos a quitarle esto.
+
+03:04.043 --> 03:06.904
+Vamos y ya aquí está todo donde
+debería ir todo el código,
+
+03:07.030 --> 03:09.741
+todo está excelente,
+vamos a poner nuestro while ahí.
+
+03:09.867 --> 03:12.120
+Y quiero que hagamos algo súper simple,
+
+03:12.120 --> 03:16.046
+quiero que veas el funcionamiento
+de un while en acción.
+
+03:16.172 --> 03:19.634
+Así que vamos a declarar una variable n
+del tipo entero,
+
+03:19.760 --> 03:23.886
+int n va a ser igual a 20, punto y coma.
+
+03:24.766 --> 03:28.094
+Y quiero que simplemente veas
+el while en acción.
+
+03:28.220 --> 03:35.203
+Entonces voy a decir que mientras n sea
+mayor a 10, voy a imprimir,
+
+03:38.866 --> 03:40.266
+voy a imprimir,
+
+03:41.719 --> 03:47.023
+n es igual a, vamos a poner por ciento de,
+
+03:47.149 --> 03:49.803
+para poner nuestro decimal aquí,
+por ciento de,
+
+03:49.929 --> 03:52.000
+coma y la variable que vamos a estar
+imprimiendo,
+
+03:52.000 --> 03:53.840
+que en este caso será n.
+
+03:53.840 --> 03:54.907
+Excelente.
+
+03:55.081 --> 03:58.529
+Guardamos y luego quiero que hagamos
+una pequeña operación de resta.
+
+03:58.655 --> 04:03.040
+Además del por ciento de hay que poner
+un salto de línea
+
+04:03.040 --> 04:07.030
+para que todo se vaya escribiendo
+en una línea más abajo y así sucesivamente.
+
+04:07.630 --> 04:09.240
+Y esto va aquí.
+
+04:10.661 --> 04:11.754
+Excelente.
+
+04:12.001 --> 04:14.920
+Luego voy a hacer una pequeña operación
+aritmética.
+
+04:14.920 --> 04:22.115
+n va a ser igual a n menos 1,
+punto y coma.
+
+04:23.022 --> 04:24.196
+¿Qué estoy haciendo aquí?
+
+04:24.322 --> 04:27.383
+Que cada ciclo le resto un 1 a n.
+
+04:27.509 --> 04:30.880
+Cada que se repite mi while
+yo le resto un 1 a n.
+
+04:30.880 --> 04:31.921
+¿Qué va a pasar?
+
+04:32.047 --> 04:35.035
+Pues que n en algún punto
+va a dejar de ser mayor que 10.
+
+04:35.457 --> 04:37.786
+Entonces vamos a ver qué pasa.
+
+04:38.892 --> 04:41.238
+Y aquí deberíamos de poner otro print.
+
+04:42.598 --> 04:45.515
+Y mira que aquí tengo un grave error
+que no he dentado el while.
+
+04:45.754 --> 04:47.432
+Lo corregimos fácilmente.
+
+04:49.925 --> 04:52.411
+Corregimos todo, corregimos todo.
+
+04:54.934 --> 04:57.375
+Y ponemos este acá.
+
+04:57.713 --> 04:58.913
+Excelente.
+
+04:59.535 --> 05:00.872
+Todo bello ahora, sí.
+
+05:01.186 --> 05:03.040
+Por último voy a poner un print.
+
+05:04.623 --> 05:11.594
+Y este print va a decir
+el ciclo while ha salido.
+
+05:11.974 --> 05:16.630
+El bucle se ha saltado.
+
+05:18.687 --> 05:21.173
+¿Hemos salido del bucle
+sería lo correcto en español?
+
+05:21.933 --> 05:27.551
+Hemos salido del bucle porque n
+
+05:27.677 --> 05:31.337
+es igual o menor que 10.
+
+05:32.110 --> 05:34.123
+Excelente.
+Punto y coma.
+
+05:34.249 --> 05:37.406
+Y ya solo nos falta el return igual,
+el return 0.
+
+05:39.273 --> 05:40.532
+Punto y coma.
+
+05:41.225 --> 05:42.726
+Uf, un typo acá.
+
+05:42.852 --> 05:43.749
+Muy bien.
+
+05:43.962 --> 05:45.200
+Todo perfecto.
+
+05:45.719 --> 05:46.859
+¿Qué debería pasar aquí?
+
+05:46.985 --> 05:48.214
+Vamos a entrar al while.
+
+05:48.340 --> 05:51.401
+Se va a verificar la expresión n
+es mayor que 10.
+
+05:51.527 --> 05:52.289
+¿Sí o no?
+
+05:52.415 --> 05:55.509
+Sí, porque n es 20 y 20 es mayor que 10.
+
+05:55.863 --> 05:58.502
+Entonces mientras esto se cumpla,
+
+05:58.628 --> 06:01.288
+se va a ejecutar este código
+que tenemos aquí adentro
+
+06:01.414 --> 06:04.336
+hasta que se deje de cumplir
+y nos salgamos.
+
+06:04.462 --> 06:08.080
+Vamos a guardar y vamos a compilar
+nuestro programa.
+
+06:08.379 --> 06:09.299
+Muy bien.
+
+06:09.425 --> 06:11.080
+Y mira que se imprime correctamente.
+
+06:11.080 --> 06:13.514
+n es igual a 20, luego le restamos 1,
+
+06:13.640 --> 06:16.670
+se repite, evalúa la expresión y 19.
+
+06:16.943 --> 06:18.288
+¿19 es mayor que 10?
+
+06:18.414 --> 06:18.974
+Sí.
+
+06:19.100 --> 06:21.720
+Entonces lo imprime, le resta 1 y es 18.
+
+06:21.884 --> 06:23.225
+¿18 es mayor que 10?
+
+06:23.351 --> 06:23.951
+Sí.
+
+06:24.077 --> 06:25.143
+Y así hasta 11.
+
+06:25.269 --> 06:26.800
+A 11 se le resta 1.
+
+06:26.926 --> 06:28.313
+¿10 es mayor que 10?
+
+06:28.439 --> 06:28.966
+No.
+
+06:29.092 --> 06:30.928
+Y nos dice hemos salido del bucle,
+
+06:31.054 --> 06:32.680
+porque n es igual o menor que 10.
+
+06:32.680 --> 06:33.851
+Se me fue una S.
+
+06:34.078 --> 06:38.122
+Ahí, bueno, no pasa nada,
+la agregamos y todo bello.
+
+06:38.248 --> 06:43.280
+Ahora, ¿qué pasa si nosotros de una
+declaramos 10 como nuestra variable?
+
+06:43.280 --> 06:44.476
+¿Qué debería pasar?
+
+06:44.602 --> 06:47.139
+Piénsalo por favor y cuéntame
+en los comentarios.
+
+06:47.265 --> 06:50.496
+Vamos con fn, f6, en mi caso porque tengo
+un laptop,
+
+06:50.622 --> 06:51.949
+compilamos y ejecutamos,
+
+06:52.075 --> 06:55.630
+y dice hemos salido del bucle porque n
+es igual o menor que 10.
+
+06:55.756 --> 06:59.316
+Como evaluamos la expresión
+y fue 0 desde el principio,
+
+06:59.442 --> 07:02.930
+nunca entramos aquí,
+nunca entramos ni una sola vez.
+
+07:03.056 --> 07:06.620
+Pero, ¿qué pasa si tú quisieras entrar
+al menos una vez?
+
+07:06.746 --> 07:09.120
+Porque tu programa lo amerita.
+
+07:09.553 --> 07:10.513
+¿Qué pasa ahí?
+
+07:10.639 --> 07:12.820
+Bueno, para eso existe el do while,
+
+07:12.946 --> 07:18.720
+y es lo que vamos a aprender
+en la próxima clase.

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/01-while_189ccca7-d3a5-4d0c-8408-4fc807afdccd.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+int n = 10;
+int main()
+{
+    while (n > 10){
+        printf("n es igual a %d\n", n);
+        n = n-1;
+    }
+    printf("hemos salido del bucle porque n es igual o menor que 10");
+    return 0;
+}
+
+
+

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/02-Ciclos WHILE y DOWHILE en Programación.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3e0cd212c53c5528720a189356438a64ca96c70673afb8424fd2dc33e7cb762
+size 69648787

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/02-Ciclos WHILE y DOWHILE en Programación.vtt

@@ -0,0 +1,490 @@
+WEBVTT
+
+00:03.140 --> 00:06.954
+Más adelante veremos el tercer bucle
+que es el ciclo FOR.
+
+00:07.080 --> 00:10.160
+Pero desde ya quiero que vayas teniendo
+clara una cosa.
+
+00:10.712 --> 00:17.040
+Los ciclos WHILE los vamos a utilizar como
+ejecución condicional en nuestro código.
+
+00:17.507 --> 00:22.580
+Es decir, tenemos que poner una condición
+y si se cumple vamos a ejecutarlo.
+
+00:22.886 --> 00:25.480
+El ejemplo que te puse va a ser igual
+para un ciclo FOR.
+
+00:25.665 --> 00:26.390
+¿Por qué?
+
+00:26.516 --> 00:31.320
+Porque el ciclo FOR siempre lo vamos a
+usar cuando nosotros sepamos cuál
+
+00:31.320 --> 00:33.440
+es la cantidad de elementos
+que querramos iterar.
+
+00:33.440 --> 00:35.040
+¿Ok?
+Toma en cuenta eso.
+
+00:35.040 --> 00:39.063
+Ciclo FOR, cuando tú tengas claro cuántos
+elementos vas a iterar.
+
+00:39.203 --> 00:44.480
+Ciclo WHILE, cuando vayas a hacer
+una ejecución condicional de tu bucle.
+
+00:44.930 --> 00:50.234
+Y aquí de nuevo, un WHILE, por ejemplo,
+podría ser para un robot de minisumo.
+
+00:50.360 --> 00:52.198
+Que los minisumos
+son estos pequeños robots
+
+00:52.323 --> 00:54.400
+que se tienen que encontrar unos a otros
+
+00:54.400 --> 00:57.080
+y sacar del dojo, como los sumos grandes
+pero en robótico.
+
+00:57.536 --> 01:02.240
+Bueno, un WHILE podría ser mientras estás
+en la rutina de búsqueda y la condición
+
+01:02.240 --> 01:07.342
+sería que si encontraste algo, entonces el
+WHILE se deja de cumplir, te sales de ahí
+
+01:07.468 --> 01:11.061
+y comienzas a otra rutina
+que sería de persecución
+
+01:11.187 --> 01:13.551
+al objetivo que has encontrado
+y de sacarlo.
+
+01:13.951 --> 01:16.381
+Eso sería un ejemplo de
+una ejecución condicional
+
+01:16.507 --> 01:18.672
+en donde depende de factores externos.
+
+01:18.798 --> 01:21.116
+Por ejemplo, de que el usuario
+ponga un input,
+
+01:21.242 --> 01:22.880
+de que tu robot detecte algo,
+
+01:23.125 --> 01:26.840
+de que tu software sienta o vea un cambio
+en su programa.
+
+01:27.267 --> 01:30.302
+Esto es lo que nosotros vamos a estar
+buscando con los ciclos WHILE.
+
+01:30.428 --> 01:34.447
+Estos pequeños cambios que si no ocurren,
+todo está cool,
+
+01:34.573 --> 01:37.899
+todo está bien y el programa se puede
+seguir bucleando.
+
+01:38.319 --> 01:39.480
+¿Todo claro? Muy bien.
+
+01:39.936 --> 01:44.400
+Otro ejemplo de este caso de uso, por
+ejemplo en C o en cuestiones de drivers,
+
+01:44.400 --> 01:47.259
+podría ser un WHILE para que mientras
+
+01:47.384 --> 01:50.976
+se están pasando archivos
+de un chip a otro chip,
+
+01:51.102 --> 01:53.806
+ok, mientras hay una
+transferencia de archivos,
+
+01:53.932 --> 01:56.396
+no hagas nada,
+simplemente transfiera archivos.
+
+01:56.536 --> 01:58.458
+Cuando terminó la transferencia,
+
+01:58.583 --> 02:00.920
+te podrías salir del ciclo WHILE y podrías
+
+02:00.920 --> 02:03.200
+simple y sencillamente continuar
+con la ejecución de tu programa.
+
+02:03.752 --> 02:05.649
+¿Cuál es la clave aquí?
+
+02:05.929 --> 02:09.470
+Que tú no sabes de antemano
+cuándo vas a acabar,
+
+02:09.596 --> 02:11.440
+por ejemplo,
+la transferencia de archivos.
+
+02:11.440 --> 02:16.400
+Tú no sabes de antemano cuándo vas
+a detectar algún cambio en tus sensores.
+
+02:16.400 --> 02:19.659
+Imagínate que haces
+un proyecto que se encarga de cerrar
+
+02:19.785 --> 02:22.135
+automáticamente tus ventanas
+cuando detecta lluvia.
+
+02:22.502 --> 02:24.439
+¿Tú sabes cuándo va a llover?
+No.
+
+02:24.565 --> 02:28.625
+Entonces tienes que tener un WHILE que
+esté constantemente esperando a la lluvia
+
+02:28.751 --> 02:32.355
+y cuando llegue la lluvia,
+entonces mientras no haya lluvia,
+
+02:32.481 --> 02:34.471
+ el WHILE sigue ahí buscando lluvia.
+
+02:34.845 --> 02:37.095
+Y tú no sabes cuándo va a llover,
+nadie sabe.
+
+02:37.262 --> 02:41.390
+Y cuando llega la lluvia, entonces el
+WHILE detecta la lluvia con tu sensor,
+
+02:41.516 --> 02:44.260
+cambias una variable
+para que la condición
+
+02:44.386 --> 02:46.840
+se deje de cumplir
+y te vas al resto del código,
+
+02:46.840 --> 02:49.800
+que sería simple y sencillamente
+cerrar la ventana.
+
+02:50.473 --> 02:54.726
+¿Qué pasa con esto?
+El WHILE es una herramienta
+
+02:54.852 --> 02:57.400
+poderosísima y quiero
+que te quede claro
+
+02:57.400 --> 03:02.410
+que se utiliza para bucles cuando
+tienen una ejecución condicional.
+
+03:02.536 --> 03:07.474
+Con esto dicho, vamos a ver al hermano
+del WHILE que es el doWHILE allá.
+
+03:07.600 --> 03:08.480
+Vamos a eso.
+
+03:08.606 --> 03:11.027
+Creamos un nuevo archivo
+en nuestro editor y lo guardamos.
+
+03:11.153 --> 03:13.393
+Este
+se va a llamar doWHILE,
+
+03:13.519 --> 03:16.647
+que significaría haz mientras.c.
+
+03:17.894 --> 03:20.218
+La estructura básica de nuestro doWHILE
+
+03:20.343 --> 03:23.561
+va a ser bien, bien parecida,
+sólo que al revés.
+
+03:23.687 --> 03:26.138
+Nosotros vamos a inicializarlo con un do,
+
+03:26.264 --> 03:29.481
+vamos a  poner todo el código
+de nuestro programa
+
+03:29.607 --> 03:31.929
+y vamos a checar con nuestro condicional.
+
+03:32.150 --> 03:36.142
+¿Qué ganamos
+con poner nuestra condicional al final?
+
+03:36.382 --> 03:39.301
+Ganamos algo muy importante
+en ciertos casos
+
+03:39.427 --> 03:44.869
+y es que vamos a ejecutar
+el código al menos una sola vez.
+
+03:44.995 --> 03:48.532
+Es decir, aunque
+en el WHILE tradicional
+
+03:48.658 --> 03:51.047
+si la condición no se
+cumple desde el principio,
+
+03:51.173 --> 03:55.006
+no lo ejecutamos nunca, pero en el doWHILE
+lo hacemos al menos una vez.
+
+03:55.132 --> 03:57.369
+Imagínate que tuvieras
+que programar un código
+
+03:57.495 --> 03:59.200
+de muy bajo nivel en donde te encargas
+
+03:59.200 --> 04:03.451
+de la transferencia de archivos
+en tu sistema operativo. ¡Uy, qué miedo!
+
+04:03.577 --> 04:06.495
+Pues no, simplemente tendrías
+que ver cómo lo hace Windows,
+
+04:06.621 --> 04:08.690
+qué variables te da, qué objetos tienes
+
+04:08.913 --> 04:13.287
+y podrías hacer un doWHILE.
+¿Por qué? Porque dentro de esta subrutina,
+
+04:13.413 --> 04:15.353
+dentro de tu
+doWHILE podrías verificar
+
+04:15.479 --> 04:18.738
+cuál es el peso del archivo,
+ya que lo necesitas saber
+
+04:18.863 --> 04:22.320
+al menos una vez.
+Si tú no sabes cuál es
+
+04:22.320 --> 04:25.134
+el peso del archivo, ¿cómo
+vas a saber si ya terminaste
+
+04:25.259 --> 04:28.738
+de transferirlo o no? Entonces podríamos
+hacerlo con un doWHILE.
+
+04:28.864 --> 04:31.561
+Verificamos el peso del archivo
+y verificamos que aún
+
+04:31.687 --> 04:34.019
+no hayamos transferido una cantidad igual
+
+04:34.145 --> 04:36.278
+al peso del archivo y repetimos
+
+04:36.403 --> 04:40.888
+el bucle hasta que ya
+el archivo completo se transfirió.
+
+04:41.014 --> 04:43.245
+Y así de fácil podríamos
+ver un caso de uso.
+
+04:43.371 --> 04:45.249
+Entonces siempre que tú digas,
+
+04:45.375 --> 04:47.514
+ah, pero yo necesito que se haga
+al menos una vez esto.
+
+04:47.640 --> 04:49.732
+¿Y cuándo vas a, como programadora
+
+04:49.858 --> 04:51.759
+o como programador, tener estos casos?
+
+04:51.885 --> 04:53.736
+Cuando tienes que inicializar algo.
+
+04:54.043 --> 04:56.080
+Imagínate que tienes un robot
+
+04:56.080 --> 04:59.033
+y tienes que asegurarte,
+antes de que el robot haga cualquier cosa,
+
+04:59.159 --> 05:00.924
+tienes que asegurarte de que el robot
+
+05:01.050 --> 05:03.409
+está sensando de forma correcta,
+
+05:03.534 --> 05:06.626
+de que los sensores están funcionando.
+Entonces podríamos
+
+05:06.752 --> 05:09.476
+hacer un código de inicialización
+que utilice un doWHILE,
+
+05:09.736 --> 05:12.394
+que diga, ok, el sensor 1,
+le mandas un voltaje,
+
+05:12.520 --> 05:14.050
+esperas una respuesta del sensor,
+
+05:14.176 --> 05:16.973
+si hay respuesta entonces
+ok, el sensor funcionó.
+
+05:17.480 --> 05:20.347
+Y si no hay respuesta,
+y eso puede ser la primera vez
+
+05:20.473 --> 05:22.017
+que ejecutas tu código, ¿no?
+
+05:22.143 --> 05:23.940
+Todos los sensores
+funcionaron en la primera,
+
+05:24.066 --> 05:26.674
+pero si no funcionaron en la primera,
+simplemente repites
+
+05:26.800 --> 05:30.480
+ese código hasta que
+todos los sensores estén inicializados
+
+05:30.606 --> 05:32.890
+y ahí sí puedes decir, ah, ok,
+mi robot está perfecto.
+
+05:33.016 --> 05:36.507
+Yo lo hacía, este tipo
+de subroutinas de inicialización
+
+05:36.633 --> 05:39.097
+son buenas porque tú tienes que verificar
+
+05:39.223 --> 05:40.318
+de alguna forma que los sensores
+
+05:40.443 --> 05:43.740
+están funcionando
+o todo tu código va a ser inútil.
+
+05:43.866 --> 05:46.179
+En robótica, si tu sensor está roto,
+
+05:46.305 --> 05:50.176
+tu código podrá estar escrito
+con las mejores prácticas y perfecto,
+
+05:50.302 --> 05:51.829
+pero si el sensor no te manda inputs,
+
+05:51.955 --> 05:54.232
+no te manda valores,
+tu robot no va a hacer nada.
+
+05:54.358 --> 05:55.815
+Por eso es un buen uso.
+
+05:55.940 --> 05:59.417
+Inicialización de cosas
+es un muy buen uso del do-while.
+
+05:59.630 --> 06:01.401
+Te voy a dejar un desafío.
+
+06:01.527 --> 06:04.600
+Este desafío va a ser que el
+while que hicimos aquí,
+
+06:04.600 --> 06:07.158
+que lo pases a la estructura
+de do-while, solo para que la veas
+
+06:07.283 --> 06:09.840
+en funcionamiento.
+Más adelante, ya cuando
+
+06:09.840 --> 06:12.702
+veamos arrays, podremos
+ver ejemplos más completos de esto.
+
+06:13.042 --> 06:14.920
+Pero mientras, te dejo ese desafío
+
+06:14.920 --> 06:18.178
+porque es el mismo código
+que tenemos acá, técnicamente,
+
+06:18.303 --> 06:20.886
+simplemente lo tienes que reacomodar.
+
+06:21.012 --> 06:24.557
+Y muéstrame si entendiste
+las diferencias, piensa un caso
+
+06:24.683 --> 06:27.680
+de uso que tú tendrías.
+Puede ser en robótica,
+
+06:27.680 --> 06:30.435
+puede ser en cuestiones
+de desarrollo de software tradicional,
+
+06:30.561 --> 06:32.439
+lo que se te ocurra. Cuéntame,
+
+06:32.565 --> 06:36.320
+do y do-while, que sea tu apunte
+en donde me dejas claras
+
+06:36.446 --> 06:38.240
+las diferencias y nos vemos
+
+06:38.240 --> 06:40.333
+con esto en la última clase
+de este módulo,
+
+06:40.459 --> 06:43.396
+en donde veremos el ciclo for.

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/02-dowhile_093e5362-d724-4dea-b1c3-7269ab208dd6.c

@@ -0,0 +1,4 @@
+do
+{
+    /* code */
+} while (/* condition */);

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/03-Lecturas recomendadas.txt

@@ -0,0 +1,3 @@
+https://youtu.be/X_yQUzzl1qM
+https://youtu.be/i678o8yDSKY
+https://youtu.be/LO6kESS-Lu8

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/03-Uso del Ciclo FOR en Programación en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e76378bc8513d0a9587161935885c0d044ed5c3f6ec10da8d59ac0a992fe833e
+size 62309502

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/03-Uso del Ciclo FOR en Programación en C.vtt

@@ -0,0 +1,416 @@
+WEBVTT
+
+00:03.366 --> 00:05.321
+El ciclo FOR lo vamos
+a utilizar siempre
+
+00:05.447 --> 00:07.874
+que tengamos clara
+la cantidad de elementos
+
+00:08.000 --> 00:12.200
+que vamos a analizar o a recorrer o que
+esperamos tener simple y sencillamente.
+
+00:12.555 --> 00:14.080
+Te voy a mostrar cómo se escribe.
+
+00:14.481 --> 00:16.412
+Lo primero es crear un nuevo archivo.
+
+00:16.538 --> 00:18.727
+Vamos a declarar nuestro ciclo FOR.
+
+00:18.853 --> 00:22.549
+Ah, primero hay que guardarlo,
+por supuesto, FOR.C.
+
+00:22.936 --> 00:27.147
+Vamos a escribir FOR
+y vamos a declarar nuestro bucle.
+
+00:27.273 --> 00:31.741
+La forma más tradicional del FOR
+es i igual a cero.
+
+00:31.867 --> 00:36.279
+Vamos a inicializar nuestra variable i
+en algún valor.
+
+00:36.432 --> 00:40.440
+Luego vamos a decir un condicional
+que siempre va a ser i mayor que,
+
+00:40.440 --> 00:43.126
+i menor que, i igual o mayor que, etc.
+
+00:43.412 --> 00:50.040
+Por ejemplo, cuando i es menor que n,
+entonces suma i más más.
+
+00:52.770 --> 00:54.503
+Esto sería el ciclo FOR.
+
+00:54.629 --> 00:56.480
+Así de simple, así de sencillo.
+
+00:56.480 --> 00:58.042
+Obviamente podremos tener llaves.
+
+00:58.168 --> 01:02.333
+Vamos a poner un printf y en este printf
+
+01:02.459 --> 01:09.044
+yo voy a decirle el valor actual de i es,
+
+01:09.691 --> 01:13.657
+por ciento de, salto de línea, slash n,
+
+01:14.323 --> 01:17.310
+muy bien, i coma la variable i.
+
+01:18.480 --> 01:23.708
+Ahí lo que estamos haciendo es simple
+y sencillamente recorrer un número,
+
+01:23.834 --> 01:25.941
+un set dado que va a ser n.
+
+01:26.067 --> 01:29.191
+Nosotros ya tenemos que saber cuál
+va a ser el tamaño de n
+
+01:29.317 --> 01:31.892
+y lo vamos a ir recorriendo en intervalos
+de uno.
+
+01:32.018 --> 01:35.469
+Y más más simplemente
+le suma un uno a esto.
+
+01:35.595 --> 01:37.945
+Ya te voy a mostrar para que te quede
+mucho más claro.
+
+01:38.432 --> 01:40.703
+Vamos a hacer esto justo ahora,
+
+01:40.829 --> 01:44.686
+pero quiero que te vaya quedando claro
+que el ciclo FOR nos va a servir
+
+01:44.812 --> 01:48.903
+cuando nosotros conocemos el tamaño
+del objeto que queremos recorrer.
+
+01:49.029 --> 01:53.763
+Y más precisamente, se suelen utilizar
+muchísimo para hacer recorridos de arrays.
+
+01:53.923 --> 01:57.120
+Así que hagamos todo el boilerplate
+de nuestro código.
+
+01:57.246 --> 02:03.067
+Vamos a declarar hashtag include,
+vamos a ponerle stdio.h,
+
+02:03.800 --> 02:06.508
+vamos a cerrar y declaramos nuestro main.
+
+02:06.846 --> 02:08.321
+Muy bien.
+
+02:09.940 --> 02:11.180
+Borramos esto.
+
+02:11.865 --> 02:14.199
+Vamos aquí a poner todo el código
+
+02:14.325 --> 02:16.565
+que acabamos de escribir
+para que no se pierda.
+
+02:16.966 --> 02:20.784
+Vamos a ponerlo acá y como bien sabes,
+no necesito crear este FOR,
+
+02:20.910 --> 02:22.734
+o sea, no necesito que sea un bloque
+
+02:22.860 --> 02:26.431
+porque ya de por sí solo tengo
+una línea de código.
+
+02:26.671 --> 02:28.717
+Así que vamos a quitarle estas llaves.
+
+02:29.366 --> 02:31.286
+Hay que seguir las buenas prácticas.
+
+02:32.503 --> 02:34.960
+Y con esto nos falta un par de cosas.
+
+02:34.960 --> 02:36.440
+Lo primero es declarar n.
+
+02:36.841 --> 02:41.760
+int, ¿qué va a ser n?
+
+02:41.760 --> 02:46.920
+Va a ser igual a, no sé, vamos a ponerlo
+que n sea igual a 1.
+
+02:48.941 --> 02:52.680
+No, n tiene que ser más o menos un 30.
+
+02:52.959 --> 02:54.039
+Bien, punto y coma.
+
+02:54.345 --> 02:58.310
+Digamos que queremos recorrer un array
+de 30 posiciones totales.
+
+02:58.735 --> 03:01.137
+Y, y va a ser inicializada en 0.
+
+03:01.263 --> 03:06.602
+Es decir, y va a empezar en 0,
+va a ir a 1, 2, 3, 4, hasta que sea 30.
+
+03:06.728 --> 03:11.090
+Y cuando y sea 30, entonces,
+¿30 es menor que 30?
+
+03:11.216 --> 03:11.976
+No.
+
+03:12.102 --> 03:14.466
+Y ahí se va a cumplir absolutamente todo.
+
+03:14.592 --> 03:20.520
+Entonces vamos a declarar int i igual a 0
+y i menos 1.
+
+03:20.520 --> 03:21.544
+Perfecto.
+
+03:21.710 --> 03:22.762
+Lo tenemos listo.
+
+03:22.888 --> 03:25.320
+Vamos a guardar y vamos a ejecutar esto.
+
+03:26.353 --> 03:27.578
+F6.
+
+03:28.411 --> 03:30.520
+Ah, y mira, nos dice la terminal.
+
+03:30.646 --> 03:36.737
+Oye, así como lo declaraste,
+solo se permitía en C99 y C11,
+
+03:36.863 --> 03:39.200
+que son estándares anteriores
+del lenguaje.
+
+03:39.200 --> 03:42.642
+Así que declaremos, no pasa nada,
+declaremos nuestra i afuera.
+
+03:43.149 --> 03:45.280
+int i, punto y coma.
+
+03:46.232 --> 03:49.840
+Vamos a poner esto y ahora sí ejecutemos
+nuestro código.
+
+03:50.519 --> 03:51.999
+Vamos al terminal.
+
+03:52.771 --> 03:53.880
+Y perfecto.
+
+03:54.113 --> 03:55.793
+Todo está funcionando.
+
+03:56.288 --> 03:57.042
+Muy bien.
+
+03:57.168 --> 04:01.583
+Vamos aquí i es igual 0, i es igual a 1,
+i es igual a 2, i es igual a 3.
+
+04:02.063 --> 04:04.640
+Y así sucesivamente
+hasta que llegamos a 29.
+
+04:04.640 --> 04:06.175
+¿Qué hicimos aquí?
+
+04:06.328 --> 04:07.000
+¿Qué hicimos?
+
+04:07.153 --> 04:08.753
+Pues fuimos del 0 al 29.
+
+04:09.148 --> 04:12.309
+Lo que ocurrió es que recorrimos 30
+posiciones.
+
+04:12.435 --> 04:15.400
+Ya esto es lo único que quiero
+que te quedes con el for.
+
+04:15.400 --> 04:21.600
+El for se va a utilizar cuando sepamos el
+tamaño del elemento que queremos analizar.
+
+04:21.600 --> 04:24.080
+Y nos va a servir para en cada uno
+de los elementos.
+
+04:24.080 --> 04:29.080
+Y un array, en resumen, es como lo que ves
+en un vector, ¿no?
+
+04:29.080 --> 04:30.080
+Con varios elementos.
+
+04:30.080 --> 04:33.040
+Una matriz de una dimensión.
+
+04:33.040 --> 04:35.000
+Y esto lo debiste ver en álgebra lineal.
+
+04:35.000 --> 04:38.120
+Entonces vamos a tener que en una matriz
+de una dimensión vas a guardar
+
+04:38.120 --> 04:43.040
+tus valores, 1, 2, 3, 4, 5.
+
+04:43.040 --> 04:46.345
+Esos valores, aquí nosotros, imagínate
+que recorriéramos
+
+04:46.471 --> 04:47.878
+un array de 30 posiciones.
+
+04:48.160 --> 04:52.320
+En cada una de esas posiciones tú podrías
+hacer diferentes operaciones.
+
+04:52.320 --> 04:54.640
+Un caso de uso es un robot
+seguidor de líneas.
+
+04:54.640 --> 04:58.080
+Te voy a dejar un enlace en la sección
+de comentarios para que veas uno que,
+
+04:58.080 --> 04:59.560
+de hecho, yo trabajé.
+
+04:59.560 --> 05:04.560
+Un robot seguidor de líneas te va a
+permitir que tú tengas varios sensores
+
+05:04.560 --> 05:09.560
+y un array de, si tienes 15 sensores,
+te podrías crear un array que recorra
+
+05:09.560 --> 05:12.610
+esos, un ciclo for que recorra
+esos 15 sensores
+
+05:12.736 --> 05:14.724
+y que lea cada uno de los sensores.
+
+05:14.920 --> 05:17.880
+Una vez terminas de leer los 15 sensores,
+entonces dices, ah, OK,
+
+05:17.880 --> 05:20.077
+el robot está en tal posición
+sobre la línea.
+
+05:20.203 --> 05:20.920
+Y ya.
+
+05:20.920 --> 05:23.400
+Le dices a los motores, oye,
+ajustense tantito.
+
+05:23.400 --> 05:26.480
+Ese es un claro uso de cómo puedes hacer
+los arrays en cada uno de los
+
+05:26.480 --> 05:27.520
+elementos del array.
+
+05:27.520 --> 05:29.280
+Puedes hacer una operación diferente.
+
+05:29.280 --> 05:33.960
+Y para eso es uno de los principales usos
+del ciclo o bucle for.
+
+05:33.960 --> 05:37.266
+Cuando nosotros sabemos
+la cantidad total de elementos
+
+05:37.392 --> 05:39.240
+que tenemos que analizar.
+
+05:39.240 --> 05:43.080
+Una última cosa es atacar este error
+que nos salió en la terminal,
+
+05:43.080 --> 05:47.480
+en la salida de nuestra compilación,
+que decía que esto que hicimos
+
+05:47.480 --> 05:50.680
+de declarar int aquí, mira,
+sígueme, por favor.
+
+05:50.680 --> 05:53.880
+En la pantalla yo había declarado int i
+igual a 0,
+
+05:53.880 --> 05:58.040
+porque esto se podía
+en las versiones 99 y 11 de C.
+
+05:58.040 --> 06:02.880
+Ahorita estamos trabajando en la versión
+2018 o la versión 18 de C.
+
+06:02.880 --> 06:04.400
+Así que ya no se puede.
+
+06:04.400 --> 06:08.280
+Tiene ciertos detallitos y el mismo
+compilador te los indica.
+
+06:08.280 --> 06:09.120
+Es genial.
+
+06:09.120 --> 06:13.560
+Por eso lo borré de aquí y declaré
+mi variable i arribita.
+
+06:13.560 --> 06:15.640
+Eso es absolutamente todo lo que hice.
+
+06:15.640 --> 06:20.600
+Y con eso se compuso nuestro código
+y logramos hacer que funcionara.
+
+06:20.600 --> 06:22.640
+Bueno, eso sería todo por esta clase.
+
+06:22.640 --> 06:28.640
+Sin más, nos vemos en la siguiente.

subir/Curso de Control de Flujo en C/03-Control de Bucles en C/03-for_53ab0088-8c9a-4daf-b43d-4b6b92f44274.c

@@ -0,0 +1,12 @@
+#include<stdio.h>
+
+int main()
+{
+    int n = 30;
+    int i;
+    for( i=0; i < n; i++){
+        printf("el valor actual de i es %d \n", i);
+    }
+    printf("el valor actual de i es %d \n", i);
+
+}

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/01-Uso de la Instrucción Break en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:480514929180213503a0c875a934fa0aa19e08f00a313462a33d17e2734b01f5
+size 37329390

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/02-Uso del Continue en Bucles de Programación.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27b050628b136158fff42d3b381ffe665ad9d73b51dd55233142ed63dbdeeb7b
+size 52016548

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/02-Uso del Continue en Bucles de Programación.vtt

@@ -0,0 +1,380 @@
+WEBVTT
+
+00:03.406 --> 00:06.320
+Ahora tenemos que hablar
+de la instrucción continue.
+
+00:06.446 --> 00:08.310
+Esta se relaciona a la instrucción break
+
+00:08.436 --> 00:10.881
+pero hace lo opuesto,
+simple y sencillamente
+
+00:11.007 --> 00:15.001
+forza que se ejecute
+la próxima iteración del bucle.
+
+00:15.234 --> 00:17.958
+Entonces, en lugar
+de que te salgas del bucle,
+
+00:18.084 --> 00:22.170
+si tú utilizas un continue,
+forzas una iteración más en tu bucle.
+
+00:22.663 --> 00:25.791
+¿Qué pasa con esto o cuándo se utilizaría?
+
+00:25.917 --> 00:27.135
+Bueno, primero que nada,
+
+00:27.261 --> 00:30.523
+a diferencia del break
+que se puede utilizar en while,
+
+00:30.648 --> 00:33.370
+en do while, en for, en switch,
+
+00:33.658 --> 00:38.963
+el continue solamente se puede
+utilizar en ciclos for, while y do while,
+
+00:39.089 --> 00:41.520
+no se puede utilizar en switch.
+
+00:41.520 --> 00:44.339
+¿Lo puedes utilizar adentro
+de un while que esté dentro de un switch?
+
+00:44.365 --> 00:45.445
+Sí, eso sí.
+
+00:45.571 --> 00:47.869
+¿Lo puedes utilizar dentro de un for
+que esté dentro de un switch?
+
+00:47.995 --> 00:48.828
+Claro que sí.
+
+00:48.954 --> 00:52.387
+Recuerda que son cosas diferentes,
+cada uno tiene sus llavecitas
+
+00:52.513 --> 00:57.028
+y cada uno tiene el código
+que va a estar adentro de esa instrucción.
+
+00:57.368 --> 01:00.045
+Con esto dicho, vamos a ver
+un ejemplo de esta instrucción.
+
+01:00.825 --> 01:01.942
+Para este ejemplo,
+
+01:02.068 --> 01:06.243
+y vamos a irnos a nuestro ciclo for
+que ya teníamos previamente,
+
+01:06.410 --> 01:09.371
+voy a agregar aquí
+unas pequeñas llavecitas,
+
+01:10.371 --> 01:12.997
+control x y la cierro aquí abajo
+
+01:13.123 --> 01:14.356
+para que esté todo bien.
+
+01:14.482 --> 01:17.615
+Vamos a identar para que se sepa
+que esto pertenece al for
+
+01:17.741 --> 01:19.833
+y vamos a dejar un espacio.
+
+01:20.676 --> 01:22.587
+Quiero que primero veas qué pasa
+
+01:22.713 --> 01:24.913
+cuando ponemos
+la instrucción continue,
+
+01:25.039 --> 01:29.159
+la voy a poner comentada
+para empezar, continue,
+
+01:29.873 --> 01:33.136
+punto y coma, muy bien,
+guardamos y vamos a ver
+
+01:33.262 --> 01:36.262
+cómo funciona nuestro
+bucle for de forma normal,
+
+01:36.388 --> 01:38.833
+cómo lo habíamos dejado
+funcionando en clases anteriores.
+
+01:38.959 --> 01:43.251
+Se imprimía todo bonito del 0 al 29,
+
+01:43.377 --> 01:46.585
+30 impresiones, que era
+lo que nosotros queríamos hacer.
+
+01:46.731 --> 01:49.039
+Ahora, ¿qué pasa
+si yo agrego continue aquí?
+
+01:49.506 --> 01:53.610
+Guardo y ejecuto mi código.
+¿Qué cambia con la instrucción continue?
+
+01:53.736 --> 01:54.993
+Quiero que vayas pensando,
+
+01:55.083 --> 01:58.454
+con base a lo que ya te expliqué,
+qué es lo que va a pasar.
+
+01:58.981 --> 02:01.060
+Y mira, ya vimos la salida,
+
+02:01.353 --> 02:06.428
+básicamente la salida fue nula,
+no nos imprimió absolutamente nada.
+
+02:06.781 --> 02:09.618
+¿Y por qué es esto?
+¿Por qué ocurre esto?
+
+02:10.051 --> 02:12.389
+Bueno, pues simple y sencillamente
+
+02:12.515 --> 02:15.812
+porque lo que hace el ciclo continue,
+como te lo expliqué previamente,
+
+02:15.938 --> 02:19.433
+es forzar la ejecución del siguiente bucle
+
+02:19.559 --> 02:21.597
+y se va al siguiente y se va al siguiente
+
+02:21.723 --> 02:27.349
+sin tomar en cuenta la parte
+de imprimir nuestros valores.
+
+02:27.475 --> 02:28.714
+Veamos aquí ya una comparación
+
+02:28.840 --> 02:31.576
+más clara con break, ¿qué
+pasa si ponemos un break?
+
+02:33.236 --> 02:35.132
+Bueno, vamos a ejecutar este código
+
+02:35.258 --> 02:37.696
+y ahorita te voy a mostrar un caso
+de uso del continue,
+
+02:37.922 --> 02:41.102
+pero quiero decirte una realidad
+y es que el break nos saca
+
+02:41.228 --> 02:42.376
+del ciclo for directamente,
+
+02:42.502 --> 02:46.185
+el continue ejecutó 30 veces el bucle
+y después nos sacó,
+
+02:46.318 --> 02:47.884
+quiero que tengas eso claro.
+
+02:48.010 --> 02:50.794
+Ahora quiero que hagamos un último
+experimento en código y vamos
+
+02:50.920 --> 02:53.989
+a poner otra vez nuestrocontinue,
+vamos a ponerle punto y coma
+
+02:54.889 --> 02:57.164
+y este print, que es el valor actual de i,
+
+02:57.290 --> 02:59.138
+que obviamente
+nos lo estamos saltando,
+
+02:59.263 --> 03:02.350
+lo voy a imprimir afuera
+del bucle para que sepamos
+
+03:02.476 --> 03:05.471
+esta diferencia entre
+continue y entre break,
+
+03:05.597 --> 03:08.832
+para que no te quede tan abstracta.
+Entonces voy a ejecutar
+
+03:08.958 --> 03:14.220
+este código que tengo aquí,
+fn f6 en mi computador,
+
+03:14.346 --> 03:16.258
+f6 si estás en una compu normal
+
+03:16.384 --> 03:21.231
+y mira que aquí el continue
+simplemente evitó que se imprimiera
+
+03:21.357 --> 03:23.240
+uno a uno lo que teníamos en el bucle,
+
+03:23.240 --> 03:26.333
+pero cuando nos salimos del bucle
+sí que se imprime
+
+03:26.459 --> 03:28.824
+y nos muestra
+que el valor de i es 30,
+
+03:28.950 --> 03:32.838
+¿por qué? porque se
+hicieron las 30 iteraciones,
+
+03:32.963 --> 03:37.901
+el continue nos forza 
+a que se itere en nuestro ciclo for,
+
+03:38.027 --> 03:40.825
+como debería hacerlo,
+solamente que nos saltamos
+
+03:40.951 --> 03:42.535
+todo el código que teníamos ahí,
+
+03:42.661 --> 03:44.838
+porque el continue le dice
+vete al siguiente bucle,
+
+03:44.963 --> 03:47.560
+vete al siguiente ciclo de este bucle.
+
+03:48.089 --> 03:51.758
+Ahora vamos a ir a nuestro
+break para que veas la diferencia,
+
+03:53.050 --> 03:57.015
+muy bien, vamos a guardar
+y vamos a compilar,
+
+03:58.055 --> 04:00.138
+esperamos el resultado en nuestra terminal
+
+04:00.305 --> 04:02.360
+y mira el valor actual de i es 0,
+
+04:02.360 --> 04:04.926
+¿what? claro porque entramos al for,
+
+04:05.052 --> 04:09.216
+llega el break y se rompe el for
+y luego se imprime 0,
+
+04:09.609 --> 04:13.182
+con esto estoy seguro que ya
+te quedó súper clara la diferencia,
+
+04:13.308 --> 04:14.801
+ya nada más te quiero contar
+
+04:14.927 --> 04:18.097
+que la instrucción continue
+de verdad yo llevo mucho tiempo
+
+04:18.223 --> 04:22.530
+programando en c años
+y es muy raro utilizarla,
+
+04:22.656 --> 04:26.460
+pero en caso de que digas,
+profe, entonces para qué me las enseñas,
+
+04:26.586 --> 04:28.686
+imagínate que tienes un programa
+
+04:28.812 --> 04:32.611
+en donde no necesitas que se impriman
+números negativos,
+
+04:33.184 --> 04:35.115
+ahí puedes poner un pequeño if
+
+04:35.375 --> 04:37.825
+que detecte si el valor
+va a ser negativo
+
+04:38.005 --> 04:40.736
+y si el valor va a ser negativo
+le pones un continue,
+
+04:41.069 --> 04:43.918
+ese continue se va
+a encargar de que te saltes
+
+04:44.043 --> 04:48.192
+esa impresión y no hagas
+la impresión del número negativo,
+
+04:48.318 --> 04:50.218
+esto te serviría
+en muchas ocasiones,
+
+04:50.344 --> 04:53.160
+por ejemplo si tienes
+un while infinito en donde
+
+04:53.286 --> 04:55.714
+tú no quieras hacer
+operaciones con números negativos,
+
+04:55.840 --> 04:57.957
+bueno siempre que detectes un negativo
+
+04:58.083 --> 05:01.018
+le metes un continue
+y eso hace que hagas el skip
+
+05:01.143 --> 05:05.502
+solamente de un ciclo,
+de una ejecución de tu bucle
+
+05:05.628 --> 05:07.292
+sin necesidad de que te salgas
+
+05:07.418 --> 05:09.804
+y tengas que hacer muchísimo
+código para manejarlo,
+
+05:09.930 --> 05:14.514
+esa es la verdad uno de los
+casos de uso más reales del continue,
+
+05:14.808 --> 05:17.200
+cuando quieres que algo muy específico
+
+05:17.200 --> 05:20.618
+que estás detectando
+con un if dentro de un bucle while,
+
+05:20.743 --> 05:22.986
+for o do while se salte,
+
+05:23.173 --> 05:26.613
+con esto dicho
+nos vemos en la próxima clase.

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/03-Uso seguro de GOTO en manejo de errores en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50705e4638946a962113a399dd9b1bb22865de4fb6acad7cbdbd54b8e9bc0384
+size 52691944

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/03-Uso seguro de GOTO en manejo de errores en C.vtt

@@ -0,0 +1,371 @@
+WEBVTT
+
+00:03.459 --> 00:08.000
+Hablemos de la instrucción GOTO
+y de las etiquetas o labels.
+
+00:08.387 --> 00:10.022
+Esta instrucción a mí me parece bien
+
+00:10.148 --> 00:14.365
+curiosa y te voy a hacer 100% honesto,
+innecesaria.
+
+00:14.589 --> 00:18.414
+Yo en mi vida programando en
+este lenguaje nunca la he utilizado,
+
+00:18.540 --> 00:21.286
+ya que puede inducirte
+muy malas prácticas,
+
+00:21.412 --> 00:23.754
+pero aún así debo mencionarte que existe,
+
+00:24.176 --> 00:28.000
+y hay un caso de uso que podríamos
+considerar apropiado para la misma.
+
+00:28.562 --> 00:31.914
+De hecho, el autor del lenguaje
+en el libro de lenguaje C,
+
+00:32.040 --> 00:34.926
+de C Programming Language, Dennis Ritchie,
+
+00:35.720 --> 00:40.834
+nos comenta que esta es una instrucción
+altamente abusable, y es verdad,
+
+00:40.960 --> 00:44.204
+los programadores
+y las programadoras pueden caer
+
+00:44.330 --> 00:46.917
+en malas prácticas al utilizar GOTO,
+
+00:47.043 --> 00:48.468
+porque esto te permite irte
+
+00:48.594 --> 00:51.837
+a cualquier parte de tu código,
+no importa dónde estés.
+
+00:52.357 --> 00:55.393
+Pero eso no es tan bueno como suena.
+
+00:55.607 --> 00:59.253
+Idealmente tu código debería
+de funcionar por principios,
+
+00:59.379 --> 01:03.998
+sin utilizar GOTO, y toda la lógica
+y toda la dirección que vamos a tener,
+
+01:04.124 --> 01:07.282
+la debes de manejar
+ya sea por máquinas de estados,
+
+01:07.408 --> 01:10.185
+la debes de manejar por bucles y ciclos,
+
+01:10.311 --> 01:14.613
+todo lo que son estructuras de secuencia
+y control, ciclos if, ciclos while,
+
+01:14.739 --> 01:17.854
+y con eso tienes suficiente
+para que tu programa
+
+01:17.980 --> 01:21.078
+también siempre llegue
+a donde debe de llegar.
+
+01:21.204 --> 01:24.123
+Es mil veces mejor
+que hagas una estructura
+
+01:24.249 --> 01:26.407
+de muchos ifs a que utilices GOTO,
+
+01:26.533 --> 01:28.801
+y no es la mejor práctica hacer 100 ifs,
+
+01:28.926 --> 01:31.654
+recuerda que tienes que ser
+inteligente al programar,
+
+01:31.780 --> 01:34.629
+y bueno, eso es lo que vamos a ir
+aprendiendo a lo largo de estos cursos,
+
+01:34.755 --> 01:36.789
+conforme se vaya poniendo más complejo.
+
+01:36.915 --> 01:39.078
+Primero, necesitas
+entender una a una todas
+
+01:39.203 --> 01:41.720
+las herramientas
+que componen este lenguaje,
+
+01:42.080 --> 01:45.274
+así que vamos a ver el único caso de uso
+que yo recomiendo para GOTO.
+
+01:46.337 --> 01:50.724
+Vamos a nuestro editor de código,
+vamos a abrir una nueva pestaña,
+
+01:51.237 --> 01:55.357
+y la vamos a guardar, recuerda que para
+abrir una nueva pestaña es control N,
+
+01:55.483 --> 01:59.000
+y para guardar es control S, goto.c.
+
+02:00.139 --> 02:04.440
+Excelente, ya la tenemos aquí lista,
+ahora vamos a escribir el código,
+
+02:04.440 --> 02:06.080
+y aquí te voy a poner un ejemplo.
+
+02:06.473 --> 02:09.563
+Imagínate que tú entras a un ciclo for,
+
+02:11.887 --> 02:13.778
+vamos a ponerle aquí cualquier cosa,
+
+02:13.903 --> 02:16.160
+lo voy a dejar vacío de hecho,
+no hace falta esto,
+
+02:17.628 --> 02:21.347
+la buena práctica
+es que cuando dejas un for vacío,
+
+02:21.473 --> 02:23.810
+como para ejemplificar en una especie de,
+
+02:23.936 --> 02:27.262
+obviamente esto no va a compilar,
+pero solo quiero que tengan el ejemplo,
+
+02:28.215 --> 02:30.679
+hay que ponerle puntos adentro.
+
+02:34.838 --> 02:38.739
+Ok, vamos a usar los code snippets,
+me gusta más la idea.
+
+02:40.746 --> 02:41.765
+Muy bien.
+
+02:41.891 --> 02:43.899
+Cuando tenemos varias estructuras,
+
+02:44.025 --> 02:46.200
+o estamos en una estructura anidada
+como esta,
+
+02:46.200 --> 02:48.120
+en donde hay tres niveles adentro,
+
+02:48.382 --> 02:49.960
+en donde estaría nuestro código,
+
+02:50.422 --> 02:51.840
+eso puede ser peligroso,
+
+02:51.840 --> 02:53.600
+y un break no te va a servir,
+
+02:53.600 --> 02:55.080
+y no te va a sacar de esta,
+
+02:55.307 --> 02:57.600
+porque un break solo te sacaría un nivel.
+
+02:58.106 --> 03:01.720
+¿Qué pasa si entras a una parte
+de tu código donde no deberías entrar,
+
+03:01.943 --> 03:05.880
+y entonces simple y sencillamente tienes
+que salirte de ahí lo más rápido posible,
+
+03:06.224 --> 03:08.080
+a la parte inicial de tu programa?
+
+03:08.080 --> 03:10.240
+Velo como un reset o un reinicio.
+
+03:10.540 --> 03:12.840
+Cuando llegas a una parte anidada
+de tu código,
+
+03:13.144 --> 03:14.440
+y encuentras un error,
+
+03:14.684 --> 03:17.520
+ah, bueno, entonces
+puedes utilizar goto ahí,
+
+03:17.520 --> 03:19.480
+y justo ese es el ejemplo
+que tengo para ti.
+
+03:19.873 --> 03:21.600
+Ahí podríamos poner,
+
+03:21.600 --> 03:28.080
+si panic, por ejemplo, o desastre,
+lo que tú quieras,
+
+03:28.742 --> 03:35.169
+lo que pasaría aquí es que nosotros
+iríamos goto error handler.
+
+03:37.872 --> 03:40.600
+Y esto sería la instrucción goto,
+
+03:40.726 --> 03:43.000
+y esto sería nuestra etiqueta.
+
+03:43.150 --> 03:46.720
+Obviamente, la etiqueta,
+simple y sencillamente,
+
+03:46.720 --> 03:49.440
+la tendríamos que poner afuera del código.
+
+03:49.440 --> 03:51.840
+Entonces iría afuera del bucle for,
+
+03:51.840 --> 03:54.520
+tendrías un mensaje como error handler,
+
+03:55.488 --> 03:56.960
+o manejador de errores,
+
+03:57.388 --> 03:58.520
+dos puntos,
+
+03:58.520 --> 04:01.000
+y aquí pondrías todo el código,
+
+04:04.259 --> 04:05.699
+todo el código,
+
+04:07.013 --> 04:11.960
+todo el código para componer tu desastre.
+
+04:14.228 --> 04:15.260
+¿Qué pasa aquí?
+
+04:15.693 --> 04:17.960
+Si en alguna situación de tu programa
+
+04:17.960 --> 04:19.680
+llegas a tener una condición,
+
+04:19.806 --> 04:22.160
+digamos, tienes un programa de robótica,
+
+04:22.160 --> 04:23.840
+o algo que maneja sensores,
+
+04:23.840 --> 04:25.800
+detectas que un sensor dejó de funcionar,
+
+04:25.950 --> 04:28.880
+ahí puedes utilizar
+una etiqueta y un goto,
+
+04:29.067 --> 04:32.240
+que simple y sencillamente te saque
+de todo peligro,
+
+04:32.240 --> 04:35.520
+y te mande a una rutina o subrutina
+
+04:35.520 --> 04:37.520
+que se encargue de manejar el error,
+
+04:37.520 --> 04:39.720
+digamos, de recalibrar el sensor,
+
+04:39.720 --> 04:42.520
+que se encargue de apagar el robot
+de forma segura,
+
+04:42.520 --> 04:45.240
+¿por qué? Porque un robot que tiene
+los sensores descompuestos
+
+04:45.240 --> 04:47.640
+es un robot peligroso,
+porque no se daría cuenta
+
+04:47.640 --> 04:49.840
+si está por chocar con un humano,
+
+04:49.840 --> 04:52.440
+si está por chocar con alguna cosa
+que no debería.
+
+04:52.440 --> 04:55.640
+¿Ok? Los sensores, recuerda,
+son los ojos de un robot.
+
+04:55.770 --> 04:58.040
+Ese es un caso de uso que se me ocurre.
+
+04:58.040 --> 05:00.040
+O en un driver, por ejemplo,
+
+05:00.040 --> 05:01.920
+como en un teclado o algo así,
+
+05:01.920 --> 05:04.240
+¿ok? Que simple y sencillamente,
+
+05:04.240 --> 05:06.240
+si detectas que algo está mal,
+
+05:06.240 --> 05:10.440
+le metes algún tipo de mecanismo
+de autodetección de errores,
+
+05:10.440 --> 05:11.840
+de mal funcionamiento,
+
+05:11.840 --> 05:13.840
+y detectas que algo está mal,
+
+05:13.840 --> 05:16.640
+lo puedes mandar a esta rutina de manejo
+de errores,
+
+05:16.640 --> 05:17.640
+y ya.
+
+05:17.640 --> 05:20.040
+Eso es el superpoder de Gotoo,
+
+05:20.040 --> 05:22.640
+es el único caso de uso que puedo pensar,
+
+05:22.640 --> 05:25.240
+y la verdad es que es muy raro que tengas
+que escribirlo,
+
+05:25.240 --> 05:27.640
+solo te lo quiero enseñar
+para que lo conozcas,
+
+05:27.640 --> 05:32.040
+y bueno, con esto dicho,
+nos vemos en la próxima clase.

subir/Curso de Control de Flujo en C/04-Uso de las instrucciones break y continue/03-goto_f20fa5d7-3cec-42f3-ba42-44d528ccb729.c

@@ -0,0 +1,15 @@
+for (size_t i = 0; i < count; i++)
+{
+      for (size_t i = 0; i < count; i++)
+        {
+          for (size_t i = 0; i < count; i++)
+            {
+                if (panic)
+                    goto errorHandler;
+             }
+        }
+}
+errorHandler: //todo el codigo para componer tu desastre
+
+  
+    

subir/fixed/Curso de Fundamentos de Ingeniería de Software/05-Introducción a Blockchain e Inteligencia Artificial/02-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://platzi.com/cursos/deeplearning/
+https://platzi.com/cursos/algebra-ml/

subir/fixed/Curso de Fundamentos de Ingeniería de Software/05-Introducción a Blockchain e Inteligencia Artificial/02-Qué es una red neuronal.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6cbc6dce7a5e9618632bc712446bb4a248b85cc7ffabeffccf2fc32a8609044
+size 334399745

subir/fixed/Curso de Fundamentos de Ingeniería de Software/05-Introducción a Blockchain e Inteligencia Artificial/02-Qué es una red neuronal.vtt

@@ -0,0 +1,763 @@
+WEBVTT
+
+00:00:00.160 --> 00:00:02.320
+Para entender qué es una red neuronal, vamos
+
+00:00:02.320 --> 00:00:06.480
+a convertir números dibujados a mano a números
+
+00:00:06.480 --> 00:00:09.040
+digitales, como un sistema de reconocimiento óptico de
+
+00:00:09.040 --> 00:00:12.400
+caracteres. Así que primero imagina que dibujas a
+
+00:00:12.400 --> 00:00:15.315
+mano un número 3 y ese número lo
+
+00:00:15.315 --> 00:00:19.315
+conviertes a una imagen digital. Para efectos de
+
+00:00:19.315 --> 00:00:21.795
+este ejercicio, imagina que lo convertimos a una
+
+00:00:21.795 --> 00:00:25.235
+imagen de 20 píxeles por 20 píxeles. Como
+
+00:00:25.235 --> 00:00:27.474
+tenemos 20 píxeles por 20 píxeles, tenemos en
+
+00:00:27.474 --> 00:00:31.540
+total 400 píxeles, y cada píxel es básicamente
+
+00:00:31.540 --> 00:00:34.180
+una representación de un porcentaje de 0 a
+
+00:00:34.180 --> 00:00:37.140
+100 por 100 que determina la cantidad de
+
+00:00:37.140 --> 00:00:39.780
+brillo de cada 1 de estos puntos. Así
+
+00:00:39.780 --> 00:00:43.535
+que, para poder representar matemáticamente este número 3
+
+00:00:43.535 --> 00:00:46.035
+en una cuadricula de 20 por 20, necesitamos
+
+00:00:46.175 --> 00:00:49.775
+400 números, y esos 400 números son un
+
+00:00:49.775 --> 00:00:52.655
+porcentaje de brillo en cada número. Creamos una
+
+00:00:52.655 --> 00:00:56.840
+matriz de esos 400 números y esa matriz
+
+00:00:56.840 --> 00:01:00.200
+serían mis neuronas de entrada. Las neuronas de
+
+00:01:00.200 --> 00:01:02.520
+entrada son los datos de input que yo
+
+00:01:02.520 --> 00:01:04.920
+le doy a una red neuronal. En este
+
+00:01:04.920 --> 00:01:07.552
+momento, una neurona no es más que un
+
+00:01:07.552 --> 00:01:10.105
+dato. En las neuronas de entrada, la neurona
+
+00:01:10.105 --> 00:01:11.945
+es un número, un dato. En este caso,
+
+00:01:11.945 --> 00:01:14.665
+el dato representa cada 1 de los pixeles
+
+00:01:14.665 --> 00:01:17.225
+que componen esas imágenes que pueden ser un
+
+00:01:17.225 --> 00:01:21.145
+número cualquiera dibujado a mano alzada. Las otras
+
+00:01:21.145 --> 00:01:23.810
+neuronas que están al final de mi red
+
+00:01:23.810 --> 00:01:26.530
+neuronal son la capa de salida. La capa
+
+00:01:26.530 --> 00:01:29.810
+de salida también son simplemente datos. En este
+
+00:01:29.810 --> 00:01:32.530
+caso, estoy construyendo una red neuronal que me
+
+00:01:32.530 --> 00:01:35.955
+va a generar al final del proceso la
+
+00:01:35.955 --> 00:01:38.535
+probabilidad de cuál es el número digital de
+
+00:01:38.535 --> 00:01:40.695
+0 a 9 que corresponde al número que
+
+00:01:40.695 --> 00:01:43.335
+yo dibujé a mano alzada. Como solamente hay
+
+00:01:43.335 --> 00:01:46.535
+10 números del 0 al 9, necesito 10
+
+00:01:46.535 --> 00:01:48.255
+neuronas, y cada una de ellas me va
+
+00:01:48.255 --> 00:01:50.535
+a representar un número entre el 0 al
+
+00:01:50.535 --> 00:01:52.560
+9. Las neuronas que se van a prender
+
+00:01:52.560 --> 00:01:54.479
+son las neuronas que corresponden al número y
+
+00:01:54.479 --> 00:01:56.280
+se van a prender con una probabilidad. ¿Esto
+
+00:01:56.280 --> 00:01:58.320
+en la práctica qué significa? Que estas neuronas
+
+00:01:58.320 --> 00:02:00.000
+no van a decir simplemente este es un
+
+00:02:00.000 --> 00:02:01.280
+3 o esto es un 5 o esto
+
+00:02:01.280 --> 00:02:03.280
+es un 8, porque, por ejemplo, el 3
+
+00:02:03.280 --> 00:02:05.494
+y el 8 se parecen. ¿Qué tal que
+
+00:02:05.494 --> 00:02:07.255
+yo dibuje un 3 que esté muy cerca
+
+00:02:07.255 --> 00:02:09.574
+al 8? Entonces, el 3 tiene que tener
+
+00:02:09.574 --> 00:02:11.415
+una probabilidad muy alta, de pronto se prende
+
+00:02:11.415 --> 00:02:13.655
+un 90 por 100, y el 8 un
+
+00:02:13.655 --> 00:02:17.495
+84 por 100. Estos son probabilidades que se
+
+00:02:17.495 --> 00:02:19.500
+colocan en números decimales entre 0 y 1.
+
+00:02:19.580 --> 00:02:22.540
+0.5 es el 50 por 100.7 es el
+
+00:02:22.540 --> 00:02:25.120
+70 por 100. Y esa generación de probabilidad
+
+00:02:25.340 --> 00:02:28.060
+es cómo funciona tanto la inteligencia humana como
+
+00:02:28.060 --> 00:02:30.860
+la inteligencia artificial, y se expresa en esta
+
+00:02:30.860 --> 00:02:33.580
+capa de salida, en estos números de probabilidad
+
+00:02:33.580 --> 00:02:36.144
+de las neuronas finales. Pero ¿cómo la capa
+
+00:02:36.144 --> 00:02:39.424
+de entrada, que tiene estos 400 números, que
+
+00:02:39.424 --> 00:02:41.905
+son los pixeles, correlaciona con la capa de
+
+00:02:41.905 --> 00:02:43.864
+salida, que tiene estos 10 números, que son
+
+00:02:43.864 --> 00:02:47.265
+el output, la salida? Pues tenemos internamente una
+
+00:02:47.265 --> 00:02:49.765
+serie de neuronas que no son simplemente números,
+
+00:02:50.010 --> 00:02:53.850
+son unas operaciones matemáticas que emergen los patrones
+
+00:02:53.850 --> 00:02:55.930
+de los datos, los patrones a través de
+
+00:02:55.930 --> 00:02:59.050
+los cuales se interpreta la información. Esas neuronas
+
+00:02:59.050 --> 00:03:02.090
+intermedias se conocen como la capa oculta y
+
+00:03:02.090 --> 00:03:04.250
+usan una serie de operaciones matemáticas que vamos
+
+00:03:04.250 --> 00:03:08.935
+a entender brevemente para extrapolar esos patrones de
+
+00:03:08.935 --> 00:03:11.095
+la información que al final del día son
+
+00:03:11.095 --> 00:03:13.974
+la inteligencia. En esta red neuronal elegí crear
+
+00:03:13.974 --> 00:03:16.215
+3 capas ocultas y en cada una de
+
+00:03:16.215 --> 00:03:19.290
+estas capas ocultas tengo 15 neuronas. La verdad
+
+00:03:19.290 --> 00:03:21.209
+es que el número es arbitrario, pueden ser
+
+00:03:21.209 --> 00:03:22.970
+2 capas ocultas o pueden ser 5, pueden
+
+00:03:22.970 --> 00:03:24.890
+ser 10 o pueden ser 100 y pueden
+
+00:03:24.890 --> 00:03:27.370
+ser 15 neuronas o 20 o 30. ¿Cómo
+
+00:03:27.370 --> 00:03:31.050
+sabes cuántas poner? Cada problema matemático y cada
+
+00:03:31.050 --> 00:03:34.250
+problema de neuronas de inteligencia artificial, dependiendo de
+
+00:03:34.250 --> 00:03:37.345
+los datos que quieras entrenar, va a ser
+
+00:03:37.345 --> 00:03:40.065
+distinta la cantidad de neuronas que necesites. Por
+
+00:03:40.065 --> 00:03:41.985
+ejemplo, para un gran modelo de lenguaje vas
+
+00:03:41.985 --> 00:03:44.065
+a usar una cantidad de capas ocultas distinta
+
+00:03:44.065 --> 00:03:46.865
+y una cantidad de neuronas distinta. A mayor
+
+00:03:46.865 --> 00:03:48.705
+cantidad de neuronas y a mayor cantidad de
+
+00:03:48.705 --> 00:03:52.340
+capas, más uso de procesador y de memoria,
+
+00:03:52.340 --> 00:03:53.700
+y como esto va a usar una cantidad
+
+00:03:53.700 --> 00:03:57.380
+de datos masivos, necesitas la menor cantidad de
+
+00:03:57.380 --> 00:03:59.860
+neuronas y la menor cantidad de capas para
+
+00:03:59.860 --> 00:04:03.605
+generar los mejores resultados. Y estadísticamente, a veces,
+
+00:04:03.605 --> 00:04:07.445
+demasiadas capas generan menos inteligencia, así como cuando
+
+00:04:07.445 --> 00:04:10.985
+las personas están demasiado especializadas en un conocimiento,
+
+00:04:12.165 --> 00:04:14.245
+es muy difícil para ellos aprender cosas nuevas
+
+00:04:14.245 --> 00:04:17.009
+porque están demasiado metidos en la caja. En
+
+00:04:17.009 --> 00:04:19.589
+esencia, lo que estas capas van a hacer
+
+00:04:19.690 --> 00:04:24.129
+es encontrar los patrones estadísticos que tiene un
+
+00:04:24.129 --> 00:04:27.409
+dato. Por ejemplo, los números tienden a tener
+
+00:04:27.409 --> 00:04:29.490
+líneas, el 9 tiene una línea, el 1
+
+00:04:29.490 --> 00:04:31.490
+tiene una línea, el 7 tiene una serie
+
+00:04:31.490 --> 00:04:34.555
+de líneas, pero también tienen círculos. El 9
+
+00:04:34.555 --> 00:04:36.395
+es un círculo, el 6 es un círculo
+
+00:04:36.395 --> 00:04:39.354
+en otra posición, el 3 es medio, 2
+
+00:04:39.354 --> 00:04:42.395
+medios círculos, el 4 son 3 líneas en
+
+00:04:42.395 --> 00:04:46.495
+ciertos órdenes diagonales. Esos patrones tienden a emerger,
+
+00:04:46.650 --> 00:04:50.090
+pero en programación clásica nosotros sabemos programado una
+
+00:04:50.090 --> 00:04:52.970
+serie de condiciones preagregándole cada 1 de esos
+
+00:04:52.970 --> 00:04:56.410
+patrones. Sin embargo, nuestros cerebros aprenden a partir
+
+00:04:56.410 --> 00:04:59.545
+de observar masivas cantidades de información e inferir
+
+00:04:59.545 --> 00:05:03.005
+de una manera casi inconsciente en nuestro entrenamiento
+
+00:05:03.305 --> 00:05:05.145
+de observar el mundo, cada 1 de sus
+
+00:05:05.145 --> 00:05:07.705
+patrones, encontrar los bordes y las formas. La
+
+00:05:07.705 --> 00:05:09.945
+idea es que en estas capas creamos un
+
+00:05:09.945 --> 00:05:14.470
+procedimiento estadístico donde les mostramos estas diferentes capas
+
+00:05:14.930 --> 00:05:17.250
+muchos, muchos, muchos de estos patrones y ellos
+
+00:05:17.250 --> 00:05:20.450
+van ajustando la relación matemática entre cada una
+
+00:05:20.450 --> 00:05:22.130
+de las capas para que, a medida que
+
+00:05:22.130 --> 00:05:24.610
+los 400 números de entrada que pasan por
+
+00:05:24.610 --> 00:05:27.355
+la capa de entrada vayan atravesando capa por
+
+00:05:27.355 --> 00:05:31.275
+capa, terminen generando a nivel numérico los porcentajes
+
+00:05:31.275 --> 00:05:33.435
+de probabilidad de la capa de salida que
+
+00:05:33.435 --> 00:05:36.955
+genere el número correcto. Las ecuaciones matemáticas son
+
+00:05:36.955 --> 00:05:39.515
+básicamente unos números que cada una de estas
+
+00:05:39.515 --> 00:05:42.290
+capas tienen, y esos números son la fuerza
+
+00:05:42.290 --> 00:05:44.690
+de la relación entre la neurona de una
+
+00:05:44.690 --> 00:05:46.850
+capa y todas las neuronas de la otra
+
+00:05:46.850 --> 00:05:49.490
+capa. Entonces, ciertas capas se conectan de una
+
+00:05:49.490 --> 00:05:51.250
+manera muy fuerte o muy débil con otras
+
+00:05:51.250 --> 00:05:54.130
+neuronas, y esos números se les conoce como
+
+00:05:54.130 --> 00:05:57.435
+pesos. Suena muy extraño y muy arbitrario, pero
+
+00:05:57.435 --> 00:06:01.275
+es simplemente un mecanismo matemático. Inicialmente, las conexiones
+
+00:06:01.275 --> 00:06:03.615
+entre las diferentes neuronas en una red neuronal
+
+00:06:03.995 --> 00:06:06.795
+se arrancan de manera aleatoria. Es un número
+
+00:06:06.795 --> 00:06:08.659
+aleatorio que tú colocas como quieras. Y luego,
+
+00:06:08.659 --> 00:06:11.460
+a medida que vas entrenando el sistema, vamos
+
+00:06:11.460 --> 00:06:13.860
+a hablar del entrenamiento en un minuto, el
+
+00:06:13.860 --> 00:06:16.820
+número se va ajustando para eventualmente corresponder a
+
+00:06:16.820 --> 00:06:19.860
+esos patrones que hablamos antes. Hablemos del entrenamiento.
+
+00:06:19.860 --> 00:06:19.935
+Lo primero es inicializar todos los pesos, todas
+
+00:06:19.935 --> 00:06:20.010
+las conexiones entre neuronas en números aleatorios. Y
+
+00:06:20.010 --> 00:06:25.255
+lo que haces, conexiones entre neuronas en números
+
+00:06:25.255 --> 00:06:27.895
+aleatorios, y lo que haces es que tienes
+
+00:06:27.895 --> 00:06:30.935
+una gran cantidad de datos de entrenamiento, es
+
+00:06:30.935 --> 00:06:34.735
+decir, tendríamos que tener una gran cantidad de
+
+00:06:34.735 --> 00:06:37.335
+imágenes de números dibujados a mano alzada entre
+
+00:06:37.335 --> 00:06:39.630
+el 0 y el 9 que corresponden a
+
+00:06:39.630 --> 00:06:42.270
+su número correcto, y los empiezas a pasar
+
+00:06:42.270 --> 00:06:44.350
+por la red. Como son números aleatorios, te
+
+00:06:44.350 --> 00:06:47.389
+va a dar errores constantemente. Los los errores
+
+00:06:47.389 --> 00:06:49.070
+es que la red neuronal va a decir
+
+00:06:49.070 --> 00:06:50.750
+que un 4 es un 5, que un
+
+00:06:50.750 --> 00:06:53.155
+1 es un 0, no importa. Cada vez
+
+00:06:53.155 --> 00:06:56.115
+que genere un error, le reportas el error
+
+00:06:56.115 --> 00:06:58.515
+a la neurona y la neurona empieza a
+
+00:06:58.515 --> 00:07:02.435
+revisar matemáticamente cuáles fueron las neuronas que estaban
+
+00:07:02.435 --> 00:07:04.920
+mal ajustadas porque dieron el error mal. Y
+
+00:07:05.160 --> 00:07:07.880
+usando una serie de ecuaciones matemáticas que para
+
+00:07:07.880 --> 00:07:09.480
+efectos de este curso no te tienes que
+
+00:07:09.480 --> 00:07:11.480
+preocupar, pero cuando tomes alguno de nuestros cursos
+
+00:07:11.480 --> 00:07:13.560
+de inteligencia artificial, vas a aprender que es
+
+00:07:13.560 --> 00:07:16.280
+una función que se llama sigmoide o otra
+
+00:07:16.280 --> 00:07:17.971
+función que se llama relu, y la derivada
+
+00:07:17.971 --> 00:07:21.945
+de esas funciones, esto es cálculo vectorial muy
+
+00:07:21.945 --> 00:07:25.785
+sencillo, cálculo diferencial realmente. Encuentran la distancia de
+
+00:07:25.785 --> 00:07:28.185
+diferencia entre cada 1 de estos pesos y
+
+00:07:28.185 --> 00:07:30.949
+lo van corrigiendo. Eso se hace en una
+
+00:07:31.090 --> 00:07:34.930
+retropropagación, generas el error y luego regresas para
+
+00:07:34.930 --> 00:07:37.650
+entender dónde cometiste el error y ajustar las
+
+00:07:37.650 --> 00:07:40.050
+conexiones entre las neuronas a partir de los
+
+00:07:40.050 --> 00:07:41.970
+datos con los que entrenaste. A medida que
+
+00:07:41.970 --> 00:07:45.335
+ajustas los pesos mostrándole los diferentes ejemplos en
+
+00:07:45.335 --> 00:07:49.255
+el entrenamiento y los devuelves ese proceso, eso
+
+00:07:49.255 --> 00:07:52.135
+es el entrenamiento. Cuando tienes una base de
+
+00:07:52.135 --> 00:07:55.815
+datos de entrenamiento, digamos que 10000 números, el
+
+00:07:55.815 --> 00:07:58.215
+completar el entrenamiento con esos 10000 números se
+
+00:07:58.215 --> 00:08:01.500
+conoce como una época o epoc. Y no
+
+00:08:01.500 --> 00:08:04.319
+solamente completar el entrenamiento una vez es suficiente.
+
+00:08:04.780 --> 00:08:07.020
+Como la red neuronal empieza de manera aleatoria,
+
+00:08:07.020 --> 00:08:09.180
+es posible que incluso con una sola época
+
+00:08:09.180 --> 00:08:11.259
+no sea suficiente para entrenar por completo la
+
+00:08:11.259 --> 00:08:14.854
+red neuronal. Probablemente necesitas entrenarla múltiples veces hasta
+
+00:08:14.854 --> 00:08:17.335
+que tu red quede muy ajustada. Y luego
+
+00:08:17.335 --> 00:08:20.055
+tienes que probar con una base de esa
+
+00:08:20.055 --> 00:08:22.775
+red de entrenamiento que te guardaste para probar,
+
+00:08:22.775 --> 00:08:24.715
+a ver si está dando los resultados correctos.
+
+00:08:25.050 --> 00:08:26.730
+Y de esa manera sabes si tu red
+
+00:08:26.730 --> 00:08:29.050
+neuronal quedó bien entrenada o no. El resultado
+
+00:08:29.050 --> 00:08:31.210
+final del entrenamiento es que, de pronto, la
+
+00:08:31.210 --> 00:08:33.929
+capa oculta número 1 detecta las formas que
+
+00:08:33.929 --> 00:08:36.169
+son una rayita, la capa oculta número 2
+
+00:08:36.169 --> 00:08:38.250
+detecta las formas que son una curvita, y
+
+00:08:38.250 --> 00:08:40.490
+la capa oculta número 3 detecta la conexión
+
+00:08:40.490 --> 00:08:42.848
+entre ambas, y eso termina siendo que la
+
+00:08:42.848 --> 00:08:45.345
+capa de salida final me genere una serie
+
+00:08:45.345 --> 00:08:47.904
+de números de probabilidad, una matriz de 10
+
+00:08:47.904 --> 00:08:50.225
+números de probabilidad desde el 100 por 100
+
+00:08:50.225 --> 00:08:52.964
+hasta el 0 por 100, donde, a mayor
+
+00:08:53.345 --> 00:08:55.620
+probabilidad de que un número específico corresponda a
+
+00:08:55.620 --> 00:08:58.060
+una de esas neuronas, esa neurona tiene un
+
+00:08:58.060 --> 00:09:00.860
+porcentaje más alto, una activación más grande. Lo
+
+00:09:00.860 --> 00:09:02.720
+que significa que en una red bien entrenada,
+
+00:09:03.100 --> 00:09:05.340
+los 400 píxeles de entrada que equivalen al
+
+00:09:05.340 --> 00:09:09.100
+número 3 me debería generar una activación de
+
+00:09:09.100 --> 00:09:12.025
+muy alto porcentaje comparado a otras neuronas en
+
+00:09:12.025 --> 00:09:14.944
+el número correspondiente al número 3. En este
+
+00:09:14.944 --> 00:09:17.325
+ejemplo, en la capa de entrada, creamos 400
+
+00:09:17.785 --> 00:09:19.225
+neuronas que equivalen a cada 1 de los
+
+00:09:19.225 --> 00:09:22.205
+pixeles, pero imagina que, en vez de usar
+
+00:09:22.745 --> 00:09:25.465
+pixeles, usamos tokens. Un token es una forma
+
+00:09:25.465 --> 00:09:28.010
+de expresar texto. El texto se puede romper
+
+00:09:28.070 --> 00:09:31.610
+en palabras, sílabas o letras, eso sería tokenizar
+
+00:09:31.910 --> 00:09:35.370
+el lenguaje. Y, por ejemplo, el lenguaje inglés
+
+00:09:35.510 --> 00:09:39.510
+tiene en total 50000 tokens, 50000 permutaciones de
+
+00:09:39.510 --> 00:09:42.895
+palabras, sílabas y letras para expresar lenguaje, incluyendo
+
+00:09:42.895 --> 00:09:46.415
+puntuación, etcétera. Si agregáramos esos 50000 neuronas y
+
+00:09:46.415 --> 00:09:48.654
+las pusiéramos en la entrada y pusiéramos otras
+
+00:09:48.654 --> 00:09:51.774
+50000 neuronas en la salida, podríamos crear la
+
+00:09:51.774 --> 00:09:54.090
+estructura de la red neuronal para un gran
+
+00:09:54.090 --> 00:09:56.890
+modelo de lenguaje, como ChatGPT o como un
+
+00:09:56.890 --> 00:09:59.690
+traductor. Una red neuronal no es suficiente para
+
+00:09:59.690 --> 00:10:02.670
+generar un traductor o para generar un autocompletador
+
+00:10:03.050 --> 00:10:06.650
+como ChatGPT. Necesitaríamos una arquitectura matemática que se
+
+00:10:06.650 --> 00:10:09.785
+conoce como transformador y un modelo especial o
+
+00:10:09.785 --> 00:10:13.385
+mecanismo llamado atención para generar ese resultado, lo
+
+00:10:13.385 --> 00:10:15.625
+cual pueden aprender en el curso de fundamentos
+
+00:10:15.625 --> 00:10:18.585
+de LLMs. Pero esta es la base fundamental,
+
+00:10:18.585 --> 00:10:20.745
+las redes neuronales. Platzi tiene un curso que
+
+00:10:20.745 --> 00:10:22.265
+encuentras en los recursos de esta clase, que
+
+00:10:22.265 --> 00:10:24.640
+es de matemáticas para inteligencia artificial. Pero no
+
+00:10:24.640 --> 00:10:28.020
+es matemática compleja, todo esto es, básicamente, álgebra
+
+00:10:28.720 --> 00:10:31.680
+lineal, vectores, matrices y un poquito de cálculo
+
+00:10:31.680 --> 00:10:34.399
+diferencial. Realmente, no es tan difícil. Así como
+
+00:10:34.399 --> 00:10:36.560
+las matemáticas no son tan difíciles, el código
+
+00:10:36.560 --> 00:10:39.014
+tampoco. Estas matrices se expresan en una estructura
+
+00:10:39.014 --> 00:10:41.334
+de datos que se conocen como vectores, hay
+
+00:10:41.334 --> 00:10:44.875
+mucha multiplicación de vectores, y también existe un
+
+00:10:45.014 --> 00:10:47.415
+tipo de dato especial llamado tensor, para hacer
+
+00:10:47.415 --> 00:10:50.860
+más fácil estas multiplicaciones, sumas, etcétera. Y, por
+
+00:10:50.860 --> 00:10:53.360
+último, mucho de esto ya está expresado en
+
+00:10:53.820 --> 00:10:57.120
+librerías existentes que hacen relativamente sencilla su implementación.
+
+00:10:57.420 --> 00:11:00.060
+En la siguiente clase, vamos a entender cómo
+
+00:11:00.060 --> 00:11:03.060
+funciona un gran modelo de lenguaje por dentro
+
+00:11:03.060 --> 00:11:04.860
+sobre lo que acabamos de aprender de redes
+
+00:11:04.860 --> 00:11:06.885
+neuronales. Pero Platzi también tiene un curso de
+
+00:11:06.885 --> 00:11:09.245
+fundamentos de LLMs que está aquí abajo en
+
+00:11:09.245 --> 00:11:11.605
+los recursos y deberías tomar, junto con un
+
+00:11:11.605 --> 00:11:15.045
+curso de algebra lineal aplicada al machine learning
+
+00:11:15.045 --> 00:11:17.125
+y, por supuesto, un curso de deep learning
+
+00:11:17.125 --> 00:11:19.300
+con TensorFlow, que es una de las librerías
+
+00:11:19.300 --> 00:11:21.560
+más usadas para construir este tipo de mecanismos.
+
+00:11:21.860 --> 00:11:24.680
+Y, por cierto, la inmensa mayoría de programadores
+
+00:11:25.060 --> 00:11:27.120
+no saben que es una red neuronal. ¿Por
+
+00:11:27.120 --> 00:11:29.280
+qué llegaste a esta clase? Estás en un
+
+00:11:29.280 --> 00:11:31.760
+porcentaje muy selecto de la gente que lo
+
+00:11:31.760 --> 00:11:32.260
+entiende.

subir/fixed/Curso de Fundamentos de Ingeniería de Software/05-Introducción a Blockchain e Inteligencia Artificial/03-Cómo funcionan los LLMs.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cde6761ea6d2ca7627919bef1c23ea47922dbe2ed08614c5e6ee026420baaa84
+size 324637685

subir/fixed/Curso de Fundamentos de Ingeniería de Software/05-Introducción a Blockchain e Inteligencia Artificial/03-Cómo funcionan los LLMs.vtt

@@ -0,0 +1,928 @@
+WEBVTT
+
+00:00:00.080 --> 00:00:01.920
+Te digo que el gato maúlla y el
+
+00:00:01.920 --> 00:00:04.120
+perro, ¿el perro qué hace? La gran mayoría
+
+00:00:04.120 --> 00:00:05.520
+de ustedes va a decir que el perro
+
+00:00:05.520 --> 00:00:07.120
+ladra, pero de pronto no, de pronto el
+
+00:00:07.120 --> 00:00:09.200
+gato maúlla y el perro se asusta, de
+
+00:00:09.200 --> 00:00:11.200
+pronto el gato maúlla y el perro no
+
+00:00:11.200 --> 00:00:14.275
+maúlla. Todas son opciones completamente válidas, pero nuestra
+
+00:00:14.275 --> 00:00:16.114
+inteligencia nos dice que la forma en la
+
+00:00:16.114 --> 00:00:17.715
+que este acertijo se resuelve es que el
+
+00:00:17.715 --> 00:00:20.435
+gato maúlla y el perro ladra. ¿Cómo hicimos
+
+00:00:20.435 --> 00:00:22.435
+esto? Esto lo hacemos a través de algo
+
+00:00:22.435 --> 00:00:25.555
+que se llama la atención. Le ponemos atención
+
+00:00:25.555 --> 00:00:28.090
+a ciertas palabras y a otras no. Esto
+
+00:00:28.090 --> 00:00:30.570
+se puede expresar matemáticamente en la ecuación que
+
+00:00:30.570 --> 00:00:32.409
+ustedes están viendo en este momento en pantalla.
+
+00:00:32.409 --> 00:00:34.170
+Lo que vamos a hacer es entender los
+
+00:00:34.170 --> 00:00:36.010
+componentes de esa ecuación porque es la forma
+
+00:00:36.010 --> 00:00:38.090
+en la que funcionan los grandes modelos de
+
+00:00:38.090 --> 00:00:41.085
+lenguaje, la inteligencia artificial moderna. Lo primero que
+
+00:00:41.085 --> 00:00:43.885
+tenemos que hacer es agarrar todo el cuerpo
+
+00:00:43.885 --> 00:00:46.204
+del lenguaje de la cultura humana y romperlo
+
+00:00:46.204 --> 00:00:49.585
+en pedacitos. Vamos a romper todas las palabras,
+
+00:00:49.725 --> 00:00:51.565
+todas las letras, todo lo que existe en
+
+00:00:51.565 --> 00:00:56.360
+la cultura humana en letras, sílabas y palabras.
+
+00:00:56.739 --> 00:00:59.060
+Ustedes dirán que estos son una cantidad de
+
+00:00:59.060 --> 00:01:01.960
+variaciones infinita, pero el lenguaje no es infinito.
+
+00:01:02.020 --> 00:01:04.900
+Efectivamente, existen permutaciones casi infinitas de las letras,
+
+00:01:04.900 --> 00:01:06.420
+pero la realidad es que cuando 1 toma
+
+00:01:06.420 --> 00:01:08.765
+todos los libros escritos, todo el Internet, todos
+
+00:01:08.765 --> 00:01:10.565
+los emails, todo lo que está en Google,
+
+00:01:10.565 --> 00:01:11.965
+todo lo que está en la Wikipedia, todo
+
+00:01:11.965 --> 00:01:14.365
+lo que está en redes, foros, etcétera, 1
+
+00:01:14.365 --> 00:01:16.125
+se da cuenta que, por ejemplo, en el
+
+00:01:16.125 --> 00:01:18.685
+caso del lenguaje inglés, hay una, más o
+
+00:01:18.685 --> 00:01:22.370
+menos, cantidad de 50000 tokens. Si le agregamos
+
+00:01:22.390 --> 00:01:25.650
+otros lenguajes, si le agregamos lenguajes de programación
+
+00:01:25.790 --> 00:01:28.210
+u otros tipos de texto, el número aumenta
+
+00:01:28.510 --> 00:01:31.970
+bastante. Típicamente, los sistemas de traducción, por ejemplo,
+
+00:01:32.030 --> 00:01:35.205
+usan entre 40000 a 50000 tokens, Y los
+
+00:01:35.205 --> 00:01:38.965
+grandes modelos de lenguaje, como GPT 4, Lama
+
+00:01:38.965 --> 00:01:41.205
+y los otros grandes modelos que existen, pueden
+
+00:01:41.205 --> 00:01:45.765
+usar hasta 256000 tokens en sus tokens del
+
+00:01:45.765 --> 00:01:47.925
+vocabulario del lenguaje. Pero por ahora, ten en
+
+00:01:47.925 --> 00:01:49.525
+mente que lo que hacemos es que agarramos
+
+00:01:49.525 --> 00:01:52.700
+las palabras y las dividimos en pedacitos. Entonces,
+
+00:01:52.700 --> 00:01:55.820
+por ejemplo, la palabra satisfacción tiene la palabra
+
+00:01:55.820 --> 00:01:58.300
+acción y acción es un token, pero la
+
+00:01:58.300 --> 00:02:01.260
+letra f puede ser otro token, el is
+
+00:02:01.260 --> 00:02:03.665
+de satisfacción es un token y el SAT
+
+00:02:03.665 --> 00:02:05.345
+es otro token. Y ahora que tengo cada
+
+00:02:05.345 --> 00:02:07.145
+1 de esos tokens, lo siguiente que tengo
+
+00:02:07.145 --> 00:02:10.565
+que hacer es evaluar la correlación que existe
+
+00:02:10.864 --> 00:02:14.145
+entre token y token. Entonces, imagina que tengo
+
+00:02:14.145 --> 00:02:16.860
+el token gato, es la palabra gato, y
+
+00:02:16.860 --> 00:02:20.220
+quiero buscar la palabra gato qué tan cercana
+
+00:02:20.220 --> 00:02:22.640
+en todo el lenguaje está a otros conceptos.
+
+00:02:23.099 --> 00:02:25.500
+Entonces, por ejemplo, imaginen que esto fuera un
+
+00:02:25.500 --> 00:02:27.260
+plano cartesiano con un eje x que va
+
+00:02:27.260 --> 00:02:30.459
+de 0 hasta n, donde n es el
+
+00:02:30.459 --> 00:02:32.955
+número de tokens que existen. Entonces la palabra
+
+00:02:32.955 --> 00:02:37.155
+gato en el eje animal estaría muy cerca
+
+00:02:37.155 --> 00:02:39.515
+al 0. Entonces yo pongo que gato con
+
+00:02:39.515 --> 00:02:42.155
+su correlación animal es un 0. Imagina que
+
+00:02:42.155 --> 00:02:44.555
+tengo una segunda dimensión, como si fuera un
+
+00:02:44.555 --> 00:02:48.870
+eje XYY estuviera la palabra automóvil. Gato respecto
+
+00:02:49.090 --> 00:02:51.250
+a automóvil muy probablemente está tan arriba como
+
+00:02:51.250 --> 00:02:52.850
+sea posible, porque gato no está cerca de
+
+00:02:52.850 --> 00:02:55.010
+la palabra automóvil. Y ahora imagina que tengo
+
+00:02:55.010 --> 00:02:58.755
+una tercera dimensión y tengo el eje amor,
+
+00:02:58.995 --> 00:03:00.595
+no ama a los gatos. Pero 1 no
+
+00:03:00.595 --> 00:03:01.875
+ama a los gatos más que a los
+
+00:03:01.875 --> 00:03:03.635
+bebés. Entonces, gato no va a estar en
+
+00:03:03.635 --> 00:03:05.795
+el 0 de la palabra amor, pero de
+
+00:03:05.795 --> 00:03:07.255
+pronto sí va a estar en el 10.
+
+00:03:07.315 --> 00:03:11.255
+Y así lo hago para todas las palabras
+
+00:03:11.475 --> 00:03:15.160
+que existen, para todos los tokens, a partir
+
+00:03:15.380 --> 00:03:18.020
+de qué tan cercanas están las palabras con
+
+00:03:18.020 --> 00:03:21.560
+otras palabras en el lenguaje. Esto es ubicarlo
+
+00:03:21.620 --> 00:03:25.515
+en un espacio nidimensional. Visualmente, los humanos solamente
+
+00:03:25.515 --> 00:03:28.234
+podemos ver 3 dimensiones, pero un computador no
+
+00:03:28.234 --> 00:03:32.075
+tiene problemas en guardar las 300000000000 de dimensiones
+
+00:03:32.075 --> 00:03:35.114
+de GPT 3 o las 50000 dimensiones de
+
+00:03:35.114 --> 00:03:38.200
+todos los tokens que requiere un traductor. Entonces,
+
+00:03:38.420 --> 00:03:41.620
+cada palabra tiene un vector o un número
+
+00:03:41.620 --> 00:03:44.500
+de números que me muestra la cercanía, entre
+
+00:03:44.500 --> 00:03:47.160
+otras palabras, y se ubican de manera multidimensional,
+
+00:03:47.780 --> 00:03:50.340
+y eso es tokenizar el lenguaje. Esto crea
+
+00:03:50.340 --> 00:03:53.155
+un efecto muy interesante, y es que palabras
+
+00:03:54.255 --> 00:03:57.155
+similares van a estar en estos espacios multidimensionales
+
+00:03:58.015 --> 00:04:00.575
+muy cerca de otras palabras similares. Entonces, por
+
+00:04:00.575 --> 00:04:03.535
+ejemplo, la palabra gato, perro y lobo van
+
+00:04:03.535 --> 00:04:05.875
+a estar muy cerca entre sí, porque son
+
+00:04:06.015 --> 00:04:09.450
+mamíferos, porque están en español, porque son animales
+
+00:04:09.550 --> 00:04:12.030
+y la palabra banano o manzana también va
+
+00:04:12.030 --> 00:04:14.110
+a estar muy cerca entre sí. El otro
+
+00:04:14.110 --> 00:04:17.070
+fenómeno interesante que tiene esto es que las
+
+00:04:17.070 --> 00:04:20.367
+palabras pueden tener vectores, un vector es una
+
+00:04:20.367 --> 00:04:20.680
+dirección en ese plano cartesiano multidimensional que se
+
+00:04:20.680 --> 00:04:24.455
+parecen dirección en ese plano cartesiano multidimensional que
+
+00:04:24.455 --> 00:04:27.015
+se parecen mucho una con la otra. Entonces,
+
+00:04:27.015 --> 00:04:30.715
+por ejemplo, rey y reina tienen una conexión
+
+00:04:30.775 --> 00:04:34.535
+muy similar a hombre mujer. Ese vector muy
+
+00:04:34.535 --> 00:04:36.875
+probablemente es el vector de la palabra género.
+
+00:04:37.120 --> 00:04:40.000
+O, por ejemplo, la palabra caminé y caminar
+
+00:04:40.000 --> 00:04:43.120
+va a estar muy similar a nadé y
+
+00:04:43.120 --> 00:04:46.160
+nadar, porque el vector de tiempo presente o
+
+00:04:46.160 --> 00:04:49.699
+pasado los hace estar muy cerca. O diferentes
+
+00:04:49.839 --> 00:04:54.115
+países y sus capitales, el vector, la coordenada,
+
+00:04:54.294 --> 00:04:57.255
+la serie de coordenadas que apuntan entre país
+
+00:04:57.255 --> 00:04:59.675
+y ciudad capital van a ser muy similares.
+
+00:04:59.815 --> 00:05:02.395
+Y si yo agarro los números que corresponden
+
+00:05:02.935 --> 00:05:06.220
+al vector entre Italia y Roma y los
+
+00:05:06.220 --> 00:05:08.880
+llevo a Colombia, muy probablemente me va a
+
+00:05:09.340 --> 00:05:13.180
+apuntar muy cerca o exactamente hacia Bogotá. Esto
+
+00:05:13.180 --> 00:05:17.900
+es convertir las palabras en expresiones matemáticas que
+
+00:05:17.900 --> 00:05:19.875
+se pueden sumar o restar. Eso nos permite
+
+00:05:19.875 --> 00:05:23.335
+hacer cosas increíbles, por ejemplo, mamá menos género
+
+00:05:23.795 --> 00:05:27.075
+probablemente me da pariente, pariente más masculino probablemente
+
+00:05:27.075 --> 00:05:30.294
+me da padre, o la palabra regente más
+
+00:05:30.435 --> 00:05:32.435
+mujer probablemente me da igual a reina, y
+
+00:05:32.435 --> 00:05:35.160
+regente más hombre rey. Lo siguiente que tengo
+
+00:05:35.160 --> 00:05:39.660
+que hacer es crear una red de pesos,
+
+00:05:40.040 --> 00:05:44.380
+de probabilidad estadística, donde las palabras estén estadísticamente
+
+00:05:44.600 --> 00:05:47.960
+conectadas entre sí, los tokens realmente. Siempre que
+
+00:05:47.960 --> 00:05:50.115
+yo diga palabras me refiero a los tokens,
+
+00:05:50.115 --> 00:05:52.995
+y los tokens son palabras, sílabas o letras
+
+00:05:52.995 --> 00:05:54.775
+de todo el lenguaje de la cultura humana.
+
+00:05:54.835 --> 00:05:56.995
+Así como usamos todo el lenguaje de la
+
+00:05:56.995 --> 00:06:00.034
+cultura humana para crear nuestros tokens, ahora necesitamos
+
+00:06:00.034 --> 00:06:01.974
+usar todo el lenguaje de la cultura humana
+
+00:06:02.060 --> 00:06:04.780
+para agregar la probabilidad de conexión entre cada
+
+00:06:04.780 --> 00:06:07.180
+1 de ellos. Con el lenguaje tokenizado, el
+
+00:06:07.180 --> 00:06:10.160
+siguiente paso es tratar de encontrar la probabilidad
+
+00:06:10.300 --> 00:06:12.620
+en la que una palabra ocurre después de
+
+00:06:12.620 --> 00:06:15.420
+otra. Como nosotros tenemos todo el lenguaje de
+
+00:06:15.420 --> 00:06:18.215
+la cultura humana en libros, en Internet, en
+
+00:06:18.215 --> 00:06:21.015
+las redes, en la Wikipedia, en tantos otros
+
+00:06:21.015 --> 00:06:24.835
+lugares. Las empresas de inteligencia artificial toman esta
+
+00:06:24.935 --> 00:06:27.254
+fuente de datos, la cultura humana, los textos
+
+00:06:27.254 --> 00:06:29.574
+que hemos escrito, y buscan expresar de una
+
+00:06:29.574 --> 00:06:32.470
+manera matemática la probabilidad de que una letra
+
+00:06:32.470 --> 00:06:34.230
+vaya después de cierta otra letra, que una
+
+00:06:34.230 --> 00:06:36.790
+palabra vaya después de cierta otra palabra. Esto
+
+00:06:36.790 --> 00:06:39.830
+se conoce como el corpus del lenguaje o
+
+00:06:39.830 --> 00:06:41.910
+los datos de entrenamiento con el que los
+
+00:06:41.910 --> 00:06:45.075
+voy a entrenar. Y divido esto en 2
+
+00:06:45.075 --> 00:06:47.475
+pedazos. Un 70 por 100 lo uso para
+
+00:06:47.475 --> 00:06:49.715
+entrenar y otro 30 por 100, el 30
+
+00:06:49.715 --> 00:06:52.355
+por 100 restante, lo uso para probar, de
+
+00:06:52.355 --> 00:06:54.755
+tal manera que este primer 70 por 100
+
+00:06:54.755 --> 00:06:56.940
+entrena mi red neuronal y luego esa red
+
+00:06:56.940 --> 00:06:58.780
+neuronal le hago pruebas con el 30 por
+
+00:06:58.780 --> 00:07:01.100
+100 restante. Y si me da lo mismo
+
+00:07:01.100 --> 00:07:02.940
+y se comporta igual, es que el entrenamiento
+
+00:07:02.940 --> 00:07:06.060
+quedó bien. Una red neuronal es un mecanismo
+
+00:07:06.060 --> 00:07:10.540
+estadístico para encontrar los patrones escondidos entre los
+
+00:07:10.540 --> 00:07:13.705
+datos. En el lenguaje, por ejemplo, nosotros sabemos
+
+00:07:13.705 --> 00:07:17.965
+que hay una conexión entre adverbios, sílabas, adjetivos,
+
+00:07:18.425 --> 00:07:22.925
+sustantivos y muchos otros patrones que emergen simplemente
+
+00:07:22.985 --> 00:07:25.240
+de la posición de las letras, las sílabas
+
+00:07:25.240 --> 00:07:27.500
+y las palabras, lo que nosotros llamamos tokens.
+
+00:07:27.880 --> 00:07:29.960
+Así que una red neuronal es un proceso
+
+00:07:29.960 --> 00:07:32.360
+que tiene una capa de entrada, unas capas
+
+00:07:32.360 --> 00:07:35.070
+escondidas y una capa de salida. La capa
+
+00:07:35.070 --> 00:07:38.775
+de entrada son todos los tokens que corresponden
+
+00:07:39.235 --> 00:07:43.414
+al vocabulario de entrenamiento, a nuestros vectores de
+
+00:07:43.875 --> 00:07:45.955
+lenguaje que aprendimos en el paso anterior. Y
+
+00:07:45.955 --> 00:07:48.354
+la capa de salida es exactamente lo mismo.
+
+00:07:48.354 --> 00:07:50.595
+La idea es predecir a partir de unas
+
+00:07:50.595 --> 00:07:53.280
+palabras de entrada cuál sería la palabra de
+
+00:07:53.280 --> 00:07:57.920
+salida. Las capas intermedias o capas escondidas son
+
+00:07:57.920 --> 00:08:02.740
+funciones matemáticas de interconexión que detectan estos patrones
+
+00:08:02.880 --> 00:08:06.745
+y que van modificando unos números estadísticos para
+
+00:08:06.745 --> 00:08:09.625
+cambiar la capa de salida. Estos patrones se
+
+00:08:09.625 --> 00:08:12.745
+van ajustando en el período de entrenamiento. A
+
+00:08:12.745 --> 00:08:16.185
+medida que nuestra red neuronal lee todo el
+
+00:08:16.185 --> 00:08:18.520
+cuerpo del lenguaje de la cultura humana, va
+
+00:08:18.520 --> 00:08:21.740
+entendiendo que muy probablemente después de la palabra
+
+00:08:21.880 --> 00:08:24.199
+yo puede seguir la palabra amo, que muy
+
+00:08:24.199 --> 00:08:27.080
+probablemente después de la palabra mi mamá sigue
+
+00:08:27.080 --> 00:08:30.575
+la palabra me. Y todo ese ajuste de
+
+00:08:30.575 --> 00:08:32.975
+entendimiento de patrones del lenguaje, como el patrón
+
+00:08:32.975 --> 00:08:36.294
+de rimar, el patrón de programar, el patrón
+
+00:08:36.294 --> 00:08:39.835
+de escribir lenguaje de marketing, se va expresando
+
+00:08:39.895 --> 00:08:43.335
+matemáticamente para generar esta estructura final que se
+
+00:08:43.335 --> 00:08:45.415
+vuelve la red neuronal de un gran modelo
+
+00:08:45.415 --> 00:08:48.690
+de lenguaje. Estos son 1000 de 1000000 de
+
+00:08:48.690 --> 00:08:51.010
+parámetros, que son los pesos de cada una
+
+00:08:51.010 --> 00:08:53.990
+de estas letras que nosotros llamamos neuronas. Estos
+
+00:08:54.050 --> 00:08:57.410
+1000 de 1000000 de parámetros toman muchísimo tiempo
+
+00:08:57.410 --> 00:08:58.529
+y es parte de la razón por la
+
+00:08:58.529 --> 00:09:00.450
+que la inteligencia artificial se demoró tanto en
+
+00:09:00.450 --> 00:09:03.935
+llegar, porque aunque estos algoritmos son viejos, nacieron
+
+00:09:03.935 --> 00:09:05.935
+en los años 50, se fueron optimizando en
+
+00:09:05.935 --> 00:09:08.415
+los noventas, no es hasta ahora que tenemos
+
+00:09:08.415 --> 00:09:11.454
+suficientes chips y suficiente memoria RAM para entrenar
+
+00:09:11.454 --> 00:09:13.295
+una red neuronal de este estilo. Esto es
+
+00:09:13.295 --> 00:09:15.795
+mucho más complejo y tiene otras ecuaciones matemáticas
+
+00:09:15.930 --> 00:09:18.830
+por dentro en las que ahondamos con más
+
+00:09:19.290 --> 00:09:21.450
+detalle en la clase de redes neuronales del
+
+00:09:21.450 --> 00:09:23.770
+curso de fundamentos de ingeniería de software. Y,
+
+00:09:23.770 --> 00:09:26.089
+por supuesto, lo podemos ver en nivel código
+
+00:09:26.089 --> 00:09:28.463
+y matemático en los cursos de redes neuronales
+
+00:09:28.463 --> 00:09:30.649
+y machine learning de Platzi. Pero esto no
+
+00:09:30.649 --> 00:09:33.475
+es suficiente. Con solo entrenar una red neuronal
+
+00:09:33.475 --> 00:09:36.035
+y tener todos los tokens puedo programar, por
+
+00:09:36.035 --> 00:09:38.995
+ejemplo, un traductor, pero no puedo hacer que
+
+00:09:38.995 --> 00:09:41.575
+el gato mahuye o que el perro ladre.
+
+00:09:41.875 --> 00:09:44.515
+Todavía no he logrado completar todos los datos
+
+00:09:44.515 --> 00:09:47.510
+que necesito para generar un sistema de predicción
+
+00:09:47.890 --> 00:09:49.810
+efectivo. En general, la razón por la que
+
+00:09:49.810 --> 00:09:51.830
+no se puede es porque tendría que multiplicar
+
+00:09:52.130 --> 00:09:53.490
+por cada una de las letras, por cada
+
+00:09:53.490 --> 00:09:54.610
+1 de los tokens, por cada una de
+
+00:09:54.610 --> 00:09:57.030
+las palabras y sílabas que tengo acá expresadas,
+
+00:09:57.410 --> 00:09:59.570
+todas las variaciones. Y esto es un problema
+
+00:09:59.570 --> 00:10:01.925
+n a la n, que tomaría una cantidad
+
+00:10:01.925 --> 00:10:04.565
+de memoria RAM, de CPU, de GPU y
+
+00:10:04.565 --> 00:10:08.085
+de chips ingente. Pero no necesito hacerlo para
+
+00:10:08.085 --> 00:10:11.845
+todas, solamente necesito hacerlo para las palabras más
+
+00:10:11.845 --> 00:10:14.635
+importantes. Cuando tú dices que el gato maúlla
+
+00:10:14.635 --> 00:10:17.740
+y el perro hay una palabra particular a
+
+00:10:17.740 --> 00:10:19.660
+la que le pones más atención. Probablemente es
+
+00:10:19.660 --> 00:10:21.900
+la palabra maúlla y hay otra palabra a
+
+00:10:21.900 --> 00:10:23.580
+la que le pones atención, probablemente es la
+
+00:10:23.580 --> 00:10:26.540
+palabra gato. Así funciona tu mente. Tú no
+
+00:10:26.540 --> 00:10:28.380
+leíste todo el texto, solo te enfocas en
+
+00:10:28.380 --> 00:10:31.655
+los elementos más importantes para predecir la siguiente
+
+00:10:31.655 --> 00:10:33.835
+palabra y de esta manera completar el texto.
+
+00:10:34.215 --> 00:10:36.055
+Esto se le conoce como el modelo de
+
+00:10:36.055 --> 00:10:39.115
+atención y funciona de la siguiente manera. Existe
+
+00:10:39.175 --> 00:10:41.575
+un query, un key y un value, una
+
+00:10:41.575 --> 00:10:44.490
+consulta, una llave y un valor. Esto que
+
+00:10:44.490 --> 00:10:46.910
+tenemos acá, el gato Maura y el perro,
+
+00:10:47.050 --> 00:10:49.450
+esto es un prompt, el prompt que tú
+
+00:10:49.450 --> 00:10:52.410
+escribes en ChatGPT o en donde sea. El
+
+00:10:52.410 --> 00:10:55.150
+prompt lo que hace es ver el último
+
+00:10:55.290 --> 00:10:57.770
+token, la última palabra, en este caso es
+
+00:10:57.770 --> 00:11:00.474
+perro, Y de ese último token va a
+
+00:11:00.474 --> 00:11:02.925
+evaluar a lo largo de todo el resto
+
+00:11:02.925 --> 00:11:05.805
+del prompt, todo lo que ha escrito, cuáles
+
+00:11:05.805 --> 00:11:10.205
+son los tokens de mayor significancia, que están
+
+00:11:10.205 --> 00:11:13.330
+más cerca del último. ¿Cómo saben que está
+
+00:11:13.330 --> 00:11:15.670
+más cerca? Porque están en el plano cartesiano
+
+00:11:15.730 --> 00:11:19.590
+del espacio enidimensional de tokens. Entonces, la palabra
+
+00:11:19.970 --> 00:11:22.310
+perro está muy cerca de la palabra maúlla
+
+00:11:22.530 --> 00:11:25.270
+y está definitivamente cerca de la palabra gato.
+
+00:11:25.890 --> 00:11:27.970
+Estas palabras que son cercanas a la palabra
+
+00:11:27.970 --> 00:11:32.105
+perro las volvemos la llave. Y luego la
+
+00:11:32.105 --> 00:11:35.785
+b es el valor. Ese valor es una
+
+00:11:35.785 --> 00:11:40.125
+ecuación matemática que multiplica y mueve las matrices
+
+00:11:40.505 --> 00:11:42.800
+de los números de puntería de la palabra
+
+00:11:42.800 --> 00:11:45.280
+perro y de la palabra maúlla y gato,
+
+00:11:45.280 --> 00:11:47.840
+a través de una función de activación. Lo
+
+00:11:47.840 --> 00:11:50.400
+importante es que esa v termina siendo un
+
+00:11:50.400 --> 00:11:53.280
+vector que usando la palabra maúlla y la
+
+00:11:53.280 --> 00:11:55.211
+palabra gato junto con la palabra perro, que
+
+00:11:55.211 --> 00:11:58.305
+es la última palabra del prompt, apunta a
+
+00:11:58.305 --> 00:12:01.584
+la probabilidad más alta de una palabra que
+
+00:12:01.584 --> 00:12:05.425
+continúe. Esto genera otro vector de probabilidades que
+
+00:12:05.425 --> 00:12:07.505
+genera una serie de palabras. Puede que el
+
+00:12:07.505 --> 00:12:09.265
+perro ladre, que el perro es, que el
+
+00:12:09.265 --> 00:12:11.670
+perro llora o que el perro no. Esta
+
+00:12:11.670 --> 00:12:14.230
+probabilidad es lo que termina siendo que eventualmente
+
+00:12:14.230 --> 00:12:16.890
+elijamos la palabra ladra, porque tiene el mayor
+
+00:12:17.029 --> 00:12:19.589
+porcentaje. Pero los grandes modelos de lenguaje no
+
+00:12:19.589 --> 00:12:22.630
+eligen solamente la palabra de mayor probabilidad. Los
+
+00:12:22.630 --> 00:12:24.149
+modelos de lenguaje tienen algo que se llama
+
+00:12:24.149 --> 00:12:27.755
+temperatura, porque la creatividad no funciona siendo siempre
+
+00:12:27.755 --> 00:12:29.755
+lo mismo. Para que haya un nivel de
+
+00:12:29.755 --> 00:12:31.514
+inteligencia tiene que haber un cierto nivel de
+
+00:12:31.514 --> 00:12:33.675
+creatividad, por ende, a veces tengo que elegir
+
+00:12:33.675 --> 00:12:36.315
+la segunda o la tercera opción. Los grandes
+
+00:12:36.315 --> 00:12:39.274
+módulos de lenguaje, a veces, de manera aleatoria,
+
+00:12:39.274 --> 00:12:40.770
+eligen la segunda o la tercera opción. Y
+
+00:12:40.770 --> 00:12:42.930
+es por esto que no son deterministas, que
+
+00:12:42.930 --> 00:12:45.430
+no generan el mismo texto todo el tiempo,
+
+00:12:45.490 --> 00:12:48.610
+pero generan textos muy similares. Sin embargo, esto
+
+00:12:48.610 --> 00:12:52.210
+solamente sirve para autocompletar los primeros GPTs o
+
+00:12:52.210 --> 00:12:55.575
+Generative Pretrain Transformers, que son estos modelos que
+
+00:12:55.575 --> 00:12:58.135
+integran la red neuronal, los tokens, el espacio
+
+00:12:58.135 --> 00:13:00.855
+en el dimensional, la atención, 1 les colocaba
+
+00:13:00.855 --> 00:13:03.975
+un texto y tenían que completarlo. No se
+
+00:13:03.975 --> 00:13:06.055
+comportaban como un chat. Lo que hizo Pen
+
+00:13:06.055 --> 00:13:08.855
+AI es que contrató a 6000 personas en
+
+00:13:08.855 --> 00:13:12.680
+África para hablar con el modelo y regañarlo
+
+00:13:12.740 --> 00:13:14.340
+cuando el modelo no se comportaba como un
+
+00:13:14.340 --> 00:13:17.620
+chat y recompensarlo cuando el modelo se comportaba
+
+00:13:17.620 --> 00:13:20.100
+como un chat. Esto recalibró las neuronas del
+
+00:13:20.100 --> 00:13:23.940
+modelo para enseñarle al modelo a responder como
+
+00:13:23.940 --> 00:13:26.725
+un chat o como no un chat. Esto
+
+00:13:26.725 --> 00:13:31.285
+se conoce como RLHF, Remeforcement Learning with Human
+
+00:13:31.285 --> 00:13:33.205
+Feedback, y es la forma en la que
+
+00:13:33.205 --> 00:13:36.265
+los modelos aprenden a hablar como un chat.
+
+00:13:36.565 --> 00:13:40.310
+Esto incluye aprender cuándo dejar de hablar, cuándo
+
+00:13:40.310 --> 00:13:43.270
+dejar de generar resultados. Esta es la razón
+
+00:13:43.270 --> 00:13:46.470
+por la que ChatGPT responde muchas veces en
+
+00:13:46.470 --> 00:13:48.970
+listas de viñetas, o por la que Anthropic
+
+00:13:49.190 --> 00:13:52.470
+Kloth y Gemini tienen respuestas tan diferentes en
+
+00:13:52.470 --> 00:13:55.050
+su personalidad a la personalidad que tiene Kloth.
+
+00:13:55.375 --> 00:13:57.695
+Hay varios cursos de Platzi de procesamiento de
+
+00:13:57.695 --> 00:13:59.215
+lenguaje natural que te lo explican más a
+
+00:13:59.215 --> 00:14:01.375
+fondo, pero el curso más importante es el
+
+00:14:01.375 --> 00:14:04.575
+curso de fundamentos de LLMs, que te enseña
+
+00:14:04.575 --> 00:14:07.087
+de punta a punta cómo construir esto, cómo
+
+00:14:07.407 --> 00:14:09.487
+instalarlo en tu computadora y cómo ser un
+
+00:14:09.487 --> 00:14:12.126
+ingeniero que está construyendo la frontera del conocimiento,
+
+00:14:12.126 --> 00:14:14.047
+que hoy en día es la inteligencia artificial
+
+00:14:14.047 --> 00:14:16.066
+generativa con grandes modelos de lenguaje.