Cap5

5
157
OBJETIVO DIDCTICO
Aplicar las bases y criterios del diseo estructurado de algoritmos a la resolucin de proble-
mas simples.
Al finalizar la unidad el alumno deber ser capaz de:
Definir y resolver un problema de complejidad simple diseando el algoritmo corres-
pondiente con la aplicacin de los criterios de programacin estructurada desarrollados
en el captulo anterior.
Comprender y utilizar las primitivas bsicas de entrada/salida, as como reconocer y
adaptar la informacin a tratar con los tipos de datos estndar ms apropiados.
Comprender el concepto de especificacin de un algoritmo y distinguirlo de la imple-
mentacin.
Aplicar la equivalencia de pseudocdigo a lenguaje de programacin sobre los dise-
os realizados, sabiendo adaptarlos, para generar programas en diferentes lenguajes
de programacin.
Los objetivos didcticos anteriores, pueden concretarse en el eje de actividad siguiente:
EAP-5. Eje de actividad parcial Captulo 5
1. Escriba un algoritmo que dado un nmero entero de bytes, entrado por teclado,
informe de su correspondiente valor expresado en Kilobytes y Megabytes.
2. Escriba un algoritmo que dada una serie de valores enteros en una secuencia,
acabada en 0, informe de si contiene alguna subserie de 5 valores ordenados de
forma creciente.
3. Escriba el algoritmo que calcule la serie siguiente, con un ngulo (en grados) y un
error mximo, entrados por teclado. Deber realizar la conversin a radianes para
calcular la serie:
+
=
= = + +
+
2 1 3 5 7 9
1
sin( ) ( 1) ...
(2 1)! 3! 5! 7! 9!
i n
i
x x x x x
x x
i
4. Programe en C++ o Pascal/Delphi los diseos anteriores y verifique su correcto
funcionamiento.
Diseo y (DPA)
programacin de
algoritmos simples
158 Fundamentos de informtica
Para dar soporte a estos objetivos y eje de actividad, seguiremos el siguiente orden de desa-
rrollo de conceptos, ejercicios y otras actividades:
Diseo y programacin de algoritmos simples
5.1. Conceptos previos.
5.2. Algoritmos de resolucin de problemas con composicin secuencial.
5.3. Algoritmos de resolucin de problemas con composicin de seleccin.
5.4. Algoritmos de resolucin de problemas con composicin iterativa.
5.5. Otras actividades propuestas.
En este captulo se pretende mostrar, a modo de ejemplo, cmo describir la resolucin de
problemas simples diseando sus algoritmos en pseudocdigo, tomando como punto de partida
los conceptos, definiciones, descripciones y criterios sobre diseo estructurado de algoritmos
desarrollados en el Captulo 4.
5.1. CONCEPTOS PREVIOS
La composicin secuencial permite describir el orden de ejecucin de las acciones necesarias para
resolver un determinado problema. Para tal fin, adems de la estructura (secuencia/fsecuencia) en
s, nos sern imprescindibles otros elementos como constantes y variables, expresiones y opera-
dores, as como tambin primitivas de entrada/salida de datos (informacin).
Como datos, entendemos los diferentes tipos de informacin que sustentaran los objetos pasi-
vos (constantes y variables) a los cuales haremos referencia en el algoritmo y que nos permitirn
resolver el problema. Empezaremos por definir los tipos simples estndar, para en captulos
posteriores entrar en estructuras de datos ms complejas.
5.1.1. Tipos de datos simples estndar
El tipo de un dato define el conjunto de valores que forman un dominio y que podr tomar una
variable. Al referirnos a datos simples estndar, pensamos en informacin cuyo formato y rango
de valores posible, permite incluirlos en tipos que ya estn predefinidos por razones de eficiencia
en los lenguajes de programacin, por lo que slo es necesario declararlos asocindolos a un
identificador, a travs del cual accederemos a la informacin que contiene.
Entero: Definimos entero como un valor numrico (positivo o negativo) sin parte fracciona-
ria. El dominio o rango de valores que puede abarcar depender del lenguaje de programacin
que utilicemos, aunque como idea, la mayora de lenguajes de programacin utilizan 32 bits co-
dificados en complemento a 2 para definir de forma estndar un entero (vase el Captulo 2).
Real o punto flotante (float): Se trata de valores numricos (positivos y negativos) con parte
fraccionaria. En este caso, no slo es crtico el rango, sino tambin la precisin (nmero de dgitos
representables) que depender del lenguaje de programacin aunque comnmente disponen de
los estndar IEEE 754 de simple y doble precisin (vase el Captulo 2).
Carcter: Es un valor alfanumrico, codificado en los lenguajes de programacin como c-
digo ASCII de 8 bits.
Lgico o booleano: Slo aceptan valores lgicos (Verdadero o Falso).
Cadena: Aunque no se corresponde con un tipo simple de dato, se incluye aqu por su facili-
dad de definicin y utilizacin como tal. Su funcin es la de contener una serie de caracteres (una
palabra, frase).
Diseo y programacin de algoritmos simples 159
AP 5.1 (c): Qu tipo de datos considera el ms apropiado para representar los si-
guientes conceptos?
a. El sueldo de un trabajador.
b. Su edad.
c. Su estado civil.
d. Su direccin.
5.1.2. Tipos de datos simples no estndar
Cuando hablamos de tipos no estndar, nos referimos a tipos de datos que los lenguajes de pro-
gramacin no tienen predefinidos, pero que permiten que el diseador/programador, mediante
mecanismos de definicin, pueda describirlos para ser utilizados posteriormente en el algoritmo.
Aunque la justificacin de los tipos definidos por el usuario se describen en el Captulo 7, se
ha optado por explicar los tipos enumerados en este captulo por tratarse bsicamente de tipos
simples de datos y porque as nos facilitar el desarrollo de algunos temas y ejemplos de los
prximos captulos.
En definitiva, los enumerados son tipos definidos por el programador y consisten en una
lista ordenada y finita de valores concretados en la definicin del tipo.
tColor = (rojo, verde, azul, blanco, negro)
tDias_semana = (lunes, martes, miercoles, jueves viernes, sabado, domingo)
Los valores descritos son internos al programa y bsicamente se usan como una ayuda para
facilitar el diseo del algoritmo al programador, pudiendo identificar y tratar la informacin de
manera ms cmoda.
En cuanto a su utilizacin deben observarse ciertas restricciones:
Una variable de tipo enumerado slo puede tomar los valores expresados en el tipo.
Al tratarse de una secuencia ordenada de valores pueden usarse en expresiones lgicas o
en variables de control de bucles o como ndices de tablas.
No le son aplicables las primitivas de entrada y salida directamente, por lo que se tienen
que utilizar estrategias de conversin que se vern ms adelante.
5.1.3. Identificadores, constantes y variables
Referimos como identificador al nombre que asignamos a un determinado objeto de un progra-
ma, como constantes, variables, tipos de datos, procedimientos, funciones, , en definitiva
cualquier cosa que se necesite nombrar.
Est formado por una secuencia de caracteres que puede ser, en principio, de cualquier
longitud, aunque comnmente existen ciertas reglas que hay que seguir:
Debe comenzar con una letra o _, seguido por otras letras, dgitos o caracteres subra-
yados (_).
No puede contener espacios en blanco, ya que suele tener una funcin de separador.
Cada lenguaje tiene sus caractersticas y limitaciones para la construccin y formato de un
identificador. Lo habitual es generar nombres que indiquen el significado o la descripcin del
dato que va a contener ese identificador.
Como constantes nos referimos a datos que no pueden variar en el transcurso de la ejecucin
del algoritmo o programa. A un determinado identificador se le asignar un valor (del tipo que
sea) y ste no podr ser modificado.
pi = 3,14159265
vel_luz = 3,00 10
8
vel_sonido = 331,4
Las variables, al contrario que las constantes, son objetos cuyo valor puede ser modificado en
cualquier momento a travs de su identificador, bien por una asignacin directa, bien como resul-
tado de alguna expresin.
Las variables deben ser declaradas y especificado su tipo, concretando el dominio de valores
en el caso de los enteros, o el rango y precisin para los valores en punto flotante, o el nmero de
caracteres en el caso de una cadena. Con el fin de que el programador asigne, en funcin del
lenguaje con el que se implementar el algoritmo, el tipo ms idneo y eficiente desde el punto de
vista del lenguaje de programacin para esa variable, evitando as comportamientos inadecuados
del algoritmo y del programa.
Ser imprescindible, pues, para cada diseo de algoritmo, requerir la especificacin del tipo
de variables utilizado, as como el rango (valores mximos) que se prevea que puedan alcanzar en
funcin de la aplicacin.
Especificacin variables:
radio, rea: punto flotante de como mximo 8 dgitos de precisin y rango 10
3

