Programación I

Ingeniería en Computación - 2021

Practica 4
Corrección de algoritmos

Ejercicio 1
Complete las anotaciones de estados que faltan en el siguiente algoritmo:

a)
[x = x₀ ∧ y = y₀]
retorno = 0;
[…]
if (x<y)
{
[x0<y0 ∧ retorno = 0]
retorno = x;
[x0<y0 ∧ retorno=x0]
}
else
{
[y0<x0 ∨ y0=x0 ∧ retorno=0 ]
retorno = y;
[y0<x0 ∨ y0=x0 ∧ retorno=y0 ]
}
[(x0<y0 ∧ retorno=x0) ∨ (y0<x0 ∨ y0=x0 ∧ retorno=y0)]

b)
[l == l₀ ∧ len(l) > 1]
retorno = false;
[…]
if (l[1] == 2)
{
[l[1]==2 ∧ retorno=true]
retorno = true;
[l[1]==2 ∧ retorno=true]
}
else
{
[l[1]!=2 ∧ retorno=false]
;
[l[1]!=2 ∧ retorno=false]
}
[(l[1]==2 ∧ retorno=true) ∨ (l[1]!=2 ∧ retorno=false) ]
 r30/2021(MrTín) Página 1 de 8
Programación I
Ingeniería en Computación - 2021

Ejercicio 2
Demostrar que cada uno de los siguientes algoritmos es correcto respecto de su
especificación.

a) identidad
identidad :{x∈ℤ→ℤ}
pre:{x=x0}
post :{retorno=x0 }
algoritmo:
retorno = x;

P = (x==x0)
S = (retorno=x)
Q = (retorno = x0)

sp(x=x0, retorno=x) = (E r)(retorno = x [x:r] ∧ x=x0 [x:r]) = (E r)(retorno = r ∧ r=x0) = retorno = x0 ⇒

retorno = x0

b) duplicar
duplicar :{x∈ℤ}
pre :{x=x0}
post :{x=x0×2}
Algoritmo:
x = x * 2;

P = (x = x0)
S = (x = x2)
Q = (x = x’*2)

sp(x = x0 ∧ x= x’*2) == (exists x’)((x == x’*2)[x:x] ∧ (x’=x0)[x:x’])

c) suma
suma :{x , y∈ℤ→ℤ}
pre :{x=x0∧ y= y0 }
post :{retorno=x0+ y 0}
Algoritmo:
retorno = x;
retorno = retorno + y;

P = (x=x0 ∧ y=y0)
S = (retorno= x + y)
Q = (retorno =x0 + y0)

sp(x=x0 ∧ y=y0, retorno=x0+y0) ⇒ (exists retorno)(retorno= x0+y0 ∧ x=x0 ∧ y=y0) ⇒ (retorno= x0 +

y0)

d) positivo
positivo:{x∈ℤ→Boolean}
pre :{x=x0}
post :{( x0>0∧retorno=true)∨(x 0≤0∧retorno=false)}
Algoritmo:
if (x>0)
{

r30/2021(MrTín) Página 2 de 8
Programación I
Ingeniería en Computación - 2021
retorno = VERDADERO;
}
else
{
retorno = FALSO;
}

P = (x = x0)
B = x0>0
S = VERDADERO;
R = FALSO;

sp(x==x0, if x > 0 : retorno = VERDADERO else : retorno = FALSO) ==

(retorno = VERDADERO ∧ x==x0 ∧ x0>0) ∨ (retorno = FALSO ∧ x==x0 ∧ x0<=0)

e) positivo II
Igual al punto d), pero cambiando la poscondición por la siguiente:
positivo_2 :{x∈ℤ→Boolean}
pre :{x=x0}
post :{( x0>0∧⇒retorno=true)∨(x0≤0⇒retorno=false)}
Algoritmo:
if (x>0)
{
retorno = VERDADERO;
}
else
{
retorno = FALSO;
}

P = (x = x0)
B = x0>0
S = VERDADERO;
R = FALSO;

sp(x==x0, if x > 0 ⇒ ( retorno = VERDADERO) else = (retorno = FALSO) ⇒

(retorno = VERDADERO ∧ x==x0 ∧ x0>0) ∨ (retorno = FALSO ∧ x==x0 ∧ x0<=0)

Ejercicio 3
Para cada una de las siguientes especificaciones, dar un algoritmo y demostrar su
corrección.

a) dos
dos:{x∈ℤ→ℤ}
pre : {true }
post : {retorno=2}

b) bisiesto
bisiesto :{x∈ℤ→Boolean}
pre :{x=x0}
post :{retorno=((4∣x0∧¬100∣x0)∨400∣x0)}
donde a∣b≡(∃k)(b=a×k)

if (4∣x0∧¬100∣x0)∨400∣x0)
{
 retorno = verdadero;
}
else{

retorno = falso;

P = (x= x0)
S = (retorno = Verdadero)
B = (retorno = falso)
Q = (4∣x0 ∧ ¬100∣x0) ∨ 400∣x0)

