Tema 5 Derivacion Algoritmos

d l í d l óMetodología de la Programación

Tema V. Diseño de algoritmos iterativosTema V. Diseño de algoritmos iterativos

Diseño de algoritmos iterativos correctosDiseño de algoritmos iterativos correctos

1MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos

1 Derivación de algoritmos1. Derivación de algoritmos

2. Diseño de algoritmos correctos con bucles

3. Diseño de bucles mediante debilitamiento de su postcondiciónde su postcondición

4. Diseño de algoritmos iterativos más complejos

5. Aplicación al diseño de algoritmos iterativos5. Aplicación al diseño de algoritmos iterativos de búsqueda en una tabla

6 li ió l di ñ d l i d6. Aplicación al diseño de algoritmos de ordenación interna de una tabla

MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 2

1 Derivación de algoritmos1. Derivación de algoritmos

Diseñar el siguiente algoritmoDiseñar el siguiente algoritmo

{ x=A ∧ y=B }??????{ x=B ∧ y=A }

Hagamos un intento de diseño Para empezar vamos aHagamos un intento de diseño. Para empezar vamos amodificar el valor de una de las variable. Por ejemplode la variable <x>:de la variable <x>:

{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }???{ x=B ∧ y=A }

Hagamos que el valor de la variable <y> sea el queHagamos que el valor de la variable <y> sea el que debe finalmente tener finalmente, es decir, <A>:

{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }???{ x=B ∧ y=A }

Sólo falta modificar el valor de la variable <x> para queSólo falta modificar el valor de la variable <x> para que valga , sin alterar el valor de <y>:

{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }x := x – y;{ x=B ∧ y=A }???{ x=B ∧ y=A }

¿ Es correcto el diseño realizado ?

¡ El diseño está concluido y es correcto (regla del¡ El diseño está concluido y es correcto (regla del debilitamiento de la postcondición) !

{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }{ y }x := x – y;{ x=B ∧ y=A }⇒⇒{ x=B ∧ y=A }

He aquí el algoritmo deducido por derivación delHe aquí el algoritmo deducido por derivación del código a partir de su especificación:

{ x=A ∧ y=B }x := x + y;y := x – y;y := x – y;x := x – y;{ x=B ∧ y=A }

Hagamos un segundo diseño modificando en primerHagamos un segundo diseño, modificando en primer lugar el valor de la variable <y>:

{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }???{ }{ x=B ∧ y=A }

Hagamos que el valor de la variable <x> sea igual aHagamos que el valor de la variable <x> sea igual a , sin modificar el valor de la variable <y>:

{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }x := x – y;{ }{ x=B ∧ y=A‐B }???{ x=B ∧ y=A }{ y }

Sólo falta modificar el valor de la variable <y> para queSólo falta modificar el valor de la variable <y> para que valga <A>, sin alterar el valor de <x>:

{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }x := x – y;{ }{ x=B ∧ y=A‐B }y := x + y;{ x=B ∧ y=A }{ y }

¡Hemos sabido derivar un segundo diseño del¡Hemos sabido derivar un segundo diseño del algoritmo!

2 Diseño de algoritmos correctos con bucles2. Diseño de algoritmos correctos con bucles

Diseñar el siguiente algoritmo con un bucle:Diseñar el siguiente algoritmo con un bucle:

{ P }??????{ Q }

Escribimos el bucle y ponemos interrogantes dondeEscribimos el bucle y ponemos interrogantes dondehaya que incluir código para completar el diseño:

{ P }???mientrasQue ??? hacermientrasQue ??? hacer

???finMQ???{ Q }

Lo primero que debemos hacer es dar con un métodoiterativo que resuelva el problema y resumirlo en unpredicado invariante. Otra alternativa es escribirprimero el invariante y deducir de él un métodoiterativo.

Anotamos en el bucle el predicado invariante :Anotamos en el bucle el predicado invariante :

{ P }???mientrasQue ??? hacer { I } (1)

???finMQ???{ Q }{ Q }

Paso 1 El predicado invariante puede deducirse enPaso 1. El predicado invariante puede deducirse enmuchos casos aplicando técnicas de debilitamiento dela postcondición <Q>la postcondición <Q>.

Paso 2 Diseñamos el código previo al bucle:Paso 2. Diseñamos el código previo al bucle:

{ P }( )Acción_previa diseñar este código (2)

{ I }mientrasQue ??? hacer { I } (1)Q { } ( )

???finMQ??????{ Q }

Pasos 3 y 4 Deducimos la condición <C> del bucle y elPasos 3 y 4. Deducimos la condición <C> del bucle y elcódigo posterior al bucle:

{ P }Acción_previa (2){ I }{ I }mientrasQue C hacer { I } (1),(3)

???finMQ{ ¬C ∧ I }Acción posterior diseñar este código (4)_p g ( ){ Q }

Pasos 5 y 6 Diseñamos el código interior del buclePasos 5 y 6. Diseñamos el código interior del bucle,garantizando su terminación mediante una función decota:cota:

{ P }( )Acción_previa (2)

{ I }mientrasQue C hacer { I } { f_cota } (1),(3),(6)Q { } { _ } ( ),( ),( )

{ I ∧ C }Acción_a_iterar diseñar este código (5){ I }{ I }

finMQ{ I ∧ ¬C }Acción_posterior (4){ Q }

3 Diseño de bucles mediante debilitamiento3. Diseño de bucles mediante debilitamiento de su postcondición

Derivar un diseño iterativo del siguiente algoritmo:

{ cierto }??????{ sumar(T) = (Σα∈[1,N].T[α]) }

El esquema algorítmico iterativo a diseñar es elEl esquema algorítmico iterativo a diseñar es elsiguiente:

{ cierto }??????mientrasQue ??? hacer { ¿I? }

???finMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }{ ( ) ( α [ , ] [α]) }