dia_mes: entero [1,31]
Algunos autores toman descriptores de tipos directamente de los lenguajes de programacin.
Nosotros hemos preferido realizar una especificacin en funcin de las necesidades del problema,
dando libertad para que ms tarde, el programador lo asocie a un tipo concreto del lenguaje que
pueda adaptarse a nuestra especificacin.
5.1.4. Expresiones y operadores
Las expresiones son slo una combinacin de operandos y operadores que son evaluadas con la
finalidad de obtener un resultado. Dicha evaluacin sigue unas normas de precedencia (prioridad)
de operadores a no ser que se especifique por la va del parntesis el orden de evaluacin de las
operaciones que contiene. Esta posibilidad se recomienda para conseguir quedar al margen del
estudio de la precedencia establecida en cada lenguaje. As pues, el valor final tomado por la ex-
presin se determina por los valores de las variables y constantes implicadas y la ejecucin de las
operaciones indicadas.
En cuanto a los operadores bsicos, podramos clasificarlos como:
aritmticos: +, , *, /, div. mod, ^
lgicos: no, y, o
relacionales: <, <=, >,>=, =, <>
Parecen todos de comprensin bastante obvia, excepto quizs el div que representa una
divisin de enteros con resultado entero y el mod que realiza el clculo del residuo de la divi-
sin entera.
2 5 div 2 1 5 mod 2 2,5 5/2
Evidentemente, los operandos numricos deben ser utilizados con operadores aritmticos
para conseguir un resultado numrico y con operadores de relacin para obtener un resultado
lgico o booleano (true, false).
Los operadores lgicos (no, y, o) se utilizan con operandos tambin lgicos para obtener un
resultado lgico.
Siendo a, b variables enteras y c booleana, se podran generar expresiones vlidas como:
a = a*((b/2)+5)
c = (a >= 100) y (a < 200)
c = no(c)
AP 5.2 (c): Suponiendo que los valores A, B y C corresponden a las alturas de tres
edificios, desarrolle las expresiones lgicas que permitan saber (sean ciertas):
El edificio A es el ms alto. A_mas_alto=
El edificio B no es el ms alto. B_no_mas_alto=
Alguno de los edificios supera los 200 metros. alguno_mayor_200=
5.1.5. Operaciones de Entrada/Salida de informacin
Para resolver cualquier problema, lo ms habitual es que partiendo de una informacin (datos) de
entrada, una serie de operaciones y toma de decisiones, obtengamos un resultado de salida. As,
cualquier algoritmo, que no deja de ser una secuencia de acciones que nos permiten describir la
resolucin del problema, tambin necesitar comunicarse con el exterior.
A esa comunicacin, en pseudocdigo, la definimos con dos primitivas, una para solicitar
datos y otra para mostrarlos, lo que llamamos entrada y salida de datos desde el punto de vista
del algoritmo.
leer (dato)
mostrar (texto, dato)
Ser en el momento de programar, cuando nos fijaremos en la equivalencia correspondiente a
estas primitivas, que variar en funcin del lenguaje de programacin que utilicemos.
5.2. ALGORITMOS DE RESOLUCIN DE PROBLEMAS
CON COMPOSICIN SECUENCIAL
En este apartado, no slo aportaremos cmo resolver problemas de carcter secuencial elaboran-
do algoritmos en pseudocdigo, sino que incluiremos la correspondencia, a modo de ejemplo, de
ese mismo algoritmo a dos de los lenguajes de programacin mayormente utilizados, como son
Pascal (Delphi) y C++.
En los anexos podr encontrar las equivalencias entre pseudocdigo y cada uno de estos lengua-
jes, de manera que una vez realizado el algoritmo, pueda de forma directa y simple, relacionar el
algoritmo con el lenguaje de programacin, con la finalidad de escribir el programa y probarlo.
El objetivo perseguido es, pues, doble: practicar la realizacin de algoritmos y hacer ver al
alumno que un algoritmo puede programarse posteriormente en distintos lenguajes de programa-
cin solamente teniendo en cuenta las equivalencias, reglas y sintaxis del lenguaje.
Veamos algunos ejemplos, empezando por lo ms simple:
ALG_5.1: Desarrollemos el algoritmo y programas para sumar dos nmeros entrados como
datos.
Figura 5.1.
Utilizando las reglas de equivalencia de los anexos, podramos realizar el programa en Delphi
y C++.
//-----------------------------------------------------------------
// Fundamentos de Informtica
// PALG _ 5.1p Algoritmo para sumar dos nmeros
// Delphi
//-----------------------------------------------------------------
program suma2;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
numero1,numero2,suma:real; // real = double
begin
writeln ('Programa para sumar dos nmeros');
write ('Entra primer numero: ');
readln (numero1);
write ('Entra segundo numero: ');
readln (numero2);
suma:= numero1 + numero2;
writeln ('La suma vale: ', suma:9:3);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.1c Algoritmo para sumar dos nmeros
// C++
//-----------------------------------------------------------------
#include <iostream.h>
int main()
{
float numero1,numero2,suma;
cout << "Programa para sumar dos nmeros" << endl;
cout << "Entra primer numero: ";
cin >> numero1;
cout << "Entra segundo numero: ";
cin >> numero2;
suma = numero1 + numero2;
cin.ignore(1,'\n');
cout << "La suma vale: << suma << endl;
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.2: Desarrollemos el algoritmo y programas para realizar el clculo del ndice de Masa
Corporal, tomando el peso y la altura como datos de entrada. IMC = peso(kg)/h
2
(m). Se consi-
dera saludable un ndice entre 18 y 25.
secuencia
leer (peso )
leer (altura )
IMC = peso / (altura * altura)
mostrar (IMC)
fsecuencia
Especificacin de variables:
peso, altura e IMC: punto flotante no superior a 3 dgitos de precisin y rango 10
3
//-----------------------------------------------------------------
// PALG _ 5.2p Algoritmo calculo masa corporal IMC=peso(kg)/h^2(m)
// Delphi
//-----------------------------------------------------------------
program seq _ imc;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
peso,altura,IMC:real;
begin
write ('Dime el peso (en Kg): ') ;
readln(peso);
write ('Dime la altura (en mt): ') ;
readln (altura);
IMC:= peso/(altura*altura);
writeln ('El indice de masa corporal es: ', IMC:8:3);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.2c Algoritmo calculo masa corporal IMC=peso(kg)/h^2(m)
// C++
//-----------------------------------------------------------------
int main()
{
float peso,altura,IMC;
cout << "Dime el peso (en Kg): " ;
cin >> peso;
cout << "Dime la altura (en mt): " ;
cin >> altura;
IMC=peso/(altura*altura);
cin.ignore(1,'\n');
cout << "El indice de masa corporal es: " << IMC << endl;
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.3: Algoritmo y programas para calcular el rea de una corona circular siendo el radio,
tanto exterior como interior, datos de entrada.
Figura 5.2.
Desarrollando la implementacin de este algoritmo en los lenguajes de programacin men-
cionados:
//-----------------------------------------------------------------
// PALG _ 5.3p Algoritmo para calcular el rea de una corona
// Delphi
//-----------------------------------------------------------------
program seq _ corona;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
radio _ exterior,radio _ interior, area _ corona:real;
area _ circulo _ exterior, area _ circulo _ interior:real;
begin
write ('Entra el radio del circulo exterior: ') ;
readln(radio _ exterior);
write ('Entra el radio del circulo interior: ') ;
readln (radio _ interior);
area _ circulo _ exterior:= pi*radio _ exterior*radio _ exterior;
area _ circulo _ interior:= pi*radio _ interior*radio _ interior;
area_corona:=area_circulo_exterior-area_circulo_interior;
writeln ('Area de la corona: ', area _ corona:8:3);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.3c Algoritmo para determinar el rea de una corona
// C++
//-----------------------------------------------------------------
#include <iomanip.h>
#define pi 3.14159
int main()
{
float radio _ exterior,radio _ interior, area _ corona;
float area _ circulo _ exterior, area _ circulo _ interior;
cout << "Entra el radio del circulo exterior: " ;
cin >> radio _ exterior;
cout << "Entra el radio del circulo interior: " ;
cin >> radio _ interior;
area _ circulo _ exterior= pi*radio _ exterior*radio _ exterior;
area _ circulo _ interior= pi*radio _ interior*radio _ interior;
area_corona=area_circulo_exterior-area_circulo_interior;
cout << "Area de la corona: " << setw(8) << area _ corona;
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.4: Desarrollemos un algoritmo y programas para conocer si un nmero entero y posi-
tivo, es mltiplo de M pero no de N, tomando los valores de M y N como datos de entrada.
De este ejemplo se desea destacar la posibilidad de utilizar expresiones lgicas.
secuencia
leer (numero)
leer (M)
leer (N)
mult_M = ((numero MOD M) = 0)
mult_N = ((numero MOD N) = 0)
cuestion = mult_M y (no(mult_N))
mostrar (cuestion)
fsecuencia
nmero, M, N: enteros [12
31
]
mult_M, mult_N, cuestin: lgica (booleana)
//-----------------------------------------------------------------
// PALG _ 5.4p Algoritmo para determinar si un nmero es
// mltiplo de M pero no de N
// Delphi
//-----------------------------------------------------------------
program seq _ multM _ N;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
numero,M,N: integer;
mult _ M, mult _ N,cuestion: boolean;
begin
write ('Entrar el numero, M y N: ');
readln (numero,M,N);
mult _ M:= ((numero MOD M)= 0);
mult _ N:= ((numero MOD N)= 0);
cuestion:= (mult _ M AND (NOT(mult _ N)));
writeln (cuestion, ' (TRUE=Cumple FALSE=No cumple)');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.4c Algoritmo para determinar si un nmero es
// mltiplo de M pero no de N
// C++
//-----------------------------------------------------------------
int main()
{
int numero,M,N;
bool mult _ M, mult _ N,cuestion;
cout << "Entrar el valor, M y N: " ;
cin >> numero >> M >> N;
mult _ M = ((numero % M)== 0);
mult _ N = ((numero % N)== 0);
cuestion = (mult _ M && (!(mult _ N)));
cout << cuestion << " (0=Cumple cond. 1=No cumple cond.)";
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.5: Algoritmo para pasar de coordenadas cartesianas a polares y a la inversa (en grados
y radianes).
secuencia
leer (x)
leer (y)
r = raiz cuadrada [(x*x) + (y*y)]
alfar = arco_tangente_con_cuadrantes (y/x)
alfag = 180*alfar/pi;
mostrar (r,alfar, alfag)
x = r * cos (alfar)
y = r * sin (alfar)
mostrar (x,y)
fsecuencia
x, y, alfar, alfag: son punto flotante de como mximo 7 dgitos y rango 10
10
//-----------------------------------------------------------------
// PALG _ 5.5p Algoritmo para pasar coordenadas rectangulares a
// polares y a la inversa (en grados y radianes)
// Delphi
//-----------------------------------------------------------------
program seq _ cart _ polar;
{$APPTYPE CONSOLE}
uses
SysUtils, Math;
var
x,y,r,alfar,alfag:real;
begin
write ('Coordenada X: ') ;
readln(x);
write ('Coordenada Y: ') ;
readln (y);
r:= sqrt((x*x) + (y*y));
alfar:= arctan2(y,x);
alfag:=180*alfar/pi;
write ('Modulo = ', r:0:4);
writeln (' Argumento = ', alfar:0:4,' rad.');
write ('Modulo = ', r:0:4);
writeln (' Argumento = ', alfag:0:2,' grados');
//-----------------------------------------------------------------
x:= r * cos(alfar);
y:= r * sin(alfar);
writeln ('Coordenada X= ', x:0:2,' Coordenada Y= ', y:0:2);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.5c Algoritmo para pasar coordenadas rectangulares a
// polares y a la inversa (en grados y radianes)
// C++
//-----------------------------------------------------------------
#include <cmath.h>
#define pi 3.14159
int main()
{
float x, y, r, alfar, alfag;
cout << "Coordenada X: ";
cin >> x;
cout << "Coordenada Y: ";
cin >> y;
r = sqrt((x*x) + (y*y));
alfar = atan2(y,x);
alfag=180*alfar/pi;
cout << "Modulo = " << r;
cout << " Argumento = " << alfar << " rad." << endl;
cout << "Modulo = << r;
cout << " Argumento = " << alfag << " grados" << endl;
//-------------------------------------------------------
x = r * cos(alfar);
y = r * sin(alfar);
cout << "Coordenada X = " << x;
cout << " Coordenada Y = " << y << endl;
cin.get(); cin.get();
return 0;
}
//------------------------------------------------------------
AP 5.3 (c): Escriba un algoritmo, en pseudocdigo, que dado el radio de un crculo
calcule y muestre su rea y permetro. (Puede basarse en el ejemplo ALG_5.3 de
este captulo).
AP 5.4 (c): Escriba un algoritmo que dado un nmero total de segundos entrado por
teclado, diga a cuntas horas, minutos y segundos corresponden.
AP 5.5 (m): Utilizando los anexos de este libro sobre la equivalencia de pseudocdigo
a lenguaje de programacin, haga los programas correspondientes en Delphi o C++.
CON COMPOSICIN DE SELECCIN
Ahora nos proponemos ilustrar, por medio de los ejemplos, la aplicacin de composiciones de
seleccin simple y doble para la toma de decisiones en la resolucin de un problema, tanto en el
algoritmo en pseudocdigo como en lenguajes de programacin.
5.3.1. Composicin simple y doble
Como ejemplo del uso y comportamiento de una composicin simple
ALG_5.6: Desarrollemos un algoritmo para determinar si un valor, entrado como dato, es
negativo.
secuencia
leer (valor)
si valor < 0 entonces
mostrar (es negativo)
fsi
fsecuencia
valor: entero mxima representacin
//-----------------------------------------------------------------
// PALG _ 5.6p Algoritmo para determinar si un dato es negativo
// Delphi
//-----------------------------------------------------------------
program alt _ pos _ neg;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
valor: integer;
begin
write ('Entra el valor: ');
readln (valor);
if (valor < 0) then
writeln ('Es negativo');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.6c Algoritmo para determinar si un dato es negativo
// C++
//-----------------------------------------------------------------
int main()
{
int valor;
cout << "Entrar el valor: " ;
cin >> valor;
if (valor<0)
cout << "Es negativo";
cin.get();
return 0;
}
//-----------------------------------------------------------------
Como ejemplo del uso y comportamiento de una composicin doble
ALG_5.7: Desarrollemos un algoritmo para determinar si un valor es negativo o positivo.
secuencia
leer (valor)
si_no
mostrar (es positivo)
fsi
fsecuencia
valor: punto flotante mxima representacin
//-----------------------------------------------------------------
// PALG _ 5.7p Algoritmo informe si un dato es positivo o negativo
// Delphi
//-----------------------------------------------------------------
{$APPTYPE CONSOLE}
uses
SysUtils;
var
valor: real;
begin
readln (valor);
if (valor<0) then
writeln ('Es negativo')
else
writeln ('Es positivo');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.7c Algoritmo informe si un dato es positivo o negativo
// C++
//-----------------------------------------------------------------
int main()
{
float valor;
cin >> valor;
if (valor<0)
else
cout << "Es positivo";
cin.get();
return 0;
}
//-----------------------------------------------------------------
Como ejemplo simple de una composicin de seleccin anidada
ALG_5.8: Desarrollemos un algoritmo que determine si un valor es cero, negativo o positivo.
secuencia
leer (valor)
si valor = 0 entonces
mostrar (es un cero)
si_no
si_no
mostrar (es positivo)
fsi
fsi
fsecuencia
valor: punto flotante mxima representacin
//-----------------------------------------------------------------
// PALG _ 5.8p Determinar si un dato es positivo,0,negativo
// Delphi
//-----------------------------------------------------------------
{$APPTYPE CONSOLE}
uses
SysUtils;
var
valor: real;
begin
readln (valor);
if (valor=0) then
writeln ('Es un cero')
else
if (valor<0) then
writeln ('Es negativo')
else
writeln ('Es positivo');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.8c Determinar si un dato es positivo,0,negativo
// C++
//-----------------------------------------------------------------
int main()
{
float valor;
cin >> valor;
if (valor==0)
cout << "Es un cero";
else
if (valor<0)
else
cout << "Es positivo";
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.9: Algoritmo que determina si dados dos valores, alguno de ellos es divisor del otro.
secuencia
leer (valor1, valor2)
si valor1 = valor2 entonces
mostrar (son iguales)
si_no
si (valor1 > valor2) entonces
mayor = valor1
menor = valor2
si_no
mayor = valor2
menor = valor1
fsi
fsi
si ((mayor MOD menor) = 0) entonces
mostrar (mayor,es divisor de, menor)
si_no
mostrar (ninguno es divisor del otro)
fsi
fsecuencia
valor1, valor2, mayor, menor: entero mxima representacin
//-----------------------------------------------------------------
// PALG _ 5.9p Algoritmo que dados dos valores, exprese si
// alguno es divisor del otro
// Delphi
//-----------------------------------------------------------------
program alt _ divisor;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
valor1, valor2, mayor, menor: integer;
begin
write ('Entrar los dos numeros: ');
readln (valor1, valor2);
if (valor1=valor2) then writeln ('Son iguales')
else
begin
if (valor1>valor2) then
begin
mayor:=valor1;
menor:=valor2;
end
else
begin
mayor:=valor2;
menor:=valor1;
end;
if ((mayor mod menor)=0) then
writeln (menor,' es divisor de ', mayor)
else
writeln (menor,' es divisor de ', mayor);
end;
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.9c Algoritmo que dados dos valores, exprese si
// alguno es divisor del otro
// C++
//-----------------------------------------------------------------
int main()
{
int valor1, valor2, mayor, menor;
cout << "Entrar los dos numeros: " ;
cin >> valor1 >> valor2;
if (valor1==valor2)
cout << "Son iguales";
else
{
if (valor1>valor2) {
mayor=valor1;
menor=valor2;
}
else {
mayor=valor2;
menor=valor1;
}
if ((mayor%menor)==0)
cout << menor << " es divisor de " << mayor;
else cout << "Ninguno es divisor del otro";
}
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.10: Algoritmo que dados tres valores, nos indique cul de ellos es el mayor.
Este desarrollo lo utilizaremos, adems, como ejemplo de estrategia de diseo por refina-
mientos.
Figura 5.3.
Podemos ahora disear por separado cada una de las acciones, observando que:
La accin @ACCIN num2_no_es ver_num1_num3@ slo se ejecuta cuando num2 no
es el mayor por lo que slo debe verificar si es num1 o num3.
La accin @ACCIN num1_no_es ver_num2_num3@ slo se ejecuta cuando num1 no
es el mayor por lo que slo debe verificar si es num2 o num3.
De forma que:
Figura 5.4.
Finalmente, teniendo diseadas cada una de las acciones, podemos sustituirlas en el primer
algoritmo (recordemos la visin por refinamientos descrita grficamente en el Captulo 4), que
una vez recompuesto quedara:
Figura 5.5.
Implementamos ahora el algoritmo resultante, en Pascal/Delphi y tambin en C++
//-----------------------------------------------------------------
// PALG _ 5.10p Algoritmo para determinar el mayor de tres nmeros
// Delphi
//-----------------------------------------------------------------
program alt _ mayor3;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
num1, num2, num3: real;
begin
write ('Entra los tres numeros: ');
readln (num1, num2, num3);
if ((num1=num2) and (num1=num3)) then
writeln ('Son iguales')
else
if (num1>num2) then
if (num1>num3) then writeln (num1:0:2, ' es el mayor')
else writeln (num3:0:2, ' es el mayor ')
else
if (num2>num3) then writeln (num2:0:2, ' es el mayor ')
else writeln (num3:0:2, ' es el mayor ');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.10c Algoritmo para determinar el mayor de tres nmeros
// C++
//-----------------------------------------------------------------
int main()
{
float num1, num2, num3;
cout << "Entrar los tres numeros: " ;
cin >> num1 >> num2 >> num3;
if (num1==num2==num3)
cout << "Son iguales";
else
if (num1>num2)
if (num1>num3) cout << num1 << " es el mayor";
else cout << num3 << " es el mayor";
else
if (num2>num3) cout << num2 << " es el mayor";
else cout << num3 << " es el mayor";
cin.get();
return 0;
}
//-----------------------------------------------------------------
5.3.2. Composicin mltiple y por valor 1 entre N
ALG_5.11: Disear en pseudocdigo y realizar el programa para validar una fecha (da, mes
y ao), teniendo en cuenta los aos bisiestos para febrero.
secuencia
fecha=falso
leer (dia, mes, anyo)
si ((mes>=1) y (mes <=12)) entonces
segun_sea_valor mes hacer
1,3,5,7,8,10,12: maxdias=31
4,6,9,11: maxdias=30
2: si (((anyo mod 4)=0) y ((anyo mod 100)<>0 or (anyo mod 400)=0))
entonces
maxdias=29
si_no
maxdias=28
fsi
fsegun_sea_valor
si ((dia>=1) y (dia<=maxdias)) entonces
fecha=cierto
fsi
fsi
si fecha entonces
mostrar (fecha correcta)
si_no
mostrar (fecha incorrecta),
fsi
fsecuencia
dia: entero [131], mes: entero [112], anyo: entero [19902050], fecha: booleana
Ntese, en la ltima composicin, que el predicado puede ser solamente una variable booleana,
sin necesidad de compararla, puesto que es cierta o falsa en s misma.
//-----------------------------------------------------------------
// PALG _ 5.11p Algoritmo para validar una fecha (da, mes y ao)
// Delphi
//-----------------------------------------------------------------
program altmult _ fecha;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
dia,mes,anyo,maxdias: integer;
fecha:boolean;
begin
fecha:=false;
write ('Entra el dia, mes y ao: ');
readln (dia,mes,anyo);
if ((mes>=1) and (mes <=12)) then
begin
case mes of
1,3,5,7,8,10,12: maxdias:=31;
4,6,9,11: maxdias:=30;
2: if (((anyo mod 4)=0) and ((anyo mod 100)<>0 or
(anyo mod 400)=0))
then
maxdias:=29
else
maxdias:=28;
end;
if ((dia>=1) and (dia<=maxdias)) then
fecha:=true;
end;
if fecha then
writeln ('Fecha correcta')
else
writeln ('Fecha incorrecta');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.11c Algoritmo para validar una fecha (da, mes y ao)
// C++
//-----------------------------------------------------------------
int main()
{
int dia,mes,anyo,maxdias;
bool fecha;
fecha=false;
cout << "Entra el dia, mes y ao: " ;
cin >> dia >> mes >> anyo;
if ((mes>=1) && (mes <=12)) {
switch (mes) {
case 1,3,5,7,8,10,12: maxdias=31; break;
case 4,6,9,11: maxdias=30; break;
case 2: if (((anyo % 4)==0) && ((anyo % 100) !=0 ||
(anyo % 400)==0))
maxdias=29;
else
maxdias=28;
break;
}
if ((dia>=1) && (dia<=maxdias))
fecha=true;
}
if (fecha)
cout << ("Fecha correcta");
else
cout << ("Fecha incorrecta");
cin.get();
return 0;
}
//-----------------------------------------------------------------
AP 5.6 (c): Escriba un algoritmo, en pseudocdigo, que permita decir si un nmero
es mltiplo de M pero no de N. Los valores de nmero, M y N, deben ser entrados por
el usuario.
Utilice, si lo cree necesario y como gua, el mismo ejemplo resuelto (ALG. 5.4) con
composicin secuencial, aunque ahora diselo con una composicin de seleccin.
AP 5.7 (m): Utilizando los anexos de equivalencia de pseudocdigo a lenguaje de
programacin, haga el programa correspondiente en Delphi o C++. Prubelo.
CON COMPOSICIN ITERATIVA
La composicin iterativa es aplicable en aquellos casos en que una accin consiste en la repeticin
de determinadas subacciones. En funcin de la situacin de la consulta al predicado y de la propia
composicin, las podemos clasificar como sigue:
5.4.1. Condicin inicial
Donde el predicado que controla la iteracin, se encuentra situado al inicio de la composicin,
pudiendo darse la circunstancia de no ejecutarse ni una sola vez en el caso de que la expresin
lgica que forma el predicado fuera ya falsa de entrada.
ALG_5.12: Algoritmo que calcule la suma de todos los nmeros enteros menores o iguales que
un mximo (max), entrado como dato.
Figura 5.6.
Obsrvese que n es un contador que va incrementndose tomando valores enteros sucesivos
que se van acumulando en la variable suma, y que estas subacciones se ejecutan reiteradamente
mientras el predicado (n<=max) es cierto. Es decir, mientras nuestro contador n no tome el valor
mximo (max + 1) dado por el usuario.
5.4.2. Condicin final
Cuando el predicado que controla la iteracin se encuentra situado al final de la estructura. En este
caso, como mnimo, las subacciones internas de la estructura se ejecutarn una vez, puesto que la
validacin de la expresin lgica que forma el predicado est situada al final de la estructura.
Figura 5.7.
Compare con el algoritmo anterior, ver que es el mismo pero con la composicin de con-
dicin final (repetir/hasta_que). Observe los predicados, son complementarios, puesto que en
el primer caso se itera mientras es verdad y en el segundo se itera mientras es falso, ya que si
el predicado (n>max) es verdad, se abandona la iteracin y contina la secuencia.
5.4.3. Repeticin
Figura 5.8.
Siguiendo con la comparacin con los dos algoritmos anteriores, notar que tanto la inicia-
lizacin como el incremento del contador n lo realiza la propia estructura. Se realizan max
iteraciones [1 max] de forma que cuando n sea mayor que max, se abandona la iteracin y con-
tina la secuencia. Al salir de la estructura desde, n = max + 1.
Expresando los tres algoritmos anteriores en un nico programa que permita verificar la
equivalencia de los tres tipos de composicin iterativa:
//-----------------------------------------------------------------
// PALG _ 5.12,13,14p Algoritmo que calcule la suma de todos los
// nmeros enteros menores o iguales que un mximo (max)
// Delphi
//-----------------------------------------------------------------
program ite _ suma _ max _ numeros;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
max, suma, n: integer;
begin
write ('Entra numero maximo: ');
readln (max);
//----------------------------------------------
// con iterativa de condicin inicial
//----------------------------------------------
n:=1;
suma:=0;
while (n<=max) do
begin
suma:=suma+n;
n:=n+1;
end;
writeln ('Suma de los ', max, ' primeros numeros es: ', suma);
//----------------------------------------------
// con iterativa de condicin final
//----------------------------------------------
n:=1;
suma:=0;
repeat
suma:=suma+n;
n:=n+1
until (n>max);
//----------------------------------------------
// con iterativa repetitiva
//----------------------------------------------
suma:=0;
for n:=1 to max do
suma:=suma+n;
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.12,13,14c Algoritmo que calcule la suma de todos los
// nmeros enteros menores o iguales que un mximo (max)
// C++
//-----------------------------------------------------------------
int main()
{
int max, suma, n;
cout << "Entra numero maximo: " ;
cin >> max;
//----------------------------------------------
// con iterativa de condicin inicial
//----------------------------------------------
n=1;
suma=0;
while (n<=max) {
suma=suma+n; // estas dos instrucciones
n++; // equivalen a suma+=n++
}
cout <<"Suma de los "<<max<<" primeros numeros es: "<<suma<< endl;
//----------------------------------------------
// con iterativa de condicin final
//----------------------------------------------
n=1;
suma=0;
do {
suma=suma+n; // estas dos instrucciones
n++; // equivalen a suma+=n++
} while (n<=max);
//----------------------------------------------
// con iterativa repetitiva
//----------------------------------------------
suma=0;
for (n=1; n<=max; n++)
suma=suma+n;
cin.get();
return 0;
}
//-----------------------------------------------------------------
5.4.4. Algn ejemplo ms
ALG_5.15: Algoritmo para determinar si un nmero entrado como dato, es primo (nmero
primo: el que slo es divisible por 1 y por l mismo).
secuencia
leer (numero)
aux=2
primo=cierto
mientras (((aux<=raiz_cuadrada(numero)) y primo) hacer
primo=((numero MOD aux )0)
aux=aux+1
fmientras
si primo entonces
mostrar (numero, es primo)
si_no
mostrar (numero, no es primo)
fsi
fsecuencia
numero, aux: entero [rango mximo de representacin]
primo: booleana
En esta ocasin, se opta por asignar parte del predicado del mientras a una variable booleana
primo que nos permitir abandonar la bsqueda de divisores en cuanto encuentre el primero,
puesto que significar que el nmero no es primo. Por otra parte, aux es la variable que se va in-
crementando, empezando por 2 puesto que por 1 sera divisible, y se utiliza para ir verificando si
existe algn divisor de nmero. El predicado consta de dos condiciones ya que es innecesaria la
bsqueda de divisores ms all de la raz cuadrada del propio nmero o de si hubiese encontrado
algn divisor.
//-----------------------------------------------------------------
// PALG _ 5.15p Algoritmo para determinar si un nmero es primo
// Delphi
//-----------------------------------------------------------------
program ite _ primo;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
numero, aux: integer;
primo: boolean;
begin
write ('Entrar el numero: ');
readln (numero);
aux:=2;
primo:=true;
while (((aux<=sqrt(numero)) and primo) do
begin
primo:=((numero mod aux)<>0);
aux:=aux+1;
end;
if (primo) then
write (numero, ' es primo')
else
write (numero, ' es primo');
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.15c Algoritmo para determinar si un nmero es primo
// C++
//-----------------------------------------------------------------
int main()
{
int numero, aux;
bool primo;
cout << "Entrar el numero: " ;
cin >> numero;
aux=2;
primo=true;
while (((aux<=sqrt(numero)) && primo) {
primo=((numero % aux)!=0);
aux=aux+1;
}
if (primo)
cout << numero << " es primo";
else
cout << numero << " no es primo";
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.16: Algoritmo para visualizar todos los nmeros primos entre dos valores (min, max)
determinados por el usuario.
Utilizando la estrategia de diseo por refinamientos descrita en el Captulo 4.
secuencia
leer (min, max)
desde numero=min hasta max incremento +1 hacer
@ACCIN numero: es_primo?@
fdesde
fsecuencia
La accin @ACCIN nmero: es_primo?@ consistira en averiguar si un nmero numero es
o no primo, pudindola disear aparte, de hecho en nuestro caso, el algoritmo ALG_5.15 realiza
esta accin. As pues, solo incluimos dicho algoritmo dentro de la estructura repetitiva, que lo
ejecuta automticamente verificando los nmeros existentes entre min y max.
secuencia
leer (min, max)
desde numero=min hasta max incremento +1 hacer
aux=2
primo=cierto
mientras (((aux<=raiz_cuadrada(numero)) y primo) hacer
primo=((numero MOD aux )0)
aux=aux+1
fmientras
si primo entonces
mostrar (numero, es primo)
fsi
fdesde
fsecuencia
min, max, numero, aux: entero [rango mximo de representacin]
primo: booleana
//-----------------------------------------------------------------
// PALG _ 5.16p Algoritmo para determinar los nmeros primos
// existentes entre 2 valores dados (min y max)
// Delphi
//-----------------------------------------------------------------
program ite _ primo _ minmax;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
numero, aux, min, max: integer;
primo: boolean;
begin
write ('Entrar DESDE que valor: ');
readln (min);
write ('Entrar HASTA que valor: ');
readln (max);
for numero:=min to max do
begin
aux:=2;
primo:=true;
while (((aux<=sqrt(numero)) and primo) do
begin
primo:=((numero mod aux)<>0);
aux:=aux+1;
end;
if (primo) then writeln (numero,' es primo');
end;
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.16c Algoritmo para determinar los nmeros primos
// existentes entre 2 valores dados (min y max)
// C++
//-----------------------------------------------------------------
int main()
{
int min, max, numero, aux;
bool primo;
cout << "Entrar DESDE que valor: " ;
cin >> min;
cout << "Entrar HASTA que valor: " ;
cin >> max;
for (numero=min;numero<=max;numero++) {
aux=2;
primo=true;
while (((aux<=sqrt(numero)) && primo) {
primo=((numero % aux)!=0);
aux=aux+1;
}
if (primo)
cout << numero << " es primo" << endl;
}
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.17: Algoritmo que dado un valor de exponente, calcule la siguiente serie con un error
menor a un valor dado por el usuario.
e
x
= 1 + x + x
2
/2! + x
3
/3! + .........
secuencia
leer (x)
leer (error)
e=1
termino=x
i=2
mientras (termino>error) hacer
e= e + termino
termino= termino * (x / i)
i=i+1
fmientras
mostrar (e)
fsecuencia
x, error, e, termino: son punto flotante de como mximo 12 dgitos y rango 10
300
i: entero mxima representacin
Se desconoce a priori cuntos trminos sern necesarios para que, como se indica en el
enunciado, el error sea menor que el propuesto por el usuario. Esto fuerza a utilizar en el diseo
una composicin iterativa de condicin inicial o final, en la que el predicado constate que el hecho
de sumar un trmino ms a la serie no influir en el resultado solicitado por el usuario, puesto que
ese trmino ya es menor al error indicado.
//-----------------------------------------------------------------
// PALG _ 5.17p Algoritmo donde dado un exponente, calcule la serie
// e^x = 1 + x + x^2/2! + x^3/3! + ...
// con un error menor que un valor entrado por el usuario
// Delphi
//-----------------------------------------------------------------
program ite _ serie _ ex;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
e, x, error, termino: real;
i:integer;
begin
write ('Entrar el exponente: ');
readln (x);
write ('Entrar el error maximo: ');
readln (error);
e:=1; termino:=x; i:=2;
while (termino>=error) do
begin
e:=e+termino;
termino:=termino*(x/i);
i:=i+1;
end;
writeln ('e^', x:6:2, ' = ', e:12:10);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.17c Algoritmo donde dado un exponente, calcule la serie
// e^x = 1 + x + x^2/2! + x^3/3! + ...
// con un error menor que un valor entrado por el usuario
// C++
//-----------------------------------------------------------------
int main()
{
float e, x, error, termino;
int i;
cout << "Entrar el exponente: ";
cin >> x;
cout << "Entrar el error maximo: ";
cin >> error;
e=1; termino=x; i=2;
while (termino>=error) {
e=e+termino;
termino=termino*(x/i);
i++;
}
cout << "e^" << x << " = " << e;
cin.get();
return 0;
}
//-----------------------------------------------------------------
ALG_5.18: Algoritmo para calcular el valor mximo, mnimo y la media aritmtica de una
lista de valores entrada por el usuario y acabada en 0.
secuencia
leer (valor)
max=min=valor
suma=0
contador=0
mientras (valor 0 ) hacer
si valor > max entonces
max=valor
si_no
si valor < min entonces
min=valor
fsi
fsi
suma= suma + valor
contador= contador + 1
leer (valor)
fmientras
si contador = 0 entonces
media=0
si_no
media= suma/contador
fsi
mostrar (max, min, media)
fsecuencia
valor, max, min, media: punto flotante (mxima representacin)
suma: punto flotante (mxima representacin)
contador: entero (mxima representacin)
//-----------------------------------------------------------------
// PALG _ 5.18p Algoritmo para calcular la media y muestra el
// valor mximo y mnimo de una lista de valores acabada en 0
// Delphi
//-----------------------------------------------------------------
program ite _ lista _ valores;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
max, min, valor, media: single;
suma: double;
contador: integer;
begin
writeln ('Media,maximo y minimo de una serie de valores (0=fin)');
write ('Entra primer valor: '); readln (valor);
max:=valor; min:=valor;
suma:=0;
contador:=0;
while (valor <> 0 ) do
begin
if valor > max then max:=valor
else
if valor < min then min:=valor;
suma:= suma + valor;
contador:= contador + 1;
write ('Entra siguiente valor: '); readln (valor);
end;
if contador = 0 then
media:=0
else
media:= suma/contador;
writeln('Maximo:',max, ' Minimo:', min, 'Media:', media);
readln;
end.
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// PALG _ 5.18c Algoritmo para calcular la media y muestra el
// valor mximo y mnimo de una lista de valores acabada en 0
// C++
//-----------------------------------------------------------------
int main()
{
float max, min, valor, media;
double suma;
int contador;
cout <<"Media,maximo,minimo de la serie de valores(0=fin)" <<endl;
cout <<"Entra primer valor: "; cin >> valor;
max=valor; min=valor;
suma=0;
contador=0;
while (valor != 0 ) {
if (valor > max) max=valor;
else
if (valor < min) min=valor;
suma= suma + valor;
contador++;
cout << "Entra siguiente valor: "; cin >> valor;
};
if (contador == 0)
media=0;
else
media= suma/contador;
cout << "Maximo:"<< max << " Minimo:"<< min << " Media:"<< media;
cin.get();
return 0;
}
//-----------------------------------------------------------------
AP 5.8 (c): Escriba un algoritmo para jugar a adivinar un nmero. La aplicacin debe
solicitar un nmero clave, a un primer jugador, que debe ser adivinado por un segun-
do jugador al que se le deben ir preguntando nmeros, indicndole en cada caso, si es
mayor o menor que la clave, hasta que lo acierte. En tal caso, se le felicitar y se le
mostrar en cuntas jugadas lo ha acertado.
AP 5.9 (c): Con la ayuda de los anexos de este libro, escriba el programa correspon-
diente a la AP 5.8 en Delphi o C++.
AP 5.10 (c): Escriba un algoritmo para validar una contrasea fijada en un programa.
Se debe solicitar al usuario esa contrasea permitiendo slo 3 intentos, si es correcta
debe dar un mensaje de Contrasea correcta y en caso contrario un mensaje de
Contrasea incorrecta y cierre el programa.
AP 5.11 (c): Utilizando los anexos de este libro, con la equivalencia de pseudocdigo a
lenguaje de programacin, escriba los programas correspondientes en Delphi o C++.
5.5. OTRAS ACTIVIDADES PROPUESTAS
AP 5.12 (c): Realice el emparejamiento de las expresiones que considere equiva-

lentes:
1. (A B) or (B = C) 1. not (A >= B) and not (B >= C)
2. (A < B) and (B < C) 2. not ((A >= B) or (B > C))
3. (A < B) and (B <= C) 3. not ((A = B) and (B C))

AP 5.13 (c): Escriba un algoritmo que permita simular una calculadora simple, con
las operaciones de +,,* y /. (Utilice una estructura alternativa mltiple para selec-
cionar la operacin).

AP 5.14 (c): Disear un algoritmo que dada una hora, como: hora, minuto, segundo,
muestre la hora de 1 segundo ms tarde.

AP 5.15 (c): Escriba un algoritmo que calcule el factorial de un nmero entero en-
trado como dato.

AP 5.16 (c): Escriba un algoritmo para generar una tabla de conversin de grados
Celsius a Farenheit. TempF = (9/5) * C + 32.

AP 5.17 (c): Escriba un algoritmo capaz de generar y visualizar todas las tablas de
multiplicar, del 1 al 10.

AP 5.18 (c): Escribir un algoritmo que dado un nmero de latas, entrado como dato,
informe de si pueden apilarse de forma piramidal, sin que sobre ni falte ninguna. En
caso afirmativo: de cuntos niveles ser?

AP 5.19 (c): Escribir un algoritmo que dada una secuencia de nmeros, acabada en
0, calcule la media de los valores positivos, as como la de los valores negativos.

AP 5.20 (c): Escriba un algoritmo que realice la conversin de un nmero entero
positivo decimal a cualquier otra base menor que 10. El nmero y la nueva base
entrados como datos.

AP 5.21 (c): Escriba un algoritmo que a partir de un nmero entero entrado como
dato, genere un segundo nmero que sea el primero pero con los dgitos invertidos,
1234 4321. Primero deber contar los dgitos que tiene y luego deber ir acumu-
lando la suma de cada dgito * 10
pos
, 4 * 10
3
+ 3 * 10
2
+ 2 * 10
1
+ 1 * 10
0
. (Utilice los
operadores mod y div para obtener los dgitos).

AP 5.22 (c): Disear un algoritmo para informar de si un nmero entero, entrado
como dato, es perfecto. (Nmero perfecto: aquel que es igual a la suma de sus divi-
sores, excepto l mismo. Ej: 6 = 1 + 2 + 3).

AP 5.23 (c): Disear un algoritmo que dada una secuencia de nmeros, acabada en
0, informe de si los valores se han entrado ordenadamente de forma creciente o ha
hallado alguno desordenado.

AP 5.24 (c): Escriba el algoritmo que desarrolle con N trminos la serie de Leibniz
para calcular el nmero .
0
( 1) 1 1 1 1
1 ....
4 (2 1) 3 5 7 9
n
n
n
=

= = + +
+

5.5.1. AP con diseo por refinamientos
Ejercicio 1
Disear y escribir una aplicacin para el clculo de la nmina de un trabajador. El operario cobra
15 la hora y en concepto de antigedad 18 por trienio. Por otra parte, se le retiene un 15%
como IRPF y un 6,35% por Seguridad Social. El programa debe pedir el nombre del trabajador,
las horas trabajadas y el ao en que entr en la empresa. Como salida debe imprimir el sueldo
bruto, las retenciones y el sueldo neto.
secuencia
leer(nombre, horas_trab, ao)
antigedad= @accin calculo_trienios
sueldo_bruto= (horas_trab*15) + (antigedad*18)
retencion_irpf= @accin calculo_retencion_irpf
retencion_ss= @accin calculo_retencion_ss
sueldo_neto= sueldo_bruto retencion_irpf retencion_ss
mostrar(sueldo_bruto, retencion_irpf, retencion_ss, sueldo_neto)
fsecuencia
nombre: cadena 60 caracteres
horas_trab, sueldo_bruto, retencion_irpf, retencion_ss, sueldo_neto: punto flotante de como
mximo 7 dgitos y rango 10
+5
ao, antigedad: entero [0 2020]
AP 5.25 (c): Desarrolle las siguientes acciones @accin calculo_trienios, @accin
calculo_retencin_irpf y @accin calculo_retencion_ss. Mntelas sobre el algoritmo
anterior de 1r. refinamiento.
AP 5.26 (m): Haciendo uso de los anexos de este libro, escriba el programa corres-
pondiente en Delphi o C++.
Quizs, el desarrollo de las acciones anteriores le han parecido excesivamente sencillas para
disear por refinamientos, pero, suponga ahora que el clculo de la retencin del IRPF ya no es
fijo del 15% si no que vara en funcin de los ingresos brutos anuales, donde la base para el cl-
culo del IRPF es el sueldo bruto anual estimado menos la retencin por Seguridad Social (el
sueldo bruto estimado puede suponerse como el del mes actual *14 pagas). Sobre esa base se
calcula la retencin global del ao por tramos, segn la siguiente tabla (los primeros 17.360 un
24%, los siguientes 15.000 al 28%, los siguientes 20.000 al 37%, ) sumando las retenciones
de cada tramo. Finalmente dividiendo la retencin anual total calculada por el sueldo bruto anual
estimado y multiplicado por 100, obtendremos el % de IRPF que se debe aplicar.
TABLA TRAMOS IRPF
de a
0,00 17.360,00 24,00%
17.360,00 32.360,00 28,00%
32.360,00 52.360,00 37,00%
52.360,00 43,00%
AP 5.27 (m): Desarrolle de nuevo la @accin calculo_retencion_irpf. Mntela sobre
el algoritmo de 1r. refinamiento.
AP 5.28 (m): Progrmela en C++ o Pascal/Delphi y verifique su funcionamiento.
Ejercicio 2
Una empresa de autobuses desea una aplicacin que calcule los tiempos de trayecto. Para tal
fin, nos facilita un cdigo de autobs, la hora de salida, hora estimada de llegada, hora real de
llegada. Todas las horas estn en formato hh:mm. Escriba un algoritmo que con esos datos de
entrada, calcule e informe del tiempo total de trayecto (hh:mm) y de la diferencia entre la lle-
gada real y la prevista.
secuencia
leer(codigo,hsalida, msalida, hll_prevista, mll_prevista, hll_real, mll_real)
@accin tiempo_trayecto con hsalida, msalida, hll_real,mll_real
@accin tiempo_retraso con hll_prevista, mll_prevista, hll_real,mll_real
mostrar(horas_tiempo_trayecto, min_tiempo_trayecto)
mostrar(horas_tiempo_retraso, min_tiempo_retraso)
fsecuencia
cdigo: cadena 10 caracteres
hsalida,hll_prevista,hll_real,horas_tiempo_trayecto,horas_tiempo_retraso: entero [0 24]
msalida,mll_prevista,mll_real,min_tiempo_trayecto,min_tiempo_retraso: entero [0 60]
AP 5.29 (m): Desarrolle las siguientes acciones: @accin tiempo_trayecto y @accin
tiempo_retraso. Le aconsejamos que para realizar estos clculos lo pase todo a minu-
tos. Observar que las dos acciones son iguales y que slo varan las variables sobre
las que se opera. En otros captulos ver cmo convertir esta accin en una accin_ex-
terna reutilizable. Escrbalas sobre el algoritmo de 1r. refinamiento.
AP 5.30 (m): Programe la aplicacin y verifique su funcionamiento.

Cap5

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Cap5

Diunggah oleh

Hak Cipta:

Format Tersedia

5

AP 5.12 (c): Realice el emparejamiento de las expresiones que considere equiva-

196 Fundamentos de informtica

Anda mungkin juga menyukai