Computación y Programación

Fundamentos de Informática
Victor.Barrientos.rodriguez@gmail.com
Tlf 942818949

srocar@uni.pe (S -Lu 4-5pm)

gcolladoa@uni.pe (lu 5-6)
lortiza@uni.pe (T lu 6-7)
1
 Objetivos
Introducción a la programación

– Entender y construir algoritmos (lenguaje semi-formal).

– Conocer conceptos importantes de programación: tipos de datos,

expresiones, instrucciones, estructuras de datos y funciones.

– Algoritmos de búsqueda, recorrido, ordenación y cálculos

matemáticos.

2
 Funcionamiento
• Clases de teoría:
– Presentar conceptos y metodología de programación. Explicar su
representación en lenguaje algorítmico.
– Ilustrarlos con ejemplos de algoritmos en lenguaje algorítmico y
con ejercicios.

• Clases de problemas y laboratorio:

– Presentar ejemplos de programas C, Java, Python y Visual Basic
en los que se utilicen los conceptos de programación vistos en
clase de teoría.
– Realizar ejercicios de programación en los diversos
Herramientas de progrmacion de los algoritmos vistos en clase
3
 Programa
1. Introducción
2. Conceptos básicos
1. Tipos de datos básicos, variables, constantes y expresiones
2. Asignación y composición secuencial, condicional e iterativa
3. Acciones y funciones
1. Declaración, definición, llamada y paso de parámetros
2. Ejercicios de acciones y funciones
4. Secuencias
1. Concepto y operaciones asociadas (búsqueda y recorrido)
2. Ejercicios de secuencias
5. Matrices o tablas
1. Vectores, matrices y operaciones asociadas
2. Ejercicios de vectores y matrices
6. Ordenación
1. Algoritmos de ordenación
2. Ejercicios de ordenación

4
 Programa

7. Estructuras o tuplas
1. Definición y operaciones asociadas
2. Tablas de estructuras
3. Ejercicios de estructuras
8. Algoritmos numéricos
9. Diseño descendente

5
1.1.- Algoritmo

Concepto de algoritmo:
Sucesión explícita de reglas para resolver correctamente un problema
genérico bien definido en un número finito de pasos.

Aspectos básicos a tener presentes a la hora de redactar un algoritmo:

• Explícito: Formal y sin ambigüedades.

• Genérico: Problema cuyos datos son generales.
• Bien definido: Problema perfectamente caracterizado.
• Correcto: Que funcione en todos los casos.
• Número finito de pasos: Debe terminar.

6
Estructura de un algoritmo:

algoritmo nombre
constantes (valores fijos)
datos tipos (nuevos dominios de datos)
variables (datos)
cuerpo (instrucciones)
falgoritmo
acciones y funciones auxiliares

7
 • Simple:
Son de un tipo entero, real, booleano, carácter
[dominio + operaciones]
• Compuesto:
tupla, tabla
[constructores + funciones de
acceso]
Datos Tienen un nombre (identificador)

• Constantes: valor fijo

Pueden ser [Literales: constantes predefinidas]

• Variables

Los datos se deben declarar con todos estos atributos (excepto los literales).
Un dato contiene siempre un valor de su tipo.
8
 Comunicarse con el exterior
[lectura y escritura]

Modificar el contenido de los datos

[asignación]

Instrucciones • Secuenciación
Controlar el orden de
• Condicional
ejecución
• Iteración

Agrupar sucesiones de instrucciones en bloques

independientes [acciones y funciones]

9
1.2.- Variables

Definición: una variable es un dato cuyo valor puede cambiar durante la ejecución
de un algoritmo.

Para asignar un valor a una variable se utiliza el operador de asignación “:=”.

Ejemplos: x := 3.0; y := x + 2.1; y := 3*x + 2; ... [x, y son variables]

Tipos básicos de datos son:

real 3.0, -2.1, ...
entero -3, +10, …
carácter ’a’, ’b’, ’F’, ’4’, ’.’, ...
booleano VERDADERO, FALSO

Definición de una variable en un algoritmo:

algoritmo nombre_algoritmo
var n: entero; x, y: real; c: carácter; b: booleano fvar
n:=3; x:=2.3; c:=’w’; b:=VERDADERO; y:=-5.0;
...
falgoritmo 10
Lectura de datos

algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
LeerEntero(n); LeerReal(x);
LeerCarácter(c); LeerBooleano(b);
...
falgoritmo

Notación alternativa:

algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
n:=LeerEntero( ); x:=LeerReal( );
c:=LeerCarácter( ); b:=LeerBooleano( );
...
falgoritmo 11
#include <stdio.h>

int main()
{
int c, n, fact = 1;

printf("Enter a number to calculate its factorial\n");

scanf("%d", &n);

for (c = 1; c <= n; c++)

fact = fact * c;

printf("Factorial of %d = %d\n", n, fact);

return 0;
}

12
package proyecto14_unidad1;

import java.util.Scanner;

public class Proyecto14_unidad1 {

public static void main(String[] args) {

Scanner s=new Scanner(System.in);
String palabra;
String palabrainvertida="";
System.out.println("Ingresa una palabra y se mostrara a la inversa:\n");
palabra=s.nextLine();

for (int i = palabra.length()-1; i>=0; i--){

palabrainvertida += palabra.charAt(i);
}

System.out.println("La palabra invertida es:\n"+ palabrainvertida);

}

}
13
Lectura de datos

algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
LeerEntero(n); LeerReal(x);
LeerCarácter(c); LeerBooleano(b);
...
falgoritmo

Notación alternativa:

algoritmo leer_variables
var n: entero; x: real; c: carácter; b: booleano fvar
n:=LeerEntero( ); x:=LeerReal( );
c:=LeerCarácter( ); b:=LeerBooleano( );
...
falgoritmo 14
Si n es entera, x es real y realizamos la asignación n:=x, la variable n toma
como valor la parte entera de x.

Se pueden transformar los valores de las variables de un tipo a otro.

algoritmo
var x: real; n: entero; c: carácter fvar
...
x := 65.2 [x <- 65.2]
n := DeRealAEntero(x) [n <- 65]
c := DeEnteroACarácter(n) [c <- “carácter correspondien-
te al número 65 en el código
de ASCII, esto es, la
letra mayúscula ‘A’.”]
...
falgoritmo

Análogamente se pueden realizar los siguientes cambios de tipos

carácter  entero  real 15
1.3.- Constantes

Definición: una constante es un dato que representa un valor fijo de un tipo deter-
minado que no se puede modificar.

Ejemplo:

algoritmo
const Pi: real = 3.1415926535897932385 fconst
var x, y: real fvar
...
x := Pi*Pi;
y := 3*Pi;
...
falgoritmo

16
1.4.- Tipos y operaciones
Definición: conjunto de valores (dominio) y operaciones aplicables.
Tipos básicos: booleano, entero, real y carácter.
• Tipo de datos booleano: Valores: {V, F}. Operadores: y, o, no, =, 
• Tipo de datos entero:
Valores: los enteros, {-MaxEnt, ..., -3, -2, -1, 0, 1, 2, 3, ..., MaxEnt }
Operadores (binarios): +: entero + entero  entero
-: entero - entero  entero
*: entero * entero  entero
(división entera) div: entero div entero  entero
(resto) mod: entero mod entero  entero
=: entero = entero  booleano
 entero  entero  booleano
<: entero < entero  booleano
>: entero > entero  booleano
 entero  entero  booleano
 entero  entero  booleano

x y x div y = q y * q + r = x
r q x mod y = r 0  r < |y| 17
 • Tipo de datos real.
Valores: los reales, {-MaxReal, ... , -MinReal, 0, MinReal ,…, MaxReal}
Operadores (binarios): +: real + real  real
-: real - real  real
*: real * real  real
/: real / real  real
=: real = real  booleano
 real  real  booleano
<: real < real  booleano
>: real > real  booleano
 real  real  booleano
 real  real  booleano

• Tipo de datos carácter. Valores: los caracteres,

{’?’, ’^’, ’#’, ’&’, ..., ’A’, ’B’, …, ’Z’, …,
’a’, ’b’, …, ’z’, …, ’0’, ’1’, ’2’, …, ’9’, …, ’+’, ’-’, ... }
Operadores (binarios): =, : carácter = carácter  booleano
...
• Más adelante veremos algunos tipos compuestos: tablas y tuplas.
18
1.5.- Expresiones
Definición:
Una variable es una expresión.
Una constante es una expresión.
Si E es una expresión, (E) es una expresión.
Si E1, E2, ..., En son expresiones y f una función, f(E1, E2, ..., En) es una expresión

Los tipos de las expresiones tienen que ser coherentes.

Las prioridades de los operadores se utilizan para evaluar correctamente las
expresiones: se aplica la regla asociativa de izquierda a derecha y, en caso de duda, se
ponen paréntesis.

