Está en la página 1de 11

TEORIA.

{ Pre: number = NUMBER ʌ NUMBER > 0 }

Por qué escribimos number = NUMBER? Tenemos que tener en cuenta que
number es una variable y su valor puede cambiar durante la ejecución del
algoritmo.
Cuando escribamos la postcondició haremos referencia al valor inicial de la
variable number. La forma de indicar el valor inicial es mediante:

number = NUMBER

• operadores aritméticos:

símbolo nombre se lee como

+ suma más
- resta menos
* multiplicación por
/ división dividido
div división (parte entera) parte entera de la división
mod división (residuo) residuo de la división
Σ sumatorio suma desde ... hasta ...

• operadores relacionales:

símbolo nombre se lee como

< desigualdad es menor que


≤ desigualdad es menor o igual que
> desigualdad es mayor que
≥ desigualdad es mayor o igual que
= igualdad es igual que
≠ desigualdad es distinto que

• operadores lógicos:

símbolo nombre se lee como

ʌ conjunción lógica y
v disjunción lógica o
¬ negación lógica no
⇒ implicación en sentido único entonces
⇔ doble implicación si y solo si

• operadores de conjuntos:

símbolo nombre se lee como

{,} delimitadores de conjuntos el conjunto formado por

Página 1 de 11
∈ pertenencia a conjuntos pertenece a
∉ pertenencia a conjuntos (negación) no pertenece a
∪ unión de conjuntos la unión de ... y ...
∩ intersección de conjuntos la intersección de ... y ...

• cuantificadores:

símbolo nombre se lee como

∀ cuantificador universal para cualquier


∃ cuantificador existencial existe como mínimo
# cuantificador existencial (negación) no existe ningún
: tal que

• números:

símbolo nombre se lee como


N números naturales N
Z números enteros Z
Q números racionales Q
R números reales R
C números complejos C
√ raíz cuadrada raíz de
∞ infinito infinito
|| valor absoluto valor absoluto de
% porcentaje porcentaje de

Precondición: debemos indicar que el método recibe dos enteros positivos.


Cómo lo hacemos? Escribimos:
{ Pre: x=X ʌ y=Y ʌ X>0 ʌ Y>0 }

Define las declaraciones (no las implementaciones) de los métodos


init_hospital, new_medicine, add_units_medicine del ejercicio anterior en
lenguaje algorítmico.

a) Por cada declaración, añade las pre y post condiciones en lenguaje


algorítmico.

a)

action init_hospital (in/out h : tHospital)

Pre: {h = H}
No hay que definir variables pues todas vienen como parámetros

Post: {h.numPat = 0 y h.numAdm = 0 y h.numMed = 0}

Página 2 de 11
action new_medicine (in/out h: tHospital; in id: integer; in name: string;
in lab: string)

Pre:{h = H y id = ID y ID>0 y name = NAME y lab = LAB}

No hay que definir variables pues todas vienen como parámetros

Post: { (Ǝi : 0 < i ≤ H.numMed : h.numMed = H.numMed y


h.pharmacy[i].code = ID) o (h.numMed= H.numMed+1 y
h.pharmacy[h.numMed].code = ID y h.pharmacy[h.numMed].name =
NAME y h.pharmacy[h.numMed].lab = LAB y h.pharmacy[h.numMed].units
= 0) }

action add_units_medicine (in/out h: tHospital; in idMed : integer;


in units : integer)

Pre: {h = H y y idMed = IDMED y IDMED>0 y units = UNITS y UNITS>=0}

No hay que definir variables pues todas vienen como parámetros

Post: { (Ǝi : 0< i ≤ H.numMed : H.pharmacy[i].code = IDMED y


h.pharmacy[i].units = H.pharmacy[i].units + UNITS) o h = H}

a) Define las declaraciones (no las implementaciones) de los métodos


new_client, new_building, new_price del ejercicio anterior en
lenguaje algorítmico. Para cada declaración, añade las pre y post
condiciones en lenguaje algorítmico.

a)
action new_client(in/out a: tAgency; in code: integer; in t: tClientType; in name:
string; in idcard: string; in email: string)
Pre:
{a = A y code = CODE y CODE>0 y t = T y name = NAME y idcard =
IDCARD y email = EMAIL}

No es necesario definir variables, todas vienen como parámetro.

Post:
{ (Ǝi : 0 < i ≤ A.num_clients : a.num_clients = A.num_clients y
a.clients[i].code = CODE) o (a.num_clients= A.num_clients+1 y
a.clients[A.num_clients].code = CODE y a.clients[A.num_clients].type = T y
a.clients[A.num_clients].name = NAME y a.clients[A.num_clients].idcard =
IDCARD y a.clients[A.num_clients].email = EMAIL) }

action new_building(in/out a: tAgency; in code: integer; in addr: string; in


nrooms: integer; in parking: boolean; in balcony: boolean; in c: char; in area:

Página 3 de 11
real; in bc: tBuildingconditions; in owner: integer; in price: real; in date: tDate)

