def buscar_estaciones_peor_top(graph, reference_table): """"Funcion para hallar los viajes que llegan a una estacion!""" estaciones = lt.newList() vertices = gr.vertices(graph) it_vertice = it.newIterator(vertices) while it.hasNext(it_vertice): vert = it.next(it_vertice) estacion = gr.indegree(graph, vert) estacion += gr.outdegree(graph, vert) lt.addLast(estaciones, (estacion, vert)) merge.mergesort(estaciones, lessFunction) final_top = [] for i in range(3): top = lt.firstElement(estaciones) nombre = conversor_id_nombre(top[1], reference_table, "end station name") final_top.append((top[0], nombre)) lt.removeFirst(estaciones) return final_top
def getDirector(catalog, director): """ Retorna a un director con su informacion. """ value= getElementCriteria(catalog, 'director_name', director) try: movies=value['movies'] info=value['details'] lst=lt.newList(datastructure='SINGLE_LINKED') iterator=it.newIterator(info) while it.hasNext(iterator): movie=it.next(iterator) title=movie['title'] lt.addLast(lst, title) avg=value['vote_avg'] size=lt.size(movies) return (lst, size, avg) except: return None
def TaxisPorCompania(analyzer): taxisXCompania = om.newMap(omaptype='RBT', comparefunction=compareIds) total_taxis = 0 nombres = om.keySet(analyzer['companias']) iter = it.newIterator(nombres) while it.hasNext(iter): cada_compania = it.next(iter) nombre_compania = om.get(analyzer['companias'], cada_compania) if nombre_compania['key'] is not None: taxis = me.getValue(nombre_compania)['taxis_afiliados'] # print(taxis) if taxis is not None: num_taxis = m.size(taxis) total_taxis += num_taxis om.put(taxisXCompania, num_taxis, cada_compania) # print(om.valueSet(taxisXCompania)) # print(om.keySet(taxisXCompania)) return (taxisXCompania)
def LikesPais(catalogo, pais, numero, tag): #sacar paises, sacar videos del pais paises = catalogo['paises'] videos = me.getValue(mp.get(paises, pais))['videos'] #iteracion, obitine diccionario con las views de los videos con el tag y el pais iterator = it.newIterator(videos) final = {} lista = lt.newList() while it.hasNext(iterator): x = it.next(iterator) answer = (mp.get(catalogo['videosID'], x)) tags = answer['value']['tags'] if tag in tags: likes = answer['value']['likes'] if x in final and likes > final[x]: final[x] = likes else: final[x] = likes #recorre el diccionario y devuelve la lista con el numero de videos pedidos lista = recorrerDic(final, numero) print(lista) for i in lista: video = mp.get(catalogo['videosID'], i) titulo = video['value']['title'] canal = video['value']['channel_title'] tiempo = video['value']['publish_time'] views = video['value']['views'] likes = video['value']['likes'] dislikes = video['value']['dislikes'] tags = video['value']['tags'] print(text.BOLD + 'Title: ' + text.END, titulo, '\n', text.BOLD + 'Channel_title: ' + text.END, canal, text.BOLD, '\n', 'Publish_time: ' + text.END, tiempo, '\n', text.BOLD + 'Views: ' + text.END, views, '\n', text.BOLD + text.YELLOW + 'Likes: ' + text.END, likes, '\n', text.BOLD + 'Dislikes: ' + text.END, dislikes, '\n', text.BOLD + 'Tags: ' + text.END, tags)
def getAccidentsByRange(analyzer, initialDate, endDate): """ Para un rango de fechas retorna la cantidad de accidentes sucedidos junto con la categoría más reportada """ lst = om.values(analyzer['dateIndex'], initialDate, endDate) #Hacemos una lista con los valores lstiterator = it.newIterator(lst) totalaccidentes = 0 most = (0, None) while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) z = lt.size(lstdate['lstaccident']) par = ((lt.getElement(lstdate['lstaccident'], 1))['Start_Time']).split() fecha = par[0] if z > most[0]: most = (z, fecha) totalaccidentes += z return totalaccidentes, most
def addPais(diccio): iterador = it.newIterator(diccio["videos"]) while it.hasNext(iterador): actual = it.next(iterador) if mp.contains(diccio["trending"], actual["country"]) == True: par = mp.get(diccio['trending'], actual["country"]) lis = me.getValue(par) lt.addLast(lis, actual) else: lis = lt.newList() mp.put(diccio['trending'], actual["country"], lis) lt.addLast(lis, actual) return diccio
def Suma_de_los_valores(citiTaxi, initialDate, finalDate): """ Retorna el numero de crimenes en un rago de fechas. """ dic={} cont=0 lst = om.keys(citiTaxi['fecha'], initialDate, finalDate) iterator = it.newIterator(lst) while it.hasNext(iterator): llave = it.next(iterator) llave2 = om.get(citiTaxi['fecha'], llave) entry = me.getValue(llave2) for i in entry: if i not in dic: dic[i] = {'dinero': entry[i]['dinero'], 'millas': entry[i]['millas'], 'servicios': entry[i]['servicios']} else: dic[i]['dinero'] += entry[i]['dinero'] dic[i]['millas'] += entry[i]['millas'] dic[i]['servicios'] += entry[i]['servicios'] return dic
def getAccidentsByHours2(analyzer, initialDate, endDate): """ Para un rango de fechas retorna la cantidad de accidentes sucedidos junto con la categoría más reportada """ lst = om.values(analyzer['hourIndex'], initialDate, endDate) #Hacemos una lista con los valores lstiterator = it.newIterator(lst) totalaccidentes = 0 conteo = {} while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) z = lt.size(lstdate['lstaccident']) par = ((lt.getElement(lstdate['lstaccident'], 1))['Severity']) if par in conteo: conteo[par] += z else: conteo[par] = z totalaccidentes += z return totalaccidentes, conteo
def getAccidentsByDate(analyzer, day): """ Para una fecha determinada, retorna el numero de accidentes por severidad. """ aDate = om.get(analyzer['date'], day) if aDate['key'] is not None: Accismap = me.getValue(aDate)['severities'] sev=m.keySet(Accismap) iterator= it.newIterator(sev) totales=0 while(it.hasNext(iterator)): severity1= it.next(iterator) numaccis = m.get(Accismap,severity1) lista= numaccis['value'] cuantas = lt.size(lista['listBySeverity']) totales+=cuantas if lista is not None: print("severidad: "+ str(severity1) + " tiene : " +str(cuantas) +" accidentes") print("accidentes totales: "+str(totales))
def totalTaxis(analyzer): cont=0 lista=[] lista2=[] valores=m.valueSet(analyzer["TaxiNum"]) iterator_valores= it.newIterator(valores) while it.hasNext(iterator_valores): elemento=it.next(iterator_valores) lista.append(elemento) for i in lista: valor=i for k in valor: numeros=valor[k] lista2.append(numeros) for z in lista2: cont+=z return cont
def EstaciónMasProxima(latO, lonO, analyzer): idynombre = [] prox = lt.newList(datastructure="ARRAY_LIST", cmpfunction=comparador) Index = analyzer["index"] A = m.keySet(Index) a = it.newIterator(A) while it.hasNext(a): B = it.next(a) C = m.get(Index, B) B = me.getValue(C) latitud = B["start station latitude"] longitud = B["start station longitude"] distancia = ha.haversine(float(lonO), float(latO), float(longitud), float(latitud)) B["Distancia al punto"] = distancia lt.addLast(prox, B) merge.mergesort(prox, MasProximo) resultado = lt.firstElement(prox) idynombre.append(resultado["start station name"]) idynombre.append(resultado["start station id"]) return idynombre
def fifthRequirement(analyzer, edad): grafo1 = analyzer['ages1'] grafo2 = analyzer['ages2'] mpa1 = djk.Dijkstra(grafo1, str(edad)) mpa2 = djk.Dijkstra(grafo2, str(edad)) res1 = lt.firstElement(djk.pathTo(mpa1, "salida"))['vertexB'] res2 = lt.firstElement(djk.pathTo(mpa2, "salida"))['vertexB'] mpa1 = djk.Dijkstra(analyzer['graph'], res1) ruta = djk.pathTo(mpa1, res2) iterator = it.newIterator(ruta) ruta = res1 while it.hasNext(iterator): element = it.next(iterator) estacion = element['vertexB'] ruta += "-" + estacion print( "Los usuarios con edad en los {}'s les gusta iniciar en la estación {} y terminar en la estación {}. Se recomienda la ruta siguiente: {}" .format(int(edad) * 10, res1, res2, ruta)) return None
def rutas(analyzer, id, res): lista = lt.newList() vert = gr.adjacents(analyzer["trips"], id) iterator = it.newIterator(vert) while it.hasNext(iterator): element = it.next(iterator) edge = gr.getEdge(analyzer["trips"], id, element) time = edge["weight"] if (float(time) <= float(res)) and (element != id): route = newRoute() route["path"] = id + "-" + edge["vertexB"] route["time"] = time route["startName"] = nameStation(analyzer, id) route["endName"] = nameStation(analyzer, edge["vertexB"]) lstTimes = route["Seg"] lt.addLast(lstTimes, (id + "-" + edge["vertexB"], time)) lt.addLast(lista, route) vertB = edge["vertexB"] ruta(analyzer, lista, route, vertB, res) return lista
def DiasPais(catalogo, pais): pais = pais.lower().strip() paises = catalogo['paises'] vidP = me.getValue(mp.get(paises, pais))['videos'] iterator = it.newIterator(vidP) maxdict = {} while it.hasNext(iterator): x = it.next(iterator) if x in maxdict: maxdict[x] += 1 else: maxdict[x] = 1 keys = list(maxdict.keys()) values = list(maxdict.values()) maxV = values.index(max(values)) topD = keys[maxV] dTop = values[maxV] video = me.getValue(mp.get(catalogo['videosID'], topD)) return video, dTop
def optionSix(): rango = input("ingrese el rango de edad: ") path_, estacion_salida, estacion_llegada, costo = controller.recomendar_rutas( cont, rango) if path_ is None: print("No hay estaciones de salida ni llegada para ese rango de edad") elif path_ == 0: print("La estacion de salida recomendada es: ", estacion_salida) print("La estacion de llegada recomendada es: ", estacion_llegada) print("El tiempo estimado de viaje es:", costo) else: print("La estacion de salida recomendada es: ", estacion_salida) print("La estacion de llegada recomendada es: ", estacion_llegada) print("El tiempo estimado de viaje es:", costo) print("***************************************") print("Las estaciones en la ruta son: ") iterador = it.newIterator(path_) while it.hasNext(iterador): element = it.next(iterador) print(element)
def getTrendVidByCountry(catalog, country_name): countries = catalog['countries'] posCountry = lt.isPresent(countries, country_name) if posCountry > 0: country = lt.getElement(countries, posCountry) mg.sort(country['videos'], cmpVideosByTitle) iteratorVid = lti.newIterator(country['videos']) trendVids = lt.newList("ARRAY_LIST", cmpfunction=compareVideoName) while lti.hasNext(iteratorVid): video = lti.next(iteratorVid) vidName = video['title'] posVid = lt.isPresent(trendVids, vidName) if posVid > 0: el = lt.getElement(trendVids, posVid) el['cuenta'] += 1 else: lt.addLast(trendVids, {"info": video, "cuenta": 1}) sortedTrendVids = mg.sort(trendVids, cmpVideosByDays) firstTrendVid = lt.firstElement(sortedTrendVids) return firstTrendVid
def numhts(tracks, catalog): mapafinal = mp.newMap(maptype="PROBING", loadfactor=0.5) tracksmap = mp.newMap(maptype="PROBING", loadfactor=0.5) d = it.newIterator(tracks) while it.hasNext(d): track = it.next(d) mp.put(tracksmap, track) x = promedio(catalog, track) if x != None: numht = x[0] prom = x[1] par = mp.get(mapafinal, numht) if par != None: lista = me.getValue(par) lt.addLast(lista, (track, prom)) else: lista = lt.newList(datastructure="ARRAY_LIST") lt.addLast(lista, (track, prom)) mp.put(mapafinal, numht, lista) return mapafinal, tracksmap
def optionNine(): try: if (cat.isdigit()) and (int(cat) > 0) and (int(cat) < 8): catLst, size = controller.getPublicityRoute(analyzer, int(cat)) routeIterator = it.newIterator(catLst) ite = 1 if size > 2: print( "Las rutas que son las más adecuadas para publicidad dentro del rango de edad ingresado son:\n" ) else: print( "La ruta que es la más adecuada para publicidad dentro del rango de edad ingresado es:\n" ) while it.hasNext(routeIterator) and (ite < size): routeTup = it.next(routeIterator) num, route = routeTup if num == 0: print( "No hay viajes registrados que cumplan con los requisitos en ese grupo de edad" ) else: statLst = route.split("-") routeAns = "" for i in range(0, len(statLst)): routeAns = routeAns + "-" + controller.getStationName( analyzer, statLst[i]) + "(id- " + statLst[i] + ")" print("La ruta " + routeAns[1:] + " con " + str(num) + " veces realizada.") ite += 1 total = it.next(routeIterator) print( "\nHubo " + str(total) + " viajes hechos por personas del rango de edad ingresado que tienen suscripción de 3 días" ) else: print( "La categoria ingresada debe ser un numero natural entre 1 y 7" ) except: print("Hubo un error en la busqueda")
def video_trending_categoria(category_name, lista, categorias) -> dict: for i in categorias: if categorias[i] == category_name: numero_categoria = int(i) mayor = 0 aux = [] dict_final = {} iterador = it.newIterator(lista) contador2 = 0 while it.hasNext(iterador): elemento = it.next(iterador) centinela = True contador = 0 if numero_categoria == int(elemento['category_id']): while contador < len(aux): if (elemento['title'] == aux[contador]["title"]): aux[contador]["numero de dias"] += 1 centinela = False contador += 1 if centinela == True: aux.append({ "title": elemento["title"], "channel_title": elemento["channel_title"], "category_id": elemento["category_id"], "numero de dias": 1, "dates": str(elemento["trending_date"]) }) while contador2 < len(aux): if int(aux[contador2]["numero de dias"]) > mayor: dict_final["title"] = aux[contador2]["title"] dict_final["channel_title"] = aux[contador2]["channel_title"] dict_final["category_id"] = numero_categoria dict_final["numero de dias"] = aux[contador2]["numero de dias"] mayor = int(aux[contador2]["numero de dias"]) contador2 += 1 return dict_final
def initSearch(graph, source): """ Inicializa la estructura de busqueda y deja todos los arcos en infinito. Se inserta en la cola indexada el vertice source Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = {'source': source, 'visited': None, 'iminpq': None} search['visited'] = map.newMap( numelements=g.numVertex(graph), maptype='PROBING', comparefunction=graph['comparefunction']) vertices = g.vertices(graph) itvertices = it.newIterator(vertices) while (it.hasNext(itvertices)): vert = it.next(itvertices) map.put(search['visited'], vert, { 'marked': False, 'edgeTo': None, 'distTo': math.inf }) map.put(search['visited'], source, { 'marked': True, 'edgeTo': None, 'distTo': 0 }) pq = iminpq.newIndexMinPQ(cmpfunction=graph['comparefunction']) search['iminpq'] = pq iminpq.insert(search['iminpq'], source, 0) return search except Exception as exp: error.reraise(exp, 'dks:init')
def findStations(citibike, lat1, lon1, lat2, lon2): iterator = it.newIterator( citibike['stations'] ) #Lugar donde se encuentra la información de todas las estaicones while it.hasNext(iterator): info = it.next(iterator) lat_s = info['start station latitude'] lon_s = info['start station longitude'] short_st_distance = 2000 short_fn_distance = 2000 start_name = '' finish_name = '' startPoint = distance(lat1, lat_s, lon1, lon_s) finishPoint = distance(lat2, lat_s, lon2, lon_s) if startPoint < short_st_distance: short_st_distance = startPoint start_name = info['start station id'] if finishPoint < short_fn_distance: short_fn_distance = finishPoint finish_name = info['start station id'] return [start_name, finish_name]
def top_companies_by_services(catalog, top_number): companies_per_services = catalog["companies"]["companies_per_services"] key_lst = m.keySet(companies_per_services) greater = 0 counter = 0 lst = lt.newList(cmpfunction=compare_companies) while counter < top_number: iterator = it.newIterator(key_lst) while it.hasNext(iterator): company = it.next(iterator) entry = m.get(companies_per_services, company) services_number = me.getValue(entry) if services_number > greater: greater = services_number greater_company = company lt.addLast(lst, (greater_company, greater)) pos = lt.isPresent(key_lst, greater_company) lt.deleteElement(key_lst, pos) greater = 0 counter += 1 return lst
def getCloserStation(analyzer, latitud, longitud): grafo = analyzer['graph'] vertice = str(72) recorrido = m.keySet(dfs.DepthFirstSearch(grafo, vertice)['visited']) iterator = it.newIterator(recorrido) distance = float('inf') closer = 0 while it.hasNext(iterator): element = it.next(iterator) coordinates = m.get(analyzer['distance'], element)['value'] if coordinates == None: a = 1 else: distancia = dinstancefunction( np.radians(float(coordinates['latitud'])), np.radians(float(coordinates['longitud'])), float(latitud), float(longitud)) if distance >= distancia: distance = distancia closer = element return closer
def hayarMinCiclos(cont, initialStation, estaciones): listaCiclos=[] for a in range(0,len(estaciones)): lista=[] cont = minimumCostPaths(cont, initialStation) tiempo1 = djk.distTo(cont["paths"],estaciones[a]) #tiempo de Inicio a V1 lista=["Hay un camino que empieza en "+str(initialStation)+" y va a " +str(estaciones[a]) +" en un tiempo de "+str(round(tiempo1))+" segundos que se conecta asi:"] cont = minimumCostPaths(cont, estaciones[a]) tiempo2 = djk.distTo(cont["paths"],initialStation) minimumCostPaths(cont, estaciones[a]) path2 = minimumCostPath(cont, initialStation) iterator = it.newIterator(path2) tiempo_visita=0 while it.hasNext(iterator): element=it.next(iterator) lista.append(element) tiempo_visita+=20 tiempo_total= tiempo1/60+tiempo2/60+tiempo_visita tupla=(lista,round(tiempo_total)) listaCiclos.append(tupla) return listaCiclos
def Req4(catalog,country,tag): videosCountry= getVideosByCountry(catalog, country) result=lt.newList('ARRAY_LIST',compareLikes) b=lit.newIterator(videosCountry['videos']) while lit.hasNext(b): e=lit.next(b) if tag in e['tags']: dic={} r= lt.isPresent(result,e) if r==0: dic['title']=e['title'] dic['channel_title']=e['channel_title'] dic['publish_time']=e['publish_time'] dic['views']=e['views'] dic['likes']=e['likes'] dic['dislikes']=e['dislikes'] dic['tags']=e['tags'] lt.addLast(result,dic) sort=sortLikes(result) #print(lt.getElement(dic_sort,1)) return sort
def TiempoNecesariomod(analyzer, GPCC, limites): if GPCC == False: return False else: Ideal = {} Pesos = {} for A in GPCC: Pesos[A] = 0 n = it.newIterator(gr.edges(GPCC[A])) if it.hasNext(n): d = it.next(n) Pesos[A] += ed.weight(d) LimiteInferior = 0*60 LimiteSuperior = limites*60 for B in Pesos: if Pesos[B] >= LimiteInferior and Pesos[B] <= LimiteSuperior: Ideal[B] = GPCC[B] if len(Ideal) == 0: return "Vacio" else: return Ideal
def test_pushElements(): """ Se prueba la creacion de una nueva pila, se agregan todos los datos creados por sistema y se imprime su valor """ stack = st.newStack(list_type) st.push(stack, book5) st.push(stack, book6) st.push(stack, book3) st.push(stack, book10) st.push(stack, book1) st.push(stack, book2) st.push(stack, book8) st.push(stack, book4) st.push(stack, book7) st.push(stack, book9) iterator = it.newIterator(stack) while it.hasNext(iterator): element = it.next(iterator) print(element)
def P_Q(analyzer): TopS = pq.newMinPQ(cmpfunction= comparefunction) TopT = pq.newMinPQ(cmpfunction= comparefunction) lstcompany = m.keySet(analyzer["Company"]) iterator = it.newIterator(lstcompany) while it.hasNext(iterator): i = it.next(iterator) consulta = m.get(analyzer["Company"], i)['value'] numtaxis = len(consulta["Taxis"]) numservices = (consulta["Services"]) taxisE = {"key": numtaxis, "company": i} servicesE = {"key": numservices, "company": i} pq.insert(TopT, taxisE) pq.insert(TopS, servicesE) return {"T_taxis": TopT, "T_services": TopS}
def accidentesPorFecha(cont): t1_start = process_time() #tiempo inicial year = input('Digite el año YYYY: ') month = input('Digite el mes MM: ') day = input('Digite el día DD: ') date = year.strip() + '-' + month.strip() + '-' + day.strip() lst = ctrl.accidentesPorFecha(cont, date) print('Los tipos de accidentes acontecidos en la fecha', date, 'fueron: ') iterator = it.newIterator(lst[1]) i = 1 while it.hasNext(iterator): print(i, '- ', it.next(iterator)) i += 1 print('Para un total de ', lst[0]['total'], ' accidentes') print('Total según severidad: ') print('Severidad 1: ', lst[0]['1']) print('Severidad 2: ', lst[0]['2']) print('Severidad 3: ', lst[0]['3']) print('Severidad 4: ', lst[0]['4']) t1_stop = process_time() #tiempo final print("Tiempo de ejecución ", t1_stop - t1_start, " segundos ")
def imprimir_recomendador(cont, ref, rango): recomendador = controller.recomendador_de_rutas(cont, ref, rango) inicio = recomendador["inicio"] llegada = recomendador["llegada"] print( f"La estación en la que inician más viajes personas en su rango de edad es la estación {inicio}\n" ) print( f"La estación en la que terminan más viajes personas en su rango de edad es la estación {llegada}\n" ) print("El camino más corto entre el par de estaciones es el siguiente:") camino = recomendador["camino"] if camino == None: print("No existe camino entre esas estaciones") else: ite = it.newIterator(camino) while it.hasNext(ite): ruta = it.next(ite) ruta_ini = ruta['vertexA'] ruta_fin = ruta['vertexB'] print(f"De la estación {ruta_ini} a la estación {ruta_fin}")