def rank_movies(function, lst_d, req_elements, algorithm, column): if len(lst_d) == 0: print('Las listas están vacías') else: t1_start = process_time() # Start time. sort_movies(algorithm, function, lst_d, column) t1_stop = process_time() # Final time. print(req_elements, 'best' if function == 'greater' else 'worst', 'count:' if column == 'vote_count' else 'average:') show_movies(lt.subList(lst_d, 0, int(req_elements)), None) print(get_average_count_points(lt.subList(lst_d, 0, int(req_elements)))) print('Tiempo de ejecución ', t1_stop - t1_start, ' segundos')
def order_movies(function, lst_d, req_elements, algorithm, column): """ Retorna una lista con cierta cantidad de elementos ordenados por el criterio """ if len(lst_d) == 0: print('Las listas están vacías') else: t1_start = process_time() # tiempo inicial # Sort movies. if algorithm == 'selection': if function == 'less': selection.selectionSort(lst_d, less_count) if column == 'vote_count' \ else selection.selectionSort(lst_d, less_average) elif function == 'greater': selection.selectionSort(lst_d, greater_count) if column == 'vote_count' \ else selection.selectionSort(lst_d, greater_average) elif algorithm == 'shell': if function == 'less': shell.shellSort(lst_d, less_count) if column == 'vote_count' \ else shell.shellSort(lst_d, less_average) elif function == 'greater': shell.shellSort(lst_d, greater_count) if column == 'vote_count' \ else shell.shellSort(lst_d, greater_average) elif algorithm == 'insertion': if function == 'less': insertion.insertionSort(lst_d, less_count) if column == 'vote_count' \ else insertion.insertionSort(lst_d, less_average) elif function == 'greater': insertion.insertionSort(lst_d, greater_count) if column == 'vote_count' \ else insertion.insertionSort(lst_d, greater_average) t1_stop = process_time() # tiempo final print(req_elements, 'best' if function == 'greater' else 'worst', 'count:' if column == 'vote_count' else 'average:') show_movies(lt.subList(lst_d, 0, int(req_elements)), None) print('Tiempo de ejecución ', t1_stop - t1_start, ' segundos')
def videos_likes(catalog, pais, tag, numero): videos_pais = lt.newList(datastructure="ARRAY_LIST") for i in range(1, lt.size(catalog["videos"])): video = lt.getElement(catalog["videos"], i) if video["country"].lower() == pais.lower(): lista_tag = video["tags"] for e in range(len(lista_tag)): if tag in lista_tag[e]: lt.addLast(videos_pais, video) videos = sortVideos(videos_pais, "None", 4, comparelikes) vids = lt.subList(videos, 1, numero) respuesta = lt.newList() for i in range(1, lt.size(vids)): video = lt.getElement(vids, i) vid_t = { "Nombre del video": video["title"], "Nombre del canal": video["channel_title"], "Fecha Publicación": video["publish_time"], "Reproducciones": video["views"], "Likes": video["likes"], "Dislikes": video["dislikes"], "Tags": video["tags"] } lt.addLast(respuesta, vid_t) return respuesta
def ranking_genero(lista, genero, tipo_votacion, orden, num_peliculas): if lista['size'] == 0: print("La lista esta vacía") return 0 else: lista_final = lt.newList("ARRAY_LIST") peliculas, tamaño, promedio = conocer_genero(lista, genero) iterador = it.newIterator(peliculas) if tipo_votacion == "vote_count" and orden.lower() == "peores": sort.insertionSort(peliculas, less) lista_final = lt.subList(peliculas, 1, int(num_peliculas)) iterador = it.newIterator(lista_final) counter = 0 while it.hasNext(iterador): element = it.next(iterador) counter += float(element["vote_count"]) elif tipo_votacion == "vote_count" and orden.lower() == "mejores": sort.insertionSort(peliculas, greater1) lista_final = lt.PsubList(peliculas, 1, int(num_peliculas)) iterador = it.newIterator(lista_final) counter = 0 while it.hasNext(iterador): element = it.next(iterador) counter += float(element["vote_count"]) elif tipo_votacion == "vote_average" and orden.lower() == "peores": sort.insertionSort(peliculas, less2) lista_final = lt.subList(peliculas, 1, int(num_peliculas)) iterador = it.newIterator(lista_final) counter = 0 while it.hasNext(iterador): element = it.next(iterador) counter += float(element["vote_average"]) elif tipo_votacion == "vote_average" and orden.lower() == "mejores": sort.insertionSort(peliculas, greater2) lista_final = lt.subList(peliculas, 1, int(num_peliculas)) iterador = it.newIterator(lista_final) counter = 0 while it.hasNext(iterador): element = it.next(iterador) counter += float(element["vote_count"]) promedio = counter / lt.size(lista_final) return lista_final, promedio
def getWorstMovies (catalog, number, criteria): if criteria=="average": movies = catalog['peliculas_prom'] else: movies = catalog['votos_totales'] size=lt.size(movies) pos=size-number worstmovies = lt.subList(movies, pos, number) return worstmovies
def getBestMovies (catalog, number, criteria): if criteria=="average": movies = catalog['peliculas_prom'] else: movies = catalog['votos_totales'] pos= 1 bestmovies = lt.subList(movies, pos, number) return bestmovies
def mergesort(lst, lessfunction, column): size = lt.size(lst) if size > 1: mid = (size // 2) #se divide la lista original, en dos partes, izquierda y derecha, desde el punto mid. leftlist = lt.subList(lst, 1, mid) rightlist = lt.subList(lst, mid + 1, size - mid) #se hace el llamado recursivo con la lista izquierda y derecha mergesort(leftlist, lessfunction, column) mergesort(rightlist, lessfunction, column) #i recorre la lista izquierda, j la derecha y k la lista original i = j = k = 1 leftelements = lt.size(leftlist) rightelements = lt.size(rightlist) while (i <= leftelements) and (j <= rightelements): elemi = lt.getElement(leftlist, i) elemj = lt.getElement(rightlist, j) #compara y ordena los elementos if lessfunction(elemj, elemi, column): # caso estricto elemj < elemi lt.changeInfo(lst, k, elemj) j += 1 else: # caso elemi <= elemj lt.changeInfo(lst, k, elemi) i += 1 k += 1 #Agrega los elementos que no se comprararon y estan ordenados while i <= leftelements: lt.changeInfo(lst, k, lt.getElement(leftlist, i)) i += 1 k += 1 while j <= rightelements: lt.changeInfo(lst, k, lt.getElement(rightlist, j)) j += 1 k += 1
def leastCapacity(catalog, city, ncapacities): rawMap = catalog['capacityMap'] statcapList = map.get(rawMap, city)['value'] response = "Least capacity stations: " LessN = lt.subList(statcapList, 1, ncapacities) if not lt.isEmpty(LessN): iteraless=it.newIterator(LessN) while it.hasNext(iteraless): station = it.next(iteraless) response += str(station) + ':' + " " return response return None
def orderElementsByCriteria(function, column, lst, elements): """ Retorna una lista con cierta cantidad de elementos ordenados por el criterio """ if lst['size'] == 0: print("La lista esta vacía") return 0 else: t1_start = process_time() #tiempo inicial lista = lt.newList() if column == "vote_count" and function.lower() == "acendente": sort.insertionSort(lst, less) iterador = it.newIterator(lst) counter = 1 while it.hasNext(iterador) and counter <= int(elements): element = it.next(iterador) lt.addLast(lista, element) counter += 1 hola = lt.subList(lst, 1, int(elements)) elif column == "vote_count" and function.lower() == "decendente": sort.insertionSort(lst, greater1) iterador = it.newIterator(lst) counter = 1 while it.hasNext(iterador) and counter <= int(elements): element = it.next(iterador) lt.addLast(lista, element) counter += 1 elif column == "vote_average" and function.lower() == "acendente": sort.insertionSort(lst, less2) iterador = it.newIterator(lst) counter = 1 while it.hasNext(iterador) and counter <= int(elements): element = it.next(iterador) lt.addLast(lista, element) counter += 1 elif column == "vote_average" and function.lower() == "decendente": sort.insertionSort(lst, greater2) iterador = it.newIterator(lst) counter = 1 while it.hasNext(iterador) and counter <= int(elements): element = it.next(iterador) lt.addLast(lista, element["vote_average"]) counter += 1 t1_stop = process_time() #tiempo final print("Tiempo de ejecución ", t1_stop - t1_start, " segundos") print(lt.size(hola)) return hola
def mostCapacity(catalog, city, ncapacities): rawMap = catalog['capacityMap'] statcapList = map.get(rawMap, city)['value'] response= "Top capacity stations: " size = lt.size(statcapList) TopN = lt.subList(statcapList, size-ncapacities+1, ncapacities) if not lt.isEmpty(TopN): iteratop=it.newIterator(TopN) while it.hasNext(iteratop): station = it.next(iteratop) response += str(station) + ':' + " " return response return None
def Ranking(column, details, compfunction, elements): """ Retorna una lista con cierta cantidad de elementos ordenados por el criterio """ t1_start = process_time() #tiempo inicial copia = lt.subList(details, 1, details["size"]) lt.shellSort(copia, compfunction, column) iterator = it.newIterator(copia) ranking = {} x = 1 while it.hasNext(iterator) and x <= elements: element = it.next(iterator) ranking[element.get("original_title")] = element.get(column) x += 1 t1_stop = process_time() #tiempo final print("Tiempo de ejecución ", t1_stop - t1_start, " segundos") return ranking
def sortVideos(catalog, size, tipo, cmpfunction): if size != "None": sub_list = lt.subList(catalog['videos'], 0, size) else: sub_list = catalog sub_list = sub_list.copy() if tipo == 1: sorted_list = se.selection_sort(sub_list, cmpfunction) elif tipo == 2: sorted_list = it.insertion_sort(sub_list, cmpfunction) elif tipo == 3: sorted_list = sa.shell_sort(sub_list, cmpfunction) elif tipo == 4: sorted_list = qu.sort(sub_list, cmpfunction) elif tipo == 5: sorted_list = me.mergesort(sub_list, cmpfunction) return sorted_list
reader = csv.DictReader(csvfile, delimiter=';') for row in reader: lt.addLast(lista, row["num"]) #====================================== # Ordenar numeros descendetemente #====================================== def less(e1, e2): return e1 < e2 #======================================= l = lt.subList(lista, 1, lt.size(lista)) t1_start = process_time() insertionsort.insertionSort(l, less) t1_stop = process_time() # printList(l) print("InsertionSort:\t", t1_stop - t1_start, " segundos") #======================================= l = lt.subList(lista, 1, lt.size(lista)) t1_start = process_time() selectionsort.selectionSort(l, less) t1_stop = process_time() # printList(l) print("SelectionSort:\t", t1_stop - t1_start, " segundos")
def muestra(lista, pos, nume): u = lt.subList(lista, pos, nume) return u
def mergeSort(lst, lessfunction): lstaux = lt.subList( lst, 1, lt.size(lst) ) #crear una lista auxiliar del mismo tamaNo y con el mismo contenido sort(lst, lstaux, lessfunction, 1, lt.size(lst))
def tripsPerTemperature(catalog, number): longList = lt.size(catalog['tempList']) leastTemp = lt.subList(catalog['tempList'],longList-number,number) mostTemp = lt.subList(catalog['tempList'], 1, number) #O(1) por ser array counter1 = 0 counter2 = 0 response1='' response2='' tripsMostTempDays = map.newMap(30, comparefunction=compareByKey) tripsLeastTempDays = map.newMap(30, comparefunction=compareByKey) while counter1<number: leastTempIterator = it.newIterator(leastTemp) #Iterar la lista con n menores temperaturas while it.hasNext(leastTempIterator): tempElement = it.next(leastTempIterator) #Temperatura dateListElement = map.get(catalog['temperatureHash'],tempElement)['value']#Lista de todas las fechas para esa temperatura if number - lt.size(dateListElement) < counter1: #si no se pueden agregar todas las fechas de esa temperatura sin alcanzar el n deseado n_dates = lt.subList(dateListElement, 1, number-counter1) #lista de las que si se pueden agragar n_iterator = it.newIterator(n_dates) while it.hasNext(n_iterator): n_dateElement = it.next(n_iterator) #fecha a agregar trips = oms.get(catalog['dateTree'], n_dateElement, greater) #hash de viajes de esa fecha #print(type(trips)) totaltrip = map.get(trips, 'total')['value'] #número de viajes totales en esa fecha value = (tempElement, totaltrip) #tupla que se asigna como valor de cada fecha: temperatura, viajes totales map.put(tripsLeastTempDays, n_dateElement, value) counter1 += lt.size(n_dates)#el número de fechas que se agregó se suma al counter else: #si se pueden agregar todas las fechas de esa temperatura sin alcanzar el n deseado n_dates = dateListElement #se recorre la lista completa n_iterator = it.newIterator(n_dates) while it.hasNext(n_iterator): n_dateElement = it.next(n_iterator) #fecha a agregar trips = oms.get(catalog['dateTree'], n_dateElement, greater) #print(type(trips)) totaltrip = map.get(trips, 'total')['value'] value = (tempElement, totaltrip) map.put(tripsLeastTempDays, n_dateElement, value) counter1 += lt.size(dateListElement) while counter2<number: mostTempIterator = it.newIterator(mostTemp) #Iterar la lista con n temperaturas más altas while it.hasNext(mostTempIterator): tempElement = it.next(mostTempIterator) dateListElement = map.get(catalog['temperatureHash'],tempElement)['value']#Lista de todas las fechas para esa temperatura if number - lt.size(dateListElement) < counter2: #si no se pueden agregar todas las fechas de esa temperatura sin alcanzar el n deseado n_dates = lt.subList(dateListElement, 1, number-counter2) n_iterator = it.newIterator(n_dates) while it.hasNext(n_iterator): n_dateElement = it.next(n_iterator) value = oms.get(catalog['dateTree'], n_dateElement, greater) value = map.get(value, 'total')['value'] value = (tempElement, value) map.put(tripsMostTempDays, n_dateElement, value) counter2 += lt.size(n_dates) else: #si se pueden agregar todas las fechas de esa temperatura sin alcanzar el n deseado n_dates = dateListElement n_iterator = it.newIterator(n_dates) while it.hasNext(n_iterator): n_dateElement = it.next(n_iterator) value = oms.get(catalog['dateTree'], n_dateElement, greater) value = map.get(value, 'total')['value'] value = (tempElement, value) map.put(tripsMostTempDays, n_dateElement, value) counter2 += lt.size(dateListElement) if not map.isEmpty(tripsMostTempDays): tempList= map.keySet(tripsMostTempDays) iteratemp=it.newIterator(tempList) while it.hasNext(iteratemp): tempKey = it.next(iteratemp) response1 += str(tempKey) + ':' + str(map.get(tripsMostTempDays,tempKey)['value']) + " " if not map.isEmpty(tripsLeastTempDays): tempList= map.keySet(tripsLeastTempDays) iteratemp=it.newIterator(tempList) while it.hasNext(iteratemp): tempKey = it.next(iteratemp) response2 += str(tempKey) + ':' + str(map.get(tripsLeastTempDays,tempKey)['value']) + " " return response1, response2