Examen de Programación 2 Diciembre de 2012

Transcripción

1 Ejercicio 1 ( puntos) Examen de Programación 2 Diciembre de 2012 La Administración Nacional de Puertos (ANP) quiere sistematizar la inspección de contenedores en tránsito en el puerto de Montevideo. El objetivo es optimizar el uso de los recursos de ANP para la inspección de contenedores en búsqueda de material ilícito, como contrabando y drogas. De cada contenedor se conocen los siguientes datos: Origen (String) Destino (String) Contenido declarado (String) Peso (Real) Matrícula del barco (String) Ubicación dentro del puerto (String) El registro de contenedores se hace en base semanal, y a medida que los barcos arriban al puerto se asigna a cada contenedor descargado un número, que lo identifica. Debido a este sistema de numeración a los contenedores de un mismo barco se les asignan identificadores consecutivos. Como la ANP no tiene recursos suficientes para inspeccionar todos los contenedores cada semana se sortea una cantidad I CR de contenedores para escanear o inspeccionar visualmente, siendo CR la cantidad de contenedores que fue registrada esa semana. Si al inspeccionar un contenedor se detecta material ilícito se inspeccionan los contenedores consecutivos (anterior y siguiente) porque es probable que también contengan material ilegal. Se pide: 1. Especifique en MODULA-2 los TADs Contenedor y ListaContenedores. Este último modela la lista semanal de contenedores y deberá contar con al menos las siguientes operaciones: Ingresar un nuevo contenedor. Devolver el contenedor con identificador i, donde 1 i CR Obtener CR Vaciar la lista de contenedores 2. Desarrolle una implementación completa del TAD ListaContenedores que considere las siguientes restricciones: El ingreso de un nuevo contenedor debe realizarse en O(1) Obtener CR debe realizarse en O(1) Asumiendo que estamos accediendo al contenedor con identificador i, donde 1 i CR, se debe poder acceder a los contenedores anterior y posterior en O(1) en caso de que estos contenedores existan (no existe el contenedor anterior al que tiene identificador 1 ni el siguiente del que tiene identificador CR). Se sugiere una implementación basada en listas con posiciones implícitas..

