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
