Instituto de Computación - Facultad de Ingeniería - Universidad de la República

Transcripción

1 Parcial de Programación 2 Julio de 2011 Generalidades: La prueba es individual y sin material. Duración: 3hs. Sólo se contestan dudas acerca de la letra de los ejercicios. Escriba las hojas de un sólo lado y con letra clara. Resuelva ejercicios diferentes en hojas diferentes. Numere cada hoja, indicando en la primera el total. Coloque su nro. de cédula y nombre en cada hoja. Se permite usar funciones y procedimientos auxiliares en todos los ejercicios, excepto en aquellos en los que se indique lo contrario. Ejercicio 1 (30 puntos) Considere una agenda de teléfonos implementada como un árbol general de caracteres (de '0' a '9'), donde la raíz no tiene información y cada nodo representa a un dígito de números telefónicos. Las listas de hermanos están ordenadas de forma lexicográfica. El camino de la raíz a una hoja determina un número telefónico de la agenda, guardándose en cada hoja el nombre del contacto asociado a ese número. Por ejemplo, el siguiente árbol contiene los contactos: 104 bombero, 105 ambulancia, 109 patrullero, 16 hora y 911 emergencia. Se pide: a) Definir la representación en Modula-2 del tipo Agenda, árbol general de caracteres implementado como un árbol primer hijo- siguiente hermano con la información del contacto en las hojas. Considere que el tipo de la información del contacto es: TYPE InfoContacto = ARRAY [ ] OF CHAR; b) Implementar, accediendo directamente a la representación, una función ObtenerContacto que, dados un número de teléfono y una Agenda, retorne la información del contacto asociado a ese número. La función tiene como precondiciones que el número de teléfono no es vacío y que debe tener exactamente un contacto asociado (esto es, que indica un camino de la raíz a una hoja). PROCEDURE ObtenerContacto (tel: Telefono; agenda: Agenda): InfoContacto; El tipo Telefono, de los números de teléfono, es una lista de caracteres. Utilice las operaciones Primero y Resto del TAD Lista para operar sobre el parámetro tel; considere que estas operaciones ya están implementadas. La operación Resto retorna un alias al resto de la lista parámetro (sin su primer elemento). c) Implementar, accediendo directamente a la representación, una función ImprimirAgenda que imprima en pantalla la información guardada en la Agenda que se pasa como parámetro. PROCEDURE ImprimirAgenda (agenda: Agenda); El formato de impresión, que muestra la estructura de árbol finitario que representa la agenda, se especifica con 1

2 el siguiente ejemplo: Si tenemos una variable miagenda con el árbol de ejemplo (ilustrado previamente), entonces ImprimirAgenda(miagenda) imprime: =bombero --5=ambulancia --9=patrullero -6=hora =emergencia SOLUCIÓN PARTE A) TYPE InfoContacto = ARRAY [0.. MAX] OF CHAR; Agenda = POINTER TO NodoAgenda; NodoAgenda = RECORD digito: CHAR; sighermano: Agenda; CASE eshoja: BOOLEAN OF TRUE: contacto: InfoContacto FALSE: primerhijo: Agenda PARTE B) PROCEDURE ObtenerContactoRec(tel: Telefono; agenda: Agenda): InfoContacto; VAR result: InfoContacto; IF Primero (tel) > agenda^.digito THEN result := ObtenerContactoRec(tel, agenda^.sighermano) (* Primero(tel) = agenda^.digito, debido al orden lexicográfico de los hermanos y a que por precondición tel es un camino válido dentro del árbol *) IF agenda^.eshoja THEN result := agenda^.contacto result := ObtenerContactoRec (Resto (tel), agenda^.primerhijo) END RETURN result END ObtenerContactoRec; PROCEDURE ObtenerContacto (tel: Telefono; agenda: Agenda): InfoContacto; (* PRE: tel es un teléfono de agenda *) RETURN ObtenerContactoRec (tel, agenda^.primerhijo) END ObtenerContacto; PARTE C) 2

