diff --git a/fundamentos-programacion/PR4/README.md b/fundamentos-programacion/PR4/README.md
index d315e3c..2cc4836 100644
--- a/fundamentos-programacion/PR4/README.md
+++ b/fundamentos-programacion/PR4/README.md
@@ -6,12 +6,11 @@
- [PR 3](#pr-3)
- [17. Esquemas de recorrido y búsqueda](#17-esquemas-de-recorrido-y-búsqueda)
- [17.1. Aprocimación intuitiva](#171-aprocimación-intuitiva)
- - [17.1.1. Ejemplo temperatura media](#1711-ejemplo-temperatura-media)
- - [17.1.2. Ejemplo](#1712-ejemplo)
+ - [17.1.1. Ejemplo 1 - Temperatura media](#1711-ejemplo-1---temperatura-media)
+ - [17.1.2. Ejemplo 2 - Recaudaciones de una sala de cine](#1712-ejemplo-2---recaudaciones-de-una-sala-de-cine)
- [17.2. Esquema de recorrido](#172-esquema-de-recorrido)
- [17.3. Esquema de búsqueda](#173-esquema-de-búsqueda)
- [17.3.1. Ejemplo](#1731-ejemplo)
- - [17.4. Ejercicios](#174-ejercicios)
## 17. Esquemas de recorrido y búsqueda
@@ -26,7 +25,7 @@ Un esquema es una especie de plantilla que nos permite solucionar un tipo de pro
La idea es que, en lugar de ir a ciegas, sigamos un esquema de recorrido o búsqueda que nos permita ir avanzando de manera sistemática y eficiente. Por ejemplo, si tenemos que recorrer una matriz, podemos hacerlo por filas o por columnas, o si tenemos que buscar un elemento en una lista, podemos hacerlo de manera secuencial o binaria.
-#### 17.1.1. Ejemplo temperatura media
+#### 17.1.1. Ejemplo 1 - Temperatura media
Vamos a calcular la temperatura media de todo el año suponiendo que vamos leyendo por el canal de entrada las temperaturas medias de cada día:
@@ -76,7 +75,7 @@ int main(int argc, char** argv) {
```
-#### 17.1.2. Ejemplo
+#### 17.1.2. Ejemplo 2 - Recaudaciones de una sala de cine
Cargamos los datos de una tabla de recaudaciones de una sala de cine a partir de lo leído por el canal de entrada estándar.
@@ -145,23 +144,170 @@ void fillTable(tTheater *movieTheater) {
### 17.2. Esquema de recorrido
+En los dos ejemplos anteriores estamos haciendo un recorrido a través de una serie de datos repitiendo el mismo esquema:
+1. Acceso al primer elemento. En el primer ejemplo, leemos el primer valor de la temperatura y en el segundo, leemos el primer valor de la tabla.
+2. Tratamiento inicial. Inicializamos las variables que utilizaremos para hacer el tratamiento posterior.
+3. Último elemento. Comprobamos si hemos llegado al último elemento.
+4. Trater elemento. Aplicamos las acciones necesarias para resolver cada uno de los datos a tratar.
+5. Acceso al siguiente elemento.
+6. Tratamiento final. Terminar las acciones que queden por resolver el problema.
+
+**Ejemplo 1**
+
+| Partes | Código |
+| ------------------------------------------------ | ---------------------------------------------------------------------------------- |
+| Acceso al primer elemento | `i := 1;` |
+| Tratamiento inicial | `media := 0;` |
+| Comprobar si ya hemos llegado al último elemento | `while i <= 365 do` |
+| Tratar el elemento | `temperatura := readReal();`
`media := media + temperatura;`
`end while` |
+| Acceso al siguiente elemento | `i := i + 1` |
+| Tratamiento final | `writeReal(media/365.0)` |
+
+**Ejemplo 2**
+
+| Partes | Código |
+| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| Acceso al primer elemento | `temp := readReal();` |
+| Tratamiento inicial | `movieTheater.numTheaters := 0;` |
+| Comprobar si ya hemos llegado al último elemento | `while temp ≠ END_SEQ do` |
+| Tratar el elemento | `movieTheater.numTheaters := movieTheater.numTheaters + 1;`
`movieTheater.collect[movieTheater.numTheaters] := temp;`
`end while` |
+| Acceso al siguiente elemento | `temp := readReal();` |
+| Tratamiento final | - |
+
+Con lo cual, en estos dos casos se comparte el **esquema de recorrido**, ya sea para recorrer datos que leemos del canal estándar o datos de una tabla. Un patrón habitual es el siguiente:
+
+```alg
+algorithm esquemaRecorrido
+
+ {acceder al primer elemento}
+ {tratamiento inicial}
+
+ while not {último elemento} do
+ {tratar elemento}
+ {acceder al siguiente elemento}
+ end while
+
+ {tratamiento final}
+
+end algorithm
+```
+
+Tener en cuenta que:
+- Todos los elementos de la secuencia son del mismo tipo.
+- Procesamos todos los elementos de la misma manera.
+- Es necesario saber cómo se acaba la secuencia.
### 17.3. Esquema de búsqueda
+Vamos a ver un ejemplo que es lo más esclarecedor.
#### 17.3.1. Ejemplo
+A partir de las temperaturas medias de un año que leemos por el canal estándar, averiguar el primer día que ha helado. Debemos comprobar que la temperatura es negativa.
+```alg
+algorithm hasFrozen
-### 17.4. Ejercicios
+ var
+ t: vector[365] real;
+ frost: boolean;
+ i: integer;
+ end var
+ i:= 1;
+ frost:= false;
+ while i ≤ 365 and frost == false do
+ t[i]:=readReal();
+ if t[i] ≤ 0 then
+ frost:= true;
+ end if
+ i:=i+1:
+ end while
+ writeBoolean(frost);
+end algorithm
+```
+```c
+#include
+#include
+
+int main(int argc, char** argv) {
+ float t[365];
+ bool frost;
+ int i;
+
+ i = 0;
+ frost = false;
+
+ while (i < 365 && !frost) {
+ scanf("%f", &t[i]);
+ if (t[i] <= 0) {
+ frost = true;
+ }
+ i = i + 1;
+ }
+
+ printf("%d\n", frost); /* Equivalence in C language: 0 == false, 1 == true */
+
+ return 0;
+}
+```
+
+Cuando encontramos el primer caso de temperatura negativa ya podemos dejar de buscar, hemos realizado una **búsqueda**. Otro caso sería si quisieramos saber cuántos días ha helado, que tendríamos que hacer un **recorrido** por todas las temperaturas.
+
+Los pasos del esquema de búsqueda son:
+1. Acceder al primer elemento.
+2. Tratamiento inicial.
+3. Último elemento
+4. Actualizar encontrado
+5. Acceder al siguiente elemento.
+6. Tratamiento final.
+
+| Partes | Código |
+| ------------------------------------------------ | ------------------------------------------------------------------------ |
+| Acceso al primer elemento | `i := 1;` |
+| Tratamiento inicial | no hace falta inicializar ninguna variable;
`encontrado := false;` |
+| Comprobar si ya hemos llegado al último elemento | `while i <= 365 and not encontrado do` |
+| Actualizar encontrado | `t[i] := readReal();`
`if t[i] ≤ 0 entonces encontrado:= true;` |
+| Acceso al siguiente elemento | `if not encontrado then`
`i:= i +1;`
`end if`
`end while` |
+| Tratamiento final | `writeBoolean(encontrado)` |
+
+Por lo tanto, este sería el **esquema de búsqueda**:
+
+```alg
+algorithm esquemaBusqueda
+ var
+ encontrado: boolean;
+ end var
+
+ {acceder_primer_elemento}
+ {tratamiento_inicial}
+
+ encontrado:= false;
+
+ while not {último elemento} and not encontrado do
+ if {elemento tratado cumple condición} then
+ encontrado:= true;
+ else
+ {acceder al siguiente elemento}
+ end if
+ end while
+
+ {tratamiento_final}
+
+end algorithm
+```
+
+Tener en cuenta que:
+- Recorremos únicamente la secuencia hasta encontrar el elemento que cumple una determinada condición.
+- Se contempla la posibilidad de que no se encuentre el elemento buscado.
+- El esquema finaliza si se encuentra el elemento buscado o si se ha recorrido toda la secuencia.
[Volver arriba](#pr-1)