sp(x = x0 ∧ ((4∣x0∧¬100∣x0)∨400∣x0) ∧ retorno = verdadero) ∨

(x = x0 ∧ NOT ((4∣x0 ∧ ¬100∣x0) ∨ 400∣x0) ∧ retorno = falso)

r30/2021(MrTín) Página 3 de 8
Programación I
Ingeniería en Computación - 2021

c) f
f:{x∈ℤ→ℤ}
pre :{x=x0 }
post :{retorno=1⇔(∃k)( x0=2×k )}

if (∃k)( x0 =2×k )
{

retorno = 1;
}
else
{
retorno = null;
}

P = (x=x0)
S = (retorno = 1)
Q = (retorno = 1 ⇔(∃k)( x0 =2×k ))

sp(x=x0) == (retorno = 1) ⇔ (∃k)( x0 =2×k ) ∨ (x = x0 ∧ NOT ((∃k)( x0 =2×k )) ∧ retorno = null)

Ejercicio 4
Demostrar que cada uno de los siguientes algoritmos es correcto respecto de su
 especificación.

a) suma_uno
suma_uno:{x∈ℤ→ℤ}
pre :{x=x0∧x>0}
post :{retorno=Σ1≤ j≤x 0 j}
variable auxiliar:{i∈ℤ}
Algoritmo:
retorno = 0;
i – 1;
while (i <= x)
{
retorno = retorno + i;
i = i + 1;
}

P = (x=x0 ∧ x>0)
S = (retorno = Σ1≤ j ≤ x0 j )
Q = (retorno = sum(1 ≤ j ≤ x0 j))

sp((retorno = sum(1 ≤ j < i : j) + i ∧ 1 ≤ i ≤ x0+1 ∧ x=x0 ∧ i ≤ x, i = i +1) ==

(exists i’)( i = i’ +1) ∧ retorno = sum(1 ≤ j < i’ : j) + i’ ∧ 1≤ i’ ≤ x0 +1 ∧ x=x0 ∧ i’ ≤ x)
== retorno = sum(1 ≤ j < (i-1) : j) + (i-1) ∧ 1≤ (i-1) ≤ x0 +1 ∧ x=x0 ∧ (i-1) ≤ x) ==
retorno = sum((1≤j< i : j) ∧ (2≤i≤x0+2) ∧ (x=x0 ∧ i ≤ x+1))

Invariante sugerido:

{1≤i≤x0+1∧retorno=Σ1≤j<+x 0j∧x=x0 }

b) suma_todos
suma_todos:{A∈List [ℤ]→ℤ}
pre :{A=A0 }
post :{retorno=Σ0≤i<|A0|A0[i]}
variable auxiliar:{i∈ℤ}
 r30/2021(MrTín) Página 4 de 8
Programación I
Ingeniería en Computación - 2021

Algoritmo:
retorno = 0;
i = 0;
while (i < len(A))
{
retorno = retorno + A[i];
i = i + 1;
}

P = (A=A0)
S = (retorno = retorno + A[i] )
Q = (retorno = Σ0 ≤ i ≤ |A0| A[i])

sp(0 <= i <= |A0 | ∧ retorno = sum(0 <= j < i, A0[j]) ∧ A=A0) ∧ NOT (i < |A0|) ⇒
retorno = sum(0 <= j < |A0|, A0[j] ==
(0 <= i <= |A0| ∧ retorno = suma(0 <= j < i, A0[j]) AND A=A0) ∧ i >= |A0| ⇒ retorno =
suma(0 <= j < |A0|, A0[j])==
(i = |A0| ∧ retorno = suma(0 <= j < |A0|, A0[j]) AND A=A0) ⇒ retorno = suma(0<= j <
|A0|, A0[j]))

Invariante sugerido
0≤i≤
{ |A0|∧retorno=Σ0≤ j<i A0[ j]∧A=A0 }

c) shift_right
shift_right :{A ∈List[ℤ]}
pre :{A=A0∧|A|>0}
post :{|A|=|A0| ∧ A [0]=a[|A0|−1] ∧ (∀i)(1≤i<|A|⇒ A[i]=AO [i−1])}
variable auxiliar:{i , anterior,tmp∈ℤ}
Algoritmo:
 anterior = A[len(A) – 1];
i = 0;
while (i<len(A))
{
tmp = A[i];
A[i] = anterior;
anterior = tmp;
i = i + 1;
}

