Curso-lenguaje-C/fundamentos-programacion/PR1

PR 1

Volver a la página principal de "Fundamentos de la Programación"

Índice

• PR 1
  • 9. Estructura de Control iterativa
    • 9.1. Estructura (o composición) iterativa: aproximación intuitiva
      • 9.1.1. Ejemplos
    • 9.2. Codificación estructura iterativa
      • 9.2.1. Ejemplo Pared
      • 9.2.2. Ejemplo Multiplicación
      • 9.2.3. Ejemplo Factorial
      • 9.2.4. La condición de final del bucle
    • 9.3. Variante de la estructura iterativa
      • 9.3.1. La construcción while
      • 9.3.2. La construcción for
        • 9.3.2.1. Modificadores de la composición
      • 9.3.3. Ejemplos
  • 10. Nomenclátor de notación algorítmica
    • 10.1 Tipos básicos
    • 10.2 Declaración de constantes
    • 10.3 Declaración de tuplas
    • 10.4 Condicional
    • 10.5 Declaración de tipos
    • 10.6 Declaración de variables
    • 10.7 Declaración de vectores
    • 10.8 Iteración
    • 10.9 Clase de parámetros
    • 10.10 Declaración de algoritmo
    • 10.11 Declaración de punteros
    • 10.12 Operadores lógicos
    • 10.13 Operador de asignación
    • 10.14 Operadores de comparación
    • 10.15 Constantes booleanas
    • 10.16 Comentario
    • 10.17 Función
    • 10.18 Acción
    • 10.19 Funciones de cambio de tipo

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

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

• 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.

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.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.

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

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)

Para hacer el cálculo hay que multiplicar todos los números entre 1 y el número del cual queremos calcular el factorial.

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.2. La construcción for

for se utiliza cuando hay que repetir un bloque de instrucciones un número conocido de veces.

Ejemplo:

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 e indicación del número de veces 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.

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:

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

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;
}

• Sumador de pares: Sumar los números pares comprendidos entre dos números n y m que cumplen que n <= m.

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

Utilizando la estructura de datos tipo vector podemos escribir el algoritmo para calcular la temperatura media de una semana

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:

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:

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.

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.

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.

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

#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;
    }
  }

  printf("%d", numDays);

  return 0;
}

10. Nomenclátor de notación algorítmica

Negrita se utiliza para las palabras clave del lenguaje.

Cursiva se tiene que sustituir por el identificador definido por el usuario (nombre de la variable, del tipo, etc.); no significa que los identificadores vayan en cursiva en los algoritmos.

Castellano se utiliza para describir instrucciones.

10.1 Tipos básicos

integer
char
real
boolean
string

10.2 Declaración de constantes

const
  CONST_NAME: type = valor;
end const

10.3 Declaración de tuplas

type
  typeName = record
    fieldName: tipo del campo;
  end record
end type

10.4 Condicional

if expresión condicional then
  bloque de instrucciones
end if
---
if expresión condicional then
  bloque de instrucciones
else
  bloque de instrucciones
end if

10.5 Declaración de tipos

type
  typeName = declaración del tipo
end type

10.6 Declaración de variables

var
  varName: tipo de la variable;
end var

10.7 Declaración de vectores

var
  vectorName: vector[longitud] of tipo del campo;
end var

10.8 Iteración

while expresión condicional do
  bloque de instrucciones
end while
---
for varName := valor inicial to valor final [step valor de incremento/decremento] do
  bloque de instrucciones
end for

10.9 Clase de parámetros

in
out
inout

10.10 Declaración de algoritmo

algorithm
  bloque de instrucciones
end algorithm

10.11 Declaración de punteros

var
  varName: pointer to tipo del campo
end var

10.12 Operadores lógicos

and
or
not

10.13 Operador de asignación

:=

10.14 Operadores de comparación

=
≠
<
>
≤
≥

10.15 Constantes booleanas

true
false

10.16 Comentario

{ comentario }

10.17 Función

function functionName (parName1: tipo del parámetro, ... , parNameN: tipo del parámetro): tipo del retorno
  bloque de instrucciones
end function

10.18 Acción

action actionName (clase del parámetro parName1: tipo del parámetro, ... , clase del parámetro parNameN: tipo del parámetro)
  bloque de instrucciones
end action

10.19 Funciones de cambio de tipo

function integerToReal(varName: integer): real;
function realToInteger(varName: real): integer;
function charToCode(varName: char): integer;
function codeToChar(varName: integer): char;
Funciones y acciones de entrada/salida
function readInteger(): integer;
function readReal(): real;
function readChar(): char;
function readString(): string;
function readBoolean(): boolean;
action writeInteger(in varName: integer);
action writeReal(in varName: real);
action writeChar(in varName: char);
action writeString(in varName: string);
action writeBoolean(in varName: boolean);

Volver arriba

Volver a la PEC3 | Seguir a la PEC 4