Operadores utilizados más frecuentemente ordenados de mayor a menor prioridad:

., [ ] (acceso a tuplas y tablas)
-, no (cambio de signo y negación lógica) [unarios]
*, /, div, mod (operadores multiplicativos)
+, - (operadores aditivos)
<, >,  (operadores relacionales)
19
y, o (y, o lógicos)
• Ejemplos
Sean i=3, j=16, x=3.5, y=2 y b=FALSO, entonces
(x+y)*y = (3.5+2.0)*2.0
= (5.5)*2.0
= 11.0
( j div i )  5 y b = ( 16 div 3 )  5 y FALSO
= ( 5 )  5 y FALSO
= VERDADERO y FALSO
= FALSO
Hay que tener en cuenta los errores que se pueden producir en tiempo
de ejecución:
• Dividir por 0: cuando utilicemos los operadores div, mod, y /.
• Problemas de precisión con los reales

20
• Ejemplos. Sean i, j y k variables o constantes enteras, x, y y z variables o
constantes reales, a, b y c variables o constantes booleanas.
34.0 es una expresión real
x es una expresión real
x+y es una expresión real
(x+y) es una expresión real
(x+y)*x es una expresión real
(x+y)*x < 24 es una expresión booleana
28 es una expresión entera
i es una expresión entera
i mod j es una expresión entera
(i mod j) es una expresión entera
(i mod j) = k es una expresión booleana
(x+y) * x > 34 y (i mod j) = k es una expresión booleana
((x+y) * x > 34 y (i mod j) = k) es una expresión booleana
no((x+y) * x > 34 y (i mod j) = k) es una expresión booleana
RealAEntero(x) es una expresión entera
RealAEntero(LeerReal(x))+Pi es una expresión real 21
MaxEnt+MaxEnt es una expresión entera (error de compilación)
1.6.- Instrucciones

Lectura (ya lo hemos visto) y Escritura

• Lectura: establece el valor de una variable a través de un dispositivo de entrada.
• Escritura: permite comunicar el valor de una expresión a través de un dispositivo
de salida.
algoritmo ejemplo
var n: entero; x: real; c: carácter; fvar
LeerEntero(n); EscribirEntero(n);
LeerReal(x); EscribirReal(x);
LeerCarácter(c); EscribirCarácter(c)
falgoritmo
La notación anterior se puede simplificar utilizando las instrucciones leer(variable),
escribir(variable), así como instrucciones de lectura y escritura múltiple. También
se pueden escribir mensajes de texto, siempre que éstos se escriban entre comillas.
algoritmo ejemplo
var n: entero; x: real; c: carácter; fvar
escribir(“Introduzca un entero, un real y un carácter:”);
leer(n, x, c); escribir(n, x, c) 22
falgoritmo
Asignación

variable := expresión [la variable toma el valor de la expresión]

Ejemplos. n := 1 (entero); x := 9.8 (real);
c := ’e’ (carácter); b := VERDADERO (booleano);
Notas: El tipo de la variable y el de la expresión deben de ser iguales.
El valor que tenía la variable antes de la asignación se pierde.
Las variables cuando se declaran no tienen ningún valor concreto.
Siempre que trabajemos con una variable debemos darle un valor
inicial. Este proceso se denomina “inicialición de las variables”.

Secuenciación

Cuando tengamos más de una instrucción, utilizaremos la instrucción de

secuenciación. Las distintas instrucciones se separan con el signo “ ; “.
instrucción_1; instrucción_2; ... ; instrucción_k; ... ; instrucción_n

En este caso la instrucción_k no se ejecuta hasta que termina la ejecución23

de las k-1 instrucciones anteriores.
Instrucción condicional o alternativa (si … entonces … si no … fsi)

si expresión_booleana entonces
instrucciones_V [instrucciones que se ejecutan si la
expresión booleana es verdadera]
si no
instrucciones_F [instrucciones que se ejecutan si la
expresión booleana es falsa (opcional)]
fsi

Cuando hay varias condiciones se puede utilizar el siguiente esquema:

si
expresión_booleana_1  instrucciones_1
expresión_booleana_2  instrucciones_2
...
expresión_booleana_n  instrucciones_n
fsi

24
Ejemplo. Calcular el máximo de dos números dados.
algoritmo máximo
var x, y: real fvar (* Declaración de variables *)
LeerReal(x); (* Instrucción de lectura *)
LeerReal(y) (* Instrucción de lectura *)
si (x  y) entonces (* Instrucción alternativa *)
EscribirReal(x) (* Instrucción de escritura *)
si no
EscribirReal(y) (* Instrucción de escritura *)
fsi
falgoritmo