Pre:
{a = A y code = CODE y CODE>0 y add=ADDR y nrooms=N y N>0 y
parking=P y balcony=B y y c=C y area=AREA y AREA>0.0 y bc=BC y
owner=O y price=PRICE y PRICE >= 0.0 y date=DATE}

No es necesario definir variables, todas vienen como parámetro.

Post:
{ (Ǝi : 0 < i ≤ A.num_buildings : a.num_buildings = A.num_buildings y
a.buildings[i].code = CODE) o (Ǝi : 0 < i ≤ A.num_clients : A.clients[i].code = O
y a.num_buildings = A.num_buldings+1 y a.buildings[A.num_buildings].code =
CODE y a.buildings[A.num_buildings].addr = ADDR y
a.buildings[A.num_buildings].number_rooms = N y
a.buildings[A.num_buildings].parking = P y
a.buildings[A.num_buildings].balcony = B y
a.buildings[A.num_buildings].energy_classification = C y
a.buildings[A.num_buildings].area = AREA y
a.buildings[A.num_buildings].conditions = bc y
a.buildings[A.num_buildings].owner = O y
a.buildings[A.num_buildings].history.changes[0].price = PRICE y
a.buildings[A.num_buildings].history.changes[0].date =
DATE y a.buildings[A.num_buildings].history.changes_size = 1) }

action new_price (in/out a: tAgency; in code: integer; in price: real; in date:


tDate)

Pre:
{a = A y code = CODE y CODE>0 y price= P y P>=0.0 y date=D y ( (Ǝi : 0
< i ≤ A.num_buildings : A.buildings[i].code = CODE y
A.buildings[i].history.changes[A.buldings[i].history.changes_size].date < D) o
( no Ǝi : 0 < i ≤ A.num_buildings : A.buildings[i].code = CODE) ) }

No es necesario definir variables, todas vienen como parámetro.

Post:
{ (Ǝi : 0 < i ≤ A.num_buildings : a.num_buildings = A.num_buildings y
a.buildings[i].code = CODE y a.buildings[i].changes_size =
A.buildings[i].changes_size+1 y
a.buildings[i].history.changes[a.buldings[i].history.changes_size].price = P y
a.buildings[i].history.changes[a.buildings[i].history.changes_size].date = D) o
(no Ǝi : 0 < i ≤ A.num_buildings : A.buildings[i].code = CODE) }

Define las declaraciones (no las implementaciones) de los métodos


init_chess_tournament y new_player del ejercicio anterior en lenguaje
algorítmico.

Página 4 de 11
a) Por cada declaración, añade las pre y post condiciones en lenguaje
algorítmico.

action init_chess_tournament (inout c: tChessTournament)

Pre: {c = C}

No hay que definir variables pues todas vienen como parámetros

Post: {c.name = "OPEN CHESS 2020” i c.location = "SPAIN" i c.date.day = 30 i


c.date.month = 1 i c.date.year = 2020 i c.numPlayers = 0 i c.numRounds = 0}

action new_player (inout c: tChessTournament, in id: integer,


in name: string, in age: integer, in nationality: string, in elo: integer)

Pre:{ c = C i id = ID i ID>0 i name = NAME i NAME != “” i age = AGE i AGE >0 i


nationality = NATIONALITY i NATIONALITY != “” i elo = ELO i ELO > 0}

No hay que definir variables pues todas vienen como parámetros

Post: { (Ǝj : 0 < j j : 0 < j ≤ C.numPlayers : c.numPlayers = C.numPlayers i


c.players[j].id = ID) o (c.numPlayers= C.numPlayers+1 i
c.players[c.numPlayers].id = ID i
c.players[c.numPlayers].name = NAME i
c.players[c.numPlayers].age = AGE i
c.players[c.numPlayers].nationality = NATIONALITY i
c.players[c.numPlayers].elo = ELO i
c.players[c.numPlayers].level = LEVEL ) }

Define la función check_enough_medicine que devuelve cierto si hay


suficientes existencias de un determinado medicamento en la farmacia del
hospital para atender durante un día todos los tratamientos de los ingresos
donde figura.

function check_enough_medicine (h: tHospital; idMed: integer): bool

Para implementar esta función se tiene que descomponer en acciones o


funciones más simples (mediante el diseño descendente) que también se
tendrán que implementar.

Como los tipos ya los tenemos definidos, la abstracción de datos ya la tenemos


hecha, y por lo tanto ya podemos utilizarlos.

Nivel 1:

Página 5 de 11
Primer nivel.

function check_enough_medicine (h: tHospital; idMed: integer): bool

var
itemsStored, itemsNeeded: integer;
end var

itemsStored := search_medicine_pharmacy (h, idMed); (nivel 2)

if itemsStored<0 then
error {This medicine does not exist in the pharmacy}

