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)