P = (A=A0 ∧ |A|>0)
S = (|A| = |A0| ∧ A[0]= a[|A0| - 1] ∧ (∀i)(1<=i < |A| ⇒ A[i] = A0[i-1])
Q = (|A| = |A0| ∧ A[0]= a[|A0| - 1] ∧ (∀i)(1<=i < |A| ⇒ A[i] = A0[i-1])

sp( (|A| = |A0| ∧ A[0]= a[|A0| - 1] ∧ (∀i)(1<=i < |A| ⇒ (exists tmp)[tmp:a[i]] = A[i] = A0[i-1]) ==
(|A| = (exists anterior)[anterior:a[i]] ∧ tmp = a[|A0| - 1] ∧ (∀i)(1<= i < |A| ⇒ anterior = A0[i-1]) ==
(|A| = (exists anterior)[anterior: a[i]] ∧ anterior = a[|A0| - 1] ∧ (∀i)(1<=i < tmp ⇒ anterior = A0[i-1])

d) máximo
maximo:{A∈List [ℤ]→ℤ}
pre :{A=A0∧|A|>0}
post :{(∃i)(0≤i<|A0| ∧ retorno=A0[i] ∧ (∀ j)(0≤ j<|A0| ⇒ A0[ j]≤A0[i]))}
variable auxiliar:{i∈ℤ}

r30/2021(MrTín) Página 5 de 8
Programación I
Ingeniería en Computación - 2021

Algoritmo
retorno = A[0];
i = 0;
while (i<len(A))
{
if (A[i] > retorno)
{
retorno = A[i];
}
i = i + 1;
}
 P = (A=A0 ∧ |A|>0)
S = (∃i)(0≤i<|A0| ∧ retorno = A 0[i] ∧ (∀ j)(0≤ j<|A0| ⇒ A 0[ j]≤A0[i])
Q = retorno = A 0[i] ∧ (∀ j)(0≤ j<|A0| ⇒ A 0[ j]≤A0[i])

sp(A=A0 ∧ |A|>0, retorno = A 0[i] ∧ (∀ j)(0≤ j<|A0| ⇒ A 0[ j]≤A0[i]) ⇒

Ejercicio 5
Para cada una de las siguientes especificaciones, dar un algoritmo y demostrar su
corrección.

a) producto
producto :{x , y ∈ℤ→ℤ}
pre :{x=x0 ∧ x>0 ∧ y= y0 ∧ y>0}
post :{retorno=x0×y 0}

b) raizCP
raizCP:{x∈ℤ→ℤ}
pre :{x=x0 ∧ x≥0}
post :{retorno=⌊√ x⌋}
En donde

√x es la raíz cuadrada positiva de x

⌊x ⌋es la parte entera de x.

c) suma_a_todos
suma_a_todos:{A∈List [ℤ] ∧ n∈ℤ}
pre :{A=A0 ∧ n=n0}
post :{|A|=|A0| ∧ (∀ i)(0≤i<|A|⇒ A[i]=A0[i]+n0)}

r30/2021(MrTín) Página 6 de 8
Programación I
Ingeniería en Computación - 2021
d) doble_suma
doble_suma :{x∈ℤ→ℤ}
pre :{x=x0}
post :{retorno=Σ1≤i≤x Σ1≤j≤ij}
0

e) permuta
permuta :{A ∈List [ℤ]}
pre :{A=A0 }
|A|=|A0| ∧
post :
{ A0[i]=A0[k ]) )}
(∀i) 0≤i<|A|⇒(# j) 0≤ j<|A| ∧
( (
=(# k) 0≤k<|A| ∧
A0[i]=A0[ j]) (

Ejercicio 6
Ordenar los elementos de una lista es un problema que puede especificarse de
forma sencilla, pero cuyas soluciones no son triviales. A continuación
presentamos un algoritmo llamado sort por selección que resuelve el problema
utilizando el algoritmo auxiliar por_mínimo_desde. Demostrar que es correcto
respecto de su especificación.

sort :{A∈List [ℤ]}

pre :{A=A0∧|A|>0}
|A|=|A0| ∧
(∀i)(0≤i<|A|−1⇒ A[i]≤A[i+1]) ∧
∧
post :
{
(∀ j) 0≤ j<|A|⇒(# k) 0≤k <|A|
( ( )}
A0[ j]= A[l])

=(# l) 0≤l<|A| ∧
A0[ j]= A0[k]) (
variables auxiliares:{i , k ,aux∈ℤ}
Algoritmo
i = 0;
while (i<len(A))
{
k = pos_minimo_desde(A,i);
aux = A[i];
A[i] = A[k];
A[k] = aux;
i = i + 1;

r30/2021(MrTín) Página 7 de 8
Programación I
Ingeniería en Computación - 2021
}

pos_minimo_desde :{A∈List[ℤ]∧d∈ℤ→ℤ}
A=A0 ∧
pre :
{
d=d0 }
|A|>0 ∧

post : d
{ 0≤retorno≤|A0| ∧
(∀ j)(d0≤ j<|A0| ⇒ A0[retorno]≤A0[ j]) }
variables auxiliares:{i∈ℤ}
Algoritmo
retorno = d;
i = d + 1;
while (i < len(A))
{
if (A[i]<A[retorno])
{
retorno = i;
}
i = i + 1;
}

r30/2021(MrTín) Página 8 de 8