Paso 1 Debilitamos la postcondición sustituyendo la constantePaso 1. Debilitamos la postcondición sustituyendo la constante<N> por una variable, por ejemplo, <hasta>, y el resultado de lafunción <sumar(T)> por una variable, por ejemplo <suma>:( )

{ cierto }{ }???mientrasQue ??? hacer { I: suma = (Σα∈[1,hasta].T[α]) }

??????finMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }

Paso 2 Procedemos a diseñar las acciones previas al bucle:Paso 2. Procedemos a diseñar las acciones previas al bucle:

{ cierto }{ cierto }hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue ??? hacer { I: suma = (Σα∈[1,hasta].T[α]) }

???finMQfinMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }

Pasos 3 y 4 Deducimos ahora la condición del bucle y el códigoPasos 3 y 4. Deducimos ahora la condición del bucle y el códigoposterior al bucle:

{ cierto }hasta := 1; suma := T[1];hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue not (hasta=N) hacer

{ I: suma = (Σα∈[1,hasta].T[α]) }???

finMQQ{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta=N }devuelve suma; { (T) (Σ [1 N] T[ ]) }{ sumar(T) = (Σα∈[1,N].T[α]) }

Pasos 5 y 6 Deducimos el código interior al bucle e identificamosPasos 5 y 6. Deducimos el código interior al bucle e identificamosuna función de cota que asegure su terminación:

{ cierto }hasta := 1; suma := T[1];hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue not (hasta=N) hacer { f_cota = N – hasta }

{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta≠N }hasta := hasta + 1; suma := suma + T[hasta];{ suma = (Σα∈[1,hasta].T[α]) }{ ( [ , ] [ ]) }

finMQ{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta=N }de el e devuelve suma; { sumar(T) = (Σα∈[1,N].T[α]) }

El algoritmo iterativo diseñado es el siguiente:El algoritmo iterativo diseñado es el siguiente:

{ cierto }hasta := 1; suma := T[1];mientrasQue not (hasta=N) hacer

{ suma = (Σα∈[1,hasta].T[α]) }{ suma (Σα∈[1,hasta].T[α]) }hasta := hasta + 1; suma := suma + T[hasta];

finMQd ldevuelve suma; { sumar(T) = (Σα∈[1,N].T[α]) }

Conviene anotar los bucles con el predicado invariante que nosh b l d dha abierto las puertas de su diseño ya que constituye unexcelente elemento de documentación del código.

Nuevo problema de diseño iterativo Derivar un diseñoNuevo problema de diseño iterativo. Derivar un diseñoiterativo del siguiente algoritmo que trabaja con unfichero <f> de datos numéricos:fichero <f> de datos numéricos:

