Update PR1
This commit is contained in:
parent
b2507e37e9
commit
9569749ff6
@ -4,99 +4,583 @@
|
||||
- [PR 1](#pr-1)
|
||||
- [9. Estructura de Control iterativa](#9-estructura-de-control-iterativa)
|
||||
- [9.1. Estructura (o composición) iterativa: aproximación intuitiva](#91-estructura-o-composición-iterativa-aproximación-intuitiva)
|
||||
- [9.1.1. Ejemplo 10\_01 - Receta de cocina](#911-ejemplo-10_01---receta-de-cocina)
|
||||
- [9.1.2. Ejemplo 10\_02 - Ir en Bici](#912-ejemplo-10_02---ir-en-bici)
|
||||
- [9.1.3. Ejemplo 10\_03 - Pared](#913-ejemplo-10_03---pared)
|
||||
- [9.1.1. Ejemplos](#911-ejemplos)
|
||||
- [9.2. Codificación estructura iterativa](#92-codificación-estructura-iterativa)
|
||||
- [9.2.1. Ejemplo 10\_04 - Pared](#921-ejemplo-10_04---pared)
|
||||
- [9.2.2. Ejemplo 10\_05 - Multiplicación](#922-ejemplo-10_05---multiplicación)
|
||||
- [9.2.3. Ejemplo 10\_06 - Factorial](#923-ejemplo-10_06---factorial)
|
||||
- [9.2.1. Ejemplo Pared](#921-ejemplo-pared)
|
||||
- [9.2.2. Ejemplo Multiplicación](#922-ejemplo-multiplicación)
|
||||
- [9.2.3. Ejemplo Factorial](#923-ejemplo-factorial)
|
||||
- [9.2.4. La condición de final del bucle](#924-la-condición-de-final-del-bucle)
|
||||
- [9.3. Variante de la estructura iterativa](#93-variante-de-la-estructura-iterativa)
|
||||
- [9.3.1. La construcción while](#931-la-construcción-while)
|
||||
- [9.3.2. La construcción for](#932-la-construcción-for)
|
||||
- [9.3.1. La construcción `while`](#931-la-construcción-while)
|
||||
- [9.3.2. La construcción `for`](#932-la-construcción-for)
|
||||
- [9.3.2.1. Modificadores de la composición](#9321-modificadores-de-la-composición)
|
||||
- [9.3.3. Ejemplos](#933-ejemplos)
|
||||
- [9.3.3.1. Ejemplo 10\_08 - Cuenta atrás](#9331-ejemplo-10_08---cuenta-atrás)
|
||||
- [9.3.3.2. Ejemplo 10\_09 - Sumador de pares](#9332-ejemplo-10_09---sumador-de-pares)
|
||||
- [9.3.3.3. Ejemplo 10\_10 - Temperatura Media](#9333-ejemplo-10_10---temperatura-media)
|
||||
- [9.3.3.4. Ejemplo 10\_13 - Ha helado](#9334-ejemplo-10_13---ha-helado)
|
||||
- [9.3.3.5. Ejemplo 10\_14 - Cuenta de días](#9335-ejemplo-10_14---cuenta-de-días)
|
||||
|
||||
|
||||
|
||||
## 9. Estructura de Control iterativa
|
||||
|
||||
Estructuras de control de flujo iterativas que se añaden a las estructuras de control secuencial y selectiva. Permiten repetir un conjunto de instrucciones un número determinado de veces o hasta que se cumpla una condición.
|
||||
|
||||
También se conoce como bucle o loop.
|
||||
|
||||
Un programa puede ejecutar una instrucción o un conjunto de instrucciones varias veces hasta cumplor una determinada condición.
|
||||
|
||||
|
||||
### 9.1. Estructura (o composición) iterativa: aproximación intuitiva
|
||||
|
||||
#### 9.1.1. Ejemplo 10_01 - Receta de cocina
|
||||
La estructura iterativa está muy presente en la vida cotidiana.
|
||||
|
||||
El primer paso es consultar el estado actual o condición. Aquí se evalúa una expresión lógica que da como resultado un valor booleano. Según el resultado, o bien ejecuta las instrucciones del bucle y vuelve al punto de evaluación de la condición, o bien, se continua con la ejecución del resto del programa, terminan la iteración.
|
||||
|
||||
#### 9.1.1. Ejemplos
|
||||
|
||||
#### 9.1.2. Ejemplo 10_02 - Ir en Bici
|
||||
|
||||
|
||||
|
||||
#### 9.1.3. Ejemplo 10_03 - Pared
|
||||
- Receta de cocina: Mientras la salsa no esté ligada, remover a fuego lento.
|
||||
- Ir en Bici: Voy en bici mientras tenga ganas
|
||||
- Pared: Poner otra fila de ladrillos encima de la última hasta llegar al techo.
|
||||
|
||||
|
||||
### 9.2. Codificación estructura iterativa
|
||||
|
||||
La estructura de control iterativa `while` es la más general. Se ejecuta mientras la condición sea verdadera.
|
||||
|
||||
| Partes | Codificación en lenguaje algorítmico |
|
||||
| ------------------------------------------- | ------------------------------------ |
|
||||
| Consulta sobre el estado actual o condición | `while expresión condicional do` |
|
||||
| Qué hacer cuando la condición es Cierta | `bloque de instrucciones` |
|
||||
| Marca de fin de estructura iterativa | `end while` |
|
||||
|
||||
#### 9.2.1. Ejemplo Pared
|
||||
|
||||
Si la altura de la pared es menor que la altura del techo, se construye una fila de ladrillos y se vuelve a preguntar por la altura de la pared.
|
||||
|
||||
```c
|
||||
algorithm wall
|
||||
var
|
||||
heightWall: real;
|
||||
heightCeiling: real;
|
||||
end var
|
||||
heightWall := readReal();
|
||||
heightCeiling := readReal();
|
||||
while heightWall < heightCeiling do
|
||||
buildWall();
|
||||
heightWall := readReal();
|
||||
end while
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
int main(int argc, char** argv) {
|
||||
float heightWall, heightCeiling;
|
||||
scanf("%f", &heightWall);
|
||||
scanf("%f", &heightCeiling);
|
||||
|
||||
while (heightWall < heightCeiling) {
|
||||
buildWall(); // función que construye una fila de ladrillos y lo suma a la variable heightWall
|
||||
scanf("%f", &heightWall); // se vuelve a preguntar por la altura de la pared
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
En caso de que la altura de la pared sea mayor o igual a la altura del techo, el bucle no se ejecuta y se continúa con el resto del programa.
|
||||
|
||||
|
||||
#### 9.2.1. Ejemplo 10_04 - Pared
|
||||
#### 9.2.2. Ejemplo Multiplicación
|
||||
|
||||
Realizar una multiplicación sin el operador `*`. Podemos hacer la multiplicación de dos números enteros positivos `a` y `b` sumando `a` veces el número `b`.
|
||||
|
||||
```c
|
||||
algorithm multiplicationIntegers
|
||||
var
|
||||
n: integer;
|
||||
m: integer;
|
||||
x: integer;
|
||||
end var
|
||||
n := readInteger();
|
||||
m := readInteger();
|
||||
x := 0;
|
||||
while m ≠ 0 do
|
||||
x := x+n;
|
||||
m := m-1;
|
||||
end while
|
||||
writeInteger(x);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
int main(int argc, char** argv) {
|
||||
int n, m, x;
|
||||
scanf("%d", &n);
|
||||
scanf("%d", &m);
|
||||
x = 0;
|
||||
|
||||
while (m != 0) {
|
||||
x = x + n; // Equivalence in C language: x += n;
|
||||
m = m - 1; // Equivalence in C language: m--;
|
||||
}
|
||||
printf("%d", x);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Necesitamos una variable auxiliar `x` que se inicializa a 0. Se suma `n` a `x` tantas veces como `m` sea mayor que 0.
|
||||
|
||||
|
||||
#### 9.2.3. Ejemplo Factorial
|
||||
|
||||
#### 9.2.2. Ejemplo 10_05 - Multiplicación
|
||||
Cálculo factorial de un número entero positivo. El factorial de un número se calcula así:
|
||||
|
||||
factorial(0) = 1 y
|
||||
factorial(n) = n * factorial(n-1)
|
||||
|
||||
#### 9.2.3. Ejemplo 10_06 - Factorial
|
||||
Para hacer el cálculo hay que multiplicar todos los números entre 1 y el número del cual queremos calcular el factorial.
|
||||
|
||||
```c
|
||||
algorithm factorial
|
||||
var
|
||||
n: integer;
|
||||
i: integer;
|
||||
fact: integer;
|
||||
end var
|
||||
n := readInteger();
|
||||
i := 1:
|
||||
fact := 1;
|
||||
while i ≤ n do
|
||||
fact := fact*i;
|
||||
i := i+1;
|
||||
end while
|
||||
writeInteger(fact);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int n, i, fact;
|
||||
scanf("%d", &n);
|
||||
i = 1;
|
||||
fact = 1;
|
||||
|
||||
while ( i <= n ) {
|
||||
fact = fact*i;
|
||||
i = i+1;
|
||||
}
|
||||
|
||||
printf("%d", fact);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Cada vez que se ejecuta la iteración, se multiplica el valor de `fact` por el valor de `i` y se incrementa `i` en 1 hasta cumplir con la condición de salida del bucle.
|
||||
|
||||
Si la variable `i` no se incrementa en 1, el bucle se ejecutaría indefinidamente.
|
||||
|
||||
|
||||
#### 9.2.4. La condición de final del bucle
|
||||
|
||||
Es importante asegurarnos de que el bucle terminará en algún momento. Existen métodos formales para asegurar de que un bucle termina.
|
||||
|
||||
|
||||
### 9.3. Variante de la estructura iterativa
|
||||
|
||||
#### 9.3.1. La construcción `while`
|
||||
|
||||
`while` permite expresar cualquier composición de instrucciones que haya que repetir de acuerdo a unas condiciones determinadas. Es la construcción iterativa más general. Se ejecuta mientras la condición sea verdadera.
|
||||
|
||||
| Partes | Codificación en lenguaje algorítmico |
|
||||
| ------------------------------------------- | ------------------------------------ |
|
||||
| Consulta sobre el estado actual o condición | `while expresión condicional do` |
|
||||
| Qué hacer cuando la condición es Cierta | ` bloque de instrucciones` |
|
||||
| Marca de fin de estructura iterativa | `end while` |
|
||||
|
||||
|
||||
#### 9.3.1. La construcción while
|
||||
#### 9.3.2. La construcción `for`
|
||||
|
||||
`for` se utiliza cuando hay que repetir un bloque de instrucciones un número conocido de veces.
|
||||
|
||||
Ejemplo:
|
||||
|
||||
#### 9.3.2. La construcción for
|
||||
```c
|
||||
algorithm factorial2
|
||||
var
|
||||
n: integer;
|
||||
i: integer;
|
||||
fact: integer;
|
||||
end var
|
||||
|
||||
n := readInteger();
|
||||
fact := 1;
|
||||
|
||||
for i:=1 to n do
|
||||
fact := fact*i;
|
||||
end for
|
||||
|
||||
writeInteger(fact);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int n, i, fact;
|
||||
scanf("%d", &n);
|
||||
fact = 1;
|
||||
|
||||
for (i = 1; i <= n; i++) {
|
||||
fact = fact*i;
|
||||
}
|
||||
|
||||
printf("%d", fact);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
| Partes | Codificación en lenguaje algorítmico |
|
||||
| ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
|
||||
| Inicialización de la variable de control<br>e indicación del número de veces<br>que hay que repetir la iteración | `for índice:= valor inicial to valor final do` |
|
||||
| Qué hacer. | ` bloque de instrucciones` |
|
||||
| Marca de fin de la estructura iterativa | `end for` |
|
||||
|
||||
El C tiene una sintaxis de la composición iterativa for idéntica. Dentro del paréntesis tenemos tres partes separadas por ‘;’ (punto y coma). Cada una de las partes desempeña un papel en la composición.
|
||||
|
||||
```c
|
||||
for (expression1; expression2; expression3) {
|
||||
/* loop body */
|
||||
}
|
||||
```
|
||||
|
||||
- *expression1*: es la parte de inicialización. En este primer segmento asignamos el valor inicial a la variable contador (i = 1).
|
||||
- *expression2*: contiene el test de continuidad. Si la evaluación de la expresión 2 es cierta se pasará a ejecutar el cuerpo del bucle. Si resulta falsa se continuará la ejecución con la instrucción inmediatamente posterior al cuerpo de la composición.
|
||||
- *expression3*: es la parte de actualización del contador. La expression3 se evaluará cuando se acabe de ejecutar el cuerpo del bucle y antes de pasar a evaluar el test. En esta parte se encuentra la instrucción que modifica la variable contador (i++).
|
||||
|
||||
No todas las iteraciones se pueden representar con una estructura `for`.
|
||||
|
||||
En general, se puede utilizar `for` cuando se conoce el número de iteraciones que se van a realizar. Si no se conoce, se debe utilizar `while`.
|
||||
|
||||
|
||||
##### 9.3.2.1. Modificadores de la composición
|
||||
|
||||
La forma que hemos visto de la composición iterativa for (que en cada vuelta se incrementa el contador en una unidad) es la más habitual. Pero no responde a todos los planteamientos con los que nos podemos encontrar.
|
||||
1. Queremos simular una cuenta atrás desde un valor determinado hasta 0.
|
||||
2. Queremos hacer la suma de todos los números pares entre dos números entrados.
|
||||
|
||||
La composición for dispone de variantes que facilitan este trabajo de indicar cómo queremos que varíe el contador en cada iteración. A la sintaxis se añade la indicación de step . Por defecto, si no se indica, ya hemos visto que se asume que step es igual a 1:
|
||||
|
||||
```c
|
||||
for índice:= valor inicial to valor final [step valor de incremento/decremento] do
|
||||
bloque de instrucciones
|
||||
end for
|
||||
```
|
||||
|
||||
#### 9.3.3. Ejemplos
|
||||
|
||||
- **Cuenta atrás**
|
||||
|
||||
```c
|
||||
algorithm countDown
|
||||
var
|
||||
n: integer;
|
||||
k: integer;
|
||||
end var
|
||||
|
||||
n := readInteger();
|
||||
for k:=n to 0 step -1 do
|
||||
writeInteger(k);
|
||||
end for
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int n, k;
|
||||
scanf("%d", &n);
|
||||
for (k = n; k > 0; k--) {
|
||||
printf("%d", k);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
##### 9.3.3.1. Ejemplo 10_08 - Cuenta atrás
|
||||
- **Sumador de pares**: Sumar los números pares comprendidos entre dos números n y m que cumplen que n <= m.
|
||||
|
||||
```c
|
||||
algorithm evenAdd
|
||||
var
|
||||
n: integer;
|
||||
m: integer;
|
||||
k: integer;
|
||||
sum: integer;
|
||||
end var
|
||||
|
||||
n := readInteger();
|
||||
m := readInteger();
|
||||
sum:= 0;
|
||||
|
||||
if (n mod 2 ≠ 0) then
|
||||
n := n+1;
|
||||
end if
|
||||
|
||||
for k:=n to m step 2 do
|
||||
sum := sum+k;
|
||||
end for
|
||||
|
||||
writeInteger(sum);
|
||||
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int n, m, k, sum;
|
||||
scanf("%d %d", &n, &m);
|
||||
sum = 0;
|
||||
|
||||
if (n % 2 > 0) {
|
||||
n++;
|
||||
}
|
||||
|
||||
for (k = n; k <= m; k += 2) {
|
||||
sum = sum+k;
|
||||
}
|
||||
|
||||
printf ("%d", sum);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
- **Temperatura Media**
|
||||
|
||||
##### 9.3.3.2. Ejemplo 10_09 - Sumador de pares
|
||||
Utilizando la estructura de datos tipo vector podemos escribir el algoritmo para calcular la temperatura media de una semana
|
||||
|
||||
```c
|
||||
algorithm meanTemp
|
||||
var
|
||||
dailyTemp: vector[7] of real;
|
||||
mean: real;
|
||||
end var
|
||||
dailyTemp[1]:=readReal();
|
||||
dailyTemp[2]:=readReal();
|
||||
dailyTemp[3]:=readReal();
|
||||
dailyTemp[4]:=readReal();
|
||||
dailyTemp[5]:=readReal();
|
||||
dailyTemp[6]:=readReal();
|
||||
dailyTemp[7]:=readReal();
|
||||
|
||||
mean := (dailyTemp[1] + dailyTemp[2] + dailyTemp[3] + dailyTemp[4] + dailyTemp[5] + dailyTemp[6] +
|
||||
|
||||
dailyTemp[7]) / 7.0;
|
||||
writeReal(mean);
|
||||
|
||||
end algorithm
|
||||
```
|
||||
Pero con `while` puede ser más sencillo:
|
||||
|
||||
```c
|
||||
algorithm meanTemp
|
||||
var
|
||||
dailyTemp: vector[7] of real;
|
||||
sum: real;
|
||||
i: integer;
|
||||
end var
|
||||
|
||||
i := 1;
|
||||
sum := 0.0;
|
||||
while i ≤ 7 do
|
||||
dailyTemp[i] := readReal();
|
||||
sum := sum + dailyTemp[i];
|
||||
i := i+1;
|
||||
end while
|
||||
writeReal(sum/7.0);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
int main(int argc, char** argv) {
|
||||
float dailyTemp[7];
|
||||
float sum;
|
||||
int i;
|
||||
i = 0; // the base index of array is 0 in C language
|
||||
sum = 0.0;
|
||||
|
||||
while (i < 7) { // "<=" is changed by "<" because in C language last element of a N-size array is N-1
|
||||
scanf("%f", &dailyTemp[i]);
|
||||
sum = sum + dailyTemp[i];
|
||||
i = i+1;
|
||||
}
|
||||
|
||||
printf("%f", sum/7);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Para la temperatura de todo el año será prácticamente igual:
|
||||
|
||||
```c
|
||||
algorithm meanTemp
|
||||
var
|
||||
dailyTemp: vector[365] of real;
|
||||
sum: real;
|
||||
i: integer;
|
||||
end var
|
||||
i := 1;
|
||||
sum := 0.0;
|
||||
while i ≤ 365 do
|
||||
dailyTemp[i] := readReal();
|
||||
sum := m + dailyTemp[i];
|
||||
i := i+1;
|
||||
end while
|
||||
writeReal(sum/365.0);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
float dailyTemp[365];
|
||||
float sum;
|
||||
int i;
|
||||
i = 0;
|
||||
sum = 0.0;
|
||||
while (i < 365) {
|
||||
scanf("%f", &dailyTemp[i]);
|
||||
sum = sum + dailyTemp[i];
|
||||
i = i+1;
|
||||
}
|
||||
printf("%f", sum/365.0);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Una mejor opción sería utilizar la estructura `for`, aprovechando que sabemos cuántos elementos del vector es necesario recorrer.
|
||||
|
||||
```c
|
||||
const
|
||||
DAYS: integer = 365;
|
||||
end const
|
||||
algorithm meanTemp
|
||||
var
|
||||
dailyTemp: vector[DAYS] of real;
|
||||
sum: real;
|
||||
i: integer;
|
||||
end var
|
||||
sum:=0.0;
|
||||
for i:=1 to DAYS do
|
||||
dailyTemp[i] := readReal();
|
||||
sum := sum + dailyTemp[i];
|
||||
end for
|
||||
writeReal(sum/integerToReal(DAYS));
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#define DAYS 365
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
float dailyTemp[DAYS];
|
||||
float sum;
|
||||
int i;
|
||||
sum = 0.0;
|
||||
for (i = 0; i < DAYS; i++) {
|
||||
scanf("%f", &dailyTemp[i]);
|
||||
sum = sum + dailyTemp[i];
|
||||
}
|
||||
|
||||
printf("%f", sum/DAYS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
- **Ha helado**: Disponemos de un registro de las temperaturas de todo el año, que tenemos almacenadas en un vector, de la misma manera que hemos hecho en el ejemplo anterior. Ahora queremos descubrir si algún día ha helado. Esto equivale a ir comprobando si alguna de les temperaturas es negativa.
|
||||
|
||||
```c
|
||||
algorithm frozenDays
|
||||
var
|
||||
dailyTemp: vector[365] of real;
|
||||
hasFrozen: boolean;
|
||||
i: integer;
|
||||
end var
|
||||
|
||||
i := 1;
|
||||
hasFrozen := false;
|
||||
while i ≤ 365 and hasFrozen = false do
|
||||
dailyTemp[i] := readReal();
|
||||
if dailyTemp[i] ≤ 0 then
|
||||
hasFrozen := true;
|
||||
end if
|
||||
i := i+1:
|
||||
end while
|
||||
writeBoolean(hasFrozen);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
float dailyTemp[365];
|
||||
bool hasFrozen;
|
||||
int i;
|
||||
i = 0;
|
||||
hasFrozen = false;
|
||||
|
||||
while (i < 365 && !hasFrozen) {
|
||||
scanf("%f", &dailyTemp[i]);
|
||||
|
||||
if (dailyTemp[i] <= 0) {
|
||||
hasFrozen = true;
|
||||
}
|
||||
|
||||
i = i+1;
|
||||
|
||||
}
|
||||
|
||||
printf("%d", hasFrozen); /* Equivalence in C language: 0 == false, 1 == true */
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
- **Cuenta de días**
|
||||
Si quisiéramos saber cuántos días ha helado, entonces tendríamos que revisar todos los elementos del vector y en este caso sería más adecuada una estructura `for`.
|
||||
|
||||
##### 9.3.3.3. Ejemplo 10_10 - Temperatura Media
|
||||
```c
|
||||
algorithm howManyDaysHasFrozen?
|
||||
var
|
||||
dailyTemp: vector[365] of real;
|
||||
numDays: integer;
|
||||
i: integer;
|
||||
end var
|
||||
|
||||
numDays:= 0;
|
||||
|
||||
for i:=1 to 365 do
|
||||
dailyTemp[i]:= readReal();
|
||||
if dailyTemp[i] ≤ 0 then
|
||||
numDays := numDays+1;
|
||||
end if
|
||||
end for
|
||||
writeInteger(numDays);
|
||||
end algorithm
|
||||
|
||||
##### 9.3.3.4. Ejemplo 10_13 - Ha helado
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
float dailyTemp[365];
|
||||
int i, numDays;
|
||||
numDays = 0;
|
||||
|
||||
for (i = 0; i < 365; i++) {
|
||||
scanf("%f", &dailyTemp[i]);
|
||||
if (dailyTemp[i] <= 0) {
|
||||
numDays = numDays+1;
|
||||
}
|
||||
}
|
||||
|
||||
##### 9.3.3.5. Ejemplo 10_14 - Cuenta de días
|
||||
printf("%d", numDays);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user