Upload batch from C CLI

Uploaded via hf-downloader C client

.gitattributes

@@ -133,3 +133,30 @@ 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/01-Computación[[:space:]]Básica/06-Cómo[[:space:]]funciona[[:space:]]internet.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/01-Computación[[:space:]]Básica/07-Cómo[[:space:]]las[[:space:]]computadoras[[:space:]]guardan[[:space:]]datos.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/01-Computación[[:space:]]Básica/08-Cómo[[:space:]]se[[:space:]]organizan[[:space:]]los[[:space:]]archivos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/01-Computación[[:space:]]Básica/09-Teléfonos[[:space:]]y[[:space:]]sus[[:space:]]System[[:space:]]on[[:space:]]a[[:space:]]Chip[[:space:]]o[[:space:]]SOC.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/01-Computación[[:space:]]Básica/10-GPUs[[:space:]]Procesadores[[:space:]]gráficos[[:space:]]y[[:space:]]de[[:space:]]AI.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/01-Computación[[:space:]]Básica/11-Qué[[:space:]]es[[:space:]]un[[:space:]]algoritmo[[:space:]]y[[:space:]]qué[[:space:]]es[[:space:]]un[[:space:]]lenguaje[[:space:]]de[[:space:]]programación.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/02-Redes[[:space:]]e[[:space:]]Internet/01-Direcciones[[:space:]]IP[[:space:]]y[[:space:]]el[[:space:]]protocolo[[:space:]]de[[:space:]]Internet.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/02-Redes[[:space:]]e[[:space:]]Internet/02-Nombres[[:space:]]de[[:space:]]dominio[[:space:]]DNS[[:space:]]y[[:space:]]cómo[[:space:]]obtener[[:space:]]un[[:space:]]com.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/02-Redes[[:space:]]e[[:space:]]Internet/03-Modelo[[:space:]]ClienteServidor[[:space:]]Cómo[[:space:]]funciona[[:space:]]un[[:space:]]sitio[[:space:]]web.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/03-Sistemas[[:space:]]Operativos[[:space:]]y[[:space:]]Almacenamiento/01-Diferencias[[:space:]]entre[[:space:]]Windows[[:space:]]Linux[[:space:]]y[[:space:]]MacOS.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/03-Sistemas[[:space:]]Operativos[[:space:]]y[[:space:]]Almacenamiento/02-Permisos[[:space:]]niveles[[:space:]]de[[:space:]]procesos[[:space:]]y[[:space:]]privilegios[[:space:]]de[[:space:]]ejecución.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/fixed/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]Ingeniería[[:space:]]de[[:space:]]Software/03-Sistemas[[:space:]]Operativos[[:space:]]y[[:space:]]Almacenamiento/03-Archivos[[:space:]]Metadatos[[:space:]]cabeceras[[:space:]]y[[:space:]]extensiones.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/01-Qué[[:space:]]son[[:space:]]las[[:space:]]bases[[:space:]]de[[:space:]]datos.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/02-Cómo[[:space:]]funciona[[:space:]]el[[:space:]]formato[[:space:]]JPG.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/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/01-Computación Básica/09-Teléfonos y sus System on a Chip o SOC.mp4

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

subir/fixed/Curso de Fundamentos de Ingeniería de Software/01-Computación Básica/09-Teléfonos y sus System on a Chip o SOC.vtt