{ cierto }???{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }{ ( [ , ( )] ( , )) }

El esquema algorítmico a diseñar es el siguiente:El esquema algorítmico a diseñar es el siguiente:

{ cierto }???mientrasQue ??? hacer { ¿I? }Q { ¿ }

???finMQ??? ??? { suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

Paso 1 Debilitamos la postcondición sustituyendo el valorPaso 1. Debilitamos la postcondición sustituyendo el valorconstante <numDatos(f)> por el valor variable<numLeídos(f)>:( )

{ cierto }{ }???mientrasQue ??? hacer

{ I: modo(f) Lec{ I: modo(f) = Lec∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }

???finMQ??? { suma = (Σα∈[1 numDatos(f)] dato(f α)) }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

Paso 2 Procedemos a diseñar las acciones previas al bucle:Paso 2. Procedemos a diseñar las acciones previas al bucle:

{ cierto }{ cierto }iniciarLectura(f); suma := 0.0;{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue ??? hacer

{ I: modo(f) = Lec∧ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }

???finMQ??? { suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

Pasos 3 y 4 Deducimos ahora la condición del bucle y el códigoPasos 3 y 4. Deducimos ahora la condición del bucle y el códigoposterior al bucle:

{ cierto }iniciarLectura(f); suma := 0.0;{ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }{ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue not finFichero(f) hacer

{ I: modo(f) = Lec∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }

???finMQQ{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) ∧ finFichero(f) ∧ finFichero(f)=(numLeídos(f)=numDatos(f)) }∧ finFichero(f)=(numLeídos(f)=numDatos(f)) }

nula; { vamos a eliminarla por ser innecesaria }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

Pasos 5 y 6 Deducimos el código interior al bucle e identificamosPasos 5 y 6. Deducimos el código interior al bucle e identificamosuna función de cota que asegure su terminación:

{ cierto }iniciarLectura(f); suma := 0 0;iniciarLectura(f); suma := 0.0;{ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue not finFichero(f) hacer

{ f_cota = numDatos(f) ‐ numLeídos(f) }{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) ∧ ¬finFichero(f) ( )∧ finFichero(f)=(numLeídos(f)≠numDatos(f)) }

leer(f, nuevo); suma := suma + nuevo;{ modo(f) = Lec ∧ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }

finMQ{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

El algoritmo iterativo diseñado es el siguiente:El algoritmo iterativo diseñado es el siguiente:

{ cierto }iniciarLectura(f); suma := 0.0;mientrasQue not finFichero(f) hacer

{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }{ modo(f) Lec ∧ suma (Σα∈[1,numLeídos(f)].dato(f,α)) }leer(f, nuevo); suma := suma + nuevo;

finMQ{ (Σ [ t (f)] d t (f )) }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }

Recordamos que conviene anotar los bucles con el predicadoinvariante que nos ha abierto las puertas de su diseño ya queconstituye un excelente elemento de documentación del código.

4 Diseño de algoritmos iterativos más4. Diseño de algoritmos iterativos más complejos

Diseñar el siguiente algoritmo sin utilizar la operación de potenciaciónde potenciación.

{ n≥0 }???{ elevar(x,n) = xn }

Aplicaremos un método cálculo basado en las siguienteAplicaremos un método cálculo basado en las siguiente propiedades.

Método de cálculo de xn de coste logarítmico en <n>:

• n 0 → xn 1 0• n=0 → xn = 1.0• n>0 ∧ n mod 2 = 0 → xn = [xn/2]2

• n>0 n mod 2 ≠ 0 → xn x [xn/2]2• n>0 ∧ n mod 2 ≠ 0 → xn = x.[xn/2]2

El esquema algorítmico a diseñar es el siguiente:El esquema algorítmico a diseñar es el siguiente:

{ n≥0 }???mientrasQue ??? hacer { ¿I? }Q { ¿ }

???finMQ??? ??? { elevar(x,n) = xn }

Un invariante del bucle que permita resolver el problema no es inmediato.Un invariante del bucle que permita resolver el problema no es inmediato.Para construirlo introducimos las variables nVar (valor variable delexponente), resultado (almacena el resultado parcial y final), e (exponentepotencia de 2) y potencias (potencias de 2) :potencia de 2) y potencias (potencias de 2) :

{ Invariante: xn = resultado.[xnVar]e ∧ potencias=xe }

x nVar resultado invariante potencias e

2 0 27 0 [ 27]1 1x 27 1.0 x27 = 1.0 [x27]1 x1 1

x 13 x x27 = x [x13]2 x2 2

x 6 x3 x27 x3 [x6]4 x4 4x 6 x3 x27 = x3 [x6]4 x4 4

x 3 x3 x27 = x3 [x3]8 x8 8

x 1 x11 x27 = x11 [x1]16 x16 16

27 1 2 8 16

x 1 x x x [x ] x 16

x 0 x27 x27 = x27 [x0]32 x32 32

Cálculos realizados: x27 = 1.x1.x2.x8.x16

Paso 1 Esquema iterativo del algoritmo a derivar ElPaso 1. Esquema iterativo del algoritmo a derivar. Elinvariante del bucle se deduce a partir del método decálculo a aplicar:cálculo a aplicar:

{ n≥0 }???mientrasQue ??? hacerQ

{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }???

finMQfinMQ??? { elevar(x,n) = xn }

Paso 2 Diseñamos el código previo al bucle:Paso 2. Diseñamos el código previo al bucle:

{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;{ xn = resultado.[xnVar]e ∧ potencias = xe }{ [ ] p }mientrasQue ??? hacer

{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }??????

finMQ??? { elevar(x,n) = xn }

Pasos 3 y 4 Deducimos la condición del bucle y elPasos 3 y 4. Deducimos la condición del bucle y elcódigo posterior a él:

{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;p{ xn = resultado.[xnVar]e ∧ potencias = xe }mientrasQue not (nVar=0) hacer

{ Inv: xn = resultado [xnVar]e ∧ potencias = xe }{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }???

finMQ{ xn = resultado.[xnVar]e ∧ potencias = xe ∧ nVar=0 }devuelve resultado; { elevar(x,n) = xn }{ elevar(x,n) x }

nVar=0 → xn = resultado.[xnVar]e = resultado.[x0]e

lt d [ ] lt d= resultado.[1]e = resultado

Pasos 5 y 6 Diseñamos el código interior del bucle yPasos 5 y 6. Diseñamos el código interior del bucle yproponemos una función de cota que permite probar suterminación:

{ n≥0 }nVar : n; resultado : 1 0; e : 1; potencias : x;nVar := n; resultado := 1.0; e := 1; potencias := x;mientrasQue not (nVar=0) hacer { f_cota : nVar }

{ xn = resultado.[xnVar]e ∧ potencias= xe ∧ nVar≠0 }si not (nVar mod 2 = 0) entonces

resultado := potencias*resultado;finSifinSinVar := nVar/2; e:= 2*e; potencias:= potencias*potencias;{ xn = resultado.[xnVar]e ∧ potencias= xe }

fifinMQdevuelve resultado; { elevar(x,n) = xn }

El resultado del diseño iterativo es el siguiente:El resultado del diseño iterativo es el siguiente:

{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;mientrasQue not (nVar=0) hacer

{ xn = resultado.[xnVar]e ∧ potencias= xe }{ x resultado.[x ] ∧ potencias x }si not (nVar mod 2 = 0) entonces

resultado := potencias*resultado;fi SifinSinVar := nVar/2; e:= 2*e; potencias:= potencias* potencias;

finMQdevuelve resultado; { elevar(x,n) = xn }

Se ha anotado el bucle con el predicado invariante que resume el método de cálculo aplicadométodo de cálculo aplicado.

5 Aplicación al diseño de algoritmos iterativos5. Aplicación al diseño de algoritmos iterativos de búsqueda en una tabla

Elementos definidos en un programa escrito en Ada.

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Definición del tipo tpTabla que almacena <N> datos de‐‐ tipo tpD‐‐ tipo tpD‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐N : constant integer := ... ; ‐‐ Núm. datos de las tablassubtype tpIndice is integer range 1..N;type tpTabla is array (tpIndice) of tpD;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 5 1 Derivar un diseño iterativo para elProblema 5.1. Derivar un diseño iterativo para elsiguiente algoritmo Ada.

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) function buscar (T : in tpTabla; dato : in tpD)

return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

( [ ] ( ) )‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐f ti b (T i t T bl d t t t D) function buscar (T : in tpTabla; dato : out tpD)

return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

???while ??? loop ‐‐ Invariante

???end loop;p;???

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Paso 1 Proponemos un predicado invariante para el buclePaso 1. Proponemos un predicado invariante para el bucle

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

‐‐ (∃α∈[1,N].T(α)=dato)???hil ??? l (∀ [ h t ] ( ) d t )while ??? loop ‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)???

end loop;???‐‐ T(buscar(T,dato))=dato

end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Paso 2 Diseñamos el código previo al buclePaso 2. Diseñamos el código previo al bucle

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;

(∀ [ h t ] ( ) d t )‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)while ??? loop ‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)

???end loop;???

T(buscar(T dato))=dato‐‐ T(buscar(T,dato))=datoend buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Pasos 3 y 4 Condición del bucle y el código posteriorPasos 3 y 4. Condición del bucle y el código posterior

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;hil t ( (h t ) d t ) lwhile not (T(hasta)=dato) loop‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)???