3 PROCEDURE ImprimirRec(nivel: CARDINAL; agenda: Agenda); VAR i : CARDINAL; IF (agenda <> NIL) THEN FOR i := 1 TO nivel DO WriteString("-") WriteChar(agenda^.digito); IF (agenda^.eshoja) THEN WriteString("="); WriteString(agenda^.contacto); WriteLn WriteLn; ImprimirRec(nivel + 1,agenda^.primerHijo) ImprimirRec(nivel,agenda^.sigHermano); END END ImprimirRec; PROCEDURE ImprimirAgenda(agenda: Agenda); VAR IF agenda <> NIL THEN ImprimirRec (0, agenda^.primerhijo); END ImprimirAgenda; Ejercicio 2 (30 puntos) Considere el TAD ListaEsperaAviones de aviones identificados por su número de vuelo, de tipo CARDINAL, y que deben ser seleccionados en orden de llegada (orden FIFO) para aterrizar en un aeropuerto. A su vez, mientras los aviones esperan para aterrizar pude suceder que se vean apurados por algún motivo, como la falta de combustible o enfermedad de un pasajero, en cuyo caso estos aviones Urgentes deben ser considerados para aterrizaje antes que los Normales, y también deben ser seleccionados en orden de llegada (orden FIFO) para aterrizar en un aeropuerto. El TAD ListaEsperaAviones, no acotado, tiene las siguientes operaciones constructoras, selectoras/ destructoras y predicados: VaciaListaEsperaAviones, crea una ListaEsperaAviones vacía. InsertarAvion, permite insertar un avión en una ListaEsperaAviones. Es una precondición que el avión a insertar no esté ya en ListaEsperaAviones. Nota: los aviones insertados son considerados Normales. ObtenerSigAvion, retorna el siguiente avión que puede aterrizar de una ListaEsperaAviones siempre y cuando no esté vacía; si hay aviones Urgentes se selecciona el siguiente de ellos en orden de llegada (orden FIFO), sino se selecciona de los aviones Normales, también en orden de llegada. PromoverAvion, permite promover un avión de Normales a Urgentes, si el avión no está presente o ya está entre los Urgentes, entonces la ListaEsperaAviones no se ve modificada. Al promover un avión de Normales a Urgentes, dicho avión será considerado último en el orden FIFO entre los Urgentes. Esto es, será el último de los Urgentes en el orden de selección para aterrizar. BorrarSigAvion, permite borrar el avión que fue seleccionado para aterrizar, con el mismo criterio que ObtenerSigAvion, siempre y cuando no esté vacía la ListaEsperaAviones. EsVaciaListaEsperaAviones, retorna TRUE si y sólo si la ListaEsperaAviones está vacía. EstaEnListaEsperaAviones, retorna TRUE si y sólo si un avión dado está en una ListaEsperaAviones. 3

4 Se pide: DestruirListaEspera, que destruye la ListaEsperaAviones, liberando toda la memoria reservada. a) Especifique, en MODULA-2, un TAD ListaEsperaAviones no acotado con operaciones constructoras, selectoras/destructoras y predicados, usando pre y postcondiciones. b) Implemente el TAD ListaEsperaAviones, donde todas las operaciones tengan O(1) de tiempo de ejecución en el peor caso, excepto PromoverAvion y DestruirListaEspera. Escriba la representación del TAD y el código de las operaciones VaciaListaEsperaAviones, InsertarAvion, ObtenerSigAvion y PromoverAvion. No utilice TADs auxiliares. c) Cuál es el orden de tiempo de ejecución en el peor caso de la operación PromoverAvion?. Explique brevemente, sin realizar cálculos. SOLUCIÓN PARTE A) DEFINITION MODULE ListaEsperaAviones; TYPE ListaEsperaAviones; (* Opaco *) Avion = CARDINAL; (************ Constructoras *************) PROCEDURE VaciaListaEsperaAviones(): ListaEsperaAviones; (*POST: Crea una ListaEsperaAviones vacía *) (*PRE: NOT EstaEnListaEsperaAviones(a, l) *) PROCEDURE InsertarAvion(a : Avion; VAR l : ListaEsperaAviones); (*POST: Inserta el Avión 'a', como avión Normal, en la lista 'l' con criterio FIFO *) (************ Predicados ****************) PROCEDURE EsVaciaListaEsperaAviones(l : ListaEsperaAviones) : BOOLEAN; (*POST: Devuelve TRUE si y sólo si la lista 'l' está vacía *) PROCEDURE EstaEnListaEsperaAviones(a : Avion; l : ListaEsperaAviones) : BOOLEAN; (*POST: Devuelve TRUE si y sólo si 'a' está en la lista 'l' *) (************ Selectoras/Destructoras ****************) (*PRE: NOT EsVaciaListaEsperaAviones(l) *) PROCEDURE ObtenerSigAvion(l : ListaEsperaAviones) : Avion; (*POST: retorna el sig. avion que puede aterrizar de la lista 'l'. Si hay aviones "Urgentes" se selecciona el siguiente de ellos con criterio FIFO, sino, se selecciona un avion "Normal" con criterio FIFO. *) PROCEDURE PromoverAvion(nroVuelo : Avion; VAR l : ListaEsperaAviones); (*POST: Si está el avión con número de vuelo 'nrovuelo' como "Normal", éste será promovido a "Urgente". Esto es, será removido de los "Normales" y agregado con criterio FIFO en los "Urgentes" *) (*PRE: NOT EsVaciaListaEsperaAviones(l) *) PROCEDURE BorrarSigAvion(VAR l : ListaEsperaAviones); (*POST: Borra el avión de la lista 'l' que seria seleccionado para aterrizar si se usara ObtenerSigAvion, liberando la memoria reservada. *) PROCEDURE DestruirListaEspera(VAR l : ListaEsperaAviones); (* Destruye la lista 'l', liberando toda la memoria reservada. *) END ListaEsperaAviones. 4

