Metodología: Subprogramas

Procedimientos. Funciones

  • Enviado por: Cesar Sanchez
  • Idioma: castellano
  • País: España España
  • 20 páginas
publicidad

Metodología y Tecnología la Programación

Ejercicios: Tema 3

Problema 3.1.

Diseñar un programa que calcule la tangente de un ángulo, introducido por teclado en grados y la muestre por la pantalla en notación decimal, con siete caracteres y dos decimales.

NOTA: Esta versión de tangente de un ángulo en grados utiliza procedimientos, funciones así como paso de parámetros por valor.

program CalculaTangenteGrados1 (input,otutput); { El programa calcula la tangente de un  ángulo, introducido por teclado en grados y la muestra por la pantalla en notación decimal, con siete caracteres y dos decimales

1.- Lee los grados

2.- Calcula la tangente

3.- La expresa por pantalla con el formato que se pide }

{ Utiliza funciones y procedimientos con parámetros por valor }

{ Precondicion: [angGrad, tan] " R " input=angGrad }

{ variables globales }

var

angGra, {ángulo en grados }

tan: real; {su tangente }

procedure EscCon2Dec(valor:real);

{ Escribe valor en formato decimal con 7 caracteres y con dos decimales }

begin {comienza el procedimiento}

write('El valor de la tangente es: ');

writeln(valor:7:2)

{postcondición: output =[valor] }

end; {fin de }

function TanEnGrados(valor:real): real;