end loop;‐‐ (∀α∈[1,hasta‐1].T(α)≠dato) ∧ T(hasta)=datodevuelve hasta;devuelve hasta;‐‐ T(buscar(T,dato))=dato

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Pasos 5 y 6 Código interior del bucle y función de cotaPasos 5 y 6. Código interior del bucle y función de cota

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐h t t I dihasta : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;while not (T(hasta)=dato) loop f cota = N hastawhile not (T(hasta)=dato) loop ‐‐ f_cota = N ‐ hasta

‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)‐‐ (∀α∈[1,hasta‐1].T(α)≠dato) ∧ T(hasta)≠datohasta := hasta + 1; ‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)

end loop;devuelve hasta;‐‐ T(buscar(T,dato))=dato

end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : out tpD)

return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

hasta : tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

hasta := 1;while not (T(hasta)=dato) loop

‐‐ (∀α∈[1 hasta‐1] T(α)≠dato)‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)hasta := hasta + 1;

end loop;devuelve hasta;devuelve hasta;

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 5 2 Derivar un diseño iterativo para elProblema 5.2. Derivar un diseño iterativo para elsiguiente algoritmo Ada.

return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

i‐‐ Pre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ ] ( ) ) ( ( )) )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)

return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: ciertoPre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

???end loop;end loop;???

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐b ibegin

