def getTrendingVideos(catalog, category_name, country, n): categorys = catalog['category'] count = lt.size(categorys) inicio = 0 while inicio <= count: elemento = lt.getElement(categorys, inicio) if elemento['name'] == category_name.strip(): categ = elemento.copy() videos = categ['videos'] tamañoVideos = lt.size(videos) cont = 0 listaVideos = lt.newList('ARRAY_LIST') tamañolv = size(listaVideos) while cont <= tamañoVideos: video = lt.getElement(videos, cont) if video['country'] == country: lt.addLast(listaVideos, video) cont += 1 listaOrdenada = ms.sort(listaVideos, cmpVideosByViews) if int(n) <= tamañolv: listaFinal = lt.subList(listaOrdenada, 0, tamañolv) elif listaVideos == None: listaFinal == None elif int(n) >= tamañolv: listaFinal = lt.subList(listaOrdenada, 0, int(n)) inicio += 1 return listaFinal
def sortBooksByYear(catalog, year, fraction, rank): """ retorna una fraccion de la lista de videos del año ordenada por rating """ # TODO: ordenamiento utilizando TAD maps y list # recuperar libros en el año apropiado ranked_list = None year_mp = mp.get(catalog['years'], year) if year_mp: # recuperar la lista de libros books_year = me.getValue(year_mp)["books"] # ajustar la muestra segun la fraccion de elementos en la lista total_books = lt.size(books_year) sample = int(total_books * fraction) print("Total de libros en " + str(year) + ": " + str(total_books)) print("Muestra de libros: " + str(sample)) # ordenando la sublista sub_list = lt.subList(books_year, 1, sample) sorted_list = sa.sort(sub_list, compareratings) ranked_list = lt.subList(sorted_list, 1, rank) return ranked_list
def Req1RepInfo(chicagoAnalyzer, mTop, nTop): if 0 in {mTop, nTop}: return 0 totalTaxi = m.size(chicagoAnalyzer['taxi']) totalCompany = m.size(chicagoAnalyzer['company']) topMCompanyTaxi = lt.newList(datastructure='ARRAY_LIST') topNCompanyService = lt.newList(datastructure='ARRAY_LIST') #Obtener taxis por compania ltCompany = m.keySet(chicagoAnalyzer['company']) for company in range(lt.size(ltCompany)): size = m.get(chicagoAnalyzer['company'], lt.getElement(ltCompany, company))['value'] lt.addLast(topMCompanyTaxi, (lt.getElement(ltCompany, company), lt.size(size))) count = 0 for idTaxi in range(lt.size(size)): infoT = m.get(chicagoAnalyzer['taxi'], lt.getElement(size, idTaxi))['value'] count += m.get(infoT, 'numServices')['value'] lt.addLast(topNCompanyService, (lt.getElement(ltCompany, company), count)) ms.mergesort(topMCompanyTaxi, comparePoints) ms.mergesort(topNCompanyService, comparePoints) return totalTaxi, totalCompany, lt.subList(topMCompanyTaxi, 1, mTop)['elements'], lt.subList( topNCompanyService, 1, nTop)['elements']
def CompaniesInfo(catalog, criteria1, criteria2): """ Proyecto Final | Req 1 Retorna: Número total de taxis reportados. Número total de compañías. TOP X compañías con más taxis afiliados. TOP Y compañías con más servicios prestados. """ companies_lt = m.keySet(catalog['Companies_Map']) num_companies = lt.size(companies_lt) moreCabs = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None) moreServices = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None) iterator = it.newIterator(companies_lt) while it.hasNext(iterator): company_name = it.next(iterator) company = m.get(catalog['Companies_Map'], company_name) lt.addLast(moreCabs, company) lt.addLast(moreServices, company) mg.mergesort(moreCabs, greaterNumCabs) mg.mergesort(moreServices, greaterNumServices) TOPNumCabs = lt.subList(moreCabs, 1, criteria1) TOPNumServices = lt.subList(moreServices, 1, criteria2) return catalog['Num_Total_Cabs'], num_companies, TOPNumCabs, TOPNumServices
def reportegeneral(analyzer, parametrom, parametron): listaviajes = analyzer["lista"] lista = [] companias = [] for i in range(lt.size(listaviajes) + 1): taxiid = lt.getElement(listaviajes, i)["taxi_id"] compania = lt.getElement(listaviajes, i)["company"] if compania == "": compania = "independent owner" if compania not in companias: companias.append(compania) if taxiid not in lista: lista.append(taxiid) addCompany(analyzer, compania, taxiid, lt.getElement(listaviajes, i)) addtaxid(analyzer, taxiid) rankingm = lt.newList("ARRAY_LIST") rankingn = lt.newList("ARRAY_LIST") for i in companias: compania = m.get(analyzer["mapcompany"], i) lt.addLast(rankingm, compania) lt.addLast(rankingn, compania) mg.mergesort(rankingm, greater_company) mg.mergesort(rankingn, greater_company_taxis) rankingm = lt.subList(rankingm, 1, parametrom + 1) rankingn = lt.subList(rankingn, 1, parametron + 1) return len(lista), len(companias), rankingm, rankingn
def sortVideos(catalog, size, cmpFunction): """Función que organiza una lista mediante Merge Sort. Parametros: catalog: Catalogo a organizar size: Tamaño del sub-catalogo que será organizado cmpFunction: Nombre de la función de comparación a utilizar.""" if cmpFunction == "sortByViews": sub_list = lt.subList(catalog['videos'], 1, size) sub_list = sub_list.copy() start_time = time.process_time() sorted_list = mergesort.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif cmpFunction == "sortByDays": sub_list = lt.subList(catalog, 1, size) sub_list = sub_list.copy() start_time = time.process_time() sorted_list = mergesort.sort(sub_list, cmpVideosByDays) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif cmpFunction == "sortByLikes": sub_list = lt.subList(catalog['videos'], 1, size) sub_list = sub_list.copy() start_time = time.process_time() sorted_list = mergesort.sort(sub_list, cmpVideosByLikes) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list
def estaciones_criticas(citibike): listavertices = lt.newList("ARRAY_LIST") grafo = citibike["graph"] vertices = gr.vertices(grafo) iterador = it.newIterator(vertices) while it.hasNext(iterador): elemento = it.next(iterador) entry = m.get(citibike["Estaciones"], elemento) valor = me.getValue(entry) indegree = valor["viajes_llegada"] outdegree = valor["viajes_salida"] menor_ut = indegree + outdegree estacion = {} estacion["Estacion"] = elemento estacion["indegree"] = indegree estacion["outdegree"] = outdegree estacion["menor_ut"] = menor_ut lt.addLast(listavertices, estacion) lista = [] sort.insertionSort(listavertices, great) indegree_list = lt.subList(listavertices, 1, 3) iterador = it.newIterator(indegree_list) while it.hasNext(iterador): element = it.next(iterador)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) sort.insertionSort(listavertices, great2) outdegree_ = lt.subList(listavertices, 1, 3) iterador2 = it.newIterator(outdegree_) while it.hasNext(iterador2): element = it.next(iterador2)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) sort.insertionSort(listavertices, less) menor_u_ = lt.subList(listavertices, 1, 3) iterador3 = it.newIterator(menor_u_) while it.hasNext(iterador3): element = it.next(iterador3)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) return lista
def consulta_req4(analyzer, list_gen): mapa_final = mp.newMap(numelements=10, maptype='PROBING') entry_2 = mp.get(analyzer['EvByCaracteristics'], 'tempo') arbol_tempo = me.getValue(entry_2) tot_eventos = 0 for gender in list_gen: num_artistas = 0 num_eventos = 0 entry_1 = mp.get(analyzer['Genders'], gender) rango = me.getValue(entry_1) estructuras = om.values(arbol_tempo, rango[0], rango[1]) mapa_trabajo = mp.newMap(numelements=80, maptype='PROBING') for estruc in lt.iterator(estructuras): for track in lt.iterator(mp.valueSet(estruc['mapa_completo'])): num_eventos += 1 artista = track['artist_id'] if mp.contains(mapa_trabajo, artista) == False: mp.put(mapa_trabajo, artista, 1) num_artistas += 1 tot_eventos += num_eventos keys = mp.keySet(mapa_trabajo) top_artistas = lt.subList(keys, 1, 10) info = (num_eventos, num_artistas, top_artistas) mp.put(mapa_final, gender, info) return tot_eventos, mapa_final
def consulta_req3(analyzer, mini_vali, max_vali, mini_valt, max_valt): entry_1 = mp.get(analyzer['EvByCaracteristics'], 'instrumentalness') entry_2 = mp.get(analyzer['EvByCaracteristics'], 'tempo') arbol_inst = me.getValue(entry_1) arbol_temp = me.getValue(entry_2) estructuras_inst = om.values(arbol_inst, mini_vali, max_vali) estructuras_temp = om.values(arbol_temp, mini_valt, max_valt) mapa_trabajo = mp.newMap(numelements=20, maptype='PROBING') lista = lt.newList('ARRAY_LIST', cmpfunction=compareIds) unique_tracks = 0 for estruc in lt.iterator(estructuras_inst): tracks = mp.keySet(estruc['mapa_unicos']) for track in lt.iterator(tracks): entry = mp.get(analyzer['tracks'], track) value = me.getValue(entry) mp.put(mapa_trabajo, track, value) for estruc in lt.iterator(estructuras_temp): tracks = mp.keySet(estruc['mapa_unicos']) for track in lt.iterator(tracks): entry = mp.get(mapa_trabajo, track) if entry is not None: unique_tracks += 1 value = me.getValue(entry) lt.addLast(lista, value) lista_final = lt.subList(lista, 1, 5) return unique_tracks, lista_final
def consulta_req2(analyzer, inf_e, sup_e, inf_d, sup_d): """ Ejecuta la consulta sobre los datos para responder al requerimiento 2 """ mapa_trabajo = mp.newMap(numelements=20, maptype='PROBING') lista_entregable = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareIds) mapa_caracs = analyzer['EvByCaracteristics'] entry_1 = mp.get(mapa_caracs, 'energy') entry_2 = mp.get(mapa_caracs, 'danceability') arbol_energy = me.getValue(entry_1) arbol_dance = me.getValue(entry_2) #Vamos primero con energy estructuras = om.values(arbol_energy, inf_e, sup_e) for estructura in lt.iterator(estructuras): mapa = estructura['mapa_unicos'] tracks = mp.keySet(mapa) for track in lt.iterator(tracks): mp.put(mapa_trabajo, track, 1) #Ahora vamos con danceability estructuras = om.values(arbol_dance, inf_d, sup_d) suma = 0 for estructura in lt.iterator(estructuras): mapa = estructura['mapa_unicos'] tracks = mp.keySet(mapa) for track in lt.iterator(tracks): entry = mp.get(mapa_trabajo, track) if entry is not None: entry_auxiliar = mp.get(analyzer['tracks'], track) track = me.getValue(entry_auxiliar) lt.addLast(lista_entregable, track) suma += 1 retorno = lt.subList(lista_entregable, 1, 5) return retorno, suma
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 subListVideos(catalog, pos, number): """ Retorna sublista de videos """ videos = catalog["videos"] return lt.subList(videos, pos, number)
def mostLiked(catalog, tagname, number, country): lista = lt.newList() videos = [] lista2 = lt.newList() tagDict = mp.get(catalog["tags"], tagname) video = me.getValue(tagDict)["videos"] for i in lt.iterator(video): if i["country"] == country: lt.addLast(lista, i) mer.sort(lista, cmpVideosByLikes) for i in lt.iterator(lista): if not i["video_id"] in videos: videos.append(i["video_id"]) lt.addLast(lista2, i) if number > lt.size(lista2): print("La cantidad de videos ha sido ajustada a " + str(lt.size(lista2)) + " ya que no existen " + str(number) + " videos disponibles") number = lt.size(lista2) sub = lt.subList(lista2, 1, number) for i in range(1, lt.size(sub) + 1): a = lt.getElement(sub, i) print("Posicion: " + str(i) + "\nTitulo: " + a["title"] + "\nCanal: " + a["channel_title"] + "\nFecha publicacion: " + a["publish_time"] + "\nVistas: " + a["views"] + "\nLikes: " + a["likes"] + "\nDislikes: " + a["dislikes"] + "\nTags: " + a["tags"] + "\n")
def subListaDePais(listaOrdenada, index, elemento): elemento = elemento.lower() i = index - 1 l = index + 1 limIzq = 0 limDer = lt.size(listaOrdenada) VerIzq = True VerDer = True while i >= 0 and VerIzq: if not (lt.getElement(listaOrdenada, i)['country'].lower() == elemento): VerIzq = False if i == 0: limIzq = i else: limIzq = i + 1 i -= 1 while l <= lt.size(listaOrdenada) and VerDer: if not (lt.getElement(listaOrdenada, l)['country'].lower() == elemento): VerDer = False if l == lt.size(listaOrdenada): limDer = l else: limDer = l - 1 l += 1 sub_list = lt.subList(listaOrdenada, limIzq, limDer - limIzq) sub_list = sub_list.copy() return sub_list
def sortSizeGeneros(generoList): sub_list = lt.subList(generoList, 1, lt.size(generoList)) sub_list = sub_list.copy() sorted_list = mergesort.sort(sub_list, cmpGeneros) return sorted_list
def R1(categoria,pais,num,catalog): delta_time = -1.0 delta_memory = -1.0 tracemalloc.start() start_time = getTime() start_memory = getMemory() ID=model.categoriaporID(categoria,catalog) if ID==None: return 'Categoría no válida' else: l=model.lporcyp(ID,pais,catalog['videos']) if l==None: return 'País no válido.' else: l2=model.sortVideos(l,lt.size(l),model.cmpVideosbyViews)[1] if num>lt.size(l2): return 'El número ingresado excede la cantidad de videos que cumplen con los requisitos. Intente con un número igual o menor a '+str(lt.size(l)) else: n=0 c='' final=lt.subList(l2,1,num) i=it.newIterator(final) while it.hasNext(i): n+=1 vid=it.next(i) c=c+'\nPuesto '+str(n)+'\ntrending_date: '+str(vid['trending_date'])+'; title: '+vid['title']+'; channel_title: '+vid['channel_title']+'; publish_time: '+vid['publish_time']+'; views: '+vid['views']+'; likes: '+vid['likes']+ '; dislikes: '+vid['dislikes']+'\n' stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) return ('Información de los '+str(num)+' videos con más views en '+pais+' para la categoría de '+categoria+':\n'+c,delta_time, delta_memory)
def printLoadInfo(answer): catalog = answer[0] print("Total eventos de escucha:", controller.listSize(catalog['events'])) print("Total eventos de artistas unicos:", answer[1]) print("Total eventos de tracks unicos:", answer[2], '\n') sub_list1 = lt.subList(catalog['events'], 1, 5) sub_list2 = lt.subList(catalog['events'], lt.size(catalog['events']) - 6, 5) n = 1 for item in lt.iterator(sub_list1): print('Video', n, ':', item, '\n') n += 1 for item in lt.iterator(sub_list2): print('Video', n, ':', item, '\n') n += 1
def musicalgenres(catalog, user_list): sublist = user_list.split(",") view_list = lt.newList("ARRAY_LIST") for element in sublist: element_list = lt.newList("ARRAY_LIST") lt.addLast(element_list, element) ranges = values(catalog, element) min_val = lt.getElement(ranges, 1) max_val = lt.getElement(ranges, 2) first = catalog["context"] second = mp.get(first, "tempo") third = me.getValue(second) four = om.values(third, min_val, max_val) auxiliarlist = lt.newList("ARRAY_LIST") for element in lt.iterator(four): if lt.size(element) >= 1: for thing in lt.iterator(element): lt.addLast(auxiliarlist, thing) lt.addLast(element_list, lt.size(auxiliarlist)) unique_track_id = lt.newList("SINGLE_LINKED", cmpfunction=cmpunique_id) for track in lt.iterator(auxiliarlist): if lt.isPresent(unique_track_id, track["artist_id"]) == 0: lt.addLast(unique_track_id, track["artist_id"]) lt.addLast(element_list, lt.size(unique_track_id)) sub_lista = lt.subList(unique_track_id, 1, 10) lt.addLast(element_list, sub_lista) lt.addLast(view_list, element_list) return view_list
def req2(analyzer): delta_time = -1.0 delta_memory = -1.0 tracemalloc.start() start_time = getTime() start_memory = getMemory() lista = model.req2(analyzer) lista_sorteada = lt.subList(mrge.sort(lista, cmpreq2), 1, 1) stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) i=1 while i<=lt.size(lista_sorteada): lp_numcables= lt.getElement(lista_sorteada,i) x=str(lp_numcables[0]) print(str(i) + ") Nombre, País: " + x + " || ID: "+str(model.iddadolp(analyzer,x.lower()))+" || Cables conectados: " + str(lp_numcables[1])) i+=1 return delta_time,delta_memory
def requerimiento1(catalog,country,category): start_time = time.process_time() country=country.lower() countries=catalog["countries"] couple=mp.get(countries,country) lista=me.getValue(couple) size=lt.size(lista) number=getCategoryNumber(category,catalog) contador=1 iterador=li.newIterator(lista) i=1 while li.hasNext(iterador): video=li.next(iterador) if cmpVideosByCategory(number,video): lt.exchange(lista,i,contador) contador+=1 i+=1 lista_total=lt.subList(lista,1,contador) size=lt.size(lista_total) ordenada=mergeSort(lista_total,1) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time)*1000 return ordenada,elapsed_time_mseg
def topVideos(catalog, topAmount, countryname, category): for i in lt.iterator(catalog["categoriesId"]): if i["name"] == category: idnumber = i["id"] categoryDict = mp.get(catalog["categories"], idnumber) videos = me.getValue(categoryDict)["videos"] top = lt.newList() for i in lt.iterator(videos): if i["country"] == countryname: lt.addLast(top, i) mer.sort(top, cmpVideosByViews) if topAmount > lt.size(top): print("No se puede mostrar el top " + str(topAmount) + ", ya que solo existen " + str(lt.size(top)) + " videos que cumplen con los filtros seleccioados") print("Se mostrara en cambio el top " + str(lt.size(top))) topAmount = lt.size(top) sub = lt.subList(top, 1, topAmount) for i in range(1, lt.size(sub) + 1): a = lt.getElement(sub, i) print("Posicion: " + str(i) + "|" + "Trending Date: " + a["trending_date"] + "|" + "Titulo: " + a["title"] + "|Canal: " + a["channel_title"] + "|Fecha publicacion: " + a["publish_time"] + "|Vistas: " + a["views"] + "|Likes: " + a["likes"] + "|Dislikes: " + a["dislikes"])
def Req3(analyzer, limInf1, limSup1, limInf2, limSup2): try: entry = mp.get(analyzer['content'], "instrumentalness") arbolInstr = me.getValue(entry) valoresInstr = om.values(arbolInstr, limInf1, limSup1) arbol_Tempo = om.newMap(omaptype="RBT", comparefunction=compareValues) for lista in lt.iterator(valoresInstr): for evento in lt.iterator(lista): tempo = float(evento["tempo"]) existe = om.get(arbol_Tempo, tempo) if existe is None: eventList = lt.newList("ARRAY_LIST", cmpfunction=compareValues) om.put(arbol_Tempo, evento["tempo"], eventList) else: eventList = me.getValue(existe) lt.addLast(eventList, evento) valoresTempo = om.values(arbol_Tempo, limInf2, limSup2) unique_tracks = mp.newMap(maptype="PROBING") for lista in lt.iterator(valoresTempo): for evento in lt.iterator(lista): mp.put(unique_tracks, evento["track_id"], evento) total_tracks = mp.valueSet(unique_tracks) num_tracks = lt.size(total_tracks) random5Tracks = lt.subList(total_tracks, random.randint(1, num_tracks - 5), 5) return num_tracks, random5Tracks except Exception: return None
def subListaDeCategories(listaOrdenada, index, elemento): i = index - 1 l = index + 1 limIzq = 0 limDer = lt.size(listaOrdenada) VerIzq = True VerDer = True while i >= 0 and VerIzq: if not (lt.getElement(listaOrdenada, i)['category_id'] == elemento): VerIzq = False if i == 0: limIzq = i else: limIzq = i + 1 i -= 1 while l <= lt.size(listaOrdenada) and VerDer: if not (lt.getElement(listaOrdenada, l)['category_id'] == elemento): VerDer = False if l == lt.size(listaOrdenada): limDer = l else: limDer = l - 1 l += 1 sub_list = lt.subList(listaOrdenada, limIzq, limDer - limIzq) sub_list = sub_list.copy() return sub_list
def sortVideos(catalog, size, sort_type, cmp): """ La Función sortVideos() la usamos en varios requerimientos por la necesidad de tener la información organizada. Por esto mismo, la función cuenta con cuatro parámetros en donde destacan "cmp" y "sort_type". Para cada caso particular, dejamos que según estos dos parámetros se invoque la función correspondiente de la librería sort y usando los algoritmos de merge sort y quick sort """ sub_list = lt.subList(catalog, 0, size) sub_list = sub_list.copy() start_time = time.process_time() if cmp == 'cmpVideosByViews': if sort_type == "ms": sorted_list = ms.sort(sub_list, cmpVideosByViews) elif sort_type == "qs": sorted_list = qs.sort(sub_list, cmpVideosByViews) if cmp == 'comparetitles': if sort_type == "ms": sorted_list = ms.sort(sub_list, comparetitles) elif sort_type == "qs": sorted_list = qs.sort(sub_list, comparetitles) if cmp == 'comparelikes': if sort_type == "ms": sorted_list = ms.sort(sub_list, comparelikes) elif sort_type == "qs": sorted_list = qs.sort(sub_list, comparelikes) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list
def quickSortVideos(catalog, size): sub_list = lt.subList(catalog['videos'], 0, size) start_time = time.process_time() sorted_list = quick.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list
def sortVideos(catalog, size, tipo): sub_list = lt.subList(catalog['videos'], 0, size) sub_list = sub_list.copy() if tipo == 'selection': start_time = time.process_time() sorted_list = ss.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif tipo == 'insertion': start_time = time.process_time() sorted_list = ins.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif tipo == 'shell': start_time = time.process_time() sorted_list = sa.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif tipo == 'quick': start_time = time.process_time() sorted_list = qs.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list elif tipo == 'merge': start_time = time.process_time() sorted_list = ms.sort(sub_list, cmpVideosByViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg, sorted_list
def quitarCopiasLikes( ord_videos, size): # Carlos dijo que no era necesario quitar las copias """ Args: ord_videos: catálogo de videos ordenados. size: videos que se van a imprimir en el view, ayuda a no recorrer todo ord_videos Return: list: Lista donde solo se incluya cada video que aparezca más de unna vez, dejando así el que mas likes tenga. """ i = 1 sub_list = lt.subList(ord_videos, 1, lt.size(ord_videos)) sub_list = sub_list.copy() for video in lt.iterator(ord_videos): ii = i + 1 while ii <= lt.size(sub_list): if (ii < lt.size(sub_list)) and video['title'] == lt.getElement( sub_list, ii)['title']: lt.deleteElement(sub_list, ii) ii += 1 if i == size + 1: return sub_list i += 1 return sub_list
def sortVideos(catalog, size, algorithm): sub_list = lt.subList(catalog['videos'], 0, size) if algorithm == 'Insertion sort': start_time = time.process_time() ins.sort(sub_list, cmpVideosbyViews) stop_time = time.process_time() elif algorithm == 'Selection sort': start_time = time.process_time() ses.sort(sub_list, cmpVideosbyViews) stop_time = time.process_time() elif algorithm == 'Shell sort': start_time = time.process_time() shs.sort(sub_list, cmpVideosbyViews) stop_time = time.process_time() elif algorithm == 'Merge sort': start_time = time.process_time() mrg.sort(sub_list, cmpVideosbyViews) stop_time = time.process_time() elif algorithm == 'Quick sort': start_time = time.process_time() qck.sort(sub_list, cmpVideosbyViews) stop_time = time.process_time() elapsed_time_mseg = (stop_time - start_time) * 1000 return elapsed_time_mseg
def sortVideos(catalog, cmp: int): """ Args: catalog: Catálogo ordenado según los Títulos cmp: (1) cmpVideosByViews (2) cmpVideosByTitle (3) cmpVideosByID (4) cmpVideosByLikes Return: list: Lista ordenada de acuerdo a los parámetros. """ sub_list = lt.subList(catalog['videos'], 1, lt.size(catalog['videos'])) sub_list = sub_list.copy() if cmp == 1: sorted_list = mergesort.sort(sub_list, cmpVideosByViews) elif cmp == 2: sorted_list = mergesort.sort(lst=sub_list, lessfunction=cmpVideosByTitle) elif cmp == 3: sorted_list = mergesort.sort(lst=sub_list, lessfunction=cmpVideosByID) else: sorted_list = mergesort.sort(lst=sub_list, lessfunction=cmpVideosByLikes) return sorted_list
def topvideoscategoriapais(catalog, categoria, pais, tamaño): categoria_id = categoryid(catalog, categoria) listacategoria = listcategory(catalog, categoria_id) listapais = listpais2(listacategoria, pais) listaordenada = sortshell(listapais, cmpVideosByViews) sub_list = lt.subList(listaordenada, 1, tamaño) return sub_list