Upload batch from C CLI

Uploaded via hf-downloader C client

.gitattributes

@@ -203,3 +203,29 @@ subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]b
 subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/04-Constantes[[:space:]]y[[:space:]]Listas[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]y[[:space:]]Manipulación[[:space:]]Básica.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/05-Operadores[[:space:]]en[[:space:]]C[[:space:]]Aritméticos[[:space:]]Comparativos[[:space:]]y[[:space:]]Lógicos.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/06-Manejo[[:space:]]de[[:space:]]Entrada[[:space:]]y[[:space:]]Salida[[:space:]]de[[:space:]]Datos[[:space:]]con[[:space:]]IOStream[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/04-Control[[:space:]]de[[:space:]]flujo/01-Condicionales[[:space:]]en[[:space:]]C[[:space:]]if[[:space:]]else[[:space:]]else[[:space:]]if[[:space:]]y[[:space:]]operadores[[:space:]]lógicos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/04-Control[[:space:]]de[[:space:]]flujo/02-Condicionales[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]de[[:space:]]la[[:space:]]Sentencia[[:space:]]Switch[[:space:]]Case.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/04-Control[[:space:]]de[[:space:]]flujo/03-Ciclos[[:space:]]For[[:space:]]en[[:space:]]C[[:space:]]Cómo[[:space:]]Iterar[[:space:]]Listas[[:space:]]y[[:space:]]Rangos[[:space:]]Numéricos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/04-Control[[:space:]]de[[:space:]]flujo/04-Ciclos[[:space:]]While[[:space:]]y[[:space:]]Do[[:space:]]While[[:space:]]en[[:space:]]C[[:space:]]Ejemplos[[:space:]]Prácticos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/05-Funciones/01-Funciones[[:space:]]en[[:space:]]C[[:space:]]creación[[:space:]]uso[[:space:]]y[[:space:]]valores[[:space:]]por[[:space:]]defecto.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/05-Funciones/02-Uso[[:space:]]de[[:space:]]la[[:space:]]Biblioteca[[:space:]]String[[:space:]]en[[:space:]]C[[:space:]]para[[:space:]]Manejo[[:space:]]de[[:space:]]Cadenas[[:space:]]de[[:space:]]Texto.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/06-Próximos[[:space:]]pasos/01-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/01-Introducción/01-Diseño[[:space:]]Eficiente[[:space:]]para[[:space:]]Programadores[[:space:]]Herramientas[[:space:]]y[[:space:]]Conceptos[[:space:]]Básicos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/01-Introducción/01-slidesdisenoparaprogram_80421720-f8bc-4435-9886-a145e6adbb5a.pdf filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/02-Entender[[:space:]]los[[:space:]]Fundamentos[[:space:]]del[[:space:]]diseño/01-Desarrollo[[:space:]]de[[:space:]]la[[:space:]]creatividad[[:space:]]para[[:space:]]diseño[[:space:]]y[[:space:]]aplicaciones[[:space:]]web.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/02-Entender[[:space:]]los[[:space:]]Fundamentos[[:space:]]del[[:space:]]diseño/02-Conceptos[[:space:]]Básicos[[:space:]]de[[:space:]]Composición[[:space:]]en[[:space:]]Diseño[[:space:]]Gráfico.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/02-Entender[[:space:]]los[[:space:]]Fundamentos[[:space:]]del[[:space:]]diseño/03-Responsive[[:space:]]Design[[:space:]]Metodologías[[:space:]]y[[:space:]]Prácticas[[:space:]]Esenciales.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/02-Entender[[:space:]]los[[:space:]]Fundamentos[[:space:]]del[[:space:]]diseño/04-Accesibilidad[[:space:]]Web[[:space:]]Mejores[[:space:]]Prácticas[[:space:]]y[[:space:]]Consejos[[:space:]]Básicos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/02-Entender[[:space:]]los[[:space:]]Fundamentos[[:space:]]del[[:space:]]diseño/05-Creación[[:space:]]de[[:space:]]un[[:space:]]Brief[[:space:]]para[[:space:]]Aplicaciones[[:space:]]de[[:space:]]Restaurantes.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/03-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]Experiencia[[:space:]]de[[:space:]]usuario/01-Diseño[[:space:]]UX[[:space:]]Creación[[:space:]]de[[:space:]]Prototipos[[:space:]]y[[:space:]]Flujos[[:space:]]de[[:space:]]Usuario.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/03-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]Experiencia[[:space:]]de[[:space:]]usuario/02-Creación[[:space:]]de[[:space:]]Diagramas[[:space:]]de[[:space:]]Flujo[[:space:]]para[[:space:]]Diseño[[:space:]]de[[:space:]]Aplicaciones.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/03-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]Experiencia[[:space:]]de[[:space:]]usuario/03-Creación[[:space:]]de[[:space:]]Wireframes[[:space:]]para[[:space:]]Diseño[[:space:]]UX[[:space:]]Básico.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/01-Diseño[[:space:]]UI[[:space:]]Estilos[[:space:]]Visuales[[:space:]]y[[:space:]]Diferencias[[:space:]]con[[:space:]]UX.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/02-Creación[[:space:]]de[[:space:]]Mood[[:space:]]Boards[[:space:]]para[[:space:]]Aplicaciones[[:space:]]Visuales.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/03-Psicología[[:space:]]del[[:space:]]Color[[:space:]]y[[:space:]]su[[:space:]]Aplicación[[:space:]]en[[:space:]]Diseño[[:space:]]Web.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/04-Creación[[:space:]]de[[:space:]]Paletas[[:space:]]de[[:space:]]Color[[:space:]]para[[:space:]]Aplicaciones.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/05-Selección[[:space:]]y[[:space:]]Uso[[:space:]]de[[:space:]]Tipografías[[:space:]]en[[:space:]]Diseño[[:space:]]Web.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/06-Creación[[:space:]]de[[:space:]]Grillas[[:space:]]Responsivas[[:space:]]con[[:space:]]CSS[[:space:]]Grid[[:space:]]y[[:space:]]SASS.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/07-Desarrollo[[:space:]]de[[:space:]]Aplicaciones[[:space:]]Web[[:space:]]con[[:space:]]Componentes[[:space:]]Reutilizables.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/08-Implementación[[:space:]]de[[:space:]]Themes[[:space:]]en[[:space:]]Aplicaciones[[:space:]]Web[[:space:]]con[[:space:]]CSS[[:space:]]y[[:space:]]SAS.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Diseño[[:space:]]para[[:space:]]Developers/04-Aprender[[:space:]]sobre[[:space:]]Diseño[[:space:]]de[[:space:]]interfaz[[:space:]]de[[:space:]]usuario/09-Selección[[:space:]]y[[:space:]]uso[[:space:]]adecuado[[:space:]]de[[:space:]]imágenes[[:space:]]para[[:space:]]la[[:space:]]web.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso de C Básico/03-Conceptos básicos/06-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/entrada-salida-datos

subir/Curso de C Básico/04-Control de flujo/01-Condicionales en C if else else if y operadores lógicos.mp4

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

subir/Curso de C Básico/04-Control de flujo/01-Condicionales en C if else else if y operadores lógicos.vtt

