DFG

Metodologa y Tecnologa la Programacin
Ejercicios: Tema 3
Problema 3.1.
Disear un programa que calcule la tangente de un ngulo, introducido por teclado en grados y la muestre por
la pantalla en notacin decimal, con siete caracteres y dos decimales.
NOTA: Esta versin de tangente de un ngulo en grados utiliza procedimientos, funciones as como paso de
parmetros 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 notacin 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 parmetros 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)
{postcondicin: 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
Precondicin: valor " 90 + k*180 }
const
Pi=3.1416; {Slo es necesaria en esta funcin } var angrad: real; {variable local: ngulo en radianes.
Necesaria slo en esta funcin }
begin { Comienza la funcin TanEnGrados}
{ Conversin de grados a radianes } { Invariante: angRad = valor * pi / 180 }
angrad:=valor * pi / 180;
{ Clculo de la tangente y devolucin del valor }
TanEnGrados:= sin(angRad) / cos (angRad)
{ Postcondicin: TanEnGrados=sin(angRad) /cos(angRad) }
end; {Salida de la funcin y devolucin 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 funcin que calcula la tangente y la devuelve }
{ Precondicin: 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
Disear 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 notacin decimal, con siete caracteres y dos decimales.
2
Esta versin de tangente de un ngulo en grados utiliza procedimientos y funciones, paso de parmetros por
valor y por referencia. Es conveniente que se compare con la versin 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 notacin
decimal, con siete caracteres y dos decimales
1. Lee los grados
3. La expresa por pantalla con el formato que se }
{ Utiliza funciones y procedimientos con parmetros por valor y por referencia }
{Precondicin: angGrad, tan " }
var { variables globales }
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 }
readln(valor) {postcondicin: input = valor }end; {fin de LeeVal }
{ Escribe valor en formato decimal con 7 caracteres y con dos decimales } begin {comienza }
writeln(valor:7:2)
{postcondicin: output = valor }
end; {fin de EscCon2Dec }
{ Recibe un valor que representa el ngulo en grados

Convierte el ngulo a radianes
Calcula la tangente del ngulo y la devuelve
const
pi=3.1416; {Slo es necesaria en esta funcin }
var
angrad: real; {variable local: ngulo en radianes. Necesaria slo en esta funcin }
begin
{ Conversin de grados a radianes
Invariante: angRad = valor * pi / 180 }
{Postcondicin: TanEnGrados=sin(angRad) /cos(angRad) }
end; {Salida de la funcin y devolucin 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.
Sintcticamente es correcta pero puede producir efectos laterales }
{ Precondicin: ngulo <> 90 + k*180 }
{Llamada al procedimiento de escritura del resultado formateado }
{write('El valor es: ',EscCon2Dec(tan)); Error: uso incorrecto de procedimiento }
4

Problema 3.3
Disear un programa que calcule la tangente de un ngulo, introducido por teclado en grados y la muestre por
la pantalla en notacin decimal, con siete caracteres y dos decimales.
Esta versin de tangente de un ngulo en grados utiliza procedimientos, funciones as como paso de
parmetros por valor .
Expone otra forma de resolver el problema de efectos laterales. Define una funcin 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 notacin
decimal, con siete caracteres y dos decimales
1. Lee los grados
3. La expresa por pantalla con el formato que se pide }
{ Utiliza funciones y procedimientos con parmetros por valor }
{Precondicin: angGra, tan " }
var { variables globales }
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 }
readln(valor)
{postcondicin: input = LeeVal }
end; {fin de LeeVal }
{ Escribe valor en formato decimal con 7 caracteres y con dos decimales }

begin {comienza EscCon2Dec }
writeln(valor:7:2) {postcondicin: output = valor }
end; {fin de EscCon2Dec }
{ Recibe un valor que representa el ngulo en grados
Convierte el ngulo a radianes
Calcula la tangente del ngulo y la devuelve
const
Pi=3.1416; {Slo es necesaria en esta funcin } var angrad: real; {variable local: ngulo en radianes.
Necesaria slo en esta funcin }
begin
{ Conversin de grados a radianes
Invariante: angRad = valor * pi / 180 }
{Postcondicin: TanEnGrados=sin(angRad) /cos(angRad) }
end; {Salida de la funcin y devolucin del valor calculado }
begin {Comienzo del programa principal CalculaTangenteGrados }
{ Lectura del valor del ngulo en grados. }
angGra:=LeeVal; { El valor de la funcin LeeVal se asigna a angGra }
{ Precondicin: angGra <> 90 + k*180 }
6
{Llamada al procedimiento de escritura del resultado formateado }

Problema 3.4.
Disear un programa que convierta F, incluidos por teclado en C, y muestre el valor introducido y el
resultado por pantalla en notacin decimal, con quince caracteres y dos decimales.
Esta versin usa procedimientos y cambia los valores de las variables globales en los procedimientos.
program FahrenheitACelsius1 (input,output);
{FahrenheitACelsius Versin 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 }
{Precondicin: [F,C] " ! " F " 459.69 (0 absoluto) " input=F
Postcondicin: output= C }
uses
crt; {Librera donde se encuentra definido el procedimiento clrscr que permite limpiar la pantalla }
var
F,
C:real;
procedure pedir (var tempFahr:real);
{ El parmetro 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)
7
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 }
{Precondicin: tempFahr " 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene ms sentido
postcondicin: 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')
{ postcondicin: output= [tempCels, tempFahr] }
end;
begin { Programa Principal}
{ Inicializacin de variables }
F:=0;
C:=0;
{ Pedir datos por teclado }
pedir (F);
{ OJO Modifica el valor de la variable global puede producir efecto lateral }
{ Conversin }
convertir(F,C);
{ Mostrar datos por pantalla }

mostrar(F,C)
end.
Problema 3.5.
Esta versin usa procedimientos y funciones, y cambia los valores de las variables globales en los
procedimientos.
program FahrenheitACelsius2(input,output); {FahrenheitACelsius Versin 2} { Programa que convierte
grados Fahrenheit en Celsius 1. Pide por pantalla la temperatura en Fahrenheit
Usa Funcin }
{ Precondicin: [F,C] " ! " F " 459.69 (0 absoluto) " input=[F]
uses
var
F,
C:real;
procedure pedir (var tempFahr:real);
{ El parmetro 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;
9
{ El parmetro se pasa por valor ,no va a cambiar su valor }

{ Precondicin: tempFahr " 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene ms sentido
Postcondicin: tempCels = (5/9) * (tempFahr 32.0) }
begin
convertir:=(5/9) * (tempFahr 32.0);
end;
{ Los dos parmetros 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}
F:=0;
C:=0;
pedir (F);
{ Conversin }
C:=convertir(f);
mostrar(F,C)
end.
Problema 3.6.
10
Esta versin usa procedimientos y variables globales en los procedimientos.

program FahrenheitACelsius3(input,output);
Usa Procedimiento, pero MUCHO CUIDADO con la forma de los parmetros}
Postcondicin: output= [C] }
uses
var
F,
C:real;
procedure pedir (tempFahr:real);
{ OJO con la forma de paso de parmetro}
begin
clrscr;
write('Escribe La temperatura en Fahrenheit MAYOR QUE 459.69 ');
readln (tempFahr)
end;
procedure convertir(tempFahr:real; tempCels:real);
Postcondicin: tempCels = (5/9) * (tempFahr 32.0) }
{OJO con la forma y resultado de paso de parmetro}
11
begin
tempCels:=(5/9) * (tempFahr 32.0);
end;
begin
clrscr;
writeln ('La temperatura en Fahrenjait es: ',tempFahr:15:2, 'F');
end;
F:=0;
C:=0;
pedir (F);
{ Conversin }
convertir(F,C);
mostrar(F,C)
end.
Problema 3.6.
Esta versin usa funcin y variables globales en procedimientos y funciones
12

Usa Funcin
Usa Variables Globales en Procedimientos y Funciones }
Postcondicin: 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;
{Precondicin: tempFahr " 459.69 (0 absoluto) aunque no es obligatorio, parece que tiene ms sentido
postcondicin: tempCels = (5/9) * (tempFahr 32.0) }
begin
convertir:=(5/9) * (F 32.0);
end;
procedure mostrar;
13
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;
F:=0;
C:=0;
pedir;
{ Conversin }
c:=convertir;
mostrar
{ Este programa no respeta el principio de autonoma de subprogramas. Los subprogramas dependen de las
variables globales. }
end.
Problema 3.7.
Esta versin usa funciones y procedimientos, evitando los parmetros por referencia, e independizando los
procedimientos y funciones.
Se consigue tambin que cada procedimiento y funcin tenga nicamente los parmetros que necesita y no
ms, ni menos. Estudia esta versin y compralas con las otras.
{FahrenheitACelsius Versin5}
14

