Minor format changes

README.md

 [English](#markdown-header-using-functions-in-c-dvd-info) | [Español](#markdown-header-utilizando-funciones-en-c-informacion-de-dvds)
 
-# Utilizando funciones en C++ - Información de DVDs
+# KUtilizando funciones en C++ - Información de DVDs
 
 ![main1.png](images/main1.png)
 ![main2.png](images/main2.png)
 ##Funciones
 
 
-En matemática, una función $f$ es una regla que se usa para asignar a cada elemento $x$ de un conjunto que se llama *dominio*, uno (y solo un) elemento $y$ de un conjunto que se llama *campo de valores*. Por lo general, esa regla se representa como una ecuación, $y=f(x)$. La variable $x$ es el parámetro de la función y la variable $y$ contendrá el resultado de la función. Una función puede tener más de un parámetro pero solo un resultado. Por ejemplo, una función puede tener la forma $y=f(x_1,x_2)$ en donde hay dos parámetros y para cada par $(a,b)$ que se use como argumento de la función, la función tiene un solo valor de $y=f(a,b)$. El dominio de la función te dice el tipo de valor que debe tener el parámetro y el campo de valores el tipo de valor que tendrá el resultado que devuelve la función.
+En matemática, una función $$f$$ es una regla que se usa para asignar a cada elemento $$x$$ de un conjunto que se llama *dominio*, uno (y solo un) elemento $$y$$ de un conjunto que se llama *campo de valores*. Por lo general, esa regla se representa como una ecuación, $$y=f(x)$$. La variable $$x$$ es el parámetro de la función y la variable $$y$$ contendrá el resultado de la función. Una función puede tener más de un parámetro pero solo un resultado. Por ejemplo, una función puede tener la forma $$y=f(x_1,x_2)$$ en donde hay dos parámetros y para cada par $$(a,b)$$ que se use como argumento de la función, la función tiene un solo valor de $$y=f(a,b)$$. El dominio de la función te dice el tipo de valor que debe tener el parámetro y el campo de valores el tipo de valor que tendrá el resultado que devuelve la función.
 
 Las funciones en lenguajes de programación de computadoras son similares. Una función 
 tiene una serie de instrucciones que toman los valores asignados a los parámetros y realiza alguna tarea. En C++ y en algunos otros lenguajes de programación, las funciones solo pueden devolver un resultado, tal y como sucede en matemáticas. La única diferencia es que una función en programación puede que no devuelva valor (en este caso la función se declara `void`). Si la función va a devolver algún valor, se hace con la instrucción `return`. Al igual que en matemática tienes que especificar el dominio y el campo de valores, en programación tienes que especificar los tipos de valores que tienen los parámetros y el resultado que devuelve la función; esto lo haces al declarar la función.
 
 La primera oración de una función se llama el *encabezado* y su estructura es como sigue:
 
-`tipo nombre(tipo parámetro01, ..., tipo parámetro0n)`
+`tipo nombre(tipo parámetro_1, ..., tipo parámetro_n)`
 
 Por ejemplo,
 
-`int ejemplo(int var1, float var2, char &var3)`
+```cpp
+int ejemplo(int var1, float var2, char &var3)
+```
 
 sería el encabezado de la función llamada `ejemplo`, que devuelve un valor entero. La función recibe como argumentos un valor entero (y guardará una copia en `var1`), un valor de tipo `float` (y guardará una copia en `var2`) y la referencia a una variable de tipo  `char` que se guardará en la variable de referencia `var3`. Nota que `var3` tiene el signo `&` antes del nombre de la variable. Esto indica que `var3` contendrá la referencia a un caracter.
 
 
 Si queremos guardar el valor del resultado de la función `ejemplo` en la variable `resultado` (que deberá ser de tipo entero), invocamos la función pasando argumentos de manera similar a:
 
-`resultado=ejemplo(2, 3.5, unCar);`
+```cpp
+resultado = ejemplo(2, 3.5, unCar);
+```
 
 Nota que al invocar funciones no incluyes el tipo de las variables en los argumentos. Como en la definición de la función `ejemplo` el tercer parámetro `&var3` es una variable de referencia, lo que se está enviando en el tercer argumento de la invocación es una *referencia* a la variable `unCar`. Los cambios que se hagan en la variable `var3` están cambiando el contenido de la variable `unCar`.
 
 También puedes usar el resultado de la función sin tener que guardarlo en una variable. Por ejemplo puedes imprimirlo:
 
-`cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);`
+```cpp
+cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);
+```
 
 o utilizarlo en una expresión aritmética:
 
-`y=3 + ejemplo(2, 3.5, unCar);`
-
+```cpp
+y = 3 + ejemplo(2, 3.5, unCar);
+```
 
 
 ###Funciones sobrecargadas (‘overloaded’)
 
 Los siguientes prototipos de funciones tienen la misma firma:
 
-```
+```cpp
 int ejemplo(int, int) ;
 void ejemplo(int, int) ; 
 string ejemplo(int, int) ;
 
 Los siguientes prototipos de  funciones tienen firmas diferentes:
 
-```
+```cpp
 int ejemplo(int) ;
 int olpmeje(int) ;
 ```
+
 Nota que a pesar de que las funciones tienen la misma cantidad de parámetros con mismo tipo `int`, el nombre de las funciones es distinto.
 
 Los siguientes prototipos de funciones son versiones sobrecargadas de la función `ejemplo`:
 
-```
+```cpp
 int ejemplo(int) ;
 void ejemplo(char) ;
 int ejemplo(int, int) ;
 
 1.  Carga a Qt el proyecto `DVDInfo`  haciendo doble "click" en el archivo `DVDInfo.pro` que se encuentra en la carpeta `Documents/eip/Functions-DVDInfo` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/functions-dvdinfo` para descargar la carpeta `Functions-DVDInfo` a tu computadora.
 
-
 2. Configura el proyecto. El archivo `main.cpp` tiene la invocación de las funciones que usarás en los siguientes ejercicios.  En los archivos `movie.h` y `movie.cpp` se encuentra la declaración y definición de las funciones que vas a invocar.
  
 3. Haz doble "click" en el archivo `movie.h` que contiene los prototipos de las funciones de este proyecto. Ve a `movie.h` e identifica cuál o cuáles funciones son sobrecargadas y describe por qué.
-
+    
     Estudia los prototipos de funciones contenidas en `movie.h` de modo que sepas la tarea que realizan y los tipos de datos que reciben y devuelven. Identifica los tipos de datos que recibe y devuelve cada una de las siguientes funciones:
 
-    ```
+    ```cpp
     showMovie
     showMovies (las dos)
     getMovieName
 
 1. Abre el archivo `main.cpp` y modifica la función `main` para que despliegue en la pantalla las películas en las posiciones 80 hasta la 100.
 
-
 2. Ahora modifica  la función `main` para que despliegue en la pantalla solo las películas que contengan “forrest gump” en el título.
 
-
 3. Modifica nuevamente la función `main` para que despliegue en la pantalla solo la película en la posición  75125 usando composición de funciones y la función `showMovie`.
 
 4. Para la película en la parte  3 de este ejercicio, modifica la función `main` para que solo despliegue el nombre y el rating de la película.
 
 3. Implementa una función sobrecargada `getMovieInfo` que devuelva el nombre del estudio además del nombre, rating, año y género. Invoca la función `getMovieInfo` desde `main()` para desplegar el nombre,  estudio, rating, año y género de la película en la posición 75125 y así demostrar su funcionamiento.
 
-
 4. Implementa una función `showMovieInLine` que **despliegue** la información de una película que despliega `showMovie` pero en una sola línea. La función debe tener un parámetro de modo que reciba el "string" de información de la película. Invoca la función `showMovieInLine` desde `main()` para desplegar la información de la película en la posición 75125 y así demostrar su funcionamiento.
 
 5. Implementa una función `showMoviesInLine` que **despliegue** la misma información que despliega `showMovies`  (todas las películas en un rango de posiciones) pero en una sola línea por película. Por ejemplo, una invocación a la función sería
 
 ##Functions
 
-In mathematics, a function $f$ is a rule that is used to assign to each element $x$ from a set called *domain*, one (and only one) element $y$ from a set called *range*. This rule is commonly represented with an equation, $y=f(x)$. The variable $x$ is the parameter of the function and the variable $y$ will contain the result of the function. A function can have more than one parameter, but only one result. For example, a function can have the form $y=f(x_1,x_2)$ where there are two parameters, and for each pair $(a,b)$ that is used as an argument in the function, the function has only one value of $y=f(a,b)$. The domain of the function tells us the type of value that the parameter should have and the range tells us the value that the returned result will have.
+In mathematics, a function $$f$$ is a rule that is used to assign to each element $$x$$ from a set called *domain*, one (and only one) element $$y$$ from a set called *range*. This rule is commonly represented with an equation, $$y=f(x)$$. The variable $$x$$ is the parameter of the function and the variable $$y$$ will contain the result of the function. A function can have more than one parameter, but only one result. For example, a function can have the form $$y=f(x_1,x_2)$$ where there are two parameters, and for each pair $$(a,b)$$ that is used as an argument in the function, the function has only one value of $$y=f(a,b)$$. The domain of the function tells us the type of value that the parameter should have and the range tells us the value that the returned result will have.
 
 Functions in programming languages are similar. A function has a series of instructions that take the assigned values as parameters and performs a certain task. In C++ and other programming languages, functions return only one result, as it happens in mathematics. The only difference is that a *programming* function could possibly not return any value (in this case the function is declared as `void`). If the function will return a value, we use the instruction `return`. As in math, you need to specify the types of values that the function's parameters and result will have; this is done when declaring the function.
 
 
 The first sentence of a function is called the *header* and its structure is as follows:
 
-`type name(type parameter01, ..., type parameter0n)`
+`type name(type parameter_1, ..., type parameter_n)`
 
 For example,
 
-`int example(int var1, float var2, char &var3)`
+```cpp
+int example(int var1, float var2, char &var3)
+```
 
 would be the header of the function called `example`, which returns an integer value. The function receives as arguments an integer value (and will store a copy in `var1`), a value of type `float` (and will store a copy in `var2`) and the reference to a variable of type `char` that will be stored in the reference variable `var3`. Note that `var3` has a & symbol before the name of the variable. This indicates that `var3` will contain the reference to a character.
 
 
 If we want to store the value of the `example` function's result in a variable `result` (that would be of type integer), we invoke the function by passing arguments as follows:
 
-`result=example(2, 3.5, unCar);`
+```cpp
+result=example(2, 3.5, unCar);
+```
 
 Note that as the function is invoked, you don't include the type of the variables in the arguments. As in the definition for the function `example`, the third parameter `&var3` is a reference variable; what is being sent to the third argument when invoking the function is a *reference* to the variable `unCar`. Any changes that are made on the variable `var3` will change the contents of the variable `unCar`.
 
 You can also use the function's result without having to store it in a variable. For example you could print it:
 
-`cout << "The result of the function example is:" << example(2, 3.5, unCar);`
+```cpp
+cout << "The result of the function example is:" << example(2, 3.5, unCar);
+```
 
 or use it in an arithmetic expression:
 
-`y=3 + example(2, 3.5, unCar);`
+```cpp
+y = 3 + example(2, 3.5, unCar);
+```
 
 
 
 
 The following function prototypes have the same signature:
 
-```
+```cpp
 int example(int, int) ;
 void example(int, int) ; 
 string example(int, int) ;
 
 The following function prototypes have different signatures:
 
-```
+```cpp
 int example(int) ;
 int elpmaxe(int) ;
 ```
 
 The following function prototypes are overloaded versions of the function `example`:
 
-```
+```cpp
 int example(int) ;
 void example(char) ;
 int example(int, int) ;
 
 1. **Header:** `int example(int var1, float var2=5.0, int var3 = 10)` 
 
-
     **Invocation:**
 
     a. `example(5, , 10)` This function call is **invalid** because it leaves an empty space in the middle argument.
 DVD stands for "digital versatile disk" or "digital video disk", which is an optical disc format for storing digital information invented by Philips, Sony, Toshiba, and Panasonic in 1995. The DVD offers larger storage capacity than compact disks (CD), but have the same dimensions. DVDs can be used to store any kind of digital data, but are famous for their use in the distribution of movies.
 
 ---
+
 ---
 
 
     
     Study the function prototypes and documentation in `movie.h` so that you understand the task they carry out and the data types they receive and return. For each of the following functions, identify the data types they receive and return:
 
-    ```
+    ```cpp
     showMovie
-    showMovies (las dos)
+    showMovies (both versions)
     getMovieName
     getMovieByName
     ```
 
 4. For the movie in part 3 of this exercise, add the necessary code to the `main` function so that the program displays the name and the rating of the movie.
 
-
 5. For the movie in part 3, add the necessary code to the `main` function so that, using `getMovieInfo`, it displays the name, rating, year and the genre of the movie in one line. Hint: note that the function `getMovieInfo` has parameters that are passed by reference. 
 
 ###Exercise 3
 [3] http://www.soft32.com/blog/platforms/windows/keep-your-dvd-collection-up-to-date-with-emdb-erics-movie-database/
 
 [4] http://www.hometheaterinfo.com/dvdlist.htm
-
-
-
-
-
-
-
-
-