@@ -0,0 +1,646 @@
+WEBVTT
+
+00:00:03.120 --> 00:00:05.279
+Vamos a hablar sobre las condicionales en C
+
+00:00:05.279 --> 00:00:08.020
+más más. Como sabes, los lenguajes de programación
+
+00:00:08.639 --> 00:00:11.540
+tienen diferentes formas de realizar toma de decisiones
+
+00:00:11.759 --> 00:00:14.320
+durante la ejecución de nuestros programas. Esto es
+
+00:00:14.320 --> 00:00:16.965
+para que la computadora no sea solo una
+
+00:00:16.965 --> 00:00:20.564
+computadora que realice cálculos de una forma tonta,
+
+00:00:20.564 --> 00:00:22.884
+sino que además pueda tomar decisiones sobre los
+
+00:00:22.884 --> 00:00:26.485
+mismos y poder implementar algoritmos más complejos y
+
+00:00:26.485 --> 00:00:29.220
+completos. Vamos a ver un ejemplo de código.
+
+00:00:29.460 --> 00:00:31.939
+A continuación, te muestro el mismo código base
+
+00:00:31.939 --> 00:00:33.640
+que hemos estado utilizando en todos nuestros ejercicios
+
+00:00:34.100 --> 00:00:36.980
+y vamos a revisar nuestros primeros condicionales, pero
+
+00:00:36.980 --> 00:00:39.780
+para esto vamos a utilizar unas variables que
+
+00:00:39.780 --> 00:00:42.579
+son de tipo booleano, vamos a realizar operaciones
+
+00:00:42.579 --> 00:00:44.840
+booleanas con las que vamos a poder comparar
+
+00:00:45.755 --> 00:00:47.915
+si los valores dan verdadero o falso, ya
+
+00:00:47.915 --> 00:00:50.635
+que los condicionales necesitan de este tipo de
+
+00:00:50.635 --> 00:00:53.675
+valor para poder funcionar. Vamos a crear una
+
+00:00:53.675 --> 00:00:56.475
+variable de tipo booleano, por ejemplo, una que
+
+00:00:56.475 --> 00:01:00.900
+se llame resultado, y que va a almacenar
+
+00:01:00.900 --> 00:01:03.400
+las operaciones de ejemplo que vamos a realizar.
+
+00:01:03.780 --> 00:01:05.960
+Y el resultado lo vamos a mostrar en
+
+00:01:06.500 --> 00:01:13.335
+la salida de nuestra terminal. Ahora, ¿cuáles son
+
+00:01:13.335 --> 00:01:17.174
+las principales operaciones booleanas que conocemos? Pues, existen
+
+00:01:17.174 --> 00:01:21.354
+tres. Existe Ant, Or y Not. La operación
+
+00:01:21.814 --> 00:01:25.255
+Ant nos permite evaluar si dos elementos dan
+
+00:01:25.255 --> 00:01:28.268
+verdadero o falso. Sí va a dar verdadero
+
+00:01:28.268 --> 00:01:30.140
+o falso dependiendo de cuál sea su cómodo.
+
+00:01:30.140 --> 00:01:33.340
+Por ejemplo, si yo tengo un valor true,
+
+00:01:33.340 --> 00:01:37.100
+que es verdadero, y otro valor true, estos
+
+00:01:37.100 --> 00:01:40.539
+valores podrían ser operaciones que devuelvan verdadero o
+
+00:01:40.539 --> 00:01:44.035
+falso, no necesariamente la palabra true, pero supongamos
+
+00:01:44.035 --> 00:01:46.354
+que yo tengo de la izquierda una expresión
+
+00:01:46.354 --> 00:01:48.595
+que devuelve verdadero y a la derecha otra
+
+00:01:48.595 --> 00:01:51.815
+expresión que devuelve verdadero o falso. La operación
+
+00:01:52.115 --> 00:01:53.955
+and, que son estos dos símbolos de aquí,
+
+00:01:53.955 --> 00:01:56.450
+lo que va a hacer es realizar una
+
+00:01:56.450 --> 00:01:59.770
+validación, una verificación. Si los dos lados son
+
+00:01:59.770 --> 00:02:03.609
+verdaderos, entonces, devolverá verdadero. Si los dos lados
+
+00:02:03.609 --> 00:02:06.729
+son falsos, devolverá falso. Y si cualquiera de
+
+00:02:06.729 --> 00:02:09.050
+los dos lados es verdadero, no importando que
+
+00:02:09.050 --> 00:02:11.310
+el otro sea falso, va a devolver verdadero.
+
+00:02:11.985 --> 00:02:14.811
+Vamos a realizar la ejecución y vamos a
+
+00:02:14.811 --> 00:02:17.045
+observar que una vez que tenemos la salida,
+
+00:02:20.225 --> 00:02:22.865
+obtenemos el resultado de nuestra operación con el
+
+00:02:22.865 --> 00:02:27.210
+valor uno, que como sabemos significa verdadero. Otra
+
+00:02:27.210 --> 00:02:31.550
+operación booleana que funciona con nuestro nuestros condicionales
+
+00:02:31.930 --> 00:02:33.810
+es la posibilidad de evaluar si solo uno
+
+00:02:33.810 --> 00:02:37.050
+de los dos es verdadero. Por ejemplo, utilizando
+
+00:02:37.050 --> 00:02:39.530
+el símbolo de doble barra, que es el
+
+00:02:39.530 --> 00:02:42.285
+operador or, vamos a poder evaluar si tanto
+
+00:02:42.285 --> 00:02:44.285
+de la izquierda o de la derecha cualquiera
+
+00:02:44.285 --> 00:02:46.845
+de los dos es verdadero, el otro puede
+
+00:02:46.845 --> 00:02:49.245
+ser falso, siempre que haya uno verdadero, la
+
+00:02:49.245 --> 00:02:52.445
+operación or nos va a devolver verdadero, y
+
+00:02:52.445 --> 00:02:56.560
+vamos a ejecutarlo. La única forma en la
+
+00:02:56.560 --> 00:02:58.319
+que la operación or nos va a devolver
+
+00:02:58.319 --> 00:03:00.720
+falso es cuando los dos lados tengan un
+
+00:03:00.720 --> 00:03:04.159
+valor falso. En este caso, son las dos
+
+00:03:04.159 --> 00:03:07.200
+principales operaciones que existen, pero existe una tercera
+
+00:03:07.200 --> 00:03:08.795
+y última que vamos a ver, que es
+
+00:03:08.795 --> 00:03:10.555
+la operación NOT, y lo que va a
+
+00:03:10.555 --> 00:03:14.415
+hacer es invertir el valor lógico que hayamos
+
+00:03:15.595 --> 00:03:19.275
+puesto después de el símbolo de negación. En
+
+00:03:19.275 --> 00:03:21.435
+este caso, el símbolo de negación es este
+
+00:03:21.435 --> 00:03:24.230
+símbolo de admiración, y lo que va a
+
+00:03:24.230 --> 00:03:26.370
+hacer es que si obtiene un valor verdadero
+
+00:03:26.510 --> 00:03:28.190
+a su derecha, lo va a convertir en
+
+00:03:28.190 --> 00:03:31.470
+un verdadero, en un valor falso, y si
+
+00:03:31.470 --> 00:03:33.390
+obtiene un valor falso, lo va a convertir
+
+00:03:33.390 --> 00:03:36.910
+en un valor verdadero. Vamos a realizar la
+
+00:03:36.910 --> 00:03:40.055
+ejecución y listo. Tienes como true se convierte
+
+00:03:40.055 --> 00:03:44.695
+en cero, que es falso. Ahora que ya
+
+00:03:44.695 --> 00:03:48.295
+conocemos cómo funcionan las funciones lógicas, las operaciones
+
+00:03:48.295 --> 00:03:52.075
+lógicas, sabemos que estas nos permiten tomar decisiones.
+
+00:03:52.375 --> 00:03:54.890
+Por ejemplo, si una contraseña es igual a
+
+00:03:54.890 --> 00:03:57.770
+otra, eso devuelve verdadero. Si un número es
+
+00:03:57.770 --> 00:04:00.570
+mayor o menor que cierto otro número de
+
+00:04:00.570 --> 00:04:02.410
+una variable, eso también nos puede dar verdadero
+
+00:04:02.410 --> 00:04:06.590
+o falso. Entonces, todas estas condiciones las podemos
+
+00:04:07.050 --> 00:04:09.115
+utilizar para tomar decisiones en nuestro programa, y
+
+00:04:09.115 --> 00:04:12.395
+eso lo vamos a hacer utilizando if. Por
+
+00:04:12.395 --> 00:04:15.535
+ejemplo, supongamos que yo quiero utilizar un programa
+
+00:04:15.755 --> 00:04:18.154
+para evaluar si una persona puede votar en
+
+00:04:18.154 --> 00:04:21.755
+unas elecciones. Supongamos que la condición es que
+
+00:04:21.755 --> 00:04:25.410
+pueden votar solo personas entre dieciocho y cuarenta
+
+00:04:25.410 --> 00:04:29.090
+años. Para esto necesitaríamos una variable que va
+
+00:04:29.090 --> 00:04:31.090
+almacenar la edad de la persona. Vamos a
+
+00:04:31.090 --> 00:04:34.610
+crear una variable que se llame edad, que
+
+00:04:34.610 --> 00:04:37.570
+contenga, pues, cualquier edad que vayamos a poder
+
+00:04:37.570 --> 00:04:40.355
+introducir. La voy a inicializar como cero y
+
+00:04:40.355 --> 00:04:41.735
+luego se la voy a pedir al usuario.
+
+00:04:41.735 --> 00:04:47.955
+Le voy a poner c out, edad, dos
+
+00:04:47.955 --> 00:04:50.995
+puntos, y a continuación voy a hacer un
+
+00:04:50.995 --> 00:04:59.450
+same. De edad. De esta manera voy a
+
+00:04:59.450 --> 00:05:02.510
+pedirle al usuario su edad cuando ejecute el
+
+00:05:03.530 --> 00:05:06.664
+programa. Ahora, necesito realizar la primera validación, que
+
+00:05:06.664 --> 00:05:09.125
+es que sea mayor de dieciocho años. Para
+
+00:05:09.224 --> 00:05:12.025
+esto, puedo utilizar la palabra if de la
+
+00:05:12.025 --> 00:05:16.504
+siguiente manera. If es esta estructura que contiene
+
+00:05:16.504 --> 00:05:19.479
+entre paréntesis una condición y entre llaves el
+
+00:05:19.479 --> 00:05:21.080
+código que se va a ejecutar si esta
+
+00:05:21.080 --> 00:05:23.479
+condición se cumple. Si yo quiero evaluar si
+
+00:05:23.479 --> 00:05:25.639
+la persona es mayor de dieciocho años o
+
+00:05:25.639 --> 00:05:28.360
+de dieciocho años, entonces yo puedo poner un
+
+00:05:28.360 --> 00:05:32.985
+condicional que sea si edad es mayor o
+
+00:05:32.985 --> 00:05:37.625
+igual de dieciocho. Si esto es correcto, entonces
+
+00:05:37.625 --> 00:05:39.865
+yo dejaría a la persona votar, ¿no? Entonces
+
+00:05:39.865 --> 00:05:43.085
+puedo poner un mensaje de salida que diga,
+
+00:05:43.385 --> 00:05:50.880
+puedes votar. Y en caso de que yo
+
+00:05:50.880 --> 00:05:52.960
+quisiera decirle un error, de que no puede
+
+00:05:52.960 --> 00:05:55.440
+votar cuando no cumple con esta característica porque
+
+00:05:55.440 --> 00:05:57.835
+sea menor de edad, entonces yo puedo utilizar
+
+00:05:57.835 --> 00:06:01.355
+la palabra else. La palabra else me indica
+
+00:06:01.355 --> 00:06:02.875
+lo que sucede en caso de que el
+
+00:06:02.875 --> 00:06:06.395
+condicional no se cumpla. En este caso, podría
+
+00:06:06.395 --> 00:06:13.900
+ponerle un mensaje como no puedes votar. Si
+
+00:06:13.900 --> 00:06:18.140
+yo probara esto, podríamos ejecutarlo y nos va
+
+00:06:18.140 --> 00:06:20.060
+a pedir una edad. Supongamos que es una
+
+00:06:20.060 --> 00:06:23.660
+persona de diecinueve años, en este caso, nos
+
+00:06:23.660 --> 00:06:27.795
+diría, puedes votar. Pero, ¿qué pasaría si entra
+
+00:06:27.795 --> 00:06:29.555
+y trata de votar una persona que solo
+
+00:06:29.555 --> 00:06:32.755
+tenga quince años? En este caso, me diría
+
+00:06:32.755 --> 00:06:35.495
+que no puedo votar. Este es el funcionamiento
+
+00:06:35.515 --> 00:06:37.555
+esperado de nuestro programa, y esta es la
+
+00:06:37.555 --> 00:06:40.660
+forma en la que funcionan los condicionales. Pero,
+
+00:06:40.660 --> 00:06:43.139
+¿qué pasaría si yo quisiera validar la segunda
+
+00:06:43.139 --> 00:06:46.340
+condición que habíamos considerado? Que solamente pueden votar
+
+00:06:46.340 --> 00:06:49.060
+personas de hasta cuarenta años, es decir, cuarenta
+
+00:06:49.060 --> 00:06:52.820
+años, pero no más. Entonces, yo podría comenzar
+
+00:06:52.820 --> 00:06:56.125
+a agregar complejidad a mi programa y realizar
+
+00:06:56.125 --> 00:06:58.445
+dentro de, ok, ya tiene más de dieciocho
+
+00:06:58.445 --> 00:07:02.205
+años o dieciocho años cumplidos otra condición. Por
+
+00:07:02.205 --> 00:07:05.324
+ejemplo, podría agregar una condición que pregunte ahora
+
+00:07:05.324 --> 00:07:08.525
+por la edad máxima. Supongamos que ahora edad
+
+00:07:08.525 --> 00:07:11.639
+es igual a, es menor o igual a
+
+00:07:12.340 --> 00:07:16.360
+el máximo de edad permitido. En ese caso,
+
+00:07:16.420 --> 00:07:19.300
+podríamos decirle a la persona que puede votar,
+
+00:07:19.300 --> 00:07:21.960
+por eso yo voy a tomar este valor,
+
+00:07:22.740 --> 00:07:25.395
+este código, y lo voy a pegar aquí.
+
+00:07:25.715 --> 00:07:27.794
+Con esto le estaríamos diciendo que si la
+
+00:07:27.794 --> 00:07:29.875
+persona primero ya cumplió que es mayor de
+
+00:07:29.875 --> 00:07:32.115
+edad, ya tiene más de dieciocho años, y
+
+00:07:32.115 --> 00:07:35.074
+luego ya cumplió que es menor de cuarenta
+
+00:07:35.074 --> 00:07:38.139
+hoy máximo cuarenta, entonces puede votar, y en
+
+00:07:38.139 --> 00:07:40.620
+caso de que no, bueno, podría agregarle otro
+
+00:07:40.620 --> 00:07:46.220
+else que nos diga no puedes votar. De
+
+00:07:46.220 --> 00:07:49.520
+esta manera, yo estaría validando todos los puntos
+
+00:07:49.580 --> 00:07:53.685
+de mi ejercicio propuesto. Ahora, supongamos que es
+
+00:07:53.685 --> 00:07:56.085
+una persona que tiene cincuenta años, en el
+
+00:07:56.085 --> 00:07:57.764
+caso de ejemplo, le diría que no puede
+
+00:07:57.764 --> 00:08:01.285
+votar. Si volvemos a repetir el ejercicio, pero
+
+00:08:01.285 --> 00:08:04.780
+ahora introducimos una edad de diecinueve años, nos
+
+00:08:04.780 --> 00:08:08.180
+diría que puede votar. Este es el funcionamiento
+
+00:08:08.180 --> 00:08:10.540
+esperado, pero existe una forma un poco más
+
+00:08:10.540 --> 00:08:13.420
+organizada de realizar este tipo de condiciones, donde
+
+00:08:13.420 --> 00:08:16.140
+validamos una misma variable una y otra vez,
+
+00:08:16.140 --> 00:08:19.260
+o incluso podemos realizar múltiples validaciones de diferentes
+
+00:08:19.260 --> 00:08:23.325
+cosas. Y es para no anidar un if
+
+00:08:23.325 --> 00:08:26.045
+dentro de otro if. En este caso, tendríamos,
+
+00:08:26.045 --> 00:08:28.605
+si tuviéramos muchas otras cosas que validar, se
+
+00:08:28.605 --> 00:08:30.925
+iría agregando una complejidad a la hora de
+
+00:08:30.925 --> 00:08:33.405
+leer nuestro programa. Por lo tanto, se inventó
+
+00:08:33.405 --> 00:08:35.620
+una forma mucho más fácil y eficiente, que
+
+00:08:35.620 --> 00:08:39.020
+es utilizar else if. Con esto, yo tengo
+
+00:08:39.020 --> 00:08:40.819
+que cambiar un poco la lógica de mi
+
+00:08:40.819 --> 00:08:43.379
+programa para indicarle cuándo puede y cuándo no
+
+00:08:43.379 --> 00:08:46.740
+puede votar la persona. En este caso, tenemos
+
+00:08:46.740 --> 00:08:49.399
+primero que validar todas las cosas que no
+
+00:08:49.610 --> 00:08:52.658
+debería poder hacer, y si ya pasó todas
+
+00:08:52.658 --> 00:08:55.725
+las validaciones, entonces ya debería poder votar. En
+
+00:08:55.725 --> 00:08:58.084
+este caso, vamos a utilizar, por ejemplo, la
+
+00:08:58.084 --> 00:09:01.805
+primera condición para preguntar si es menor que
+
+00:09:01.805 --> 00:09:05.020
+dieciocho años. Si la persona es menor que
+
+00:09:05.020 --> 00:09:08.640
+dieciocho años, entonces le diríamos, no puedes votar,
+
+00:09:09.420 --> 00:09:13.360
+y si no, entonces pasaría al puedes votar.
+
+00:09:14.940 --> 00:09:17.740
+Esto funcionaría para validar que sea mayor de
+
+00:09:17.740 --> 00:09:22.925
+dieciocho años, pero ahora necesitamos validar la otra
+
+00:09:23.105 --> 00:09:25.585
+característica que es que sea menor de cuarenta,
+
+00:09:25.585 --> 00:09:29.345
+¿no? Entonces, podríamos agregarle otra condición y ahora
+
+00:09:29.345 --> 00:09:32.965
+sí utilizaríamos la magia de nuestro condicional combinando
+
+00:09:33.105 --> 00:09:34.610
+else con un nuevo if. En este caso,
+
+00:09:34.610 --> 00:09:37.230
+podríamos decirle, y si no fue lo anterior,
+
+00:09:38.329 --> 00:09:41.450
+hago otra pregunta que ahora sería sobre su
+
+00:09:41.450 --> 00:09:45.450
+edad menor de cuarenta años. Por ejemplo, si
+
+00:09:45.450 --> 00:09:46.830
+la persona, y y aquí vamos a validar
+
+00:09:46.830 --> 00:09:48.595
+lo que de error, en este caso, si
+
+00:09:48.595 --> 00:09:52.595
+la persona es mayor de cuarenta años, entonces
+
+00:09:52.595 --> 00:09:57.075
+si edad es mayor de cuarenta años y
+
+00:09:57.075 --> 00:09:59.475
+le volveríamos a dar un error que diga
+
+00:09:59.475 --> 00:10:02.210
+no puedes votar. Fíjate bien lo que pasa
+
+00:10:02.210 --> 00:10:05.250
+aquí. Primero, si la persona tiene menos de
+
+00:10:05.250 --> 00:10:08.070
+dieciocho años, le dices que no puedes votar.
+
+00:10:08.770 --> 00:10:11.490
+Si no, o sea, es mayor de dieciocho
+
+00:10:11.490 --> 00:10:13.890
+años, pero ahora le preguntas una nueva cosa,
+
+00:10:13.890 --> 00:10:16.591
+¿es mayor de cuarenta años? Si eso es
+
+00:10:16.591 --> 00:10:19.845
+verdad, entonces no puedes votar tampoco. Y si
+
+00:10:19.845 --> 00:10:23.605
+ninguna de las cosas anteriores sucedió, entonces ahora
+
+00:10:23.605 --> 00:10:26.665
+sí le dirás que puede votar, porque puedes
+
+00:10:26.805 --> 00:10:28.805
+asumir que cumplió con el rango de edad
+
+00:10:28.805 --> 00:10:31.709
+establecido. Vamos a realizar la ejecución de este
+
+00:10:32.009 --> 00:10:36.329
+programa con una edad de veinticuatro años, y
+
+00:10:36.329 --> 00:10:38.430
+el programa ahora te dice que puedes votar.
+
+00:10:39.050 --> 00:10:41.209
+¿Qué sucede si yo pongo una persona que
+
+00:10:41.209 --> 00:10:44.649
+solo tenga catorce años? Pues me dice que
+
+00:10:44.649 --> 00:10:47.525
+no puede votar, y por último, una persona
+
+00:10:47.825 --> 00:10:51.985
+que tenga cincuenta años me dirá que no
+
+00:10:51.985 --> 00:10:54.225
+puede votar. Esta es la forma de utilizar
+
+00:10:54.225 --> 00:10:56.865
+sentencias condicionales dentro de c más más, la
+
+00:10:56.865 --> 00:10:59.550
+forma de utilizar if, else y else if.
+
+00:10:59.550 --> 00:11:01.950
+Pero esta no es la forma más óptima
+
+00:11:01.950 --> 00:11:04.670
+de escribir este ejemplo, te reto a escribir
+
+00:11:04.670 --> 00:11:09.266
+una mejor alternativa utilizando la condición utilizando una
+
+00:11:09.266 --> 00:11:12.467
+sentencia or. Nos vemos en la próxima clase,
+
+00:11:12.467 --> 00:11:15.446
+donde aprenderemos a utilizar switch con case.

subir/Curso de C Básico/04-Control de flujo/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/condicional-if

subir/Curso de C Básico/04-Control de flujo/01-condicional-if.zip

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

subir/Curso de C Básico/04-Control de flujo/02-Condicionales en C Uso de la Sentencia Switch Case.mp4

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

subir/Curso de C Básico/04-Control de flujo/02-Condicionales en C Uso de la Sentencia Switch Case.vtt