Usa Procedimiento y Funciones }
{ Precondicin: [F,C] " ! " F " 459.69 (0 absoluto) " input=F
uses
var
tempFahr,
tempCels:real;
function TFahren: real;
{ La funcin 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 funcin convierte la temperatura de F a C, y devuelve la temperatura en C
tempFahr es parmetro de entrada, no cambia de valor,
15
Postcondicin: TCelsiu = (5/9) * (tempFahr 32.0) }

begin
TCelsiu:=(5/9) * (tempFahr 32.0);
end;
procedure Mostrar(tempFahr,tempCels:real);
{ Los parmetros 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');
{ Postcondicin: output= [tempCels, tempFahr }
end;
begin { Comienza el Programa Principal de Convertir a Faherenheit }
tempFahr:=0;
tempCels:=0;
temFahr:= TFahren; { La asignacion a tempFahr se produce en el programa principal }
{ Conversin }
tempCels:=TCelsiu(tempFahr); { tempCels recoge el valor que calcula TCelsiu }
Mostrar(tempFahr,tempCels)
end. { Finaliza el Programa Principal de Convertir a Faherenheit }
Problema 3.8.
Disear un programa que convierta encripte un nmero entero introducido por el teclado.
16
program EncriptaCodigo (input, output);

{versin 2: Utiliza subprogramas anidados}
{ Este programa encripta un nmero entero positivo: Para ello:
1. Pide que se introduzca el nmero por teclado
2. Calcula el encriptado del numero que se ha introducido. Para ello:
2.1 Aplica la frmula 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 divisin entera de NE
y 256
3. Muestra por pantalla el carcter resultante de la encriptacinn }
{ Precondiciones: input = n, n pertenece a Z+
Invariante: c=asc( k *(1+sqr(n)) mod 256)
Postcondicin 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
{Obtencin de datos}
write('Introduce un nmero positivo: ');
readln (num);
writeln (' COMPRUEBA EL RESULTADO ');
writeln ('El nmero introducido es: ',num);
17
writeln ('Pulsa <enter> para seguir ');

readln;
LeeNum:=num
end;
function Encriptado (num:integer):char;
{Clculo del nmero encriptado}
const
NAscii=256; { Slo se utiliza en esta funcin }
{Funcin anidada que calcula el valor reducido de un nmero slo se utiliza para la encriptacin }
function NumRed (num:integer):integer;
const K=23; {Slo se utiliza en esta funcin}
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 nmero escrito es: ', num:8);
writeln('El caracter que lo encripta es:', car:3)
end;
begin { comienza el programa EncriptaCodigo}
{Lectura del Nmero}
18
num:=LeeNum;
{Encripta el Nmero}
car:=Encriptado(num);
{Muestra entrada y salida}
MosEntSal(num,car);
end.
Problema 3.9.
Disear un subprograma documentado, que admita dos valores reales y los devuelva cambiados. Utiliza el
subprograma en un programa,tambin 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 subprogramacin }
uses crt; {en la Librera Standard de Pascal}
var {variables globales}
x,y:real;
procedure EntDatos (var x,y:real);
{Precondicin: [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);
19
write('Escribe el valor real de Y: ');

readln (y)
end;
procedure Confirma (x,y:real);
{Precondicin: [x,y] pertenecen a R}
{Postcondicin: output=[x,y]}
begin {Confirmacin 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);
{Precondicin: [x,y] pertenecen a R y x=m e y=n}
{Postcondicin: 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);
{Precondicin: [x,y] pertenecen a R y x=n e y=m}
{Postcondicion: output=[x,y]}
20
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}
{Slo 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.
Disear 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 propsito de ste y de cada
subprograma. Incluye igualmente las precondiciones y postcondiciones de cada subprograma.
program Maximo3 (input,output);
{Calcula el mximo de 3 enteros introducidos por teclado
1. Recoge los datos del teclado
2. Calcula el mximo de los tres
3. Muestra por pantalla el mximo }
var
N1,N2,N3,
Maximo:integer;
21
procedure TomaDatos(VAR x,y,z:integer);

{Toma los datos por teclado y los comprueba}
{Precondicin: [x,y,z] " R
Postcondicin: 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 Includos son: ',x:5,y:5,z:5);
readln;
end; {De Compruebadatos}
begin {De TomaDatos}
write('Introduce N1: ');
readln(x);
readln(y);
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
22
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
Metodologa y Tecnologa de la Programacin
23

DFG

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

DFG

Uploaded by

Copyright:

Available Formats

Metodologa y Tecnologa la Programacin

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

{ Recibe un valor que representa el ngulo en grados

end. {Fin del programa CalculaTangenteGrados }

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

{Llamada al procedimiento de escritura del resultado formateado }

{ Mostrar datos por pantalla }

{ El parmetro se pasa por valor ,no va a cambiar su valor }

Esta versin usa procedimientos y variables globales en los procedimientos.

1. Pide por pantalla la temperatura en Fahrenheit

1. Pide por pantalla la temperatura en Fahrenheit

Postcondicin: TCelsiu = (5/9) * (tempFahr 32.0) }

program EncriptaCodigo (input, output);

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

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

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

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

You might also like