diseño y (dpa) programación de algoritmos...

5

��

objetiVo didÁctico

Aplicar las bases y criterios del diseño estructurado de algoritmos a la resolución de proble-mas simples.

Al finalizar la unidad el alumno deberá ser capaz de:

• Definir y resolver un problema de complejidad simple diseñando el algoritmo corres-pondiente con la aplicación de los criterios de programación estructurada desarrollados en el capítulo anterior.

• Comprender y utilizar las primitivas básicas de entrada/salida, así como reconocer y adaptar la información a tratar con los tipos de datos estándar más apropiados.

• Comprender el concepto de especificación de un algoritmo y distinguirlo de la imple-mentación.

• Aplicar la equivalencia de pseudocódigo a lenguaje de programación sobre los dise-ños realizados, sabiendo adaptarlos, para generar programas en diferentes lenguajes de programación.

Los objetivos didácticos anteriores, pueden concretarse en el eje de actividad siguiente:

EAP-5. Eje de actividad parcial Capítulo 5

1. Escriba un algoritmo que dado un número 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 máximo, entrados por teclado. Deberá realizar la conversión a radianes para calcular la serie:

+

=

= − = − + − + −+∑2 1 3 5 7 9

1

sin( ) ( 1) ...(2 1)! 3! 5! 7! 9!

in

i

x x x x xx x

i

4. Programe en C++ o Pascal/Delphi los diseños anteriores y verifique su correcto funcionamiento.

diseño y (dpa)programación de algoritmos simples

�� Fundamentos de informática

Para dar soporte a estos objetivos y eje de actividad, seguiremos el siguiente orden de desa-rrollo de conceptos, ejercicios y otras actividades:

Diseño y programación de algoritmos simples

5.1. Conceptos previos.

5.2. Algoritmos de resolución de problemas con composición secuencial.

5.3. Algoritmos de resolución de problemas con composición de selección.

5.4. Algoritmos de resolución de problemas con composición iterativa.

5.5. Otras actividades propuestas.

En este capítulo se pretende mostrar, a modo de ejemplo, cómo describir la resolución de problemas simples diseñando sus algoritmos en pseudocódigo, tomando como punto de partida los conceptos, definiciones, descripciones y criterios sobre diseño estructurado de algoritmos desarrollados en el Capítulo 4.

�.�. conceptoS preVioS

La composición secuencial permite describir el orden de ejecución de las acciones necesarias para resolver un determinado problema. Para tal fin, además de la estructura (secuencia/fsecuencia) en sí, nos serán imprescindibles otros elementos como constantes y variables, expresiones y opera-dores, así como también primitivas de entrada/salida de datos (información).

Como datos, entendemos los diferentes tipos de información que sustentaran los objetos pasi-vos (constantes y variables) a los cuales haremos referencia en el algoritmo y que nos permitirán resolver el problema. Empezaremos por definir los tipos simples “estándar”, para en capítulos posteriores entrar en estructuras de datos más complejas.

�.�.�. tipos de datos simples estándarEl tipo de un dato define el conjunto de valores que forman un dominio y que podrá tomar una variable. Al referirnos a datos simples estándar, pensamos en información cuyo formato y rango de valores posible, permite incluirlos en tipos que ya están predefinidos por razones de eficiencia en los lenguajes de programación, por lo que sólo es necesario declararlos asociándolos a un identificador, a través del cual accederemos a la información que contiene.

Entero: Definimos entero como un valor numérico (positivo o negativo) sin parte fracciona-ria. El dominio o rango de valores que puede abarcar dependerá del lenguaje de programación que utilicemos, aunque como idea, la mayoría de lenguajes de programación utilizan 32 bits co-dificados en complemento a 2 para definir de forma estándar un entero (véase el Capítulo 2).

Real o punto flotante (float): Se trata de valores numéricos (positivos y negativos) con parte fraccionaria. En este caso, no sólo es crítico el rango, sino también la precisión (número de dígitos representables) que dependerá del lenguaje de programación aunque comúnmente disponen de los estándar IEEE 754 de simple y doble precisión (véase el Capítulo 2).