@@ -0,0 +1,436 @@
+WEBVTT
+
+00:00:03.040 --> 00:00:04.960
+Vamos a ver la segunda parte de los
+
+00:00:04.960 --> 00:00:07.359
+condicionales en C más más. Vamos a hablar
+
+00:00:07.359 --> 00:00:10.900
+de la sentencia switch case. Vamos al código.
+
+00:00:11.120 --> 00:00:13.440
+La sentencia switch case es una forma más
+
+00:00:13.440 --> 00:00:16.805
+óptima de escribir algunos condicionales, específicamente cuando vamos
+
+00:00:16.805 --> 00:00:20.105
+a validar si una misma variable contiene diferentes
+
+00:00:20.165 --> 00:00:22.645
+opciones de datos. Vamos a hacer un ejemplo.
+
+00:00:22.645 --> 00:00:25.465
+Supongamos que yo tengo, por ejemplo, un menú
+
+00:00:25.525 --> 00:00:27.845
+principal de algún sistema. No sé si alguna
+
+00:00:27.845 --> 00:00:29.525
+vez has llamado a alguna de estas líneas
+
+00:00:29.525 --> 00:00:32.170
+telefónicas que te dicen, si quiere tal opción,
+
+00:00:32.170 --> 00:00:34.930
+marque uno, si quiere esta otra, marque dos,
+
+00:00:34.930 --> 00:00:37.850
+o incluso algunos chatbots también hacen esto, pues
+
+00:00:37.850 --> 00:00:39.950
+es el ejemplo que vamos a manejar aquí.
+
+00:00:40.170 --> 00:00:43.129
+Supongamos que la persona quiere introducir un número
+
+00:00:43.129 --> 00:00:46.015
+para seleccionar una opción en un menú. Para
+
+00:00:46.015 --> 00:00:48.574
+esto, tendríamos que crear una variable que contenga
+
+00:00:48.574 --> 00:00:51.155
+el número que la persona seleccionó. Por ejemplo,
+
+00:00:51.295 --> 00:00:54.655
+vamos a crear un valor entero que se
+
+00:00:54.655 --> 00:01:00.559
+llame opción, y le vamos a asignar un
+
+00:01:00.559 --> 00:01:04.560
+valor inicial de cero. Y ahora, si yo
+
+00:01:04.560 --> 00:01:06.479
+quisiera validar cuál es la opción que escogió
+
+00:01:06.479 --> 00:01:10.159
+el usuario, podría comenzar de una forma, pues,
+
+00:01:10.159 --> 00:01:12.615
+conocida, que podría ser la condición if. Supongamos
+
+00:01:12.615 --> 00:01:14.855
+que yo quiero validar si la opción fue
+
+00:01:14.855 --> 00:01:16.935
+uno o dos o tres, entonces, yo podría
+
+00:01:16.935 --> 00:01:19.995
+hacer una serie de condicionales como este, opción
+
+00:01:22.455 --> 00:01:25.275
+igual igual a uno, y en este caso,
+
+00:01:25.575 --> 00:01:28.160
+podría ponerle como seleccionaste tal cosa, ¿no? Por
+
+00:01:28.620 --> 00:01:40.155
+ejemplo, primera opción del menú. Y de la
+
+00:01:40.155 --> 00:01:41.995
+misma manera, irías validando cada una de las
+
+00:01:41.995 --> 00:01:44.975
+opciones. Por ejemplo, podrías colocar un else if
+
+00:01:45.115 --> 00:01:48.395
+y, a continuación, otra otro valor igual a
+
+00:01:48.395 --> 00:01:51.435
+dos, luego otro condicional con el sif, y
+
+00:01:51.435 --> 00:01:53.640
+ahora el igual igual a tres, igual igual
+
+00:01:53.640 --> 00:01:55.320
+a cuatro en los sucesivos, y así te
+
+00:01:55.320 --> 00:01:57.880
+irías, ¿no? Entonces, una forma más breve de
+
+00:01:57.880 --> 00:02:00.040
+escribir esto es, sabiendo que este es el
+
+00:02:00.040 --> 00:02:02.440
+patrón que vas a seguir, para este caso
+
+00:02:02.440 --> 00:02:05.560
+específico existe switch case. La forma de escribirlo
+
+00:02:05.560 --> 00:02:07.800
+es de la siguiente manera, escribes la palabra
+
+00:02:07.800 --> 00:02:12.334
+switch, paréntesis, entre paréntesis vas a poner la
+
+00:02:12.334 --> 00:02:15.234
+variable que quieres validar, en este caso sería
+
+00:02:15.614 --> 00:02:23.215
+opción. Y, a continuación, vas a abrir un
+
+00:02:23.215 --> 00:02:25.750
+par de llaves donde vas a escribir los
+
+00:02:25.750 --> 00:02:29.350
+diferentes casos que puede tener. Por ejemplo, si
+
+00:02:29.350 --> 00:02:32.170
+queremos hacer un menú de opciones, podemos validar,
+
+00:02:32.310 --> 00:02:35.110
+pues, el número. En este caso, podemos utilizar
+
+00:02:35.110 --> 00:02:39.194
+la palabra case para indicarle cada una de
+
+00:02:39.194 --> 00:02:41.515
+las opciones o de las posibilidades que puede
+
+00:02:41.515 --> 00:02:44.415
+tener esta variable, y podemos utilizar a continuación
+
+00:02:45.034 --> 00:02:46.814
+un valor que es el que la persona
+
+00:02:46.875 --> 00:02:49.915
+va a introducir. Supongamos que queremos ese menú
+
+00:02:49.915 --> 00:02:53.560
+de opciones basarlo en números, podríamos validar si
+
+00:02:53.560 --> 00:02:56.120
+el primer caso, pues, es uno. Si quisiéramos
+
+00:02:56.120 --> 00:02:59.080
+basarlo en letras y fuera una variable tipo
+
+00:02:59.080 --> 00:03:01.880
+char podríamos hacerlo, y entonces podríamos hacerlo tal
+
+00:03:01.880 --> 00:03:04.680
+vez con la letra ABC. En este caso,
+
+00:03:04.680 --> 00:03:06.675
+lo voy a hacer con números, y la
+
+00:03:06.675 --> 00:03:09.155
+forma sería escribir case, el valor con el
+
+00:03:09.155 --> 00:03:13.395
+que estamos comprobando, y dos puntos. Dentro de
+
+00:03:13.395 --> 00:03:16.355
+este case vamos a poder escribir todo lo
+
+00:03:16.355 --> 00:03:18.515
+que queremos que pase, cualquier cantidad de líneas
+
+00:03:18.515 --> 00:03:21.160
+de código, para que se ejecuten. Yo solamente
+
+00:03:21.160 --> 00:03:31.525
+voy a escribir un mensaje. Opción uno. De
+
+00:03:31.525 --> 00:03:34.005
+esta manera, cuando la persona introduzca el valor
+
+00:03:34.005 --> 00:03:37.125
+uno, va a suceder este caso. Lo mismo
+
+00:03:37.125 --> 00:03:39.285
+yo puedo hacer para validar todos los otros
+
+00:03:39.285 --> 00:03:42.005
+casos, por ejemplo, yo puedo hacer otro caso
+
+00:03:42.005 --> 00:03:44.085
+que sea para cuando la persona introduzca el
+
+00:03:44.085 --> 00:03:50.820
+número dos, y puedo incluso copiar aquí esta
+
+00:03:50.820 --> 00:03:54.660
+opción, la puedo pegar y cambiarle aquí el
+
+00:03:54.660 --> 00:03:57.700
+número dos. Y así sucesivamente, si yo tengo
+
+00:03:57.700 --> 00:04:00.644
+tres, cuatro, cinco opciones, no importa, esto lo
+
+00:04:00.644 --> 00:04:03.004
+puedo seguir haciendo y lo único que al
+
+00:04:03.004 --> 00:04:05.605
+final yo yo tendré una última opción, que
+
+00:04:05.605 --> 00:04:08.325
+será el default. ¿Te acuerdas de si hacías
+
+00:04:08.325 --> 00:04:10.885
+una cadena de if, else if, else if,
+
+00:04:10.885 --> 00:04:12.644
+al final tenías un else en caso de
+
+00:04:12.644 --> 00:04:14.610
+que todo lo anterior no hubiera ocurrido? Pues
+
+00:04:14.610 --> 00:04:17.250
+aquí es lo mismo, con default vas a
+
+00:04:17.250 --> 00:04:19.570
+poder hacer un código que se va a
+
+00:04:19.570 --> 00:04:22.850
+ejecutar única y exclusivamente cuando ninguno de los
+
+00:04:22.850 --> 00:04:29.169
+casos anteriores haya sucedido. Por ejemplo, podemos aprovechar
+
+00:04:29.169 --> 00:04:32.795
+para indicar al usuario si escogió un menú
+
+00:04:32.795 --> 00:04:34.555
+o un valor del menú que no fue,
+
+00:04:34.555 --> 00:04:41.195
+que no existe, ¿no? Y esta sería la
+
+00:04:41.195 --> 00:04:43.915
+forma en la que quedaría nuestro primer ejemplo,
+
+00:04:43.915 --> 00:04:48.820
+vamos a hacer una ejecución del programa. Aquí
+
+00:04:49.280 --> 00:04:51.280
+todavía no hemos preguntado por un valor al
+
+00:04:51.280 --> 00:04:54.080
+usuario, en este caso, como el valor inicial
+
+00:04:54.080 --> 00:04:56.639
+es cero y no tenemos validado si es
+
+00:04:56.639 --> 00:04:58.320
+un valor cero, solo tenemos el uno y
+
+00:04:58.320 --> 00:05:00.395
+el dos, se fue a la opción default
+
+00:05:00.455 --> 00:05:02.535
+y nos dijo que no existe. Vamos a
+
+00:05:02.535 --> 00:05:03.975
+habilitar para que se le pueda pedir al
+
+00:05:03.975 --> 00:05:06.365
+usuario este valor, por ejemplo, vamos a hacer
+
+00:05:06.365 --> 00:05:14.720
+c out, y vamos a poner introduce una
+
+00:05:15.640 --> 00:05:19.400
+opción. Este programa lo podríamos hacer más bonito
+
+00:05:19.460 --> 00:05:22.020
+si le agregáramos que primero haga varios COuts
+
+00:05:22.020 --> 00:05:24.660
+para mostrar las opciones disponibles, pero de momento
+
+00:05:24.660 --> 00:05:29.785
+vamos a hacerlo de esta manera, si introducimos
+
+00:05:29.785 --> 00:05:36.425
+el valor a opción. Con esto, ya podemos
+
+00:05:36.425 --> 00:05:38.650
+ahora sí realizar la ejecución del programa y
+
+00:05:38.650 --> 00:05:40.729
+nos va a pedir que introduzcamos la opción
+
+00:05:40.729 --> 00:05:42.889
+que querramos. Si yo pongo una de las
+
+00:05:42.889 --> 00:05:45.130
+opciones que están en los cases, por ejemplo,
+
+00:05:45.130 --> 00:05:46.410
+el A uno o la dos, va a
+
+00:05:46.410 --> 00:05:50.330
+suceder el código relacionado a ese caso. En
+
+00:05:50.330 --> 00:05:52.970
+este caso, si te das cuenta, está pasando
+
+00:05:52.970 --> 00:05:55.195
+algo más, que es que la opción dos
+
+00:05:55.195 --> 00:05:58.095
+se está ejecutando, pero también se está ejecutando
+
+00:05:58.155 --> 00:05:59.915
+el código por defecto. Y esto es porque
+
+00:05:59.915 --> 00:06:02.835
+nos falta poner una sentencia muy importante cuando
+
+00:06:02.835 --> 00:06:05.675
+utilizas switch case, que va a evitar que
+
+00:06:05.675 --> 00:06:07.675
+sucedan todos los demás casos. ¿Qué es lo
+
+00:06:07.675 --> 00:06:10.310
+que está pasando aquí? La opción tiene el
+
+00:06:10.690 --> 00:06:13.750
+valor dos, entonces el caso uno no sucede
+
+00:06:14.290 --> 00:06:16.530
+porque no no es el caso. El caso
+
+00:06:16.530 --> 00:06:20.370
+dos sí sucede y se ejecuta, pero continúa
+
+00:06:20.370 --> 00:06:22.210
+con todo lo que siga debajo. Si hubiera
+
+00:06:22.210 --> 00:06:24.045
+un caso tres, un caso cuatro, todos los
+
+00:06:24.045 --> 00:06:26.625
+demás hasta llegar a default, se seguirían validando.
+
+00:06:27.005 --> 00:06:29.665
+Como esos casos no serían correctos, no sucederían,
+
+00:06:29.965 --> 00:06:32.845
+pero el default sí llega a ejecutarse. Entonces,
+
+00:06:32.845 --> 00:06:36.125
+siempre tendríamos este bug, que es un efecto
+
+00:06:36.125 --> 00:06:39.190
+secundario, de no poner una palabra que es
+
+00:06:39.190 --> 00:06:42.150
+break. Con break, lo que vamos a hacer
+
+00:06:42.150 --> 00:06:44.870
+es indicarle a nuestro compilador que, una vez
+
+00:06:44.870 --> 00:06:47.449
+que termine de de ejecutar ese caso en
+
+00:06:47.990 --> 00:06:50.745
+específico, termine el switch. De esa forma, si
+
+00:06:50.745 --> 00:06:53.165
+yo ya llegué al caso dos, por ejemplo,
+
+00:06:58.425 --> 00:07:00.825
+le puedo decir que ya no ejecute el
+
+00:07:00.825 --> 00:07:05.610
+caso por defecto. Vamos a ejecutar este programa,
+
+00:07:06.110 --> 00:07:08.210
+y supongamos que yo escojo la opción dos,
+
+00:07:09.150 --> 00:07:12.110
+listo, solamente ejecutó el código necesario para el
+
+00:07:12.110 --> 00:07:15.230
+caso dos, ya no llegó al código por
+
+00:07:15.230 --> 00:07:18.235
+defecto, y lo mismo podríamos seguir realizando con
+
+00:07:18.235 --> 00:07:21.194
+cualquier otro caso. Te recuerdo que no solamente
+
+00:07:21.194 --> 00:07:25.089
+puedes utilizar números, puedes utilizar cualquier valor posible
+
+00:07:25.149 --> 00:07:27.229
+para la variable que estés validando, y esta
+
+00:07:27.229 --> 00:07:29.549
+variable podría ser de cualquier tipo de dato.
+
+00:07:29.549 --> 00:07:31.009
+Esta es la forma en la que funcionan
+
+00:07:31.309 --> 00:07:34.269
+los condicionales con switch y case. Te invito
+
+00:07:34.269 --> 00:07:35.489
+a la próxima clase.

subir/Curso de C Básico/04-Control de flujo/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/condicional-switch

subir/Curso de C Básico/04-Control de flujo/02-condicional-switch.zip

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

subir/Curso de C Básico/04-Control de flujo/03-Ciclos For en C Cómo Iterar Listas y Rangos Numéricos.mp4

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

subir/Curso de C Básico/04-Control de flujo/03-Ciclos For en C Cómo Iterar Listas y Rangos Numéricos.vtt

