Solución Segundo Parcial Semestre B

Solución Segundo examen parcial de AD2.
Grupos de trabajo 2º cuatrimestre.
16/5/2002
Ejercicio 1 (teoría). Puntuación: 1 punto. (0.25 cada apartado).
Según la implementación enlazada con punteros del tipo cola vista en clase, la definición de tipos para una cola de enteros
sería la siguiente:
type
enlace = ^nodo;
nodo = record
dato: integer;
sig: enlace
end;
cola = record
pri, ult: enlace;
long: integer
end;
Los siguientes procedimientos pretenden duplicar el valor de los elementos de una cola q de enteros.
procedure primero (q: cola);
var aux: enlace;
begin
aux:= q.pri;
while aux<>nil do begin
aux^.dato:= aux^.dato * 2;
aux:= aux^.sig
end;
end;
procedure segundo (var q: cola); procedure tercero (q: cola);
procedure cuarto (var q: cola);
var aux: enlace;
begin
begin
begin
while q.pri<>nil do begin
while q.pri<>nil do begin
aux:= q.pri;
q.pri^.dato:= q.pri^.dato * 2;
q.pri^.dato:= q.pri^.dato * 2;
while aux<>nil do begin
q.pri:= q.pri^.sig
q.pri:= q.pri^.sig
aux^.dato:= aux^.dato * 2;
end;
end;
aux:= aux^.sig
end;
end;
end;
end;
Los procedimientos se invocan desde el programa principal pasándoles como parámetro actual una variable global micola:
micola
5
pri
ult
long
3
4
2
X
Completar los dibujos que representan como queda micola:
a)
después de la llamada a primero(micola),
micola
10
c)
pri
ult
b) después de la llamada a segundo(micola),
long
3
8
4
X
después de la llamada a tercero(micola),
micola
10
pri
ult
10
long
3
8
pri
X
micola
4
ult
4
X
d) después de la llamada a cuarto(micola),
long
3
8
pri
micola
X
10
8
ult
long
3
4
X
Ejercicio 2 (teoría). Puntuación: 2 puntos.
Dada una lista (con punto de interés) l de palabras del castellano ordenadas alfabéticamente y una palabra p, diseñar un
procedimiento iterativo o recursivo borrapalant que, si dicha palabra ya está en la lista, borre todas las palabras alfabéticamente
anteriores a ella y, si no está en la lista, borre todas las palabras hasta la inmediatamente mayor alfabéticamente.
Ejemplo .
Dadas l = {“ASNO”, “CARNE”, “DIENTE”, “LAGO”, “OJO”, “SOL”} y p = “LAGO”, la lista resultado será l = {“LAGO”, “OJO”, “SOL”}.
Dadas l = {“ASNO”, “CARNE”, “DIENTE”, “LAGO”, “OJO”, “SOL”} y p = “MANO”, la lista resultado será l = { “OJO”, “SOL”}.
Para el diseño de la función borrapalant se deben utilizar:
a) las operaciones del TAD lista con punto de interés que se han estudiado en la teoría:
procedimiento creal (sal l:lista[palabra]);
procedimiento inserta (ent/sal l: lista[palabra]; ent p: palabra);
procedimiento suprime (ent/sal l: lista[palabra]);
función recupera (l: lista[palabra]) devuelve palabra;
procedimiento principio (ent/sal l: lista[palabra]);
procedimiento fin (ent/sal l: lista[palabra]);
procedimiento siguiente (ent/sal l: lista[palabra]);
función esvacial (l: lista[palabra]) devuelve lógico;
función esfinl (l: lista[palabra]) devuelve lógico;
b) y la función comPalabras(p1,p2) que dadas dos palabras p1 y p2 devuelve 0 si son iguales, -1 si p1 es alfabéticamente menor
que p2 y 1 si p1 es alfabéticamente mayor que p2.
Ejemplo .
comPalabras(“hola”,”ciao”)=1
comPalabras(“ciao”,”hola”)=-1
comPalabras(“ciao”,”ciao”)=0
Completar en el recuadro el diseño del procedimiento. Si lo resuelves de forma recursiva, indica cómo se invocaría el procedimiento
desde el programa principal.
procedimiento borrapalant (ent/sal l: lista[palabra]; ent p: palabra);
(* VERSIÓN ITERATIVA *)
var esta: lógico; e: palabra; fvar;
principio(l); esta:= falso;
(* VERSIÓN RECURSIVA *)
var e: palabra; fvar;
si not esfinl(l)
entonces e:= recupera(l);
si (comPalabras(e, p) = -1)
entonces suprime(l);
borrapalant(l, p)
fsi
fsi
mientras not esfinl(l) y not esta hacer
e:= recupera(l);
si (comPalabras(e, p) >= 0)
entonces esta:= verdadero
sino
suprime(l)
fsi
fmientras;
fprocedimiento;
Llamada inicial para la función recursiva: principio( li ); borrapalant(li, pa);
donde li y pa son variables globales declaradas como sigue:
li: lista[palabra];
pa: palabra;
Ejercicio 3 (teoría). Puntuación: 0.5 puntos. (0.25 cada apartado).
Suponiendo que el coste de la función comPalabras que compara dos palabras sea despreciable (la longitud máxima de una
palabra puede considerarse despreciable con respecto a la longitud de la lista de palabras del idioma si ésta contiene un número
elevado de palabras), estudiar el coste del algoritmo borrapalant en función de la talla del problema, sabiendo que dicha talla es
el número de palabras o longitud de la lista. Completar:
a) En el caso mejor, el coste temporal es
constante
con la talla del problema y
el coste espacial es
constante
con la talla del problema.
b) En el caso peor, el coste temporal es
lineal
con la talla del problema y
el coste espacial es constante (si iterativo) / lineal (si recursivo) con la talla del problema.
Ejercicio 4 (prácticas). Puntuación: 2.5 puntos.
El idioma buduma es hablado por unas 70.000 personas pertenecientes al Pueblo Buduma, en Chad, Nigeria y Camerún.
Estamos construyendo un diccionario de español a buduma según las siguientes definiciones de tipos:
type
palabra = ^nodoPal;
nodoPal = record
letra: char;
sig: palabra
end;
diccionario = ^nodoLista;
nodoLista = record
esp, bud: palabra;
sig: diccionario
end;
Dado un diccionario d (lista de palabras enlazadas español-buduma ordenadas alfabéticamente según la palabra española), una
palabra en español e y su correspondiente palabra en buduma b, diseñar un procedimiento insertapal que, si dicha palabra no
existe, la inserte ordenadamente en el diccionario. Utilícese la función comPalabras(p1, p2), que dadas p1 y p2 de tipo palabra
se comporta igual que la función comPalabras explicada en el Ejercicio 2.
Ejemplo .
Dado el diccionario d = {(“ASNO” – “KORO”), (“CARNE” – “SU”), (“DIENTE” – “SANNAY”), (“OJO” – “YIL”), (“SOL” – “AAJI”)},
la palabra española e = “LAGO” y la palabra buduma b = “KULU”, el resultado sería:
d = {(“ASNO” – “KORO”), (“CARNE” – “SU”), (“DIENTE” – “SANNAY”), (“LAGO” – “KULU”), (“OJO” – “YIL”), (“SOL” – “AAJI”)}
Completar en el recuadro el diseño del procedimiento:
procedure insertapal (var d: diccionario; e, b: palabra);
var aux, ant_aux, nuevo: diccionario; esta: boolean;
comp: integer;
(* si necesitas otras variables, decláralas *)
begin
aux:= d;
ant_aux:= nil;
esta:= false;
while (aux<>nil) and (not esta) do begin
comp:= comPalabras(aux ^.esp, e);
if comp>= 0 then esta:= true
else begin
ant_aux:= aux;
aux:= aux ^.sig
end
end;
if esta then if comp=1 then esta:= false;
if not esta then begin
new(nuevo); nuevo^.esp:= e; nuevo^.bud:= b;
if ant_aux = nil then d:= nuevo
else ant_aux^.sig:= nuevo
end
end;
nuevo^.sig:= aux;