virtualword
Te invitamos a registrarte para poder acceder a todo el contenido gratuito que esta comunidad provee.

Saludos Wink

Lección 014 a 017: El uso de subprogramas y el pasaje de parámetros.

Ir abajo

Lección 014 a 017: El uso de subprogramas y el pasaje de parámetros.

Mensaje  Kyshuo Ayame el Miér Sep 18, 2013 11:15 am

Estos ejercicios estarán divididos en dos partes. La primera se centrará en el uso de procedimientos y funciones incluyendo los distintos tipos de pasaje de parámetros. La segunda parte se centrará en el alcanse de identificadores. Es conveniente que hagan varios ejercicios de cada parte, aunque no todos.


PRIMERA PARTE: Procedimientos y funciones

Ejercicio 1

Identifiquen los parámetros de entrada (por valor) y de entrada-salida (por referencia) en el siguiente encabezado de procedimiento :

Código:
PROCEDURE Cheque (x, y, z : integer; VAR a, b, c : integer);
Expliquen la diferencia entre un parámetro por valor y uno por referencia.

En la siguiente tabla marquen los parámetros de entrada (los pasados por valor)


  • x
  • y
  • z
  • a
  • b
  • c


=============================================================================

Ejercicio 2

Expliquen la diferencia entre un parámetro formal (o nominales) y un parámetro verdadero (o efectivo).

=============================================================================

Ejercicio 3

Examine el siguiente código:

Código:
PROGRAM . . .
. . .
PROCEDURE Inicio (tiempo, espacio: real; VAR dia: real; signo: char);
. . .
BEGIN
 . . .
    Inicio (3.5, 6.0, hora, Z’);
 . . .
END.
Identifiquen los parámetros formales y los parámetros verdaderos. En la siguiente tabla marquen los parámetros formales.


  • tiempo
  • espacio
  • dia
  • signo
  • 3.5
  • 6.0
  • hora
  • ‘Z’


=============================================================================

Ejercicio 4

Escribir un procedimiento con solo tres parámetros enteros: a, b y c. El efecto del procedimiento debe ser “girar” los valores de los parámetros hacia la derecha de manera que, después de la ejecución, el valor que originalmente estaba en a quede en b, el que estaba en b quede en c y el que estaba en c quede en a.

Ejemplos de entrada:

Código:
4 1 7
-12 6 2
Ejemplos de salida:

Código:
7 4 1
2 -12 6
En la siguiente tabla indiquen las proposiciones verdaderas:


  • Todos los parámetros son variables
  • Todos los parámetros son formales
  • Todos los parámetros son de entrada
  • Hay parámetros formales y verdaderos
  • No hay parámetros de entrada-salida


Probar el procedimiento con un programa que tome a, b y c de la entrada estándar.

=============================================================================

Ejercicio 5

Consideren el siguiente programa :


Código:
PROGRAM alcance (input, output);
VAR tum, num, temp : Integer;

PROCEDURE Prog (a, b : integer; VAR c : integer);
VAR reloj : Integer;
BEGIN
   reloj := a * b;
    reloj := reloj + 1;
    c := reloj + a;
    WriteLn (a, b, c, reloj)
END;
(*Programa principal*)
BEGIN
   tum := 1;
    num := 2;
    Prog (tum, num, temp);
    WriteLn (temp);
    tum := 0;
    num := 1;
    Prog (tum, num, temp);
    WriteLn (temp)
END.

  • Identifiquen la/s variable/s global/es del programa principal.
  • Identifiquen la/s variable/s local/es declarada/s en el procedimiento Prog.
  • Identifiquen los parámetros formales del procedimiento Prog. Determine los parámetros de entrada (por valor) y de salida (por referencia).
  • Determinen los parámetros por valor verdaderos (efectivos) en la primera invocación del procedimiento.
  • Determinen los parámetros por valor verdaderos (efectivos) en la segunda invocación del procedimiento.
  • Determinen la salida estándar del programa. ¿Cuántas líneas se escribirán ?