‐‐ cierto???while ??? loop

‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato)‐‐ ∧ esta → T(hasta)=dato‐‐ ∧ esta → T(hasta)=dato???

end loop;???‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ , ] ( ) ) ( ( , )) )

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐b ibegin

‐‐ ciertohasta := 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datowhile ??? loop

‐‐ Inv: esta=(∃α∈[1 hasta] T(α)=dato)‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato)‐‐ ∧ esta → T(hasta)=dato???

end loop;???‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)( [ , ] ( ) ) ( , ) )‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ ciertohasta := 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datoesta (∃α∈[1,hasta].T(α) dato) ∧ esta → T(hasta) datowhile not (hasta=N or esta) loop

‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato??????

end loop;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ ∧ (hasta=N ∨ esta)‐‐ ∧ (hasta=N ∨ esta)if esta then return hasta; else return 0; end if;‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)

∧ ((∃α∈[1 N] T(α)=dato) → T(buscar(T dato))=dato)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ ciertohasta := 1; esta := T(hasta)=dato;while not (hasta=N or esta) loop ‐‐ f cota = N ‐ hastawhile not (hasta N or esta) loop f_cota N hasta

‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ ∧ (hasta≠N ∧ ¬esta)∧ (hasta≠N ∧ ¬esta)hasta := hasta + 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato

end loop;end loop;if esta then return hasta; else return 0; end if;‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)

∧ ((∃α∈[1 N] T(α)=dato) → T(buscar(T dato))=dato)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)

return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)∧ ((∃α∈[1,N].T(α) dato) → T(buscar(T,dato)) dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

hasta : tpIndice; esta : boolean;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

hasta := 1; esta := T(hasta)=dato;while not (hasta=N or esta) loopwhile not (hasta=N or esta) loop

‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datohasta := hasta + 1; esta := T(hasta)=dato;

end loop;end loop;if esta then return hasta; else return 0; end if;

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 5 3 Derivar un diseño iterativo del siguienteProblema 5.3. Derivar un diseño iterativo del siguiente algoritmo Ada.

return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

( [ ] ( ) ( ))‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ ] ( ) ) ( ( )) )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

