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