@@ -0,0 +1,754 @@
+WEBVTT
+
+00:00:03.600 --> 00:00:06.160
+Vamos a hablar sobre otra característica muy importante
+
+00:00:06.160 --> 00:00:08.639
+de los lenguajes de programación, que son los
+
+00:00:08.639 --> 00:00:11.599
+ciclos. Los ciclos nos van a permitir iterar
+
+00:00:11.599 --> 00:00:14.205
+un mismo bloque de código sobre una lista
+
+00:00:14.205 --> 00:00:17.085
+o un rango numérico. Por ejemplo, si tenemos
+
+00:00:17.085 --> 00:00:19.404
+una lista de números y queremos realizar una
+
+00:00:19.404 --> 00:00:21.885
+misma operación sobre cada uno de ellos, podemos
+
+00:00:21.885 --> 00:00:24.765
+utilizar un ciclo. Si tenemos un rango de
+
+00:00:24.765 --> 00:00:26.770
+números sobre el cual tenemos que operar o
+
+00:00:26.770 --> 00:00:29.970
+un rango de cosas que pueden ser variables
+
+00:00:29.970 --> 00:00:31.650
+que provengan de la entrada de tu programa,
+
+00:00:31.650 --> 00:00:35.430
+puedes utilizar ciclos para realizar estas operaciones repetitivas
+
+00:00:35.570 --> 00:00:38.450
+o iterativas. Vamos a ver cómo se programan
+
+00:00:38.450 --> 00:00:40.450
+los ciclos en este lenguaje de programación que
+
+00:00:40.450 --> 00:00:42.485
+es C más más y vamos al ejemplo
+
+00:00:42.485 --> 00:00:45.545
+de código. Para comenzar a programar un ciclo,
+
+00:00:45.925 --> 00:00:47.925
+es importante que tengamos en cuenta qué tipo
+
+00:00:47.925 --> 00:00:52.005
+de interacción vamos a realizar. Existen principalmente dos
+
+00:00:52.005 --> 00:00:53.685
+tipos de ciclos dentro de C más más
+
+00:00:53.685 --> 00:00:54.965
+y el primero es el que vamos a
+
+00:00:54.965 --> 00:00:57.375
+ver en esta clase, que son los ciclos
+
+00:00:57.375 --> 00:00:59.600
+for. Los ciclos for nos van a permitir
+
+00:00:59.820 --> 00:01:04.140
+integrar sobre rangos numéricos o sobre el tamaño
+
+00:01:04.140 --> 00:01:06.300
+de una lista. Por ejemplo, si tenemos diez
+
+00:01:06.300 --> 00:01:09.600
+elementos, podemos decir, repite este bloque de código
+
+00:01:09.660 --> 00:01:13.215
+diez veces. La forma básica de realizarlo sería
+
+00:01:13.515 --> 00:01:15.435
+utilizar simplemente una variable que vaya contando cada
+
+00:01:15.435 --> 00:01:20.075
+alteración. Y la estructura sería la siguiente, escribimos
+
+00:01:20.075 --> 00:01:22.635
+la palabra for, que es la palabra clave
+
+00:01:22.635 --> 00:01:24.815
+dentro del lenguaje C más más para realizar
+
+00:01:25.195 --> 00:01:27.729
+los ciclos for, y vamos a comenzar a
+
+00:01:27.729 --> 00:01:30.670
+declarar la variable que va a utilizar sobre
+
+00:01:31.330 --> 00:01:33.490
+el ciclo para realizar su conteo. En este
+
+00:01:33.490 --> 00:01:36.630
+caso, podemos utilizar una variable de tipo entero
+
+00:01:37.170 --> 00:01:41.175
+que se puede llamar I y podemos inicializarla
+
+00:01:41.395 --> 00:01:44.115
+en algún valor, por ejemplo, en el valor
+
+00:01:44.115 --> 00:01:46.935
+cero. Cabe destacar que no necesita ser cero,
+
+00:01:46.995 --> 00:01:49.715
+pero por lo general, si quieres iterar una
+
+00:01:49.715 --> 00:01:51.475
+lista de números, pues vas a comenzar a
+
+00:01:51.475 --> 00:01:55.690
+partir del cero. La segunda parte que necesita
+
+00:01:55.690 --> 00:01:59.210
+nuestro ciclo for es una condición sobre la
+
+00:01:59.210 --> 00:02:01.290
+cual va a evaluar en qué momento debe
+
+00:02:01.290 --> 00:02:05.050
+detenerse. En este caso, podemos utilizar cualquier valor
+
+00:02:05.050 --> 00:02:07.290
+que podríamos utilizar dentro de un condicional, justo
+
+00:02:07.290 --> 00:02:10.284
+como lo hacíamos dentro de if. Aquí vamos
+
+00:02:10.284 --> 00:02:13.405
+a realizar esa condición, por ejemplo, limitando el
+
+00:02:13.405 --> 00:02:15.885
+máximo el tamaño de la letra I. En
+
+00:02:15.885 --> 00:02:18.765
+este caso, si I llega a diez, podemos
+
+00:02:18.765 --> 00:02:21.424
+detener el ciclo. Esto haría que se repita
+
+00:02:21.644 --> 00:02:26.550
+diez veces. Si I es mayor que diez,
+
+00:02:29.010 --> 00:02:31.250
+si I es menor que diez, si evaluara
+
+00:02:31.250 --> 00:02:33.650
+si es mayor que diez, nunca llegaría ahí
+
+00:02:33.650 --> 00:02:36.290
+porque I es cero. Entonces, mi condición debe
+
+00:02:36.290 --> 00:02:38.470
+ser si I es menor que diez, entonces
+
+00:02:38.665 --> 00:02:42.385
+sigo realizando las ejecuciones del ciclo. Y por
+
+00:02:42.385 --> 00:02:45.145
+último, necesito indicarle de cuánto en cuánto se
+
+00:02:45.145 --> 00:02:47.145
+va a ir incrementando la variable. En este
+
+00:02:47.145 --> 00:02:50.025
+caso, si yo quiero contar del cero al
+
+00:02:50.025 --> 00:02:53.250
+nueve, diez, son diez veces, y necesita incrementar
+
+00:02:53.250 --> 00:02:56.290
+de uno en uno, yo podría realizar la
+
+00:02:56.290 --> 00:03:01.810
+iteración haciendo I más igual uno. Como vimos
+
+00:03:01.810 --> 00:03:04.795
+en los operadores, pues esto va a incrementar
+
+00:03:04.935 --> 00:03:07.335
+el valor de I en uno. Si I
+
+00:03:07.335 --> 00:03:09.175
+valía cero, va a convertirse en uno, si
+
+00:03:09.175 --> 00:03:13.495
+valía dos, va a ser tres, etcétera. Y
+
+00:03:13.495 --> 00:03:16.375
+para para terminar nuestro ciclo, pues tenemos que
+
+00:03:16.375 --> 00:03:18.215
+escribir el código que queremos que se repita.
+
+00:03:18.215 --> 00:03:20.540
+En este caso, yo solamente voy a mostrar
+
+00:03:20.540 --> 00:03:23.120
+en pantalla el valor de I. Por ejemplo,
+
+00:03:23.660 --> 00:03:27.580
+vamos a utilizar si out y vamos a
+
+00:03:27.580 --> 00:03:29.340
+poder mostrar el valor de I a la
+
+00:03:29.340 --> 00:03:31.875
+salida de la terminal. Para que no se
+
+00:03:31.875 --> 00:03:34.795
+junten los números dentro uno después del otro,
+
+00:03:34.795 --> 00:03:36.955
+vamos a utilizar end line para que haga
+
+00:03:36.955 --> 00:03:39.455
+un cambio de línea después de haber impreso
+
+00:03:39.515 --> 00:03:43.755
+cada uno de los números. Vamos a realizar
+
+00:03:43.755 --> 00:03:46.495
+la ejecución con la tecla f seis y
+
+00:03:49.080 --> 00:03:53.000
+ahí está. Aquí tienes tus números del cero
+
+00:03:53.000 --> 00:03:55.739
+al nueve. Se repitió diez veces el código
+
+00:03:56.120 --> 00:03:59.180
+y pasó en primer lugar siendo el valor
+
+00:03:59.239 --> 00:04:02.040
+cero, luego se incrementó más uno, entonces ahora
+
+00:04:02.040 --> 00:04:05.135
+I vale uno, luego dos, tres y así
+
+00:04:05.135 --> 00:04:07.535
+hasta llegar a romper la condición que se
+
+00:04:07.535 --> 00:04:09.775
+le puso dentro de el la sintaxis de
+
+00:04:09.775 --> 00:04:12.655
+nuestro ciclo for. Esta es la forma básica
+
+00:04:12.655 --> 00:04:14.975
+de realizar cualquier ciclo for dentro de ese
+
+00:04:14.975 --> 00:04:17.100
+más más, pero hay algunas cosas que puedes
+
+00:04:17.100 --> 00:04:20.320
+hacer. Por ejemplo, si tu valor de límite
+
+00:04:20.779 --> 00:04:25.720
+es variable, puedes convertir precisamente este límite numérico,
+
+00:04:25.740 --> 00:04:28.300
+pues que no esté directamente, pues puesto ahí,
+
+00:04:28.300 --> 00:04:30.985
+sino que esté dentro de algún otro, de
+
+00:04:30.985 --> 00:04:33.145
+alguna otra variable. Por ejemplo, yo voy a
+
+00:04:33.145 --> 00:04:35.245
+crear una variable que se llame el límite
+
+00:04:38.185 --> 00:04:41.865
+y esta variable podría ser una variable tipo
+
+00:04:41.865 --> 00:04:50.780
+entero, justo como la letra I. Y de
+
+00:04:50.780 --> 00:04:53.099
+esta manera, yo tendría la ventaja de poder
+
+00:04:53.099 --> 00:04:55.819
+controlar hasta cuánto vamos a contar dentro de
+
+00:04:55.819 --> 00:04:58.155
+nuestro ciclo. Por ejemplo, con un dato de
+
+00:04:58.155 --> 00:05:00.555
+entrada del usuario, si yo quisiera pedirle al
+
+00:05:00.555 --> 00:05:03.835
+usuario el el límite de ejecuciones durante el
+
+00:05:03.835 --> 00:05:05.995
+tiempo de ejecución, podría hacerlo, por ejemplo, con
+
+00:05:05.995 --> 00:05:11.840
+se out y sein. En este caso, voy
+
+00:05:11.840 --> 00:05:14.400
+a mostrar en pantalla la palabra límite dos
+
+00:05:14.400 --> 00:05:17.540
+puntos y voy a utilizar SEIN para que
+
+00:05:17.600 --> 00:05:20.240
+la persona que esté usando nuestro programa pueda
+
+00:05:20.240 --> 00:05:22.880
+introducir un límite durante el tiempo de ejecución
+
+00:05:22.880 --> 00:05:26.985
+de nuestro programa. Voy a ejecutarlo y vamos
+
+00:05:26.985 --> 00:05:29.385
+a ver, me está pidiendo un límite. ¿Qué
+
+00:05:29.385 --> 00:05:34.825
+pasa si yo le pongo un veinte? Genial,
+
+00:05:34.825 --> 00:05:38.185
+ha realizado veinte iteraciones. Esto mismo lo podemos
+
+00:05:38.185 --> 00:05:41.919
+utilizar para listas. Por ejemplo, si yo tengo
+
+00:05:41.919 --> 00:05:44.879
+una lista de números y quiero elevar al
+
+00:05:44.879 --> 00:05:47.379
+cuadrado o multiplicar por dos cada uno de
+
+00:05:47.520 --> 00:05:50.240
+ellos, no necesito escribir muchos bloques con muchas
+
+00:05:50.240 --> 00:05:52.240
+líneas de código para realizar la operación por
+
+00:05:52.240 --> 00:05:53.885
+cada una de ellas, De la misma manera
+
+00:05:53.885 --> 00:05:56.365
+en que tenemos listas para poder almacenar en
+
+00:05:56.365 --> 00:05:59.104
+una en una sola variable todos nuestros números,
+
+00:05:59.405 --> 00:06:02.444
+podemos utilizar ciclos para iterar un mismo bloque
+
+00:06:02.444 --> 00:06:04.604
+de código por cada uno de ellos. Vamos
+
+00:06:04.604 --> 00:06:09.950
+al ejemplo. Si yo tengo una lista de
+
+00:06:11.610 --> 00:06:14.810
+números, ¿qué puedo crear? Utilizando mi sintaxis de
+
+00:06:14.810 --> 00:06:16.990
+listas de C más más, que es utilizando
+
+00:06:17.130 --> 00:06:19.370
+corchetes y luego en un par de llaves
+
+00:06:19.370 --> 00:06:22.785
+separar los valores, Yo puedo colocar todos los
+
+00:06:22.785 --> 00:06:26.465
+números que quiera dentro de mi lista y
+
+00:06:26.465 --> 00:06:28.865
+supongamos que yo quiero multiplicar por dos cada
+
+00:06:28.865 --> 00:06:32.145
+uno de ellos, entonces yo podría realizar aquí
+
+00:06:32.145 --> 00:06:36.300
+mi operación de por dos, pero ya no
+
+00:06:36.300 --> 00:06:38.380
+vamos a imprimir I. En lugar de eso,
+
+00:06:38.380 --> 00:06:40.300
+vamos a tomar el valor de cada elemento
+
+00:06:40.300 --> 00:06:44.060
+de la lista. Si recuerdas clases anteriores, para
+
+00:06:44.060 --> 00:06:46.880
+poder obtener o acceder al valor de un
+
+00:06:47.259 --> 00:06:49.100
+elemento de una lista, podemos acceder por medio
+
+00:06:49.100 --> 00:06:51.875
+de su índice. Si recuerdas, la sintaxis era
+
+00:06:51.875 --> 00:06:53.875
+algo así como escribir el nombre de la
+
+00:06:53.875 --> 00:06:56.355
+variable que contiene la lista y entre los
+
+00:06:56.355 --> 00:06:59.475
+corchetes colocar el número del índice al que
+
+00:06:59.475 --> 00:07:02.910
+queremos acceder, comenzando a contar de cero. En
+
+00:07:02.910 --> 00:07:05.710
+este caso, si yo quisiera imprimir con COUT
+
+00:07:05.710 --> 00:07:09.390
+el valor de lista corchetes uno, estaría imprimiendo
+
+00:07:09.390 --> 00:07:12.350
+el valor doscientos, porque estaría accediendo al segundo
+
+00:07:12.350 --> 00:07:16.815
+elemento de la lista. Entonces, yo podría utilizar
+
+00:07:16.915 --> 00:07:19.795
+esta misma sintaxis, pero reemplazar esta variable que
+
+00:07:19.795 --> 00:07:22.675
+está escrita, este este número que está literalmente
+
+00:07:22.675 --> 00:07:26.595
+escrito dentro de la variable de índice, y
+
+00:07:26.595 --> 00:07:29.475
+reemplazarlo precisamente por el valor de la letra
+
+00:07:29.475 --> 00:07:30.435
+I, que es la que va a ir
+
+00:07:30.435 --> 00:07:31.950
+cambiando a lo largo de ejecución de la
+
+00:07:31.950 --> 00:07:35.470
+lista. Por ejemplo, yo podría tomar este ejemplo
+
+00:07:35.470 --> 00:07:41.470
+de de aquí y colocarlo aquí. Antes de
+
+00:07:41.470 --> 00:07:44.485
+multiplicarlo por dos, quiero mostrarte cómo se vería
+
+00:07:44.485 --> 00:07:48.505
+simplemente ejecutar una lista de los diez elementos,
+
+00:07:49.365 --> 00:07:51.764
+pero sobre la lista de números. En este
+
+00:07:51.764 --> 00:07:55.285
+caso, mi límite ya no es cualquier límite
+
+00:07:55.285 --> 00:07:57.620
+que quiera poner el usuario, sino que sabemos
+
+00:07:57.620 --> 00:08:00.180
+que tiene tres elementos. Entonces, para no romper
+
+00:08:00.180 --> 00:08:02.659
+mi programa, solamente voy a introducir un valor
+
+00:08:02.659 --> 00:08:08.259
+con el número tres. Ok, aquí eliminé mi
+
+00:08:08.259 --> 00:08:11.060
+lista, mi variable límite. Entonces voy a volver
+
+00:08:11.060 --> 00:08:20.225
+a crearla. Listo. Ahora mi variable límite ya
+
+00:08:20.225 --> 00:08:24.705
+existe y cuando me pregunte cuántas iteraciones quiero
+
+00:08:24.705 --> 00:08:25.905
+realizar, como yo sé que en la lista
+
+00:08:25.905 --> 00:08:27.780
+tengo tres elementos, solo voy a poner el
+
+00:08:27.780 --> 00:08:30.980
+número tres. Y listo, realizó tres iteraciones y
+
+00:08:30.980 --> 00:08:32.900
+por cada una de ellas ejecutó el código
+
+00:08:32.900 --> 00:08:35.700
+de mostrar, pues, qué contia, qué contenía ese
+
+00:08:35.700 --> 00:08:39.000
+valor en ese índice. Imprimió nuestros tres números
+
+00:08:39.059 --> 00:08:42.544
+y todo está bien. Aquí quiero mencionarte un
+
+00:08:42.544 --> 00:08:45.024
+problema en el que hemos al que hemos
+
+00:08:45.024 --> 00:08:47.345
+llegado en C más más y es qué
+
+00:08:47.345 --> 00:08:49.584
+pasaría ahí si yo pongo otro límite distinto,
+
+00:08:49.584 --> 00:08:54.020
+no? Vamos a ejecutarlo. Si yo realizo la
+
+00:08:54.320 --> 00:08:56.800
+ejecución sobre esta misma versión del programa y
+
+00:08:56.800 --> 00:08:59.120
+yo coloco el número dos, no habría ningún
+
+00:08:59.120 --> 00:09:02.000
+problema porque solo realizaría las primeras dos ejecuciones
+
+00:09:02.000 --> 00:09:04.320
+o iteraciones. Pero, ¿qué pasa si yo pongo
+
+00:09:04.320 --> 00:09:06.685
+un número más grande? Por ejemplo, seis. Pues
+
+00:09:06.685 --> 00:09:08.764
+esto es lo que sucede, me muestra cien,
+
+00:09:08.764 --> 00:09:10.845
+doscientos, trescientos y los otros tres números los
+
+00:09:10.845 --> 00:09:13.165
+llena con números aleatorios que obtiene de la
+
+00:09:13.165 --> 00:09:16.944
+memoria. Esto es básicamente basura. Pero, ¿cómo podríamos
+
+00:09:17.245 --> 00:09:20.204
+saber en tiempo de ejecución cuántos elementos tiene
+
+00:09:20.204 --> 00:09:22.400
+la lista? La verdad es que C más
+
+00:09:22.400 --> 00:09:25.090
+más no nos da una forma fácil, pero
+
+00:09:25.090 --> 00:09:27.190
+la forma ya la vimos en las clases
+
+00:09:27.250 --> 00:09:30.290
+de listas, y esto es obtener el tamaño
+
+00:09:30.290 --> 00:09:33.170
+total de la lista y dividirlo entre el
+
+00:09:33.170 --> 00:09:36.105
+tamaño de un elemento de la lista. En
+
+00:09:36.105 --> 00:09:38.665
+lugar de pedirle el límite al usuario, lo
+
+00:09:38.665 --> 00:09:40.745
+que yo puedo hacer es utilizar la operación
+
+00:09:40.745 --> 00:09:43.065
+size off para obtener el tamaño total de
+
+00:09:43.065 --> 00:09:46.845
+la lista y realizar la división. Con size
+
+00:09:47.145 --> 00:09:50.730
+off, recuerda, obtenemos el tamaño en bytes de
+
+00:09:50.730 --> 00:09:53.130
+una variable. En este caso, si yo tengo
+
+00:09:53.130 --> 00:09:58.030
+la variable lista, obtendría que tiene, son tres
+
+00:09:58.250 --> 00:10:01.610
+elementos enteros y utiliza, sabemos que se utilizan,
+
+00:10:01.610 --> 00:10:03.795
+por lo menos en mi computadora, cuatro bytes
+
+00:10:04.115 --> 00:10:06.915
+por cada entero, entonces estaríamos hablando de doce
+
+00:10:06.915 --> 00:10:10.274
+bytes. Y si eso lo dividimos entre los
+
+00:10:10.274 --> 00:10:13.154
+cuatro bytes que mide cada elemento de la
+
+00:10:13.154 --> 00:10:15.475
+lista, obtendríamos el tamaño de la lista, que
+
+00:10:15.475 --> 00:10:18.610
+sería tres. Para hacerlo un poquito más dinámico,
+
+00:10:18.610 --> 00:10:20.790
+en lugar de solo poner el número cuatro,
+
+00:10:20.850 --> 00:10:24.949
+voy a utilizar size off sobre el primer
+
+00:10:25.009 --> 00:10:32.075
+elemento de la lista. Ahora sabes lo que
+
+00:10:32.295 --> 00:10:35.335
+significa cómo obtener el tamaño límite. Vamos a
+
+00:10:35.335 --> 00:10:41.335
+ejecutarlo y veremos qué pasa. Listo. Ya funcionó
+
+00:10:41.335 --> 00:10:43.654
+nuestro código de ejemplo. Ya sabes cómo iterar
+
+00:10:43.654 --> 00:10:46.720
+una lista de números sin necesidad de tener
+
+00:10:46.720 --> 00:10:48.800
+alguna funcionalidad extra de C más más, que
+
+00:10:48.800 --> 00:10:51.120
+de momento sabemos que no la tiene, para
+
+00:10:51.120 --> 00:10:52.640
+leer cuál es el tamaño de la lista,
+
+00:10:52.640 --> 00:10:53.920
+pero este es un gran truco que te
+
+00:10:53.920 --> 00:10:55.760
+va a servir muchísimo a lo largo de
+
+00:10:55.760 --> 00:10:58.925
+los ejercicios de este lenguaje de programación. Para
+
+00:10:58.925 --> 00:11:01.485
+finalizar, vamos a hablar de una característica más
+
+00:11:01.485 --> 00:11:03.405
+que tienen los ciclos for, en C más
+
+00:11:03.405 --> 00:11:05.725
+más, y es la capacidad de romper el
+
+00:11:05.725 --> 00:11:10.620
+ciclo determinando cierta condición. Por ejemplo, si yo
+
+00:11:10.620 --> 00:11:13.200
+quisiera que el ciclo se rompa siempre que
+
+00:11:13.340 --> 00:11:17.120
+encuentre un número doscientos, yo podría hacerlo añadiendo
+
+00:11:17.180 --> 00:11:20.060
+una condición y nuestra palabra para romper ciclos,
+
+00:11:20.060 --> 00:11:23.260
+que es break. ¿Cómo podría hacerlo? Por ejemplo,
+
+00:11:23.260 --> 00:11:26.455
+de esta manera. Si yo quiero que cuando
+
+00:11:26.455 --> 00:11:27.975
+la el valor que voy a mostrar, en
+
+00:11:27.975 --> 00:11:32.955
+este caso sería lista por el índice, sea
+
+00:11:33.335 --> 00:11:37.370
+cuando es igual a doscientos, en ese momento
+
+00:11:37.370 --> 00:11:41.850
+yo puedo utilizar mi palabra reservada break para
+
+00:11:41.850 --> 00:11:45.770
+romper el ciclo. Si yo ejecuto esto, entonces
+
+00:11:45.770 --> 00:11:48.510
+voy a ver que nada más ejecuta cien,
+
+00:11:48.570 --> 00:11:52.045
+doscientos y termina. ¿Por qué pasó esto? Porque
+
+00:11:52.045 --> 00:11:54.964
+c out está justo antes de esta condición,
+
+00:11:54.964 --> 00:11:57.885
+así que encuentra el doscientos si lo imprime
+
+00:11:57.885 --> 00:12:00.285
+y después ya rompe el ciclo. ¿Qué pasaría
+
+00:12:00.285 --> 00:12:03.185
+si yo pongo el if primero? Pues entonces,
+
+00:12:03.350 --> 00:12:05.990
+se rompería justo antes de mostrar el doscientos
+
+00:12:05.990 --> 00:12:09.190
+y solo habríamos visto el número cien. Esta
+
+00:12:09.190 --> 00:12:11.670
+es la característica que a veces vamos a
+
+00:12:11.670 --> 00:12:14.950
+utilizar mucho para decidir cuándo romper un ciclo,
+
+00:12:14.950 --> 00:12:17.404
+sobre todo cuando no tenemos tanto control sobre
+
+00:12:18.024 --> 00:12:20.985
+cuál es el límite máximo de iteraciones y,
+
+00:12:20.985 --> 00:12:22.505
+pues, nos va a ser muy útil en
+
+00:12:22.505 --> 00:12:25.325
+nuestra próxima sentencia de ciclos, que es while.
+
+00:12:26.185 --> 00:12:28.870
+Ahora, esto no es lo único puedes hacer
+
+00:12:28.870 --> 00:12:31.189
+con ciclos, puedes hacer muchísimas cosas, y por
+
+00:12:31.189 --> 00:12:34.230
+eso te reto a que como tarea realices
+
+00:12:34.230 --> 00:12:37.829
+un ejercicio donde solo muestres los números pares
+
+00:12:37.829 --> 00:12:42.241
+utilizando un condicional. Nos vemos en la próxima
+
+00:12:42.241 --> 00:12:44.321
+clase, donde vamos a comenzar a hablar sobre
+
+00:12:44.321 --> 00:12:45.541
+ciclos while.