lUtilizaremos: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))t (T d t i f ) (∃ [i f ] T( ) d t )esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)

t i t ireturn integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: ordenada(T,1,N) ‐‐ Post: (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Hemos utilizado los siguientes predicados:Hemos utilizado los siguientes predicados:ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)

Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)

return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))Pre: (∀α∈[1,N 1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

???end loop;end loop;???

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha: tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ ordenada(T,1,N)???while ??? loopwhile ??? loop

‐‐ Inv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)

??????end loop;???‐‐ (¬esta(T dato 1 N) → buscar(T dato)=0)‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Donde: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))esta(T dato inf sup) (∃ [inf sup] T( ) dato)esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ ordenada(T,1,N)izda := 1; dcha := N;‐‐ ordenada(T,1,N) ∧ izda≤dchaordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)while ??? loop

‐‐ Inv: ordenada(T 1 N) ∧ izda≤dchaInv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)???

end loop;end loop;???‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)

∧ (esta(T dato 1 N) → T(buscar(T dato))=dato)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ ordenada(T,1,N)izda := 1; dcha := N;while not (izda = dcha) loopwhile not (izda dcha) loop

‐‐ Inv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)??????

end loop;‐‐ ordenada(T,1,N) ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)‐‐ ∧ izda = dcha‐‐ ∧ izda = dchaif T(izda)=dato then return izda; else return 0; end if;‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)

∧ (esta(T dato 1 N) → T(buscar(T dato))=dato)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha, medio: tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ ordenada(T,1,N)( , , )izda := 1; dcha := N;while not (izda = dcha) loop ‐‐ f_cota = dcha ‐ izda

‐‐ ordenada(T,1,N) ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)ordenada(T,1,N) ∧ esta(T,dato,1,N) esta(T,dato,izda,dcha)‐‐ ∧ izda<dchamedio := (izda + dcha)/2;if T(medio)<dato if T(medio)<dato then izda := medio + 1; else dcha := medio;

end if;‐‐ ordenada(T 1 N) ∧ izda≤dchaordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)

end loop;if T(izda)=dato then return izda; else return 0; end if;if T(izda)=dato then return izda; else return 0; end if;‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)

end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) return integer isfunction buscar (T : in tpTabla; dato : in tpD) return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

izda, dcha, medio: tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

izda := 1; dcha := N;while not (izda = dcha) loopwhile not (izda = dcha) loop

‐‐ ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)medio := (izda + dcha)/2;if T(medio)<dato

then izda := medio + 1; else dcha := medio; end if;

d lend loop;if T(izda)=dato then return izda; else return 0; end if;

end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

6 Aplicación al diseño de algoritmos de6. Aplicación al diseño de algoritmos de ordenación interna de una tabla

Diseñar el siguiente algoritmo Ada:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: (∀α∈[1,N‐1].T(α)≤T(α+1)) ‐‐ ∧ (∀α∈[1,N].(Núm β∈[1,N].To(β)=To(α)) ‐‐ = (Núm β∈[1,N].T(β)=To(α))) ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Utilizaremos:Utilizaremos: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))sonPermutacion(T1,T2,inf,sup) =

(∀α∈[inf,sup].(Núm β∈[inf,sup].T1(β)=T1(α)) = (Núm β∈[inf,sup].T2(β)=T1(α))) 64

Diseñar el siguiente algoritmo Ada:Diseñar el siguiente algoritmo Ada:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) isprocedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To

P t P t i (T T 1 N) d d (T 1 N)‐‐ Post: sonPermutacion(To,T,1,N) ∧ ordenada(T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Hemos utilizado los siguientes predicados: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))sonPermutacion(T1 T2 inf sup) =sonPermutacion(T1,T2,inf,sup) =

(∀α∈[inf,sup].(Núm β∈[inf,sup].T1(β)=T1(α)) = (Núm β∈[inf,sup].T2(β)=T1(α)))

Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

??????while ??? loop ‐‐ Invariante

???end loop;???

end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 6 1 Diseño del algoritmo de ordenación interna porProblema 6.1. Diseño del algoritmo de ordenación interna por selección directa

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Pre: T = To‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

???while ??? loop

I ????‐‐ Inv: ???????

end loop;??????

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