2 Solución 1) CONST MAX = 50; TYPE String = ARRAY [1..MAX] OF CHAR; (* Definición del tipo Contenedor *) TYPE Contenedor; (* Opaco *) PROCEDURE CrearContenedor (Peso : REAL; Origen, Destino, ContDecl, MatrBarco, Ubicacion : String) : Contenedor; PROCEDURE ObtenerPeso (c : Contenedor) : REAL; PROCEDURE ObtenerOrigen (c : Contenedor) : String; PROCEDURE ObtenerDestino (c : Contenedor) : String; PROCEDURE ObtenerContenidoDeclarado (c : Contenedor) : String; PROCEDURE ObtenerMatriculaBarco (c : Contenedor) : String; PROCEDURE ObtenerUbicacion ( c : Contenedor) : String; PROCEDURE DestruirContenedor (c : Contenedor); (* ListaContenedor *) TYPE ListaContenedor; (* Opaco *) (* POST: Crea la lista vacía y el cursor interno queda indefinido *) PROCEDURE CrearListaVacia () : ListaContenedor; (* POST: Ingresa el contenedor 'c' al final de la lista 'l' en O(1) *) PROCEDURE IngresarContenedor (c : Contenedor; VAR l : ListaContenedor); (* POST: Devuelve la cantidad de contenedores registrados (CR) en la lista 'l' en O(1) *) PROCEDURE ObtenerCantContReg (l : ListaContenedor) : CARDINAL; (* PRE: 1 <= i AND i <= ObtenerCantContReg(l) *) (* POST: Posiciona el cursor interno de la lista 'l' en el contenedor con identificador 'i' en O(n) en el peor caso *) PROCEDURE PosicionarCursor (i : CARDINAL; l : ListaContenedor); (* PRE: ObtenerCantContReg(l) > 0 *) PROCEDURE ObtenerPosicionCursor (l : ListaContenedor) : CARDINAL; (* PRE: ObtenerPosicionCursor(l) > 1 *) (* POST: Devuelve el contendor anterior al de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorAnterior (l : ListaContenedor) : Contenedor; (* PRE: ObtenerPosicionCursor(l) < ObtenerCantContReg(l) *) (* POST: Devuelve el contendor siguiente al de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorSiguiente (l : ListaContenedor) : Contenedor; (* PRE: ObtenerCantContReg(l) > 0 *) (* POST: Devuelve el contendor de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorActual (l : ListaContenedor) : Contenedor; (* POST: Libera la memoria de todos los contenedores de la lista 'l' y la deja en el mismo estado como si se invocara a CrearListaVacia *) PROCEDURE VaciarLista (l : ListaContenedor); (* POST: Libera toda la memoria reservada para la lista 'l' y los contenedores *) PROCEDURE DestruirLista (l : ListaContenedor); END ListaContenedor.

3 2) IMPLEMENTATION MODULE ListaContenedor; FROM Storage IMPORT ALLOCATE, DEALLOCATE; TYPE NodoLista = POINTER TO Nodo; Nodo = RECORD cont : Contenedor; pos : CARDINAL; ant, sig : NodoLista; ListaContenedor = POINTER TO Lista; Lista = RECORD inicio, fin, cursor : NodoLista; PROCEDURE CrearListaVacia () : ListaContenedor; VAR l : ListaContenedor; NEW(l); NEW(l^.inicio); (* Celda dummy *) l^.inicio^.ant := NIL; l^.inicio^.sig := NIL; l^.inicio^.pos := 0; (* No es tan dummy! *) l^.cursor := l^.inicio; l^.fin := l^.inicio; RETURN l; END CrearListaVacia; PROCEDURE IngresarContenedor (c : Contenedor; VAR l : ListaContenedor); NEW(l^.fin^.sig); l^.fin^.sig^.ant := l^.fin; l^.fin := l^.fin^.sig; l^.fin^.sig := NIL; l^.fin^.cont := c; l^.fin^.pos := l^.fin^.ant^.pos + 1; (* Acá sirve inicializar en 0 la posición de la celda dummy *) END IngresarContenedor; PROCEDURE ObtenerCantContReg (l : ListaContenedor) : CARDINAL; RETURN l^.fin^.pos; END ObtenerCantContReg; (* PRE: 1 <= i AND i <= ObtenerCantContReg(l) *) (* POST: Posiciona el cursor interno de la lista 'l' en el contenedor con identificador 'i' en O(n) en el peor caso *) PROCEDURE PosicionarCursor (i : CARDINAL; l : ListaContenedor); (* Obtener consecutivos es eficiente! *) WHILE (l^.cursor^.pos <> i) DO IF l^.cursor^.pos > i THEN l^.cursor := l^.cursor^.ant; l^.cursor := l^.cursor^.sig;

4 END PosicionarCursor; (* PRE: ObtenerCantContReg(l) > 0 *) PROCEDURE ObtenerPosicionCursor (l : ListaContenedor) : CARDINAL; RETURN l^.cursor^.pos; END ObtenerPosicionCursor; (* PRE: ObtenerPosicionCursor(l) > 1 *) (* POST: Devuelve el contendor anterior al de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorAnterior (l : ListaContenedor) : Contenedor; RETURN l^.cursor^.ant^.cont; END ContenedorAnterior; (* PRE: ObtenerPosicionCursor(l) < ObtenerCantContReg(l) *) (* POST: Devuelve el contendor siguiente al de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorSiguiente (l : ListaContenedor) : Contenedor; RETURN l^.cursor^.sig^.cont; END ContenedorSiguiente; (* PRE: ObtenerCantContReg(l) > 0 *) (* POST: Devuelve el contendor de la posición actual del cursor interno de la lista 'l' en O(1) *) PROCEDURE ContenedorActual (l : ListaContenedor) : Contenedor; RETURN l^.cursor^.cont; END ContenedorActual; (* POST: Libera la memoria de todos los contenedores de la lista 'l' y la deja en el mismo estado como si se invocara a CrearListaVacia *) PROCEDURE VaciarLista (l : ListaContenedor); VAR aborrar : NodoLista; l^.cursor := l^.inicio^.sig; WHILE l^.cursor <> NIL DO aborrar := l^.cursor; l^.cursor := l^.cursor^.sig; DestruirContenedor(aBorrar^.cont); DISPOSE(aBorrar); l^.inicio^.sig := NIL; l^.fin := l^.inicio; l^.cursor := l^.inicio; END VaciarLista; (* POST: Libera toda la memoria reservada para la lista 'l' y los contenedores *) PROCEDURE DestruirLista (l : ListaContenedor); VaciarLista(l); DISPOSE(l^.inicio); (* La celda dummy *) DISPOSE(l); END DestruirLista; END ListaContenedor.

5 Ejercicio 2 ( puntos) Sea ABB un tipo que representa árboles binarios de búsqueda cuyos elementos son del tipo TInfo que se describe a continuación. Los nodos de ABB están ordenados según el campo clave. TInfo = RECORD clave: CARDINAL; dato: T; Se dispone de las siguientes primitivas: PROCEDURE Crear (): ABB; (* Devuelve un árbol vacío. *) PROCEDURE Cons (info: TInfo; izq, der: ABB): ABB; (* Crea un árbol con raíz igual a "info" y con subárboles izquierdo y derecho "izq" y "der" respectivamente. Precondición: info.clave es mayor que las claves en "izq" y menor que las claves en "der". *) PROCEDURE EsVacio (t: ABB): BOOLEAN; (* Devuelve TRUE si "t" es vacio o FALSE en otro caso. *) PROCEDURE Raiz (t: ABB): TInfo; (* Devuelve la raíz de "t". PROCEDURE Izquierdo (t: ABB): ABB; (* Devuelve el subárbol izquierdo de "t". PROCEDURE Derecho (t: ABB): ABB; (* Devuelve el subárbol derecho de "t". PROCEDURE Mayor (t: ABB): TInfo; (* Devuelve el elemento de "t" cuya clave es más grande. PROCEDURE RemoverMayor (VAR t: ABB); (* Remueve de "t" el nodo cuya clave es más grande y libera los registros de memoria mantenidos por ese nodo. PROCEDURE Destruir (VAR t: ABB); (* Libera todos los registros de memoria utilizados para almacenar el árbol "t". El árbol "t" queda indefinido.*) Se pide: 1. Implemente RemoverMayor accediendo a la representación de ABB. Para ello defina el tipo ABB. La implementación no debe ser recursiva. No se puede utilizar procedimientos auxiliares ni las primitivas. 2. Dado un árbol t de tipo ABB, se quiere obtener otro ABB t 1 que sólo contenga copias de los nodos de t para los cuales el campo dato es mayor que una cierta cota. El árbol obtenido t 1 no debe compartir registros de memoria con t y debe ser un árbol binario de búsqueda ordenado según clave.

6 Para esto se cuenta con la siguiente función auxiliar: PROCEDURE EsMenor (a,b:t) : BOOLEAN (* Devuelve TRUE si y sólo si a<b, FALSE en cualquier otro caso.*) Se debe implementar la función Filtrado, sin definir procedimientos auxiliares ni acceder a la representación (usando solamente las primitivas y la función EsMenor): PROCEDURE Filtrado (t: ABB; cota: T): ABB; (* Devuelve un árbol con los elementos de "t" en los que "dato" es mayor que "cota". *) A modo de ejemplo, y suponiendo que el tipo T corresponda a strings, en la Figura 1 se presenta un árbol t (sobre a izquierda) y el resultado de filtrarlo con una cota igual al string manzana (sobre la derecha). 3. Suponga que también se dispone de la siguiente primitiva: PROCEDURE DestruirRaiz (VAR t: ABB); (* Libera los registros de memoria mantenidos por la raíz de "t". El árbol "t" queda indefinido. Figura 1: Ejemplo del resultado de aplicar la función Filtrado Usando solo las primitivas, incluida DestruirRaiz, implemente el procedimiento PROCEDURE Insertar (info: TInfo; VAR t: ABB); (* Inserta "info" en "t" manteniendo el orden dado por "clave". Precondición: info.clave no es una clave en "t". *) 4. Ahora suponga que en cada nodo se mantiene también la altura del árbol. El tipo TInfo pasa a ser el siguiente: TInfo = RECORD clave: CARDINAL; altura: CARDINAL; dato: T; Implemente, sin definir procedimientos auxiliares y accediendo directamente a la representación del tipo ABB definido en la parte 1, RemoverMayorRec (VAR t: ABB), una versión recursiva de RemoverMayor que además mantenga de manera correcta la altura de cada nodo. La Figura 2 presenta un ejemplo de árbol con el tipo TInfo modificado para almacenar la altura en cada nodo (izquierda) y el resultado de aplicar la función RemoverMayorRec sobre dicho árbol (derecha).

7 Figura 2: Ejemplo de aplicación de la función RemoverMayorRec Solución 1) TYPE T = CARDINAL; TInfo = RECORD clave : CARDINAL; dato : T; altura : CARDINAL; ABB = POINTER TO ABBNodo; ABBNodo = RECORD; info : TInfo; izq, der : ABB; PROCEDURE RemoverMayor (VAR a : ABB); (* NOT EsVacio(t)*) VAR hijo, padre, aborrar : ABB; padre := NIL; hijo := a; (* Busco el primer nodo que el derecho sea NIL *) WHILE hijo^.der <> NIL DO padre := hijo; hijo := hijo^.der; aborrar := hijo; IF padre = NIL THEN (* Era un arbol sin nodo derecho *) a := a^.izq; ELSIF hijo^.izq = NIL THEN (* El más grande es una hoja *) padre^.der := NIL; (* El más grande tiene subarbol izquierdo *) padre^.der := hijo^.izq; DISPOSE(aBorrar); END RemoverMayor;

8 2) PROCEDURE Filtrado (t : ABB; cota : T) : ABB; VAR fizq, fder : ABB; imayor, iraiz : TInfo; IF EsVacio(t) THEN RETURN Crear(); fizq := Filtrado(Izquierdo(t), cota); fder := Filtrado(Derecho(t), cota); iraiz := Raiz(t); IF EsMenor(cota, iraiz.dato)then RETURN Cons(iraiz, fizq, fder); ELSIF EsVacio(fizq) THEN Destruir(fizq); RETURN fder; ELSIF EsVacio(fder) THEN Destruir(fder); RETURN fizq; (* Ninguno de los 2 es vacío y además la raíz no va *) imayor := Mayor(fizq); RemoverMayor(fizq); RETURN Cons(imayor, fizq, fder); END Filtrado; Solución 3) PROCEDURE Insertar (info : TInfo; VAR t: ABB); VAR raiz : TInfo; izq, der : ABB; IF EsVacio(t) THEN t := Cons(info, Crear(), Crear()); raiz := Raiz(t); der := Derecho(t); izq := Izquierdo(t); IF raiz.clave < info.clave THEN Insertar(info, der); Insertar(info, izq); DestruirRaiz(t); t := Cons(raiz, izq, der); END Insertar;

9 4) PROCEDURE RemoverMayorRec (VAR t : ABB); VAR borrar : ABB; (* El arbol no es vacío *) IF t^.der = NIL THEN (* Caso base. La raíz es el elemento mayor. *) borrar := t; t := t^.izq; DISPOSE (borrar); (* Caso recursivo. El mayor está en el subárbol derecho. *) RemoverMayorRec(t^.der); (* controlar y tal vez modificar altura*) IF (t^.izq = NIL) OR (t^.info.altura > 1 + t^.izq^.info.altura) THEN (* La altura de 't' estaba determinada por la de su subárbol derecho, que no era nulo: t^.info.altura = 1 + hder, siendo hder la altura de t^.der antes de la llamada. Al remover solo un nodo la altura de t^.der quedará igual o disminuirá 1.*) IF (t^.der = NIL) OR (t^.info.altura = 2 + t^.der^.info.altura ) THEN (* La altura de t^.der disminuyó 1.*) t^.info.altura := t^.info.altura - 1; END RemoverMayorRec;