subir/Curso de C Básico/04-Control de flujo/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/ciclo-for

subir/Curso de C Básico/04-Control de flujo/03-ciclo-for.zip

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

subir/Curso de C Básico/04-Control de flujo/04-Ciclos While y Do While en C Ejemplos Prácticos.mp4

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

subir/Curso de C Básico/04-Control de flujo/04-Ciclos While y Do While en C Ejemplos Prácticos.vtt

@@ -0,0 +1,463 @@
+WEBVTT
+
+00:00:03.679 --> 00:00:06.399
+Vamos a continuar hablando sobre la segunda parte
+
+00:00:06.399 --> 00:00:09.840
+de ciclos de C más más. Para esto,
+
+00:00:09.840 --> 00:00:12.320
+tenemos que hablar de dos ciclos específicos que
+
+00:00:12.320 --> 00:00:15.405
+son while y the while. Son muy similares
+
+00:00:15.405 --> 00:00:17.645
+a la forma de utilizar for, excepto porque
+
+00:00:17.645 --> 00:00:19.965
+estos son pensados para no tener un límite
+
+00:00:19.965 --> 00:00:22.945
+numérico, sino que se pueden ejecutar de forma
+
+00:00:23.085 --> 00:00:26.205
+indefinida hasta que alguna situación externa, pues, los
+
+00:00:26.205 --> 00:00:28.720
+haga terminar, ya sea por medio de un
+
+00:00:28.720 --> 00:00:31.599
+condicional o alguna otra situación que surja que
+
+00:00:31.599 --> 00:00:34.800
+termine el ciclo. Ahora, vamos a pasar al
+
+00:00:34.800 --> 00:00:38.720
+ejemplo de código. Para realizar nuestro ejemplo de
+
+00:00:38.720 --> 00:00:40.739
+código en c más más vamos a proponer
+
+00:00:40.879 --> 00:00:44.105
+el siguiente problema. Supongamos que tú tienes un
+
+00:00:44.105 --> 00:00:45.625
+programa de esos que se ejecutan en la
+
+00:00:45.625 --> 00:00:49.325
+terminal de comandos y necesitas realizar un menú
+
+00:00:49.545 --> 00:00:52.185
+principal donde necesitas preguntarle a la persona si
+
+00:00:52.185 --> 00:00:54.745
+ya desea retirarse y salir del programa o
+
+00:00:54.745 --> 00:00:58.580
+desea continuar usándolo. Dependiendo de su respuesta, vas
+
+00:00:58.580 --> 00:01:00.940
+a terminar la ejecución del programa o vas
+
+00:01:00.940 --> 00:01:03.220
+a volver a mostrarle el menú de opciones
+
+00:01:03.220 --> 00:01:06.040
+o alguna otra característica que tú tengas programada
+
+00:01:06.580 --> 00:01:09.060
+para que el usuario pueda seguir haciendo, pues,
+
+00:01:09.060 --> 00:01:12.825
+uso de tu programa correctamente. Esto sería un
+
+00:01:12.825 --> 00:01:15.465
+caso de uso ideal para un ciclo while.
+
+00:01:15.465 --> 00:01:18.905
+Entonces, vamos a ver primero qué pasaría si
+
+00:01:18.905 --> 00:01:20.744
+yo tratara de desarrollar esto con un ciclo
+
+00:01:20.744 --> 00:01:23.065
+for. Si yo tratara de hacerlo, tendría que
+
+00:01:23.065 --> 00:01:25.065
+ponerle un número muy grande porque no sé
+
+00:01:25.065 --> 00:01:26.710
+cuántos intentos voy a hacer antes de que
+
+00:01:26.710 --> 00:01:28.549
+el usuario por fin me dice que me
+
+00:01:28.549 --> 00:01:30.409
+diga que tiene que terminar el programa, ¿no?
+
+00:01:31.030 --> 00:01:34.250
+Por ejemplo, yo podría hacer un ciclo for
+
+00:01:35.110 --> 00:01:37.350
+que le pregunte al usuario si ya desea
+
+00:01:37.350 --> 00:01:42.634
+terminar el programa, por ejemplo, sea out. Deseas
+
+00:01:43.734 --> 00:01:47.674
+terminar y a partir de lo que responda
+
+00:01:49.814 --> 00:01:54.454
+podríamos, por ejemplo, pedirle que responda con un
+
+00:01:54.454 --> 00:01:57.750
+carácter, con una letra. Por ejemplo, los programas
+
+00:01:57.750 --> 00:01:59.510
+que hacen esto suelen utilizar la y para
+
+00:01:59.510 --> 00:02:01.990
+decir que sí, yes, o la n para
+
+00:02:01.990 --> 00:02:05.610
+decir que no. Entonces, supongamos que queremos utilizar
+
+00:02:06.150 --> 00:02:09.509
+esta misma este mismo estándar, pues podríamos utilizar
+
+00:02:09.509 --> 00:02:14.605
+una variable que sea tipo carácter que sea
+
+00:02:14.605 --> 00:02:22.045
+la respuesta de la persona. Y originalmente le
+
+00:02:22.045 --> 00:02:24.284
+voy a poner un valor vacío porque enseguida
+
+00:02:24.284 --> 00:02:25.805
+lo voy a llenar con lo que la
+
+00:02:25.805 --> 00:02:30.263
+persona haya contestado. Y voy a preguntar si
+
+00:02:30.291 --> 00:02:33.940
+la respuesta fue yes, entonces terminaríamos el programa,
+
+00:02:33.940 --> 00:02:37.160
+por lo tanto, puedo utilizar un break. Si,
+
+00:02:38.420 --> 00:02:46.614
+respuesta fue igual a la letra y, entonces
+
+00:02:47.555 --> 00:02:53.875
+podría, por ejemplo, decirle bye bye. Y a
+
+00:02:53.875 --> 00:03:00.070
+continuación terminar el programa. De esta manera, cuando
+
+00:03:00.070 --> 00:03:02.550
+la persona que esté utilizando este programa use
+
+00:03:02.550 --> 00:03:03.830
+la respuesta con esta y, se va a
+
+00:03:03.830 --> 00:03:06.070
+terminar el programa, y cuando use cualquier otra
+
+00:03:06.070 --> 00:03:09.270
+respuesta, simplemente el programa va a continuar. En
+
+00:03:09.270 --> 00:03:11.830
+este caso, vamos a probarlo con la tecla
+
+00:03:11.830 --> 00:03:14.465
+f seis. Ok, me dice que tengo un
+
+00:03:14.465 --> 00:03:16.305
+problema en el código y es cierto, no
+
+00:03:16.305 --> 00:03:20.004
+llené los datos de el ciclo for. Olvidamos
+
+00:03:20.065 --> 00:03:23.665
+llenar las condiciones necesarias para que funcione nuestro
+
+00:03:23.665 --> 00:03:26.165
+ciclo for. En este caso, voy a utilizar
+
+00:03:26.224 --> 00:03:28.870
+simplemente un número muy grande como límite y
+
+00:03:29.010 --> 00:03:32.690
+una variable contador, pues que vaya realizando las
+
+00:03:32.690 --> 00:03:35.890
+iteraciones incrementando de uno en uno. Por ejemplo,
+
+00:03:35.890 --> 00:03:37.810
+voy a crear la variable I, que la
+
+00:03:37.810 --> 00:03:41.205
+voy a inicializar en cero. El límite para
+
+00:03:41.205 --> 00:03:43.125
+que el ciclo termine lo voy a poner
+
+00:03:43.125 --> 00:03:44.985
+muy alto, por lo tanto, voy a preguntarle
+
+00:03:45.525 --> 00:03:49.205
+que haga diez mil ciclos, por ejemplo, y
+
+00:03:49.205 --> 00:03:51.205
+lo voy a incrementar solo de uno en
+
+00:03:51.205 --> 00:03:56.420
+uno. Con esto, este ciclo se va a
+
+00:03:56.420 --> 00:03:59.860
+repetir mil ciclos o si el usuario responde
+
+00:03:59.860 --> 00:04:01.700
+que ya no desea continuar, en ese momento
+
+00:04:01.700 --> 00:04:07.620
+se va a terminar. Me dice que no
+
+00:04:07.620 --> 00:04:10.354
+puedo poner un carácter vacío. Vamos a poner
+
+00:04:10.354 --> 00:04:19.595
+algún otro valor, por ejemplo, la u. Listo.
+
+00:04:19.595 --> 00:04:21.514
+Ahora, me va a preguntar si deseo terminar.
+
+00:04:21.514 --> 00:04:23.675
+¿Qué pasa si yo contesto cualquier cosa, por
+
+00:04:23.675 --> 00:04:27.780
+ejemplo, la n de, no? Se sigue repitiendo,
+
+00:04:27.780 --> 00:04:32.099
+¿no? Yo puedo realizar este ejercicio hasta mil
+
+00:04:32.099 --> 00:04:34.740
+intentos, y si llego a mil intentos, entonces
+
+00:04:34.740 --> 00:04:37.139
+el ciclo for va a terminar. Si yo
+
+00:04:37.139 --> 00:04:39.481
+contesto en algún momento que sí, en ese
+
+00:04:39.481 --> 00:04:41.615
+momento me dice bye bye y termine la
+
+00:04:41.615 --> 00:04:45.775
+ejecución de mi programa. Ahora, esto está bien
+
+00:04:45.775 --> 00:04:48.915
+entre comillas porque nuestro programa va a continuar
+
+00:04:49.135 --> 00:04:50.895
+durante mil veces y esto podría ser un
+
+00:04:50.895 --> 00:04:53.290
+número muy grande para este ejemplo, pero la
+
+00:04:53.290 --> 00:04:54.730
+verdad es que este no es el comportamiento
+
+00:04:54.730 --> 00:04:58.030
+ideal y necesitamos una mejor forma de hacerlo.
+
+00:04:58.410 --> 00:05:00.410
+Por lo tanto, el lenguaje de programación C
+
+00:05:00.410 --> 00:05:02.970
+más más nos provee de la funcionalidad de
+
+00:05:02.970 --> 00:05:09.495
+while. While nos permitiría reemplazar estas variables como
+
+00:05:09.495 --> 00:05:11.735
+que son contadores y el incremento de uno
+
+00:05:11.735 --> 00:05:14.715
+en uno, y solamente nos permitiría poner una
+
+00:05:15.015 --> 00:05:17.255
+condición que puede ser de cualquier tipo, como
+
+00:05:17.255 --> 00:05:21.495
+un if. Por ejemplo, yo podría simplemente terminar
+
+00:05:21.495 --> 00:05:26.380
+con todo esto y decirle cambiar el for
+
+00:05:26.380 --> 00:05:30.620
+por un while, y decirle que esto siempre
+
+00:05:30.620 --> 00:05:33.740
+va a ser verdadero. Ahora, algo que va
+
+00:05:33.740 --> 00:05:37.419
+a pasar aquí es que la respuesta inicialmente
+
+00:05:37.419 --> 00:05:39.755
+tiene un carácter vacío, eso no nos lo
+
+00:05:39.755 --> 00:05:42.955
+va a permitir el compilador, pero sabiendo que
+
+00:05:42.955 --> 00:05:45.275
+una vez que ejecutemos el programa enseguida le
+
+00:05:45.275 --> 00:05:48.074
+vamos a pedir ese input al usuario, lo
+
+00:05:48.074 --> 00:05:50.814
+que podemos hacer es dejar este valor vacío
+
+00:05:51.240 --> 00:05:53.640
+a la hora de crearlo y simplemente siempre
+
+00:05:53.640 --> 00:05:54.840
+se va a llenar con lo que el
+
+00:05:54.840 --> 00:05:57.960
+usuario haya contestado. En este caso, vamos a
+
+00:05:57.960 --> 00:06:01.080
+pasar a la ejecución del programa y aquí
+
+00:06:01.080 --> 00:06:03.960
+está. Ya tenemos un ciclo que es infinito,
+
+00:06:03.960 --> 00:06:06.040
+por lo tanto, nos va a a seguir
+
+00:06:06.040 --> 00:06:08.355
+preguntando todas las veces que sea necesario hasta
+
+00:06:08.355 --> 00:06:11.875
+que el usuario use la opción de responder
+
+00:06:11.875 --> 00:06:14.515
+y, en ese caso, va a terminar. Si
+
+00:06:14.515 --> 00:06:17.035
+yo quiero comprobar que esto, pues, va a
+
+00:06:17.035 --> 00:06:19.175
+seguir funcionando por la eternidad, pues, podría realizar
+
+00:06:19.475 --> 00:06:24.250
+todas las entradas posibles y, pues continuar verificando
+
+00:06:24.250 --> 00:06:30.650
+que esto continuará ejecutándose. Vamos a ver un
+
+00:06:30.650 --> 00:06:33.560
+tema más que es la función do while,
+
+00:06:33.855 --> 00:06:35.535
+Y esto es la forma en la que
+
+00:06:35.535 --> 00:06:38.815
+funciona nuestro condicional, va a depender mucho de
+
+00:06:38.815 --> 00:06:41.375
+la condición inicial. ¿Por qué? Si yo aquí
+
+00:06:41.375 --> 00:06:46.255
+tengo una condición true, sea directamente true o
+
+00:06:46.255 --> 00:06:48.735
+alguna otra condición que me devuelva verdadero o
+
+00:06:48.735 --> 00:06:51.320
+falso, esta condición siempre se va a preguntar
+
+00:06:51.380 --> 00:06:54.260
+antes de entrar a la primera alteración siquiera
+
+00:06:54.260 --> 00:06:57.540
+de mi ciclo while. Sin embargo, en algunas
+
+00:06:57.540 --> 00:06:59.300
+ocasiones o en la mayoría de las ocasiones
+
+00:06:59.300 --> 00:07:02.675
+yo podría querer realizar una primera ejecución siempre
+
+00:07:03.135 --> 00:07:06.735
+antes de utilizar, pues, esa condición. Entonces, lo
+
+00:07:06.735 --> 00:07:08.495
+que nos va a permitir C más más
+
+00:07:08.495 --> 00:07:11.455
+es utilizar do while. En lugar de tener
+
+00:07:11.455 --> 00:07:13.935
+la condición al inicio de el while, yo
+
+00:07:13.935 --> 00:07:16.595
+podría colocarla después de que se haya ejecutado
+
+00:07:17.180 --> 00:07:20.000
+el while. Para esto, reemplazo aquí por do
+
+00:07:20.460 --> 00:07:23.039
+y la condición la traigo para acá abajo
+
+00:07:24.620 --> 00:07:27.580
+y así está. Entonces, do while lo que
+
+00:07:27.580 --> 00:07:29.680
+va lo que va a permitirme es ejecutar
+
+00:07:29.740 --> 00:07:32.764
+una vez este primer bloque de código y
+
+00:07:32.764 --> 00:07:34.625
+después de que se haya ejecutado la primera
+
+00:07:34.685 --> 00:07:37.885
+vez, va a realizar la condición. Con esta
+
+00:07:37.885 --> 00:07:40.845
+condición sabrá si ejecuta nuevamente el código o
+
+00:07:40.845 --> 00:07:43.805
+si simplemente termina. Esto es la forma fácil
+
+00:07:43.805 --> 00:07:47.010
+y rápida de realizar todo tipo de ciclos
+
+00:07:47.170 --> 00:07:49.650
+dentro de C más más utilizando while y
+
+00:07:49.650 --> 00:07:52.390
+to while, ya vimos el ciclo for, y
+
+00:07:52.450 --> 00:07:54.450
+tienes que saber que esto lo puedes combinar
+
+00:07:54.450 --> 00:07:57.250
+con todos los demás conocimientos que hemos aprendido
+
+00:07:57.250 --> 00:07:59.490
+a lo largo de este curso. Puedes utilizar
+
+00:07:59.490 --> 00:08:02.390
+condicionales como lo vimos aquí, puedes utilizar listas,
+
+00:08:02.701 --> 00:08:06.861
+variables y todos los operadores. Te veo en
+
+00:08:06.861 --> 00:08:07.761
+la próxima clase.

subir/Curso de C Básico/04-Control de flujo/04-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/ciclo-while

subir/Curso de C Básico/04-Control de flujo/04-ciclo-while.zip

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

subir/Curso de C Básico/05-Funciones/01-Funciones en C creación uso y valores por defecto.mp4

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

subir/Curso de C Básico/05-Funciones/01-Funciones en C creación uso y valores por defecto.vtt