Carácter: Es un valor alfanumérico, codificado en los lenguajes de programación como có-digo ASCII de 8 bits.

Lógico o booleano: Sólo aceptan valores lógicos (Verdadero o Falso).Cadena: Aunque no se corresponde con un tipo simple de dato, se incluye aquí por su facili-

dad de definición y utilización como tal. Su función es la de contener una serie de caracteres (una palabra, frase…).

Diseño y programación de algoritmos simples ��

AP 5.1 (c): ¿Qué tipo de datos considera el más apropiado para representar los si-guientes conceptos?

a. El sueldo de un trabajador.b. Su edad.c. Su estado civil.d. Su dirección.

�.�.�. tipos de datos simples no estándar Cuando hablamos de tipos no estándar, nos referimos a tipos de datos que los lenguajes de pro-gramación no tienen predefinidos, pero que permiten que el diseñador/programador, mediante mecanismos de definición, pueda describirlos para ser utilizados posteriormente en el algoritmo.

Aunque la justificación de los tipos definidos por el usuario se describen en el Capítulo 7, se ha optado por explicar los tipos enumerados en este capítulo por tratarse básicamente de tipos simples de datos y porque así nos facilitará el desarrollo de algunos temas y ejemplos de los próximos capítulos.

En definitiva, los enumerados son tipos definidos por el programador y consisten en una lista ordenada y finita de valores concretados en la definición 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 básicamente se usan como una ayuda para facilitar el diseño del algoritmo al programador, pudiendo identificar y tratar la información de manera más cómoda.

En cuanto a su utilización deben observarse ciertas restricciones:• Una variable de tipo enumerado sólo puede tomar los valores expresados en el tipo.• Al tratarse de una secuencia ordenada de valores pueden usarse en expresiones lógicas 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 conversión que se verán más adelante.

�.�.�. 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 comúnmente existen ciertas reglas que hay que seguir:

• Debe comenzar con una letra o “_”, seguido por otras letras, dígitos o caracteres subra-yados (“_”).

• No puede contener espacios en blanco, ya que suele tener una función de separador.

Cada lenguaje tiene sus características y limitaciones para la construcción y formato de un identificador. Lo habitual es generar nombres que indiquen el significado o la descripción del dato que va a contener ese identificador.

��0 Fundamentos de informática

Como constantes nos referimos a datos que no pueden variar en el transcurso de la ejecución 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 · 108

vel_sonido = 331,4

Las variables, al contrario que las constantes, son objetos cuyo valor puede ser modificado en cualquier momento a través de su identificador, bien por una asignación directa, bien como resul-tado de alguna expresión.

Las variables deben ser declaradas y especificado su tipo, concretando el dominio de valores en el caso de los enteros, o el rango y precisión para los valores en punto flotante, o el número de caracteres en el caso de una cadena. Con el fin de que el programador asigne, en función del lenguaje con el que se implementará el algoritmo, el tipo más idóneo y eficiente desde el punto de vista del lenguaje de programación para esa variable, evitando así comportamientos inadecuados del algoritmo y del programa.

Será imprescindible, pues, para cada diseño de algoritmo, requerir la especificación del tipo de variables utilizado, así como el rango (valores máximos) que se prevea que puedan alcanzar en función de la aplicación.

Especificación variables:

radio, área: punto flotante de como máximo 8 dígitos de precisión y rango 103

dia_mes: entero ∈ [1,31]

Algunos autores toman descriptores de tipos directamente de los lenguajes de programación. Nosotros hemos preferido realizar una especificación en función de las necesidades del problema, dando libertad para que más tarde, el programador lo asocie a un tipo concreto del lenguaje que pueda adaptarse a nuestra especificación.

�.�.�. expresiones y operadores Las expresiones son sólo una combinación de operandos y operadores que son evaluadas con la finalidad de obtener un resultado. Dicha evaluación sigue unas normas de precedencia (prioridad) de operadores a no ser que se especifique por la vía del paréntesis el orden de evaluación 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-presión se determina por los valores de las variables y constantes implicadas y la ejecución de las operaciones indicadas.