else

itemsNeeded := count_doses_admissions (h, idMed); (nivel 2)

end if

return (itemsNeeded <= itemsStored);

end function

Nivel 2:

function search_medicine_pharmacy (h: tHospital;


idMed: integer) : integer

var
units, i: integer;
end var

units := -1;
i := 1;

while (i < h.numMed) and (units < 0) do

if (h.pharmacy[i].code = idMed) then


units := h.pharmacy[i].units;

else

i := i +1;

end if

end while

Página 6 de 11
return units;

end function

Nivel 2:

function count_doses_admissions (h: tHospital; idMed:integer) : integer

var
i, num: integer;
end var

num := 0

for i:=1 to h.numAdm do

num := num + count_doses_treatment (h.admissions[i].treatment,idMed); (nivel


3)

end for

return num;

end function

Nivel 3:

function count_doses_treatment (t: tTreatment; idMed:integer) : integer

var
units, i: integer;
end var

units := 0;
i := 1;

while (i < t.numDoses) and (units = 0) do

if (t.doses[i].idMed = idMed) then

units := t.doses[i].units * t.doses[i].timesPerDay;

else

i := i +1;

end if
end while

Página 7 de 11
return units;
end function

Define en lenguaje algorítmico, la función check_sales, que devuelve el


porcentaje de inmuebles que ha tenido más de una bajada de precio en su
historial. Para este cálculo sólo se deben tener en cuenta los inmuebles que
NO están dados de baja.

function check_sales (a: tAgency): real

Para implementar esta función se tiene que descomponer en acciones o


funciones más simples (mediante el diseño descendente) que también se
tendrán que implementar.

Como los tipos ya los tenemos definidos, la abstracción de datos ya la


tenemos hecha, y por lo tanto ya podemos utilizarlos.

Nivel 1:

function check_sales (a: tAgency): real

Pre: { Ǝi : 0< i ≤ a.num_buildings : a.buildings[i].status ≠ off }

var
num_available, index: integer;
num_sales: integer;
porc_sales: real;
end var
num_available := 0;
num_sales := 0;

for index := 1 to a.num_buildings do

if is_available (a.buildings[index]) then (nivel 2)

num_available := num_available + 1;

if get_number_sales (a.buildings[index]) > 1 then (nivel2)

num_sales := num_sales + 1;

end if

end if

end for

Página 8 de 11
porc_sales:=(intToReal(num_sales) / intToReal(num_available))*100.0;

return porc_sales;

end function

Nivel 2:

function is_available (b: tBuilding) : boolean

return (b.status ≠ off);

end function

function get_number_sales (b: tBuilding): integer

Pre: { b.history.changes_size>0 and ∀i : 0< i <b.history.changes_size :


b.history.changes[i].date < b.history.changes[i+1].date }

var
last_price : real;
index, sales: integer;
end var

sales := 0;
last_price := b.history.changes[1].price;

for index := 2 to b.history.changes_size do

if b.history.changes[index].price < last_price then

sales := sales + 1;
last_price := b.history.changes[index].price;

end if
end for

return sales;

end function

Define en lenguaje algorítmico la acción levels_winners que muestra un


listado por pantalla con los niveles que tienen los jugadores que han ganado en
cada ronda.

action levels_winners (c:tChessTournament)

Página 9 de 11
Para implementar esta función se tiene que descomponer en acciones o
funciones más simples (mediante el diseño descendente) que también se
tendrán que implementar.

Nivel 1: (nota: separar en otro nivel el bucle interior “for j:=1 to r.numPairings
do” también es una solución correcta)

action levels_winners (c: tChessTournament)

var
i, j: integer;
r: tRound;
p: tPairing;
res: tResult;
levelW, levelB: tLevel;
end var

for i:=1 to c.numRounds do

r := c.rounds[i];
writeString(Elo's of round);
writeInteger(r.number);

for j:=1 to r.numPairings do


p := r.pairings[j];
res := p.result;
if (res=whiteWins) then
levelW := get_level(c, p.idWhitePlayer);
writeString(levelW);
else if (res=blackWins) then
levelB := get_level(c, p.idBlackPlayer);
writeString(levelB);
end if

end for

end for

end action

Página 10 de 11
Nivel 2:
function tLevel get_level(c: tChessTournament, id: integer)

var
l: tLevel;
elo: integer;
end var

elo := get_elo(c, id);


if (elo <= 1800) then
l := novice;
else if (elo <= 2000) then
l := medium;
else if (elo <= 2400) then
l := advanced;
else l := master;
end if
return l;
end function

Nivel 3:

function int get_elo(c: tChessTournament, id: integer)

var
i: integer;
elo: integer;
end var

i := 0;
while (i < c.numPlayers) do
if (c.players[i].id = id) then
elo := c.players[i].elo;
end if
i++;
end while

return elo;

end function

Página 11 de 11

También podría gustarte