@@ -0,0 +1,427 @@
+WEBVTT
+
+00:00:04.160 --> 00:00:06.720
+Vamos a hablar sobre las funciones en c
+
+00:00:06.720 --> 00:00:09.679
+más más. Las funciones son esta característica de
+
+00:00:09.679 --> 00:00:12.580
+los lenguajes de programación que nos permiten aislar
+
+00:00:12.639 --> 00:00:16.785
+bloques de código para poder invocarlos posteriormente. Nos
+
+00:00:16.785 --> 00:00:20.705
+permiten aislar, por ejemplo, algoritmos que realicen algún
+
+00:00:20.705 --> 00:00:23.845
+subproceso dentro de nuestro programa, que pueden recibir
+
+00:00:23.985 --> 00:00:26.305
+datos de entrada para realizar su trabajo y
+
+00:00:26.305 --> 00:00:29.550
+pueden retornar algún dato de salida. Funciona más
+
+00:00:29.550 --> 00:00:32.430
+o menos así, funciona como una especie de
+
+00:00:32.430 --> 00:00:34.110
+caja negra a la que le ponemos un
+
+00:00:34.110 --> 00:00:37.230
+nombre, por ejemplo, una nombre un nombre para
+
+00:00:37.230 --> 00:00:40.350
+una función puede ser f, y puede recibir
+
+00:00:40.350 --> 00:00:43.135
+una serie de inputs, que son valores de
+
+00:00:43.135 --> 00:00:45.535
+entrada, que pueden ser, dependiendo de lo que
+
+00:00:45.535 --> 00:00:47.715
+se trate la función, pues pueden ser números,
+
+00:00:47.774 --> 00:00:50.175
+letras, cualquier tipo de dato que tú quieras
+
+00:00:50.175 --> 00:00:52.655
+manejar con tu lenguaje de programación, y a
+
+00:00:52.655 --> 00:00:54.975
+la salida, pues te va a devolver algún
+
+00:00:54.975 --> 00:00:57.220
+valor de retorno, también puede ser de cualquier
+
+00:00:57.220 --> 00:00:59.460
+tipo que tú puedas establecer dentro de tu
+
+00:00:59.460 --> 00:01:03.700
+lenguaje de programación. Y algunas funciones, incluso, pueden
+
+00:01:03.700 --> 00:01:06.900
+no retornar algo, solamente realizar la ejecución de
+
+00:01:06.900 --> 00:01:10.020
+algún bloque de código, pero como definición, pues,
+
+00:01:10.020 --> 00:01:13.135
+pueden hacerlo. Entonces, vamos al ejemplo de código
+
+00:01:13.435 --> 00:01:15.355
+para que veas cómo se programan las funciones
+
+00:01:15.355 --> 00:01:18.555
+en C más más. Entonces, vamos a hacer
+
+00:01:18.555 --> 00:01:21.835
+nuestro ejemplo de código. Para definir funciones en
+
+00:01:21.835 --> 00:01:25.080
+C más más podemos hacerlo indicando qué tipo
+
+00:01:25.080 --> 00:01:27.240
+de dato van a recibir, qué tipo de
+
+00:01:27.240 --> 00:01:29.400
+dato van a retornar y cuál va a
+
+00:01:29.400 --> 00:01:31.640
+ser su nombre. La forma que nos ofrece
+
+00:01:31.640 --> 00:01:34.200
+el lenguaje de programación es indicarlo de la
+
+00:01:34.200 --> 00:01:36.200
+siguiente manera, por ejemplo, si yo quiero realizar
+
+00:01:36.200 --> 00:01:38.680
+una función suma que toma dos números como
+
+00:01:38.680 --> 00:01:40.814
+entrada y devuelve un número como salida, sé
+
+00:01:40.814 --> 00:01:42.414
+que voy a utilizar un tipo de dato
+
+00:01:42.414 --> 00:01:45.534
+entero, en este caso, int. Luego, voy a
+
+00:01:45.534 --> 00:01:47.215
+poder escribir el nombre de la función, en
+
+00:01:47.215 --> 00:01:49.695
+este caso, le voy a llamar suma, y
+
+00:01:49.695 --> 00:01:52.655
+entre paréntesis voy a poder indicarle todos los
+
+00:01:52.655 --> 00:01:55.370
+argumentos que recibe como valores de entrada. En
+
+00:01:55.370 --> 00:01:59.130
+este caso, respetando los mismos las mismas condiciones
+
+00:01:59.130 --> 00:02:01.550
+de cómo nombrar las variables, vamos a poder
+
+00:02:02.570 --> 00:02:04.650
+nombrar aquí dos variables, por ejemplo, la variable
+
+00:02:04.650 --> 00:02:07.210
+a y la la variable b, que van
+
+00:02:07.210 --> 00:02:09.150
+a ser dos variables que van a contener
+
+00:02:09.210 --> 00:02:13.685
+números enteros para realizar nuestra suma. Luego podemos,
+
+00:02:13.685 --> 00:02:15.685
+en un par de llaves, escribir todo el
+
+00:02:15.685 --> 00:02:18.724
+código necesario para que ejecute nuestra función. Como
+
+00:02:18.724 --> 00:02:20.885
+es una función de ejemplo, vamos a utilizar
+
+00:02:20.885 --> 00:02:24.260
+solamente una línea de código para realizar el
+
+00:02:24.260 --> 00:02:26.420
+proceso que queremos realizar, que es a más
+
+00:02:26.420 --> 00:02:28.900
+b. Como se trata de una orden que
+
+00:02:28.900 --> 00:02:30.760
+le estamos dando a la computadora, no debemos
+
+00:02:31.220 --> 00:02:34.500
+olvidar poner el punto y coma. Ahora, las
+
+00:02:34.500 --> 00:02:37.379
+funciones no solamente pueden recibir datos, como vimos
+
+00:02:37.379 --> 00:02:39.915
+pueden retornarlos, y para esto utilizamos la palabra
+
+00:02:39.915 --> 00:02:44.555
+reservada return. Esta palabra le indica a nuestro
+
+00:02:44.555 --> 00:02:46.795
+lenguaje de programación que lo que haya obtenido,
+
+00:02:46.795 --> 00:02:48.395
+en este caso de a más b, es
+
+00:02:48.395 --> 00:02:50.315
+lo que va a retornar como respuesta de
+
+00:02:50.315 --> 00:02:53.940
+la función. Una vez que ya definimos nuestra
+
+00:02:53.940 --> 00:02:57.239
+función, tenemos que utilizarla. Para hacerlo, podemos invocarla
+
+00:02:57.300 --> 00:02:59.300
+desde nuestra función main, que es la que
+
+00:02:59.300 --> 00:03:01.060
+sabemos que va a se va a ejecutar
+
+00:03:01.060 --> 00:03:03.780
+siempre cuando inicie nuestro programa, y lo que
+
+00:03:03.780 --> 00:03:05.700
+vamos a hacer es, por ejemplo, llamarla con
+
+00:03:05.700 --> 00:03:08.905
+ceo y mostrar el resultado de la suma
+
+00:03:08.905 --> 00:03:13.625
+de dos más dos. Suma, entre paréntesis ponemos
+
+00:03:13.625 --> 00:03:15.565
+los dos números que está esperando la suma
+
+00:03:16.985 --> 00:03:20.205
+y cerramos. Esta es la forma de utilizarlas,
+
+00:03:20.425 --> 00:03:22.433
+lo que está pasando aquí es que, al
+
+00:03:22.433 --> 00:03:24.940
+invocar a la función suma y pasarle dos
+
+00:03:24.940 --> 00:03:28.060
+valores, va a realizar esta operación, va a
+
+00:03:28.060 --> 00:03:30.700
+retornar el resultado y el resultado es como
+
+00:03:30.700 --> 00:03:32.860
+si lo hubiéramos escrito directamente en lugar de
+
+00:03:32.860 --> 00:03:34.754
+esto, así que si out lo va a
+
+00:03:34.754 --> 00:03:36.775
+devolver y lo va a mostrar en pantalla.
+
+00:03:37.075 --> 00:03:44.595
+Vamos a ejecutar el programa. Como puedes ver,
+
+00:03:44.595 --> 00:03:47.474
+ahora tenemos el número cuatro. Realizamos la suma
+
+00:03:47.474 --> 00:03:51.090
+de dos más dos. Si queremos realizar alguna
+
+00:03:51.090 --> 00:03:53.010
+otra operación, la ventaja que nos dan las
+
+00:03:53.010 --> 00:03:55.330
+funciones es que, una vez que las declaramos,
+
+00:03:55.330 --> 00:03:58.390
+ya podemos utilizarlas todas las veces que querramos.
+
+00:03:58.450 --> 00:04:00.850
+Por ejemplo, si yo quiero sumar dos más
+
+00:04:00.850 --> 00:04:04.715
+doscientos, ahora puedo realizar esta ejecución y va
+
+00:04:04.715 --> 00:04:07.035
+a suceder de la forma correcta. Esa es
+
+00:04:07.035 --> 00:04:09.375
+la ventaja de utilizar funciones, que podemos reutilizar
+
+00:04:09.515 --> 00:04:13.675
+mucho código, podemos abstraerlo y organizarlo conforme nos
+
+00:04:13.675 --> 00:04:16.175
+vaya conviniendo, pues, a la hora de programar.
+
+00:04:17.740 --> 00:04:20.300
+Si quisiéramos realizar otra función, lo único que
+
+00:04:20.300 --> 00:04:22.540
+tendríamos que hacer es del mismo modo que
+
+00:04:22.540 --> 00:04:25.580
+creamos la función suma, pues podríamos realizar a
+
+00:04:25.580 --> 00:04:28.940
+cualquier otra operación. Yo, imaginemos que quiero realizar
+
+00:04:28.940 --> 00:04:32.294
+ahora una multiplicación, pues lo podemos hacer. Por
+
+00:04:32.294 --> 00:04:35.974
+ejemplo, si yo quiero realizar una función que
+
+00:04:35.974 --> 00:04:40.935
+multiplique dos números, puedo crear una función que
+
+00:04:40.935 --> 00:04:43.014
+sabemos que una multiplicación, pues devuelve un entero,
+
+00:04:43.014 --> 00:04:47.950
+entonces es int, y multiplicar el número a
+
+00:04:48.530 --> 00:04:52.230
+con el número b como datos de entrada,
+
+00:04:52.770 --> 00:04:55.730
+y vamos a retornar, pues, el resultado de
+
+00:04:55.730 --> 00:05:01.375
+esa multiplicación. Así. Ahora, en lugar de utilizar
+
+00:05:01.375 --> 00:05:04.195
+la suma, yo podría utilizar mi función multiplicar.
+
+00:05:06.655 --> 00:05:09.295
+Vamos a ejecutarlo y ahí lo tienes, doscientos
+
+00:05:09.295 --> 00:05:12.960
+por dos da cuatrocientos. Excelente, ahora has realizado
+
+00:05:12.960 --> 00:05:15.680
+tus primeras funciones en c más más. Esto
+
+00:05:15.680 --> 00:05:17.280
+no es lo único que puedes hacer, también
+
+00:05:17.280 --> 00:05:19.840
+puedes hacer muchas otras cosas, vas a poder
+
+00:05:19.840 --> 00:05:22.659
+utilizar cualquier tipo de datos conforme los vayas
+
+00:05:23.280 --> 00:05:25.199
+aprendiendo a utilizar, vas a ver que puedes
+
+00:05:25.199 --> 00:05:28.295
+utilizar caracteres y más adelante veremos cómo utilizar
+
+00:05:28.675 --> 00:05:31.635
+cadenas de texto. Una última cosa antes de
+
+00:05:31.635 --> 00:05:33.955
+terminar el tema de funciones es que cuando
+
+00:05:33.955 --> 00:05:37.335
+hablamos de funciones puedes declarar valores por defecto,
+
+00:05:37.635 --> 00:05:40.035
+sobre todo para el último argumento de la
+
+00:05:40.035 --> 00:05:42.270
+función. En este caso, si yo quisiera que
+
+00:05:42.530 --> 00:05:46.169
+mi función de multiplicar pueda utilizar un valor
+
+00:05:46.169 --> 00:05:49.130
+por defecto para el segundo número, por ejemplo,
+
+00:05:49.130 --> 00:05:53.449
+siempre si yo proveo dos números, multiplica esos
+
+00:05:53.449 --> 00:05:55.465
+dos números, por ejemplo, dos por doscientos, pero
+
+00:05:55.465 --> 00:05:57.865
+si yo no proveyera el segundo número que
+
+00:05:57.865 --> 00:05:59.785
+ya tenga como que algún valor por defecto,
+
+00:05:59.785 --> 00:06:02.185
+pues yo lo podría hacer. Por ejemplo, pongamos
+
+00:06:02.185 --> 00:06:04.985
+que yo solo quiero proveer el número, el
+
+00:06:04.985 --> 00:06:07.384
+primer número, el doscientos, y quiero que por
+
+00:06:07.384 --> 00:06:09.065
+defecto, si yo no le doy otro número,
+
+00:06:09.065 --> 00:06:10.985
+me los multiplique por dos, cualquier cosa que
+
+00:06:10.985 --> 00:06:13.920
+yo meta. Entonces, lo que puedo hacer es
+
+00:06:13.920 --> 00:06:16.400
+utilizar aquí un símbolo de igual y poner
+
+00:06:16.400 --> 00:06:18.880
+el valor por defecto. De esta manera, si
+
+00:06:18.880 --> 00:06:20.800
+yo no pusiera otro valor para b, dos
+
+00:06:20.800 --> 00:06:23.040
+va a ser su valor. ¿Qué pasa si
+
+00:06:23.040 --> 00:06:25.940
+yo lo ejecuto? Pues tengo el mismo resultado.
+
+00:06:26.224 --> 00:06:28.465
+Tuve el número doscientos y ahora lo multipliqué
+
+00:06:28.465 --> 00:06:31.444
+por el número por defecto. Si yo quisiera
+
+00:06:31.745 --> 00:06:35.205
+cambiarlo, simplemente podría poner cualquier otro valor y
+
+00:06:35.585 --> 00:06:38.305
+realizamos la ejecución y ahí está, tenemos mil
+
+00:06:38.305 --> 00:06:40.518
+doscientos. Esto puede llegar a ser muy útil,
+
+00:06:40.518 --> 00:06:42.520
+dado que, pues, en algunas funciones, pues, no
+
+00:06:42.520 --> 00:06:45.960
+queremos estar metiendo valores bastante repetitivos a la
+
+00:06:45.960 --> 00:06:48.280
+hora de invocarlos, y esto nos puede ayudar
+
+00:06:48.280 --> 00:06:51.260
+bastante. Te veo en la próxima clase.

subir/Curso de C Básico/05-Funciones/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/funciones

subir/Curso de C Básico/05-Funciones/01-funciones.zip

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

subir/Curso de C Básico/05-Funciones/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/biblioteca-estandar

subir/Curso de C Básico/05-Funciones/02-Uso de la Biblioteca String en C para Manejo de Cadenas de Texto.mp4

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

subir/Curso de C Básico/05-Funciones/02-Uso de la Biblioteca String en C para Manejo de Cadenas de Texto.vtt

