DELTA – MASTER

DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
Ejercicio 1 [3.5 puntos] Un hoter ofrece alojamiento a turistas todos los días comprendidos en un
intervalo [a..b] (donde a y b son naturales) cuya longitud b-a+1 se sabe que es par (sin estar excluida
la posibilidad de que sea 0, pero sí de que sea negativa). El precio de una estancia diaria varía cada
día, siendo:
•
•
•
1 euro para los días a y b (comienzo y fin de temporada),
2 euros para los días a+1 y b-1,
2² euros para los días a+2 y b-2,
Y así sucesivamente, es decir, el precio se multiplica por dos a medida que nos acercamos al centro
del intervalo (temporada alta). Se pide:
a) [1 punto] Especificar formalmente una funcion ingresos que calcule los ingresos obtenidos
por el hotel durante una temporada. La función toma un vector v que almacena en cada
posición k el número de huéspedes del día k, y dos naturales a y b indicando al principio y el
final de la temporada.
b) [2.5 puntos] Derivar detalladamente, a partir de la especificación formal del apartado (a), un
algoritmo iterativo para la función ingresos, de coste lineal con respecto al tamaño del vector.
Se ha de demostrar que el coste es, efectivamente, lineal.
SOLUCION
a) ingresos : VEC NAT NAT -> NAT
{a<=b, b-a+1 mod 2 = 0}
fun ingresos (E/S v[1..N] de ent, E a,b:ent) dev c:nat
{c = ∑ i: a<=i<=a+b /2 +1 : v[a]*2i-a }
b) Inicialización : <i,c> := <a,0>
Avanzar: i := i+1
Cota : a+b/2 +1 –i
Invariante siguiente paso: = ∑ i: a<=i+1<=a+b /2 +1 : v[a]*2i+1-a Λ a<= i+1 <= b+a/2+1
Vemos que tras avanzar se sigue cumpliendo el invariante
<i,c> := <a,0> ;
{I ≡c=∑ i: a<=i<=a+b /2 +1 : v[a]*2i-a Λ a<= i <= b+a/2+1}
Mientras i ≠ a+b/2+1 hacer
{I Λ i≠ a+b/2+1}
C:= c + v[a]*2i-a
Fmientras
La complejidad en el tiempo del algoritmo ésta en O(n) ya que la complejidad del cuerpo del
bucle es constante y el número de iteraciones en exactamente N
1
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
Ejercicio 2 [2 puntos] Dada la siguiente especificación algebraica:
parametro CLAVE
Usa BOOL .
Tipos Clave .
operaciones
op _<_ : clave clave -> bool .
op equivalente : Clave Clave -> bool .
op canonico : Clave -> Clave .
vars c1 c2 : Clave .
ceq canonico(c1) = caninico(c2) if equivalente(c1,c2) .
fparametro
parametro CONTENIDO
tipos Contenido .
operaciones
op conbinar : Contenido Contenido -> Contenido // asociativa y conmutativa
op codigo : Contenido -> Contenido .
op compresor : Contenido Contenido -> Contenido .
variables
vars y1 y2 : Contenido
ecuaciones
eq combinar(codigo(y1),codigo(y2)) = codigo(combinar(y1,y2)) .
fparametro
especificación EJERCICIO {X :: CLAVE, Y :: CONTENIDO}
tipos TAD{X,Y} .
operaciones
op error : -> [TAD{X,Y}] .
op vacio : -> TAD{X,Y} [constructor] .
op insertar : TAD{X,Y} Clave contenido -> TAD{X,Y} [constructor] .
op eliminar : TAD{X,Y} Clave -> TAD{X,Y} .
op es-vacio? : TAD{X,Y} -> Bool .
op cifrar : TAD{X,Y} Clave ->p TAD{X,Y} .
op comprimir : TAD{X,Y} -> TAD{X,Y} .
variables
var t : TAD{X,Y} .
vars x1 x2 : Clave .
vars y1 y2 : Contenido .
ecuaciones
eq insertar(insertar(t,x1,y1),x2,y2) = insertar(insertar(t,x2,y2),x1,y1) .
eq insertar(t,x1,y1),x1,y2) = insertar(t,x1,convinar(y1,y2)) .
fespecificacion
2
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
especificar las operaciones:
a) [1 punto] cifrar: operación parcial que cifra el contenido asociado a una clave dada. La
operación utilizada para cifrar un contenido es codigo. La operación produce error si la clave
dada no se encuentra en el TAD{X,Y}
b) [1 punto]comprimir: operación total que comprime el contenido de un TAD. Para ellos, si dos
claves del TAD son equivalentes, es decir, si la función equivalente aplicada a las claves da
como resultado cierto, aplicar la función compresor a sus contenidos, produciendo una
entrada en el TAD con clave el término canónico obtenido con la operación canonico aplicada
a una de las claves equivalente y contenido el resultado de la función compresor.
SOLUCION
a) eq cifrar(vacio,x1) = error
ceq cifrar (insertar(t,x1,y1),x2) = error if codigo(x2) =/= y1
ceq cifrar((insertar(t,x1,y1),x2) = t if codigo(x2) == y1
b) eq comprimir(vacio) = vacio
eq comprimir (insertar(insertar(t,x1,y1),x2,y2)) = insertar(t,canonico(x1),compresor(y1,y2))
if equivalente(x1,x2)
3
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
Ejercicio 3 [2.5 puntos] Se desea diseñar un tipo abstracto de datos para representar la gestión y
ejecución de programas en un sistema operativo.Para cada programa, el sistema guarda la siguiente
información: un identificador nuevo para cada programa con el nombre que va a ser reconocido en el
sistema, un estado en el que se encuentra el programa en cada momento (preparado si está listo para
ser ejecutado, o bien suspendido en caso contrario) y una prioridad (un numero natural) dependiendo
del programa, de forma de que se ejecuten antes en el sistema los más prioritarios (con un mayor
número natural) cuyo estado sea el de preparado. De entre todos los programas preparados que tengan
la misma prioridad, se ejecurará siempre por el orden de llegada al sistema. A continuación se
muestra la especificación algebraica de dicho tipo abstracto de datos en que suponemos que los
programas disponen de una operación de igualdad y otra de orden entre los identificadores:
parametro ESTADO
tipos Estado
operaciones
op preparado : -> Estado
op suspendido : -> Estado
fparametro
parametro ID_PROG
tipo id-prog
operaciones
_<_ : id-prog id-prog -> bool .
fparametros
especificacion SISTEMA-OPERATIVO {X :: Id-PROG , Y :: ESTADO}
usa LISTA_ORD .
tipos SO{X, Y} .
operaciones
op error : -> [Estado] .
op error :-> [SO{X,Y}] .
op vacio : -> SO{X,Y} [constructor] .
op añadir : SO{X,Y} id-prog Nat Estado ->p SO{X,Y} [constructor]
op ejecutar : SO{X,Y} ->p SO{X,Y} .
op consultar : SO{X,Y} id-prog ->p Estado .
op cambiar : SO{X,Y} id-prog -> p SO{X,Y} .
op listar : SO{X,Y} -> ListaOrdenada{X} .
operaciones privadas
op max-pri : SO{X,Y} -> Nat .
variables
var s : SO{X,Y} .
vars x1 x2 : id-prog .
vars n1 n2 : Nat .
vars y1 y2 : Estado .
ecuaciones
eq añadir(añadir(s,x1,n1,y1),x1,n2,y2) = error .
ceq añadir(añadir(s,x1,n1,y1),x2,n2,y2) = añadir(añadir(s,x2,n2,y2),x1,n1,y1) if n1 =/= n2 .
4
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
eq max-pri(vacio) = 0 .
ceq max-pri(añadir(s,x1,n1,y1)) n1 if n1 >= max-pri(a) and y1 == preparado .
ceq max-pri(añadir(s,x1,n1,y1)) = max-pri(s)
if n1 <= max-pri(s) or y1 =/= preparado .
eq ejecutar(vacio) = error .
ceq ejecutar(añadir(vacio,x1,n1,y1)) = vacio if y1 == preparado .
ceq ejecutar(añadir(vacio,x1,n1,y1)) = añadir(vacio,x1,n1,y1) if y1 =/= preparado .
ceq ejecutar(añadir(s,x1,n1,y1)) = añadir(ejecutar(s),x1,n1,y1)
if y1 =/= preparado or n1 <= max-pri(s) .
eq consultar(vacio,x1) = error .
eq consultar(añadir(s,x1,n1,y1),x1) = y1 .
ceq consultar(añadir(s,x1,n1,y1),x2) = consultar(s,x2) if x1 =/= x2 .
eq cambiar(vacio,x1) = error .
eq cambiar(añadir(s,x1,n1,preparado),x1) =añadir(s,x1,n1,suspendido) .
eq cambiar(añadir(s,x1,n1,suspendido),x1) = añadir(s,x1,n1,preparado) .
ceq cambiar(añadir(s,x1,n1,y1),x2) = añadir(cambiar(s,x2),x1,n1,y1) if x1 =/= x2 .
eq lista(vacia) = crear .
eq listar(añadir(s,x1,n1,y1)) = insertarOrd(x1,listar(s)) .
fespecificacion
Se pide implementar este tipo abstracto de datos. Para ello, se debe explicar con detalle la
representación elegida, codificar cada una de las operaciones de la especificación y justificar el coste
de cada una de dichas operaciones.
Suponer que las operaciones de consulta realizan una copia de las estructura de datos. Calcular
el coste teniendo en cuenta esta copia. Indicad también cual sería el coste en el caso de que no se
realizara la copia (esto es, las operaciones de consulta compartieran memoria).
Nota: Se puede suponer que el número de programas que pueden tener la misma prioriad es pequeño,
es decir, puede considerarse siempre menor que una constante. Hay que tener en cuenta además que
la información no debe aparecer en la representación elegida más de dos veces. Ninguna operación
debe tener un coste superior a O(log(n)) (sin tener en cuenta el coste de las copias de TADs), siendo n
el número de programas en el sistema, salvo listar, que tendrá complejidad lineal.
5
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
SOLUCION
El sistema operativo en un ejemplo de colas de prioridad en la que se introduce los datos en orden de
prioridades colocando los elementos de la misma prioridad ordenados por tiempo de entrada. Existen
múltiples implementaciones para las colas de prioridad, siendo la que se ajusta a las complegidades
pedidas el empleo de los montículos. Tendremos un móticulo para los elementro preparados y otro
para los elementos suspendidos.
Para la resulución este problema suponemos que los móticulos están implementados según los
apuntes de clase. Si no bastaría con incluir dichos métodos en la Solución
Tipos
Programa = reg
E de Estado
Id de ID_PROG
Prior de 0..M
freg
Monticulos = reg
V[1..N] de Programa
Ultimo : 0..N
freg
SisOp = reg
Preparados de Monticulo
Suspendidos de Monticulo
ftipos
proc añadir (SO : SisOp, id: ID_PROG, n: Nat, e: Estado)
si preparado(e) entonces
añadir(SO.Preparados,Programa(id,n,e))
si no
añadir(SO.Suspendidos,Programa(id,n,e))
fsi
fproc
La complegidad en O(n) ya que la insercion en un montículo es O(n)
proc ejecutar (SO :SisOp)
e = programa;
si SO.Preparados.Ultimo = 0 entonces error
si no
e = minimo (SO.preparados);
eliminar-min (SO.preparados);
suspender(e);
añadir (e);
6
DELTA – MASTER
EDI
FORMACIÓN UNIVERSITARIA
C/ Gral. Ampudia, 16
Teléf.: 91 533 38 42 - 91 535 19 32
28003 MADRID
fsi
fproc
La complejidad depende de minimo que sería O(n)
func cosultar (SO :SisOp): e = programa
e = programa;
si SO.Preparados.Ultimo = 0 entonces error
si no
e = minimo (SO.preparados);
fsi
ffunc
La complejidad depende de minimo que sería O(n)
Proc cambiar (SO:SisOp,id : id-prog)
e: programa
e =Sacar(SO.Suspendidos, id)
si no error
preparar (e.estado)
añadir (SO.Preparados, e.id,e.prioridad, e.estado)
si no
e=Sacar(SO.Preparados,id)
suspender (e,estado)
añadir (SO.Suspendidos, e.id,e.prioridad, e.estado)
fsi
pfin
En donde Sacar será una operación parcial de extracción (borrado) en un montículo O(log n) que da
un error si el elemento no existiera.
Func listar(SO: SisOp): ListaOrdenada
Lo: lista Ordenada;
mientras no Vacia(SO.preparados);
Insertar (Lo, minimo (SO.preparados);
fmientras
mientras no Vacia(SO.suspendidos);
Insertar (Lo, minimo (SO.suspendidos);
fmientras
fin listar
Teniendo una complejidad de lineal
TODAS estas complejidades suponen que NO se realizar copias de los Objetos. Si se realizaran las
funciones aunemtarian a O(n) al copiar todas las extructuras
7