=============================================================================

Ejercicio 6

Dado el siguiente procedimiento

Código:
PROCEDURE Prueba (x: Real; y: Integer; VAR z: Real);
y las siguientes variables

Código:
VAR tiempo   : Real;
tiempo_i : Integer;
Determinen cuáles de las siguientes invocaciones son correctas. Justifiquen.


    Código:
    Prueba( 1, 2.0, tiempo );
    Código:
    Prueba( tiempo_i, 3, tiempo );
    Código:
    Prueba( tiempo_i, 3, 2.0 );
    Código:
    Prueba( 1, 3, tiempo_i );
    Código:
    Prueba( 5 * tiempo_i, round( 7.3 ), tiempo ); (* tiempo_i ya fue inicializada *)
    Código:
    Prueba( tiempo, 3, tiempo );
    Código:
    Prueba( Prueba( 5, 33.8, tiempo ), 92, tiempo );


¿Cuáles son los errores en las invocaciones incorrectas?

============================================================================

Ejercicio 7

Implementen un subprograma para calcular las raíces de un polinomio de 2do grado. Este tendrá 6 parámetros: 3 para los coeficientes del polinomio (enteros), 2 para las raíces (reales) y uno para la cantidad de raíces halladas (entero). Determinen si corresponde escribir una función o un procedimiento y qué parámetros deben ser pasados por valor y qué parámetros deben ser pasados por referencia.

Escriban un programa completo en Pascal que incluya el subprograma desarrollado en la parte anterior. El programa deberá tomar de la entrada estándar los coeficientes del polinomio y deberá desplegar la cantidad de raíces halladas y sus valores.

=============================================================================

Ejercicio 8

Implementen un procedimiento que dado un arreglo de enteros devuelva el valor más grande y el índice en que éste ocurre. El largo del arreglo es dado por una constante N global al procedimiento.

=============================================================================

Ejercicio 9

Para cada uno de los siguientes problemas, indiquen si la forma más apropiada de expresar la solución es con una función o un procedimiento, justificando brevemente.


  • Dado un número primo, determinar el número primo inmediato más grande.
  • Dado un entero positivo N diferente de cero, determinar el número de factores primos de N y los dos (o menos) factores únicos más grandes.
  • Dado un carácter del conjunto de caracteres ASCII, determinar su posición ordinal en el conjunto de caracteres EBCDIC.
  • Dado un número de años N y una cantidad C que se va a obtener, determinar la tasa mínima de interés anual necesaria para alcanzar C en N años si el interés es compuesto anual, y la tasa de interés anual necesaria para alcanzar C en N años si el interés es compuesto mensual.


============================================================================

Ejercicio 10

