Update PR4

This commit is contained in:
Manuel Vergara 2024-06-02 20:48:24 +02:00
parent 19034a1b78
commit 5bfcbb9efc

View File

@ -6,12 +6,11 @@
- [PR 3](#pr-3) - [PR 3](#pr-3)
- [17. Esquemas de recorrido y búsqueda](#17-esquemas-de-recorrido-y-búsqueda) - [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. Aprocimación intuitiva](#171-aprocimación-intuitiva)
- [17.1.1. Ejemplo temperatura media](#1711-ejemplo-temperatura-media) - [17.1.1. Ejemplo 1 - Temperatura media](#1711-ejemplo-1---temperatura-media)
- [17.1.2. Ejemplo](#1712-ejemplo) - [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.2. Esquema de recorrido](#172-esquema-de-recorrido)
- [17.3. Esquema de búsqueda](#173-esquema-de-búsqueda) - [17.3. Esquema de búsqueda](#173-esquema-de-búsqueda)
- [17.3.1. Ejemplo](#1731-ejemplo) - [17.3.1. Ejemplo](#1731-ejemplo)
- [17.4. Ejercicios](#174-ejercicios)
## 17. Esquemas de recorrido y búsqueda ## 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. 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: 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. 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 ### 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();` <br> `media := media + temperatura;` <br> `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;`<br>`movieTheater.collect[movieTheater.numTheaters] := temp;` <br> `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 ### 17.3. Esquema de búsqueda
Vamos a ver un ejemplo que es lo más esclarecedor.
#### 17.3.1. Ejemplo #### 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 <stdio.h>
#include <stdbool.h>
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; <br> `encontrado := false;` |
| Comprobar si ya hemos llegado al último elemento | `while i <= 365 and not encontrado do` |
| Actualizar encontrado | `t[i] := readReal();` <br> `if t[i] ≤ 0 entonces encontrado:= true;` |
| Acceso al siguiente elemento | `if not encontrado then` <br> `i:= i +1;` <br> `end if` <br> `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) [Volver arriba](#pr-1)