From 5bfcbb9efcc87807257bcfe9b676a2e66becda2b Mon Sep 17 00:00:00 2001 From: Manuel Vergara Date: Sun, 2 Jun 2024 20:48:24 +0200 Subject: [PATCH] Update PR4 --- fundamentos-programacion/PR4/README.md | 158 ++++++++++++++++++++++++- 1 file changed, 152 insertions(+), 6 deletions(-) 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)