5 PARTE B) IMPLEMENTATION MODULE ListaEsperaAviones; FROM Storage IMPORT ALLOCATE, DEALLOCATE; TYPE NodoAvion = POINTER TO RECORD avion : Avion; sig : NodoAvion; ColaAviones = RECORD primero : NodoAvion; ultimo : NodoAvion; ListaEsperaAviones = POINTER TO RECORD urgentes : ColaAviones; (* estructura FIFO para aviones urgentes *) normales : ColaAviones; (* estructura FIFO para aviones normales, que permite supresión de elementos arbitrarios *) (************ Operaciones Solicitadas *************) PROCEDURE VaciaListaEsperaAviones(): ListaEsperaAviones; VAR l : ListaEsperaAviones; NEW(l); l^.urgentes.primero := NIL; l^.urgentes.ultimo := NIL; l^.normales.primero := NIL; l^.normales.ultimo := NIL; RETURN l; END VaciaListaEsperaAviones; PROCEDURE InsertarAvion(a : Avion; VAR l : ListaEsperaAviones); VAR nuevonodo : NodoAvion; NEW(nuevoNodo); nuevonodo^.avion := a; nuevonodo^.sig := NIL; IF l^.normales.primero = NIL THEN l^.normales.primero := nuevonodo; l^.normales.ultimo := nuevonodo; l^.normales.ultimo^.sig := nuevonodo; l^.normales.ultimo := nuevonodo; END InsertarAvion; PROCEDURE ObtenerSigAvion(l : ListaEsperaAviones) : Avion; IF (l^.urgentes.primero <> NIL) THEN RETURN l^.urgentes.primero^.avion; RETURN l^.normales.primero^.avion; END ObtenerSigAvion; PROCEDURE PromoverAvion(nroVuelo : Avion; VAR l : ListaEsperaAviones); VAR mover, iter : NodoAvion; insertarenurgentes : BOOLEAN; insertarenurgentes := FALSE; 5

6 IF NOT EsVaciaListaEsperaAviones(l) THEN IF (l^.normales.primero^.avion = nrovuelo) THEN (* Es el primero *) mover := l^.normales.primero; l^.normales.primero := mover^.sig; IF (mover = l^.normales.ultimo) THEN l^.normales.ultimo := NIL; insertarenurgentes := TRUE; iter := l^.normales.primero; WHILE (iter^.sig <> NIL) AND (iter^.sig^.avion <> nrovuelo) DO iter := iter^.sig; IF (iter^.sig <> NIL) THEN (* encontre el avión a mover *) mover := iter^.sig; iter^.sig := mover^.sig; IF (l^.normales.ultimo = mover) THEN l^.normales.ultimo := iter; insertarenurgentes := TRUE; IF insertarenurgentes THEN IF (l^.urgentes.ultimo = NIL) THEN l^.urgentes.ultimo := mover; l^.urgentes.primero := mover; l^.urgentes.ultimo^.sig := mover; l^.urgentes.ultimo := mover; (* EsVacia*) END PromoverAvion; PARTE C) El orden de tiempo de ejecución en el peor caso es O(n), con n la cantidad de aviones "Normales". Esto surge de considerar que el peor caso se produce cuando al buscar el avión a promover en la estructura de aviones "Normales", o bien el avión está en el último lugar de la lista ó bien no está. En ambos casos el algoritmo recorre toda la estructura de aviones "Normales". Observar que la inserción en la estructura FIFO "Urgentes" es O(1). 6