@@ -0,0 +1,448 @@
+WEBVTT
+
+00:00:03.919 --> 00:00:06.000
+Vamos a hablar sobre la biblioteca estándar de
+
+00:00:06.000 --> 00:00:08.639
+C más más. Como bien sabes, hemos estado
+
+00:00:08.639 --> 00:00:12.340
+utilizando números y letras de tipos de dato
+
+00:00:12.400 --> 00:00:14.625
+carácter o booleanos a lo largo de los
+
+00:00:14.625 --> 00:00:19.265
+ejemplos de este curso. Pero, si has trabajado
+
+00:00:19.265 --> 00:00:21.345
+con algún otro lenguaje de programación, te habrás
+
+00:00:21.345 --> 00:00:24.305
+dado cuenta que no tenemos cadenas de texto
+
+00:00:24.305 --> 00:00:27.465
+para poder utilizar, por ejemplo, mensajes completos. Los
+
+00:00:27.465 --> 00:00:30.120
+hemos utilizado con CEOut, pero al momento no
+
+00:00:30.120 --> 00:00:32.840
+los hemos utilizado como valores de variables, y
+
+00:00:32.840 --> 00:00:34.440
+esto es por una razón, y es que
+
+00:00:34.440 --> 00:00:36.840
+en C más más no tenemos el tipo
+
+00:00:36.840 --> 00:00:41.100
+tipo string dentro de nuestro lenguaje de programación,
+
+00:00:41.575 --> 00:00:45.095
+sino que es dentro de su biblioteca estándar
+
+00:00:45.095 --> 00:00:48.215
+donde podemos importarlo, pero es necesario importarlo como
+
+00:00:48.215 --> 00:00:50.855
+una librería. Para esto tenemos que hablar, pues,
+
+00:00:50.855 --> 00:00:53.335
+sobre las diferentes librerías que nos provee la
+
+00:00:53.335 --> 00:00:56.530
+biblioteca estándar de C más Mall. A continuación,
+
+00:00:56.910 --> 00:01:00.110
+estarás viendo una tabla donde puedes ver algunas
+
+00:01:00.110 --> 00:01:03.070
+de las muchas bibliotecas que incluye. En primer
+
+00:01:03.070 --> 00:01:05.229
+lugar, tenemos iOStream, que ya la conoces, la
+
+00:01:05.229 --> 00:01:07.310
+hemos estado utilizando para entrada y salida de
+
+00:01:07.310 --> 00:01:10.045
+datos durante los ejercicios del programa. En segundo
+
+00:01:10.045 --> 00:01:12.765
+lugar, tienes string, que nos permite el manejo
+
+00:01:12.765 --> 00:01:14.285
+de cadenas de texto dentro de C más
+
+00:01:14.285 --> 00:01:16.685
+más esa es la que vamos a aprender
+
+00:01:16.685 --> 00:01:20.145
+en las siguientes clases, y tenemos algunas otras.
+
+00:01:20.365 --> 00:01:23.073
+Esto es para que sepas que existen, realmente
+
+00:01:23.073 --> 00:01:25.982
+no nos daría tiempo de utilizar todas las
+
+00:01:25.982 --> 00:01:27.990
+bibliotecas que existen a lo largo de la
+
+00:01:27.990 --> 00:01:30.970
+biblioteca estándar de C más más, pero existen
+
+00:01:31.750 --> 00:01:35.450
+algunas especiales para manejar errores, otras para operaciones
+
+00:01:36.425 --> 00:01:40.185
+matemáticas, como conseguir sacar un exponente o realizar
+
+00:01:40.185 --> 00:01:43.145
+una operación de senos y cosenos. También tienes
+
+00:01:43.145 --> 00:01:46.025
+otras que te sirven para manejar arrays o
+
+00:01:46.025 --> 00:01:49.570
+incluso algunas para manejar vectores de datos, y
+
+00:01:49.570 --> 00:01:53.250
+todas estas tienen sus propias funciones internas que
+
+00:01:53.250 --> 00:01:55.970
+te permiten realizar, pues, todas las operaciones necesarias
+
+00:01:55.970 --> 00:01:59.430
+con este tipo de estructuras. En este caso,
+
+00:01:59.570 --> 00:02:03.634
+vamos a hablar sobre la la librería string,
+
+00:02:03.634 --> 00:02:04.755
+que es la que nos va a permitir
+
+00:02:04.755 --> 00:02:07.395
+el manejo de cadenas de texto. Vamos al
+
+00:02:07.395 --> 00:02:10.675
+ejemplo de código. Para trabajar con cadenas de
+
+00:02:10.675 --> 00:02:13.235
+texto, primero tenemos que hablar sobre el tema
+
+00:02:13.235 --> 00:02:17.790
+de listas de caracteres. Como sabes, en C
+
+00:02:17.790 --> 00:02:21.010
+más más tenemos el tipo carácter, por ejemplo,
+
+00:02:21.069 --> 00:02:23.390
+char, y podemos crear una variable con él,
+
+00:02:23.390 --> 00:02:28.269
+por ejemplo, un texto, ¿no? Ahora, también vimos
+
+00:02:28.269 --> 00:02:29.915
+el tema de las listas, ¿no? Sabes que
+
+00:02:29.915 --> 00:02:32.075
+si les ponemos este símbolo de aquí, esto
+
+00:02:32.075 --> 00:02:36.015
+es corchetes, y comenzamos a escribir caracteres individuales,
+
+00:02:36.075 --> 00:02:38.395
+pues esto podría funcionar como una forma de
+
+00:02:38.395 --> 00:02:40.815
+escribir un texto de más de un carácter.
+
+00:02:41.355 --> 00:02:44.575
+Por ejemplo, si queremos escribir la palabra hola,
+
+00:02:45.030 --> 00:02:49.349
+podríamos hacerlo de la siguiente manera. Esto no
+
+00:02:49.349 --> 00:02:51.510
+es una forma muy eficiente, pero es una
+
+00:02:51.510 --> 00:02:53.989
+forma que funciona para C más más. Vamos
+
+00:02:53.989 --> 00:02:55.189
+a ver qué es lo que genera en
+
+00:02:55.189 --> 00:03:04.185
+la salida. Si ejecutamos este bloque de código,
+
+00:03:04.185 --> 00:03:08.605
+obtenemos que nuestra variable texto, pues, efectivamente contiene
+
+00:03:08.905 --> 00:03:13.120
+la palabra hola, ya que, si out lo
+
+00:03:13.120 --> 00:03:14.440
+que hace es tomar cada uno de los
+
+00:03:14.440 --> 00:03:17.160
+caracteres y y colocarlos en la terminal, pues
+
+00:03:17.160 --> 00:03:20.120
+no notamos ninguna gran diferencia. Sin embargo, si
+
+00:03:20.120 --> 00:03:23.160
+comenzáramos a querer trabajar con esta forma de
+
+00:03:23.160 --> 00:03:26.295
+escribir la palabra hola, además de que no
+
+00:03:26.295 --> 00:03:28.855
+es muy eficiente escribir todas las palabras que
+
+00:03:28.855 --> 00:03:31.834
+queramos. Tendríamos las limitantes de que no podemos
+
+00:03:31.834 --> 00:03:34.534
+conocer, por ejemplo, de una forma sencilla cuál
+
+00:03:34.534 --> 00:03:37.095
+es el número de caracteres que contiene, tendríamos
+
+00:03:37.095 --> 00:03:38.855
+que realizar, pues, la fórmula que vimos con
+
+00:03:38.855 --> 00:03:43.390
+size off tendríamos que realizar algún otro tipo
+
+00:03:43.390 --> 00:03:45.770
+de trucos que vamos a ir descubriendo de
+
+00:03:45.790 --> 00:03:47.790
+cómo utilizar, pues, las listas. A lo mejor,
+
+00:03:47.790 --> 00:03:49.970
+si quisieras mostrar cada una de las letras,
+
+00:03:50.030 --> 00:03:52.965
+tendrías que hacer, tal vez, un ciclo. Y
+
+00:03:52.965 --> 00:03:56.005
+si quisieras procesarlo en general para un uso
+
+00:03:56.005 --> 00:03:57.845
+de un if o de un case, pues
+
+00:03:57.845 --> 00:04:01.285
+también podría ser bastante complicado. Para esto, la
+
+00:04:01.285 --> 00:04:04.165
+librería estándar, la biblioteca estándar de C más
+
+00:04:04.165 --> 00:04:06.985
+más nos provee una librería que es string.
+
+00:04:09.840 --> 00:04:14.560
+Con include podemos invocar esta librería y se
+
+00:04:14.560 --> 00:04:18.480
+llama string. String nos va a permitir declarar
+
+00:04:18.480 --> 00:04:21.524
+un nuevo tipo de dato para nuestras variables,
+
+00:04:21.604 --> 00:04:24.245
+que es precisamente el tipo de dato del
+
+00:04:24.245 --> 00:04:27.445
+mismo nombre, string. Y con esto ya no
+
+00:04:27.445 --> 00:04:31.604
+necesitaremos utilizar esta sintaxis extraña de una lista
+
+00:04:31.604 --> 00:04:33.604
+de caracteres dentro de C más más, sino
+
+00:04:33.604 --> 00:04:37.044
+que pasaríamos a simplemente poder utilizar las dobles
+
+00:04:37.044 --> 00:04:41.360
+comillas. Por ejemplo, hola mundo. De esta manera,
+
+00:04:41.420 --> 00:04:44.380
+nuestra variable texto ya contiene todos los caracteres
+
+00:04:44.380 --> 00:04:46.940
+necesarios para funcionar y, a la hora de
+
+00:04:46.940 --> 00:04:51.775
+ejecutarlos, vamos a obtener un resultado correcto. Si
+
+00:04:51.775 --> 00:04:54.414
+te diste cuenta, nuestra forma de escribir ahora
+
+00:04:54.414 --> 00:04:56.835
+las cadenas de texto es mucho más fácil.
+
+00:04:57.615 --> 00:05:00.255
+Ahora, C más más nos provee de algunos
+
+00:05:00.255 --> 00:05:03.055
+métodos adicionales para trabajar con las listas. Por
+
+00:05:03.055 --> 00:05:05.710
+ejemplo, obtener cuál es su tamaño. En lugar
+
+00:05:05.710 --> 00:05:09.650
+de simplemente hacer una operación con size off,
+
+00:05:09.710 --> 00:05:11.710
+la cual, de hecho, ya no serviría con
+
+00:05:11.710 --> 00:05:16.270
+este tipo de dato, podemos simplemente obtener su
+
+00:05:16.270 --> 00:05:20.770
+propiedad size con la siguiente sintaxis, punto size.
+
+00:05:21.395 --> 00:05:24.514
+Y entre paréntesis porque es una función que
+
+00:05:24.514 --> 00:05:28.595
+le pertenece a cualquier texto. De esta manera,
+
+00:05:28.595 --> 00:05:32.055
+nos está devolviendo que tiene diez caracteres nuestra
+
+00:05:32.115 --> 00:05:36.310
+nuestro hola mundo. Otras cosas que podemos hacer
+
+00:05:36.310 --> 00:05:39.669
+con la biblioteca string dentro de C más
+
+00:05:39.669 --> 00:05:41.990
+más es, por ejemplo, tomar un valor que
+
+00:05:41.990 --> 00:05:44.009
+venga de una cadena de texto y convertirlo
+
+00:05:44.310 --> 00:05:47.129
+a un número. Esto puede ser necesario si
+
+00:05:47.190 --> 00:05:50.064
+trabajamos, por ejemplo, con Sein y queremos que
+
+00:05:50.064 --> 00:05:54.784
+la persona introduzca algo, algún valor y queremos
+
+00:05:54.784 --> 00:05:56.865
+separar solamente la parte numérica y nos queda,
+
+00:05:56.865 --> 00:05:58.865
+pues, a lo mejor algo como esto, el
+
+00:05:58.865 --> 00:06:01.905
+número diez, pero en forma de cadena de
+
+00:06:01.905 --> 00:06:04.320
+texto. Bueno, la forma que nos da la
+
+00:06:04.320 --> 00:06:07.280
+librería de C más más es utilizar una
+
+00:06:07.280 --> 00:06:10.320
+función que se llama string to int, pero
+
+00:06:10.320 --> 00:06:14.400
+abreviado es s to I. String to int
+
+00:06:14.400 --> 00:06:16.365
+lo que nos va a recibir es una
+
+00:06:16.365 --> 00:06:19.949
+cadena de texto que contiene algo válido como
+
+00:06:19.949 --> 00:06:22.485
+un número, como en este caso, y lo
+
+00:06:22.485 --> 00:06:25.485
+que va a devolver es precisamente un entero.
+
+00:06:25.485 --> 00:06:28.385
+De esta manera, ya no necesitaríamos realizar ninguna
+
+00:06:28.765 --> 00:06:31.040
+otra operación extraña, y si tratamos de hacer
+
+00:06:31.040 --> 00:06:34.640
+operaciones matemáticas o algebraicas, con este número podríamos
+
+00:06:34.640 --> 00:06:38.660
+hacerlo. Si nuestro número no fuera un tipo
+
+00:06:38.960 --> 00:06:41.520
+entero, sino que tuviéramos, por ejemplo, un tipo
+
+00:06:41.520 --> 00:06:44.400
+flotante, podríamos hacerlo, por ejemplo, un diez punto
+
+00:06:44.400 --> 00:06:46.735
+cinco. Lo único que tendríamos que hacer es
+
+00:06:46.735 --> 00:06:49.634
+cambiar a otra función que sirve para convertirlo
+
+00:06:49.694 --> 00:06:51.455
+en flotante. Lo único que tenemos que hacer
+
+00:06:51.455 --> 00:06:55.315
+es string to float. Así, string to float
+
+00:06:55.694 --> 00:06:58.735
+es una función que nos provee la biblioteca
+
+00:06:58.735 --> 00:07:01.470
+de string, de C más más y ahí
+
+00:07:01.470 --> 00:07:03.870
+lo tenemos. No nos está dando errores, ya
+
+00:07:03.870 --> 00:07:06.270
+podemos realizar operaciones con ellos. Si yo quisiera,
+
+00:07:06.270 --> 00:07:08.030
+por ejemplo, validar que esto es un número,
+
+00:07:08.030 --> 00:07:10.510
+pues podría intentar realizar a lo mejor una
+
+00:07:10.510 --> 00:07:12.350
+suma y ver que no me da ningún
+
+00:07:12.350 --> 00:07:15.255
+error, porque realmente se está procesando como un
+
+00:07:15.255 --> 00:07:17.575
+número. Aunque SEOut no nos muestre realmente la
+
+00:07:17.575 --> 00:07:21.175
+diferencia, por detrás, si quisiéramos realizar operaciones directamente
+
+00:07:21.175 --> 00:07:25.115
+con una cadena de texto, no podríamos. Esta
+
+00:07:25.255 --> 00:07:28.130
+y muchas otras funciones son contenidas dentro de
+
+00:07:28.130 --> 00:07:30.370
+la biblioteca estándar de C más más, en
+
+00:07:30.370 --> 00:07:33.330
+este caso para string, pero existen muchas otras
+
+00:07:33.330 --> 00:07:35.410
+y me gustaría invitarte a que investigues y
+
+00:07:35.410 --> 00:07:37.750
+realices ejercicios con algunas de ellas.

subir/Curso de C Básico/05-Funciones/02-biblioteca-estandar.zip

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

subir/Curso de C Básico/06-Próximos pasos/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/cursos/c-plus-plus-poo/

subir/Curso de C Básico/06-Próximos pasos/01-Programación Orientada a Objetos con C.mp4

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

subir/Curso de Diseño para Developers/01-Introducción/01-Diseño Eficiente para Programadores Herramientas y Conceptos Básicos.mp4

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

subir/Curso de Diseño para Developers/01-Introducción/01-Diseño Eficiente para Programadores Herramientas y Conceptos Básicos.vtt

@@ -0,0 +1,61 @@
+WEBVTT
+
+00:00.000 --> 00:06.440
+Hola, te doy la bienvenida a este curso de
+diseño para programadores.
+
+00:06.440 --> 00:10.280
+Mi nombre es Samantha Martínez y he tenido
+la oportunidad de trabajar tanto en las áreas
+
+00:10.280 --> 00:14.480
+de diseño como en las áreas de
+programación y entiendo lo difícil que es muchas veces
+
+00:14.480 --> 00:19.240
+definir un flujo de trabajo entre
+diseñadores y programadores y también entiendo lo difícil
+
+00:19.240 --> 00:22.320
+que es para muchos programadores empezar a
+diseñar.
+
+00:22.320 --> 00:26.440
+En este curso te vamos a dar las
+herramientas para que no solo programes tu aplicación,
+
+00:26.440 --> 00:28.480
+sino puedas hacer un diseño eficiente.
+
+00:28.480 --> 00:32.320
+A lo largo de este curso vamos a tener un
+proyecto que va a ser el hilo conductor y
+
+00:32.320 --> 00:36.440
+vamos a tener una serie de clases en donde
+vamos a ir entendiendo los conceptos básicos
+
+00:36.440 --> 00:37.440
+del
+diseño.
+
+00:37.440 --> 00:42.080
+También hay un repositorio en GitHub donde
+vamos a subir todas las clases del proyecto,
+
+00:42.080 --> 00:46.060
+lo puedes descargar y puedes consultar ahí
+todo lo que necesites y también puedes opinar
+
+00:46.060 --> 00:49.360
+en el foro y escribir todas las preguntas
+que se te ocurran.
+
+00:49.360 --> 00:54.600
+Te invito a que me sigas en redes sociales,
+estoy en Twitter como MSSroboto y te espero
+
+00:54.600 --> 00:58.520
+en la próxima clase en donde vamos a
+hablar sobre el proceso creativo.
+

subir/Curso de Diseño para Developers/01-Introducción/01-Lecturas recomendadas.txt

@@ -0,0 +1,3 @@
+https://github.com/mssroboto/diseno-para-programadores
+https://twitter.com/mssroboto
+https://platzi.com/blog/disenadora-grafica-front-end-developer/

subir/Curso de Diseño para Developers/01-Introducción/01-slidesdisenoparaprogram_80421720-f8bc-4435-9886-a145e6adbb5a.pdf

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

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/01-Desarrollo de la creatividad para diseño y aplicaciones web.mp4

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

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/01-Desarrollo de la creatividad para diseño y aplicaciones web.vtt

@@ -0,0 +1,134 @@
+WEBVTT
+
+00:00.000 --> 00:07.600
+¿Cuántas veces has escuchado a tus
+compañeros programadores o incluso tú mismo te has dicho
+
+00:07.600 --> 00:12.440
+esta frase? Me gustaría diseñar pero no
+tengo creatividad. Hay personas que son más creativas
+
+00:12.440 --> 00:17.320
+que otras. Pues la verdad es que no es así.
+El proceso creativo, al igual que cualquier otro
+
+00:17.320 --> 00:22.480
+proceso técnico, consta de algunos pasos y
+aunque los hagamos de una manera inconsciente, siempre lo
+
+00:22.480 --> 00:28.080
+aplicamos para solucionar distintos problemas.
+Estos pasos son el primero preparación, segundo
+
+00:28.080 --> 00:34.400
+incubación, tercero iluminación, cuarto
+evaluación y quinto implementación. ¿En qué consisten estos
+
+00:34.400 --> 00:39.680
+pasos? El primer paso en la preparación es
+cuando investigamos y recopilamos toda la información
+
+00:39.680 --> 00:46.400
+relativa a un problema o una cosa que
+queramos solucionar. El segundo es la etapa incubación. En
+
+00:46.400 --> 00:51.960
+esta etapa lo que hacemos es experimentar,
+buscar diferentes soluciones, mirar cómo alguien más
+
+00:51.960 --> 00:57.240
+soluciona este problema y luego pasamos a
+la tercera etapa que es la iluminación. La etapa
+
+00:57.240 --> 01:02.120
+de la iluminación es donde se nos ocurre
+la idea. Entonces en esta etapa es donde se nos permite
+
+01:02.120 --> 01:07.360
+idear e imaginar soluciones. Y luego
+tenemos que ir a la cuarta etapa que es en donde evaluamos
+
+01:07.360 --> 01:13.520
+si estas soluciones son prácticas, son
+viables y las criticamos y si es necesario las replanteamos.
+
+01:13.520 --> 01:19.200
+Finalmente tenemos la etapa de
+implementación que es en donde ya construimos nuestra idea,
+
+01:19.200 --> 01:25.720
+trabajamos en ella y tenemos un producto
+final. Este proceso no solamente se aplica para diseño
+
+01:25.720 --> 01:32.280
+ni para hacer aplicaciones ni algo que
+esté relacionado con un campo técnico o productivo.
+
+01:32.280 --> 01:37.240
+Este proceso lo aplicamos todos los días
+para solucionar problemas de la vida cotidiana. Por
+
+01:37.240 --> 01:42.840
+ejemplo, Olga necesita hacer un pastel de
+cumpleaños. Antes de empezar hace una lista de insumos y busca
+
+01:42.840 --> 01:47.920
+recetas. En este caso, Olga está haciendo
+la etapa de investigación. Después de investigar,
+
+01:47.920 --> 01:52.760
+Olga se da cuenta de que todas las recetas
+de pasteles requieren horno. Entonces busca recetas
+
+01:52.760 --> 01:57.520
+de postres que no lo requieran. En esta
+etapa ella empieza a experimentar y a buscar soluciones que
+
+01:57.520 --> 02:03.120
+necesita. Siguiente, tras considerar
+varias opciones, a Olga se le ocurre preparar un cheesecake frío de
+
+02:03.120 --> 02:07.760
+fresa. Es este momento en el que ocurre la
+iluminación. La iluminación y la idea de
+
+02:07.760 --> 02:12.480
+preparar un cheesecake frío de fresa no
+fue la primera opción sino el resultado de un proceso,
+
+02:12.480 --> 02:20.440
+un proceso mental que ha venido haciendo ella.
+¿Qué pasa? Antes de empezar a cocinar, Olga revisa que
+
+02:20.440 --> 02:25.960
+tiene todo lo necesario y ahí se da cuenta
+de que no tiene suficientes fresas. Entonces replantea su
+
+02:25.960 --> 02:32.360
+idea y decide preparar un cheesecake de
+arándanos. Ya con su idea clara, Olga llega y empieza a
+
+02:32.360 --> 02:36.880
+implementar y empieza a cocinar y
+finalmente tiene su... no tiene una torta de cumpleaños,
+
+02:36.880 --> 02:41.680
+pero tiene un cheesecake. Cumple la misma
+función y acaba de aplicar el proceso creativo de una
+
+02:41.680 --> 02:46.520
+manera en la que no se dio cuenta.
+Entonces todo este proceso es importante que lo sepamos para
+
+02:46.520 --> 02:51.360
+que entendamos que la creatividad no es un
+talento, no es algo con lo que se nace, es algo
+
+02:51.360 --> 02:55.360
+que se desarrolla y en este curso vamos a
+aprender a desarrollar nuestra creatividad
+
+02:55.360 --> 03:17.360
+aplicada a la creación de una aplicación o
+de un diseño web.
+

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/02-Conceptos Básicos de Composición en Diseño Gráfico.mp4

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

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/02-Conceptos Básicos de Composición en Diseño Gráfico.vtt

