Clase Práctica 6

Algoritmos y Estructura de Datos I
Imperativo y Transformaciones de Estados
Pasaje de parámetros - Condicionales
Algoritmos y Estructura de Datos I
¿Dónde estamos?
Teóricas y Prácticas:
• Presentación de la materia. Introducción a la
especificación de problemas.
• Lógica proposicional trivaluada. Semántica de
cortocircuito. Tipos básicos.
• Lenguaje de especificación. Requiere. Asegura. Listas
por comprensión.
• Sintaxis inicial. Tipos básicos. Lógica proposicional.
Tabla de verdad.
• Especificación de Problemas
(P1, P2, P3, P4)
• Introducción a C++, SVN, LATEX
• Trabajo Práctico 1
Nos vamos a meter con transformación de estados...
← Usted está aquí
Primer parcial
Allá por el 22 de Septiembre
Algoritmos y Estructura de Datos I
Algoritmos y Estructura de Datos I
Ejercicio 1
int alCuadrado(int b){
problema alCuadrado(a : Z) = res : Z{
int x = b;
asegura : res == a ∗ a;
x = x * b;
}
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 1.1
int alCuadrado(int b){
problema alCuadrado(a : Z) = res : Z{
int x = b;
asegura : res == a ∗ a;
x = x * b;
}
return x;
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 1.2
int alCuadrado(const int b){
problema alCuadrado(a : Z) = res : Z{
int x = b;
asegura : res == a ∗ a;
x = x * b;
}
return x;
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 1.2
Resuelto
int alCuadrado(const int b){
int x = b;
// estado 1;
// vale x == b;
problema alCuadrado(a : Z) = res : Z{
x = x * b;
// estado 2;
// vale x == x@1 * b;
// implica x == b * b;
asegura : res == a ∗ a;
}
return x;
// vale res == x@2;
// implica res == b * b;
}
No hay chances de que no lo sea.
Algoritmos y Estructura de Datos I
Ejercicio 2
¿La implementación es correcta respecto de la especificación?
int alCuadrado(int b){
problema alCuadrado(a : Z) = {
int x = b;
modifica a;
x = x * b;
asegura :
a == pre(a) ∗ pre(a);
b =
}
x;
return b;
}
Algoritmos y Estructura de Datos I
Ejercicio 2.1
¿La implementación es correcta respecto de la especificación?
problema alCuadrado(a : Z) = {
void alCuadrado(int b){
modifica a;
int x = b;
asegura :
a == pre(a) ∗ pre(a);
x = x * b;
b =
}
x;
}
Algoritmos y Estructura de Datos I
Ejercicio 2.2
¿La implementación es correcta respecto de la especificación?
problema alCuadrado(a : Z) = {
void alCuadrado(int& b){
modifica a;
int x = b;
asegura :
a == pre(a) ∗ pre(a);
x = x * b;
b =
}
x;
}
Algoritmos y Estructura de Datos I
Ejercicio 2.2
Resuelto
void alCuadrado(int& b){
// estado 1;
// vale b == pre(b);
int x = b;
// estado 2;
// vale x == b@1 && b == b@1;
// implica x == pre(b) && b == pre(b);
problema alCuadrado(a : Z) = {
modifica a;
asegura :
a == pre(a) ∗ pre(a);
x = x * b;
// estado 3;
// vale x == x@2 * b@2 && b == b@2;
// implica:
// x == pre(b)*pre(b) && b == pre(b);
}
Es re correcta
b = x;
// estado 4;
// vale x == x@3 && b == x@3
// implica x == pre(b)*pre(b)
// implica b == pre(b)*pre(b)
}
Algoritmos y Estructura de Datos I
Ejercicio 3
int alCuadrado(int b){
problema alCuadrado(a : Z) = res : Z{
int res = b;
asegura :
res == a ∗ a;
b = res * b;
return b;
}
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 3.1
int alCuadrado(int b){
problema alCuadrado(a : Z) = res : Z{
int x = b;
asegura :
res == a ∗ a;
b = x * b;
return b;
}
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 3.1
Resuelto
int alCuadrado(int b){
// local b;
// estado 1;
// vale b == pre(b);
int x = b;
// estado 2;
// vale x == b@1 && b == b@1;
// implica:
// x == pre(b) && b == pre(b);
problema alCuadrado(a : Z) = res : Z{
asegura :
res == a ∗ a;
b = x * b;
// estado 3;
// vale b == x@2 * b@2 && x == x@2;
// implica:
// b == pre(b)*pre(b) && x ==pre(b);
}
return b;
// estado 4;
// vale res == b@3 && x == x@3;
// implica res == pre(b)*pre(b);
}
Algoritmos y Estructura de Datos I
Ejercicio 4
int sumaHasta(const int n){
int i = n;
if (n == 88) {
problema sumaHasta(n : Z) = res : Z{
i = 3916;
requiere : n ≥ 0;
} else {
asegura : res == ∑[0 . . . n];
i = (n+1) * i;
i = i / 2;
}
}
return i;
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Ejercicio 5
int eseDelMedio(const int[] xs, int n){
int i = n;
if (i mod 2 == 0){
i = i / 2;
problema eseDelMedio(xs : [Z], n : Z) = res : Z{
}else{
requiere : n == |xs| ∧ |xs| > 0;
i = i - 1;
asegura : res == xs[n/2];
i = i / 2;
}
}
n = i;
return xs[n];
}
¿La implementación es correcta respecto de la especificación?
Algoritmos y Estructura de Datos I
Último Ejercicio
problema elQueEsMasGrande(a, b, c : Z) = res : Z{
asegura : res == max(a, max(b, c));
}
int max(int x, int& y){
int elQueEsMasGrande(int a, int b, int c){
int m= a;
if (x > y){
y = x;
}
if ( max(a,b) == b ) {
m = max(b,c);
return y;
} else {
}
m = max(a,c);
}
return m;
}
• ¿Está bien la
implementación?
• ¿Puedo demostrar
correctitud?
Algoritmos y Estructura de Datos I
Próximamente
Ciclos
Próximamente:
• Cuando tengo un ciclo hay
algo que se preserva, que es
invariante.
int maximo(const int[] xs, const int n){
int m = xs[0];
int i = 1;
• Vamos a ver correctitud para
ciclos. . .
while ( i < n ) {
if ( m < xs[i] ) {
m = xs[i];
problema maximo(xs : [Z], n : Z) = res : Z{
}
requiere : |xs| > 0 ∧ n == |xs|;
i = i + 1;
asegura :
res == [ x|x ← xs, (∀ y ← xs) x ≥ y ]0 ;
}
return m;
}
}
Algoritmos y Estructura de Datos I