Lección 021: Complemento de arreglos y registros.

A continuación les expongo varios ejercicios, todos diseñados por docentes de Facultad de Ingeniería. Todos los ejercicios pueden y deben ser resueltos con lo visto hasta el momento. La información que yo les he dado en este curso resulta incluso mucho más completa que la que dan los profesores en las clases ya que ellos apuntan a que los estudiantes investiguen lo que no conocen y se las arreglen solos en muchos casos, usando clases de consulta como apoyo a las dudas.

Muchos ejercicios son de gran dificultad, identificaré las dificultades de cada ejercicio con colores: Verde (dificultad baja), Amarillo (Dificultad Media), Naranja (Dificultad Media Alta), Rojo (Dificultad Alta).

Algunos ejercicios apuntan, además de a la programación en sí, al uso de conocimientos matemáticos que no se imparten aquí, por lo cual simplemente aclararé para esos casos que se requiere el conocimiento matemático y ustedes decidirán si lo tienen o no para realizar el ejercicio.

Fuera de todos aquellos que requieren matemática, usedes deben ser capaces de resolver estos problemas. Recuerden que la mejor herramienta para la programación es la práctica. Si no trabajan mucho con estas cosas no llegarán a nada, y tratar de avanzar para ver que viene pero dejando cosas en el camino no servirá de nada. ¡¡¡Adelante!!!

======================================================================
Ejercicio 1: Examinen la siguiente declaración :

Código:

CONST
  CANT_PERS = 100;
  MAX_CADENA = 30;

TYPE
  Cadena = RECORD
      letras : ARRAY[1..MAX_CADENA] OF CHAR;
      largo : 0..MAX_CADENA;
  END;

  Persona = RECORD
      nombre : Cadena;
      edad : 0..120;
      estado : (casado, soltero, divorciado);
      salario : REAL;
      exenciones : 0..MAXINT;
  END;

VAR
  juanita : Persona;
  grupo : ARRAY[1..CANT_PERS] OF Persona;

Determinen cuáles de las siguientes proposiciones son válidas:
a)

Código:

grupo [1] := juanita;

b)

Código:

grupo [1].nombre := 'juanita';

c)

Código:

Read (grupo [1].estado);

d)

Código:

WITH grupo DO writeln (nombre);

e)

Código:

WITH grupo [100] DO
BEGIN
  Read (edad);
END;

f)

Código:

WITH juanita DO
BEGIN
  nombre := grupo [50].nombre;
  salario := grupo [1].salario
END;

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

Ejercicio 2: Supongan que una sociedad genealógica tiene un arreglo de registros que indican la fecha de nacimiento y subíndice en el arreglo de los registros de los padres y madres de varias personas. El arreglo de registros y las variables correspondientes podrían ser parecidos a éstos :

Código:

CONST
  MAXPERSONAS = 1000;
  MAXCAD = 20;

TYPE
  Cadena = RECORD
      letras : Array[1..MAXCAD] Of Char;
      largo : 0..MAXCAD;
  END;

  UnaPersona = RECORD
      nombre : Cadena;
      FechNac : RECORD (* Fecha de nacimiento *)
        mes : 1..12;
        dia : 1..31;
        anio : 0..MAXINT
      END;
      IndMadre, IndPadre : 0..MAXPERSONAS;
  END;

  Familia = RECORD
      pers : ARRAY[1..MAXPERSONAS] OF UnaPersona;
      tope : 0..MAXPERSONAS;
  END;

VAR
  historia : Familia;
  usted : Cadena;

Los campos IndMadre e IndPadre contienen el subíndice en el arreglo historia de los registros de la madre y el padre. Este valor será cero si no se dispone de la información correspondiente. Supongan que la variable usted contiene el nombre de una persona; exhiban entonces los nombres y fechas de nacimiento de los padres y los cuatro abuelos de esa persona (si es que se contienen la información).

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


Ejercicio 3: Escriban una función en PASCAL llamada alfa que tenga como parámetro una cadena de caracteres (representada con un arreglo con tope) llamada frase y una variable de tipo carácter llamada letra. La función alfa produce el número de apariciones del carácter letra en la frase.

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

Ejercicio 4: (Requiere conocimientos de matemática básica de nivel secundario, concretamente deben saber hallar las raíces de cualquier polinomio de segundo grado (función cuadrática)) Implementen un procedimiento que calcule las raíces de una ecuación de segundo grado. El cabezal del procedimiento debe de ser el siguiente:

Código:

Procedure Raices(a, b, c : Real; Var r : TipoRaices);

1. Definan el tipo TipoRaices utilizando la estructura de registro con variante.
2. Implementen el procedimiento pedido.

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

Ejercicio 5: (Este conocimiento está basado en una notación matemática común para cualquier estudiante pero avanzada para su tratamiento. El conocimiento necesario se corresponde con los últimos años de secundaria y/o inicios de estudios terciarios) Se considera el tipo de dato Nerr que es la unión de los números naturales (N) con el conjunto Err. El conjunto Err se define como {diverr, reserr, argerr}, donde diverr es el error de la división por cero,reserr es el error de la resta con resultado negativo y argerr es el error de cualquier operación donde alguno de sus argumentos no es natural.
Se definen las siguientes operaciones sobre elementos del tipo Nerr:

Código:

division: Nerr x Nerr → Nerr
Si a pertenece a N y b pertenece a N - {0} ==> divivision(a,b) = a DIV b;
Si a pertenece a N y b = 0 ==> division(a,b) = diverr;
Si a pertenece a Err o b pertenece a Err ==> division(a,b) = argerr;

resta: Nerr x Nerr → Nerr
Si a pertenece a N y b pertenece a N y a >= b ==> resta(a,b) = a - b;
Si a pertenece a N y b pertenece a N y a < b ==> resta(a,b) = reserr;
Si a pertenece a Err o b pertenece a Err ==> resta(a,b) = argerr;

suma: Nerr x Nerr → Nerr
Si a pertenece a N y b pertenece a N ==> suma(a,b) = a + b;
Si a pertenece a Err o b pertenece a Err ==> suma(a,b) = argerr;

producto: Nerr x Nerr → Nerr
Si a pertenece a N y b pertenece a N ==> producto(a,b) = a * b;
Si a pertenece a Err o b pertenece a Err ==> producto(a,b) = argerr;

1. Definan en PASCAL el tipo Err.
2. Definan en PASCAL el tipo Nerr.
3. Implementen los procedimientos que implementan respectivamente las operaciones división, resta, suma y producto del tipo Nerr.

Código:

PROCEDURE division (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE resta (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE suma (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE producto (n1:Nerr; n2:Nerr; VAR n3:Nerr);

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


Ejercicio 6: (Matemática de nivel terciario (Álgebra lineal de matrices)) Se desea implementar en PASCAL el producto de matrices de elementos de tipo Nerr. Las matrices a operar podrán tener diferentes dimensiones. Se sabe que si una matriz tiene dimensión mxn, m y n son enteros positivos que nunca superarán a constantes X e Y respectivamente.
El producto entre matrices de tipo Nerr se define de manera análoga al producto de matrices de números naturales con la suma y el producto para el tipo Nerr dado en el ejercicio anterior.
Sea la matriz m1 de dimensión m x n y la matriz m2 de dimensión p x q. Si n = p el producto m1 x m2 tendrá dimensión m x q, en caso contrario diremos que el producto falla.
Definir en PASCAL el tipo MNerr, que representa las matrices de dimensiones m x n de tipo Nerr, para cualquier m entre 1 e Y, y para cualquier n entre 1 y X. Puede asumir que X e Y son mayores o iguales que 1.
Además MNerr debe tener un valor de error “merr” para el caso en que el producto de matrices falle.
Implementar el procedimiento:

Código:

PROCEDURE mprod (m1:MNErr; m2:MNerr; VAR m3:MNerr);

El procedimiento mprod recibe dos matrices m1 y m2, retornando en m3 el producto m1 x m2 o merren caso de que dicho producto falle.

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


Ejercicio 7: En una isla del Caribe una banda de piratas se gana la vida asaltando barcos mercantes. Anualmente en la isla se realiza un evento multitudinario llamado “la entrega de los premios Calavera”. Para este año los piratas están pensando en entregar el premio “Calavera de Oro” al pirata que haya conseguido mas dinero asaltando barcos para la banda. Como usualmente los piratas discuten a quién le corresponden los premios en trifulcas interminables y sangrientas, este año la comisión directiva de la banda ha decidido informatizar el registro de logros de los piratas en los distintos asaltos, con la esperanza de terminar así con algunas de las discuciones sobre los créditos que le corresponden a cada pirata.

Los logros de los piratas durante el año se organizan en la siguiente estructura:

Código:

CONST
  MAXPIRATAS=10000; (* Limite de piratas que pueden vivir en la isla. *)
  MAXASALTOS=500; (* Limite de asaltos a los que estadisticamente puede sobrevivir un pirata. *)
  MAXDIGITOSCI=8; (* Cantidad de digitos para almacenar un numero de cédula. *)

TYPE
  TipoCI=ARRAY[1..MAXDIGITOSCI] OF CHAR;
 
  TipoFecha=RECORD
      dia:1..31;
      mes:1..12;
      anho:INTEGER
  END;

  TipoAsalto=RECORD
      nombre_barco:ARRAY[1..30] OF CHAR; (* Nombre del barco asaltado *)
      fecha:TipoFecha; (* Fecha del atraco *)
      botin:INTEGER (* Suma de dinero obtenida para la banda *)
  END;

  ConjuntoAsaltos=RECORD (* Contiene información sobre los asaltos *)
      asaltos:ARRAY[1..MAXASALTOS] OF TipoAsalto;
      tope:0..MAXASALTOS
  END;

  TipoPirata=RECORD
      nombre:ARRAY[1..30] OF CHAR; (* Nombre del pirata *)
      CI:TipoCI; (* Cédula de identidad *)
      CASE estavivo:BOOLEAN OF (* Indica el estado vital actual del pirata *)
        TRUE: (asaltos:ConjuntoAsaltos); (* Contiene información sobre los asaltos *)
                (* realizados por el pirata *)
        FALSE: ()
  END;

  Banda=RECORD
      pirata:ARRAY[1..MAXPIRATAS] OF TipoPirata; (* Contiene información de los piratas de la banda *)
      tope:0..MAXPIRATAS (* Indica cantidad de piratas *)
  END;


Se pide:
Parte a)
Implementar la función:

FUNCTION dinero_obtenido_por_pirata(pirata:TipoCI, anho:INTEGER, b:Banda) : INTEGER;
la cual debe recibir la CI de un pirata, un año y una banda, y retornar la suma de dinero obtenida por el pirata para la banda en ese año. En caso de que el pirata se encuentre muerto o no se encuentre en la banda debe retornar 0.

Se sugiere implementar primero funciones:

Código:

FUNCTION CIiguales (ci1, ci2:TipoCI):BOOLEAN;
(* Retorna TRUE si "ci1" y "ci2" son iguales, FALSE si no. *)

FUNCTION contar_dinero (ca:ConjuntoAsaltos; anho:INTEGER):INTEGER;
(* Retorna la suma del dinero obtenido en los asaltos del conjunto "ca" realizados durante el año "anho". *)

Parte b)
Implementar el procedimiento:

Código:

PROCEDURE hallar_ganadores(piratas:Banda, anho:INTEGER; VAR piratas_merecedores:ConjuntoCIs)

el cual dada una banda de pirata y un año, devuelve en piratas_merecedores las cédulas de los piratas vivos merecedores del premio “Calavera de Oro”. Tengamos en cuenta, que varios piratas pueden coincidir en la cantidad de dinero obtenido para la banda y que no hayan otros piratas que los superen. ConjuntoCIs se declara como sigue:

Código:

TYPE
  ConjuntoCIs=RECORD
      cedulas:ARRAY[1..MAXPIRATAS] OF TipoCI; (* Arreglo de cedulas *)
      tope:0..MAXPIRATAS (* Cantidad de cédulas en el array *)
  END;


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

Ejercicio 8: Examen Agosto 2001

Se desea trabajar con una aritmética de Naturales de hasta 100 dígitos. Los Enteros de PASCAL no soportan dicha aritmética, por lo que se piensa utilizar la siguiente representación de Naturales basada en arreglos con tope:

Código:

CONST
  MaxDig = 100;

TYPE
  Digito = 0..9;
  Natural = RECORD
      digitos : ARRAY[1..MaxDig] OF Digito;
      tope : 0..MaxDig;
  END;


Implementar la suma de Naturales representados en términos de la estructura anterior. Utilizar el siguiente cabezal:

Código:

Procedure Suma(a, b : Natural: Var c : Natural);

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

Navegación:

• Ir al índice del curso.
  
• Ir al índice de ejercicios de Pascal.