def musica_req3(valor_minTempo, valor_maxTempo, valor_minInstrumentalness, valor_maxInstrumentalness, catalog): """ Retorna una lista con las canciones """ tracksUnicos = lt.newList('ARRAY_LIST') canciones = lt.newList('ARRAY_LIST') artistasRepetidos = lt.newList('ARRAY_LIST') MapInstrumentalness = mp.get(catalog['caraContenido'], 'instrumentalness') RBTInstrumentalness = me.getValue(MapInstrumentalness) lista_listas_Instrumentalness = om.values(RBTInstrumentalness, valor_minInstrumentalness, valor_maxInstrumentalness) lista_Instrumentalness = it.newIterator(lista_listas_Instrumentalness) while it.hasNext(lista_Instrumentalness): listas_musica = it.next(lista_Instrumentalness) musicas = it.newIterator(listas_musica) while it.hasNext(musicas): musica = it.next(musicas) if (musica['tempo'] >= valor_minTempo and musica['tempo'] <= valor_maxTempo): if int(lt.isPresent(tracksUnicos, musica['track_id'])) == 0: lt.addLast(tracksUnicos, musica['track_id']) if int( lt.isPresent( artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id'])) lt.addLast(canciones, musica) else: if int( lt.isPresent( artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id'])) lt.addLast(canciones, musica) return canciones, tracksUnicos
def top_servcios(catalogo): llaves=m.keySet(catalogo["lista_compañias"]) ite=it.newIterator(llaves) lista=lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None) while it.hasNext(ite): llave=it.next(ite) pareja=m.get(catalogo["lista_compañias"],llave) lt.addLast(lista,pareja) mer.mergesort(lista,comparar_data_servicios) return lista
def printElementData(element): """ Imprime los datos de un elemento determinado """ print('Promedio: ' + str(round(element['average_rating'], 2))) print('Total de películas: ' + str(lt.size(element['movies']))) iterator = it.newIterator(element['movies']) while it.hasNext(iterator): movie = it.next(iterator) print('Película: ' + movie['title'])
def printReq3(resp): print("\n") print("TOP 3 ESTACIONES DE SALIDA") itresp = it.newIterator(resp["salidas"]) while it.hasNext(itresp): M = it.next(itresp) print("- " + M) print("\n") print("TOP 3 ESTACIONES DE DESTINO") itresp2 = it.newIterator(resp["llegadas"]) while it.hasNext(itresp2): F = it.next(itresp2) print("- " + F) print("\n") print("TOP 3 ESTACIONES MENOS USADAS") itresp3 = it.newIterator(resp["usadas"]) while it.hasNext(itresp3): R = it.next(itresp3) print("- " + R)
def imprimirActores(result): print("\nPelículas de:", actor) iterator = it.newIterator(result[0]) while it.hasNext(iterator): pelicula = it.next(iterator) print("{:<50}{:<20}{:}".format(pelicula[0], pelicula[1], pelicula[2])) print("\nLa cantidad de películas del actor es:", result[1]) print("El promedio de la cantidad de votos de las películas del actor:", round(result[2], 2)) print("El nombre del director con el que mas ha colaborado es:", result[3])
def imprimirGeneros(result): print("\nPelículas de:", genero) iterator = it.newIterator(result[0]) while it.hasNext(iterator): pelicula = it.next(iterator) print("{:<50}{:<5}{:<10}".format(pelicula[0], pelicula[1], pelicula[2])) print("\nLa cantidad de películas del género es:", result[1]) print("El promedio de la cantidad de votos del género es:", round(result[2], 2))
def show_country_data(country): """ Imprime las películas de una productara. """ if country: print('País de producción de cine encontrada: ' + country['name']) print('Promedio: ' + str(country['average_rating'])) print('Total de películas: ' + str(lt.size(country['movies']))) iterator = it.newIterator(country['movies']) iterator_2 = it.newIterator(country['director']) while it.hasNext(iterator): movie = it.next(iterator) while it.hasNext(iterator_2): director = it.next(iterator_2) print('Título: ' + movie['title'] + ' | Relase Date: ' + movie['release_date'] + '| Director: ' + director['director_name']) else: print('No se encontró el país')
def Requerimiento2(analyzer): vertic = gr.vertices(analyzer['connections']) listaR = lt.newList('SINGLE_LINKED') iterator = it.newIterator(vertic) while it.hasNext(iterator): posi = it.next(iterator) vert_adya = gr.degree(analyzer['connections'], posi) lt.addLast(listaR, (posi, vert_adya)) res = sorting2(listaR, 10, cmpfunction_merge) return res
def optionFour(): print("Requerimiento 2") print("Se desea conocer las rutas circulares que se pueden realizar en un estimado espacio de tiempo") time1=int(input('Escriba el tiempo minimo que estima para su visita de la ciudad: '))*60 time2=int(input('Escriba el tiempo maximo que tiene para visitar la ciudad: '))*60 start=int(input('Escriba el id de la estación de la que desea empezar su recorrido: ')) result=controller.FindCycles(cont,start,time1,time2) cycles=it.newIterator(result) print("hay ",lt.size(result),"rutas circulares que se pueden visitar en el tiempo dado \n Estos son: \n") while it.hasNext(cycles): print("-----------------------------") cycle=it.next(cycles) cycleit= it.newIterator(cycle) while it.hasNext(cycleit): edge=it.next(cycleit) if edge!=None: print("salida",edge["vertexA"],"llegada",edge["vertexB"],"tiempo estimado",round(edge["weight"]/60,2),"min\n")
def printMoviesByGenre(catalog, genreName): moviesByGenre = controller.getMoviesByGenre(catalog, genreName) iterator = it.newIterator(moviesByGenre["movies"]) while it.hasNext(iterator): movie = it.next(iterator) print(movie["title"]) size = controller.genreMoviesSize(catalog, genreName) promedio = controller.averageByGenre(catalog, genreName) print("\nSe encontraron "+ str(size) +" películas") print("El promedio de votos de las películas del género "+genreName+" es: "+str(round(promedio,1)))
def printMoviesByCountry(catalog, countryName): moviesByCountry = controller.getMoviesByCountry(catalog, countryName) iterator = it.newIterator(moviesByCountry["movies"]) while it.hasNext(iterator): movie = it.next(iterator) casting = controller.linkIdToMovieCasting(catalog, movie["id"]) director = casting["director_name"] split = movie["release_date"].split("/") año = split[2] print("Título:", movie["title"]," ", "Año:", año," ","Director:", director)
def printMoviesByProductionCompany(catalog, companyName): moviesByProductionCompany = controller.getMoviesByProductionCompany(catalog, companyName) iterator = it.newIterator(moviesByProductionCompany["movies"]) while it.hasNext(iterator): movie = it.next(iterator) print(movie["title"]) size = controller.companyMoviesSize(catalog, companyName) promedio = controller.averageByProductionCompany(catalog, companyName) print("\nSe encontraron "+ str(size) +" películas") print("El promedio de calificación de las películas producidas por "+companyName+" es: "+str(round(promedio,1)))
def printBooksbyYear(books): """ Imprime los libros que han sido publicados en un año """ print('Se encontraron: ' + str(lt.size(books)) + ' Libros') iterator = it.newIterator(books) while it.hasNext(iterator): book = it.next(iterator) print(book['title'])
def printBooksbyTag(books): """ Imprime los libros que han sido clasificados con una etiqueta """ print('Se encontraron: ' + str(lt.size(books)) + ' Libros') iterator = it.newIterator(books) while it.hasNext(iterator): book = it.next(iterator) print(book['title'])
def loadData(catalog, Detailsfile, Castingfile): """ Carga los datos de los archivos en el modelo """ list_unida = lt.newList("ARRAY_LIST", None) list_details = loadDetails(catalog, Detailsfile) list_casting = loadCasting(catalog, Castingfile) it1 = it.newIterator(list_details) while it.hasNext(it1): movie = it.next(it1) model.addMovie(catalog, movie) it2 = it.newIterator(list_casting) while it.hasNext(it2): peli = it.next(it2) if movie["id"] == peli["id"]: union = {**movie, **peli} lt.addLast(list_unida, union) break return list_unida
def bfsVertex(search, graph, source, maxtime): """ Funcion auxiliar para calcular un recorrido BFS Args: search: Estructura para almacenar el recorrido vertex: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: adjsqueue = queue.newQueue() queue.enqueue(adjsqueue, source) while not queue.isEmpty(adjsqueue): vertex = queue.dequeue(adjsqueue) visited_v = map.get(search['visited'], vertex)['value'] adjslst = g.adjacents(graph, vertex) adjslstiter = it.newIterator(adjslst) if not (it.hasNext(adjslstiter)): visited_v["final"] = True c = 0 while (it.hasNext(adjslstiter)): if c == 1 and vertex != source: break total_time = 0 w = it.next(adjslstiter) if not (it.hasNext(adjslstiter)) and c == 0: visited_v["final"] = True edge = g.getEdge(graph, vertex, w) time = edge['weight'] / 60 visited_w = map.get(search['visited'], w) if visited_w is None: if visited_v["final"] == False: dist_to_w = visited_v['distTo'] + time total_time = dist_to_w if total_time <= maxtime: visited_w = { 'marked': True, 'edgeTo': vertex, "distTo": dist_to_w, "final": False } map.put(search['visited'], w, visited_w) queue.enqueue(adjsqueue, w) c = 1 return search except Exception as exp: error.reraise(exp, 'bfs:bfsVertex')
def mejorHorario(analyzer): # Req. 3 hora_inicio = '' hora_fin = '' area1 = input('Digita el area comunitaria de inicio: ') area2 = input('Digita el area comunitaria final: ') inicio_H = int( input('Digita las horas de la hora inicial en formato HH: ')) inicio_M = int( input('Digita los minutos de la hora inicial en formato MM: ')) fin_H = int(input('Digita las horas de la hora final en formato HH: ')) fin_M = int(input('Digita los minutos de la hora final en formato MM: ')) if inicio_M > 60 or inicio_H > 24 or fin_M > 60 or fin_H > 24: print('¡¡ KELLY, UNA HORA TIENE 60 MINUTOS Y UN DÍA 24 HORAS !!') else: if inicio_M > 0 and inicio_M <= 15: inicio_M = '15' hora_inicio = str(inicio_H) + ':' + inicio_M elif inicio_M == 0: inicio_M = '00' hora_inicio = str(inicio_H) + ':' + inicio_M elif inicio_M > 15 and inicio_M <= 30: inicio_M = '30' hora_inicio = str(inicio_H) + ':' + inicio_M elif inicio_M > 30 and inicio_M <= 45: inicio_M = '45' hora_inicio = str(inicio_H) + ':' + inicio_M elif inicio_M > 45 and inicio_M <= 60: inicio_M = '00' inicio_H += 1 hora_inicio = str(inicio_H) + ':' + inicio_M if fin_M > 0 and fin_M <= 15: fin_M = '15' hora_fin = str(fin_H) + ':' + fin_M elif fin_M > 15 and fin_M <= 30: fin_M = '30' hora_fin = str(fin_H) + ':' + fin_M elif fin_M > 30 and fin_M <= 45: fin_M = '45' hora_fin = str(fin_H) + ':' + fin_M elif fin_M > 45 and fin_M <= 60: fin_M = '00' fin_H += 1 hora_fin = str(fin_H) + ':' + fin_M data = ctrl.parteC(analyzer, area1, area2, hora_inicio, hora_fin) print('El mejor horario de ', area1, ' a ', area2, ' es de ', str(data[1][1]), ' a ', str(data[2][1]), ' con una duracion promedio de ', data[0], 'segundos.') iterator = it.newIterator(data[3]) string = [] while it.hasNext(iterator): current = it.next(iterator) string.append('Community Area ' + str(current['vertexA'][0]) + ' -> Community Area ' + str(current['vertexB'][0])) string = ", ".join(string) print('Haciendo el siguiente recorrido: ', string)
def sortVideosCountryTrending(catalog, country): tracemalloc.start() delta_time = -1.0 delta_memory = -1.0 start_time = getTime() start_memory = getMemory() sublistcountries = mp.get(catalog["countries_sorted"], country)["value"] sorted_list_titles = merge.sort(sublistcountries, compVideoByTitle) video_id = "" days = 0 days_max = 0 video_id_max = "" channel = "" channel_max = "" title = "" title_max = "" iterator2 = it.newIterator(sorted_list_titles) while it.hasNext(iterator2): element = it.next(iterator2) idNumber = element["video_id"] if video_id != "#NAME": if video_id == idNumber: days += 1 else: if days > days_max: days_max = days video_id_max = video_id channel_max = channel title_max = title video_id = element["video_id"] channel = element["channel_title"] title = element["title"] days = 1 result = ("Titulo: " + str(title_max) + ", Nombre del canal: " + str(channel_max) + ", País: " + str(country) + ", Días: " + str(days_max)) 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, result
def getdates(cont): date = input(print('Ingrese la fecha:')) n = int(input(print('Ingrese el numero de taxis:'))) date = datetime.datetime.strptime(date, '%Y-%m-%d') date = date.date() crimedate = om.get(cont, date) a = me.getValue(crimedate)['taxiIndex'] b = map.keySet(a) i = it.newIterator(b) puntajes = {} while it.hasNext(i): c = it.next(i) millas = 0 servicios = 0 dinero = 0 taxi = map.get(a, c) taxi = me.getValue(taxi) taxi = taxi['lsttrips'] x = it.newIterator(taxi) while it.hasNext(x): w = it.next(x) if float(w['trip_total']) > 0: milla = float(w['trip_miles']) millas += milla money = float(w['trip_total']) dinero += money servicios += 1 if dinero > 0: puntaje = (millas / dinero) * servicios puntajes[c] = puntaje puntajes_ord = sorted(puntajes.items(), key=operator.itemgetter(1), reverse=True) num = 1 cent = 0 while n >= 0: print( str(num) + '.' + puntajes_ord[cent][0] + ' con un total de' + ' ' + str(puntajes_ord[cent][1])) num += 1 cent += 1 n -= 1
def maxDateinRange(mindate, maxdate, analyzer): date = None max_acc = 0 values = valuesinRange(mindate, maxdate, analyzer) iterator = it.newIterator(values) while it.hasNext(iterator): elemento = it.next(iterator) if lt.size(elemento['AccidentList']) > max_acc: max_acc = lt.size(elemento['AccidentList']) date = elemento['Date'] return (date, max_acc)
def tags(catalog, lista, tag): """ Dada una lista de videos retorna otra con los videos que tienen un tag dado """ final = lt.newList(datastructure='ARRAY_LIST') i = it.newIterator(lista) while it.hasNext(i): vid = it.next(i) if tag in vid['tags']: lt.addLast(final, vid) return final
def optionSix(): initialStation = input("Escriba la estacion de inicio del trayecto: ") limite = input("Escriba la duracion deseada del trayecto: ") lstpaths = it.newIterator( controller.rutasPorResistencia(cont, initialStation, int(limite))) while it.hasNext(lstpaths): eachPath = it.next(lstpaths) print( "Estacion de partida {} ---- Estacion de llegada {} ----- Duracion {} " .format(eachPath["Initial Station"], eachPath["Final Station"], eachPath["Time"]))
def addRouteConnections(citibike): """ Por cada vertice (cada estacion) se recorre la lista de rutas servidas en dicha estación y se crean arcos entre ellas para representar el cambio de ruta que se puede realizar en una estación. """ lststops = m.keySet(citibike['stops']) stopsiterator = it.newIterator(lststops) while it.hasNext(stopsiterator): key = it.next(stopsiterator) lstroutes = m.get(citibike['stops'], key)['value'] prevrout = None routeiterator = it.newIterator(lstroutes) while it.hasNext(routeiterator): route = key + '-' + it.next(routeiterator) if prevrout is not None: addConnection(citibike, prevrout, route, 0) addConnection(citibike, route, prevrout, 0) prevrout = route
def getAccidentsByRange(analyzer, initialDate, finalDate): """ Retorna el numero de crimenes en un rago de fechas. """ lst = om.values(analyzer['fechas'], initialDate, finalDate) lstiterator = it.newIterator(lst) totcrimes = 0 while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) totcrimes += lt.size(lstdate['accidentes']) return totcrimes
def rango_accidentes_severidad(accidentes, initialDate, finalDate): lst = om.values(accidentes['Fechas'], initialDate.date(), finalDate) lstiterator = it.newIterator(lst) totacc = 0 lista = {} while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) lista[lstdate['Accidentes']["first"]["info"]['Start_Time']] = lt.size( lstdate['Accidentes']) totacc += lt.size(lstdate['Accidentes']) return totacc, lista
def stationNear(mapa, lat1, lon1): keys = m.keySet(mapa) values = m.valueSet(mapa) small = m.get(mapa, 72) valorilt = small['value'][0] valorilo = small['value'][1] Thedis = distance(valorilt, lat1, valorilo, lon1) itv = it.newIterator(values) itk = it.newIterator(keys) while it.hasNext(itv): value = it.next(itv) key = it.next(itk) lat = value[0] lon = value[1] dist = distance(lat1, lat, lon1, lon) if dist < Thedis: Thedis = dist station = key return station
def optionThree(): parte1 = controller.totalTaxis(cont) print("Se tienen: " + str(parte1) + " " + "Taxis en total") parte2 = controller.totalCompanies(cont) print("Se tienen: " + str(parte2) + " " + "empresas en total") num = int(input("¿Cuántas compañías se revisarán (top taxis)? \n")) num2 = int(input("¿Cuántas compañías se revisarán (top servicios)? \n")) info = controller.companiesByTaxis(cont, num) infoIterator = it.newIterator(info) print('Compañia:\tNúmero de taxis afiliado:\n') while it.hasNext(infoIterator): elem = it.next(infoIterator) print(elem['company'], '\t', elem['taxis']) info2 = controller.companiesByServices(cont, num2) infoIterator2 = it.newIterator(info2) print('Compañia:\tNúmero de servicios afiliado:\n') while it.hasNext(infoIterator2): elem = it.next(infoIterator2) print(elem['company'], '\t', elem['servicios'])
def addTaxisServices (analyzer): iterator=it.newIterator(analyzer["companies"]["taxis"]) while it.hasNext(iterator): company=it.next(iterator) mp.insert(analyzer["companies"]["total_taxis"],(lt.size(company["taxis_id"])*-1),company["company"]) mp.insert(analyzer["companies"]["total_services"],(company["services"])*-1,company["company"]) analyzer["NumTaxis"]+=lt.size(company["taxis_id"]) for i in range(0,mp.size(analyzer["companies"]["total_taxis"])): analyzer["companies"]["diccio"]["top_taxis"].append(mp.delMin(analyzer["companies"]["total_taxis"])) for j in range (0,mp.size(analyzer["companies"]["total_services"])): analyzer["companies"]["diccio"]["top_services"].append(mp.delMin(analyzer["companies"]["total_services"]))
def relacionar_id_categorias(category, catalog): nombre = "" iterador = it.newIterator(catalog['categories']) while it.hasNext(iterador): elemento = it.next(iterador) if category == elemento['id']: nombre = elemento['name'] break return nombre """
def parteA2(analyzer): answer = 0 companies = m.keySet(analyzer['companyByTaxis']) iterator = it.newIterator(companies) while it.hasNext(iterator): company = it.next(iterator) value = m.get(analyzer['companyByTaxis'], company)['value'] size = m.size(value) if size > 0: answer += 1 return answer