Ejemplo. Calcular el máximo de dos números teniendo en cuenta si son iguales.

algoritmo máximo=
var x, y: real fvar
LeerReal(x); LeerReal(y)
si
(x > y)  EscribirReal(x)
(x < y)  EscribirReal(y)
(x = y)  EscribirCadenadeCarateres(“Son iguales.”)
fsi 25
falgoritmo
Ejercicio 3. Determinar las raíces de una ecuación de segundo grado

• Las raíces de la ecuación de segundo grado ax2+bx+c=0 se obtienen mediante la

fórmula x=(-b  (b2-4ac)1/2)  2a

• Esta expresión para x se obtiene

1. sustituyendo x por t-(b/2a) en la ecuación ax2+bx+c=0
2. despejando t
3. calculando el valor de x a partir del valor de t.

26
algoritmo raíces de ecuación de segundo grado
var a, b, c, x, y, aux: real fvar
Escribir (“Introducir los coeficientes de mayor a menor grado, i.e., a, b y c
tales que la ecuación es ax^2+bx+c=0:”);
LeerReal(a); LeerReal(b); LeerReal(c); aux := b2 - 4ac;
si
a = 0 y b = 0 —> Escribir(“No es una ecuación.”);
a = 0 y b  0 —> Escribir(“Ecuacion de primer grado con raiz:”);
x := -c/b; EscribirReal(x);
aux > 0 —> Escribir(“Tiene dos raices reales distintas:”);
x := (- b + aux 1/2 ) / 2a ; y := (- b - aux 1/2 ) / 2a;
EscribirReal(x) ; EscribirReal(y)
aux = 0 —> Escribir(“Tiene dos raices reales iguales:”);
x := - b / 2a ; y := x; EscribirReal(x)
aux < 0 —> Escribir(“Tiene dos raices complejas:”);
aux := (-aux) 1/2 ;
EscribirReal(-b/2a); EscribirCadenadeCaracteres(“+i”); EscribirReal(|aux/2a|) ;
EscribirCadenadeCaracteres(“\n”);
EscribirReal(-b/2a); EscribirCadenadeCaracteres(“-i”); EscribirReal(|aux/2a|)
fsi
falgoritmo 27
Instrucción iterativa (mientras … hacer … fmientras)

mientras expresión_booleana hacer

instrucciones
fmientras

Notas:
• Mientras la expresión_booleana sea cierta, las instrucciones se ejecutan.
• Cuando la expresión_booleana deja de ser cierta entonces la instrucción
iterativa se acaba.
• Si la expresión_booleana es inicialmente falsa la instrucción iterativa no
hace nada.
• Hay que asegurarse de que las instrucciones modifiquen los valores de las
variables que forman parte de la expresión_booleana de manera que la
instrucción iterativa termine en un número finito de pasos.

28
Ejemplo. El algoritmo de Euclides sirve para calcular el máximo común divisor
(m.c.d.) de dos números positivos. Dados dos números enteros positivos:

1. Se calcula el resto r de dividir el número mayor de los dos x por el menor y.

2. Si r es 0, entonces y es el máximo común divisor.
3. Si r no es 0, entonces se asigna a x el antiguo valor de y, se asigna a y el valor
de r, y se repite todo el proceso.
Ejemplo: x=49, y=42, r=7  x=42, y=7, r=0  7 es el m.c.d. de 49 y 42.
algoritmo Euclides
var x, y, r: entero; fvar
LeerEntero(x); LeerEntero(y);
si y>0 y x>0 entonces
r:= x mod y;
mientras (r ≠ 0) hacer
x:=y ; y:=r; r:= x mod y;
fmientras
Escribir(“El maximo común divisor es “); Escribir(y);
fsi
falgoritmo
30
Instrucción iterativa (para … hasta … hacer ... fpara)
para variable := valor_inicial hasta valor_final hacer
instrucciones
fpara

En la definición anterior el valor asignado inicialmente a la variable se incrementa

en una unidad en cada iteración. También se puede incluir un valor con la opción
paso que permite especificar la cantidad en la que se quiere incrementar el valor
de la variable en cada interacción.
para variable := valor_inicial hasta valor_final paso incremento hacer
instrucciones
fpara

Ejemplo. Escribir los números pares del 1 al 100.