i : integer;i : integer;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

??????while ??? loop

‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???

end loop;??????

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ T = Toi := 0;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)while ??? loop

‐‐ Inv: (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???

end loop;end loop;???‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ T = Toi := 0;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)while not (i = N‐1) loop

‐‐ Inv: (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???

end loop;end loop;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N) ∧ i = N‐1nula; la eliminamos por ser innecesarianula; ‐‐ la eliminamos por ser innecesaria‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

T T‐‐ T = Toi := 0;while not (i = N‐1) loop

‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???while ??? loop

‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)???d lend loop;

???end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i; j := i;‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)while ??? loop

‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))d d (T 1 i) P t i (T T 1 N)‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)

???end loop;??????

end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice; dato : tpD;g j p p

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = Toi := 0;while not (i = N‐1) loop

‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i ; j := i;while not (j = N) loop

‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)???

end loop;( ( ( ) ( ))) ( ( ) ( ))‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))

‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N) ∧ j = Ndato := T(i); T(i) := T(iMenor); T(iMenor) := dato;‐‐ (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice; dato : tpD;g j p p

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = Toi := 0;while not (i = N‐1) loop ‐‐ f_cota = N ‐ i

‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i ; j := i;while not (j = N) loop ‐‐ f_cota = N ‐ j

‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N) ∧ j ≠ Nj := j + 1;if T(j)<T(iMenor) then iMenor := j; end if;

( ( ( ) ( ))) ( ( ) ( ))‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)

end loop;dato := T(i); T(i) := T(iMenor); T(iMenor) := dato;dato := T(i); T(i) := T(iMenor); T(iMenor) := dato;

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 6 2 Diseño del algoritmo de ordenación interna porProblema 6.2. Diseño del algoritmo de ordenación interna por intercambio directo

???while ??? loop

I ???‐‐ Inv: ??????

end loop;??????

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

i : tpIndice;i : tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

??????while ??? loop

‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???

end loop;??????

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ T = Toi := 0;‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))(∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)while ??? loop

‐‐ Inv: (∀α∈[1 N‐i] (∀β∈[N‐i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???

end loop;end loop;???‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging

‐‐ T = Toi := 0;while not (i = N‐1) loopwhile not (i N 1) loop

‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)??????

end loop;‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N) ∧ i = N‐1‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i = N‐1nula; ‐‐ la eliminamos por ser innecesaria‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, j : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???while ??? loop

‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)

??????end loop;???

end loop;end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i j t I dii, j : tpIndice;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = ToT Toi := 0;while not (i = N‐1) loop

‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N‐1i := i + 1; j := 0;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))

T(j 1) (Má [1 j 1] T( ))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)while ??? loop

‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))Inv2: (∀α∈[1,N i+1].(∀β∈[N i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)

???end loop;???

end loop;d d (T 1 N) P t i (T T 1 N)‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ 80

beginT T‐‐ T = To

i := 0;while not (i = N‐1) loop

‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop

‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)

??????end loop;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))∧ T(j+1) (Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ j = N ‐inula; ‐‐ la eliminamos por ser innecesaria‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)

end dend ordenar;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, j : tpIndice; d : tpD;j p p ;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = Toi := 0;while not (i = N‐1) loop ‐‐ f_cota = N ‐ i

‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop ‐‐ f_cota = N ‐ j

‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N ‐ij := j + 1;i (j) (j ) (j) (j) (j ) (j ) iif T(j)>T(j+1) then d := T(j); T(j) := T(j+1); T(j+1):= d; end if;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N) ∧ i ≠ N ‐i∧ ordenada(T,N i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N i

end loop;end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) isp ( p )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

i, j : tpIndice; d : tpD;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

i := 0;while not (i = N‐1) loop

‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop

( ( ( ) ( )))‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)j := j + 1;j := j + 1;if T(j)>T(j+1) then d := T(j); T(j) := T(j+1); T(j+1):= d; end if;

end loop;end loop;

end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Problema 6 3 Diseño del algoritmo de ordenación interna por elProblema 6.3. Diseño del algoritmo de ordenación interna por el método de ordenación rápida (quicksort) de C.A.R. Hoare

???end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Se plantea un diseño por inmersión.

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To

t d d ( 1 ) t i ( 1 )‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) isprocedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha‐‐ Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