En cuanto a los operadores básicos, podríamos clasificarlos como:

aritméticos: +, –, *, /, div. mod, ^

lógicos: no, y, o

relacionales: <, <=, >,>=, =, <>

Parecen todos de comprensión bastante obvia, excepto quizás el div que representa una división de enteros con resultado entero y el mod que realiza el cálculo del residuo de la divi-sión entera.

2 5 div 2 1 5 mod 2 2,5 5/2


Evidentemente, los operandos numéricos deben ser utilizados con operadores aritméticos para conseguir un resultado numérico y con operadores de relación para obtener un resultado lógico o booleano (true, false).

Los operadores lógicos (no, y, o) se utilizan con operandos también lógicos para obtener un resultado lógico.

Siendo a, b variables enteras y c booleana, se podrían generar expresiones válidas 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 lógicas que permitan saber (sean ciertas):

• El edificio A es el más alto. A_mas_alto= • El edificio B no es el más alto. B_no_mas_alto=• Alguno de los edificios supera los 200 metros. alguno_mayor_200=

�.�.�. operaciones de entrada/Salida de información Para resolver cualquier problema, lo más habitual es que partiendo de una información (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 resolución del problema, también necesitará comunicarse con el exterior.

A esa comunicación, en pseudocódigo, 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 función del lenguaje de programación que utilicemos.

�.�. alGoritmoS de reSolUción de problemaS con compoSición SecUencial

En este apartado, no sólo aportaremos cómo resolver problemas de carácter secuencial elaboran-do algoritmos en pseudocódigo, sino que incluiremos la correspondencia, a modo de ejemplo, de ese mismo algoritmo a dos de los lenguajes de programación mayormente utilizados, como son Pascal (Delphi) y C++.

En los anexos podrá encontrar las equivalencias entre pseudocódigo 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 programación, con la finalidad de escribir el programa y probarlo.


El objetivo perseguido es, pues, doble: practicar la realización de algoritmos y hacer ver al alumno que un algoritmo puede programarse posteriormente en distintos lenguajes de programa-ción solamente teniendo en cuenta las equivalencias, reglas y sintaxis del lenguaje.

Veamos algunos ejemplos, empezando por lo más simple:

ALG_5.1: Desarrollemos el algoritmo y programas para sumar dos números entrados como datos.

Figura �.�.

Utilizando las reglas de equivalencia de los anexos, podríamos realizar el programa en Delphi y C++.

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.1p Algoritmo para sumar dos números// Delphi//-----------------------------------------------------------------program suma2;{$APPTYPE CONSOLE}uses SysUtils;var numero1,numero2,suma:real; // real = double

begin writeln ('Programa para sumar dos números'); write ('Entra primer numero: '); readln (numero1); write ('Entra segundo numero: '); readln (numero2);


suma:= numero1 + numero2; writeln ('La suma vale: ', suma:9:3); readln;end.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.1c Algoritmo para sumar dos números// C++//-----------------------------------------------------------------#include <iostream.h>

int main(){ float numero1,numero2,suma;

cout << "Programa para sumar dos números" << 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 cálculo del Índice de Masa Corporal, tomando el peso y la altura como datos de entrada. IMC = peso(kg)/h2(m). Se consi-dera saludable un índice entre 18 y 25.

secuencia

leer (peso )

leer (altura )

IMC = peso / (altura * altura)

mostrar (IMC)

fsecuencia

Especificación de variables:

peso, altura e IMC: punto flotante no superior a 3 dígitos de precisión y rango 103


//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.2c Algoritmo calculo masa corporal IMC=peso(kg)/h^2(m)// C++//-----------------------------------------------------------------#include <iostream.h>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 �.�.

Desarrollando la implementación de este algoritmo en los lenguajes de programación men-cionados:

//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.3c Algoritmo para determinar el área de una corona// C++//-----------------------------------------------------------------#include <iostream.h>#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 número entero y posi-tivo, es múltiplo 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 lógicas.

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


número, M, N: enteros ∈ [1÷231]

mult_M, mult_N, cuestión: lógica (booleana)


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.4p Algoritmo para determinar si un número es // múltiplo 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.4c Algoritmo para determinar si un número es// múltiplo de M pero no de N// C++//-----------------------------------------------------------------#include <iostream.h>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 máximo 7 dígitos y rango 10±10

//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.5c Algoritmo para pasar coordenadas rectangulares a// polares y a la inversa (en grados y radianes)// C++//-----------------------------------------------------------------#include <iostream.h>#include <cmath.h>#define pi 3.14159int 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 pseudocódigo, que dado el radio de un círculo calcule y muestre su área y perímetro. (Puede basarse en el ejemplo ALG_5.3 de este capítulo).

AP 5.4 (c): Escriba un algoritmo que dado un número total de segundos entrado por teclado, diga a cuántas horas, minutos y segundos corresponden.

AP 5.5 (m): Utilizando los anexos de este libro sobre la equivalencia de pseudocódigo a lenguaje de programación, haga los programas correspondientes en Delphi o C++.


�.�. alGoritmoS de reSolUción de problemaS con compoSición de Selección

Ahora nos proponemos ilustrar, por medio de los ejemplos, la aplicación de composiciones de selección simple y doble para la toma de decisiones en la resolución de un problema, tanto en el algoritmo en pseudocódigo como en lenguajes de programación.

�.�.�. composición simple y doble

como ejemplo del uso y comportamiento de una composición 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 máxima representación

//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.6c Algoritmo para determinar si un dato es negativo// C++//-----------------------------------------------------------------#include <iostream.h>

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 composición 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 máxima representación

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.7p Algoritmo informe si un dato es positivo o negativo// Delphi//-----------------------------------------------------------------program alt _ pos _ neg;{$APPTYPE CONSOLE}uses


SysUtils;var valor: real;

begin write ('Entra el valor: '); readln (valor); if (valor<0) then writeln ('Es negativo') else writeln ('Es positivo');

readln;end.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.7c Algoritmo informe si un dato es positivo o negativo// C++//-----------------------------------------------------------------#include <iostream.h>

int main(){ float valor;

cout << "Entrar el valor: " ; cin >> valor; if (valor<0) cout << "Es negativo"; else cout << "Es positivo";

cin.get(); return 0;}//-----------------------------------------------------------------

como ejemplo simple de una composición de selección 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 máxima representación

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.8p Determinar si un dato es positivo,0,negativo// Delphi//-----------------------------------------------------------------program alt _ pos _ neg;{$APPTYPE CONSOLE}uses SysUtils;var valor: real;

begin write ('Entra el valor: '); readln (valor);

if (valor=0) then writeln ('Es un cero') else if (valor<0) then writeln ('Es negativo') else writeln ('Es positivo');

readln;end.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.8c Determinar si un dato es positivo,0,negativo// C++//-----------------------------------------------------------------#include <iostream.h>


int main(){ float valor;

cout << "Entrar el valor: " ; cin >> valor;

if (valor==0) cout << "Es un cero"; else if (valor<0) cout << "Es negativo"; 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 máxima representación


//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.9c Algoritmo que dados dos valores, exprese si // alguno es divisor del otro// C++//-----------------------------------------------------------------#include <iostream.h>

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 cuál de ellos es el mayor.Este desarrollo lo utilizaremos, además, como ejemplo de estrategia de diseño por refina-

mientos.

Figura �.�.

Podemos ahora diseñar por separado cada una de las acciones, observando que:

• La acción @ACCIÓN num2_no_es ver_num1_num3@ sólo se ejecuta cuando num2 no es el mayor por lo que sólo debe verificar si es num1 o num3.

• La acción @ACCIÓN num1_no_es ver_num2_num3@ sólo se ejecuta cuando num1 no es el mayor por lo que sólo debe verificar si es num2 o num3.


De forma que:

Figura �.�.

Finalmente, teniendo diseñadas cada una de las acciones, podemos sustituirlas en el primer algoritmo (recordemos la visión por refinamientos descrita gráficamente en el Capítulo 4), que una vez recompuesto quedaría:

Figura �.�.


Implementamos ahora el algoritmo resultante, en Pascal/Delphi y también en C++

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.10p Algoritmo para determinar el mayor de tres números// 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.10c Algoritmo para determinar el mayor de tres números// C++//-----------------------------------------------------------------#include <iostream.h>

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

�.�.�. composición múltiple y por valor � entre n ALG_5.11: Diseñar en pseudocódigo y realizar el programa para validar una fecha (día, mes y año), teniendo en cuenta los años 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 ∈ [1÷31], mes: entero ∈ [1÷12], anyo: entero ε [1990÷2050], fecha: booleana

Nótese, en la última composición, que el predicado puede ser solamente una variable booleana, sin necesidad de compararla, puesto que es cierta o falsa en sí misma.

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.11p Algoritmo para validar una fecha (día, mes y año)// 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 año: '); 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.11c Algoritmo para validar una fecha (día, mes y año)// C++//-----------------------------------------------------------------#include <iostream.h>

int main(){ int dia,mes,anyo,maxdias; bool fecha; fecha=false; cout << "Entra el dia, mes y año: " ; 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 pseudocódigo, que permita decir si un número es múltiplo de M pero no de N. Los valores de número, M y N, deben ser entrados por el usuario.

Utilice, si lo cree necesario y como guía, el mismo ejemplo resuelto (ALG. 5.4) con composición secuencial, aunque ahora diséñelo con una composición de selección.

AP 5.7 (m): Utilizando los anexos de equivalencia de pseudocódigo a lenguaje de programación, haga el programa correspondiente en Delphi o C++. Pruébelo.

�.�. alGoritmoS de reSolUción de problemaS con compoSición iteratiVa

La composición iterativa es aplicable en aquellos casos en que una acción consiste en la repetición de determinadas subacciones. En función de la situación de la consulta al predicado y de la propia composición, las podemos clasificar como sigue:

�.�.�. condición inicial Donde el predicado que controla la iteración, se encuentra situado al inicio de la composición, pudiendo darse la circunstancia de no ejecutarse ni una sola vez en el caso de que la expresión lógica que forma el predicado fuera ya falsa de entrada.

ALG_5.12: Algoritmo que calcule la suma de todos los números enteros menores o iguales que un máximo (max), entrado como dato.

∈

Figura �.�.


Obsérvese que n es un contador que va incrementándose 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 máximo (max + 1) dado por el usuario.

�.�.�. condición final Cuando el predicado que controla la iteración se encuentra situado al final de la estructura. En este caso, como mínimo, las subacciones internas de la estructura se ejecutarán una vez, puesto que la validación de la expresión lógica que forma el predicado está situada al final de la estructura.


∈

Figura �.�.

Compare con el algoritmo anterior, verá que es el mismo pero con la composición de con-dición 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 iteración y continúa la secuencia.

�.�.�. repetición



Figura �.�.

Siguiendo con la comparación con los dos algoritmos anteriores, notará que tanto la inicia-lización 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 iteración y con-tinúa 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 composición iterativa:

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.12,13,14p Algoritmo que calcule la suma de todos los// números enteros menores o iguales que un máximo (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 condición 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 condición final//---------------------------------------------- n:=1; suma:=0; repeat suma:=suma+n; n:=n+1 until (n>max); writeln ('Suma de los ', max, ' primeros numeros es: ', suma);

//----------------------------------------------// con iterativa repetitiva//---------------------------------------------- suma:=0; for n:=1 to max do suma:=suma+n; writeln ('Suma de los ', max, ' primeros numeros es: ', suma);

readln;end.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.12,13,14c Algoritmo que calcule la suma de todos los// números enteros menores o iguales que un máximo (max)// C++//-----------------------------------------------------------------#include <iostream.h>

int main(){ int max, suma, n;

cout << "Entra numero maximo: " ; cin >> max;

//----------------------------------------------// con iterativa de condición 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 condición final//---------------------------------------------- n=1; suma=0; do { suma=suma+n; // estas dos instrucciones n++; // equivalen a suma+=n++ } while (n<=max); cout <<"Suma de los "<<max<<" primeros numeros es: "<<suma<< endl;

//----------------------------------------------// con iterativa repetitiva//---------------------------------------------- suma=0; for (n=1; n<=max; n++) suma=suma+n; cout <<"Suma de los "<<max<<" primeros numeros es: "<<suma<< endl;

cin.get(); return 0;}//-----------------------------------------------------------------

�.�.�. algún ejemplo más ALG_5.15: Algoritmo para determinar si un número entrado como dato, es primo (número primo: el que sólo 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 máximo de representación]

primo: booleana

En esta ocasión, se opta por asignar parte del predicado del mientras a una variable booleana primo que nos permitirá abandonar la búsqueda de divisores en cuanto encuentre el primero, puesto que significará que el número no es primo. Por otra parte, aux es la variable que se va in-crementando, empezando por 2 puesto que por 1 sería divisible, y se utiliza para ir verificando si existe algún divisor de número. El predicado consta de dos condiciones ya que es innecesaria la búsqueda de divisores más allá de la raíz cuadrada del propio número o de si hubiese encontrado algún divisor.

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.15p Algoritmo para determinar si un número 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.//-----------------------------------------------------------------


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.15c Algoritmo para determinar si un número es primo// C++//-----------------------------------------------------------------#include <iostream.h>

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 números primos entre dos valores (min, max) determinados por el usuario.

Utilizando la estrategia de diseño por refinamientos descrita en el Capítulo 4.

secuencia

leer (min, max)

desde numero=min hasta max incremento +1 hacer

@ACCIÓN numero: es_primo?@

fdesde

fsecuencia

La acción @ACCIÓN número: es_primo?@ consistiría en averiguar si un número numero es o no primo, pudiéndola diseñar aparte, de hecho en nuestro caso, el algoritmo ALG_5.15 realiza esta acción. Así pues, solo incluimos dicho algoritmo dentro de la estructura repetitiva, que lo ejecuta automáticamente verificando los números 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 fdesdefsecuencia

Especificación de variables: min, max, numero, aux: entero ∈ [rango máximo de representación]primo: booleana

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.16p Algoritmo para determinar los números 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.//-----------------------------------------------------------------


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.16c Algoritmo para determinar los números primos// existentes entre 2 valores dados (min y max)// C++//-----------------------------------------------------------------#include <iostream.h>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.

ex = 1 + x + x2/2! + x3/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 máximo 12 dígitos y rango 10±300

i: entero máxima representación

Se desconoce a priori cuántos términos serán 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 diseño una composición iterativa de condición inicial o final, en la que el predicado constate que el hecho de sumar un término más a la serie no influirá en el resultado solicitado por el usuario, puesto que ese término ya es menor al error indicado.

//-----------------------------------------------------------------// Fundamentos de Informática// 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.//-----------------------------------------------------------------

//-----------------------------------------------------------------// Fundamentos de Informática// 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++


//-----------------------------------------------------------------#include <iostream.h>

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 máximo, mínimo y la media aritmética 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 (máxima representación)suma: punto flotante (máxima representación)contador: entero (máxima representación)

//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.18p Algoritmo para calcular la media y muestra el// valor máximo y mínimo 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.//-----------------------------------------------------------------


//-----------------------------------------------------------------// Fundamentos de Informática// PALG _ 5.18c Algoritmo para calcular la media y muestra el// valor máximo y mínimo de una lista de valores acabada en 0// C++//-----------------------------------------------------------------#include <iostream.h>

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 número. La aplicación debe solicitar un número clave, a un primer jugador, que debe ser adivinado por un segun-do jugador al que se le deben ir preguntando números, indicándole 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 cuántas 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 contraseña fijada en un programa. Se debe solicitar al usuario esa contraseña permitiendo sólo 3 intentos, si es correcta debe dar un mensaje de “Contraseña correcta” y en caso contrario un mensaje de “Contraseña incorrecta” y cierre el programa.

AP 5.11 (c): Utilizando los anexos de este libro, con la equivalencia de pseudocódigo a lenguaje de programación, escriba los programas correspondientes en Delphi o C++.


�.�. 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 múltiple para selec-cionar la operación).

AP 5.14 (c): Diseñar un algoritmo que dada una hora, como: hora, minuto, segundo, muestre la hora de 1 segundo más tarde.

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

AP 5.16 (c): Escriba un algoritmo para generar una tabla de conversión 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 número de latas, entrado como dato, informe de si pueden apilarse de forma piramidal, sin que sobre ni falte ninguna. En caso afirmativo: ¿de cuántos niveles será?

AP 5.19 (c): Escribir un algoritmo que dada una secuencia de números, 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 conversión de un número entero positivo decimal a cualquier otra base menor que 10. El número y la nueva base entrados como datos.

AP 5.21 (c): Escriba un algoritmo que a partir de un número entero entrado como dato, genere un segundo número que sea el primero pero con los dígitos invertidos, 1234 4321. Primero deberá contar los dígitos que tiene y luego deberá ir acumu-lando la suma de cada dígito * 10pos, 4 * 103 + 3 * 102 + 2 * 101 + 1 * 100. (Utilice los operadores mod y div para obtener los dígitos).

AP 5.22 (c): Diseñar un algoritmo para informar de si un número entero, entrado como dato, es perfecto. (Número perfecto: aquel que es igual a la suma de sus divi-sores, excepto él mismo. Ej: 6 = 1 + 2 + 3).

AP 5.23 (c): Diseñar un algoritmo que dada una secuencia de números, 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 términos la serie de Leibniz para calcular el número π.

0

( 1) 1 1 1 11 ....

4 (2 1) 3 5 7 9

n

n n

∞

=

π −= = − + − + −

+∑


�.�.�. ap con diseño por refinamientos

ejercicio �

Diseñar y escribir una aplicación para el cálculo de la nómina de un trabajador. El operario cobra 15 € la hora y en concepto de antigüedad 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 año en que entró en la empresa. Como salida debe imprimir el sueldo bruto, las retenciones y el sueldo neto.

secuencia

leer(nombre, horas_trab, año)

antigüedad= @acción calculo_trienios

sueldo_bruto= (horas_trab*15) + (antigüedad*18)

retencion_irpf= @acción calculo_retencion_irpf

retencion_ss= @acción 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 máximo 7 dígitos y rango 10+5

año, antigüedad: entero ∈ [0 ÷ 2020]

AP 5.25 (c): Desarrolle las siguientes acciones @acción calculo_trienios, @acción calculo_retención_irpf y @acción calculo_retencion_ss. Móntelas 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++.

Quizás, el desarrollo de las acciones anteriores le han parecido excesivamente sencillas para diseñar por refinamientos, pero, suponga ahora que el cálculo de la retención del IRPF ya no es fijo del 15% si no que varía en función de los ingresos brutos anuales, donde la base para el cál-culo del IRPF es el sueldo bruto anual estimado menos la retención por Seguridad Social (el sueldo bruto estimado puede suponerse como el del mes actual *14 pagas). Sobre esa base se calcula la retención global del año por tramos, según 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 retención 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 @acción calculo_retencion_irpf. Móntela sobre el algoritmo de 1r. refinamiento.

AP 5.28 (m): Prográmela en C++ o Pascal/Delphi y verifique su funcionamiento.

ejercicio �

Una empresa de autobuses desea una aplicación que calcule los tiempos de trayecto. Para tal fin, nos facilita un código de autobús, la hora de salida, hora estimada de llegada, hora real de llegada. Todas las horas están 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)

@acción tiempo_trayecto con hsalida, msalida, hll_real,mll_real

@acción 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


código: 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: @acción tiempo_trayecto y @acción tiempo_retraso. Le aconsejamos que para realizar estos cálculos lo pase todo a minu-tos. Observará que las dos acciones son iguales y que sólo varían las variables sobre las que se opera. En otros capítulos verá cómo convertir esta acción en una acción_ex-terna reutilizable. Escríbalas sobre el algoritmo de 1r. refinamiento.

AP 5.30 (m): Programe la aplicación y verifique su funcionamiento.

diseño y (dpa) programación de algoritmos...

Documents

Transcript of diseño y (dpa) programación de algoritmos...