def main():
#? Definicion local de la variable global que llevara el conteo
global time
#* Establecemos un limite de casos a evaluar
limit = 22
#* Definicion del archivo auxiliar donde escribiremos los resultados
file = open("./files_practices/pract_3.txt", 'w')
#* Llenamos el arreglo con casos aleatorios hasta limit-iteraciones y los imprimimos en el archivo
casosAleatoriosMerge(limit, file)
#* Imprimimos los valores obtenido en el archivo
for i in range(limit):
impresion(file, 2*(i + 1), 2*(i + 1), limit * 2)
#* Llenamos el arreglo con los peores casos hasta limit-iteraciones y los imprimimos en el archivo
peoresCasosMerge(limit, file)
#* Cerramos el archivo
file.close()
#* Graficamos los resultados
grafico = Graphics("./files_practices/pract_3.txt")
grafico.graficar("Merge-Sort", "n: Tamaño del arreglo", "t: numero de iteraciones realizadas", "nlog(n)")
def main():
#? Definicion local de la variable global que llevara el conteo de iteraciones
global time
#* Recibimos por el shell la cantidad de numeros fibonacci a evaluar
limit = int(input("Ingresa la cantidad de numeros Fibobacci a encontrar [F(n)] : "))
#* Abrimos los archivos donde guardaremos los datos recolectados tanto de la funcion recursiva como iterativa
f1 = open("./files_practices/pract_2.1a.txt", 'w')
f2 = open("./files_practices/pract_2.1b.txt", 'w')
#* Para todos los numeros fibonacci entre 1 y lo ingresado desde shell
for i in range(limit):
#* Imprimimos el numero de iteracion, el numero fibonacci y el tiempo que total utilizado
#* y llamamos a la funcion fibonacci recursiva
print("Iteracion : %d" % int(i + 1))
fibonacci = fibRecursivo(i)
print('Numero de la sucecion de fibonacci recursivo: %d' % fibonacci)
print('Tiempo: %d' % time)
#? Escribimos en el archivo correspondiente los resultados del tiempo utilizado y
#? reiniciamos la variable global
impresion(time, f1, i + 1, limit)
time = 0
#* Imprimimos el numero fibonacci y el tiempo que total utilizado
#* y llamamos a la funcion fibonacci iterativa
fibonacci = fibIterativo(i)
print('Numero de la sucecion de fibonacci iterativo: %d' % fibonacci)
print('Tiempo: %d\n\n' % time)
#? Escribimos en el archivo correspondiente los resultados del tiempo utilizado y
#? reiniciamos la variable global
impresion(time, f2, i + 1, limit)
time = 0
#* Llamamos a la funcion que escribe el array de numeros fibonacci que sacamos de la evaluacion anterior
escrituraN(limit, f1)
escrituraN(limit, f2)
#* Llamamos funcion que genera valores aleatorios para verificar a que tipo de funcion corresponde
escribirAlRe(limit, f1)
escribirAlIt(limit, f2)
#* Cerramos los archivos donde escribimos los resultados obtenidos
f1.close()
f2.close()
#* Creamos 2 Objetos de tipo graphics para que nos genere 2 graficas
#* *** Una correspondiente al caso iterativo ***
#* *** Una correspondiente al caso recursivo ***
graphicsRe = Graphics("./files_practices/pract_2.1a.txt")
graphicsIt = Graphics("./files_practices/pract_2.1b.txt")
#* Graficamos los dos graficas a partir de los resultados obtenidos
graphicsIt.graficar("Fibonacci Iterativo", "n = n-esimo termino Fibonacci de la sucesion", "t = total de pasos realizados")
graphicsRe.graficar("Fibonacci Recursivo", "n = n-esimo termino Fibonacci de la sucesion", "t = total de pasos realizados")
def main():
global time
A=[]
file = open("./files_practices/pract_5c.txt", 'w')
limit = 19
#* Determinamos los mejores casos para los peores casos
for i in range(1,20):
n=i
llenarAleatorio(A,n)
CocktailSort(A)
print("Caso aleatorio:", A)
impresion(time, file, limit, i)
A.clear()
time=0
escrituraN(n, file)
#* Determinamos los mejores casos para los peores casos
for i in range(1,20):
n=i
PeorCaso(A,n)
print("Peor caso:", A)
impresion(time, file, limit, i)
A.clear()
time=0
escrituraN(n, file)
#* Determinamos los mejores casos para los mejores casos
for i in range(1,20):
n=i
MejorCaso(A,n)
print("Mejor caso:", A)
impresion(time, file, limit, i)
A.clear()
time=0
escrituraN(n, file)
file.close()
#* Configuracion de la graficas
title = "CockTailSort"
x_label = "n: Tamaño del arreglo"
y_label = "t: Tiempo de ejecución"
big_O = "O(n^2)"
omega = "\Omega(n)"
theta = "\Theta(n)"
#* Graficamos los resultados
graph = Graphics("./files_practices/pract_5c.txt")
graph.graficar(title, x_label, y_label, big_O, theta, omega)
def main():
global time
file = open("./files_practices/pract_5a.txt", 'w')
A = []
tam = 3
limit = 20
#* Elejimos los mejores casos
for i in range(10, limit + 10):
determinarCasos(A, i, 9999)
impresion(time, file, limit + 9, i)
A.clear()
time = 0
escrituraN(limit, file)
#* Elejimos los peores casos
for i in range(10, limit + 10):
determinarCasos(A, i, 9999999999)
impresion(time, file, limit + 9, i)
A.clear()
time = 0
escrituraN(limit, file)
#* Elejimos los mejores casos
for i in range(10, limit + 10):
determinarCasos(A, i, 9)
impresion(time, file, limit + 9, i)
A.clear()
time = 0
escrituraN(limit, file)
file.close()
#* Configuramos las graficas
title = "RadixSort"
x_label = "n: tamaño del arreglo"
y_label = "t: tiempo de ejecucion"
labelO = "\Theta (10n)"
labelT = "\Theta (3n)"
labelOm = "\Theta (1n)"
graph = Graphics("./files_practices/pract_5a.txt")
graph.graficar(title, x_label, y_label, labelO, labelT, labelOm)
def main():
global time
file = open("./files_practices/Practica_6a.txt", 'w')
A = []
limit = 50
alto = limit
mitad = int(limit / 2)
bajo = 0
for i in range(1, limit + 1):
alto = i
mitad = int(i / 2)
casoAleatorio(A, i, bajo, mitad, alto, file, limit + 1)
escrituraN(limit, file)
for i in range(1, limit + 1):
alto = i
mitad = int(i / 2)
peorCaso(A, i, bajo, mitad, alto, file, limit + 1)
escrituraN(limit, file)
for i in range(1, limit + 1):
alto = i
mitad = int(i / 2)
mejorCaso(A, i, bajo, mitad, alto, file, limit + 1)
escrituraN(limit, file)
file.close()
#* Configuracion de la graficas
title = "Maximo SubArreglo Cruzado"
x_label = "n: Tamaño del arreglo"
y_label = "t: Tiempo de ejecución"
big_O = "O(n)"
omega = "\Omega(n)"
theta = "\Theta(n)"
#* Graficamos los resultados
graph = Graphics("./files_practices/Practica_6a.txt")
graph.graficar(title, x_label, y_label, big_O, theta, omega)
def main():
#? Defincion local de las variables globales
global totalTime
global totalSteps
#* Establecemos un limite de evaluaciones de Merge
limit = 25
#? Abrimos el archivo en modo escritura donde escribiremos los resultados de las iteraciones
file = open("./files_practices/pract_3.txt", 'w')
#* Repetimos el algoritmo limit-veces llenandolo aleatoriamente
for i in range(2,limit + 2):
llenadoAleatorio(i)
#? Ordenamos las listas para poderlas graficar mejor
totalTime.sort()
totalSteps.sort()
#? Imprimimos en el archivo los resultados totales del programa
for j in range(limit):
impresion(file,j,totalTime[j],limit- 1)
for j in range(limit):
impresion(file,j,totalSteps[j],limit- 1)
for j in range(limit):
impresion(file,j,totalTime[j],limit- 1)
#* Cerramos el archivo
file.close()
#* Llamamos al objeto que nos permite graficar
graph = Graphics("./files_practices/pract_3.txt")
graph.graficar("Merge","n: Tamaño del Arreglo","t: Número de Iteraciones", "n")
def main():
#?Definimos variables globales que ayudaran al conteo
global time
#* abrimos el archivo donde guardaremos los datos recolectados
file = open("./files_practices/pract_4a.txt", 'w')
limit = 30
#* LLamamos las funciones para cada uno de los casos
CaAleatorio(limit, file)
escrituraN(limit, file)
PResult(limit, file)
escrituraN(limit, file)
#*Cerramos el archivo
file.close()
#*Configuramos la grafica
title = "Partition"
x_label = "n: Tamaño del arreglo"
y_label = "t: Tiempo de ejecución"
big_O = "n"
theta = "n"
#* Graficamos los resultados
graph = Graphics("./files_practices/pract_4a.txt")
graph.graficar(title, x_label, y_label, big_O, theta)
def main():
#? Definicion local de la variable global que contara el total de iteraciones
global time
#* Abrimos los archivos correspondientes sonde se escribiran los resultados obtenidos de time
f1 = open("./files_practices/pract_2.2a.txt", 'w')
f2 = open("./files_practices/pract_2.2b.txt", 'w')
#* Obtenenmos desde shell un valor maximo entero a calcular
num = int(input("Ingrese un numero entero positivo maximo a calcular: "))
#* Para todos los valores desde 0 hasta el valor recibido desde shell
for i in range(num):
#* Llama a la funcion que calculara la suma de los primeros n numeros cubicos recursivamente
print("Iteracion n : %d" % i)
print(
"La suma de los primeros %d numeros cubicos recursivamente: %d\n" %
(i, SRe(i + 1)))
#? Ingreso los valores obtenidos en la lista global
totalTime.append(time)
#* Escribe en el archivo correspondiente los resultados obtenidos
impresion(time, f1, i + 1, num)
#? Reiniciamos el contador global
time = 0
#* Llama a la funcion que calculara la suma de los primeros n numeros cubicos iterativamente
SIt(i + 1)
#* Escribe en el archivo correspondiente los resultados obtenidos
impresion(time, f2, i + 1, num)
#? Reiniciamos el contador global
time = 0
#* Llama a la funcion que escribe en el archivo correspondiente los valores treabajados
escrituraN(num, f1)
escrituraN(num, f2)
#* Lama a la funcion que determina escribe en el archivo correspondiente los resultados de las iteraciones
escribirAlIt(num, f2)
for i in range(num):
impresion(totalTime[i], f1, i + 1, num)
#* Cierra los archivos usados
f1.close()
f2.close()
#* Creamos dos objetos del tipo graphics para graficar nuestros resultados
graphicsRe = Graphics("./files_practices/pract_2.2a.txt")
graphicsIt = Graphics("./files_practices/pract_2.2b.txt")
#* Graficamos los resultados obtenidos
graphicsIt.graficar("Suma de numeros cubicos Iterativo",
"n = n-esimo termino de la suma",
"t = total de pasos realizados")
graphicsRe.graficar("Suma de numeros cubicos Recursivo",
"n = n-esimo termino de la suma",
"t = total de pasos realizados")
def main():
#? Definicion local de las variable global que llevara el conteo
global time
global totalTime
global totalSteps
#* Definicion del archivo auxiliar donde escribiremos los resultados
file = open("./files_practices/pract_4b.txt", 'w')
#? Definicion local de arreglos
A_hip = []
A_middle = []
#*Para todos los valores dentro de 20
for i in range(20):
#*Limpiamos el arreglo
A_middle.clear()
#*Le damos valores necesarios para crear el arreglo
n = random.randint(4, 30)
p = 0
r = n - 1
llenarAleatoriamente(A_middle, n)
print("r = %d" % r)
print("inorder A = ", A_middle)
#*llamamos quickSortMiddle con los indices que queremos
QuickSortMiddle(A_middle, p, r)
#*Agregagamos los valores de las iteraciones
totalSteps.append(n)
totalTime.append(time)
time = 0
print("order A = ", A_middle)
totalSteps.sort()
totalTime.sort()
#*Mandamos a llamar imprimirResultados en el archivo
imprimirResultados(file)
totalSteps.clear()
totalTime.clear()
print("-------------------------------------------------------------")
#*Para todos los valores dentro de 20
for i in range(20):
#*Limpiamos el arreglo
A_hip.clear()
#*Le damos valores necesarios para crear el arreglo
n = random.randint(4, 30)
r = n - 1
llenarAleatoriamente(A_hip, n)
print(A_hip)
print("r = %d" % r)
A_hip.sort()
A_hip.reverse()
print("inorder A = ", A_hip)
#*llamamos quickSortMiddle con los indices que queremos
QuickSort(A_hip, p, r)
#*Agregagamos los valores de las iteraciones
totalSteps.append(n)
totalTime.append(time)
time = 0
print("order A = ", A_hip)
totalSteps.sort()
totalTime.sort()
#*Mandamos a llamar imprimirResultados en el archivo
imprimirResultados(file)
#*Cerramos el archivo
file.close()
#*Configuramos la grafica
title = "QuickSort"
x_label = "n: Tamaño del array"
y_label = "t: Tiempo de ejecución"
big_O = "n^2"
theta = "n \log (n)"
#* Graficamos los resultados
graph = Graphics("./files_practices/pract_4b.txt")
graph.graficar(title, x_label, y_label, big_O, theta)
def main():
global time
A = []
file = open("./files_practices/pract_5b.txt", 'w')
limit = 70
#* Iteramos para cada tamaño i del arreglo para los peores casos
for i in range(1, limit):
n = i
llenarAleatorio(A, n)
bucketSort(A, n)
print("Caso Aleatorio:", A)
#? Escribimos en cada iteracion el resultado de ordenar
impresion(time, file, limit - 1, i)
A.clear()
time = 0
print(
"--------------------------------------------------------------------------------"
)
escrituraN(n, file)
#* Iteramos para cada tamaño i del arreglo para los peores casos
for i in range(1, limit):
n = i
A = PeorCaso(A, n)
print("Peor caso:", A)
#? Escribimos en cada iteracion el resultado de ordenar
impresion(time, file, limit - 1, i)
A.clear()
time = 0
print(
"--------------------------------------------------------------------------------"
)
escrituraN(n, file)
# * Iteramos para cada tamaño i del arreglo para los mejores casos
for i in range(1, limit):
n = i
MejorCaso(A, n)
print("Mejor caso:", A)
#? Escribimos en cada iteracion el resultado de ordenar
impresion(time, file, limit - 1, i)
A.clear()
time = 0
print(
"--------------------------------------------------------------------------------"
)
escrituraN(n, file)
file.close()
#*Configuramos la grafica
title = "BucketSort"
x_label = "n: Tamaño del arreglo"
y_label = "t: Tiempo de ejecución"
big_O = "O(n)"
theta = "\Theta(n)"
omega = "\Omega(n)"
#* Graficamos los resultados
graph = Graphics("./files_practices/pract_5b.txt")
graph.graficar(title, x_label, y_label, big_O, theta, omega)