@@ -0,0 +1,725 @@
+WEBVTT
+
+00:00:00.000 --> 00:00:03.800
+Los circuitos integrados, los chips, la forma en la que funciona la electrónica moderna,
+
+00:00:03.800 --> 00:00:09.120
+empezaron como unos tubos de vacío que ocupaban inmensas cantidades de espacio
+
+00:00:09.120 --> 00:00:14.400
+y que así fue como empezaron las primeras computadoras, los televisores, muchísimas otras mecánicas
+
+00:00:14.400 --> 00:00:17.000
+de la forma en la que se construía la electrónica moderna.
+
+00:00:17.000 --> 00:00:21.320
+Pero lentamente nuestros dispositivos se fueron haciendo más pequeños y más pequeños y más pequeños
+
+00:00:21.320 --> 00:00:24.840
+porque empezamos a empacar transistores en formas más cortas
+
+00:00:24.840 --> 00:00:28.840
+y porque el consumidor quería dispositivos más pequeños que usaran menos electricidad
+
+00:00:28.840 --> 00:00:30.400
+y que fueran más portátiles.
+
+00:00:30.400 --> 00:00:35.480
+La electricidad funcionaba inicialmente con baterías AA, AAA o esas baterías grandotas de 9 voltios
+
+00:00:35.480 --> 00:00:38.840
+con las que podíamos usar cosas como una grabadora de cassette,
+
+00:00:38.840 --> 00:00:42.760
+una de las que llamaban boombox, y de esa manera tenemos música o un Walkman
+
+00:00:42.760 --> 00:00:48.360
+o tantos otros dispositivos que quemaban y quemaban esas baterías a muy alta velocidad
+
+00:00:48.360 --> 00:00:53.680
+y eran muy costosas, así que había un incentivo natural de los fabricantes de reducir las baterías.
+
+00:00:53.680 --> 00:00:58.040
+Y luego llegaron los smartphones y antes de eso los teléfonos móviles, entre muchas otras cosas.
+
+00:00:58.040 --> 00:01:02.880
+Esa necesidad de reducir el gasto de electricidad y reducir el espacio
+
+00:01:02.880 --> 00:01:07.240
+empezó a hacer que los chips se volvieran más y más y más especializados.
+
+00:01:07.240 --> 00:01:10.080
+Luego la computación hizo que nuestras computadoras
+
+00:01:10.080 --> 00:01:12.640
+cupieran en una caja gigante y luego en un laptop,
+
+00:01:12.640 --> 00:01:15.160
+pero con el pasar del tiempo nos pusimos a pensar
+
+00:01:15.160 --> 00:01:16.760
+¿Por qué tenemos chips para todo?
+
+00:01:16.760 --> 00:01:21.560
+¿Por qué hay un chip que es la CPU y otra tarjeta distinta es la tarjeta gráfica
+
+00:01:21.560 --> 00:01:23.760
+y otra tarjeta distinta es la tarjeta de sonido?
+
+00:01:23.800 --> 00:01:28.160
+¿Por qué a medida que especializamos todo, no pegamos todo en un solo chip?
+
+00:01:28.160 --> 00:01:30.640
+Estos son conocidos como System on a Chip.
+
+00:01:30.640 --> 00:01:34.440
+Los dos problemas más grandes son de electricidad y de espacio.
+
+00:01:34.440 --> 00:01:39.360
+Entre más chips hay, más gastan batería porque más largo tienen que viajar los electrones
+
+00:01:39.360 --> 00:01:41.880
+dentro de la tarjeta en cada uno de los ciclos
+
+00:01:41.880 --> 00:01:45.360
+que nos permiten jugar un videojuego en el teléfono o atender una llamada.
+
+00:01:45.360 --> 00:01:48.520
+El segundo problema es que los teléfonos eran un ladrillo gigante
+
+00:01:48.520 --> 00:01:51.840
+y queríamos que fueran cada vez más pequeños, y no solo eran teléfonos,
+
+00:01:51.880 --> 00:01:56.720
+eran cámaras digitales, eran iPods, Walkmans, televisores.
+
+00:01:56.720 --> 00:01:59.240
+Ahora que todo vive en un teléfono, pues lo vemos más claro,
+
+00:01:59.240 --> 00:02:01.760
+pero antes eran todo tipo de dispositivos.
+
+00:02:01.760 --> 00:02:04.640
+Así que empezamos a pensar qué podemos integrar.
+
+00:02:04.640 --> 00:02:06.520
+En el caso de los teléfonos, por ejemplo,
+
+00:02:06.520 --> 00:02:09.640
+un teléfono es básicamente una pantalla gigante,
+
+00:02:09.640 --> 00:02:15.160
+así que necesita un procesador gráfico que sea muy eficiente y que no se sienta lento,
+
+00:02:15.160 --> 00:02:18.160
+porque si un teléfono se siente lento, no se puede usar.
+
+00:02:18.160 --> 00:02:21.800
+Los seres humanos estamos conscientes y aceptamos que una computadora se pone lenta,
+
+00:02:21.800 --> 00:02:24.040
+pero no aceptamos que un teléfono se ponga lento.
+
+00:02:24.040 --> 00:02:26.720
+Y por supuesto necesitamos el procesamiento normal de una computadora
+
+00:02:26.720 --> 00:02:29.920
+para navegar en internet, mandar correos, hacer juegos, etc.
+
+00:02:29.920 --> 00:02:33.240
+Así que necesitamos una CPU y una GPU en el mismo lugar.
+
+00:02:33.240 --> 00:02:37.640
+Combinar en un solo chip la CPU y la GPU fue el primer paso en System on a Chip.
+
+00:02:37.640 --> 00:02:42.400
+Quiero aclarar que no es como que el mismo chip sea CPU y GPU al mismo tiempo
+
+00:02:42.400 --> 00:02:44.040
+con los mismos transistores.
+
+00:02:44.040 --> 00:02:50.000
+Realmente es que en la oblea de silicio, en el wafer, en donde hacen el chip,
+
+00:02:50.000 --> 00:02:54.280
+ahí dentro, colocan en un ladito los transistores que funcionan como CPU
+
+00:02:54.280 --> 00:02:56.800
+y en otro ladito, muy pegadito, muy cerca,
+
+00:02:56.800 --> 00:03:00.040
+en el mismo mecanismo de circuito integrado, rodeado de baquelita,
+
+00:03:00.040 --> 00:03:01.160
+los chips de la GPU.
+
+00:03:01.160 --> 00:03:04.360
+Y así empezaron a pensar en otros chips, porque esto es un computador completo, ¿no?
+
+00:03:04.360 --> 00:03:07.800
+Cuando uno armó una computadora, uno tenía estos tabletas de memoria
+
+00:03:07.800 --> 00:03:11.200
+que hemos visto antes, la memoria RAM, o estos discos duros externos.
+
+00:03:11.200 --> 00:03:13.800
+Pues la memoria RAM, ¿por qué no la pegamos ahí también?
+
+00:03:13.800 --> 00:03:15.840
+¿Y por qué no pegamos el modem?
+
+00:03:15.840 --> 00:03:19.320
+Porque cuando uno hace una llamada, los teléfonos internamente tienen un chip
+
+00:03:19.320 --> 00:03:23.360
+que es un modem, que es el que tiene que hablar con la central telefónica
+
+00:03:23.360 --> 00:03:24.640
+y procesar la llamada.
+
+00:03:24.640 --> 00:03:28.240
+El modem se conecta a las antenas 3G y 4G y los chips también necesitan
+
+00:03:28.240 --> 00:03:29.360
+conectarse a Wi-Fi.
+
+00:03:29.360 --> 00:03:33.440
+Entonces, el Wi-Fi es otro módulo que antes era un circuito aparte en un chip
+
+00:03:33.440 --> 00:03:34.320
+aparte.
+
+00:03:34.320 --> 00:03:37.760
+Como los teléfonos se estandarizaron y todos los teléfonos tienen que procesar
+
+00:03:37.760 --> 00:03:41.440
+video a través de la cámara, capturar audio del micrófono,
+
+00:03:41.440 --> 00:03:46.280
+generar imágenes, todas esas funciones estándar que antes eran periféricos
+
+00:03:46.280 --> 00:03:48.880
+adicionales, fueron creándose en un solo chip.
+
+00:03:48.880 --> 00:03:52.760
+Porque la otra ventaja es que estos dispositivos pues mantenían el mismo
+
+00:03:52.760 --> 00:03:54.200
+hardware constantemente.
+
+00:03:54.200 --> 00:03:58.760
+Si tienes una computadora, te lo puedes conectar mil marcas de webcam,
+
+00:03:58.760 --> 00:04:03.160
+pero en tu teléfono, tu marca como Samsung o Apple o Google,
+
+00:04:03.160 --> 00:04:06.480
+tú sabes exactamente qué lente y qué cámara le estás poniendo a tus
+
+00:04:06.480 --> 00:04:10.000
+teléfonos, exactamente qué tipo de micrófono y qué tipo de parlante.
+
+00:04:10.000 --> 00:04:14.360
+Esa estandarización también ayudó a que los chips sean mucho más sencillos.
+
+00:04:14.360 --> 00:04:19.520
+Huawei, por cierto, es la primera marca en integrar un módem de tecnología 5G
+
+00:04:19.520 --> 00:04:20.360
+en un chip.
+
+00:04:20.360 --> 00:04:24.520
+Aquí en mis notas veo que fue el chip Huawei Kirin 990.
+
+00:04:24.520 --> 00:04:26.200
+La innovación viene de todas partes.
+
+00:04:26.200 --> 00:04:28.680
+Cuando compras tu teléfono y lo enciendes,
+
+00:04:28.680 --> 00:04:33.680
+tu dedo prime el botón de encendido, lo cual conecta dos contactos que hacen un
+
+00:04:33.680 --> 00:04:37.640
+paso de electricidad de la batería al circuito que llega a una señal en el
+
+00:04:37.640 --> 00:04:38.760
+System on a Chip.
+
+00:04:38.760 --> 00:04:41.640
+El primer circuito de un System on a Chip es la BIOS.
+
+00:04:41.640 --> 00:04:44.160
+Es ese sistema de arranque que, por ejemplo,
+
+00:04:44.160 --> 00:04:48.400
+en el caso de iPod y de los dispositivos de Apple como el iPhone,
+
+00:04:48.400 --> 00:04:51.560
+el iPad, etcétera, se llama iBoot.
+
+00:04:51.560 --> 00:04:54.160
+O lo mismo que habría en la BIOS de un computador normal,
+
+00:04:54.160 --> 00:04:55.800
+solamente que aquí está en el chip.
+
+00:04:55.800 --> 00:04:58.480
+Y ahí dentro del chip empieza a arrancar todo.
+
+00:04:58.480 --> 00:05:00.520
+Ese pecito de chip prende la CPU.
+
+00:05:00.520 --> 00:05:03.880
+La CPU va a la memoria flash, que es la memoria,
+
+00:05:03.880 --> 00:05:06.080
+llamémosla permanente o el equivalente al disco duro.
+
+00:05:06.080 --> 00:05:10.680
+Eso sí está aparte porque es un circuito más grande y de una química diferente.
+
+00:05:10.680 --> 00:05:14.840
+Y ahí van y buscan el código del sistema operativo y el resto es igual que una
+
+00:05:14.840 --> 00:05:15.720
+computadora.
+
+00:05:15.720 --> 00:05:18.040
+Pero en vez de estar viajando entre diferentes chips,
+
+00:05:18.040 --> 00:05:19.800
+todo está viajando en el mismo chip.
+
+00:05:19.800 --> 00:05:21.720
+La CPU y la GPU están muy cerca.
+
+00:05:21.720 --> 00:05:26.440
+Y la CPU y la GPU lo que hacen es que la CPU arranca los computadores en cuanto a
+
+00:05:26.440 --> 00:05:29.840
+su sistema operativo y la GPU arranca los pixeles de la pantalla,
+
+00:05:29.840 --> 00:05:33.320
+trabajando en conjunto y compartiendo memoria.
+
+00:05:33.320 --> 00:05:36.000
+Eso es una de las cosas únicas de un System on a Chip.
+
+00:05:36.000 --> 00:05:40.640
+En una computadora, la GPU tiene su propia memoria y es la memoria que usa para
+
+00:05:40.640 --> 00:05:43.840
+representar cosas en pantalla o hacer cálculos paralelos como cálculos de
+
+00:05:43.840 --> 00:05:45.400
+criptomonedas o AI.
+
+00:05:45.400 --> 00:05:48.840
+Y la CPU usa la memoria RAM para ejecutar los computadores.
+
+00:05:48.840 --> 00:05:52.560
+En un System on a Chip, en particular en la arquitectura que creó Apple,
+
+00:05:52.560 --> 00:05:56.880
+se usa una memoria unificada que lo comparte en todas las necesidades del
+
+00:05:56.880 --> 00:05:57.760
+sistema operativo.
+
+00:05:57.760 --> 00:06:01.280
+Ahí carga el kernel y el kernel son los drivers que prenden los periféricos.
+
+00:06:01.280 --> 00:06:05.080
+Pero el periférico, que típicamente sería un circuito con sus mecanismos
+
+00:06:05.080 --> 00:06:08.720
+químicos y mecánicos, como la membrana del micrófono,
+
+00:06:08.720 --> 00:06:11.720
+como los sensores digitales de luz que tiene una cámara,
+
+00:06:11.720 --> 00:06:13.720
+son simplemente la parte de hardware.
+
+00:06:13.720 --> 00:06:16.600
+Y el circuito, toda realmente la operación,
+
+00:06:16.600 --> 00:06:18.720
+está metida en ese System on a Chip.
+
+00:06:18.720 --> 00:06:21.600
+Hace todo más sencillo, mucho más eficiente,
+
+00:06:21.600 --> 00:06:24.560
+con menos generación de calor, con menos gasto de batería.
+
+00:06:24.560 --> 00:06:29.600
+Por eso un teléfono que tiene 8 GB de RAM y una CPU muy pequeña hace muchas más
+
+00:06:29.600 --> 00:06:33.800
+cosas que una computadora con una CPU más grande y los mismos 8 GB de RAM.
+
+00:06:33.800 --> 00:06:37.560
+Un teléfono, además, es básicamente un experimento de física.
+
+00:06:37.560 --> 00:06:40.560
+Por dentro de tu teléfono hay un barómetro que detecta la presión
+
+00:06:40.560 --> 00:06:41.440
+ambiental.
+
+00:06:41.440 --> 00:06:42.720
+Hay un termómetro.
+
+00:06:42.720 --> 00:06:45.800
+A veces te habrá salido una alerta que tu teléfono está muy caliente y de
+
+00:06:45.800 --> 00:06:48.440
+pronto se apaga porque está detectando la temperatura.
+
+00:06:48.440 --> 00:06:52.600
+Todos esos son mecanismos físicos que usando electrónica,
+
+00:06:52.600 --> 00:06:58.640
+mecánica o química hacen que llegue una señal digital al procesador.
+
+00:06:58.640 --> 00:07:00.880
+Pero en vez de tener chips individuales,
+
+00:07:00.880 --> 00:07:04.600
+le delegan el procesamiento de chips a ese System on a Chip que tiene los
+
+00:07:04.600 --> 00:07:06.880
+transistores necesarios para que funcione.
+
+00:07:06.880 --> 00:07:11.160
+Y como son tan similares, entonces muchas de las marcas no tienen que
+
+00:07:11.160 --> 00:07:14.160
+programar sus teléfonos para soportar un montón de drivers,
+
+00:07:14.160 --> 00:07:17.440
+como si le toca hacer a Microsoft con Windows en una computadora,
+
+00:07:17.440 --> 00:07:20.560
+o a Apple con Mac, o a los sistemas operativos Linux.
+
+00:07:20.560 --> 00:07:23.280
+Todo eso apoya a la eficiencia de estos sistemas.
+
+00:07:23.280 --> 00:07:28.400
+Un dato curioso, la cámara de los teléfonos modernos han notado que se
+
+00:07:28.400 --> 00:07:31.680
+estabiliza a pesar de que uno está a veces temblándole las manos al tomar la
+
+00:07:31.680 --> 00:07:34.600
+foto, hay una estabilización que funciona con software,
+
+00:07:34.600 --> 00:07:39.400
+pero hay ciertas cámaras de los teléfonos más costosos donde el lente
+
+00:07:39.400 --> 00:07:42.200
+está flotando en un tipo de aceite,
+
+00:07:42.200 --> 00:07:46.160
+que hace que cuando ustedes estén temblando el lente se mantenga fijo.
+
+00:07:46.160 --> 00:07:50.920
+En otros casos está flotando con electroimanes que lo mantienen fijo o
+
+00:07:50.920 --> 00:07:52.480
+con pequeños sistemas de resortes.
+
+00:07:52.480 --> 00:07:54.520
+Es fascinante y súper chiquito.
+
+00:07:54.520 --> 00:07:59.320
+¿Has notado que a los teléfonos casi siempre les dura 24 horas la batería a
+
+00:07:59.320 --> 00:08:01.720
+pesar de que la tecnología crece y crece y crece?
+
+00:08:01.720 --> 00:08:02.320
+¿Por qué será?
+
+00:08:02.320 --> 00:08:04.160
+Están mejorando las tecnologías de las baterías,
+
+00:08:04.160 --> 00:08:08.760
+pero las baterías están limitadas por los límites químicos de lo que hemos
+
+00:08:08.760 --> 00:08:13.120
+descubierto que es la mayor cantidad de densidad de electricidad que podemos
+
+00:08:13.120 --> 00:08:15.240
+meter en la batería de un teléfono moderno.
+
+00:08:15.240 --> 00:08:17.640
+Lo que realmente está pasando son dos mecanismos.
+
+00:08:17.640 --> 00:08:22.040
+Uno es que el mercado, nosotros que compramos teléfonos,
+
+00:08:22.040 --> 00:08:26.000
+aceptamos teléfonos que duren un día, pero no aceptamos teléfonos que duren 6
+
+00:08:26.000 --> 00:08:30.240
+horas y no recompensamos tanto a nivel financiero los teléfonos que duran dos
+
+00:08:30.240 --> 00:08:31.760
+días. Ese mercado es más pequeño.
+
+00:08:31.760 --> 00:08:32.360
+Existe.
+
+00:08:32.360 --> 00:08:37.000
+Son esos teléfonos grandotototes como el iPhone Pro o como los Samsung Galaxy
+
+00:08:37.000 --> 00:08:38.720
+Node o Ultra, etc.
+
+00:08:38.720 --> 00:08:41.440
+Es un mercado que existe, pero no es tan grande.
+
+00:08:41.440 --> 00:08:45.800
+Lo otro es que los fabricantes de chips son muy conscientes de que cada
+
+00:08:45.800 --> 00:08:50.200
+generación de chip nuevo tiene que gastar menos electricidad y a veces tienen
+
+00:08:50.200 --> 00:08:51.800
+saltos espectaculares.
+
+00:08:51.800 --> 00:08:57.560
+Por eso los MacBook Pros, desde la generación de los chips Apple M, M1, M2,
+
+00:08:57.560 --> 00:09:03.640
+M3 y M4, han ido aumentando de una manera fuerte la duración de la batería de los
+
+00:09:03.640 --> 00:09:07.200
+laptops y ahora es normal que un laptop tenga batería de 12 horas.
+
+00:09:07.200 --> 00:09:10.960
+Los teléfonos, lo que pasa es que siguen exigiéndose cada vez más porque las apps
+
+00:09:10.960 --> 00:09:14.640
+son cada vez más complejas y sofisticadas, pero esa es parte de la razón por la que
+
+00:09:14.640 --> 00:09:16.600
+la batería tiende a durar esto.
+
+00:09:16.600 --> 00:09:21.800
+Súmenle que hay un dato más y es que el uso intensivo de tu teléfono lo calienta
+
+00:09:21.800 --> 00:09:25.280
+y el calor, al estar tan cerca de la batería, puede causar un efecto de
+
+00:09:25.280 --> 00:09:26.080
+explosión.
+
+00:09:26.080 --> 00:09:29.280
+Esto le pasó a una marca de Galaxy Nodes, que básicamente solvían granadas en el
+
+00:09:29.280 --> 00:09:30.120
+bolsillo.
+
+00:09:30.120 --> 00:09:33.840
+Así que los fabricantes de teléfonos tienen que ser muy cuidadosos de no
+
+00:09:33.840 --> 00:09:37.680
+pasarse de cierta cantidad de flujo eléctrico para que no se caliente el
+
+00:09:37.680 --> 00:09:38.920
+teléfono y no explote.
+
+00:09:38.920 --> 00:09:41.560
+La realidad es que en el día de hoy esto casi no es un problema.
+
+00:09:41.560 --> 00:09:44.360
+¿Recuerdan cuando hablamos de la arquitectura de las CPUs?
+
+00:09:44.360 --> 00:09:47.240
+X86, RISC, ARM.
+
+00:09:47.240 --> 00:09:52.680
+ARM domina la arquitectura de los chips de los teléfonos y de los system on a
+
+00:09:52.680 --> 00:09:53.280
+chip.
+
+00:09:53.280 --> 00:09:57.440
+ARM, una empresa inglesa adquirida por una empresa japonesa, Softbank, y en la
+
+00:09:57.440 --> 00:10:00.240
+cual ese diseño es en el que están basados los chips de Apple.
+
+00:10:00.240 --> 00:10:03.680
+La industria de tecnología está mudando casi todo a un system on a chip debido a
+
+00:10:03.680 --> 00:10:05.080
+que son más eficientes.
+
+00:10:05.080 --> 00:10:09.160
+Por ejemplo, acá adentro en un teléfono inteligente o en un smartwatch va a haber
+
+00:10:09.160 --> 00:10:10.340
+un system on a chip.
+
+00:10:10.340 --> 00:10:14.560
+En esos anillos que son sensores de salud hay un system on a chip.
+
+00:10:14.560 --> 00:10:18.200
+En tu automóvil, en el sistema de entretenimiento hay un system on a chip.
+
+00:10:18.200 --> 00:10:21.600
+Y la arquitectura de estos chips en ocasiones agrega cosas completamente
+
+00:10:21.600 --> 00:10:25.080
+nuevas que no existen en la computación de escritorio,
+
+00:10:25.080 --> 00:10:29.520
+como las unidades de procesamiento neuronal, las NPUs o Neural Processing
+
+00:10:29.520 --> 00:10:30.280
+Units.
+
+00:10:30.280 --> 00:10:33.720
+Apple es un pionero de esto, pero ahora todos los fabricantes lo están haciendo.
+
+00:10:33.720 --> 00:10:37.320
+Es un chip que, como la GPU, hace procesamiento paralelo.
+
+00:10:37.320 --> 00:10:40.240
+Pero recuerda que GPU significa Graphic Processing Unit,
+
+00:10:40.240 --> 00:10:41.760
+la unidad de procesamiento gráfico.
+
+00:10:41.760 --> 00:10:43.240
+No fue diseñada para eso.
+
+00:10:43.240 --> 00:10:46.680
+Hay nuevos chips, inicialmente inventados por Google para servidores,
+
+00:10:46.680 --> 00:10:51.440
+llamados TPU, Tensor Processor Units, que también se están colocando dentro de los
+
+00:10:51.440 --> 00:10:54.320
+teléfonos porque los teléfonos empiezan a necesitar hacer uso de inteligencia
+
+00:10:54.320 --> 00:10:55.280
+artificial.
+
+00:10:55.280 --> 00:10:59.200
+Cuando tú haces un dictado de voz en el teléfono, cuando usas asistentes,
+
+00:10:59.200 --> 00:11:02.600
+estás haciendo un uso de Machine Learning, de inteligencia artificial.
+
+00:11:02.600 --> 00:11:07.120
+Cuando el teléfono te coloca filtros en WhatsApp o en Instagram o en Snapchat,
+
+00:11:07.120 --> 00:11:08.720
+esto es inteligencia artificial.
+
+00:11:08.720 --> 00:11:12.720
+Y usan estas NPUs que vienen integradas en el chip completo.
+
+00:11:12.720 --> 00:11:17.200
+Las CPUs que están dentro de un sistema de chip son muy similares a la CPU de una
+
+00:11:17.200 --> 00:11:18.440
+computadora normal.
+
+00:11:18.440 --> 00:11:22.040
+Tienen igual procesamiento por gigahertz, tienen las mismas unidades,
+
+00:11:22.040 --> 00:11:23.440
+incluso tienen núcleos.
+
+00:11:23.440 --> 00:11:27.720
+De hecho, hoy en día es mucho más común ver multinúcleos en el chip de un
+
+00:11:27.720 --> 00:11:29.840
+teléfono que en el chip de una computadora.
+
+00:11:29.840 --> 00:11:32.640
+Los sistemas de chip tienen que tener hasta 16 núcleos,
+
+00:11:32.640 --> 00:11:36.840
+donde típicamente en las computadoras de arquitectura x86 veamos cuatro a ocho
+
+00:11:36.840 --> 00:11:37.440
+núcleos.
+
+00:11:37.440 --> 00:11:40.040
+A medida que la inteligencia artificial captura todo el planeta,
+
+00:11:40.040 --> 00:11:43.520
+empezamos a tener una hiper optimización de cosas distintas.
+
+00:11:43.520 --> 00:11:46.320
+La inteligencia artificial está conectada directamente a plantas de energía
+
+00:11:46.320 --> 00:11:49.960
+nuclear, así que el problema de la energía no es el problema que creemos.
+
+00:11:49.960 --> 00:11:53.560
+Nuestro problema es más de memoria y de velocidad de procesamiento.
+
+00:11:53.560 --> 00:11:56.760
+Resulta que los sistemas de chip también son ideales para esto,
+
+00:11:56.760 --> 00:12:02.520
+porque en el modelo anterior la GPU y la memoria estaban aparte y en el modelo
+
+00:12:02.520 --> 00:12:08.320
+nuevo el procesador de un iPhone comparte la memoria entre la CPU,
+
+00:12:08.320 --> 00:12:12.400
+la GPU y la NPU, el procesador neural de inteligencia artificial.
+
+00:12:12.400 --> 00:12:15.480
+Así que cuando el sistema operativo no necesita tanta RAM,
+
+00:12:15.480 --> 00:12:19.600
+esa RAM la puede aprovechar por completo la inteligencia artificial,
+
+00:12:19.600 --> 00:12:21.920
+haciendo estos sistemas mucho más eficientes.
+
+00:12:21.920 --> 00:12:27.240
+Durante el 2025, China tuvo un momento en el que venció a OpenAI,
+
+00:12:27.240 --> 00:12:31.120
+aprovechándose de esta característica para poder crear modelos de inteligencia
+
+00:12:31.120 --> 00:12:33.880
+artificial que corran en local en laptops.
+
+00:12:33.880 --> 00:12:35.640
+Y es parte de la razón por la que Apple,
+
+00:12:35.640 --> 00:12:38.560
+a pesar de estar atrás en la carrera de inteligencia artificial,
+
+00:12:38.560 --> 00:12:41.040
+sigue constantemente liderando el desarrollo de inteligencia artificial
+
+00:12:41.040 --> 00:12:44.640
+local por los system on a chip y su arquitectura de memoria unificada.
+
+00:12:44.640 --> 00:12:46.640
+De inteligencia artificial se puede hablar mucho más.
+
+00:12:46.640 --> 00:12:49.960
+El system on a chip es solo un componente de una gran cantidad de cosas,
+
+00:12:49.960 --> 00:12:52.160
+pero eso viene dentro de poco en el curso de Fundamentos de Ingeniería de
+
+00:12:52.160 --> 00:12:53.720
+Software.
+

