def inpacto_landing(analyzer, landing):
Entry1 = mp.get(analyzer["landing_points"], landing)
Pais_id = me.getValue(Entry1)
paises_id = gr.adjacentEdges(analyzer["Arcos"],
str(Pais_id["landing_point_id"]))
iterador = it.newIterator(paises_id)
pesos = lt.newList()
while it.hasNext(iterador):
Pais_id = it.next(iterador)
lt.addLast(pesos, Pais_id)
merge.sort(pesos, comparar_pesos)
iterador_2 = it.newIterator(pesos)
IDs = lt.newList()
unicos = 0
while it.hasNext(iterador_2):
Pais_id = it.next(iterador_2)
vertice_id = Pais_id["vertexB"]
Entry2 = mp.get(analyzer["paises_codigos"], vertice_id)
Pais_ciudad = me.getValue(Entry2)
nombre = str(Pais_ciudad["name"]).split(",")
nombre_pais = str(nombre[-1])
if not lt.isPresent(IDs, nombre_pais):
lt.addLast(IDs, nombre_pais)
unicos += 1
return unicos, IDs
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 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 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 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 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 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(lt, sorting):
if sorting == 0:
sa.sort(lt, cmpVideosByViews)
elif sorting == 1:
ins.sort(lt, cmpVideosByViews)
elif sorting == 2:
sel.sort(lt, cmpVideosByViews)
elif sorting == 3:
mer.sort(lt, cmpVideosByViews)
else:
qck.sort(lt, cmpVideosByViews)
def sortVideos(lista, size, cmpfunction):
if size <= lt.size(lista):
sub_list = lt.subList(lista, 1, size)
sub_list = sub_list.copy()
start_time = time.process_time()
mrge.sort(sub_list, cmpfunction)
stop_time = time.process_time()
elapsed_time_mseg = round((stop_time - start_time) * 1000, 2)
return elapsed_time_mseg, sub_list
else:
return None
def mostLikedCategories(catalog, number, category):
for i in lt.iterator(catalog["categoriesId"]):
if i["name"] == category:
idnumber = i["id"]
a = mp.get(catalog["categories"], idnumber)
video = me.getValue(a)["videos"]
mer.sort(video, cmpVideosByLikes)
sub = lt.subList(video, 1, number)
for i in range(1, lt.size(sub) + 1):
a = lt.getElement(sub, i)
print("Nombre: " + a["title"] + "|Categoria: " + category +
"|Likes: " + a["likes"])
def PaisesAfectados(catalog, nombreLanding):
landing = mp.get(catalog["LandingPointN"], nombreLanding)
listaPaises = "NE"
if landing != None:
#listaPaises = lt.newList('ARRAY_LIST')
tablitaPaises = mp.newMap(numelements=10,
maptype='PROBING',
comparefunction=compareCountryNames)
landing = me.getValue(landing)
datosLanding = lt.getElement(
me.getValue(mp.get(catalog["LandingPointI"], landing))['lstData'],
1)
paisLanding = datosLanding["name"].split(",")
paisLanding = paisLanding[len(paisLanding) - 1].strip()
h = paisLanding
edge = gr.getEdge(catalog["connectionsDistance"], paisLanding, landing)
peso = e.weight(edge) / 1000
#lt.addLast(listaPaises,paisLanding)
mp.put(tablitaPaises, paisLanding, peso)
adyacentes = gr.adjacentEdges(catalog["connectionsDistance"], landing)
for arco in lt.iterator(adyacentes):
OtroVertex = e.other(arco, landing)
if not mp.contains(catalog['countriesInfo'], OtroVertex):
adyacentes2 = gr.adjacentEdges(catalog["connectionsDistance"],
OtroVertex)
for arco2 in lt.iterator(adyacentes2):
OtroVertex2 = e.other(arco2, OtroVertex)
if not mp.contains(catalog['countriesInfo'],
OtroVertex2) and OtroVertex2 != landing:
peso = e.weight(arco2) / 1000
id = OtroVertex2.split("*")[0]
datosLanding = lt.getElement(
me.getValue(mp.get(catalog["LandingPointI"],
id))['lstData'], 1)
paisLanding = datosLanding["name"].split(",")
paisLanding = paisLanding[len(paisLanding) - 1].strip()
#if lt.isPresent(listaPaises,paisLanding)==0:
# lt.addLast(listaPaises,paisLanding)
pais = mp.get(tablitaPaises, paisLanding)
if pais != None:
pais = me.getValue(pais)
if (peso < pais):
mp.put(tablitaPaises, paisLanding, peso) #ACA
else:
mp.put(tablitaPaises, paisLanding, peso) #ACA
#heap = pq.newMinPQ(cmpfunction=compareDistance)
listaPaises = lt.newList('ARRAY_LIST')
for pais in lt.iterator(mp.keySet(tablitaPaises)):
elemento = me.getValue(mp.get(tablitaPaises, pais))
#pq.insert(heap,(pais,elemento))
lt.addLast(listaPaises, (pais, elemento))
merge.sort(listaPaises, compareDistance)
return listaPaises
def sortVideos(catalog, size, criteria):
if criteria == 'views':
sorted_list = ms.sort(catalog['videos'], cmpVideosByViews)
elif criteria == 'title':
sorted_list = ms.sort(catalog['videos'], cmpVideosByTitle)
elif criteria == 'likes':
sorted_list = ms.sort(catalog['videos'], cmpVideosByLikes)
if criteria == 'views' or criteria == 'likes':
sorted_list = lt.subList(sorted_list, 1, size)
return sorted_list
def mergeSortVideos(lstevent, size, parametro):
sub_list = lt.subList(lstevent, 1, size)
sub_list = sub_list.copy()
if parametro == 'reprod':
start_time = time.process_time()
mergeSortList = mer.sort(sub_list, cmpGenreByReprod)
stop_time = time.process_time()
elif parametro == 'hashtag':
start_time = time.process_time()
mergeSortList = mer.sort(sub_list, cmpByHashtag)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return (mergeSortList, elapsed_time_mseg)
def req5(analyzer,lp_name):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
"""
id = mp.get(analyzer["id_dado_lp"], lp_name)["value"]
mapa = model.req5(analyzer,id)
paises = mp.keySet(mapa)
final = lt.newList(datastructure="ARRAY_LIST")
i=1
while i <= lt.size(paises):
pais = lt.getElement(paises, i)
distancia = mp.get(mapa, pais)["value"]
lt.addLast(final, (pais,distancia))
i+=1
mrge.sort(final, cmpaux2)
"""
ide = mp.get(analyzer["id_dado_lp"], lp_name)
if ide!=None:
mapa = model.req5(analyzer,ide["value"])
paises = mp.keySet(mapa)
final = lt.newList(datastructure="ARRAY_LIST")
i=1
while i <= lt.size(paises):
pais = lt.getElement(paises, i)
distancia = mp.get(mapa, pais)["value"]
lt.addLast(final, (pais,distancia))
i+=1
mrge.sort(final, cmpaux2)
ii = 1
while ii <= lt.size(final):
elemento = lt.getElement(final, ii)
print("PAÍS: " + str(elemento[0]) + " | DISTANCIA (km): " + str(elemento[1]))
ii+=1
print(str(lt.size(final)) + " países afectados.")
else:
print('No hay información para este landing point.')
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return delta_time,delta_memory
def filtrada(catalog, pais, id_categoria, numero_videos):
tad = lt.newList('ARRAY_LIST')
lista_n = []
i = 1
while i < (lt.size(catalog['videos'])):
if (pais in (lt.getElement(
catalog['videos'],
i)['country'])) and (str(id_categoria) in (lt.getElement(
catalog['videos'], i)['category_id'])):
lt.addLast(tad, lt.getElement(catalog['videos'], i))
i += 1
a = tad.copy()
mer.sort(a, cmpVideosByViews)
b = lt.subList(a, 1, numero_videos)
return b
def getMostViewedVideosByCountryAndCategory(catalog, pais, id_categoria,
numero_videos):
tad = lt.newList()
cont = mp.get(
catalog['categoryIds'],
id_categoria) #Esta la pareja de llave,valor y luego #Esta es la lista
cant = me.getValue(cont)['videos'] #.keys()
videos = it.newIterator(cant) #sacamos lista
while it.hasNext(videos):
video = it.next(videos)
if video['country'] == pais:
lt.addLast(tad, video)
mer.sort(tad, cmpVideosByViews)
b = lt.subList(tad, 1, int(numero_videos))
return b
def req_2(self):
respuesta = lt.newList(datastructure='ARRAY_LIST')
vertices = gp.vertices(self.connections_map)
vertex_it = ll_it.newIterator(vertices)
while ll_it.hasNext(vertex_it):
vertex = ll_it.next(vertex_it)
name = self.id_to_fullname(vertex)
edges = gp.degree(self.connections_map, vertex)
lt.addLast(respuesta, [name, vertex, edges])
mergesort.sort(respuesta, self.req_2_cmp_func)
graphing_helper(self).graph_req_2(respuesta)
respuesta = "\n".join([
"{} ({}): {} conexiones".format(*t) for t in respuesta['elements']
])
return respuesta
def FindMostLikedByTag(catalog, tag, country, elements):
entry = mp.get(catalog["country"], country.strip().lower())
dos = me.getValue(entry)
reduced_list = dos["videos"]
print(lt.size(reduced_list))
tag_list = lt.newList("ARRAY_LIST")
for element in range(1, lt.size(reduced_list) + 1):
video = lt.getElement(reduced_list, element)
yes = video["tags"].split("|")
for sub_element in yes:
if sub_element.lower().find(tag) != -1:
lt.addLast(tag_list, video)
print(lt.size(tag_list))
final_list = merg.sort(tag_list, cmpVideosByLikes)
user_list = lt.newList("ARRAY_LIST", comparador_ascendente)
lt.addFirst(user_list, lt.firstElement(final_list))
iterator = 1
while lt.size(user_list) < int(elements) + 1 and iterator != lt.size(
final_list):
video = lt.getElement(final_list, iterator)
if lt.isPresent(user_list, video) == 0:
lt.addLast(user_list, video)
iterator += 1
else:
iterator += 1
return user_list
def countries_to_landing_point(analyzer, landing_name):
#req 5
landing_id = name_to_id(analyzer, landing_name)
country_origin = m.get(analyzer['landing_points_info'],
landing_id)['value']['country']
lstcables = m.get(analyzer['landing_points_cables'], landing_id)['value']
mapa = m.newMap()
for cable in lt.iterator(lstcables):
vertex = format_vertex(landing_id, cable)
arcos = gr.adjacentEdges(analyzer['connections'], vertex)
for arco in lt.iterator(arcos):
landing_id2 = arco['vertexB'].split('~')[0]
distance = arco['weight']
country = m.get(analyzer['landing_points_info'],
landing_id2)['value']['country']
if country == country_origin:
distance = 0
entry = (country, distance)
if not m.contains(mapa, country):
m.put(mapa, country, entry)
else:
entry2 = m.get(mapa, country)['value']
if distance < entry2[1]:
m.put(mapa, country, entry)
lista = merge.sort(m.valueSet(mapa), compare_entry_req5)
numcountries = lt.size(lista)
return numcountries, lista
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 FindTrendVideoByCategory(catalog, category_name):
cat_id = getCategory_ID(catalog, category_name)
entry = mp.get(catalog["categories"], cat_id)
dos = me.getValue(entry)
reduced_list = dos["videos"]
print(lt.size(reduced_list))
sorted_final_list = merg.sort(reduced_list, cmpVideosByVideoID)
final_element = ""
days = 0
contador = 0
for element in range(1, lt.size(sorted_final_list) + 1):
actual = lt.getElement(sorted_final_list, element)
pos = element + 1
if actual == lt.lastElement(sorted_final_list):
if actual["video_id"] == final_element["video_id"]:
days += 1
days += 1
return final_element, days
next_one = lt.getElement(sorted_final_list, pos)
if actual["video_id"] == next_one["video_id"]:
contador += 1
else:
if contador >= days:
days = contador
final_element = lt.getElement(sorted_final_list, element)
contador = 0
return final_element, days
def mergeSortVideos(catalog, size):
sub_list = lt.subList(catalog['videos'], 0, size)
start_time = time.process_time()
sorted_list = merge.sort(sub_list, cmpVideosByViews)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return elapsed_time_mseg, sorted_list
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 requerimiento4(dicci, tag: str, numero: int):
lili = lt.newList()
lastima = []
for i in range(0, lt.size(dicci["videos"])):
rta = lt.getElement(dicci["videos"], i)
if tag in rta["tags"]:
lt.addLast(lili, rta)
x = mg.sort(lili, cmpPaisesbylikes)
for i in range(numero):
tt = lt.getElement(x, i)
lastima.append(
("titulo: " + str(tt["title"]),
" Nombre del canal: " + str(tt["channel_title"]),
" Fecha de publicacion: " + str(tt["publish_time"]),
" Visitas: " + str(tt["views"]), " Me gustas" + str(tt["likes"]),
"No me gustas: " + str(tt["dislikes"])))
return lastima
def sortVideosByLikes (lista_filtros):
"""
Ordena la lista recibida organizando los datos según sus Likes.
"""
sorted_list = mergesort.sort(lista_filtros, cmpVideosByLikes)
return sorted_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 requerimiento3(catalog, categor, tipodeorden, tipo):
nueva = lt.newList(tipo)
listae = {}
for i in range(0, lt.size(catalog['videos'])):
ele = lt.getElement(catalog['videos'], i)
if ele['category_id'] == categor and not (ele['title']
in listae.keys()):
listae[ele['title']] = 1
ele['dias'] = 1
lt.addLast(nueva, ele)
elif ele['category_id'] == categor and (ele['title'] in listae.keys()):
listae[ele['title']] = listae[ele['title']] + 1
ele['dias'] = listae[ele['title']]
lt.addLast(nueva, ele)
sublista = nueva.copy()
start_time = time.process_time()
if (tipodeorden == "shell"):
sorted_list = sa.sort(sublista, cmpVideosBytiempo)
elif (tipodeorden == "insertion"):
sorted_list = si.sort(sublista, cmpVideosBytiempo)
elif (tipodeorden == "selection"):
sorted_list = ss.sort(sublista, cmpVideosBytiempo)
elif (tipodeorden == "quick"):
sorted_list = sq.sort(sublista, cmpVideosBytiempo)
elif (tipodeorden == "merge"):
sorted_list = sm.sort(sublista, cmpVideosBytiempo)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return sorted_list
def requerimiento4(catalog, size, tipodeorden, tagg, tipo):
nueva = lt.newList(tipo)
final = lt.newList(tipo)
listaee = []
for i in range(0, lt.size(catalog['videos'])):
ele = lt.getElement(catalog['videos'], i)
if tagg in ele['tags']:
lt.addLast(nueva, ele)
sublista = nueva.copy()
start_time = time.process_time()
if (tipodeorden == "shell"):
sorted_list = sa.sort(sublista, cmpVideosByLikes)
elif (tipodeorden == "insertion"):
sorted_list = si.sort(sublista, cmpVideosByLikes)
elif (tipodeorden == "selection"):
sorted_list = ss.sort(sublista, cmpVideosByLikes)
elif (tipodeorden == "quick"):
sorted_list = sq.sort(sublista, cmpVideosByLikes)
elif (tipodeorden == "merge"):
sorted_list = sm.sort(sublista, cmpVideosByLikes)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
for i in range(0, lt.size(sorted_list)):
ete = lt.getElement(sorted_list, i)
if not (ete['title'] in listaee):
listaee.append(ete['title'])
lt.addLast(final, ete)
return elapsed_time_mseg, final
def sortLikes(tag, catalog, pais):
pais = obtener_videos_pais(catalog, pais)
lista_pais = pais['videos']
lista_tags = tags_en_lista(tag, lista_pais, catalog)
sorted_list = ms.sort(lista_tags, cmpVideosByLikes)
return sorted_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
