Upload via hfc (batch)

Uploaded using hfc tool

.gitattributes

@@ -118,3 +118,14 @@ subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:
 subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/01-Uso[[:space:]]de[[:space:]]la[[:space:]]Instrucción[[:space:]]Break[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/02-Uso[[:space:]]del[[:space:]]Continue[[:space:]]en[[:space:]]Bucles[[:space:]]de[[:space:]]Programación.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/04-Uso[[:space:]]de[[:space:]]las[[:space:]]instrucciones[[:space:]]break[[:space:]]y[[:space:]]continue/03-Uso[[:space:]]seguro[[:space:]]de[[:space:]]GOTO[[:space:]]en[[:space:]]manejo[[:space:]]de[[:space:]]errores[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/05-Cierre/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/01-Funciones[[:space:]]en[[:space:]]C[[:space:]]Declaración[[:space:]]y[[:space:]]Uso[[:space:]]Práctico.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/02-Funciones[[:space:]]en[[:space:]]C[[:space:]]Creación[[:space:]]y[[:space:]]Uso[[:space:]]para[[:space:]]Potencias[[:space:]]de[[:space:]]Enteros.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/03-Creación[[:space:]]y[[:space:]]uso[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/04-Tipos[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C[[:space:]]Argumentos[[:space:]]y[[:space:]]Valores[[:space:]]de[[:space:]]Retorno.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]C/01-Funciones[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]de[[:space:]]void[[:space:]]y[[:space:]]manejo[[:space:]]de[[:space:]]return[[:space:]]types.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]C/02-Paso[[:space:]]de[[:space:]]Argumentos[[:space:]]por[[:space:]]Valor[[:space:]]en[[:space:]]C[[:space:]]Conceptos[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/01-Bibliotecas[[:space:]]estándar[[:space:]]del[[:space:]]lenguaje[[:space:]]C[[:space:]]y[[:space:]]sus[[:space:]]funciones[[:space:]]principales.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/02-Funciones[[:space:]]matemáticas[[:space:]]básicas[[:space:]]en[[:space:]]C[[:space:]]con[[:space:]]la[[:space:]]biblioteca[[:space:]]math.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/03-Manejo[[:space:]]de[[:space:]]Strings[[:space:]]en[[:space:]]C[[:space:]]Funciones[[:space:]]y[[:space:]]Operaciones[[:space:]]Básicas.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/04-Manejo[[:space:]]de[[:space:]]tiempo[[:space:]]en[[:space:]]C[[:space:]]con[[:space:]]la[[:space:]]biblioteca[[:space:]]timeh.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso de Control de Flujo en C/05-Cierre/02-Estructuras de Control de Flujo en C.mp4

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

subir/Curso de Control de Flujo en C/05-Cierre/02-Estructuras de Control de Flujo en C.vtt

@@ -0,0 +1,248 @@
+WEBVTT
+
+00:03.580 --> 00:06.801
+¡Hey! Hemos llegado al final
+de nuestro curso de C,
+
+00:06.927 --> 00:10.909
+en donde nos enfocamos
+en las estructuras de control de flujo.
+
+00:11.035 --> 00:14.339
+Recuerda que esta serie de cursos
+que estás tomando del lenguaje C
+
+00:14.465 --> 00:18.074
+existen para que tal cual aprendas
+el lenguaje.
+
+00:18.200 --> 00:22.600
+Más adelante se viene el curso
+de estructuras de datos,
+
+00:22.600 --> 00:24.365
+en donde hablaremos de los arrays,
+
+00:24.491 --> 00:27.334
+hablaremos de otros elementos
+específicos de C,
+
+00:27.460 --> 00:29.865
+como por ejemplo la instrucción struct,
+
+00:30.025 --> 00:32.916
+y vamos a aprender muchísimo más
+de este lenguaje.
+
+00:33.042 --> 00:36.480
+También más adelante viene el curso
+de funciones en C,
+
+00:36.639 --> 00:39.200
+de hecho ese es el siguiente curso
+a este que acabamos de grabar.
+
+00:39.342 --> 00:41.760
+Ahí vamos a entender todo
+sobre el manejo de funciones
+
+00:41.760 --> 00:43.597
+en este maravilloso lenguaje,
+
+00:43.723 --> 00:48.085
+y con esto vamos a ir logrando dominar
+este lenguaje poco a poco.
+
+00:48.391 --> 00:50.440
+Cuéntame en los comentarios
+qué te están pareciendo
+
+00:50.440 --> 00:52.640
+estos cursos súper cortos y enfocados.
+
+00:52.858 --> 00:55.640
+A mí me encantan porque, o sea,
+yo como programador,
+
+00:55.848 --> 00:59.320
+me encantaba tener lugares de referencia
+a algo específico,
+
+00:59.607 --> 01:02.320
+y justo eso es lo que te estamos dando
+en este tipo de cursos.
+
+01:02.651 --> 01:06.781
+Si tienes dudas de cómo funciona el IF,
+el WHILE, el DO, etc.,
+
+01:06.907 --> 01:09.252
+pues simplemente te vienes a este curso,
+
+01:09.378 --> 01:11.682
+tomas las clases que necesitas y repasas,
+
+01:11.808 --> 01:15.421
+no te tienes que preocupar además
+de que haces el examen
+
+01:15.547 --> 01:18.365
+de solamente las partes
+de control de flujo.
+
+01:18.491 --> 01:21.828
+Con esto garantizamos que estás
+aprendiendo algo bien,
+
+01:21.954 --> 01:23.430
+estás aprendiendo algo a fondo,
+
+01:23.556 --> 01:26.666
+en cada parte de los cursos
+del lenguaje C.
+
+01:26.926 --> 01:29.717
+Yo soy Ricardo Celis,
+fui tu profesor en este curso,
+
+01:29.843 --> 01:32.341
+seguiré siendo tu profesor
+en el resto de cursos de C,
+
+01:32.467 --> 01:34.420
+estoy muy emocionado por verte allá.
+
+01:34.546 --> 01:36.892
+La verdad es que C es un lenguaje
+maravilloso
+
+01:37.018 --> 01:42.418
+y obviamente luego cuando termines todos
+estos cursos del lenguaje C,
+
+01:42.544 --> 01:44.777
+vas a tener un mundo de posibilidades
+para hacer.
+
+01:44.903 --> 01:47.474
+De hecho, una vez termines
+estos cursos de C,
+
+01:47.600 --> 01:49.984
+sería genial que me alcanzaras
+en los cursos de Arduino,
+
+01:50.110 --> 01:51.761
+en cursos de microcontroladores,
+
+01:51.887 --> 01:54.367
+y por qué no, cuéntame si te gustaría
+aprender robótica
+
+01:54.493 --> 01:58.135
+para que hagamos cursos de eso,
+si vemos que hay suficiente interés
+
+01:58.261 --> 02:01.360
+de parte de todas
+y todos nuestros estudiantes.
+
+02:01.609 --> 02:04.080
+Como siempre,
+te invito a que tomes el examen,
+
+02:04.080 --> 02:05.520
+a que repases mucho,
+
+02:05.520 --> 02:07.520
+recuerda que estos cursos de lenguajes
+
+02:07.520 --> 02:09.080
+que estamos haciendo ahora en Platzi,
+
+02:09.318 --> 02:11.640
+existen para que los uses
+como una referencia,
+
+02:12.002 --> 02:13.680
+tanto para cuando aprendas
+el lenguaje
+
+02:13.680 --> 02:16.680
+como para cuando quieras aplicarlo
+o tengas dudas.
+
+02:16.940 --> 02:19.560
+Recuerda que tienes que tomar
+toda nuestra carrera
+
+02:19.560 --> 02:20.760
+de Computer Science,
+
+02:20.760 --> 02:24.440
+en donde ya aprendes más las bases
+de la computación,
+
+02:24.440 --> 02:27.720
+tenemos los cursos de pensamiento
+computacional con Python,
+
+02:27.720 --> 02:30.640
+es una serie de cuatro cursos
+que son excelentes
+
+02:30.640 --> 02:34.760
+y son los primeritos en nuestra ruta
+de Computer Science
+
+02:34.760 --> 02:36.400
+que justamente existen
+
+02:36.400 --> 02:40.360
+para que puedas tener la capacidad
+de ser una persona
+
+02:40.360 --> 02:43.000
+que no tiene que aprender
+a hacer cosas puntuales
+
+02:43.000 --> 02:44.080
+y seguir tutoriales,
+
+02:44.080 --> 02:47.000
+sino que seas una persona que domina
+varios lenguajes,
+
+02:47.000 --> 02:49.120
+entiende cómo funciona la computación,
+
+02:49.120 --> 02:51.120
+sabe programar no importa qué
+
+02:51.120 --> 02:53.120
+y eso te va a separar del resto.
+
+02:53.447 --> 02:55.827
+Estoy muy feliz de que hayas terminado
+este curso,
+
+02:55.953 --> 02:59.000
+recuerda mi Twitter es @CelisMx,
+
+02:59.000 --> 03:01.600
+ahí me puedes presumir tu diploma
+cuando lo termines,
+
+03:01.840 --> 03:04.440
+a mí me encantará darle un like,
+un retweet, etcétera.
+
+03:04.657 --> 03:06.360
+También si llegas a tener dudas,
+
+03:06.360 --> 03:08.714
+mándame un tweet,
+yo feliz de la vida te ayudo
+
+03:08.993 --> 03:14.840
+y sin más, nos vemos en el próximo curso.

subir/Curso de Control de Flujo en C/05-Cierre/02-Lecturas recomendadas.txt

@@ -0,0 +1,4 @@
+https://platzi.com/clases/python-cs/
+https://platzi.com/clases/poo-python/
+https://platzi.com/clases/programacion-estocastica/
+https://platzi.com/clases/probabilistica/

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Funciones en C Declaración y Uso Práctico.mp4

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Funciones en C Declaración y Uso Práctico.vtt

@@ -0,0 +1,166 @@
+WEBVTT
+
+00:02.893 --> 00:05.324
+¡Hey! Hola, bienvenida o bienvenido
+
+00:05.450 --> 00:07.999
+a este nuevo curso de programación en C.
+
+00:08.125 --> 00:09.958
+Recuerda que este es el tercer curso
+
+00:10.083 --> 00:12.280
+de la ruta de cursos 
+de este increíble lenguaje
+
+00:12.280 --> 00:16.280
+que estoy haciendo para ti aquí en Platzi
+y que espero que vayas tomando y que vayas
+
+00:16.280 --> 00:17.940
+aprendiendo muchísimo.
+
+00:18.066 --> 00:20.681
+La idea de dividir 
+los lenguajes de programación
+
+00:20.807 --> 00:23.785
+en varios cursos cortos 
+es que sea mucho más eficiente
+
+00:23.910 --> 00:25.975
+para ti el proceso de aprendizaje,
+
+00:26.101 --> 00:29.158
+de que vayas obteniendo
+pequeños logros,
+
+00:29.283 --> 00:31.840
+como es en este caso 
+con el curso de introducción a C.
+
+00:31.840 --> 00:34.342
+Obtienes tu diploma,
+obtienes conocimiento importantísimo,
+
+00:34.468 --> 00:35.674
+te va quedando todo claro.
+
+00:35.800 --> 00:39.399
+Luego te pasas al curso
+de estructuras de control de flujo en C,
+
+00:39.525 --> 00:41.840
+en donde pues,
+como su nombre lo dice,
+
+00:41.840 --> 00:44.888
+hablamos de if, while, for, de todo eso.
+
+00:45.014 --> 00:48.520
+También hablamos de continue,
+de break y de más sentencias
+
+00:48.520 --> 00:51.087
+que te van a servir para
+darle mucho dinamismo
+
+00:51.212 --> 00:53.720
+a tu programa 
+y que haga lo que tú quieras.
+
+00:53.720 --> 00:56.158
+En este tercer curso
+te voy a explicar todo
+
+00:56.283 --> 00:57.530
+sobre las funciones en C.
+
+00:57.656 --> 01:00.932
+Vamos a entender cómo
+puedes declarar tus propias funciones,
+
+01:01.057 --> 01:03.600
+cómo les puedes
+pasar valores y obviamente
+
+01:03.600 --> 01:08.220
+vamos a explorar algunas de las funciones
+más utilizadas que de hecho
+
+01:08.220 --> 01:09.823
+tienen que ver con la manipulación 
+de strings
+
+01:09.949 --> 01:15.200
+para hacer un par de ejemplos
+de cómo puedes utilizarlas en tus códigos.
+
+01:15.326 --> 01:19.320
+Recuerda que este no es el final, 
+tenemos más temas de C que abordar,
+
+01:19.320 --> 01:22.113
+así que bueno, bienvenido a este curso 
+en donde ya,
+
+01:22.239 --> 01:24.028
+ como te conté, aprenderás todo
+
+01:24.154 --> 01:28.360
+respecto a las funciones y espero 
+que me vayas contando qué te han parecido
+
+01:28.360 --> 01:31.285
+los cursos anteriores 
+y quiero darte un pequeño,
+
+01:31.410 --> 01:34.080
+como una pequeña explicación sobre por qué
+
+01:34.080 --> 01:38.978
+estamos haciendo esto y es que descubrimos
+que es mucho más eficiente
+
+01:39.104 --> 01:42.282
+que aprendas los lenguajes
+de programación de forma segmentada.
+
+01:42.408 --> 01:45.892
+Así no te damos un curso larguísimo,
+muy difícil de consumir,
+
+01:46.018 --> 01:49.080
+que puede que no lo logres 
+y puede que lo dejes a medias
+
+01:49.080 --> 01:52.345
+o que lo dejes en el principio 
+y simplemente te desmotive.
+
+01:52.471 --> 01:56.206
+Aquí te estamos dando varios
+cursos súper cortos y enfocados,
+
+01:56.332 --> 01:59.120
+cada uno de ellos te da un
+diploma que obtienes y que puedes
+
+01:59.120 --> 02:01.451
+descargarte y presumir 
+en todas tus redes sociales
+
+02:01.576 --> 02:04.140
+y también son materiales de consulta
+
+02:04.140 --> 02:06.681
+una vez ya aprendes el
+lenguaje y es que puedes
+
+02:06.806 --> 02:10.253
+regresar a tomarlos cuantas veces quieras 
+con tu suscripción.
+
+02:10.379 --> 02:14.140
+Con esto dicho, ¿qué estás esperando? 
+¡Comencemos este curso!

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Lecturas recomendadas.txt

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/02-Funciones en C Creación y Uso para Potencias de Enteros.mp4

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/02-Funciones en C Creación y Uso para Potencias de Enteros.vtt

@@ -0,0 +1,422 @@
+WEBVTT
+
+00:03.226 --> 00:06.290
+Una función es una utilidad 
+que nos da el lenguaje
+
+00:06.416 --> 00:09.700
+para poder encapsular cierta lógica 
+de programación,
+
+00:09.700 --> 00:14.200
+un fragmento de código que va 
+a realizar una tarea específica.
+
+00:14.200 --> 00:15.200
+¿Para qué?
+
+00:15.200 --> 00:19.143
+Para que más adelante simplemente 
+llamemos nuestra función
+
+00:19.269 --> 00:21.377
+para que ejecute una tarea específica
+
+00:21.503 --> 00:25.366
+sin preocuparnos de escribir
+varias veces la implementación.
+
+00:25.392 --> 00:26.474
+Simple.
+
+00:26.500 --> 00:28.100
+Imagínate que hay un bloque de código
+
+00:28.100 --> 00:31.300
+que estás usando mucho en un software,
+en tu programa.
+
+00:31.300 --> 00:34.000
+Por ejemplo, el lenguaje C, por defecto,
+
+00:34.000 --> 00:36.400
+no tiene el operador asterisco, asterisco,
+
+00:36.400 --> 00:38.900
+que en otros lenguajes se utiliza
+
+00:38.900 --> 00:40.900
+para elevar un número a una potencia.
+
+00:40.900 --> 00:44.100
+Entonces, en algún software 
+que estés desarrollando,
+
+00:44.100 --> 00:46.100
+puede que llegues a necesitar un programa
+
+00:46.100 --> 00:47.400
+o un pedazo de código
+
+00:47.400 --> 00:50.400
+que eleva un número a la potencia 
+que tú le indiques.
+
+00:50.400 --> 00:53.500
+Eso es un caso de uso perfecto 
+para una función.
+
+00:53.500 --> 00:54.200
+¿Por qué?
+
+00:54.200 --> 00:55.400
+Lo declaramos una vez,
+
+00:55.400 --> 00:58.900
+creamos nuestra función de elevar 
+un número m a la n,
+
+00:58.900 --> 01:01.500
+y con esto simplemente cada que queramos
+
+01:01.500 --> 01:04.100
+elevar un número a una potencia dada,
+
+01:04.100 --> 01:06.500
+llamamos la función y la ejecutamos.
+
+01:06.500 --> 01:09.600
+Nos ahorramos tener que escribir 
+la implementación directa
+
+01:09.600 --> 01:14.200
+de cómo hacer que un número se
+eleve a una potencia dada cada vez.
+
+01:14.200 --> 01:17.600
+Más adelante, de hecho, 
+en otros cursos dentro de este pad,
+
+01:17.600 --> 01:21.000
+veremos sobre librerías 
+o bibliotecas de código.
+
+01:21.000 --> 01:22.800
+Y es que son esenciales en C
+
+01:22.800 --> 01:25.800
+y lo que hacen principalmente 
+es recopilar funciones
+
+01:25.800 --> 01:29.100
+que van a traer utilidades similares.
+
+01:29.100 --> 01:32.100
+Por ejemplo, la librería STDIO
+
+01:32.100 --> 01:35.800
+que estamos utilizando en otras clases 
+de estos cursos,
+
+01:35.800 --> 01:38.700
+nos sirve para manejar inputs y outputs.
+
+01:38.700 --> 01:40.900
+Es la librería estándar 
+de inputs y outputs.
+
+01:40.900 --> 01:44.500
+Y de hecho, esta librería cuenta 
+con la función printf,
+
+01:44.500 --> 01:46.800
+que es la función que contiene el código
+
+01:46.800 --> 01:49.600
+para que el lenguaje C pueda imprimir 
+un mensaje
+
+01:49.600 --> 01:51.200
+en tu pantalla de tu terminal
+
+01:51.200 --> 01:54.000
+y es lo que hemos estado 
+utilizando muchísimo
+
+01:54.000 --> 01:56.700
+a lo largo de todos 
+estos cursos anteriores.
+
+01:56.700 --> 01:59.700
+Así que ahora no solo vamos 
+a aprender a utilizar funciones,
+
+01:59.700 --> 02:01.800
+vamos a aprender a declararlas.
+
+02:01.800 --> 02:04.900
+Con esto dicho, vamos al código 
+donde justamente te voy a enseñar
+
+02:04.900 --> 02:08.200
+cómo crear una función que eleve 
+un número a una potencia.
+
+02:08.200 --> 02:11.200
+Para empezar, abre tu Visual Studio Code,
+como siempre.
+
+02:11.200 --> 02:16.200
+Vamos a guardar este archivo 
+como functions. c
+
+02:16.800 --> 02:18.300
+Y quiero comentarte un poco
+
+02:18.300 --> 02:21.100
+cómo funciona la definición 
+de una función.
+
+02:21.100 --> 02:25.700
+Lo primero es que vamos a tener 
+los siguientes elementos.
+
+02:25.985 --> 02:28.184
+return type,
+
+02:29.410 --> 02:32.700
+es decir, el tipo de datos que la función
+va a retornar,
+
+02:32.700 --> 02:34.856
+el nombre de la función,
+
+02:34.982 --> 02:37.200
+que vamos a escribir como function name.
+
+02:37.479 --> 02:42.000
+También vamos a tener parameter,
+
+02:42.189 --> 02:44.401
+declarations,
+
+02:46.640 --> 02:48.194
+if any.
+
+02:49.100 --> 02:50.700
+Muy bien.
+
+02:50.700 --> 02:53.521
+Luego, obviamente, adentro de la función
+
+02:53.647 --> 02:55.500
+tendríamos que abrir nuestras llaves
+
+02:55.500 --> 02:59.200
+y aquí tendríamos nuestras declaraciones
+
+02:59.200 --> 03:01.700
+y nuestros statements.
+
+03:01.700 --> 03:04.927
+Recuerda que yo ya te había dicho 
+que era un statement en C
+
+03:05.053 --> 03:07.000
+y que era un declaration.
+
+03:07.000 --> 03:08.500
+Aquí vamos a poder declarar,
+
+03:08.500 --> 03:10.800
+en caso de ser necesario, 
+algún tipo de variable,
+
+03:10.800 --> 03:12.600
+inicializarle algunas cosas,
+
+03:12.600 --> 03:16.000
+todo lo que se necesite 
+para que la función funcione,
+
+03:16.000 --> 03:18.800
+valga la redundancia de forma adecuada.
+
+03:18.800 --> 03:20.700
+Y statements o declaraciones,
+
+03:20.700 --> 03:23.000
+que son las instrucciones 
+que vamos a ejecutar
+
+03:23.000 --> 03:26.700
+dentro de nuestra función.
+¿Ok?
+
+03:26.700 --> 03:30.300
+Con esto dicho, déjame aclararte
+un poquito más qué es cada cosa.
+
+03:30.300 --> 03:33.900
+return type es el tipo de datos 
+que la función va a retornar.
+
+03:33.900 --> 03:36.100
+Por ejemplo, si tú dentro de la función
+
+03:36.100 --> 03:38.300
+haces un procesamiento 
+con números enteros,
+
+03:38.300 --> 03:42.700
+entonces la función va a retornar 
+un tipo de datos enteros.
+
+03:42.700 --> 03:46.000
+Y volviendo al código, 
+podríamos poner int.
+
+03:46.000 --> 03:50.400
+Si tu función se va a encargar de hacer 
+la potencia de dos números enteros,
+
+03:50.400 --> 03:56.900
+entonces power of integers.
+
+03:56.900 --> 03:59.200
+Y aquí tenemos nuestra función 
+que se va a encargar
+
+03:59.200 --> 04:01.700
+de hacer la potencia 
+de dos números enteros.
+
+04:01.700 --> 04:04.700
+Parámetros. ¿Qué son los parámetros?
+
+04:04.700 --> 04:06.700
+Los parámetros son los valores
+
+04:06.700 --> 04:09.000
+que le vamos a pasar a nuestra función.
+
+04:09.000 --> 04:11.200
+Estos valores son importantísimos
+
+04:11.200 --> 04:13.500
+porque es lo que va a ocupar 
+el código más,
+
+04:13.500 --> 04:15.900
+el código que esté 
+adentro de nuestra función,
+
+04:15.900 --> 04:18.700
+para resolver la tarea que le pidamos.
+
+04:18.700 --> 04:21.300
+En este caso, estamos hablando 
+de la potencia
+
+04:21.300 --> 04:22.400
+de un número entero.
+
+04:22.400 --> 04:24.900
+Como bien sabes, 
+vamos a tener dos elementos
+
+04:24.900 --> 04:27.100
+que van a ser de tipo entero
+
+04:27.100 --> 04:30.000
+y el primero va a ser la base 
+de nuestra potencia,
+
+04:30.000 --> 04:32.200
+si va a ser base 2, base 3, etc.
+
+04:32.200 --> 04:36.400
+Y el segundo valor va a ser
+igual entero y va a ser la n,
+
+04:36.400 --> 04:41.000
+es decir, a qué factor estamos elevando 
+nuestra base.
+
+04:41.000 --> 04:43.700
+Con esto dicho, ya tenemos los parámetros
+
+04:43.700 --> 04:45.300
+que necesitaría nuestra función.
+
+04:45.300 --> 04:48.300
+Antes de continuar, 
+quiero contarte que en C
+
+04:48.300 --> 04:51.500
+esto es correcto y es una buena práctica.
+¿Por qué?
+
+04:51.500 --> 04:55.269
+Porque te ayuda a tener 
+mejor documentadas tus funciones.
+
+04:55.395 --> 04:56.800
+Hay otra forma de hacerlo.
+
+04:56.800 --> 04:59.200
+Si tú quisieras, 
+puedes simplemente decirle
+
+04:59.200 --> 05:03.500
+a tu función que va a recibir 
+dos valores de tipo entero.
+
+05:03.778 --> 05:07.280
+Esto está ok, el compilador lo aceptaría,
+
+05:07.406 --> 05:10.438
+sin embargo, 
+no es una buena práctica
+
+05:10.564 --> 05:12.200
+porque entonces no vas a tener claro
+
+05:12.200 --> 05:15.800
+de qué se trata 
+cada uno de estos valores enteros.
+
+05:15.800 --> 05:18.749
+Y aquí ya le estamos diciendo 
+el tipo de dato
+
+05:18.875 --> 05:23.100
+y el nombre del valor 
+que estamos teniendo.
+
+05:23.100 --> 05:28.111
+Es simplemente para que el código
+sea legible y fácil de comprender.
+
+05:28.237 --> 05:31.970
+Con esto dicho, veamos qué más
+habría que hacer en nuestra función.
+
+05:32.096 --> 05:35.000
+Con esto dicho, ya sabes 
+de qué se trata una función.
+
+05:35.000 --> 05:37.800
+Ahora, esto lo vas a utilizar muchísimo
+
+05:37.800 --> 05:39.500
+a lo largo de tu desarrollo en C.
+
+05:39.500 --> 05:41.900
+Obviamente, vamos a ver una implementación
+
+05:41.900 --> 05:44.900
+de esto y lo veremos en la próxima clase.
+
+05:44.900 --> 05:51.500
+Así que vamos para allá.

subir/Curso de Funciones en C/01-Introducción a las funciones en C/02-function_0343da15-da02-412b-8715-bf15e00c974b.c

@@ -0,0 +1,11 @@
+return-type function-name(parameters declaration, if any)
+{
+    declarations
+    statements
+}
+
+int powerOfIntegers(int base, int n)
+{
+    declarations
+    statements
+}

subir/Curso de Funciones en C/01-Introducción a las funciones en C/03-Creación y uso de funciones en lenguaje C.mp4

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/03-Creación y uso de funciones en lenguaje C.vtt

@@ -0,0 +1,662 @@
+WEBVTT
+
+00:03.113 --> 00:05.272
+¡Listo! Es momento
+de llevar este concepto
+
+00:05.398 --> 00:07.799
+de función a la práctica. Vamos a eso.
+
+00:08.047 --> 00:10.967
+Vamos a abrir una nueva pestaña
+en Visual Studio Code,
+
+00:11.092 --> 00:14.055
+lo guardamos, ya sabes,
+le vamos a poner de nombre
+
+00:14.181 --> 00:18.350
+function one point C,
+dice que ya existe, claro,
+
+00:18.476 --> 00:21.069
+lo voy a sobreescribir,
+no pasa nada y empezamos
+
+00:21.195 --> 00:22.860
+con todo lo que es el boilerplate,
+
+00:22.986 --> 00:28.064
+que es este código que digamos
+que hay que escribir porque sí,
+
+00:29.031 --> 00:31.435
+como es el include,
+que tenemos que escribirlo
+
+00:31.561 --> 00:36.196
+sí o sí porque vamos
+a necesitar nuestra librería stdio.h,
+
+00:36.322 --> 00:38.801
+vamos a declarar
+ahora nuestra función,
+
+00:38.927 --> 00:41.106
+siempre tienes
+que declarar tus funciones arriba,
+
+00:41.232 --> 00:43.175
+justo en donde declaramos las variables,
+
+00:43.301 --> 00:47.307
+porque eso te sirve
+para que el compilador sepa
+
+00:47.433 --> 00:49.917
+que esa función existe
+y si se le encuentra en tu código
+
+00:50.043 --> 00:52.400
+más adelante,
+pues no diga oye, ¿qué es esto?
+
+00:52.400 --> 00:55.605
+No tengo idea, sino que sea,
+esta es la función power,
+
+00:55.731 --> 00:58.111
+vamos a pasarle nuestras variables
+
+00:58.237 --> 01:01.498
+que como lo habíamos hecho
+antes van a ser m
+
+01:01.623 --> 01:06.194
+o base y luego le vamos a
+pasar nuestra variable n,
+
+01:06.320 --> 01:10.590
+int n, ok, todo bien por acá,
+simplemente punto y coma,
+
+01:10.716 --> 01:12.602
+ya con esto
+declaramos nuestra función,
+
+01:12.728 --> 01:16.274
+ahora procedemos a escribir nuestro main,
+
+01:16.741 --> 01:19.080
+vamos a abrir sus llaves 
+para todo el código
+
+01:19.080 --> 01:23.468
+que va a corresponder
+y adentro de este código main,
+
+01:23.594 --> 01:25.473
+lo primero que quiero 
+es declarar un auxiliar
+
+01:25.599 --> 01:29.538
+y un contador,
+vamos a escribir luego un ciclo for,
+
+01:29.663 --> 01:33.139
+este ciclo for lo que va 
+a tener de particular
+
+01:33.265 --> 01:36.702
+es que nos va a servir
+para iterar en diferentes
+
+01:36.828 --> 01:38.960
+valores y quiero que veas cómo se imprime
+
+01:38.960 --> 01:42.075
+el resultado de números
+elevados a diversas potencias
+
+01:42.200 --> 01:45.120
+y cómo escribimos un código bien,
+bien corto,
+
+01:45.120 --> 01:47.634
+compacto, que tiene
+bastante funcionalidad,
+
+01:48.251 --> 01:50.807
+vamos a decirle que cuando
+i sea menor que 10,
+
+01:50.933 --> 01:54.590
+quiero que iterate de 0 a 10,
+excelente y más más,
+
+01:54.716 --> 01:58.276
+eso se queda así, luego voy a tener
+un print bastante largo,
+
+01:58.402 --> 02:00.642
+pero ya te explico para qué va a servir,
+
+02:00.768 --> 02:03.910
+vamos a imprimir tres valores,
+
+02:04.109 --> 02:11.062
+el primero va a ser n es igual a %d,
+
+02:11.849 --> 02:15.715
+el segundo va a ser resultado
+
+02:18.773 --> 02:20.773
+o resultado
+
+02:23.473 --> 02:24.633
+de la potencia
+
+02:26.318 --> 02:31.668
+va a ser igual a %d, bellísimo,
+
+02:32.588 --> 02:36.198
+vamos a cerrar aquí
+con un salto de línea,
+
+02:39.657 --> 02:45.298
+ya sabes barra invertida n,
+cerramos nuestras comillas,
+
+02:45.424 --> 02:47.200
+coma y aquí le pasamos el valor,
+
+02:47.200 --> 02:51.205
+primero le voy a pasar
+i que va a ser n en este caso,
+
+02:51.331 --> 02:54.120
+el exponente y luego le paso mi potencia
+
+02:54.120 --> 02:59.967
+o el resultado de mi potencia,
+vamos a hacerlo de esta forma 2,i,
+
+03:00.533 --> 03:02.600
+perfecto, 2 va a ser la base
+
+03:02.600 --> 03:05.278
+que voy a utilizar
+para este ejemplo e i
+
+03:05.403 --> 03:07.446
+va a ser el exponencial
+que vamos a tener
+
+03:07.572 --> 03:12.674
+que se va a ir iterando en este ciclo for,
+eso es todo lo que tenemos en este código,
+
+03:12.800 --> 03:14.445
+todo está muy bello,
+
+03:14.571 --> 03:18.468
+cerramos nuestros paréntesis
+
+03:20.927 --> 03:24.874
+y le ponemos su correspondiente
+punto y coma, excelente,
+
+03:25.000 --> 03:28.746
+ya tenemos nuestro for escrito,
+veamos que todo esté correcto,
+
+03:28.872 --> 03:30.960
+tenemos aquí el paréntesis
+
+03:30.960 --> 03:33.878
+que resierra el print,
+tenemos nuestras comillas
+
+03:34.003 --> 03:36.920
+que se cierran bien
+y tenemos los textos escritos,
+
+03:36.920 --> 03:41.180
+todo está excelente,
+vamos a poner aquí el resultado
+
+03:41.306 --> 03:44.508
+de la potencia,
+nos estaba faltando utilizar
+
+03:44.634 --> 03:49.007
+ahí un artículo, muy bien,
+ya tenemos declarado nuestro for,
+
+03:49.133 --> 03:51.188
+ahora simplemente por estándar
+
+03:51.314 --> 03:56.358
+cerramos con nuestro return 0 para indicar
+el fin de la ejecución de nuestro código,
+
+03:56.844 --> 04:02.547
+con esto dicho vamos a la carnita de esta
+clase que es la declaración de la función,
+
+04:02.813 --> 04:06.104
+abajo de nuestro main
+vamos a declarar nuestra función power,
+
+04:06.230 --> 04:08.160
+es decir, vamos a definir nuestra función,
+
+04:08.160 --> 04:12.601
+mejor dicho, a escribir todo el código
+que va a estar adentro de la misma,
+
+04:12.727 --> 04:15.938
+aquí la inicializamos,
+eso es todo, la declaramos
+
+04:16.063 --> 04:19.640
+por decirlo así y aquí
+vamos ahora sí a escribirla,
+
+04:19.640 --> 04:22.758
+a crearla, a ponerle
+todo lo que va a ir adentro,
+
+04:22.883 --> 04:26.895
+lo primero va a ser
+comenzar a escribir la base y n,
+
+04:27.021 --> 04:28.856
+excelente, abrimos nuestras llaves
+
+04:28.982 --> 04:31.662
+para indicarle al compilador
+que todo lo que está adentro
+
+04:31.788 --> 04:33.680
+pertenece a esta función power,
+
+04:33.805 --> 04:36.440
+voy a declarar dos variables
+auxiliares que la primera
+
+04:36.566 --> 04:39.261
+va a ser y i la segunda va a ser p, 
+punto y coma,
+
+04:39.386 --> 04:42.774
+luego voy a
+inicializar mi variable p en 1,
+
+04:44.573 --> 04:50.015
+en 1, punto y coma y por último voy
+a hacer un pequeñísimo ciclo for,
+
+04:50.141 --> 04:54.180
+este ciclo for
+va a comenzar en i igual a 1,
+
+04:54.306 --> 04:57.891
+estoy usando
+delete en vez de backspace,
+
+04:58.016 --> 05:03.984
+i igual a 1, excelente,
+i menor o igual que n,
+
+05:05.847 --> 05:09.438
+punto y coma y luego mi iterador
+
+05:09.563 --> 05:13.799
+que va a ser i ++, excelente,
+mi incrementador,
+
+05:13.925 --> 05:16.283
+mi variable que va a estar sumando
+de 1 en 1,
+
+05:16.409 --> 05:19.600
+perfecto, ahora le ponemos
+la carnita o el código
+
+05:19.600 --> 05:22.860
+de mi función que de hecho
+es bastante simple,
+
+05:22.986 --> 05:29.640
+te vas a sorprender, simplemente 
+voy a declarar p igual a p por base,
+
+05:30.243 --> 05:35.633
+muy bien, y por último 
+algo esencial es retornar,
+
+05:35.766 --> 05:39.938
+siempre que declaramos una función,
+siempre que escribimos todo el código
+
+05:40.063 --> 05:44.369
+de nuestra función, tenemos
+que decirle que vamos a retornar,
+
+05:44.495 --> 05:46.058
+qué variable es la que va a agarrar
+
+05:46.183 --> 05:49.690
+y va a retornar, porque si no
+C va a retornar la primera variable
+
+05:49.816 --> 05:51.598
+o el primer dato que se encuentre
+
+05:51.723 --> 05:54.546
+y no vamos a estar obteniendo
+el resultado adecuado,
+
+05:54.672 --> 05:59.769
+en este caso vamos a retornar
+un valor entero como ya lo definimos
+
+05:59.895 --> 06:01.695
+en el principio en mi return type
+
+06:01.821 --> 06:05.449
+y el return simplemente
+debe de indicar qué valor
+
+06:05.575 --> 06:07.297
+es el que va a estar regresando
+
+06:07.423 --> 06:10.298
+cuando se le ejecute o se le llama
+esta función, cuando estamos
+
+06:10.423 --> 06:12.800
+llamando nuestra función,
+aquí lo estamos llamando
+
+06:12.800 --> 06:14.860
+en cada bucle de nuestro ciclo for,
+
+06:14.986 --> 06:19.000
+estamos llamando nuestra función power
+y ahora mi programa,
+
+06:19.000 --> 06:22.289
+mi función sabe que debe
+de retornar el valor de p,
+
+06:22.415 --> 06:26.464
+en cada uno de esos
+ciclos que se le llama,
+
+06:26.590 --> 06:29.754
+perfecto, ahora quiero
+explicarte una cosita más
+
+06:29.880 --> 06:31.800
+y es que si no tienes
+claro el concepto
+
+06:31.800 --> 06:33.924
+de una potencia pues
+no vas a entender este código
+
+06:34.049 --> 06:36.420
+y eso es un concepto matemático básico,
+
+06:36.420 --> 06:39.722
+pero no te preocupes yo te lo explico,
+simple y sencillamente
+
+06:39.848 --> 06:43.076
+nosotros vamos a tener,
+cuando elevamos un número a una potencia,
+
+06:43.202 --> 06:46.713
+dos valores, la base
+que es el número que tenemos
+
+06:46.839 --> 06:48.480
+y la potencia o el exponencial
+
+06:48.480 --> 06:52.709
+que nos dice cuántas veces se va 
+a multiplicar ese número por sí mismo,
+
+06:52.835 --> 06:55.217
+en este caso si tú elevas una potencia
+
+06:55.343 --> 06:59.078
+que es base 2 por ejemplo un 2 a la 3,
+
+06:59.203 --> 07:02.101
+este sería 2 por 2, 4 por 2, 8,
+
+07:02.227 --> 07:06.311
+el resultado de elevar 2 
+a la tercera potencia es un 8,
+
+07:06.437 --> 07:10.450
+así de fácil es como funcionan las potencias
+y eso es lo que tenemos en el código,
+
+07:10.576 --> 07:13.218
+vamos a verlo,
+justo aquí puedes ver
+
+07:13.344 --> 07:16.777
+que tengo mi ciclo for,
+imagínate que le paso el en base,
+
+07:16.903 --> 07:22.614
+le paso 2 y en n le paso 3,
+que sería un 2 a la 3,
+
+07:22.740 --> 07:26.440
+ok, una base 2 exponencial 3,
+
+07:26.566 --> 07:32.277
+comenzamos entonces, p comienza
+valiendo 1 y comienza valiendo 1,
+
+07:32.403 --> 07:37.305
+dice i o sea 1 es menor o igual que n,
+n era 3, si,
+
+07:37.431 --> 07:39.841
+1 si es menor o igual que 3,
+
+07:39.967 --> 07:42.160
+entonces incrementamos y ahora
+
+07:42.286 --> 07:48.640
+en este caso i vale 2, ok,
+
+07:48.640 --> 07:52.693
+sólo para llevar la cuenta,
+p que habíamos inicializado en 1
+
+07:52.819 --> 07:56.880
+simplemente dice 1 es
+
+07:56.880 --> 08:01.641
+o a este valor p le vamos a asignar
+el número 1 por la base,
+
+08:01.767 --> 08:05.476
+esta es la primera
+multiplicación, sería 1 por 2,
+
+08:05.602 --> 08:08.232
+ok, ¿cuánto valió p en este caso?
+
+08:08.358 --> 08:14.422
+la primera vez tuvo un valor de 2,
+excelente, ahora vamos a poner p acá
+
+08:14.548 --> 08:18.494
+de nuevo y vamos
+a ejecutar otra vez nuestro bucle,
+
+08:18.620 --> 08:25.925
+ahora i que es 2
+es menor que n, si, n es 3 y 2
+
+08:26.051 --> 08:31.098
+es menor o igual a 3,
+si, pasa por la condición,
+
+08:31.223 --> 08:37.313
+incrementamos, ahora
+i va a valer 3, excelente,
+
+08:37.439 --> 08:43.658
+y p que valía 2 va a ser
+igual a 2 por 2, ahora p vale 4,
+
+08:44.504 --> 08:49.034
+se vuelve a iterar
+i que es 3 es menor o igual que n,
+
+08:49.160 --> 08:51.296
+pues no es menor pero si es igual,
+
+08:51.421 --> 08:54.912
+entonces excelente,
+se ejecuta y p valía 4,
+
+08:55.038 --> 09:00.087
+entonces 4 por 2 es 8,
+por último p termina valiendo 8,
+
+09:00.213 --> 09:03.240
+excelente, ya viste
+cómo pasamos esta lógica
+
+09:03.240 --> 09:05.620
+matemática a un algoritmo o a una serie
+
+09:05.745 --> 09:08.600
+de instrucciones a seguir
+que nos ayudan a realizar
+
+09:08.600 --> 09:12.265
+la potencia de un número,
+esto es excelente
+
+09:12.391 --> 09:16.300
+y ahora vamos a ver que funcione,
+probemos ya en código directamente,
+
+09:16.426 --> 09:17.763
+para esto voy a borrar todos
+
+09:17.889 --> 09:20.511
+los números auxiliares
+raros que le metí porque si no,
+
+09:20.637 --> 09:23.818
+no va a compilar de ninguna forma,
+
+09:23.943 --> 09:27.720
+vamos a ponerle p por base
+y date cuenta cómo al utilizar
+
+09:27.720 --> 09:30.344
+estas variables nos evitamos
+tener que quemar valores,
+
+09:30.470 --> 09:33.583
+eso es algo que es simple
+y sencillamente excelente,
+
+09:33.709 --> 09:35.353
+es una buena práctica,
+
+09:36.223 --> 09:39.920
+muy bien ya lo tenemos todo listo,
+i igual a 1, p igual a base,
+
+09:39.920 --> 09:46.140
+excelente, return, vamos
+a guardar ctrl s y procede
+
+09:46.266 --> 09:50.954
+a compilar el código,
+ya sabes que se compila con f6,
+
+09:51.080 --> 09:55.253
+uy y veamos los resultados,
+dice cuando n vale a 0
+
+09:55.379 --> 09:59.620
+el resultado de la potencia es 1,
+si 2 a la 0 efectivamente nos da 1,
+
+09:59.745 --> 10:05.600
+luego cuando la potencia es 1,
+o sea 2 a la 1 nos da 2, 2 a la 2 nos da 4,
+
+10:05.600 --> 10:07.758
+2 a la 3 nos da 8
+y mira que este
+
+10:07.883 --> 10:10.040
+es el que nosotros hicimos
+a mano y nos da lo mismo
+
+10:10.040 --> 10:13.617
+a mano que por código,
+eso significa que está excelente,
+
+10:13.743 --> 10:18.525
+luego 4, 16, 2 a la 5 nos da 32,
+
+10:18.651 --> 10:24.997
+2 a la 6 nos da 64,
+2 a la 7 128, 2 a la 8 256
+
+10:25.123 --> 10:29.600
+y así va incrementando
+sucesivamente con cada uno
+
+10:29.600 --> 10:34.314
+de los valores, mira que ya
+con esto hiciste tu primer programa
+
+10:34.440 --> 10:35.641
+que utiliza una función,
+
+10:35.767 --> 10:38.658
+cuéntame si te emocionó bastante
+en los comentarios,
+
+10:38.783 --> 10:40.960
+también recuerda que las funciones
+las vamos a utilizar
+
+10:40.960 --> 10:43.418
+muchísimo en el lenguaje C,
+siempre que tengas
+
+10:43.543 --> 10:46.280
+un bloque de código que
+vas a reutilizar bastante
+
+10:46.280 --> 10:49.618
+en tus programas,
+necesitas meter ese código
+
+10:49.743 --> 10:53.420
+en una función, simplemente
+es una buena práctica,
+
+10:53.546 --> 11:00.080
+con esto dicho
+nos vemos en la siguiente clase.

subir/Curso de Funciones en C/01-Introducción a las funciones en C/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/clases/fundamentos-matematicas/

subir/Curso de Funciones en C/01-Introducción a las funciones en C/03-powerofintegers_a2741312-e4b5-409e-b3ec-6a2e15a430b8.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+int power(int base, int n);
+
+int main() 
+{
+    int i;
+    for (i = 0; i < 10; i++)
+    {
+        printf("n = %d resultado de la potencia = %d\n", i, power(2,i));
+    }
+
+    return 0;
+}
+
+int power(int base, int n)
+{
+    int i, p;
+    p = 1;
+    for (i = 0; i <= n; i++)
+    {
+        p = p * base;
+    }
+
+    return p;
+}

subir/Curso de Funciones en C/01-Introducción a las funciones en C/04-Tipos de Funciones en C Argumentos y Valores de Retorno.mp4

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/04-Tipos de Funciones en C Argumentos y Valores de Retorno.vtt

@@ -0,0 +1,650 @@
+WEBVTT
+
+00:03.000 --> 00:05.981
+Bien, hasta aquí ya aprendiste cuestiones
+
+00:06.107 --> 00:09.160
+importantísimas sobre
+el manejo de funciones,
+
+00:09.160 --> 00:11.372
+como son la declaración de la función,
+
+00:11.498 --> 00:13.701
+que es cuando le dices al compilador,
+
+00:13.827 --> 00:16.268
+¿esta función existe? 
+¿Recuerdas lo que hacemos
+
+00:16.393 --> 00:19.200
+en la parte de arriba 
+donde estamos definiendo variables,
+
+00:19.326 --> 00:21.288
+donde estamos utilizando nuestros defines,
+
+00:21.414 --> 00:24.805
+donde estamos importando 
+nuestras bibliotecas de código?
+
+00:24.931 --> 00:27.168
+También ya sabes
+cómo llamar una función,
+
+00:27.294 --> 00:30.599
+que escribes el nombre, paréntesis, 
+le pasas o no argumentos,
+
+00:30.724 --> 00:34.216
+y por supuesto también
+sabes cómo declarar una función,
+
+00:34.342 --> 00:35.998
+que es donde escribimos todo el código
+
+00:36.123 --> 00:38.760
+que va a vivir dentro de la misma.
+
+00:38.760 --> 00:40.649
+Ahora te quiero hablar
+de algo importantísimo,
+
+00:40.775 --> 00:43.406
+que son los tipos de funciones
+
+00:43.532 --> 00:47.034
+según el valor o el dato 
+que te van a retornar.
+
+00:47.160 --> 00:50.052
+Vamos a verlo. En Visual Studio Code, 
+como siempre,
+
+00:50.178 --> 00:52.740
+vamos a abrir un nuevo archivo,
+vamos a guardarlo,
+
+00:52.866 --> 00:56.859
+le voy a poner function types,
+
+00:58.732 --> 01:01.362
+types per argument,
+
+01:01.622 --> 01:07.607
+per return type. Listo, punto C.
+
+01:07.733 --> 01:10.284
+Y aquí te quiero hablar de algunos temas
+
+01:10.410 --> 01:14.930
+que vamos a tener. 
+Lo primero es que vamos a tener funciones
+
+01:15.763 --> 01:22.753
+sin argumentos 
+y sin valor de retorno.
+
+01:23.825 --> 01:27.107
+Estas funciones van a utilizar el tipo void
+
+01:27.233 --> 01:30.298
+y van a declararse de la siguiente forma,
+
+01:30.424 --> 01:34.736
+function name, y en donde deberías
+ponerle el argumento,
+
+01:34.862 --> 01:40.476
+simplemente vas a abrir
+y cerrar tus paréntesis.
+
+01:40.602 --> 01:43.141
+Vamos a poner punto y coma,
+
+01:43.267 --> 01:45.007
+ya le ponemos punto y coma
+
+01:45.133 --> 01:47.122
+y esa sería la declaración de una función
+
+01:47.248 --> 01:50.536
+que no va a tener 
+ningún tipo de argumentos
+
+01:50.662 --> 01:53.139
+y no va a retornar valores de ningún tipo.
+
+01:53.265 --> 01:58.090
+Por ejemplo, esta función simplemente 
+la llamarías así, function name,
+
+01:58.585 --> 02:01.251
+paréntesis y punto y coma,
+
+02:01.377 --> 02:05.098
+y esto sería el llamado a la función,
+y obviamente esta función
+
+02:05.223 --> 02:07.447
+la definirías de la siguiente forma,
+
+02:07.573 --> 02:14.167
+void function name, punto y coma. 
+Perfecto.
+
+02:14.582 --> 02:21.135
+Luego vamos a tener
+funciones con argumentos
+
+02:23.299 --> 02:27.727
+pero sin valores a retornar.
+
+02:30.152 --> 02:32.412
+Estas funciones se van a definir igual
+
+02:32.538 --> 02:36.788
+utilizando la instrucción void, 
+sería function name,
+
+02:37.796 --> 02:41.176
+y obviamente esta sí tendría 
+tus argumentos.
+
+02:41.302 --> 02:44.977
+Entonces tendríamos que pasarle 
+un tipo de dato,
+
+02:45.103 --> 02:46.672
+lo que sea que vayamos a tener aquí,
+
+02:46.798 --> 02:49.998
+y quiero profundizar un poquito más 
+en estos argumentos.
+
+02:50.123 --> 02:54.095
+Quiero contarte que estos argumentos
+pueden ser de todos los tipos de datos
+
+02:54.221 --> 02:56.776
+que ya te hablé previamente
+en cursos anteriores.
+
+02:56.902 --> 02:58.582
+Eso es todo lo que necesitas saber.
+
+02:58.708 --> 03:03.099
+Obviamente no son solo ints, 
+si tú quisieras puedes trabajar con float,
+
+03:03.225 --> 03:06.840
+si tú quisieras puedes trabajar
+con un long, puedes trabajar con todo tipo
+
+03:06.840 --> 03:10.597
+de datos de argumentos,
+pero recuerda que C es un lenguaje tipado,
+
+03:10.723 --> 03:12.680
+de hecho se cataloga como un lenguaje
+
+03:12.806 --> 03:17.036
+relativamente débilmente tipado, 
+pero eso simple y sencillamente
+
+03:17.162 --> 03:20.629
+no evita que el compilador siempre te pida
+
+03:20.755 --> 03:23.280
+el tipo de datos que le estás requiriendo
+
+03:23.280 --> 03:25.098
+al lenguaje, y con esto dicho,
+
+03:25.224 --> 03:28.041
+pues debes de ser muy cuidadoso
+al escribirlo,
+
+03:28.239 --> 03:31.606
+y aquí te va un tip 
+que yo te he dado desde el primer curso,
+
+03:31.732 --> 03:35.818
+siempre trata de saber cuáles 
+van a ser los resultados de tus cálculos
+
+03:35.943 --> 03:39.141
+dentro de las funciones de antemano 
+para que no te agarre por sorpresa
+
+03:39.267 --> 03:42.489
+y no sea que un tipo de dato
+que declaraste se quede corto
+
+03:42.615 --> 03:46.644
+y tengas el famoso de que se
+desborda la memoria,
+
+03:46.770 --> 03:49.547
+es decir, no cabe la información 
+que tú quieres guardar
+
+03:49.673 --> 03:52.919
+en la variable que le asignaste,
+demás cuestiones.
+
+03:53.045 --> 03:55.708
+Antes de continuar 
+con este segundo ejemplo
+
+03:55.833 --> 03:59.620
+de unas funciones con argumentos 
+pero sin valores a retornar,
+
+03:59.746 --> 04:03.802
+bueno, aquí te quiero decir 
+que FunctionName, bueno,
+
+04:03.928 --> 04:07.942
+para la parte que sería la definición
+de nuestra función,
+
+04:08.068 --> 04:10.880
+hay que abrir y cerrar
+nuestras llavecitas,
+
+04:10.880 --> 04:16.994
+aquí iría la lógica, lógica, 
+y aquí no lleva punto y coma, ¿ok?
+
+04:17.120 --> 04:20.298
+Recuerda, el primero,
+lo que hacemos cuando
+
+04:20.423 --> 04:22.209
+escribimos la función por primera vez,
+
+04:22.335 --> 04:25.972
+por decirlo de alguna forma,
+contarle al compilador
+
+04:26.098 --> 04:30.369
+que nuestra función existe, 
+se llama declaración de la función,
+
+04:30.495 --> 04:32.518
+tenemos la forma de ejecutar
+
+04:32.643 --> 04:38.560
+o llamar a nuestra función y vamos a tener
+la parte de la definición.
+
+04:38.560 --> 04:40.678
+Aquí es muy importante
+que no te confundas,
+
+04:40.803 --> 04:42.453
+por eso estoy haciendo este hincapié,
+
+04:42.579 --> 04:45.068
+tenemos lo primero que es declaración
+
+04:45.194 --> 04:48.187
+y vamos a tener la parte de definición
+
+04:48.313 --> 04:52.013
+que es cuando nosotros 
+escribimos la lógica de nuestra función,
+
+04:52.139 --> 04:55.160
+ese es como un repaso
+para que lo tengas en cuenta.
+
+04:55.160 --> 04:56.740
+Bueno, continuamos con el ejemplo
+
+04:56.866 --> 04:59.702
+de funciones con argumentos 
+pero sin valores a retornar,
+
+04:59.828 --> 05:04.536
+recuerda que entonces la instrucción void
+nos va a servir para indicar
+
+05:04.662 --> 05:09.415
+que el return type de nuestra función,
+si te acuerdas del prototipo de la función,
+
+05:09.541 --> 05:12.947
+esto se llama return type
+
+05:14.401 --> 05:16.758
+y este return type puede ser,
+
+05:16.884 --> 05:18.883
+como ya vimos anteriormente, un int,
+
+05:19.009 --> 05:23.038
+también puede ser un void y el void
+simple y sencillamente
+
+05:23.163 --> 05:26.196
+indica que no nos va a retornar nada
+
+05:26.322 --> 05:27.847
+y aquí quizás te preguntas
+
+05:27.973 --> 05:31.456
+¿para qué voy a yo utilizar una función 
+que no me retorna nada?
+
+05:31.582 --> 05:33.760
+¿Qué sentido tiene?
+
+05:33.760 --> 05:36.348
+Pues la verdad es 
+que tiene muchísimo sentido,
+
+05:36.473 --> 05:38.573
+por ejemplo, una de las aplicaciones,
+
+05:38.699 --> 05:42.241
+de hecho la aplicación más importante 
+que tiene el lenguaje C hoy en día
+
+05:42.367 --> 05:44.000
+es en sistemas embebidos,
+
+05:44.000 --> 05:47.193
+todo lo que tiene que ver con desarrollo
+de circuitos electrónicos,
+
+05:47.319 --> 05:50.798
+lo que tiene que ver 
+con sistemas como por ejemplo
+
+05:50.923 --> 05:53.944
+drivers y cuestiones de ese tipo 
+y cuando hablamos de hardware,
+
+05:54.070 --> 05:56.728
+muchas veces tú puedes ejecutar
+
+05:56.854 --> 05:58.891
+una función para que haga algo,
+
+05:59.017 --> 06:02.533
+por ejemplo que cambie un valor de 0 a 1 
+pero no necesitas
+
+06:02.659 --> 06:06.130
+que esa función haga
+ningún tipo de procesamiento numérico
+
+06:06.256 --> 06:07.896
+necesariamente que te va a retornar
+
+06:08.021 --> 06:10.683
+para que tú hagas algo
+con esos números, ¿por qué?
+
+06:10.809 --> 06:12.673
+Porque como estás trabajando con hardware
+
+06:12.799 --> 06:15.720
+simplemente le pides a la función, 
+oye, configúrame
+
+06:15.720 --> 06:18.178
+el robot para que avance hacia adelante
+
+06:18.303 --> 06:20.760
+y ya, la función no te necesita 
+retornar nada
+
+06:20.760 --> 06:23.124
+porque ya hizo que el robot 
+vaya hacia adelante
+
+06:23.249 --> 06:25.560
+simplemente modificando los ceros y unos
+
+06:25.560 --> 06:28.782
+que se van a encargar de cambiar 
+la dirección de giro de los motores,
+
+06:28.908 --> 06:31.933
+ese es un caso de uso, 
+hay muchísimos más.
+
+06:32.059 --> 06:36.944
+Vamos a nuestro editor de código, 
+te voy a mostrar el ejemplo
+
+06:37.070 --> 06:40.765
+de cómo llamarías esta función, es igual,
+function name, obviamente
+
+06:40.891 --> 06:45.958
+aquí sí le pasarías el número float 
+o la variable que necesites,
+
+06:46.084 --> 06:49.760
+pondrías punto y coma y por último 
+cómo haríamos la parte
+
+06:49.760 --> 06:52.478
+de la definición de nuestra función,
+
+06:52.603 --> 06:55.995
+recuerda que la definición es
+donde ponemos el código de la misma,
+
+06:56.121 --> 07:01.346
+function name, float,
+
+07:03.550 --> 07:07.960
+punto y coma y aquí irían nuestras llaves,
+
+07:07.960 --> 07:10.560
+aquí iría la lógica.
+
+07:10.560 --> 07:13.774
+Muy bien, con eso ya estamos listos 
+con este tipo de funciones
+
+07:13.900 --> 07:19.979
+que tienen argumentos, recuerda argumentos
+pero sin valores a retornar,
+
+07:20.105 --> 07:23.040
+por ejemplo, si tuvieras
+un pequeño robot móvil
+
+07:23.040 --> 07:24.921
+y este robot móvil fuera hacia adelante,
+
+07:25.046 --> 07:27.120
+atrás, izquierda o derecha, 
+tú podrías hacer
+
+07:27.120 --> 07:29.309
+una función que se llame dirección
+
+07:29.435 --> 07:33.153
+y el argumento puede ser
+adelante, atrás, izquierda o derecha
+
+07:33.279 --> 07:35.619
+y ya conforme tú le pasas el argumento
+
+07:35.745 --> 07:37.640
+haces que el robot, que los motores giren
+
+07:37.640 --> 07:40.268
+en unas direcciones
+o en otras direcciones,
+
+07:40.394 --> 07:42.200
+ese es un caso de uso de una función
+
+07:42.200 --> 07:45.459
+que no necesitaría retornarte
+absolutamente nada
+
+07:45.585 --> 07:49.400
+y funcionaría perfectamente
+bien porque cumpliría
+
+07:49.400 --> 07:50.960
+con su cometido.
+
+07:50.960 --> 07:52.262
+Volvemos a nuestro código,
+
+07:52.388 --> 07:55.460
+aquí se me fue un pequeño error 
+por copiar, casi casi copiar y pegar,
+
+07:55.586 --> 07:57.078
+puse el punto y coma,
+
+07:57.203 --> 07:59.480
+recuerda que cuando estamos definiendo 
+nuestra función
+
+07:59.480 --> 08:02.680
+no lleva el punto y coma, continuamos.
+
+08:02.680 --> 08:04.856
+Ahora te quiero mostrar
+otro tipo de funciones
+
+08:04.982 --> 08:08.564
+que va a ser la función sin argumentos
+
+08:10.531 --> 08:14.503
+pero que sí nos retorna un valor,
+
+08:14.709 --> 08:20.625
+funciones con argumentos, sin argumentos
+
+08:23.432 --> 08:30.416
+pero que sí tiene valores a retornar.
+
+08:32.801 --> 08:35.383
+Esta función como ya te lo
+deberías estar imaginando
+
+08:35.509 --> 08:38.160
+en este punto, 
+pues simple y sencillamente
+
+08:38.160 --> 08:42.877
+va a tener el tipo de return type, 
+int o float
+
+08:43.003 --> 08:45.420
+o lo que sea que queramos retornar
+
+08:45.546 --> 08:50.316
+y estas funciones pues igual
+function name no necesitan
+
+08:50.441 --> 08:54.080
+tener un argumento, serían así la parte
+
+08:54.080 --> 08:58.778
+de la declaración de la función y ya 
+por último tendríamos funciones
+
+08:58.904 --> 09:05.091
+que tienen con argumentos 
+con return value y estas funciones
+
+09:06.325 --> 09:09.680
+y estas funciones, 
+como te lo debes estar imaginando
+
+09:09.680 --> 09:13.743
+van a ser de la siguiente forma, 
+function name
+
+09:14.389 --> 09:17.660
+y van a tener un tipo de datos 
+en el argumento
+
+09:17.660 --> 09:23.200
+o varios como cualquier argumento 
+de una función en el prototipo de la misma.
+
+09:23.200 --> 09:26.495
+Con esto dicho ya vimos los cuatro tipos
+
+09:26.621 --> 09:28.780
+de funciones 
+con los que te vas a encontrar,
+
+09:28.906 --> 09:31.300
+no quiero que te confundas con el void, 
+simplemente
+
+09:31.426 --> 09:34.194
+indica que no va a haber nada retornando,
+
+09:34.320 --> 09:37.198
+eso es absolutamente todo 
+lo que te indica el void,
+
+09:37.323 --> 09:40.200
+es una función de tipo void,
+
+09:40.200 --> 09:42.021
+cuando se declara el return type así,
+
+09:42.147 --> 09:45.240
+recuerda que podemos tener todas
+estas combinaciones
+
+09:45.240 --> 09:49.588
+que es una función que no tiene 
+return type y no tiene argumentos,
+
+09:49.714 --> 09:53.338
+una función que no tiene return type 
+y tiene argumentos,
+
+09:53.463 --> 09:57.086
+una función que tiene
+return type pero no tiene argumentos
+
+09:57.212 --> 09:59.318
+y la función que lo tiene todo,
+
+09:59.443 --> 10:03.560
+que tiene un return type 
+y que tiene también argumentos.
+
+10:03.560 --> 10:05.866
+En la próxima clase 
+te voy a mostrar un ejemplo
+
+10:05.991 --> 10:08.600
+de una función de este último
+
+10:08.600 --> 10:10.728
+porque creo que puede ser el más difícil,
+
+10:10.853 --> 10:14.127
+de hecho. de este primero
+que es la función que no tiene return type
+
+10:14.253 --> 10:15.649
+y que no tiene argumentos
+
+10:15.775 --> 10:17.240
+porque seguro te estás preguntando bueno,
+
+10:17.240 --> 10:22.680
+y eso qué, para qué lo voy a utilizar pues
+ya lo veremos en la siguiente clase.

subir/Curso de Funciones en C/02-Manejo de funciones en C/01-Funciones en C Uso de void y manejo de return types.mp4

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

subir/Curso de Funciones en C/02-Manejo de funciones en C/01-Funciones en C Uso de void y manejo de return types.vtt

@@ -0,0 +1,561 @@
+WEBVTT
+
+00:03.000 --> 00:05.233
+Bueno, veamos un ejemplo de una función
+
+00:05.359 --> 00:09.487
+que no reciba argumentos
+y que no tenga un return type.
+
+00:09.613 --> 00:11.728
+Vamos a nuestro editor de código,
+
+00:11.853 --> 00:14.660
+archivo nuevo, guardamos.
+Lo primero que vamos a hacer
+
+00:14.660 --> 00:19.107
+es llamar nuestro include
+y vamos a importar nuestra stdio,
+
+00:19.233 --> 00:20.480
+que es la clásica librería
+
+00:20.480 --> 00:22.987
+que hemos estado
+usando en nuestros cursos.
+
+00:23.113 --> 00:27.474
+Luego vamos a poner
+nuestro main. Perfecto.
+
+00:27.600 --> 00:30.034
+No necesito ningún tipo de argumento acá.
+
+00:30.160 --> 00:32.760
+Ahora tú ya sabes que
+esto es una función y sí,
+
+00:32.760 --> 00:35.744
+es la función en donde está
+todo tu código en C.
+
+00:35.870 --> 00:38.560
+Ya ahora también sabes
+que esta función tiene
+
+00:38.560 --> 00:41.911
+un return type de tipo entero
+y por eso retornamos
+
+00:42.037 --> 00:44.772
+un cero al final
+y esto le indica al compilador
+
+00:44.898 --> 00:47.893
+que todo se ejecutó sin problemas.
+
+00:48.019 --> 00:52.840
+Tenemos el main y bueno,
+no voy a necesitar pasar nada
+
+00:52.840 --> 00:56.416
+de estos argumentos que me pone aquí
+Visual Studio Code por defecto.
+
+00:56.542 --> 00:59.543
+Eso no se necesita. Vamos a continuar.
+
+01:00.910 --> 01:04.993
+Ahora vamos a ver qué podemos sacar
+
+01:05.119 --> 01:06.845
+con este tipo de funciones.
+
+01:06.971 --> 01:11.176
+Primero vamos a definir nuestra función
+que, como ya te lo había dicho,
+
+01:11.302 --> 01:13.873
+va a ser de tipo void. 
+Así que ponemos void.
+
+01:13.999 --> 01:16.869
+Ese es nuestro return type. 
+Luego declaramos
+
+01:16.994 --> 01:19.276
+nuestra función que sería demo,
+
+01:19.934 --> 01:23.318
+simple y sencillamente,
+y le indicamos que va a ser
+
+01:23.443 --> 01:26.440
+una función sin ningún valor a retornar.
+
+01:26.440 --> 01:29.158
+Aquí quiero enseñarte algo más
+y es que como buena práctica
+
+01:29.283 --> 01:32.157
+también puedes indicar
+acá void para que sepa
+
+01:32.283 --> 01:36.049
+que no vas a tener
+ningún tipo de argumentos.
+
+01:36.175 --> 01:39.280
+No lo vamos a hacer ahorita,
+de momento, simplemente
+
+01:39.280 --> 01:41.499
+quiero que sepas que existe esa opción.
+
+01:41.624 --> 01:45.544
+Vamos a continuar con nuestro código.
+Ahora ya tenemos nuestra función,
+
+01:45.670 --> 01:46.692
+vamos a llamarla.
+
+01:46.818 --> 01:51.520
+Simplemente escribiríamos demo,
+abrimos y cerramos y ponemos
+
+01:51.520 --> 01:54.918
+punto y coma y quiero
+que esta función demo
+
+01:55.043 --> 01:58.598
+me haga la impresión
+de una simple y sencilla suma.
+
+01:59.124 --> 02:03.099
+Vamos a pasar a hacer
+la parte de la definición
+
+02:03.225 --> 02:06.840
+de nuestra función. Entonces void demo,
+
+02:08.141 --> 02:12.528
+no necesitamos pasarle nada,
+abrimos y cerramos nuestras llaves.
+
+02:12.654 --> 02:14.629
+Esta es otra forma de identar
+
+02:14.755 --> 02:16.918
+o de poner organizadas tus llaves.
+
+02:17.043 --> 02:19.520
+A mí me gusta más la clásica
+que siempre he estado utilizando
+
+02:19.520 --> 02:23.218
+en el curso, pero eso ya
+es una cuestión de gustos personales.
+
+02:23.744 --> 02:27.541
+Vamos a declarar int a,
+
+02:28.534 --> 02:32.611
+punto y coma,
+vamos a declarar un int b también.
+
+02:32.737 --> 02:34.760
+Aquí lo que estoy
+haciendo es una declaración
+
+02:34.760 --> 02:37.198
+de varias variables,
+todas de tipo entero,
+
+02:37.323 --> 02:40.607
+la variable a y la variable b.
+Vamos a hacer una suma,
+
+02:41.647 --> 02:47.876
+sum es igual a,
+vamos a sumar a más b,
+
+02:50.096 --> 02:54.838
+a más b, punto y coma y vamos
+a darle unos valores a,
+
+02:54.964 --> 03:00.822
+a va a ser igual a 100,
+b va a ser igual a 100,
+
+03:01.582 --> 03:03.440
+porque pues así nosotros
+podemos hacer la suma
+
+03:03.440 --> 03:06.658
+tan rápido como la
+computadora y luego vamos
+
+03:06.783 --> 03:10.137
+a simple y sencillamente
+ver qué ocurre con esto.
+
+03:10.263 --> 03:11.976
+¿Qué tendríamos que hacer aquí?
+
+03:12.102 --> 03:17.140
+Pues imprimir nuestro resultado,
+vamos a imprimir el resultado de la suma.
+
+03:18.819 --> 03:24.832
+The result is dos puntos %d,
+
+03:26.126 --> 03:30.440
+ya sabes ponemos la comita
+para indicar que acá
+
+03:30.440 --> 03:33.277
+vamos a poner nuestra
+variable y nuestra variable
+
+03:33.403 --> 03:38.723
+va a ser la suma.
+Uy, ese autocomplete que no me gustó.
+
+03:38.849 --> 03:41.351
+Listo y punto y coma.
+Excelente, tenemos
+
+03:41.477 --> 03:43.880
+nuestra función demo,
+si te das cuenta es algo
+
+03:43.880 --> 03:46.740
+súper simple, solo se
+encarga de imprimir un valor,
+
+03:46.865 --> 03:51.181
+es absolutamente sencillo,
+todo lo hacemos dentro de la función,
+
+03:51.307 --> 03:54.695
+así que no le tenemos que pasar ningún
+tipo de argumentos, vamos a guardar
+
+03:54.821 --> 03:59.287
+y vamos a ejecutar
+la misma para ver el resultado
+
+03:59.547 --> 04:06.517
+y hay un problema,
+dice <i>error sum undeclared first use</i>,
+
+04:06.643 --> 04:08.993
+claro, no declaramos
+nuestra variable sum,
+
+04:09.119 --> 04:11.259
+vamos a declararla acá
+
+04:14.499 --> 04:18.563
+y vamos a volver a ejecutar
+nuestro código.
+
+04:19.549 --> 04:21.566
+Compile successfully
+
+04:21.692 --> 04:27.240
+y me dice the result is 200, perfecto,
+el resultado es 200.
+
+04:27.240 --> 04:30.464
+Si te das cuenta lo que
+hicimos aquí fue el proceso
+
+04:30.590 --> 04:33.145
+tal cual correcto,
+declaramos nuestra función,
+
+04:33.271 --> 04:36.729
+llamamos nuestra función
+y definimos nuestra función,
+
+04:36.855 --> 04:40.320
+en todo momento
+no utilizamos para nada
+
+04:40.320 --> 04:44.095
+nuestros argumentos
+de ningún tipo y no utilizamos
+
+04:44.220 --> 04:47.680
+nuestros return type.
+Ahora voy a hacer
+
+04:47.680 --> 04:50.129
+unas modificaciones en esta
+función para que veas pues
+
+04:50.255 --> 04:52.895
+cómo más se puede hacer,
+por ejemplo,
+
+04:53.021 --> 04:59.626
+qué pasa si yo en mi definición le digo
+que vamos a tener int a e int b,
+
+05:00.606 --> 05:02.880
+ah bueno
+ya es diferente la cosa,
+
+05:02.880 --> 05:05.989
+no, simple y sencillamente
+vamos a pasar
+
+05:06.115 --> 05:08.777
+la declaración de mis variables
+aquí afuerita,
+
+05:12.081 --> 05:13.998
+vamos a decirle que a es igual a 100,
+
+05:14.123 --> 05:17.901
+vamos a quitarle sum porque
+eso si no lo necesitamos
+
+05:18.027 --> 05:21.675
+y a mi función le voy
+a cambiar el nombre a sum,
+
+05:23.969 --> 05:27.360
+de hecho sum de suma
+en español, no,
+
+05:27.360 --> 05:30.658
+le voy a poner add de suma
+ya en inglés porque es una mejor
+
+05:30.783 --> 05:32.981
+práctica manejar todo en inglés,
+
+05:33.107 --> 05:37.606
+vamos a ponerle add
+y aquí se va a llamar mi variable add,
+
+05:40.207 --> 05:46.000
+esta variable va a ser del tipo entero,
+punto y coma,
+
+05:46.240 --> 05:48.887
+muy bien todo maravilloso,
+ahora hay que pasarle
+
+05:49.013 --> 05:55.320
+nuestras dos variables
+int a int b, excelente
+
+05:55.320 --> 06:01.921
+ya tenemos declarado a y b arriba,
+perfecto, pasémosle los valores acá,
+
+06:05.255 --> 06:08.582
+entonces no, así se pasan,
+podemos pasarle
+
+06:08.708 --> 06:11.360
+de la siguiente forma
+directamente los valores,
+
+06:11.360 --> 06:13.686
+quiero que veas las dos
+formas de hacerlo
+
+06:13.812 --> 06:17.481
+para que te quede claro,
+quitamos este punto y coma,
+
+06:17.607 --> 06:20.418
+hagamos un repaso,
+aquí que está pasando,
+
+06:20.543 --> 06:24.030
+bueno aquí estoy como ya sabes
+declarando mi función,
+
+06:24.156 --> 06:27.018
+aquí estoy ejecutando
+o llamando mi función
+
+06:27.143 --> 06:30.400
+y aquí estoy definiendo
+mi función, es decir,
+
+06:30.400 --> 06:33.518
+estoy haciendo toda la lógica 
+que vamos a tener,
+
+06:34.035 --> 06:37.044
+perfecto, veamos
+cómo funciona esto,
+
+06:38.781 --> 06:41.598
+compilamos y ejecutamos
+y nos da un error, claro,
+
+06:41.724 --> 06:44.315
+porque estoy imprimiendo
+sum y ahora se llama add,
+
+06:44.942 --> 06:47.855
+excelente, guardamos,
+es bien importante
+
+06:47.981 --> 06:49.934
+que todo el tiempo estén leyendo la terminal,
+
+06:50.060 --> 06:53.218
+la consola y mira
+el resultado es 200,
+
+06:53.343 --> 06:56.760
+nos da el mismo resultado
+pero lo hicimos de una forma
+
+06:56.760 --> 07:00.133
+totalmente distinta
+y eso es importante
+
+07:00.259 --> 07:02.640
+que lo tengas claro, ahorita
+te voy a mostrar
+
+07:02.640 --> 07:05.113
+la otra forma que es teniendo
+un return type,
+
+07:05.239 --> 07:11.648
+vamos a cambiarlo aquí también,
+este return sería entero,
+
+07:13.091 --> 07:15.817
+perfecto, esto no cambia acá, ya en esta
+
+07:15.943 --> 07:19.560
+función lo primero que
+voy a hacer es comentar
+
+07:19.560 --> 07:21.739
+este print, ya no lo
+vamos a necesitar,
+
+07:21.865 --> 07:26.160
+justo aquí como lo teníamos,
+muy bien y este void
+
+07:26.160 --> 07:28.478
+hay que cambiarlo porque
+como sabes, como lo hicimos
+
+07:28.603 --> 07:31.310
+desde la parte de arriba,
+bueno ahora va a ser
+
+07:31.436 --> 07:34.656
+un int porque vamos a
+retornar un valor, perfecto,
+
+07:34.781 --> 07:37.695
+vamos por último a
+agregar nuestro return
+
+07:37.821 --> 07:41.538
+y la variable que voy a retornar
+es add guardo
+
+07:41.663 --> 07:44.115
+y esto debería de funcionar
+sin problema
+
+07:44.241 --> 07:46.865
+pero hay que agregar ahora el print
+aquí arriba,
+
+07:46.991 --> 07:52.740
+entonces simplemente me lo voy
+a robar de acá y lo voy
+
+07:52.866 --> 07:55.698
+a imprimir aquí abajito,
+excelente,
+
+07:56.495 --> 08:00.131
+guardamos, vamos a ver si esto
+funciona de forma adecuada,
+
+08:00.257 --> 08:03.698
+fnf6 para compilar
+y ejecutar y mira que,
+
+08:05.147 --> 08:08.286
+que está pasando, nos dice el resultado es
+
+08:08.763 --> 08:11.993
+41.400,
+
+08:12.119 --> 08:17.826
+si es un número grande, 4.199.786, what?
+
+08:17.999 --> 08:22.258
+¿de dónde sacó esto?
+veamos, ¿por qué? ¿por qué pasó esto?
+
+08:22.384 --> 08:24.729
+porque estoy
+llamando la variable add como
+
+08:24.854 --> 08:26.698
+si yo estuviera adentro
+de la función,
+
+08:26.824 --> 08:31.264
+lo que tenemos que hacer es
+simple y sencillamente cambiar
+
+08:31.389 --> 08:35.061
+aquí por como lo hicimos
+ya de forma previa,
+
+08:35.187 --> 08:39.320
+vamos a guardar, vamos a
+ejecutar y ahora sí veamos
+
+08:39.446 --> 08:44.059
+qué resultado nos trae
+y todo está funcionando perfecto,
+
+08:44.185 --> 08:45.878
+hay muchas
+formas de cómo debemos
+
+08:46.003 --> 08:49.040
+de nosotros acceder a la
+información en C por cómo
+
+08:49.040 --> 08:51.968
+funciona internamente este
+lenguaje, eso lo veremos
+
+08:52.093 --> 08:54.960
+en cursos más avanzados
+pero hay algo que sí
+
+08:54.960 --> 08:58.038
+que tenemos que ver ahora
+y es cómo podemos llamar
+
+08:58.163 --> 09:02.474
+o pasar un argumento por valor
+o por referencia a nuestras funciones,
+
+09:02.600 --> 09:04.680
+veremos eso en la próxima clase.

subir/Curso de Funciones en C/02-Manejo de funciones en C/01-add_c0320bcc-2842-4e74-a4a7-11798f414800.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+int add(int a, int b);
+
+int main()
+{
+    printf("the result is %d", add(100, 100));
+    return 0;
+}
+
+int add(int a, int b)
+{
+    int add;
+    add = a + b;
+    return add;
+}

subir/Curso de Funciones en C/02-Manejo de funciones en C/02-Lecturas recomendadas.txt

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

subir/Curso de Funciones en C/02-Manejo de funciones en C/02-Paso de Argumentos por Valor en C Conceptos y Ejemplos Prácticos.mp4

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

subir/Curso de Funciones en C/02-Manejo de funciones en C/02-Paso de Argumentos por Valor en C Conceptos y Ejemplos Prácticos.vtt

@@ -0,0 +1,791 @@
+WEBVTT
+
+00:03.001 --> 00:05.768
+En el lenguaje C,
+un tema importantísimo
+
+00:05.894 --> 00:08.278
+es que por defecto en las funciones,
+
+00:08.404 --> 00:13.764
+siempre que pasamos argumentos,
+estos se pasan o se llaman por valor.
+
+00:13.890 --> 00:15.320
+¿Qué quiere decir esto?
+
+00:15.320 --> 00:18.409
+Que el compilador crea
+una copia de la variable
+
+00:18.535 --> 00:22.128
+que estamos pasándole
+y simplemente en esta copia temporal
+
+00:22.254 --> 00:25.771
+se encarga de almacenar el valor
+que estamos pasándole.
+
+00:25.897 --> 00:29.460
+Es decir, no modificamos directamente
+la variable original
+
+00:29.585 --> 00:32.120
+que tú declaraste al utilizarla
+
+00:32.120 --> 00:34.532
+cuando la estás pasando
+como un argumento de una función,
+
+00:34.657 --> 00:36.385
+sino que dentro de la función,
+
+00:36.511 --> 00:41.730
+dentro de todo el procesamiento,
+se utiliza la copia temporal que se ejecuta
+
+00:41.856 --> 00:46.162
+o que se utiliza para poder
+mantener la información clara.
+
+00:46.288 --> 00:50.040
+Esto es un poco complejo
+de entender,
+
+00:50.040 --> 00:53.596
+sobre todo para programadores
+de otros lenguajes contemporáneos a C,
+
+00:53.722 --> 00:55.480
+como podrían ser Fortran,
+
+00:55.480 --> 01:01.094
+que de hecho estaban acostumbrados a pasar
+los valores por referencia.
+
+01:01.220 --> 01:03.442
+¿Qué significa pasar
+un valor por referencia?
+
+01:03.568 --> 01:07.600
+Pasar un valor por referencia
+es ir directamente a la variable
+
+01:07.726 --> 01:10.896
+y cambiar el valor ahí.
+Entonces no estabas
+
+01:11.022 --> 01:15.141
+pasando solamente el valor,
+estabas pasándole la referencia
+
+01:15.267 --> 01:17.178
+de memoria que te daba acceso
+
+01:17.304 --> 01:18.957
+a modificar tu variable original.
+
+01:19.083 --> 01:23.100
+En C, cuando le pasamos una función,
+esto genera por nosotros,
+
+01:23.225 --> 01:26.000
+cuando le pasamos el valor a una función
+
+01:26.000 --> 01:29.074
+como su argumento,
+se genera una copia temporal
+
+01:29.199 --> 01:32.000
+de este y la que se modifica es la copia.
+
+01:32.000 --> 01:34.468
+No se va a la referencia
+de la memoria
+
+01:34.593 --> 01:37.060
+y no hace las modificaciones directamente
+
+01:37.060 --> 01:39.245
+sobre nuestras variables originales.
+
+01:39.371 --> 01:43.046
+Esto es algo muy positivo
+porque C te agrega un nivel de control
+
+01:43.172 --> 01:44.456
+que antes no tenías.
+
+01:44.582 --> 01:48.295
+Antes tenías que generar una copia 
+de la variable tú, etc.
+
+01:48.421 --> 01:50.166
+Ahora C lo hace por ti.
+
+01:50.291 --> 01:52.720
+¿Qué más hay que tomar en cuenta aquí?
+
+01:52.720 --> 01:56.464
+Bueno, los punteros o pointers
+o apuntadores como los conozcas.
+
+01:56.611 --> 01:58.280
+El puntero es una forma
+
+01:58.280 --> 02:00.718
+de pasar el valor por referencia,
+
+02:00.844 --> 02:04.720
+apuntando a la dirección
+de memoria de la variable
+
+02:04.720 --> 02:09.214
+para así modificar directamente
+el dato original que ibas a tener.
+
+02:09.340 --> 02:11.244
+Vemos un ejemplo de cómo funciona esto
+
+02:11.370 --> 02:14.019
+en el código que teníamos
+de clases anteriores.
+
+02:14.145 --> 02:18.640
+¿Recuerdas el programa que habíamos hecho
+en clases anteriores en donde te enseñaba
+
+02:18.640 --> 02:21.478
+cómo generar una función de una potencia?
+
+02:21.816 --> 02:24.187
+Pues mira, acuérdate que utilizábamos
+
+02:24.313 --> 02:30.378
+nuestro auxiliar i para saber que fuera 
+menor a n, que fuera un valor menor
+
+02:30.504 --> 02:33.404
+a lo que nosotros íbamos a tener
+para asegurarnos
+
+02:33.530 --> 02:37.330
+de que la potencia se ejecutara
+de forma correcta.
+
+02:37.456 --> 02:42.159
+Ahora mira que esto
+lo podemos hacer de manera distinta
+
+02:42.606 --> 02:45.298
+y es que nosotros aquí ya tenemos n,
+
+02:45.424 --> 02:49.004
+que si recuerdas n era
+el número al que estábamos
+
+02:49.130 --> 02:51.680
+elevando nuestra
+potencia, o sea,
+
+02:51.680 --> 02:54.758
+teníamos nuestra base, por ejemplo,
+2 y n que era nuestro exponente,
+
+02:54.883 --> 02:58.488
+que puede ser 2, 3, 4 o literalmente n,
+
+02:58.614 --> 03:02.800
+o sea, cualquier número que quepa
+dentro del tipo de datos integer.
+
+03:03.091 --> 03:06.534
+Perfecto, con esto dicho,
+quiero que te quede claro
+
+03:06.660 --> 03:09.276
+que cuando nosotros
+le pasamos n a nuestra función,
+
+03:09.402 --> 03:15.240
+este programa no va a modificar
+el valor original de n. ¿Por qué?
+
+03:15.240 --> 03:17.827
+Porque estamos trabajando
+con el valor, con la copia
+
+03:17.953 --> 03:20.453
+que genera del valor
+que teníamos en nuestra variable,
+
+03:20.579 --> 03:23.700
+no con la variable original en sí.
+
+03:23.894 --> 03:27.240
+Hagamos una modificación
+en el código superbreve,
+
+03:27.240 --> 03:29.973
+para empezar voy a eliminar el auxiliar i
+
+03:30.706 --> 03:34.680
+y voy a decirle que
+también voy a eliminar
+
+03:34.680 --> 03:36.938
+el auxiliar p, ahorita vas a ver por qué,
+
+03:37.063 --> 03:39.691
+te lo voy a explicar,
+no te preocupes, y vamos a decir
+
+03:39.817 --> 03:43.887
+que p es igual a 1, 
+para comenzar, perfecto,
+
+03:44.041 --> 03:47.417
+también voy a decir que n,
+
+03:48.124 --> 03:50.543
+si n es mayor que 0,
+
+03:52.084 --> 03:56.021
+entonces, y aquí mira que esta 
+es la nueva condición que estoy utilizando,
+
+03:56.147 --> 03:58.111
+¿por qué estoy utilizando la condición n?
+
+03:58.236 --> 04:01.310
+Ah, bueno, porque ahora
+voy a hacer la lógica directa, ¿ok?
+
+04:01.436 --> 04:05.557
+¿Qué pasaba? Si nos daban un exponente,
+por ejemplo, 3, bueno,
+
+04:05.683 --> 04:09.138
+3 es mayor que 0, sí,
+y para que lleguemos
+
+04:09.263 --> 04:12.200
+a que se deje de cumplir
+esta condición voy a utilizar
+
+04:12.200 --> 04:16.639
+n --. Entonces voy a tomar
+el valor original de n,
+
+04:16.765 --> 04:18.720
+que era 3, por poner un ejemplo
+
+04:18.720 --> 04:23.087
+para este caso que
+ahorita vamos a declararle,
+
+04:24.769 --> 04:27.480
+ok, sí, por ejemplo,
+aquí nos va a aparecer
+
+04:27.480 --> 04:31.338
+todo lo que es de 0 a 10, excelente,
+
+04:31.476 --> 04:36.539
+de 0 a 9 para ser exactos,
+y eso va a ir pasándose como n, ¿ok?
+
+04:36.966 --> 04:39.471
+Cada vez n va a ir pasando
+a nuestro ciclo for
+
+04:39.597 --> 04:42.478
+y vamos a hacer toda la lógica 
+de potencias que ya te enseñé,
+
+04:42.603 --> 04:45.330
+solo que ahora invertí 
+la lógica en mi ciclo for.
+
+04:45.456 --> 04:47.083
+Recuerda que si tienes dudas con esto
+
+04:47.209 --> 04:50.595
+también te recomiendo mucho
+nuestros cursos de algoritmos, ¿perfecto?
+
+04:50.721 --> 04:51.837
+Con esto dicho,
+
+04:51.963 --> 04:53.660
+vamos a analizar nuestro ciclo for,
+
+04:53.786 --> 04:56.835
+p es igual a 1, está bien,
+estamos inicializando p en 1,
+
+04:56.961 --> 05:00.040
+lo necesitamos, n mayor que 0, ¿por qué?
+
+05:00.040 --> 05:02.391
+Porque ahora en vez
+de hacer ascendente, o sea,
+
+05:02.516 --> 05:05.704
+que vaya sumando
+y vamos a ir restándole a n,
+
+05:05.830 --> 05:07.414
+hasta que n valga 0,
+
+05:07.540 --> 05:12.131
+la condición se deje de cumplir y con eso 
+tendríamos nuestra potencia lista.
+
+05:12.257 --> 05:15.361
+Por último, voy a agregar
+un print aquí,
+
+05:19.166 --> 05:23.727
+mira, el print me va a ir diciendo el valor 
+de n cada vez, eso está excelente.
+
+05:24.640 --> 05:26.035
+¿Te acuerdas que lo habíamos puesto aquí?
+
+05:26.161 --> 05:27.992
+n es igual a, muy bien,
+
+05:28.118 --> 05:31.725
+guardamos, compilamos y ejecutamos,
+
+05:33.320 --> 05:35.570
+voy a cerrar esto por aquí 
+en lo que se compila
+
+05:35.696 --> 05:39.350
+y todo está excelente.
+Date cuenta que dice n es 0,
+
+05:39.476 --> 05:41.322
+el resultado de la potencia es igual a 1,
+
+05:41.448 --> 05:44.379
+n es igual a 1, el resultado
+de la potencia es igual a 2,
+
+05:44.505 --> 05:47.250
+tal cual no estamos modificando n
+
+05:47.376 --> 05:49.160
+porque dentro de la función se trabaja
+
+05:49.160 --> 05:51.246
+con una copia de n,
+
+05:51.372 --> 05:58.680
+eso es de lo que se trata trabajar 
+por un valor en el lenguaje C.
+
+05:58.680 --> 06:00.803
+Para que esto te quede aún más claro,
+
+06:00.929 --> 06:03.600
+tengo un ejemplo preparado
+para ti y es que vamos
+
+06:03.600 --> 06:06.113
+a utilizar el código de nuestro programa
+
+06:06.238 --> 06:09.200
+Function1 que tienes
+en la sección de archivos,
+
+06:09.200 --> 06:11.140
+es el que en donde hicimos todo el código
+
+06:11.265 --> 06:13.400
+para una potencia.
+Lo primero que voy a hacer
+
+06:13.400 --> 06:18.470
+es sacar este print aquí porque lo voy
+a necesitar y vamos a borrar
+
+06:18.596 --> 06:22.504
+todo lo que era parte del ciclo for.
+Hagamos justamente eso,
+
+06:22.810 --> 06:24.760
+compongamos nuestra
+identación para que
+
+06:24.760 --> 06:26.725
+el programa se vea elegible y bonito,
+
+06:26.851 --> 06:32.960
+eso es muy importante y listo.
+Tenemos nuestro print,
+
+06:32.960 --> 06:36.589
+nuestro return,
+ya no voy a usar el auxiliar i,
+
+06:36.715 --> 06:39.792
+voy a poner directamente
+una variable llamada n,
+
+06:40.025 --> 06:43.540
+int n, y esta variable int n
+
+06:43.666 --> 06:48.021
+va a ser igual a 3, quiero hacer
+la potencia del número 3,
+
+06:48.147 --> 06:50.498
+aquí voy a cambiar este i, voy a poner n
+
+06:50.623 --> 06:53.680
+y potencia de 2, n que es la variable
+
+06:53.680 --> 06:57.878
+que tengo con el número 3,
+es una variable de tipo entero,
+
+06:58.003 --> 07:00.306
+entonces es compatible perfectamente
+
+07:00.432 --> 07:05.178
+con nuestra función
+que habíamos aquí declarado, perfecto.
+
+07:05.591 --> 07:07.760
+Ahora vamos a modificar acá abajo,
+
+07:07.760 --> 07:09.380
+ya no necesitaré p
+
+07:11.280 --> 07:15.660
+y este ciclo for va 
+a ser igual a p igual a 1,
+
+07:16.405 --> 07:20.687
+n menor que n mayor que 0,
+
+07:24.115 --> 07:26.934
+vamos a quitarle
+ese signo de interrogación,
+
+07:27.060 --> 07:32.128
+perfecto, y vamos a ponerle n --,
+
+07:33.830 --> 07:39.108
+n --. Ahora, ¿qué estoy haciendo aquí?
+¿por qué cambié esto? ¿qué está pasando?
+
+07:39.234 --> 07:43.840
+¿y por qué borré esta p? Bueno,
+primero esta p tiene que estar ahí,
+
+07:43.840 --> 07:45.921
+es lo que vamos a utilizar
+como nuestro auxiliar
+
+07:46.047 --> 07:49.856
+y esta p la tenemos
+que declarar de tipo entero, int
+
+07:51.396 --> 07:54.334
+p, punto y coma, eso es todo.
+
+07:54.460 --> 07:58.400
+Ahora, ¿qué está pasando
+en este ciclo for?
+
+07:58.400 --> 08:01.876
+Si te das cuenta,
+nosotros estamos declarando que n vale 3,
+
+08:02.002 --> 08:06.138
+nuestra llamada a la función power
+le va a pasar el exponente n,
+
+08:06.263 --> 08:08.840
+le va a pasar el número 3 y aquí quiero
+
+08:08.840 --> 08:10.604
+que te quede claro que estamos pasando
+
+08:10.730 --> 08:13.920
+las cosas por valor,
+si tuviéramos que pasarla
+
+08:13.920 --> 08:17.729
+por referencia sería un relajo,
+un problema, porque directamente
+
+08:17.855 --> 08:22.038
+estaríamos modificando nuestra variable n,
+habría mucho problema
+
+08:22.163 --> 08:25.600
+y no queremos eso,
+definitivamente no lo necesitamos,
+
+08:25.600 --> 08:27.277
+pero te explico qué está pasando,
+
+08:27.403 --> 08:30.059
+al pasarle este argumento
+a nuestra función,
+
+08:30.184 --> 08:32.184
+al pasarle este argumento
+a nuestra función,
+
+08:32.459 --> 08:37.081
+se genera una copia y solo toma
+el valor que teníamos guardado en n,
+
+08:37.207 --> 08:39.942
+ya con este valor n,
+simple y sencillamente
+
+08:40.068 --> 08:44.837
+nuestra función dice, 3 es mayor que 0,
+sí, entonces restémosle 1
+
+08:44.963 --> 08:49.200
+y hagamos la operación,
+la operación era p es igual a p por base,
+
+08:49.326 --> 08:51.486
+o sea, p es igual a 1 por 2,
+
+08:51.612 --> 08:54.202
+entonces nos da 2 y así sucesivamente
+
+08:54.328 --> 08:57.271
+nos va a dar la potencia
+tal cual como lo hacía.
+
+08:57.397 --> 08:58.794
+Quiero agregar algo para que veas
+
+08:58.919 --> 09:01.842
+cómo se modifica el valor de n 
+dentro de la función,
+
+09:01.968 --> 09:04.510
+pero afuera sigue manteniéndose el mismo,
+
+09:04.877 --> 09:07.340
+entonces voy a agregar aquí un print,
+
+09:08.420 --> 09:12.374
+un print f y dentro de este print
+
+09:12.500 --> 09:16.817
+voy a poner el valor temporal de n,
+
+09:19.070 --> 09:22.340
+de n es, vamos a ponerle aquí,
+
+09:22.466 --> 09:28.600
+se me fue ese espacio, 2 puntos
+%d y un saltito de línea
+
+09:28.600 --> 09:31.812
+para que todo se vea lindo,
+vamos a ponerle coma
+
+09:31.937 --> 09:35.520
+y nuestra variable n,
+punto y coma para finalizar,
+
+09:35.520 --> 09:38.097
+excelente y ahora quiero
+que veas el resultado
+
+09:38.222 --> 09:40.680
+de este programa,
+le voy a poner de nombre
+
+09:40.680 --> 09:46.586
+function1V2, perfecto,
+
+09:48.743 --> 09:53.820
+es del tipo c, vamos a compilar 
+y vamos a esperar
+
+09:53.820 --> 09:56.354
+el resultado de nuestro código.
+
+09:56.480 --> 10:01.180
+Y mira, aquí lo tenemos,
+el valor temporal de n es 3,
+
+10:01.180 --> 10:04.258
+¿qué está pasando aquí?
+Entramos al print,
+
+10:04.383 --> 10:07.460
+no se imprime esto 
+porque se está ejecutando
+
+10:07.460 --> 10:10.481
+nuestra función y el print
+sólo se va a imprimir
+
+10:10.607 --> 10:12.620
+cuando se termine
+de ejecutar nuestra función
+
+10:12.620 --> 10:17.900
+y tengamos el resultado que la función
+nos retorna, entonces dentro de la función,
+
+10:17.900 --> 10:20.118
+en cada una de las iteraciones
+de mi ciclo for,
+
+10:20.243 --> 10:23.590
+lo que estoy haciendo es que imprimo
+el valor temporal de n,
+
+10:23.730 --> 10:25.325
+el valor temporal de n es 3,
+
+10:25.451 --> 10:29.409
+el valor temporal de n es 2,
+el valor temporal de n es 1,
+
+10:29.535 --> 10:32.486
+se sale del ciclo for, nos retorna p,
+
+10:32.612 --> 10:35.255
+eso hace que nuestro print termine
+
+10:35.381 --> 10:38.345
+y nuestro print imprime n
+y si te das cuenta,
+
+10:38.470 --> 10:40.382
+la n que estaba fuera de la función
+
+10:40.508 --> 10:45.486
+siguió siendo 3 aunque la n adentro
+de la función ya era 0.
+
+10:45.612 --> 10:47.740
+Solo para que te quede aún más claro,
+
+10:47.740 --> 10:52.715
+voy a agregar otro print
+que imprima la n de afuera,
+
+10:54.803 --> 11:00.155
+el valor del exponente n afuera,
+
+11:01.203 --> 11:04.280
+original para que sea más <i>classy</i>,
+
+11:04.406 --> 11:11.227
+original sigue siendo 2 puntos y aquí,
+
+11:11.381 --> 11:16.256
+no necesito un salto de línea, no,
+no lo necesito, muy bien,
+
+11:16.910 --> 11:20.083
+el valor del exponente original 
+sigue siendo
+
+11:20.209 --> 11:24.890
+y le vamos a pasar nuestra variable
+que en este caso sería n,
+
+11:25.016 --> 11:29.382
+cerramos con un punto y coma,
+guardamos, veamos que compile,
+
+11:29.508 --> 11:31.161
+que no nos tire ningún tipo de error
+
+11:31.287 --> 11:34.978
+y mira que el valor 
+del exponente n original
+
+11:35.104 --> 11:38.279
+sigue siendo, claro, nos falta el %d,
+
+11:39.019 --> 11:45.757
+vamos a guardar, vamos a volver a compilar
+y ahora nos dice sigue siendo 3
+
+11:45.883 --> 11:49.408
+a pesar de que n dentro 
+de la función valía 0.
+
+11:49.533 --> 11:53.873
+Esto es un ejemplo clarísimo
+de lo que significa pasar por valor,
+
+11:53.999 --> 11:55.898
+estamos trabajando adentro de la función
+
+11:56.023 --> 11:59.320
+con una copia, ok, no modificamos
+
+11:59.320 --> 12:01.605
+nuestro valor original y eso es algo
+
+12:01.730 --> 12:03.954
+bien importante que lo sepas
+todo el tiempo,
+
+12:04.080 --> 12:07.958
+cuando tú le pasas un argumento
+directo a tu función,
+
+12:08.921 --> 12:11.740
+esta genera una
+copia de tu valor original
+
+12:11.740 --> 12:16.293
+y esto se llama pasar por valor
+o <i>call by value</i> en inglés.
+
+12:16.512 --> 12:18.636
+Solo para que te quede todavía más claro,
+
+12:18.762 --> 12:24.992
+pongamos un n más grande, un n,
+no sé, un n12, vamos a guardar,
+
+12:25.932 --> 12:29.610
+vamos a ver cómo nos va en el código
+compilando y ejecutando
+
+12:29.803 --> 12:34.301
+y mira,
+aquí n fue de 12 hasta 0,
+
+12:34.427 --> 12:36.828
+el resultado de la potencia 
+seguro está bien,
+
+12:36.953 --> 12:40.180
+pero n, el original se mantuvo en 12,
+
+12:40.180 --> 12:42.413
+no importa cuántos
+ciclos iteremos,
+
+12:42.539 --> 12:46.284
+recuerda que dentro de la función
+estamos trabajando con una copia.
+
+12:46.410 --> 12:51.760
+Con esto dicho,
+nos vemos en la próxima clase.

subir/Curso de Funciones en C/02-Manejo de funciones en C/02-powerofintegers2_f852e42a-a15b-4834-a79d-f2ca262c7f5b.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+int power(int base, int n);
+
+int main() 
+{
+    int n;
+    n = 3;
+    
+    printf("n = %d resultado de la potencia = %d\n", n, power(2,n));
+    
+
+    return 0;
+}
+
+int power(int base, int n)
+{
+    int p;
+    for (p = 1; n > 0; n--)
+    {
+        p = p * base;
+        printf("el vaor temporal de n es %d\n", n);
+    }
+
+    return p;
+}

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/01-Bibliotecas estándar del lenguaje C y sus funciones principales.mp4

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/01-Bibliotecas estándar del lenguaje C y sus funciones principales.vtt

@@ -0,0 +1,713 @@
+WEBVTT
+
+00:03.326 --> 00:07.523
+Por defecto, en el lenguaje C
+vamos a tener un set de bibliotecas
+
+00:07.649 --> 00:09.480
+o libraries para disponer
+
+00:09.480 --> 00:11.960
+de varias funciones que pueden ser útiles
+
+00:12.085 --> 00:14.872
+durante tu tiempo
+desarrollando en este lenguaje.
+
+00:14.898 --> 00:16.235
+Así que te las quiero mostrar.
+
+00:16.261 --> 00:19.480
+Vamos a tener este set
+de bibliotecas estándares,
+
+00:19.480 --> 00:22.396
+también se les conoce como librerías,
+pero ese es un error,
+
+00:22.522 --> 00:25.748
+igual es un error que ya es tan común
+que es el estándar,
+
+00:25.873 --> 00:28.559
+así que les voy a decir bibliotecas
+o librerías, cualquiera de las dos.
+
+00:28.685 --> 00:33.040
+Vamos a tener STDIO que es
+una librería estándar de input y output,
+
+00:33.040 --> 00:35.588
+aquí tenemos funciones
+para capturar input
+
+00:35.713 --> 00:38.260
+desde el teclado del usuario,
+vamos a tener también
+
+00:38.260 --> 00:41.214
+funciones para imprimir
+resultados a pantalla
+
+00:41.340 --> 00:43.520
+como ya lo hemos hecho con print.
+
+00:43.520 --> 00:46.619
+Vamos a tener también CONIO
+que es console input output,
+
+00:46.745 --> 00:49.720
+nos sirve para tener entradas y salidas,
+
+00:49.720 --> 00:51.860
+comunicarnos directamente en la consola.
+
+00:51.985 --> 00:54.840
+Vamos a tener STRING
+que te puede servir bastantísimo
+
+00:54.840 --> 00:57.822
+cuando estás trabajando
+con cadenas de caracteres,
+
+00:57.947 --> 01:00.680
+desde para copiar strings
+hasta para cortar,
+
+01:00.680 --> 01:05.797
+truncar o revisar qué tienes
+de contenido en esas strings.
+
+01:05.923 --> 01:09.578
+Así mismo vamos a tener STDELIV,
+esta es la librería estándar,
+
+01:09.703 --> 01:12.535
+esta trae varias funciones
+bien importantes como SYSTEM,
+
+01:12.661 --> 01:15.331
+SYSTEM nos va a servir para comunicarnos
+
+01:15.456 --> 01:18.440
+afuera del programa de C
+con nuestro sistema,
+
+01:18.440 --> 01:19.908
+como lo dice su nombre.
+
+01:20.034 --> 01:23.760
+También vamos a tener funciones
+como ATOY que nos va a servir bastantísimo
+
+01:23.760 --> 01:27.495
+cuando querramos convertir
+un string o cadena de caracteres
+
+01:27.621 --> 01:30.120
+a un entero, a un valor numérico,
+
+01:30.120 --> 01:32.236
+es decir pasar de algo que el programa
+
+01:32.361 --> 01:34.840
+está considerando una cadena
+de caracteres a números,
+
+01:34.840 --> 01:38.458
+eso es bastante útil.
+Vamos a tener a TOLL que hace lo mismo
+
+01:38.584 --> 01:40.346
+pero en vez de a entero
+lo convierte a LONG,
+
+01:40.472 --> 01:43.359
+a TOFF que nos convierte
+a FLOW, entre otras.
+
+01:43.485 --> 01:44.520
+Así mismo vamos a tener
+
+01:44.520 --> 01:49.258
+la función RAND que nos genera
+números enteros aleatorios
+
+01:49.384 --> 01:52.476
+y la función DELAY que es súper importante
+
+01:52.602 --> 01:54.124
+cuando necesitas que tu programa
+
+01:54.250 --> 01:58.280
+tenga una pequeña
+pausa durante la ejecución
+
+01:58.280 --> 02:00.747
+y bueno otras bien
+importantes que, de hecho,
+
+02:00.872 --> 02:03.722
+vamos a usar en algunos
+de los cursos a futuro
+
+02:03.848 --> 02:06.663
+de este lenguaje C
+que estamos haciendo aquí en Platzi.
+
+02:06.789 --> 02:08.720
+Así mismo vamos a tener MAT,
+
+02:08.720 --> 02:11.478
+MAT cuenta con funciones
+como SIN, COSIN
+
+02:12.176 --> 02:15.165
+que se escriben directamente
+igual que como en tu calculadora,
+
+02:15.291 --> 02:18.780
+SIN, COS, COS de H,
+cuestiones de ese estilo
+
+02:18.906 --> 02:21.974
+eso existe en nuestra función MAT.
+
+02:22.100 --> 02:23.871
+También vienen funciones como FLUR
+
+02:23.996 --> 02:26.719
+que ya sabes nos manda 
+el entero más cercano,
+
+02:26.845 --> 02:30.514
+más bajo y cercano al número
+que le estemos pasando.
+
+02:30.640 --> 02:34.040
+Vamos a tener SALE que hace lo mismo
+pero al revés para el número,
+
+02:34.040 --> 02:38.114
+para el siguiente
+número entero más próximo.
+
+02:38.240 --> 02:40.400
+Entre otras funciones matemáticas
+
+02:40.400 --> 02:44.396
+que puedes utilizar,
+una de las más que podría llegar
+
+02:44.522 --> 02:46.882
+a usar es SQRT en caso
+de que estés trabajando
+
+02:47.008 --> 02:49.826
+con un programa que te pida la raíz.
+
+02:49.952 --> 02:53.400
+También vamos a tener TIME.H
+que nos sirve directamente
+
+02:53.400 --> 02:56.177
+para cuestiones que tienen
+que ver con fechas
+
+02:56.302 --> 02:58.792
+del sistema o tiempos en el sistema.
+
+02:58.918 --> 03:02.178
+Siempre que estés trabajando
+con cuestiones que, por ejemplo,
+
+03:02.303 --> 03:05.466
+van a ser utilizadas
+en diferentes zonas horarias
+
+03:05.592 --> 03:08.194
+esta función va a ser
+esencial pero también toma
+
+03:08.320 --> 03:10.946
+en cuenta que tu código
+debe de ser capaz de entender
+
+03:11.072 --> 03:13.298
+en qué lugar está para que puedas hacer
+
+03:13.423 --> 03:16.440
+los cálculos de forma correcta y mejor
+
+03:16.440 --> 03:19.521
+y todavía más importante si estás
+trabajando con servidores
+
+03:19.647 --> 03:22.000
+cuando la computadora
+puede estar en el horario
+
+03:22.000 --> 03:24.890
+de Australia pero tus
+clientes van a estar
+
+03:25.015 --> 03:29.012
+en México por ejemplo,
+no sé, por ponerte un ejemplo extremo,
+
+03:29.138 --> 03:30.498
+bueno tienes que ser muy cuidadosa
+
+03:30.623 --> 03:32.880
+o cuidadoso porque lo que va a pasar
+
+03:32.880 --> 03:36.141
+es que tu servidor les va a mandar
+fechas y horas que no son acordes
+
+03:36.267 --> 03:39.000
+a lo que los usuarios están recibiendo
+
+03:39.000 --> 03:43.590
+o a la zona horaria real del usuario
+que está recibiendo tu contenido.
+
+03:43.716 --> 03:45.060
+Tienes que ser muy cuidadoso
+
+03:45.186 --> 03:49.228
+y saber siempre tomar precauciones
+con los tiempos.
+
+03:49.855 --> 03:53.083
+Asimismo vamos a tener la función CTYPE.
+
+03:53.209 --> 03:55.198
+TYPE viene de como tipo
+
+03:55.323 --> 03:59.317
+o sea tiene que ver con todo
+lo que es manejo de caracteres.
+
+03:59.443 --> 04:02.520
+Este es para manejo de strings
+o sea cadenas de caracteres.
+
+04:02.646 --> 04:05.590
+Esto es para manejo 
+de caracteres individuales.
+
+04:05.716 --> 04:07.538
+Vamos a tener SIGNAL que nos ayuda
+
+04:07.663 --> 04:10.720
+a manejar todo
+lo que tiene que ver con señales
+
+04:10.720 --> 04:13.938
+en nuestro programa
+y aquí quizás te preguntas
+
+04:14.063 --> 04:16.144
+¿qué tipo de señales?
+
+04:16.270 --> 04:18.032
+Que de hecho SIGNAL
+te va a servir mucho
+
+04:18.158 --> 04:20.440
+por ejemplo para detectar
+cuestiones por afuera
+
+04:20.566 --> 04:23.638
+de la ejecución de tu programa.
+Una señal puede ser un evento
+
+04:23.763 --> 04:26.240
+como que alguien está apretando
+una tecla interactiva
+
+04:26.240 --> 04:30.109
+en tu teclado o una
+de estas cuestiones específicas
+
+04:30.235 --> 04:33.302
+o algo que quieras detectar
+tú para que tu programa
+
+04:33.428 --> 04:35.352
+funcione de forma adecuada.
+
+04:35.478 --> 04:40.684
+Ahí podrías utilizar esto
+que de hecho puedes utilizar RACE
+
+04:40.810 --> 04:43.245
+que nos manda una señal 
+de forma artificial
+
+04:43.371 --> 04:45.307
+cuando tú lo necesites entre otras cosas.
+
+04:45.433 --> 04:49.158
+CTYPE quería comentarte antes de seguir
+que de hecho va a tener
+
+04:49.283 --> 04:52.200
+funciones que son bastante
+útiles cuando necesites
+
+04:52.200 --> 04:55.553
+detectar por ejemplo
+un espacio en blanco
+
+04:55.679 --> 05:00.120
+en una cadena de caracteres
+o en información cuando
+
+05:00.120 --> 05:01.884
+estés buscando cuestiones de ese estilo
+
+05:02.010 --> 05:07.360
+ahí entraría en funcionamiento
+esta biblioteca CTYPE.
+
+05:08.216 --> 05:10.751
+También CTYPE nos va
+a servir para detectar
+
+05:10.877 --> 05:14.774
+si un carácter está en minúsculas,
+si un carácter está en mayúsculas,
+
+05:14.900 --> 05:16.757
+si es un signo de puntuación,
+
+05:16.882 --> 05:19.030
+entre muchas muchas cosas más.
+
+05:19.156 --> 05:22.251
+Entonces siempre que necesites cuestiones
+que tienen que ver con caracteres
+
+05:22.376 --> 05:25.080
+a mucho detalle vas a poder hacerlo
+
+05:25.080 --> 05:28.677
+y vas a poder hacerlo con mucha precisión
+
+05:28.803 --> 05:30.880
+eso es bien importante incluyendo
+
+05:30.880 --> 05:34.037
+obviamente tu lower,
+tu upper, que te va a servir
+
+05:34.163 --> 05:37.116
+para a nivel caracter ir pasando
+
+05:37.242 --> 05:40.978
+de mayúscula a minúscula
+de minúscula a mayúscula. ¿Por qué?
+
+05:41.103 --> 05:43.210
+Porque recuerda que en programación
+
+05:43.336 --> 05:47.098
+tenemos el código ASCII
+y cada carácter es diferente,
+
+05:47.224 --> 05:48.885
+cada carácter tiene un código único,
+
+05:49.011 --> 05:52.365
+entonces una a mayúscula
+es diferente a una minúscula,
+
+05:53.593 --> 05:56.023
+eso es importantísimo que lo tengas claro
+
+05:56.149 --> 06:00.927
+y una a mayúscula con acento
+es diferente a una minúscula con acento
+
+06:01.053 --> 06:03.899
+entonces a ese nivel tú vas
+a poder tener control
+
+06:04.025 --> 06:07.379
+de tus caracteres en código
+y es importante que entiendas
+
+06:07.505 --> 06:09.702
+que en lenguajes de programación como C
+
+06:09.828 --> 06:13.544
+que son tipados 
+y que tienes mucha precisión
+
+06:13.670 --> 06:15.831
+en los datos, en los tipos de datos, etc.,
+
+06:15.957 --> 06:18.604
+bueno siempre vas a deber tener
+
+06:18.730 --> 06:21.560
+diferenciación 
+entre una variable que todas
+
+06:21.560 --> 06:24.265
+las letras están con mayúsculas,
+una que están con minúsculas,
+
+06:24.391 --> 06:26.922
+una cadena de caracteres
+en mayúsculas no va a ser igual
+
+06:27.048 --> 06:29.108
+a una cadena de caracteres
+con minúsculas
+
+06:29.234 --> 06:31.449
+eso lo debes de tener súper claro
+
+06:31.575 --> 06:34.058
+y ahí es donde entran estos
+casos de uso en donde tienes
+
+06:34.183 --> 06:36.263
+que convertir todo a mayúsculas, 
+por ejemplo,
+
+06:36.389 --> 06:38.791
+si tu procesamiento
+tiene que ver con mucho texto
+
+06:38.917 --> 06:43.301
+de pronto te serviría, de pronto no,
+si tu procesamiento necesita
+
+06:43.427 --> 06:45.520
+que sea sensitivo
+de mayúsculas y minúsculas
+
+06:45.646 --> 06:47.177
+entonces no podrías hacer eso
+
+06:47.303 --> 06:49.527
+pero si no y pues simple y sencillamente
+
+06:49.653 --> 06:52.809
+quieres que lo que un usuario escribe,
+digamos que un usuario escribe
+
+06:52.935 --> 06:55.348
+oye, necesito tal cosa y tu programa
+
+06:55.474 --> 06:57.101
+va a hacer algo con esa información,
+
+06:57.227 --> 07:00.358
+bueno ahí deberías de asegurarte
+de pasarlo a mayúsculas
+
+07:00.483 --> 07:03.960
+para que siempre hagas match
+y no tengas que estar validando
+
+07:04.086 --> 07:05.318
+dos condiciones, esa es una forma
+
+07:05.443 --> 07:08.025
+de atacar el problema,
+también puedes simplemente
+
+07:08.151 --> 07:09.838
+validar las dos condiciones,
+lo escriben mayúsculas
+
+07:09.963 --> 07:11.774
+lo escriben minúsculas entre otras cosas.
+
+07:11.900 --> 07:15.406
+Vamos a tener otras funciones
+como lo que locale.
+
+07:15.531 --> 07:19.040
+Lacles es una librería o biblioteca
+bien importante
+
+07:19.040 --> 07:22.341
+porque nos ayuda a definir
+cuestiones locales al software
+
+07:22.466 --> 07:25.560
+a donde esto te sirve
+para cuestiones como
+
+07:25.560 --> 07:29.005
+el formato de la fecha 
+o símbolos para la moneda
+
+07:29.131 --> 07:30.484
+con la que vas a estar trabajando
+
+07:30.610 --> 07:32.512
+en caso de que tu programa lo requiera.
+
+07:32.638 --> 07:36.520
+Esto es como una librería más 
+o biblioteca específica
+
+07:36.520 --> 07:40.232
+a configuraciones que vas 
+a requerir cuando necesitas
+
+07:40.358 --> 07:42.840
+que tu programa se adapte
+a diferentes locaciones
+
+07:42.840 --> 07:46.406
+a diferentes lugares.
+Luego vamos a tener herno
+
+07:46.532 --> 07:48.720
+que esta es la librería o
+biblioteca que nos ayuda
+
+07:48.720 --> 07:51.138
+a manejar errores, 
+esto tiene funciones
+
+07:51.263 --> 07:53.382
+que nos van a servir 
+para manejo de errores
+
+07:53.508 --> 07:56.830
+dentro del programa y por último
+tenemos la biblioteca
+
+07:56.955 --> 08:00.640
+hacer que esto nos provee
+un macro no nos provee
+
+08:00.640 --> 08:04.469
+funciones sino que nos provee 
+una macro que se puede utilizar
+
+08:04.595 --> 08:07.053
+para verificar asum asumciones
+
+08:07.179 --> 08:11.443
+como cuando asumimos 
+que nuestro programa e imprimir
+
+08:11.569 --> 08:13.766
+un diagnóstico de lo que está ocurriendo
+
+08:13.892 --> 08:16.935
+si no se cumple la condición 
+que le estamos pasando.
+
+08:17.061 --> 08:19.936
+La verdad es que esto no
+se suele utilizar muchísimo
+
+08:20.062 --> 08:22.993
+pero igual cuéntame
+si te gustaría ver de qué
+
+08:23.119 --> 08:25.520
+se va a tratar esto 
+y yo tengo un ejemplo
+
+08:25.520 --> 08:28.303
+que te podría servir, obviamente
+esto lo veríamos en cursos
+
+08:28.428 --> 08:31.134
+más avanzados, 
+mucho más adelante de la carrera.
+
+08:31.561 --> 08:34.501
+Con esto dicho, estas 
+son las principales bibliotecas
+
+08:34.627 --> 08:37.429
+con las que cuentas en C, 
+hay muchas bibliotecas más
+
+08:37.555 --> 08:39.638
+que podrías llegar
+a consultar pero ya son
+
+08:39.763 --> 08:43.748
+hechas por otras personas o no
+son contenidas dentro del estándar
+
+08:43.873 --> 08:46.664
+tradicional del lenguaje que vamos a tener.
+
+08:46.790 --> 08:48.209
+Estas son las principales
+
+08:48.335 --> 08:51.630
+y estas son las que te van a dar 
+muchas funcionalidades bases,
+
+08:51.770 --> 08:54.360
+nada muy específico,
+nada muy avanzado,
+
+08:54.360 --> 08:57.674
+no hay como o como en javascript, 
+por ejemplo,
+
+08:57.800 --> 09:00.360
+que tienes una biblioteca
+para hacer front-end,
+
+09:00.360 --> 09:01.907
+una biblioteca para hacer back-end,
+
+09:02.033 --> 09:04.244
+una biblioteca para montarte tu servidor,
+
+09:04.370 --> 09:05.982
+una biblioteca para manejar un chat,
+
+09:06.108 --> 09:07.683
+tienes una biblioteca para todo.
+
+09:07.808 --> 09:10.921
+En C, por decirlo así, el acercamiento
+es un poquito más genérico,
+
+09:11.047 --> 09:12.213
+más general.
+
+09:12.339 --> 09:15.477
+Y, si bien, si hay muchas 
+bibliotecas desarrolladas,
+
+09:15.603 --> 09:17.829
+te toca ir y buscarlas 
+y no son tan populares
+
+09:17.955 --> 09:21.038
+y no las instalas directamente con npm 
+ni nada de eso,
+
+09:21.164 --> 09:23.146
+simplemente la metes en tu proyecto
+
+09:23.272 --> 09:26.680
+y la llamas con la directiva incluide.
+
+09:26.806 --> 09:28.740
+Con esto dicho. nos vemos 
+en la siguiente clase
+
+09:28.866 --> 09:34.480
+donde te mostraré un par de funciones 
+de estas bibliotecas.

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/01-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://devdocs.io/c/
+https://docs.microsoft.com/en-us/cpp/c-language/c-language-reference?view=vs-2019

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/01-libraries_52ae0350-75bf-4e6b-a5d7-1b57fd7d6a03.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <conio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+#include <ctype.h>
+#include <signal.h>
+#include <locale.h>
+#include <errno.h>
+#include <assert.h>

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/02-Funciones matemáticas básicas en C con la biblioteca math.mp4

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/02-Funciones matemáticas básicas en C con la biblioteca math.vtt

@@ -0,0 +1,493 @@
+WEBVTT
+
+00:03.013 --> 00:07.077
+La primera biblioteca 
+que vamos a revisar es mat.h,
+
+00:07.203 --> 00:08.500
+así que vamos al código.
+
+00:08.626 --> 00:11.882
+Obviamente vamos 
+a necesitar nuestra amiga,
+
+00:12.008 --> 00:13.664
+la biblioteca stdio,
+
+00:13.790 --> 00:17.000
+para poder manejar el print.
+
+00:17.000 --> 00:20.253
+Y también vamos a necesitar, ahora sí,
+
+00:20.379 --> 00:23.348
+incluir a la estrella de esta clase,
+que es mat.h.
+
+00:23.474 --> 00:24.765
+Perfecto.
+
+00:24.891 --> 00:27.500
+No vamos a hacer nada más, 
+vamos a escribir nuestro main.
+
+00:27.500 --> 00:29.500
+Muy bien, ya tenemos el main.
+
+00:30.128 --> 00:32.885
+Y dentro del main, lo que vamos a colocar
+
+00:33.011 --> 00:36.788
+va a ser simple y sencillamente 
+un código básico.
+
+00:36.914 --> 00:41.103
+Aquí quiero mostrarte una función 
+para obtener información del teclado.
+
+00:41.229 --> 00:42.500
+Vamos a hacer eso.
+
+00:42.500 --> 00:43.500
+print
+
+00:45.666 --> 00:46.666
+Ingrese
+
+00:48.871 --> 00:50.966
+el valor de x.
+
+00:51.299 --> 00:53.990
+Perfecto, entonces aquí tenemos 
+ya nuestro print.
+
+00:54.116 --> 00:57.311
+Le va a aparecer a la persona, 
+ingrese el valor de x.
+
+00:57.437 --> 00:59.297
+Vamos a ponerle dos puntos.
+
+00:59.443 --> 01:01.601
+Y vamos a dejar un espacio.
+
+01:01.727 --> 01:03.749
+Ya, con eso está.
+Punto y coma.
+
+01:03.875 --> 01:06.724
+Luego, más abajo, 
+vamos a volver a llamar
+
+01:06.850 --> 01:10.387
+a otra función de stdio.h,
+
+01:10.513 --> 01:13.170
+pero esta función va a ser ahora scanf.
+
+01:13.617 --> 01:16.410
+Scanf hace justo lo contrario de print.
+
+01:16.536 --> 01:17.878
+Print imprime un valor,
+
+01:18.004 --> 01:22.377
+scanf recibe o escanea 
+un valor de entrada.
+
+01:22.503 --> 01:24.217
+Así que vamos a ponerle,
+
+01:24.343 --> 01:26.138
+oye, necesito que te traigas un valor,
+
+01:26.264 --> 01:29.500
+va a ser %d, o sea,
+va a ser un número entero.
+
+01:30.032 --> 01:33.894
+Y este valor lo vamos a asignar,
+
+01:34.020 --> 01:35.737
+esto se escribe de esta forma,
+
+01:35.863 --> 01:38.500
+a la variable x.
+
+01:40.114 --> 01:42.429
+Hay que declarar la variable x, 
+por supuesto,
+
+01:42.555 --> 01:44.777
+entonces vamos arriba 
+a declarar nuestra variable,
+
+01:44.903 --> 01:46.432
+int x, punto y coma,
+
+01:46.558 --> 01:48.345
+ya declaramos nuestra variable x.
+
+01:48.471 --> 01:50.107
+Y aquí lo que estamos pasando
+
+01:50.233 --> 01:53.488
+es que le estamos asignando 
+el valor que escaneamos
+
+01:53.614 --> 01:55.255
+a nuestra variable x.
+
+01:56.709 --> 01:58.277
+Aquí si no es una copia de x,
+
+01:58.403 --> 02:01.000
+nada, nada, lo estamos asignando directo,
+
+02:01.000 --> 02:03.000
+mandándoselo derechito.
+
+02:03.000 --> 02:06.000
+Muy bien, punto y coma, excelente.
+
+02:06.000 --> 02:07.500
+Luego, ya que tenemos esto,
+
+02:07.500 --> 02:09.254
+probemos nuestro print
+
+02:09.380 --> 02:12.000
+para asegurarnos 
+de que está funcionando bien.
+
+02:12.000 --> 02:15.000
+Vamos a darle el valor ingresado es...
+
+02:17.332 --> 02:20.500
+El valor ingresado es dos puntos,
+
+02:20.500 --> 02:23.500
+y vamos a imprimir nuestra variable,
+como ya lo sabes hacer,
+
+02:23.500 --> 02:25.238
+entonces %d,
+
+02:25.364 --> 02:29.500
+y luego le pasamos la variable x 
+a través de una coma.
+
+02:29.759 --> 02:30.759
+Excelente.
+
+02:30.885 --> 02:33.500
+Punto y coma, todo se ve bien 
+en nuestro código,
+
+02:33.500 --> 02:35.500
+guardemos, imprimamos,
+
+02:37.663 --> 02:39.500
+y veamos qué ocurre.
+
+02:39.500 --> 02:42.500
+Vamos a compilar 
+nuestro código y ejecutarlo.
+
+02:43.703 --> 02:45.500
+Dice, ingresa el valor de x,
+
+02:45.500 --> 02:47.500
+y mira, nos pide un número,
+
+02:47.500 --> 02:49.500
+voy a poner 56, enter.
+
+02:49.500 --> 02:52.000
+El valor ingresado es 56.
+
+02:52.194 --> 02:53.903
+Todo está funcionando excelente.
+
+02:54.029 --> 02:56.500
+Ahora sí, probemos 
+nuestras funciones matemáticas.
+
+02:56.973 --> 03:00.346
+Para probar nuestras funciones
+matemáticas, lo que voy a hacer es,
+
+03:00.472 --> 03:05.402
+pues, obviamente, voy a trabajar con x
+para que sea algo más dinámico,
+
+03:05.528 --> 03:07.500
+y te voy a escribir varias 
+de las funciones
+
+03:07.500 --> 03:09.429
+que están en mat.h,
+
+03:09.555 --> 03:13.000
+por ejemplo, sin, 
+que es la función del seno.
+
+03:14.710 --> 03:16.734
+Esta función tiene un argumento,
+
+03:16.860 --> 03:18.500
+que es, hay que pasarle un valor,
+
+03:18.500 --> 03:20.737
+y para ser fiel con las matemáticas,
+
+03:20.863 --> 03:23.000
+voy a poner seno de x directamente.
+
+03:23.000 --> 03:24.500
+Luego, vamos a...
+
+03:26.000 --> 03:29.500
+Vamos a guardar esto 
+en una variable auxiliar,
+
+03:31.808 --> 03:32.820
+int,
+
+03:32.946 --> 03:35.946
+y la variable auxiliar 
+se va a llamar result.
+
+03:36.993 --> 03:38.132
+Perfecto.
+
+03:39.305 --> 03:40.614
+Vamos a dejar un espacio acá
+
+03:40.740 --> 03:43.500
+para que esté bien bonito 
+todo nuestro programa.
+
+03:45.000 --> 03:46.000
+Listo.
+
+03:46.828 --> 03:50.483
+Y vamos a guardar esto 
+en nuestra variable auxiliar.
+
+03:51.866 --> 03:52.866
+Result,
+
+03:53.880 --> 03:57.470
+result va a ser igual a seno de x.
+
+03:57.956 --> 03:59.994
+Todo está excelente por acá.
+
+04:00.120 --> 04:01.365
+De hecho, el seno de x,
+
+04:01.491 --> 04:03.526
+probablemente vamos a necesitar
+
+04:03.652 --> 04:05.496
+que nos dé un resultado en float,
+
+04:06.511 --> 04:08.351
+porque estas operaciones suelen darnos
+
+04:08.477 --> 04:10.702
+puntitos decimales 
+y cuestiones de ese estilo.
+
+04:10.828 --> 04:13.112
+Así que hagamos el experimento.
+
+04:15.131 --> 04:17.067
+Nada más me falta agregar un print.
+
+04:20.340 --> 04:22.198
+Vamos a copiar y pegar el que ya teníamos
+
+04:22.324 --> 04:25.146
+para optimizar la escritura del código.
+
+04:25.780 --> 04:30.333
+El valor del seno de x es,
+
+04:31.102 --> 04:34.286
+%f, porque es un número decimal,
+
+04:34.532 --> 04:36.533
+y le vamos a pasar result.
+
+04:36.659 --> 04:37.693
+Excelente.
+
+04:38.468 --> 04:40.417
+Guardamos, compilamos,
+
+04:40.543 --> 04:42.221
+y ejecutamos nuestro código.
+
+04:42.760 --> 04:44.434
+Y esperamos a que salga el resultado.
+
+04:44.560 --> 04:46.766
+Ingrese el valor de x, 56.
+
+04:47.653 --> 04:49.674
+Ah, mira, el valor ingresado es 56.
+
+04:49.800 --> 04:53.256
+El valor del seno de x es menos 0.52.
+
+04:53.282 --> 04:54.316
+Excelente.
+
+04:54.342 --> 04:56.328
+Confío plenamente en que eso está bien,
+
+04:56.454 --> 04:58.751
+entonces no hay nada más que hacer.
+
+04:58.877 --> 05:00.642
+Ya por último hay que agregar
+
+05:00.768 --> 05:02.839
+diagonal invertida n para corregir eso
+
+05:02.965 --> 05:04.583
+de que salieron los dos ahí juntitos.
+
+05:04.709 --> 05:05.976
+Eso no está bien, nunca.
+
+05:06.342 --> 05:08.120
+Entonces, diagonal invertida n,
+
+05:08.246 --> 05:09.537
+diagonal invertida n, y listo.
+
+05:09.732 --> 05:11.003
+Hagamos más operaciones.
+
+05:11.129 --> 05:12.356
+Ya vimos seno.
+
+05:12.482 --> 05:14.456
+Hagamos ahora coseno.
+
+05:17.000 --> 05:20.176
+Guardamos, compilamos y ejecutamos.
+
+05:23.500 --> 05:26.000
+Ingrese el valor de x, menos 1.
+
+05:29.000 --> 05:32.000
+El coseno de x es 0.54.
+
+05:32.000 --> 05:33.000
+¿Ok?
+
+05:33.000 --> 05:35.000
+Ahora hagamos otra operación.
+
+05:35.000 --> 05:37.000
+Pero aquí ya básicamente simplemente
+
+05:37.000 --> 05:38.000
+estoy cambiando esto.
+
+05:38.000 --> 05:40.000
+Ya sabes cómo llamar funciones.
+
+05:40.000 --> 05:43.000
+Recuerda que el lenguaje C 
+tiene muchísimas,
+
+05:43.000 --> 05:45.500
+muchísisísimas funciones matemáticas.
+
+05:45.500 --> 05:47.000
+Ya te dije varias de ellas,
+
+05:47.000 --> 05:49.000
+pero quiero invitarte a que lo consultes,
+
+05:49.000 --> 05:51.132
+a que generes tus propias guías 
+de estudio.
+
+05:51.258 --> 05:53.500
+Y si de verdad 
+vas a estar trabajando con C,
+
+05:53.500 --> 05:56.000
+inclusive que le des una leída a el libro
+
+05:56.000 --> 05:58.000
+de C Programming Language.
+
+05:58.000 --> 06:01.000
+Te voy a dejar el nombre aquí
+en la sección de comentarios.
+
+06:01.000 --> 06:02.401
+Y, bueno, le das un corazoncito
+
+06:02.527 --> 06:04.500
+para que mi comentario 
+se quede arriba.
+
+06:04.500 --> 06:06.500
+Con eso ya tú sabrás que, bueno,
+
+06:06.500 --> 06:09.000
+ahí puedes consultarlo como una referencia
+
+06:09.000 --> 06:11.500
+para que veas todas las funciones que hay.
+
+06:11.500 --> 06:15.267
+Ya te dije, está Flour, 
+está Seal, está SQRT,
+
+06:15.393 --> 06:19.000
+está POU, está LOC, está X, está Tangente,
+
+06:19.000 --> 06:23.316
+está todo lo que tendríamos 
+como funcionalidades básicas
+
+06:23.442 --> 06:25.000
+de una calculadora, por decirlo así.
+
+06:25.000 --> 06:27.000
+Obviamente no tenemos suma, 
+multiplicación,
+
+06:27.000 --> 06:29.500
+porque esas son operaciones 
+que ya tenemos
+
+06:29.500 --> 06:32.000
+directamente por nuestros 
+operadores aritméticos.
+
+06:32.000 --> 06:33.500
+Así que no hay problema.
+
+06:33.500 --> 06:36.679
+O suma, división, resta, 
+multiplicación, etc.
+
+06:36.805 --> 06:39.500
+Con esto dicho, bueno, 
+ya hicimos nuestra exploración
+
+06:39.500 --> 06:42.000
+de esta biblioteca de mat.h.
+
+06:42.000 --> 06:47.400
+Nos vemos en la próxima clase.

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://www.tutorialspoint.com/c_standard_library/math_h.htm

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/02-mathdemo_4d517300-d5e9-4437-82ad-b7fdbe0bc464.c

@@ -0,0 +1,16 @@
+#include<stdio.h>
+#include<math.h>
+
+int x;
+float result;
+
+int main()
+{
+    printf("ingrese el valor de x: ");
+    scanf("%d", &x);
+    result = cos(x);
+    printf("El valor ingresado es:%d \n", x);
+    printf("El valor del seno de X es:%f\n", result);
+
+    return 0;
+}

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://www.tutorialspoint.com/c_standard_library/string_h.htm

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/03-Manejo de Strings en C Funciones y Operaciones Básicas.mp4

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/03-Manejo de Strings en C Funciones y Operaciones Básicas.vtt

@@ -0,0 +1,722 @@
+WEBVTT
+
+00:03.220 --> 00:05.435
+Ahora es momento de trabajar con strings.
+
+00:05.561 --> 00:07.797
+Para esto vamos a ir
+a nuestro Visual Studio Code,
+
+00:07.823 --> 00:09.047
+creamos un nuevo archivo,
+
+00:09.173 --> 00:13.234
+control N y luego lo guardamos,
+le vamos a poner string.c,
+
+00:13.360 --> 00:16.661
+excelente, me dice que ya existe, ok, sí,
+
+00:16.787 --> 00:19.825
+quiero reemplazarlo y voy a proceder.
+
+00:20.048 --> 00:22.808
+Lo primero es agregar nuestras includes,
+
+00:22.934 --> 00:27.592
+vamos a decirle tráete stdio.h
+
+00:27.718 --> 00:31.560
+y también tráete string.h
+
+00:31.560 --> 00:33.775
+que es la estrella de esta clase.
+
+00:34.466 --> 00:37.275
+Luego no voy a declarar ninguna
+variable, voy a poner mi main,
+
+00:37.401 --> 00:40.568
+int main, abrimos
+y cerramos nuestras llaves,
+
+00:42.055 --> 00:44.280
+muy bien, y dentro de mi main voy
+
+00:44.280 --> 00:47.345
+a declarar una variable de tipo char,
+
+00:47.471 --> 00:49.840
+que en realidad voy a declarar una array
+
+00:49.840 --> 00:53.276
+para guardar mi string
+o cadena de caracteres.
+
+00:53.476 --> 00:57.600
+String 1 le voy a poner
+y va a ser de máximo,
+
+00:57.600 --> 01:02.871
+no sé, unos 60 caracteres,
+60 posiciones en el array.
+
+01:04.253 --> 01:05.880
+Muy bien, recuerda que un array
+
+01:05.880 --> 01:08.233
+no es más que una forma
+de almacenar información,
+
+01:08.358 --> 01:10.560
+es como una variable
+que tiene varias celdas
+
+01:10.560 --> 01:13.722
+y simple y sencillamente
+puedes irle poniendo muchos valores.
+
+01:13.848 --> 01:15.972
+Cada uno de estos 60 va a ser,
+
+01:16.098 --> 01:17.904
+por decirlo así, un carácter,
+
+01:18.030 --> 01:20.866
+entonces vamos a tener
+una cadena de caracteres,
+
+01:20.992 --> 01:24.281
+de 60 caracteres, perfecto.
+
+01:26.024 --> 01:29.005
+Vamos a imprimir, printf
+
+01:29.131 --> 01:35.852
+y voy a imprimir un mensaje
+que diga escribe una frase,
+
+01:36.198 --> 01:40.528
+una frase, perfecto, 
+simple y sencillamente
+
+01:40.654 --> 01:43.638
+le vamos a poner diagonal n
+
+01:43.844 --> 01:46.595
+y luego vamos a pedir nuestra frase.
+
+01:46.721 --> 01:49.240
+Para pedir nuestra frase
+no vamos a utilizar
+
+01:49.240 --> 01:51.109
+lo que vimos en la clase
+anterior de math,
+
+01:51.235 --> 01:54.314
+en donde utilizamos scam,
+aquí vamos a utilizar
+
+01:54.440 --> 01:58.040
+algo que es específico
+para obtener un string
+
+01:58.165 --> 02:01.680
+que es gets y este gets
+lo vamos a pasar
+
+02:01.680 --> 02:05.277
+a nuestro string 1, perfecto,
+simplemente estamos
+
+02:05.402 --> 02:08.760
+diciéndole que la string
+que nos asignemos
+
+02:08.760 --> 02:13.108
+lo aguardemos en nuestro string 1,
+perfecto.
+
+02:13.234 --> 02:16.760
+Luego vamos a utilizar una función
+
+02:16.760 --> 02:19.547
+que es la primera que te quiero
+mostrar de nuestro string.h
+
+02:19.673 --> 02:24.673
+que es strreb, sorry que la tengo
+que dar letra a letra
+
+02:24.799 --> 02:27.960
+pero si no siempre me confundía
+con esta y a mí me pasaba
+
+02:27.960 --> 02:29.859
+que siempre me saltaba una de las r
+
+02:29.985 --> 02:34.120
+así que es porque es así
+porque es string str y ref
+
+02:34.120 --> 02:37.013
+de reverse.
+Esta función es bien cool
+
+02:37.139 --> 02:41.400
+porque nos permite cambiar
+el sentido a nuestro string
+
+02:41.400 --> 02:43.967
+y lo ponemos en reversa,
+de hecho voy a buscar
+
+02:44.092 --> 02:46.121
+un palíndromo
+para nuestro ejemplo
+
+02:46.247 --> 02:48.136
+pero eso lo veremos más adelante.
+
+02:48.262 --> 02:52.080
+String ref le pasamos el string
+que vamos a reversar por decirlo
+
+02:52.080 --> 02:57.298
+de alguna forma y luego
+vamos a imprimir nuestro string nuevo.
+
+02:57.423 --> 03:03.841
+Print, vamos a ponerle
+el string al revés es,
+
+03:05.574 --> 03:07.845
+es dos puntos y aquí le hacemos
+
+03:07.971 --> 03:10.320
+lo de siempre para pasar una variable
+
+03:10.320 --> 03:13.328
+%s porque es un string, le vamos a poner
+
+03:13.454 --> 03:15.851
+nuestro salto de línea
+porque es una buena práctica
+
+03:15.977 --> 03:20.239
+y le vamos a pasar
+nuestra variable string 1,
+
+03:20.365 --> 03:22.640
+dejamos un punto y coma,
+
+03:22.640 --> 03:25.916
+ponemos retorno cero
+para que se finalice el programa,
+
+03:27.499 --> 03:31.584
+return cero, punto y coma
+y ya estamos del otro lado
+
+03:31.710 --> 03:32.908
+con nuestro código.
+
+03:33.034 --> 03:36.936
+Excelente, ya tenemos todo listo,
+vamos a ver cómo funciona esto.
+
+03:37.062 --> 03:42.032
+Guardo, compilo
+y esperemos a que compile,
+
+03:42.158 --> 03:45.600
+no se va a demorar y ahí está,
+dice escribe una frase
+
+03:45.726 --> 03:50.878
+Anita lava latina,
+
+03:52.237 --> 03:56.786
+el string al revés es Anita lava
+latina, date cuenta cómo
+
+03:56.919 --> 03:59.497
+funciona nuestro
+palíndromo pero obviamente
+
+03:59.623 --> 04:02.200
+existen los espacios
+eso es lo que me sirve
+
+04:02.200 --> 04:05.368
+de evidencia para que tú
+te des cuenta que en efecto
+
+04:05.494 --> 04:07.320
+sí lo puso al revés y no solamente
+
+04:07.320 --> 04:09.498
+lo copió y lo volvió a imprimir.
+
+04:09.623 --> 04:12.134
+Vamos a ver un par de cosas
+más curiosas que se pueden hacer
+
+04:12.260 --> 04:15.553
+con esta librería string.
+Ahora tengo otro ejemplo para ti
+
+04:15.679 --> 04:17.240
+que va a ser string compare,
+
+04:17.240 --> 04:23.867
+str de string y comp
+que lo deletrean como cmp.c,
+
+04:23.993 --> 04:26.760
+perfecto, este es el nombre
+de mi programa,
+
+04:26.760 --> 04:29.170
+vamos a copiarnos este
+que hicimos acá porque
+
+04:29.295 --> 04:32.423
+por favor así nos ahorramos
+un poquitín de código,
+
+04:33.387 --> 04:35.854
+vamos a guardar esto, perfecto,
+
+04:35.980 --> 04:40.170
+escribe una frase y eso
+lo guardamos en string 1,
+
+04:40.296 --> 04:43.680
+voy a copiar este print,
+voy a poner escribe otra frase,
+
+04:44.206 --> 04:49.356
+escribe otra frase para comparar,
+
+04:50.923 --> 04:53.955
+para comparar eso lo vamos
+a guardar en string 2
+
+04:54.081 --> 04:56.753
+que de hecho no lo hemos declarado,
+así que ahorita lo haré,
+
+04:57.688 --> 05:00.840
+vamos a pasarnos todas
+nuestras declaraciones afuera del main,
+
+05:00.840 --> 05:04.974
+prefiero hacerlo así,
+creo que es todo mucho más claro,
+
+05:05.221 --> 05:09.720
+string 1 y string 2, perfecto,
+
+05:09.720 --> 05:11.818
+las dos de 60 caracteres, excelente,
+
+05:11.943 --> 05:14.509
+escribe una frase, string 1,
+escribe otra frase para comparar,
+
+05:14.635 --> 05:18.748
+string 2 y vamos a,
+no voy a usar string reverse
+
+05:18.874 --> 05:21.250
+esta vez porque ya no es lo que quiero
+
+05:21.376 --> 05:24.148
+y vamos a hacer un pequeño código if.
+
+05:25.579 --> 05:27.680
+En este código if la condición va
+
+05:28.206 --> 05:34.943
+a ser utilizar nuestra
+función strcmp que en humano
+
+05:35.069 --> 05:38.480
+sería string compare, str de string,
+
+05:38.480 --> 05:42.720
+cmp de compare, quiero que vayas viendo
+el patrón de cómo decidieron ponerle
+
+05:42.720 --> 05:45.071
+estos nombres a nuestras funciones,
+eso te va a servir mucho
+
+05:45.196 --> 05:47.840
+para recordarlos y voy a comparar
+
+05:47.840 --> 05:53.393
+mi string 1 con mi string 2,
+simplemente se las pasamos
+
+05:53.519 --> 05:54.960
+como argumentos de las funciones
+
+05:54.960 --> 05:59.624
+que ahora tú ya sabes clarísimo
+qué es un argumento y eso está excelente,
+
+05:59.750 --> 06:02.616
+te cuento un poquito más de string
+compare cómo funciona,
+
+06:02.741 --> 06:06.661
+es súper simple, esto hace una comparación
+entre las dos cadenas de caracteres
+
+06:06.787 --> 06:09.661
+que tú le estás pasando y si te dice
+
+06:09.787 --> 06:12.540
+si son iguales entonces te retorna 0,
+
+06:12.666 --> 06:17.840
+0 el valor, el dígito 
+y si son diferentes entonces
+
+06:17.840 --> 06:22.014
+te retorna un 1.
+Con esto dicho hagamos nuestro if
+
+06:22.140 --> 06:24.980
+y vamos, ya sabemos
+que si el strcmp me dice
+
+06:25.106 --> 06:28.801
+el resultado de la comparación 
+fue igual a 0
+
+06:28.927 --> 06:32.000
+entonces la persona metió el caracter
+
+06:32.000 --> 06:35.105
+igual aquí se me fue
+un paréntesis de más,
+
+06:35.230 --> 06:38.720
+listo, y aquí también
+se me fue un paréntesis
+
+06:38.720 --> 06:42.520
+de más, excelente, entonces aquí quiero
+que veas esta operación que dice hago
+
+06:42.520 --> 06:45.896
+el strcmp esto nos retorna
+un resultado entonces
+
+06:46.021 --> 06:48.138
+va a valer 0 o 1 y yo le digo
+
+06:48.264 --> 06:52.240
+si eres igual a 0
+estoy haciendo una comparación,
+
+06:52.366 --> 06:56.630
+este es un operador de comparación,
+me dice si eres igual a 0 significa que,
+
+06:56.756 --> 07:00.780
+entonces va a ir el código 
+y aquí voy a imprimir.
+
+07:04.358 --> 07:05.498
+print
+
+07:06.465 --> 07:12.585
+ingresaste dos strings idénticos
+
+07:13.085 --> 07:17.057
+o dos strings idénticos, excelente,
+
+07:17.183 --> 07:20.354
+vamos a dejarle su buen 
+salto de línea, y ya
+
+07:20.693 --> 07:23.680
+punto y coma y en caso de que no,
+
+07:23.680 --> 07:26.526
+de hecho como es una sola línea
+de código en el if no necesitamos,
+
+07:26.652 --> 07:28.040
+acuérdate que yo te lo enseñé,
+
+07:28.040 --> 07:30.318
+no necesitamos las llavecitas,
+
+07:30.444 --> 07:35.547
+luego vamos a poner un else
+y dentro del else el código va a ser,
+
+07:37.014 --> 07:38.817
+vamos a borrar las llavecitas,
+
+07:40.869 --> 07:46.428
+el código dentro del else
+va a ser print ingresaste
+
+07:47.935 --> 07:53.567
+dos cosas distintas, excelente,
+
+07:53.693 --> 07:59.634
+salto de línea y punto y coma,
+bueno estamos listos
+
+07:59.760 --> 08:05.083
+para probar el código voy
+a borrar este print y guardamos,
+
+08:05.209 --> 08:07.960
+ya que guardamos simplemente
+compilemos y ejecutemos,
+
+08:08.086 --> 08:11.381
+ya sabes, si no sabes cómo lo programamos
+
+08:11.507 --> 08:14.684
+ve el primer curso de toda
+esta serie de cursos de C,
+
+08:14.810 --> 08:16.739
+ahí te enseño cómo configurar tu entorno,
+
+08:16.865 --> 08:20.174
+primero nos dice VS code,
+escribe una frase,
+
+08:20.561 --> 08:24.811
+hola platzi, 
+escribe otra frase para comparar,
+
+08:24.937 --> 08:28.263
+hola platzI,
+
+08:28.858 --> 08:31.391
+ingresaste dos cosas distintas,
+
+08:31.517 --> 08:34.280
+¿qué? pero si escribí lo mismo, 
+bueno recuerda
+
+08:34.280 --> 08:38.680
+lo que ya te había enseñado en C importa
+y son caracteres diferentes la I mayúscula
+
+08:38.680 --> 08:42.071
+y la I minúscula,
+probemos de nuevo nuestro programa,
+
+08:42.681 --> 08:45.511
+dice escribe una frase, hola,
+
+08:45.637 --> 08:50.840
+escribe otra frase para comparar,
+hola, ya ingresastedos strings idénticos,
+
+08:50.966 --> 08:53.243
+si te das cuenta nuestro string compare
+
+08:53.369 --> 08:54.485
+está funcionando a la perfección
+
+08:54.610 --> 08:56.800
+y la última función que te quiero enseñar
+
+08:56.800 --> 08:59.159
+recuerda que hay más,
+te reto a que las revises,
+
+08:59.285 --> 09:00.640
+a que investigues todas las que hay
+
+09:00.640 --> 09:02.978
+y que me las dejes
+en la sección de comentarios,
+
+09:03.103 --> 09:07.141
+la última que quiero
+mostrarte es el comando string concat,
+
+09:07.267 --> 09:10.022
+entonces cuando quiero
+que cuando sean diferentes,
+
+09:10.148 --> 09:13.672
+o sea en mi else y aquí sí
+voy a necesitar mis llaves,
+
+09:13.797 --> 09:16.613
+quiero que cuando sean
+diferentes las strings las concatene
+
+09:16.739 --> 09:18.989
+en una nueva y única string,
+
+09:19.352 --> 09:22.320
+es decir vamos a agarrar
+dos strings de caracteres
+
+09:22.320 --> 09:27.920
+y las vamos a juntar en una, esto se llama
+concatenar, no necesariamente en strings,
+
+09:27.920 --> 09:29.640
+tú puedes concatenar varias cosas
+
+09:29.766 --> 09:33.800
+pero vamos a analizar
+la concatenación de strings,
+
+09:33.800 --> 09:37.761
+es como encadenar, ok,
+es agarrar una y le pego la otra
+
+09:37.887 --> 09:39.304
+y todo esto se va a guardar
+
+09:39.430 --> 09:42.570
+en la primera string
+que le pasemos a nuestra función,
+
+09:42.696 --> 09:45.651
+vamos a ver cómo
+sería esto en la práctica,
+
+09:46.840 --> 09:49.021
+básicamente lo que vamos
+a hacer ahora es,
+
+09:49.147 --> 09:53.320
+en caso de que no ingresaste
+dos cosas distintas,
+
+09:53.320 --> 09:57.332
+si las unimos el resultado es
+
+10:00.465 --> 10:04.960
+y aquí tenemos que hacer la concatenación
+de nuestras strings,
+
+10:04.960 --> 10:07.079
+para esto vamos a utilizar la función
+
+10:07.205 --> 10:12.760
+strcat de string concatenation
+y esta función strcat
+
+10:12.760 --> 10:15.546
+requiere dos argumentos
+que son las dos strings
+
+10:15.672 --> 10:19.880
+que vamos a concatenar,
+string1, string2
+
+10:19.880 --> 10:22.920
+y lo cool es que todo lo guarda
+en la primera que le pases,
+
+10:23.046 --> 10:24.930
+así que si como le estamos pasando
+
+10:25.056 --> 10:27.498
+primero string1,
+ya solamente vamos
+
+10:27.623 --> 10:30.520
+a tener que imprimir
+string1 % string
+
+10:30.520 --> 10:37.057
+y vamos a pasarle la
+variable string1, excelente,
+
+10:37.730 --> 10:40.000
+guardamos, esto debería estar haciendo
+
+10:40.000 --> 10:46.906
+la concatenación, es súper simple de hacer
+y vamos a compilar nuestro código,
+
+10:47.499 --> 10:50.038
+y bien me dice escribe una frase,
+
+10:50.164 --> 10:52.436
+la frase que voy a poner va a ser
+
+10:52.562 --> 10:58.229
+al principio el lenguaje de programación,
+
+11:02.219 --> 11:07.140
+escribe otra frase, C es el mejor, punto,
+
+11:07.868 --> 11:10.240
+ingresaste dos cosas distintas,
+
+11:10.240 --> 11:14.353
+si las unimos el resultado es el lenguaje
+de programación C,
+
+11:14.479 --> 11:17.873
+mira que aquí hace la unión, es el mejor
+
+11:17.999 --> 11:21.103
+bien ya aprendiste cómo
+concatenar caracteres,
+
+11:21.229 --> 11:23.138
+recuerda que está haciéndolo
+
+11:23.264 --> 11:25.928
+de una forma en la que no le pusimos
+
+11:26.054 --> 11:28.160
+ningún espacio 
+a la segunda frase al inicio,
+
+11:28.160 --> 11:30.478
+así que lo ignora, todo lo hace perfecto,
+
+11:30.603 --> 11:32.920
+con esto dicho,
+te reto, como ya te dije,
+
+11:32.920 --> 11:36.192
+que me dejes en los comentarios
+qué otras funciones ves de strings
+
+11:36.318 --> 11:39.170
+y, ¿por qué no?
+que practiques con tus propios códigos,
+
+11:39.295 --> 11:41.760
+tienes todo lo que necesitas
+para ponerlas a pruebas,
+
+11:41.886 --> 11:46.084
+ya viste cómo yo combino ifs,
+elses que vimos en cursos anteriores
+
+11:46.210 --> 11:47.800
+con cuestiones que estamos aprendiendo
+
+11:47.800 --> 11:52.080
+en este curso y así sucesivamente vamos
+a seguir aprendiendo todo sobre C.
+
+11:52.206 --> 11:57.406
+Nos vemos en la próxima clase.

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/03-strcmp_249b729e-6242-41e0-83ce-fcbc7d8c1537.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <string.h>
+
+char string1[60];
+char string2[60];
+
+int main()
+{
+    
+
+    printf("Escribe una frase\n");
+    gets(string1);
+    printf("Escribe otra frase para comparar\n");
+    gets(string2);
+    
+    if (strcmp(string1, string2) == 0)
+        printf("Ingresaste dos strings identicos\n");
+    else
+    {
+        strcat(string1, string2);
+        printf("Ingresaste dos cosas distintas, si las unimos el resultado es> %s\n", string1);
+
+    }    
+    
+    
+    return 0;
+}

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/04-Manejo de tiempo en C con la biblioteca timeh.mp4

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/04-Manejo de tiempo en C con la biblioteca timeh.vtt

@@ -0,0 +1,718 @@
+WEBVTT
+
+00:03.273 --> 00:04.767
+Hablemos de time.h.
+
+00:04.893 --> 00:08.040
+Lo primero que te quiero contar es un
+dato curioso y es que no sé si conoces
+
+00:08.040 --> 00:11.722
+el Epoch Time de Unix.
+Bueno, esto es una fecha
+
+00:11.848 --> 00:14.726
+que se decidió de forma
+arbitraria pero que ha servido
+
+00:14.852 --> 00:16.691
+muchísimo para que todos
+los programas puedan
+
+00:16.817 --> 00:20.000
+seguir un estándar de fecha y hora.
+
+00:20.000 --> 00:23.358
+Y es que el Epoch Time se toma
+como que las horas
+
+00:23.483 --> 00:29.737
+o el tiempo que ha pasado en segundos
+desde el 1/1/1970
+
+00:29.863 --> 00:32.249
+a las 0 horas con 0 minutos.
+
+00:32.375 --> 00:35.440
+Simplemente es un punto
+en el tiempo que,
+
+00:35.440 --> 00:37.425
+como lo sabes, el tiempo es relativo.
+Nosotros los humanos
+
+00:37.551 --> 00:41.080
+decidimos guardarlo
+en horas, días, años,
+
+00:41.080 --> 00:43.646
+pero pues en computo se guarda en ciclos
+
+00:43.772 --> 00:45.613
+de procesamiento, por decirlo
+de alguna forma,
+
+00:45.739 --> 00:48.786
+y tenemos nuestros propios reloj
+en los CPUs.
+
+00:48.912 --> 00:51.954
+Estos reloj hacen que cada instrucción
+tome un tiempo
+
+00:52.080 --> 00:54.503
+y con eso tú puedes calcular
+tiempo específico
+
+00:54.629 --> 00:57.646
+en mundo de procesamiento
+y en mundo de cómputo y programación.
+
+00:57.772 --> 01:00.152
+Ahora, para no meternos
+y no hacernos bolas,
+
+01:00.278 --> 01:03.176
+solo quiero contarte eso.
+El Epoch Time es la fecha
+
+01:03.302 --> 01:08.051
+que se definió para comenzar a tomar
+el tiempo en programación.
+
+01:08.177 --> 01:10.223
+Vamos a nuestro VS Code,
+
+01:10.349 --> 01:16.173
+vamos a abrir un nuevo archivo, vamos
+a guardarlo y vamos a ponerle time.c.
+
+01:16.422 --> 01:23.416
+No, vamos a guardar otra vez file,
+save as, time.c.
+
+01:24.436 --> 01:28.862
+Ahora sí, todo está excelente.
+Lo primero que voy a mostrarte es,
+
+01:28.988 --> 01:31.383
+bueno, lo primero en verdad
+que voy a hacer
+
+01:31.509 --> 01:33.687
+es incluir STDIO como siempre,
+
+01:33.813 --> 01:38.386
+nuestra confiable
+biblioteca para input-output.
+
+01:38.512 --> 01:40.640
+Luego también vamos
+a incluir a la estrella
+
+01:40.640 --> 01:44.233
+de esta clase que es time.h.
+Excelente.
+
+01:44.359 --> 01:49.551
+Vamos a declarar una variable
+que va a ser de tipo time
+
+01:49.711 --> 01:52.494
+y esta variable se va a llamar seconds,
+
+01:54.541 --> 01:58.840
+seconds de segundos, punto y coma,
+y luego, bueno,
+
+01:58.840 --> 02:01.438
+ya con esto hecho
+vamos a hacer nuestro main.
+
+02:01.563 --> 02:06.247
+Int main. Esto se pone en un
+color verde porque es un type def,
+
+02:06.373 --> 02:09.251
+es un type definition, ok.
+Estamos definiendo
+
+02:09.376 --> 02:12.208
+un tipo específico de información
+
+02:12.334 --> 02:16.472
+y va a ser time-t, el tipo específico
+que estamos trabajando.
+
+02:16.598 --> 02:19.858
+Esto nos da una
+estructura de tipo long, long,
+
+02:19.984 --> 02:24.252
+y nos da los segundos, ok.
+Eso es todo lo que estamos haciendo ahí.
+
+02:24.378 --> 02:28.010
+Segundos es el nombre que yo le puse,
+como a cualquier variable.
+
+02:28.135 --> 02:32.827
+Vamos a tener nuestro main, excelente.
+Abrimos y cerramos nuestras llaves.
+
+02:32.953 --> 02:34.286
+Antes de que se nos olvide,
+
+02:34.412 --> 02:37.844
+escribimos nuestro return,
+cero, punto y coma,
+
+02:37.970 --> 02:41.015
+y estamos listos para
+meterle todo el código.
+
+02:41.402 --> 02:45.646
+Lo primero que voy a hacer
+es guardar el current time en epoch.
+
+02:45.772 --> 02:48.973
+Esto lo vamos a poner seconds,
+
+02:49.780 --> 02:51.020
+seconds,
+
+02:52.980 --> 02:57.154
+igual a time, que ya es una función
+
+02:57.280 --> 03:03.337
+de nuestra biblioteca time.h,
+y le vamos a pasar el argumento null.
+
+03:03.650 --> 03:05.773
+Muy bien, punto y coma.
+
+03:05.899 --> 03:10.981
+Luego de esto vamos a hacer
+un print y le voy a decir que
+
+03:12.702 --> 03:14.135
+el número
+
+03:16.988 --> 03:18.340
+de horas
+
+03:19.752 --> 03:21.899
+desde epoch,
+
+03:22.936 --> 03:28.054
+que es 1/1/1970
+
+03:28.180 --> 03:32.086
+a las 00, es,
+
+03:34.816 --> 03:36.621
+muy bien, ya lo tenemos acá.
+
+03:36.747 --> 03:39.526
+Ahora voy a dejar,
+voy a poner las variables
+
+03:39.652 --> 03:43.314
+que voy a pasarle a esto,
+que va a ser %d.
+
+03:45.327 --> 03:49.488
+Excelente. Y luego vamos a, de hecho,
+
+03:49.614 --> 03:52.298
+no es %d, es %ld, porque es un long
+
+03:52.423 --> 03:56.491
+y está en enteros.
+Le voy a pasar luego
+
+03:56.617 --> 04:00.867
+diagonal n para un salto
+de línea y vamos a agarrar
+
+04:00.993 --> 04:02.710
+nuestra variable de seconds
+
+04:03.660 --> 04:05.796
+y los vamos a dividir entre
+
+04:08.235 --> 04:10.569
+3600
+
+04:10.695 --> 04:16.410
+para pasarlo a horas.
+Muy bien, punto y coma.
+
+04:16.536 --> 04:20.594
+Guardamos, compilamos
+y veamos qué ocurre con nuestro programa.
+
+04:23.614 --> 04:24.747
+Y aquí está.
+
+04:25.366 --> 04:28.921
+Nos dice, oye, 
+el número de horas desde epoch,
+
+04:29.047 --> 04:35.997
+que es 1/1/1970 a las 00,
+han sido 442,162.
+
+04:36.921 --> 04:43.681
+Ya por último, para compilar
+que en efecto son 442,169 horas sin epoch,
+
+04:43.807 --> 04:47.074
+veamos en una página que se
+llama timeanddate.com
+
+04:47.200 --> 04:49.118
+y sí, en efecto, desde esa fecha
+
+04:49.244 --> 04:55.528
+han pasado 18,423 días,
+442,160 horas
+
+04:55.654 --> 04:58.400
+y estos minutos
+y estos segundos que no pienso leer
+
+04:58.400 --> 05:01.488
+porque están demasiado largos.
+Entonces ya vimos
+
+05:01.614 --> 05:04.820
+que nuestro epoch funciona,
+todo está bien en nuestro sistema.
+
+05:04.946 --> 05:07.078
+Ahora vamos a hacer otro ejemplo con time.
+
+05:07.203 --> 05:10.905
+Vamos a crear un nuevo archivo,
+nuevo archivo
+
+05:11.031 --> 05:13.481
+y quiero mostrarte
+cómo obtener la fecha
+
+05:13.607 --> 05:17.923
+y la hora de tu computadora.
+Bueno, como siempre,
+
+05:18.049 --> 05:21.469
+vamos a reutilizar
+el código anterior, control C,
+
+05:21.595 --> 05:24.041
+control C, vamos a nuestra nueva pestaña,
+
+05:24.167 --> 05:28.403
+control V, vamos a guardar esto
+como time div.
+
+05:28.529 --> 05:30.720
+Quiero mostrarte un ejemplo
+de cómo puedes tomar
+
+05:30.720 --> 05:33.998
+la diferencia de tiempo
+entre un punto y otro.
+
+05:34.123 --> 05:37.400
+Y bueno, aquí vamos 
+a guardar dos variables
+
+05:37.400 --> 05:41.171
+que van a ser de tipo tiempo,
+begin y end.
+
+05:41.625 --> 05:45.198
+Este caso de uso lo podrías tomar,
+por ejemplo, cuando estás haciendo
+
+05:45.324 --> 05:48.859
+un análisis de quieres saber cuánto
+se demoró tu código en ejecutarse,
+
+05:48.985 --> 05:51.082
+cuánto se tardó tu programa
+en hacer una tarea
+
+05:51.208 --> 05:53.515
+y justo te voy a mostrar
+cómo puedes hacer eso.
+
+05:53.781 --> 05:56.341
+Así que vamos a agarrar nuestro,
+
+05:56.467 --> 05:58.631
+vamos a crear una auxiliar i,
+
+05:58.757 --> 06:01.520
+este auxiliar va a ser de tipo long
+porque aquí
+
+06:01.520 --> 06:04.251
+sí que estamos trabajando
+con cantidades grandes de números,
+
+06:04.376 --> 06:06.827
+de ciclos, de cifras, etc.
+
+06:06.953 --> 06:09.503
+Vamos a,ya declaré mi auxiliar
+long,
+
+06:09.629 --> 06:13.896
+excelente y ahora vamos
+a agarrar el tiempo actual.
+
+06:14.022 --> 06:17.411
+Recuerda que si tú usas esto,
+no lo dije en la clase anterior,
+
+06:17.537 --> 06:20.528
+pero aprovecho a decirte ahorita,
+si tú pones time y agarras null,
+
+06:20.654 --> 06:22.689
+te da el tiempo a la fecha,
+
+06:22.814 --> 06:26.000
+el tiempo actual
+en tu sistema que tenemos,
+
+06:26.000 --> 06:28.541
+obviamente en epoch.
+Vamos a poner begin,
+
+06:28.667 --> 06:30.720
+es igual a time
+y esto es lo que nos va a servir
+
+06:30.720 --> 06:35.407
+es para almacenar en qué momento
+empezó nuestro programa a ejecutarse.
+
+06:35.674 --> 06:37.151
+Ahora voy a escribir un ciclo for
+
+06:37.277 --> 06:39.724
+para que sea nuestro consumidor,
+
+06:39.850 --> 06:42.054
+por decirlo así, de recursos.
+
+06:42.306 --> 06:46.124
+Es en donde se va a ir todo el tiempo
+de ejecución de este programa
+
+06:46.250 --> 06:52.405
+i igual a cero, sí,
+i menor a count, i menor que count
+
+06:52.531 --> 06:54.537
+y le voy a poner una cantidad grande
+
+06:54.663 --> 06:57.645
+para que se demore la ejecución,
+de verdad grande,
+
+06:57.771 --> 07:01.253
+vamos a ponerle unos 15,
+muchos ceros,
+
+07:01.419 --> 07:05.925
+ahí está y vamos a ponerle nuestro
+incrementador de uno en uno.
+
+07:05.951 --> 07:06.958
+Excelente.
+
+07:06.984 --> 07:11.040
+El código que voy a hacer,
+pues nada, en realidad solo quiero
+
+07:11.040 --> 07:13.298
+que este ciclo for nos robe tiempo,
+
+07:13.423 --> 07:16.622
+así que ni siquiera voy a molestarme
+en imprimir absolutamente nada
+
+07:16.748 --> 07:18.615
+y ya cuando termine el ciclo for,
+
+07:18.741 --> 07:21.160
+que de hecho como se va
+a ejecutar y no hay más código,
+
+07:21.160 --> 07:25.098
+le ponemos un punto y coma
+y cuando termine el ciclo for
+
+07:25.224 --> 07:28.876
+vamos a utilizar nuestro end para sacar
+
+07:29.002 --> 07:31.495
+otro snapshot del tiempo ahora.
+
+07:31.621 --> 07:33.820
+Time, null,
+
+07:35.020 --> 07:36.060
+muy bien,
+
+07:36.399 --> 07:37.997
+vamos a ponerle punto y coma
+
+07:38.123 --> 07:42.312
+vamos a imprimir el resultado.
+Ya tengo aquí un print,
+
+07:42.438 --> 07:46.246
+lo voy a reutilizar,
+el número de horas desde epoch, no
+
+07:46.752 --> 07:47.812
+el tiempo
+
+07:49.889 --> 07:54.210
+el tiempo que duró nuestro for es
+
+07:55.148 --> 07:59.107
+y bueno vamos a utilizar igual el %,
+
+07:59.233 --> 08:01.628
+uy no, bueno aquí va a ser %F
+
+08:01.754 --> 08:04.641
+porque estoy tomando
+mis segundos directamente,
+
+08:04.767 --> 08:09.420
+vamos a ponerlo así,
+to complete, ok y la variable
+
+08:09.546 --> 08:12.239
+que le voy a pasar
+es el diferencial del tiempo,
+
+08:12.365 --> 08:15.638
+así que aquí voy a ejecutar mi función,
+div time,
+
+08:16.917 --> 08:19.628
+vamos a ponerle end,
+que es el primer parámetro,
+
+08:19.754 --> 08:23.529
+luego begin, es decir,
+al tiempo final le vamos a restar
+
+08:23.655 --> 08:28.234
+el tiempo inicial para obtener en segundos
+cuántos segundos
+
+08:28.360 --> 08:32.546
+se demoró la ejecución de mi código,
+perfecto.
+
+08:33.032 --> 08:35.326
+Vamos a dejar aquí un espacio,
+excelente,
+
+08:35.452 --> 08:40.037
+guardamos y ejecutamos
+el programa a ver qué salida nos da.
+
+08:42.534 --> 08:46.904
+Se está ejecutando, si te das cuenta
+no ha terminado y sigue ejecutándose,
+
+08:47.364 --> 08:49.649
+oh my god, puede
+que me haya pasado de ceros,
+
+08:53.027 --> 08:55.574
+vamos a esperar a que termine de hacer
+la ejecución.
+
+08:56.973 --> 08:59.949
+Ahora en mi caso
+se demoró un par de minutos
+
+09:00.075 --> 09:02.677
+y no ha terminado,
+así que tenemos que seguir grabando,
+
+09:02.870 --> 09:04.881
+quiero mostrarte
+el administrador de tareas
+
+09:05.007 --> 09:07.458
+y si aquí buscamos nuestro
+programa que estamos ejecutando
+
+09:07.584 --> 09:11.679
+que es time diff, está consumiendo
+todo un núcleo de mi cpu,
+
+09:12.005 --> 09:14.648
+zoom meetings que es otro
+programa bastante pesado,
+
+09:14.774 --> 09:17.602
+hace video llamadas en internet,
+
+09:17.852 --> 09:19.930
+está consumiendo sólo el 20%,
+
+09:20.056 --> 09:23.757
+o sea time diff está consumiendo lo
+mismo que zoom que está procesando video,
+
+09:23.984 --> 09:26.743
+nada más para que te des cuenta
+que básicamente lo que hicimos
+
+09:26.869 --> 09:30.789
+fue poner un hilo de mi cpu
+que es de varios núcleos,
+
+09:31.029 --> 09:33.318
+un núcleo está única y exclusivamente
+
+09:33.443 --> 09:35.812
+trabajando en este programa de C
+
+09:36.032 --> 09:40.558
+que no tiene mucho sentido,
+así que bueno quería mostrarte eso,
+
+09:40.684 --> 09:42.719
+es curioso, no le pongas
+un número tan grande,
+
+09:43.019 --> 09:47.131
+aquí dice mi cpu pues es
+un cpu de bajo consumo energético
+
+09:47.257 --> 09:50.120
+pero aún así tiene su buen poder
+
+09:50.120 --> 09:54.627
+y bueno vamos a terminar
+la ejecución de este programa,
+
+09:54.753 --> 09:57.240
+voy a simplemente darle en borrar
+
+09:57.240 --> 10:00.556
+y vamos a reducir esto
+porque 15 billones no fue buena idea,
+
+10:00.682 --> 10:02.364
+le voy a quitar tres ceros,
+
+10:02.490 --> 10:05.720
+vamos a ponerle guardar
+y vamos a volver a ejecutarlo
+
+10:05.932 --> 10:09.091
+para ver cuánto se demora,
+de hecho le voy a quitar un cero más
+
+10:09.957 --> 10:13.816
+y vamos a guardar,
+ejecutar y veamos qué pasa,
+
+10:15.896 --> 10:18.823
+el tiempo que duró nuestro for es 0.00,
+
+10:19.010 --> 10:22.881
+ahora fue demasiado rápido,
+vamos a ponerle un cero,
+
+10:23.007 --> 10:24.486
+vamos a esperar a que demore más,
+
+10:26.699 --> 10:29.847
+vamos a compilar,
+ejecutar y sigue siendo 0,
+
+10:29.973 --> 10:32.497
+qué está pasando,
+vamos a ponerle uno más,
+
+10:38.356 --> 10:44.674
+ahí está, ya se demoró un segundo,
+entonces por fin aparece y como te decía,
+
+10:44.800 --> 10:47.798
+este fue el sweet spot que encontramos,
+
+10:47.923 --> 10:52.985
+a ver cuántos ceros le puse,
+1, 2, 3, 4, 5, 6, 150 millones,
+
+10:53.111 --> 10:56.251
+a ver pongámosle unos 60 millones,
+
+10:56.377 --> 10:59.731
+a ver cómo cambia la 600 millones,
+
+11:00.324 --> 11:02.172
+veamos cómo cambia
+el tiempo de ejecución,
+
+11:02.298 --> 11:05.320
+deberían ser unos 4 segundos de pronto,
+
+11:07.247 --> 11:09.498
+mira fueron 2 segundos, excelente,
+
+11:09.624 --> 11:11.834
+ya te diste cuenta 
+cómo está funcionando esto,
+
+11:12.061 --> 11:15.342
+siempre que quieras saber cuánto
+se demoró alguna parte de la ejecución,
+
+11:15.669 --> 11:17.712
+puedes utilizar esta funcionalidad,
+
+11:17.838 --> 11:21.289
+ahí te dejo esta última 
+utilidad de time.h,
+
+11:21.529 --> 11:24.896
+el mismo reto que en la clase anterior,
+cuéntame qué otras funciones
+
+11:25.021 --> 11:27.128
+te parecen interesantes de time.h,
+
+11:27.254 --> 11:30.205
+aquí en la sección de comentarios
+y te reto a que hagas un programa
+
+11:30.331 --> 11:32.379
+que te diga la fecha, la hora y el día
+
+11:32.626 --> 11:35.699
+y me dejes el screenshot
+justamente aquí al lado,
+
+11:35.960 --> 11:37.500
+con esto dicho nos vemos
+
+11:37.626 --> 11:44.626
+en la próxima clase de este curso.

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/04-time_b57bea89-545a-4dd2-aa58-9ee4ebf6dbb8.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <time.h>
+
+time_t seconds;
+
+int main()
+{
+
+    seconds = time( NULL);
+    printf("El numero de horas desde EPOCH 1ro de Enero de 1970 a las 00:00 es:%ld \n", seconds/3600);
+    return 0;
+}

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/04-timediff_73766468-af49-4500-94ef-07de638bb8c2.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <time.h>
+
+time_t begin, end;
+
+int main()
+{
+    long i;
+    begin = time(NULL);
+    for (i = 0; i < 600000000; i++);
+    end = time(NULL);
+    printf("El tiempo que duro nuestro for es: %f \n", difftime(end, begin));
+    return 0;
+}