{ 1.- Recibe un valor que representa el  ángulo en grados

2.- Convierte el  ángulo a radianes

3.- Calcula la tangente del  ángulo y la devuelve

Precondición: valor " 90 + k*180 }

const

Pi=3.1416; {Sólo es necesaria en esta función } var angrad: real; {variable local: ángulo en radianes. Necesaria sólo en esta función }

begin { Comienza la función TanEnGrados}

{ Conversión de grados a radianes } { Invariante: angRad = valor * pi / 180 }

angrad:=valor * pi / 180;

{ Cálculo de la tangente y devolución del valor }

TanEnGrados:= sin(angRad) / cos (angRad)

{ Postcondición: TanEnGrados=sin(angRad) /cos(angRad) }

end; {Salida de la función y devolución del valor calculado }

begin {Comienzo del programa pricipal CalculaTangenteGrados }

{ Lectura del valor del ángulo en grados }

write ('Escribe el  ángulo en grados ( ángulo<>90+k*180): ');

readln(angGra);

{ Llamada a la función que calcula la tangente y la devuelve }

{ Precondición:  ángulo <> 90 + k*180 }

tan:=TanEnGrados(angGra);

{Llamada al procedimiento de escritura del resultado } {write('El valor es: ',EscCon2Dec(t)); OJO Error: uso incorrecto de procedimiento }

EscCon2Dec(tan); {Llamada al Procedimiento }

end. {Fin del programa CalculaTangenteGrados }

Problema 3.2

Diseñar y codificar en PASCAL un programa que calcule la tangente de un ángulo, introducido por teclado en grados y la muestre por la pantalla en notación decimal, con siete caracteres y dos decimales.

Esta versión de tangente de un ángulo en grados utiliza procedimientos y funciones, paso de parámetros por valor y por referencia. Es conveniente que se compare con la versión anterior y siguientes.

program CalculaTangenteGrados2 (input,otutput);

{ Este programa calcula la tangente de un  ángulo, introducido por teclado en grados y la muestra por la pantalla en notación

decimal, con siete caracteres y dos decimales

1.- Lee los grados

2.- Calcula la tangente

3.- La expresa por pantalla con el formato que se }

{ Utiliza funciones y procedimientos con parámetros por valor y por referencia }

{Precondición: angGrad, tan " }

var { variables globales }

angGra, {ángulo en grados }

tan: real; {su tangente }

procedure LeeVal(var valor:real);

{ recoge el valor del  ángulo por teclado y asigna el valor del  ángulo a la variable local valor

NOTA: Esto puede dar lugar a efectos laterales }

begin {comienzo de LeeVal }

write ('Escribe el  ángulo en grados ( ángulo<>90+k*180): ');

readln(valor) {postcondición: input = valor }end; {fin de LeeVal }

procedure EscCon2Dec(valor:real);

{ Escribe valor en formato decimal con 7 caracteres y con dos decimales } begin {comienza }

write('El valor de la tangente es: ');

writeln(valor:7:2)

{postcondición: output = valor }

end; {fin de EscCon2Dec }

function TanEnGrados(valor:real): real;

{ Recibe un valor que representa el  ángulo en grados

Convierte el  ángulo a radianes

Calcula la tangente del  ángulo y la devuelve

Precondición: valor " 90 + k*180 }

const

pi=3.1416; {Sólo es necesaria en esta función }

var

angrad: real; {variable local: ángulo en radianes. Necesaria sólo en esta función }

begin

{ Conversión de grados a radianes

Invariante: angRad = valor * pi / 180 }

angrad:=valor * pi / 180;

{ Cálculo de la tangente y devolución del valor }

TanEnGrados:= sin(angRad) / cos (angRad)

{Postcondición: TanEnGrados=sin(angRad) /cos(angRad) }

end; {Salida de la función y devolución del valor }

begin {Comienzo del programa principal CalculaTangenteGrados}

{ Lectura del valor del ángulo en grados. }

LeeVal(angGra); { esta llamada pasa angGrad por referencia, por lo que el procedimiento puede cambiar su valor.

Sintácticamente es correcta pero puede producir efectos laterales }

{ Llamada a la función que calcula la tangente y la devuelve }

{ Precondición:  ángulo <> 90 + k*180 }

tan:=TanEnGrados(angGra);

{Llamada al procedimiento de escritura del resultado formateado }

{write('El valor es: ',EscCon2Dec(tan)); Error: uso incorrecto de procedimiento }

EscCon2Dec(tan); {Llamada al Procedimiento }

end. {Fin del programa CalculaTangenteGrados }

Problema 3.3

Diseñar un programa que calcule la tangente de un ángulo, introducido por teclado en grados y la muestre por la pantalla en notación decimal, con siete caracteres y dos decimales.

Esta versión de tangente de un ángulo en grados utiliza procedimientos, funciones así como paso de parámetros por valor .

Expone otra forma de resolver el problema de efectos laterales. Define una función que se encarga de la lectura.

program CalculaTangenteGrados3(input,otutput);{ Este programa calcula la tangente de un  ángulo, introducido por teclado en grados y la muestra por la pantalla en notación

decimal, con siete caracteres y dos decimales

1.- Lee los grados

2.- Calcula la tangente

3.- La expresa por pantalla con el formato que se pide }

{ Utiliza funciones y procedimientos con parámetros por valor }

{Precondición: angGra, tan " }

var { variables globales }

angGra, {ángulo en grados }

tan: real; {su tangente }

function LeeVal:real;

{ recoge el valor del  ángulo por teclado y asigna el valor del  ángulo a la variable local valor }

var

valor:real; begin {comienzo de LeeVal }

write ('Escribe el  ángulo en grados ( ángulo<>90+k*180): ');

readln(valor)

{postcondición: input = LeeVal }

end; {fin de LeeVal }

procedure EscCon2Dec(valor:real);

{ Escribe valor en formato decimal con 7 caracteres y con dos decimales }

begin {comienza EscCon2Dec }

write('El valor de la tangente es: ');

writeln(valor:7:2) {postcondición: output = valor }

end; {fin de EscCon2Dec }

function TanEnGrados(valor:real): real;

{ Recibe un valor que representa el  ángulo en grados

Convierte el  ángulo a radianes

Calcula la tangente del  ángulo y la devuelve

Precondición: valor " 90 + k*180 }

const

Pi=3.1416; {Sólo es necesaria en esta función } var angrad: real; {variable local: ángulo en radianes. Necesaria sólo en esta función }

begin

{ Conversión de grados a radianes

Invariante: angRad = valor * pi / 180 }

angrad:=valor * pi / 180;

{ Cálculo de la tangente y devolución del valor }

TanEnGrados:= sin(angRad) / cos (angRad)

{Postcondición: TanEnGrados=sin(angRad) /cos(angRad) }

end; {Salida de la función y devolución del valor calculado }

begin {Comienzo del programa principal CalculaTangenteGrados }

{ Lectura del valor del ángulo en grados. }

angGra:=LeeVal; { El valor de la función LeeVal se asigna a angGra }

{ Llamada a la función que calcula la tangente y la devuelve }

{ Precondición:  angGra <> 90 + k*180 }

tan:=TanEnGrados(angGra);

{Llamada al procedimiento de escritura del resultado formateado }

EscCon2Dec(tan); {Llamada al Procedimiento }

end. {Fin del programa CalculaTangenteGrados }

Problema 3.4.

Diseñar un programa que convierta º F, incluidos por teclado en º C, y muestre el valor introducido y el resultado por pantalla en notación decimal, con quince caracteres y dos decimales.

Esta versión usa procedimientos y cambia los valores de las variables globales en los procedimientos.

program FahrenheitACelsius1 (input,output);

{FahrenheitACelsius Versión 1}

{ Programa que convierte grados Fahrenheit en Celsius

1.- Pide por pantalla la temperatura en Fahrenheit

2.- Convierte la temperatura de Fahrenheit a Celsius

3.- Muestra el resultado por pantalla

Usa Procedimientos }

{Precondición: [F,C] " ! " F " - 459.69 (0 absoluto) " input=F

Postcondición: output= C }

uses

crt; {Librería donde se encuentra definido el procedimiento clrscr que permite limpiar la pantalla }

var

F,

C:real;

procedure pedir (var tempFahr:real);

{ El parámetro cambiar de valor y se pasa por referencia pero puede producir efectos laterales }

begin

clrscr;

write('Escribe La temperatura en Fahrenheit MAYOR QUE - 459.69 ');

readln (tempFahr)

end;

procedure convertir(tempFahr:real; var tempCels:real);

{ El procedimiento convierte la temperatura de ºF a ºC, y devuelve por referencia la temperatura en ºC

tempFahr es de entrada, no cambia de valor,

tempCels si cambiar el valor cuando sale se define por referencia }

{Precondición: tempFahr "- 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene más sentido

postcondición: tempCels = (5/9) * (tempFahr - 32.0) }

begin

tempCels:=(5/9) * (tempFahr - 32.0)

end;

procedure mostrar(tempFahr,tempCels:real);

begin

clrscr;

writeln ('La temperatura en Fahrenheit es: ',tempFahr:15:2, 'ºF');

writeln ('La temperatura en Celsius es: ',tempCels:15:2, 'ºC')

{ postcondición: output= [tempCels, tempFahr] }

end;

begin { Programa Principal}

{ Inicialización de variables }

F:=0;

C:=0;

{ Pedir datos por teclado }

pedir (F);

{ OJO Modifica el valor de la variable global puede producir efecto lateral }

{ Conversión }

convertir(F,C);

{ Mostrar datos por pantalla }

mostrar(F,C)

end.

Problema 3.5.

Diseñar un programa que convierta º F, incluidos por teclado en º C, y muestre el valor introducido y el resultado por pantalla en notación decimal, con quince caracteres y dos decimales.

Esta versión usa procedimientos y funciones, y cambia los valores de las variables globales en los procedimientos.

program FahrenheitACelsius2(input,output); {FahrenheitACelsius Versión 2} { Programa que convierte grados Fahrenheit en Celsius 1.- Pide por pantalla la temperatura en Fahrenheit

2.- Convierte la temperatura de Fahrenheit a Celsius

3.- Muestra el resultado por pantalla

Usa Función }

{ Precondición: [F,C] " ! " F " - 459.69 (0 absoluto) " input=[F]

Postcondición: output= C }

uses

crt; {Librería donde se encuentra definido el procedimiento clrscr que permite limpiar la pantalla }

var

F,

C:real;

procedure pedir (var tempFahr:real);

{ El parámetro se pasa por referencia y devuelve el valor cambiado. Puede producir efectos laterales}

begin

clrscr;

write('Escribe La temperatura en Fahrenheit (MAYOR QUE - 459.69): ');

readln (tempFahr)

end;

function convertir(tempFahr:real):real;

{ El parámetro se pasa por valor ,no va a cambiar su valor }

{ Precondición: tempFahr "- 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene más sentido

Postcondición: tempCels = (5/9) * (tempFahr - 32.0) }

begin

convertir:=(5/9) * (tempFahr - 32.0);

end;

procedure mostrar(tempFahr,tempCels:real);

{ Los dos parámetros se pasan por valor y ninguno cambia su valor}

begin

clrscr;

writeln ('La temperatura en Fahrenheit es: ':45,tempFahr:15:2, ' ºF');

writeln ('La temperatura en Celsius es: ':45,tempCels:15:2, ' ºC');

end;

begin {Programa Principal}

{ Inicializaci¢n de variables }

F:=0;

C:=0;

{ Pedir datos por teclado }

pedir (F);

{ Conversión }

C:=convertir(f);

{ Mostrar datos por pantalla }

mostrar(F,C)

end.

Problema 3.6.

Diseñar un programa que convierta º F, incluidos por teclado en º C, y muestre el valor introducido y el resultado por pantalla en notación decimal, con quince caracteres y dos decimales.

Esta versión usa procedimientos y variables globales en los procedimientos.

program FahrenheitACelsius3(input,output);

{FahrenheitACelsius Versión 3}

{ Programa que convierte grados Fahrenheit en Celsius

1.- Pide por pantalla la temperatura en Fahrenheit

2.- Convierte la temperatura de Fahrenheit a Celsius

3.- Muestra el resultado por pantalla

Usa Procedimiento, pero MUCHO CUIDADO con la forma de los parámetros}

{ Precondición: [F,C] " ! " F " - 459.69 (0 absoluto) " input=[F]

Postcondición: output= [C] }

uses

crt; {Librería donde se encuentra definido el procedimiento clrscr que permite limpiar la pantalla }

var

F,

C:real;

procedure pedir (tempFahr:real);

{ OJO con la forma de paso de parámetro}

begin

clrscr;

write('Escribe La temperatura en Fahrenheit MAYOR QUE - 459.69 ');

readln (tempFahr)

end;

procedure convertir(tempFahr:real; tempCels:real);

{ Precondición: tempFahr "- 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene más sentido

Postcondición: tempCels = (5/9) * (tempFahr - 32.0) }

{OJO con la forma y resultado de paso de parámetro}

begin

tempCels:=(5/9) * (tempFahr - 32.0);

end;

procedure mostrar(tempFahr,tempCels:real);

begin

clrscr;

writeln ('La temperatura en Fahrenjait es: ',tempFahr:15:2, 'ºF');

writeln ('La temperatura en Celsius es: ',tempCels:15:2, 'ºC')

end;

begin { Programa Principal}

{ Inicialización de variables }

F:=0;

C:=0;

{ Pedir datos por teclado }

pedir (F);

{ Conversión }

convertir(F,C);

{ Mostrar datos por pantalla }

mostrar(F,C)

end.

Problema 3.6.

Diseñar un programa que convierta º F, incluidos por teclado en º C, y muestre el valor introducido y el resultado por pantalla en notación decimal, con quince caracteres y dos decimales.

Esta versión usa función y variables globales en procedimientos y funciones

program FahrenheitACelsius4 (input,output);

{FahrenheitACelsius Versión 4}

{ Programa que convierte grados Fahrenheit en Celsius

1.- Pide por pantalla la temperatura en Fahrenheit

2.- Convierte la temperatura de Fahrenheit a Celsius

3.- Muestra el resultado por pantalla

Usa Función

Usa Variables Globales en Procedimientos y Funciones }

{ Precondición: [F,C] " ! " F " - 459.69 (0 absoluto) " input=[F]

Postcondición: output=[ C] }

uses

crt; {Libreria donde se encuentra definido el procedimiento clrscr

que permite limpiar la pantalla }

var

F,

C:real;

procedure pedir;

begin

clrscr;

write('Escribe La temperatura en Fahrenheit (MAYOR QUE - 459.69): ');

readln (F)

end;

function convertir:real;

{Precondición: tempFahr "- 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene más sentido

postcondición: tempCels = (5/9) * (tempFahr - 32.0) }

begin

convertir:=(5/9) * (F - 32.0);

end;

procedure mostrar;

begin

clrscr;

writeln ('La temperatura en Fahrenheit es: ':45,F:15:2, ' ºF');

writeln ('La temperatura en Celsius es: ':45,C:15:2, ' ºC');

end;

begin { Programa Principal}

{ Inicialización de variables }

F:=0;

C:=0;

{ Pedir datos por teclado }

pedir;

{ Conversión }

c:=convertir;

{ Mostrar datos por pantalla }

mostrar

{ Este programa no respeta el principio de autonomía de subprogramas. Los subprogramas dependen de las variables globales. }

end.

Problema 3.7.

Diseñar un programa que convierta º F, incluidos por teclado en º C, y muestre el valor introducido y el resultado por pantalla en notación decimal, con quince caracteres y dos decimales.

Esta versión usa funciones y procedimientos, evitando los parámetros por referencia, e independizando los procedimientos y funciones.

Se consigue también que cada procedimiento y función tenga únicamente los parámetros que necesita y no más, ni menos. Estudia esta versión y compáralas con las otras.

program FahrenheitACelsius5 (input,output);

{FahrenheitACelsius Versión5}

{ Programa que convierte grados Fahrenheit en Celsius

1.- Pide por pantalla la temperatura en Fahrenheit

2.- Convierte la temperatura de Fahrenheit a Celsius

3.- Muestra el resultado por pantalla

Usa Procedimiento y Funciones }

{ Precondición: [F,C] " ! " F " - 459.69 (0 absoluto) " input=F

Postcondición: output= C }

uses

crt; {Librería donde se encuentra definido el procedimiento clrscr que permite limpiar la pantalla }

var

tempFahr,

tempCels:real;

function TFahren: real;

{ La función retorna un valor real y es independiente del programa principal }

var

tempFahr:real; { Esta variable local anula la variable global con el mismo identificador }

begin

clrscr;

write('Escribe una temperatura en Fahrenheit MAYOR QUE - 459.69 ');

readln (tempFahr);

write('La temperatura escrita es: ', tempFahr:10:2);

TFahrern:=tempFahr

end;

function TCelsiu(tempFahr:real):real;

{ La función convierte la temperatura de ºF a ºC, y devuelve la temperatura en ºC

tempFahr es parámetro de entrada, no cambia de valor,

{ Precondición: tempFahr "- 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene más sentido

Postcondición: TCelsiu = (5/9) * (tempFahr - 32.0) }

begin

TCelsiu:=(5/9) * (tempFahr - 32.0);

end;

procedure Mostrar(tempFahr,tempCels:real);

{ Los parámetros del procedimiento son variables locales del procedimiento, anulan a los identificadores de

las variables globales}

begin

clrscr;

writeln ('La temperatura en Fahrenjait es: ',tempFahr:15:2, 'ºF');

writeln ('La temperatura en Celsius es: ',tempCels:15:2, 'ºC')

{ Postcondición: output= [tempCels, tempFahr }

end;

begin { Comienza el Programa Principal de Convertir a Faherenheit }

{ Inicialización de variables }

tempFahr:=0;

tempCels:=0;

{ Pedir datos por teclado }

temFahr:= TFahren; { La asignacion a tempFahr se produce en el programa principal }

{ Conversión }

tempCels:=TCelsiu(tempFahr); { tempCels recoge el valor que calcula TCelsiu }

{ Mostrar datos por pantalla }

Mostrar(tempFahr,tempCels)

end. { Finaliza el Programa Principal de Convertir a Faherenheit }

Problema 3.8.

Diseñar un programa que convierta encripte un número entero introducido por el teclado.

program EncriptaCodigo (input, output);

{versión 2: Utiliza subprogramas anidados}

{ Este programa encripta un número entero positivo: Para ello:

1.- Pide que se introduzca el número por teclado

2.- Calcula el encriptado del numero que se ha introducido. Para ello:

2.1 Aplica la fórmula NE = K * (1 + N2), donde K = 23

2.2 Encripta NE. Para ello

2.2.1 Recoge el resultado NE

2.2.2 Devuelve el caracter ASCII de la división entera de NE

y 256

3.- Muestra por pantalla el carácter resultante de la encriptaciónn }

{ Precondiciones: input = n, n pertenece a Z+

Invariante: c=asc( k *(1+sqr(n)) mod 256)

Postcondici¢n c <- asc( k *(1+sqr(n)) mod 256 " output= c }

var

num:integer;

car:char;

function LeeNum:integer;

var

num:integer; {este num local anula el num global }

begin

{Obtención de datos}

write('Introduce un número positivo: ');

readln (num);

writeln ('----------- COMPRUEBA EL RESULTADO ---------');

writeln ('El número introducido es: ',num);

writeln ('Pulsa <enter> para seguir ');

readln;

LeeNum:=num

end;

function Encriptado (num:integer):char;

{Cálculo del número encriptado}

const

NAscii=256; { Sólo se utiliza en esta función }

{Función anidada que calcula el valor reducido de un número sólo se utiliza para la encriptación }

function NumRed (num:integer):integer;

const K=23; {Sólo se utiliza en esta función}

begin { De NumRed }

NumRed:=(K*(1+sqr(num)))

end; { De NumRed }

begin {De Encriptado}

Encriptado:=char (NumRed(num) mod NASCII)

end; {De Encriptado}

procedure MosEntSal(num:integer;car:char);

begin

{ Escritura de Resutados}

writeln(' ------ RESULTADOS ------');

writeln('El n£mero escrito es: ', num:8);

writeln('El caracter que lo encripta es:', car:3)

end;

begin { comienza el programa EncriptaCodigo}

{Lectura del Número}

num:=LeeNum;

{Encripta el Número}

car:=Encriptado(num);

{Muestra entrada y salida}

MosEntSal(num,car);

end.

Problema 3.9.

Diseñar un subprograma documentado, que admita dos valores reales y los devuelva cambiados. Utiliza el subprograma en un programa,también documentado, que solicite los dos reales por teclado y los presente en pantalla una vez intercambiados.

program Intercambio (input,output);

{El programa intercambia el valor de dos variables

reales que entran previamente por teclado, y

muestra en pantalla los valores de entrada intercambiados

1.- Entrada de datos por teclado

2-. Intercambio de valores

3.- Salida por pantalla del resultado

Ahora utilizamos subprogramación }

uses crt; {en la Librería Standard de Pascal}

var {variables globales}

x,y:real;

procedure EntDatos (var x,y:real);

{Precondici¢n: [x,y] pertenecen a R}

{Postcondicion: input=[m,n] y x=m e y=n}

begin

write('Escribe el valor real de X: ');

readln (x);

write('Escribe el valor real de Y: ');

readln (y)

end;

procedure Confirma (x,y:real);

{Precondición: [x,y] pertenecen a R}

{Postcondición: output=[x,y]}

begin {Confirmación de datos}

gotoxy(1,5); {Posiciona el cursor en la fila 5 columna 1 de la pantalla}

writeln (' Has escrito los siguientes datos');

writeln (' X= ',x:7:2);

writeln (' Y= ',y:7:2);

readln;

end; {de Confirma}

procedure Intercambia (var x,y:real);

{Precondici¢n: [x,y] pertenecen a R y x=m e y=n}

{Postcondici¢n: x=n e y=m}

var

aux:real; {local}

begin {Intercambio de valores}

aux:=x;

x:=y;

y:=aux;

end; {de Intercambia}

procedure Mostrar(x,y:real);

{Precondici¢n: [x,y] pertenecen a R y x=n e y=m}

{Postcondicion: output=[x,y]}

begin

{Resultados por Pantalla}

writeln (' Los valores ahora valen: ');

writeln (' X= ',x:7:2);

writeln (' Y= ',y:7:2)

readln;

end; {de Mostrar}

begin {Programa Principal}

{Sólo llamadas a subprogramas}

ClrScr; {Borra Pantalla}

EntDatos(x,y);

Confirma (x,y);

Intercambia(x,y);

Mostrar(x,y)

end. {Del Programa Principal}

Problema 3.10.

Diseñar un programa utilizando subprogramacion, y sin utilizar estructuras de control, que acepte tres valores enteros y devuelva el mayor de ellos. Documenta el programa incluyendo el propósito de éste y de cada subprograma. Incluye igualmente las precondiciones y postcondiciones de cada subprograma.

program Maximo3 (input,output);

{Calcula el máximo de 3 enteros introducidos por teclado

1.- Recoge los datos del teclado

2.- Calcula el máximo de los tres

3.- Muestra por pantalla el máximo }

var

N1,N2,N3,

Maximo:integer;

procedure TomaDatos(VAR x,y,z:integer);

{Toma los datos por teclado y los comprueba}

{Precondición: [x,y,z] " R

Postcondición: Input=[a,b,c] , x=a, y=b z=c}

procedure CompruebaDatos(x,y,z:integer);

{Precondicion: [x,y,z] pertenecen a R

Inveriante: x=a, y=b, z=c

{Postcondicion: output=[x,y,z] }

begin {De CompruebaDatos}

writeln ('Los datos Inclu¡dos son: ',x:5,y:5,z:5);

readln;

end; {De Compruebadatos}

begin {De TomaDatos}

write('Introduce N1: ');

readln(x);

write('Introduce N2: ');

readln(y);

write('Introduce N3: ');

readln(z);

CompruebaDatos(x,y,z);

end; {De TomaDatos}

procedure MuestraResultado (x:integer);

{Precondicion: x pertenece a R

Invariante: x=Maximo

Postcondicion: Output=x}

begin

writeln ('El Maximo es: ',x);

readln;

end;

function Max2(x,y:integer):integer;

{Precondicion: x,y pertenece a R

Postcondicion: Max2=ord(x>y)*x + ord(x<y)*y}

begin

Max2:=ord(x>=y)*x + ord(x<y)*y

end;

function Max3(x,y,z:integer):integer;

{Precondicion: x,y,z pertenece a R

Postcondicion: Max3=Max2(x,Max2(y,z)); }

begin

Max3:=Max2(x,Max2(y,z));

end;

begin {Programa Principal Maximo3}

TomaDatos(N1,N2,N3);

Maximo:= Max3(N1,N2,N3);

MuestraResultado(Maximo);

end. {del Programa Principal}

Problemas Tema 3: Subprogramas

1

20

Metodología y Tecnología de la Programación