Invariantes

CC3001
Otoño 2023
¿Qué es un
invariante?
 Propiedad
¿Qué es un que siempre
se cumple
invariante?
 Propiedad
¿Qué es un que siempre
se cumple
invariante?

Es la lógica detrás
de nuestro
algoritmo
 Propiedad
¿Qué es un que siempre
se cumple
invariante?

Es la lógica detrás
de nuestro
algoritmo

Nos permite
discernir si
estamos
resolviendo bien el
problema
 Propiedad
¿Qué es un que siempre
se cumple
invariante?

No quiere decir Es la lógica detrás

que la variable no de nuestro
cambie!! algoritmo

Nos permite
discernir si
estamos
resolviendo bien el
problema
Veamos un ejemplo
def particionLomuto(a,p)
def particionLomuto(a,p)
(i,j) = (0, 0)
n = len(a)
while j < n:
.
.
.
j+=1
return
 • Existe una
propiedad que
siempre se cumple
 • Existe una
propiedad que
siempre se cumple
• La comparación del
a[j] es la lógica del
proceso
• Existe una propiedad
que siempre se
cumple
• La comparación del
a[j] es la lógica del
proceso
• Podemos ver que al
avanzar j, se van
produciendo las
particiones
• Existe una propiedad
que siempre se cumple
• La comparación del
a[j] es la lógica del
proceso
• Podemos ver que al
avanzar j, se van
produciendo las
particiones
• J si varía durante el
proceso
P1 – Contar Vocales
1. Identifiquemos
el invariante
• En las primeras x letras hay
una cantidad y de vocales
• En las primeras x letras hay
una cantidad y de vocales
• Condición de inicio:?
• En las primeras x letras hay
una cantidad y de vocales
• Condición de inicio: 0 vocales
y 0 letras
• En las primeras x letras hay
una cantidad y de vocales
• Condición de inicio: 0 vocales
y 0 letras
• Condición de termino: ?
• En las primeras x letras hay una
cantidad y de vocales
• Condición de inicio: 0 vocales y 0
letras
• Condición de termino: Revisar
ultima letra
2. Ahora en código
 Se utiliza un Contador

def countVowels(Word):
vowels = 0
 Variable auxiliar como
Indice

def countVowels(Word):
vowels = 0
index = 0
 Recorremos el string
Letra a letra
def countVowels(Word):
vowels = 0
index = 0
while index < len(word):
letter = word[index]
def countVowels(Word): Revisamos si la letra es
una vocal
vowels = 0
index = 0
while index < len(word):
letter = word[index]
if letter in
“aeiouáéíóú”:
vowels += 1
index +=1
return vowels
P2 – Palíndromos
1. Identifiquemos
el invariante
• String de largo n
• String de largo n
• 2 Indices, i y j
 Invariante:
• i<j, substring s[0...i−1] es
el inverso del substring
s[j+1...n−1]
• Condición de Inicio: ?
• Condición de Inicio:i=0 , j=n−1
• Condición de Inicio: i=0 , j=n−1
• Condición de termino: ?
• Condición de Inicio: i=0 , j=n−1
• Condición de termino:
o i=j
• Condición de Inicio: i=0 , j=n−1
• Condición de termino:
o i=j
o i>j
2. Ahora en código
 Definimos los Índices

def palindromos(s):
s = s.replace(" ", "").lower()
n = len(s)
i=0
j=n-1
 Marcamos la condición
de Termino
def palindromos(s):
n = len(s)
i=0
j=n–1
while i < j:
 Verificamos la letra actual
def palindromos(s): de ambos sub-strings
n = len(s)
i=0
j=n–1
while i < j:
if s[i] != s[j]:
print(“No es palíndromo”)
return
def palindromos(s):
Nos movemos a la
n = len(s)
derecha (i) e izquierda (j)
i=0
j=n–1
while i < j:
if s[i] != s[j]:
print(“No es palíndromo”)
return
i += 1
j -= 1
print(“Es palíndromo”)
P3 - Bandera Holandesa
a) Analice los posibles invariantes del problema y
dibújelos
1. Identifiquemos
los invariantes
• Q: Situación inicial
• Q: Situación inicial
• R: Arreglo al que queremos llegar
• 4 Invariantes identificados
• Siempre podemos
identificar los 4
grupos
• Siempre podemos
identificar los 4
grupos
• Al clasificarlos
todos, el grupo
indeterminado
quedara vacío
 • Siempre podemos
identificar los 4
grupos
• Al clasificarlos todos,
el grupo
indeterminado
quedara vacío
• En los 4 invariantes
solo cambia la
posición del grupo
indeterminado
b) Programe la solución al problema siguiendo
alguno de los invariantes de la parte a)
• Utilicemos el 3er
invariante
• La idea es utilizar 3
contadores
 • La idea es utilizar 3
contadores
• El fin es poder delimitar los
trozos del arreglo
• Índice 0 a i -> rojo
• Índice 0 a i -> rojo
• Índice i hasta el j -> blanco
• Índice 0 a i -> rojo
• Índice i hasta el j -> blanco
• Índice j hasta el k -> indeterminados
• Índice 0 a i -> rojo
• Índice i hasta el j -> blanco
• Índice j hasta el k -> indeterminados
• Índice k al n-1 -> azul
• Cuando el Índice j supere al k, todos
los elementos estarán ordenados.
Para simplificar el
código usaremos:
• 0 -> rojo
• 1 -> blanco
• 2 -> azul
2. Ahora en código
 Definimos los
Contadores

def ordenarBandera(arr):
i=0
j=0
k = len(arr) - 1
 Establecemos la
condición de Termino

def ordenarBandera(arr):
i=0
j=0
k = len(arr) – 1
while( j <= k):
def ordenarBandera(arr): Caso para una esfera de
i=0 color Rojo
j=0
k = len(arr) – 1
while( j <= k):
if arr[j] == 0:
arr[i], arr[j] = arr[j], arr[i]
i += 1
j += 1
def ordenarBandera(arr): Caso para una esfera de
i=0 color Blanco
j=0
k = len(arr) – 1
while( j <= k):
if arr[j] == 0:
arr[i], arr[j] = arr[j], arr[i]
i += 1
j += 1
elif arr[j] == 1:
j += 1
def ordenarBandera(arr):
i=0 Caso para una esfera de
j=0 color Azul
k = len(arr) – 1
while( j <= k):
if arr[j] == 0:
arr[i], arr[j] = arr[j], arr[i]
i += 1
j += 1
elif arr[j] == 1:
j += 1
else:
arr[j], arr[k] = arr[k], arr[j]
k -= 1
def ordenarBandera(arr):
i=0 Caso para una esfera de
j=0 color Azul
k = len(arr) – 1
while( j <= k):
if arr[j] == 0:
arr[i], arr[j] = arr[j], arr[i]
i += 1 Notemos que no
j += 1 aumentamos el índice j,
porque en k había un valor
elif arr[j] == 1:
no determinado
j += 1
else:
arr[j], arr[k] = arr[k], arr[j]
k -= 1
Invariantes