algoritmo pares
var n: entero fvar (* Declaración de variables *)
para n:= 2 hasta 100 paso 2 hacer (* Instrucción iterativa *)
EscribirEntero(n); (* Instrucción de escritura *)
fpara 31
falgoritmo
algoritmo Suma lista N
cons N: entero = 10; fcons
var i: entero; número, suma: real fvar
suma := 0.0;
para i:=1 hasta N hacer
Escribir(“Introduzca un número: “);
Leer(número);
suma := suma+número;
fpara
Escribir(“La suma de los números introducidos es “);
Escribir(suma);
falgoritmo
algoritmo Producto lista N
cons N: entero = 5; fcons
var i: entero; número, producto: real fvar
producto := 1.0;
para i:=1 hasta N hacer
Escribir(“Introduzca un número: “);
Leer(número);
producto := producto*número;
fpara
Escribir(“El producto de los números introducidos es “);
Escribir(producto);
falgoritmo
Ejercicio 1. Calcular el factorial de un número introducido por el
usuario.
algoritmo factorial
var n, i, resultado: entero; fvar
Escribir(“Introduzca un número positivo: “);
LeerEntero(n);
resultado := 1;
si (n > 1) entonces
para i := 2 hasta n hacer
resultado := resultado*i;
fpara
fsi

Escribir(“El factorial de “); Escribir(n);

Escribir(“ es “); Escribir(resultado);

falgoritmo
Ejercicio 2. Calcula la suma de los dígitos de un número.
algoritmo Suma dígitos de un número
var número, suma, aux: entero fvar
suma := 0;
Escribir(“Introduzca un número entero positivo: “);
Leer(número);
aux := número;
mientras número ≠ 0 hacer
suma := suma + (número mod 10);
número := número div 10;
fmientras
Escribir(“La suma de los dígitos de “);
Escribir(aux);
Escribir(“ es “);
Escribir(suma);
falgoritmo
Ejercicio 3. Determinar si un número es primo.

Un número n es primo si es mayor que 1 y sólo es divisible por sí mismo y la unidad.

algoritmo primo
var n, i: entero; primo: booleano fvar
Escribir(“Introduzca un número entero positivo: “); LeerEntero(n);

si (n = 1) entonces primo := F
si no
primo :=V; i := 2;
mientras primo y i ≤ n-1 hacer
si (n mod i) = 0 entonces
primo := F;
si no
i:= i+1;
fsi
fmientras
fsi
si primo entonces
Escribir(n); Escribir(“ es primo.”)
si no
Escribir(n); Escribir(“ no es primo.”)
fsi
falgoritmo
Ejercicio 4. Determinar si un número es primo.

Un número n es primo si es mayor que 1 y sólo es divisible por sí mismo y la unidad.

Para determinarlo comprobamos que n no es par y que no es divisible por los impares
comprendidos entre 3 y n(1/2).
algoritmo primo
var n, i: entero; primo: booleano fvar
Escribir(“Introduzca un número entero: “); LeerEntero(n);

si (n = 1) o ((n mod 2) = 0 y n ≠ 2) entonces primo := F

si no
primo :=V; i := 3;
mientras primo y i2 ≤ n hacer
si (n mod i) = 0 entonces
primo := F;
si no
i:= i+2;
fsi
fmientras
fsi
si primo entonces
Escribir(n); Escribir(“ es primo.”)
si no
Escribir(n); Escribir(“ no es primo.”)
fsi
falgoritmo
Ejercicio 5. Escribir los n primeros números de la sucesión de Fibonacci.

La sucesión de Fibonacci viene definida por las siguientes reglas:

• fib[0]=0

• fib[1]=1

• fib[i]=fib[i-1]+fib[i-2], para i>1.

algoritmo Fibonacci
var n, último, penúltimo, aux, i: entero fvar
Escribir(“Introduzca un número: “); LeerEntero(n);

penúltimo:=0; último:=1;
para i:=0 hasta n-1 hacer
EscribirEntero(penúltimo);
aux:=último; último:=último+penúltimo; penúltimo := aux;
fpara
falgoritmo
 Estructura de un programa C

algoritmo nombre inclusiones

constantes constantes
tipos tipos
variables prototipos
instrucciones int main (void) {
falgoritmo variables
acciones y funciones auxiliares instrucciones
}
acciones y funciones auxiliares

archivo nombre.cpp
A lo largo del curso iremos viendo cómo se traduce cada parte del algoritmo.
Hay que respetar el orden de aparición de las distintas partes que aparecen en esta transparencia.
Las inclusiones son referencias a archivos que tienen información auxiliar.
Los prototipos son declaraciones de las acciones y funciones auxiliares (no deben olvidarse).
int, main y void son palabras clave, hay que escribirlas tal y como aparecen en la transparencia.
44
 Constantes