???d i k tend quicksort;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin

quicksort(T, 1, N);end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha

t d d ( i d d h ) t i ( i d d h )‐‐ Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = To ∧ izda≤dchaT To ∧ izda≤dchaif izda<dcha then

???while ??? loop

‐‐ Inv: ??????

end loop;??????

end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)

end quicksort;end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote : tpD;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = To ∧ izda≤dchaif izda<dcha then

???while ??? loopwhile ??? loop

‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)( , , , )???

end loop;???

end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

i d d h‐‐ T = To ∧ izda≤dchaif izda<dcha then

‐‐ T = To ∧ izda<dchapivote := T(izda); i := izda + 1; d := dcha;pivote := T(izda); i := izda + 1; d := dcha;‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)while ??? loop

‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))

P t i (T T i d d h )‐‐ ∧ sonPermutacion(To,T,izda,dcha)???

end loop;??????

end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

i d d h‐‐ T = To ∧ izda≤dchaif izda<dcha then

pivote := T(izda); i := izda + 1; d := dcha;while not (i = d+1) loopwhile not (i = d+1) loop

‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha)???

end loop;‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1

(∀ [i d 1 i 1] T( ) ≤ i t ) (∀ [d 1 d h ] i t ≤ T( )) ‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha) ∧ i = d+1T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);quicksort(T, izda, d 1); quicksort(T, d+1, dcha);‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)

end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

‐‐ T = To ∧ izda≤dchaif izda<dcha then

i t T(i d ) i i d 1 d d hpivote := T(izda); i := izda + 1; d := dcha;while not (i = d + 1) loop ‐‐ f_cota = d – i + 1

‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ∧ (∀α∈[izda+1,i 1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha) ∧ i ≠ d + 1 if T(i)≤pivote

then i := i + 1; elsif T(d)≥pivote then d := d – 1;else dato:= T(i); T(i) := T(d); T(d):= dato; i := i + 1; d := d – 1;

end if;i t T(i d ) i d 1 ≤ i d ≤ d h i ≤ d 1‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1

‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha)

end loop;end loop;T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);

end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ 90

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha‐‐ Post: ordenada(T izda dcha) ∧ sonPermutacion(To T izda dcha)Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote, dato : tpD;

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin

if izda<dcha thenpivote := T(izda); i := izda + 1; d := dcha;while not (i = d + 1) loop( ) p

‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)if T(i)≤pivoteif T(i)≤pivotethen i := i + 1; elsif T(d)≥pivote then d := d – 1;else dato:= T(i); T(i) := T(d); T(d):= dato; i := i + 1; d := d – 1;

end if;end loop;T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);quicksort(T, izda, d 1); quicksort(T, d+1, dcha);

end if;end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Tema 5 Derivacion Algoritmos

Documents

Transcript of Tema 5 Derivacion Algoritmos

Calculo Derivacion Individual

Derivacion de is-lm

derivacion funciones trascendentes

Tema 9 Algoritmos sobre listas - Academia Madrid Ingeniería Cartagena99 Centro de ... · 2015. 12. 14. · Programación - Tema 9: Algoritmos sobre listas 3 Algoritmos sobre Arrays

Derivacion a especialistas

Tema V. Fundamentos de algoritmos - UNAM

Tema 21: Algoritmos de exploración de grafos Universidad ...jalonso/cursos/i1m-09/temas/tema-21-1x2.pdf · ... Algoritmos de exploración de grafos Tema 21: Algoritmos de ... grafos

Cajas Y DERIVACION

Calculo 2, derivacion

Prolemas de Derivacion Logica

Algoritmos y Estructuras de Datos Tema 2: Diseño de Algoritmos€¦ · 3. Algoritmos de búsqueda y su complejidad ! 4. Optimización de algoritmos Algoritmos y Estructuras de datos

Cap 9 Derivacion Numérica

Software rayen derivacion

Tema 2 La Eficiencia de Los Algoritmos

Derivacion e integracion numéricas

Tema 1 Algoritmos. IWI-131 - Tema 1 Algoritmos Algoritmos ¿Que es un algoritmo? –“Una lista de instrucciones donde se especifica una sucesión de operaciones.

Tecnicas derivacion

Tema 5 computabilidad y algoritmos

Cap 5 tema algoritmos

Derivacion Made 2013