Escriban una función llamada conv que convierta un arreglo de caracteres, cada uno de los cuales contiene un dígito decimal, al entero equivalente.
Por ejemplo, si el parámetro de entrada es [ `1′, `2′, `3′ ], entonces el entero resultante será 123. El largo del arreglo es dado por una constante N global a la función.

=============================================================================

Ejercicio 11

Escriban una función llamada magnitud que tenga cuatro parámetros de entrada (por valor) llamados x1, y1, x2 e y2, y retorne la distancia absoluta entre los puntos (x1,y1) y (x2,y2). Todas las variables son de tipo real.

=============================================================================

Ejercicio 12

Escriban una función en Pascal para determinar el área de una figura de cuatro lados, dadas las coordenadas de los vértices de la figura. Utilizar la función de área de triángulos siguiente.


Código:
FUNCTION CalcArea( a, b, c: Real ) : Real;
 (*Calcula el area de un triangulo de lados a, b, c*)
 VAR s         : Real  (* Mitad del perimetro del triangulo*)
    perimetro : Real; (* Perimetro del triangulo*)
 BEGIN
   perimetro := a + b + c;
    s := perimetro / 2;
    (* Calculo del area mediante la formula de Heron *)
    CalcArea := sqrt (s * (s-a) * (s-b) * (s-c))
 END;
======================================================================

Ejercicio 13

Escribir una función en Pascal que indique si un número pasado como argumento es primo. Su firma debe ser:

Código:
FUNCTION EsPrimo( valor: Integer ) : Boolean;    (* Devuelve TRUE si y solo si "valor" es primo *)
======================================================================

Ejercicio 14

Escriban una función booleana llamada Multiplo que tenga dos argumentos enteros m y n. Multiplo debe producir el valor True si m es un múltiplo entero de n, o si n es un múltiplo entero de m. Escriban un programa para probar esta función.

El programa deberá leer una pareja de enteros positivos de cada línea de datos de entrada, invocar a Multiplo, y exhibir el resultado de esta función. La secuencia de enteros finaliza cuando el usuario ingresa el valor -1.

Ejemplo de entrada/salida:

Código:
4 7
Falso

4 8
Verdadero

16 8
Verdadero

-1
=====================================================================

Ejercicio 15

Implementen una función que dados 2 arreglos de caracteres, determine si el primero es prefijo del segundo. Luego reescriban el Ejercicio 4 de la Lección 11 utilizando esta función. En caso de que la cadena más corta pertenezca a la más larga, despliegue en la salida estándar la posición en que comienza la coincidencia. Tomando el primer ejemplo dado en el Ej. 4, la salida sería:

Código:
El texto 'tor' se encuentra dentro del texto 'totora' ( posición de comienzo: 3 ).
En caso de que no haya coincidencia, el mensaje deberá ser el mismo que en el Ej. 4.

======================================================================

Ejercicio 16

Una matriz simétrica a es un arreglo cuadrado bidimensional con la propiedad de que a[i,j] = a[j,i]. Una matriz así se puede almacenar en forma compacta ( en el arreglo ac) ya que basta con almacenar una sola vez los elementos duplicados del arreglo.

En primer término, diseñen un método para almacenar un arreglo de éstos sin repetir los elementos duplicados. Después escriban una función OBTSIM( ac, i, j ) que dé el valor de a[i,j] y un procedimiento ALMASIM( ac, i, j, val ) que almacene val en la posición que corresponda del arreglo compacto ac.

Sugerencia: Basta con almacenar n elementos de la columna n; pensar en un arreglo unidimensional que contiene los elementos de la columna uno, después de la columna dos, y así sucesivamente.

======================================================================

Ejercicio 17

Escriban una función que produzca el factor primo más pequeño de su argumento entero positivo. Escribir un programa principal que use esta función para exhibir los factores primos de los enteros que aparecen en los datos de entrada. La secuencia de enteros termina en 0.
Exhibir los resultados para cada dato en una línea, precedidos por el entero mismo y un signo de igual. Separar los factores primos mediante asteriscos.

Ejemplo de entrada:

Código:
39 42 1517 0
Ejemplo de salida:

Código:
39 = 3 * 13
42 = 2 * 3 * 7
1517 = 37 * 41
****************************************************************************************************************
======================================================================
****************************************************************************************************************

SEGUNDA PARTE: Alcance

Ejercicio 1

Dado el siguiente programa:

Código:
PROGRAM principal (input, output);
VAR a, b : Integer;

   PROCEDURE a1 (VAR x : Real);
   VAR c : char;

      PROCEDURE a2 (y : char);
      VAR d : Integer;
      BEGIN
      . . .
      END;

   BEGIN
   . . .
   END;

   PROCEDURE b1;
   VAR e : Integer;
   BEGIN
   . . .
   END;

BEGIN
. . .
END;
Indiquen las variables a las que se puede hacer referencia dentro del alcance del procedimiento a2, las variables a las que se puede hacer referencia dentro del alcance del procedimiento a1; las que se puede hacer referencia dentro del alcance del procedimiento b1y cuáles procedimientos podría llamar el programa principal.

======================================================================

Ejercicio 2

Determinen la salida del siguiente programa si se obtiene de la entrada estándar el entero 4.

Código:
PROGRAM Ppal (input, output);
VAR x : Integer;

PROCEDURE a (VAR y : Integer);
BEGIN
   y := y * 2;
END;

PROCEDURE b (x : Integer);
BEGIN
   x := x + 5;
END;

BEGIN
   ReadLn (x);
   b (x);
   WriteLn (x);
   a (x);
   WriteLn (x);
END.
El simbolo - representa el salto de línea

Código:
4-8
4-9
9-18
9-8
======================================================================

Ejercicio 3

Dado el siguiente programa

Código:
PROGRAM Alcance (input, output);
VAR num, reloj, temp : Integer;

PROCEDURE pascal (num : Integer; VAR suma : Integer);
VAR reloj : Integer;
BEGIN
   temp := 2 * num + suma;
   reloj := temp * suma;
   num := num + 1;
   suma := suma + num;
   WriteLn (temp, reloj, num, suma);
END;

BEGIN
   num := 1;
   reloj := 0;
   temp := 0;
   pascal (num, temp);
   WriteLn (num, reloj, temp);
   temp := temp + 1;
   pascal (temp, num);
   WriteLn (num, reloj, temp);
END.
a) Determinen la salida del programa Alcance

b) Indiquen cuáles de las siguientes afirmaciones respecto al programa Alcance son verdaderas:


  • El alcance de la variable temp no incluye al procedimiento.
  • El programa principal no puede hacer referencia a la variable local reloj del procedimiento.
  • El procedimiento se podría colocar después del programa principal.
  • La variable local reloj es ilegal, ya que se declaró en el programa principal.
  • El parámetro por referencia suma debe ir antes del parámetro por valor num.


c) Indiquen cuáles de las siguientes afirmaciones acerca del programa Alcance son falsas:


  • El procedimiento puede hacer referencia a la variable global temp.
  • El nombre de procedimiento pascal no es un identificador válido.
  • La variable local llamada reloj es un identificador válido.
  • El alcance de la variable local reloj es el procedimiento.
  • El WriteLn en el programa principal no exhibirá el contenido de la variable local reloj en el procedimiento.
  • El parámetro por valor num en la declaración del procedimiento es un parámetro formal.
  • El parámetro num en la proposición que llama al procedimiento es el parámetro verdadero.
  • El parámetro formal num es una variable local.
  • La variable global num es idéntica al parámetro formal num.
  • El alcance de la variable global num no incluye al procedimiento
.

======================================================================

Ejercicio 4

Determinen la salida del siguiente programa:

Código:
PROGRAM Detectar (input, output);
VAR a, b, c, d : Integer;

PROCEDURE pal (y: Integer; VAR z: Integer);

VAR c : Integer;

BEGIN
   b := y * z;
   c := b + z;
   y := y + 1;
   z := z * (z + 1);
   WriteLn (b:3, c:3, y:3, z:3)
END;

BEGIN
   a := 2;
   c := 3;
   d := 5;
   pal (c, d);
   WriteLn (a:3, b:3, c:3, d:3);
   b := 4;
   pal (b, a);
   WriteLn (a:3, b:3, c:3, d:3)
END.
El simbolo - representa el salto de línea.

Código:
15 20 4 30- 2 15 4 30- 9 10 9 6- 6 9 4 30
15 20 4 30- 2 15 4 5- 9 10 9 6- 2 9 4 5
15 20 4 30- 2 15 3 30- 8 10 5 6- 6 8 3 30
15 20 4 30- 2 15 3 5- 8 10 5 3- 2 8 3 5
=====================================================================

Ejercicio 5

Determinen qué es lo que se exhibe cuando se ejecuta el siguiente programa.

Código:
PROGRAM Final (input, output);
VAR manzanas, bananas, naranjas : Integer;

PROCEDURE grado (a, b : Integer; VAR c : Integer);
VAR manzanas : Integer;
 PROCEDURE que (VAR d : Integer);
 BEGIN
    d := d * 2
 END;
BEGIN
   que (b);
   manzanas := 16;
   que (c)
END;

BEGIN
   manzanas := 2;
   bananas := 3;
   naranjas := 6;
   grado (manzanas, bananas, naranjas);
   WriteLn (manzanas, bananas, naranjas)
END.
Código:
16 3 6
2 6 6
16 3 12
2 3 12
======================================================================

Ejercicio 6

En el esqueleto de programa que se muestra a continuación se incluyen definiciones y declaraciones CONST y VAR abreviadas. Después de cada uno de los tres comentarios que indican la colocación de las proposiciones de los procedimientos y el programa, indiquen cuáles identificadores son alcanzables, lo que representan (constantes o variables), y dónde se declararon (programa x, procedimiento y o z)

(1)

Código:
PROGRAM x;
CONST a, b, c;
VAR d, e, f;
PROCEDURE y;
VAR b, e;
PROCEDURE z;
VAR f, g;
BEGIN
(*Proposiciones del procedimiento z*)
END;
BEGIN
(*Proposiciones del procedimiento y*)
END;
BEGIN
  (*Proposiciones del programa x*)
END.
(2)

Código:
PROGRAM x;
CONST a, b, c;
VAR d, e, f;
PROCEDURE y;
PROCEDURE z;
VAR f, g;
BEGIN
(*Proposiciones del procedimiento z*)
END;
VAR b, e;
BEGIN
(*Proposiciones del procedimiento y*)
END;
BEGIN
  (*Proposiciones del programa x*)
END.
=====================================================================

Ejercicio 7

Indiquen cual sería la salida del siguiente programa suponiendo que como entrada se le proporciona el último dígito de su número de documento de identidad. Por ejemplo, si su número de cédula es el 1.234.567-8, entonces el número que se ingresa es el 7.

Código:
Program Ej1 (input,output);
var z: integer;

function f (y : integer) : boolean;
begin
     z := z + y;
     f := y mod 2 = 0
end;

procedure a (var y : integer);
begin
     y := 2 * y;
end;

procedure b (var z : integer);
begin
     z := z + 5;
end;

begin
     readln(z);
     if f(z) then a(z) else b(z);
     writeln('Salida = ', z)
end.
Dar el resultado para todos los dígitos (0..9)

=====================================================================

Ejercicio 8

Indiquen cual sería la salida del siguiente programa suponiendo que como entrada se le proporciona el último dígito de su número de documento de identidad. Por ejemplo, si su número de cédula es el 1.234.567-8, entonces el número que se ingresa es el 7. El orden de evaluacion de las expresiones numericas depende de cada compilador. En este caso, asuman que ese orden es de izquierda a derecha.

Código:
program jul2002 (input,output);
var z: integer;

function g (var x: integer):integer;
begin
   x := x + 1;
   z := z + 1;
   writeln('Salida en g1:',x + z);
   g := x + z
end;

function f (x: integer; var y: integer): integer;

  function g(x: integer): integer;
  begin
     x := x + 1;
     writeln('Salida en g2:',x + z);
     g := x + z
  end;

begin
   x := x + 1;
   z := z + x - y + 2;
   if x mod 2 = 0 then y := y + 1
   else y := y - 1;
   x := g(x) + y;
   writeln('Salida en f:',x);
  f := x
end;

procedure p (var x,y: integer);
begin
   y := f(x,y) + z;
   y := y + g(x) + x;
   x := x + 1;
   writeln('Salida en p:',y)
end;

begin
   readln(z);
   p(z,z);
   writeln('Salida final:',z + 1);
end.
Dar el resultado para todos los dígitos (0..9)

======================================================================

Navegación:
avatar
Kyshuo Ayame
Admin

Mensajes : 105
Fecha de inscripción : 14/11/2012
Edad : 29

Ver perfil de usuario http://virtualworld.foroargentina.net

Volver arriba Ir abajo

Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.