Cada constante se define en una línea diferente de la forma

nombre: tipo = valor --> #define nombre valor

Ejemplo:
const
pi: real = 3.1415926 #define pi 3.1415926
Terminador: carácter = ‘\0' #define Terminador ‘\0'
fconst

45
 Declaración de variables

Las declaraciones de las variables de un algoritmo se traducen indicando en

primer lugar el tipo traducido y en segundo lugar el nombre de la variable.
var nombre: tipo fvar  tipo-traducido nombre;
Los tipos básicos se traducen del modo siguiente:
entero --> int real --> double o float
carácter --> char booleano --> bool [En C++, false, true]
Ejemplo:
var
suma: entero; int suma;
x, y: real double x, y;
letra: carácter char letra;
primo: booleano bool primo;
46
fvar
 Tabla resumen de los operadores del lenguaje C

• Aritméticos: + (suma), - (cambio de signo), - (resta), * (producto), / (división),

% (módulo)
• Lógicos: && (conjunción, “y”), || (disyunción, “o”), ! (negación, “no”)
• Relacionales: == (igualdad), != (desigualdad), <, >, <=, >= (comparaciones)
• Cambio de tipo: (tipo), donde (tipo) puede ser int, double, float o char
(double) n convierte el valor de n a real de doble precisión
• Prioridad de evaluación: operadores ordenados de mayor a menor.
– Operadores unarios: - (cambio de signo), !, (tipo)
– Operadores multiplicativos: *, /, %
– Operadores aditivos: +, - (resta)
– Operadores de comparación: <, <=, >, >=
– Operadores de igualdad: ==, !=
– Conjunción: &&
– Disyunción: ||
• A igual prioridad la regla asociativa se aplica de izquierda a derecha. 47
 Instrucciones de entrada, salida y asignación

La instrucción de entrada habitual se traduce del modo siguiente:

Leer(var)  cin >> var;
puede tener varios argumentos cin >> var_1 >> var_2 >> ... >> var_n;

La instrucción de salida habitual se traduce del modo siguiente:

Escribir(expr)  cout << expr;
puede tener varios argumentos cout << expr_1 << ... << expr_n;
cout << endl; produce un salto de línea

La instrucción de asignación se traduce del modo siguiente:

var := expr  var = expr;

48
 Instrucción condicional IF

si expr entonces
instrucciones_V
si no
instrucciones_F
fsi
En C la expresión se escribe entre paréntesis y las instrucciones de los casos V
(verdadero) y F (falso) entre llaves.
if (expr) {
instrucciones_V
} else {
instrucciones_F
49
}
 Instrucción condicional ELSE IF

si
expresión_booleana_1  instrucciones_1
expresión_booleana_2  instrucciones_2
...
expresión_booleana_n  instrucciones_n
fsi

if (expresión_booleana_1) {
instrucciones_1
} else if (expresión_booleana_2) {
instrucciones_2
....
} else {
instrucciones_n
50
}
 Instrucción Iterativa WHILE

mientras expr hacer

instrucciones
fmientras

En C la expresión se escribe entre paréntesis y las instrucciones entre llaves.

while (expr) {
instrucciones
}

51
 Instrucción iterativa FOR

En notación algorítmica se escribe

para var := valor_inicial hasta valor_final paso incremento hacer

instrucciones
fpara

En C se escribe

for (var = valor_inicial ; var <= valor_final ; var = var + incremento) {

instrucciones
}

52
En general la instrucción iterativa for

for (expr1; expr2 ; expr3) {

instrucciones
}

equivale a

expr1;
while (expr2) {
instrucciones;
expr3;
53
}
 Comentarios
Tanto en los programas como en los algoritmos deben aparecer comentarios ex-
plicativos. En C los comentarios se escriben así (pueden ocupar varias líneas):
/* Esto es un comentario. */

Indentación
Se suelen dejar espacios en blanco al comienzo de la línea para reflejar la es-
tructura lógica de un programa.
También se dejan dos líneas en blanco para separar unidades lógicas diferen-
tes de un programa. Por ejemplo, para separar las inclusiones de las constan-
tes, o las distintas funciones.

Identificadores
Los nombres de las constantes, variables y funciones deben ser autoexpli-
cativos (e.g., Par, SumaTotal o Resultado).
54