Insoportables Enunciado original Enunciado agregado

Insoportables
Enunciado original
Insoportables es un programa televisivo que aparece todas las tardes en la TV, debatiendo acerca de las relaciones
entre famosos. Debido al crecimiento exponencial de peleas y reconciliaciones, los productores sugirieron el desarrollo
de un sistema que permita seguir el rastro de quiénes están peleados y quiénes no. Además, los productores quieren
saber quiénes son los famosos que actualmente se encuentran en la mayor cantidad de peleas (no importa su historia).
Una premisa de los productores es que una vez que una persona es famosa, sigue siendo famosa para siempre.
Enunciado agregado
Los productores del programa se dieron cuenta que las peleas viejas no garpan tanto como las más recientes.
Además, los mismos famosos se olvidan de sus viejos enemigos, en pos de agarrarse de los pelos con los nuevos. Nos
pidieron que nuestro sistema modele este comportamiento. A los fines prácticos, vamos a considerar que un famoso no
puede tener más de 3 enemigos a la vez.
TAD Insoportables
géneros
paparazzi
exporta
...
usa
...
igualdad observacional
famosos(p) = famosos(p0 ) ∧L
(∀p, p0 : paparazzi) p =obs p0 ⇐⇒
(∀f : famoso)(f ∈ famosos(p) ⇒L enemigos(p, f ) = enemigos(p0 , f ))
observadores básicos
famosos
enemigos
: paparazzi
: paparazzi p × famoso f
−→ conj(famoso)
−→ secu(famoso)
{f ∈ famosos(p)}
generadores
salirAlAire
nuevoFamoso
:
: paparazzi p × famoso f
−→ paparazzi
−→ paparazzi
pelear
otras operaciones
enemigosDePeleador
{f 6∈ famosos(p)}
: paparazzi p × famoso f × famoso f 0
−→ paparazzi
{{f, f 0 } ⊆ famosos(p) ∧ f 6= f 0 ∧L f ∈
6 enemigos(p, f 0 )}
: paparazzi p × famoso f × famoso g
−→ secu(famoso)
{{f, g} ⊆ famosos(p)}
enemigosDeNoPeleador : paparazzi p × famoso f × famoso g × famoso g 0 −→ secu(famoso)
{{f, g, g 0 } ⊆ famosos(p)}
esTercerEnemigo
: paparazzi p × famoso f × famoso g
−→ bool
{{f, g} ⊆ famosos(p)}
...
axiomas
famosos(salirAlAire)
≡ ∅
famosos(nuevoFamoso(p, f )) ≡ Ag(p, f )
famosos(pelear(p, f , f 0 ))
≡ famosos(p)
enemigos(nuevoFamoso(p, g), f )
enemigos(pelear(p, g, g 0 ), f )
≡ if g = f then <> else enemigos(p, f ) fi
≡ if f ∈ {g, g 0 } then if f = g then
enemigosDePeleador(p, f , g 0 ) else enemigosDePeleador(p, f , g) fi
else
enemigosDeNoPeleador(p, f , g, g 0 )
fi
1
≡ if long(enemigos(p, f )) < 3 then
g• enemigos(p, f )
else
g• com(enemigos(p, f ))
fi
enemigosDeNoPeleador(p, f , g, g 0 ) ≡ if esTercerEnemigo(p, f , g) ∨ esTercerEnemigo(p, f , g 0 ) then if
esTercerEnemigo(p, f , g) then
sacar(g, enemigos(p, f )) else sacar(g 0 , enemigos(p, f )) fi
else
enemigos(p, f )
fi
esTercerEnemigo(p, f , g) ≡ long(enemigos(p, g)) = 3 ∧ ult(enemigos(p, g)) = f
enemigosDePeleador(p, f , g)
Fin TAD
Ascensor
Queremos modelar el comportamiento de un ascensor automático. Para simplificar el problema, el ascensor sólo
recorrerá 2 pisos (PB y 1er piso). Este ascensor tiene una capacidad máxima de 5 personas y, para optimizar la
cantidad de viajes, el ascensor no podrá viajar a menos que este completo, en cuanto se completa automáticamente
viaja al otro piso.
TAD Ascensor
géneros
ascensor
exporta
...
usa
...
igualdad observacional
(∀a, a0 : ascensor) (a =obs a0 ⇐⇒ (piso(a) = piso(a0 ) ∧ (∀p: piso)(#personas(a,p) = #personas(a,p0 ))))
observadores básicos
piso
: ascensor a
−→ piso
#personas
: ascensor a × piso p −→ nat
generadores
crearAscensor : piso p
−→ ascensor
llegarPersona : ascensor a × piso p −→ ascensor
...
axiomas
piso(crearAscensor(p))
≡ p
piso(llegarPersona(a, p)) ≡ if piso(a) 6= p then piso(a) else if #personas(a, p) < 4 ∨ #personas(a,
elOtroPiso(p)) < 5 then
p
else
elOtroPiso(p) fi
fi
#personas(crearAscensor(p), p0 )) ≡ 0
#personas(llegarPersona(a, p), p0 ) ≡ if piso(a) 6= p ∨ #personas(a,p) < 4 then #personas(a,p0 ) + if p = p0
then 1 else 0 fi else if piso(a) = p0 then 0 else #personas(a,
p0 ) - if #personas(a, p0 ) ≥ 5 then 5 else 0 fi fi fi
Fin TAD
2