7 ALTERNATIVA 1. Se consideran las mismas estructuras de datos que en la solución de la página pero se da una solución alternativa al procedimiento PromoverAvión. PROCEDURE PromoverAvion(nroVuelo : Avion; VAR l : ListaEsperaAviones); PROCEDURE EliminarNormal(nroVuelo:Avion; VAR l:listaesperaaviones): NodoAvion; VAR mover : NodoAvion; mover := NIL; IF (l^.normales.primero^.avion = nrovuelo) THEN (* Es el primero *) mover := l^.normales.primero; l^.normales.primero := mover^.sig; IF (mover = l^.normales.ultimo) THEN l^.normales.ultimo := NIL; iter := l^.normales.primero; WHILE (iter^.sig <> NIL) AND (iter^.sig^.avion <> nrovuelo) DO iter := iter^.sig; IF (iter^.sig <> NIL) THEN (* encontré el avión a mover *) mover := iter^.sig; iter^.sig := mover^.sig; IF (l^.normales.ultimo = mover) THEN l^.normales.ultimo := iter; RETURN mover; END EliminarNormal; PROCEDURE AgregarUrgente(avion : NodoAvion; VAR l : ListaEsperaAviones); IF (l^.urgentes.ultimo = NIL) THEN l^.urgentes.ultimo := avion; l^.urgentes.primero := avion; l^.urgentes.ultimo^.sig := avion; l^.urgentes.ultimo := avion; END AgregarUrgente; VAR mover : NodoAvion; IF NOT EsVaciaListaEsperaAviones(l) THEN (* Elimino nodo de normales *) mover := EliminarNormal(nroVuelo, l); IF mover <> NIL THEN (* Inserto nodo en urgentes *) AgregarUrgente(mover, l); END END PromoverAvion; 7

8 ALTERNATIVA 2 Se propone una solución completa con una estructura de datos diferente a la de la planteada en la página 4. ListaEsperaAviones = POINTER TO RECORD dummy, ultimourgente, ultimo: NodoAvion; PROCEDURE VaciaListaEsperaAviones(): ListaEsperaAviones; VAR result: ListaEsperaAviones; NEW (result); NEW (result^.dummy); result^.ultimo := result^.dummy; result^.ultimourgente := result^.dummy; RETURN result; END VaciaListaEsperaAviones; PROCEDURE PromoverAvion(nroVuelo : Avion; VAR l : ListaEsperaAviones); VAR mover, iter : NodoAvion; iter := l^.ultimourgente; (* iter^.sig es el primero de los "Normales" o NIL *) WHILE (iter^.sig <> NIL) AND (iter^.sig^.avion <> nrovuelo ) DO iter := iter^.sig IF iter^.sig <> NIL THEN IF (l^.ultimo = iter^.sig) AND (l^.dummy^.sig <> l^.ultimo) THEN (* cambia el ultimo si el que se mueve es el ultimo y no es el unico *) l^.ultimo := iter mover := iter^.sig; iter^.sig := mover^.sig; mover^.sig := l^.ultimourgente^.sig; l^.ultimourgente^.sig := mover; l^.ultimourgente := mover END END PromoverAvion; PROCEDURE EsVaciaListaEsperaAviones(l : ListaEsperaAviones) : BOOLEAN; RETURN (l^.ultimo = l^.dummy) END EsVaciaListaEsperaAviones; PROCEDURE ObtenerSigAvion(l : ListaEsperaAviones) : Avion; RETURN l^.dummy^.sig^.avion; END ObtenerSigAvion; Insertar es más sencillo por la celda dummy: PROCEDURE InsertarAvion(a : Avion; VAR l : ListaEsperaAviones); VAR nuevonodo : NodoAvion; NEW(nuevoNodo); nuevonodo^.avion := a; nuevonodo^.sig := NIL; l^.ultimo^.sig := nuevonodo; l^.ultimo := nuevonodo; END InsertarAvion; 8