@@ -0,0 +1,331 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+Hola, ahora vamos a estudiar seis
+conceptos básicos
+
+00:03.000 --> 00:04.600
+de la composición en
+diseño.
+
+00:04.600 --> 00:06.600
+Tener estos seis conceptos básicos
+claros
+
+00:06.600 --> 00:09.400
+te van a ayudar a crear composiciones no
+solamente web,
+
+00:09.400 --> 00:12.400
+sino composición editoriales, ilustraciones,
+etc.
+
+00:14.000 --> 00:15.600
+Empecemos con el
+balance.
+
+00:15.600 --> 00:18.000
+El balance se refiere a la estructura y
+estabilidad
+
+00:18.000 --> 00:20.600
+de una composición en donde la posición de
+cada elemento
+
+00:20.600 --> 00:22.400
+está dada por su peso
+visual.
+
+00:22.400 --> 00:24.800
+Podemos tener un balance simétrico o
+asimétrico,
+
+00:24.800 --> 00:27.000
+como lo veremos en los siguientes ejemplos.
+
+00:27.000 --> 00:29.400
+Aquí vemos un ejemplo de balance simétrico.
+
+00:29.400 --> 00:32.000
+Si bien no todos los elementos tienen el
+mismo tamaño,
+
+00:32.000 --> 00:35.000
+sí tenemos una composición que va de
+arriba hacia abajo
+
+00:35.000 --> 00:36.600
+y de izquierda a
+derecha,
+
+00:36.600 --> 00:39.600
+y que tiene los colores más fuertes en la
+parte de abajo.
+
+00:41.000 --> 00:44.600
+En este ejemplo podemos ver un ejemplo de
+composición asimétrica.
+
+00:45.000 --> 00:47.000
+Vemos cómo se marca una
+diagonal
+
+00:47.000 --> 00:49.000
+en donde tenemos contenido en la parte de
+arriba
+
+00:49.000 --> 00:50.600
+y en la parte de
+abajo,
+
+00:50.600 --> 00:53.600
+y a pesar de no tener una cuadrícula
+específica,
+
+00:53.600 --> 00:55.600
+tenemos una composición bastante balanceada,
+
+00:55.600 --> 00:58.000
+porque la cantidad de elementos que hay
+sobre la botella
+
+00:58.000 --> 01:00.000
+y bajo la botella es muy
+similar.
+
+01:01.400 --> 01:04.200
+Otro de los conceptos importantes es el
+contraste.
+
+01:04.200 --> 01:07.600
+El contraste lo podemos utilizar para
+señalar un concepto
+
+01:07.600 --> 01:11.000
+marcado por la diferencia entre dos
+elementos distintos.
+
+01:11.000 --> 01:13.400
+Por ejemplo, claro-oscuro, moderno-antiguo,
+
+01:13.400 --> 01:15.000
+grande-pequeño,
+etc.
+
+01:15.800 --> 01:18.400
+Acá podemos ver un muy buen ejemplo de
+contraste,
+
+01:18.400 --> 01:20.600
+donde no solamente está contando con el color,
+
+01:20.600 --> 01:23.000
+sino que también está contando con el color.
+
+01:23.000 --> 01:25.000
+No solamente está contrastando el color,
+
+01:25.000 --> 01:26.600
+sino el tamaño de los
+elementos.
+
+01:26.600 --> 01:29.000
+Podemos ver que tenemos un botón al lado
+izquierdo
+
+01:29.000 --> 01:30.600
+y otro botón al lado
+derecho.
+
+01:32.200 --> 01:34.600
+Otro concepto importante es la alineación.
+
+01:34.600 --> 01:37.200
+La alineación nos permite crear una ruta
+visual
+
+01:37.200 --> 01:40.400
+entre diferentes elementos que queremos
+señalarle al usuario.
+
+01:41.400 --> 01:44.400
+En este ejemplo vemos cómo tenemos
+alineados al centro
+
+01:44.400 --> 01:46.400
+los botones y el título
+principal
+
+01:46.400 --> 01:48.600
+y los elementos decorativos a la derecha.
+
+01:48.600 --> 01:51.000
+Si quisiéramos tener nuestro elemento
+principal
+
+01:51.000 --> 01:53.800
+alineado a la izquierda, pondríamos los
+elementos decorativos
+
+01:53.800 --> 01:57.000
+al lado derecho, cuidando de que el peso
+visual de las cosas
+
+01:57.000 --> 01:58.600
+no se vea
+afectado.
+
+02:00.000 --> 02:02.400
+El siguiente concepto es la proximidad.
+
+02:02.400 --> 02:05.800
+La proximidad nos permite agrupar
+diferentes elementos.
+
+02:05.800 --> 02:08.600
+La proximidad no necesariamente tiene que
+ser física,
+
+02:08.600 --> 02:10.400
+sino que podemos agrupar
+elementos
+
+02:10.400 --> 02:14.400
+utilizando colores, íconos u otro tipo de
+elementos.
+
+02:15.400 --> 02:17.600
+Acá vemos en esta página de un
+restaurante
+
+02:17.600 --> 02:19.800
+cómo tenemos tres categorías de un
+menú
+
+02:19.800 --> 02:22.400
+y estas tienen una proximidad no solamente
+física,
+
+02:22.400 --> 02:24.800
+sino que están utilizando el mismo estilo
+visual.
+
+02:24.800 --> 02:27.400
+Así es más fácil para el usuario a primera
+vista
+
+02:27.400 --> 02:30.600
+entender que las tres hacen parte de una
+misma categoría.
+
+02:31.800 --> 02:34.000
+El siguiente concepto es la repetición.
+
+02:34.000 --> 02:37.600
+La repetición es muy utilizada para
+generar concepto de marca.
+
+02:37.600 --> 02:41.200
+Vemos cómo muchas marcas utilizan siempre
+los mismos colores,
+
+02:41.200 --> 02:44.200
+las iniciales de sus logotipos, etc.
+
+02:44.200 --> 02:47.800
+Acá, por ejemplo, en este siguiente caso,
+
+02:47.800 --> 02:49.800
+vemos cómo tenemos una
+cuadrícula,
+
+02:49.800 --> 02:52.800
+es una página de gaseosas y ellos utilizan
+la repetición
+
+02:52.800 --> 02:55.600
+no solamente para mostrarnos los sabores
+de gaseosas,
+
+02:55.600 --> 02:58.000
+sino para mostrarnos su logo cuatro veces.
+
+02:58.000 --> 03:00.600
+Eso genera una recordación en los usuarios
+de la marca
+
+03:00.600 --> 03:02.800
+y también ayuda a reforzar un concepto.
+
+03:04.000 --> 03:06.200
+El último concepto es el
+espacio.
+
+03:06.200 --> 03:09.000
+El espacio lo podemos aprovechar de muchas
+maneras.
+
+03:09.000 --> 03:11.200
+En este ejemplo podemos
+ver
+
+03:11.200 --> 03:13.200
+que tenemos al lado izquierdo un
+título
+
+03:13.200 --> 03:14.800
+y al lado derecho una
+imagen.
+
+03:14.800 --> 03:17.400
+Ellos no se conformaron solamente con
+ubicar un título
+
+03:17.400 --> 03:19.200
+en el centro de la
+página,
+
+03:19.200 --> 03:21.600
+sino que están aprovechando el espacio
+negativo
+
+03:21.600 --> 03:24.600
+para poner una imagen y para seguir
+añadiendo más fuerza
+
+03:24.600 --> 03:27.600
+a su concepto, que en este caso es una
+página de vinos.
+
+03:28.200 --> 03:30.600
+Ahora que ya tienes claros los seis
+conceptos básicos
+
+03:30.600 --> 03:32.800
+de la composición, vamos a
+aprender
+
+03:32.800 --> 03:34.600
+cómo aplicar estos conceptos
+básicos
+
+03:34.600 --> 03:36.600
+para que se adapten a todos los
+dispositivos
+
+03:36.600 --> 03:37.800
+y tamaños de
+pantalla.
+
+03:37.800 --> 03:40.000
+Para eso es importante tener claro el
+concepto
+
+03:40.000 --> 03:42.000
+de Responsive Design o diseño
+responsivo
+
+03:42.000 --> 03:48.000
+que haremos en la siguiente
+clase.
+

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/03-Responsive Design Metodologías y Prácticas Esenciales.mp4

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

subir/Curso de Diseño para Developers/02-Entender los Fundamentos del diseño/03-Responsive Design Metodologías y Prácticas Esenciales.vtt

@@ -0,0 +1,186 @@
+WEBVTT
+
+00:00.000 --> 00:07.120
+Hola, ahora que tienes claros los seis
+conceptos básicos de la composición,
+
+00:07.120 --> 00:11.280
+vamos a aprender a adaptarlos a diferentes
+tamaños de pantalla por medio del uso del
+
+00:11.280 --> 00:16.520
+responsive design o diseño responsivo.
+¿Pero qué es el responsive design? El responsive design es
+
+00:16.520 --> 00:21.520
+una metodología de diseño que nos permite
+crear diferentes diseños que sean adaptables a diferentes
+
+00:21.520 --> 00:27.720
+tamaños de pantalla. ¿Cómo podemos
+garantizar que nuestra aplicación sea responsive? Lo primero,
+
+00:27.720 --> 00:31.880
+tenemos que empezar por dispositivos móviles.
+Esto nos va a garantizar que vamos a partir
+
+00:31.880 --> 00:36.840
+desde el contenido básico hasta el
+contenido más complejo. Lo segundo, separar las capas
+
+00:36.840 --> 00:41.320
+de contenido y funcionalidad. ¿Para qué
+nos sirve esto? Esto nos sirve para garantizarle al usuario
+
+00:41.320 --> 00:46.560
+el acceso a todo el contenido de nuestra
+página sin tener que ejecutar scripts, de realizar ninguna
+
+00:46.560 --> 00:52.920
+acción ni de ejecutar animaciones complejas.
+El tercero, utiliza sistemas de grillas y columnas.
+
+00:52.920 --> 00:57.920
+¿Para qué nos sirve esto? Las columnas son
+una referencia que tenemos en nuestro layout total de
+
+00:57.920 --> 01:02.840
+la página y nos sirve para ir mirando el
+ancho de nuestra página. De esta manera va a ser mucho más
+
+01:02.840 --> 01:11.480
+fácil adaptar los contenidos como imágenes,
+textos, videos, etc. Hay distintas metodologías para hacer
+
+01:11.480 --> 01:17.680
+responsive design. La primera es la mejora
+progresiva o progressive enhancement. ¿Qué es
+
+01:17.680 --> 01:22.840
+esta metodología? Esta metodología es la
+que yo les recomiendo, en la que se parte de una base
+
+01:22.840 --> 01:28.360
+sólida en donde tenemos los elementos
+esenciales y básicos de nuestra aplicación y luego le vamos
+
+01:28.360 --> 01:33.960
+añadiendo capas de complejidad. Esto nos
+permite garantizar que los usuarios con baja memoria o con
+
+01:33.960 --> 01:38.640
+un dispositivo muy pequeño puedan acceder
+al contenido y los usuarios que tengan mejores
+
+01:38.640 --> 01:42.800
+dispositivos o una pantalla más grande
+puedan ver el mismo contenido pero con una experiencia
+
+01:42.800 --> 01:49.760
+más enriquecida como con animaciones y
+otras funcionalidades. Acá vemos un ejemplo de mejora
+
+01:49.760 --> 01:56.360
+progresiva. Entonces vemos cómo tenemos en
+el tamaño más pequeño una fresa, en la tablet
+
+01:56.360 --> 02:01.240
+tenemos una fresa y una naranja y en
+desktop tenemos ya todas las frutas. Estamos transmitiendo
+
+02:01.240 --> 02:06.400
+exactamente el mismo concepto pero estamos
+garantizando que cada tamaño de pantalla tenga
+
+02:06.400 --> 02:13.840
+el contenido básico sin sobrecargar la
+aplicación. La siguiente metodología es la degradación
+
+02:13.840 --> 02:19.480
+agraciada o graceful degradation. Esta es
+todo lo contrario. En esta partimos de una versión full y
+
+02:19.480 --> 02:24.560
+completa en donde tenemos todas las
+animaciones, todos los contenidos, todas las imágenes y empezamos
+
+02:24.560 --> 02:30.080
+a quitarle capas de complejidad para que
+se adapte a tablet, a mobile y para que se adapte a dispositivos
+
+02:30.080 --> 02:34.840
+que son más lentos. Esta se puede
+recomendar en escenarios específicos como cuando estamos
+
+02:34.840 --> 02:40.360
+adaptando una página que ya está hecha,
+que no estamos haciendo desde ceros, que por alguna razón
+
+02:40.360 --> 02:45.840
+se hizo primero la versión desktop y
+tenemos que adaptarla a tablet y a mobile. Esta metodología
+
+02:45.840 --> 02:51.920
+es válida para esos casos pero como les
+digo para mí lo mejor es empezar siempre desde mobile.
+
+02:53.200 --> 02:57.600
+Acá vemos un ejemplo de degradación agraciada,
+entonces vemos cómo tenemos nuestra versión full
+
+02:57.600 --> 03:02.720
+en desktop con todas las frutas, luego en
+tablet pues se alcanza a adaptar, todavía alcanzamos a
+
+03:02.720 --> 03:08.040
+tener las cuatro frutas, pero cuando vamos
+a ir a mobile ya empezamos a tener inconvenientes porque
+
+03:08.040 --> 03:13.160
+se empieza a salir de nuestro contenedor.
+Hay ciertas maneras de hacerlo eficiente como cambiando
+
+03:13.160 --> 03:18.360
+el orden o la distribución de nuestros
+elementos y puede funcionar pero a veces es muy complicado
+
+03:18.360 --> 03:22.920
+entonces yo te recomiendo siempre utilizar
+Mobile First o Progressive Enhancement.
+
+03:24.360 --> 03:29.480
+Acá vemos un ejemplo y es que estas
+metodologías no solamente aplican al diseño sino también al
+
+03:29.480 --> 03:35.480
+código, entonces vemos como por ejemplo en
+diseño primero partimos de un contenido de nuestros datos,
+
+03:35.480 --> 03:40.680
+luego hacemos los wireframes que son bocetos,
+luego hacemos nuestro diseño visual y finalmente
+
+03:40.680 --> 03:45.960
+añadimos las animaciones. Lo mismo pasa
+cuando vamos a programar, tú siempre vas a empezar desde
+
+03:45.960 --> 03:51.600
+los datos, después vas a hacer el markup,
+la maquetación básica con HTML, después añade los
+
+03:51.600 --> 03:56.920
+estilos con CSS y por último el JavaScript.
+¿Qué pasa si empezamos por JavaScript primero? Que
+
+03:56.920 --> 04:01.920
+nuestra aplicación va a estar basada en
+scripts y no en web semántica que es lo ideal.
+
+04:04.200 --> 04:09.280
+Ahora vamos a aprender accesibilidad de
+diseño que es otro de los conceptos importantes que
+
+04:09.280 --> 04:12.240
+vamos a tener en cuenta, entonces quédate
+atento a la siguiente clase.
+