subir/fixed/Curso de Fundamentos de Ingeniería de Software/01-Computación Básica/10-GPUs Procesadores gráficos y de AI.mp4

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

subir/fixed/Curso de Fundamentos de Ingeniería de Software/01-Computación Básica/10-GPUs Procesadores gráficos y de AI.vtt

@@ -0,0 +1,620 @@
+WEBVTT
+
+00:00:00.000 --> 00:00:08.760
+Las primeras computadoras no tenían pantalla, las primeras computadoras cuando tú les colocabas datos y hacías cálculos de cómputo, te imprimían los cálculos.
+
+00:00:08.760 --> 00:00:17.320
+Las primeras pantallas realmente no eran de computadoras, eran un instrumento electrónico para ver las ondas electromagnéticas llamada osciloscopio.
+
+00:00:17.320 --> 00:00:27.560
+Y unos ingenieros encontraron cómo usar la imagen del osciloscopio para colocar dos palitos y una bolita que rebotaba y así nace el primer videojuego de la historia, Pong.
+
+00:00:27.560 --> 00:00:35.240
+Desde ese momento, los videojuegos empezaron a usar la computación para empujar cada vez más lo que era posible a nivel gráfico.
+
+00:00:35.240 --> 00:00:39.240
+Primero hubo gráficos de videojuego antes de que hubieran sistemas operativos gráficos.
+
+00:00:39.240 --> 00:00:47.440
+En sistemas UNIX o en DOS, uno podía jugar juegos como Tetris, Prince of Persia, sin necesidad de tener todavía ventanas,
+
+00:00:47.440 --> 00:00:54.240
+porque cargaban cada una de estas pantallas y eran juegos muy sencillos que llevaban al máximo la capacidad de los chips.
+
+00:00:54.240 --> 00:00:59.520
+Por décadas, si no fuera por los videojuegos, no habríamos llevado los chips a su máximo nivel.
+
+00:00:59.520 --> 00:01:08.480
+Y como estábamos llevando estos chips a su máximo nivel, empezó a existir una industria que creaba chips específicamente para poner a correr esos gráficos,
+
+00:01:08.480 --> 00:01:14.880
+para diseño gráfico, para producción audiovisual de efectos especiales, pero sobre todo para videojuegos.
+
+00:01:14.880 --> 00:01:18.800
+Esos chips se llaman Unidades de Procesamiento Gráfico o GPUs.
+
+00:01:18.800 --> 00:01:21.160
+¿Cuál es la diferencia entre una CPU y una GPU?
+
+00:01:21.160 --> 00:01:26.680
+Como ya hemos visto en este curso, las CPUs procesan de manera seria la información a través de ciclos,
+
+00:01:26.680 --> 00:01:31.240
+y tienen millones de transistores que hacen cálculos matemáticos hipercomplejos,
+
+00:01:31.240 --> 00:01:34.600
+porque eso es lo que se necesita para correr una hoja de cálculo en Excel,
+
+00:01:34.600 --> 00:01:38.000
+eso es lo que se necesita para los cálculos que necesitan navegar una página web,
+
+00:01:38.000 --> 00:01:40.680
+y todo lo que hacemos en una computadora normal.
+
+00:01:40.680 --> 00:01:47.840
+Una GPU realmente son muchísimos, muchísimos núcleos de procesadores chiquitos,
+
+00:01:47.840 --> 00:01:55.760
+que hacen muchos menos cálculos con mucho menos poder, pero como son muchísimos núcleos, los hacen al mismo tiempo.
+
+00:01:55.760 --> 00:02:04.400
+Representar una imagen en pantalla es representar un cálculo de una matriz de millones de puntos de luz, conocida como pixeles.
+
+00:02:04.400 --> 00:02:12.760
+Cada uno de esos puntos tiene que calcular cuánto va a ser el brillo que tienen a partir de prender el rojo, el verde o el azul,
+
+00:02:12.760 --> 00:02:15.320
+y ese brillo tiene que calcularse al mismo tiempo.
+
+00:02:15.320 --> 00:02:20.440
+¿Recuerdan en el pasado que algunas imágenes cargaban como si fuera una línea detrás de otra?
+
+00:02:20.440 --> 00:02:23.360
+Eso es procesamiento serial, lo que haría una CPU.
+
+00:02:23.360 --> 00:02:30.000
+Que la imagen de repente cargue y vaya cambiando dinámicamente es procesamiento paralelo, esa es la magia de una GPU.
+
+00:02:30.000 --> 00:02:34.520
+Tú puedes ver los pixeles, los pixeles de un teléfono, sobre todo un teléfono moderno,
+
+00:02:34.520 --> 00:02:40.920
+ese rojo, verde y azul, son muy chiquitos porque son microscópicos, por más de que acerques el ojo, no los vas a alcanzar a ver.
+
+00:02:40.960 --> 00:02:45.480
+Pero si tienes un monitor de toda la vida, uno de estos monitores que no tiene tanta resolución,
+
+00:02:45.480 --> 00:02:50.760
+puedes agarrar el monitor y acercar los ojos mucho, mucho, mucho a la pantalla mientras está prendida
+
+00:02:50.760 --> 00:02:54.640
+y vas a alcanzar a ver las líneas de rojo, verde y azul con tus ojos humanos.
+
+00:02:54.640 --> 00:03:01.600
+NVIDIA y ATI, que luego fue adquirida por AMD, crearon esta industria de las tarjetas gráficas.
+
+00:03:01.600 --> 00:03:06.440
+De hecho, si no fuera por esa industria, no habría crecido la industria de las consolas de videojuegos.
+
+00:03:06.440 --> 00:03:11.680
+Una consola de videojuegos, en esencia, es una computadora que tiene todas las partes de una computadora por dentro,
+
+00:03:11.680 --> 00:03:17.200
+pero cuyo sistema operativo está específicamente optimizado para la reproducción de videojuegos,
+
+00:03:17.200 --> 00:03:19.800
+y sus chips incluyen GPUs, por supuesto.
+
+00:03:19.800 --> 00:03:24.000
+Cuando tuvimos la clase de sistemas operativos, aprendimos de interrupciones,
+
+00:03:24.000 --> 00:03:28.480
+estos mecanismos que tiene el sistema operativo para darle prioridad a algunos procesos contra otros.
+
+00:03:28.480 --> 00:03:32.800
+Por eso, por ejemplo, cuando tu computadora está muy colgada haciendo un proceso muy complejo,
+
+00:03:32.800 --> 00:03:37.920
+tu mouse se puede mover a alta velocidad, porque el mouse tiene una alta prioridad en la jerarquía.
+
+00:03:37.920 --> 00:03:44.920
+Cuando se procesa una pantalla, imagínate que la GPU se cuelgue y solamente tengas imagen en el 75% de la pantalla
+
+00:03:44.920 --> 00:03:47.640
+y el resto se quede quieto. Sería extraño, ¿verdad?
+
+00:03:47.640 --> 00:03:52.880
+Así que las GPUs fueron originalmente diseñadas para que toda la pantalla tenga la misma prioridad,
+
+00:03:52.880 --> 00:03:55.320
+a través de un sistema que se conoce como pipelines.
+
+00:03:55.320 --> 00:03:59.160
+En resumen, los primeros circuitos de GPU eran circuitos sencillos,
+
+00:03:59.160 --> 00:04:02.160
+donde simplemente estaban encargados de sectores de la pantalla.
+
+00:04:02.160 --> 00:04:06.440
+Todos los sectores de la pantalla tienen la misma prioridad y todos tienen que representar una imagen.
+
+00:04:06.440 --> 00:04:09.480
+No eran nada versátiles de programar, pero por la ley de Moore,
+
+00:04:09.480 --> 00:04:13.080
+a medida que aumentaba exponencialmente la complejidad de los transistores,
+
+00:04:13.080 --> 00:04:19.520
+empezaron a emerger características como la característica de generar texturas
+
+00:04:19.520 --> 00:04:24.320
+y se programaron shaders y luces y cálculos de física,
+
+00:04:24.320 --> 00:04:28.760
+porque todo lo que necesitaba procesamiento paralelo, como pasa mucho en los videojuegos,
+
+00:04:28.760 --> 00:04:35.000
+se podía pasar por estos cientos de miles de núcleos que hacen cálculos paralelos de alta velocidad.
+
+00:04:35.000 --> 00:04:37.440
+Y emergió un nuevo tipo de computación paralela,
+
+00:04:37.440 --> 00:04:41.280
+que es la forma en la que funciona toda la industria de los efectos especiales,
+
+00:04:41.280 --> 00:04:42.880
+de los videojuegos, de la animación.
+
+00:04:42.880 --> 00:04:47.520
+Pero como necesita nunca trabarse, no puede usar la memoria RAM tradicional
+
+00:04:47.520 --> 00:04:49.880
+que en una computadora está muy lejos del chip.
+
+00:04:49.880 --> 00:04:53.080
+Esto es mucho antes de los System on a Chip, que tienen todo integrado.
+
+00:04:53.080 --> 00:04:58.120
+Así que las GPUs son tarjetas que, además de tener estos procesadores gráficos,
+
+00:04:58.120 --> 00:05:01.120
+tienen una memoria especial independiente.
+
+00:05:01.120 --> 00:05:05.840
+Esa memoria se conoce como VRAM y es la memoria de RAM de video,
+
+00:05:05.840 --> 00:05:09.920
+una memoria volátil específicamente para esa computación paralela.
+
+00:05:09.920 --> 00:05:13.680
+Así que cuando uno empieza a jugar videojuegos, uno carga datos en la VRAM.
+
+00:05:13.680 --> 00:05:18.840
+Ahí es donde se cargan las texturas de tu videojuego, los polígonos y todos esos cálculos de física que vas a usar
+
+00:05:18.840 --> 00:05:20.480
+cuando estás jugando un juego tridimensional.
+
+00:05:20.480 --> 00:05:23.000
+¿Qué otras cosas requieren procesamiento paralelo?
+
+00:05:23.000 --> 00:05:24.840
+Por ejemplo, el mundo.
+
+00:05:24.840 --> 00:05:30.520
+Cuando tú quieres modelar el sistema de las nubes para poder predecir el clima,
+
+00:05:30.520 --> 00:05:34.040
+pues eso es el procesamiento paralelo de muchísimas variables al mismo tiempo.
+
+00:05:34.040 --> 00:05:37.320
+Así que las GPUs eran ideales para simulación.
+
+00:05:37.320 --> 00:05:43.360
+Hubo una época en la que investigadores que creaban supercomputadoras para simulaciones de física,
+
+00:05:43.360 --> 00:05:49.560
+de estrellas, agujeros negros, etcétera, se dieron cuenta que el chip del PlayStation 3,
+
+00:05:49.560 --> 00:05:54.400
+un chip creado por IBM que combinaba CPU y GPU para los videojuegos de PlayStation 3,
+
+00:05:54.400 --> 00:05:56.600
+era increíblemente eficiente.
+
+00:05:56.600 --> 00:05:59.880
+Y como en el PlayStation 3 se puede instalar Linux de toda la vida,
+
+00:05:59.880 --> 00:06:06.040
+empezaron a comprar PlayStation 3 en masa y a crear clústeres de PlayStation con Linux
+
+00:06:06.040 --> 00:06:09.520
+para hacer simulaciones y fabricar supercomputadoras.
+
+00:06:09.520 --> 00:06:12.120
+Mucho más barato de lo que cuesta una supercomputadora.
+
+00:06:12.120 --> 00:06:16.840
+Porque al final del día, un videojuego no es más que una simulación del mundo real.
+
+00:06:16.840 --> 00:06:19.160
+Así que me servía perfecto para la física.
+
+00:06:19.160 --> 00:06:23.200
+Porque el dinero, Sony, Microsoft con el Xbox o Nintendo con...
+
+00:06:23.200 --> 00:06:26.880
+Bueno, Nintendo es una excepción, la verdad, Nintendo sí hace plata con las consolas.
+
+00:06:26.880 --> 00:06:30.480
+Pero Sony y Microsoft no hacen dinero con el PlayStation o con el Xbox.
+
+00:06:30.480 --> 00:06:34.600
+Lo venden a pérdida porque ganan dinero con la venta de los videojuegos.
+
+00:06:34.600 --> 00:06:36.840
+PlayStation 3 era vendido a pérdida.
+
+00:06:36.840 --> 00:06:40.560
+Así que PlayStation estaba perdiendo dinero haciendo todas estas consolas
+
+00:06:40.560 --> 00:06:44.480
+para las que nunca se iban a comprar videojuegos porque las estaban usando científicos
+
+00:06:44.480 --> 00:06:47.440
+y pues cerraron el chorro y dejaron de permitir esto.
+
+00:06:47.440 --> 00:06:50.360
+Pero por un momento mágico, por un momento mágico,
+
+00:06:50.360 --> 00:06:52.800
+la computación científica corría en PlayStation.
+
+00:06:52.800 --> 00:06:56.280
+La inteligencia artificial también es procesamiento paralelo.
+
+00:06:56.280 --> 00:07:00.720
+Cuando tú usas un modelo de lenguaje de inteligencia artificial para generar un texto,
+
+00:07:00.720 --> 00:07:05.040
+el modelo de lenguaje empieza a recorrer un árbol gigantesco
+
+00:07:05.040 --> 00:07:08.560
+de la estructura del lenguaje humano con el que fue entrenado.
+
+00:07:08.560 --> 00:07:11.800
+Y trata de encontrar diferentes caminos para responder una pregunta
+
+00:07:11.800 --> 00:07:15.640
+que tú le haces a ChatGPT o a DeepSeek o a Cloud o a Gemini
+
+00:07:15.640 --> 00:07:18.360
+o al modelo que estés usando en el momento en el que estés viendo este curso.
+
+00:07:18.360 --> 00:07:24.440
+El punto es que ese procesamiento paralelo ocurre en GPUs originalmente,
+
+00:07:24.440 --> 00:07:26.800
+pero luego hemos empezado a usar chips especializados,
+
+00:07:26.800 --> 00:07:28.160
+pero eso viene más adelante.
+
+00:07:28.160 --> 00:07:31.440
+Inicialmente, los primeros modelos de inteligencia artificial
+
+00:07:31.440 --> 00:07:34.680
+antes de la superinteligencia fueron entrenados en GPUs.
+
+00:07:34.680 --> 00:07:40.120
+Los autónomos autónomos como los Tesla o Waymo de Google usan GPUs
+
+00:07:40.120 --> 00:07:45.080
+porque así como una GPU tiene que procesar al mismo tiempo cada píxel de una pantalla,
+
+00:07:45.080 --> 00:07:50.520
+un automóvil usa las cámaras y los radares que tiene en el marco del automóvil,
+
+00:07:50.520 --> 00:07:53.920
+en su estructura, para capturar imágenes del mundo exterior.
+
+00:07:53.920 --> 00:07:56.720
+Esa captura de imágenes tiene que ser procesada en tiempo real
+
+00:07:56.720 --> 00:07:59.560
+para convertirla en los ponígonos tridimensionales
+
+00:07:59.560 --> 00:08:02.280
+que le permiten a un algoritmo de inteligencia artificial
+
+00:08:02.280 --> 00:08:05.440
+decidir si el auto va a frenar, acelerar o moverse.
+
+00:08:05.440 --> 00:08:09.000
+Sin GPUs, ese procesamiento paralelo de alta velocidad,
+
+00:08:09.000 --> 00:08:12.320
+de cálculos relativamente simples, pero millones al mismo tiempo,
+
+00:08:12.320 --> 00:08:13.200
+no sería posible.
+
+00:08:13.200 --> 00:08:17.640
+Las CPUs normales se programan con un lenguaje ensamblador.
+
+00:08:17.640 --> 00:08:21.480
+Ese lenguaje es el que arranca el kernel y el que habla el sistema operativo.
+
+00:08:21.480 --> 00:08:27.080
+Las aplicaciones se programan en lenguajes como C++, Python, Visual Basic, entre otros.
+
+00:08:27.080 --> 00:08:30.720
+Pero todos esos lenguajes compilan al lenguaje ensamblador de la CPU.
+
+00:08:30.720 --> 00:08:32.800
+Las GPUs tienen algo muy parecido.
+
+00:08:32.800 --> 00:08:36.560
+Y fabricantes como Nvidia han creado lenguajes intermedios
+
+00:08:36.560 --> 00:08:39.760
+para que los programadores le hablen al metal,
+
+00:08:39.760 --> 00:08:42.440
+para que puedan programar el chip de la GPU.
+
+00:08:42.440 --> 00:08:46.200
+El más popular en este momento se llama CUDA de Nvidia.
+
+00:08:46.200 --> 00:08:48.480
+Inicialmente pensaba para videojuegos,
+
+00:08:48.480 --> 00:08:52.840
+CUDA es parte de la razón por la que la revolución de la inteligencia artificial es posible.
+
+00:08:52.840 --> 00:08:55.720
+Porque permite hacer estos cálculos masivos
+
+00:08:55.720 --> 00:08:59.880
+reprogramando el comportamiento de chips que originalmente fueron pensados
+
+00:08:59.880 --> 00:09:00.840
+para mover pixeles.
+
+00:09:00.840 --> 00:09:05.520
+Las GPUs también se programan y se diseñan a nivel físico de hardware
+
+00:09:05.520 --> 00:09:07.600
+con consideraciones distintas.
+
+00:09:07.600 --> 00:09:09.880
+La CPU, que es el procesador que arranca el sistema operativo,
+
+00:09:09.880 --> 00:09:13.800
+está en el corazón de la tarjeta madre de una computadora
+
+00:09:13.800 --> 00:09:16.200
+o de la tarjeta central de un teléfono.
+
+00:09:16.200 --> 00:09:21.440
+Pero la GPU se conecta a alta velocidad a través de un puerto que se llama PCI-E,
+
+00:09:21.440 --> 00:09:24.080
+que es un puerto, es una serie de muesquitas
+
+00:09:24.080 --> 00:09:27.680
+que se conectan directamente a la electrónica de la tarjeta madre.
+
+00:09:27.680 --> 00:09:31.440
+En un teléfono o en una computadora de Apple que tienen System on a Chip,
+
+00:09:31.440 --> 00:09:35.400
+las GPUs directamente están pegadas a la CPU en el System on a Chip,
+
+00:09:35.400 --> 00:09:36.880
+como lo vimos en la clase anterior.
+
+00:09:36.880 --> 00:09:40.920
+En una computadora normal, la CPU tiene un ventilador o un sistema
+
+00:09:40.920 --> 00:09:43.840
+de refrigeramiento por agua que enfría la CPU.
+
+00:09:43.840 --> 00:09:47.480
+Pero las GPUs también se calientan, así que tienen sus propios sistemas
+
+00:09:47.480 --> 00:09:50.680
+de enfriamiento paralelo, sus propios ventiladores o su propia
+
+00:09:50.680 --> 00:09:51.920
+refrigeración de agua.
+
+00:09:51.920 --> 00:09:54.840
+En algunos casos, como en las computadoras de videojuegos más
+
+00:09:54.840 --> 00:09:57.920
+poderosas, o en las computadoras de render de efectos especiales,
+
+00:09:57.920 --> 00:10:02.160
+o en las supercomputadoras de simulación para efectos científicos,
+
+00:10:02.160 --> 00:10:04.440
+llegan a enfriarlas con aceite.
+
+00:10:04.440 --> 00:10:06.400
+El aceite no conduce la electricidad.
+
+00:10:06.400 --> 00:10:10.080
+Así que hay computadoras que se hunden en aceite para que el aceite
+
+00:10:10.080 --> 00:10:11.000
+disipe el calor.
+
+00:10:11.000 --> 00:10:13.840
+Más adelante vamos a hablar de codecs, que son codificadores de
+
+00:10:13.840 --> 00:10:17.160
+codificadores, un tipo de algoritmo de compresión y descompresión que
+
+00:10:17.160 --> 00:10:19.880
+es, por ejemplo, la forma en la que funciona el video.
+
+00:10:19.880 --> 00:10:24.040
+Los videos antes eran súper pesados y ahora son mucho más livianos.
+
+00:10:24.040 --> 00:10:26.960
+Antes teníamos Blu-rays y ahora tenemos YouTube y Netflix.
+
+00:10:26.960 --> 00:10:31.720
+Pero esos son algoritmos que gastan muchísimo de el chip.
+
+00:10:31.720 --> 00:10:34.320
+Y antes usaban la GPU y mucho antes la CPU.
+
+00:10:34.320 --> 00:10:39.360
+Ahora usan transistores especializados dentro de la GPU como instrucciones
+
+00:10:39.360 --> 00:10:42.760
+que solamente se encargan de codificar y decodificar video,
+
+00:10:42.760 --> 00:10:44.880
+usando mucho menos electricidad.
+
+00:10:44.880 --> 00:10:47.200
+Lo mismo pasa con la simulación de ciertos videojuegos.
+
+00:10:47.200 --> 00:10:48.520
+Los videojuegos empezaron, por ejemplo,
+
+00:10:48.520 --> 00:10:51.480
+a simular el comportamiento de los fotones del mundo real,
+
+00:10:51.480 --> 00:10:55.040
+el comportamiento de la luz, con una técnica llamada ray tracing,
+
+00:10:55.040 --> 00:10:57.640
+que inicialmente se programaba en código,
+
+00:10:57.640 --> 00:11:02.440
+pero ahora se crean el transistor en los chips y la GPU tiene unidades
+
+00:11:02.440 --> 00:11:04.440
+específicamente diseñadas para ray tracing.
+
+00:11:04.440 --> 00:11:06.440
+Con la inteligencia artificial pasa lo mismo.
+
+00:11:06.440 --> 00:11:08.160
+La inteligencia artificial es, en esencia,
+
+00:11:08.160 --> 00:11:11.760
+multiplicación de matrices y recorrido de árboles.
+
+00:11:11.760 --> 00:11:15.600
+Eso se puede programar en el chip y es la esencia de las unidades de
+
+00:11:15.600 --> 00:11:17.040
+procesamiento neural.
+
+00:11:17.040 --> 00:11:19.680
+Nvidia, por ejemplo, tiene unos chips que solo hacen eso,
+
+00:11:19.680 --> 00:11:20.800
+que vamos a ver más adelante.
+
+00:11:20.800 --> 00:11:24.400
+Antes de que la inteligencia artificial consumiera masivas cantidades de chips
+
+00:11:24.400 --> 00:11:27.600
+gráficos, lo hizo las criptomonedas.
+
+00:11:27.600 --> 00:11:31.800
+Bitcoin y casi todas las monedas que usan blockchain requieren hacer un tipo de
+
+00:11:31.800 --> 00:11:35.520
+cálculo matemático muy particular para que el blockchain funcione de manera
+
+00:11:35.520 --> 00:11:36.440
+cifrada.
+
+00:11:36.440 --> 00:11:40.040
+Ese cálculo es más amigable en procesamiento paralelo que en
+
+00:11:40.040 --> 00:11:41.280
+procesamiento serial.
+
+00:11:41.280 --> 00:11:43.160
+Así que aprovecha las GPUs.
+
+00:11:43.160 --> 00:11:47.560
+Y como Bitcoin recompensa con criptomonedas a las personas que hacen
+
+00:11:47.560 --> 00:11:50.320
+este proceso de ejecutar las ecuaciones matemáticas,
+
+00:11:50.320 --> 00:11:54.200
+llamado criptominería, se creó toda una industria de minería de Bitcoin,
+
+00:11:54.200 --> 00:11:58.600
+que es poner a correr estas GPUs al máximo en grandes granjas de servidores
+
+00:11:58.600 --> 00:12:02.200
+pegadas a granjas de hidroeléctricas, plantas de energía nuclear,
+
+00:12:02.200 --> 00:12:04.280
+energía basada en gas, etcétera.
+
+00:12:04.280 --> 00:12:07.800
+Hay países enteros que tienen cosas así, como por ejemplo El Salvador.
+
+00:12:07.800 --> 00:12:11.800
+Eso hizo que la demanda de chips aumentara justo antes de que llegara la
+
+00:12:11.800 --> 00:12:12.880
+inteligencia artificial.
+
+00:12:12.880 --> 00:12:16.880
+No es como que las GPUs hayan abandonado la industria de los videojuegos.
+
+00:12:16.880 --> 00:12:18.400
+Todavía hay mucha innovación.
+
+00:12:18.400 --> 00:12:22.840
+Valve, la empresa detrás de juegos como Portal, Half-Life y el sistema Steam,
+
+00:12:22.840 --> 00:12:26.840
+tiene un sistema operativo llamado SteamOS que reemplaza el sistema operativo que
+
+00:12:26.880 --> 00:12:30.480
+estás creando en tu computadora para maximizar el uso de recursos para un
+
+00:12:30.480 --> 00:12:31.320
+videojuego,
+
+00:12:31.320 --> 00:12:34.840
+de tal manera que tu computadora se vuelve en esencia una consola de videojuegos.
+
+00:12:34.840 --> 00:12:39.800
+También la realidad aumentada y la realidad virtual han aumentado la necesidad
+
+00:12:39.800 --> 00:12:44.360
+de procesadores gráficos porque en cada ojo estás procesando dos pantallas
+
+00:12:44.360 --> 00:12:48.800
+distintas para crear esa sensación de tridimensionalidad y presencia que tiene
+
+00:12:48.800 --> 00:12:49.840
+la realidad virtual.
+
+00:12:49.840 --> 00:12:53.640
+Así que aún sigue habiendo mucha innovación gráfica,
+
+00:12:53.640 --> 00:12:57.200
+solo que la inteligencia artificial lo absorbió mucho y todavía tenemos mucho
+
+00:12:57.200 --> 00:12:58.680
+de procesamiento científico que hacer.
+
+00:12:58.680 --> 00:13:03.000
+Las GPUs son un procesador revolucionario que avanzó la ciencia humana.
+